@zeno-lib/schema 0.2.0 → 0.2.2

package/dist/index.d.mts

@@ -0,0 +1,34 @@
+import { Column, InferInsertModel, InferSelectModel, Table } from "drizzle-orm";
+import { BuildRefine, BuildSchema, CoerceOptions, CreateSchemaFactoryOptions, NoUnknownKeys, createInsertSchema, createSchemaFactory, createSelectSchema, createUpdateSchema } from "drizzle-orm/zod";
+import { z } from "zod";
+//#region src/index.d.ts
+declare const noTableSchemaOptions: unique symbol;
+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>>>;
+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 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>>;
+  select: BuildSchema<"select", TableColumns<TTable>, RefineFromOptions<TOptions, "select">, TCoerce>;
+  update: OmitKeys<BuildSchema<"update", TableColumns<TTable>, RefineFromOptions<TOptions, "update">, TCoerce>, AuditKeys<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>;
+//#endregion
+export { type DefineTableSchemaOptions, type DefineTableSchemaResult, createInsertSchema, createSchemaFactory, createSelectSchema, createUpdateSchema, defineTableSchema };

package/dist/index.mjs

@@ -0,0 +1,52 @@
+import { getColumns } from "drizzle-orm";
+import { createInsertSchema, createSchemaFactory, createSchemaFactory as createSchemaFactory$1, createSelectSchema, createUpdateSchema } from "drizzle-orm/zod";
+//#region src/index.ts
+const AUDIT_COLUMN_KEYS = /* @__PURE__ */ new Set([
+	"createdAt",
+	"createdBy",
+	"updatedAt",
+	"updatedBy"
+]);
+const auditKeys = (table) => {
+	const columns = getColumns(table);
+	const keys = [];
+	for (const key of Object.keys(columns)) if (AUDIT_COLUMN_KEYS.has(key) && columns[key]?.hasDefault) keys.push(key);
+	return keys;
+};
+const isPositiveIdentity = (column) => {
+	const identity = column.generatedIdentity;
+	if (identity === void 0) return false;
+	const { increment = 1, minValue = 1, startWith = minValue } = identity.sequenceOptions ?? {};
+	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 columns = getColumns(table);
+	const merged = { ...refinements };
+	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));
+	}
+	return merged;
+};
+function defineTableSchema(table, options) {
+	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 factory = schemaFactory;
+	const build = (variant, create) => create(table, withPositiveIdentities(table, options?.[variant]));
+	return {
+		insert: omitAudit(build("insert", factory.createInsertSchema)),
+		select: build("select", factory.createSelectSchema),
+		update: omitAudit(build("update", factory.createUpdateSchema))
+	};
+}
+//#endregion
+export { createInsertSchema, createSchemaFactory, createSelectSchema, createUpdateSchema, defineTableSchema };

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "@zeno-lib/schema",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "type": "module",
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
   },
   "files": [
+    "dist",
     "src"
   ],
   "publishConfig": {
@@ -21,12 +26,14 @@
   },
   "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"
   },
   "scripts": {
+    "build": "tsdown",
     "test": "vitest --run",
     "test:watch": "vitest watch",
     "types:check": "tsc --noEmit"

package/src/index.test-d.ts

@@ -80,3 +80,29 @@ test("defaulted audit columns leave the insert and update types", () => {
     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 schemas = defineTableSchema(drafts, {
+    insert: {
+      note: (schema) => schema.min(1),
+      status: (schema) => schema.min(1),
+      title: (schema) => schema.min(1),
+    },
+  })
+
+  expectTypeOf<z.infer<typeof schemas.insert>>().toEqualTypeOf<{
+    note?: string | null | undefined
+    status?: string | undefined
+    title: string
+  }>()
+  expectTypeOf<z.input<typeof schemas.insert>>().toEqualTypeOf<{
+    note?: string | null | undefined
+    status?: string | undefined
+    title: string
+  }>()
+})

package/src/index.test.ts

@@ -210,4 +210,23 @@ describe("defineTableSchema", () => {
     expect(schemas.insert.safeParse({ id: 11 }).success).toBe(false)
     expect(schemas.insert.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 schemas = defineTableSchema(drafts, {
+      insert: { note: (schema) => schema.min(1) },
+    })
+
+    expect(schemas.insert.parse({ title: "x" })).toEqual({ title: "x" })
+    expect(schemas.insert.parse({ note: null, title: "x" })).toEqual({
+      note: null,
+      title: "x",
+    })
+    expect(schemas.insert.safeParse({ note: "", title: "x" }).success).toBe(
+      false
+    )
+  })
 })

package/src/index.ts

@@ -99,17 +99,54 @@ type OmitKeys<TSchema, TKeys extends PropertyKey> =
       >
     : never
 
+// Drizzle types a function refinement on an insert column as required, even
+// when the column is nullable or defaulted and the runtime wraps it in
+// `.optional()`. This puts the wrapper back into the type.
+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<
-    BuildSchema<
-      "insert",
-      TableColumns<TTable>,
-      RefineFromOptions<TOptions, "insert">,
-      TCoerce
+    OptionalRefinedInsert<
+      BuildSchema<
+        "insert",
+        TableColumns<TTable>,
+        RefineFromOptions<TOptions, "insert">,
+        TCoerce
+      >,
+      TTable,
+      RefineFromOptions<TOptions, "insert">
     >,
     AuditKeys<TTable>
   >