@tailorkit/app 0.1.0-beta.2 → 0.1.0-beta.21

package/dist/client/reference.d.ts

@@ -0,0 +1,20 @@
+import type { z } from "zod";
+import type { FunctionResult, Functions } from "../server/functions";
+export interface Reference<K extends "query" | "mutation" | "action", I, O> {
+    readonly name: string;
+    readonly $types?: {
+        kind: K;
+        input: I;
+        output: O;
+    };
+}
+export declare function 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;
+    } ? 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>;

package/dist/client/session.d.ts

@@ -0,0 +1,14 @@
+export interface Session {
+    token: string;
+    expiresAt: number;
+    url: string;
+}
+export declare function sessionRenewalDelay(session: Session): number;
+/** Host-owned provider: project credentials never cross into the sandbox. */
+export declare function createSessionProvider(options: {
+    baseUrl: string | URL;
+    appId: string;
+    fetch?: typeof fetch;
+}): (input: {
+    refresh: boolean;
+}) => Promise<Session>;

package/dist/client.d.ts

@@ -0,0 +1,7 @@
+export * from "./views";
+export * from "./preact";
+export { createClient, createSessionProvider, reference } from "./client/connection";
+export { createApi } from "./client/reference";
+export type { Client, Session, Reference, References } from "./client/connection";
+export { AppError, appError } from "./errors";
+export type { ErrorCode } from "./errors";

package/dist/client.js

@@ -0,0 +1,32 @@
+import {
+  ClientProvider,
+  createApi,
+  createClient,
+  createRemoteComponent,
+  createSessionProvider,
+  defineClient,
+  defineView,
+  reference,
+  useAction,
+  useMutation,
+  useQuery
+} from "./chunk-RHCGWGSG.js";
+import {
+  AppError,
+  appError
+} from "./chunk-IJBQ77AH.js";
+export {
+  AppError,
+  ClientProvider,
+  appError,
+  createApi,
+  createClient,
+  createRemoteComponent,
+  createSessionProvider,
+  defineClient,
+  defineView,
+  reference,
+  useAction,
+  useMutation,
+  useQuery
+};

package/dist/config/config.d.ts

@@ -6,12 +6,96 @@ declare const tailorkitConfigSchema: z.ZodObject<{
     }, z.core.$strip>>;
     client: z.ZodOptional<z.ZodObject<{
         entry: z.ZodDefault<z.ZodString>;
-    }, z.core.$strip>>;
+    }, z.core.$strict>>;
     host: z.ZodString;
-}, z.core.$strip>;
-export type TailorKitConfig = z.input<typeof tailorkitConfigSchema>;
+    logos: z.ZodOptional<z.ZodObject<{
+        dark: z.ZodOptional<z.ZodString>;
+        light: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    server: z.ZodOptional<z.ZodObject<{
+        entry: z.ZodDefault<z.ZodString>;
+        migrations: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/**
+ * App configuration exported from `tailorkit.config.ts`.
+ * Relative paths are resolved from the directory containing the config file.
+ */
+export interface TailorKitConfig extends z.input<typeof tailorkitConfigSchema> {
+    /**
+     * ID of the app on the TailorKit host, used for deployment and remote preview.
+     * When omitted, the first deployment creates an app and saves its ID here.
+     * The agent command prompts to select or create an app and saves its ID here.
+     * Remote preview requires an existing app ID.
+     * @default undefined
+     */
+    appId?: string;
+    /**
+     * Build output settings. Omit to use the default output directory.
+     * @default undefined
+     */
+    build?: {
+        /**
+         * Directory for generated client bundles, server bundles, and migration assets.
+         * A build or CLI `outDir` option overrides this value.
+         * @default ".tailorkit"
+         */
+        outDir?: string;
+    };
+    /**
+     * Browser client build settings. Omit to use the default client entry point.
+     * @default undefined
+     */
+    client?: {
+        /**
+         * Source entry point for the app's browser bundle.
+         * @default "src/client.ts"
+         */
+        entry?: string;
+    };
+    /**
+     * URL of the TailorKit host used for authentication, deployment, remote preview,
+     * and fetching the host schema for generated types. Required; has no default.
+     */
+    host: string;
+    /**
+     * Optional app logo assets included in the build and uploaded on deployment.
+     * Accepts SVG, PNG, or WebP files. Omit to upload no custom logos.
+     * @default undefined
+     */
+    logos?: {
+        /**
+         * Path to the app logo for dark mode. Omit to upload no dark-mode logo.
+         * @default undefined
+         */
+        dark?: string;
+        /**
+         * Path to the app logo for light mode. Omit to upload no light-mode logo.
+         * @default undefined
+         */
+        light?: string;
+    };
+    /**
+     * Enables the private app backend and its database migrations when present.
+     * Set to `{}` to use the default paths; omit for a client-only app.
+     * @default undefined
+     */
+    server?: {
+        /**
+         * Source entry point for the app's private backend bundle.
+         * @default "src/server.ts"
+         */
+        entry?: string;
+        /**
+         * Directory containing Drizzle migrations, used for generation and bundling.
+         * When omitted, uses `./migrations` and allows that directory to be absent.
+         * An explicitly configured directory must exist when building the backend.
+         * @default "./migrations"
+         */
+        migrations?: string;
+    };
+}
 export type ResolvedTailorKitConfig = z.output<typeof tailorkitConfigSchema>;
 export { tailorkitConfigSchema };
 export declare const defineConfig: (config: TailorKitConfig) => TailorKitConfig;
 export declare const defineTailorKitConfig: typeof defineConfig;
-//# sourceMappingURL=config.d.ts.map

package/dist/config/index.d.ts

@@ -1,2 +1 @@
 export { defineConfig, defineTailorKitConfig, type TailorKitConfig } from "./config";
-//# sourceMappingURL=index.d.ts.map

package/dist/config/loader.d.ts

@@ -5,4 +5,3 @@ export interface LoadedTailorKitConfig {
     root: string;
 }
 export declare const loadTailorKitConfig: (configPath: string | undefined, cwd?: string) => Promise<LoadedTailorKitConfig>;
-//# sourceMappingURL=loader.d.ts.map

package/dist/config-loader.js

@@ -1,7 +1,7 @@
 import {
   loadTailorKitConfig
-} from "./chunk-7L6ZZHCK.js";
-import "./chunk-AGGRUUWG.js";
+} from "./chunk-DEU6RITM.js";
+import "./chunk-GVB2PAK7.js";
 export {
   loadTailorKitConfig
 };

package/dist/config.js

@@ -1,7 +1,7 @@
 import {
   defineConfig,
   defineTailorKitConfig
-} from "./chunk-AGGRUUWG.js";
+} from "./chunk-GVB2PAK7.js";
 export {
   defineConfig,
   defineTailorKitConfig

package/dist/database/schema.d.ts

@@ -0,0 +1,78 @@
+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<{
+    name: N;
+    schema: undefined;
+    columns: { [Key in keyof C]: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: string;
+        tableName: N;
+        dataType: C[Key]["_"]["dataType"];
+        data: C[Key]["_"] extends infer T ? T extends C[Key]["_"] ? T extends {
+            $type: infer U;
+        } ? U : T["data"] : never : never;
+        driverParam: C[Key]["_"]["driverParam"];
+        notNull: C[Key]["_"]["notNull"] extends true ? true : false;
+        hasDefault: C[Key]["_"]["hasDefault"] extends true ? true : false;
+        isPrimaryKey: C[Key]["_"] extends infer T_1 ? T_1 extends C[Key]["_"] ? T_1 extends {
+            isPrimaryKey: true;
+        } ? true : false : never : never;
+        isAutoincrement: C[Key]["_"] extends infer T_2 ? T_2 extends C[Key]["_"] ? T_2 extends {
+            isAutoincrement: true;
+        } ? true : false : never : never;
+        hasRuntimeDefault: C[Key]["_"] extends infer T_3 ? T_3 extends C[Key]["_"] ? T_3 extends {
+            hasRuntimeDefault: true;
+        } ? true : false : never : never;
+        enumValues: C[Key]["_"] extends infer T_4 ? T_4 extends C[Key]["_"] ? T_4 extends {
+            enumValues: [string, ...string[]];
+        } ? T_4["enumValues"] : undefined : never : never;
+        baseColumn: C[Key]["_"] extends infer T_5 ? T_5 extends C[Key]["_"] ? T_5 extends {
+            baseBuilder: infer U_1 extends ColumnBuilderBase;
+        } ? import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: N;
+            dataType: U_1["_"]["dataType"];
+            data: U_1["_"] extends infer T_6 ? T_6 extends U_1["_"] ? T_6 extends {
+                $type: infer U;
+            } ? U : T_6["data"] : never : never;
+            driverParam: U_1["_"]["driverParam"];
+            notNull: U_1["_"]["notNull"] extends true ? true : false;
+            hasDefault: U_1["_"]["hasDefault"] extends true ? true : false;
+            isPrimaryKey: U_1["_"] extends infer T_7 ? T_7 extends U_1["_"] ? T_7 extends {
+                isPrimaryKey: true;
+            } ? true : false : never : never;
+            isAutoincrement: U_1["_"] extends infer T_8 ? T_8 extends U_1["_"] ? T_8 extends {
+                isAutoincrement: true;
+            } ? true : false : never : never;
+            hasRuntimeDefault: U_1["_"] extends infer T_9 ? T_9 extends U_1["_"] ? T_9 extends {
+                hasRuntimeDefault: true;
+            } ? true : false : never : never;
+            enumValues: U_1["_"] extends infer T_10 ? T_10 extends U_1["_"] ? T_10 extends {
+                enumValues: [string, ...string[]];
+            } ? T_10["enumValues"] : undefined : never : never;
+            baseColumn: U_1["_"] extends infer T_11 ? T_11 extends U_1["_"] ? T_11 extends {
+                baseBuilder: infer U_1 extends ColumnBuilderBase;
+            } ? import("drizzle-orm/sqlite-core").SQLiteColumn</*elided*/ any, {}> : never : never : never;
+            identity: U_1["_"] extends infer T_12 ? T_12 extends U_1["_"] ? T_12 extends {
+                identity: 'always';
+            } ? "always" : T_12 extends {
+                identity: 'byDefault';
+            } ? "byDefault" : undefined : never : never;
+            generated: U_1["_"] extends infer T_13 ? T_13 extends U_1["_"] ? T_13 extends {
+                generated: infer G;
+            } ? unknown extends G ? undefined : G extends undefined ? undefined : G : undefined : never : never;
+        }, {}> : never : never : never;
+        identity: C[Key]["_"] extends infer T_14 ? T_14 extends C[Key]["_"] ? T_14 extends {
+            identity: 'always';
+        } ? "always" : T_14 extends {
+            identity: 'byDefault';
+        } ? "byDefault" : undefined : never : never;
+        generated: C[Key]["_"] extends infer T_15 ? T_15 extends C[Key]["_"] ? T_15 extends {
+            generated: infer G;
+        } ? unknown extends G ? undefined : G extends undefined ? undefined : G : undefined : never : never;
+    }, {}>; };
+    dialect: 'sqlite';
+}>;
+export declare const text: (name?: string) => import("drizzle-orm/sqlite-core").SQLiteTextBuilder<[string, ...string[]]>;
+export declare const integer: (name?: string) => import("drizzle-orm/sqlite-core").SQLiteIntegerBuilder;
+export declare const real: (name?: string) => import("drizzle-orm/sqlite-core").SQLiteRealBuilder;
+export declare const boolean: (name?: string) => import("drizzle-orm/sqlite-core").SQLiteBooleanBuilder;
+export { eq, ne, gt, gte, lt, lte, and, or, asc, desc, count, isNull, isNotNull, inArray, } from "drizzle-orm";

package/dist/database/types.d.ts

@@ -0,0 +1,7 @@
+import type { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core";
+type Database = BaseSQLiteDatabase<"sync", {
+    changes: number;
+}>;
+export type QueryDatabase = Pick<Database, "select" | "selectDistinct">;
+export type MutationDatabase = QueryDatabase & Pick<Database, "insert" | "update" | "delete">;
+export {};

package/dist/errors.d.ts

@@ -0,0 +1,6 @@
+export type ErrorCode = "BAD_REQUEST" | "UNAUTHORIZED" | "FORBIDDEN" | "NOT_FOUND" | "CONFLICT" | "INCOMPATIBLE_VERSION" | "UNAVAILABLE" | "INTERNAL_SERVER_ERROR";
+export declare class AppError extends Error {
+    readonly code: ErrorCode;
+    constructor(code: ErrorCode, message?: string);
+}
+export declare function appError(error: unknown): AppError;

package/dist/index.d.ts

@@ -1,72 +1,2 @@
-import { h } from "preact";
-import type { ComponentChild, ComponentChildren, VNode } from "preact";
-export interface TailorKitScreens {
-}
-export type ScreenPath = Extract<keyof TailorKitScreens & string, `/${string}`>;
-export type AppScreenPath = ScreenPath;
-export type ScreenProps<TPath extends ScreenPath> = TailorKitScreens[TPath] extends object ? TailorKitScreens[TPath] : Record<string, never>;
-export type ScreenPropsForPath<TPath extends AppScreenPath> = TPath extends ScreenPath ? ScreenProps<TPath> : never;
-export type ScreenContext<TPath extends AppScreenPath> = ScreenPropsForPath<TPath> extends {
-    context: infer TContext;
-} ? TContext : Record<string, never>;
-export type View<TProps extends object = Record<string, never>> = (props: TProps) => ComponentChild;
-export type ScreenRuntimeProps<TPath extends AppScreenPath> = {
-    context: ScreenContext<TPath>;
-    screen: TPath;
-    status: "ready";
-} | {
-    context?: never;
-    screen: TPath;
-    status: "loading";
-} | {
-    context?: never;
-    screen: TPath;
-    status: "error";
-};
-export interface ScreenDefinition<TPath extends AppScreenPath = AppScreenPath> {
-    component: View<ScreenRuntimeProps<TPath>>;
-    path: TPath;
-    useContext: () => ScreenContext<TPath>;
-}
-type RegisteredScreens = {
-    [TPath in AppScreenPath]: ScreenDefinition<TPath>;
-};
-type ScreenDefinitions = Partial<RegisteredScreens>;
-type InvalidScreenPath<TScreens> = Exclude<keyof TScreens & string, `/${string}`>;
-type RequireScreenPaths<TScreens> = InvalidScreenPath<TScreens> extends never ? unknown : {
-    readonly __tailorkit_error__: `Screen paths must start with "/". Invalid screen: ${InvalidScreenPath<TScreens>}`;
-};
-type ScreenKeyPathMismatch<TScreens> = {
-    [TPath in keyof TScreens & string]: TScreens[TPath] extends ScreenDefinition<infer TScreenPath> ? TScreenPath extends TPath ? never : TPath : TPath;
-}[keyof TScreens & string];
-type RequireMatchingScreenKeys<TScreens> = ScreenKeyPathMismatch<TScreens> extends never ? unknown : {
-    readonly __tailorkit_error__: `Screen key must match createScreen path. Invalid screen: ${ScreenKeyPathMismatch<TScreens>}`;
-};
-export interface TailorKitClient<TScreens extends ScreenDefinitions = ScreenDefinitions> {
-    screens: TScreens;
-}
-export interface TailorKitClientMeta {
-    preactVersion: string;
-}
-export interface TailorKitClientRuntime {
-    h: typeof h;
-    render: (vnode: VNode, parent: Element | Document | ShadowRoot | DocumentFragment) => void;
-}
-export type TailorKitClientWithMeta<TScreens extends ScreenDefinitions = ScreenDefinitions> = TailorKitClient<TScreens> & {
-    $meta: TailorKitClientMeta;
-    $runtime: TailorKitClientRuntime;
-};
-export declare const createScreen: <const TPath extends AppScreenPath>(path: TPath, options: {
-    component: View<Record<string, never>>;
-    error?: View<Record<string, never>>;
-    loading?: View<Record<string, never>>;
-}) => ScreenDefinition<TPath>;
-export declare const defineClient: <const TScreens extends ScreenDefinitions>(client: TailorKitClient<TScreens> & RequireScreenPaths<TScreens> & RequireMatchingScreenKeys<TScreens>) => TailorKitClientWithMeta<TScreens>;
-export declare const createRemoteComponent: <TProps extends object, TSlots extends readonly string[]>(name: string, options: {
-    callbacks?: Record<string, number>;
-    slots: TSlots;
-}) => View<TProps & {
-    children?: ComponentChildren;
-}>;
-export {};
-//# sourceMappingURL=index.d.ts.map
+export * from "./client";
+export * from "./server";

package/dist/index.js

@@ -1,79 +1,84 @@
-// 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,
+  createApi,
+  createClient,
+  createRemoteComponent,
+  createSessionProvider,
+  defineClient,
+  defineView,
+  reference,
+  useAction,
+  useMutation,
+  useQuery
+} from "./chunk-RHCGWGSG.js";
+import {
+  action,
+  and,
+  asc,
+  boolean,
+  count,
+  defineServer,
+  desc,
+  eq,
+  gt,
+  gte,
+  inArray,
+  integer,
+  isNotNull,
+  isNull,
+  lt,
+  lte,
+  mutation,
+  ne,
+  or,
+  query,
+  real,
+  table,
+  text,
+  tk,
+  withInstanceResolvers
+} from "./chunk-7NOEYJOB.js";
+import {
+  AppError,
+  appError
+} from "./chunk-IJBQ77AH.js";
 export {
+  AppError,
+  ClientProvider,
+  action,
+  and,
+  appError,
+  asc,
+  boolean,
+  count,
+  createApi,
+  createClient,
   createRemoteComponent,
-  createScreen,
-  defineClient
+  createSessionProvider,
+  defineClient,
+  defineServer,
+  defineView,
+  desc,
+  eq,
+  gt,
+  gte,
+  inArray,
+  integer,
+  isNotNull,
+  isNull,
+  lt,
+  lte,
+  mutation,
+  ne,
+  or,
+  query,
+  real,
+  reference,
+  table,
+  text,
+  tk,
+  useAction,
+  useMutation,
+  useQuery,
+  withInstanceResolvers
 };

package/dist/preact-version.d.ts

@@ -5,4 +5,3 @@ export interface PreactVersionCheck {
 }
 export declare const parsePreactVersion: (version: string) => PreactVersionCheck;
 export declare const assertSupportedPreactVersion: (version: string) => PreactVersionCheck;
-//# sourceMappingURL=preact-version.d.ts.map

package/dist/preact.d.ts

@@ -0,0 +1,52 @@
+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 { 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 function 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 function 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 function 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 {};