@cloud-cli/px 2.0.1 → 3.0.0

package/dist/index.d.ts

@@ -1,10 +1,13 @@
-import { HttpProxy, Domain } from './proxy-manager.js';
+import { init } from '@cloud-cli/cli';
+import { DomainAndTarget, Domain } from './proxy-manager.js';
+import { ProxyEntry } from './proxy.js';
 declare const _default: {
-    add(options: HttpProxy): Promise<unknown>;
-    remove(options: HttpProxy): Promise<unknown>;
-    get(options: Domain): HttpProxy[];
+    add(options: ProxyEntry): Promise<unknown>;
+    remove(options: DomainAndTarget): Promise<unknown>;
+    list(): Promise<ProxyEntry[]>;
+    get(options: Domain): Promise<ProxyEntry[]>;
     reload(): void;
-    domains(): string[];
-    list(): string[];
+    domains(): Promise<string[]>;
+    [init](): void;
 };
 export default _default;

package/dist/index.js

@@ -1,22 +1,35 @@
+import { init } from '@cloud-cli/cli';
+import { Resource, SQLiteDriver } from '@cloud-cli/store';
 import { ProxyManager } from './proxy-manager.js';
+import { ProxyEntry, ProxyServer } from './proxy.js';
+const px = new ProxyServer();
 const manager = new ProxyManager();
 export default {
-    add(options) {
-        return manager.addProxy(options);
+    async add(options) {
+        const proxy = await manager.addProxy(options);
+        px.reload();
+        return proxy;
     },
-    remove(options) {
-        return manager.removeProxy(options);
+    async remove(options) {
+        const removed = await manager.removeProxy(options);
+        px.reload();
+        return removed;
+    },
+    list() {
+        return manager.getProxyList();
     },
     get(options) {
         return manager.getProxyListForDomain(options);
     },
     reload() {
-        return manager.reloadProxies();
+        this[init]();
     },
     domains() {
         return manager.getDomainList();
     },
-    list() {
-        return manager.getProxyList();
+    [init]() {
+        Resource.use(new SQLiteDriver());
+        Resource.create(ProxyEntry);
+        return px.start();
     },
 };

package/dist/proxy-manager.d.ts

@@ -1,23 +1,21 @@
+import { ProxyEntry } from './proxy.js';
 export interface Domain {
     domain: string;
 }
-export interface HttpProxy extends Domain {
+export interface DomainAndTarget extends Domain {
     target: string;
 }
+type KeysOf<T> = {
+    [K in keyof T]: T[K] extends () => any ? never : K;
+}[keyof T];
+type ClassProperties<T> = {
+    [K in KeysOf<T>]: T[K] extends never ? never : T[K];
+};
 export declare class ProxyManager {
-    private proxyList;
-    private _proxy;
-    private get proxy();
-    addProxy(proxy: HttpProxy): Promise<unknown>;
-    removeProxy(options: HttpProxy): Promise<unknown>;
-    getDomainList(): string[];
-    getProxyList(): string[];
-    getProxyListForDomain(options: Domain): HttpProxy[];
-    reloadProxies(): void;
-    private readProxyList;
-    private disconnectDomainAndTarget;
-    private connectDomainToTarget;
-    private findRootDomain;
-    private saveProxies;
-    private closeProxy;
+    addProxy(proxy: ClassProperties<ProxyEntry>): Promise<unknown>;
+    removeProxy(options: DomainAndTarget): Promise<unknown>;
+    getDomainList(): Promise<string[]>;
+    getProxyList(): Promise<ProxyEntry[]>;
+    getProxyListForDomain(options: Domain): Promise<ProxyEntry[]>;
 }
+export {};

package/dist/proxy-manager.js

@@ -1,117 +1,61 @@
-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');
+import { Query, Resource } from '@cloud-cli/store';
+import { ProxyEntry } from './proxy.js';
 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.proxyList = [];
-    }
-    get proxy() {
-        if (!this._proxy) {
-            this._proxy = redbird({
-                port: 80,
-                ssl: {
-                    port: 443,
-                },
-                bunyan: false,
-            });
-        }
-        return this._proxy;
-    }
     addProxy(proxy) {
-        return new Promise((resolve, reject) => {
+        return new Promise(async (resolve, reject) => {
             if (!proxy.domain) {
                 return reject(domainNotSpecifiedError);
             }
             if (!proxy.target) {
                 return reject(targetNotSpecifiedError);
             }
-            this.connectDomainToTarget(proxy);
-            this.saveProxies();
-            resolve(null);
+            const entry = new ProxyEntry({
+                domain: proxy.domain,
+                target: proxy.target,
+                cors: !!proxy.cors,
+                redirect: !!proxy.redirect,
+            });
+            try {
+                await entry.save();
+                resolve(entry);
+            }
+            catch (error) {
+                reject(error);
+            }
         });
     }
     removeProxy(options) {
-        return new Promise((resolve, reject) => {
+        return new Promise(async (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) {
+            const proxy = await Resource.find(ProxyEntry, new Query().where('domain').is(options.domain).where('target').is(options.target));
+            if (!proxy.length) {
                 return reject(notFoundError);
             }
-            this.disconnectDomainAndTarget(proxy);
-            this.saveProxies();
-            resolve(true);
+            try {
+                await proxy[0].remove();
+                resolve(true);
+            }
+            catch (error) {
+                reject(error);
+            }
         });
     }
-    getDomainList() {
-        return this.proxyList.map((p) => p.domain);
+    async getDomainList() {
+        const proxies = await Resource.find(ProxyEntry, new Query());
+        return proxies.map((proxy) => proxy.domain);
     }
-    getProxyList() {
-        return this.proxyList.map(proxyKey);
+    async getProxyList() {
+        return Resource.find(ProxyEntry, new Query());
     }
     getProxyListForDomain(options) {
-        return this.proxyList.filter((p) => p.domain === options.domain);
-    }
-    reloadProxies() {
-        this.closeProxy();
-        this.proxyList = [];
-        this.readProxyList().forEach((proxy) => this.connectDomainToTarget(proxy));
-    }
-    readProxyList() {
-        if (!existsSync(configurationFile)) {
-            return [];
-        }
-        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);
-    }
-    findRootDomain(domain) {
-        let rootDomain = '';
-        const parts = domain.split('/')[0].split('.');
-        while (parts.length) {
-            rootDomain = parts.join('.');
-            if (existsSync(join(certificatesFolder, rootDomain, certificateFile))) {
-                return rootDomain;
-            }
-            parts.shift();
-        }
-        return '';
-    }
-    saveProxies() {
-        writeFileSync(configurationFile, JSON.stringify(this.proxyList));
-    }
-    closeProxy() {
-        this.proxy.close();
-        delete this._proxy;
+        return Resource.find(ProxyEntry, new Query().where('domain').is(options.domain));
     }
 }

package/dist/proxy.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from 'http';
+import { Resource } from '@cloud-cli/store';
+export declare class ProxyEntry extends Resource {
+    domain: string;
+    target: string;
+    redirect: boolean;
+    cors: boolean;
+    constructor(p: Partial<ProxyEntry>);
+}
+interface Certificates {
+    key: string;
+    cert: string;
+}
+export declare class ProxyServer {
+    protected certs: Record<string, Certificates>;
+    protected targets: Record<string, ProxyEntry>;
+    protected servers: any;
+    start(): void;
+    reload(): void;
+    protected loadCertificates(): Promise<void>;
+    protected loadTargets(): Promise<void>;
+    protected serveRequest(req: IncomingMessage, res: ServerResponse): void;
+    protected getSslOptions(): {
+        SNICallback(domain: string, cb: Function): any;
+    };
+}
+export {};

package/dist/proxy.js

@@ -0,0 +1,162 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { createServer as createHttpServer, request as httpRequest } from 'http';
+import { createServer as createHttpsServer, request as httpsRequest } from 'https';
+import { createSecureContext } from 'tls';
+import { Model, Property, Query, Resource } from '@cloud-cli/store';
+import { readdir, readFile, stat } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join } from 'path';
+const certificatesFolder = process.env.PX_CERTS_FOLDER || '/etc/letsencrypt/live';
+const certificateFile = 'fullchain.pem';
+const keyFile = 'privkey.pem';
+let ProxyEntry = class ProxyEntry extends Resource {
+    constructor(p) {
+        super(p);
+    }
+};
+__decorate([
+    Property(String)
+], ProxyEntry.prototype, "domain", void 0);
+__decorate([
+    Property(String)
+], ProxyEntry.prototype, "target", void 0);
+__decorate([
+    Property(Number)
+], ProxyEntry.prototype, "redirect", void 0);
+__decorate([
+    Property(Number)
+], ProxyEntry.prototype, "cors", void 0);
+ProxyEntry = __decorate([
+    Model('proxyentry')
+], ProxyEntry);
+export { ProxyEntry };
+export class ProxyServer {
+    constructor() {
+        this.certs = {};
+        this.targets = {};
+        this.servers = [];
+    }
+    start() {
+        this.reload();
+        this.servers.forEach((server) => server.close());
+        this.servers = [
+            createHttpServer((req, res) => this.serveRequest(req, res)).listen(80),
+            createHttpsServer(this.getSslOptions(), (req, res) => this.serveRequest(req, res)).listen(443),
+        ];
+    }
+    reload() {
+        this.loadCertificates();
+        this.loadTargets();
+    }
+    async loadCertificates() {
+        const certs = (this.certs = {});
+        const localCerts = await readdir(certificatesFolder);
+        const folders = await Promise.all(localCerts.map(async (dir) => {
+            const status = await stat(join(certificatesFolder, dir));
+            return status.isDirectory() ? dir : '';
+        }));
+        folders.filter(Boolean).forEach(async (rootDomain) => {
+            console.log(`Loading certificate for ${rootDomain}`);
+            certs[rootDomain] = createSecureContext({
+                cert: await readFile(join(certificatesFolder, rootDomain, certificateFile), 'utf8'),
+                key: await readFile(join(certificatesFolder, rootDomain, keyFile), 'utf8'),
+            });
+        });
+    }
+    async loadTargets() {
+        const targets = await Resource.find(ProxyEntry, new Query());
+        this.targets = {};
+        targets.forEach((entry) => (this.targets[entry.domain] = entry));
+    }
+    serveRequest(req, res) {
+        const origin = getOrigin(req);
+        const proxyEntry = this.targets[origin?.hostname];
+        if (!origin.hostname || !proxyEntry) {
+            res.writeHead(404, 'Not found');
+            res.end();
+            return;
+        }
+        const target = proxyEntry.target;
+        const url = new URL(req.url, target);
+        const isCorsPreflight = req.method === 'OPTIONS' && proxyEntry.cors;
+        if (isCorsPreflight) {
+            res.writeHead(204, 'OK');
+            res.setHeader('Access-Control-Allow-Origin', origin.hostname);
+            res.end();
+            return;
+        }
+        const proxyRequest = (url.protocol === 'https:' ? httpsRequest : httpRequest)(url, { method: req.method });
+        setHeaders(req, proxyRequest);
+        proxyRequest.setHeader('host', getHost(target));
+        req.on('data', (chunk) => proxyRequest.write(chunk));
+        req.on('end', () => proxyRequest.end());
+        proxyRequest.on('error', (error) => handleError(error, res));
+        proxyRequest.on('response', (proxyRes) => {
+            setHeaders(proxyRes, res);
+            const isCorsSimple = req.method !== 'OPTIONS' && proxyEntry.cors && req.headers.origin;
+            if (isCorsSimple) {
+                const corsOrigin = new URL(req.headers.origin);
+                res.setHeader('Access-Control-Allow-Origin', corsOrigin.origin);
+            }
+            res.writeHead(proxyRes.statusCode, proxyRes.statusMessage);
+            proxyRes.on('data', (chunk) => res.write(chunk));
+            proxyRes.on('end', () => res.end());
+        });
+    }
+    getSslOptions() {
+        const server = this;
+        return {
+            SNICallback(domain, cb) {
+                // TODO sanitize string to avoid file navigation!
+                const rootDomain = findRootDomain(domain);
+                if (rootDomain in server.certs) {
+                    return cb(null, server.certs[rootDomain]);
+                }
+                throw new Error('Not found', { cause: 404 });
+            },
+        };
+    }
+}
+function findRootDomain(domain) {
+    let rootDomain = '';
+    const parts = domain.split('/')[0].split('.');
+    while (parts.length) {
+        rootDomain = parts.join('.');
+        if (existsSync(join(certificatesFolder, rootDomain, certificateFile))) {
+            return rootDomain;
+        }
+        parts.shift();
+    }
+    return '';
+}
+function setHeaders(from, to) {
+    const headers = Object.entries(from.headers);
+    for (const header of headers) {
+        to.setHeader(header[0], header[1]);
+    }
+}
+function handleError(error, res) {
+    console.log(error);
+    if (error.code === 'ECONNREFUSED') {
+        res.writeHead(502);
+        res.end();
+        return;
+    }
+    if (!res.headersSent) {
+        res.writeHead(500);
+        res.end();
+    }
+}
+function getOrigin(req) {
+    const host = req.headers['x-forwarded-host'] || req.headers.host || '';
+    return (host && new URL('http://' + host)) || null;
+}
+function getHost(string) {
+    const url = new URL(string);
+    return url.hostname + (url.port ? ':' + url.port : '');
+}

package/jest.config.mjs

@@ -0,0 +1,3 @@
+import config from '@cloud-cli/jest-config';
+
+export default { ...config };

package/package.json

@@ -1,31 +1,24 @@
 {
   "name": "@cloud-cli/px",
-  "version": "2.0.1",
+  "version": "3.0.0",
   "description": "Reverse Proxy",
   "main": "dist/index.js",
   "type": "module",
   "types": "./dist/index.d.ts",
+  "prettier": "@cloud-cli/prettier-config",
   "scripts": {
-    "test": "echo true",
-    "xtest": "jest",
+    "test": "echo jest",
     "tdd": "jest --watchAll",
-    "build": "rm -rf ./dist/* && tsc --project ./tsconfig.json"
+    "build": "rm -rf ./dist/* && tsc"
   },
   "keywords": [
     "cloudy"
   ],
   "license": "MIT",
   "devDependencies": {
-    "@types/jasmine": "^4.0.3",
-    "@types/jest": "^27.0.1",
-    "@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",
+    "@cloud-cli/jest-config": "^1.0.0",
+    "@cloud-cli/prettier-config": "^1.0.0",
+    "@cloud-cli/typescript-config": "^1.0.1",
     "typescript": "^4.7.3"
   },
   "repository": {
@@ -36,6 +29,8 @@
     "access": "public"
   },
   "dependencies": {
+    "@cloud-cli/cli": "^1.2.2",
+    "@cloud-cli/store": "^1.1.0",
     "redbird": "^0.10.0"
   }
 }

package/.prettierrc

@@ -1,9 +0,0 @@
-{
-  "printWidth": 120,
-  "tabWidth": 2,
-  "useTabs": false,
-  "semi": true,
-  "singleQuote": true,
-  "trailingComma": "all",
-  "bracketSpacing": true
-}