@epoch32/visage 1.1.3 → 1.1.4

package/dist/index-df5e614s.js

@@ -0,0 +1,334 @@
+import {
+  RPCError2,
+  createProcedure2,
+  matchesRulePattern
+} from "./index-965ryh36.js";
+import {
+  createMutation2,
+  createQuery2
+} from "./index-y9bq7h9g.js";
+// src/rpc/client.ts
+async function resolveHeaders(headers, fullPath = "") {
+  if (!headers)
+    return {};
+  if (typeof headers === "function") {
+    return await headers();
+  }
+  const result = {};
+  for (const [key, val] of Object.entries(headers)) {
+    if (typeof val === "object" || typeof val === "function") {
+      if (matchesRulePattern(key, fullPath, fullPath)) {
+        const resolved = typeof val === "function" ? await val() : val;
+        if (resolved && typeof resolved === "object") {
+          Object.assign(result, resolved);
+        }
+      }
+    } else if (typeof val === "string") {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+function createProxyPath(options, path = []) {
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (prop === "then")
+        return;
+      if (prop === "query") {
+        return async (input, callOpts) => {
+          const fetchFn = options.fetch ?? globalThis.fetch;
+          const baseUrl = options.baseUrl.replace(/\/+$/, "");
+          const fullPath = path.join(".");
+          let url = `${baseUrl}/${fullPath}`;
+          if (input !== undefined) {
+            const serialized = JSON.stringify(input);
+            url += `${url.includes("?") ? "&" : "?"}input=${encodeURIComponent(serialized)}`;
+          }
+          const dynamicHeaders = await resolveHeaders(options.headers, fullPath);
+          const headers = {
+            Accept: "application/json",
+            ...dynamicHeaders,
+            ...callOpts?.headers
+          };
+          const devtools = typeof window !== "undefined" ? window.__VISAGE_DEVTOOLS__ : null;
+          const logId = devtools?.logRpcCall({
+            id: `rpc_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+            path: fullPath,
+            type: "query",
+            input
+          });
+          try {
+            const res = await fetchFn(url, {
+              method: "GET",
+              headers,
+              signal: callOpts?.signal
+            });
+            const body = await res.json();
+            if ("error" in body) {
+              devtools?.updateRpcCall(logId, { status: "error", error: body.error });
+              throw new RPCError2({
+                code: body.error.code,
+                message: body.error.message,
+                issues: body.error.issues
+              });
+            }
+            devtools?.updateRpcCall(logId, { status: "success", response: body.result.data });
+            return body.result.data;
+          } catch (err) {
+            devtools?.updateRpcCall(logId, { status: "error", error: err });
+            throw err;
+          }
+        };
+      }
+      if (prop === "mutate") {
+        return async (input, callOpts) => {
+          const fetchFn = options.fetch ?? globalThis.fetch;
+          const baseUrl = options.baseUrl.replace(/\/+$/, "");
+          const fullPath = path.join(".");
+          const url = `${baseUrl}/${fullPath}`;
+          const dynamicHeaders = await resolveHeaders(options.headers, fullPath);
+          const headers = {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            ...dynamicHeaders,
+            ...callOpts?.headers
+          };
+          const devtools = typeof window !== "undefined" ? window.__VISAGE_DEVTOOLS__ : null;
+          const logId = devtools?.logRpcCall({
+            id: `rpc_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+            path: fullPath,
+            type: "mutation",
+            input
+          });
+          try {
+            const res = await fetchFn(url, {
+              method: "POST",
+              headers,
+              body: JSON.stringify({ input }),
+              signal: callOpts?.signal
+            });
+            const body = await res.json();
+            if ("error" in body) {
+              devtools?.updateRpcCall(logId, { status: "error", error: body.error });
+              throw new RPCError2({
+                code: body.error.code,
+                message: body.error.message,
+                issues: body.error.issues
+              });
+            }
+            devtools?.updateRpcCall(logId, { status: "success", response: body.result.data });
+            return body.result.data;
+          } catch (err) {
+            devtools?.updateRpcCall(logId, { status: "error", error: err });
+            throw err;
+          }
+        };
+      }
+      if (prop === "subscribe") {
+        return (input, callbacks) => {
+          const fetchFn = options.fetch ?? globalThis.fetch;
+          const baseUrl = options.baseUrl.replace(/\/+$/, "");
+          const fullPath = path.join(".");
+          let url = `${baseUrl}/${fullPath}`;
+          if (input !== undefined) {
+            const serialized = JSON.stringify(input);
+            url += `${url.includes("?") ? "&" : "?"}input=${encodeURIComponent(serialized)}`;
+          }
+          const controller = new AbortController;
+          const devtools = typeof window !== "undefined" ? window.__VISAGE_DEVTOOLS__ : null;
+          const logId = devtools?.logRpcCall({
+            id: `rpc_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+            path: fullPath,
+            type: "subscription",
+            input
+          });
+          (async () => {
+            try {
+              const dynamicHeaders = await resolveHeaders(options.headers, fullPath);
+              const headers = {
+                Accept: "text/event-stream",
+                ...dynamicHeaders
+              };
+              const res = await fetchFn(url, {
+                method: "GET",
+                headers,
+                signal: controller.signal
+              });
+              if (!res.ok || !res.body) {
+                throw new Error(`Subscription connection failed with status ${res.status}`);
+              }
+              const reader = res.body.getReader();
+              const decoder = new TextDecoder;
+              let buffer = "";
+              while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                  break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split(`
+
+`);
+                buffer = lines.pop() ?? "";
+                for (const line of lines) {
+                  const trimmed = line.trim();
+                  if (trimmed.startsWith("data:")) {
+                    const jsonStr = trimmed.slice(5).trim();
+                    try {
+                      const parsed = JSON.parse(jsonStr);
+                      devtools?.logRpcEvent(logId, parsed);
+                      callbacks.onData(parsed);
+                    } catch (parseErr) {
+                      devtools?.updateRpcCall(logId, { status: "error", error: parseErr });
+                      callbacks.onError?.(parseErr);
+                    }
+                  } else if (trimmed.startsWith("event: error")) {
+                    devtools?.updateRpcCall(logId, { status: "error" });
+                    callbacks.onError?.(new Error("Server event stream error"));
+                  }
+                }
+              }
+              callbacks.onComplete?.();
+            } catch (err) {
+              if (!controller.signal.aborted) {
+                callbacks.onError?.(err);
+              }
+            }
+          })();
+          return {
+            unsubscribe: () => {
+              controller.abort();
+            }
+          };
+        };
+      }
+      if (prop === "queryKey") {
+        return (input) => {
+          const resolvedInput = typeof input === "function" ? input() : input;
+          const key = [...path];
+          if (resolvedInput !== undefined) {
+            key.push(resolvedInput);
+          }
+          return key;
+        };
+      }
+      if (prop === "queryOptions") {
+        return (input, extra) => {
+          const resolvedInput = typeof input === "function" ? input() : input;
+          const key = [...path];
+          if (resolvedInput !== undefined) {
+            key.push(resolvedInput);
+          }
+          return {
+            queryKey: key,
+            queryFn: ({ signal }) => {
+              const queryFn = createProxyPath(options, path).query;
+              return queryFn(resolvedInput, { signal });
+            },
+            ...extra
+          };
+        };
+      }
+      if (prop === "createQuery" || prop === "useQuery") {
+        return (input, extra) => {
+          const proxy = createProxyPath(options, path);
+          return createQuery2(() => proxy.queryOptions(input, extra));
+        };
+      }
+      if (prop === "mutationKey") {
+        return () => [...path];
+      }
+      if (prop === "mutationOptions") {
+        return (extra) => {
+          return {
+            mutationKey: [...path],
+            mutationFn: (input) => {
+              const mutateFn = createProxyPath(options, path).mutate;
+              return mutateFn(input);
+            },
+            ...extra
+          };
+        };
+      }
+      if (prop === "createMutation" || prop === "useMutation") {
+        return (extra) => {
+          const proxy = createProxyPath(options, path);
+          return createMutation2(proxy.mutationOptions(extra));
+        };
+      }
+      return createProxyPath(options, [...path, prop]);
+    }
+  });
+}
+function createClient2(options) {
+  return createProxyPath(options, []);
+}
+// src/rpc/router.ts
+class RouterImpl2 {
+  _def;
+  constructor(record = {}, middlewares = []) {
+    this._def = {
+      record: { ...record },
+      middlewares: [...middlewares]
+    };
+  }
+  query(name, options) {
+    const proc = createProcedure2("query", options, this._def.middlewares);
+    const newRecord = {
+      ...this._def.record,
+      [name]: proc
+    };
+    return new RouterImpl2(newRecord, this._def.middlewares);
+  }
+  mutation(name, options) {
+    const proc = createProcedure2("mutation", options, this._def.middlewares);
+    const newRecord = {
+      ...this._def.record,
+      [name]: proc
+    };
+    return new RouterImpl2(newRecord, this._def.middlewares);
+  }
+  subscription(name, options) {
+    const proc = createProcedure2("subscription", options, this._def.middlewares);
+    const newRecord = {
+      ...this._def.record,
+      [name]: proc
+    };
+    return new RouterImpl2(newRecord, this._def.middlewares);
+  }
+  use(middleware) {
+    const updatedMiddlewares = [...this._def.middlewares, middleware];
+    const updatedRecord = {};
+    for (const key in this._def.record) {
+      const item = this._def.record[key];
+      if ("type" in item) {
+        updatedRecord[key] = {
+          ...item,
+          middlewares: [...updatedMiddlewares]
+        };
+      } else {
+        updatedRecord[key] = item;
+      }
+    }
+    return new RouterImpl2(updatedRecord, updatedMiddlewares);
+  }
+  merge(prefix, router) {
+    const newRecord = {
+      ...this._def.record,
+      [prefix]: router
+    };
+    return new RouterImpl2(newRecord, this._def.middlewares);
+  }
+}
+function createRouter2(record) {
+  return new RouterImpl2(record ?? {});
+}
+function query3(options) {
+  return createProcedure2("query", options);
+}
+function mutation3(options) {
+  return createProcedure2("mutation", options);
+}
+function subscription3(options) {
+  return createProcedure2("subscription", options);
+}
+export { createClient2, RouterImpl2, createRouter2, query3, mutation3, subscription3 };