@milkio/stargate 1.0.0-alpha.3 → 1.0.0-alpha.34

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,24 +109,25 @@ 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>]
     > {
       if (!options) options = {};
       if (options.headers === undefined) options.headers = {};
@@ -85,11 +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";
-
-        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: body });
+
           const response = await new Promise<string>(async (resolve, reject) => {
             const timeout = options?.timeout ?? options?.timeout ?? 6000;
             const timer = setTimeout(() => {
@@ -106,12 +168,18 @@ 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 ?? null;
+          await eventManager.emit("milkio:executeError", { handleError, path: path as string, options: options as any, error: error });
           return [error, null, { executeId: "unknown" }];
         }
 
@@ -121,7 +189,6 @@ export async function createStargate<Generated extends { routeSchema: any; rejec
         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,
           {
@@ -174,6 +241,11 @@ 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: body });
+
             const response = await $fetch(url, {
               method: "POST",
               headers: options!.headers,
@@ -188,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" }]);
           }
         }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@milkio/stargate",
   "module": "index.ts",
-  "version": "1.0.0-alpha.3",
+  "version": "1.0.0-alpha.34",
   "type": "module",
   "dependencies": {
     "@southern-aurora/tson": "^2.0.2"