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

package/dist/index.js

@@ -1,79 +1,94 @@
-// src/index.ts
-import { createContext, h, render } from "preact";
-import { useContext } from "preact/hooks";
-var preactVersion = "10.29.8";
-var createScreen = (path, options) => {
-  const Context = createContext(null);
-  const Screen = (props) => {
-    if (props.status === "loading") {
-      return options.loading ? h(options.loading, {}) : null;
-    }
-    if (props.status === "error") {
-      return options.error ? h(options.error, {}) : null;
-    }
-    return h(
-      Context.Provider,
-      { value: props.context },
-      h(options.component, {})
-    );
-  };
-  return {
-    component: Screen,
-    path,
-    useContext: () => {
-      const context = useContext(Context);
-      if (context === null) {
-        throw new Error(`Screen context is only available while rendering "${path}".`);
-      }
-      return context;
-    }
-  };
-};
-var defineClient = (client) => ({
-  ...client,
-  $meta: {
-    preactVersion
-  },
-  $runtime: {
-    h,
-    render
-  }
-});
-var componentTagPrefix = "tailorkit-";
-var toComponentTagName = (name) => `${componentTagPrefix}${name.replaceAll(/([a-z0-9])([A-Z])/gu, "$1-$2").replaceAll(/[\s_]+/gu, "-").toLowerCase()}`;
-var toCallbackEventName = (name) => `tailorkitcallback${name.replaceAll(/[^A-Za-z0-9_$]/gu, "").toLowerCase()}`;
-var toEventProp = (event) => `on${event}`;
-var createRemoteComponent = (name, options) => {
-  const tagName = toComponentTagName(name);
-  const callbacks = options.callbacks;
-  if (!callbacks || Object.keys(callbacks).length === 0) {
-    return function RemoteComponent({ children, ...props }) {
-      return h(tagName, props, children);
-    };
-  }
-  return function RemoteComponent({ children, ...props }) {
-    const nextProps = { ...props };
-    const callbackMap = {};
-    for (const [key, inputCount] of Object.entries(callbacks)) {
-      const callback = nextProps[key];
-      Reflect.deleteProperty(nextProps, key);
-      if (typeof callback !== "function") {
-        continue;
-      }
-      const eventName = toCallbackEventName(key);
-      callbackMap[eventName] = { callback: key, inputCount };
-      nextProps[toEventProp(eventName)] = (event) => {
-        callback(...(event.detail ?? []).slice(0, inputCount));
-      };
-    }
-    if (Object.keys(callbackMap).length > 0) {
-      nextProps["data-tailorkit-callbacks"] = JSON.stringify(callbackMap);
-    }
-    return h(tagName, nextProps, children);
-  };
-};
+import {
+  ClientProvider,
+  Route,
+  callTool,
+  createFileClient,
+  createRemoteComponent,
+  defineRoute,
+  defineView,
+  useAction,
+  useMutation,
+  useQuery
+} from "./chunk-UDXPIO6D.js";
+import {
+  createApi,
+  createClient,
+  createSessionProvider,
+  reference
+} from "./chunk-PJBDA2RU.js";
+import {
+  action,
+  and,
+  asc,
+  boolean,
+  count,
+  defineDatabase,
+  defineServer,
+  desc,
+  eq,
+  fn,
+  gt,
+  gte,
+  inArray,
+  integer,
+  isNotNull,
+  isNull,
+  lt,
+  lte,
+  mutation,
+  ne,
+  or,
+  query,
+  real,
+  table,
+  text,
+  withInstanceResolvers
+} from "./chunk-YX3JURMG.js";
+import {
+  AppError,
+  appError
+} from "./chunk-7ZQPXG7O.js";
 export {
+  AppError,
+  ClientProvider,
+  Route,
+  action,
+  and,
+  appError,
+  asc,
+  boolean,
+  callTool,
+  count,
+  createApi,
+  createClient,
+  createFileClient,
   createRemoteComponent,
-  createScreen,
-  defineClient
+  createSessionProvider,
+  defineDatabase,
+  defineRoute,
+  defineServer,
+  defineView,
+  desc,
+  eq,
+  fn,
+  gt,
+  gte,
+  inArray,
+  integer,
+  isNotNull,
+  isNull,
+  lt,
+  lte,
+  mutation,
+  ne,
+  or,
+  query,
+  real,
+  reference,
+  table,
+  text,
+  useAction,
+  useMutation,
+  useQuery,
+  withInstanceResolvers
 };

package/dist/preact.d.ts

@@ -0,0 +1,52 @@
+import type { ComponentChildren } from "preact";
+import type { Client } from "./client/connection";
+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;
+    /** Supply a client for custom transport configuration. Caller-owned clients are not closed. */
+    client?: Client;
+    onError?: (error: AppError) => void;
+}
+export declare const ClientProvider: ({ children, client, onError, }: ClientProviderProps) => import("preact").VNode<import("preact").Attributes & {
+    value: QueryStore | null;
+    children?: ComponentChildren;
+}>;
+export interface QueryOptions {
+    enabled?: boolean;
+}
+type InputArguments<I> = undefined extends I ? [input?: I] : [input: I];
+type QueryArguments<I> = undefined extends I ? [input?: I, options?: QueryOptions] : [input: I, options?: QueryOptions];
+export interface QueryResult<T> extends QueryState<T> {
+    isPending: boolean;
+    isLoading: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+}
+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;
+}
+export interface CallState<T> {
+    data: T | undefined;
+    error: AppError | null;
+    status: "idle" | "pending" | "success" | "error";
+    isPending: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+    reset: () => void;
+}
+export interface MutationResult<I, O> extends CallState<O> {
+    mutate: (...args: InputArguments<I>) => void;
+    mutateAsync: (...args: InputArguments<I>) => Promise<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 const useAction: <I, O>(ref: Reference<"action", I, O>, options?: CallOptions<I, O>) => ActionResult<I, O>;
+export {};

package/dist/protocol.d.ts

@@ -0,0 +1,74 @@
+import type { ContractRouterClient } from "@orpc/contract";
+import { z } from "zod";
+export declare const invocationSchema: z.ZodObject<{
+    args: z.ZodOptional<z.ZodUnknown>;
+    name: z.ZodString;
+}, z.core.$strict>;
+export type Invocation = z.infer<typeof invocationSchema>;
+export type MutationInvocation = Invocation & {
+    requestId: string;
+};
+/** Public wire contract; implementations and clients both depend on this definition. */
+export declare const appContract: {
+    actions: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<z.ZodObject<{
+        args: z.ZodOptional<z.ZodUnknown>;
+        name: z.ZodString;
+    }, z.core.$strict>, import("@orpc/contract").Schema<unknown, unknown>, {
+        BAD_REQUEST: {};
+        CONFLICT: {};
+        FORBIDDEN: {};
+        INCOMPATIBLE_VERSION: {};
+        INTERNAL_SERVER_ERROR: {};
+        NOT_FOUND: {};
+        UNAUTHORIZED: {};
+        UNAVAILABLE: {};
+    }>;
+    mutations: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<z.ZodObject<{
+        args: z.ZodOptional<z.ZodUnknown>;
+        name: z.ZodString;
+        requestId: z.ZodUUID;
+    }, z.core.$strict>, import("@orpc/contract").Schema<unknown, unknown>, {
+        BAD_REQUEST: {};
+        CONFLICT: {};
+        FORBIDDEN: {};
+        INCOMPATIBLE_VERSION: {};
+        INTERNAL_SERVER_ERROR: {};
+        NOT_FOUND: {};
+        UNAUTHORIZED: {};
+        UNAVAILABLE: {};
+    }>;
+    queries: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<z.ZodObject<{
+        args: z.ZodOptional<z.ZodUnknown>;
+        name: z.ZodString;
+    }, z.core.$strict>, import("@orpc/contract").Schema<unknown, unknown>, {
+        BAD_REQUEST: {};
+        CONFLICT: {};
+        FORBIDDEN: {};
+        INCOMPATIBLE_VERSION: {};
+        INTERNAL_SERVER_ERROR: {};
+        NOT_FOUND: {};
+        UNAUTHORIZED: {};
+        UNAVAILABLE: {};
+    }>;
+    subscribe: import("@orpc/contract").ProcedureContractBuilderWithInputOutput<z.ZodObject<{
+        args: z.ZodOptional<z.ZodUnknown>;
+        name: z.ZodString;
+    }, z.core.$strict>, import("@orpc/contract").Schema<AsyncIterableIterator<unknown>, AsyncIterableIterator<unknown>>, {
+        BAD_REQUEST: {};
+        CONFLICT: {};
+        FORBIDDEN: {};
+        INCOMPATIBLE_VERSION: {};
+        INTERNAL_SERVER_ERROR: {};
+        NOT_FOUND: {};
+        UNAUTHORIZED: {};
+        UNAVAILABLE: {};
+    }>;
+};
+export type PlatformClient = ContractRouterClient<typeof appContract>;
+export type SubscriptionClient = Pick<PlatformClient, "subscribe">;
+/** Drizzle-generated SQL exported by application bundles. */
+export interface AppMigration {
+    id: string;
+    hash: string;
+    statements: string[];
+}

package/dist/protocol.js

@@ -0,0 +1,30 @@
+// src/protocol.ts
+import { oc, type } from "@orpc/contract";
+import { z } from "zod";
+var invocationSchema = z.strictObject({
+  args: z.unknown().optional(),
+  name: z.string().max(512).regex(
+    /^(?:[a-zA-Z][a-zA-Z0-9_]{0,63}|_tailorkit)(?:\.[a-zA-Z][a-zA-Z0-9_]{0,63})*$/u
+  )
+});
+var procedure = oc.errors({
+  BAD_REQUEST: {},
+  CONFLICT: {},
+  FORBIDDEN: {},
+  INCOMPATIBLE_VERSION: {},
+  INTERNAL_SERVER_ERROR: {},
+  NOT_FOUND: {},
+  UNAUTHORIZED: {},
+  UNAVAILABLE: {}
+});
+var appContract = {
+  actions: procedure.input(invocationSchema).output(type()),
+  mutations: procedure.input(invocationSchema.extend({ requestId: z.uuid() })).output(type()),
+  queries: procedure.input(invocationSchema).output(type()),
+  // A pass-through type schema preserves the private hibernation iterator instance.
+  subscribe: procedure.input(invocationSchema).output(type())
+};
+export {
+  appContract,
+  invocationSchema
+};

package/dist/routing.d.ts

@@ -0,0 +1,34 @@
+import type { ComponentChildren, ComponentType } from "preact";
+import type { TailorKitClientWithMeta } from "./views";
+export interface ShellProps {
+    children?: ComponentChildren;
+}
+export interface RouteDefinition {
+    readonly shellComponent: ComponentType<ShellProps>;
+}
+/** Define the shell in an app or slot root.tsx. */
+export declare const defineRoute: (options: RouteDefinition) => RouteDefinition;
+/** Render the next layout or selected view inside a root shell or layout. */
+export declare const Route: () => string | number | bigint | boolean | object | import("preact").ComponentChild[] | import("preact").VNode<any> | null;
+export interface RouteModule {
+    filename: string;
+    definition: unknown;
+}
+export interface FileViewModule extends RouteModule {
+    slot: string;
+}
+export interface FileLayoutModule extends RouteModule {
+    slot: string;
+    path: string;
+}
+/** The app builder generates this registration; apps only export their files.
+ * @internal
+ */
+export declare const createFileClient: (options: {
+    root?: RouteModule;
+    roots: (RouteModule & {
+        slot: string;
+    })[];
+    layouts: FileLayoutModule[];
+    views: FileViewModule[];
+}) => TailorKitClientWithMeta;

package/dist/server/builder.d.ts

@@ -0,0 +1,45 @@
+import type { AnyRelations, EmptyRelations } from "drizzle-orm/relations";
+import { z } from "zod";
+import type { DatabaseDefinition } from "#database/definition";
+import type { MutationDatabase, QueryDatabase } from "#database/types";
+import type { ActionContext, FunctionKind, Functions, Identity } from "./functions";
+type HandlerContext<K extends FunctionKind, A extends z.ZodType, F extends Functions, D extends AnyRelations> = {
+    input: z.output<A>;
+} & (K extends "action" ? ActionContext<F> : {
+    db: K extends "query" ? QueryDatabase<D> : MutationDatabase<D>;
+    identity: Identity;
+});
+type OutputInput<R> = R extends z.ZodType ? z.input<R> : unknown;
+type HandlerOutput<K, O> = K extends "action" ? O | Promise<O> : O & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
+type BuiltFunction<K extends FunctionKind, A extends z.ZodType, R, O, F extends Functions, D extends AnyRelations> = {
+    readonly kind: K;
+    readonly args: A;
+    readonly database?: DatabaseDefinition<D>;
+    readonly handler: (context: Omit<HandlerContext<K, A, F, D>, "input"> & {
+        args: z.output<A>;
+    }) => HandlerOutput<K, O>;
+} & (R extends z.ZodType ? {
+    readonly result: R;
+} : unknown) & (K extends "action" ? {
+    readonly functions: F;
+} : unknown);
+/** Immutable builders preserve the validated input and wire output types at every step. */
+declare class FunctionBuilder<K extends FunctionKind, A extends z.ZodType, R extends z.ZodType | undefined = undefined, F extends Functions = Record<never, never>, D extends AnyRelations = EmptyRelations> {
+    private readonly kind;
+    private readonly args;
+    private readonly result;
+    private readonly calls;
+    private readonly databaseDefinition;
+    constructor(kind: K, args: A, result: R, calls: F, database?: DatabaseDefinition<D>);
+    input<S extends z.ZodType>(schema: S): FunctionBuilder<K, S, R, F, D>;
+    output<S extends z.ZodType>(schema: S): FunctionBuilder<K, A, S, F, D>;
+    functions<const G extends Functions>(this: FunctionBuilder<"action", A, R, F, D>, functions: G): FunctionBuilder<"action", A, R, G, D>;
+    database<const E extends AnyRelations>(this: FunctionBuilder<K, A, R, F, D> & (K extends "action" ? never : unknown), database: DatabaseDefinition<E>): FunctionBuilder<K, A, R, F, E>;
+    handler<O extends OutputInput<R>>(handler: (context: HandlerContext<K, A, F, D>) => HandlerOutput<K, O>): BuiltFunction<K, A, R, O, F, D>;
+}
+export declare const fn: Readonly<{
+    action: FunctionBuilder<"action", z.ZodUndefined, undefined, {}, EmptyRelations>;
+    mutation: FunctionBuilder<"mutation", z.ZodUndefined, undefined, {}, EmptyRelations>;
+    query: FunctionBuilder<"query", z.ZodUndefined, undefined, {}, EmptyRelations>;
+}>;
+export {};

package/dist/server/bundle.d.ts

@@ -0,0 +1,12 @@
+import type { AppMigration } from "#protocol";
+import type { AppDefinition } from "./functions";
+/** Interface between an uploaded application module and the server runtime. */
+export interface RuntimeManifest {
+    apiVersion: number;
+    requires: readonly string[];
+}
+export interface ApplicationModule {
+    default: AppDefinition;
+    migrations: readonly AppMigration[];
+    runtimeManifest: RuntimeManifest;
+}

package/dist/server/functions.d.ts

@@ -0,0 +1,105 @@
+import type { AnyRelations, EmptyRelations } from "drizzle-orm/relations";
+import type { z } from "zod";
+import type { TailorKitServerTools } from "#client/tools";
+import type { DatabaseDefinition } from "#database/definition";
+import type { QueryDatabase, MutationDatabase } from "#database/types";
+export interface Identity {
+    readonly subjectId?: string;
+    readonly scope: {
+        name: string;
+        value: Record<string, z.output<ReturnType<typeof z.json>>>;
+    };
+    readonly toolUrl: string;
+    readonly projectId: string;
+    readonly appId: string;
+    readonly installationId: string;
+    readonly deploymentId: string;
+    readonly expiresAt: number;
+}
+export type FunctionKind = "query" | "mutation" | "action";
+export type FunctionResult<D> = D extends {
+    result: infer R extends z.ZodType;
+} ? z.output<R> : D extends {
+    handler: (context: never) => infer O;
+} ? Awaited<O> : never;
+export type FunctionCalls<F, K extends "query" | "mutation"> = {
+    readonly [N in keyof F as F[N] extends {
+        kind: FunctionKind;
+    } ? F[N] extends {
+        kind: K;
+    } ? N : never : N]: F[N] extends {
+        args: infer A extends z.ZodType;
+        handler: (context: never) => infer _Output;
+    } ? K extends "mutation" ? (...args: undefined extends z.input<A> ? [args?: z.input<A>, options?: {
+        requestId?: string;
+    }] : [args: z.input<A>, options?: {
+        requestId?: string;
+    }]) => Promise<FunctionResult<F[N]>> : (...args: undefined extends z.input<A> ? [args?: z.input<A>] : [args: z.input<A>]) => Promise<FunctionResult<F[N]>> : F[N] extends Functions ? FunctionCalls<F[N], K> : never;
+};
+export interface ActionContext<F extends Functions = Record<never, never>> {
+    readonly identity: Identity;
+    readonly tools: TailorKitServerTools;
+    readonly requestId: string;
+    readonly scope: Identity["scope"];
+    readonly signal: AbortSignal;
+    readonly queries: FunctionCalls<F, "query">;
+    readonly mutations: FunctionCalls<F, "mutation">;
+}
+export interface FunctionDefinition<K extends FunctionKind, A extends z.ZodType, O, F extends Functions = Record<never, never>, D extends AnyRelations = EmptyRelations> {
+    readonly kind: K;
+    readonly args: A;
+    readonly database?: K extends "action" ? never : DatabaseDefinition<D>;
+    readonly result?: z.ZodType<O>;
+    readonly handler: (context: {
+        args: z.output<A>;
+    } & (K extends "action" ? ActionContext<F> : {
+        db: K extends "query" ? QueryDatabase<D> : MutationDatabase<D>;
+        identity: Identity;
+    })) => K extends "action" ? O | Promise<O> : O;
+}
+export declare const query: <A extends z.ZodType, O, const D extends AnyRelations = EmptyRelations>(definition: Omit<FunctionDefinition<"query", A, O, Record<never, never>, D>, "kind"> & {
+    handler: FunctionDefinition<"query", A, O, Record<never, never>, D>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
+}) => Readonly<{
+    args: A;
+    database?: DatabaseDefinition<D> | undefined;
+    result?: z.ZodType<O, unknown, z.core.$ZodTypeInternals<O, unknown>> | undefined;
+    handler: FunctionDefinition<"query", A, O, Record<never, never>, D>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
+    kind: "query";
+}>;
+export declare const mutation: <A extends z.ZodType, O, const D extends AnyRelations = EmptyRelations>(definition: Omit<FunctionDefinition<"mutation", A, O, Record<never, never>, D>, "kind"> & {
+    handler: FunctionDefinition<"mutation", A, O, Record<never, never>, D>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
+}) => Readonly<{
+    args: A;
+    database?: DatabaseDefinition<D> | undefined;
+    result?: z.ZodType<O, unknown, z.core.$ZodTypeInternals<O, unknown>> | undefined;
+    handler: FunctionDefinition<"mutation", A, O, Record<never, never>, D>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
+    kind: "mutation";
+}>;
+export declare const action: <A extends z.ZodType, O, const F extends Functions = Record<never, never>>(definition: Omit<FunctionDefinition<"action", A, O, F>, "kind"> & {
+    functions?: F;
+}) => Readonly<{
+    args: A;
+    database?: undefined;
+    result?: z.ZodType<O, unknown, z.core.$ZodTypeInternals<O, unknown>> | undefined;
+    handler: (context: {
+        args: z.infer<A>;
+    } & ActionContext<F>) => O | Promise<O>;
+    functions?: F;
+    kind: "action";
+}>;
+export interface RegisteredFunction<TOutput = unknown> {
+    kind: FunctionKind;
+    args: z.ZodType;
+    result?: z.ZodType;
+    handler: (context: never) => TOutput;
+    functions?: Functions;
+    database?: DatabaseDefinition;
+}
+export interface Functions {
+    readonly [name: string]: RegisteredFunction | Functions;
+}
+export declare const isFunction: (value: RegisteredFunction | Functions) => value is RegisteredFunction;
+export declare const defineServer: <const F extends Functions>(functions: F) => Readonly<{
+    functions: F;
+}>;
+export type AppDefinition = ReturnType<typeof defineServer>;

package/dist/server/instances.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import type { ViewDataFields } from "#views";
+import type { AppDefinition, Identity } from "./functions";
+interface InstanceResolver<TOutput = unknown> {
+    slot: string;
+    path: string;
+    dataSchema: z.ZodType;
+    resolve: (context: {
+        context: ViewDataFields;
+        identity: Identity;
+        signal: AbortSignal;
+        queries: unknown;
+    }) => TOutput;
+}
+/** Build-generated actions run through the existing authenticated action runtime. */
+export declare const withInstanceResolvers: (app: AppDefinition, resolvers: readonly InstanceResolver[]) => AppDefinition;
+export {};

package/dist/server.d.ts

@@ -0,0 +1,11 @@
+export { defineServer, query, mutation, action } from "./server/functions";
+export { defineDatabase } from "./database/definition";
+export type { DatabaseDefinition } from "./database/definition";
+export { fn } from "./server/builder";
+export { withInstanceResolvers } from "./server/instances";
+export type { QueryDatabase, MutationDatabase } from "./database/types";
+export type { Identity, FunctionDefinition, AppDefinition, ActionContext, FunctionKind, } from "./server/functions";
+export { table, text, integer, real, boolean, eq, ne, gt, gte, lt, lte, and, or, asc, desc, count, isNull, isNotNull, inArray, } from "./database/schema";
+export { AppError } from "./errors";
+export type { ErrorCode } from "./errors";
+export type { ApplicationModule, RuntimeManifest } from "./server/bundle";

package/dist/server.js

@@ -0,0 +1,60 @@
+import {
+  action,
+  and,
+  asc,
+  boolean,
+  count,
+  defineDatabase,
+  defineServer,
+  desc,
+  eq,
+  fn,
+  gt,
+  gte,
+  inArray,
+  integer,
+  isNotNull,
+  isNull,
+  lt,
+  lte,
+  mutation,
+  ne,
+  or,
+  query,
+  real,
+  table,
+  text,
+  withInstanceResolvers
+} from "./chunk-YX3JURMG.js";
+import {
+  AppError
+} from "./chunk-7ZQPXG7O.js";
+export {
+  AppError,
+  action,
+  and,
+  asc,
+  boolean,
+  count,
+  defineDatabase,
+  defineServer,
+  desc,
+  eq,
+  fn,
+  gt,
+  gte,
+  inArray,
+  integer,
+  isNotNull,
+  isNull,
+  lt,
+  lte,
+  mutation,
+  ne,
+  or,
+  query,
+  real,
+  table,
+  text,
+  withInstanceResolvers
+};