@zeno-lib/schema 0.2.1 → 0.3.0

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { InferInsertModel, InferSelectModel, Table } from "drizzle-orm";
+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
@@ -21,8 +21,10 @@ type DefineTableSchemaOptions<TTable extends Table, TCoerce extends CoerceOption
 };
 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<BuildSchema<"insert", TableColumns<TTable>, RefineFromOptions<TOptions, "insert">, TCoerce>, AuditKeys<TTable>>;
+  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>>;
 };

package/package.json

@@ -1,6 +1,10 @@
 {
   "name": "@zeno-lib/schema",
-  "version": "0.2.1",
+  "version": "0.3.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.1.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

@@ -12,11 +12,9 @@ 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(),
@@ -80,3 +78,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>
   >