@cloud-cli/px 3.5.2 → 3.5.3

package/dist/index.d.ts

@@ -1,13 +1,15 @@
 import { init } from '@cloud-cli/cli';
 import { DomainAndTarget, Domain } from './proxy-manager.js';
-import { ProxyEntry } from './proxy.js';
-declare function add(options: ProxyEntry): Promise<unknown>;
+import { Proxy } from './proxy.js';
+import { ProxyServer } from '@cloud-cli/proxy';
+declare function reload(): Promise<void>;
+declare function add(options: Proxy): Promise<unknown>;
 declare function remove(options: DomainAndTarget): Promise<unknown>;
-declare function update(options: ProxyEntry): Promise<boolean>;
-declare function list(): Promise<ProxyEntry[]>;
-declare function get(options: Domain): Promise<ProxyEntry[]>;
+declare function update(options: Proxy): Promise<boolean>;
+declare function list(): Promise<Proxy[]>;
+declare function get(options: Domain): Promise<Proxy[]>;
 declare function domains(): Promise<string[]>;
-declare function reload(): Promise<void>;
+declare function initServer(): Promise<ProxyServer>;
 declare const _default: {
     add: typeof add;
     remove: typeof remove;
@@ -16,6 +18,6 @@ declare const _default: {
     update: typeof update;
     domains: typeof domains;
     reload: typeof reload;
-    [init]: typeof reload;
+    [init]: typeof initServer;
 };
 export default _default;

package/dist/index.js

@@ -1,22 +1,43 @@
 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();
+import { loadTargets, Proxy } from './proxy.js';
+import { ProxyServer, ProxySettings, ProxyEntry } from '@cloud-cli/proxy';
+const settings = new ProxySettings({
+    certificatesFolder: process.env.PX_CERTS_FOLDER || '/etc/letsencrypt/live',
+    certificateFile: 'fullchain.pem',
+    keyFile: 'privkey.pem',
+});
+const px = new ProxyServer(settings);
 const manager = new ProxyManager();
+async function reload() {
+    const targets = await loadTargets();
+    px.reset();
+    targets.forEach(t => {
+        px.add(new ProxyEntry({
+            domain: t.domain,
+            target: t.target,
+            path: t.path,
+            redirectToHttps: t.redirect,
+            redirectToUrl: t.redirectUrl,
+            cors: t.cors,
+        }));
+    });
+    px.start();
+}
 async function add(options) {
     const proxy = await manager.addProxy(options);
-    px.reload();
+    await reload();
     return proxy;
 }
 async function remove(options) {
     const removed = await manager.removeProxy(options);
-    px.reload();
+    await reload();
     return removed;
 }
 async function update(options) {
     const output = await manager.updateProxy(options);
-    px.reload();
+    await reload();
     return output;
 }
 function list() {
@@ -28,9 +49,10 @@ function get(options) {
 function domains() {
     return manager.getDomainList();
 }
-async function reload() {
+async function initServer() {
     Resource.use(new SQLiteDriver());
-    await Resource.create(ProxyEntry);
-    return px.start();
+    await Resource.create(Proxy);
+    await reload();
+    return px;
 }
-export default { add, remove, list, get, update, domains, reload, [init]: reload };
+export default { add, remove, list, get, update, domains, reload, [init]: initServer };

package/dist/proxy-manager.d.ts

@@ -1,4 +1,4 @@
-import { ProxyEntry } from './proxy.js';
+import { Proxy } from './proxy.js';
 export interface Domain {
     domain: string;
     host?: string;
@@ -13,15 +13,15 @@ type ClassProperties<T> = {
     [K in KeysOf<T>]: T[K] extends never ? never : T[K];
 };
 export declare class ProxyManager {
-    addProxy(proxy: ClassProperties<ProxyEntry> & {
+    addProxy(proxy: ClassProperties<Proxy> & {
         host?: string;
     }): Promise<unknown>;
-    updateProxy(options: ClassProperties<ProxyEntry> & {
+    updateProxy(options: ClassProperties<Proxy> & {
         host?: string;
     }): Promise<boolean>;
     removeProxy(options: DomainAndTarget): Promise<unknown>;
     getDomainList(): Promise<string[]>;
-    getProxyList(): Promise<ProxyEntry[]>;
-    getProxyListForDomain(options: Domain): Promise<ProxyEntry[]>;
+    getProxyList(): Promise<Proxy[]>;
+    getProxyListForDomain(options: Domain): Promise<Proxy[]>;
 }
 export {};

package/dist/proxy-manager.js

@@ -1,5 +1,5 @@
 import { Query, Resource } from '@cloud-cli/store';
-import { ProxyEntry } from './proxy.js';
+import { Proxy } from './proxy.js';
 const domainNotSpecifiedError = new Error('Domain not specified');
 const targetNotSpecifiedError = new Error('Target not specified');
 export class ProxyManager {
@@ -11,7 +11,7 @@ export class ProxyManager {
             if (!proxy.target && !proxy.redirectUrl) {
                 return reject(targetNotSpecifiedError);
             }
-            const entry = new ProxyEntry({
+            const entry = new Proxy({
                 domain: proxy.domain || proxy.host,
                 target: proxy.target,
                 cors: !!proxy.cors,
@@ -31,9 +31,9 @@ export class ProxyManager {
     async updateProxy(options) {
         const domain = options.domain || options.host;
         const query = new Query().where('domain').is(domain);
-        const proxies = await Resource.find(ProxyEntry, query);
+        const proxies = await Resource.find(Proxy, query);
         if (!proxies.length) {
-            proxies.push(new ProxyEntry({ domain }));
+            proxies.push(new Proxy({ domain }));
         }
         for (const proxy of proxies) {
             ['target', 'cors', 'redirect', 'redirectUrl'].forEach(p => p in options && (proxy[p] = options[p]));
@@ -50,7 +50,7 @@ export class ProxyManager {
             if (options.target) {
                 query.where('target').is(options.target);
             }
-            const proxy = await Resource.find(ProxyEntry, query);
+            const proxy = await Resource.find(Proxy, query);
             try {
                 for (const p of proxy) {
                     await p.remove();
@@ -63,13 +63,13 @@ export class ProxyManager {
         });
     }
     async getDomainList() {
-        const proxies = await Resource.find(ProxyEntry, new Query());
+        const proxies = await Resource.find(Proxy, new Query());
         return proxies.map((proxy) => proxy.domain);
     }
     async getProxyList() {
-        return Resource.find(ProxyEntry, new Query());
+        return Resource.find(Proxy, new Query());
     }
     getProxyListForDomain(options) {
-        return Resource.find(ProxyEntry, new Query().where('domain').is(options.domain || options.host));
+        return Resource.find(Proxy, new Query().where('domain').is(options.domain || options.host));
     }
 }

package/dist/proxy.d.ts

@@ -1,34 +1,12 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import { IncomingMessage, ClientRequest, ServerResponse } from 'http';
-import { ServerOptions as HttpsServerOptions } from 'https';
-import { SecureContext } from 'tls';
 import { Resource } from '@cloud-cli/store';
-export declare class ProxyEntry extends Resource {
+export declare class Proxy extends Resource {
     id: number;
     domain: string;
+    path: string;
     target: string;
     redirect: boolean;
     redirectUrl: string;
     cors: boolean;
-    constructor(p: Partial<ProxyEntry>);
-}
-export declare class ProxyServer {
-    protected certs: Record<string, SecureContext>;
-    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, insecure?: boolean): void;
-    protected getSslOptions(): HttpsServerOptions;
-    protected findRootDomain(domain: string): SecureContext;
-    protected setHeaders(from: IncomingMessage, to: ServerResponse | ClientRequest): void;
-    protected getOrigin(req: IncomingMessage): URL;
-    protected getHost(string: string): string;
-    protected setCorsHeaders(req: IncomingMessage, res: ServerResponse): void;
-    protected handleError(error: any, res: ServerResponse): void;
+    constructor(p: Partial<Proxy>);
 }
+export declare function loadTargets(): Promise<Proxy[]>;

package/dist/proxy.js

@@ -4,16 +4,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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, Primary, Property, Query, Resource } from '@cloud-cli/store';
-import { readdir, readFile } from 'fs/promises';
-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 {
+let Proxy = class Proxy extends Resource {
     constructor(p) {
         super(p);
     }
@@ -21,172 +13,29 @@ let ProxyEntry = class ProxyEntry extends Resource {
 __decorate([
     Primary(),
     Property(Number)
-], ProxyEntry.prototype, "id", void 0);
+], Proxy.prototype, "id", void 0);
 __decorate([
     Property(String)
-], ProxyEntry.prototype, "domain", void 0);
+], Proxy.prototype, "domain", void 0);
 __decorate([
     Property(String)
-], ProxyEntry.prototype, "target", void 0);
+], Proxy.prototype, "path", void 0);
+__decorate([
+    Property(String)
+], Proxy.prototype, "target", void 0);
 __decorate([
     Property(Number)
-], ProxyEntry.prototype, "redirect", void 0);
+], Proxy.prototype, "redirect", void 0);
 __decorate([
     Property(String)
-], ProxyEntry.prototype, "redirectUrl", void 0);
+], Proxy.prototype, "redirectUrl", void 0);
 __decorate([
     Property(Number)
-], ProxyEntry.prototype, "cors", void 0);
-ProxyEntry = __decorate([
+], Proxy.prototype, "cors", void 0);
+Proxy = __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, true)).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, { withFileTypes: true });
-        const folders = localCerts.filter((entry) => entry.isDirectory()).map((dir) => dir.name);
-        for (const rootDomain of folders) {
-            if (process.env.DEBUG) {
-                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, insecure = false) {
-        const origin = this.getOrigin(req);
-        const proxyEntry = this.targets[origin?.hostname];
-        if (!origin.hostname || !proxyEntry) {
-            res.writeHead(404, 'Not found');
-            res.end();
-            return;
-        }
-        if (proxyEntry.redirectUrl) {
-            res.setHeader('Location', String(proxyEntry.redirectUrl));
-            res.writeHead(302, 'Moved somewhere else');
-            res.end();
-            return;
-        }
-        if (proxyEntry.redirect && insecure) {
-            const newURL = new URL(req.url, `https://${req.headers.host}`);
-            res.setHeader('Location', String(newURL));
-            res.writeHead(301, 'HTTPS is better');
-            res.end();
-            return;
-        }
-        const target = proxyEntry.target;
-        const url = new URL(req.url, target);
-        const isCorsPreflight = req.method === 'OPTIONS' && proxyEntry.cors;
-        if (isCorsPreflight) {
-            this.setCorsHeaders(req, res);
-            res.writeHead(204, { 'Content-Length': '0' });
-            res.end();
-            return;
-        }
-        const proxyRequest = (url.protocol === 'https:' ? httpsRequest : httpRequest)(url, { method: req.method });
-        this.setHeaders(req, proxyRequest);
-        proxyRequest.setHeader('host', this.getHost(target));
-        proxyRequest.setHeader('x-forwarded-for', req.headers.host);
-        proxyRequest.setHeader('x-forwarded-proto', insecure ? 'http' : 'https');
-        proxyRequest.setHeader('forwarded', 'host=' + req.headers.host + ';proto=' + (insecure ? 'http' : 'https'));
-        req.on('data', (chunk) => proxyRequest.write(chunk));
-        req.on('end', () => proxyRequest.end());
-        proxyRequest.on('error', (error) => this.handleError(error, res));
-        proxyRequest.on('response', (proxyRes) => {
-            this.setHeaders(proxyRes, res);
-            const isCorsSimple = req.method !== 'OPTIONS' && proxyEntry.cors && req.headers.origin;
-            if (isCorsSimple) {
-                this.setCorsHeaders(req, res);
-            }
-            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) {
-                const rootDomain = server.findRootDomain(domain);
-                if (rootDomain) {
-                    return cb(null, rootDomain);
-                }
-                cb(new Error('Not found', { cause: 404 }), null);
-            },
-        };
-    }
-    findRootDomain(domain) {
-        const parts = domain.split('/')[0].split('.');
-        const certs = this.certs;
-        while (parts.length) {
-            const rootDomain = parts.join('.');
-            if (certs[rootDomain]) {
-                return certs[rootDomain];
-            }
-            parts.shift();
-        }
-        return null;
-    }
-    setHeaders(from, to) {
-        const headers = Object.entries(from.headers);
-        for (const header of headers) {
-            to.setHeader(header[0], header[1]);
-        }
-    }
-    getOrigin(req) {
-        const host = req.headers['x-forwarded-for'] || req.headers.host || '';
-        return (host && new URL('http://' + host)) || null;
-    }
-    getHost(string) {
-        const url = new URL(string);
-        return url.hostname + (url.port ? ':' + url.port : '');
-    }
-    setCorsHeaders(req, res) {
-        const headers = req.headers;
-        const corsOrigin = new URL(req.headers.origin).origin;
-        const allowedMethod = headers['access-control-request-method'] || 'GET,HEAD,PUT,PATCH,POST,DELETE';
-        const allowedHeaders = headers['access-control-request-headers'] || '*';
-        res.setHeader('Vary', 'Origin');
-        res.setHeader('Access-Control-Allow-Origin', corsOrigin);
-        res.setHeader('Access-Control-Allow-Headers', allowedHeaders);
-        res.setHeader('Access-Control-Allow-Methods', allowedMethod);
-        res.setHeader('Access-Control-Allow-Credentials', 'true');
-    }
-    handleError(error, res) {
-        console.error(error);
-        if (error.code === 'ECONNREFUSED' || error.code === 'ECONNRESET') {
-            res.writeHead(502);
-            res.end();
-            return;
-        }
-        if (!res.headersSent) {
-            res.writeHead(500);
-            res.end();
-        }
-    }
+], Proxy);
+export { Proxy };
+export async function loadTargets() {
+    return await Resource.find(Proxy, new Query());
 }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@cloud-cli/px",
-  "version": "3.5.2",
+  "version": "3.5.3",
   "description": "Reverse Proxy",
-  "main": "dist/index.js",
+  "main": "./dist/index.js",
   "type": "module",
   "types": "./dist/index.d.ts",
   "prettier": "@cloud-cli/prettier-config",
@@ -29,6 +29,7 @@
   },
   "dependencies": {
     "@cloud-cli/cli": "^1.2.2",
-    "@cloud-cli/store": "^1.1.0"
+    "@cloud-cli/store": "^1.1.0",
+    "@cloud-cli/proxy": "^1.0.0"
   }
 }