@milkio/stargate 1.0.0-alpha.99 → 1.0.0-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 akirarika
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/index.d.ts

@@ -0,0 +1,284 @@
+export type MilkioStargateOptions = {
+    baseUrl: string | (() => string) | (() => Promise<string>);
+    timeout?: number;
+    fetch?: typeof fetch;
+    abort?: typeof AbortController;
+};
+export type Mixin<T, U> = U & Omit<T, keyof U>;
+export type ExecuteOptions = {
+    params?: Record<any, any>;
+    headers?: Record<string, string>;
+    timeout?: number;
+    type?: "action" | "stream";
+    baseUrl?: string | (() => string) | (() => Promise<string>);
+};
+export type ExecuteResultsOption = {
+    executeId: string;
+};
+export type Ping = [
+    {
+        connect: false;
+        delay: number;
+        error: any;
+    },
+    null
+] | [
+    null,
+    {
+        connect: true;
+        delay: number;
+        serverTimestamp: number;
+    }
+];
+export declare function createStargate<Generated extends {
+    routeSchema: any;
+    rejectCode: any;
+}>(stargateOptions: MilkioStargateOptions): Promise<{
+    $types: {
+        generated: Generated;
+    };
+    options: MilkioStargateOptions;
+    execute<Path extends keyof Generated["routeSchema"]>(path: Path, options?: Mixin<ExecuteOptions, {
+        params?: Generated["routeSchema"][Path]["types"]["params"];
+    }>): Promise<Generated["routeSchema"][Path]["types"]["\uD83D\uDC23"] extends boolean ? // action
+    [Partial<Generated["rejectCode"]>, null, ExecuteResultsOption] | [null, Generated["routeSchema"][Path]["types"]["result"], ExecuteResultsOption] : // stream
+    [Partial<Generated["rejectCode"]>, null, ExecuteResultsOption] | [null, AsyncGenerator<[Partial<Generated["rejectCode"]>, null] | [null, GeneratorGeneric<Generated["routeSchema"][Path]["types"]["result"]>], ExecuteResultsOption>]>;
+    __cookbook: {
+        subscribe: (baseUrl: string) => Promise<any>;
+    };
+    ping(options?: {
+        timeout?: number;
+    }): Promise<Ping>;
+    on: <Key extends keyof {
+        "milkio:executeBefore": {
+            path: string;
+            options: Mixin<ExecuteOptions, {
+                headers: Record<string, string>;
+                baseUrl: string;
+            }>;
+        };
+        "milkio:fetchBefore": {
+            path: string;
+            options: Mixin<ExecuteOptions, {
+                headers: Record<string, string>;
+                baseUrl: string;
+            }>;
+            body: string;
+        };
+        "milkio:executeError": {
+            path: string;
+            options: Mixin<ExecuteOptions, {
+                headers: Record<string, string>;
+                baseUrl: string;
+            }>;
+            error: Partial<Generated["rejectCode"]>;
+            handleError: <K extends keyof Partial<Generated["rejectCode"]>>(error: any, key: K, handler: (error: Partial<Generated["rejectCode"][K]>) => boolean | Promise<boolean>) => Promise<void>;
+        };
+    }, Handler extends (event: {
+        "milkio:executeBefore": {
+            path: string;
+            options: Mixin<ExecuteOptions, {
+                headers: Record<string, string>;
+                baseUrl: string;
+            }>;
+        };
+        "milkio:fetchBefore": {
+            path: string;
+            options: Mixin<ExecuteOptions, {
+                headers: Record<string, string>;
+                baseUrl: string;
+            }>;
+            body: string;
+        };
+        "milkio:executeError": {
+            path: string;
+            options: Mixin<ExecuteOptions, {
+                headers: Record<string, string>;
+                baseUrl: string;
+            }>;
+            error: Partial<Generated["rejectCode"]>;
+            handleError: <K extends keyof Partial<Generated["rejectCode"]>>(error: any, key: K, handler: (error: Partial<Generated["rejectCode"][K]>) => boolean | Promise<boolean>) => Promise<void>;
+        };
+    }[Key]) => void>(key: Key, handler: Handler) => () => void;
+    off: <Key extends keyof {
+        "milkio:executeBefore": {
+            path: string;
+            options: Mixin<ExecuteOptions, {
+                headers: Record<string, string>;
+                baseUrl: string;
+            }>;
+        };
+        "milkio:fetchBefore": {
+            path: string;
+            options: Mixin<ExecuteOptions, {
+                headers: Record<string, string>;
+                baseUrl: string;
+            }>;
+            body: string;
+        };
+        "milkio:executeError": {
+            path: string;
+            options: Mixin<ExecuteOptions, {
+                headers: Record<string, string>;
+                baseUrl: string;
+            }>;
+            error: Partial<Generated["rejectCode"]>;
+            handleError: <K extends keyof Partial<Generated["rejectCode"]>>(error: any, key: K, handler: (error: Partial<Generated["rejectCode"][K]>) => boolean | Promise<boolean>) => Promise<void>;
+        };
+    }, Handler extends (event: {
+        "milkio:executeBefore": {
+            path: string;
+            options: Mixin<ExecuteOptions, {
+                headers: Record<string, string>;
+                baseUrl: string;
+            }>;
+        };
+        "milkio:fetchBefore": {
+            path: string;
+            options: Mixin<ExecuteOptions, {
+                headers: Record<string, string>;
+                baseUrl: string;
+            }>;
+            body: string;
+        };
+        "milkio:executeError": {
+            path: string;
+            options: Mixin<ExecuteOptions, {
+                headers: Record<string, string>;
+                baseUrl: string;
+            }>;
+            error: Partial<Generated["rejectCode"]>;
+            handleError: <K extends keyof Partial<Generated["rejectCode"]>>(error: any, key: K, handler: (error: Partial<Generated["rejectCode"][K]>) => boolean | Promise<boolean>) => Promise<void>;
+        };
+    }[Key]) => void>(key: Key, handler: Handler) => void;
+    emit: <Key extends keyof {
+        "milkio:executeBefore": {
+            path: string;
+            options: Mixin<ExecuteOptions, {
+                headers: Record<string, string>;
+                baseUrl: string;
+            }>;
+        };
+        "milkio:fetchBefore": {
+            path: string;
+            options: Mixin<ExecuteOptions, {
+                headers: Record<string, string>;
+                baseUrl: string;
+            }>;
+            body: string;
+        };
+        "milkio:executeError": {
+            path: string;
+            options: Mixin<ExecuteOptions, {
+                headers: Record<string, string>;
+                baseUrl: string;
+            }>;
+            error: Partial<Generated["rejectCode"]>;
+            handleError: <K extends keyof Partial<Generated["rejectCode"]>>(error: any, key: K, handler: (error: Partial<Generated["rejectCode"][K]>) => boolean | Promise<boolean>) => Promise<void>;
+        };
+    }, Value extends {
+        "milkio:executeBefore": {
+            path: string;
+            options: Mixin<ExecuteOptions, {
+                headers: Record<string, string>;
+                baseUrl: string;
+            }>;
+        };
+        "milkio:fetchBefore": {
+            path: string;
+            options: Mixin<ExecuteOptions, {
+                headers: Record<string, string>;
+                baseUrl: string;
+            }>;
+            body: string;
+        };
+        "milkio:executeError": {
+            path: string;
+            options: Mixin<ExecuteOptions, {
+                headers: Record<string, string>;
+                baseUrl: string;
+            }>;
+            error: Partial<Generated["rejectCode"]>;
+            handleError: <K extends keyof Partial<Generated["rejectCode"]>>(error: any, key: K, handler: (error: Partial<Generated["rejectCode"][K]>) => boolean | Promise<boolean>) => Promise<void>;
+        };
+    }[Key]>(key: Key, value: Value) => Promise<void>;
+}>;
+export interface ExecuteStreamOptions {
+    headers?: Record<string, string>;
+    timeout?: number;
+}
+export interface ApiSchemaExtend {
+    apiValidator: {
+        generatedAt: number;
+        validate: Record<any, any>;
+    };
+    apiMethodsSchema: Record<any, any>;
+    apiMethodsTypeSchema: Record<any, any>;
+    apiTestsSchema: Record<any, any>;
+}
+export type FailCodeExtend = Record<any, (...args: Array<any>) => any>;
+export type BootstrapMiddleware = (data: {
+    storage: ClientStorage;
+}) => Promise<void> | void;
+export type BeforeExecuteMiddleware = (data: {
+    path: string;
+    params: any;
+    headers: Record<string, string>;
+    storage: ClientStorage;
+}) => Promise<void> | void;
+export type AfterExecuteMiddleware = (data: {
+    path: string;
+    result: {
+        value: any;
+    };
+    storage: ClientStorage;
+}) => Promise<void> | void;
+export interface MiddlewareOptions {
+    bootstrap?: BootstrapMiddleware;
+    beforeExecute?: BeforeExecuteMiddleware;
+    afterExecute?: AfterExecuteMiddleware;
+}
+export interface ClientStorage {
+    getItem: (key: string) => Promise<string | null>;
+    setItem: (key: string, value: string) => Promise<void>;
+    removeItem: (key: string) => Promise<void>;
+}
+export interface ExecuteResultSuccess<Result> {
+    executeId: string;
+    success: true;
+    data: Result;
+}
+export type GeneratorGeneric<T> = T extends AsyncGenerator<infer I> ? I : never;
+export type FlattenKeys<T, Prefix extends string = ""> = {
+    [K in keyof T]: T[K] extends object ? FlattenKeys<T[K], `${Prefix}${Exclude<K, symbol>}.`> : `$input.${Prefix}${Exclude<K, symbol>}`;
+}[keyof T];
+/**
+ * Represents a message sent in an event stream
+ * https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format
+ */
+export interface EventSourceMessage {
+    data: string;
+}
+/**
+ * Converts a ReadableStream into a callback pattern.
+ * @param stream The input ReadableStream.
+ * @param onChunk A function that will be called on each new byte chunk in the stream.
+ * @returns {Promise<void>} A promise that will be resolved when the stream closes.
+ */
+export declare function getBytes(stream: ReadableStream<Uint8Array>, onChunk: (arr: Uint8Array) => void): Promise<void>;
+/**
+ * Parses arbitary byte chunks into EventSource line buffers.
+ * Each line should be of the format "field: value" and ends with \r, \n, or \r\n.
+ * @param onLine A function that will be called on each new EventSource line.
+ * @returns A function that should be called for each incoming byte chunk.
+ */
+export declare function getLines(onLine: (line: Uint8Array, fieldLength: number) => void): (arr: Uint8Array) => void;
+/**
+ * Parses line buffers into EventSourceMessages.
+ * @param onId A function that will be called on each `id` field.
+ * @param onRetry A function that will be called on each `retry` field.
+ * @param onMessage A function that will be called on each message.
+ * @returns A function that should be called for each incoming line buffer.
+ */
+export declare function getMessages(onMessage?: (msg: EventSourceMessage) => void): (line: Uint8Array, fieldLength: number) => void;
+export declare function withResolvers<T = any>(): PromiseWithResolvers<T>;