@opensaas/stack-core 0.21.0 → 0.22.0

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' }],

package/src/fields/text-keystone-compat.test.ts

@@ -0,0 +1,126 @@
+import { describe, it, expect } from 'vitest'
+import { text, integer } from './index.js'
+
+/**
+ * Unit coverage for Keystone-compat mode on text() (issue #475).
+ *
+ * Keystone 6 gives every non-null text column an implicit empty-string default.
+ * The `keystoneCompat` flag (db.keystoneCompat) reaches text()'s getPrismaType as
+ * the 4th positional argument — the same way provider/listName already do — and
+ * emits `@default("")` for a non-null text column that has no explicit default.
+ *
+ * These tests pin the precise on/off/explicit-default/nullable/non-text matrix
+ * from the issue's acceptance criteria.
+ */
+describe('text() Keystone-compat empty-string default', () => {
+  const KEYSTONE_COMPAT = true
+
+  describe('with keystoneCompat ON', () => {
+    it('emits @default("") for a required (non-null) text field without an explicit default', () => {
+      const field = text({ validation: { isRequired: true } })
+
+      const result = field.getPrismaType!('name', 'sqlite', 'User', KEYSTONE_COMPAT)
+
+      expect(result.type).toBe('String')
+      expect(result.modifiers).toBe('@default("")')
+    })
+
+    it('emits @default("") for a non-null text field made non-null via db.isNullable: false', () => {
+      // Non-null at the DB level even though validation does not mark it required.
+      const field = text({ db: { isNullable: false } })
+
+      const result = field.getPrismaType!('phone', 'sqlite', 'User', KEYSTONE_COMPAT)
+
+      expect(result.modifiers).toBe('@default("")')
+    })
+
+    it('does NOT emit a default for a nullable text field', () => {
+      // Optional → nullable; Keystone-compat must leave it alone.
+      const field = text()
+
+      const result = field.getPrismaType!('bio', 'sqlite', 'User', KEYSTONE_COMPAT)
+
+      expect(result.modifiers).toBe('?')
+      expect(result.modifiers).not.toContain('@default')
+    })
+
+    it('does NOT emit a default for a text field made nullable via db.isNullable: true', () => {
+      // Required validation, but explicitly nullable at the DB level.
+      const field = text({ validation: { isRequired: true }, db: { isNullable: true } })
+
+      const result = field.getPrismaType!('note', 'sqlite', 'User', KEYSTONE_COMPAT)
+
+      expect(result.modifiers).toBe('?')
+      expect(result.modifiers).not.toContain('@default')
+    })
+
+    it('lets an explicit defaultValue win over the compat empty-string default', () => {
+      const field = text({ validation: { isRequired: true }, defaultValue: 'PLEASE_UPDATE' })
+
+      const result = field.getPrismaType!('status', 'sqlite', 'Account', KEYSTONE_COMPAT)
+
+      expect(result.modifiers).toBe('@default("PLEASE_UPDATE")')
+      expect(result.modifiers).not.toContain('@default("")')
+    })
+
+    it('honours an explicit empty-string defaultValue without double-emitting', () => {
+      const field = text({ validation: { isRequired: true }, defaultValue: '' })
+
+      const result = field.getPrismaType!('label', 'sqlite', 'Account', KEYSTONE_COMPAT)
+
+      // A single @default("") — the explicit default, not a duplicate.
+      expect(result.modifiers).toBe('@default("")')
+      expect(result.modifiers!.match(/@default/g)).toHaveLength(1)
+    })
+
+    it('places @default("") alongside other modifiers in the expected order', () => {
+      const field = text({
+        validation: { isRequired: true },
+        isIndexed: 'unique',
+        db: { nativeType: 'Text', map: 'full_name' },
+      })
+
+      const result = field.getPrismaType!('fullName', 'postgresql', 'User', KEYSTONE_COMPAT)
+
+      // nativeType → default → unique → map, matching the builder's modifier order.
+      expect(result.modifiers).toBe('@db.Text @default("") @unique @map("full_name")')
+    })
+  })
+
+  describe('with keystoneCompat OFF (default)', () => {
+    it('emits no default for a required text field when the flag is omitted', () => {
+      const field = text({ validation: { isRequired: true } })
+
+      const result = field.getPrismaType!('name', 'sqlite', 'User')
+
+      expect(result.modifiers).toBeUndefined()
+    })
+
+    it('emits no default for a required text field when the flag is explicitly false', () => {
+      const field = text({ validation: { isRequired: true } })
+
+      const result = field.getPrismaType!('name', 'sqlite', 'User', false)
+
+      expect(result.modifiers).toBeUndefined()
+    })
+
+    it('still honours an explicit defaultValue when the flag is off', () => {
+      const field = text({ validation: { isRequired: true }, defaultValue: 'PLEASE_UPDATE' })
+
+      const result = field.getPrismaType!('status', 'sqlite', 'Account', false)
+
+      expect(result.modifiers).toBe('@default("PLEASE_UPDATE")')
+    })
+  })
+
+  describe('non-text fields are unaffected by the flag', () => {
+    it('does not give a required integer field an empty-string default under keystoneCompat', () => {
+      const field = integer({ validation: { isRequired: true } })
+
+      const result = field.getPrismaType!('count', 'sqlite', 'Widget', KEYSTONE_COMPAT)
+
+      expect(result.type).toBe('Int')
+      expect(result.modifiers ?? '').not.toContain('@default')
+    })
+  })
+})

package/src/hooks/index.ts

@@ -2,6 +2,7 @@ import type { Hooks } from '../config/types.js'
 import type { AccessContext } from '../access/types.js'
 import type { FieldConfig } from '../config/types.js'
 import { validateWithZod } from '../validation/schema.js'
+import { checkFieldAccess } from '../access/field-access.js'
 
 /**
  * Validation error collection
@@ -235,24 +236,66 @@ export async function executeFieldResolveInputHooks(
     // Skip if field not in data
     if (!(fieldKey in result)) continue
 
-    // Skip if no hooks defined
-    if (!fieldConfig.hooks?.resolveInput) continue
+    // A field's resolveInput produces its resolved value; for most fields that
+    // value is stored back under the same key. Multi-column fields additionally
+    // split that value across their physical columns below.
+    let resolvedValue: unknown = result[fieldKey]
 
-    // Execute field hook
-    // Type assertion is safe here because hooks are typed correctly in field definitions
-    // and we're working with runtime values that match those types
-    const transformedValue = await fieldConfig.hooks.resolveInput({
-      listKey,
-      fieldKey,
-      operation,
-      inputData,
-      item,
-      resolvedData: { ...result }, // Pass a copy to avoid mutation affecting recorded args
-      context,
-    } as Parameters<typeof fieldConfig.hooks.resolveInput>[0])
-
-    // Create new object with updated field to avoid mutating the passed reference
-    result = { ...result, [fieldKey]: transformedValue }
+    if (fieldConfig.hooks?.resolveInput) {
+      // Execute field hook
+      // Type assertion is safe here because hooks are typed correctly in field definitions
+      // and we're working with runtime values that match those types
+      resolvedValue = await fieldConfig.hooks.resolveInput({
+        listKey,
+        fieldKey,
+        operation,
+        inputData,
+        item,
+        resolvedData: { ...result }, // Pass a copy to avoid mutation affecting recorded args
+        context,
+      } as Parameters<typeof fieldConfig.hooks.resolveInput>[0])
+    } else if (!fieldConfig.splitColumns) {
+      // No resolveInput and not a multi-column field — nothing to do.
+      continue
+    }
+
+    if (fieldConfig.splitColumns) {
+      // Multi-column field (e.g. storage image()/file() in Keystone-parity
+      // mode): replace the single logical key with its per-part columns so the
+      // write payload targets the live columns instead of a single one.
+      //
+      // The split removes the logical key from the payload BEFORE the
+      // canonical writable-field filter (`filterWritableFields`) runs, and the
+      // raw per-part column keys are not in `fieldConfigs` — so that later
+      // filter cannot enforce this field's own write access. Enforce it HERE,
+      // using the canonical field-access evaluator with the SAME arguments the
+      // write pipeline uses. A single-column field denied by `update`/`create`
+      // is simply omitted from the write; a denied multi-column field must
+      // likewise contribute NONE of its per-part columns. (sudo bypasses via
+      // `checkFieldAccess`.)
+      const canWrite = await checkFieldAccess(fieldConfig.access, operation, {
+        session: context.session,
+        item,
+        context,
+        inputData,
+      })
+      if (!canWrite) {
+        // Denied: drop the logical key and write none of its columns — exactly
+        // as filterWritableFields drops a denied single-column field.
+        const next = { ...result }
+        delete next[fieldKey]
+        result = next
+        continue
+      }
+      const columns = fieldConfig.splitColumns(fieldKey, resolvedValue)
+      // Drop the logical key (it is not a real column) and merge the columns.
+      const next = { ...result, ...columns }
+      delete next[fieldKey]
+      result = next
+    } else {
+      // Create new object with updated field to avoid mutating the passed reference
+      result = { ...result, [fieldKey]: resolvedValue }
+    }
   }
 
   return result

package/src/index.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect, expectTypeOf } from 'vitest'
+// Import from the package root entry point exactly as the docs / CHANGELOG /
+// migrate-context-calls skill instruct consumers to. If the root `index.ts`
+// stops re-exporting the query API, this file fails to type-check / run,
+// preventing a silent regression (issue #496).
+import { defineFragment, runQuery, runQueryOne } from './index.js'
+import type { ResultOf, RelationSelector, QueryArgs } from './index.js'
+
+// ─────────────────────────────────────────────────────────────
+// Stand-in model type (mirrors a Prisma-generated type)
+// ─────────────────────────────────────────────────────────────
+
+type User = {
+  id: string
+  name: string
+  email: string
+}
+
+describe('@opensaas/stack-core root entry point — query API re-exports (issue #496)', () => {
+  it('re-exports the runtime query functions from the package root', () => {
+    expect(typeof defineFragment).toBe('function')
+    expect(typeof runQuery).toBe('function')
+    expect(typeof runQueryOne).toBe('function')
+  })
+
+  it('defineFragment imported from the root produces a usable fragment', () => {
+    const userFragment = defineFragment<User>()({ id: true, name: true } as const)
+
+    expect(userFragment._type).toBe('fragment')
+    expect(userFragment._fields).toEqual({ id: true, name: true })
+  })
+
+  it('exposes ResultOf as a usable type alias from the root', () => {
+    const userFragment = defineFragment<User>()({ id: true, name: true } as const)
+    expect(userFragment._type).toBe('fragment')
+
+    // Type-level assertion: ResultOf<typeof fragment> narrows to the selection.
+    expectTypeOf<ResultOf<typeof userFragment>>().toEqualTypeOf<{ id: string; name: string }>()
+  })
+
+  it('exposes QueryArgs and RelationSelector as usable types from the root', () => {
+    // Type-level usage — these annotations only compile if the types resolve
+    // from the root entry point.
+    const args: QueryArgs = { where: { id: 'abc' }, take: 5 }
+    expect(args.take).toBe(5)
+
+    const selector: RelationSelector<User> = defineFragment<User>()({ id: true } as const)
+    expectTypeOf(selector).not.toBeNever()
+  })
+})

package/src/index.ts

@@ -14,7 +14,14 @@ export { config, list } from './config/index.js'
 // Config types a consumer annotates with.
 // Concrete field-config types (TextField, …) live on '@opensaas/stack-core/fields'
 // alongside their builders.
-export type { OpenSaasConfig, ListConfig, FieldConfig, OperationAccess } from './config/index.js'
+export type {
+  OpenSaasConfig,
+  OutputConfig,
+  ListConfig,
+  DatabaseConfig,
+  FieldConfig,
+  OperationAccess,
+} from './config/index.js'
 
 // Access control — the types a consumer writes against
 export type {
@@ -40,3 +47,12 @@ export { ValidationError } from './hooks/index.js'
 // with a clear per-field message instead of deep inside generation.
 export { validateFieldConfig, validateConfigFields } from './validation/field-config.js'
 export type { FieldConfigValidationError } from './validation/field-config.js'
+
+// Fragment-based query API — composable, type-safe reads that mirror
+// Keystone's GraphQL fragments without a GraphQL runtime. The migration
+// guide, CHANGELOG, and migrate-context-calls skill all advertise importing
+// these from the root entry point. The internal runtime helpers (isFragment,
+// buildInclude, pickFields) and the Fragment/FieldSelection types stay off the
+// root surface — those live on '@opensaas/stack-core/internal'.
+export { defineFragment, runQuery, runQueryOne } from './query/index.js'
+export type { ResultOf, RelationSelector, QueryArgs } from './query/index.js'

package/src/mcp/handler.ts

@@ -410,8 +410,6 @@ async function handleToolsCall(
   const toolName = params?.name
   const toolArgs = params?.arguments || {}
 
-  console.log('Handling tool call:', toolName, toolArgs)
-
   if (!toolName) {
     return new Response(
       JSON.stringify({