zenstack-trpc 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,284 @@
+# zenstack-trpc
+
+Auto-generate fully type-safe tRPC routers from [ZenStack V3](https://zenstack.dev) schemas.
+
+## Features
+
+- **Zero codegen** - Router generated at runtime from schema metadata
+- **Full type inference** - Input AND output types from your ZenStack schema
+- **Dynamic result typing** - `include`/`select` options reflected in return types
+- **Zod validation** - Runtime input validation built-in
+- **All CRUD operations** - findMany, findUnique, create, update, delete, and more
+- **Standard tRPC** - Works with all tRPC adapters (HTTP, WebSocket, Next.js, etc.)
+
+## Installation
+
+```bash
+npm install zenstack-trpc @trpc/server @zenstackhq/orm zod
+# or
+pnpm add zenstack-trpc @trpc/server @zenstackhq/orm zod
+# or
+yarn add zenstack-trpc @trpc/server @zenstackhq/orm zod
+```
+
+## Quick Start
+
+### 1. Define your ZenStack schema
+
+```prisma
+// schema.zmodel
+model User {
+  id        String   @id @default(cuid())
+  email     String   @unique
+  name      String?
+  posts     Post[]
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+
+model Post {
+  id        String   @id @default(cuid())
+  title     String
+  content   String?
+  published Boolean  @default(false)
+  author    User     @relation(fields: [authorId], references: [id])
+  authorId  String
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+```
+
+### 2. Generate ZenStack artifacts
+
+```bash
+npx zenstack generate
+```
+
+### 3. Create the tRPC router
+
+```typescript
+import { ZenStackClient } from "@zenstackhq/orm";
+import { schema, SchemaType } from "./zenstack/schema.js";
+import {
+  createTRPC,
+  createZenStackRouter,
+  type Context,
+  type TypedRouterCaller,
+} from "zenstack-trpc";
+
+// Create your database client
+const db = new ZenStackClient(schema, {
+  dialect: yourDialect, // Kysely dialect (SQLite, PostgreSQL, MySQL, etc.)
+});
+
+// Create tRPC instance
+const t = createTRPC<Context>();
+
+// Generate the router from your schema
+const appRouter = createZenStackRouter(schema, t);
+
+// Export for client usage
+export type AppRouter = typeof appRouter;
+```
+
+### 4. Use the router
+
+```typescript
+// Create a typed caller
+const caller = appRouter.createCaller({ db }) as TypedRouterCaller<SchemaType>;
+
+// All operations are fully typed!
+const users = await caller.user.findMany();
+//    ^? { id: string, email: string, name: string | null, ... }[]
+
+// Include relations - return type automatically includes them
+const usersWithPosts = await caller.user.findMany({
+  include: { posts: true }
+});
+//    ^? { id: string, ..., posts: Post[] }[]
+
+// Select specific fields
+const emails = await caller.user.findMany({
+  select: { id: true, email: true }
+});
+//    ^? { id: string, email: string }[]
+
+// Create with full validation
+const user = await caller.user.create({
+  data: {
+    email: "alice@example.com",
+    name: "Alice",
+  },
+});
+
+// Update with type-safe where clause
+await caller.user.update({
+  where: { id: user.id },
+  data: { name: "Alice Smith" },
+});
+```
+
+## API Reference
+
+### `createTRPC<Context>()`
+
+Creates a tRPC instance with the given context type.
+
+```typescript
+import { createTRPC, type Context } from "zenstack-trpc";
+
+const t = createTRPC<Context>();
+```
+
+### `createZenStackRouter(schema, t)`
+
+Generates a tRPC router from a ZenStack schema.
+
+```typescript
+import { createZenStackRouter } from "zenstack-trpc";
+
+const appRouter = createZenStackRouter(schema, t);
+```
+
+### `TypedRouterCaller<SchemaType>`
+
+Type helper for fully typed caller with dynamic input/output inference.
+
+```typescript
+import type { TypedRouterCaller } from "zenstack-trpc";
+import type { SchemaType } from "./zenstack/schema.js";
+
+const caller = appRouter.createCaller({ db }) as TypedRouterCaller<SchemaType>;
+```
+
+### `TypedModelProcedures<Schema, Model>`
+
+Type helper for a single model's procedures.
+
+```typescript
+import type { TypedModelProcedures } from "zenstack-trpc";
+
+type UserProcedures = TypedModelProcedures<SchemaType, "User">;
+```
+
+## Generated Router Structure
+
+For each model in your schema, the following procedures are generated:
+
+```
+router
+├── user
+│   ├── findMany    (query)
+│   ├── findUnique  (query)
+│   ├── findFirst   (query)
+│   ├── create      (mutation)
+│   ├── createMany  (mutation)
+│   ├── update      (mutation)
+│   ├── updateMany  (mutation)
+│   ├── upsert      (mutation)
+│   ├── delete      (mutation)
+│   ├── deleteMany  (mutation)
+│   ├── count       (query)
+│   ├── aggregate   (query)
+│   └── groupBy     (query)
+├── post
+│   └── ... (same operations)
+```
+
+## Using with tRPC Adapters
+
+### Standalone HTTP Server
+
+```typescript
+import { createHTTPServer } from "@trpc/server/adapters/standalone";
+
+const server = createHTTPServer({
+  router: appRouter,
+  createContext: () => ({ db }),
+});
+
+server.listen(3000);
+```
+
+### Next.js App Router
+
+```typescript
+// app/api/trpc/[trpc]/route.ts
+import { fetchRequestHandler } from "@trpc/server/adapters/fetch";
+
+const handler = (req: Request) =>
+  fetchRequestHandler({
+    endpoint: "/api/trpc",
+    req,
+    router: appRouter,
+    createContext: () => ({ db }),
+  });
+
+export { handler as GET, handler as POST };
+```
+
+### Express
+
+```typescript
+import express from "express";
+import { createExpressMiddleware } from "@trpc/server/adapters/express";
+
+const app = express();
+
+app.use(
+  "/trpc",
+  createExpressMiddleware({
+    router: appRouter,
+    createContext: () => ({ db }),
+  })
+);
+```
+
+## Advanced Usage
+
+### Custom Context
+
+Extend the context with authentication or other data:
+
+```typescript
+interface MyContext extends Context {
+  db: any;
+  userId?: string;
+}
+
+const t = createTRPC<MyContext>();
+const appRouter = createZenStackRouter(schema, t);
+
+// In your adapter
+createContext: (opts) => ({
+  db: getEnhancedDb(opts.req), // ZenStack enhanced client with access control
+  userId: getUserFromRequest(opts.req),
+});
+```
+
+### Zod Schema Access
+
+Access the generated Zod schemas for custom validation:
+
+```typescript
+import {
+  createModelSchemas,
+  createWhereSchema,
+  createCreateDataSchema,
+} from "zenstack-trpc";
+
+const userSchemas = createModelSchemas(schema, "User");
+const whereSchema = createWhereSchema(schema, "User");
+```
+
+## Requirements
+
+- Node.js >= 18
+- TypeScript >= 5.0
+- ZenStack V3 (`@zenstackhq/orm` >= 3.0.0)
+- tRPC >= 11.0.0
+- Zod >= 3.0.0
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * zenstack-trpc
+ *
+ * Auto-generate fully type-safe tRPC routers from ZenStack V3 schemas.
+ *
+ * @example
+ * ```typescript
+ * import { ZenStackClient } from "@zenstackhq/orm";
+ * import { schema, SchemaType } from "./zenstack/schema.js";
+ * import {
+ *   createTRPC,
+ *   createZenStackRouter,
+ *   type Context,
+ *   type TypedRouterCaller,
+ * } from "zenstack-trpc";
+ *
+ * const db = new ZenStackClient(schema, { dialect: yourDialect });
+ * const t = createTRPC<Context>();
+ * const appRouter = createZenStackRouter(schema, t);
+ *
+ * // Create a typed caller with full type inference
+ * const caller = appRouter.createCaller({ db }) as TypedRouterCaller<SchemaType>;
+ *
+ * // All operations are fully typed!
+ * const users = await caller.user.findMany({ include: { posts: true } });
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { createTRPC, createZenStackRouter, type Context, type ZenStackRouter, type TypedRouterCaller, type TypedModelProcedures, type TRPCInstance, } from "./router-generator.js";
+export { createModelSchemas, createWhereSchema, createCreateDataSchema, createUpdateDataSchema, createUniqueWhereSchema, createSelectSchema, createIncludeSchema, createOrderBySchema, } from "./zod-schemas.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAGH,OAAO,EACL,UAAU,EACV,oBAAoB,EACpB,KAAK,OAAO,EACZ,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EACzB,KAAK,YAAY,GAClB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,sBAAsB,EACtB,sBAAsB,EACtB,uBAAuB,EACvB,kBAAkB,EAClB,mBAAmB,EACnB,mBAAmB,GACpB,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,33 @@
+/**
+ * zenstack-trpc
+ *
+ * Auto-generate fully type-safe tRPC routers from ZenStack V3 schemas.
+ *
+ * @example
+ * ```typescript
+ * import { ZenStackClient } from "@zenstackhq/orm";
+ * import { schema, SchemaType } from "./zenstack/schema.js";
+ * import {
+ *   createTRPC,
+ *   createZenStackRouter,
+ *   type Context,
+ *   type TypedRouterCaller,
+ * } from "zenstack-trpc";
+ *
+ * const db = new ZenStackClient(schema, { dialect: yourDialect });
+ * const t = createTRPC<Context>();
+ * const appRouter = createZenStackRouter(schema, t);
+ *
+ * // Create a typed caller with full type inference
+ * const caller = appRouter.createCaller({ db }) as TypedRouterCaller<SchemaType>;
+ *
+ * // All operations are fully typed!
+ * const users = await caller.user.findMany({ include: { posts: true } });
+ * ```
+ *
+ * @packageDocumentation
+ */
+// Router generator and types
+export { createTRPC, createZenStackRouter, } from "./router-generator.js";
+// Zod schema generators (for advanced usage)
+export { createModelSchemas, createWhereSchema, createCreateDataSchema, createUpdateDataSchema, createUniqueWhereSchema, createSelectSchema, createIncludeSchema, createOrderBySchema, } from "./zod-schemas.js";

package/dist/router-generator.d.ts

@@ -0,0 +1,284 @@
+import type { SchemaDef, GetModels } from "@zenstackhq/orm/schema";
+import type { FindManyArgs, FindUniqueArgs, FindFirstArgs, CreateArgs, CreateManyArgs, UpdateArgs, UpdateManyArgs, UpsertArgs, DeleteArgs, DeleteManyArgs, CountArgs, AggregateArgs, GroupByArgs, SimplifiedPlainResult } from "@zenstackhq/orm";
+/**
+ * Context type for the tRPC router
+ * The db property accepts any ZenStack client instance
+ */
+export interface Context {
+    db: any;
+}
+declare const _initTRPCResult: import("@trpc/server").TRPCRootObject<Context, object, import("@trpc/server").TRPCRuntimeConfigOptions<Context, object>, {
+    ctx: Context;
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: false;
+}>;
+/**
+ * Type representing the result of initTRPC.context().create()
+ */
+export type TRPCInstance = typeof _initTRPCResult;
+/**
+ * Creates a tRPC instance with the given context
+ * @returns A tRPC instance configured with your context type
+ */
+export declare function createTRPC<TContext extends Context>(): TRPCInstance;
+/**
+ * Type helper to convert model names to lowercase
+ */
+type Uncapitalize<S extends string> = S extends `${infer First}${infer Rest}` ? `${Lowercase<First>}${Rest}` : S;
+/**
+ * Type for a single model's procedures - provides FULL dynamic input AND output typing
+ *
+ * When you pass `include` or `select`, the return type automatically includes those fields!
+ */
+export interface TypedModelProcedures<Schema extends SchemaDef, Model extends GetModels<Schema>> {
+    /**
+     * Find multiple records
+     * @example
+     * // Returns User[] with posts included
+     * const users = await caller.user.findMany({ include: { posts: true } });
+     */
+    findMany<T extends FindManyArgs<Schema, Model>>(input?: T): Promise<SimplifiedPlainResult<Schema, Model, T>[]>;
+    /**
+     * Find a unique record by ID or unique field
+     */
+    findUnique<T extends FindUniqueArgs<Schema, Model>>(input: T): Promise<SimplifiedPlainResult<Schema, Model, T> | null>;
+    /**
+     * Find the first matching record
+     */
+    findFirst<T extends FindFirstArgs<Schema, Model>>(input?: T): Promise<SimplifiedPlainResult<Schema, Model, T> | null>;
+    /**
+     * Create a new record
+     */
+    create<T extends CreateArgs<Schema, Model>>(input: T): Promise<SimplifiedPlainResult<Schema, Model, T>>;
+    /**
+     * Create multiple records
+     */
+    createMany(input: CreateManyArgs<Schema, Model>): Promise<{
+        count: number;
+    }>;
+    /**
+     * Update a record
+     */
+    update<T extends UpdateArgs<Schema, Model>>(input: T): Promise<SimplifiedPlainResult<Schema, Model, T>>;
+    /**
+     * Update multiple records
+     */
+    updateMany(input: UpdateManyArgs<Schema, Model>): Promise<{
+        count: number;
+    }>;
+    /**
+     * Create or update a record
+     */
+    upsert<T extends UpsertArgs<Schema, Model>>(input: T): Promise<SimplifiedPlainResult<Schema, Model, T>>;
+    /**
+     * Delete a record
+     */
+    delete<T extends DeleteArgs<Schema, Model>>(input: T): Promise<SimplifiedPlainResult<Schema, Model, T>>;
+    /**
+     * Delete multiple records
+     */
+    deleteMany(input: DeleteManyArgs<Schema, Model>): Promise<{
+        count: number;
+    }>;
+    /**
+     * Count records
+     */
+    count(input?: CountArgs<Schema, Model>): Promise<number>;
+    /**
+     * Aggregate records
+     */
+    aggregate(input: AggregateArgs<Schema, Model>): Promise<any>;
+    /**
+     * Group records
+     */
+    groupBy(input: GroupByArgs<Schema, Model>): Promise<any[]>;
+}
+/**
+ * Type for the generated router caller - maps model names to their typed procedures
+ *
+ * This provides FULL type inference including:
+ * - Input types (where, data, include, select, etc.)
+ * - Output types that reflect include/select options
+ *
+ * @example
+ * ```ts
+ * const caller = appRouter.createCaller({ db }) as TypedRouterCaller<SchemaType>;
+ *
+ * // Basic query - returns User[]
+ * const users = await caller.user.findMany();
+ *
+ * // With include - returns (User & { posts: Post[] })[]
+ * const usersWithPosts = await caller.user.findMany({ include: { posts: true } });
+ *
+ * // With select - returns { id: string, email: string }[]
+ * const userEmails = await caller.user.findMany({ select: { id: true, email: true } });
+ * ```
+ */
+export type TypedRouterCaller<Schema extends SchemaDef> = {
+    [K in GetModels<Schema> as Uncapitalize<K>]: TypedModelProcedures<Schema, K>;
+};
+/**
+ * Creates a tRPC router from a ZenStack schema.
+ *
+ * The router follows the pattern: router.modelName.operation
+ * Example: router.user.findMany(), router.post.create()
+ *
+ * For proper typing on the caller, use the TypedRouterCaller type:
+ *
+ * @example
+ * ```ts
+ * import { createZenStackRouter, createTRPC, Context, TypedRouterCaller } from './trpc';
+ * import { schema, SchemaType } from '../zenstack/schema';
+ *
+ * const t = createTRPC<Context>();
+ * const appRouter = createZenStackRouter(schema, t);
+ *
+ * // Create a typed caller with FULL type inference
+ * const caller = appRouter.createCaller({ db }) as TypedRouterCaller<SchemaType>;
+ *
+ * // Types are fully inferred based on your query!
+ * const users = await caller.user.findMany();
+ * // ^? { id: string, email: string, name: string | null, ... }[]
+ *
+ * const usersWithPosts = await caller.user.findMany({ include: { posts: true } });
+ * // ^? { id: string, email: string, ..., posts: Post[] }[]
+ *
+ * export type AppRouter = typeof appRouter;
+ * ```
+ */
+export declare function createZenStackRouter<Schema extends SchemaDef>(schema: Schema, t: TRPCInstance): import("@trpc/server").TRPCBuiltRouter<{
+    ctx: Context;
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<Record<string, import("@trpc/server").TRPCBuiltRouter<{
+    ctx: Context;
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    findMany: import("@trpc/server").TRPCQueryProcedure<{
+        input: unknown;
+        output: any;
+        meta: object;
+    }> | import("@trpc/server").TRPCMutationProcedure<{
+        input: unknown;
+        output: any;
+        meta: object;
+    }>;
+    findUnique: import("@trpc/server").TRPCQueryProcedure<{
+        input: unknown;
+        output: any;
+        meta: object;
+    }> | import("@trpc/server").TRPCMutationProcedure<{
+        input: unknown;
+        output: any;
+        meta: object;
+    }>;
+    findFirst: import("@trpc/server").TRPCQueryProcedure<{
+        input: unknown;
+        output: any;
+        meta: object;
+    }> | import("@trpc/server").TRPCMutationProcedure<{
+        input: unknown;
+        output: any;
+        meta: object;
+    }>;
+    count: import("@trpc/server").TRPCQueryProcedure<{
+        input: unknown;
+        output: any;
+        meta: object;
+    }> | import("@trpc/server").TRPCMutationProcedure<{
+        input: unknown;
+        output: any;
+        meta: object;
+    }>;
+    aggregate: import("@trpc/server").TRPCQueryProcedure<{
+        input: unknown;
+        output: any;
+        meta: object;
+    }> | import("@trpc/server").TRPCMutationProcedure<{
+        input: unknown;
+        output: any;
+        meta: object;
+    }>;
+    groupBy: import("@trpc/server").TRPCQueryProcedure<{
+        input: unknown;
+        output: any;
+        meta: object;
+    }> | import("@trpc/server").TRPCMutationProcedure<{
+        input: unknown;
+        output: any;
+        meta: object;
+    }>;
+    create: import("@trpc/server").TRPCQueryProcedure<{
+        input: unknown;
+        output: any;
+        meta: object;
+    }> | import("@trpc/server").TRPCMutationProcedure<{
+        input: unknown;
+        output: any;
+        meta: object;
+    }>;
+    createMany: import("@trpc/server").TRPCQueryProcedure<{
+        input: unknown;
+        output: any;
+        meta: object;
+    }> | import("@trpc/server").TRPCMutationProcedure<{
+        input: unknown;
+        output: any;
+        meta: object;
+    }>;
+    update: import("@trpc/server").TRPCQueryProcedure<{
+        input: unknown;
+        output: any;
+        meta: object;
+    }> | import("@trpc/server").TRPCMutationProcedure<{
+        input: unknown;
+        output: any;
+        meta: object;
+    }>;
+    updateMany: import("@trpc/server").TRPCQueryProcedure<{
+        input: unknown;
+        output: any;
+        meta: object;
+    }> | import("@trpc/server").TRPCMutationProcedure<{
+        input: unknown;
+        output: any;
+        meta: object;
+    }>;
+    upsert: import("@trpc/server").TRPCQueryProcedure<{
+        input: unknown;
+        output: any;
+        meta: object;
+    }> | import("@trpc/server").TRPCMutationProcedure<{
+        input: unknown;
+        output: any;
+        meta: object;
+    }>;
+    delete: import("@trpc/server").TRPCQueryProcedure<{
+        input: unknown;
+        output: any;
+        meta: object;
+    }> | import("@trpc/server").TRPCMutationProcedure<{
+        input: unknown;
+        output: any;
+        meta: object;
+    }>;
+    deleteMany: import("@trpc/server").TRPCQueryProcedure<{
+        input: unknown;
+        output: any;
+        meta: object;
+    }> | import("@trpc/server").TRPCMutationProcedure<{
+        input: unknown;
+        output: any;
+        meta: object;
+    }>;
+}>>>>>;
+/**
+ * Type helper to extract the router type for a given schema
+ */
+export type ZenStackRouter<Schema extends SchemaDef> = ReturnType<typeof createZenStackRouter<Schema>>;
+export {};
+//# sourceMappingURL=router-generator.d.ts.map

package/dist/router-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router-generator.d.ts","sourceRoot":"","sources":["../src/router-generator.ts"],"names":[],"mappings":"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"}

package/dist/router-generator.js

@@ -0,0 +1,93 @@
+import { initTRPC, TRPCError } from "@trpc/server";
+import { createModelSchemas } from "./zod-schemas.js";
+// Internal type for initTRPC result
+const _initTRPCResult = initTRPC.context().create();
+/**
+ * Creates a tRPC instance with the given context
+ * @returns A tRPC instance configured with your context type
+ */
+export function createTRPC() {
+    return initTRPC.context().create();
+}
+/**
+ * Creates procedures for a single model
+ */
+function createModelProcedures(schema, modelName, t) {
+    const schemas = createModelSchemas(schema, modelName);
+    const modelNameLower = modelName.charAt(0).toLowerCase() + modelName.slice(1);
+    const createHandler = (op, isQuery) => {
+        const inputSchema = schemas[op];
+        const handler = async ({ ctx, input }) => {
+            const db = ctx.db;
+            const model = db[modelNameLower];
+            if (!model || typeof model[op] !== "function") {
+                throw new TRPCError({
+                    code: "INTERNAL_SERVER_ERROR",
+                    message: `Operation ${op} not found on model ${modelName}`,
+                });
+            }
+            return model[op](input);
+        };
+        if (isQuery) {
+            return t.procedure.input(inputSchema).query(handler);
+        }
+        else {
+            return t.procedure.input(inputSchema).mutation(handler);
+        }
+    };
+    const procedures = {
+        findMany: createHandler("findMany", true),
+        findUnique: createHandler("findUnique", true),
+        findFirst: createHandler("findFirst", true),
+        count: createHandler("count", true),
+        aggregate: createHandler("aggregate", true),
+        groupBy: createHandler("groupBy", true),
+        create: createHandler("create", false),
+        createMany: createHandler("createMany", false),
+        update: createHandler("update", false),
+        updateMany: createHandler("updateMany", false),
+        upsert: createHandler("upsert", false),
+        delete: createHandler("delete", false),
+        deleteMany: createHandler("deleteMany", false),
+    };
+    return t.router(procedures);
+}
+/**
+ * Creates a tRPC router from a ZenStack schema.
+ *
+ * The router follows the pattern: router.modelName.operation
+ * Example: router.user.findMany(), router.post.create()
+ *
+ * For proper typing on the caller, use the TypedRouterCaller type:
+ *
+ * @example
+ * ```ts
+ * import { createZenStackRouter, createTRPC, Context, TypedRouterCaller } from './trpc';
+ * import { schema, SchemaType } from '../zenstack/schema';
+ *
+ * const t = createTRPC<Context>();
+ * const appRouter = createZenStackRouter(schema, t);
+ *
+ * // Create a typed caller with FULL type inference
+ * const caller = appRouter.createCaller({ db }) as TypedRouterCaller<SchemaType>;
+ *
+ * // Types are fully inferred based on your query!
+ * const users = await caller.user.findMany();
+ * // ^? { id: string, email: string, name: string | null, ... }[]
+ *
+ * const usersWithPosts = await caller.user.findMany({ include: { posts: true } });
+ * // ^? { id: string, email: string, ..., posts: Post[] }[]
+ *
+ * export type AppRouter = typeof appRouter;
+ * ```
+ */
+export function createZenStackRouter(schema, t) {
+    const modelRouters = {};
+    // Get all model names from the schema
+    const modelNames = Object.keys(schema.models);
+    for (const modelName of modelNames) {
+        const modelNameLower = modelName.charAt(0).toLowerCase() + modelName.slice(1);
+        modelRouters[modelNameLower] = createModelProcedures(schema, modelName, t);
+    }
+    return t.router(modelRouters);
+}

package/dist/zod-schemas.d.ts

@@ -0,0 +1,128 @@
+import { z } from "zod";
+import type { SchemaDef } from "@zenstackhq/orm/schema";
+/**
+ * Creates a Zod schema for a model's where input
+ */
+export declare function createWhereSchema<Schema extends SchemaDef>(schema: Schema, modelName: keyof Schema["models"]): z.ZodTypeAny;
+/**
+ * Creates a Zod schema for a model's create data input
+ */
+export declare function createCreateDataSchema<Schema extends SchemaDef>(schema: Schema, modelName: keyof Schema["models"]): z.ZodTypeAny;
+/**
+ * Creates a Zod schema for a model's update data input
+ */
+export declare function createUpdateDataSchema<Schema extends SchemaDef>(schema: Schema, modelName: keyof Schema["models"]): z.ZodTypeAny;
+/**
+ * Creates a Zod schema for unique where input (id or unique fields)
+ */
+export declare function createUniqueWhereSchema<Schema extends SchemaDef>(schema: Schema, modelName: keyof Schema["models"]): z.ZodTypeAny;
+/**
+ * Creates a Zod schema for select input
+ */
+export declare function createSelectSchema<Schema extends SchemaDef>(schema: Schema, modelName: keyof Schema["models"]): z.ZodTypeAny;
+/**
+ * Creates a Zod schema for include input
+ */
+export declare function createIncludeSchema<Schema extends SchemaDef>(schema: Schema, modelName: keyof Schema["models"]): z.ZodTypeAny;
+/**
+ * Creates a Zod schema for orderBy input
+ */
+export declare function createOrderBySchema<Schema extends SchemaDef>(schema: Schema, modelName: keyof Schema["models"]): z.ZodTypeAny;
+/**
+ * Creates all Zod schemas for a model's CRUD operations
+ */
+export declare function createModelSchemas<Schema extends SchemaDef>(schema: Schema, modelName: keyof Schema["models"]): {
+    findMany: z.ZodOptional<z.ZodObject<{
+        where: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        select: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        include: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        orderBy: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        skip: z.ZodOptional<z.ZodNumber>;
+        take: z.ZodOptional<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        distinct: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>>;
+    findUnique: z.ZodObject<{
+        where: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        select: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        include: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }, z.core.$loose>;
+    findFirst: z.ZodOptional<z.ZodObject<{
+        where: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        select: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        include: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        orderBy: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        skip: z.ZodOptional<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    }, z.core.$loose>>;
+    create: z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        select: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        include: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }, z.core.$loose>;
+    createMany: z.ZodOptional<z.ZodObject<{
+        data: z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>]>;
+        skipDuplicates: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>;
+    update: z.ZodObject<{
+        where: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        select: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        include: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }, z.core.$loose>;
+    updateMany: z.ZodObject<{
+        where: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>;
+    upsert: z.ZodObject<{
+        where: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        create: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        update: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        select: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        include: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }, z.core.$loose>;
+    delete: z.ZodObject<{
+        where: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        select: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        include: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }, z.core.$loose>;
+    deleteMany: z.ZodOptional<z.ZodObject<{
+        where: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+    count: z.ZodOptional<z.ZodObject<{
+        where: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        select: z.ZodOptional<z.ZodAny>;
+        cursor: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        skip: z.ZodOptional<z.ZodNumber>;
+        take: z.ZodOptional<z.ZodNumber>;
+        orderBy: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    }, z.core.$loose>>;
+    aggregate: z.ZodObject<{
+        where: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        cursor: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        skip: z.ZodOptional<z.ZodNumber>;
+        take: z.ZodOptional<z.ZodNumber>;
+        orderBy: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        _count: z.ZodOptional<z.ZodAny>;
+        _avg: z.ZodOptional<z.ZodAny>;
+        _sum: z.ZodOptional<z.ZodAny>;
+        _min: z.ZodOptional<z.ZodAny>;
+        _max: z.ZodOptional<z.ZodAny>;
+    }, z.core.$loose>;
+    groupBy: z.ZodObject<{
+        by: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+        where: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        having: z.ZodOptional<z.ZodAny>;
+        orderBy: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        skip: z.ZodOptional<z.ZodNumber>;
+        take: z.ZodOptional<z.ZodNumber>;
+        _count: z.ZodOptional<z.ZodAny>;
+        _avg: z.ZodOptional<z.ZodAny>;
+        _sum: z.ZodOptional<z.ZodAny>;
+        _min: z.ZodOptional<z.ZodAny>;
+        _max: z.ZodOptional<z.ZodAny>;
+    }, z.core.$loose>;
+};
+//# sourceMappingURL=zod-schemas.d.ts.map

package/dist/zod-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-schemas.d.ts","sourceRoot":"","sources":["../src/zod-schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAsDxD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,SAAS,SAAS,EACxD,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,MAAM,CAAC,QAAQ,CAAC,GAChC,CAAC,CAAC,UAAU,CAmDd;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,SAAS,SAAS,EAC7D,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,MAAM,CAAC,QAAQ,CAAC,GAChC,CAAC,CAAC,UAAU,CAyCd;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,SAAS,SAAS,EAC7D,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,MAAM,CAAC,QAAQ,CAAC,GAChC,CAAC,CAAC,UAAU,CAuCd;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,SAAS,SAAS,EAC9D,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,MAAM,CAAC,QAAQ,CAAC,GAChC,CAAC,CAAC,UAAU,CAed;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,SAAS,SAAS,EACzD,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,MAAM,CAAC,QAAQ,CAAC,GAChC,CAAC,CAAC,UAAU,CAcd;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,SAAS,SAAS,EAC1D,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,MAAM,CAAC,QAAQ,CAAC,GAChC,CAAC,CAAC,UAAU,CAiBd;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,SAAS,SAAS,EAC1D,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,MAAM,CAAC,QAAQ,CAAC,GAChC,CAAC,CAAC,UAAU,CAkBd;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,SAAS,SAAS,EACzD,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,MAAM,CAAC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmIlC"}

package/dist/zod-schemas.js

@@ -0,0 +1,362 @@
+import { z } from "zod";
+/**
+ * Maps ZenStack field types to Zod schemas
+ */
+function getZodTypeForField(fieldType, isOptional, isArray) {
+    let baseSchema;
+    switch (fieldType) {
+        case "String":
+            baseSchema = z.string();
+            break;
+        case "Int":
+        case "Float":
+            baseSchema = z.number();
+            break;
+        case "BigInt":
+            baseSchema = z.bigint();
+            break;
+        case "Boolean":
+            baseSchema = z.boolean();
+            break;
+        case "DateTime":
+            baseSchema = z.union([z.date(), z.string().datetime()]);
+            break;
+        case "Json":
+            baseSchema = z.any();
+            break;
+        case "Bytes":
+            baseSchema = z.instanceof(Uint8Array);
+            break;
+        case "Decimal":
+            baseSchema = z.union([z.number(), z.string()]);
+            break;
+        default:
+            // For relation types or unknown types, use any
+            baseSchema = z.any();
+    }
+    if (isArray) {
+        baseSchema = z.array(baseSchema);
+    }
+    if (isOptional) {
+        baseSchema = baseSchema.optional().nullable();
+    }
+    return baseSchema;
+}
+/**
+ * Creates a Zod schema for a model's where input
+ */
+export function createWhereSchema(schema, modelName) {
+    const model = schema.models[modelName];
+    if (!model) {
+        return z.object({}).passthrough();
+    }
+    const fields = model.fields;
+    const shape = {};
+    for (const [fieldName, fieldDef] of Object.entries(fields)) {
+        const isRelation = fieldDef.relation !== undefined;
+        if (isRelation) {
+            // For relations, allow nested where clauses
+            shape[fieldName] = z.any().optional();
+        }
+        else {
+            // For scalar fields, allow direct value or filter object
+            const fieldType = fieldDef.type;
+            const baseType = getZodTypeForField(fieldType, false, false);
+            shape[fieldName] = z
+                .union([
+                baseType,
+                z.object({
+                    equals: baseType.optional(),
+                    not: baseType.optional(),
+                    in: z.array(baseType).optional(),
+                    notIn: z.array(baseType).optional(),
+                    lt: baseType.optional(),
+                    lte: baseType.optional(),
+                    gt: baseType.optional(),
+                    gte: baseType.optional(),
+                    contains: z.string().optional(),
+                    startsWith: z.string().optional(),
+                    endsWith: z.string().optional(),
+                }).passthrough(),
+            ])
+                .optional();
+        }
+    }
+    // Add logical operators
+    const baseSchema = z.object(shape).passthrough();
+    return z
+        .object({
+        AND: z.union([baseSchema, z.array(baseSchema)]).optional(),
+        OR: z.array(baseSchema).optional(),
+        NOT: z.union([baseSchema, z.array(baseSchema)]).optional(),
+    })
+        .merge(baseSchema)
+        .partial();
+}
+/**
+ * Creates a Zod schema for a model's create data input
+ */
+export function createCreateDataSchema(schema, modelName) {
+    const model = schema.models[modelName];
+    if (!model) {
+        return z.object({}).passthrough();
+    }
+    const fields = model.fields;
+    const shape = {};
+    for (const [fieldName, fieldDef] of Object.entries(fields)) {
+        const isRelation = fieldDef.relation !== undefined;
+        const hasDefault = fieldDef.default !== undefined;
+        const isId = fieldDef.id === true;
+        const isUpdatedAt = fieldDef.updatedAt === true;
+        const isOptional = fieldDef.optional === true || hasDefault || isId || isUpdatedAt;
+        const isForeignKey = fieldDef.foreignKeyFor !== undefined;
+        if (isRelation) {
+            // For relations, allow create/connect/connectOrCreate
+            shape[fieldName] = z
+                .object({
+                create: z.any().optional(),
+                connect: z.any().optional(),
+                connectOrCreate: z.any().optional(),
+            })
+                .passthrough()
+                .optional();
+        }
+        else {
+            // Regular fields including foreign keys
+            const fieldType = fieldDef.type;
+            // Foreign keys are optional if a relation is used instead
+            const isFkOptional = isForeignKey ? true : isOptional;
+            shape[fieldName] = getZodTypeForField(fieldType, isFkOptional, fieldDef.array === true);
+        }
+    }
+    return z.object(shape).passthrough();
+}
+/**
+ * Creates a Zod schema for a model's update data input
+ */
+export function createUpdateDataSchema(schema, modelName) {
+    const model = schema.models[modelName];
+    if (!model) {
+        return z.object({}).passthrough();
+    }
+    const fields = model.fields;
+    const shape = {};
+    for (const [fieldName, fieldDef] of Object.entries(fields)) {
+        const isRelation = fieldDef.relation !== undefined;
+        const isId = fieldDef.id === true;
+        if (isId)
+            continue; // Skip id fields for updates
+        if (isRelation) {
+            // For relations, allow full nested operations
+            shape[fieldName] = z
+                .object({
+                create: z.any().optional(),
+                connect: z.any().optional(),
+                connectOrCreate: z.any().optional(),
+                disconnect: z.any().optional(),
+                delete: z.any().optional(),
+                update: z.any().optional(),
+                updateMany: z.any().optional(),
+                deleteMany: z.any().optional(),
+                set: z.any().optional(),
+                upsert: z.any().optional(),
+            })
+                .passthrough()
+                .optional();
+        }
+        else {
+            const fieldType = fieldDef.type;
+            shape[fieldName] = getZodTypeForField(fieldType, true, fieldDef.array === true);
+        }
+    }
+    return z.object(shape).passthrough();
+}
+/**
+ * Creates a Zod schema for unique where input (id or unique fields)
+ */
+export function createUniqueWhereSchema(schema, modelName) {
+    const model = schema.models[modelName];
+    if (!model) {
+        return z.object({}).passthrough();
+    }
+    const uniqueFields = model.uniqueFields;
+    const shape = {};
+    for (const [fieldName, fieldDef] of Object.entries(uniqueFields)) {
+        const fieldType = fieldDef.type;
+        shape[fieldName] = getZodTypeForField(fieldType, true, false);
+    }
+    return z.object(shape).passthrough();
+}
+/**
+ * Creates a Zod schema for select input
+ */
+export function createSelectSchema(schema, modelName) {
+    const model = schema.models[modelName];
+    if (!model) {
+        return z.object({}).passthrough();
+    }
+    const fields = model.fields;
+    const shape = {};
+    for (const fieldName of Object.keys(fields)) {
+        shape[fieldName] = z.union([z.boolean(), z.any()]).optional();
+    }
+    return z.object(shape).passthrough().optional();
+}
+/**
+ * Creates a Zod schema for include input
+ */
+export function createIncludeSchema(schema, modelName) {
+    const model = schema.models[modelName];
+    if (!model) {
+        return z.object({}).passthrough();
+    }
+    const fields = model.fields;
+    const shape = {};
+    for (const [fieldName, fieldDef] of Object.entries(fields)) {
+        const isRelation = fieldDef.relation !== undefined;
+        if (isRelation) {
+            shape[fieldName] = z.union([z.boolean(), z.any()]).optional();
+        }
+    }
+    return z.object(shape).passthrough().optional();
+}
+/**
+ * Creates a Zod schema for orderBy input
+ */
+export function createOrderBySchema(schema, modelName) {
+    const model = schema.models[modelName];
+    if (!model) {
+        return z.any();
+    }
+    const fields = model.fields;
+    const shape = {};
+    const sortOrder = z.enum(["asc", "desc"]);
+    for (const [fieldName, fieldDef] of Object.entries(fields)) {
+        const isRelation = fieldDef.relation !== undefined;
+        if (!isRelation) {
+            shape[fieldName] = sortOrder.optional();
+        }
+    }
+    return z.union([z.object(shape).passthrough(), z.array(z.object(shape).passthrough())]).optional();
+}
+/**
+ * Creates all Zod schemas for a model's CRUD operations
+ */
+export function createModelSchemas(schema, modelName) {
+    const whereSchema = createWhereSchema(schema, modelName);
+    const uniqueWhereSchema = createUniqueWhereSchema(schema, modelName);
+    const createDataSchema = createCreateDataSchema(schema, modelName);
+    const updateDataSchema = createUpdateDataSchema(schema, modelName);
+    const selectSchema = createSelectSchema(schema, modelName);
+    const includeSchema = createIncludeSchema(schema, modelName);
+    const orderBySchema = createOrderBySchema(schema, modelName);
+    return {
+        findMany: z
+            .object({
+            where: whereSchema.optional(),
+            select: selectSchema,
+            include: includeSchema,
+            orderBy: orderBySchema,
+            skip: z.number().optional(),
+            take: z.number().optional(),
+            cursor: uniqueWhereSchema.optional(),
+            distinct: z.array(z.string()).optional(),
+        })
+            .passthrough()
+            .optional(),
+        findUnique: z.object({
+            where: uniqueWhereSchema,
+            select: selectSchema,
+            include: includeSchema,
+        }).passthrough(),
+        findFirst: z
+            .object({
+            where: whereSchema.optional(),
+            select: selectSchema,
+            include: includeSchema,
+            orderBy: orderBySchema,
+            skip: z.number().optional(),
+            cursor: uniqueWhereSchema.optional(),
+        })
+            .passthrough()
+            .optional(),
+        create: z.object({
+            data: createDataSchema,
+            select: selectSchema,
+            include: includeSchema,
+        }).passthrough(),
+        createMany: z
+            .object({
+            data: z.union([createDataSchema, z.array(createDataSchema)]),
+            skipDuplicates: z.boolean().optional(),
+        })
+            .passthrough()
+            .optional(),
+        update: z.object({
+            where: uniqueWhereSchema,
+            data: updateDataSchema,
+            select: selectSchema,
+            include: includeSchema,
+        }).passthrough(),
+        updateMany: z.object({
+            where: whereSchema.optional(),
+            data: updateDataSchema,
+            limit: z.number().optional(),
+        }).passthrough(),
+        upsert: z.object({
+            where: uniqueWhereSchema,
+            create: createDataSchema,
+            update: updateDataSchema,
+            select: selectSchema,
+            include: includeSchema,
+        }).passthrough(),
+        delete: z.object({
+            where: uniqueWhereSchema,
+            select: selectSchema,
+            include: includeSchema,
+        }).passthrough(),
+        deleteMany: z
+            .object({
+            where: whereSchema.optional(),
+            limit: z.number().optional(),
+        })
+            .passthrough()
+            .optional(),
+        count: z
+            .object({
+            where: whereSchema.optional(),
+            select: z.any().optional(),
+            cursor: uniqueWhereSchema.optional(),
+            skip: z.number().optional(),
+            take: z.number().optional(),
+            orderBy: orderBySchema,
+        })
+            .passthrough()
+            .optional(),
+        aggregate: z.object({
+            where: whereSchema.optional(),
+            cursor: uniqueWhereSchema.optional(),
+            skip: z.number().optional(),
+            take: z.number().optional(),
+            orderBy: orderBySchema,
+            _count: z.any().optional(),
+            _avg: z.any().optional(),
+            _sum: z.any().optional(),
+            _min: z.any().optional(),
+            _max: z.any().optional(),
+        }).passthrough(),
+        groupBy: z.object({
+            by: z.union([z.string(), z.array(z.string())]),
+            where: whereSchema.optional(),
+            having: z.any().optional(),
+            orderBy: orderBySchema,
+            skip: z.number().optional(),
+            take: z.number().optional(),
+            _count: z.any().optional(),
+            _avg: z.any().optional(),
+            _sum: z.any().optional(),
+            _min: z.any().optional(),
+            _max: z.any().optional(),
+        }).passthrough(),
+    };
+}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "zenstack-trpc",
+  "version": "0.1.0",
+  "description": "Auto-generate type-safe tRPC routers from ZenStack V3 schemas",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "pnpm run build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "zenstack",
+    "trpc",
+    "typescript",
+    "orm",
+    "prisma",
+    "typesafe",
+    "api",
+    "rpc",
+    "router",
+    "codegen"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/olup/zenstack-trpc"
+  },
+  "homepage": "https://github.com/olup/zenstack-trpc#readme",
+  "bugs": {
+    "url": "https://github.com/olup/zenstack-trpc/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "peerDependencies": {
+    "@trpc/server": ">=11.0.0",
+    "@zenstackhq/orm": ">=3.0.0",
+    "zod": ">=3.0.0 || >=4.0.0"
+  },
+  "devDependencies": {
+    "@trpc/server": "^11.8.1",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^25.0.3",
+    "@zenstackhq/cli": "^3.1.0",
+    "@zenstackhq/orm": "^3.1.0",
+    "better-sqlite3": "^12.5.0",
+    "kysely": "^0.28.9",
+    "prisma": "^7.2.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.16",
+    "zod": "^4.3.5"
+  }
+}