@opensaas/stack-core 0.21.0 → 0.23.0

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({

package/tests/context.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
 import { getContext } from '../src/context/index.js'
 import type { OpenSaasConfig } from '../src/config/types.js'
 
@@ -425,4 +425,83 @@ describe('getContext', () => {
       expect(configWithHook.lists.User.hooks?.resolveInput).toHaveBeenCalledTimes(2)
     })
   })
+
+  // `select` is not honoured by context.db reads — it is a visible no-op: the
+  // op warns (once per list+operation) and still returns the full, access-
+  // filtered result. Each test re-imports getContext via vi.resetModules() so
+  // the module-level warn-once cache starts empty.
+  describe('select no-op warning', () => {
+    let warnSpy: ReturnType<typeof vi.spyOn>
+    let freshGetContext: typeof getContext
+
+    beforeEach(async () => {
+      vi.resetModules()
+      warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+      const mod = await import('../src/context/index.js')
+      freshGetContext = mod.getContext
+    })
+
+    afterEach(() => {
+      warnSpy.mockRestore()
+    })
+
+    it('warns AND still returns the row when findUnique is passed a select', async () => {
+      const mockUser = { id: '1', name: 'John', email: 'john@example.com' }
+      mockPrisma.user.findFirst.mockResolvedValue(mockUser)
+
+      const context = await freshGetContext(config, mockPrisma, null)
+      const result = await context.db.user.findUnique({
+        where: { id: '1' },
+        select: { name: true },
+      })
+
+      expect(warnSpy).toHaveBeenCalledTimes(1)
+      expect(warnSpy.mock.calls[0][0]).toContain('`select` is ignored')
+      expect(warnSpy.mock.calls[0][0]).toContain('findUnique')
+      // Behaviour unchanged: the op still runs and returns the full row.
+      expect(mockPrisma.user.findFirst).toHaveBeenCalled()
+      expect(result).toEqual(mockUser)
+    })
+
+    it('warns AND still returns the rows when findMany is passed a select', async () => {
+      const mockUsers = [
+        { id: '1', name: 'John' },
+        { id: '2', name: 'Jane' },
+      ]
+      mockPrisma.user.findMany.mockResolvedValue(mockUsers)
+
+      const context = await freshGetContext(config, mockPrisma, null)
+      const result = await context.db.user.findMany({ select: { name: true } })
+
+      expect(warnSpy).toHaveBeenCalledTimes(1)
+      expect(warnSpy.mock.calls[0][0]).toContain('`select` is ignored')
+      expect(warnSpy.mock.calls[0][0]).toContain('findMany')
+      expect(mockPrisma.user.findMany).toHaveBeenCalled()
+      expect(result).toEqual(mockUsers)
+    })
+
+    it('warns only once per list+operation across repeated calls', async () => {
+      mockPrisma.user.findMany.mockResolvedValue([])
+
+      const context = await freshGetContext(config, mockPrisma, null)
+      await context.db.user.findMany({ select: { name: true } })
+      await context.db.user.findMany({ select: { name: true } })
+      await context.db.user.findMany({ select: { email: true } })
+
+      expect(warnSpy).toHaveBeenCalledTimes(1)
+    })
+
+    it('does NOT warn for findUnique/findMany using only include or query', async () => {
+      const mockUser = { id: '1', name: 'John' }
+      mockPrisma.user.findFirst.mockResolvedValue(mockUser)
+      mockPrisma.user.findMany.mockResolvedValue([mockUser])
+
+      const context = await freshGetContext(config, mockPrisma, null)
+      await context.db.user.findUnique({ where: { id: '1' }, include: { posts: true } })
+      await context.db.user.findMany({ include: { posts: true } })
+      await context.db.user.findMany()
+
+      expect(warnSpy).not.toHaveBeenCalled()
+    })
+  })
 })