wirejs-resources 0.1.7-alpha → 0.1.9-alpha

package/dist/adapters/context.d.ts

@@ -0,0 +1,21 @@
+import { CookieJar } from "./cookie-jar.js";
+type ApiMethod = (...args: any) => any;
+type ApiNamespace = {
+    [K in string]: ApiMethod | ApiNamespace;
+};
+type ContextfulApiMethod<T> = T extends ((...args: infer ARGS) => infer RT) ? ((context: Context | boolean, ...args: ARGS) => RT extends Promise<any> ? RT : Promise<RT>) : never;
+type ContextfulApiNamespace<T> = {
+    [K in keyof T]: T[K] extends ApiMethod ? ContextfulApiMethod<T[K]> : ContextfulApiNamespace<T[K]>;
+};
+type ContextWrapped<T extends ApiNamespace | ApiMethod> = T extends ApiMethod ? ContextfulApiMethod<T> : ContextfulApiNamespace<T>;
+export declare function withContext<T extends ApiMethod | ApiNamespace>(contextWrapper: (context: Context) => T, path?: string[]): ContextWrapped<T>;
+export declare function requiresContext(fnOrNS: Object): fnOrNS is (context: Context) => any;
+export declare class Context {
+    cookies: CookieJar;
+    location: URL;
+    constructor({ cookies, location }: {
+        cookies: CookieJar;
+        location: URL;
+    });
+}
+export {};

package/dist/adapters/context.js

@@ -0,0 +1,32 @@
+const __requiresContext = Symbol('__requiresContext');
+export function withContext(contextWrapper, path = []) {
+    // first param needs to be a function, which enables `Proxy` to implement `apply()`.
+    const fnOrNs = new Proxy(function () { }, {
+        apply(_target, _thisArg, args) {
+            const [context, ...remainingArgs] = args;
+            let functionOrNamespaceObject = contextWrapper(context);
+            console.log({ context, args, functionOrNamespaceObject, path });
+            for (const k of path) {
+                functionOrNamespaceObject = functionOrNamespaceObject[k];
+            }
+            return functionOrNamespaceObject(...remainingArgs);
+        },
+        get(_target, prop) {
+            if (prop === __requiresContext)
+                return true;
+            return withContext(contextWrapper, [...path, prop]);
+        }
+    });
+    return fnOrNs;
+}
+export function requiresContext(fnOrNS) {
+    return fnOrNS[__requiresContext] === true;
+}
+export class Context {
+    cookies;
+    location;
+    constructor({ cookies, location }) {
+        this.cookies = cookies;
+        this.location = location;
+    }
+}

package/dist/adapters/cookie-jar.d.ts

@@ -0,0 +1,30 @@
+export type Cookie = {
+    name: string;
+    value: string;
+    httpOnly?: boolean;
+    secure?: boolean;
+    maxAge?: number;
+};
+export declare class CookieJar {
+    #private;
+    /**
+     * Initialize
+     */
+    constructor(cookie?: string);
+    set(cookie: Cookie): void;
+    get(name: string): {
+        name: string;
+        value: string;
+        httpOnly?: boolean;
+        secure?: boolean;
+        maxAge?: number;
+    } | undefined;
+    delete(name: string): void;
+    /**
+     * Gets a copy of all cookies.
+     *
+     * Changes made to this copy are not reflected
+     */
+    getAll(): Record<string, string>;
+    getSetCookies(): Cookie[];
+}

package/dist/adapters/cookie-jar.js

@@ -0,0 +1,55 @@
+export class CookieJar {
+    #cookies = {};
+    /**
+     * The list of cookies that have been set with `set()` which need to be
+     * sent to the client.
+     */
+    #setCookies = new Set();
+    /**
+     * Initialize
+     */
+    constructor(cookie) {
+        this.#cookies = Object.fromEntries((cookie || '')
+            .split(/;/g)
+            .map(c => {
+            const [k, v] = c.split('=').map(p => decodeURIComponent(p.trim()));
+            return [k, {
+                    name: k,
+                    value: v
+                }];
+        }));
+    }
+    set(cookie) {
+        this.#cookies[cookie.name] = { ...cookie };
+        this.#setCookies.add(cookie.name);
+    }
+    get(name) {
+        return this.#cookies[name] ? { ...this.#cookies[name] } : undefined;
+    }
+    delete(name) {
+        if (this.#cookies[name]) {
+            this.#cookies[name].value = '-- deleted --';
+            this.#cookies[name].maxAge = 0;
+            this.#setCookies.add(name);
+        }
+    }
+    /**
+     * Gets a copy of all cookies.
+     *
+     * Changes made to this copy are not reflected
+     */
+    getAll() {
+        const all = {};
+        for (const cookie of Object.values(this.#cookies)) {
+            all[cookie.name] = cookie.value;
+        }
+        return all;
+    }
+    getSetCookies() {
+        const all = [];
+        for (const name of this.#setCookies) {
+            all.push({ ...this.#cookies[name] });
+        }
+        return all;
+    }
+}

package/dist/client/index.d.ts

@@ -0,0 +1 @@
+export declare function apiTree(INTERNAL_API_URL: string, path?: string[]): () => void;

package/dist/client/index.js

@@ -0,0 +1,68 @@
+async function callApi(INTERNAL_API_URL, method, ...args) {
+    function isNode() {
+        return typeof args[0]?.cookies?.getAll === 'function';
+    }
+    function apiUrl() {
+        if (isNode()) {
+            return INTERNAL_API_URL;
+        }
+        else {
+            return "/api";
+        }
+    }
+    let cookieHeader = {};
+    if (isNode()) {
+        const context = args[0];
+        const cookies = context.cookies.getAll();
+        cookieHeader = typeof cookies === 'object'
+            ? {
+                Cookie: Object.entries(cookies).map(kv => kv.join('=')).join('; ')
+            }
+            : {};
+    }
+    const response = await fetch(apiUrl(), {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...cookieHeader
+        },
+        body: JSON.stringify([{ method, args: [...args] }]),
+    });
+    const body = await response.json();
+    if (isNode()) {
+        const context = args[0];
+        for (const c of response.headers.getSetCookie()) {
+            const parts = c.split(';').map(p => p.trim());
+            const flags = parts.slice(1);
+            const [name, value] = parts[0].split('=').map(decodeURIComponent);
+            const httpOnly = flags.includes('HttpOnly');
+            const secure = flags.includes('Secure');
+            const maxAgePart = flags.find(f => f.startsWith('Max-Age='))?.split('=')[1];
+            context.cookies.set({
+                name,
+                value,
+                httpOnly,
+                secure,
+                maxAge: maxAgePart ? parseInt(maxAgePart) : undefined
+            });
+        }
+    }
+    const error = body[0].error;
+    if (error) {
+        throw new Error(error);
+    }
+    const value = body[0].data;
+    return value;
+}
+;
+export function apiTree(INTERNAL_API_URL, path = []) {
+    return new Proxy(function () { }, {
+        apply(_target, _thisArg, args) {
+            return callApi(INTERNAL_API_URL, path, ...args);
+        },
+        get(_target, prop) {
+            return apiTree(INTERNAL_API_URL, [...path, prop]);
+        }
+    });
+}
+;

package/dist/hosting/client.d.ts

@@ -0,0 +1 @@
+export declare function apiTree(INTERNAL_API_URL: string, path?: string[]): () => void;

package/dist/hosting/client.js

@@ -0,0 +1,68 @@
+async function callApi(INTERNAL_API_URL, method, ...args) {
+    function isNode() {
+        return typeof args[0]?.cookies?.getAll === 'function';
+    }
+    function apiUrl() {
+        if (isNode()) {
+            return INTERNAL_API_URL;
+        }
+        else {
+            return "/api";
+        }
+    }
+    let cookieHeader = {};
+    if (isNode()) {
+        const context = args[0];
+        const cookies = context.cookies.getAll();
+        cookieHeader = typeof cookies === 'object'
+            ? {
+                Cookie: Object.entries(cookies).map(kv => kv.join('=')).join('; ')
+            }
+            : {};
+    }
+    const response = await fetch(apiUrl(), {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...cookieHeader
+        },
+        body: JSON.stringify([{ method, args: [...args] }]),
+    });
+    const body = await response.json();
+    if (isNode()) {
+        const context = args[0];
+        for (const c of response.headers.getSetCookie()) {
+            const parts = c.split(';').map(p => p.trim());
+            const flags = parts.slice(1);
+            const [name, value] = parts[0].split('=').map(decodeURIComponent);
+            const httpOnly = flags.includes('HttpOnly');
+            const secure = flags.includes('Secure');
+            const maxAgePart = flags.find(f => f.startsWith('Max-Age='))?.split('=')[1];
+            context.cookies.set({
+                name,
+                value,
+                httpOnly,
+                secure,
+                maxAge: maxAgePart ? parseInt(maxAgePart) : undefined
+            });
+        }
+    }
+    const error = body[0].error;
+    if (error) {
+        throw new Error(error);
+    }
+    const value = body[0].data;
+    return value;
+}
+;
+export function apiTree(INTERNAL_API_URL, path = []) {
+    return new Proxy(function () { }, {
+        apply(_target, _thisArg, args) {
+            return callApi(INTERNAL_API_URL, path, ...args);
+        },
+        get(_target, prop) {
+            return apiTree(INTERNAL_API_URL, [...path, prop]);
+        }
+    });
+}
+;

package/dist/index.js

@@ -0,0 +1,6 @@
+export { FileService } from './services/file.js';
+export { AuthenticationService } from './services/authentication.js';
+export { CookieJar } from './adapters/cookie-jar.js';
+export { withContext, requiresContext, Context } from './adapters/context.js';
+export { Resource } from './resource.js';
+export { overrides } from './overrides.js';

package/dist/internal/client.d.ts

@@ -0,0 +1 @@
+export declare function apiTree(INTERNAL_API_URL: string, path?: string[]): () => void;

package/dist/internal/client.js

@@ -0,0 +1,68 @@
+async function callApi(INTERNAL_API_URL, method, ...args) {
+    function isNode() {
+        return typeof args[0]?.cookies?.getAll === 'function';
+    }
+    function apiUrl() {
+        if (isNode()) {
+            return INTERNAL_API_URL;
+        }
+        else {
+            return "/api";
+        }
+    }
+    let cookieHeader = {};
+    if (isNode()) {
+        const context = args[0];
+        const cookies = context.cookies.getAll();
+        cookieHeader = typeof cookies === 'object'
+            ? {
+                Cookie: Object.entries(cookies).map(kv => kv.join('=')).join('; ')
+            }
+            : {};
+    }
+    const response = await fetch(apiUrl(), {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...cookieHeader
+        },
+        body: JSON.stringify([{ method, args: [...args] }]),
+    });
+    const body = await response.json();
+    if (isNode()) {
+        const context = args[0];
+        for (const c of response.headers.getSetCookie()) {
+            const parts = c.split(';').map(p => p.trim());
+            const flags = parts.slice(1);
+            const [name, value] = parts[0].split('=').map(decodeURIComponent);
+            const httpOnly = flags.includes('HttpOnly');
+            const secure = flags.includes('Secure');
+            const maxAgePart = flags.find(f => f.startsWith('Max-Age='))?.split('=')[1];
+            context.cookies.set({
+                name,
+                value,
+                httpOnly,
+                secure,
+                maxAge: maxAgePart ? parseInt(maxAgePart) : undefined
+            });
+        }
+    }
+    const error = body[0].error;
+    if (error) {
+        throw new Error(error);
+    }
+    const value = body[0].data;
+    return value;
+}
+;
+export function apiTree(INTERNAL_API_URL, path = []) {
+    return new Proxy(function () { }, {
+        apply(_target, _thisArg, args) {
+            return callApi(INTERNAL_API_URL, path, ...args);
+        },
+        get(_target, prop) {
+            return apiTree(INTERNAL_API_URL, [...path, prop]);
+        }
+    });
+}
+;

package/dist/internal/index.d.ts

@@ -0,0 +1 @@
+export declare function prebuildApi(): Promise<void>;

package/dist/internal/index.js

@@ -0,0 +1,27 @@
+import process from 'process';
+import fs from 'fs';
+import path from 'path';
+export async function prebuildApi() {
+    const CWD = process.cwd();
+    let API_URL = '/api';
+    const indexModule = await import(path.join(CWD, 'index.js'));
+    try {
+        const backendConfigModule = await import(path.join(CWD, 'config.js'));
+        const backendConfig = backendConfigModule.default;
+        console.log("backend config found", backendConfig);
+        if (backendConfig.apiUrl) {
+            API_URL = backendConfig.apiUrl;
+        }
+    }
+    catch {
+        console.log("No backend API config found.");
+    }
+    const apiCode = Object.keys(indexModule)
+        .map(k => `export const ${k} = apiTree(INTERNAL_API_URL, ${JSON.stringify([k])});`)
+        .join('\n');
+    const baseClient = [
+        `import { apiTree } from "wirejs-resources/client";`,
+        `const INTERNAL_API_URL = ${JSON.stringify(API_URL)};`,
+    ].join('\n');
+    await fs.promises.writeFile(path.join(CWD, 'index.client.js'), [baseClient, apiCode].join('\n\n'));
+}

package/dist/overrides.d.ts

@@ -0,0 +1,11 @@
+import type { FileService } from "./services/file";
+import type { AuthenticationService } from "./services/authentication";
+import type { Secret } from "./resources/secret";
+/**
+ * Used by hosting providers to provide service overrides.
+ */
+export declare const overrides: {
+    FileService?: typeof FileService;
+    AuthenticationService?: typeof AuthenticationService;
+    Secret?: typeof Secret;
+};

package/{lib → dist}/overrides.js

@@ -1,4 +1,4 @@
 /**
  * Used by hosting providers to provide service overrides.
  */
-export const overrides = {};
+export const overrides = {};

package/dist/resource.d.ts

@@ -0,0 +1,6 @@
+export declare class Resource {
+    scope: Resource | string;
+    id: string;
+    constructor(scope: Resource | string, id: string);
+    get absoluteId(): string;
+}

package/dist/resource.js

@@ -0,0 +1,20 @@
+export class Resource {
+    scope;
+    id;
+    constructor(scope, id) {
+        this.scope = scope;
+        this.id = id;
+    }
+    get absoluteId() {
+        const sanitizedId = encodeURIComponent(this.id);
+        if (typeof this.scope === 'string') {
+            return `${encodeURIComponent(this.scope)}/${sanitizedId}`;
+        }
+        else if (typeof this.scope?.id === 'string') {
+            return `${this.scope.absoluteId}/${sanitizedId}`;
+        }
+        else {
+            throw new Error("Resources must defined within a scope. Provide either a namespace string or parent resource.");
+        }
+    }
+}

package/dist/resources/secret.d.ts

@@ -0,0 +1,7 @@
+import { Resource } from '../resource.js';
+export declare class Secret extends Resource {
+    #private;
+    constructor(scope: Resource | string, id: string);
+    read(): Promise<any>;
+    write(data: any): Promise<void>;
+}

package/dist/resources/secret.js

@@ -0,0 +1,28 @@
+import crypto from 'crypto';
+import { Resource } from '../resource.js';
+import { FileService } from '../services/file.js';
+import { overrides } from '../overrides.js';
+const FILENAME = 'secret';
+export class Secret extends Resource {
+    #fileService;
+    #initPromise;
+    constructor(scope, id) {
+        super(scope, id);
+        this.#fileService = new (overrides.FileService || FileService)(this, 'files');
+    }
+    #initialize() {
+        this.#initPromise = this.#initPromise || this.#fileService.write(FILENAME, JSON.stringify(crypto.randomBytes(64).toString('base64url')), { onlyIfNotExists: true }).catch(error => {
+            if (!this.#fileService.isAlreadyExistsError(error))
+                throw error;
+        });
+        return this.#initPromise;
+    }
+    async read() {
+        await this.#initialize();
+        return JSON.parse(await this.#fileService.read(FILENAME));
+    }
+    async write(data) {
+        await this.#initialize();
+        await this.#fileService.write(FILENAME, JSON.stringify(data));
+    }
+}

package/dist/services/authentication.d.ts

@@ -0,0 +1,67 @@
+import { Resource } from '../resource.js';
+import type { CookieJar } from '../adapters/cookie-jar.js';
+type AuthenticationInput = {
+    label: string;
+    type: 'text' | 'password';
+    isRequired?: boolean;
+};
+type Action = {
+    name: string;
+    title?: string;
+    description?: string;
+    message?: string;
+    inputs?: Record<string, AuthenticationInput>;
+    buttons?: string[];
+};
+type AuthenticationBaseState = {
+    state: 'authenticated' | 'unauthenticated';
+    user: string | undefined;
+};
+type AuthenticationState = {
+    state: AuthenticationBaseState;
+    message?: string;
+    actions: Record<string, Action>;
+};
+type PerformActionParameter = {
+    key: string;
+    inputs: Record<string, string | number | boolean>;
+    verb: string;
+};
+type AuthenticationError = {
+    message: string;
+    field?: string;
+};
+type AuthenticationServiceOptions = {
+    /**
+     * The number of seconds the authentication session stays alive.
+     */
+    duration?: number;
+    /**
+     * Whether to automatically extend (keep alive) an authentication session when used.
+     */
+    keepalive?: boolean;
+    /**
+     * The name of the cookie to use to store the authentication state JWT.
+     */
+    cookie?: string;
+};
+export declare class AuthenticationService extends Resource {
+    #private;
+    constructor(scope: Resource | string, id: string, { duration, keepalive, cookie }?: AuthenticationServiceOptions);
+    getSigningSecret(): Promise<Uint8Array<ArrayBufferLike>>;
+    get signingSecret(): Promise<Uint8Array<ArrayBufferLike>>;
+    getBaseState(cookies: CookieJar): Promise<AuthenticationBaseState>;
+    getState(cookies: CookieJar): Promise<AuthenticationState>;
+    setBaseState(cookies: CookieJar, user?: string): Promise<void>;
+    missingFieldErrors(input: Record<string, string | number | boolean>, fields: string[]): AuthenticationError[] | undefined;
+    setState(cookies: CookieJar, { key, inputs, verb: _verb }: PerformActionParameter): Promise<AuthenticationState | {
+        errors: AuthenticationError[];
+    }>;
+    buildApi(this: AuthenticationService): {
+        getState: (context: import("../adapters/context.js").Context | boolean) => Promise<AuthenticationState>;
+        setState: (context: import("../adapters/context.js").Context | boolean, options: PerformActionParameter) => Promise<AuthenticationState | {
+            errors: AuthenticationError[];
+        }>;
+    };
+}
+export {};