@milkio/stargate 1.0.0-alpha.1 → 1.0.0-alpha.100

package/index.ts

@@ -40,6 +40,64 @@ export async function createStargate<Generated extends { routeSchema: any; rejec
   const $fetch = stargateOptions.fetch ?? fetch;
   const $abort = stargateOptions.abort ?? AbortController;
 
+  type StargateEvents = {
+    "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>;
+    };
+  };
+
+  const handleError: any = async (error: any, key: string, handler: (error: any) => boolean | Promise<boolean>) => {
+    if (key in error) {
+      const handled = await handler(error[key]);
+      if (handled) delete error[key];
+    }
+  };
+
+  const __initEventManager = () => {
+    const handlers = new Map<(event: any) => void, string>();
+    const indexed = new Map<string, Set<(event: any) => void>>();
+
+    const eventManager = {
+      on: <Key extends keyof StargateEvents, Handler extends (event: StargateEvents[Key]) => void>(key: Key, handler: Handler) => {
+        handlers.set(handler, key as string);
+        if (indexed.has(key as string) === false) {
+          indexed.set(key as string, new Set());
+        }
+        const set = indexed.get(key as string)!;
+        set.add(handler);
+        handlers.set(handler, key as string);
+
+        return () => {
+          handlers.delete(handler);
+          set.delete(handler);
+        };
+      },
+      off: <Key extends keyof StargateEvents, Handler extends (event: StargateEvents[Key]) => void>(key: Key, handler: Handler) => {
+        const set = indexed.get(key as string);
+        if (!set) return;
+        handlers.delete(handler);
+        set.delete(handler);
+      },
+      emit: async <Key extends keyof StargateEvents, Value extends StargateEvents[Key]>(key: Key, value: Value): Promise<void> => {
+        const h = indexed.get(key as string);
+        if (h) {
+          for (const handler of h) {
+            await handler(value);
+          }
+        }
+      },
+    };
+
+    return eventManager;
+  };
+
+  const eventManager = __initEventManager();
+
   const bootstrap = async () => {
     let baseUrl = stargateOptions.baseUrl;
     if (typeof baseUrl === "function") baseUrl = await baseUrl();
@@ -51,25 +109,27 @@ export async function createStargate<Generated extends { routeSchema: any; rejec
   const baseUrl: Promise<string> = bootstrap();
 
   const stargate = {
+    ...eventManager,
     $types: {
       generated: void 0 as unknown as Generated,
     },
     options: stargateOptions,
-    async execute<Path extends keyof Generated["routeSchema"]["$types"]>(
+    async execute<Path extends keyof Generated["routeSchema"]>(
       path: Path,
       options?: Mixin<
         ExecuteOptions,
         {
-          params?: Generated["routeSchema"]["$types"][Path]["params"];
+          params?: Generated["routeSchema"][Path]["types"]["params"];
         }
       >,
     ): Promise<
-      Generated["routeSchema"]["$types"][Path]["🐣"] extends boolean
+      Generated["routeSchema"][Path]["types"]["🐣"] extends boolean
         ? // action
-          [Partial<Generated["rejectCode"]>, null, ExecuteResultsOption] | [null, Generated["routeSchema"]["$types"][Path]["result"], ExecuteResultsOption]
+          [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"]["$types"][Path]["result"]>], ExecuteResultsOption>]
+          [Partial<Generated["rejectCode"]>, null, ExecuteResultsOption] | [null, AsyncGenerator<[Partial<Generated["rejectCode"]>, null] | [null, GeneratorGeneric<Generated["routeSchema"][Path]["types"]["result"]>], ExecuteResultsOption>]
     > {
+      // biome-ignore lint/style/noParameterAssign: <explanation>
       if (!options) options = {};
       if (options.headers === undefined) options.headers = {};
 
@@ -79,17 +139,23 @@ export async function createStargate<Generated extends { routeSchema: any; rejec
         if (typeof baseUrl === "function") baseUrl = await baseUrl();
         if (baseUrl.endsWith("/")) baseUrl = baseUrl.slice(0, -1);
         url = baseUrl + (path as string);
-      } else url = (await baseUrl) + (path as string);
+      } else {
+        url = (await baseUrl) + (path as string);
+      }
 
       if (options.type !== "stream") {
         // action
-        if (options.headers["Accept"] === undefined) options.headers["Accept"] = "application/json";
+        if (options.headers.Accept === undefined) options.headers.Accept = "application/json";
         if (options.headers["Content-Type"] === undefined) options.headers["Content-Type"] = "application/json";
-
-        const body = TSON.stringify(options.params) ?? "";
-
         let result: { value: Record<any, any> };
+
         try {
+          await eventManager.emit("milkio:executeBefore", { path: path as string, options: options as any });
+
+          const body = TSON.stringify(options.params) ?? "";
+          await eventManager.emit("milkio:fetchBefore", { path: path as string, options: options as any, body });
+
+          // biome-ignore lint/suspicious/noAsyncPromiseExecutor: <explanation>
           const response = await new Promise<string>(async (resolve, reject) => {
             const timeout = options?.timeout ?? options?.timeout ?? 6000;
             const timer = setTimeout(() => {
@@ -106,22 +172,27 @@ export async function createStargate<Generated extends { routeSchema: any; rejec
           });
           result = { value: TSON.parse(response) };
         } catch (error: any) {
-          if (error?.[0]?.REQUEST_TIMEOUT) return error;
-          return [{ REQUEST_FAIL: error }, null, { executeId: "unknown" }];
+          if (error?.[0]?.REQUEST_TIMEOUT) {
+            await eventManager.emit("milkio:executeError", { handleError, path: path as string, options: options as any, error });
+            return error;
+          }
+          const errorPined = { REQUEST_FAIL: error };
+          await eventManager.emit("milkio:executeError", { handleError, path: path as string, options: options as any, error: errorPined });
+          return [errorPined, null, { executeId: "unknown" }];
         }
         if (result.value.success !== true) {
           const error: any = {};
-          error[result.value.code] = result.value.reject;
+          error[result.value.code] = result.value.reject ?? null;
+          await eventManager.emit("milkio:executeError", { handleError, path: path as string, options: options as any, error });
           return [error, null, { executeId: "unknown" }];
         }
 
         return [null, result.value.data, { executeId: result.value.executeId }] as any;
       } else {
         // stream
-        if (options.headers["Accept"] === undefined) options.headers["Accept"] = "text/event-stream";
+        if (options.headers.Accept === undefined) options.headers.Accept = "text/event-stream";
         if (options.headers["Content-Type"] === undefined) options.headers["Content-Type"] = "application/json";
 
-        const body = TSON.stringify(options.params) ?? "";
         const stacks: Map<
           number,
           {
@@ -131,10 +202,10 @@ export async function createStargate<Generated extends { routeSchema: any; rejec
             reject: (reason: any) => void;
           }
         > = new Map();
-        let stacksIndex: number = 0;
-        let iteratorIndex: number = 0;
-        let streamResult: any = undefined;
-        let streamResultFetched = withResolvers<undefined>();
+        let stacksIndex = 0;
+        let iteratorIndex = 0;
+        let streamResult: any;
+        const streamResultFetched = withResolvers<undefined>();
 
         const timeout = stargateOptions?.timeout ?? options?.timeout ?? 6000;
         const timer = setTimeout(() => {
@@ -151,7 +222,6 @@ export async function createStargate<Generated extends { routeSchema: any; rejec
               streamResultFetched.reject([{ REQUEST_FAIL: error }, null, { executeId: "unknown" }]);
               clearTimeout(timer);
             }
-            return;
           } else {
             const index = ++stacksIndex;
             if (stacks.has(index)) {
@@ -174,10 +244,15 @@ export async function createStargate<Generated extends { routeSchema: any; rejec
             iterator.return();
           });
           try {
+            await eventManager.emit("milkio:executeBefore", { path: path as string, options: options as any });
+
+            const body = TSON.stringify(options!.params) ?? "";
+            await eventManager.emit("milkio:fetchBefore", { path: path as string, options: options as any, body });
+
             const response = await $fetch(url, {
               method: "POST",
               headers: options!.headers,
-              body: body,
+              body,
               signal: curRequestController.signal,
             });
 
@@ -188,15 +263,13 @@ export async function createStargate<Generated extends { routeSchema: any; rejec
 
             await getBytes(response.body!, getLines(getMessages(onmessage)));
 
-            // for (const m of _afterExecuteMiddlewares) {
-            //   await m.middleware({ path: path as string, storage: options.storage as ClientStorage, result: { value: undefined } });
-            // }
-
             await iterator.return();
           } catch (err) {
             if (!curRequestController.signal.aborted) curRequestController.abort();
+            const error = { REQUEST_FAIL: err };
+            await eventManager.emit("milkio:executeError", { handleError, path: path as string, options: options as any, error });
             await iterator.throw(err);
-            streamResultFetched.reject([{ REQUEST_FAIL: err }, null, { executeId: "unknown" }]);
+            streamResultFetched.reject([error, null, { executeId: "unknown" }]);
           }
         }
 
@@ -258,7 +331,7 @@ export async function createStargate<Generated extends { routeSchema: any; rejec
         }
       }
     },
-    cookbook: {
+    __cookbook: {
       subscribe: async (baseUrl: string) => {
         const headers = {
           "Content-Type": "application/json",
@@ -276,8 +349,8 @@ export async function createStargate<Generated extends { routeSchema: any; rejec
             reject: (reason: any) => void;
           }
         > = new Map();
-        let stacksIndex: number = 0;
-        let iteratorIndex: number = 0;
+        let stacksIndex = 0;
+        let iteratorIndex = 0;
 
         const onmessage = (event: EventSourceMessage) => {
           const index = ++stacksIndex;
@@ -301,8 +374,8 @@ export async function createStargate<Generated extends { routeSchema: any; rejec
           try {
             const response = await $fetch(`${baseUrl}/$subscribe`, {
               method: "POST",
-              headers: headers,
-              body: body,
+              headers,
+              body,
               signal: curRequestController.signal,
             });
 
@@ -363,10 +436,11 @@ export async function createStargate<Generated extends { routeSchema: any; rejec
       },
     },
     async ping(options?: { timeout?: number }): Promise<Ping> {
+      // biome-ignore lint/suspicious/noAsyncPromiseExecutor: <explanation>
       return await new Promise<Ping>(async (resolve) => {
-        const url = (await baseUrl) + "/generate_204";
+        const url = `${await baseUrl}/generate_204`;
         const timeout = stargateOptions?.timeout ?? options?.timeout ?? 6000;
-        let startsTime = Date.now();
+        const startsTime = Date.now();
         const timer = setTimeout(() => {
           const endsTime = Date.now();
           resolve([{ connect: false, delay: endsTime - startsTime, error: { REQUEST_TIMEOUT: { timeout, message: `Execute timeout after ${timeout}ms.` } } }, null]);
@@ -377,13 +451,13 @@ export async function createStargate<Generated extends { routeSchema: any; rejec
           const endsTime = Date.now();
           clearTimeout(timer);
           if (response.status !== 204) {
-            resolve([{ connect: false, delay: endsTime - startsTime, error: { REQUEST_FAIL: { response, status: response.status, message: `Status code not 204` } } }, null]);
+            resolve([{ connect: false, delay: endsTime - startsTime, error: { REQUEST_FAIL: { response, status: response.status, message: "Status code not 204" } } }, null]);
           }
 
           resolve([null, { connect: true, delay: endsTime - startsTime, serverTimestamp: Number(response.headers.get("Content-Type")!.substring(17)) }]);
         } catch (error: any) {
           const endsTime = Date.now();
-          return [{ connect: false, delay: endsTime - startsTime, error: error }, null];
+          return [{ connect: false, delay: endsTime - startsTime, error }, null];
         }
       });
     },
@@ -392,12 +466,12 @@ export async function createStargate<Generated extends { routeSchema: any; rejec
   return stargate;
 }
 
-export type ExecuteStreamOptions = {
+export interface ExecuteStreamOptions {
   headers?: Record<string, string>;
   timeout?: number;
-};
+}
 
-export type ApiSchemaExtend = {
+export interface ApiSchemaExtend {
   apiValidator: {
     generatedAt: number;
     validate: Record<any, any>;
@@ -405,7 +479,7 @@ export type ApiSchemaExtend = {
   apiMethodsSchema: Record<any, any>;
   apiMethodsTypeSchema: Record<any, any>;
   apiTestsSchema: Record<any, any>;
-};
+}
 
 export type FailCodeExtend = Record<any, (...args: Array<any>) => any>;
 
@@ -413,27 +487,27 @@ export type BootstrapMiddleware = (data: { storage: ClientStorage }) => Promise<
 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 type MiddlewareOptions = {
+export interface MiddlewareOptions {
   bootstrap?: BootstrapMiddleware;
   beforeExecute?: BeforeExecuteMiddleware;
   afterExecute?: AfterExecuteMiddleware;
-};
+}
 
-export type ClientStorage = {
+export interface ClientStorage {
   getItem: (key: string) => Promise<string | null>;
   setItem: (key: string, value: string) => Promise<void>;
   removeItem: (key: string) => Promise<void>;
-};
+}
 
-export type ExecuteResultSuccess<Result> = {
+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 extends any, Prefix extends string = ""> = {
+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];
 
@@ -457,18 +531,12 @@ export interface EventSourceMessage {
 export async function getBytes(stream: ReadableStream<Uint8Array>, onChunk: (arr: Uint8Array) => void) {
   const reader = stream.getReader();
   let result: ReadableStreamReadResult<Uint8Array>;
+  // biome-ignore lint/suspicious/noAssignInExpressions: <explanation>
   while (!(result = await reader.read()).done) {
     onChunk(result.value);
   }
 }
 
-const enum ControlChars {
-  NewLine = 10,
-  CarriageReturn = 13,
-  Space = 32,
-  Colon = 58,
-}
-
 /**
  * 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.
@@ -496,7 +564,7 @@ export function getLines(onLine: (line: Uint8Array, fieldLength: number) => void
     let lineStart = 0; // index where the current line starts
     while (position < bufLength) {
       if (discardTrailingNewline) {
-        if (buffer[position] === ControlChars.NewLine) {
+        if (buffer[position] === 10) {
           lineStart = ++position; // skip to next char
         }
 
@@ -507,16 +575,16 @@ export function getLines(onLine: (line: Uint8Array, fieldLength: number) => void
       let lineEnd = -1; // index of the \r or \n char
       for (; position < bufLength && lineEnd === -1; ++position) {
         switch (buffer[position]) {
-          case ControlChars.Colon:
+          case 58:
             if (fieldLength === -1) {
               // first colon in line
               fieldLength = position - lineStart;
             }
             break;
-          // @ts-ignore:7029 \r case below should fallthrough to \n:
-          case ControlChars.CarriageReturn:
+          // biome-ignore lint/suspicious/noFallthroughSwitchClause: <explanation>
+          case 13:
             discardTrailingNewline = true;
-          case ControlChars.NewLine:
+          case 10:
             lineEnd = position;
             break;
         }
@@ -567,14 +635,14 @@ export function getMessages(onMessage?: (msg: EventSourceMessage) => void) {
       // line is of format "<field>:<value>" or "<field>: <value>"
       // https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation
       const field = decoder.decode(line.subarray(0, fieldLength));
-      const valueOffset = fieldLength + (line[fieldLength + 1] === ControlChars.Space ? 2 : 1);
+      const valueOffset = fieldLength + (line[fieldLength + 1] === 32 ? 2 : 1);
       const value = decoder.decode(line.subarray(valueOffset));
 
       switch (field) {
         case "data":
           // if this message already has data, append the new value to the old.
           // otherwise, just set to the new value:
-          message.data = message.data ? message.data + "\n" + value : value; // otherwise,
+          message.data = message.data ? `${message.data}\n${value}` : value; // otherwise,
           break;
       }
     }

package/package.json

@@ -1,15 +1,12 @@
 {
   "name": "@milkio/stargate",
-  "module": "index.ts",
-  "version": "1.0.0-alpha.1",
   "type": "module",
+  "version": "1.0.0-alpha.100",
+  "module": "index.ts",
   "dependencies": {
     "@southern-aurora/tson": "^2.0.2"
   },
   "devDependencies": {
     "@types/bun": "latest"
-  },
-  "peerDependencies": {
-    "typescript": "5.6.0"
   }
 }

package/tsconfig.json

@@ -1,27 +1,28 @@
 {
   "compilerOptions": {
+    "target": "ESNext",
+    "jsx": "react-jsx",
+    "erasableSyntaxOnly":true,
     // Enable latest features
     "lib": ["ESNext", "DOM"],
-    "target": "ESNext",
-    "module": "ESNext",
     "moduleDetection": "force",
-    "jsx": "react-jsx",
-    "allowJs": true,
+    "module": "ESNext",
 
     // Bundler mode
     "moduleResolution": "bundler",
     "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-    "noEmit": true,
+    "allowJs": true,
 
     // Best practices
     "strict": true,
-    "skipLibCheck": true,
     "noFallthroughCasesInSwitch": true,
 
+    "noPropertyAccessFromIndexSignature": false,
     // Some stricter flags (disabled by default)
     "noUnusedLocals": false,
     "noUnusedParameters": false,
-    "noPropertyAccessFromIndexSignature": false
+    "noEmit": true,
+    "verbatimModuleSyntax": true,
+    "skipLibCheck": true
   }
 }