@cloud-cli/px 1.0.1 → 1.1.1

package/README.md

@@ -1,75 +1,58 @@
 ## PX
 
-Reverse proxy with Nginx
+Reverse proxy to map local services to http(s) subdomains
 
 #### Usage
 
-As a module:
-
 ```ts
-import px from '@cloud-cli/px';
-
-px.start({ port: 4567 });
+// cloudy.conf.mjs
 
-px.removeProxy({ domain: 'example.com' });
-px.addProxy({ domain: 'example.com', target: 'localhost:1234' });
+import proxy from '@cloud-cli/px';
 
-px.removeCertificate({ domain: 'example.com' });
-px.addCertificate({ domain: 'example.com', certificate: '...', key: '...' });
+export default { proxy };
 
-console.log(px.getDomainList());
-console.log(px.getProxyForDomain('example.com'));
 ```
 
-With Cloudy CLI:
+#### API
 
-```ts
-import px from '@cloud-cli/px';
-import { cli } from '@cloud-cli/cy';
+**Add a certificate**
 
-cli.add('px', px);
+```
+cy proxy.addCertificate --domain="example.com" --certificate @path/to/cert --key @path/to/key
 ```
 
-**start() options**
-
-| Property | Type   | Default     |
-| -------- | ------ | ----------- |
-| `host`   | String | '127.0.0.1' |
-| `port`   | Number |             |
+**Remove a certificate**
 
-#### HTTP API
+```
+cy proxy.removeCertificate --domain example.com
+```
 
-**Add a certificate**
+**Add a proxy to a local service**
 
 ```
-POST /certificates
+cy proxy.addProxy --domain "foo.example.com" --target "localhost:1234"
+```
 
-{
-  "domain": "example.com",
-  "certificate": "...",
-  "key": "...",
-}
+**Remove a proxy**
 
+```
+cy proxy.removeProxy --domain "foo.example.com"
 ```
 
-**Add a certificate**
+**List proxies**
 
 ```
-DELETE /certificates/example.com
+cy proxy.getProxyList
 ```
 
-**Add a service**
+**List registered domains**
 
 ```
-POST /services
-{
-  "domain": "example.com",
-  "target": "localhost:1234"
-}
+cy proxy.getDomainList
 ```
 
-**Remove a service**
+**Reload all configurations**
 
 ```
-DELETE /services/example.com
+cy proxy.reload
 ```

package/dist/index.d.ts

@@ -2,8 +2,11 @@ import { Proxy, DomainOption, Certificate } 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;
     reload(): void;
+    getDomainList(): string[];
+    getProxyList(): [string, Proxy][];
 };
 export default _default;

package/dist/index.js

@@ -7,6 +7,9 @@ export default {
     removeProxy(options) {
         return manager.removeProxy(options);
     },
+    getProxy(options) {
+        return manager.getProxyForDomain(options);
+    },
     addCertificate(options) {
         return manager.addCertificate(options);
     },
@@ -16,4 +19,10 @@ export default {
     reload() {
         return manager.reloadProxies();
     },
+    getDomainList() {
+        return manager.getDomainList();
+    },
+    getProxyList() {
+        return manager.getProxyList();
+    }
 };

package/dist/proxy-manager.d.ts

@@ -20,11 +20,10 @@ export declare class ProxyManager {
     addCertificate({ domain, certificate, key }: Certificate): void;
     removeCertificate(options: DomainOption): void;
     getDomainList(): string[];
-    getProxyForDomain(domain: string): Proxy;
+    getProxyForDomain(options: DomainOption): Proxy;
     reloadProxies(): void;
     getProxyList(): [string, Proxy][];
     private connectDomainToTarget;
-    private mkdir;
     private writeFile;
     private saveProxies;
     private closeProxy;

package/dist/proxy-manager.js

@@ -1,14 +1,16 @@
-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';
+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";
 export class ProxyManager {
     constructor() {
         this.proxyConfiguration = new Map();
-        this.mkdir(certificatesFolder);
+        if (!existsSync(certificatesFolder)) {
+            mkdirSync(certificatesFolder, { recursive: true });
+        }
     }
     get proxy() {
         if (!this._proxy) {
@@ -39,22 +41,19 @@ export class ProxyManager {
     }
     addCertificate({ domain, certificate, key }) {
         const basePath = join(certificatesFolder, domain);
-        this.mkdir(basePath);
-        this.writeFile(join(basePath, certificateFileName), certificate);
-        this.writeFile(join(basePath, keyFileName), key);
+        this.writeFile(basePath + certificateExtension, certificate);
+        this.writeFile(basePath + keyExtension, key);
     }
     removeCertificate(options) {
-        const { domain } = options;
-        const path = join(certificatesFolder, domain);
-        if (!existsSync(path)) {
-            rmdirSync(path, { recursive: true });
-        }
+        const basePath = join(certificatesFolder, options.domain);
+        rmSync(basePath + certificateExtension, { force: true });
+        rmSync(basePath + keyExtension, { force: true });
     }
     getDomainList() {
         return Array.from(this.proxyConfiguration.keys() || []);
     }
-    getProxyForDomain(domain) {
-        return this.proxyConfiguration.get(domain);
+    getProxyForDomain(options) {
+        return this.proxyConfiguration.get(options.domain);
     }
     reloadProxies() {
         this.closeProxy();
@@ -69,23 +68,29 @@ export class ProxyManager {
     getProxyList() {
         if (!existsSync(configurationFile))
             return [];
-        const json = readFileSync(configurationFile, 'utf8') || '[]';
+        const json = readFileSync(configurationFile, "utf8") || "[]";
         const entries = JSON.parse(json);
         return entries;
     }
     connectDomainToTarget(domain, target) {
+        const parts = domain.split(".");
+        let rootDomain = "";
+        while (parts.length) {
+            rootDomain = parts.join(".");
+            if (existsSync(join(certificatesFolder, rootDomain) + keyExtension))
+                break;
+            parts.shift();
+        }
+        if (!rootDomain) {
+            throw new Error("Certificate not found for " + domain);
+        }
         this.proxy.register(domain, target, {
             ssl: {
-                cert: join(certificatesFolder, domain, certificateFileName),
-                key: join(certificatesFolder, domain, keyFileName),
+                cert: join(certificatesFolder, rootDomain) + certificateExtension,
+                key: join(certificatesFolder, rootDomain) + keyExtension,
             },
         });
     }
-    mkdir(path) {
-        if (!existsSync(path)) {
-            mkdirSync(path, { recursive: true });
-        }
-    }
     writeFile(path, content) {
         writeFileSync(path, content);
     }

package/package.json

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