@opensaas/stack-core 0.21.0 → 0.22.0

package/src/config/types.ts

@@ -462,12 +462,16 @@ export type BaseFieldConfig<TTypeInfo extends TypeInfo> = {
    * @param fieldName - The name of the field (for generating modifiers)
    * @param provider - Optional database provider ('sqlite', 'postgresql', 'mysql', etc.)
    * @param listName - Optional list name (used for generating enum type names)
+   * @param keystoneCompat - Whether Keystone-compat mode is enabled (db.keystoneCompat).
+   *   When true, non-null text columns without an explicit defaultValue emit
+   *   `@default("")` to match Keystone 6's implicit empty-string text default.
    * @returns Prisma type string, optional modifiers, and optional enum values
    */
   getPrismaType?: (
     fieldName: string,
     provider?: string,
     listName?: string,
+    keystoneCompat?: boolean,
   ) => {
     type: string
     modifiers?: string
@@ -506,6 +510,72 @@ export type BaseFieldConfig<TTypeInfo extends TypeInfo> = {
      */
     typeOnly?: boolean
   }>
+  /**
+   * Multi-column Prisma emission.
+   *
+   * Most scalar fields back a single Prisma column via {@link getPrismaType}.
+   * A field that maps onto SEVERAL physical columns (e.g. the storage
+   * `image()`/`file()` fields in multi-column / Keystone-parity mode — see
+   * ADR-0006) implements this instead: it returns one descriptor per column,
+   * each becoming its own line in the generated model. When present, the
+   * generator emits these lines and skips the single-column `getPrismaType`
+   * path. The field itself owns the column layout — the generator stays a
+   * neutral coordinator (no field-type switches), mirroring how relationship
+   * fields emit FK + relation lines through `getPrismaRelation`.
+   *
+   * @param fieldName - The field's config key (used to derive default column names)
+   * @returns One descriptor per physical column, or `undefined` to fall back to
+   *   the single-column `getPrismaType` path.
+   */
+  getPrismaColumns?: (fieldName: string) => MultiColumnPrismaResult[] | undefined
+  /**
+   * The physical Prisma column names this field owns when it spans multiple
+   * columns (see {@link getPrismaColumns}). The read path uses this to strip the
+   * raw per-part columns from query results so only the assembled logical value
+   * (produced by {@link assembleColumns}) is exposed.
+   *
+   * @param fieldName - The field's config key
+   */
+  getColumnNames?: (fieldName: string) => string[]
+  /**
+   * Assemble the field's logical value from a database row's per-part columns
+   * (the read direction of a multi-column field). Pure transform — called by the
+   * read pipeline before field visibility. Receives the full row so it can read
+   * its sibling columns by name.
+   *
+   * @param fieldName - The field's config key
+   * @param row - The raw database row (contains the per-part columns)
+   */
+  assembleColumns?: (fieldName: string, row: Record<string, unknown>) => unknown
+  /**
+   * Split the field's logical value into per-part columns for writing (the write
+   * direction of a multi-column field). Pure transform — called by the write
+   * pipeline after `resolveInput`; the returned record is merged into the write
+   * payload in place of the single field key.
+   *
+   * @param fieldName - The field's config key
+   * @param value - The resolved logical value (metadata, or `null` to clear)
+   */
+  splitColumns?: (fieldName: string, value: unknown) => Record<string, unknown>
+}
+
+/**
+ * A single physical column contributed by a multi-column field
+ * (see {@link BaseFieldConfig.getPrismaColumns}).
+ */
+export type MultiColumnPrismaResult = {
+  /** The Prisma model field name (the property the column is declared as). */
+  name: string
+  /** The Prisma scalar type, e.g. `'String'` or `'Int'`. */
+  type: string
+  /**
+   * Field modifiers, e.g. `'?'` for nullable. A leading `'?'` attaches to the
+   * type; anything after it is treated as trailing attributes (matching the
+   * single-column `getPrismaType` modifier convention).
+   */
+  modifiers?: string
+  /** Physical column name for the `@map` attribute, when it differs from `name`. */
+  map?: string
 }
 
 export type TextField<TTypeInfo extends TypeInfo = TypeInfo> = BaseFieldConfig<TTypeInfo> & {
@@ -587,6 +657,46 @@ export type SelectField<TTypeInfo extends TypeInfo = TypeInfo> = BaseFieldConfig
      */
     type?: 'string' | 'enum'
     map?: string
+    /**
+     * Force the generated column to be nullable (`?`) even when a `defaultValue`
+     * is present. By default a select with a `defaultValue` generates NOT NULL;
+     * set this to `true` for an explicit opt-in to a nullable column with a
+     * default (e.g. `String? @default("X")` or `<Enum>? @default(X)`), so that
+     * a live column containing NULLs migrates without a NOT NULL failure.
+     *
+     * @default undefined (NOT NULL when a default is present — unchanged behaviour)
+     *
+     * @example
+     * ```typescript
+     * // Optional select with a default, but keep the column nullable
+     * status: select({
+     *   options: [{ label: 'Draft', value: 'draft' }],
+     *   defaultValue: 'draft',
+     *   db: { isNullable: true },
+     * })
+     * // Generates: String? @default("draft")
+     * ```
+     */
+    isNullable?: boolean
+    /**
+     * Override the generated Prisma enum type name for native-enum selects
+     * (only applies when `type: 'enum'`). By default the enum is named
+     * `<List><Field>` (e.g. `AccountNoteStatus`); set this to match a live DB
+     * enum type whose name differs (e.g. Keystone's `…Type` suffix).
+     *
+     * The custom name is applied to both the generated `enum` block and every
+     * reference to it in the owning model.
+     *
+     * @example
+     * ```typescript
+     * status: select({
+     *   options: [{ label: 'Open', value: 'open' }],
+     *   db: { type: 'enum', enumName: 'AccountNoteStatusType' },
+     * })
+     * // Generates: enum AccountNoteStatusType { ... } and the column references it
+     * ```
+     */
+    enumName?: string
   }
   validation?: {
     isRequired?: boolean
@@ -1199,6 +1309,65 @@ export type ListConfig<TTypeInfo extends TypeInfo> = {
     operation?: OperationAccess<TTypeInfo['item']>
   }
   hooks?: Hooks<TTypeInfo['item'], TTypeInfo['inputs']['create'], TTypeInfo['inputs']['update']>
+  /**
+   * Database configuration for this list (model level)
+   */
+  db?: {
+    /**
+     * Custom database table name.
+     * Adds a `@@map` attribute to the generated Prisma model.
+     *
+     * Useful when the Prisma model name (the list key) must differ from the
+     * physical table name — e.g. adopting an existing better-auth installation
+     * whose tables were created under a different name.
+     *
+     * @example
+     * ```typescript
+     * AuthUser: list({ fields: { ... }, db: { map: 'user' } })
+     * // Generates: model AuthUser { ... @@map("user") }
+     * ```
+     */
+    map?: string
+    /**
+     * Database schema for this model (Postgres multi-schema).
+     * Adds a `@@schema` attribute to the generated Prisma model.
+     *
+     * Requires the schema to be listed in the datasource `schemas` array (see
+     * {@link DatabaseConfig.schemas}) and the `multiSchema` preview feature,
+     * both of which the generator emits automatically when `db.schemas` is set.
+     *
+     * Useful when adopting an existing installation whose tables live in a
+     * non-`public` schema — e.g. a separate-schema better-auth layout.
+     *
+     * @example
+     * ```typescript
+     * AuthUser: list({ fields: { ... }, db: { schema: 'auth' } })
+     * // Generates: model AuthUser { ... @@schema("auth") }
+     * ```
+     */
+    schema?: string
+    /**
+     * Per-list override for auto-injected `createdAt`/`updatedAt` timestamp columns.
+     *
+     * Takes precedence over the global `db.timestamps` setting:
+     * - `true` forces auto-timestamps on for this list, even when the global default is off.
+     * - `false` forces them off for this list, even when enabled globally.
+     * - `undefined` (the default) falls back to the global `db.timestamps` setting.
+     *
+     * When timestamps resolve to on but the list already declares its own `createdAt`/
+     * `updatedAt` field, the auto column is skipped for the declared field(s) so Prisma
+     * never sees a duplicate (`P1012`).
+     *
+     * @example Opt a single list out of timestamps even when enabled globally
+     * ```typescript
+     * Production: list({
+     *   fields: { name: text() },
+     *   db: { timestamps: false },
+     * })
+     * ```
+     */
+    timestamps?: boolean
+  }
   /**
    * MCP server configuration for this list
    */
@@ -1331,6 +1500,86 @@ export type DatabaseConfig = {
    * ```
    */
   joinTableNaming?: 'prisma' | 'keystone'
+  /**
+   * Postgres multi-schema support.
+   *
+   * When set, the generator enables Prisma's `multiSchema` preview feature and
+   * emits the `schemas = [...]` array on the datasource block. Combine with a
+   * per-list `db.schema` (see {@link ListConfig}) to place models in a specific
+   * schema via `@@schema(...)`.
+   *
+   * Only applies to the `postgresql` provider. When unset, the generated schema
+   * is unchanged (single `public` schema, no `@@schema` attributes).
+   *
+   * @example Separate `auth` schema alongside the default `public`
+   * ```typescript
+   * db: {
+   *   provider: 'postgresql',
+   *   schemas: ['public', 'auth'],
+   *   // ...
+   * }
+   * ```
+   */
+  schemas?: string[]
+  /**
+   * Auto-inject `createdAt`/`updatedAt` timestamp columns into every generated model.
+   *
+   * Default: `false`. The generator does NOT add timestamps automatically — a list
+   * opts in either by declaring the fields itself or by enabling this flag. This matches
+   * Keystone 6, which never adds timestamps automatically, and keeps Keystone → stack
+   * migrations non-destructive (Schema parity). See ADR-0004.
+   *
+   * When `true`, every list receives:
+   * ```prisma
+   * createdAt DateTime @default(now())
+   * updatedAt DateTime @default(now()) @updatedAt
+   * ```
+   *
+   * A per-list `db.timestamps` override takes precedence over this global setting. When
+   * timestamps are enabled but a list already declares its own `createdAt`/`updatedAt`
+   * field, the auto column is skipped for the declared field(s) so Prisma never sees a
+   * duplicate (`P1012`).
+   *
+   * @default false
+   *
+   * @example Re-enable auto-timestamps globally
+   * ```typescript
+   * db: {
+   *   provider: 'postgresql',
+   *   timestamps: true,
+   *   // ... rest of config
+   * }
+   * ```
+   */
+  timestamps?: boolean
+  /**
+   * Opt into Keystone-compat mode for generated schema defaults.
+   *
+   * Keystone 6 gives every non-null text column an implicit empty-string
+   * default. With `keystoneCompat: true`, the generator mirrors that: any
+   * non-null `text()` column that has no explicit `defaultValue` emits
+   * `@default("")`, so a migrating project reaches Schema parity without
+   * hand-setting `defaultValue: ''` on dozens of columns.
+   *
+   * Stays opt-in (default `false`) because a greenfield project would not want
+   * implicit empty-string text defaults cluttering its schema. The flag never
+   * affects nullable text, fields with an explicit `defaultValue`, or any
+   * non-text field — an explicit `text({ defaultValue: 'x' })` always wins.
+   *
+   * @default false
+   *
+   * @example Reach Schema parity when migrating from Keystone
+   * ```typescript
+   * db: {
+   *   provider: 'postgresql',
+   *   keystoneCompat: true, // non-null text without a default → @default("")
+   *   // ... rest of config
+   * }
+   * ```
+   *
+   * @see ADR-0004 (Keystone-compatible generator defaults)
+   */
+  keystoneCompat?: boolean
   /**
    * Optional function to extend or modify the generated Prisma schema
    * Receives the generated schema as a string and should return the modified schema
@@ -1821,6 +2070,34 @@ export type Plugin = {
  * Main configuration type
  * Using interface instead of type to allow module augmentation
  */
+/**
+ * Configurable generator output locations.
+ *
+ * Lets a project relocate the generated Prisma schema and the `.opensaas`
+ * bundle directory. Paths are interpreted relative to the project root.
+ *
+ * @example
+ * ```typescript
+ * output: {
+ *   prismaSchema: 'prisma-opensaas/schema.prisma',
+ *   opensaasDir: '.opensaas',
+ * }
+ * ```
+ */
+export interface OutputConfig {
+  /**
+   * Path to the generated Prisma schema file.
+   * @default "prisma/schema.prisma"
+   */
+  prismaSchema?: string
+  /**
+   * Directory for the generated `.opensaas` bundle (types, lists, context,
+   * plugin-types, prisma-extensions, and the patched Prisma client).
+   * @default ".opensaas"
+   */
+  opensaasDir?: string
+}
+
 export interface OpenSaasConfig {
   db: DatabaseConfig
   // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Config must accept any list configuration
@@ -1841,6 +2118,20 @@ export interface OpenSaasConfig {
    * @default ".opensaas"
    */
   opensaasPath?: string
+  /**
+   * Relocate the generator's output so `opensaas generate` can coexist with an
+   * existing `prisma/` directory (e.g. during a Keystone → stack migration).
+   *
+   * Both fields are resolved relative to the project root (the directory the
+   * CLI runs in). When omitted, defaults are unchanged: the schema is written to
+   * `prisma/schema.prisma` and the `.opensaas` bundle to `.opensaas/`.
+   *
+   * The generated files' cross-references follow these locations — `context.ts`
+   * imports the generated types/lists from the resolved `.opensaas` dir, and the
+   * top-level `prisma.config.ts` points at the configured schema path so the
+   * `prisma` CLI keeps working.
+   */
+  output?: OutputConfig
   /**
    * Plugins to extend the stack
    * Executed in array order (or dependency order if dependencies specified)

package/src/extend.ts

@@ -11,4 +11,9 @@
 export type { Plugin, PluginContext, GeneratedFiles } from './config/index.js'
 
 // Third-party field authoring (implement BaseFieldConfig; see custom-field docs)
-export type { BaseFieldConfig, TypeInfo, TypeDescriptor } from './config/index.js'
+export type {
+  BaseFieldConfig,
+  TypeInfo,
+  TypeDescriptor,
+  MultiColumnPrismaResult,
+} from './config/index.js'

package/src/fields/format-prisma-default.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect } from 'vitest'
+import { formatPrismaDefault, type PrismaDefaultFieldType } from './format-prisma-default.js'
+
+describe('formatPrismaDefault', () => {
+  describe('table-driven serialisation', () => {
+    const cases: Array<{
+      name: string
+      value: unknown
+      fieldType: PrismaDefaultFieldType
+      expected: string | undefined
+    }> = [
+      // text
+      {
+        name: 'non-empty string',
+        value: 'PLEASE_UPDATE',
+        fieldType: 'text',
+        expected: '"PLEASE_UPDATE"',
+      },
+      { name: 'empty string', value: '', fieldType: 'text', expected: '""' },
+      {
+        name: 'string with embedded quotes',
+        value: 'say "hi"',
+        fieldType: 'text',
+        expected: '"say \\"hi\\""',
+      },
+      // integer
+      { name: 'integer', value: 3550, fieldType: 'integer', expected: '3550' },
+      { name: 'zero integer', value: 0, fieldType: 'integer', expected: '0' },
+      { name: 'negative integer', value: -7, fieldType: 'integer', expected: '-7' },
+      // json
+      { name: 'JSON array', value: [1, 2, 3, 4, 5], fieldType: 'json', expected: '"[1,2,3,4,5]"' },
+      {
+        name: 'JSON object',
+        value: { a: 1, b: 'two' },
+        fieldType: 'json',
+        expected: '"{\\"a\\":1,\\"b\\":\\"two\\"}"',
+      },
+      { name: 'empty array', value: [], fieldType: 'json', expected: '"[]"' },
+      { name: 'empty object', value: {}, fieldType: 'json', expected: '"{}"' },
+      // undefined → no default for every field type
+      { name: 'undefined text', value: undefined, fieldType: 'text', expected: undefined },
+      { name: 'undefined integer', value: undefined, fieldType: 'integer', expected: undefined },
+      { name: 'undefined json', value: undefined, fieldType: 'json', expected: undefined },
+    ]
+
+    it.each(cases)('serialises $name → $expected', ({ value, fieldType, expected }) => {
+      expect(formatPrismaDefault(value, fieldType)).toBe(expected)
+    })
+  })
+
+  it('produces canonical space-free JSON (no extra whitespace)', () => {
+    // Guards against pretty-printed JSON sneaking into the literal.
+    expect(formatPrismaDefault([1, 2, 3], 'json')).toBe('"[1,2,3]"')
+    expect(formatPrismaDefault({ nested: { x: [1] } }, 'json')).toBe(
+      '"{\\"nested\\":{\\"x\\":[1]}}"',
+    )
+  })
+
+  it('wraps a JSON string default in escaped quotes around the JSON text', () => {
+    // A string value under the json field type is itself valid JSON; it gets
+    // double-serialised: inner JSON.stringify("hi") = "\"hi\"", then wrapped.
+    expect(formatPrismaDefault('hi', 'json')).toBe('"\\"hi\\""')
+  })
+})

package/src/fields/format-prisma-default.ts

@@ -0,0 +1,67 @@
+/**
+ * Field types that {@link formatPrismaDefault} knows how to serialise.
+ *
+ * Kept narrow on purpose: only the scalar fields whose `defaultValue` maps to a
+ * Prisma `@default(...)` literal via this shared helper. Other fields (e.g.
+ * `checkbox`, `decimal`, `timestamp`) format their own defaults inline because
+ * their literal forms diverge (`@default(now())`, bare booleans, etc.).
+ */
+export type PrismaDefaultFieldType = 'text' | 'integer' | 'json'
+
+/**
+ * Serialise a field's `defaultValue` into the inner literal of a Prisma
+ * `@default(...)` attribute.
+ *
+ * Pure: no I/O, no field-builder coupling. Returns just the literal (the caller
+ * wraps it in `@default(...)`), so it composes with whatever modifier string a
+ * field builder assembles. Returns `undefined` when there is nothing to emit, so
+ * a field with no `defaultValue` produces no `@default(...)` at all.
+ *
+ * Serialisation rules (Keystone 6 compatible):
+ * - `integer` → bare numeric literal, e.g. `3550` → `@default(3550)`.
+ * - `text` → double-quoted string literal, e.g. `PLEASE_UPDATE` → `@default("PLEASE_UPDATE")`.
+ * - `json` → Keystone's JSON-literal form: `JSON.stringify` the value with no
+ *   extra whitespace, then wrap the result in escaped double quotes, e.g.
+ *   `[1,2,3,4,5]` → `@default("[1,2,3,4,5]")` and `[]` → `@default("[]")`.
+ *
+ * Nullability (the `?` modifier) is the caller's concern and is handled
+ * independently of the default — this function never touches it.
+ *
+ * @param value - The configured `defaultValue` (the field builder's `defaultValue`).
+ * @param fieldType - The field's discriminator, selecting the serialisation rule.
+ * @returns The literal to place inside `@default(...)`, or `undefined` when
+ *   `value` is `undefined` (no default to emit).
+ */
+export function formatPrismaDefault(
+  value: unknown,
+  fieldType: PrismaDefaultFieldType,
+): string | undefined {
+  if (value === undefined) {
+    return undefined
+  }
+
+  switch (fieldType) {
+    case 'integer':
+      // Bare numeric literal — Prisma expects no quotes for Int defaults.
+      return String(value)
+
+    case 'text':
+      // Double-quoted string literal. The value is escaped via JSON.stringify so
+      // embedded quotes/backslashes are handled correctly.
+      return JSON.stringify(String(value))
+
+    case 'json': {
+      // Keystone's JSON-literal form: canonical, space-free JSON.stringify of the
+      // value, then wrap the whole serialised string in escaped double quotes so
+      // Prisma stores the JSON text as the column default. The outer
+      // JSON.stringify produces the escaped, double-quoted wrapper.
+      const serialised = JSON.stringify(value)
+      // JSON.stringify can return undefined for unserialisable values (e.g. a
+      // function). Treat that as "no default" rather than emitting `@default()`.
+      if (serialised === undefined) {
+        return undefined
+      }
+      return JSON.stringify(serialised)
+    }
+  }
+}

package/src/fields/index.ts

@@ -16,6 +16,7 @@ import type {
   PrismaRelationResult,
 } from '../config/types.js'
 import { hashPassword, isHashedPassword, HashedPassword } from '../utils/password.js'
+import { formatPrismaDefault } from './format-prisma-default.js'
 
 // Field-config types live here, alongside the builders that produce them.
 // (The umbrella `FieldConfig` and authoring `BaseFieldConfig` stay on the root
@@ -33,6 +34,7 @@ export type {
   JsonField,
   VirtualField,
   PrismaRelationResult,
+  MultiColumnPrismaResult,
 } from '../config/types.js'
 
 /**
@@ -87,7 +89,12 @@ export function text<
 
       return !isRequired ? withMax.optional().nullable() : withMax
     },
-    getPrismaType: (_fieldName: string) => {
+    getPrismaType: (
+      _fieldName: string,
+      _provider?: string,
+      _listName?: string,
+      keystoneCompat?: boolean,
+    ) => {
       const validation = options?.validation
       const db = options?.db
       const isRequired = validation?.isRequired
@@ -104,6 +111,23 @@ export function text<
         modifiers += ` @db.${db.nativeType}`
       }
 
+      // Default value. An explicit `defaultValue` always wins. When none is set
+      // and Keystone-compat mode is on, a non-null text column gets Keystone's
+      // implicit empty-string default. Both go through formatPrismaDefault, so
+      // the empty-string literal (`""`) is produced the same way as any other
+      // text default. Independent of the nullable `?` modifier above — the
+      // default never overwrites nullability.
+      const defaultSource =
+        options?.defaultValue !== undefined
+          ? options.defaultValue
+          : keystoneCompat && !isNullable
+            ? ''
+            : undefined
+      const defaultLiteral = formatPrismaDefault(defaultSource, 'text')
+      if (defaultLiteral !== undefined) {
+        modifiers += ` @default(${defaultLiteral})`
+      }
+
       // Unique/index modifiers
       if (options?.isIndexed === 'unique') {
         modifiers += ' @unique'
@@ -182,6 +206,13 @@ export function integer<
         modifiers += ` @db.${db.nativeType}`
       }
 
+      // Default value if provided (bare numeric literal). Independent of the
+      // nullable `?` modifier above — the default never overwrites nullability.
+      const defaultLiteral = formatPrismaDefault(options?.defaultValue, 'integer')
+      if (defaultLiteral !== undefined) {
+        modifiers += ` @default(${defaultLiteral})`
+      }
+
       // Map modifier
       if (db?.map) {
         modifiers += ` @map("${db.map}")`
@@ -677,7 +708,6 @@ export function password<TTypeInfo extends import('../config/types.js').TypeInfo
       resolveInput: async ({ inputData, fieldKey }: { inputData: any; fieldKey: string }) => {
         // Skip if undefined or null (allows partial updates)
         const inputValue = inputData[fieldKey]
-        console.log('Password resolveInput called with value:', inputValue)
         if (inputValue === undefined || inputValue === null) {
           return inputValue
         }
@@ -823,21 +853,35 @@ export function select<
     },
     getPrismaType: (fieldName: string, _provider?: string, listName?: string) => {
       const isRequired = options.validation?.isRequired
+      const hasDefault = options.defaultValue !== undefined
+      // Nullability rules (Keystone parity):
+      //  - `db.isNullable` is an explicit override and always wins. Setting it
+      //    `true` forces the `?` even when a `defaultValue` is present.
+      //  - Otherwise a select is nullable only when it is neither required nor
+      //    carrying a default: a `defaultValue` makes the column NOT NULL (the
+      //    long-standing default behaviour). This mirrors the previous logic
+      //    where a present default overwrote the `?`.
+      // Nullability and the default are assembled independently with `+=`
+      // (mirroring text/integer) so the default never overwrites the `?`.
+      const isNullable = options.db?.isNullable ?? (!isRequired && !hasDefault)
       let modifiers = ''
 
+      // Optional modifier
+      if (isNullable) {
+        modifiers += '?'
+      }
+
       if (isNativeEnum) {
-        // Derive enum name from list name + field name in PascalCase
+        // Enum type name: explicit `db.enumName` wins, otherwise derive from
+        // list name + field name in PascalCase. The same name is used for the
+        // generated enum block (via `result.type`) and the column reference.
         const capitalizedField = fieldName.charAt(0).toUpperCase() + fieldName.slice(1)
-        const enumName = listName ? `${listName}${capitalizedField}` : capitalizedField
-
-        // Required fields don't get the ? modifier
-        if (!isRequired) {
-          modifiers = '?'
-        }
+        const derivedEnumName = listName ? `${listName}${capitalizedField}` : capitalizedField
+        const enumName = options.db?.enumName ?? derivedEnumName
 
         // Add default value if provided (no quotes for enum values)
-        if (options.defaultValue !== undefined) {
-          modifiers = ` @default(${options.defaultValue})`
+        if (hasDefault) {
+          modifiers += ` @default(${options.defaultValue})`
         }
 
         // Map modifier
@@ -854,14 +898,9 @@ export function select<
 
       // String type (default)
 
-      // Required fields don't get the ? modifier
-      if (!isRequired) {
-        modifiers = '?'
-      }
-
       // Add default value if provided
-      if (options.defaultValue !== undefined) {
-        modifiers = ` @default("${options.defaultValue}")`
+      if (hasDefault) {
+        modifiers += ` @default("${options.defaultValue}")`
       }
 
       // Map modifier
@@ -1300,6 +1339,14 @@ export function json<
         modifiers += ` @db.${db.nativeType}`
       }
 
+      // Default value if provided. Uses Keystone's JSON-literal form: canonical
+      // (space-free) JSON wrapped in escaped double quotes. Independent of the
+      // nullable `?` modifier above — the default never overwrites nullability.
+      const defaultLiteral = formatPrismaDefault(options?.defaultValue, 'json')
+      if (defaultLiteral !== undefined) {
+        modifiers += ` @default(${defaultLiteral})`
+      }
+
       // Map modifier
       if (db?.map) {
         modifiers += ` @map("${db.map}")`