@tailorkit/app 0.1.0-beta.8 → 1.0.0-beta.44

package/dist/server/builder.d.ts

@@ -0,0 +1,46 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { AnyRelations, EmptyRelations } from "drizzle-orm/relations";
+import * as v from "valibot";
+import type { DatabaseDefinition } from "#database/definition";
+import type { MutationDatabase, QueryDatabase } from "#database/types";
+import type { ActionContext, EmptyFunctions, FunctionKind, Functions, Identity } from "./functions";
+type HandlerContext<K extends FunctionKind, A extends StandardSchemaV1, F extends Functions, D extends AnyRelations> = {
+    input: StandardSchemaV1.InferOutput<A>;
+} & (K extends "action" ? ActionContext<F> : {
+    db: K extends "query" ? QueryDatabase<D> : MutationDatabase<D>;
+    identity: Identity;
+});
+type OutputInput<R> = R extends StandardSchemaV1 ? StandardSchemaV1.InferInput<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 StandardSchemaV1, 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: StandardSchemaV1.InferOutput<A>;
+    }) => HandlerOutput<K, O>;
+} & (R extends StandardSchemaV1 ? {
+    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 StandardSchemaV1, R extends StandardSchemaV1 | undefined = undefined, F extends Functions = EmptyFunctions, 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 StandardSchemaV1>(schema: S): FunctionBuilder<K, S, R, F, D>;
+    output<S extends StandardSchemaV1>(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", v.UndefinedSchema<undefined>, undefined, {}, EmptyRelations>;
+    mutation: FunctionBuilder<"mutation", v.UndefinedSchema<undefined>, undefined, {}, EmptyRelations>;
+    query: FunctionBuilder<"query", v.UndefinedSchema<undefined>, 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,113 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { AnyRelations, EmptyRelations } from "drizzle-orm/relations";
+import type { TailorKitServerTools } from "#client/tools";
+import type { DatabaseDefinition } from "#database/definition";
+import type { QueryDatabase, MutationDatabase } from "#database/types";
+import type { JsonValue } from "#validation";
+export type EmptyFunctions = Record<never, never>;
+export interface Identity {
+    readonly subjectId?: string;
+    readonly scope: {
+        name: string;
+        value: Record<string, JsonValue>;
+    };
+    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 StandardSchemaV1;
+} ? StandardSchemaV1.InferOutput<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 StandardSchemaV1;
+        handler: (context: never) => infer _Output;
+    } ? K extends "mutation" ? (...args: undefined extends StandardSchemaV1.InferInput<A> ? [
+        args?: StandardSchemaV1.InferInput<A>,
+        options?: {
+            requestId?: string;
+        }
+    ] : [
+        args: StandardSchemaV1.InferInput<A>,
+        options?: {
+            requestId?: string;
+        }
+    ]) => Promise<FunctionResult<F[N]>> : (...args: undefined extends StandardSchemaV1.InferInput<A> ? [args?: StandardSchemaV1.InferInput<A>] : [args: StandardSchemaV1.InferInput<A>]) => Promise<FunctionResult<F[N]>> : F[N] extends Functions ? FunctionCalls<F[N], K> : never;
+};
+export interface ActionContext<F extends Functions = EmptyFunctions> {
+    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 StandardSchemaV1, O, F extends Functions = EmptyFunctions, D extends AnyRelations = EmptyRelations> {
+    readonly kind: K;
+    readonly args: A;
+    readonly database?: K extends "action" ? never : DatabaseDefinition<D>;
+    readonly result?: StandardSchemaV1<unknown, O>;
+    readonly handler: (context: {
+        args: StandardSchemaV1.InferOutput<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 StandardSchemaV1, O, const D extends AnyRelations = EmptyRelations>(definition: Omit<FunctionDefinition<"query", A, O, EmptyFunctions, D>, "kind"> & {
+    handler: FunctionDefinition<"query", A, O, EmptyFunctions, D>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
+}) => Readonly<{
+    args: A;
+    database?: DatabaseDefinition<D> | undefined;
+    result?: StandardSchemaV1<unknown, O> | undefined;
+    handler: FunctionDefinition<"query", A, O, EmptyFunctions, D>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
+    kind: "query";
+}>;
+export declare const mutation: <A extends StandardSchemaV1, O, const D extends AnyRelations = EmptyRelations>(definition: Omit<FunctionDefinition<"mutation", A, O, EmptyFunctions, D>, "kind"> & {
+    handler: FunctionDefinition<"mutation", A, O, EmptyFunctions, D>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
+}) => Readonly<{
+    args: A;
+    database?: DatabaseDefinition<D> | undefined;
+    result?: StandardSchemaV1<unknown, O> | undefined;
+    handler: FunctionDefinition<"mutation", A, O, EmptyFunctions, D>["handler"] & ([O] extends [never] ? unknown : O extends PromiseLike<unknown> ? never : unknown);
+    kind: "mutation";
+}>;
+export declare const action: <A extends StandardSchemaV1, O, const F extends Functions = EmptyFunctions>(definition: Omit<FunctionDefinition<"action", A, O, F>, "kind"> & {
+    functions?: F;
+}) => Readonly<{
+    args: A;
+    database?: undefined;
+    result?: StandardSchemaV1<unknown, O> | undefined;
+    handler: (context: {
+        args: StandardSchemaV1.InferOutput<A>;
+    } & ActionContext<F>) => O | Promise<O>;
+    functions?: F;
+    kind: "action";
+}>;
+export interface RegisteredFunction<TOutput = unknown> {
+    kind: FunctionKind;
+    args: StandardSchemaV1;
+    result?: StandardSchemaV1;
+    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 type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { ViewDataFields } from "#views";
+import type { AppDefinition, Identity } from "./functions";
+interface InstanceResolver<TOutput = unknown> {
+    slot: string;
+    path: string;
+    dataSchema: StandardSchemaV1;
+    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 { EmptyFunctions, 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-QDZXHVTU.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
+};

package/dist/validation.d.ts

@@ -0,0 +1,5 @@
+import * as v from "valibot";
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export declare const jsonValueSchema: v.GenericSchema<JsonValue>;

package/dist/views.d.ts

@@ -0,0 +1,126 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import { h } from "preact";
+import type { ComponentChild, ComponentChildren, VNode } from "preact";
+import type { FunctionCalls, Identity } from "./server/functions";
+export interface TailorKitViews {
+}
+export interface TailorKitSlots {
+}
+export interface TailorKitServerFunctions {
+}
+export type ViewDataFields = Record<string, unknown>;
+export interface ViewInstance<TData = unknown> {
+    key: string;
+    metadata: ViewDataFields;
+    data: TData;
+}
+export interface InstanceResolverContext<TPath extends AppViewPath> {
+    context: ViewContext<TPath>;
+    identity: Identity;
+    signal: AbortSignal;
+    queries: FunctionCalls<TailorKitServerFunctions, "query">;
+}
+export interface ViewInstances<TPath extends AppViewPath, TSchema extends StandardSchemaV1> {
+    dataSchema: TSchema;
+    /** Runs on the app server. Only registered queries are available. */
+    resolve: (context: InstanceResolverContext<TPath>) => ViewInstance<StandardSchemaV1.InferInput<TSchema>>[] | Promise<ViewInstance<StandardSchemaV1.InferInput<TSchema>>[]>;
+}
+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, TData = unknown> = {
+    context: ViewContext<TPath>;
+    view: TPath;
+    status: "ready";
+    instance?: ViewInstance<TData>;
+} | {
+    context?: never;
+    view: TPath;
+    status: "loading";
+    instance?: never;
+} | {
+    context?: never;
+    view: TPath;
+    status: "error";
+    instance?: never;
+};
+export interface ViewDefinition<TPath extends AppViewPath = AppViewPath, TData = unknown, TSlot extends SlotName = SlotName> {
+    component: View<ViewRuntimeProps<TPath>>;
+    path: TPath;
+    slot: TSlot;
+    useContext: () => ViewContext<TPath>;
+    /** The selected instance, with data inferred from instances.dataSchema. */
+    useInstance: () => ViewInstance<TData>;
+    /** Build-only lookup key connecting this view to its extracted server implementation. */
+    instances?: {
+        resolver: string;
+    };
+}
+export type SlotView<TSlot extends SlotName> = TailorKitSlots[TSlot] extends {
+    views: infer TViews;
+} ? Extract<TViews, AppViewPath> : never;
+type SlotInstanceDefinition<TSlot extends SlotName> = TailorKitSlots[TSlot] extends {
+    multiple: true;
+} ? {
+    instances: {
+        resolver: string;
+    };
+} : {
+    instances?: never;
+};
+type SlotDefinitions = {
+    [V in SlotName]?: Partial<{
+        [P in SlotView<V>]: (ViewDefinition<P, unknown, V> & SlotInstanceDefinition<V>) | false;
+    }>;
+};
+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;
+};
+type ViewOptions<TPath extends AppViewPath, TSlot extends SlotName, TSchema extends StandardSchemaV1> = {
+    [S in TSlot]: {
+        slot: S;
+        view: TPath;
+        component: View;
+    } & (TPath extends SlotView<S> ? unknown : {
+        readonly __tailorkit_error__: "View is not supported by this slot";
+    }) & (TailorKitSlots[S] extends {
+        multiple: true;
+    } ? {
+        instances: ViewInstances<TPath, TSchema>;
+    } : {
+        instances?: never;
+    });
+}[TSlot];
+/** In .view.tsx files, the builder supplies the slot and filename-derived path.
+ * An explicit view must match the file path and provides precise host context typing. */
+export declare function defineView<const TPath extends AppViewPath = AppViewPath, TSchema extends StandardSchemaV1 = StandardSchemaV1>(options: {
+    slot?: never;
+    view?: TPath;
+    component: View;
+    instances?: ViewInstances<TPath, TSchema>;
+}): ViewDefinition<TPath, StandardSchemaV1.InferOutput<TSchema>>;
+export declare function defineView<const TPath extends AppViewPath, const TSlot extends SlotName, TSchema extends StandardSchemaV1>(options: ViewOptions<TPath, TSlot, TSchema>): ViewDefinition<TPath, StandardSchemaV1.InferOutput<TSchema>, TSlot> & SlotInstanceDefinition<TSlot>;
+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 {};

package/package.json

@@ -1,56 +1,93 @@
 {
   "name": "@tailorkit/app",
-  "version": "0.1.0-beta.8",
-  "license": "AGPL-3.0-only",
+  "version": "1.0.0-beta.44",
+  "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/AlfieJones/tailorkit.git",
+    "url": "git+https://github.com/TailorKit-Labs/TailorKit.git",
     "directory": "packages/app"
   },
   "files": [
     "dist"
   ],
   "type": "module",
+  "imports": {
+    "#env": "./src/env.ts",
+    "#*": {
+      "development": [
+        "./src/*",
+        "./src/*.ts",
+        "./src/*.tsx",
+        "./src/*/index.ts",
+        "./src/*/index.tsx"
+      ],
+      "types": [
+        "./dist/*",
+        "./dist/*.d.ts",
+        "./dist/*/index.d.ts"
+      ],
+      "default": [
+        "./src/*",
+        "./src/*.ts",
+        "./src/*.tsx",
+        "./src/*/index.ts",
+        "./src/*/index.tsx"
+      ]
+    }
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./config": {
-      "types": "./dist/config/index.d.ts",
-      "import": "./dist/config.js"
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
     },
-    "./config/loader": {
-      "types": "./dist/config/loader.d.ts",
-      "import": "./dist/config-loader.js"
+    "./protocol": {
+      "types": "./dist/protocol.d.ts",
+      "import": "./dist/protocol.js"
     },
-    "./builder": {
-      "types": "./dist/builder/index.d.ts",
-      "import": "./dist/builder.js"
+    "./client/connection": {
+      "types": "./dist/client/connection.d.ts",
+      "import": "./dist/client-connection.js"
     }
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@tailorkit/core": "0.1.0-beta.8",
-    "cosmiconfig": "^10.0.0",
-    "vite": "^8.2.2",
-    "zod": "^4.4.3"
+    "@nanostores/preact": "1.1.1",
+    "@orpc/client": "2.0.0-beta.40",
+    "@orpc/contract": "2.0.0-beta.40",
+    "@standard-schema/spec": "^1.1.0",
+    "drizzle-orm": "1.0.0-rc.4-5d5b77c",
+    "nanostores": "1.5.5",
+    "valibot": "^1.5.0"
   },
   "devDependencies": {
-    "@tailorkit/asset-delivery": "0.0.0",
     "@tailorkit/config": "0.0.0",
-    "@types/node": "26.2.0",
-    "preact": "^10.29.8",
+    "@types/node": "26.6.4",
+    "happy-dom": "^20.14.6",
+    "preact": "^11.0.1",
     "tsup": "^8.5.1",
-    "typescript": "^7.0.2"
+    "typescript": "^7.0.2",
+    "vite": "npm:@voidzero-dev/vite-plus-core@1.1.0",
+    "vite-plus": "1.1.0",
+    "zod": "^4.6.5"
   },
   "peerDependencies": {
-    "preact": "^10.0.0"
+    "preact": "^11.0.0"
   },
   "scripts": {
     "build": "tsup --config tsup.config.ts && tsc -p tsconfig.build.json",
-    "check-types": "tsc --noEmit"
+    "check-types": "tsc --noEmit",
+    "test": "vp test run",
+    "lint": "vp lint .",
+    "lint:fix": "vp lint --fix ."
   }
 }