@opensaas/stack-core 0.37.0 → 0.39.0

package/tests/field-types.test.ts

@@ -2,6 +2,7 @@ import { describe, test, expect } from 'vitest'
 import {
   text,
   integer,
+  bigInt,
   checkbox,
   timestamp,
   password,
@@ -327,6 +328,227 @@ describe('Field Types', () => {
     })
   })
 
+  describe('bigInt field', () => {
+    describe('getZodSchema', () => {
+      test('returns optional bigint schema for non-required field', () => {
+        const field = bigInt()
+        const schema = field.getZodSchema('epoch', 'create')
+
+        expect(schema.safeParse(25n).success).toBe(true)
+        expect(schema.safeParse(undefined).success).toBe(true)
+      })
+
+      test('returns required schema for required field in create mode', () => {
+        const field = bigInt({ validation: { isRequired: true } })
+        const schema = field.getZodSchema('epoch', 'create')
+
+        expect(schema.safeParse(25n).success).toBe(true)
+        expect(schema.safeParse(undefined).success).toBe(false)
+      })
+
+      test('returns optional schema for required field in update mode', () => {
+        const field = bigInt({ validation: { isRequired: true } })
+        const schema = field.getZodSchema('epoch', 'update')
+
+        expect(schema.safeParse(25n).success).toBe(true)
+        expect(schema.safeParse(undefined).success).toBe(true)
+      })
+
+      test('coerces a bigint input to a bigint output unchanged', () => {
+        const field = bigInt()
+        const schema = field.getZodSchema('epoch', 'create')
+
+        const result = schema.safeParse(9007199254740993n)
+        expect(result.success).toBe(true)
+        if (result.success) {
+          expect(result.data).toBe(9007199254740993n)
+          expect(typeof result.data).toBe('bigint')
+        }
+      })
+
+      test('coerces a safe-integer number input to a bigint output', () => {
+        const field = bigInt()
+        const schema = field.getZodSchema('epoch', 'create')
+
+        const result = schema.safeParse(1700000000000)
+        expect(result.success).toBe(true)
+        if (result.success) {
+          expect(result.data).toBe(1700000000000n)
+          expect(typeof result.data).toBe('bigint')
+        }
+      })
+
+      test('coerces a numeric string input to a bigint output, round-tripping beyond Number.MAX_SAFE_INTEGER', () => {
+        const field = bigInt()
+        const schema = field.getZodSchema('epoch', 'create')
+
+        const result = schema.safeParse('9223372036854775807')
+        expect(result.success).toBe(true)
+        if (result.success) {
+          expect(result.data).toBe(9223372036854775807n)
+        }
+      })
+
+      test('accepts a negative numeric string', () => {
+        const field = bigInt()
+        const schema = field.getZodSchema('delta', 'create')
+
+        const result = schema.safeParse('-42')
+        expect(result.success).toBe(true)
+        if (result.success) {
+          expect(result.data).toBe(-42n)
+        }
+      })
+
+      test('rejects a non-integer number', () => {
+        const field = bigInt()
+        const schema = field.getZodSchema('epoch', 'create')
+
+        expect(schema.safeParse(1.5).success).toBe(false)
+      })
+
+      test('rejects a number above Number.MAX_SAFE_INTEGER instead of silently losing precision', () => {
+        const field = bigInt()
+        const schema = field.getZodSchema('epoch', 'create')
+
+        expect(schema.safeParse(Number.MAX_SAFE_INTEGER + 10).success).toBe(false)
+      })
+
+      test('rejects a non-numeric string', () => {
+        const field = bigInt()
+        const schema = field.getZodSchema('epoch', 'create')
+
+        expect(schema.safeParse('not-a-number').success).toBe(false)
+      })
+
+      test('rejects a decimal string', () => {
+        const field = bigInt()
+        const schema = field.getZodSchema('epoch', 'create')
+
+        expect(schema.safeParse('1.5').success).toBe(false)
+      })
+
+      test('validates min value', () => {
+        const field = bigInt({ validation: { min: 0n } })
+        const schema = field.getZodSchema('epoch', 'create')
+
+        expect(schema.safeParse(-1n).success).toBe(false)
+        expect(schema.safeParse(0n).success).toBe(true)
+        expect(schema.safeParse(1n).success).toBe(true)
+      })
+
+      test('validates max value', () => {
+        const field = bigInt({ validation: { max: 100n } })
+        const schema = field.getZodSchema('epoch', 'create')
+
+        expect(schema.safeParse(99n).success).toBe(true)
+        expect(schema.safeParse(100n).success).toBe(true)
+        expect(schema.safeParse(101n).success).toBe(false)
+      })
+
+      test('validates min and max together', () => {
+        const field = bigInt({ validation: { min: 18n, max: 65n } })
+        const schema = field.getZodSchema('age', 'create')
+
+        expect(schema.safeParse(17n).success).toBe(false)
+        expect(schema.safeParse(18n).success).toBe(true)
+        expect(schema.safeParse(65n).success).toBe(true)
+        expect(schema.safeParse(66n).success).toBe(false)
+      })
+    })
+
+    describe('getPrismaType', () => {
+      test('returns BigInt type for basic field', () => {
+        const field = bigInt()
+        const prismaType = field.getPrismaType('epoch')
+
+        expect(prismaType.type).toBe('BigInt')
+        expect(prismaType.modifiers).toBe('?')
+      })
+
+      test('returns required BigInt for required field', () => {
+        const field = bigInt({ validation: { isRequired: true } })
+        const prismaType = field.getPrismaType('epoch')
+
+        expect(prismaType.type).toBe('BigInt')
+        expect(prismaType.modifiers).toBeUndefined()
+      })
+
+      test('db.isNullable: false makes field non-nullable regardless of validation', () => {
+        const field = bigInt({ db: { isNullable: false } })
+        const prismaType = field.getPrismaType('epoch')
+
+        expect(prismaType.modifiers).toBeUndefined()
+      })
+
+      test('db.map generates @map attribute', () => {
+        const field = bigInt({ db: { map: 'occurred_at_ms' } })
+        const prismaType = field.getPrismaType('epoch')
+
+        expect(prismaType.modifiers).toContain('@map("occurred_at_ms")')
+      })
+
+      test('defaultValue generates a bare @default literal', () => {
+        const field = bigInt({ defaultValue: 0n })
+        const prismaType = field.getPrismaType('epoch')
+
+        expect(prismaType.modifiers).toContain('@default(0)')
+      })
+
+      test('isIndexed: true requests a block-level index', () => {
+        const field = bigInt({ isIndexed: true })
+        const prismaType = field.getPrismaType('epoch')
+
+        expect(prismaType.index).toBe(true)
+      })
+
+      test("isIndexed: 'unique' generates @unique modifier", () => {
+        const field = bigInt({ isIndexed: 'unique' })
+        const prismaType = field.getPrismaType('epoch')
+
+        expect(prismaType.modifiers).toContain('@unique')
+      })
+    })
+
+    describe('getTypeScriptType', () => {
+      test('returns optional bigint type for non-required field', () => {
+        const field = bigInt()
+        const tsType = field.getTypeScriptType()
+
+        expect(tsType.type).toBe('bigint')
+        expect(tsType.optional).toBe(true)
+      })
+
+      test('returns required bigint type for required field', () => {
+        const field = bigInt({ validation: { isRequired: true } })
+        const tsType = field.getTypeScriptType()
+
+        expect(tsType.type).toBe('bigint')
+        expect(tsType.optional).toBe(false)
+      })
+    })
+
+    describe('getFilterSpec', () => {
+      test('parses a valid integer token into a BigInt condition', () => {
+        const field = bigInt()
+        const spec = field.getFilterSpec?.('epoch', 'Event', {} as never)
+
+        expect(spec?.toCondition('eq', '9007199254740993')).toEqual({
+          epoch: { equals: 9007199254740993n },
+        })
+        expect(spec?.toCondition('gt', '5')).toEqual({ epoch: { gt: 5n } })
+      })
+
+      test('degrades to free text (null) for a non-integer token', () => {
+        const field = bigInt()
+        const spec = field.getFilterSpec?.('epoch', 'Event', {} as never)
+
+        expect(spec?.toCondition('eq', '1.5')).toBeNull()
+        expect(spec?.toCondition('eq', 'not-a-number')).toBeNull()
+      })
+    })
+  })
+
   describe('checkbox field', () => {
     describe('getZodSchema', () => {
       test('returns optional boolean schema', () => {

package/tests/mcp-handler.test.ts

@@ -326,6 +326,40 @@ describe('MCP Handler', () => {
       })
     })
 
+    // Regression test (issue #907 / ADR-0029): a bare `JSON.stringify` throws
+    // `TypeError: Do not know how to serialize a BigInt` on a bigInt() field's
+    // value. This must respond successfully, rendering the value as a decimal
+    // string — the field's MCP wire representation.
+    it('should serialize a bigint field value as a decimal string instead of throwing', async () => {
+      const mockResults = [{ id: '1', title: 'Post 1', occurredAtMs: 9007199254740993n }]
+      mockPrisma.post.findMany.mockResolvedValue(mockResults)
+
+      const handlers = createMcpHandlers({ config, getSession: mockGetSession, getContext })
+
+      const request = new Request('http://localhost/api/mcp', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          jsonrpc: '2.0',
+          id: 1,
+          method: 'tools/call',
+          params: {
+            name: 'list_post_query',
+            arguments: { where: {}, take: 10 },
+          },
+        }),
+      })
+
+      const response = await handlers.POST(request)
+      expect(response.status).toBe(200)
+
+      const data = await response.json()
+      expect(data.result.content[0].text).toContain('"occurredAtMs": "9007199254740993"')
+
+      const result = JSON.parse(data.result.content[0].text)
+      expect(result.items[0].occurredAtMs).toBe('9007199254740993')
+    })
+
     it('should execute create operation', async () => {
       const mockResult = { id: '1', title: 'New Post', content: 'New Content' }
       mockPrisma.post.create.mockResolvedValue(mockResult)

package/tests/needs-declared-dependencies.test.ts

@@ -294,11 +294,14 @@ describe('a computed field declares the relations it needs (#850, ADR-0025)', ()
     expect(result).toHaveProperty('title')
   })
 
-  it('a declaration cycle across two lists terminates via the existing relationship-graph cycle guard (ADR-0026 note)', async () => {
+  it("a declaration cycle across two lists terminates via the declaration fold's own cycle guard (ADR-0026 note)", async () => {
     // Order.total needs lineItems; LineItem.orderTitle needs order — a
-    // two-list declaration cycle. This must not hang or crash: it rides the
-    // SAME `visitedLists` cycle guard `buildIncludeWithAccessControl` already
-    // uses for the relationship graph, not a separate mechanism.
+    // two-list declaration cycle. This must not hang or crash: it rides
+    // `foldDeclaredDependencies`'s own `visitedLists` cycle guard — the same
+    // list-name-path mechanism the pre-ADR-0026 relationship-graph auto-walk
+    // used, re-pointed at the declaration fold now that nothing walks the
+    // relationship graph unprompted (defense in depth; the primary backstop
+    // is `validateNeedsClosureDepth` at generate time, see needs-closure.ts).
     const testConfig = await buildTestConfig({ withDeclarationCycle: true })
     const mockPrisma = createMockPrisma()
     mockPrisma.order.findMany.mockResolvedValue([

package/tests/resolve-chain.test.ts

@@ -331,7 +331,7 @@ describe('resolve chain — concurrent hook invocations are isolated (#844)', ()
     expect(observedLengths.sort()).toEqual([1, 1, 1])
   })
 
-  it('an unrelated top-level read in flight alongside a hook still gets its full explicit include scoped', async () => {
+  it('an unrelated top-level read in flight alongside a hook still gets its own explicit include scoped', async () => {
     let releaseSlowHook: () => void = () => {}
 
     const config: OpenSaasConfig = {
@@ -389,21 +389,21 @@ describe('resolve chain — concurrent hook invocations are isolated (#844)', ()
     await new Promise((resolve) => setTimeout(resolve, 0))
 
     // While the slow hook is still in flight, issue a plain top-level read
-    // that has nothing to do with it. A bare read fetches scalars only
-    // (ADR-0024), so name `child` explicitly — a caller include naming a
-    // relation BARE (`true`, no nested include of its own) still picks up the
-    // access-controlled include for whatever lies beneath it.
-    const fastPromise = context.db.fast.findMany({ include: { child: true } })
+    // that has nothing to do with it, explicitly naming a nested path two
+    // levels deep (child → grandchild) — the "One hop" rule (ADR-0026) means
+    // reaching grandchild requires naming it, which this request does.
+    const fastPromise = context.db.fast.findMany({
+      include: { child: { include: { grandchild: true } } },
+    })
 
     await fastPromise
     releaseSlowHook()
     await slowPromise
 
-    // The unrelated read's access-controlled scoping must still descend two
-    // levels deep (child → grandchild), not collapse to a bare `{ child: true }`
-    // because it happened to run while a totally different read's hook was
-    // active — `insideResolveOutput` must stay scoped to the hook's OWN
-    // derived context, never leak into a concurrently-running, unrelated one.
+    // The unrelated read's access-controlled scoping must descend exactly as
+    // far as ITS OWN request named, unaffected by a totally different read's
+    // hook being in flight concurrently — no shared, leaking context state
+    // between the two.
     expect(prisma.fast.findMany.mock.calls[0][0].include).toEqual({
       child: { include: { grandchild: true } },
     })