4.0.2

.gitignore

@@ -1,5 +1,20 @@
-node_modules/
+.nogit/
+
+# artifacts
 coverage/
 public/
 pages/
-.nogit/
+
+# installs
+node_modules/
+
+# caches
+.yarn/
+.cache/
+.rpt2_cache
+
+# builds
+dist/
+dist_*/
+
+# custom

.gitlab-ci.yml

@@ -1,16 +1,16 @@
-# gitzone standard
-image: hosttoday/ht-docker-node:npmci
+# gitzone ci_default
+image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
 
 cache:
   paths:
-  - .npmci_cache/
-  key: "$CI_BUILD_STAGE"
+    - .npmci_cache/
+  key: '$CI_BUILD_STAGE'
 
 stages:
-- security
-- test
-- release
-- metadata
+  - security
+  - test
+  - release
+  - metadata
 
 # ====================
 # security stage
@@ -18,127 +18,115 @@ stages:
 mirror:
   stage: security
   script:
-  - npmci git mirror
+    - npmci git mirror
+  only:
+    - tags
   tags:
-  - docker
-  - notpriv
+    - lossless
+    - docker
+    - notpriv
 
-snyk:
+auditProductionDependencies:
+  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
   stage: security
   script:
     - npmci npm prepare
-    - npmci command npm install -g snyk
-    - npmci command npm install --ignore-scripts
-    - npmci command snyk test
+    - npmci command npm install --production --ignore-scripts
+    - npmci command npm config set registry https://registry.npmjs.org
+    - npmci command npm audit --audit-level=high --only=prod --production
   tags:
-  - docker
-  - notpriv
-
-sast:
-  stage: security
-  image: registry.gitlab.com/hosttoday/ht-docker-dbase:npmci
-  variables:
-    DOCKER_DRIVER: overlay2
+    - docker
   allow_failure: true
-  services:
-    - docker:stable-dind
+
+auditDevDependencies:
+  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  stage: security
   script:
     - npmci npm prepare
-    - npmci npm install
-    - npmci command npm run build
-    - export SP_VERSION=$(echo "$CI_SERVER_VERSION" | sed 's/^\([0-9]*\)\.\([0-9]*\).*/\1-\2-stable/')
-    - docker run
-        --env SAST_CONFIDENCE_LEVEL="${SAST_CONFIDENCE_LEVEL:-3}"
-        --volume "$PWD:/code"
-        --volume /var/run/docker.sock:/var/run/docker.sock
-        "registry.gitlab.com/gitlab-org/security-products/sast:$SP_VERSION" /app/bin/run /code
-  artifacts:
-    reports:
-      sast: gl-sast-report.json
+    - npmci command npm install --ignore-scripts
+    - npmci command npm config set registry https://registry.npmjs.org
+    - npmci command npm audit --audit-level=high --only=dev
   tags:
-  - docker
-  - priv
+    - docker
+  allow_failure: true
 
 # ====================
 # test stage
 # ====================
 
-testLTS:
+testStable:
   stage: test
   script:
-  - npmci npm prepare
-  - npmci node install lts
-  - npmci npm install
-  - npmci npm test
+    - npmci npm prepare
+    - npmci node install stable
+    - npmci npm install
+    - npmci npm test
   coverage: /\d+.?\d+?\%\s*coverage/
   tags:
-  - docker
-  - notpriv
+    - docker
 
-testSTABLE:
+testBuild:
   stage: test
   script:
-  - npmci npm prepare
-  - npmci node install stable
-  - npmci npm install
-  - npmci npm test
+    - npmci npm prepare
+    - npmci node install stable
+    - npmci npm install
+    - npmci command npm run build
   coverage: /\d+.?\d+?\%\s*coverage/
   tags:
-  - docker
-  - notpriv
+    - docker
 
 release:
   stage: release
   script:
-  - npmci node install stable
-  - npmci npm publish
+    - npmci node install stable
+    - npmci npm publish
   only:
-  - tags
+    - tags
   tags:
-  - docker
-  - notpriv
+    - lossless
+    - docker
+    - notpriv
 
 # ====================
 # metadata stage
 # ====================
 codequality:
   stage: metadata
-  image: docker:stable
   allow_failure: true
-  services:
-    - docker:stable-dind
+  only:
+    - tags
   script:
-    - export SP_VERSION=$(echo "$CI_SERVER_VERSION" | sed 's/^\([0-9]*\)\.\([0-9]*\).*/\1-\2-stable/')
-    - docker run
-        --env SOURCE_CODE="$PWD"
-        --volume "$PWD":/code
-        --volume /var/run/docker.sock:/var/run/docker.sock
-        "registry.gitlab.com/gitlab-org/security-products/codequality:$SP_VERSION" /code
-  artifacts:
-    paths: [codeclimate.json]
+    - npmci command npm install -g tslint typescript
+    - npmci npm prepare
+    - npmci npm install
+    - npmci command "tslint -c tslint.json ./ts/**/*.ts"
   tags:
-  - docker
-  - priv
+    - lossless
+    - docker
+    - priv
 
 trigger:
   stage: metadata
   script:
-  - npmci trigger
+    - npmci trigger
   only:
-  - tags
+    - tags
   tags:
-  - docker
-  - notpriv
+    - lossless
+    - docker
+    - notpriv
 
 pages:
-  image: hosttoday/ht-docker-node:npmci
   stage: metadata
   script:
-    - npmci command npm install -g typedoc typescript
+    - npmci node install lts
+    - npmci command npm install -g @gitzone/tsdoc
     - npmci npm prepare
     - npmci npm install
-    - npmci command typedoc --module "commonjs" --target "ES2016" --out public/ ts/
+    - npmci command tsdoc
   tags:
+    - lossless
     - docker
     - notpriv
   only:
@@ -146,5 +134,5 @@ pages:
   artifacts:
     expire_in: 1 week
     paths:
-    - public
+      - public
   allow_failure: true

.snyk

@@ -1,12 +0,0 @@
-# Snyk (https://snyk.io) policy file, patches or ignores known vulnerabilities.
-version: v1.12.0
-# ignores vulnerabilities until expiry date; change duration by modifying expiry date
-ignore:
-  'npm:node-forge:20180226':
-    - rsa-compat > node-forge:
-        reason: None given
-        expires: '2018-09-11T19:17:24.148Z'
-    - acme-v2 > rsa-compat > node-forge:
-        reason: None given
-        expires: '2018-09-11T19:17:24.148Z'
-patch: {}

.vscode/launch.json

@@ -0,0 +1,29 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "current file",
+      "type": "node",
+      "request": "launch",
+      "args": [
+        "${relativeFile}"
+      ],
+      "runtimeArgs": ["-r", "@gitzone/tsrun"],
+      "cwd": "${workspaceRoot}",
+      "protocol": "inspector",
+      "internalConsoleOptions": "openOnSessionStart"
+    },
+    {
+      "name": "test.ts",
+      "type": "node",
+      "request": "launch",
+      "args": [
+        "test/test.ts"
+      ],
+      "runtimeArgs": ["-r", "@gitzone/tsrun"],
+      "cwd": "${workspaceRoot}",
+      "protocol": "inspector",
+      "internalConsoleOptions": "openOnSessionStart"
+    }
+  ]
+}

.vscode/settings.json

@@ -0,0 +1,26 @@
+{
+  "json.schemas": [
+    {
+      "fileMatch": ["/npmextra.json"],
+      "schema": {
+        "type": "object",
+        "properties": {
+          "npmci": {
+            "type": "object",
+            "description": "settings for npmci"
+          },
+          "gitzone": {
+            "type": "object",
+            "description": "settings for gitzone",
+            "properties": {
+              "projectType": {
+                "type": "string",
+                "enum": ["website", "element", "service", "npm", "wcc"]
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}

README.md

@@ -1,63 +0,0 @@
-# smartacme
-
-acme implementation in TypeScript
-
-## Availabililty
-
-[![npm](https://umbrellazone.gitlab.io/assets/repo-button-npm.svg)](https://www.npmjs.com/package/smartacme)
-[![git](https://umbrellazone.gitlab.io/assets/repo-button-git.svg)](https://GitLab.com/umbrellazone/smartacme)
-[![git](https://umbrellazone.gitlab.io/assets/repo-button-mirror.svg)](https://github.com/umbrellazone/smartacme)
-[![docs](https://umbrellazone.gitlab.io/assets/repo-button-docs.svg)](https://umbrellazone.gitlab.io/smartacme/)
-
-## Status for master
-
-[![build status](https://GitLab.com/umbrellazone/smartacme/badges/master/build.svg)](https://GitLab.com/umbrellazone/smartacme/commits/master)
-[![coverage report](https://GitLab.com/umbrellazone/smartacme/badges/master/coverage.svg)](https://GitLab.com/umbrellazone/smartacme/commits/master)
-[![npm downloads per month](https://img.shields.io/npm/dm/smartacme.svg)](https://www.npmjs.com/package/smartacme)
-[![Dependency Status](https://david-dm.org/umbrellazone/smartacme.svg)](https://david-dm.org/umbrellazone/smartacme)
-[![bitHound Dependencies](https://www.bithound.io/github/umbrellazone/smartacme/badges/dependencies.svg)](https://www.bithound.io/github/umbrellazone/smartacme/master/dependencies/npm)
-[![bitHound Code](https://www.bithound.io/github/umbrellazone/smartacme/badges/code.svg)](https://www.bithound.io/github/umbrellazone/smartacme)
-[![TypeScript](https://img.shields.io/badge/TypeScript-2.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
-[![node](https://img.shields.io/badge/node->=%206.x.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
-[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-standard-brightgreen.svg)](http://standardjs.com/)
-
-## Usage
-
-Use TypeScript for best in class instellisense.
-
-```javascript
-import { SmartAcme } from 'smartacme';
-
-let smac = new SmartAcme()(async () => {
-  // learn async/await, it'll make your life easier
-
-  // optionally accepts a filePath Arg with a stored acmeaccount.json
-  // will create an account and
-  let myAccount = await smac.createAcmeAccount();
-
-  // will return a dnsHash to set in your DNS record
-  let myCert = await myAccount.createAcmeCert('example.com');
-
-  // gets and accepts the specified challenge
-  // first argument optional, defaults to dns-01 (which is the cleanest method for production use)
-  let myChallenge = await myCert.getChallenge('dns-01');
-
-  /* ----------
-    Now you need to set the challenge in your DNS
-    myChallenge.domainNamePrefixed is the address for the record
-    myChallenge.dnsKeyHash is the ready to use txt record value expected by letsencrypt
-    -------------*/
-})();
-```
-
-## Other relevant npm modules
-
-| module name | description                                                         |
-| ----------- | ------------------------------------------------------------------- |
-| cert        | a higlevel production module that uses smartacme to manage certs    |
-| smartnginx  | a highlevel production tool for docker environments to manage nginx |
-
-> MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
-> | By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy.html)
-
-[![repo-footer](https://umbrellazone.gitlab.io/assets/repo-footer.svg)](https://umbrella.zone

npmextra.json

@@ -1,4 +1,16 @@
 {
+  "gitzone": {
+    "projectType": "npm",
+    "module": {
+      "githost": "gitlab.com",
+      "gitscope": "pushrocks",
+      "gitrepo": "smartacme",
+      "shortDescription": "acme with an easy yet powerful interface in TypeScript",
+      "npmPackagename": "@pushrocks/smartacme",
+      "license": "MIT",
+      "projectDomain": "push.rocks"
+    }
+  },
   "npmci": {
     "npmGlobalTools": [],
     "npmAccessLevel": "public"

package.json

@@ -1,13 +1,14 @@
 {
   "name": "@pushrocks/smartacme",
-  "version": "2.0.12",
+  "version": "4.0.2",
   "private": false,
-  "description": "acme implementation in TypeScript",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "description": "acme with an easy yet powerful interface in TypeScript",
+  "main": "dist_ts/index.js",
+  "typings": "dist_ts/index.d.ts",
+  "type": "module",
   "scripts": {
     "test": "(tstest test/)",
-    "build": "(tsbuild)"
+    "build": "(tsbuild --web --allowimplicitany)"
   },
   "repository": {
     "type": "git",
@@ -25,26 +26,42 @@
   },
   "homepage": "https://gitlab.com/umbrellazone/smartacme#README",
   "dependencies": {
-    "@pushrocks/lik": "^3.0.4",
-    "@pushrocks/smartdata": "^3.1.13",
-    "@pushrocks/smartdelay": "^2.0.2",
-    "@pushrocks/smartdns": "^3.0.8",
-    "@pushrocks/smartexpress": "^3.0.0",
-    "@pushrocks/smartpromise": "^2.0.5",
-    "@pushrocks/smartrequest": "^1.1.14",
-    "@pushrocks/smarttime": "^3.0.5",
-    "@pushrocks/smartunique": "^3.0.1",
-    "acme-client": "^2.2.2"
+    "@pushrocks/lik": "^6.0.0",
+    "@pushrocks/smartdata": "^5.0.8",
+    "@pushrocks/smartdelay": "^2.0.13",
+    "@pushrocks/smartdns": "^5.0.2",
+    "@pushrocks/smartexpress": "^4.0.21",
+    "@pushrocks/smartlog": "^3.0.1",
+    "@pushrocks/smartpromise": "^3.1.7",
+    "@pushrocks/smartrequest": "^2.0.11",
+    "@pushrocks/smartstring": "^4.0.5",
+    "@pushrocks/smarttime": "^3.0.45",
+    "@pushrocks/smartunique": "^3.0.3",
+    "@tsclass/tsclass": "^4.0.21",
+    "acme-client": "^4.2.5"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.4",
-    "@gitzone/tsrun": "^1.1.17",
-    "@gitzone/tstest": "^1.0.18",
-    "@mojoio/cloudflare": "^2.0.0",
-    "@pushrocks/qenv": "^3.0.2",
-    "@pushrocks/tapbundle": "^3.0.7",
-    "@types/node": "^10.12.18",
-    "tslint": "^5.12.0",
-    "tslint-config-prettier": "^1.17.0"
-  }
+    "@gitzone/tsbuild": "^2.1.65",
+    "@gitzone/tsrun": "^1.2.37",
+    "@gitzone/tstest": "^1.0.73",
+    "@mojoio/cloudflare": "^6.0.1",
+    "@pushrocks/qenv": "^5.0.2",
+    "@pushrocks/tapbundle": "^5.0.4",
+    "@types/node": "^18.7.23"
+  },
+  "files": [
+    "ts/**/*",
+    "ts_web/**/*",
+    "dist/**/*",
+    "dist_*/**/*",
+    "dist_ts/**/*",
+    "dist_ts_web/**/*",
+    "assets/**/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
+  ]
 }

qenv.yml

@@ -1,6 +1,5 @@
 required:
-  - CF_EMAIL
-  - CF_KEY
+  - CF_TOKEN
   - MONGODB_URL
   - MONGODB_PASSWORD
   - MONGODB_DATABASE

readme.md

@@ -0,0 +1,66 @@
+# @pushrocks/smartacme
+acme with an easy yet powerful interface in TypeScript
+
+## Availabililty and Links
+* [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/smartacme)
+* [gitlab.com (source)](https://gitlab.com/pushrocks/smartacme)
+* [github.com (source mirror)](https://github.com/pushrocks/smartacme)
+* [docs (typedoc)](https://pushrocks.gitlab.io/smartacme/)
+
+## Status for master
+
+Status Category | Status Badge
+-- | --
+GitLab Pipelines | [![pipeline status](https://gitlab.com/pushrocks/smartacme/badges/master/pipeline.svg)](https://lossless.cloud)
+GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/pushrocks/smartacme/badges/master/coverage.svg)](https://lossless.cloud)
+npm | [![npm downloads per month](https://badgen.net/npm/dy/@pushrocks/smartacme)](https://lossless.cloud)
+Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/pushrocks/smartacme)](https://lossless.cloud)
+TypeScript Support | [![TypeScript](https://badgen.net/badge/TypeScript/>=%203.x/blue?icon=typescript)](https://lossless.cloud)
+node Support | [![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+Code Style | [![Code Style](https://badgen.net/badge/style/prettier/purple)](https://lossless.cloud)
+PackagePhobia (total standalone install weight) | [![PackagePhobia](https://badgen.net/packagephobia/install/@pushrocks/smartacme)](https://lossless.cloud)
+PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@pushrocks/smartacme)](https://lossless.cloud)
+BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@pushrocks/smartacme)](https://lossless.cloud)
+Platform support | [![Supports Windows 10](https://badgen.net/badge/supports%20Windows%2010/yes/green?icon=windows)](https://lossless.cloud) [![Supports Mac OS X](https://badgen.net/badge/supports%20Mac%20OS%20X/yes/green?icon=apple)](https://lossless.cloud)
+
+## Usage
+
+Use TypeScript for best in class instellisense.
+
+```javascript
+import { SmartAcme } from 'smartacme';
+
+const run = async () => {
+  smartAcmeInstance = new smartacme.SmartAcme({
+    accountEmail: 'domains@lossless.org',
+    accountPrivateKey: null,
+    mongoDescriptor: {
+      mongoDbName: testQenv.getEnvVarRequired('MONGODB_DATABASE'),
+      mongoDbPass: testQenv.getEnvVarRequired('MONGODB_PASSWORD'),
+      mongoDbUrl: testQenv.getEnvVarRequired('MONGODB_URL'),
+    },
+    removeChallenge: async (dnsChallenge) => {
+      // somehow provide a function that is able to remove the dns challenge
+    },
+    setChallenge: async (dnsChallenge) => {
+      // somehow provide a function that is able to the dns challenge
+    },
+    environment: 'integration',
+  });
+  await smartAcmeInstance.init();
+
+  // myCert has properties for public/private keys and csr ;)
+  const myCert = await smartAcmeInstance.getCertificateForDomain('bleu.de');
+};
+```
+
+## Contribution
+
+We are always happy for code contributions. If you are not the code contributing type that is ok. Still, maintaining Open Source repositories takes considerable time and thought. If you like the quality of what we do and our modules are useful to you we would appreciate a little monthly contribution: You can [contribute one time](https://lossless.link/contribute-onetime) or [contribute monthly](https://lossless.link/contribute). :)
+
+For further information read the linked docs at the top of this readme.
+
+> MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
+| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
+
+[![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)

test/test.ts

@@ -1,9 +1,11 @@
 import { tap, expect } from '@pushrocks/tapbundle';
 import { Qenv } from '@pushrocks/qenv';
+import * as cloudflare from '@mojoio/cloudflare';
 
 const testQenv = new Qenv('./', './.nogit/');
+const testCloudflare = new cloudflare.CloudflareAccount(testQenv.getEnvVarOnDemand('CF_TOKEN'));
 
-import * as smartacme from '../ts/index';
+import * as smartacme from '../ts/index.js';
 
 let smartAcmeInstance: smartacme.SmartAcme;
 
@@ -11,20 +13,36 @@ tap.test('should create a valid instance of SmartAcme', async () => {
   smartAcmeInstance = new smartacme.SmartAcme({
     accountEmail: 'domains@lossless.org',
     accountPrivateKey: null,
-    removeChallenge: async (...args) => {
-      console.log(args);
-    },
-    setChallenge: async (...args) => {
-      console.log(args);
-    },
     mongoDescriptor: {
-      mongoDbName: testQenv.getEnvVarOnDemand('MONGODB_DATABASE'),
-      mongoDbPass: testQenv.getEnvVarOnDemand('MONGODB_PASSWORD'),
-      mongoDbUrl: testQenv.getEnvVarOnDemand('MONGODB_URL')
-    }
+      mongoDbName: testQenv.getEnvVarRequired('MONGODB_DATABASE'),
+      mongoDbPass: testQenv.getEnvVarRequired('MONGODB_PASSWORD'),
+      mongoDbUrl: testQenv.getEnvVarRequired('MONGODB_URL'),
+    },
+    removeChallenge: async (dnsChallenge) => {
+      testCloudflare.convenience.acmeRemoveDnsChallenge(dnsChallenge);
+    },
+    setChallenge: async (dnsChallenge) => {
+      testCloudflare.convenience.acmeSetDnsChallenge(dnsChallenge);
+    },
+    environment: 'integration',
   });
   await smartAcmeInstance.init();
-  await smartAcmeInstance.getCertificateForDomain('bleu.de');
+});
+
+tap.test('should get a domain certificate', async () => {
+  const certificate = await smartAcmeInstance.getCertificateForDomain('bleu.de');
+  console.log(certificate);
+});
+
+tap.test('certmatcher should correctly match domains', async () => {
+  const certMatcherMod = await import('../ts/smartacme.classes.certmatcher.js');
+  const certMatcher = new certMatcherMod.CertMatcher();
+  const matchedCert = certMatcher.getCertificateDomainNameByDomainName('level3.level2.level1');
+  expect(matchedCert).toEqual('level2.level1');
+});
+
+tap.test('should stop correctly', async () => {
+  await smartAcmeInstance.stop();
 });
 
 tap.start();

ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@pushrocks/smartacme',
+  version: '4.0.2',
+  description: 'acme with an easy yet powerful interface in TypeScript'
+}

ts/index.ts

@@ -1,3 +1 @@
-export * from './smartacme.classes.smartacme';
-
-export * from './smartacme.classes.certremoteclient';
+export * from './smartacme.classes.smartacme.js';

ts/interfaces/index.ts

@@ -1 +1 @@
-export * from './accountdata';
+export * from './accountdata.js';

ts/smartacme.classes.cert.ts

@@ -1,34 +1,62 @@
-import * as plugins from './smartacme.plugins';
-import { CertManager } from './smartacme.classes.certmanager';
+import * as plugins from './smartacme.plugins.js';
+
+import * as interfaces from './interfaces/index.js';
+
+import { CertManager } from './smartacme.classes.certmanager.js';
 
 import { Collection, svDb, unI } from '@pushrocks/smartdata';
 
 @plugins.smartdata.Collection(() => {
   return CertManager.activeDB;
 })
-export class Cert extends plugins.smartdata.SmartDataDbDoc<Cert> {
+export class Cert extends plugins.smartdata.SmartDataDbDoc<Cert, plugins.tsclass.network.ICert>
+  implements plugins.tsclass.network.ICert {
   @unI()
-  public index: string;
+  public id: string;
 
   @svDb()
-  domainName: string;
+  public domainName: string;
 
   @svDb()
-  created: number;
+  public created: number;
 
   @svDb()
-  privateKey: string;
+  public privateKey: string;
 
   @svDb()
-  publicKey: string;
+  public publicKey: string;
 
   @svDb()
-  csr: string;
+  public csr: string;
 
-  constructor(privateKeyArg: string, publicKeyArg: string, csrArg: string) {
+  @svDb()
+  public validUntil: number;
+
+  public isStillValid(): boolean {
+    return this.validUntil >= Date.now();
+  }
+
+  public shouldBeRenewed(): boolean {
+    const shouldBeValidAtLeastUntil =
+      Date.now() +
+      plugins.smarttime.getMilliSecondsFromUnits({
+        days: 10,
+      });
+    return !(this.validUntil >= shouldBeValidAtLeastUntil);
+  }
+
+  public update(certDataArg: plugins.tsclass.network.ICert) {
+    Object.keys(certDataArg).forEach((key) => {
+      this[key] = certDataArg[key];
+    });
+  }
+
+  constructor(optionsArg: plugins.tsclass.network.ICert) {
     super();
-    this.privateKey = privateKeyArg;
-    this.publicKey = publicKeyArg;
-    this.csr = csrArg;
+    if (optionsArg) {
+      Object.keys(optionsArg).forEach((key) => {
+        this[key] = optionsArg[key];
+      });
+    }
   }
 }

ts/smartacme.classes.certmanager.ts

@@ -1,6 +1,8 @@
-import * as plugins from './smartacme.plugins';
-import { Cert } from './smartacme.classes.cert';
+import * as plugins from './smartacme.plugins.js';
+import { Cert } from './smartacme.classes.cert.js';
+import { SmartAcme } from './smartacme.classes.smartacme.js';
 
+import * as interfaces from './interfaces/index.js';
 
 export class CertManager {
   // =========
@@ -8,60 +10,68 @@ export class CertManager {
   // =========
   public static activeDB: plugins.smartdata.SmartdataDb;
 
-  
   // =========
   // INSTANCE
   // =========
   private mongoDescriptor: plugins.smartdata.IMongoDescriptor;
   public smartdataDb: plugins.smartdata.SmartdataDb;
 
-  constructor(optionsArg: {
-    mongoDescriptor: plugins.smartdata.IMongoDescriptor;
-  }) {
+  public interestMap: plugins.lik.InterestMap<string, Cert>;
+
+  constructor(
+    smartAcmeArg: SmartAcme,
+    optionsArg: {
+      mongoDescriptor: plugins.smartdata.IMongoDescriptor;
+    }
+  ) {
     this.mongoDescriptor = optionsArg.mongoDescriptor;
   }
 
-  public async init () {
+  public async init() {
+    // Smartdata DB
     this.smartdataDb = new plugins.smartdata.SmartdataDb(this.mongoDescriptor);
     await this.smartdataDb.init();
     CertManager.activeDB = this.smartdataDb;
-  };
+
+    // Pending Map
+    this.interestMap = new plugins.lik.InterestMap((certName) => certName);
+  }
 
   /**
    * retrieves a certificate
    * @returns the Cert class or null
-   * @param domainName the domain Name to retrieve the vcertificate for
+   * @param certDomainNameArg the domain Name to retrieve the vcertificate for
    */
-  public async retrieveCertificate(domainName: string): Promise<Cert> {
-    const existingCertificate: Cert = await Cert.getInstance({
-      name: domainName
+  public async retrieveCertificate(certDomainNameArg: string): Promise<Cert> {
+    const existingCertificate: Cert = await Cert.getInstance<Cert>({
+      domainName: certDomainNameArg,
     });
 
-    if(existingCertificate) {
+    if (existingCertificate) {
       return existingCertificate;
     } else {
       return null;
     }
-
   }
 
   /**
-   * stores the certificate with the 
-   * @param publicKeyArg 
-   * @param privateKeyArg 
-   * @param csrArg 
+   * stores the certificate
+   * @param optionsArg
    */
-  public async storeCertificate(privateKeyArg: string, publicKeyArg: string, csrArg: string) {
-    const cert = new Cert(privateKeyArg, publicKeyArg, csrArg);
-    cert.save();
-  };
+  public async storeCertificate(optionsArg: plugins.tsclass.network.ICert) {
+    const cert = new Cert(optionsArg);
+    await cert.save();
+    const interest = this.interestMap.findInterest(cert.domainName);
+    if (interest) {
+      interest.fullfillInterest(cert);
+      interest.markLost();
+    }
+  }
 
-  public async deleteCertificate(domainName: string) {
-
-  };
-
-  /**
-   * checks all certs for expiration
-   */
-  checkCerts() {}
+  public async deleteCertificate(certDomainNameArg: string) {
+    const cert: Cert = await Cert.getInstance<Cert>({
+      domainName: certDomainNameArg,
+    });
+    await cert.delete();
+  }
 }

ts/smartacme.classes.certmatcher.ts

@@ -0,0 +1,19 @@
+import * as plugins from './smartacme.plugins.js';
+import * as interfaces from './interfaces/index.js';
+
+/**
+ * certmatcher is responsible for matching certificates
+ */
+export class CertMatcher {
+  /**
+   * creates a domainName for the certificate that will include the broadest scope
+   * for wild card certificates
+   * @param domainNameArg the domainNameArg to create the scope from
+   */
+  public getCertificateDomainNameByDomainName(domainNameArg: string): string {
+    const originalDomain = new plugins.smartstring.Domain(domainNameArg);
+    if (!originalDomain.level4) {
+      return `${originalDomain.level2}.${originalDomain.level1}`;
+    }
+  }
+}

ts/smartacme.classes.certremoteclient.ts

@@ -1,10 +0,0 @@
-import * as plugins from './smartacme.plugins';
-
-export class CertRemoteClient {
-  constructor(optionsArg: {
-    remoteUrl: string;
-    secret: string;
-  }) {
-    
-  }
-}

ts/smartacme.classes.certremotehandler.ts

@@ -1,3 +0,0 @@
-import * as plugins from './smartacme.plugins';
-
-export class CertRemoteHandler {}

ts/smartacme.classes.smartacme.ts

@@ -1,75 +1,138 @@
-import * as plugins from './smartacme.plugins';
-import { CertManager } from './smartacme.classes.certmanager';
-import { CertRemoteHandler } from './smartacme.classes.certremotehandler';
+import * as plugins from './smartacme.plugins.js';
+import { Cert } from './smartacme.classes.cert.js';
+import { CertManager } from './smartacme.classes.certmanager.js';
+import { CertMatcher } from './smartacme.classes.certmatcher.js';
 
 /**
- *
+ * the options for the class @see SmartAcme
  */
 export interface ISmartAcmeOptions {
   accountPrivateKey?: string;
   accountEmail: string;
-  setChallenge: (domainName: string, keyAuthorization: string) => Promise<any>;
-  removeChallenge: (domainName: string) => Promise<any>;
   mongoDescriptor: plugins.smartdata.IMongoDescriptor;
+  setChallenge: (dnsChallengeArg: plugins.tsclass.network.IDnsChallenge) => Promise<any>;
+  removeChallenge: (dnsChallengeArg: plugins.tsclass.network.IDnsChallenge) => Promise<any>;
+  environment: 'production' | 'integration';
 }
 
+/**
+ * class SmartAcme
+ * can be used for setting up communication with an ACME authority
+ *
+ * ```ts
+ * const mySmartAcmeInstance = new SmartAcme({
+ *  // see ISmartAcmeOptions for options
+ * })
+ * ```
+ */
 export class SmartAcme {
   private options: ISmartAcmeOptions;
 
   // the acme client
   private client: any;
-  private smartdns = new plugins.smartdns.Smartdns();
+  private smartdns = new plugins.smartdns.Smartdns({});
+  public logger: plugins.smartlog.ConsoleLog;
 
   // the account private key
   private privateKey: string;
 
   // challenge fullfillment
-  private setChallenge: (domainName: string, keyAuthorization: string) => Promise<any>;
-  private removeChallenge: (domainName: string) => Promise<any>;
+  private setChallenge: (dnsChallengeArg: plugins.tsclass.network.IDnsChallenge) => Promise<any>;
+  private removeChallenge: (dnsChallengeArg: plugins.tsclass.network.IDnsChallenge) => Promise<any>;
 
   // certmanager
   private certmanager: CertManager;
-  private certremoteHandler: CertRemoteHandler;
+  private certmatcher: CertMatcher;
 
   constructor(optionsArg: ISmartAcmeOptions) {
     this.options = optionsArg;
+    this.logger = new plugins.smartlog.ConsoleLog();
   }
 
+  /**
+   * inits the instance
+   * ```ts
+   * await myCloudlyInstance.init() // does not support options
+   * ```
+   */
   public async init() {
-    this.privateKey = this.options.accountPrivateKey || (await plugins.acme.forge.createPrivateKey());
+    this.privateKey =
+      this.options.accountPrivateKey || (await plugins.acme.forge.createPrivateKey()).toString();
     this.setChallenge = this.options.setChallenge;
     this.removeChallenge = this.options.removeChallenge;
 
-    this.certmanager = new CertManager({
-      mongoDescriptor: this.options.mongoDescriptor
+    // CertMangaer
+    this.certmanager = new CertManager(this, {
+      mongoDescriptor: this.options.mongoDescriptor,
     });
     await this.certmanager.init();
-    this.certremoteHandler = new CertRemoteHandler();
 
+    // CertMatcher
+    this.certmatcher = new CertMatcher();
+
+    // ACME Client
     this.client = new plugins.acme.Client({
-      directoryUrl: plugins.acme.directory.letsencrypt.staging,
-      accountKey: this.privateKey
+      directoryUrl: (() => {
+        if (this.options.environment === 'production') {
+          return plugins.acme.directory.letsencrypt.production;
+        } else {
+          return plugins.acme.directory.letsencrypt.staging;
+        }
+      })(),
+      accountKey: this.privateKey,
     });
 
     /* Register account */
     await this.client.createAccount({
       termsOfServiceAgreed: true,
-      contact: [`mailto:${this.options.accountEmail}`]
+      contact: [`mailto:${this.options.accountEmail}`],
     });
   }
 
-  public async getCertificateForDomain(domainArg: string) {
-    const domain = domainArg;
+  public async stop() {
+    await this.certmanager.smartdataDb.close();
+  }
 
-    const retrievedCertificate = await this.certmanager.retrieveCertificate(domain);
+  /**
+   * gets a certificate
+   * it runs through the following steps
+   *
+   * * look in the database
+   * * if in the database and still valid return it
+   * * if not in the database announce it
+   * * then get it from letsencrypt
+   * * store it
+   * * remove it from the pending map (which it go onto by announcing it)
+   * * retrieve it from the databse and return it
+   *
+   * @param domainArg
+   */
+  public async getCertificateForDomain(domainArg: string): Promise<Cert> {
+    const certDomainName = this.certmatcher.getCertificateDomainNameByDomainName(domainArg);
+    const retrievedCertificate = await this.certmanager.retrieveCertificate(certDomainName);
 
-    if(retrievedCertificate) {
+    if (
+      !retrievedCertificate &&
+      (await this.certmanager.interestMap.checkInterest(certDomainName))
+    ) {
+      const existingCertificateInterest = this.certmanager.interestMap.findInterest(certDomainName);
+      const certificate = existingCertificateInterest.interestFullfilled;
+      return certificate;
+    } else if (retrievedCertificate && !retrievedCertificate.shouldBeRenewed()) {
       return retrievedCertificate;
+    } else if (retrievedCertificate && retrievedCertificate.shouldBeRenewed()) {
+      await retrievedCertificate.delete();
     }
 
+    // lets make sure others get the same interest
+    const currentDomainInterst = await this.certmanager.interestMap.addInterest(certDomainName);
+
     /* Place new order */
     const order = await this.client.createOrder({
-      identifiers: [{ type: 'dns', value: domain }, { type: 'dns', value: `*.${domain}` }]
+      identifiers: [
+        { type: 'dns', value: certDomainName },
+        { type: 'dns', value: `*.${certDomainName}` },
+      ],
     });
 
     /* Get authorizations and select challenges */
@@ -77,8 +140,8 @@ export class SmartAcme {
 
     for (const authz of authorizations) {
       console.log(authz);
-      const domainDnsName: string = `_acme-challenge.${authz.identifier.value}`;
-      const dnsChallenge: string = authz.challenges.find(challengeArg => {
+      const fullHostName: string = `_acme-challenge.${authz.identifier.value}`;
+      const dnsChallenge: string = authz.challenges.find((challengeArg) => {
         return challengeArg.type === 'dns-01';
       });
       // process.exit(1);
@@ -86,8 +149,14 @@ export class SmartAcme {
 
       try {
         /* Satisfy challenge */
-        await this.setChallenge(domainDnsName, keyAuthorization);
-        await this.smartdns.checkUntilAvailable(domainDnsName, 'TXT', keyAuthorization, 100, 5000);
+        await this.setChallenge({
+          hostName: fullHostName,
+          challenge: keyAuthorization,
+        });
+        await plugins.smartdelay.delayFor(30000);
+        await this.smartdns.checkUntilAvailable(fullHostName, 'TXT', keyAuthorization, 100, 5000);
+        console.log('Cool down an extra 60 second for region availability');
+        await plugins.smartdelay.delayFor(60000);
 
         /* Verify that challenge is satisfied */
         await this.client.verifyChallenge(authz, dnsChallenge);
@@ -100,7 +169,10 @@ export class SmartAcme {
       } finally {
         /* Clean up challenge response */
         try {
-          await this.removeChallenge(domainDnsName);
+          await this.removeChallenge({
+            hostName: fullHostName,
+            challenge: keyAuthorization,
+          });
         } catch (e) {
           console.log(e);
         }
@@ -109,20 +181,32 @@ export class SmartAcme {
 
     /* Finalize order */
     const [key, csr] = await plugins.acme.forge.createCsr({
-      commonName: `*.${domain}`,
-      altNames: [domain]
+      commonName: `*.${certDomainName}`,
+      altNames: [certDomainName],
     });
 
     await this.client.finalizeOrder(order, csr);
     const cert = await this.client.getCertificate(order);
 
     /* Done */
-    console.log(`CSR:\n${csr.toString()}`);
-    console.log(`Private key:\n${key.toString()}`);
-    console.log(`Certificate:\n${cert.toString()}`);
 
-    this.certmanager.storeCertificate(key.toString(), cert.toString(), csr.toString());
+    await this.certmanager.storeCertificate({
+      id: plugins.smartunique.shortId(),
+      domainName: certDomainName,
+      privateKey: key.toString(),
+      publicKey: cert.toString(),
+      csr: csr.toString(),
+      created: Date.now(),
+      validUntil:
+        Date.now() +
+        plugins.smarttime.getMilliSecondsFromUnits({
+          days: 90,
+        }),
+    });
+
+    const newCertificate = await this.certmanager.retrieveCertificate(certDomainName);
+    currentDomainInterst.fullfillInterest(newCertificate);
+    currentDomainInterst.destroy();
+    return newCertificate;
   }
-
-  toStorageObject() {}
 }

ts/smartacme.plugins.ts

@@ -4,14 +4,33 @@ import * as smartdata from '@pushrocks/smartdata';
 import * as smartdelay from '@pushrocks/smartdelay';
 import * as smartdns from '@pushrocks/smartdns';
 import * as smartexpress from '@pushrocks/smartexpress';
+import * as smartlog from '@pushrocks/smartlog';
 import * as smartpromise from '@pushrocks/smartpromise';
 import * as smartrequest from '@pushrocks/smartrequest';
 import * as smartunique from '@pushrocks/smartunique';
+import * as smartstring from '@pushrocks/smartstring';
 import * as smarttime from '@pushrocks/smarttime';
 
-export { lik, smartdata, smartdelay, smartdns, smartexpress, smartpromise, smartrequest, smartunique, smarttime };
+export {
+  lik,
+  smartdata,
+  smartdelay,
+  smartdns,
+  smartexpress,
+  smartlog,
+  smartpromise,
+  smartrequest,
+  smartunique,
+  smartstring,
+  smarttime,
+};
 
-// thirs party scope
+// @tsclass scope
+import * as tsclass from '@tsclass/tsclass';
+
+export { tsclass };
+
+// third party scope
 import * as acme from 'acme-client';
 
 export { acme };

tsconfig.json

@@ -1,7 +1,10 @@
 {
   "compilerOptions": {
     "experimentalDecorators": true,
-    "target": "es2017",
-    "module": "commonjs"
+    "useDefineForClassFields": false,
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "nodenext",
+    "esModuleInterop": true
   }
 }

tslint.json

@@ -1,17 +0,0 @@
-{
-  "extends": ["tslint:latest", "tslint-config-prettier"],
-  "rules": {
-    "semicolon": [true, "always"],
-    "no-console": false,
-    "ordered-imports": false,
-    "object-literal-sort-keys": false,
-    "member-ordering": {
-      "options":{
-        "order": [
-          "static-method"
-        ]
-      }
-    }
-  },
-  "defaultSeverity": "warning"
-}