@milkio/stargate-worker 1.0.1 → 1.0.3

package/index.d.ts

@@ -8,11 +8,26 @@ export type MilkioStargateOptions = {
             data: any;
         }) => void) => void;
     };
+    cacheStorage?: CacheStorage;
+    cacheEncryption?: boolean;
 };
 export type Mixin<T, U> = U & Omit<T, keyof U>;
-export type ExecuteOptions = {
+export type CacheStrategy = 'off' | 'fallback' | 'throttle';
+export type RetryStrategy = boolean | number;
+export interface CacheStorage {
+    get: (key: string) => Promise<{
+        data: any;
+        timestamp: number;
+    } | null>;
+    set: (key: string, data: any) => Promise<void>;
+}
+export type ExecuteOptions<T extends any = any> = {
     params?: Record<any, any>;
     headers?: Record<string, string>;
+    cacheStrategy?: CacheStrategy;
+    cacheThrottleMs?: number;
+    onCacheHit?: (result: T) => void | Promise<void>;
+    retryStrategy?: RetryStrategy;
 };
 export type ExecuteResultsOption = {
     executeId: string;
@@ -23,7 +38,7 @@ export declare function createStargateWorker<Generated extends {
     rejectCode: any;
 }>(stargateOptions: MilkioStargateOptions): Promise<{
     close(): void;
-    execute<Path extends keyof Generated["routeSchema"]>(path: Path, options: Mixin<ExecuteOptions, {
+    execute<Path extends keyof Generated["routeSchema"]>(path: Path, options: Mixin<ExecuteOptions<Generated["routeSchema"][Path]["types"]["result"]>, {
         params?: Generated["routeSchema"][Path]["types"]["params"];
     }>): Promise<Generated["routeSchema"][Path]["types"]["\uD83E\uDD5B"] extends boolean ? // action
     [Partial<Generated["rejectCode"]>, null, ExecuteResultsOption] | [null, Generated["routeSchema"][Path]["types"]["result"], ExecuteResultsOption] : // stream
@@ -43,3 +58,8 @@ export type MilkioFlow<T, TReturn = any, TNext = any> = {
     throw(error: any, disablePostCloseMessage?: true): Promise<IteratorResult<T, TReturn>>;
 };
 export declare function createFlow<T>(stargateOptions: MilkioStargateOptions, executeId: string): MilkioFlow<T>;
+export declare function reviveJSONParse<T>(json: T): T;
+export declare function createDefaultCacheStorage(options?: {
+    encryption?: boolean;
+    encryptionKey?: string;
+}): Promise<CacheStorage>;

package/index.js

@@ -110,32 +110,85 @@ async function createStargateWorker(stargateOptions) {
     async execute(path, options) {
       return new Promise(async (resolve) => {
         await connect;
-        const executeId = __createId();
-        executeIds.add(executeId);
         if (!path.endsWith("~")) {
-          const handler = (event) => {
-            if (typeof event.data !== "object")
-              return;
-            if (event.data.executeId !== executeId)
-              return;
-            executeIds.delete(executeId);
-            stargateOptions.port.removeEventListener("message", handler);
-            if (!event.data.success) {
-              const error = {};
-              error[event.data.error.code] = event.data.error.reject;
-              resolve([error, null, { executeId }]);
+          const cacheStrategy = options?.cacheStrategy ?? "off";
+          let retryCount = 0;
+          if (options?.retryStrategy === true || options?.retryStrategy === 2) {
+            retryCount = 2;
+          } else if (typeof options?.retryStrategy === "number" && options?.retryStrategy > 0) {
+            retryCount = options?.retryStrategy;
+          }
+          const cacheThrottleMs = options?.cacheThrottleMs ?? 0;
+          const cacheKey = generateCacheKey(path, options?.params);
+          let cacheStorage = stargateOptions.cacheStorage;
+          if (cacheStrategy !== "off" && !cacheStorage) {
+            cacheStorage = await createDefaultCacheStorage({ encryption: stargateOptions.cacheEncryption });
+          }
+          if (cacheStrategy !== "off" && cacheStorage && options?.onCacheHit) {
+            const cached = await cacheStorage.get(cacheKey);
+            if (cached) {
+              try {
+                await options.onCacheHit(cached.data);
+              } catch {}
             }
-            if (event.data.success)
-              resolve([null, event.data.data, { executeId }]);
+          }
+          if (cacheStrategy === "throttle" && cacheStorage) {
+            const cached = await cacheStorage.get(cacheKey);
+            if (cached && Date.now() - cached.timestamp < cacheThrottleMs) {
+              return resolve([null, cached.data, { executeId: "cached" }]);
+            }
+          }
+          const executeRequest = () => {
+            return new Promise((reqResolve) => {
+              const reqExecuteId = __createId();
+              executeIds.add(reqExecuteId);
+              const handler = (event) => {
+                if (typeof event.data !== "object")
+                  return;
+                if (event.data.executeId !== reqExecuteId)
+                  return;
+                executeIds.delete(reqExecuteId);
+                stargateOptions.port.removeEventListener("message", handler);
+                if (!event.data.success) {
+                  const error2 = {};
+                  error2[event.data.error.code] = event.data.error.reject;
+                  reqResolve([error2, null, { executeId: reqExecuteId }]);
+                } else {
+                  reqResolve([null, event.data.data, { executeId: reqExecuteId }]);
+                }
+              };
+              stargateOptions.port.addEventListener("message", handler);
+              stargateOptions.port.postMessage({
+                executeId: reqExecuteId,
+                path,
+                params: options?.params,
+                headers: options?.headers
+              });
+            });
           };
-          stargateOptions.port.addEventListener("message", handler);
-          stargateOptions.port.postMessage({
-            executeId,
-            path,
-            params: options?.params,
-            headers: options?.headers
-          });
+          let [error, result, resultOption] = await executeRequest();
+          for (let retryIndex = 0;retryIndex < retryCount && error; retryIndex++) {
+            if (retryIndex > 0) {
+              await new Promise((r) => setTimeout(r, 500));
+            }
+            [error, result, resultOption] = await executeRequest();
+          }
+          if (error) {
+            if (cacheStrategy !== "off" && cacheStorage) {
+              const cached = await cacheStorage.get(cacheKey);
+              if (cached) {
+                return resolve([null, cached.data, { executeId: "cached" }]);
+              }
+            }
+            return resolve([error, null, resultOption]);
+          }
+          if (cacheStrategy !== "off" && cacheStorage) {
+            await cacheStorage.set(cacheKey, result);
+          }
+          resolve([null, result, resultOption]);
         } else {
+          const executeId = __createId();
+          executeIds.add(executeId);
           let flow;
           const handler = (event) => {
             if (typeof event.data !== "object")
@@ -250,10 +303,144 @@ function withResolvers() {
   });
   return { promise, resolve, reject };
 }
+var isoDatePattern = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?)(Z|[+-]\d{2}:?\d{2})?$/;
+function reviveJSONParse(json) {
+  if (json !== null && typeof json === "object") {
+    if (json instanceof Date || typeof json.getTime === "function" && typeof json.toISOString === "function") {
+      return json;
+    }
+    if (Array.isArray(json)) {
+      return json.map((item) => reviveJSONParse(item));
+    }
+    return Object.entries(json).reduce((acc, [key, value]) => {
+      acc[key] = reviveJSONParse(value);
+      return acc;
+    }, {});
+  }
+  if (typeof json === "string") {
+    const match = json.match(isoDatePattern);
+    if (match) {
+      const normalizedDateString = match[2] ? `${match[1]}${match[2].replace(":", "")}` : `${match[1]}Z`;
+      return new Date(normalizedDateString);
+    }
+  }
+  return json;
+}
+var DB_NAME = "StargateWorker";
+var STORE_NAME = "caches";
+var dbInstance = null;
+async function openDB() {
+  if (dbInstance)
+    return dbInstance;
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, 1);
+    request.onerror = () => reject(request.error);
+    request.onsuccess = () => {
+      dbInstance = request.result;
+      resolve(dbInstance);
+    };
+    request.onupgradeneeded = (event) => {
+      const db = event.target.result;
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        db.createObjectStore(STORE_NAME);
+      }
+    };
+  });
+}
+async function createDefaultCacheStorage(options) {
+  await openDB();
+  let encryptionKey = null;
+  const counter = new Uint8Array(16);
+  if (options?.encryption) {
+    const keyString = options.encryptionKey ?? DB_NAME;
+    new TextEncoder().encode(keyString).forEach((byte, i) => {
+      if (i < 16)
+        counter[i] = byte;
+    });
+    const encoder = new TextEncoder;
+    const keyData = encoder.encode(keyString);
+    const importedKey = await crypto.subtle.importKey("raw", keyData, { name: "PBKDF2" }, false, ["deriveKey"]);
+    encryptionKey = await crypto.subtle.deriveKey({
+      name: "PBKDF2",
+      salt: encoder.encode("milkio-stargate-worker-cache"),
+      iterations: 1e5,
+      hash: "SHA-256"
+    }, importedKey, { name: "AES-CTR", length: 256 }, false, ["encrypt", "decrypt"]);
+  }
+  const encryptData = async (data) => {
+    if (!encryptionKey)
+      return data;
+    const jsonString = JSON.stringify(data);
+    const encoder = new TextEncoder;
+    const dataBytes = encoder.encode(jsonString);
+    const encryptedArrayBuffer = await crypto.subtle.encrypt({
+      name: "AES-CTR",
+      counter,
+      length: 64
+    }, encryptionKey, dataBytes);
+    return new Uint8Array(encryptedArrayBuffer);
+  };
+  const decryptData = async (encryptedData) => {
+    if (!encryptionKey || !encryptedData)
+      return encryptedData;
+    const arrayBuffer = encryptedData instanceof Uint8Array ? encryptedData.buffer : encryptedData;
+    const decryptedBytes = await crypto.subtle.decrypt({
+      name: "AES-CTR",
+      counter,
+      length: 64
+    }, encryptionKey, arrayBuffer);
+    const decoder = new TextDecoder;
+    const jsonString = decoder.decode(decryptedBytes);
+    return reviveJSONParse(JSON.parse(jsonString));
+  };
+  return {
+    async get(key) {
+      const db = await openDB();
+      return new Promise((resolve, reject) => {
+        const transaction = db.transaction(STORE_NAME, "readonly");
+        const store = transaction.objectStore(STORE_NAME);
+        const request = store.get(key);
+        request.onerror = () => reject(request.error);
+        request.onsuccess = async () => {
+          const result = request.result;
+          if (!result) {
+            resolve(null);
+            return;
+          }
+          if (options?.encryption && (result.data instanceof ArrayBuffer || result.data instanceof Uint8Array)) {
+            const decryptedData = await decryptData(result.data);
+            resolve({ data: decryptedData, timestamp: result.timestamp });
+            return;
+          }
+          resolve(result ?? null);
+        };
+      });
+    },
+    async set(key, data) {
+      const db = await openDB();
+      let dataToStore = data;
+      if (options?.encryption) {
+        dataToStore = await encryptData(data);
+      }
+      return new Promise((resolve, reject) => {
+        const transaction = db.transaction(STORE_NAME, "readwrite");
+        const store = transaction.objectStore(STORE_NAME);
+        const request = store.put({ data: dataToStore, timestamp: Date.now() }, key);
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => resolve();
+      });
+    }
+  };
+}
+function generateCacheKey(path, params) {
+  return `${path}:${JSON.stringify(params ?? {})}`;
+}
 export {
+  reviveJSONParse,
   createStargateWorker,
-  createFlow
+  createFlow,
+  createDefaultCacheStorage
 };
 
-//# debugId=1BC79B1210E27E9364756E2164756E21
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../utils/create-id.ts", "../index.ts"],
  "sourcesContent": [
    "type IdGeneratorOptions = {\n  length?: number;\n  timestamp: boolean;\n  sequential: boolean;\n};\n\nfunction defineIdGenerator(options: IdGeneratorOptions) {\n  if (!options.length) options.length = 24;\n  if (options.length < 1) throw new Error(\"Invalid length\");\n  if (options.length > 61) throw new Error(\"Invalid length\");\n  if (options.timestamp && options.length < 9) throw new Error(\"Invalid length\");\n  let lastTime = 0;\n  let lastDecimal = 0n;\n  return {\n    createId() {\n      let randLength = options.length!;\n      const now = Date.now();\n      let id = \"\";\n      if (options.timestamp) {\n        randLength -= 8;\n        id = `${id}${__bigIntToString(BigInt(now)).padStart(8, \"0\")}`;\n      }\n      if (options.sequential && lastTime === now) {\n        id = `${id}${__bigIntToString(++lastDecimal).padStart(1, \"0\")}`;\n      } else {\n        lastTime = now;\n        const min = 0n;\n        const max = __getMaxValue(BigInt(randLength));\n        lastDecimal = __secureRandomBigInt(min, max);\n        id = `${id}${__bigIntToString(lastDecimal).padStart(randLength, \"0\")}`;\n      }\n      return id;\n    },\n    getIdTimestamp(id: string) {\n      return options.timestamp ? Number(__stringToBigInt(id.slice(0, 8).replaceAll(\"0\", \"\"))) : 0;\n    },\n  };\n}\n\nconst ENCODING = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\";\n\nfunction __secureRandomBigInt(min: bigint, max: bigint): bigint {\n  if (min >= max) throw new Error(\"Invalid range\");\n\n  const range = max - min + 1n;\n  const byteCount = Math.ceil(Number(BigInt(range.toString(2).length)) / 8);\n  const entropyBytes = new Uint8Array(byteCount);\n\n  let randomValue: bigint;\n  do {\n    crypto.getRandomValues(entropyBytes);\n    randomValue =\n      BigInt(\n        `0x${Array.from(entropyBytes)\n          .map((b) => b.toString(16).padStart(2, \"0\"))\n          .join(\"\")}`,\n      ) % range;\n  } while (randomValue < 0n);\n\n  return min + randomValue;\n}\n\nfunction __bigIntToString(value: bigint): string {\n  const base = BigInt(ENCODING.length);\n  let result = \"\";\n  let current = value;\n\n  if (current === 0n) return ENCODING[0];\n\n  while (current > 0n) {\n    const remainder = current % base;\n    result = ENCODING[Number(remainder)] + result;\n    current = current / base;\n  }\n  return result;\n}\n\nfunction __stringToBigInt(str: string): bigint {\n  const charMap: { [key: string]: number } = {};\n  for (let i = 0; i < ENCODING.length; i++) {\n    charMap[ENCODING[i]] = i;\n  }\n\n  const base = BigInt(ENCODING.length);\n  let result = 0n;\n\n  for (let i = 0; i < str.length; i++) {\n    const char = str[i];\n    if (!(char in charMap)) {\n      throw new Error(`Invalid character '${char}' in input string`);\n    }\n    const value = BigInt(charMap[char]);\n    result = result * base + value;\n  }\n\n  return result;\n}\n\nfunction __getMaxValue(n: bigint): bigint {\n  return BigInt(ENCODING.length) ** n - 1n;\n}\n\nconst idGenerator = defineIdGenerator({ length: 24, timestamp: false, sequential: false });\n\nexport const __createId = idGenerator.createId;\n",
    "import { __createId } from \"./utils/create-id.ts\";\n\nexport type MilkioStargateOptions = {\n    port: {\n        postMessage: (data: any) => void;\n        addEventListener: (event: \"message\", callback: (event: { data: any }) => void) => void;\n        removeEventListener: (event: \"message\", callback: (event: { data: any }) => void) => void;\n    };\n};\n\nexport type Mixin<T, U> = U & Omit<T, keyof U>;\n\nexport type ExecuteOptions = {\n    params?: Record<any, any>;\n    headers?: Record<string, string>;\n};\n\nexport type ExecuteResultsOption = { executeId: string };\n\nexport type GeneratorGeneric<T> = T extends AsyncGenerator<infer I> ? I : never;\n\nexport async function createStargateWorker<Generated extends { routeSchema: any; rejectCode: any }>(stargateOptions: MilkioStargateOptions) {\n    const executeIds = new Set<string>();\n    const connect = new Promise((resolve) => {\n        const handler = (event: { data: any }) => {\n            if (event.data !== \"PONG\") return;\n            clearInterval(timer);\n            stargateOptions.port.removeEventListener(\"message\", handler);\n            resolve(true);\n        };\n        stargateOptions.port.addEventListener(\"message\", handler);\n        stargateOptions.port.postMessage(\"PING\");\n        const timer = setInterval(() => stargateOptions.port.postMessage(\"PING\"), 42);\n    });\n    const stargate = {\n        close() {\n            for (const executeId of executeIds) {\n                stargateOptions.port.postMessage(`CLOSE_STREAM:${executeId}`);\n            }\n            stargateOptions.port.postMessage(\"CLOSED\");\n        },\n        async execute<Path extends keyof Generated[\"routeSchema\"]>(\n            path: Path,\n            options: Mixin<\n                ExecuteOptions,\n                {\n                    params?: Generated[\"routeSchema\"][Path][\"types\"][\"params\"];\n                }\n            >,\n        ): Promise<\n            Generated[\"routeSchema\"][Path][\"types\"][\"🥛\"] extends boolean\n            ? // action\n            [Partial<Generated[\"rejectCode\"]>, null, ExecuteResultsOption] | [null, Generated[\"routeSchema\"][Path][\"types\"][\"result\"], ExecuteResultsOption]\n            : // stream\n            [Partial<Generated[\"rejectCode\"]>, null, ExecuteResultsOption] | [null, AsyncGenerator<[Partial<Generated[\"rejectCode\"]>, null] | [null, GeneratorGeneric<Generated[\"routeSchema\"][Path][\"types\"][\"result\"]>], undefined>, ExecuteResultsOption]\n        > {\n            // oxlint-disable-next-line no-async-promise-executor\n            return new Promise(async (resolve) => {\n                await connect;\n                const executeId = __createId();\n                executeIds.add(executeId);\n                if (!(path as string).endsWith(\"~\")) {\n                    const handler = (event: { data: any }) => {\n                        if (typeof event.data !== \"object\") return;\n                        if (event.data.executeId !== executeId) return;\n                        executeIds.delete(executeId);\n                        stargateOptions.port.removeEventListener(\"message\", handler);\n                        if (!event.data.success) {\n                            const error: any = {};\n                            error[event.data.error.code] = event.data.error.reject;\n                            resolve([error, null, { executeId }]);\n                        }\n                        if (event.data.success) resolve([null, event.data.data, { executeId }] as any);\n                    };\n                    stargateOptions.port.addEventListener(\"message\", handler);\n                    stargateOptions.port.postMessage({\n                        executeId,\n                        path,\n                        params: options?.params,\n                        headers: options?.headers,\n                    });\n                } else {\n                    let flow: ReturnType<typeof createFlow> | undefined;\n                    const handler = (event: { data: any }) => {\n                        if (typeof event.data !== \"object\") return;\n                        if (event.data.executeId !== executeId) return;\n                        if (!flow) {\n                            flow = createFlow(stargateOptions, executeId);\n                            if (!event.data.success) {\n                                const error: any = {};\n                                error[event.data.error.code] = event.data.error.reject;\n                                resolve([error, null, { executeId }]);\n                            }\n                            if (event.data.success) resolve([null, flow, { executeId }] as any);\n                        } else {\n                            if (event.data.done) {\n                                stargateOptions.port.removeEventListener(\"message\", handler);\n                                executeIds.delete(executeId);\n                                if (event.data.success) flow.return(undefined, true);\n                                else flow.throw(event.data.data?.at(0), true);\n                            } else if (!event.data.success) {\n                                stargateOptions.port.removeEventListener(\"message\", handler);\n                                executeIds.delete(executeId);\n                                flow.throw(event.data.data, true);\n                            } else if (event.data.success) flow.emit(event.data.data);\n                        }\n                    };\n                    stargateOptions.port.addEventListener(\"message\", handler);\n                    stargateOptions.port.postMessage({\n                        executeId,\n                        path,\n                        params: options?.params,\n                        headers: options?.headers,\n                    });\n                }\n            });\n        },\n        $types: undefined as unknown as {\n            generated: Generated,\n            error: Generated[\"rejectCode\"];\n            params: {\n                [Path in keyof Generated[\"routeSchema\"]]: Generated[\"routeSchema\"][Path][\"types\"][\"params\"]\n            },\n            results: {\n                [Path in keyof Generated[\"routeSchema\"]]: Generated[\"routeSchema\"][Path][\"types\"][\"🥛\"] extends boolean\n                ? // action\n                Generated[\"routeSchema\"][Path][\"types\"][\"result\"]\n                : // stream\n                AsyncGenerator<[Partial<Generated[\"rejectCode\"]>, null] | [null, GeneratorGeneric<Generated[\"routeSchema\"][Path][\"types\"][\"result\"]>], undefined>\n            },\n        },\n    };\n\n    return stargate;\n}\n\nexport type MilkioFlow<T, TReturn = any, TNext = any> = {\n    emit: (flow: T) => void;\n    [Symbol.asyncIterator]: () => MilkioFlow<T>;\n    next(...[value]: [] | [TNext]): Promise<IteratorResult<T, TReturn>>;\n    return(data: undefined, disablePostCloseMessage?: true): Promise<IteratorResult<T, TReturn>>;\n    throw(error: any, disablePostCloseMessage?: true): Promise<IteratorResult<T, TReturn>>;\n};\n\nexport function createFlow<T>(stargateOptions: MilkioStargateOptions, executeId: string): MilkioFlow<T> {\n    let status: \"pending\" | \"resolved\" | \"rejected\" = \"pending\";\n    const flows: Array<{\n        blank: boolean;\n        promise: Promise<T>;\n        resolve: (value?: T | PromiseLike<T>) => void;\n        reject: (reason?: any) => void;\n    }> = [];\n\n    const iterator = {\n        emit: (flow: T) => {\n            if (flows.at(-1)?.blank === true) {\n                const item = flows.at(-1)!;\n                item.blank = false;\n                item.resolve(flow);\n                return;\n            } else {\n                const resolvers = withResolvers<T>();\n                resolvers.resolve(flow);\n                flows.push({ ...resolvers, blank: false } as any);\n            }\n        },\n        ...({\n            async next(): Promise<IteratorResult<T>> {\n                if (status !== \"pending\") return { done: true, value: null };\n                if (flows.length === 0) {\n                    const resolvers = withResolvers<T>();\n                    flows.push({ ...resolvers, blank: true } as any);\n                }\n                const flow = flows.at(0)!;\n                const result = await flow.promise;\n                flows.shift();\n                return { done: status !== \"pending\", value: result };\n            },\n            async return(_: undefined, disablePostCloseMessage?: true): Promise<IteratorResult<void>> {\n                status = \"resolved\";\n                if (!disablePostCloseMessage) stargateOptions.port.postMessage(`CLOSE_STREAM:${executeId}`);\n                for (const flow of flows) {\n                    flow.blank = false;\n                    flow.resolve(undefined);\n                }\n                return { done: true, value: null };\n            },\n            async throw(err: any, disablePostCloseMessage?: true): Promise<IteratorResult<void>> {\n                status = \"rejected\";\n                if (!disablePostCloseMessage) stargateOptions.port.postMessage(`CLOSE_STREAM:${executeId}`);\n                if (flows.length === 0) {\n                    const resolvers = withResolvers<T>();\n                    flows.push({ ...resolvers, blank: true } as any);\n                }\n                for (const flow of flows) {\n                    flow.blank = false;\n                    flow.reject(err);\n                }\n                return { done: true, value: null };\n            },\n        } satisfies AsyncIterator<unknown>),\n        [Symbol.asyncIterator]() {\n            return this;\n        },\n    };\n\n    return iterator as MilkioFlow<T>;\n}\n\nfunction withResolvers<T = any>(): PromiseWithResolvers<T> {\n    let resolve: PromiseWithResolvers<T>[\"resolve\"];\n    let reject: PromiseWithResolvers<T>[\"reject\"];\n    const promise = new Promise<T>((res, rej) => {\n        resolve = res;\n        reject = rej;\n    });\n    return { promise, resolve: resolve!, reject: reject! };\n}\n"
  ],
  "mappings": "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",
  "debugId": "1BC79B1210E27E9364756E2164756E21",
  "names": []
}
+//# debugId=A0E5907D1372DBD864756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../utils/create-id.ts", "../index.ts"],
  "sourcesContent": [
    "type IdGeneratorOptions = {\n  length?: number;\n  timestamp: boolean;\n  sequential: boolean;\n};\n\nfunction defineIdGenerator(options: IdGeneratorOptions) {\n  if (!options.length) options.length = 24;\n  if (options.length < 1) throw new Error(\"Invalid length\");\n  if (options.length > 61) throw new Error(\"Invalid length\");\n  if (options.timestamp && options.length < 9) throw new Error(\"Invalid length\");\n  let lastTime = 0;\n  let lastDecimal = 0n;\n  return {\n    createId() {\n      let randLength = options.length!;\n      const now = Date.now();\n      let id = \"\";\n      if (options.timestamp) {\n        randLength -= 8;\n        id = `${id}${__bigIntToString(BigInt(now)).padStart(8, \"0\")}`;\n      }\n      if (options.sequential && lastTime === now) {\n        id = `${id}${__bigIntToString(++lastDecimal).padStart(1, \"0\")}`;\n      } else {\n        lastTime = now;\n        const min = 0n;\n        const max = __getMaxValue(BigInt(randLength));\n        lastDecimal = __secureRandomBigInt(min, max);\n        id = `${id}${__bigIntToString(lastDecimal).padStart(randLength, \"0\")}`;\n      }\n      return id;\n    },\n    getIdTimestamp(id: string) {\n      return options.timestamp ? Number(__stringToBigInt(id.slice(0, 8).replaceAll(\"0\", \"\"))) : 0;\n    },\n  };\n}\n\nconst ENCODING = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\";\n\nfunction __secureRandomBigInt(min: bigint, max: bigint): bigint {\n  if (min >= max) throw new Error(\"Invalid range\");\n\n  const range = max - min + 1n;\n  const byteCount = Math.ceil(Number(BigInt(range.toString(2).length)) / 8);\n  const entropyBytes = new Uint8Array(byteCount);\n\n  let randomValue: bigint;\n  do {\n    crypto.getRandomValues(entropyBytes);\n    randomValue =\n      BigInt(\n        `0x${Array.from(entropyBytes)\n          .map((b) => b.toString(16).padStart(2, \"0\"))\n          .join(\"\")}`,\n      ) % range;\n  } while (randomValue < 0n);\n\n  return min + randomValue;\n}\n\nfunction __bigIntToString(value: bigint): string {\n  const base = BigInt(ENCODING.length);\n  let result = \"\";\n  let current = value;\n\n  if (current === 0n) return ENCODING[0];\n\n  while (current > 0n) {\n    const remainder = current % base;\n    result = ENCODING[Number(remainder)] + result;\n    current = current / base;\n  }\n  return result;\n}\n\nfunction __stringToBigInt(str: string): bigint {\n  const charMap: { [key: string]: number } = {};\n  for (let i = 0; i < ENCODING.length; i++) {\n    charMap[ENCODING[i]] = i;\n  }\n\n  const base = BigInt(ENCODING.length);\n  let result = 0n;\n\n  for (let i = 0; i < str.length; i++) {\n    const char = str[i];\n    if (!(char in charMap)) {\n      throw new Error(`Invalid character '${char}' in input string`);\n    }\n    const value = BigInt(charMap[char]);\n    result = result * base + value;\n  }\n\n  return result;\n}\n\nfunction __getMaxValue(n: bigint): bigint {\n  return BigInt(ENCODING.length) ** n - 1n;\n}\n\nconst idGenerator = defineIdGenerator({ length: 24, timestamp: false, sequential: false });\n\nexport const __createId = idGenerator.createId;\n",
    "import { __createId } from \"./utils/create-id.ts\";\n\nexport type MilkioStargateOptions = {\n    port: {\n        postMessage: (data: any) => void;\n        addEventListener: (event: \"message\", callback: (event: { data: any }) => void) => void;\n        removeEventListener: (event: \"message\", callback: (event: { data: any }) => void) => void;\n    };\n    cacheStorage?: CacheStorage;\n    cacheEncryption?: boolean;\n};\n\nexport type Mixin<T, U> = U & Omit<T, keyof U>;\n\nexport type CacheStrategy = 'off' | 'fallback' | 'throttle';\n\nexport type RetryStrategy = boolean | number;\n\nexport interface CacheStorage {\n    get: (key: string) => Promise<{ data: any; timestamp: number } | null>;\n    set: (key: string, data: any) => Promise<void>;\n}\n\nexport type ExecuteOptions<T extends any = any> = {\n    params?: Record<any, any>;\n    headers?: Record<string, string>;\n    cacheStrategy?: CacheStrategy;\n    cacheThrottleMs?: number;\n    onCacheHit?: (result: T) => void | Promise<void>;\n    retryStrategy?: RetryStrategy;\n};\n\nexport type ExecuteResultsOption = { executeId: string };\n\nexport type GeneratorGeneric<T> = T extends AsyncGenerator<infer I> ? I : never;\n\nexport async function createStargateWorker<Generated extends { routeSchema: any; rejectCode: any }>(stargateOptions: MilkioStargateOptions) {\n    const executeIds = new Set<string>();\n    const connect = new Promise((resolve) => {\n        const handler = (event: { data: any }) => {\n            if (event.data !== \"PONG\") return;\n            clearInterval(timer);\n            stargateOptions.port.removeEventListener(\"message\", handler);\n            resolve(true);\n        };\n        stargateOptions.port.addEventListener(\"message\", handler);\n        stargateOptions.port.postMessage(\"PING\");\n        const timer = setInterval(() => stargateOptions.port.postMessage(\"PING\"), 42);\n    });\n    const stargate = {\n        close() {\n            for (const executeId of executeIds) {\n                stargateOptions.port.postMessage(`CLOSE_STREAM:${executeId}`);\n            }\n            stargateOptions.port.postMessage(\"CLOSED\");\n        },\n        async execute<Path extends keyof Generated[\"routeSchema\"]>(\n            path: Path,\n            options: Mixin<\n                ExecuteOptions<Generated[\"routeSchema\"][Path][\"types\"][\"result\"]>,\n                {\n                    params?: Generated[\"routeSchema\"][Path][\"types\"][\"params\"];\n                }\n            >,\n        ): Promise<\n            Generated[\"routeSchema\"][Path][\"types\"][\"🥛\"] extends boolean\n            ? // action\n            [Partial<Generated[\"rejectCode\"]>, null, ExecuteResultsOption] | [null, Generated[\"routeSchema\"][Path][\"types\"][\"result\"], ExecuteResultsOption]\n            : // stream\n            [Partial<Generated[\"rejectCode\"]>, null, ExecuteResultsOption] | [null, AsyncGenerator<[Partial<Generated[\"rejectCode\"]>, null] | [null, GeneratorGeneric<Generated[\"routeSchema\"][Path][\"types\"][\"result\"]>], undefined>, ExecuteResultsOption]\n        > {\n            // oxlint-disable-next-line no-async-promise-executor\n            return new Promise(async (resolve) => {\n                await connect;\n\n                if (!(path as string).endsWith(\"~\")) {\n                    // action\n                    const cacheStrategy = options?.cacheStrategy ?? 'off';\n                    let retryCount = 0;\n                    if (options?.retryStrategy === true || options?.retryStrategy === 2) {\n                        retryCount = 2;\n                    } else if (typeof options?.retryStrategy === 'number' && options?.retryStrategy > 0) {\n                        retryCount = options?.retryStrategy;\n                    }\n                    const cacheThrottleMs = options?.cacheThrottleMs ?? 0;\n                    const cacheKey = generateCacheKey(path as string, options?.params);\n\n                    let cacheStorage = stargateOptions.cacheStorage;\n                    if (cacheStrategy !== 'off' && !cacheStorage) {\n                        cacheStorage = await createDefaultCacheStorage({ encryption: stargateOptions.cacheEncryption });\n                    }\n\n                    if (cacheStrategy !== 'off' && cacheStorage && options?.onCacheHit) {\n                        const cached = await cacheStorage.get(cacheKey);\n                        if (cached) {\n                            try {\n                                await options.onCacheHit(cached.data);\n                            } catch {\n                                // ignore onCacheHit errors\n                            }\n                        }\n                    }\n\n                    if (cacheStrategy === 'throttle' && cacheStorage) {\n                        const cached = await cacheStorage.get(cacheKey);\n                        if (cached && Date.now() - cached.timestamp < cacheThrottleMs) {\n                            return resolve([null, cached.data, { executeId: 'cached' }] as any);\n                        }\n                    }\n\n                    const executeRequest = (): Promise<[any, any, ExecuteResultsOption]> => {\n                        return new Promise((reqResolve) => {\n                            const reqExecuteId = __createId();\n                            executeIds.add(reqExecuteId);\n                            const handler = (event: { data: any }) => {\n                                if (typeof event.data !== \"object\") return;\n                                if (event.data.executeId !== reqExecuteId) return;\n                                executeIds.delete(reqExecuteId);\n                                stargateOptions.port.removeEventListener(\"message\", handler);\n                                if (!event.data.success) {\n                                    const error: any = {};\n                                    error[event.data.error.code] = event.data.error.reject;\n                                    reqResolve([error, null, { executeId: reqExecuteId }]);\n                                } else {\n                                    reqResolve([null, event.data.data, { executeId: reqExecuteId }]);\n                                }\n                            };\n                            stargateOptions.port.addEventListener(\"message\", handler);\n                            stargateOptions.port.postMessage({\n                                executeId: reqExecuteId,\n                                path,\n                                params: options?.params,\n                                headers: options?.headers,\n                            });\n                        });\n                    };\n\n                    let [error, result, resultOption] = await executeRequest();\n\n                    for (let retryIndex = 0; retryIndex < retryCount && error; retryIndex++) {\n                        if (retryIndex > 0) {\n                            await new Promise((r) => setTimeout(r, 500));\n                        }\n                        [error, result, resultOption] = await executeRequest();\n                    }\n\n                    if (error) {\n                        if (cacheStrategy !== 'off' && cacheStorage) {\n                            const cached = await cacheStorage.get(cacheKey);\n                            if (cached) {\n                                return resolve([null, cached.data, { executeId: 'cached' }] as any);\n                            }\n                        }\n                        return resolve([error, null, resultOption]);\n                    }\n\n                    if (cacheStrategy !== 'off' && cacheStorage) {\n                        await cacheStorage.set(cacheKey, result);\n                    }\n\n                    resolve([null, result, resultOption] as any);\n                } else {\n                    // stream\n                    const executeId = __createId();\n                    executeIds.add(executeId);\n\n                    let flow: ReturnType<typeof createFlow> | undefined;\n                    const handler = (event: { data: any }) => {\n                        if (typeof event.data !== \"object\") return;\n                        if (event.data.executeId !== executeId) return;\n                        if (!flow) {\n                            flow = createFlow(stargateOptions, executeId);\n                            if (!event.data.success) {\n                                const error: any = {};\n                                error[event.data.error.code] = event.data.error.reject;\n                                resolve([error, null, { executeId }]);\n                            }\n                            if (event.data.success) resolve([null, flow, { executeId }] as any);\n                        } else {\n                            if (event.data.done) {\n                                stargateOptions.port.removeEventListener(\"message\", handler);\n                                executeIds.delete(executeId);\n                                if (event.data.success) flow.return(undefined, true);\n                                else flow.throw(event.data.data?.at(0), true);\n                            } else if (!event.data.success) {\n                                stargateOptions.port.removeEventListener(\"message\", handler);\n                                executeIds.delete(executeId);\n                                flow.throw(event.data.data, true);\n                            } else if (event.data.success) flow.emit(event.data.data);\n                        }\n                    };\n                    stargateOptions.port.addEventListener(\"message\", handler);\n                    stargateOptions.port.postMessage({\n                        executeId,\n                        path,\n                        params: options?.params,\n                        headers: options?.headers,\n                    });\n                }\n            });\n        },\n        $types: undefined as unknown as {\n            generated: Generated,\n            error: Generated[\"rejectCode\"];\n            params: {\n                [Path in keyof Generated[\"routeSchema\"]]: Generated[\"routeSchema\"][Path][\"types\"][\"params\"]\n            },\n            results: {\n                [Path in keyof Generated[\"routeSchema\"]]: Generated[\"routeSchema\"][Path][\"types\"][\"🥛\"] extends boolean\n                ? // action\n                Generated[\"routeSchema\"][Path][\"types\"][\"result\"]\n                : // stream\n                AsyncGenerator<[Partial<Generated[\"rejectCode\"]>, null] | [null, GeneratorGeneric<Generated[\"routeSchema\"][Path][\"types\"][\"result\"]>], undefined>\n            },\n        },\n    };\n\n    return stargate;\n}\n\nexport type MilkioFlow<T, TReturn = any, TNext = any> = {\n    emit: (flow: T) => void;\n    [Symbol.asyncIterator]: () => MilkioFlow<T>;\n    next(...[value]: [] | [TNext]): Promise<IteratorResult<T, TReturn>>;\n    return(data: undefined, disablePostCloseMessage?: true): Promise<IteratorResult<T, TReturn>>;\n    throw(error: any, disablePostCloseMessage?: true): Promise<IteratorResult<T, TReturn>>;\n};\n\nexport function createFlow<T>(stargateOptions: MilkioStargateOptions, executeId: string): MilkioFlow<T> {\n    let status: \"pending\" | \"resolved\" | \"rejected\" = \"pending\";\n    const flows: Array<{\n        blank: boolean;\n        promise: Promise<T>;\n        resolve: (value?: T | PromiseLike<T>) => void;\n        reject: (reason?: any) => void;\n    }> = [];\n\n    const iterator = {\n        emit: (flow: T) => {\n            if (flows.at(-1)?.blank === true) {\n                const item = flows.at(-1)!;\n                item.blank = false;\n                item.resolve(flow);\n                return;\n            } else {\n                const resolvers = withResolvers<T>();\n                resolvers.resolve(flow);\n                flows.push({ ...resolvers, blank: false } as any);\n            }\n        },\n        ...({\n            async next(): Promise<IteratorResult<T>> {\n                if (status !== \"pending\") return { done: true, value: null };\n                if (flows.length === 0) {\n                    const resolvers = withResolvers<T>();\n                    flows.push({ ...resolvers, blank: true } as any);\n                }\n                const flow = flows.at(0)!;\n                const result = await flow.promise;\n                flows.shift();\n                return { done: status !== \"pending\", value: result };\n            },\n            async return(_: undefined, disablePostCloseMessage?: true): Promise<IteratorResult<void>> {\n                status = \"resolved\";\n                if (!disablePostCloseMessage) stargateOptions.port.postMessage(`CLOSE_STREAM:${executeId}`);\n                for (const flow of flows) {\n                    flow.blank = false;\n                    flow.resolve(undefined);\n                }\n                return { done: true, value: null };\n            },\n            async throw(err: any, disablePostCloseMessage?: true): Promise<IteratorResult<void>> {\n                status = \"rejected\";\n                if (!disablePostCloseMessage) stargateOptions.port.postMessage(`CLOSE_STREAM:${executeId}`);\n                if (flows.length === 0) {\n                    const resolvers = withResolvers<T>();\n                    flows.push({ ...resolvers, blank: true } as any);\n                }\n                for (const flow of flows) {\n                    flow.blank = false;\n                    flow.reject(err);\n                }\n                return { done: true, value: null };\n            },\n        } satisfies AsyncIterator<unknown>),\n        [Symbol.asyncIterator]() {\n            return this;\n        },\n    };\n\n    return iterator as MilkioFlow<T>;\n}\n\nfunction withResolvers<T = any>(): PromiseWithResolvers<T> {\n    let resolve: PromiseWithResolvers<T>[\"resolve\"];\n    let reject: PromiseWithResolvers<T>[\"reject\"];\n    const promise = new Promise<T>((res, rej) => {\n        resolve = res;\n        reject = rej;\n    });\n    return { promise, resolve: resolve!, reject: reject! };\n}\n\nconst isoDatePattern = /^(\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{1,3})?)(Z|[+-]\\d{2}:?\\d{2})?$/;\n\nexport function reviveJSONParse<T>(json: T): T {\n    if (json !== null && typeof json === 'object') {\n        if (json instanceof Date || (typeof (json as any).getTime === 'function' && typeof (json as any).toISOString === 'function')) {\n            return json;\n        }\n        if (Array.isArray(json)) {\n            return json.map((item) => reviveJSONParse(item)) as any;\n        }\n        return Object.entries(json).reduce((acc, [key, value]) => {\n            acc[key as keyof T] = reviveJSONParse(value);\n            return acc;\n        }, {} as T);\n    }\n    if (typeof json === 'string') {\n        const match = json.match(isoDatePattern);\n        if (match) {\n            const normalizedDateString = match[2] ? `${match[1]}${match[2].replace(':', '')}` : `${match[1]}Z`;\n            return new Date(normalizedDateString) as any;\n        }\n    }\n    return json;\n}\n\nconst DB_NAME = 'StargateWorker';\nconst STORE_NAME = 'caches';\nlet dbInstance: IDBDatabase | null = null;\n\nasync function openDB(): Promise<IDBDatabase> {\n    if (dbInstance) return dbInstance;\n\n    return new Promise((resolve, reject) => {\n        const request = indexedDB.open(DB_NAME, 1);\n        request.onerror = () => reject(request.error);\n        request.onsuccess = () => {\n            dbInstance = request.result;\n            resolve(dbInstance);\n        };\n        request.onupgradeneeded = (event) => {\n            const db = (event.target as IDBOpenDBRequest).result;\n            if (!db.objectStoreNames.contains(STORE_NAME)) {\n                db.createObjectStore(STORE_NAME);\n            }\n        };\n    });\n}\n\nexport async function createDefaultCacheStorage(options?: { encryption?: boolean; encryptionKey?: string }): Promise<CacheStorage> {\n    await openDB();\n\n    let encryptionKey: CryptoKey | null = null;\n    const counter = new Uint8Array(16);\n\n    if (options?.encryption) {\n        const keyString = options.encryptionKey ?? DB_NAME;\n        new TextEncoder().encode(keyString).forEach((byte, i) => {\n            if (i < 16) counter[i] = byte;\n        });\n\n        const encoder = new TextEncoder();\n        const keyData = encoder.encode(keyString);\n        const importedKey = await crypto.subtle.importKey('raw', keyData, { name: 'PBKDF2' }, false, ['deriveKey']);\n\n        encryptionKey = await crypto.subtle.deriveKey(\n            {\n                name: 'PBKDF2',\n                salt: encoder.encode('milkio-stargate-worker-cache'),\n                iterations: 100000,\n                hash: 'SHA-256',\n            },\n            importedKey,\n            { name: 'AES-CTR', length: 256 },\n            false,\n            ['encrypt', 'decrypt'],\n        );\n    }\n\n    const encryptData = async (data: any): Promise<Uint8Array> => {\n        if (!encryptionKey) return data;\n\n        const jsonString = JSON.stringify(data);\n        const encoder = new TextEncoder();\n        const dataBytes = encoder.encode(jsonString);\n\n        const encryptedArrayBuffer = await crypto.subtle.encrypt(\n            {\n                name: 'AES-CTR',\n                counter: counter,\n                length: 64,\n            },\n            encryptionKey!,\n            dataBytes,\n        );\n\n        return new Uint8Array(encryptedArrayBuffer);\n    };\n\n    const decryptData = async (encryptedData: ArrayBuffer | Uint8Array): Promise<any> => {\n        if (!encryptionKey || !encryptedData) return encryptedData;\n\n        const arrayBuffer = encryptedData instanceof Uint8Array ? (encryptedData.buffer as ArrayBuffer) : encryptedData;\n\n        const decryptedBytes = await crypto.subtle.decrypt(\n            {\n                name: 'AES-CTR',\n                counter: counter,\n                length: 64,\n            },\n            encryptionKey!,\n            arrayBuffer,\n        );\n\n        const decoder = new TextDecoder();\n        const jsonString = decoder.decode(decryptedBytes);\n        return reviveJSONParse(JSON.parse(jsonString));\n    };\n\n    return {\n        async get(key: string): Promise<{ data: any; timestamp: number } | null> {\n            const db = await openDB();\n            return new Promise((resolve, reject) => {\n                const transaction = db.transaction(STORE_NAME, 'readonly');\n                const store = transaction.objectStore(STORE_NAME);\n                const request = store.get(key);\n                request.onerror = () => reject(request.error);\n                request.onsuccess = async () => {\n                    const result = request.result;\n                    if (!result) {\n                        resolve(null);\n                        return;\n                    }\n\n                    if (options?.encryption && (result.data instanceof ArrayBuffer || result.data instanceof Uint8Array)) {\n                        const decryptedData = await decryptData(result.data);\n                        resolve({ data: decryptedData, timestamp: result.timestamp });\n                        return;\n                    }\n\n                    resolve(result ?? null);\n                };\n            });\n        },\n        async set(key: string, data: any): Promise<void> {\n            const db = await openDB();\n            let dataToStore: any = data;\n\n            if (options?.encryption) {\n                dataToStore = await encryptData(data);\n            }\n\n            return new Promise((resolve, reject) => {\n                const transaction = db.transaction(STORE_NAME, 'readwrite');\n                const store = transaction.objectStore(STORE_NAME);\n                const request = store.put({ data: dataToStore, timestamp: Date.now() }, key);\n                request.onerror = () => reject(request.error);\n                request.onsuccess = () => resolve();\n            });\n        },\n    };\n}\n\nfunction generateCacheKey(path: string, params: any): string {\n    return `${path}:${JSON.stringify(params ?? {})}`;\n}\n"
  ],
  "mappings": "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",
  "debugId": "A0E5907D1372DBD864756E2164756E21",
  "names": []
}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milkio/stargate-worker",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "type": "module",
   "exports": "./index.js",
   "types": "./index.d.ts",