@tailorkit/app 0.1.0-beta.29 → 0.1.0-beta.32

package/dist/{chunk-ANTVMHDZ.js → chunk-YX3JURMG.js}

@@ -1,34 +1,26 @@
 import {
   AppError
-} from "./chunk-IJBQ77AH.js";
+} from "./chunk-7ZQPXG7O.js";
 
 // src/server/functions.ts
-function query(definition) {
-  return Object.freeze({ ...definition, kind: "query" });
-}
-function mutation(definition) {
-  return Object.freeze({ ...definition, kind: "mutation" });
-}
-function action(definition) {
-  return Object.freeze({ ...definition, kind: "action" });
-}
-function isFunction(value) {
-  return typeof value.kind === "string" && typeof value.handler === "function";
-}
-function defineServer(functions) {
+var query = (definition) => Object.freeze({ ...definition, kind: "query" });
+var mutation = (definition) => Object.freeze({ ...definition, kind: "mutation" });
+var action = (definition) => Object.freeze({ ...definition, kind: "action" });
+var isFunction = (value) => typeof value.kind === "string" && typeof value.handler === "function";
+var defineServer = (functions) => {
   for (const [name, value] of Object.entries(functions)) {
     if (!/^[a-zA-Z][a-zA-Z0-9_]{0,63}$/u.test(name)) {
       throw new Error("Invalid function name");
     }
-    if (!isFunction(value)) defineServer(value);
+    if (!isFunction(value)) {
+      defineServer(value);
+    }
   }
   return Object.freeze({ functions });
-}
+};
 
 // src/database/definition.ts
-function defineDatabase(definition) {
-  return Object.freeze({ relations: definition.relations });
-}
+var defineDatabase = (definition) => Object.freeze({ relations: definition.relations });
 
 // src/server/builder.ts
 import { z } from "zod";
@@ -46,10 +38,22 @@ var FunctionBuilder = class _FunctionBuilder {
     this.databaseDefinition = database;
   }
   input(schema) {
-    return new _FunctionBuilder(this.kind, schema, this.result, this.calls, this.databaseDefinition);
+    return new _FunctionBuilder(
+      this.kind,
+      schema,
+      this.result,
+      this.calls,
+      this.databaseDefinition
+    );
   }
   output(schema) {
-    return new _FunctionBuilder(this.kind, this.args, schema, this.calls, this.databaseDefinition);
+    return new _FunctionBuilder(
+      this.kind,
+      this.args,
+      schema,
+      this.calls,
+      this.databaseDefinition
+    );
   }
   functions(functions) {
     return new _FunctionBuilder(
@@ -70,43 +74,67 @@ var FunctionBuilder = class _FunctionBuilder {
     );
   }
   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 })
-    });
+    const metadata = {};
+    if (this.databaseDefinition) {
+      metadata.database = this.databaseDefinition;
+    }
+    if (this.result) {
+      metadata.result = this.result;
+    }
+    if (this.kind === "action") {
+      metadata.functions = this.calls;
+    }
+    return (
+      /* oxlint-disable typescript/no-unsafe-type-assertion, anti-slop/no-chained-type-assertions -- This builder or fixture preserves the declared capabilities across an erased generic boundary. */
+      Object.freeze({
+        ...metadata,
+        args: this.args,
+        handler: (context) => (
+          // SAFETY: The adapter reconstructs the same runtime contract, but TypeScript cannot relate the erased generic parameters across this library boundary.
+          // oxlint-disable-next-line anti-slop/no-chained-type-assertions -- The adapter reconstructs the same runtime contract, but TypeScript cannot relate the erased generic parameters across this library boundary.
+          handler({
+            ...context,
+            input: context.args
+          })
+        ),
+        kind: this.kind
+      })
+    );
   }
 };
-var tk = Object.freeze({
-  query: new FunctionBuilder("query", z.undefined(), void 0, {}),
+var fn = Object.freeze({
+  action: new FunctionBuilder("action", z.undefined(), void 0, {}),
   mutation: new FunctionBuilder("mutation", z.undefined(), void 0, {}),
-  action: new FunctionBuilder("action", z.undefined(), void 0, {})
+  query: new FunctionBuilder("query", z.undefined(), void 0, {})
 });
 
 // src/server/instances.ts
 import { z as z2 } from "zod";
 var addressSchema = z2.object({
-  slot: z2.string().min(1).max(255),
-  path: z2.string().startsWith("/").max(1024)
+  path: z2.string().startsWith("/").max(1024),
+  slot: z2.string().min(1).max(255)
 });
-function registeredQueries(functions) {
+var registeredQueries = (functions) => {
   const queries = {};
-  for (const [name, fn] of Object.entries(functions)) {
-    if (isFunction(fn)) {
-      if (fn.kind === "query") queries[name] = fn;
+  for (const [name, fn2] of Object.entries(functions)) {
+    if (isFunction(fn2)) {
+      if (fn2.kind === "query") {
+        queries[name] = fn2;
+      }
     } else {
-      const nested = registeredQueries(fn);
-      if (Object.keys(nested).length) queries[name] = nested;
+      const nested = registeredQueries(fn2);
+      if (Object.keys(nested).length) {
+        queries[name] = nested;
+      }
     }
   }
   return queries;
-}
-function withInstanceResolvers(app, resolvers) {
+};
+var withInstanceResolvers = (app, resolvers) => {
   if (Object.hasOwn(app.functions, "_tailorkit")) {
-    throw new Error("The _tailorkit function namespace is reserved by TailorKit.");
+    throw new Error(
+      "The _tailorkit function namespace is reserved by TailorKit."
+    );
   }
   const queries = registeredQueries(app.functions);
   const registry = /* @__PURE__ */ new Map();
@@ -124,30 +152,42 @@ function withInstanceResolvers(app, resolvers) {
     }
     const result = z2.array(
       z2.object({
+        data: resolver.dataSchema,
         key: z2.string().min(1),
-        metadata: z2.record(z2.string(), z2.unknown()),
-        data: resolver.dataSchema
+        metadata: z2.record(z2.string(), z2.unknown())
       })
-    ).refine((items) => new Set(items.map((item) => item.key)).size === items.length, {
-      message: "Instance keys must be unique"
-    });
+    ).refine(
+      (items) => new Set(items.map((item) => item.key)).size === items.length,
+      {
+        message: "Instance keys must be unique"
+      }
+    );
     paths.set(resolver.path, { resolver, result });
   }
   const instances = {
     resolve: action({
+      args: addressSchema.extend({
+        context: z2.record(z2.string(), z2.unknown())
+      }),
       functions: queries,
-      args: addressSchema.extend({ context: z2.record(z2.string(), z2.unknown()) }),
-      async handler({ args, identity, signal, queries: queries2 }) {
+      handler: async ({ args, identity, signal, queries: queriesValue }) => {
         const entry = registry.get(args.slot)?.get(args.path);
-        if (!entry) throw new AppError("NOT_FOUND", "Instance resolver not found");
+        if (!entry) {
+          throw new AppError("NOT_FOUND", "Instance resolver not found");
+        }
         const value = await entry.resolver.resolve({
           context: args.context,
           identity,
-          signal,
-          queries: queries2
+          queries: queriesValue,
+          signal
         });
         const result = entry.result.safeParse(value);
-        if (!result.success) throw new AppError("INTERNAL_SERVER_ERROR", "Invalid function result");
+        if (!result.success) {
+          throw new AppError(
+            "INTERNAL_SERVER_ERROR",
+            "Invalid function result"
+          );
+        }
         return result.data;
       }
     })
@@ -156,7 +196,7 @@ function withInstanceResolvers(app, resolvers) {
   return Object.freeze({
     functions: { ...app.functions, _tailorkit: internal.functions }
   });
-}
+};
 
 // src/database/schema.ts
 import {
@@ -181,11 +221,12 @@ import {
   isNotNull,
   inArray
 } from "drizzle-orm";
-function table(name, columns) {
-  if (!/^[a-zA-Z][a-zA-Z0-9_]{0,62}$/u.test(name) || name.startsWith("sqlite_") || name.startsWith("tailorkit_"))
+var table = (name, columns) => {
+  if (!/^[a-zA-Z][a-zA-Z0-9_]{0,62}$/u.test(name) || name.startsWith("sqlite_") || name.startsWith("tailorkit_")) {
     throw new Error("Invalid or reserved table name");
+  }
   return sqliteTable(name, columns);
-}
+};
 var text = (name = "") => sqliteText(name);
 var integer = (name = "") => sqliteInteger(name);
 var real = (name = "") => sqliteReal(name);
@@ -197,7 +238,7 @@ export {
   action,
   defineServer,
   defineDatabase,
-  tk,
+  fn,
   withInstanceResolvers,
   table,
   text,

package/dist/client/connection.d.ts

@@ -1,10 +1,10 @@
-import { AppError } from "../errors";
+import { AppError } from "#errors";
 import type { Reference } from "./reference";
 import type { Session } from "./session";
 export type { Session } from "./session";
 export { reference } from "./reference";
 export type { Reference, References } from "./reference";
-export { AppError } from "../errors";
+export { AppError } from "#errors";
 type InputArguments<I> = undefined extends I ? [args?: I] : [args: I];
 type MutationArguments<I> = undefined extends I ? [args?: I, options?: {
     requestId?: string;
@@ -12,20 +12,20 @@ type MutationArguments<I> = undefined extends I ? [args?: I, options?: {
     requestId?: string;
 }];
 export interface Client {
-    query<I, O>(reference: Reference<"query", I, O>, ...args: InputArguments<NoInfer<I>>): Promise<O>;
-    mutate<I, O>(reference: Reference<"mutation", I, O>, ...args: MutationArguments<NoInfer<I>>): Promise<O>;
-    action<I, O>(reference: Reference<"action", I, O>, ...args: InputArguments<NoInfer<I>>): Promise<O>;
-    subscribe<I, O>(reference: Reference<"query", I, O>, args: NoInfer<I>, next: (value: O) => void, options?: {
+    query: <I, O>(reference: Reference<"query", I, O>, ...args: InputArguments<NoInfer<I>>) => Promise<O>;
+    mutate: <I, O>(reference: Reference<"mutation", I, O>, ...args: MutationArguments<NoInfer<I>>) => Promise<O>;
+    action: <I, O>(reference: Reference<"action", I, O>, ...args: InputArguments<NoInfer<I>>) => Promise<O>;
+    subscribe: <I, O>(reference: Reference<"query", I, O>, args: NoInfer<I>, next: (value: O) => void, options?: {
         onError?: (error: AppError) => void;
-    }): () => void;
-    close(): void;
+    }) => () => void;
+    close: () => void;
 }
-export declare function createClient(options?: {
+export declare const createClient: (options?: {
     getSession?: (options: {
         refresh: boolean;
     }) => Promise<Session>;
     connect?: (url: string, protocols: string[]) => WebSocket | Promise<WebSocket>;
     fetch?: typeof fetch;
     retryDelayMs?: number;
-}): Client;
-export { createSessionProvider } from "./session";
+}) => Client;
+export { createSessionProvider, parseSession } from "./session";

package/dist/client/query-store.d.ts

@@ -1,13 +1,13 @@
+import type { AppError } from "#errors";
 import type { Client } from "./connection";
 import type { Reference } from "./reference";
-import type { AppError } from "../errors";
 export interface QueryState<T> {
     data: T | undefined;
     error: AppError | null;
     status: "pending" | "success" | "error";
 }
 export declare const pendingQuery: QueryState<never>;
-export declare function serializeInput(input: unknown): string;
+export declare const serializeInput: (input: unknown) => string;
 /** One subscription per active query/input pair, scoped to this provider's client. */
 export declare class QueryStore {
     readonly state: import("nanostores").PreinitializedWritableAtom<Map<string, QueryState<unknown>>> & object;

package/dist/client/reference.d.ts

@@ -1,5 +1,5 @@
 import type { z } from "zod";
-import type { FunctionResult, Functions } from "../server/functions";
+import type { FunctionResult, Functions } from "#server/functions";
 export interface Reference<K extends "query" | "mutation" | "action", I, O> {
     readonly name: string;
     readonly $types?: {
@@ -8,13 +8,13 @@ export interface Reference<K extends "query" | "mutation" | "action", I, O> {
         output: O;
     };
 }
-export declare function reference<K extends "query" | "mutation" | "action", I, O>(name: string, _kind: K): Reference<K, I, O>;
+export declare const reference: <K extends "query" | "mutation" | "action", I, O>(name: string, _kind: K) => Reference<K, I, O>;
 export type References<F> = {
     readonly [N in keyof F]: F[N] extends {
         kind: infer K extends "query" | "mutation" | "action";
         args: infer A extends z.ZodType;
-        handler: (...args: never[]) => unknown;
+        handler: (...args: never[]) => infer _Output;
     } ? Reference<K, z.input<A>, FunctionResult<F[N]>> : F[N] extends Functions ? References<F[N]> : never;
 };
 /** Browser references inferred directly from the server's exported function type. */
-export declare function createApi<F extends Functions>(): References<F>;
+export declare const createApi: <F extends Functions>() => References<F>;

package/dist/client/session.d.ts

@@ -1,4 +1,26 @@
-import type { Identity } from "../server/functions";
+import { z } from "zod";
+import type { Identity } from "#server/functions";
+declare const sessionSchema: z.ZodObject<{
+    expiresAt: z.ZodNumber;
+    identity: z.ZodOptional<z.ZodObject<{
+        appId: z.ZodString;
+        deploymentId: z.ZodString;
+        expiresAt: z.ZodNumber;
+        installationId: z.ZodString;
+        projectId: z.ZodString;
+        scope: z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        }, z.core.$strip>;
+        subjectId: z.ZodOptional<z.ZodString>;
+        toolUrl: z.ZodString;
+    }, z.core.$strip>>;
+    subjectId: z.ZodOptional<z.ZodString>;
+    token: z.ZodString;
+    toolUrl: z.ZodOptional<z.ZodString>;
+    url: z.ZodString;
+}, z.core.$strip>;
+export declare const parseSession: (value: Parameters<typeof sessionSchema.parse>[0]) => Session;
 export interface Session {
     toolUrl?: string;
     identity?: Identity;
@@ -7,12 +29,13 @@ export interface Session {
     expiresAt: number;
     url: string;
 }
-export declare function sessionRenewalDelay(session: Session): number;
+export declare const sessionRenewalDelay: (session: Session) => number;
 /** Host-owned provider: project credentials never cross into the sandbox. */
-export declare function createSessionProvider(options: {
+export declare const createSessionProvider: (options: {
     baseUrl: string | URL;
     appId: string;
     fetch?: typeof fetch;
-}): (input: {
+}) => (input: {
     refresh: boolean;
 }) => Promise<Session>;
+export {};

package/dist/client/tools.d.ts

@@ -1,10 +1,16 @@
 import type { Session } from "./session";
-export interface ToolBridge {
-    client(path: string, input: unknown): Promise<unknown>;
-    session(path: string): Promise<Session>;
+export interface ToolBridge<TInput = unknown, TOutput = unknown> {
+    client: (path: string, input: TInput) => Promise<TOutput>;
+    session: (path: string) => Promise<Session>;
+}
+declare global {
+    var __tailorkitTools: ToolBridge | undefined;
+    var __tailorkitBackendSession: ((options: {
+        refresh: boolean;
+    }) => Promise<Session>) | undefined;
 }
 export interface TailorKitServerTools {
 }
+export declare const executeServerTool: (session: Session, path: string, input: unknown, request?: typeof fetch, signal?: AbortSignal) => Promise<unknown>;
 /** Generated callers delegate only transport; host/server declarations validate both directions. */
-export declare function callTool(kind: "client" | "server", path: string, input?: unknown): Promise<unknown>;
-export declare function executeServerTool(session: Session, path: string, input: unknown, request?: typeof fetch, signal?: AbortSignal): Promise<unknown>;
+export declare const callTool: (kind: "client" | "server", path: string, input?: Parameters<ToolBridge["client"]>[1]) => ReturnType<ToolBridge["client"]>;

package/dist/client-connection.js

@@ -1,14 +1,16 @@
 import {
   createClient,
   createSessionProvider,
+  parseSession,
   reference
-} from "./chunk-SWBQZDWT.js";
+} from "./chunk-PJBDA2RU.js";
 import {
   AppError
-} from "./chunk-IJBQ77AH.js";
+} from "./chunk-7ZQPXG7O.js";
 export {
   AppError,
   createClient,
   createSessionProvider,
+  parseSession,
   reference
 };

package/dist/client.d.ts

@@ -2,9 +2,9 @@ export * from "./views";
 export * from "./preact";
 export { defineRoute, Route, createFileClient } from "./routing";
 export type { RouteDefinition, ShellProps } from "./routing";
-export { createClient, createSessionProvider, reference } from "./client/connection";
+export { createClient, createSessionProvider, reference, } from "./client/connection";
 export { createApi } from "./client/reference";
-export type { Client, Session, Reference, References } from "./client/connection";
+export type { Client, Session, Reference, References, } from "./client/connection";
 export { AppError, appError } from "./errors";
 export type { ErrorCode } from "./errors";
 export { callTool } from "./client/tools";

package/dist/client.js

@@ -9,17 +9,17 @@ import {
   useAction,
   useMutation,
   useQuery
-} from "./chunk-STTKSRAI.js";
+} from "./chunk-UDXPIO6D.js";
 import {
   createApi,
   createClient,
   createSessionProvider,
   reference
-} from "./chunk-SWBQZDWT.js";
+} from "./chunk-PJBDA2RU.js";
 import {
   AppError,
   appError
-} from "./chunk-IJBQ77AH.js";
+} from "./chunk-7ZQPXG7O.js";
 export {
   AppError,
   ClientProvider,

package/dist/database/definition.d.ts

@@ -3,6 +3,6 @@ export interface DatabaseDefinition<R extends AnyRelations = AnyRelations> {
     readonly relations: R;
 }
 /** Configure the installation database with Drizzle relations, which also contain its tables. */
-export declare function defineDatabase<const R extends AnyRelations>(definition: DatabaseDefinition<R>): Readonly<{
+export declare const defineDatabase: <const R extends AnyRelations>(definition: DatabaseDefinition<R>) => Readonly<{
     relations: R;
 }>;

package/dist/database/schema.d.ts

@@ -1,5 +1,5 @@
 import type { ColumnBuilderBase } from "drizzle-orm";
-export declare function table<N extends string, C extends Record<string, ColumnBuilderBase>>(name: N, columns: C): import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+export declare const table: <N extends string, C extends Record<string, ColumnBuilderBase>>(name: N, columns: C) => import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
     name: N;
     schema: undefined;
     columns: { [Key in keyof C]: import("drizzle-orm/sqlite-core").SQLiteColumn<{

package/dist/errors.d.ts

@@ -3,4 +3,4 @@ export declare class AppError extends Error {
     readonly code: ErrorCode;
     constructor(code: ErrorCode, message?: string);
 }
-export declare function appError(error: unknown): AppError;
+export declare const appError: (cause: unknown) => AppError;

package/dist/index.js

@@ -9,13 +9,13 @@ import {
   useAction,
   useMutation,
   useQuery
-} from "./chunk-STTKSRAI.js";
+} from "./chunk-UDXPIO6D.js";
 import {
   createApi,
   createClient,
   createSessionProvider,
   reference
-} from "./chunk-SWBQZDWT.js";
+} from "./chunk-PJBDA2RU.js";
 import {
   action,
   and,
@@ -26,6 +26,7 @@ import {
   defineServer,
   desc,
   eq,
+  fn,
   gt,
   gte,
   inArray,
@@ -41,13 +42,12 @@ import {
   real,
   table,
   text,
-  tk,
   withInstanceResolvers
-} from "./chunk-ANTVMHDZ.js";
+} from "./chunk-YX3JURMG.js";
 import {
   AppError,
   appError
-} from "./chunk-IJBQ77AH.js";
+} from "./chunk-7ZQPXG7O.js";
 export {
   AppError,
   ClientProvider,
@@ -70,6 +70,7 @@ export {
   defineView,
   desc,
   eq,
+  fn,
   gt,
   gte,
   inArray,
@@ -86,7 +87,6 @@ export {
   reference,
   table,
   text,
-  tk,
   useAction,
   useMutation,
   useQuery,

package/dist/preact.d.ts

@@ -1,8 +1,8 @@
 import type { ComponentChildren } from "preact";
 import type { Client } from "./client/connection";
-import type { Reference } from "./client/reference";
 import { QueryStore } from "./client/query-store";
 import type { QueryState } from "./client/query-store";
+import type { Reference } from "./client/reference";
 import type { AppError } from "./errors";
 export interface ClientProviderProps {
     children?: ComponentChildren;
@@ -10,7 +10,7 @@ export interface ClientProviderProps {
     client?: Client;
     onError?: (error: AppError) => void;
 }
-export declare function ClientProvider({ children, client, onError }: ClientProviderProps): import("preact").VNode<import("preact").Attributes & {
+export declare const ClientProvider: ({ children, client, onError, }: ClientProviderProps) => import("preact").VNode<import("preact").Attributes & {
     value: QueryStore | null;
     children?: ComponentChildren;
 }>;
@@ -25,7 +25,7 @@ export interface QueryResult<T> extends QueryState<T> {
     isSuccess: boolean;
     isError: boolean;
 }
-export declare function useQuery<I, O>(ref: Reference<"query", I, O>, ...[input, options]: QueryArguments<NoInfer<I>>): QueryResult<O>;
+export declare const useQuery: <I, O>(ref: Reference<"query", I, O>, ...[input, options]: QueryArguments<NoInfer<I>>) => QueryResult<O>;
 export interface CallOptions<I, O> {
     onSuccess?: (data: O, input: I) => void;
     onError?: (error: AppError, input: I) => void;
@@ -43,10 +43,10 @@ export interface MutationResult<I, O> extends CallState<O> {
     mutate: (...args: InputArguments<I>) => void;
     mutateAsync: (...args: InputArguments<I>) => Promise<O>;
 }
-export declare function useMutation<I, O>(ref: Reference<"mutation", I, O>, options?: CallOptions<I, O>): MutationResult<I, O>;
+export declare const useMutation: <I, O>(ref: Reference<"mutation", I, O>, options?: CallOptions<I, O>) => MutationResult<I, O>;
 export interface ActionResult<I, O> extends CallState<O> {
     execute: (...args: InputArguments<I>) => void;
     executeAsync: (...args: InputArguments<I>) => Promise<O>;
 }
-export declare function useAction<I, O>(ref: Reference<"action", I, O>, options?: CallOptions<I, O>): ActionResult<I, O>;
+export declare const useAction: <I, O>(ref: Reference<"action", I, O>, options?: CallOptions<I, O>) => ActionResult<I, O>;
 export {};