@cloud-cli/px 3.7.0 → 4.0.0

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,45 +1,19 @@
-import { init } from '@cloud-cli/cli';
-import { Resource, SQLiteDriver } from '@cloud-cli/store';
+import { init, logInfo } from '@cloud-cli/cli';
 import { ProxyManager } from './proxy-manager.js';
-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,
-            headers: t.headers,
-            authorization: t.authorization,
-        }));
-    });
-    px.start();
-}
 async function add(options) {
     const proxy = await manager.addProxy(options);
-    await reload();
+    await manager.reload();
     return proxy;
 }
 async function remove(options) {
     const removed = await manager.removeProxy(options);
-    await reload();
+    await manager.reload();
     return removed;
 }
 async function update(options) {
     const output = await manager.updateProxy(options);
-    await reload();
+    await manager.reload();
     return output;
 }
 function list() {
@@ -52,9 +26,11 @@ function domains() {
     return manager.getDomainList();
 }
 async function initServer() {
-    Resource.use(new SQLiteDriver());
-    await Resource.create(Proxy);
-    await reload();
-    return px;
+    await manager.reload();
+    return manager.server;
+}
+async function reload() {
+    logInfo('Reloading proxy server');
+    return await manager.reload();
 }
 export default { add, remove, list, get, update, domains, reload, [init]: initServer };

package/dist/proxy-manager.d.ts

@@ -1,11 +1,23 @@
-import { Proxy } from './proxy.js';
-export interface Domain {
-    domain: string;
+import { ProxyServer } from '@cloud-cli/proxy';
+interface OptionalProps {
     host?: string;
+    _: string[];
+}
+export interface Domain extends OptionalProps {
+    domain: string;
 }
 export interface DomainAndTarget extends Domain {
     target: string;
 }
+export interface Proxy {
+    domain: string;
+    target: string;
+    redirect: boolean;
+    redirectUrl: string;
+    headers: string;
+    authorization: string;
+    cors: boolean;
+}
 type KeysOf<T> = {
     [K in keyof T]: T[K] extends () => any ? never : K;
 }[keyof T];
@@ -13,16 +25,14 @@ type ClassProperties<T> = {
     [K in KeysOf<T>]: T[K] extends never ? never : T[K];
 };
 export declare class ProxyManager {
-    addProxy(proxy: ClassProperties<Proxy> & {
-        host?: string;
-    }): Promise<unknown>;
-    updateProxy(options: ClassProperties<Proxy> & {
-        host?: string;
-    }): Promise<boolean>;
+    server: ProxyServer;
+    addProxy(proxy: ClassProperties<Proxy> & OptionalProps): Promise<Proxy>;
+    updateProxy(options: ClassProperties<Proxy> & OptionalProps): Promise<boolean>;
     removeProxy(options: DomainAndTarget): Promise<unknown>;
     getDomainList(): Promise<string[]>;
     getProxyList(): Promise<Proxy[]>;
     getProxyListForDomain(options: Domain): Promise<Proxy[]>;
+    reload(): Promise<void>;
     private findByDomainAndPath;
 }
 export {};

package/dist/proxy-manager.js

@@ -1,48 +1,57 @@
-import { Query, Resource } from '@cloud-cli/store';
-import { Proxy } from './proxy.js';
+import { getStorage } from '@cloud-cli/cli';
+import { ProxyEntry, ProxyServer, ProxySettings } from '@cloud-cli/proxy';
 const domainNotSpecifiedError = new Error('Domain not specified');
 const targetNotSpecifiedError = new Error('Target not specified');
+const { set, remove, getAll } = getStorage('px');
+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 emptyProxy = {
+    domain: '',
+    target: '',
+    cors: false,
+    redirect: false,
+    redirectUrl: '',
+    headers: '',
+    authorization: '',
+};
 export class ProxyManager {
-    addProxy(proxy) {
-        return new Promise(async (resolve, reject) => {
-            if (!proxy.domain && !proxy.host) {
-                return reject(domainNotSpecifiedError);
-            }
-            if (!proxy.target && !proxy.redirectUrl) {
-                return reject(targetNotSpecifiedError);
-            }
-            const [domain, path = ''] = (proxy.domain || proxy.host).split('/');
-            const entry = new Proxy({
-                domain: domain,
-                path: path,
-                target: proxy.target,
-                cors: !!proxy.cors,
-                redirect: !!proxy.redirect,
-                redirectUrl: proxy.redirectUrl || '',
-                headers: proxy.headers || '',
-                authorization: proxy.authorization,
-            });
-            try {
-                const id = await entry.save();
-                entry.id = id;
-                resolve(entry);
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
+    constructor() {
+        this.server = px;
+    }
+    async addProxy(proxy) {
+        if (!proxy.domain && !proxy.host) {
+            throw domainNotSpecifiedError;
+        }
+        if (!proxy.target && !proxy.redirectUrl) {
+            throw targetNotSpecifiedError;
+        }
+        const domainAndPath = proxy.domain || proxy.host || proxy._[0];
+        const entry = {
+            domain: domainAndPath,
+            target: proxy.target,
+            cors: !!proxy.cors,
+            redirect: !!proxy.redirect,
+            redirectUrl: proxy.redirectUrl || '',
+            headers: proxy.headers || '',
+            authorization: proxy.authorization,
+        };
+        await set(domainAndPath, entry);
+        return entry;
     }
     async updateProxy(options) {
-        const host = options.domain || options.host;
+        const host = options.domain || options.host || options._[0];
         const proxies = await this.findByDomainAndPath(host);
         if (!proxies.length) {
-            const [domain, path = ''] = host.split('/');
-            proxies.push(new Proxy({ domain, path }));
+            proxies.push({ ...emptyProxy, domain: host });
         }
         const properties = ['target', 'cors', 'redirect', 'redirectUrl', 'headers', 'authorization'];
         for (const proxy of proxies) {
             properties.forEach((p) => p in options && (proxy[p] = options[p]));
-            await proxy.save();
+            set(proxy.domain, proxy);
         }
         return true;
     }
@@ -55,7 +64,7 @@ export class ProxyManager {
             const proxies = await this.findByDomainAndPath(host);
             try {
                 for (const p of proxies) {
-                    await p.remove();
+                    await remove(p.domain);
                 }
                 resolve({ found: proxies.length });
             }
@@ -65,23 +74,36 @@ export class ProxyManager {
         });
     }
     async getDomainList() {
-        const proxies = await Resource.find(Proxy, new Query());
-        const list = proxies.map((proxy) => proxy.domain);
-        return [...new Set(list)];
+        const proxies = await getAll();
+        return proxies.map((proxy) => proxy.domain);
     }
     async getProxyList() {
-        return Resource.find(Proxy, new Query());
+        return await getAll();
     }
     getProxyListForDomain(options) {
         return this.findByDomainAndPath(options.domain || options.host);
     }
+    async reload() {
+        const targets = await getAll();
+        px.reset();
+        targets.forEach((t) => {
+            const [domain, path = ''] = t.domain.split('/');
+            px.add(new ProxyEntry({
+                domain: domain,
+                path: path,
+                target: t.target,
+                redirectToHttps: t.redirect,
+                redirectToUrl: t.redirectUrl,
+                cors: t.cors,
+                headers: t.headers,
+                authorization: t.authorization,
+            }));
+        });
+        px.start();
+    }
     async findByDomainAndPath(string) {
         const [domain, path = ''] = string.split('/');
-        const query = new Query().where('domain').is(domain);
-        if (path) {
-            query.where('path').is(path);
-        }
-        const proxies = await Resource.find(Proxy, query);
-        return proxies;
+        const proxies = await getAll();
+        return proxies.filter(p => p.domain === domain && (!path || domain === path));
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloud-cli/px",
-  "version": "3.7.0",
+  "version": "4.0.0",
   "description": "Reverse Proxy",
   "main": "./dist/index.js",
   "type": "module",
@@ -29,7 +29,6 @@
   },
   "dependencies": {
     "@cloud-cli/cli": "^1.2.2",
-    "@cloud-cli/proxy": "^1.2.0",
-    "@cloud-cli/store": "^1.1.0"
+    "@cloud-cli/proxy": "^1.2.0"
   }
 }

package/dist/proxy.d.ts

@@ -1,14 +0,0 @@
-import { Resource } from '@cloud-cli/store';
-export declare class Proxy extends Resource {
-    id: number;
-    domain: string;
-    path: string;
-    target: string;
-    redirect: boolean;
-    redirectUrl: string;
-    headers: string;
-    authorization: string;
-    cors: boolean;
-    constructor(p: Partial<Proxy>);
-}
-export declare function loadTargets(): Promise<Proxy[]>;

package/dist/proxy.js

@@ -1,47 +0,0 @@
-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 { Model, Primary, Property, Query, Resource } from '@cloud-cli/store';
-let Proxy = class Proxy extends Resource {
-    constructor(p) {
-        super(p);
-    }
-};
-__decorate([
-    Primary(),
-    Property(Number)
-], Proxy.prototype, "id", void 0);
-__decorate([
-    Property(String)
-], Proxy.prototype, "domain", void 0);
-__decorate([
-    Property(String)
-], Proxy.prototype, "path", void 0);
-__decorate([
-    Property(String)
-], Proxy.prototype, "target", void 0);
-__decorate([
-    Property(Number)
-], Proxy.prototype, "redirect", void 0);
-__decorate([
-    Property(String)
-], Proxy.prototype, "redirectUrl", void 0);
-__decorate([
-    Property(String)
-], Proxy.prototype, "headers", void 0);
-__decorate([
-    Property(String)
-], Proxy.prototype, "authorization", void 0);
-__decorate([
-    Property(Number)
-], Proxy.prototype, "cors", void 0);
-Proxy = __decorate([
-    Model('proxyentry')
-], Proxy);
-export { Proxy };
-export async function loadTargets() {
-    return await Resource.find(Proxy, new Query());
-}

package/jest.config.mjs

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