@zeno-lib/schema 0.0.1

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@zeno-lib/schema",
+  "version": "0.0.1",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "url": "https://github.com/zeno-lib/zeno.git",
+    "directory": "packages/schema"
+  },
+  "scripts": {
+    "test": "vitest --run",
+    "test:watch": "vitest watch",
+    "types:check": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "drizzle-orm": "1.0.0-rc.3",
+    "zod": ">=4"
+  },
+  "devDependencies": {
+    "@zeno-lib/typescript": "workspace:^",
+    "drizzle-orm": "1.0.0-rc.3",
+    "typescript": "6.0.3",
+    "vitest": "4.1.0",
+    "zod": "^4.4.3"
+  }
+}

package/src/index.test-d.ts

@@ -0,0 +1,54 @@
+import { integer, pgTable, text } from "drizzle-orm/pg-core"
+import { expectTypeOf, test } from "vitest"
+import { z } from "zod"
+
+import { defineTableSchema } from "./index"
+
+type StandardSchema<T> = {
+  readonly "~standard": {
+    readonly types?: { readonly input: T; readonly output: T }
+    readonly validate: (value: unknown) => unknown
+  }
+}
+
+function acceptsFormsSchema<TFormData>(
+  _schema: StandardSchema<TFormData>
+): void {
+  return
+}
+
+const posts = pgTable("posts", {
+  id: integer("id").primaryKey().generatedAlwaysAsIdentity(),
+  slug: text("slug").notNull(),
+  title: text("title").notNull(),
+})
+
+test("insert and update schemas infer form-compatible Standard Schema data", () => {
+  const schemas = defineTableSchema(posts)
+
+  acceptsFormsSchema(schemas.insert)
+  acceptsFormsSchema(schemas.update)
+
+  expectTypeOf<z.infer<typeof schemas.insert>>().toEqualTypeOf<{
+    slug: string
+    title: string
+  }>()
+
+  expectTypeOf<z.infer<typeof schemas.update>>().toEqualTypeOf<{
+    slug?: string | undefined
+    title?: string | undefined
+  }>()
+})
+
+test("refined schemas preserve refinement-specific output types", () => {
+  const schemas = defineTableSchema(posts, {
+    insert: {
+      title: z.literal("fixed"),
+    },
+  })
+
+  expectTypeOf<z.infer<typeof schemas.insert>>().toEqualTypeOf<{
+    slug: string
+    title: "fixed"
+  }>()
+})

package/src/index.test.ts

@@ -0,0 +1,119 @@
+import { integer, pgTable, text, timestamp } from "drizzle-orm/pg-core"
+import { describe, expect, it } from "vitest"
+
+import { defineTableSchema } from "./index"
+
+const posts = pgTable("posts", {
+  createdAt: timestamp("created_at", { mode: "date" }).notNull().defaultNow(),
+  id: integer("id").primaryKey().generatedAlwaysAsIdentity(),
+  slug: text("slug").notNull(),
+  summary: text("summary"),
+  title: text("title").notNull(),
+})
+
+describe("defineTableSchema", () => {
+  it("returns select, insert, and update Zod schemas for a Drizzle table", () => {
+    const schemas = defineTableSchema(posts)
+
+    expect(
+      schemas.select.parse({
+        createdAt: new Date("2026-06-08T00:00:00.000Z"),
+        id: 1,
+        slug: "hello-world",
+        summary: null,
+        title: "Hello world",
+      })
+    ).toMatchObject({
+      id: 1,
+      slug: "hello-world",
+      summary: null,
+      title: "Hello world",
+    })
+
+    expect(
+      schemas.insert.parse({
+        slug: "hello-world",
+        title: "Hello world",
+      })
+    ).toEqual({
+      slug: "hello-world",
+      title: "Hello world",
+    })
+
+    expect(
+      schemas.update.parse({
+        title: "Updated title",
+      })
+    ).toEqual({
+      title: "Updated title",
+    })
+  })
+
+  it("omits generated columns from insert and update schemas", () => {
+    const schemas = defineTableSchema(posts)
+
+    expect(
+      schemas.insert.parse({
+        id: 1,
+        slug: "hello-world",
+        title: "Hello world",
+      })
+    ).toEqual({
+      slug: "hello-world",
+      title: "Hello world",
+    })
+
+    expect(
+      schemas.update.parse({
+        id: 1,
+        title: "Updated title",
+      })
+    ).toEqual({
+      title: "Updated title",
+    })
+  })
+
+  it("applies per-variant refinements only to the targeted schema", () => {
+    const schemas = defineTableSchema(posts, {
+      insert: {
+        title: (schema) => schema.min(3),
+      },
+      select: {
+        slug: (schema) => schema.startsWith("post-"),
+      },
+      update: {
+        title: (schema) => schema.min(10),
+      },
+    })
+
+    expect(
+      schemas.insert.safeParse({
+        slug: "hello-world",
+        title: "Hi",
+      }).success
+    ).toBe(false)
+
+    expect(
+      schemas.update.safeParse({
+        title: "Short",
+      }).success
+    ).toBe(false)
+
+    expect(
+      schemas.select.safeParse({
+        createdAt: new Date("2026-06-08T00:00:00.000Z"),
+        id: 1,
+        slug: "hello-world",
+        summary: null,
+        title: "Hello world",
+      }).success
+    ).toBe(false)
+
+    expect(
+      schemas.insert.safeParse({
+        slug: "hello-world",
+        title: "Okay",
+      }).success
+    ).toBe(true)
+  })
+})

package/src/index.ts

@@ -0,0 +1,135 @@
+/* biome-ignore-all lint/performance/noBarrelFile: package root intentionally re-exports the public schema surface. */
+import type { InferInsertModel, InferSelectModel, Table } from "drizzle-orm"
+import {
+  type BuildRefine,
+  type BuildSchema,
+  type CoerceOptions,
+  type CreateSchemaFactoryOptions,
+  createSchemaFactory as createDrizzleSchemaFactory,
+  type NoUnknownKeys,
+} from "drizzle-orm/zod"
+
+export {
+  createInsertSchema,
+  createSchemaFactory,
+  createSelectSchema,
+  createUpdateSchema,
+} from "drizzle-orm/zod"
+
+declare const noTableSchemaOptions: unique symbol
+type NoTableSchemaOptions = { [noTableSchemaOptions]?: never }
+
+type TableColumns<TTable extends Table> = TTable["_"]["columns"]
+type InsertColumns<TTable extends Table> = Pick<
+  TableColumns<TTable>,
+  keyof InferInsertModel<TTable>
+>
+
+type SelectRefine<
+  TTable extends Table,
+  TCoerce extends CoerceOptions,
+> = BuildRefine<TableColumns<TTable>, TCoerce>
+type InsertRefine<
+  TTable extends Table,
+  TCoerce extends CoerceOptions,
+> = BuildRefine<InsertColumns<TTable>, TCoerce>
+type UpdateRefine<
+  TTable extends Table,
+  TCoerce extends CoerceOptions,
+> = BuildRefine<InsertColumns<TTable>, TCoerce>
+
+type DefineTableSchemaOptions<
+  TTable extends Table,
+  TCoerce extends CoerceOptions = undefined,
+> = {
+  factory?: CreateSchemaFactoryOptions<TCoerce>
+  insert?: NoUnknownKeys<
+    InsertRefine<TTable, TCoerce>,
+    InferInsertModel<TTable>
+  >
+  select?: NoUnknownKeys<
+    SelectRefine<TTable, TCoerce>,
+    InferSelectModel<TTable>
+  >
+  update?: UpdateRefine<TTable, TCoerce>
+}
+
+type RefineFromOptions<
+  TOptions,
+  TKey extends string,
+> = TKey extends keyof TOptions
+  ? NonNullable<TOptions[TKey]> extends Record<string, unknown>
+    ? NonNullable<TOptions[TKey]>
+    : undefined
+  : undefined
+
+type DefineTableSchemaResult<
+  TTable extends Table,
+  TCoerce extends CoerceOptions,
+  TOptions,
+> = {
+  insert: BuildSchema<
+    "insert",
+    TableColumns<TTable>,
+    RefineFromOptions<TOptions, "insert">,
+    TCoerce
+  >
+  select: BuildSchema<
+    "select",
+    TableColumns<TTable>,
+    RefineFromOptions<TOptions, "select">,
+    TCoerce
+  >
+  update: BuildSchema<
+    "update",
+    TableColumns<TTable>,
+    RefineFromOptions<TOptions, "update">,
+    TCoerce
+  >
+}
+
+function defineTableSchema<TTable extends Table>(
+  table: TTable
+): DefineTableSchemaResult<TTable, undefined, NoTableSchemaOptions>
+function defineTableSchema<
+  TTable extends Table,
+  TCoerce extends CoerceOptions = undefined,
+  TOptions extends DefineTableSchemaOptions<
+    TTable,
+    TCoerce
+  > = DefineTableSchemaOptions<TTable, TCoerce>,
+>(
+  table: TTable,
+  options: TOptions
+): DefineTableSchemaResult<TTable, TCoerce, TOptions>
+function defineTableSchema<
+  TTable extends Table,
+  TCoerce extends CoerceOptions = undefined,
+  TOptions extends DefineTableSchemaOptions<
+    TTable,
+    TCoerce
+  > = DefineTableSchemaOptions<TTable, TCoerce>,
+>(
+  table: TTable,
+  options?: TOptions
+): DefineTableSchemaResult<TTable, TCoerce, TOptions> {
+  const schemaFactory = createDrizzleSchemaFactory(options?.factory)
+
+  return {
+    insert: schemaFactory.createInsertSchema(
+      table,
+      options?.insert
+    ) as DefineTableSchemaResult<TTable, TCoerce, TOptions>["insert"],
+    select: schemaFactory.createSelectSchema(
+      table,
+      options?.select
+    ) as DefineTableSchemaResult<TTable, TCoerce, TOptions>["select"],
+    update: schemaFactory.createUpdateSchema(
+      table,
+      options?.update
+    ) as DefineTableSchemaResult<TTable, TCoerce, TOptions>["update"],
+  }
+}
+
+export type { DefineTableSchemaOptions, DefineTableSchemaResult }
+export { defineTableSchema }