akanjs 2.2.6 → 2.2.7-rc.1

package/fetch/client/fetchClient.ts

@@ -17,6 +17,7 @@ import { type ErrorConstructor, HttpClient } from "./httpClient";
 import { WsClient } from "./wsClient";
 
 type FetchHandler = (...args: unknown[]) => PromiseOrObject<unknown>;
+type FetchHandlerFactory = () => FetchHandler;
 type UnknownRecord = Record<string, unknown>;
 
 const isNullableArg = (arg: SerializedArg) => arg.nullable ?? arg.type === "search";
@@ -46,13 +47,18 @@ type ClientSignalMap<SigType extends { fetch: any }> = {
 
 /** Runtime fetch client that registers serialized Akan signals as HTTP/WebSocket methods. */
 export class FetchClient {
+  static #sharedSerializedSignal: { [key: string]: SerializedSignal } = {};
+  static #sharedRegistryVersion = 0;
   readonly logger = new Logger("FetchClient");
   readonly origin: string;
   readonly http: HttpClient;
   readonly ws: WsClient;
-  readonly handler: Record<string, FetchHandler> = {};
+  readonly handler: Record<string, FetchHandler>;
   readonly slice: Record<string, SliceMeta> = {};
   readonly sortKeyMap = new Map<string, string[]>();
+  readonly #handlerStore: Record<string, FetchHandler> = {};
+  readonly #handlerFactory = new Map<string, FetchHandlerFactory>();
+  #sharedRegistryAppliedVersion = 0;
   serializedSignal: { [key: string]: SerializedSignal } = {};
   jwt: string | null = null;
 
@@ -66,16 +72,52 @@ export class FetchClient {
     this.http = new HttpClient(origin, ErrorCls);
     const wsUri = `${origin.replace("http://", "ws://").replace("https://", "wss://")}/ws`;
     this.ws = new WsClient(wsUri, ErrorCls);
-    this.handler = handler;
+    Object.assign(this.#handlerStore, handler);
+    this.handler = this.#makeHandlerProxy();
     this.applySignal(serializedSignal);
   }
+  static resetSharedRegistry() {
+    FetchClient.#sharedSerializedSignal = {};
+    FetchClient.#sharedRegistryVersion++;
+  }
+  static #mergeSerializedSignalInto(
+    serializedSignal: { [key: string]: SerializedSignal },
+    refName: string,
+    signal: SerializedSignal,
+  ) {
+    const current = serializedSignal[refName];
+    serializedSignal[refName] = current
+      ? {
+          ...current,
+          ...signal,
+          endpoint: { ...current.endpoint, ...signal.endpoint },
+          slice: current.slice || signal.slice ? { ...current.slice, ...signal.slice } : undefined,
+          filter:
+            current.filter || signal.filter
+              ? {
+                  filter: { ...current.filter?.filter, ...signal.filter?.filter },
+                  sortKeys: [...new Set([...(current.filter?.sortKeys ?? []), ...(signal.filter?.sortKeys ?? [])])],
+                }
+              : undefined,
+          getGuards: signal.getGuards ?? current.getGuards,
+          cruGuards: signal.cruGuards ?? current.cruGuards,
+        }
+      : signal;
+  }
   setErrorConstructor(ErrorCls?: ErrorConstructor) {
     this.ErrorCls = ErrorCls;
     this.http.setErrorConstructor(ErrorCls);
     this.ws.setErrorConstructor(ErrorCls);
   }
-  applySignal(serializedSignal: { [key: string]: SerializedSignal }) {
-    Object.assign(this.serializedSignal, serializedSignal);
+  applySignal(serializedSignal: { [key: string]: SerializedSignal }, { share = true }: { share?: boolean } = {}) {
+    if (share && Object.keys(serializedSignal).length > 0) {
+      for (const [refName, signal] of Object.entries(serializedSignal))
+        FetchClient.#mergeSerializedSignalInto(FetchClient.#sharedSerializedSignal, refName, signal);
+      FetchClient.#sharedRegistryVersion++;
+      this.#sharedRegistryAppliedVersion = FetchClient.#sharedRegistryVersion;
+    }
+    for (const [refName, signal] of Object.entries(serializedSignal))
+      FetchClient.#mergeSerializedSignalInto(this.serializedSignal, refName, signal);
     for (const [refName, signal] of Object.entries(serializedSignal)) {
       for (const [key, endpoint] of Object.entries(signal.endpoint))
         this.#registerEndpoint(key, endpoint, signal.prefix);
@@ -93,6 +135,44 @@ export class FetchClient {
     }
     return this;
   }
+  #makeHandlerProxy() {
+    return new Proxy(this.#handlerStore, {
+      get: (target, prop) => {
+        if (typeof prop !== "string") return undefined;
+        return target[prop] ?? this.#getOrCreateHandler(prop);
+      },
+      has: (target, prop) => {
+        if (typeof prop !== "string") return prop in target;
+        return prop in target || this.#handlerFactory.has(prop);
+      },
+    });
+  }
+  #syncSharedRegistry() {
+    if (this.#sharedRegistryAppliedVersion === FetchClient.#sharedRegistryVersion) return;
+    this.applySignal(FetchClient.#sharedSerializedSignal, { share: false });
+    this.#sharedRegistryAppliedVersion = FetchClient.#sharedRegistryVersion;
+  }
+  #getOrCreateHandler(key: string): FetchHandler | undefined {
+    const current = this.#handlerStore[key];
+    if (current) return current;
+    const factory = this.#handlerFactory.get(key);
+    if (factory) {
+      const handler = factory();
+      this.#handlerStore[key] = handler;
+      return handler;
+    }
+    this.#syncSharedRegistry();
+    const syncedFactory = this.#handlerFactory.get(key);
+    if (!syncedFactory) return undefined;
+    const handler = syncedFactory();
+    this.#handlerStore[key] = handler;
+    return handler;
+  }
+  #requireHandler<T extends FetchHandler = FetchHandler>(key: string, owner: string): T {
+    const handler = this.#getOrCreateHandler(key);
+    if (!handler) throw new Error(`${owner} requires fetch handler "${key}", but it is not registered`);
+    return handler as T;
+  }
   connect() {
     this.ws.connect();
   }
@@ -176,58 +256,66 @@ export class FetchClient {
   #registerEndpoint(key: string, endpoint: SerializedEndpoint, prefix?: string) {
     switch (endpoint.type) {
       case "query": {
-        return Object.assign(this.handler, { [key]: this.#makeHttpFn(key, endpoint, prefix) });
+        this.#handlerFactory.set(key, () => this.#makeHttpFn(key, endpoint, prefix));
+        return;
       }
       case "mutation": {
-        return Object.assign(this.handler, { [key]: this.#makeHttpFn(key, endpoint, prefix) });
+        this.#handlerFactory.set(key, () => this.#makeHttpFn(key, endpoint, prefix));
+        return;
       }
       case "pubsub": {
-        const roomArgs = endpoint.args.filter((arg) => arg.type === "room");
-        const roomArgLength = roomArgs.length;
-        const serializerMap = this.#makeArgSerializer(endpoint.args);
-        const parseReturn = this.#makeReturnParser(endpoint.returns);
-        const wrappedListeners = new WeakMap<(data: unknown) => void, (data: unknown) => void>();
-        const pubsubFn = async (...argData: unknown[]) => {
-          const args = argData.slice(0, roomArgLength);
-          const handleEvent = argData[roomArgLength] as (data: unknown) => void;
-          const fetchPolicy = argData[roomArgLength + 1] as FetchPolicy | undefined;
-          const data = roomArgs.map((arg, idx) => serializerMap.get(arg.name)?.(args[idx]) ?? null);
-          const wrapped = (data: unknown) => {
-            const parsedReturn = parseReturn(data, { crystalize: fetchPolicy?.crystalize ?? true });
-            handleEvent(parsedReturn);
+        this.#handlerFactory.set(`subscribe${capitalize(key)}`, () => {
+          const roomArgs = endpoint.args.filter((arg) => arg.type === "room");
+          const roomArgLength = roomArgs.length;
+          const serializerMap = this.#makeArgSerializer(endpoint.args);
+          const parseReturn = this.#makeReturnParser(endpoint.returns);
+          const wrappedListeners = new WeakMap<(data: unknown) => void, (data: unknown) => void>();
+          return async (...argData: unknown[]) => {
+            const args = argData.slice(0, roomArgLength);
+            const handleEvent = argData[roomArgLength] as (data: unknown) => void;
+            const fetchPolicy = argData[roomArgLength + 1] as FetchPolicy | undefined;
+            const data = roomArgs.map((arg, idx) => serializerMap.get(arg.name)?.(args[idx]) ?? null);
+            const wrapped = (data: unknown) => {
+              const parsedReturn = parseReturn(data, { crystalize: fetchPolicy?.crystalize ?? true });
+              handleEvent(parsedReturn);
+            };
+            wrappedListeners.set(handleEvent, wrapped);
+            this.ws.subscribe({
+              key,
+              data,
+              handleEvent: wrapped,
+            });
+            return () =>
+              this.ws.unsubscribe({ key, data, handleEvent: wrappedListeners.get(handleEvent) ?? handleEvent });
           };
-          wrappedListeners.set(handleEvent, wrapped);
-          this.ws.subscribe({
-            key,
-            data,
-            handleEvent: wrapped,
-          });
-          return () =>
-            this.ws.unsubscribe({ key, data, handleEvent: wrappedListeners.get(handleEvent) ?? handleEvent });
-        };
-        return Object.assign(this.handler, { [`subscribe${capitalize(key)}`]: pubsubFn });
+        });
+        return;
       }
       case "message": {
-        const msgArgs = endpoint.args.filter((arg) => arg.type === "msg");
-        const msgArgLength = msgArgs.length;
-        const serializerMap = this.#makeArgSerializer(endpoint.args);
-        const parseReturn = this.#makeReturnParser(endpoint.returns);
-        const wrappedListeners = new WeakMap<(data: unknown) => void, (data: unknown) => void>();
-        const messageFn = async (...argData: unknown[]) => {
-          const args = argData.slice(0, msgArgLength);
-          const data = msgArgs.map((arg, idx) => serializerMap.get(arg.name)?.(args[idx]) ?? null);
-          this.ws.emit(key, data);
-        };
-        const listenFn = (handleEvent: (data: unknown) => void, fetchPolicy: FetchPolicy = {}) => {
-          const wrapped = (data: unknown) => {
-            const parsedReturn = parseReturn(data, { crystalize: fetchPolicy?.crystalize ?? true });
-            handleEvent(parsedReturn);
+        this.#handlerFactory.set(key, () => {
+          const msgArgs = endpoint.args.filter((arg) => arg.type === "msg");
+          const msgArgLength = msgArgs.length;
+          const serializerMap = this.#makeArgSerializer(endpoint.args);
+          return async (...argData: unknown[]) => {
+            const args = argData.slice(0, msgArgLength);
+            const data = msgArgs.map((arg, idx) => serializerMap.get(arg.name)?.(args[idx]) ?? null);
+            this.ws.emit(key, data);
           };
-          wrappedListeners.set(handleEvent, wrapped);
-          this.ws.on(key, wrapped);
-          return () => this.ws.off(key, wrappedListeners.get(handleEvent) ?? handleEvent);
-        };
-        return Object.assign(this.handler, { [key]: messageFn, [`listen${capitalize(key)}`]: listenFn });
+        });
+        this.#handlerFactory.set(`listen${capitalize(key)}`, () => {
+          const parseReturn = this.#makeReturnParser(endpoint.returns);
+          const wrappedListeners = new WeakMap<(data: unknown) => void, (data: unknown) => void>();
+          return ((handleEvent: (data: unknown) => void, fetchPolicy: FetchPolicy = {}) => {
+            const wrapped = (data: unknown) => {
+              const parsedReturn = parseReturn(data, { crystalize: fetchPolicy?.crystalize ?? true });
+              handleEvent(parsedReturn);
+            };
+            wrappedListeners.set(handleEvent, wrapped);
+            this.ws.on(key, wrapped);
+            return () => this.ws.off(key, wrappedListeners.get(handleEvent) ?? handleEvent);
+          }) as FetchHandler;
+        });
+        return;
       }
       default:
         this.logger.error(`Unsupported endpoint type: ${endpoint.type}`);
@@ -302,7 +390,6 @@ export class FetchClient {
     return endpoint;
   }
   #registerModelBaseEndpoint(refName: string, signal: SerializedSignal) {
-    const cnst = ConstantRegistry.getDatabase(refName);
     const capRefName = capitalize(refName);
     const names = {
       createModel: `create${capRefName}`,
@@ -319,66 +406,90 @@ export class FetchClient {
       mergeModel: `merge${capRefName}`,
     };
     const endpoint = FetchClient.getBaseEndpoint(refName, signal);
-    const handler = Object.fromEntries(
-      Object.entries(endpoint).map(([key, value]) => [key, this.#makeHttpFn(key, value, signal.prefix)]),
-    );
-    Object.assign(this.handler, handler);
-
-    if (signal.cruGuards)
-      Object.assign(this.handler, {
-        [names.viewModel]: async (id: string, option?: FetchPolicy) => {
-          const modelObj = await this.handler[names.model](id, { ...option, crystalize: false });
-          const model = new cnst.full(modelObj as object);
-          return {
-            [refName]: model,
-            [`${refName}View`]: { refName, [`${refName}Obj`]: modelObj, [`${refName}ViewAt`]: new Date() },
-          };
-        },
-        [names.getModelView]: async (id: string, option?: FetchPolicy) => {
-          const modelObj = await this.handler[names.model](id, { ...option, crystalize: false });
-          return { refName, [`${refName}Obj`]: modelObj, [`${refName}ViewAt`]: new Date() };
-        },
-        [names.editModel]: async (id: string, option?: FetchPolicy) => {
-          const modelObj = await this.handler[names.model](id, { ...option, crystalize: false });
-          const model = new cnst.full(modelObj as object);
-          return {
-            [refName]: model,
-            [`${refName}Edit`]: { refName, [`${refName}Obj`]: modelObj, [`${refName}ViewAt`]: new Date() },
-          };
-        },
-        [names.getModelEdit]: async (id: string, option?: FetchPolicy) => {
-          const modelObj = await this.handler[names.model](id, { ...option, crystalize: false });
-          return { refName, [`${refName}Obj`]: modelObj, [`${refName}ViewAt`]: new Date() };
-        },
-      });
+    Object.entries(endpoint).forEach(([key, value]) => {
+      this.#handlerFactory.set(key, () => this.#makeHttpFn(key, value, signal.prefix));
+    });
 
-    if (signal.cruGuards)
-      Object.assign(this.handler, {
-        [names.mergeModel]: async (modelOrId: string | { id: string }, data: UnknownRecord, option?: FetchPolicy) => {
-          const id = typeof modelOrId === "string" ? modelOrId : modelOrId.id;
-          return await this.handler[names.updateModel](id, data, option);
-        },
-      });
+    if (signal.cruGuards) {
+      this.#handlerFactory.set(
+        names.viewModel,
+        () =>
+          (async (id: string, option?: FetchPolicy) => {
+            const cnst = ConstantRegistry.getDatabase(refName);
+            const modelFn = this.#requireHandler(names.model, names.viewModel);
+            const modelObj = await modelFn(id, { ...option, crystalize: false });
+            const model = new cnst.full(modelObj as object);
+            return {
+              [refName]: model,
+              [`${refName}View`]: { refName, [`${refName}Obj`]: modelObj, [`${refName}ViewAt`]: new Date() },
+            };
+          }) as FetchHandler,
+      );
+      this.#handlerFactory.set(
+        names.getModelView,
+        () =>
+          (async (id: string, option?: FetchPolicy) => {
+            const modelFn = this.#requireHandler(names.model, names.getModelView);
+            const modelObj = await modelFn(id, { ...option, crystalize: false });
+            return { refName, [`${refName}Obj`]: modelObj, [`${refName}ViewAt`]: new Date() };
+          }) as FetchHandler,
+      );
+      this.#handlerFactory.set(
+        names.editModel,
+        () =>
+          (async (id: string, option?: FetchPolicy) => {
+            const cnst = ConstantRegistry.getDatabase(refName);
+            const modelFn = this.#requireHandler(names.model, names.editModel);
+            const modelObj = await modelFn(id, { ...option, crystalize: false });
+            const model = new cnst.full(modelObj as object);
+            return {
+              [refName]: model,
+              [`${refName}Edit`]: { refName, [`${refName}Obj`]: modelObj, [`${refName}ViewAt`]: new Date() },
+            };
+          }) as FetchHandler,
+      );
+      this.#handlerFactory.set(
+        names.getModelEdit,
+        () =>
+          (async (id: string, option?: FetchPolicy) => {
+            const modelFn = this.#requireHandler(names.model, names.getModelEdit);
+            const modelObj = await modelFn(id, { ...option, crystalize: false });
+            return { refName, [`${refName}Obj`]: modelObj, [`${refName}ViewAt`]: new Date() };
+          }) as FetchHandler,
+      );
+      this.#handlerFactory.set(
+        names.mergeModel,
+        () =>
+          (async (modelOrId: string | { id: string }, data: UnknownRecord, option?: FetchPolicy) => {
+            const id = typeof modelOrId === "string" ? modelOrId : modelOrId.id;
+            const updateFn = this.#requireHandler(names.updateModel, names.mergeModel);
+            return await updateFn(id, data, option);
+          }) as FetchHandler,
+      );
+    }
 
-    Object.assign(this.handler, {
-      [names.addModelFiles]: async (fileList: FileList, parentId?: string, option?: FetchPolicy) => {
-        const cap = resolveFileUploadCapability(this.serializedSignal);
-        const endpoint = cap ? this.serializedSignal[cap.refName]?.endpoint[cap.endpointKey] : undefined;
-        if (!cap || !endpoint)
-          throw new Error(
-            "File upload is not configured. Mark an upload mutation with { fileUpload: true } (e.g. shared FileEndpoint.addFiles).",
-          );
-        const { fields, buildMetas } = fileUploadContract;
-        const formData = new FormData();
-        for (let i = 0; i < fileList.length; i++) formData.append(fields.files, fileList[i]);
-        formData.append(fields.metas, JSON.stringify(buildMetas(fileList)));
-        formData.append(fields.type, refName);
-        if (parentId) formData.append(fields.parentId, parentId);
-        const url = FetchClient.makeHttpUrl(cap.endpointKey, endpoint, cap.prefix, new Map());
-        return await this.http.post(url, formData, { headers: this.#makeAuthHeaders(option) });
-      },
-    });
+    this.#handlerFactory.set(
+      names.addModelFiles,
+      () =>
+        (async (fileList: FileList, parentId?: string, option?: FetchPolicy) => {
+          const cap = resolveFileUploadCapability(this.serializedSignal);
+          const endpoint = cap ? this.serializedSignal[cap.refName]?.endpoint[cap.endpointKey] : undefined;
+          if (!cap || !endpoint)
+            throw new Error(
+              "File upload is not configured. Mark an upload mutation with { fileUpload: true } (e.g. shared FileEndpoint.addFiles).",
+            );
+          const { fields, buildMetas } = fileUploadContract;
+          const formData = new FormData();
+          for (let i = 0; i < fileList.length; i++) formData.append(fields.files, fileList[i]);
+          formData.append(fields.metas, JSON.stringify(buildMetas(fileList)));
+          formData.append(fields.type, refName);
+          if (parentId) formData.append(fields.parentId, parentId);
+          const url = FetchClient.makeHttpUrl(cap.endpointKey, endpoint, cap.prefix, new Map());
+          return await this.http.post(url, formData, { headers: this.#makeAuthHeaders(option) });
+        }) as FetchHandler,
+    );
   }
+
   static getEndpointFromSlice(
     refName: string,
     suffix: string,
@@ -406,7 +517,6 @@ export class FetchClient {
     return endpoint;
   }
   #registerSlice(refName: string, suffix: string, slice: SerializedSlice, prefix?: string) {
-    const cnst = ConstantRegistry.getDatabase(refName);
     const capSuffix = capitalize(suffix);
     const sliceName = `${refName}${capSuffix}`;
     const capRefName = capitalize(refName);
@@ -418,16 +528,14 @@ export class FetchClient {
     };
 
     const endpoint = FetchClient.getEndpointFromSlice(refName, suffix, slice);
-    const handler = Object.fromEntries(
-      Object.entries(endpoint).map(([key, value]) => [key, this.#makeHttpFn(key, value, prefix)]),
-    );
-    Object.assign(this.handler, handler);
+    Object.entries(endpoint).forEach(([key, value]) => {
+      this.#handlerFactory.set(key, () => this.#makeHttpFn(key, value, prefix));
+    });
 
     const argLength = slice.args.length;
     this.slice[sliceName] = { refName, sliceName, argLength };
-    const listFn = this.handler[names.list] as (...args: unknown[]) => Promise<unknown[]>;
-    const insightFn = this.handler[names.insight] as (...args: unknown[]) => Promise<unknown>;
-    const initFn = async (...argData: unknown[]) => {
+    this.#handlerFactory.set(names.init, () => async (...argData: unknown[]) => {
+      const cnst = ConstantRegistry.getDatabase(refName);
       const queryArgs = normalizeQueryArgs(
         Array.from({ length: Math.min(argData.length, argLength) }, (_, idx) => argData[idx]),
         slice.args,
@@ -436,6 +544,8 @@ export class FetchClient {
       const option = (argData[argLength] ?? {}) as { page?: number; limit?: number; sort?: string; insight?: boolean };
       const { page = 1, limit = 20, sort = "latest", insight: fetchInsight = true } = option;
       const skip = (page - 1) * limit;
+      const listFn = this.#requireHandler<(...args: unknown[]) => Promise<unknown[]>>(names.list, names.init);
+      const insightFn = this.#requireHandler<(...args: unknown[]) => Promise<unknown>>(names.insight, names.init);
 
       const [modelObjList, modelObjInsight] = (await Promise.all([
         listFn(...fetchQueryArgs, skip, limit, sort, { ...option, crystalize: false }),
@@ -465,13 +575,14 @@ export class FetchClient {
         [`${refName}List${capSuffix}`]: modelList,
         [`${refName}Insight${capSuffix}`]: modelInsight,
       };
-    };
-    Object.assign(this.handler, {
-      [names.init]: initFn,
-      [names.getInit]: async (...args: unknown[]) => {
-        const result = await initFn(...args);
-        return result[`${refName}Init${capSuffix}`];
-      },
+    });
+    this.#handlerFactory.set(names.getInit, () => async (...args: unknown[]) => {
+      const initFn = this.#requireHandler<(...args: unknown[]) => Promise<Record<string, unknown>>>(
+        names.init,
+        names.getInit,
+      );
+      const result = await initFn(...args);
+      return result[`${refName}Init${capSuffix}`];
     });
   }
   #makeArgSerializer(args: SerializedArg[]) {
@@ -540,34 +651,18 @@ export class FetchClient {
   >(...signals: Signals): FetchProxy<MergeAllFetchTypes<Signals>, GetSliceMetaObjFromDatabaseSignals<Signals>> {
     const serializedSignal: { [key: string]: SerializedSignal } = {};
     const handler: Record<string, FetchHandler> = {};
-    const mergeSerializedSignal = (refName: string, signal: SerializedSignal) => {
-      const current = serializedSignal[refName];
-      serializedSignal[refName] = current
-        ? {
-            ...current,
-            ...signal,
-            endpoint: { ...current.endpoint, ...signal.endpoint },
-            slice: current.slice || signal.slice ? { ...current.slice, ...signal.slice } : undefined,
-            filter:
-              current.filter || signal.filter
-                ? {
-                    filter: { ...current.filter?.filter, ...signal.filter?.filter },
-                    sortKeys: [...new Set([...(current.filter?.sortKeys ?? []), ...(signal.filter?.sortKeys ?? [])])],
-                  }
-                : undefined,
-            getGuards: signal.getGuards ?? current.getGuards,
-            cruGuards: signal.cruGuards ?? current.cruGuards,
-          }
-        : signal;
-    };
     signals.forEach((signal) => {
       if ("endpoint" in signal) {
         const refName = (signal as DatabaseSignal | ServiceSignal).endpoint.baseName;
-        mergeSerializedSignal(refName, (signal as DatabaseSignal | ServiceSignal).serializedSignal);
+        FetchClient.#mergeSerializedSignalInto(
+          serializedSignal,
+          refName,
+          (signal as DatabaseSignal | ServiceSignal).serializedSignal,
+        );
       } else {
         Object.assign(handler, (signal as FetchClient).handler);
         Object.entries((signal as FetchClient).serializedSignal).forEach(([refName, signal]) => {
-          mergeSerializedSignal(refName, signal);
+          FetchClient.#mergeSerializedSignalInto(serializedSignal, refName, signal);
         });
       }
     });
@@ -613,8 +708,11 @@ export class FetchClient {
       get(target, prop) {
         if (prop in target) return (target as any)[prop];
         else if (prop === "instance") return instance;
-        else if (prop in instance.handler) return instance.handler[prop as string];
-        else return (instance as any)[prop as string];
+        else if (typeof prop === "string") {
+          const handler = instance.#getOrCreateHandler(prop);
+          if (handler) return handler;
+        }
+        return (instance as unknown as Record<PropertyKey, unknown>)[prop];
       },
     }) as FetchProxy<FetchType, SliceMetaObj>;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "2.2.6",
+  "version": "2.2.7-rc.1",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/types/fetch/client/fetchClient.d.ts

@@ -34,9 +34,12 @@ export declare class FetchClient {
     constructor(origin: string, handler?: Record<string, FetchHandler>, serializedSignal?: {
         [key: string]: SerializedSignal;
     }, ErrorCls?: ErrorConstructor | undefined);
+    static resetSharedRegistry(): void;
     setErrorConstructor(ErrorCls?: ErrorConstructor): void;
     applySignal(serializedSignal: {
         [key: string]: SerializedSignal;
+    }, { share }?: {
+        share?: boolean;
     }): this;
     connect(): void;
     disconnect(): void;