@cloud-cli/px 4.0.1 → 4.1.1

package/README.md

@@ -16,22 +16,24 @@ export default { proxy };
 
 ## API
 
+All proxies have the following properties:
+
+| Options         | Description                                                                                          |
+| --------------- | ---------------------------------------------------------------------------------------------------- |
+| `domain`        | Required. entrypoint for reverse proxy                                                               |
+| `target`        | Required. Any target address, can be local or remote                                                 |
+| `cors`          | handle CORS request on proxy level. See notes below!                                                 |
+| `redirect`      | if request comes as http, redirect to https                                                          |
+| `redirectUrl`   | if provided, issues a `Location` header and terminates with status 302 instead of proxying a request |
+| `headers`       | comma separated headers to set in the outbound connection, e.g. authorisation headers                |
+| `authorization` | matches incoming request headers against this value. If strings match, requests can continue.        |
+
 **Add a proxy to a local service**
 
 ```bash
 cy proxy.add --domain "foo.example.com" --target "http://localhost:1234"
 ```
 
-All available options:
-
-- `domain`: entrypoint for reverse proxy
-- `target`: any target for requests, can be local or remote
-- `cors`: handle CORS request on proxy level. See notes below!
-- `redirect`: if request comes as http, redirect to https
-- `redirectUrl`: if provided, issues a `Location` header and terminates with status 302 instead of proxying a request
-- `headers`: comma separated headers to set in the outbound connection, e.g. authorisation headers
-- `authorization`: matches incoming request headers against this value. If strings match, requests can continue.
-
 **Remove a proxy**
 
 ```bash
@@ -88,6 +90,6 @@ CORS handling on proxy level is convenient, **but a security risk**. Beware:
 Every request has additional headers:
 
 - x-forwarded-for: the host of the original request.
-If a proxy is from 'https://foo.example.com' to 'http://localhost:1234', the header will be 'foo.example.com'
+  If a proxy is from 'https://foo.example.com' to 'http://localhost:1234', the header will be 'foo.example.com'
 - x-forwarded-proto: 'http' or 'https', depends on the original request
 - forwarded: the standard header with the same information as the other two above

package/dist/index.d.ts

@@ -1,24 +1,13 @@
 import { init } from '@cloud-cli/cli';
-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 & ExtraProps): Promise<boolean>;
-declare function list(): Promise<Proxy[]>;
-declare function get(options: Domain): Promise<Proxy[]>;
-declare function domains(): Promise<string[]>;
-declare function initServer(): Promise<import("@cloud-cli/proxy").ProxyServer>;
-declare function reload(): Promise<void>;
+import { DomainAndTarget, DomainName, Proxy, WithOptionalProps } from './types.js';
 declare const _default: {
-    add: typeof add;
-    remove: typeof remove;
-    list: typeof list;
-    get: typeof get;
-    update: typeof update;
-    domains: typeof domains;
-    reload: typeof reload;
-    [init]: typeof initServer;
+    add(options: WithOptionalProps<Proxy>): Promise<Proxy>;
+    remove(options: WithOptionalProps<DomainAndTarget>): Promise<boolean>;
+    update(options: WithOptionalProps<Proxy>): Promise<Proxy>;
+    list(filters: Partial<Proxy>): Promise<Proxy[]>;
+    get(options: DomainName): Proxy[];
+    domains(): Promise<string[]>;
+    [init](): Promise<import("@cloud-cli/proxy").ProxyServer>;
+    reload(): Promise<void>;
 };
 export default _default;

package/dist/index.js

@@ -1,36 +1,31 @@
 import { init, logInfo } from '@cloud-cli/cli';
 import { ProxyManager } from './proxy-manager.js';
 const manager = new ProxyManager();
-async function add(options) {
-    const proxy = await manager.addProxy(options);
-    await manager.reload();
-    return proxy;
-}
-async function remove(options) {
-    const removed = await manager.removeProxy(options);
-    await manager.reload();
-    return removed;
-}
-async function update(options) {
-    const output = await manager.updateProxy(options);
-    await manager.reload();
-    return output;
-}
-function list() {
-    return manager.getProxyList();
-}
-function get(options) {
-    return manager.getProxyListForDomain(options);
-}
-function domains() {
-    return manager.getDomainList();
-}
-async function initServer() {
-    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 };
+export default {
+    async add(options) {
+        return manager.addProxy(options);
+    },
+    async remove(options) {
+        return manager.removeProxy(options);
+    },
+    async update(options) {
+        return await manager.updateProxy(options);
+    },
+    list(filters) {
+        return manager.getProxyList(filters);
+    },
+    get(options) {
+        return manager.getProxyListForDomain(options);
+    },
+    domains() {
+        return manager.getDomainList();
+    },
+    async [init]() {
+        await manager.reload();
+        return manager.server;
+    },
+    async reload() {
+        logInfo('Reloading proxy server');
+        return await manager.reload();
+    },
+};

package/dist/proxy-manager.d.ts

@@ -1,38 +1,12 @@
 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];
-type ClassProperties<T> = {
-    [K in KeysOf<T>]: T[K] extends never ? never : T[K];
-};
+import type { DomainAndTarget, DomainName, Proxy, WithOptionalProps } from './types.js';
 export declare class ProxyManager {
     server: ProxyServer;
-    addProxy(proxy: ClassProperties<Proxy> & OptionalProps): Promise<Proxy>;
-    updateProxy(options: ClassProperties<Proxy> & OptionalProps): Promise<boolean>;
-    removeProxy(options: DomainAndTarget): Promise<unknown>;
+    addProxy(proxy: WithOptionalProps<Proxy>): Promise<Proxy>;
+    updateProxy(options: WithOptionalProps<Proxy>): Promise<Proxy>;
+    removeProxy(options: WithOptionalProps<DomainAndTarget>): Promise<boolean>;
     getDomainList(): Promise<string[]>;
-    getProxyList(): Promise<Proxy[]>;
-    getProxyListForDomain(options: Domain): Promise<Proxy[]>;
+    getProxyList(filters?: Partial<Proxy>): Promise<Proxy[]>;
+    getProxyListForDomain(options: WithOptionalProps<DomainName>): Proxy[];
     reload(): Promise<void>;
-    private findByDomainAndPath;
 }
-export {};

package/dist/proxy-manager.js

@@ -8,7 +8,7 @@ const defaultOptions = {
 const domainNotSpecifiedError = new Error('Domain not specified');
 const targetNotSpecifiedError = new Error('Target not specified');
 const moduleConfig = await getConfig('px', defaultOptions);
-const { set, remove, getAll } = getStorage('px');
+const { set, get, has, remove, getAll } = getStorage('px');
 const settings = new ProxySettings({
     certificatesFolder: moduleConfig.certsFolder,
     certificateFile: 'fullchain.pem',
@@ -26,20 +26,21 @@ const emptyProxy = {
     headers: '',
     authorization: '',
 };
+const readDomain = (options) => (options.domain = options.domain || options.host || options._[0]);
 export class ProxyManager {
     constructor() {
         this.server = px;
     }
     async addProxy(proxy) {
-        if (!proxy.domain && !proxy.host) {
+        readDomain(proxy);
+        if (!proxy.domain) {
             throw domainNotSpecifiedError;
         }
         if (!proxy.target && !proxy.redirectUrl) {
             throw targetNotSpecifiedError;
         }
-        const domainAndPath = proxy.domain || proxy.host || proxy._[0];
         const entry = {
-            domain: domainAndPath,
+            domain: proxy.domain,
             target: proxy.target,
             cors: !!proxy.cors,
             redirect: !!proxy.redirect,
@@ -47,49 +48,59 @@ export class ProxyManager {
             headers: proxy.headers || '',
             authorization: proxy.authorization,
         };
-        await set(domainAndPath, entry);
+        set(proxy.domain, entry);
+        await this.reload();
         return entry;
     }
     async updateProxy(options) {
-        const host = options.domain || options.host || options._[0];
-        const proxies = await this.findByDomainAndPath(host);
-        if (!proxies.length) {
-            proxies.push({ ...emptyProxy, domain: host });
+        readDomain(options);
+        const host = options.domain;
+        let proxy = get(host);
+        if (!proxy) {
+            proxy = { ...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]));
-            set(proxy.domain, proxy);
-        }
-        return true;
-    }
-    removeProxy(options) {
-        return new Promise(async (resolve, reject) => {
-            const host = options.domain || options.host;
-            if (!host) {
-                return reject(domainNotSpecifiedError);
-            }
-            const proxies = await this.findByDomainAndPath(host);
-            try {
-                for (const p of proxies) {
-                    await remove(p.domain);
-                }
-                resolve({ found: proxies.length });
-            }
-            catch (error) {
-                reject(error);
+        properties.forEach((p) => {
+            if (p in options) {
+                proxy[p] = options[p];
             }
         });
+        set(proxy.domain, proxy);
+        await this.reload();
+        return proxy;
+    }
+    async removeProxy(options) {
+        readDomain(options);
+        const host = options.domain;
+        if (!host) {
+            throw domainNotSpecifiedError;
+        }
+        if (has(host)) {
+            remove(host);
+            await this.reload();
+            return true;
+        }
+        return false;
     }
     async getDomainList() {
-        const proxies = await getAll();
+        const proxies = getAll();
         return proxies.map((proxy) => proxy.domain);
     }
-    async getProxyList() {
-        return await getAll();
+    async getProxyList(filters = {}) {
+        const list = getAll();
+        const keys = Object.keys(filters);
+        if (!keys.length) {
+            return list;
+        }
+        return keys.reduce((list, key) => {
+            const filter = String(filters[key]).toLowerCase();
+            return list.filter((p) => String(p[key]).toLowerCase().includes(filter));
+        }, list);
     }
     getProxyListForDomain(options) {
-        return this.findByDomainAndPath(options.domain || options.host);
+        readDomain(options);
+        const all = getAll();
+        return all.filter((p) => p.domain === options.domain);
     }
     async reload() {
         const targets = await getAll();
@@ -109,9 +120,4 @@ export class ProxyManager {
         });
         px.start();
     }
-    async findByDomainAndPath(string) {
-        const [domain, path = ''] = string.split('/');
-        const proxies = await getAll();
-        return proxies.filter((p) => p.domain === domain && (!path || domain === path));
-    }
 }

package/dist/types.d.ts

@@ -0,0 +1,21 @@
+interface OptionalProps {
+    host?: string;
+    _: string[];
+}
+export interface DomainName extends OptionalProps {
+    domain: string;
+}
+export interface DomainAndTarget extends DomainName {
+    target: string;
+}
+export interface Proxy {
+    domain: string;
+    target: string;
+    redirect: boolean;
+    redirectUrl: string;
+    headers: string;
+    authorization: string;
+    cors: boolean;
+}
+export type WithOptionalProps<T extends object> = T & OptionalProps;
+export {};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloud-cli/px",
-  "version": "4.0.1",
+  "version": "4.1.1",
   "description": "Reverse Proxy",
   "main": "./dist/index.js",
   "type": "module",
@@ -28,7 +28,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@cloud-cli/cli": "^1.2.2",
     "@cloud-cli/proxy": "^1.2.0"
+  },
+  "peerDependencies": {
+    "@cloud-cli/cli": "^2.0.0"
   }
 }