wirejs-resources 0.1.105 → 0.1.107-payments

package/dist/adapters/context.d.ts

@@ -1,4 +1,5 @@
 import { CookieJar } from "./cookie-jar.js";
+import { SystemAttribute } from "../resources/system-attribute.js";
 type ApiMethod = (...args: any) => any;
 type ApiNamespace = {
     [K in string]: ApiMethod | ApiNamespace;
@@ -8,14 +9,34 @@ export type ContextfulApiNamespace<T> = {
     [K in keyof T]: T[K] extends ApiMethod ? ContextfulApiMethod<T[K]> : ContextfulApiNamespace<T[K]>;
 };
 export type ContextWrapped<T extends ApiNamespace | ApiMethod> = T extends ApiMethod ? ContextfulApiMethod<T> : ContextfulApiNamespace<T>;
+export type SystemInfo = Record<string, SystemAttribute>;
 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` can be directly manipulated. The response pipeline
+     * will ingest changes to cookies when issuing a response.
+     */
+    readonly cookies: CookieJar;
+    readonly httpMethod?: string;
+    readonly requestHeaders: Record<string, string | string[]>;
+    readonly requestBody?: string;
+    responseHeaders: Record<string, string>;
+    responseCode: number | undefined;
+    private _location;
+    private _locationChanged;
+    private _runtimeAttributes;
+    constructor({ cookies, location, httpMethod, requestHeaders, requestBody, runtimeAttributes, }: {
         cookies: CookieJar;
         location: URL;
+        httpMethod: string;
+        requestHeaders: Record<string, string | string[]>;
+        requestBody: string | undefined;
+        runtimeAttributes?: SystemAttribute[];
     });
+    get location(): URL;
+    set location(url: URL | string);
+    get locationIsDirty(): boolean;
+    get systemInfo(): MapIterator<SystemAttribute>;
 }
 export {};

package/dist/adapters/context.js

@@ -1,3 +1,4 @@
+import { SystemAttribute } from "../resources/system-attribute.js";
 const __requiresContext = '__requiresContext';
 export function withContext(contextWrapper, path = []) {
     // first param needs to be a function, which enables `Proxy` to implement `apply()`.
@@ -27,10 +28,46 @@ export function requiresContext(fnOrNS) {
     return true;
 }
 export class Context {
+    /**
+     * `cookies` can be directly manipulated. The response pipeline
+     * will ingest changes to cookies when issuing a response.
+     */
     cookies;
-    location;
-    constructor({ cookies, location }) {
+    httpMethod;
+    requestHeaders;
+    requestBody;
+    responseHeaders = {};
+    responseCode;
+    _location;
+    _locationChanged = false;
+    _runtimeAttributes = [];
+    constructor({ cookies, location, httpMethod, requestHeaders, requestBody, runtimeAttributes, }) {
         this.cookies = cookies;
         this.location = location;
+        this.httpMethod = httpMethod;
+        this.requestHeaders = requestHeaders;
+        this.requestBody = requestBody;
+        this._runtimeAttributes = runtimeAttributes || [];
+    }
+    get location() {
+        return this._location;
+    }
+    set location(url) {
+        if (this._location)
+            this._locationChanged = true;
+        this._location = new URL(url);
+    }
+    get locationIsDirty() {
+        return this._locationChanged;
+    }
+    get systemInfo() {
+        const all = new Map();
+        for (const attr of SystemAttribute.listStaticAttributes()) {
+            all.set(attr.absoluteId, attr);
+        }
+        for (const attr of this._runtimeAttributes) {
+            all.set(attr.absoluteId, attr);
+        }
+        return all.values();
     }
 }

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

@@ -1,4 +1,4 @@
-import type { Secret } from '../resources/secret.js';
+import type { Setting } from '../resources/setting.js';
 import { Cookie, CookieJar } from './cookie-jar.js';
 import { Resource } from '../resource.js';
 export declare class SignedCookie<T> {
@@ -6,7 +6,10 @@ export declare class SignedCookie<T> {
     private name;
     private signingSecret;
     private options;
-    constructor(scope: Resource | string, name: string, signingSecret: Secret, options?: Omit<Cookie, 'value' | 'name'>);
+    constructor(scope: Resource | string, name: string, signingSecret: Setting<{
+        private: true;
+        init: 'random';
+    }>, options?: Omit<Cookie, 'value' | 'name'>);
     get cookieName(): string;
     read(cookies: CookieJar): Promise<T | null>;
     write(cookies: CookieJar, value: T | null): Promise<void>;

package/dist/index.d.ts

@@ -5,10 +5,13 @@ export { SignedCookie } from './adapters/signed-cookie.js';
 export { withContext, requiresContext, Context, ContextWrapped } from './adapters/context.js';
 export { Resource } from './resource.js';
 export { overrides } from './overrides.js';
-export { Secret } from './resources/secret.js';
+export { Setting } from './resources/setting.js';
 export { DistributedTable, PassThruParser, matchesFilter, indexName } from './resources/distributed-table.js';
 export type * from './resources/distributed-table.js';
 export * from './types/index.js';
 export * from './derived-types.js';
 export * from './services/realtime.js';
 export * from './resources/background-job.js';
+export * from './resources/key-value-store.js';
+export * from './resources/endpoint.js';
+export * from './resources/system-attribute.js';

package/dist/index.js

@@ -5,9 +5,12 @@ export { SignedCookie } from './adapters/signed-cookie.js';
 export { withContext, requiresContext, Context } from './adapters/context.js';
 export { Resource } from './resource.js';
 export { overrides } from './overrides.js';
-export { Secret } from './resources/secret.js';
+export { Setting } from './resources/setting.js';
 export { DistributedTable, PassThruParser, matchesFilter, indexName } from './resources/distributed-table.js';
 export * from './types/index.js';
 export * from './derived-types.js';
 export * from './services/realtime.js';
 export * from './resources/background-job.js';
+export * from './resources/key-value-store.js';
+export * from './resources/endpoint.js';
+export * from './resources/system-attribute.js';

package/dist/overrides.d.ts

@@ -1,16 +1,21 @@
-import type { FileService } from "./services/file";
 import type { AuthenticationService } from "./services/authentication";
-import type { Secret } from "./resources/secret";
-import type { RealtimeService } from "./services/realtime";
 import type { BackgroundJob } from "./resources/background-job";
+import type { DistributedTable } from "./resources/distributed-table";
+import type { Endpoint } from "./resources/endpoint";
+import type { FileService } from "./services/file";
+import type { KeyValueStore } from "./resources/key-value-store";
+import type { RealtimeService } from "./services/realtime";
+import type { Setting } from "./resources/setting";
 /**
  * Used by hosting providers to provide service overrides.
  */
 export declare const overrides: {
     AuthenticationService?: typeof AuthenticationService;
-    DistributedTable?: typeof AuthenticationService;
+    BackgroundJob?: typeof BackgroundJob;
+    DistributedTable?: typeof DistributedTable;
+    Endpoint?: typeof Endpoint;
     FileService?: typeof FileService;
-    Secret?: typeof Secret;
+    KeyValueStore?: typeof KeyValueStore;
     RealtimeService?: typeof RealtimeService;
-    BackgroundJob?: typeof BackgroundJob;
+    Setting?: typeof Setting;
 };

package/dist/resources/distributed-table.d.ts

@@ -26,7 +26,9 @@ export declare class DistributedTable<const P extends Parser<any>, const T exten
     });
     get partitionKeyName(): Key['partition']['field'];
     get sortKeyName(): 'field' extends keyof Key['sort'] ? (Key['sort']['field'] extends string ? Key['sort']['field'] : undefined) : undefined;
-    save(item: T): Promise<void>;
+    save(item: T, options?: {
+        onlyIfNotExists?: boolean;
+    }): Promise<void>;
     saveMany(items: T[]): Promise<void>;
     delete(item: KindaPretty<RecordKey<T, Key>>): Promise<void>;
     deleteMany(items: (KindaPretty<RecordKey<T, Key>>)[]): Promise<void>;
@@ -58,4 +60,5 @@ export declare class DistributedTable<const P extends Parser<any>, const T exten
         where: KeyCondition<DistributedTable<P, T, Key, Indexes>, GivenPartition>;
         filter?: Filter<Omit<T, IndexFieldNames<DistributedTable<P, T, Key, Indexes>, GivenPartition> & string>>;
     }): AsyncGenerator<T>;
+    isAlreadyExistsError(error: any): boolean;
 }

package/dist/resources/distributed-table.js

@@ -80,9 +80,11 @@ export class DistributedTable extends Resource {
         }
         return parts.map(String).join('__') + '.json';
     }
-    async save(item) {
+    async save(item, options) {
         const key = this.#getFilename(item);
-        await this.#fileService.write(key, JSON.stringify(item));
+        await this.#fileService.write(key, JSON.stringify(item), {
+            onlyIfNotExists: options?.onlyIfNotExists
+        });
     }
     async saveMany(items) {
         const promises = items.map(item => {
@@ -125,9 +127,10 @@ export class DistributedTable extends Resource {
      */
     async *scan(options) {
         for await (const filename of this.#fileService.list()) {
+            console.log('scanning', filename);
             const data = await this.#fileService.read(filename);
             const record = this.parse(JSON.parse(data));
-            if (!options.filter || matchesFilter(record, options.filter)) {
+            if (!options?.filter || matchesFilter(record, options.filter)) {
                 yield record;
             }
         }
@@ -157,4 +160,7 @@ export class DistributedTable extends Resource {
             }
         });
     }
+    isAlreadyExistsError(error) {
+        return this.#fileService.isAlreadyExistsError(error);
+    }
 }

package/dist/resources/endpoint.d.ts

@@ -0,0 +1,42 @@
+import { Resource } from '../resource.js';
+import { Context } from '../adapters/context.js';
+export type EndpointOptions = {
+    /**
+     * If left unspecified, the path will derived from its `absoluteId`.
+     *
+     * If specified, the endpoint *may* end in a wildcard (`%`) to handle
+     * all requests matching the given prefix.
+     *
+     * Programmatically created endpoints take precedence over
+     */
+    path?: string;
+    /**
+     * The function that will handle requests.
+     *
+     * Currently, these handlers can only return strings, which means that if
+     * your endpoint returns an HTML page that requires other resources, you
+     * must also provide those resources manually.
+     *
+     * @param context
+     * @returns
+     */
+    handle: (context: Context) => string | Promise<string>;
+    /**
+     * Message explaining the purpose of the path.
+     */
+    description?: string;
+};
+export declare class Endpoint extends Resource {
+    options: EndpointOptions;
+    constructor(scope: Resource | string, id: string, options: EndpointOptions);
+    static list(): MapIterator<Endpoint>;
+    static get(key: string): Endpoint | undefined;
+    get description(): string | undefined;
+    get path(): string;
+    get handle(): (context: Context) => string | Promise<string>;
+    /**
+     * Constructed full URL of the endpoint based on the configured
+     * `wirejs/endpoint-origin` setting.
+     */
+    determineUrl(): Promise<string>;
+}

package/dist/resources/endpoint.js

@@ -0,0 +1,48 @@
+import { Resource } from '../resource.js';
+import { Setting } from './setting.js';
+import { overrides } from '../overrides.js';
+let endpointOrigin;
+const allEndpoints = new Map();
+function createOriginSetting() {
+    return new (overrides.Setting || Setting)('wirejs', 'endpoint-origin', {
+        description: 'Base URL modules should broadcast to external services.',
+        init: () => 'http://localhost:3000',
+        private: false,
+    });
+}
+export class Endpoint extends Resource {
+    options;
+    constructor(scope, id, options) {
+        super(scope, id);
+        this.options = options;
+        allEndpoints.set(this.absoluteId, this);
+        endpointOrigin = endpointOrigin || createOriginSetting();
+    }
+    static list() {
+        return allEndpoints.values();
+    }
+    static get(key) {
+        return allEndpoints.get(key);
+    }
+    get description() {
+        return this.options.description;
+    }
+    get path() {
+        const path = this.options.path || this.absoluteId;
+        return path.startsWith('/') ? path : `/${path}`;
+    }
+    get handle() {
+        return this.options.handle;
+    }
+    /**
+     * Constructed full URL of the endpoint based on the configured
+     * `wirejs/endpoint-origin` setting.
+     */
+    async determineUrl() {
+        const origin = await endpointOrigin?.read();
+        const normalizedOrigin = origin?.endsWith('/')
+            ? origin.slice(0, origin.length - 1)
+            : origin;
+        return `${normalizedOrigin}${this.path}`;
+    }
+}

package/dist/resources/key-value-store.d.ts

@@ -0,0 +1,16 @@
+import { Resource } from '../resource.js';
+import { KindaPretty } from '../types/index.js';
+export declare class KeyValueStore<T> extends Resource {
+    #private;
+    constructor(scope: Resource | string, id: string);
+    get(key: string): Promise<KindaPretty<KindaPretty<T>> | undefined>;
+    set(key: string, value: KindaPretty<T>, options?: {
+        onlyIfNotExists?: boolean;
+    }): Promise<void>;
+    delete(key: string): Promise<void>;
+    scan(): AsyncGenerator<{
+        key: string;
+        value: KindaPretty<T>;
+    }>;
+    isAlreadyExistsError(error: any): boolean;
+}

package/dist/resources/key-value-store.js

@@ -0,0 +1,34 @@
+import { Resource } from '../resource.js';
+import { DistributedTable, PassThruParser } from './distributed-table.js';
+import { overrides } from '../overrides.js';
+const defineTable = (kvStore) => {
+    const ctor = overrides.DistributedTable || DistributedTable;
+    return new ctor(kvStore, 'table', {
+        parse: (PassThruParser),
+        key: { partition: { field: "key", type: 'string' } },
+    });
+};
+export class KeyValueStore extends Resource {
+    #table;
+    constructor(scope, id) {
+        super(scope, id);
+        this.#table = defineTable(this);
+    }
+    async get(key) {
+        return (await this.#table.get({ key }))?.value;
+    }
+    async set(key, value, options) {
+        return this.#table.save({ key, value }, { onlyIfNotExists: options?.onlyIfNotExists });
+    }
+    async delete(key) {
+        return this.#table.delete({ key });
+    }
+    async *scan() {
+        for await (const record of this.#table.scan({})) {
+            yield record;
+        }
+    }
+    isAlreadyExistsError(error) {
+        return this.#table.isAlreadyExistsError(error);
+    }
+}

package/dist/resources/setting.d.ts

@@ -0,0 +1,25 @@
+import { Resource } from '../resource.js';
+type Initializer<ValidOptions extends string = string> = 'random' | (() => ValidOptions) | null | undefined;
+export type SettingDetails<Init extends Initializer<ValidOptions>, ValidOptions extends string = string> = {
+    private: boolean;
+    description?: string;
+    init?: Init;
+    options?: ValidOptions[];
+};
+type ReturnTypeFor<T extends SettingDetails<Initializer, string>> = T extends SettingDetails<undefined | null, infer ValidOptions> ? (ValidOptions | undefined) : string;
+type SetTypeFor<T extends SettingDetails<Initializer, string>> = T extends SettingDetails<undefined | null, infer ValidOptions> ? ValidOptions : string;
+export declare class Setting<const Details extends SettingDetails<Initializer> = SettingDetails<null>> extends Resource {
+    private details;
+    constructor(scope: Resource | string, id: string, details?: Details);
+    get isPrivate(): boolean;
+    get description(): string | undefined;
+    get options(): string[] | undefined;
+    read(): Promise<ReturnTypeFor<Details>>;
+    write(value: SetTypeFor<Details>, options?: {
+        onlyIfNotExists?: boolean;
+    }): Promise<void | undefined>;
+    static list(): MapIterator<Setting<SettingDetails<Initializer<string>, string>>>;
+    static get(key: string): Setting<SettingDetails<Initializer<string>, string>> | undefined;
+    isAlreadyExistsError(error: any): boolean | undefined;
+}
+export {};

package/dist/resources/setting.js

@@ -0,0 +1,61 @@
+import * as crypto from 'crypto';
+import { Resource } from '../resource.js';
+import { KeyValueStore } from './key-value-store.js';
+import { overrides } from '../overrides.js';
+let settings;
+const allSettings = new Map();
+export class Setting extends Resource {
+    details;
+    constructor(scope, id, details) {
+        super(scope, id);
+        this.details = (details || { private: false });
+        settings = new (overrides.KeyValueStore || KeyValueStore)('wirejs', 'settings');
+        allSettings.set(this.absoluteId, this);
+    }
+    get isPrivate() {
+        return this.details.private;
+    }
+    get description() {
+        return this.details.description;
+    }
+    get options() {
+        return this.details.options;
+    }
+    async read() {
+        const existingValue = await settings?.get(this.absoluteId);
+        if (!existingValue && !!this.details.init) {
+            try {
+                const initValue = this.details.init === 'random'
+                    ? crypto.randomBytes(64).toString('base64url')
+                    : this.details.init();
+                await this.write(initValue, { onlyIfNotExists: true });
+                return initValue;
+            }
+            catch (error) {
+                if (!this.isAlreadyExistsError(error))
+                    throw error;
+                return this.read();
+            }
+        }
+        else {
+            return existingValue?.value;
+        }
+    }
+    async write(value, options) {
+        return settings?.set(this.absoluteId, {
+            value,
+            private: this.details.private,
+            description: this.details.description,
+            options: this.details.options,
+        }, { onlyIfNotExists: options?.onlyIfNotExists });
+    }
+    static list() {
+        return allSettings.values();
+    }
+    static get(key) {
+        return allSettings.get(key);
+    }
+    isAlreadyExistsError(error) {
+        return settings?.isAlreadyExistsError(error);
+    }
+}

package/dist/resources/system-attribute.d.ts

@@ -0,0 +1,21 @@
+import { Resource } from '../resource.js';
+type SystemAttributeProperties = {
+    description: string;
+    value: string | null;
+};
+export declare class SystemAttribute extends Resource {
+    private props;
+    constructor(scope: Resource | string, id: string, props: SystemAttributeProperties);
+    get name(): string;
+    get description(): string;
+    get value(): string | null;
+    /**
+     * Lists attributes defined statically by code and modules within your
+     * codebase and imported modules. This is *not* intended to includes
+     * attributes defined by the build system or runtime. To enumerate all known
+     * attributes, use `Context.systemInfo`.
+     * @returns
+     */
+    static listStaticAttributes(): MapIterator<SystemAttribute>;
+}
+export {};

package/dist/resources/system-attribute.js

@@ -0,0 +1,29 @@
+import { Resource } from '../resource.js';
+const staticAttributes = new Map();
+export class SystemAttribute extends Resource {
+    props;
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.props = props;
+        staticAttributes.set(this.absoluteId, this);
+    }
+    get name() {
+        return this.absoluteId;
+    }
+    get description() {
+        return this.props.description;
+    }
+    get value() {
+        return this.props.value;
+    }
+    /**
+     * Lists attributes defined statically by code and modules within your
+     * codebase and imported modules. This is *not* intended to includes
+     * attributes defined by the build system or runtime. To enumerate all known
+     * attributes, use `Context.systemInfo`.
+     * @returns
+     */
+    static listStaticAttributes() {
+        return staticAttributes.values();
+    }
+}

package/dist/services/authentication.js

@@ -1,7 +1,7 @@
 import { scrypt, randomBytes, randomUUID } from 'crypto';
 import { Resource } from '../resource.js';
 import { FileService } from './file.js';
-import { Secret } from '../resources/secret.js';
+import { Setting } from '../resources/setting.js';
 import { SignedCookie } from '../adapters/signed-cookie.js';
 import { withContext } from '../adapters/context.js';
 import { overrides } from '../overrides.js';
@@ -187,7 +187,11 @@ export class AuthenticationService extends Resource {
     constructor(scope, id, { duration, keepalive, cookie } = {}) {
         super(scope, id);
         this.#keepalive = !!keepalive;
-        const signingSecret = new (overrides.Secret || Secret)(this, 'jwt-signing-secret');
+        const SettingCtor = overrides.Setting || Setting;
+        const signingSecret = new SettingCtor(this, 'jwt-signing-secret', {
+            private: true, init: 'random',
+            description: "Used for signing the auth JWT. Should generally not be changed."
+        });
         const fileService = new (overrides.FileService || FileService)(this, 'files');
         this.#cookie = new SignedCookie(this, cookie ?? 'identity', signingSecret, 
         // in the future, we might want to set `secure` based on whether we're in

package/dist/services/file.js

@@ -28,11 +28,19 @@ export class FileService extends Resource {
     async *list({ prefix = '' } = {}) {
         const root = this.#fullNameFor('');
         try {
-            const all = await fs.promises.readdir(root, { recursive: true });
+            const entries = await fs.promises.readdir(root, {
+                recursive: true,
+                withFileTypes: true
+            });
+            const all = entries
+                .filter(entry => entry.isFile())
+                .map(entry => path.join(entry.parentPath, entry.name));
             for (const name of all) {
+                const relativeName = name.slice(root.length);
+                console.log('relativeName', relativeName);
                 if (prefix === undefined
-                    || name.slice(0, root.length).startsWith(prefix)) {
-                    yield name;
+                    || relativeName.startsWith(prefix)) {
+                    yield relativeName;
                 }
             }
         }

package/dist/services/realtime.d.ts

@@ -1,4 +1,5 @@
 import { Resource } from '../resource.js';
+import { Context } from '../adapters/context.js';
 export type MessageStream<T = any> = {
     /**
      * Returns a function to close the subscription.
@@ -16,7 +17,7 @@ export declare class RealtimeService<T = any> extends Resource {
     /**
      * The address the client will need to connect to.
      */
-    get address(): string;
+    address(context: Context): string;
     publish(channel: string, events: T[]): Promise<void>;
-    getStream(channel: string): Promise<MessageStream<T>>;
+    getStream(context: Context, channel: string): Promise<MessageStream<T>>;
 }

package/dist/services/realtime.js

@@ -1,7 +1,7 @@
 import * as jose from 'jose';
 import { WebSocketServer, WebSocket } from 'ws';
 import { Resource } from '../resource.js';
-import { Secret } from '../resources/secret.js';
+import { Setting } from '../resources/setting.js';
 import { overrides } from '../overrides.js';
 const servers = new Map();
 const channels = new Map();
@@ -11,7 +11,10 @@ export class RealtimeService extends Resource {
     #server;
     constructor(scope, id) {
         super(scope, id);
-        this.#secret = new (overrides.Secret || Secret)(this, 'auth-secret');
+        this.#secret = new (overrides.Setting || Setting)(this, 'auth-secret', {
+            private: true, init: 'random',
+            description: "Used to sign realtime subscription authorization. Should generally not be changed."
+        });
         if (servers.has(this.absoluteId)) {
             console.log('existing realtime service found');
             this.#server = servers.get(this.absoluteId);
@@ -29,7 +32,7 @@ export class RealtimeService extends Resource {
         if (this.#server)
             return;
         console.log('Starting WebSocket server...');
-        this.#server = new WebSocketServer({ port: 0 });
+        this.#server = new WebSocketServer({ port: 3001 });
         servers.set(this.absoluteId, this.#server);
         this.#server.on('connection', async (ws, req) => {
             const encodedChannel = req.url?.split('/')[1];
@@ -97,7 +100,7 @@ export class RealtimeService extends Resource {
     /**
      * The address the client will need to connect to.
      */
-    get address() {
+    address(context) {
         this.#requireServer();
         const address = this.#server.address();
         if (typeof address === 'string') {
@@ -105,7 +108,7 @@ export class RealtimeService extends Resource {
         }
         else if (typeof address === 'object' && address !== null) {
             const { port } = address;
-            return `ws://localhost:${port}`;
+            return `ws://${context.location.hostname}:${port}`;
         }
         else {
             throw new Error('Server address is not available');
@@ -123,7 +126,7 @@ export class RealtimeService extends Resource {
             }
         });
     }
-    async getStream(channel) {
+    async getStream(context, channel) {
         this.#requireServer();
         this.#validateChannelName(channel);
         const channelString = Buffer.from(channel).toString('base64');
@@ -137,7 +140,7 @@ export class RealtimeService extends Resource {
         // It's the metadata needed to satisfy the contract client-side.
         return {
             __wjstype: 'realtime',
-            url: `${this.address}/${channelString}`,
+            url: `${this.address(context)}/${channelString}`,
             protocol: jwt
         };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wirejs-resources",
-	"version": "0.1.105",
+	"version": "0.1.107-payments",
 	"description": "Basic services and server-side resources for wirejs apps",
 	"type": "module",
 	"main": "./dist/index.js",

package/dist/hosting/client.d.ts

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

package/dist/hosting/client.js

@@ -1,68 +0,0 @@
-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/client.d.ts

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

package/dist/internal/client.js

@@ -1,68 +0,0 @@
-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/setup/index.d.ts

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

package/dist/setup/index.js

@@ -1,27 +0,0 @@
-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/hosting/client.js";`,
-        `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'));
-}