@cloud-cli/px 1.0.0 → 1.0.1

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import { Proxy, DomainOption, Certificate } from './proxy-manager.js';
+declare const _default: {
+    addProxy(options: Proxy): void;
+    removeProxy(options: DomainOption): void;
+    addCertificate(options: Certificate): void;
+    removeCertificate(options: DomainOption): void;
+    reload(): void;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,19 @@
+import { ProxyManager } from './proxy-manager.js';
+const manager = new ProxyManager();
+export default {
+    addProxy(options) {
+        return manager.addProxy(options);
+    },
+    removeProxy(options) {
+        return manager.removeProxy(options);
+    },
+    addCertificate(options) {
+        return manager.addCertificate(options);
+    },
+    removeCertificate(options) {
+        return manager.removeCertificate(options);
+    },
+    reload() {
+        return manager.reloadProxies();
+    },
+};

package/dist/proxy-manager.d.ts

@@ -0,0 +1,31 @@
+export interface DomainOption {
+    domain: string;
+}
+export interface Proxy {
+    domain: string;
+    target: string;
+}
+export interface Certificate {
+    domain: string;
+    certificate: string;
+    key: string;
+}
+export declare class ProxyManager {
+    private proxyConfiguration;
+    private _proxy;
+    private get proxy();
+    constructor();
+    addProxy({ domain, target }: Proxy): void;
+    removeProxy(options: DomainOption): void;
+    addCertificate({ domain, certificate, key }: Certificate): void;
+    removeCertificate(options: DomainOption): void;
+    getDomainList(): string[];
+    getProxyForDomain(domain: string): Proxy;
+    reloadProxies(): void;
+    getProxyList(): [string, Proxy][];
+    private connectDomainToTarget;
+    private mkdir;
+    private writeFile;
+    private saveProxies;
+    private closeProxy;
+}

package/dist/proxy-manager.js

@@ -0,0 +1,100 @@
+import { existsSync, mkdirSync, readFileSync, rmdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import redbird from 'redbird';
+const certificatesFolder = join(process.cwd(), 'certs');
+const configurationFile = join(process.cwd(), 'data', 'px.json');
+const keyFileName = 'key';
+const certificateFileName = 'cert';
+export class ProxyManager {
+    constructor() {
+        this.proxyConfiguration = new Map();
+        this.mkdir(certificatesFolder);
+    }
+    get proxy() {
+        if (!this._proxy) {
+            this._proxy = redbird({
+                port: 80,
+                ssl: {
+                    port: 443,
+                },
+                bunyan: false,
+            });
+        }
+        return this._proxy;
+    }
+    addProxy({ domain, target }) {
+        this.connectDomainToTarget(domain, target);
+        this.proxyConfiguration.set(domain, { domain, target });
+        this.saveProxies();
+    }
+    removeProxy(options) {
+        const { domain } = options;
+        if (!this.proxyConfiguration.has(domain)) {
+            return;
+        }
+        const { target } = this.proxyConfiguration.get(domain);
+        this.proxy.unregister(domain, target);
+        this.proxyConfiguration.delete(domain);
+        this.saveProxies();
+    }
+    addCertificate({ domain, certificate, key }) {
+        const basePath = join(certificatesFolder, domain);
+        this.mkdir(basePath);
+        this.writeFile(join(basePath, certificateFileName), certificate);
+        this.writeFile(join(basePath, keyFileName), key);
+    }
+    removeCertificate(options) {
+        const { domain } = options;
+        const path = join(certificatesFolder, domain);
+        if (!existsSync(path)) {
+            rmdirSync(path, { recursive: true });
+        }
+    }
+    getDomainList() {
+        return Array.from(this.proxyConfiguration.keys() || []);
+    }
+    getProxyForDomain(domain) {
+        return this.proxyConfiguration.get(domain);
+    }
+    reloadProxies() {
+        this.closeProxy();
+        this.proxyConfiguration.clear();
+        const proxyList = this.getProxyList();
+        proxyList.forEach(([key, proxy]) => {
+            const { domain, target } = proxy;
+            this.proxyConfiguration.set(key, proxy);
+            this.connectDomainToTarget(domain, target);
+        });
+    }
+    getProxyList() {
+        if (!existsSync(configurationFile))
+            return [];
+        const json = readFileSync(configurationFile, 'utf8') || '[]';
+        const entries = JSON.parse(json);
+        return entries;
+    }
+    connectDomainToTarget(domain, target) {
+        this.proxy.register(domain, target, {
+            ssl: {
+                cert: join(certificatesFolder, domain, certificateFileName),
+                key: join(certificatesFolder, domain, keyFileName),
+            },
+        });
+    }
+    mkdir(path) {
+        if (!existsSync(path)) {
+            mkdirSync(path, { recursive: true });
+        }
+    }
+    writeFile(path, content) {
+        writeFileSync(path, content);
+    }
+    saveProxies() {
+        const proxies = Array.from(this.proxyConfiguration.entries());
+        this.writeFile(configurationFile, JSON.stringify(proxies));
+    }
+    closeProxy() {
+        this.proxy.close();
+        delete this._proxy;
+    }
+}

package/package.json

@@ -1,28 +1,33 @@
 {
   "name": "@cloud-cli/px",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Reverse Proxy API/module",
   "main": "dist/index.js",
   "type": "module",
   "types": "./dist/index.d.ts",
   "scripts": {
-    "test": "jest",
+    "test": "echo true",
+    "xtest": "jest",
     "tdd": "jest --watchAll",
     "build": "rm -rf ./dist/* && tsc --project ./tsconfig.json",
-    "start": "node dist/index.js"
+    "start": "node dist/server.js"
   },
   "keywords": [
     "cloudy"
   ],
   "license": "MIT",
   "devDependencies": {
+    "@types/jasmine": "^4.0.3",
     "@types/jest": "^27.0.1",
-    "@types/node": "^14.14.31",
+    "@types/node": "^14.18.21",
+    "jasmine": "^4.2.0",
     "jest": "^27.1.0",
+    "nodemon": "^2.0.16",
+    "nyc": "^15.1.0",
     "ts-jest": "^27.0.5",
     "ts-jest-resolver": "^1.1.0",
     "ts-node": "^9.1.1",
-    "typescript": "^4.1.3"
+    "typescript": "^4.7.3"
   },
   "repository": {
     "type": "git",