@spoosh/core 0.15.1 → 0.17.0

package/dist/index.js

@@ -26,6 +26,7 @@ __export(src_exports, {
   __DEV__: () => __DEV__,
   buildUrl: () => buildUrl,
   clone: () => clone,
+  composeAdapter: () => composeAdapter,
   containsFile: () => containsFile,
   createClient: () => createClient,
   createEventEmitter: () => createEventEmitter,
@@ -39,12 +40,14 @@ __export(src_exports, {
   createSelectorProxy: () => createSelectorProxy,
   createSpooshPlugin: () => createSpooshPlugin,
   createStateManager: () => createStateManager,
+  createSubscriptionController: () => createSubscriptionController,
   createTracer: () => createTracer,
   executeFetch: () => executeFetch,
   extractMethodFromSelector: () => extractMethodFromSelector,
   extractPathFromSelector: () => extractPathFromSelector,
   fetchTransport: () => fetchTransport,
   form: () => form,
+  generateSelfTagFromKey: () => generateSelfTagFromKey,
   generateTags: () => generateTags,
   getContentType: () => getContentType,
   isAbortError: () => isAbortError,
@@ -716,7 +719,7 @@ function createSelectorProxy(onCapture) {
       {},
       {
         get(_, prop) {
-          if (HTTP_METHODS.includes(prop)) {
+          if (typeof prop === "string" && prop === prop.toUpperCase()) {
             const selectorFn = (options) => {
               onCapture?.({
                 call: { path, method: prop, options },
@@ -759,7 +762,19 @@ function createInitialState() {
 function generateSelfTagFromKey(key) {
   try {
     const parsed = JSON.parse(key);
-    return parsed.path;
+    const rawPath = parsed.path;
+    if (!rawPath) return void 0;
+    const path = Array.isArray(rawPath) ? rawPath.join("/") : rawPath;
+    const params = parsed.options?.params ?? parsed.pageRequest?.params;
+    if (!params) return path;
+    return path.split("/").map((segment) => {
+      if (segment.startsWith(":")) {
+        const paramName = segment.slice(1);
+        const value = params[paramName];
+        return value !== void 0 ? String(value) : segment;
+      }
+      return segment;
+    }).join("/");
   } catch {
     return void 0;
   }
@@ -996,7 +1011,7 @@ function createPluginExecutor(initialPlugins = []) {
   const createPluginAccessor = (context) => ({
     get(name) {
       const plugin = plugins.find((p) => p.name === name);
-      return plugin?.exports?.(context);
+      return plugin?.internal?.(context);
     }
   });
   const executeLifecycleImpl = async (phase, operationType, context) => {
@@ -1063,6 +1078,9 @@ function createPluginExecutor(initialPlugins = []) {
     getPlugins() {
       return frozenPlugins;
     },
+    getPluginsForOperation(operationType) {
+      return frozenPlugins.filter((p) => p.operations.includes(operationType));
+    },
     registerContextEnhancer(enhancer) {
       contextEnhancers.push(enhancer);
     },
@@ -1095,6 +1113,7 @@ var Spoosh = class _Spoosh {
   baseUrl;
   defaultOptions;
   _plugins;
+  _transports = /* @__PURE__ */ new Map();
   /**
    * Creates a new Spoosh instance.
    *
@@ -1119,10 +1138,13 @@ var Spoosh = class _Spoosh {
    * });
    * ```
    */
-  constructor(baseUrl, defaultOptions, plugins) {
+  constructor(baseUrl, defaultOptions, plugins, transports) {
     this.baseUrl = baseUrl;
     this.defaultOptions = defaultOptions || {};
     this._plugins = plugins || [];
+    if (transports) {
+      this._transports = transports;
+    }
   }
   /**
    * Adds plugins to the Spoosh instance.
@@ -1146,8 +1168,37 @@ var Spoosh = class _Spoosh {
     return new _Spoosh(
       this.baseUrl,
       this.defaultOptions,
-      plugins
+      plugins,
+      this._transports
+    );
+  }
+  /**
+   * Registers transport implementations for real-time operations.
+   *
+   * @param transports - Array of transport instances to register
+   * @returns This Spoosh instance for method chaining
+   *
+   * @example
+   * ```ts
+   * import { sse } from '@spoosh/transport-sse';
+   *
+   * const spoosh = new Spoosh<Schema, Error>('/api')
+   *   .withTransports([sse()])
+   *   .use([...]);
+   * ```
+   */
+  withTransports(transports) {
+    const newTransports = new Map(this._transports);
+    for (const transport of transports) {
+      newTransports.set(transport.name, transport);
+    }
+    const instance = new _Spoosh(
+      this.baseUrl,
+      this.defaultOptions,
+      this._plugins,
+      newTransports
     );
+    return instance;
   }
   /**
    * Cached instance of the underlying SpooshInstance.
@@ -1174,6 +1225,7 @@ var Spoosh = class _Spoosh {
         stateManager,
         eventEmitter,
         pluginExecutor,
+        transports: this._transports,
         config: {
           baseUrl: this.baseUrl,
           defaultOptions: this.defaultOptions
@@ -1181,7 +1233,8 @@ var Spoosh = class _Spoosh {
         _types: {
           schema: void 0,
           defaultError: void 0,
-          plugins: this._plugins
+          plugins: this._plugins,
+          transports: void 0
         }
       };
     }
@@ -1291,6 +1344,18 @@ var Spoosh = class _Spoosh {
   get _types() {
     return this.getInstance()._types;
   }
+  /**
+   * Map of registered transport implementations.
+   *
+   * @example
+   * ```ts
+   * const { transports } = client;
+   * const sseTransport = transports.get('sse');
+   * ```
+   */
+  get transports() {
+    return this.getInstance().transports;
+  }
 };
 
 // src/createClient.ts
@@ -1302,6 +1367,16 @@ function createClient(baseUrl, defaultOptions) {
   });
 }
 
+// src/transport/compose.ts
+function composeAdapter(baseAdapter, plugins) {
+  return plugins.reduce((adapter, plugin) => {
+    if (plugin.wrapAdapter) {
+      return plugin.wrapAdapter(adapter);
+    }
+    return adapter;
+  }, baseAdapter);
+}
+
 // src/controllers/base/controller.ts
 function createOperationController(options) {
   const {
@@ -2245,3 +2320,190 @@ function createQueueController(config, context) {
     }
   };
 }
+
+// src/controllers/subscription/controller.ts
+function createSubscriptionController(options) {
+  const {
+    channel,
+    baseAdapter,
+    pluginExecutor,
+    operationType,
+    stateManager,
+    eventEmitter,
+    queryKey,
+    path,
+    method,
+    instanceId
+  } = options;
+  const plugins = pluginExecutor.getPluginsForOperation(operationType);
+  const adapter = composeAdapter(
+    baseAdapter,
+    plugins
+  );
+  let handle = null;
+  const subscribers = /* @__PURE__ */ new Set();
+  let subscriptionVersion = 0;
+  let cachedState = {
+    data: void 0,
+    error: void 0,
+    isConnected: false
+  };
+  const updateStateFromHandle = () => {
+    if (!handle) return;
+    const newData = handle.getData();
+    const newError = handle.getError();
+    if (newData !== cachedState.data || newError !== cachedState.error) {
+      cachedState = {
+        data: newData,
+        error: newError,
+        isConnected: true
+      };
+    }
+  };
+  const notify = () => {
+    subscribers.forEach((callback) => callback());
+  };
+  const createContext = () => {
+    const baseCtx = pluginExecutor.createContext({
+      operationType,
+      path,
+      method,
+      queryKey,
+      tags: [],
+      requestTimestamp: Date.now(),
+      instanceId,
+      request: { headers: {} },
+      temp: /* @__PURE__ */ new Map(),
+      stateManager,
+      eventEmitter
+    });
+    return {
+      ...baseCtx,
+      channel
+    };
+  };
+  return {
+    subscribe: ((callbackOrVoid) => {
+      if (callbackOrVoid === void 0) {
+        subscriptionVersion++;
+        const thisVersion = subscriptionVersion;
+        if (handle) {
+          handle.unsubscribe();
+          handle = null;
+        }
+        cachedState = { data: void 0, error: void 0, isConnected: false };
+        notify();
+        const ctx = createContext();
+        ctx.onData = (data) => {
+          if (thisVersion !== subscriptionVersion) {
+            return;
+          }
+          cachedState = {
+            data,
+            error: cachedState.error,
+            isConnected: true
+          };
+          notify();
+        };
+        ctx.onError = (error) => {
+          if (thisVersion !== subscriptionVersion) {
+            return;
+          }
+          cachedState = {
+            data: cachedState.data,
+            error,
+            isConnected: cachedState.isConnected
+          };
+          notify();
+        };
+        ctx.onDisconnect = () => {
+          if (thisVersion !== subscriptionVersion) {
+            return;
+          }
+          cachedState = {
+            ...cachedState,
+            isConnected: false
+          };
+          notify();
+        };
+        return adapter.subscribe(ctx).then((newHandle) => {
+          if (thisVersion !== subscriptionVersion) {
+            newHandle.unsubscribe();
+            return newHandle;
+          }
+          handle = newHandle;
+          const handleError = newHandle.getError();
+          if (handleError) {
+            cachedState = {
+              ...cachedState,
+              error: handleError,
+              isConnected: false
+            };
+          } else {
+            updateStateFromHandle();
+            cachedState = {
+              ...cachedState,
+              isConnected: true
+            };
+          }
+          notify();
+          return handle;
+        }).catch((err) => {
+          if (thisVersion !== subscriptionVersion) {
+            return null;
+          }
+          cachedState = {
+            ...cachedState,
+            error: err,
+            isConnected: false
+          };
+          notify();
+          return null;
+        });
+      }
+      subscribers.add(callbackOrVoid);
+      return () => {
+        subscribers.delete(callbackOrVoid);
+      };
+    }),
+    emit: async (message) => {
+      const ctx = createContext();
+      ctx.message = message;
+      return adapter.emit(ctx);
+    },
+    unsubscribe: () => {
+      subscriptionVersion++;
+      if (handle) {
+        handle.unsubscribe();
+        handle = null;
+      }
+      cachedState = {
+        ...cachedState,
+        isConnected: false
+      };
+      notify();
+    },
+    getState: () => cachedState,
+    mount: () => {
+    },
+    unmount: () => {
+      subscriptionVersion++;
+      if (handle) {
+        handle.unsubscribe();
+        handle = null;
+      }
+      cachedState = {
+        ...cachedState,
+        isConnected: false
+      };
+      notify();
+    },
+    setDisconnected: () => {
+      cachedState = {
+        ...cachedState,
+        isConnected: false
+      };
+      notify();
+    }
+  };
+}