@zeno-lib/schema 0.2.2 → 0.4.0

package/src/index.test.ts

@@ -1,7 +1,10 @@
 import { sql } from "drizzle-orm"
 import {
   bigint,
+  date,
   integer,
+  pgEnum,
+  pgSchema,
   pgTable,
   text,
   timestamp,
@@ -9,15 +12,18 @@ import {
 } from "drizzle-orm/pg-core"
 import { describe, expect, it } from "vitest"
 
-import { defineTableSchema } from "./index"
+import { defineTableSchema, writableColumns } from "./index"
+import { zenoTable } from "./test-table"
 
-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(),
-})
+const posts = zenoTable(
+  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", () => {
@@ -57,6 +63,13 @@ describe("defineTableSchema", () => {
     })
   })
 
+  it("refuses a plain drizzle table, whose column markers would be ignored", () => {
+    const raw = pgTable("raw", { label: text("label") })
+
+    // @ts-expect-error: only a table from `@zeno-lib/db/schema` records rules.
+    expect(() => defineTableSchema(raw)).toThrow(TypeError)
+  })
+
   it("omits generated columns from insert and update schemas", () => {
     const schemas = defineTableSchema(posts)
 
@@ -125,73 +138,54 @@ describe("defineTableSchema", () => {
     ).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",
+  it("keeps a column named like an audit column, which only its marker leaves out", () => {
+    const events = zenoTable(
+      pgTable("events", {
+        createdAt: timestamp("created_at").notNull().defaultNow(),
+        createdBy: uuid("created_by").default(sql`auth.uid()`),
+        label: text("label").notNull(),
+      })
+    )
+    const imported = {
       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",
+      label: "x",
     }
 
-    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",
-      ])
-    )
+    expect(defineTableSchema(events).insert.parse(imported)).toEqual(imported)
   })
 
-  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("keeps identity ids out of insert and update, and positive in select", () => {
+    const items = zenoTable(
+      pgTable("items", {
+        id: bigint("id", { mode: "number" })
+          .primaryKey()
+          .generatedByDefaultAsIdentity(),
+        label: text("label").notNull(),
+      })
+    )
+    const schemas = defineTableSchema(items)
 
-  it("rejects non-positive identity ids in every variant", () => {
-    const items = pgTable("items", {
-      id: bigint("id", { mode: "number" })
-        .primaryKey()
-        .generatedByDefaultAsIdentity(),
-      label: text("label").notNull(),
+    expect(schemas.insert.parse({ id: 5000, label: "x" })).toEqual({
+      label: "x",
+    })
+    expect(schemas.update.parse({ id: 5000, label: "x" })).toEqual({
+      label: "x",
     })
-    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 }),
-    })
+    const ledger = zenoTable(
+      pgTable("ledger", {
+        id: integer("id")
+          .primaryKey()
+          .generatedByDefaultAsIdentity({ increment: -1, startWith: -1 }),
+      })
+    )
 
     expect(defineTableSchema(ledger).select.parse({ id: -5 })).toEqual({
       id: -5,
@@ -199,23 +193,27 @@ describe("defineTableSchema", () => {
   })
 
   it("runs a function refinement on top of the positive identity check", () => {
-    const items = pgTable("items", {
-      id: integer("id").primaryKey().generatedByDefaultAsIdentity(),
-    })
+    const items = zenoTable(
+      pgTable("items", {
+        id: integer("id").primaryKey().generatedByDefaultAsIdentity(),
+      })
+    )
     const schemas = defineTableSchema(items, {
-      insert: { id: (schema) => schema.max(10) },
+      select: { 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)
+    expect(schemas.select.safeParse({ id: 0 }).success).toBe(false)
+    expect(schemas.select.safeParse({ id: 11 }).success).toBe(false)
+    expect(schemas.select.safeParse({ id: 5 }).success).toBe(true)
   })
 
   it("keeps a function-refined nullable insert column optional", () => {
-    const drafts = pgTable("drafts", {
-      note: text("note"),
-      title: text("title").notNull(),
-    })
+    const drafts = zenoTable(
+      pgTable("drafts", {
+        note: text("note"),
+        title: text("title").notNull(),
+      })
+    )
     const schemas = defineTableSchema(drafts, {
       insert: { note: (schema) => schema.min(1) },
     })
@@ -230,3 +228,78 @@ describe("defineTableSchema", () => {
     )
   })
 })
+
+describe("string-mode dates and timestamps", () => {
+  const events = zenoTable(
+    pgTable("events", {
+      at: timestamp("at", { mode: "string", withTimezone: true }),
+      day: date("day", { mode: "string" }),
+      days: date("days", { mode: "string" }).array(),
+      localAt: timestamp("local_at", { mode: "string" }),
+    })
+  )
+  const { insert, update } = defineTableSchema(events)
+  const accepts = (value: Record<string, unknown>) =>
+    insert.safeParse(value).success && update.safeParse(value).success
+
+  it("takes a calendar date", () => {
+    expect(accepts({ day: "2026-09-17" })).toBe(true)
+    expect(accepts({ day: null })).toBe(true)
+    expect(accepts({ day: "2026-02-30" })).toBe(false)
+    expect(accepts({ day: "17.09.2026" })).toBe(false)
+    expect(accepts({ day: "infinity" })).toBe(true)
+    expect(accepts({ days: ["2026-09-17", "2026-09-18"] })).toBe(true)
+  })
+
+  it("takes ISO 8601 and the text Postgres returns, with the offset a time zone needs", () => {
+    for (const at of [
+      "2026-09-17T07:53:56.357127+00:00",
+      "2026-09-17 07:53:56.357127+00",
+      "2026-09-17T07:53Z",
+    ]) {
+      expect(accepts({ at }), at).toBe(true)
+    }
+    expect(accepts({ at: "2026-09-17T07:53:56" })).toBe(false)
+    expect(accepts({ at: "yesterday" })).toBe(false)
+    expect(accepts({ at: "-infinity" })).toBe(true)
+    expect(accepts({ localAt: "2026-09-17 07:53:56.357127" })).toBe(true)
+    expect(accepts({ localAt: "yesterday" })).toBe(false)
+  })
+
+  it("refuses a time Postgres would reject or shift", () => {
+    expect(accepts({ at: "2026-02-30 07:00+00" })).toBe(false)
+    expect(accepts({ at: "2026-09-17T24:00Z" })).toBe(false)
+    expect(accepts({ at: "2026-09-17T07:00+16:00" })).toBe(false)
+    // Postgres drops an offset on a column without a time zone.
+    expect(accepts({ localAt: "2026-09-16T22:00:00.000Z" })).toBe(false)
+  })
+
+  it("lets an object refinement report next to a bad timestamp", () => {
+    const result = insert
+      .refine(() => false, { message: "cross-field" })
+      .safeParse({ at: "yesterday" })
+
+    expect(result.error?.issues.map((issue) => issue.message)).toContain(
+      "cross-field"
+    )
+  })
+})
+
+describe("writableColumns", () => {
+  it("lists each Zeno table's writable columns, and skips everything else", () => {
+    const status = pgEnum("status", ["open", "closed"])
+    const billing = pgSchema("billing")
+    const invoices = zenoTable(
+      billing.table("invoices", {
+        id: integer("id").primaryKey().generatedByDefaultAsIdentity(),
+        total: integer("total").notNull(),
+      })
+    )
+    const raw = pgTable("raw", { label: text("label") })
+
+    expect(writableColumns({ invoices, posts, raw, status })).toEqual({
+      "billing.invoices": ["total"],
+      posts: ["createdAt", "slug", "summary", "title"],
+    })
+  })
+})