@opensaas/stack-core 0.15.0 → 0.17.0

package/src/config/types.ts

@@ -618,6 +618,34 @@ export type RelationshipField<TTypeInfo extends TypeInfo = TypeInfo> =
        * ```
        */
       foreignKey?: boolean | { map?: string }
+      /**
+       * Custom relation name for many-to-many relationships
+       * Overrides the global joinTableNaming setting
+       * Prisma will create an implicit join table named _relationName
+       * Only needs to be set on one side of a bidirectional relationship
+       *
+       * @example KeystoneJS-style naming for migration
+       * ```typescript
+       * Lesson: list({
+       *   fields: {
+       *     teachers: relationship({
+       *       ref: 'Teacher.lessons',
+       *       many: true,
+       *       db: { relationName: 'Lesson_teachers' }
+       *       // Prisma creates join table _Lesson_teachers
+       *     })
+       *   }
+       * })
+       *
+       * Teacher: list({
+       *   fields: {
+       *     lessons: relationship({ ref: 'Lesson.teachers', many: true })
+       *     // Automatically uses same relationName from other side
+       *   }
+       * })
+       * ```
+       */
+      relationName?: string
       /**
        * Extend or modify the generated Prisma schema lines for this relationship field
        * Receives the generated FK line (if applicable) and relation line
@@ -1192,6 +1220,28 @@ export type DatabaseConfig = {
   // Different database adapters have varying type signatures that are hard to unify
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   prismaClientConstructor: (PrismaClientClass: any) => any
+  /**
+   * Join table naming strategy for many-to-many relationships
+   * - 'prisma': Use Prisma's default alphabetically-sorted naming (e.g., `_LessonToTeacher`)
+   * - 'keystone': Use KeystoneJS-compatible naming based on field location (e.g., `_Lesson_teachers`)
+   *
+   * Default: 'prisma'
+   *
+   * **Important for KeystoneJS migration:**
+   * When migrating from KeystoneJS, set this to 'keystone' to preserve existing join table names
+   * and avoid data loss. Keystone names join tables as `_Model_fieldName` based on where the
+   * relationship is defined in the schema.
+   *
+   * @example Preserve Keystone join table names during migration
+   * ```typescript
+   * db: {
+   *   provider: 'postgresql',
+   *   joinTableNaming: 'keystone',  // Use KeystoneJS naming convention
+   *   // ... rest of config
+   * }
+   * ```
+   */
+  joinTableNaming?: 'prisma' | 'keystone'
   /**
    * Optional function to extend or modify the generated Prisma schema
    * Receives the generated schema as a string and should return the modified schema

package/src/context/index.ts

@@ -438,13 +438,25 @@ export function getContext<
 
     // Create base operations
     const createOp = createCreate(listName, listConfig, prisma, context, config)
+    const findManyOp = createFindMany(listName, listConfig, prisma, context, config)
+    const updateOp = createUpdate(listName, listConfig, prisma, context, config)
     const operations: Record<string, unknown> = {
       findUnique: createFindUnique(listName, listConfig, prisma, context, config),
-      findMany: createFindMany(listName, listConfig, prisma, context, config),
+      findMany: findManyOp,
       create: createOp,
-      update: createUpdate(listName, listConfig, prisma, context, config),
+      update: updateOp,
       delete: createDelete(listName, listConfig, prisma, context),
       count: createCount(listName, listConfig, prisma, context),
+      createMany: createCreateMany(listName, listConfig, prisma, context, config, createOp),
+      updateMany: createUpdateMany(
+        listName,
+        listConfig,
+        prisma,
+        context,
+        config,
+        findManyOp,
+        updateOp,
+      ),
     }
 
     // Add get() method for singleton lists
@@ -914,6 +926,32 @@ function createCreate<TPrisma extends PrismaClientLike>(
   }
 }
 
+/**
+ * Create createMany operation with access control and hooks
+ * Runs create in a loop to ensure all hooks and access control are executed for each item
+ */
+function createCreateMany<TPrisma extends PrismaClientLike>(
+  listName: string,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- ListConfig must accept any TypeInfo
+  listConfig: ListConfig<any>,
+  prisma: TPrisma,
+  context: AccessContext<TPrisma>,
+  config: OpenSaasConfig,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  createFn: any,
+) {
+  return async (args: { data: Record<string, unknown>[] }) => {
+    const results = []
+
+    for (const item of args.data) {
+      const result = await createFn({ data: item })
+      results.push(result)
+    }
+
+    return results
+  }
+}
+
 /**
  * Create update operation with access control and hooks
  */
@@ -1096,6 +1134,37 @@ function createUpdate<TPrisma extends PrismaClientLike>(
   }
 }
 
+/**
+ * Create updateMany operation with access control and hooks
+ * Runs findMany to get records, then update in a loop to ensure all hooks and access control are executed
+ */
+function createUpdateMany<TPrisma extends PrismaClientLike>(
+  listName: string,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- ListConfig must accept any TypeInfo
+  listConfig: ListConfig<any>,
+  prisma: TPrisma,
+  context: AccessContext<TPrisma>,
+  config: OpenSaasConfig,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  findManyFn: any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  updateFn: any,
+) {
+  return async (args: { where?: Record<string, unknown>; data: Record<string, unknown> }) => {
+    // First, find all matching records (respects access control)
+    const items = await findManyFn({ where: args.where })
+
+    // Then update each one individually (runs hooks and access control for each)
+    const results = []
+    for (const item of items) {
+      const result = await updateFn({ where: { id: item.id }, data: args.data })
+      results.push(result)
+    }
+
+    return results
+  }
+}
+
 /**
  * Create delete operation with access control and hooks
  */

package/tests/context.test.ts

@@ -276,5 +276,153 @@ describe('getContext', () => {
       expect(mockPrisma.user.count).toHaveBeenCalled()
       expect(result).toBe(5)
     })
+
+    it('should batch create items via createMany', async () => {
+      const mockUsers = [
+        { id: '1', name: 'John', email: 'john@example.com' },
+        { id: '2', name: 'Jane', email: 'jane@example.com' },
+        { id: '3', name: 'Bob', email: 'bob@example.com' },
+      ]
+
+      // Mock create to return each user in sequence
+      mockPrisma.user.create
+        .mockResolvedValueOnce(mockUsers[0])
+        .mockResolvedValueOnce(mockUsers[1])
+        .mockResolvedValueOnce(mockUsers[2])
+
+      const context = await getContext(config, mockPrisma, null)
+      const result = await context.db.user.createMany({
+        data: [
+          { name: 'John', email: 'john@example.com' },
+          { name: 'Jane', email: 'jane@example.com' },
+          { name: 'Bob', email: 'bob@example.com' },
+        ],
+      })
+
+      // Should call create 3 times (once for each item)
+      expect(mockPrisma.user.create).toHaveBeenCalledTimes(3)
+      expect(result).toEqual(mockUsers)
+    })
+
+    it('should batch update items via updateMany', async () => {
+      const mockUsers = [
+        { id: '1', name: 'John', email: 'john@example.com' },
+        { id: '2', name: 'Jane', email: 'jane@example.com' },
+      ]
+
+      const updatedUsers = [
+        { id: '1', name: 'John Updated', email: 'john@example.com' },
+        { id: '2', name: 'Jane Updated', email: 'jane@example.com' },
+      ]
+
+      // Mock findMany to return the users
+      mockPrisma.user.findMany.mockResolvedValue(mockUsers)
+
+      // Mock findUnique for each update's access check
+      mockPrisma.user.findUnique
+        .mockResolvedValueOnce(mockUsers[0])
+        .mockResolvedValueOnce(mockUsers[1])
+
+      // Mock update to return updated users
+      mockPrisma.user.update
+        .mockResolvedValueOnce(updatedUsers[0])
+        .mockResolvedValueOnce(updatedUsers[1])
+
+      const context = await getContext(config, mockPrisma, null)
+      const result = await context.db.user.updateMany({
+        where: { id: { in: ['1', '2'] } },
+        data: { name: 'Updated' },
+      })
+
+      // Should call findMany once to get records
+      expect(mockPrisma.user.findMany).toHaveBeenCalledWith({
+        where: { id: { in: ['1', '2'] } },
+        take: undefined,
+        skip: undefined,
+        include: undefined,
+      })
+
+      // Should call update twice (once for each item)
+      expect(mockPrisma.user.update).toHaveBeenCalledTimes(2)
+      expect(result).toEqual(updatedUsers)
+    })
+
+    it('should run hooks and access control for each item in createMany', async () => {
+      // Test that hooks are called for each item
+      const mockUsers = [
+        { id: '1', name: 'John', email: 'john@example.com' },
+        { id: '2', name: 'Jane', email: 'jane@example.com' },
+      ]
+
+      mockPrisma.user.create.mockResolvedValueOnce(mockUsers[0]).mockResolvedValueOnce(mockUsers[1])
+
+      // Config with hook
+      const configWithHook: OpenSaasConfig = {
+        ...config,
+        lists: {
+          ...config.lists,
+          User: {
+            ...config.lists.User,
+            hooks: {
+              resolveInput: vi.fn(async ({ resolvedData }) => resolvedData),
+            },
+          },
+        },
+      }
+
+      const context = await getContext(configWithHook, mockPrisma, null)
+      await context.db.user.createMany({
+        data: [
+          { name: 'John', email: 'john@example.com' },
+          { name: 'Jane', email: 'jane@example.com' },
+        ],
+      })
+
+      // Hook should be called twice (once for each item)
+      expect(configWithHook.lists.User.hooks?.resolveInput).toHaveBeenCalledTimes(2)
+    })
+
+    it('should run hooks and access control for each item in updateMany', async () => {
+      const mockUsers = [
+        { id: '1', name: 'John', email: 'john@example.com' },
+        { id: '2', name: 'Jane', email: 'jane@example.com' },
+      ]
+
+      const updatedUsers = [
+        { id: '1', name: 'John Updated', email: 'john@example.com' },
+        { id: '2', name: 'Jane Updated', email: 'jane@example.com' },
+      ]
+
+      mockPrisma.user.findMany.mockResolvedValue(mockUsers)
+      mockPrisma.user.findUnique
+        .mockResolvedValueOnce(mockUsers[0])
+        .mockResolvedValueOnce(mockUsers[1])
+      mockPrisma.user.update
+        .mockResolvedValueOnce(updatedUsers[0])
+        .mockResolvedValueOnce(updatedUsers[1])
+
+      // Config with hook
+      const configWithHook: OpenSaasConfig = {
+        ...config,
+        lists: {
+          ...config.lists,
+          User: {
+            ...config.lists.User,
+            hooks: {
+              resolveInput: vi.fn(async ({ resolvedData }) => resolvedData),
+            },
+          },
+        },
+      }
+
+      const context = await getContext(configWithHook, mockPrisma, null)
+      await context.db.user.updateMany({
+        where: { id: { in: ['1', '2'] } },
+        data: { name: 'Updated' },
+      })
+
+      // Hook should be called twice (once for each item)
+      expect(configWithHook.lists.User.hooks?.resolveInput).toHaveBeenCalledTimes(2)
+    })
   })
 })