@zeno-lib/schema 0.0.1 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeno-lib/schema",
-  "version": "0.0.1",
+  "version": "0.2.0",
   "type": "module",
   "exports": {
     ".": "./src/index.ts"
@@ -15,20 +15,20 @@
     "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"
+    "typescript": "7.0.2",
+    "vitest": "4.1.11",
+    "zod": "^4.4.3",
+    "@zeno-lib/typescript": "^1.1.0"
+  },
+  "scripts": {
+    "test": "vitest --run",
+    "test:watch": "vitest watch",
+    "types:check": "tsc --noEmit"
   }
-}
+}

package/src/index.test-d.ts

@@ -1,4 +1,5 @@
-import { integer, pgTable, text } from "drizzle-orm/pg-core"
+import { sql } from "drizzle-orm"
+import { integer, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core"
 import { expectTypeOf, test } from "vitest"
 import { z } from "zod"
 
@@ -52,3 +53,30 @@ test("refined schemas preserve refinement-specific output types", () => {
     title: "fixed"
   }>()
 })
+
+test("defaulted audit columns leave the insert and update types", () => {
+  const notes = pgTable("notes", {
+    body: text("body").notNull(),
+    createdAt: timestamp("created_at").notNull().defaultNow(),
+    createdBy: uuid("created_by").notNull().default(sql`auth.uid()`),
+    updatedAt: timestamp("updated_at").notNull(),
+  })
+  const schemas = defineTableSchema(notes)
+
+  expectTypeOf<z.infer<typeof schemas.insert>>().toEqualTypeOf<{
+    body: string
+    updatedAt: Date
+  }>()
+  expectTypeOf<z.infer<typeof schemas.update>>().toEqualTypeOf<{
+    body?: string | undefined
+    updatedAt?: Date | undefined
+  }>()
+  expectTypeOf<keyof z.infer<typeof schemas.select>>().toEqualTypeOf<
+    "body" | "createdAt" | "createdBy" | "updatedAt"
+  >()
+
+  defineTableSchema(notes, {
+    // @ts-expect-error: an omitted audit column has nothing to refine.
+    insert: { createdBy: (schema) => schema },
+  })
+})

package/src/index.test.ts

@@ -1,4 +1,12 @@
-import { integer, pgTable, text, timestamp } from "drizzle-orm/pg-core"
+import { sql } from "drizzle-orm"
+import {
+  bigint,
+  integer,
+  pgTable,
+  text,
+  timestamp,
+  uuid,
+} from "drizzle-orm/pg-core"
 import { describe, expect, it } from "vitest"
 
 import { defineTableSchema } from "./index"
@@ -116,4 +124,90 @@ describe("defineTableSchema", () => {
       }).success
     ).toBe(true)
   })
+
+  it("omits defaulted audit columns from insert and update, not select", () => {
+    const notes = pgTable("notes", {
+      body: text("body").notNull(),
+      createdAt: timestamp("created_at").notNull().defaultNow(),
+      createdBy: uuid("created_by").notNull().default(sql`auth.uid()`),
+      id: integer("id").primaryKey().generatedByDefaultAsIdentity(),
+      updatedAt: timestamp("updated_at").notNull().defaultNow(),
+      updatedBy: uuid("updated_by").default(sql`auth.uid()`),
+    })
+    const schemas = defineTableSchema(notes)
+    const forged = {
+      body: "Hello",
+      createdAt: new Date("2000-01-01T00:00:00.000Z"),
+      createdBy: "00000000-0000-4000-8000-000000000000",
+      updatedAt: new Date("2000-01-01T00:00:00.000Z"),
+      updatedBy: "00000000-0000-4000-8000-000000000000",
+    }
+
+    expect(schemas.insert.parse(forged)).toEqual({ body: "Hello" })
+    expect(schemas.update.parse(forged)).toEqual({ body: "Hello" })
+    expect(Object.keys(schemas.select.shape)).toEqual(
+      expect.arrayContaining([
+        "createdAt",
+        "createdBy",
+        "updatedAt",
+        "updatedBy",
+      ])
+    )
+  })
+
+  it("keeps an audit-named column the database does not fill", () => {
+    const events = pgTable("events", {
+      createdAt: timestamp("created_at").notNull(),
+      id: integer("id").primaryKey().generatedAlwaysAsIdentity(),
+    })
+
+    expect(defineTableSchema(events).insert.safeParse({}).success).toBe(false)
+  })
+
+  it("rejects non-positive identity ids in every variant", () => {
+    const items = pgTable("items", {
+      id: bigint("id", { mode: "number" })
+        .primaryKey()
+        .generatedByDefaultAsIdentity(),
+      label: text("label").notNull(),
+    })
+    const schemas = defineTableSchema(items)
+
+    for (const id of [0, -1]) {
+      expect(schemas.insert.safeParse({ id, label: "x" }).success).toBe(false)
+      expect(schemas.update.safeParse({ id }).success).toBe(false)
+      expect(schemas.select.safeParse({ id, label: "x" }).success).toBe(false)
+    }
+
+    expect(schemas.insert.parse({ id: 1, label: "x" })).toEqual({
+      id: 1,
+      label: "x",
+    })
+    expect(schemas.insert.parse({ label: "x" })).toEqual({ label: "x" })
+  })
+
+  it("leaves identities configured to go below one unconstrained", () => {
+    const ledger = pgTable("ledger", {
+      id: integer("id")
+        .primaryKey()
+        .generatedByDefaultAsIdentity({ increment: -1, startWith: -1 }),
+    })
+
+    expect(defineTableSchema(ledger).select.parse({ id: -5 })).toEqual({
+      id: -5,
+    })
+  })
+
+  it("runs a function refinement on top of the positive identity check", () => {
+    const items = pgTable("items", {
+      id: integer("id").primaryKey().generatedByDefaultAsIdentity(),
+    })
+    const schemas = defineTableSchema(items, {
+      insert: { id: (schema) => schema.max(10) },
+    })
+
+    expect(schemas.insert.safeParse({ id: 0 }).success).toBe(false)
+    expect(schemas.insert.safeParse({ id: 11 }).success).toBe(false)
+    expect(schemas.insert.safeParse({ id: 5 }).success).toBe(true)
+  })
 })

package/src/index.ts

@@ -1,5 +1,11 @@
 /* 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 Column,
+  getColumns,
+  type InferInsertModel,
+  type InferSelectModel,
+  type Table,
+} from "drizzle-orm"
 import {
   type BuildRefine,
   type BuildSchema,
@@ -8,6 +14,7 @@ import {
   createSchemaFactory as createDrizzleSchemaFactory,
   type NoUnknownKeys,
 } from "drizzle-orm/zod"
+import type { z } from "zod"
 
 export {
   createInsertSchema,
@@ -20,9 +27,30 @@ declare const noTableSchemaOptions: unique symbol
 type NoTableSchemaOptions = { [noTableSchemaOptions]?: never }
 
 type TableColumns<TTable extends Table> = TTable["_"]["columns"]
+
+// The keys `timestamps()` and `authorship()` from `@zeno-lib/db/schema` emit.
+// This package cannot import them, so it matches the names instead, and only
+// when the column has a default, since a column the database never fills is
+// one the caller has to write.
+const AUDIT_COLUMN_KEYS = new Set<string>([
+  "createdAt",
+  "createdBy",
+  "updatedAt",
+  "updatedBy",
+])
+type AuditColumnKey = "createdAt" | "createdBy" | "updatedAt" | "updatedBy"
+
+type AuditKeys<TTable extends Table> = {
+  [K in keyof TableColumns<TTable>]: K extends AuditColumnKey
+    ? TableColumns<TTable>[K]["_"]["hasDefault"] extends true
+      ? K
+      : never
+    : never
+}[keyof TableColumns<TTable>]
+
 type InsertColumns<TTable extends Table> = Pick<
   TableColumns<TTable>,
-  keyof InferInsertModel<TTable>
+  Exclude<keyof InferInsertModel<TTable>, AuditKeys<TTable>>
 >
 
 type SelectRefine<
@@ -63,16 +91,27 @@ type RefineFromOptions<
     : undefined
   : undefined
 
+type OmitKeys<TSchema, TKeys extends PropertyKey> =
+  TSchema extends z.ZodObject<infer TShape, infer TConfig>
+    ? z.ZodObject<
+        { [K in keyof TShape as K extends TKeys ? never : K]: TShape[K] },
+        TConfig
+      >
+    : never
+
 type DefineTableSchemaResult<
   TTable extends Table,
   TCoerce extends CoerceOptions,
   TOptions,
 > = {
-  insert: BuildSchema<
-    "insert",
-    TableColumns<TTable>,
-    RefineFromOptions<TOptions, "insert">,
-    TCoerce
+  insert: OmitKeys<
+    BuildSchema<
+      "insert",
+      TableColumns<TTable>,
+      RefineFromOptions<TOptions, "insert">,
+      TCoerce
+    >,
+    AuditKeys<TTable>
   >
   select: BuildSchema<
     "select",
@@ -80,14 +119,86 @@ type DefineTableSchemaResult<
     RefineFromOptions<TOptions, "select">,
     TCoerce
   >
-  update: BuildSchema<
-    "update",
-    TableColumns<TTable>,
-    RefineFromOptions<TOptions, "update">,
-    TCoerce
+  update: OmitKeys<
+    BuildSchema<
+      "update",
+      TableColumns<TTable>,
+      RefineFromOptions<TOptions, "update">,
+      TCoerce
+    >,
+    AuditKeys<TTable>
   >
 }
 
+type Refinements = Record<string, unknown>
+
+const auditKeys = (table: Table) => {
+  const columns: Record<string, Column> = getColumns(table)
+  const keys: string[] = []
+
+  for (const key of Object.keys(columns)) {
+    if (AUDIT_COLUMN_KEYS.has(key) && columns[key]?.hasDefault) {
+      keys.push(key)
+    }
+  }
+
+  return keys
+}
+
+// Postgres starts an ascending identity at its minimum value, which defaults
+// to 1, so only a sequence configured below that can hand out 0 or less.
+const isPositiveIdentity = (column: Column) => {
+  const identity = column.generatedIdentity
+
+  if (identity === undefined) {
+    return false
+  }
+
+  const {
+    increment = 1,
+    minValue = 1,
+    startWith = minValue,
+  } = identity.sequenceOptions ?? {}
+
+  return Number(increment) > 0 && Number(minValue) > 0 && Number(startWith) > 0
+}
+
+type PositiveSchema = { positive: () => unknown }
+
+const toPositive = (schema: unknown) =>
+  typeof (schema as Partial<PositiveSchema>).positive === "function"
+    ? (schema as PositiveSchema).positive()
+    : schema
+
+// A caller's function refinement runs on the positive schema, so it can narrow
+// further. A caller's schema replaces the column schema outright, positive
+// check included, the same as it replaces every other generated rule.
+const withPositiveIdentities = (
+  table: Table,
+  refinements: Refinements = {}
+): Refinements => {
+  const columns: Record<string, Column> = getColumns(table)
+  const merged: Refinements = { ...refinements }
+
+  for (const key of Object.keys(columns)) {
+    const column = columns[key]
+
+    if (column === undefined || !isPositiveIdentity(column)) {
+      continue
+    }
+
+    const refinement = refinements[key]
+
+    if (refinement === undefined) {
+      merged[key] = toPositive
+    } else if (typeof refinement === "function") {
+      merged[key] = (schema: unknown) => refinement(toPositive(schema))
+    }
+  }
+
+  return merged
+}
+
 function defineTableSchema<TTable extends Table>(
   table: TTable
 ): DefineTableSchemaResult<TTable, undefined, NoTableSchemaOptions>
@@ -114,21 +225,36 @@ function defineTableSchema<
   options?: TOptions
 ): DefineTableSchemaResult<TTable, TCoerce, TOptions> {
   const schemaFactory = createDrizzleSchemaFactory(options?.factory)
+  const audit = auditKeys(table)
+  // Zod rejects an omit key the shape lacks, which a generated audit column
+  // would be.
+  const omitAudit = (schema: z.ZodObject) => {
+    const mask: Record<string, true> = {}
 
-  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"],
+    for (const key of audit) {
+      if (key in schema.shape) {
+        mask[key] = true
+      }
+    }
+
+    return schema.omit(mask)
   }
+  // The drizzle factory's refinement parameters are typed per table, which a
+  // generic `TTable` cannot satisfy, so the merged maps go in untyped.
+  const factory = schemaFactory as unknown as Record<
+    "createInsertSchema" | "createSelectSchema" | "createUpdateSchema",
+    (table: Table, refine: Refinements) => z.ZodObject
+  >
+  const build = (
+    variant: "insert" | "select" | "update",
+    create: (typeof factory)["createInsertSchema"]
+  ) => create(table, withPositiveIdentities(table, options?.[variant]))
+
+  return {
+    insert: omitAudit(build("insert", factory.createInsertSchema)),
+    select: build("select", factory.createSelectSchema),
+    update: omitAudit(build("update", factory.createUpdateSchema)),
+  } as unknown as DefineTableSchemaResult<TTable, TCoerce, TOptions>
 }
 
 export type { DefineTableSchemaOptions, DefineTableSchemaResult }