@milkio/stargate 1.0.0-alpha.0 → 1.0.0-alpha.10

package/README.md

@@ -1,4 +1,4 @@
-# milkio-world
+# milkio-starter
 
 To install dependencies:
 

package/index.ts

@@ -3,15 +3,8 @@ import { TSON } from "@southern-aurora/tson";
 export type MilkioStargateOptions = {
   baseUrl: string | (() => string) | (() => Promise<string>);
   timeout?: number;
-  // middlewares?: () => Array<MiddlewareOptions & { isMiddleware: true }>;
   fetch?: typeof fetch;
   abort?: typeof AbortController;
-  // storage?: {
-  //   getItem: (key: string) => string | null | Promise<string | null>;
-  //   setItem: (key: string, value: string) => void | Promise<void>;
-  //   removeItem: (key: string) => void | Promise<void>;
-  // };
-  // memoryStorage?: boolean;
 };
 
 export type Mixin<T, U> = U & Omit<T, keyof U>;
@@ -47,50 +40,76 @@ 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();
     if (baseUrl.endsWith("/")) baseUrl = baseUrl.slice(0, -1);
 
-    // if (options.middlewares) {
-    //   const middlewares = [...builtinMiddlewares, ...options.middlewares()];
-
-    //   const push = (index: number, middlewares: Array<any>, middleware: any) => {
-    //     const id = ++guid;
-    //     middlewares.push({ id, index, middleware });
-    //     return () =>
-    //       middlewares.splice(
-    //         middlewares.findIndex((v) => v.id === id),
-    //         1,
-    //       );
-    //   };
-
-    //   const _middlewareHandler = (index: number, options: MiddlewareOptions) => {
-    //     if (options.bootstrap) push(index, _bootstrapMiddlewares, options.bootstrap);
-    //     if (options.beforeExecute) push(index, _beforeExecuteMiddlewares, options.beforeExecute);
-    //     if (options.afterExecute) push(index, _afterExecuteMiddlewares, options.afterExecute);
-    //   };
-
-    //   for (let index = 0; index < middlewares.length; index++) {
-    //     const middlewareOptions = middlewares[index];
-    //     _middlewareHandler(index, middlewareOptions);
-    //   }
-
-    //   _bootstrapMiddlewares.sort((a, b) => a.index - b.index);
-    //   _beforeExecuteMiddlewares.sort((a, b) => a.index - b.index);
-    //   _afterExecuteMiddlewares.sort((a, b) => b.index - a.index);
-
-    //   for (const m of _bootstrapMiddlewares) {
-    //     await m.middleware({ storage: options.storage as ClientStorage });
-    //   }
-    // }
-
     return baseUrl;
   };
 
   const baseUrl: Promise<string> = bootstrap();
 
   const stargate = {
+    ...eventManager,
     $types: {
       generated: void 0 as unknown as Generated,
     },
@@ -125,15 +144,14 @@ export async function createStargate<Generated extends { routeSchema: any; rejec
         // action
         if (options.headers["Accept"] === undefined) options.headers["Accept"] = "application/json";
         if (options.headers["Content-Type"] === undefined) options.headers["Content-Type"] = "application/json";
+        let result: { value: Record<any, any> };
 
-        // for (const m of _beforeExecuteMiddlewares) {
-        //   await m.middleware({ path: path as string, params: options.params, headers: options.headers, storage: options.storage as ClientStorage });
-        // }
+        try {
+          await eventManager.emit("milkio:executeBefore", { path: path as string, options: options as any });
 
-        const body = TSON.stringify(options.params) ?? "";
+          const body = TSON.stringify(options.params) ?? "";
+          await eventManager.emit("milkio:fetchBefore", { path: path as string, options: options as any, body: body });
 
-        let result: { value: Record<any, any> };
-        try {
           const response = await new Promise<string>(async (resolve, reject) => {
             const timeout = options?.timeout ?? options?.timeout ?? 6000;
             const timer = setTimeout(() => {
@@ -150,29 +168,31 @@ 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: error });
+            return error;
+          }
+          let 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: error });
           return [error, null, { executeId: "unknown" }];
         }
 
-        // for (const m of _afterExecuteMiddlewares) {
-        //   await m.middleware({ path: path as string, storage: options.storage as ClientStorage, result });
-        // }
-
         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["Content-Type"] === undefined) options.headers["Content-Type"] = "application/json";
 
-        const body = TSON.stringify(options.params) ?? "";
         const stacks: Map<
           number,
           {
+            done: boolean;
             promise: Promise<IteratorResult<any>>;
             resolve: (value: IteratorResult<any>) => void;
             reject: (reason: any) => void;
@@ -201,11 +221,14 @@ export async function createStargate<Generated extends { routeSchema: any; rejec
             return;
           } else {
             const index = ++stacksIndex;
-            if (stacks.has(index)) stacks.get(index)!.resolve({ done: false, value: TSON.parse(event.data) });
-            else {
+            if (stacks.has(index)) {
+              const stack = stacks.get(index);
+              stack!.done = true;
+              stack!.resolve({ done: false, value: TSON.parse(event.data) });
+            } else {
               const stack = withResolvers<IteratorResult<any>>();
               stack.resolve({ done: false, value: TSON.parse(event.data) });
-              stacks.set(index, stack);
+              stacks.set(index, { ...stack, done: false });
             }
           }
         };
@@ -214,11 +237,14 @@ export async function createStargate<Generated extends { routeSchema: any; rejec
 
         async function create() {
           curRequestController = new $abort();
-          curRequestController.signal.addEventListener("abort", () => iterator.return());
+          curRequestController.signal.addEventListener("abort", () => {
+            iterator.return();
+          });
           try {
-            // for (const m of _beforeExecuteMiddlewares) {
-            //   await m.middleware({ path: path as string, params: eventOptions.params, headers: eventOptions.headers!, storage: options.storage as ClientStorage });
-            // }
+            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: body });
 
             const response = await $fetch(url, {
               method: "POST",
@@ -234,15 +260,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: error });
             await iterator.throw(err);
-            streamResultFetched.reject([{ REQUEST_FAIL: err }, null, { executeId: "unknown" }]);
+            streamResultFetched.reject([error, null, { executeId: "unknown" }]);
           }
         }
 
@@ -253,13 +277,17 @@ export async function createStargate<Generated extends { routeSchema: any; rejec
             next(): Promise<IteratorResult<unknown>> {
               const index = ++iteratorIndex;
               if (stacks.has(index - 2)) stacks.delete(index - 2);
-              if (stacks.has(index)) {
-                return stacks.get(index)!.promise;
-              } else {
+              if (!stacks.has(index) && !curRequestController.signal.aborted) {
+                const stack = withResolvers<IteratorResult<any>>();
+                stacks.set(index, { ...stack, done: false });
+                return stack.promise;
+              }
+              if (!stacks.has(index) && curRequestController.signal.aborted) {
                 const stack = withResolvers<IteratorResult<any>>();
-                stacks.set(index, stack);
+                stack.resolve({ done: true, value: undefined });
                 return stack.promise;
               }
+              return stacks.get(index)!.promise;
             },
             async return(): Promise<IteratorResult<void>> {
               if (!curRequestController.signal.aborted) curRequestController.abort();
@@ -277,6 +305,11 @@ export async function createStargate<Generated extends { routeSchema: any; rejec
                   data: err,
                 },
               };
+              for (const [_index, stack] of stacks) {
+                if (stack.done) continue;
+                stack.done = true;
+                stack.resolve({ done: true, value: undefined });
+              }
               if (!curRequestController.signal.aborted) curRequestController.abort();
               for (const [_, iterator] of stacks) iterator.resolve({ done: true, value: undefined });
               return { done: true, value: undefined };
@@ -307,6 +340,7 @@ export async function createStargate<Generated extends { routeSchema: any; rejec
         const stacks: Map<
           number,
           {
+            done: boolean;
             promise: Promise<IteratorResult<any>>;
             resolve: (value: IteratorResult<any>) => void;
             reject: (reason: any) => void;
@@ -314,15 +348,16 @@ export async function createStargate<Generated extends { routeSchema: any; rejec
         > = new Map();
         let stacksIndex: number = 0;
         let iteratorIndex: number = 0;
-        let streamResult: any = undefined;
 
         const onmessage = (event: EventSourceMessage) => {
           const index = ++stacksIndex;
-          if (stacks.has(index)) stacks.get(index)!.resolve({ done: false, value: TSON.parse(event.data) });
-          else {
+          if (stacks.has(index)) {
+            const stack = stacks.get(index);
+            stack!.resolve({ done: false, value: TSON.parse(event.data) });
+          } else {
             const stack = withResolvers<IteratorResult<any>>();
             stack.resolve({ done: false, value: TSON.parse(event.data) });
-            stacks.set(index, stack);
+            stacks.set(index, { ...stack, done: false });
           }
         };
 
@@ -330,7 +365,9 @@ export async function createStargate<Generated extends { routeSchema: any; rejec
 
         async function create() {
           curRequestController = new $abort();
-          curRequestController.signal.addEventListener("abort", () => iterator.return());
+          curRequestController.signal.addEventListener("abort", () => {
+            iterator.return();
+          });
           try {
             const response = await $fetch(`${baseUrl}/$subscribe`, {
               method: "POST",
@@ -360,13 +397,17 @@ export async function createStargate<Generated extends { routeSchema: any; rejec
             next(): Promise<IteratorResult<unknown>> {
               const index = ++iteratorIndex;
               if (stacks.has(index - 2)) stacks.delete(index - 2);
-              if (stacks.has(index)) {
-                return stacks.get(index)!.promise;
-              } else {
+              if (!stacks.has(index) && !curRequestController.signal.aborted) {
+                const stack = withResolvers<IteratorResult<any>>();
+                stacks.set(index, { ...stack, done: false });
+                return stack.promise;
+              }
+              if (!stacks.has(index) && curRequestController.signal.aborted) {
                 const stack = withResolvers<IteratorResult<any>>();
-                stacks.set(index, stack);
+                stack.resolve({ done: true, value: undefined });
                 return stack.promise;
               }
+              return stacks.get(index)!.promise;
             },
             async return(): Promise<IteratorResult<void>> {
               if (!curRequestController.signal.aborted) curRequestController.abort();
@@ -374,15 +415,6 @@ export async function createStargate<Generated extends { routeSchema: any; rejec
               return { done: true, value: undefined };
             },
             async throw(err: any): Promise<IteratorResult<void>> {
-              streamResult = {
-                success: false,
-                fail: {
-                  code: "NETWORK_ERROR",
-                  message: "Network Error",
-                  fromClient: true,
-                  data: err,
-                },
-              };
               if (!curRequestController.signal.aborted) curRequestController.abort();
               for (const [_, iterator] of stacks) iterator.resolve({ done: true, value: undefined });
               return { done: true, value: undefined };
@@ -430,15 +462,6 @@ export async function createStargate<Generated extends { routeSchema: any; rejec
   return stargate;
 }
 
-// export function defineMiddleware(options: MiddlewareOptions): () => MiddlewareOptions & { isMiddleware: true } {
-//   return () => ({
-//     ...options,
-//     isMiddleware: true,
-//   });
-// }
-
-let guid = 0;
-
 export type ExecuteStreamOptions = {
   headers?: Record<string, string>;
   timeout?: number;

package/package.json

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