@tailorkit/app 0.1.0-beta.23 → 0.1.0-beta.24

package/dist/{chunk-7NOEYJOB.js → chunk-ANTVMHDZ.js}

@@ -25,6 +25,11 @@ function defineServer(functions) {
   return Object.freeze({ functions });
 }
 
+// src/database/definition.ts
+function defineDatabase(definition) {
+  return Object.freeze({ relations: definition.relations });
+}
+
 // src/server/builder.ts
 import { z } from "zod";
 var FunctionBuilder = class _FunctionBuilder {
@@ -32,25 +37,43 @@ var FunctionBuilder = class _FunctionBuilder {
   args;
   result;
   calls;
-  constructor(kind, args, result, calls) {
+  databaseDefinition;
+  constructor(kind, args, result, calls, database) {
     this.kind = kind;
     this.args = args;
     this.result = result;
     this.calls = calls;
+    this.databaseDefinition = database;
   }
   input(schema) {
-    return new _FunctionBuilder(this.kind, schema, this.result, this.calls);
+    return new _FunctionBuilder(this.kind, schema, this.result, this.calls, this.databaseDefinition);
   }
   output(schema) {
-    return new _FunctionBuilder(this.kind, this.args, schema, this.calls);
+    return new _FunctionBuilder(this.kind, this.args, schema, this.calls, this.databaseDefinition);
   }
   functions(functions) {
-    return new _FunctionBuilder(this.kind, this.args, this.result, functions);
+    return new _FunctionBuilder(
+      this.kind,
+      this.args,
+      this.result,
+      functions,
+      this.databaseDefinition
+    );
+  }
+  database(database) {
+    return new _FunctionBuilder(
+      this.kind,
+      this.args,
+      this.result,
+      this.calls,
+      database
+    );
   }
   handler(handler) {
     return Object.freeze({
       kind: this.kind,
       args: this.args,
+      ...this.databaseDefinition ? { database: this.databaseDefinition } : {},
       ...this.result ? { result: this.result } : {},
       ...this.kind === "action" ? { functions: this.calls } : {},
       handler: (context) => handler({ ...context, input: context.args })
@@ -173,6 +196,7 @@ export {
   mutation,
   action,
   defineServer,
+  defineDatabase,
   tk,
   withInstanceResolvers,
   table,

package/dist/{chunk-GVB2PAK7.js → chunk-DA2TE2FW.js}

@@ -10,7 +10,6 @@ var logosConfigSchema = z.object({
 var tailorkitConfigSchema = z.strictObject({
   appId: z.string().min(1).optional(),
   build: buildConfigSchema.optional(),
-  client: z.strictObject({ entry: z.string().min(1).default("src/client.ts") }).optional(),
   host: z.string().url(),
   logos: logosConfigSchema.optional(),
   server: z.strictObject({

package/dist/{chunk-DEU6RITM.js → chunk-L5ECQGR7.js}

@@ -1,6 +1,6 @@
 import {
   tailorkitConfigSchema
-} from "./chunk-GVB2PAK7.js";
+} from "./chunk-DA2TE2FW.js";
 
 // src/config/loader.ts
 import { cosmiconfig } from "cosmiconfig";
@@ -14,11 +14,6 @@ var loadTailorKitConfig = async (configPath, cwd = process.cwd()) => {
   if (result === null) {
     throw new Error(`Could not find tailorkit config from ${searchFrom}.`);
   }
-  if (result.config && typeof result.config === "object" && "storage" in result.config) {
-    throw new Error(
-      "The legacy storage configuration was removed. Use server configuration and @tailorkit/app."
-    );
-  }
   return {
     config: tailorkitConfigSchema.parse(result.config),
     filepath: result.filepath,

package/dist/chunk-LIPODQ7B.js

@@ -0,0 +1,307 @@
+import {
+  AppError,
+  appError
+} from "./chunk-IJBQ77AH.js";
+
+// src/client/connection.ts
+import { createORPCClient } from "@orpc/client";
+import { RPCLink as FetchLink } from "@orpc/client/fetch";
+import { RPCLink } from "@orpc/client/websocket";
+
+// src/client/session.ts
+var APP_SESSION_RENEWAL_MS = 6e4;
+function sessionRenewalDelay(session) {
+  return Math.max(500, session.expiresAt - Date.now() - APP_SESSION_RENEWAL_MS);
+}
+function createSessionProvider(options) {
+  const base = new URL(options.baseUrl, globalThis.location?.href);
+  if (!base.pathname.endsWith("/")) {
+    base.pathname += "/";
+  }
+  let cached;
+  let pending;
+  return (input) => {
+    if (!input.refresh && cached && cached.expiresAt > Date.now() + APP_SESSION_RENEWAL_MS) {
+      return Promise.resolve(cached);
+    }
+    pending ??= (async () => {
+      const response = await (options.fetch ?? fetch)(new URL("backend/session", base), {
+        method: "POST",
+        credentials: "same-origin",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ appId: options.appId })
+      }).catch(() => {
+        throw new AppError("UNAVAILABLE", "Unable to reach the app session provider");
+      });
+      if (!response.ok) {
+        const code = response.status === 403 ? "FORBIDDEN" : "UNAVAILABLE";
+        throw new AppError(
+          response.status === 401 ? "UNAUTHORIZED" : code,
+          "Unable to authorize the app backend"
+        );
+      }
+      const value = await response.json();
+      if (typeof value.token !== "string" || typeof value.expiresAt !== "number" || typeof value.url !== "string") {
+        throw new AppError("UNAVAILABLE", "Invalid app session");
+      }
+      cached = { token: value.token, expiresAt: value.expiresAt, url: value.url };
+      return cached;
+    })().finally(() => {
+      pending = void 0;
+    });
+    return pending;
+  };
+}
+
+// src/client/reference.ts
+function reference(name, _kind) {
+  return Object.freeze({ name });
+}
+function createApi() {
+  function group(path) {
+    return new Proxy(/* @__PURE__ */ Object.create(null), {
+      get(_target, name) {
+        if (typeof name !== "string" || name === "then") return;
+        if (name === "name" && path) return path;
+        return group(path ? `${path}.${name}` : name);
+      }
+    });
+  }
+  return group("");
+}
+
+// src/client/connection.ts
+function createClient(options = {}) {
+  let closed = false;
+  let socket;
+  let timer;
+  const stops = /* @__PURE__ */ new Set();
+  const requests = /* @__PURE__ */ new Set();
+  const getSession = options.getSession ?? ((request) => {
+    const bridge = globalThis.__tailorkitBackendSession;
+    if (!bridge) {
+      throw new AppError("UNAVAILABLE", "The host JWT bridge is unavailable");
+    }
+    return bridge(request);
+  });
+  const wire = createORPCClient(
+    new RPCLink({
+      connect: async (info) => {
+        if (closed) {
+          throw new AppError("UNAVAILABLE", "App client closed");
+        }
+        const session = await getSession({ refresh: info.totalAttempt > 1 });
+        if (closed) {
+          throw new AppError("UNAVAILABLE", "App client closed");
+        }
+        const url = backendUrl(session, "queries");
+        url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+        socket = await (options.connect ?? ((url2, protocols) => new WebSocket(url2, protocols)))(
+          url.href,
+          ["tailorkit", `jwt.${session.token}`]
+        );
+        clearTimeout(timer);
+        timer = setTimeout(
+          () => socket?.close(1e3, "Renew authentication"),
+          sessionRenewalDelay(session)
+        );
+        return socket;
+      },
+      reconnect: {
+        enabled: true,
+        delay: (info) => info.attempt === 1 ? 0 : options.retryDelayMs ?? 1e3
+      }
+    })
+  );
+  async function call(kind, input) {
+    if (closed) {
+      throw new AppError("UNAVAILABLE", "App client closed");
+    }
+    const controller = new AbortController();
+    requests.add(controller);
+    try {
+      const invocation = kind === "mutations" ? structuredClone(input) : input;
+      let attempt = 0;
+      let refresh = false;
+      let refreshed = false;
+      while (true) {
+        try {
+          if (closed) {
+            throw new AppError("UNAVAILABLE", "App client closed");
+          }
+          const session = await getSession({ refresh });
+          refresh = false;
+          if (closed) {
+            throw new AppError("UNAVAILABLE", "App client closed");
+          }
+          const url = backendUrl(session, kind);
+          url.pathname = url.pathname.slice(0, -kind.length).replace(/\/$/u, "");
+          const http = createORPCClient(
+            new FetchLink({
+              url: url.pathname,
+              origin: url.origin,
+              headers: { authorization: `Bearer ${session.token}` },
+              fetch: async (url2, init) => {
+                let response;
+                try {
+                  response = await (options.fetch ?? fetch)(url2, { ...init, credentials: "omit" });
+                } catch {
+                  throw new AppError("UNAVAILABLE", "App connection interrupted");
+                }
+                if ([502, 503, 504].includes(response.status)) {
+                  throw new AppError("UNAVAILABLE", "App backend temporarily unavailable");
+                }
+                if (kind === "mutations" && response.body) {
+                  try {
+                    return new Response(await response.arrayBuffer(), {
+                      status: response.status,
+                      headers: response.headers
+                    });
+                  } catch {
+                    throw new AppError("UNAVAILABLE", "App connection interrupted");
+                  }
+                }
+                return response;
+              }
+            })
+          );
+          if (kind === "mutations") {
+            return await http.mutations(invocation, {
+              signal: controller.signal
+            });
+          }
+          return await http[kind](invocation, { signal: controller.signal });
+        } catch (error) {
+          const failure = appError(error);
+          if (kind !== "mutations" || closed || controller.signal.aborted) {
+            throw failure;
+          }
+          if (failure.code === "UNAUTHORIZED" && !refreshed) {
+            refresh = true;
+            refreshed = true;
+            continue;
+          }
+          if (failure.code !== "UNAVAILABLE") {
+            throw failure;
+          }
+          await waitForRetry(
+            controller.signal,
+            Math.min((options.retryDelayMs ?? 1e3) * 2 ** Math.min(attempt++, 5), 3e4)
+          );
+        }
+      }
+    } catch (error) {
+      throw appError(error);
+    } finally {
+      requests.delete(controller);
+    }
+  }
+  return {
+    query: (ref, ...[args]) => call("queries", { name: ref.name, args }),
+    mutate: (ref, ...[args, settings]) => call("mutations", {
+      name: ref.name,
+      args,
+      requestId: settings?.requestId ?? crypto.randomUUID()
+    }),
+    action: (ref, ...[args]) => call("actions", { name: ref.name, args }),
+    subscribe(ref, args, next, settings = {}) {
+      if (closed) {
+        throw new AppError("UNAVAILABLE", "App client closed");
+      }
+      const controller = new AbortController();
+      const stop = () => {
+        controller.abort();
+        stops.delete(stop);
+      };
+      stops.add(stop);
+      const run = async () => {
+        while (!controller.signal.aborted) {
+          try {
+            const stream = await wire.subscribe(
+              { name: ref.name, args },
+              { signal: controller.signal }
+            );
+            for await (const value of stream) {
+              if (controller.signal.aborted || closed) {
+                break;
+              }
+              next(value);
+            }
+          } catch (error) {
+            if (controller.signal.aborted || closed) {
+              break;
+            }
+            const failure = appError(error);
+            if (!(error instanceof Error && error.name === "AbortError")) {
+              settings.onError?.(failure);
+            }
+            if (!["UNAUTHORIZED", "UNAVAILABLE", "INTERNAL_SERVER_ERROR"].includes(failure.code)) {
+              break;
+            }
+          }
+          if (!controller.signal.aborted && !closed) {
+            await waitForRetry(controller.signal, options.retryDelayMs ?? 1e3);
+          }
+        }
+        stop();
+      };
+      void run().catch((error) => {
+        stop();
+        settings.onError?.(appError(error));
+      });
+      return stop;
+    },
+    close() {
+      closed = true;
+      for (const stop of stops) {
+        stop();
+      }
+      for (const request of requests) {
+        request.abort();
+      }
+      clearTimeout(timer);
+      socket?.close();
+    }
+  };
+}
+function backendUrl(session, route) {
+  const url = new URL(session.url);
+  if (url.username || url.password || url.search || url.hash) {
+    throw new AppError("BAD_REQUEST", "Invalid app backend URL");
+  }
+  if (url.protocol === "wss:") {
+    url.protocol = "https:";
+  }
+  if (url.protocol === "ws:") {
+    url.protocol = "http:";
+  }
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))) {
+    throw new AppError("BAD_REQUEST", "App backends require HTTPS");
+  }
+  if (session.expiresAt <= Date.now() + 1e3) {
+    throw new AppError("UNAUTHORIZED", "App token expired");
+  }
+  url.pathname = `${url.pathname.replace(/\/$/u, "")}/${route}`;
+  return url;
+}
+function waitForRetry(signal, delayMs) {
+  if (signal.aborted) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => {
+    const wake = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", wake);
+      resolve();
+    };
+    const timer = setTimeout(wake, delayMs);
+    signal.addEventListener("abort", wake, { once: true });
+  });
+}
+
+export {
+  createSessionProvider,
+  reference,
+  createApi,
+  createClient
+};