@tailorkit/app 0.1.0-beta.14 → 0.1.0-beta.16

package/dist/chunk-46CTW3XJ.js

@@ -0,0 +1,120 @@
+// 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) {
+  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);
+  }
+  return Object.freeze({ functions });
+}
+
+// src/server/builder.ts
+import { z } from "zod";
+var FunctionBuilder = class _FunctionBuilder {
+  kind;
+  args;
+  result;
+  calls;
+  constructor(kind, args, result, calls) {
+    this.kind = kind;
+    this.args = args;
+    this.result = result;
+    this.calls = calls;
+  }
+  input(schema) {
+    return new _FunctionBuilder(this.kind, schema, this.result, this.calls);
+  }
+  output(schema) {
+    return new _FunctionBuilder(this.kind, this.args, schema, this.calls);
+  }
+  functions(functions) {
+    return new _FunctionBuilder(this.kind, this.args, this.result, functions);
+  }
+  handler(handler) {
+    return Object.freeze({
+      kind: this.kind,
+      args: this.args,
+      ...this.result ? { result: this.result } : {},
+      ...this.kind === "action" ? { functions: this.calls } : {},
+      handler: (context) => handler({ ...context, input: context.args })
+    });
+  }
+};
+var tk = Object.freeze({
+  query: new FunctionBuilder("query", z.undefined(), void 0, {}),
+  mutation: new FunctionBuilder("mutation", z.undefined(), void 0, {}),
+  action: new FunctionBuilder("action", z.undefined(), void 0, {})
+});
+
+// src/database/schema.ts
+import {
+  sqliteTable,
+  text as sqliteText,
+  integer as sqliteInteger,
+  real as sqliteReal
+} from "drizzle-orm/sqlite-core";
+import {
+  eq,
+  ne,
+  gt,
+  gte,
+  lt,
+  lte,
+  and,
+  or,
+  asc,
+  desc,
+  count,
+  isNull,
+  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_"))
+    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);
+var boolean = (name = "") => sqliteInteger(name, { mode: "boolean" });
+
+export {
+  query,
+  mutation,
+  action,
+  defineServer,
+  tk,
+  table,
+  text,
+  integer,
+  real,
+  boolean,
+  eq,
+  ne,
+  gt,
+  gte,
+  lt,
+  lte,
+  and,
+  or,
+  asc,
+  desc,
+  count,
+  isNull,
+  isNotNull,
+  inArray
+};

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

@@ -1,6 +1,6 @@
 import {
   tailorkitConfigSchema
-} from "./chunk-ZFYKVXDO.js";
+} from "./chunk-GVB2PAK7.js";
 
 // src/config/loader.ts
 import { cosmiconfig } from "cosmiconfig";
@@ -14,6 +14,11 @@ 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-ZFYKVXDO.js → chunk-GVB2PAK7.js}

@@ -1,8 +1,5 @@
 // src/config/config.ts
 import { z } from "zod";
-var clientConfigSchema = z.object({
-  entry: z.string().default("./src/client.ts")
-});
 var buildConfigSchema = z.object({
   outDir: z.string().default(".tailorkit")
 });
@@ -10,12 +7,16 @@ var logosConfigSchema = z.object({
   dark: z.string().min(1).optional(),
   light: z.string().min(1).optional()
 });
-var tailorkitConfigSchema = z.object({
+var tailorkitConfigSchema = z.strictObject({
   appId: z.string().min(1).optional(),
   build: buildConfigSchema.optional(),
-  client: clientConfigSchema.optional(),
+  client: z.strictObject({ entry: z.string().min(1).default("src/client.ts") }).optional(),
   host: z.string().url(),
-  logos: logosConfigSchema.optional()
+  logos: logosConfigSchema.optional(),
+  server: z.strictObject({
+    entry: z.string().min(1).default("src/server.ts"),
+    migrations: z.string().min(1).optional()
+  }).optional()
 });
 var defineConfig = (config) => config;
 var defineTailorKitConfig = defineConfig;

package/dist/chunk-IJBQ77AH.js

@@ -0,0 +1,35 @@
+// src/errors.ts
+var AppError = class extends Error {
+  constructor(code, message = code) {
+    super(message);
+    this.code = code;
+    this.name = "AppError";
+  }
+  code;
+};
+function appError(error) {
+  if (error instanceof AppError) return error;
+  if (error instanceof Error && error.name === "AbortError")
+    return new AppError("UNAVAILABLE", "App connection interrupted");
+  if (error && typeof error === "object" && "code" in error && error.code === "NETWORK_ERROR")
+    return new AppError("UNAVAILABLE", "App connection interrupted");
+  if (error && typeof error === "object" && "code" in error && [
+    "BAD_REQUEST",
+    "UNAUTHORIZED",
+    "FORBIDDEN",
+    "NOT_FOUND",
+    "CONFLICT",
+    "INCOMPATIBLE_VERSION",
+    "UNAVAILABLE"
+  ].includes(String(error.code)))
+    return new AppError(
+      error.code,
+      "message" in error ? String(error.message) : String(error.code)
+    );
+  return new AppError("INTERNAL_SERVER_ERROR", "App function failed");
+}
+
+export {
+  AppError,
+  appError
+};

package/dist/client/connection.d.ts

@@ -0,0 +1,31 @@
+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";
+type InputArguments<I> = undefined extends I ? [args?: I] : [args: I];
+type MutationArguments<I> = undefined extends I ? [args?: I, options?: {
+    requestId?: string;
+}] : [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?: {
+        onError?: (error: AppError) => void;
+    }): () => void;
+    close(): void;
+}
+export declare function 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";

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

@@ -0,0 +1,23 @@
+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;
+/** One subscription per active query/input pair, scoped to this provider's client. */
+export declare class QueryStore {
+    readonly state: import("@tanstack/store").Store<Map<string, QueryState<unknown>>, never>;
+    private readonly entries;
+    private disposed;
+    readonly client: Client;
+    private readonly ownsClient;
+    private readonly errorHandler;
+    constructor(client: Client, ownsClient: boolean, errorHandler?: (error: AppError) => void);
+    watch<I, O>(key: string, ref: Reference<"query", I, O>, input: I): () => void;
+    dispose(): void;
+    onError(error: AppError): void;
+}

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,
+  createView,
+  defineClient,
+  reference,
+  useAction,
+  useMutation,
+  useQuery
+} from "./chunk-3XA36UOQ.js";
+import {
+  AppError,
+  appError
+} from "./chunk-IJBQ77AH.js";
+export {
+  AppError,
+  ClientProvider,
+  appError,
+  createApi,
+  createClient,
+  createRemoteComponent,
+  createSessionProvider,
+  createView,
+  defineClient,
+  reference,
+  useAction,
+  useMutation,
+  useQuery
+};

package/dist/config/config.d.ts

@@ -6,13 +6,17 @@ 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;
     logos: z.ZodOptional<z.ZodObject<{
         dark: z.ZodOptional<z.ZodString>;
         light: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
-}, z.core.$strip>;
+    server: z.ZodOptional<z.ZodObject<{
+        entry: z.ZodDefault<z.ZodString>;
+        migrations: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
 export type TailorKitConfig = z.input<typeof tailorkitConfigSchema>;
 export type ResolvedTailorKitConfig = z.output<typeof tailorkitConfigSchema>;
 export { tailorkitConfigSchema };

package/dist/config-loader.js

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

package/dist/config.js

@@ -1,7 +1,7 @@
 import {
   defineConfig,
   defineTailorKitConfig
-} from "./chunk-ZFYKVXDO.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,87 +1,2 @@
-import { h } from "preact";
-import type { ComponentChild, ComponentChildren, VNode } from "preact";
-export interface TailorKitViews {
-}
-export interface TailorKitSlots {
-}
-export type SlotName = keyof TailorKitSlots & string;
-export type ViewPath = Extract<keyof TailorKitViews & string, `/${string}`>;
-export type AppViewPath = ViewPath;
-export type ViewProps<TPath extends ViewPath> = TailorKitViews[TPath] extends object ? TailorKitViews[TPath] : Record<string, never>;
-export type ViewPropsForPath<TPath extends AppViewPath> = TPath extends ViewPath ? ViewProps<TPath> : never;
-export type ViewContext<TPath extends AppViewPath> = ViewPropsForPath<TPath> extends {
-    context: infer TContext;
-} ? TContext : Record<string, never>;
-export type View<TProps extends object = Record<string, never>> = (props: TProps) => ComponentChild;
-export type ViewRuntimeProps<TPath extends AppViewPath> = {
-    context: ViewContext<TPath>;
-    view: TPath;
-    status: "ready";
-} | {
-    context?: never;
-    view: TPath;
-    status: "loading";
-} | {
-    context?: never;
-    view: TPath;
-    status: "error";
-};
-export interface ViewDefinition<TPath extends AppViewPath = AppViewPath> {
-    component: View<ViewRuntimeProps<TPath>>;
-    path: TPath;
-    useContext: () => ViewContext<TPath>;
-}
-type RegisteredViews = {
-    [TPath in AppViewPath]: ViewDefinition<TPath>;
-};
-type ViewDefinitions = Partial<{
-    [P in AppViewPath]: RegisteredViews[P] | false;
-}>;
-type InvalidViewPath<TViews> = Exclude<keyof TViews & string, AppViewPath>;
-type RequireViewPaths<TViews> = InvalidViewPath<TViews> extends never ? unknown : {
-    readonly __tailorkit_error__: `View paths must be declared by the host. Invalid view: ${InvalidViewPath<TViews>}`;
-};
-type ViewKeyPathMismatch<TViews> = {
-    [TPath in keyof TViews & string]: TViews[TPath] extends false ? never : TViews[TPath] extends ViewDefinition<infer TViewPath> ? TViewPath extends TPath ? never : TPath : TPath;
-}[keyof TViews & string];
-type RequireMatchingViewKeys<TViews> = ViewKeyPathMismatch<TViews> extends never ? unknown : {
-    readonly __tailorkit_error__: `View key must match createView path. Invalid view: ${ViewKeyPathMismatch<TViews>}`;
-};
-export type SlotView<TSlot extends SlotName> = Extract<TailorKitSlots[TSlot], AppViewPath>;
-type SlotDefinitions = {
-    [V in SlotName]?: Pick<ViewDefinitions, SlotView<V>>;
-};
-type RequireSlotViews<V, S> = V extends SlotName ? Exclude<keyof S, SlotView<V>> extends never ? unknown : {
-    readonly __tailorkit_error__: "View is not supported by this slot";
-} : never;
-export interface TailorKitClient<TSlots extends SlotDefinitions = SlotDefinitions> {
-    slots: TSlots;
-}
-export interface TailorKitClientMeta {
-    preactVersion: string;
-}
-export interface TailorKitClientRuntime {
-    h: typeof h;
-    render: (vnode: VNode | null, parent: Element | Document | ShadowRoot | DocumentFragment) => void;
-}
-export type TailorKitClientWithMeta<TViews extends SlotDefinitions = SlotDefinitions> = TailorKitClient<TViews> & {
-    $meta: TailorKitClientMeta;
-    $runtime: TailorKitClientRuntime;
-};
-export declare const createView: <const TPath extends AppViewPath>(path: TPath, options: {
-    component: View<Record<string, never>>;
-    error?: View<Record<string, never>>;
-    loading?: View<Record<string, never>>;
-}) => ViewDefinition<TPath>;
-export declare const defineClient: <const TSlots extends SlotDefinitions>(client: TailorKitClient<TSlots> & {
-    slots: { [V in keyof TSlots]: TSlots[V] & RequireViewPaths<TSlots[V]> & RequireMatchingViewKeys<TSlots[V]> & RequireSlotViews<V, TSlots[V]>; };
-} & (Exclude<keyof TSlots, SlotName> extends never ? unknown : {
-    __tailorkit_error__: "Unknown slot";
-})) => TailorKitClientWithMeta<TSlots>;
-export declare const createRemoteComponent: <TProps extends object, TChildren extends boolean = false>(name: string, options?: {
-    callbacks?: Record<string, number>;
-    children?: TChildren;
-}) => View<TProps & {
-    children?: TChildren extends true ? ComponentChildren : never;
-}>;
-export {};
+export * from "./client";
+export * from "./server";