@opensaas/stack-core 0.20.1 → 0.22.0

package/src/fields/index.ts

@@ -11,8 +11,31 @@ import type {
   RelationshipField,
   JsonField,
   VirtualField,
+  OpenSaasConfig,
+  FieldConfig,
+  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
+// and `/extend` entry points respectively.)
+export type {
+  TextField,
+  IntegerField,
+  DecimalField,
+  CheckboxField,
+  TimestampField,
+  CalendarDayField,
+  PasswordField,
+  SelectField,
+  RelationshipField,
+  JsonField,
+  VirtualField,
+  PrismaRelationResult,
+  MultiColumnPrismaResult,
+} from '../config/types.js'
 
 /**
  * Format field name for display in error messages
@@ -66,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
@@ -83,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'
@@ -161,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}")`
@@ -642,7 +694,7 @@ export function password<TTypeInfo extends import('../config/types.js').TypeInfo
     type: 'password',
     ...options,
     resultExtension: {
-      outputType: "import('@opensaas/stack-core').HashedPassword",
+      outputType: "import('@opensaas/stack-core/internal').HashedPassword",
       // No compute - delegates to resolveOutput hook
     },
     ui: {
@@ -656,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
         }
@@ -802,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
@@ -833,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
@@ -865,6 +925,284 @@ export function select<
   }
 }
 
+/**
+ * Parse a relationship ref into its target list and optional target field.
+ * Supports both 'ListName.fieldName' (bidirectional) and 'ListName' (list-only) formats.
+ */
+function parseRelationshipRef(ref: string): { list: string; field?: string } {
+  const parts = ref.split('.')
+  if (parts.length === 1) {
+    const list = parts[0]
+    if (!list) {
+      throw new Error(`Invalid relationship ref: ${ref}`)
+    }
+    return { list }
+  } else if (parts.length === 2) {
+    const [list, field] = parts
+    if (!list || !field) {
+      throw new Error(`Invalid relationship ref: ${ref}`)
+    }
+    return { list, field }
+  } else {
+    throw new Error(`Invalid relationship ref: ${ref}`)
+  }
+}
+
+/**
+ * Check if a relationship is one-to-one (bidirectional with both sides having many: false).
+ */
+function isOneToOneRelationship(
+  fieldName: string,
+  field: RelationshipField,
+  config: OpenSaasConfig,
+): boolean {
+  const { list: targetList, field: targetField } = parseRelationshipRef(field.ref)
+  if (!targetField) {
+    return false
+  }
+
+  if (field.many) {
+    return false
+  }
+
+  const targetListConfig = config.lists[targetList]
+  if (!targetListConfig) {
+    throw new Error(`Referenced list "${targetList}" not found in config`)
+  }
+
+  const targetFieldConfig = targetListConfig.fields[targetField]
+  if (!targetFieldConfig) {
+    throw new Error(
+      `Referenced field "${targetList}.${targetField}" not found. If you want a one-sided relationship, use ref: "${targetList}" instead of ref: "${targetList}.${targetField}"`,
+    )
+  }
+  if (targetFieldConfig.type !== 'relationship') {
+    throw new Error(`Referenced field "${targetList}.${targetField}" is not a relationship field`)
+  }
+
+  return !(targetFieldConfig as RelationshipField).many
+}
+
+/**
+ * Determine if this side of a relationship should store the foreign key.
+ * For one-to-one relationships, only one side stores the foreign key.
+ */
+function shouldHaveForeignKey(
+  listKey: string,
+  fieldName: string,
+  field: RelationshipField,
+  config: OpenSaasConfig,
+): boolean {
+  const { list: targetList, field: targetField } = parseRelationshipRef(field.ref)
+  if (!targetField) {
+    return true
+  }
+
+  if (field.many) {
+    return false
+  }
+
+  const isOneToOne = isOneToOneRelationship(fieldName, field, config)
+  if (!isOneToOne) {
+    return true
+  }
+
+  const targetListConfig = config.lists[targetList]!
+  const targetFieldConfig = targetListConfig.fields[targetField] as RelationshipField
+
+  const thisSideExplicit = field.db?.foreignKey
+  const otherSideExplicit = targetFieldConfig.db?.foreignKey
+
+  if (thisSideExplicit === true && otherSideExplicit === true) {
+    throw new Error(
+      `Invalid one-to-one relationship: both "${listKey}.${fieldName}" and "${targetList}.${targetField}" have db.foreignKey set to true. Only one side can store the foreign key.`,
+    )
+  }
+
+  if (thisSideExplicit === true) {
+    return true
+  }
+
+  if (otherSideExplicit === true) {
+    return false
+  }
+
+  // Default: the alphabetically "smaller" list name gets the foreign key
+  const comparison = listKey.localeCompare(targetList)
+  if (comparison !== 0) {
+    return comparison < 0
+  }
+
+  // Self-referential: use field name ordering
+  return fieldName.localeCompare(targetField) < 0
+}
+
+/**
+ * Check whether a many relationship is a true many-to-many (both sides many).
+ */
+function isManyToMany(
+  fieldName: string,
+  field: RelationshipField,
+  config: OpenSaasConfig,
+): boolean {
+  if (!field.many) {
+    return false
+  }
+
+  const { list: targetList, field: targetField } = parseRelationshipRef(field.ref)
+
+  // List-only ref with many: true is implicitly many-to-many
+  if (!targetField) {
+    return true
+  }
+
+  const targetFieldConfig = config.lists[targetList]?.fields[targetField]
+  if (!targetFieldConfig || targetFieldConfig.type !== 'relationship') {
+    return false
+  }
+
+  return !!(targetFieldConfig as RelationshipField).many
+}
+
+/**
+ * Compute the explicit relation name for a bidirectional many-to-many relationship,
+ * or `undefined` when Prisma's default naming should be used.
+ *
+ * Honours per-field `db.relationName` (which must match on both sides) and the
+ * global `db.joinTableNaming: 'keystone'` setting, picking a deterministic owner
+ * for bidirectional relationships so both sides resolve to the same name.
+ */
+function computeManyToManyRelationName(
+  listKey: string,
+  fieldName: string,
+  field: RelationshipField,
+  config: OpenSaasConfig,
+): string | undefined {
+  const { list: targetList, field: targetField } = parseRelationshipRef(field.ref)
+  const joinTableNaming = config.db.joinTableNaming || 'prisma'
+
+  const sourceRelationName = field.db?.relationName
+  let targetRelationName: string | undefined
+  if (targetField) {
+    const targetFieldConfig = config.lists[targetList]?.fields[targetField]
+    if (targetFieldConfig?.type === 'relationship') {
+      targetRelationName = (targetFieldConfig as RelationshipField).db?.relationName
+    }
+  }
+
+  if (sourceRelationName && targetRelationName && sourceRelationName !== targetRelationName) {
+    throw new Error(
+      `Relation name mismatch: ${listKey}.${fieldName} has relationName "${sourceRelationName}" but ${targetList}.${targetField} has "${targetRelationName}". Both sides must use the same relationName.`,
+    )
+  }
+
+  const explicitRelationName = sourceRelationName || targetRelationName
+  if (explicitRelationName) {
+    return explicitRelationName
+  }
+
+  if (joinTableNaming === 'keystone') {
+    if (targetField) {
+      // Pick a deterministic owner so both sides agree on the relation name
+      const sourceKey = `${listKey}.${fieldName}`
+      const targetKey = `${targetList}.${targetField}`
+      return sourceKey.localeCompare(targetKey) < 0
+        ? `${listKey}_${fieldName}`
+        : `${targetList}_${targetField}`
+    }
+    return `${listKey}_${fieldName}`
+  }
+
+  // Default Prisma naming - no explicit relation name needed
+  return undefined
+}
+
+/**
+ * Build the Prisma schema contribution for a relationship field.
+ */
+function getPrismaRelation(
+  field: RelationshipField,
+  fieldName: string,
+  listKey: string,
+  config: OpenSaasConfig,
+): PrismaRelationResult {
+  const { list: targetList, field: targetField } = parseRelationshipRef(field.ref)
+  const paddedName = fieldName.padEnd(12)
+
+  // Synthetic back-relation for list-only refs (Prisma requires an opposite field)
+  let backRelation: PrismaRelationResult['backRelation']
+  if (!targetField) {
+    const syntheticFieldName = `from_${listKey}_${fieldName}`
+    const relationName = field.db?.relationName ?? `${listKey}_${fieldName}`
+    backRelation = {
+      targetList,
+      line: `  ${syntheticFieldName.padEnd(12)} ${listKey}[]  @relation("${relationName}")`,
+    }
+  }
+
+  if (field.many) {
+    let relationLine: string
+
+    if (targetField) {
+      // Bidirectional many side: use explicit relation name only for true many-to-many
+      const m2mName = isManyToMany(fieldName, field, config)
+        ? computeManyToManyRelationName(listKey, fieldName, field, config)
+        : undefined
+      relationLine = m2mName
+        ? `  ${paddedName} ${targetList}[]  @relation("${m2mName}")`
+        : `  ${paddedName} ${targetList}[]`
+    } else {
+      // List-only ref many side: always a named relation paired with the synthetic field
+      const relationName = field.db?.relationName ?? `${listKey}_${fieldName}`
+      relationLine = `  ${paddedName} ${targetList}[]  @relation("${relationName}")`
+    }
+
+    if (field.db?.extendPrismaSchema) {
+      relationLine = field.db.extendPrismaSchema({ relationLine }).relationLine
+    }
+
+    return { modelLines: [relationLine], backRelation }
+  }
+
+  // Single relationship
+  if (shouldHaveForeignKey(listKey, fieldName, field, config)) {
+    const foreignKeyField = `${fieldName}Id`
+    const fkPaddedName = foreignKeyField.padEnd(12)
+
+    const uniqueModifier = isOneToOneRelationship(fieldName, field, config) ? ' @unique' : ''
+
+    const mapModifier =
+      typeof field.db?.foreignKey === 'object' && field.db.foreignKey.map
+        ? ` @map("${field.db.foreignKey.map}")`
+        : ` @map("${fieldName}")`
+
+    let fkLine = `  ${fkPaddedName} String?${uniqueModifier}${mapModifier}`
+    let relationLine = targetField
+      ? `  ${paddedName} ${targetList}?  @relation(fields: [${foreignKeyField}], references: [id])`
+      : `  ${paddedName} ${targetList}?  @relation("${listKey}_${fieldName}", fields: [${foreignKeyField}], references: [id])`
+
+    if (field.db?.extendPrismaSchema) {
+      const extended = field.db.extendPrismaSchema({ fkLine, relationLine })
+      fkLine = extended.fkLine ?? fkLine
+      relationLine = extended.relationLine
+    }
+
+    // Default to indexing foreign keys (matching Keystone behaviour) unless disabled
+    const indexType = field.isIndexed ?? true
+    const foreignKeyIndex = indexType !== false ? { foreignKeyField, indexType } : undefined
+
+    return { modelLines: [fkLine, relationLine], foreignKeyIndex, backRelation }
+  }
+
+  // Non-FK side of a one-to-one relationship: just the relation field
+  let relationLine = `  ${paddedName} ${targetList}?`
+  if (field.db?.extendPrismaSchema) {
+    relationLine = field.db.extendPrismaSchema({ relationLine }).relationLine
+  }
+
+  return { modelLines: [relationLine], backRelation }
+}
+
 /**
  * Relationship field
  */
@@ -902,10 +1240,19 @@ export function relationship<
     }
   }
 
-  return {
+  const field: RelationshipField<TTypeInfo> = {
     type: 'relationship',
     ...options,
   }
+
+  field.getPrismaRelation = (
+    fieldName: string,
+    _allFields: Record<string, FieldConfig>,
+    listKey: string,
+    config: OpenSaasConfig,
+  ) => getPrismaRelation(field as RelationshipField, fieldName, listKey, config)
+
+  return field
 }
 
 /**
@@ -992,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}")`

package/src/fields/select.test.ts

@@ -52,6 +52,48 @@ describe('select field builder', () => {
       expect(result.modifiers).toBe(' @default("draft")')
     })
 
+    it('should emit NOT NULL (no ?) for optional string select with a default', () => {
+      const field = select({
+        options: [
+          { label: 'Draft', value: 'draft' },
+          { label: 'Published', value: 'published' },
+        ],
+        defaultValue: 'draft',
+      })
+
+      const result = field.getPrismaType!('status', 'sqlite', 'Post')
+      // Default behaviour: a present default makes the column NOT NULL
+      expect(result.modifiers).toBe(' @default("draft")')
+      expect(result.modifiers).not.toContain('?')
+    })
+
+    it('should force ? with db.isNullable even when a default is present (string)', () => {
+      const field = select({
+        options: [
+          { label: 'Draft', value: 'draft' },
+          { label: 'Published', value: 'published' },
+        ],
+        defaultValue: 'draft',
+        db: { isNullable: true },
+      })
+
+      const result = field.getPrismaType!('status', 'sqlite', 'Post')
+      expect(result.type).toBe('String')
+      expect(result.modifiers).toBe('? @default("draft")')
+    })
+
+    it('should keep ? from db.isNullable for a required string select with default', () => {
+      const field = select({
+        options: [{ label: 'Draft', value: 'draft' }],
+        defaultValue: 'draft',
+        validation: { isRequired: true },
+        db: { isNullable: true },
+      })
+
+      const result = field.getPrismaType!('status', 'sqlite', 'Post')
+      expect(result.modifiers).toBe('? @default("draft")')
+    })
+
     it('should generate union TypeScript type from options', () => {
       const field = select({
         options: [
@@ -205,6 +247,63 @@ describe('select field builder', () => {
       expect(result.modifiers).not.toContain('"')
     })
 
+    it('should emit NOT NULL (no ?) for optional enum select with a default', () => {
+      const field = select({
+        options: [
+          { label: 'Draft', value: 'draft' },
+          { label: 'Published', value: 'published' },
+        ],
+        db: { type: 'enum' },
+        defaultValue: 'draft',
+      })
+
+      const result = field.getPrismaType!('status', 'sqlite', 'Post')
+      expect(result.modifiers).toBe(' @default(draft)')
+      expect(result.modifiers).not.toContain('?')
+    })
+
+    it('should force ? with db.isNullable even when a default is present (enum)', () => {
+      const field = select({
+        options: [
+          { label: 'Draft', value: 'draft' },
+          { label: 'Published', value: 'published' },
+        ],
+        db: { type: 'enum', isNullable: true },
+        defaultValue: 'draft',
+      })
+
+      const result = field.getPrismaType!('status', 'sqlite', 'Post')
+      expect(result.type).toBe('PostStatus')
+      expect(result.modifiers).toBe('? @default(draft)')
+    })
+
+    it('should override the derived enum name with db.enumName', () => {
+      const field = select({
+        options: [
+          { label: 'Open', value: 'open' },
+          { label: 'Closed', value: 'closed' },
+        ],
+        db: { type: 'enum', enumName: 'AccountNoteStatusType' },
+      })
+
+      const result = field.getPrismaType!('status', 'sqlite', 'AccountNote')
+      // result.type drives both the enum block name and the column reference
+      expect(result.type).toBe('AccountNoteStatusType')
+      expect(result.enumValues).toEqual(['open', 'closed'])
+    })
+
+    it('should ignore db.enumName for string (non-enum) selects', () => {
+      const field = select({
+        options: [{ label: 'Open', value: 'open' }],
+        // enumName only applies to native-enum selects; string selects stay String
+        db: { enumName: 'ShouldBeIgnored' },
+      })
+
+      const result = field.getPrismaType!('status', 'sqlite', 'AccountNote')
+      expect(result.type).toBe('String')
+      expect(result.enumValues).toBeUndefined()
+    })
+
     it('should include @map modifier for enum field with map option', () => {
       const field = select({
         options: [{ label: 'Draft', value: 'draft' }],