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

package/dist/server/builder.d.ts

@@ -1,18 +1,21 @@
 import { z } from "zod";
+import type { AnyRelations, EmptyRelations } from "drizzle-orm/relations";
+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> = {
+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 : MutationDatabase;
+    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> = {
+type BuiltFunction<K extends FunctionKind, A extends z.ZodType, R, O, F extends Functions, D extends AnyRelations> = {
     readonly kind: K;
     readonly args: A;
-    readonly handler: (context: Omit<HandlerContext<K, A, F>, "input"> & {
+    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 ? {
@@ -21,20 +24,22 @@ type BuiltFunction<K extends FunctionKind, A extends z.ZodType, R, O, F extends
     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>> {
+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;
-    constructor(kind: K, args: A, result: R, calls: F);
-    input<S extends z.ZodType>(schema: S): FunctionBuilder<K, S, R, F>;
-    output<S extends z.ZodType>(schema: S): FunctionBuilder<K, A, S, F>;
-    functions<const G extends Functions>(this: FunctionBuilder<"action", A, R, F>, functions: G): FunctionBuilder<"action", A, R, G>;
-    handler<O extends OutputInput<R>>(handler: (context: HandlerContext<K, A, F>) => HandlerOutput<K, O>): BuiltFunction<K, A, R, O, F>;
+    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 tk: Readonly<{
-    query: FunctionBuilder<"query", z.ZodUndefined, undefined, {}>;
-    mutation: FunctionBuilder<"mutation", z.ZodUndefined, undefined, {}>;
-    action: FunctionBuilder<"action", z.ZodUndefined, undefined, {}>;
+    query: FunctionBuilder<"query", z.ZodUndefined, undefined, {}, EmptyRelations>;
+    mutation: FunctionBuilder<"mutation", z.ZodUndefined, undefined, {}, EmptyRelations>;
+    action: FunctionBuilder<"action", z.ZodUndefined, undefined, {}, EmptyRelations>;
 }>;
 export {};

package/dist/server/bundle.d.ts

@@ -13,5 +13,5 @@ export interface ApplicationModule {
 /** Emitted by this SDK's builder; breaking interface changes increment apiVersion. */
 export declare const runtimeManifest: {
     readonly apiVersion: 1;
-    readonly requires: readonly ["database", "actions"];
+    readonly requires: readonly ["database", "actions", "database-relations"];
 };

package/dist/server/functions.d.ts

@@ -1,4 +1,6 @@
 import type { z } from "zod";
+import type { AnyRelations, EmptyRelations } from "drizzle-orm/relations";
+import type { DatabaseDefinition } from "../database/definition";
 import type { QueryDatabase, MutationDatabase } from "../database/types";
 export interface Identity {
     readonly userId: string;
@@ -34,37 +36,41 @@ export interface ActionContext<F extends Functions = Record<never, never>> {
     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>> {
+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 : MutationDatabase;
+        db: K extends "query" ? QueryDatabase<D> : MutationDatabase<D>;
         identity: Identity;
     })) => K extends "action" ? O | Promise<O> : O;
 }
-export declare function query<A extends z.ZodType, O>(definition: Omit<FunctionDefinition<"query", A, O>, "kind"> & {
-    handler: FunctionDefinition<"query", A, O>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
+export declare function 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>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
+    handler: FunctionDefinition<"query", A, O, Record<never, never>, D>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
     kind: "query";
 }>;
-export declare function mutation<A extends z.ZodType, O>(definition: Omit<FunctionDefinition<"mutation", A, O>, "kind"> & {
-    handler: FunctionDefinition<"mutation", A, O>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
+export declare function 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>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
+    handler: FunctionDefinition<"mutation", A, O, Record<never, never>, D>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
     kind: "mutation";
 }>;
 export declare function 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>;
@@ -78,6 +84,7 @@ export type RegisteredFunction = {
     result?: z.ZodType;
     handler: (context: never) => unknown;
     functions?: Functions;
+    database?: DatabaseDefinition;
 };
 export interface Functions {
     readonly [name: string]: RegisteredFunction | Functions;

package/dist/server.d.ts

@@ -1,4 +1,6 @@
 export { defineServer, query, mutation, action } from "./server/functions";
+export { defineDatabase } from "./database/definition";
+export type { DatabaseDefinition } from "./database/definition";
 export { tk } from "./server/builder";
 export { withInstanceResolvers } from "./server/instances";
 export type { QueryDatabase, MutationDatabase } from "./database/types";

package/dist/server.js

@@ -4,6 +4,7 @@ import {
   asc,
   boolean,
   count,
+  defineDatabase,
   defineServer,
   desc,
   eq,
@@ -24,7 +25,7 @@ import {
   text,
   tk,
   withInstanceResolvers
-} from "./chunk-7NOEYJOB.js";
+} from "./chunk-ANTVMHDZ.js";
 import {
   AppError
 } from "./chunk-IJBQ77AH.js";
@@ -35,6 +36,7 @@ export {
   asc,
   boolean,
   count,
+  defineDatabase,
   defineServer,
   desc,
   eq,

package/dist/views.d.ts

@@ -1,5 +1,5 @@
 import { h } from "preact";
-import type { ComponentChild, ComponentChildren, ComponentType, VNode } from "preact";
+import type { ComponentChild, ComponentChildren, VNode } from "preact";
 import type { z } from "zod";
 import type { FunctionCalls, Identity } from "./server/functions";
 export interface TailorKitViews {
@@ -61,16 +61,6 @@ export interface ViewDefinition<TPath extends AppViewPath = AppViewPath, TData =
         resolver: string;
     };
 }
-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 defineView path. Invalid view: ${ViewKeyPathMismatch<TViews>}`;
-};
 export type SlotView<TSlot extends SlotName> = TailorKitSlots[TSlot] extends {
     views: infer TViews;
 } ? Extract<TViews, AppViewPath> : never;
@@ -88,15 +78,8 @@ type SlotDefinitions = {
         [P in SlotView<V>]: (ViewDefinition<P, unknown, V> & SlotInstanceDefinition<V>) | false;
     }>;
 };
-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;
-    /** Wrap the app root with providers shared by every view. */
-    component?: ComponentType<{
-        children?: ComponentChildren;
-    }>;
 }
 export interface TailorKitClientMeta {
     preactVersion: string;
@@ -124,12 +107,15 @@ type ViewOptions<TPath extends AppViewPath, TSlot extends SlotName, TSchema exte
         instances?: never;
     });
 }[TSlot];
-export declare const defineView: <const TPath extends AppViewPath, const TSlot extends SlotName, TSchema extends z.ZodType>(options: ViewOptions<TPath, TSlot, TSchema>) => ViewDefinition<TPath, z.output<TSchema>, TSlot> & SlotInstanceDefinition<TSlot>;
-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>;
+/** In .view.tsx files, the builder supplies the slot and filename-derived path.
+ * Keep an explicit view for a custom path and precise host context typing. */
+export declare function defineView<const TPath extends AppViewPath = AppViewPath, TSchema extends z.ZodType = z.ZodType>(options: {
+    slot?: never;
+    view?: TPath;
+    component: View<Record<string, never>>;
+    instances?: ViewInstances<TPath, TSchema>;
+}): ViewDefinition<TPath, z.output<TSchema>>;
+export declare function defineView<const TPath extends AppViewPath, const TSlot extends SlotName, TSchema extends z.ZodType>(options: ViewOptions<TPath, TSlot, TSchema>): ViewDefinition<TPath, z.output<TSchema>, TSlot> & SlotInstanceDefinition<TSlot>;
 export declare const createRemoteComponent: <TProps extends object, TChildren extends boolean = false>(name: string, options?: {
     callbacks?: Record<string, number>;
     children?: TChildren;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tailorkit/app",
-  "version": "0.1.0-beta.23",
+  "version": "0.1.0-beta.24",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -39,6 +39,10 @@
     "./protocol": {
       "types": "./dist/protocol.d.ts",
       "import": "./dist/protocol.js"
+    },
+    "./client/connection": {
+      "types": "./dist/client/connection.d.ts",
+      "import": "./dist/client-connection.js"
     }
   },
   "publishConfig": {