@zeno-lib/schema 0.2.2 → 0.4.0

package/dist/index.d.mts

@@ -7,28 +7,134 @@ type NoTableSchemaOptions = {
   [noTableSchemaOptions]?: never;
 };
 type TableColumns<TTable extends Table> = TTable["_"]["columns"];
-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>, Exclude<keyof InferInsertModel<TTable>, AuditKeys<TTable>>>;
+declare const COLUMN_RULES_KEY = "~zeno";
+/**
+ * What a column marker from `@zeno-lib/db/schema` records. `writer` says who
+ * writes the column when a client doesn't: `"server"` code (`serverOwned`), or
+ * only the `"database"`, through a default and a trigger (the audit columns
+ * `timestamps()` and `authorship()` emit). `refine` runs on it in insert and
+ * update, and `hint` goes to the form field that edits it.
+ */
+type ColumnRule = {
+  readonly writer?: "database" | "server";
+  readonly refine?: unknown;
+  readonly hint?: FieldHint;
+};
+type Writer = NonNullable<ColumnRule["writer"]>;
+/**
+ * A table built by `table()`, `unsecureTable()` or `schema(...).table` from
+ * `@zeno-lib/db/schema`, which records its column rules. A plain drizzle
+ * table has none, so its markers would vanish without a trace.
+ */
+type ZenoTable = Table & {
+  readonly [COLUMN_RULES_KEY]: {
+    readonly columns: object;
+  };
+};
+type TableColumnRules<TTable extends ZenoTable> = TTable[typeof COLUMN_RULES_KEY]["columns"];
+type WrittenByKeys<TTable extends ZenoTable, TWriter extends Writer> = { [K in keyof TableColumnRules<TTable>]: TableColumnRules<TTable>[K] extends {
+  readonly writer: TWriter;
+} ? K : never; }[keyof TableColumnRules<TTable>];
+type ColumnRefinements<TTable extends ZenoTable> = { [K in keyof TableColumnRules<TTable> as TableColumnRules<TTable>[K] extends {
+  readonly refine: unknown;
+} ? K : never]: TableColumnRules<TTable>[K] extends {
+  readonly refine: infer TRefine;
+} ? TRefine : never; };
+type IdentityKeys<TTable extends Table> = { [K in keyof TableColumns<TTable>]: TableColumns<TTable>[K]["_"]["identity"] extends "always" | "byDefault" ? K : never; }[keyof TableColumns<TTable>];
+type ClientExcludes = Writer;
+type ServerExcludes = "database";
+type UnwritableKeys<TTable extends ZenoTable, TExcludes extends Writer = ClientExcludes> = IdentityKeys<TTable> | WrittenByKeys<TTable, TExcludes>;
+type InsertColumns<TTable extends ZenoTable, TExcludes extends Writer = ClientExcludes> = Pick<TableColumns<TTable>, Exclude<keyof InferInsertModel<TTable>, UnwritableKeys<TTable, TExcludes>>>;
 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> = {
+type WriteRefineOptions<TTable extends ZenoTable, TCoerce extends CoerceOptions, TExcludes extends Writer> = BuildRefine<InsertColumns<TTable, TExcludes>, TCoerce>;
+type DefineTableSchemaOptions<TTable extends ZenoTable, TCoerce extends CoerceOptions = undefined, TExcludes extends Writer = ClientExcludes> = {
   factory?: CreateSchemaFactoryOptions<TCoerce>;
-  insert?: NoUnknownKeys<InsertRefine<TTable, TCoerce>, InferInsertModel<TTable>>;
+  insert?: NoUnknownKeys<WriteRefineOptions<TTable, TCoerce, TExcludes>, InferInsertModel<TTable>>;
   select?: NoUnknownKeys<SelectRefine<TTable, TCoerce>, InferSelectModel<TTable>>;
-  update?: UpdateRefine<TTable, TCoerce>;
+  update?: WriteRefineOptions<TTable, TCoerce, TExcludes>;
 };
 type RefineFromOptions<TOptions, TKey extends string> = TKey extends keyof TOptions ? NonNullable<TOptions[TKey]> extends Record<string, unknown> ? NonNullable<TOptions[TKey]> : undefined : undefined;
+type WriteRefine<TTable extends ZenoTable, TOptions, TKey extends string> = RefineFromOptions<TOptions, TKey> extends (infer TCaller) ? TCaller extends Record<string, unknown> ? Omit<ColumnRefinements<TTable>, keyof TCaller> & TCaller : ColumnRefinements<TTable> : never;
 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 IsInsertOptional<TColumn> = TColumn extends Column ? TColumn["_"]["notNull"] extends true ? TColumn["_"]["hasDefault"] extends true ? true : false : true : false;
 type OptionalRefinedInsert<TSchema, TTable extends Table, TRefine> = TSchema extends z.ZodObject<infer TShape, infer TConfig> ? z.ZodObject<{ [K in keyof TShape]: K extends keyof TRefine ? TRefine[K] extends ((schema: never) => unknown) ? (K extends keyof TableColumns<TTable> ? IsInsertOptional<TableColumns<TTable>[K]> : false) extends true ? TShape[K] extends z.ZodOptional ? TShape[K] : z.ZodOptional<TShape[K]> : TShape[K] : TShape[K] : TShape[K]; }, TConfig> : never;
-type DefineTableSchemaResult<TTable extends Table, TCoerce extends CoerceOptions, TOptions> = {
-  insert: OmitKeys<OptionalRefinedInsert<BuildSchema<"insert", TableColumns<TTable>, RefineFromOptions<TOptions, "insert">, TCoerce>, TTable, RefineFromOptions<TOptions, "insert">>, AuditKeys<TTable>>;
+type DefineTableSchemaResult<TTable extends ZenoTable, TCoerce extends CoerceOptions, TOptions, TExcludes extends Writer = ClientExcludes> = {
+  /** The table the schemas come from, for `ownedRows`. */
+  table: TTable;
+  insert: OmitKeys<OptionalRefinedInsert<BuildSchema<"insert", TableColumns<TTable>, WriteRefine<TTable, TOptions, "insert">, TCoerce>, TTable, WriteRefine<TTable, TOptions, "insert">>, UnwritableKeys<TTable, TExcludes>>;
   select: BuildSchema<"select", TableColumns<TTable>, RefineFromOptions<TOptions, "select">, TCoerce>;
-  update: OmitKeys<BuildSchema<"update", TableColumns<TTable>, RefineFromOptions<TOptions, "update">, TCoerce>, AuditKeys<TTable>>;
+  update: OmitKeys<BuildSchema<"update", TableColumns<TTable>, WriteRefine<TTable, TOptions, "update">, TCoerce>, UnwritableKeys<TTable, TExcludes>>;
+};
+/** What a column's `withRule` hints the form field that edits it. */
+type FieldHint = {
+  readonly field: string;
+};
+declare function defineTableSchema<TTable extends ZenoTable>(table: TTable): DefineTableSchemaResult<TTable, undefined, NoTableSchemaOptions>;
+declare function defineTableSchema<TTable extends ZenoTable, TCoerce extends CoerceOptions = undefined, TOptions extends DefineTableSchemaOptions<TTable, TCoerce> = DefineTableSchemaOptions<TTable, TCoerce>>(table: TTable, options: TOptions): DefineTableSchemaResult<TTable, TCoerce, TOptions>;
+/**
+ * `defineTableSchema` for code that runs only on the server, such as a sync
+ * job, which writes the columns `serverOwned()` keeps from clients. Identity
+ * and audit columns stay out, as the database writes them. Never parse what a
+ * client sends with it: a server action's input is a client's.
+ */
+declare function defineServerTableSchema<TTable extends ZenoTable>(table: TTable): DefineTableSchemaResult<TTable, undefined, NoTableSchemaOptions, ServerExcludes>;
+declare function defineServerTableSchema<TTable extends ZenoTable, TCoerce extends CoerceOptions = undefined, TOptions extends DefineTableSchemaOptions<TTable, TCoerce, ServerExcludes> = DefineTableSchemaOptions<TTable, TCoerce, ServerExcludes>>(table: TTable, options: TOptions): DefineTableSchemaResult<TTable, TCoerce, TOptions, ServerExcludes>;
+type ColumnKey<TTable extends Table> = Extract<keyof TableColumns<TTable>, string>;
+type OwnableSchema = {
+  insert: z.ZodObject;
+  select: {
+    shape: {
+      id: z.ZodType;
+    };
+  };
+  table: ZenoTable;
+};
+type OwnedRowSchema<TSchema extends OwnableSchema, TParentKey extends string> = TSchema["insert"] extends z.ZodObject<infer TShape, infer TConfig> ? z.ZodObject<{ [K in keyof TShape as K extends TParentKey ? never : K]: TShape[K]; } & {
+  id: z.ZodOptional<TSchema["select"]["shape"]["id"]>;
+}, TConfig> : never;
+/**
+ * A table's rows that belong to one parent row and are edited as a list, such
+ * as an order's lines. `syncRows` from `@zeno-lib/db/query` takes it in place
+ * of the table, and a form validates each row with `row`.
+ */
+type OwnedRows<TTable extends ZenoTable, TParentKey extends string, TRow extends z.ZodObject> = {
+  /** The columns that point at the parent row, which `row` leaves out. */
+  readonly parent: readonly TParentKey[];
+  /**
+   * One row as a client sends it: the `insert` columns but the parent's, and
+   * the `id` of a stored row, absent on a new one.
+   */
+  readonly row: TRow;
+  readonly table: TTable;
 };
-declare function defineTableSchema<TTable extends Table>(table: TTable): DefineTableSchemaResult<TTable, undefined, NoTableSchemaOptions>;
-declare 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>;
+/**
+ * The rows of `schema`'s table that belong to a parent through the `parent`
+ * columns, for a form that edits them as a list and the `syncRows` that saves
+ * it:
+ *
+ * ```ts
+ * const orderLines = ownedRows(defineTableSchema(lines), { parent: "orderId" })
+ *
+ * const orderSchema = defineTableSchema(orders).insert.extend({
+ *   lines: z.array(orderLines.row),
+ * })
+ *
+ * await syncRows(tx, orderLines, { parent: { orderId }, rows: input.lines })
+ * ```
+ *
+ * The table needs a sequential `id`. A link table matched by a natural key
+ * goes to `syncRows` with its `key` option instead.
+ */
+declare const ownedRows: <TSchema extends OwnableSchema, TParentKey extends ColumnKey<TSchema["table"]>>(schema: TSchema, { parent }: {
+  parent: TParentKey | readonly TParentKey[];
+}) => OwnedRows<TSchema["table"], TParentKey, OwnedRowSchema<TSchema, TParentKey>>;
+/**
+ * The columns a client may write, for every Zeno table among `exports` (a
+ * schema barrel, say), keyed by name (`schema.table` outside `public`): what `defineTableSchema`'s
+ * `insert` accepts, and `update` accepts the same. Columns are writable unless
+ * marked, so snapshot this in one test, and a newly writable column shows up
+ * as a diff in review.
+ */
+declare const writableColumns: (exports: Record<string, unknown>) => Record<string, string[]>;
 //#endregion
-export { type DefineTableSchemaOptions, type DefineTableSchemaResult, createInsertSchema, createSchemaFactory, createSelectSchema, createUpdateSchema, defineTableSchema };
+export { type DefineTableSchemaOptions, type DefineTableSchemaResult, type OwnedRows, type ZenoTable, createInsertSchema, createSchemaFactory, createSelectSchema, createUpdateSchema, defineServerTableSchema, defineTableSchema, ownedRows, writableColumns };

package/dist/index.mjs

@@ -1,18 +1,52 @@
-import { getColumns } from "drizzle-orm";
+import { Table, getColumns, getTableName, getTableUniqueName, is } from "drizzle-orm";
 import { createInsertSchema, createSchemaFactory, createSchemaFactory as createSchemaFactory$1, createSelectSchema, createUpdateSchema } from "drizzle-orm/zod";
+import { z } from "zod";
 //#region src/index.ts
-const AUDIT_COLUMN_KEYS = /* @__PURE__ */ new Set([
-	"createdAt",
-	"createdBy",
-	"updatedAt",
-	"updatedBy"
-]);
-const auditKeys = (table) => {
+const COLUMN_RULES_KEY = "~zeno";
+const columnRules = (table) => table[COLUMN_RULES_KEY].columns;
+const CLIENT_EXCLUDES = /* @__PURE__ */ new Set(["database", "server"]);
+const SERVER_EXCLUDES = /* @__PURE__ */ new Set(["database"]);
+const unwritableKeys = (table, excludes) => {
 	const columns = getColumns(table);
+	const rules = columnRules(table);
 	const keys = [];
-	for (const key of Object.keys(columns)) if (AUDIT_COLUMN_KEYS.has(key) && columns[key]?.hasDefault) keys.push(key);
+	for (const key of Object.keys(columns)) {
+		const isIdentity = columns[key]?.generatedIdentity !== void 0;
+		const writer = rules[key]?.writer;
+		if (isIdentity || writer !== void 0 && excludes.has(writer)) keys.push(key);
+	}
 	return keys;
 };
+const composeRefinements = (refinements, generated) => {
+	const merged = { ...refinements };
+	for (const key of Object.keys(generated)) {
+		const inner = generated[key];
+		const refinement = refinements?.[key];
+		if (refinement === void 0) merged[key] = inner;
+		else if (typeof refinement === "function") merged[key] = (schema) => refinement(inner(schema));
+	}
+	return merged;
+};
+const FIELD_HINTS_KEY = Symbol.for("@zeno-lib/field-hints");
+const fieldHints = (() => {
+	const holder = globalThis;
+	holder[FIELD_HINTS_KEY] ??= z.registry();
+	return holder[FIELD_HINTS_KEY];
+})();
+const withHint = (rule, hint) => (schema) => {
+	const ruled = rule(schema);
+	fieldHints.add(ruled, hint);
+	return ruled;
+};
+const withRuleRefinements = (table, refinements) => {
+	const rules = columnRules(table);
+	const generated = {};
+	for (const key of Object.keys(rules)) {
+		const { hint, refine } = rules[key] ?? {};
+		if (typeof refine === "function") generated[key] = hint === void 0 ? refine : withHint(refine, hint);
+	}
+	return composeRefinements(refinements, generated);
+};
 const isPositiveIdentity = (column) => {
 	const identity = column.generatedIdentity;
 	if (identity === void 0) return false;
@@ -20,33 +54,108 @@ const isPositiveIdentity = (column) => {
 	return Number(increment) > 0 && Number(minValue) > 0 && Number(startWith) > 0;
 };
 const toPositive = (schema) => typeof schema.positive === "function" ? schema.positive() : schema;
-const withPositiveIdentities = (table, refinements = {}) => {
+const positiveCheck = (column) => isPositiveIdentity(column) ? toPositive : void 0;
+const TIMESTAMP = /^(\d{4}-\d{2}-\d{2})[T ](?:[01]\d|2[0-3]):[0-5]\d(?::[0-5]\d(?:\.\d+)?)?([+-](?:0\d|1[0-5])(?::?[0-5]\d)?|Z)?$/;
+const INFINITIES = /* @__PURE__ */ new Set(["-infinity", "infinity"]);
+const ISO_DATE = z.iso.date();
+const isDate = (value) => ISO_DATE.safeParse(value).success;
+const isTimestamp = (withTimezone) => (value) => {
+	const [, day, offset] = TIMESTAMP.exec(value) ?? [];
+	return day !== void 0 && isDate(day) && offset !== void 0 === withTimezone;
+};
+const withFormat = (format, isValid) => (schema) => schema.check((context) => {
+	if (!(INFINITIES.has(context.value) || isValid(context.value))) context.issues.push({
+		code: "invalid_format",
+		continue: true,
+		format,
+		input: context.value
+	});
+});
+const formatCheck = (column) => {
+	const { dimensions = 0, withTimezone = false } = column;
+	if (dimensions > 0) return;
+	switch (column.dataType) {
+		case "string date": return withFormat("date", isDate);
+		case "string timestamp": return withFormat("datetime", isTimestamp(withTimezone));
+		default: return;
+	}
+};
+const withChecks = (table, checkFor, refinements) => {
 	const columns = getColumns(table);
-	const merged = { ...refinements };
+	const generated = {};
 	for (const key of Object.keys(columns)) {
 		const column = columns[key];
-		if (column === void 0 || !isPositiveIdentity(column)) continue;
-		const refinement = refinements[key];
-		if (refinement === void 0) merged[key] = toPositive;
-		else if (typeof refinement === "function") merged[key] = (schema) => refinement(toPositive(schema));
+		const check = column === void 0 ? void 0 : checkFor(column);
+		if (check !== void 0) generated[key] = check;
 	}
-	return merged;
+	return composeRefinements(refinements, generated);
 };
-function defineTableSchema(table, options) {
+const omitPresent = (schema, keys) => {
+	const mask = {};
+	for (const key of keys) if (key in schema.shape) mask[key] = true;
+	return schema.omit(mask);
+};
+const buildTableSchema = (name, table, options, excludes) => {
+	if (!(COLUMN_RULES_KEY in table)) throw new TypeError(`${name} reads the column rules of a table from table(), unsecureTable() or schema(...).table in @zeno-lib/db/schema, and "${getTableName(table)}" has none.`);
 	const schemaFactory = createSchemaFactory$1(options?.factory);
-	const audit = auditKeys(table);
-	const omitAudit = (schema) => {
-		const mask = {};
-		for (const key of audit) if (key in schema.shape) mask[key] = true;
-		return schema.omit(mask);
-	};
+	const unwritable = unwritableKeys(table, excludes);
+	const omitUnwritable = (schema) => omitPresent(schema, unwritable);
 	const factory = schemaFactory;
-	const build = (variant, create) => create(table, withPositiveIdentities(table, options?.[variant]));
+	const write = (variant, create) => omitUnwritable(create(table, withChecks(table, formatCheck, withRuleRefinements(table, options?.[variant]))));
 	return {
-		insert: omitAudit(build("insert", factory.createInsertSchema)),
-		select: build("select", factory.createSelectSchema),
-		update: omitAudit(build("update", factory.createUpdateSchema))
+		insert: write("insert", factory.createInsertSchema),
+		select: factory.createSelectSchema(table, withChecks(table, positiveCheck, options?.select)),
+		table,
+		update: write("update", factory.createUpdateSchema)
 	};
+};
+function defineTableSchema(table, options) {
+	return buildTableSchema("defineTableSchema", table, options, CLIENT_EXCLUDES);
+}
+function defineServerTableSchema(table, options) {
+	return buildTableSchema("defineServerTableSchema", table, options, SERVER_EXCLUDES);
 }
+/**
+* The rows of `schema`'s table that belong to a parent through the `parent`
+* columns, for a form that edits them as a list and the `syncRows` that saves
+* it:
+*
+* ```ts
+* const orderLines = ownedRows(defineTableSchema(lines), { parent: "orderId" })
+*
+* const orderSchema = defineTableSchema(orders).insert.extend({
+*   lines: z.array(orderLines.row),
+* })
+*
+* await syncRows(tx, orderLines, { parent: { orderId }, rows: input.lines })
+* ```
+*
+* The table needs a sequential `id`. A link table matched by a natural key
+* goes to `syncRows` with its `key` option instead.
+*/
+const ownedRows = (schema, { parent }) => {
+	const parentKeys = typeof parent === "string" ? [parent] : [...parent];
+	const id = schema.select.shape.id;
+	if (id === void 0) throw new TypeError(`ownedRows tells rows apart by their id, and "${getTableName(schema.table)}" has none.`);
+	return {
+		parent: parentKeys,
+		row: omitPresent(schema.insert, parentKeys).extend({ id: id.optional() }),
+		table: schema.table
+	};
+};
+const isZenoTable = (value) => is(value, Table) && COLUMN_RULES_KEY in value;
+/**
+* The columns a client may write, for every Zeno table among `exports` (a
+* schema barrel, say), keyed by name (`schema.table` outside `public`): what `defineTableSchema`'s
+* `insert` accepts, and `update` accepts the same. Columns are writable unless
+* marked, so snapshot this in one test, and a newly writable column shows up
+* as a diff in review.
+*/
+const writableColumns = (exports) => {
+	const tables = Object.keys(exports).map((key) => exports[key]).filter(isZenoTable).map((table) => [getTableUniqueName(table), table]).sort(([a], [b]) => a < b ? -1 : 1);
+	const columns = {};
+	for (const [name, table] of tables) columns[name] = Object.keys(buildTableSchema("writableColumns", table, void 0, CLIENT_EXCLUDES).insert.shape).sort();
+	return columns;
+};
 //#endregion
-export { createInsertSchema, createSchemaFactory, createSelectSchema, createUpdateSchema, defineTableSchema };
+export { createInsertSchema, createSchemaFactory, createSelectSchema, createUpdateSchema, defineServerTableSchema, defineTableSchema, ownedRows, writableColumns };

package/package.json

@@ -1,6 +1,10 @@
 {
   "name": "@zeno-lib/schema",
-  "version": "0.2.2",
+  "version": "0.4.0",
+  "repository": {
+    "url": "https://github.com/zeno-lib/zeno.git",
+    "directory": "packages/schema"
+  },
   "type": "module",
   "exports": {
     ".": {
@@ -13,24 +17,20 @@
     "dist",
     "src"
   ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "url": "https://github.com/zeno-lib/zeno.git",
-    "directory": "packages/schema"
+  "devDependencies": {
+    "@zeno-lib/typescript": "^1.2.0",
+    "drizzle-orm": "1.0.0-rc.5-5935859",
+    "tsdown": "^0.23.0",
+    "typescript": "7.0.2",
+    "vitest": "5.0.3",
+    "zod": "^4.6.5"
   },
   "peerDependencies": {
-    "drizzle-orm": "1.0.0-rc.3",
+    "drizzle-orm": "1.0.0-rc.5-5935859",
     "zod": ">=4"
   },
-  "devDependencies": {
-    "drizzle-orm": "1.0.0-rc.3",
-    "tsdown": "^0.22.14",
-    "typescript": "7.0.2",
-    "vitest": "4.1.11",
-    "zod": "^4.4.3",
-    "@zeno-lib/typescript": "^1.1.0"
+  "publishConfig": {
+    "access": "public"
   },
   "scripts": {
     "build": "tsdown",

package/src/index.test-d.ts

@@ -1,9 +1,9 @@
-import { sql } from "drizzle-orm"
-import { integer, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core"
+import { integer, pgTable, text, timestamp } from "drizzle-orm/pg-core"
 import { expectTypeOf, test } from "vitest"
 import { z } from "zod"
 
 import { defineTableSchema } from "./index"
+import { zenoTable } from "./test-table"
 
 type StandardSchema<T> = {
   readonly "~standard": {
@@ -12,17 +12,17 @@ type StandardSchema<T> = {
   }
 }
 
-function acceptsFormsSchema<TFormData>(
+declare function acceptsFormsSchema<TFormData>(
   _schema: StandardSchema<TFormData>
-): void {
-  return
-}
+): void
 
-const posts = pgTable("posts", {
-  id: integer("id").primaryKey().generatedAlwaysAsIdentity(),
-  slug: text("slug").notNull(),
-  title: text("title").notNull(),
-})
+const posts = zenoTable(
+  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)
@@ -54,39 +54,29 @@ test("refined schemas preserve refinement-specific output types", () => {
   }>()
 })
 
-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)
+test("a column named like an audit column stays in the insert type", () => {
+  const events = zenoTable(
+    pgTable("events", {
+      createdAt: timestamp("created_at").notNull().defaultNow(),
+      label: text("label").notNull(),
+    })
+  )
+  const schemas = defineTableSchema(events)
 
   expectTypeOf<z.infer<typeof schemas.insert>>().toEqualTypeOf<{
-    body: string
-    updatedAt: Date
+    createdAt?: Date | undefined
+    label: string
   }>()
-  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 },
-  })
 })
 
 test("a function refinement keeps a nullable or defaulted insert column optional", () => {
-  const drafts = pgTable("drafts", {
-    note: text("note"),
-    status: text("status").notNull().default("open"),
-    title: text("title").notNull(),
-  })
+  const drafts = zenoTable(
+    pgTable("drafts", {
+      note: text("note"),
+      status: text("status").notNull().default("open"),
+      title: text("title").notNull(),
+    })
+  )
   const schemas = defineTableSchema(drafts, {
     insert: {
       note: (schema) => schema.min(1),