@opensaas/stack-core 0.39.2 → 0.40.0

package/tests/context.test.ts

@@ -895,6 +895,224 @@ describe('getContext', () => {
         const created = result as { created: boolean; fieldErrors?: Record<string, string> }
         expect(created.fieldErrors?.title).toBeDefined()
       })
+
+      // Prisma 7 driver adapters (verified against @prisma/adapter-pg and PGlite,
+      // issue #979) leave `meta.target` undefined and put the equivalent data at
+      // `meta.driverAdapterError.cause` instead, as free-text-adjacent structured
+      // data rather than the documented shape.
+      describe('P2002 under Prisma 7 driver adapters (issue #979)', () => {
+        it('produces per-field errors for a composite unique violation', async () => {
+          mockPrisma.post.create.mockRejectedValue({
+            code: 'P2002',
+            meta: {
+              modelName: 'Post',
+              driverAdapterError: {
+                name: 'DriverAdapterError',
+                cause: {
+                  originalCode: '23505',
+                  originalMessage:
+                    'duplicate key value violates unique constraint "post_title_content_key"',
+                  kind: 'UniqueConstraintViolation',
+                  constraint: { fields: ['title', 'content'] },
+                },
+              },
+            },
+          })
+          mockPrisma.user.findUnique.mockResolvedValue({ id: 'u1' })
+
+          const context = await getContext(config, mockPrisma, { userId: 'u1' })
+          const result = await context.serverAction({
+            listKey: 'Post',
+            action: 'createRelated',
+            data: { title: 'Dup', content: 'Dup' },
+            field: 'author',
+            parentId: 'u1',
+          })
+
+          expect(result).toMatchObject({ created: false })
+          const created = result as { created: boolean; fieldErrors?: Record<string, string> }
+          expect(created.fieldErrors?.title).toBeDefined()
+          expect(created.fieldErrors?.content).toBeDefined()
+        })
+
+        it('produces a field error for a single-column unique violation', async () => {
+          mockPrisma.post.create.mockRejectedValue({
+            code: 'P2002',
+            meta: {
+              modelName: 'Post',
+              driverAdapterError: {
+                cause: {
+                  originalMessage:
+                    'duplicate key value violates unique constraint "post_title_key"',
+                  constraint: { fields: ['title'] },
+                },
+              },
+            },
+          })
+          mockPrisma.user.findUnique.mockResolvedValue({ id: 'u1' })
+
+          const context = await getContext(config, mockPrisma, { userId: 'u1' })
+          const result = await context.serverAction({
+            listKey: 'Post',
+            action: 'createRelated',
+            data: { title: 'Dup' },
+            field: 'author',
+            parentId: 'u1',
+          })
+
+          const created = result as { created: boolean; fieldErrors?: Record<string, string> }
+          expect(created.fieldErrors?.title).toBeDefined()
+        })
+
+        it('strips quotes so a camelCase column is keyed correctly (not left quoted)', async () => {
+          // Postgres quotes an identifier in `constraint.fields` only when it
+          // needed quoting — a camelCase column arrives as `"authorId"`. A naive
+          // fix that skips stripping would key fieldErrors by the literal string
+          // `"authorId"` (quotes included), missing the real field name.
+          mockPrisma.post.create.mockRejectedValue({
+            code: 'P2002',
+            meta: {
+              driverAdapterError: {
+                cause: {
+                  originalMessage:
+                    'duplicate key value violates unique constraint "post_authorId_key"',
+                  constraint: { fields: ['"authorId"'] },
+                },
+              },
+            },
+          })
+          mockPrisma.user.findUnique.mockResolvedValue({ id: 'u1' })
+
+          const context = await getContext(config, mockPrisma, { userId: 'u1' })
+          const result = await context.serverAction({
+            listKey: 'Post',
+            action: 'createRelated',
+            data: { title: 'Dup' },
+            field: 'author',
+            parentId: 'u1',
+          })
+
+          const created = result as { created: boolean; fieldErrors?: Record<string, string> }
+          expect(created.fieldErrors).toEqual({ authorId: 'This value is already in use' })
+        })
+
+        it('humanizes a camelCase field name in the message instead of running words together', async () => {
+          // Before this fix, `target` was always empty under a driver adapter, so
+          // this label-formatting path never ran for a camelCase column. Recovering
+          // real column names makes it reachable — verify it reads as words, not
+          // "tenantid".
+          const camelCaseConfig: OpenSaasConfig = {
+            ...config,
+            lists: {
+              ...config.lists,
+              Post: {
+                ...config.lists.Post,
+                fields: { ...config.lists.Post.fields, tenantSlug: { type: 'text' } },
+              },
+            },
+          }
+          mockPrisma.post.create.mockRejectedValue({
+            code: 'P2002',
+            meta: {
+              driverAdapterError: {
+                cause: {
+                  originalMessage:
+                    'duplicate key value violates unique constraint "post_tenantSlug_key"',
+                  constraint: { fields: ['"tenantSlug"'] },
+                },
+              },
+            },
+          })
+          mockPrisma.user.findUnique.mockResolvedValue({ id: 'u1' })
+
+          const context = await getContext(camelCaseConfig, mockPrisma, { userId: 'u1' })
+          const result = await context.serverAction({
+            listKey: 'Post',
+            action: 'createRelated',
+            data: { title: 'Dup' },
+            field: 'author',
+            parentId: 'u1',
+          })
+
+          const created = result as { created: boolean; fieldErrors?: Record<string, string> }
+          expect(created.fieldErrors).toEqual({
+            tenantSlug: 'This tenant slug is already in use',
+          })
+        })
+
+        it('leaves an already-populated meta.target unaffected (existing path still wins)', async () => {
+          mockPrisma.post.create.mockRejectedValue({
+            code: 'P2002',
+            meta: {
+              target: ['title'],
+              // Present but must be ignored — meta.target already answers the question.
+              driverAdapterError: {
+                cause: {
+                  originalMessage: 'duplicate key value violates unique constraint "other_key"',
+                  constraint: { fields: ['content'] },
+                },
+              },
+            },
+          })
+          mockPrisma.user.findUnique.mockResolvedValue({ id: 'u1' })
+
+          const context = await getContext(config, mockPrisma, { userId: 'u1' })
+          const result = await context.serverAction({
+            listKey: 'Post',
+            action: 'createRelated',
+            data: { title: 'Dup' },
+            field: 'author',
+            parentId: 'u1',
+          })
+
+          const created = result as { created: boolean; fieldErrors?: Record<string, string> }
+          expect(created.fieldErrors).toEqual({ title: 'This title is already in use' })
+        })
+
+        it('falls back to the generic message (not a throw) when nothing is recoverable', async () => {
+          mockPrisma.post.create.mockRejectedValue({ code: 'P2002', meta: {} })
+          mockPrisma.user.findUnique.mockResolvedValue({ id: 'u1' })
+
+          const context = await getContext(config, mockPrisma, { userId: 'u1' })
+          const result = await context.serverAction({
+            listKey: 'Post',
+            action: 'createRelated',
+            data: { title: 'Dup' },
+            field: 'author',
+            parentId: 'u1',
+          })
+
+          expect(result).toEqual({
+            created: false,
+            error: 'A record with this value already exists',
+            fieldErrors: {},
+          })
+        })
+
+        it('leaves a non-P2002 Prisma error unaffected', async () => {
+          mockPrisma.post.create.mockRejectedValue({
+            code: 'P2025',
+            meta: { driverAdapterError: { cause: { constraint: { fields: ['title'] } } } },
+            message: 'Record to update not found',
+          })
+          mockPrisma.user.findUnique.mockResolvedValue({ id: 'u1' })
+
+          const context = await getContext(config, mockPrisma, { userId: 'u1' })
+          const result = await context.serverAction({
+            listKey: 'Post',
+            action: 'createRelated',
+            data: { title: 'Dup' },
+            field: 'author',
+            parentId: 'u1',
+          })
+
+          expect(result).toEqual({
+            created: false,
+            error: 'Record to update not found',
+            fieldErrors: {},
+          })
+        })
+      })
     })
 
     describe('relationshipOptions', () => {
@@ -2194,7 +2412,7 @@ describe('getContext', () => {
           }
         }
 
-        it('findUnique inside a resolveOutput hook row-scopes the relation instead of dropping the where', async () => {
+        it('findUnique inside a resolveOutput hook still fetches the relation, unscoped at the Prisma level (#974)', async () => {
           let innerIncludeSeen: unknown
           const hookConfig = configWithResolveOutputProbe({ post: true }, (include) => {
             innerIncludeSeen = include
@@ -2206,9 +2424,11 @@ describe('getContext', () => {
           const context = await getContext(hookConfig, relPrisma, null)
           await context.db.author.findUnique({ where: { id: 'a1' } })
 
-          // `post` is still fetched (not dropped) but now carries Post's own
-          // query-access `where` — it is no longer a bare, unscoped `true`.
-          expect(innerIncludeSeen).toEqual({ post: { where: { status: { equals: 'published' } } } })
+          // `post` is still fetched (not dropped). It carries no `where` — Post
+          // is a to-one relation here, and Prisma rejects a `where` on a to-one
+          // include (#974); Post's own access filter is enforced afterward via
+          // a batched existence check instead (see access-filter.test.ts).
+          expect(innerIncludeSeen).toEqual({ post: true })
         })
 
         it('findMany inside a resolveOutput hook scopes the relation but does not auto-expand its nested include', async () => {
@@ -2227,10 +2447,10 @@ describe('getContext', () => {
           await context.db.author.findMany()
 
           // The caller's own nested selection (`post.include.author`) is honoured
-          // as-is (access control does not auto-descend further here), while
-          // `post` itself picks up its access `where`.
+          // as-is (access control does not auto-descend further here). `post`
+          // itself carries no `where` — see the findUnique test above (#974).
           expect(innerIncludeSeen).toEqual({
-            post: { where: { status: { equals: 'published' } }, include: { author: true } },
+            post: { include: { author: true } },
           })
         })
       })
@@ -2289,7 +2509,7 @@ describe('getContext', () => {
           expect(chainPrisma.c0.findMany).not.toHaveBeenCalled()
         })
 
-        it('still returns correctly row-scoped data for the same include one hop shallower', async () => {
+        it('still applies row-scoping at the deepest hop for the same include one hop shallower', async () => {
           const chainLength = READ_INCLUDE_MAX_DEPTH + 1
           const chainConfig: OpenSaasConfig = {
             db: { provider: 'postgresql', url: 'postgresql://localhost:5432/test' },
@@ -2300,7 +2520,20 @@ describe('getContext', () => {
           for (let i = 0; i < chainLength; i++) {
             chainPrisma[`c${i}`] = { findMany: vi.fn(), findFirst: vi.fn(), findUnique: vi.fn() }
           }
-          chainPrisma.c0.findMany.mockResolvedValue([])
+
+          // Every hop here is to-one (no `many: true`), so none of them can
+          // carry a `where` on the Prisma include (#974) — the chain comes
+          // back unscoped at the Prisma level, one nested object per hop, and
+          // row-scoping is enforced afterward via a batched existence check
+          // per hop instead.
+          let deepestItem: Record<string, unknown> = { id: `id${chainLength - 1}`, name: 'leaf' }
+          for (let i = chainLength - 2; i >= 0; i--) {
+            deepestItem = { id: `id${i}`, name: 'x', next: deepestItem }
+          }
+          chainPrisma.c0.findMany.mockResolvedValue([deepestItem])
+          for (let i = 1; i < chainLength; i++) {
+            chainPrisma[`c${i}`].findMany.mockResolvedValue([{ id: `id${i}` }])
+          }
 
           const context = await getContext(chainConfig, chainPrisma, null)
 
@@ -2308,13 +2541,27 @@ describe('getContext', () => {
             include: { next: nestedCallerInclude(READ_INCLUDE_MAX_DEPTH - 1) },
           })
 
-          // Walk the built include down to the last list — it must carry that
-          // list's own access `where`, proving row scoping, not just "no throw".
+          // Walk the built include down to the last list — no hop carries a
+          // `where` (they are all to-one).
           let entry = chainPrisma.c0.findMany.mock.calls[0][0].include.next
           for (let i = 1; i < READ_INCLUDE_MAX_DEPTH; i++) {
+            expect(entry.where).toBeUndefined()
             entry = entry.include.next
           }
-          expect(entry.where).toEqual({ ownerId: { equals: `C${READ_INCLUDE_MAX_DEPTH}` } })
+          expect(entry.where).toBeUndefined()
+
+          // The deepest hop's own existence check still carries that list's
+          // access filter — row scoping reaches all the way down, just not
+          // through the Prisma `include` itself.
+          expect(chainPrisma[`c${READ_INCLUDE_MAX_DEPTH}`].findMany).toHaveBeenCalledWith({
+            where: {
+              AND: [
+                { ownerId: { equals: `C${READ_INCLUDE_MAX_DEPTH}` } },
+                { id: { in: [`id${READ_INCLUDE_MAX_DEPTH}`] } },
+              ],
+            },
+            select: { id: true },
+          })
         })
       })
 

package/tests/field-types.test.ts

@@ -307,6 +307,29 @@ describe('Field Types', () => {
         expect(prismaType.type).toBe('Int')
         expect(prismaType.modifiers).toBe('@db.BigInt')
       })
+
+      test('isIndexed: true requests a block-level index', () => {
+        const field = integer({ isIndexed: true })
+        const prismaType = field.getPrismaType('rank')
+
+        expect(prismaType.index).toBe(true)
+      })
+
+      test("isIndexed: 'unique' generates @unique modifier", () => {
+        const field = integer({ isIndexed: 'unique' })
+        const prismaType = field.getPrismaType('rank')
+
+        expect(prismaType.modifiers).toContain('@unique')
+        expect(prismaType.index).toBeUndefined()
+      })
+
+      test('no isIndexed generates neither modifier nor index', () => {
+        const field = integer()
+        const prismaType = field.getPrismaType('rank')
+
+        expect(prismaType.modifiers).not.toContain('@unique')
+        expect(prismaType.index).toBeUndefined()
+      })
     })
 
     describe('getTypeScriptType', () => {
@@ -679,6 +702,29 @@ describe('Field Types', () => {
         expect(prismaType.type).toBe('DateTime')
         expect(prismaType.modifiers).toContain('@db.Timestamptz')
       })
+
+      test('isIndexed: true requests a block-level index', () => {
+        const field = timestamp({ isIndexed: true })
+        const prismaType = field.getPrismaType('publishedAt')
+
+        expect(prismaType.index).toBe(true)
+      })
+
+      test("isIndexed: 'unique' generates @unique modifier", () => {
+        const field = timestamp({ isIndexed: 'unique' })
+        const prismaType = field.getPrismaType('publishedAt')
+
+        expect(prismaType.modifiers).toContain('@unique')
+        expect(prismaType.index).toBeUndefined()
+      })
+
+      test('no isIndexed generates neither modifier nor index', () => {
+        const field = timestamp()
+        const prismaType = field.getPrismaType('publishedAt')
+
+        expect(prismaType.modifiers).not.toContain('@unique')
+        expect(prismaType.index).toBeUndefined()
+      })
     })
 
     describe('getTypeScriptType', () => {
@@ -810,6 +856,27 @@ describe('Field Types', () => {
         )
       })
     })
+
+    describe('ui.listView.defaultColumn (issue #1018)', () => {
+      test('is excluded from default admin table columns by default', () => {
+        const field = password()
+
+        expect(field.ui?.listView?.defaultColumn).toBe(false)
+      })
+
+      test('can be opted back into default columns explicitly', () => {
+        const field = password({ ui: { listView: { defaultColumn: true } } })
+
+        expect(field.ui?.listView?.defaultColumn).toBe(true)
+      })
+
+      test('preserves other caller-supplied ui options', () => {
+        const field = password({ ui: { description: 'Account password' } })
+
+        expect(field.ui?.description).toBe('Account password')
+        expect(field.ui?.listView?.defaultColumn).toBe(false)
+      })
+    })
   })
 
   describe('select field', () => {
@@ -905,6 +972,52 @@ describe('Field Types', () => {
         expect(prismaType.type).toBe('String')
         expect(prismaType.modifiers).toBe(' @default("draft")')
       })
+
+      test('isIndexed: true requests a block-level index on the default string column', () => {
+        const field = select({
+          options: [{ label: 'Draft', value: 'draft' }],
+          isIndexed: true,
+        })
+        const prismaType = field.getPrismaType('status')
+
+        expect(prismaType.type).toBe('String')
+        expect(prismaType.index).toBe(true)
+      })
+
+      test("isIndexed: 'unique' generates @unique on the default string column", () => {
+        const field = select({
+          options: [{ label: 'Draft', value: 'draft' }],
+          isIndexed: 'unique',
+        })
+        const prismaType = field.getPrismaType('status')
+
+        expect(prismaType.modifiers).toContain('@unique')
+        expect(prismaType.index).toBeUndefined()
+      })
+
+      test('isIndexed: true requests a block-level index on a native-enum column', () => {
+        const field = select({
+          options: [{ label: 'Draft', value: 'draft' }],
+          db: { type: 'enum' },
+          isIndexed: true,
+        })
+        const prismaType = field.getPrismaType('status', undefined, 'Post')
+
+        expect(prismaType.type).toBe('PostStatus')
+        expect(prismaType.index).toBe(true)
+      })
+
+      test("isIndexed: 'unique' generates @unique on a native-enum column", () => {
+        const field = select({
+          options: [{ label: 'Draft', value: 'draft' }],
+          db: { type: 'enum' },
+          isIndexed: 'unique',
+        })
+        const prismaType = field.getPrismaType('status', undefined, 'Post')
+
+        expect(prismaType.modifiers).toContain('@unique')
+        expect(prismaType.index).toBeUndefined()
+      })
     })
 
     describe('getTypeScriptType', () => {