@cloud-cli/px 1.1.2 → 2.0.1

package/README.md

@@ -4,6 +4,8 @@ Reverse proxy to map local services to http(s) subdomains
 
 #### Usage
 
+Use it with [Cloudy](https://github.com/cloud-cli/cli)
+
 ```ts
 // cloudy.conf.mjs
 
@@ -14,50 +16,56 @@ export default { proxy };
 
 #### API
 
-**Add a certificate**
+**Add a proxy to a local service**
 
 ```
-cy proxy.addCertificate --domain example.com --certificate @path/to/cert --key @path/to/key
+cy proxy.add --domain "foo.example.com" --target "localhost:1234"
+cy proxy.add --domain "bar.example.com/api" --target "localhost:3000"
 ```
 
-**Remove a certificate**
+**Remove a proxy**
 
 ```
-cy proxy.removeCertificate --domain example.com
+cy proxy.remove --domain "foo.example.com" --target "localhost:1234"
+cy proxy.remove --domain "bar.example.com/api" --target "localhost:1234"
 ```
 
-**Add a proxy to a local service**
+**Get details of a proxy**
 
 ```
-cy proxy.addProxy --domain "foo.example.com" --target "localhost:1234"
+cy proxy.get --domain "foo.example.com"
 ```
 
-**Remove a proxy**
+**List proxies**
 
 ```
-cy proxy.removeProxy --domain "foo.example.com"
+cy proxy.list
 ```
 
-**Get details of a proxy**
+**List registered domains**
 
 ```
-cy proxy.getProxy --domain "foo.example.com"
+cy proxy.domains
 ```
 
-**List proxies**
+**Reload all configurations**
 
 ```
-cy proxy.getProxyList
+cy proxy.reload
 ```
 
-**List registered domains**
+## Certificate file resolution
 
 ```
-cy proxy.getDomainList
+certificatesFolder  = '/etc/letsencrypt/live' or process.env.PX_CERTS_FOLDER
+rootDomain          = 'example.com' in 'xyz.example.com'
+cert                = certificatesFolder + '/' + rootDomain + '/' + certificateFile
+key                 = certificatesFolder + '/' + rootDomain + '/' + keyFile
 ```
 
-**Reload all configurations**
+So xyz.example.com points to:
 
 ```
-cy proxy.reload
+/etc/letsencrypt/live/example.com/fullchain.pem   for certificate
+/etc/letsencrypt/live/example.com/privkey.pem     for private key
 ```

package/dist/index.d.ts

@@ -1,12 +1,10 @@
-import { Proxy, DomainOption, Certificate } from './proxy-manager.js';
+import { HttpProxy, Domain } from './proxy-manager.js';
 declare const _default: {
-    addProxy(options: Proxy): void;
-    removeProxy(options: DomainOption): void;
-    getProxy(options: DomainOption): Proxy;
-    addCertificate(options: Certificate): void;
-    removeCertificate(options: DomainOption): void;
+    add(options: HttpProxy): Promise<unknown>;
+    remove(options: HttpProxy): Promise<unknown>;
+    get(options: Domain): HttpProxy[];
     reload(): void;
-    getDomainList(): string[];
-    getProxyList(): [string, Proxy][];
+    domains(): string[];
+    list(): string[];
 };
 export default _default;

package/dist/index.js

@@ -1,28 +1,22 @@
 import { ProxyManager } from './proxy-manager.js';
 const manager = new ProxyManager();
 export default {
-    addProxy(options) {
+    add(options) {
         return manager.addProxy(options);
     },
-    removeProxy(options) {
+    remove(options) {
         return manager.removeProxy(options);
     },
-    getProxy(options) {
-        return manager.getProxyForDomain(options);
-    },
-    addCertificate(options) {
-        return manager.addCertificate(options);
-    },
-    removeCertificate(options) {
-        return manager.removeCertificate(options);
+    get(options) {
+        return manager.getProxyListForDomain(options);
     },
     reload() {
         return manager.reloadProxies();
     },
-    getDomainList() {
+    domains() {
         return manager.getDomainList();
     },
-    getProxyList() {
+    list() {
         return manager.getProxyList();
-    }
+    },
 };

package/dist/proxy-manager.d.ts

@@ -1,30 +1,23 @@
-export interface DomainOption {
+export interface Domain {
     domain: string;
 }
-export interface Proxy {
-    domain: string;
+export interface HttpProxy extends Domain {
     target: string;
 }
-export interface Certificate {
-    domain: string;
-    certificate: string;
-    key: string;
-}
 export declare class ProxyManager {
-    private proxyConfiguration;
+    private proxyList;
     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;
+    addProxy(proxy: HttpProxy): Promise<unknown>;
+    removeProxy(options: HttpProxy): Promise<unknown>;
     getDomainList(): string[];
-    getProxyForDomain(options: DomainOption): Proxy;
+    getProxyList(): string[];
+    getProxyListForDomain(options: Domain): HttpProxy[];
     reloadProxies(): void;
-    getProxyList(): [string, Proxy][];
+    private readProxyList;
+    private disconnectDomainAndTarget;
     private connectDomainToTarget;
-    private writeFile;
+    private findRootDomain;
     private saveProxies;
     private closeProxy;
 }

package/dist/proxy-manager.js

@@ -1,16 +1,17 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, 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 keyExtension = ".key";
-const certificateExtension = ".cert";
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import redbird from 'redbird';
+const certificatesFolder = process.env.PX_CERTS_FOLDER || '/etc/letsencrypt/live';
+const certificateFile = 'fullchain.pem';
+const keyFile = 'privkey.pem';
+const configurationFile = join(process.cwd(), 'data', 'px.json');
+const domainNotSpecifiedError = new Error('Domain not specified');
+const targetNotSpecifiedError = new Error('Target not specified');
+const notFoundError = new Error('Proxy not found');
+const proxyKey = ({ domain, target }) => `${domain} => ${target}`;
 export class ProxyManager {
     constructor() {
-        this.proxyConfiguration = new Map();
-        if (!existsSync(certificatesFolder)) {
-            mkdirSync(certificatesFolder, { recursive: true });
-        }
+        this.proxyList = [];
     }
     get proxy() {
         if (!this._proxy) {
@@ -24,79 +25,90 @@ export class ProxyManager {
         }
         return this._proxy;
     }
-    addProxy({ domain, target }) {
-        this.connectDomainToTarget(domain, target);
-        this.proxyConfiguration.set(domain, { domain, target });
-        this.saveProxies();
+    addProxy(proxy) {
+        return new Promise((resolve, reject) => {
+            if (!proxy.domain) {
+                return reject(domainNotSpecifiedError);
+            }
+            if (!proxy.target) {
+                return reject(targetNotSpecifiedError);
+            }
+            this.connectDomainToTarget(proxy);
+            this.saveProxies();
+            resolve(null);
+        });
     }
     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.writeFile(basePath + certificateExtension, certificate);
-        this.writeFile(basePath + keyExtension, key);
-    }
-    removeCertificate(options) {
-        const basePath = join(certificatesFolder, options.domain);
-        rmSync(basePath + certificateExtension, { force: true });
-        rmSync(basePath + keyExtension, { force: true });
+        return new Promise((resolve, reject) => {
+            if (!options.domain) {
+                return reject(domainNotSpecifiedError);
+            }
+            if (!options.target) {
+                return reject(targetNotSpecifiedError);
+            }
+            const proxy = this.proxyList.find((p) => proxyKey(p) === proxyKey(options));
+            if (!proxy) {
+                return reject(notFoundError);
+            }
+            this.disconnectDomainAndTarget(proxy);
+            this.saveProxies();
+            resolve(true);
+        });
     }
     getDomainList() {
-        return Array.from(this.proxyConfiguration.keys() || []);
+        return this.proxyList.map((p) => p.domain);
     }
-    getProxyForDomain(options) {
-        return this.proxyConfiguration.get(options.domain);
+    getProxyList() {
+        return this.proxyList.map(proxyKey);
+    }
+    getProxyListForDomain(options) {
+        return this.proxyList.filter((p) => p.domain === options.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);
-        });
+        this.proxyList = [];
+        this.readProxyList().forEach((proxy) => this.connectDomainToTarget(proxy));
     }
-    getProxyList() {
-        if (!existsSync(configurationFile))
+    readProxyList() {
+        if (!existsSync(configurationFile)) {
             return [];
-        const json = readFileSync(configurationFile, "utf8") || "[]";
-        const entries = JSON.parse(json);
-        return entries;
+        }
+        const json = readFileSync(configurationFile, 'utf8') || '[]';
+        return JSON.parse(json);
+    }
+    disconnectDomainAndTarget(proxy) {
+        const { domain, target } = proxy;
+        this.proxy.unregister(domain, target);
+        this.proxyList = this.proxyList.filter((p) => proxyKey(p) !== proxyKey(proxy));
+    }
+    connectDomainToTarget(proxy) {
+        const { domain, target } = proxy;
+        const rootDomain = this.findRootDomain(domain);
+        const ssl = { redirect: false };
+        if (rootDomain) {
+            Object.assign(ssl, {
+                redirect: true,
+                cert: join(certificatesFolder, rootDomain, certificateFile),
+                key: join(certificatesFolder, rootDomain, keyFile),
+            });
+        }
+        this.proxy.register(domain, target, { ssl });
+        this.proxyList = this.proxyList.filter((p) => proxyKey(p) !== proxyKey(proxy)).concat(proxy);
     }
-    connectDomainToTarget(domain, target) {
-        const parts = domain.split(".");
-        let rootDomain = "";
+    findRootDomain(domain) {
+        let rootDomain = '';
+        const parts = domain.split('/')[0].split('.');
         while (parts.length) {
-            rootDomain = parts.join(".");
-            if (existsSync(join(certificatesFolder, rootDomain) + keyExtension))
-                break;
+            rootDomain = parts.join('.');
+            if (existsSync(join(certificatesFolder, rootDomain, certificateFile))) {
+                return rootDomain;
+            }
             parts.shift();
         }
-        if (!rootDomain) {
-            throw new Error("Certificate not found for " + domain);
-        }
-        this.proxy.register(domain, target, {
-            ssl: {
-                cert: join(certificatesFolder, rootDomain) + certificateExtension,
-                key: join(certificatesFolder, rootDomain) + keyExtension,
-            },
-        });
-    }
-    writeFile(path, content) {
-        writeFileSync(path, content);
+        return '';
     }
     saveProxies() {
-        const proxies = Array.from(this.proxyConfiguration.entries());
-        this.writeFile(configurationFile, JSON.stringify(proxies));
+        writeFileSync(configurationFile, JSON.stringify(this.proxyList));
     }
     closeProxy() {
         this.proxy.close();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloud-cli/px",
-  "version": "1.1.2",
+  "version": "2.0.1",
   "description": "Reverse Proxy",
   "main": "dist/index.js",
   "type": "module",