prisma-prefixed-ids 1.4.0 → 1.5.1

package/README.md

@@ -19,7 +19,7 @@ import { type Prisma, PrismaClient } from "@prisma/client";
 import { extendPrismaClient } from 'prisma-prefixed-ids';
 
 type ModelName = Prisma.ModelName;
-// NOTE: is your Prisma.ModelName is not available in your setup,
+// NOTE: if your Prisma.ModelName is not available in your setup,
 // simply use the following instead:
 // type ModelName = string;
 
@@ -49,6 +49,179 @@ const organization = await extendedPrisma.organization.create({
 console.log(organization.id); // e.g., 'org_abc123...'
 ```
 
+## Nested Writes Support (v1.5.0+)
+
+Since version 1.5.0, this package fully supports **nested writes** with automatic ID generation for all related records. This includes complex relationship operations like:
+
+### Basic Nested Creates
+
+```typescript
+// Create a user with nested posts
+const userWithPosts = await extendedPrisma.user.create({
+  data: {
+    name: 'John Doe',
+    email: 'john@example.com',
+    posts: {
+      create: [
+        {
+          title: 'My First Post',
+          content: 'Hello world!',
+          published: true,
+        },
+        {
+          title: 'Draft Post', 
+          content: 'Work in progress...',
+          published: false,
+        },
+      ],
+    },
+  },
+  include: { posts: true },
+});
+
+// Result:
+// - User gets ID: usr_abc123...
+// - Posts get IDs: pst_def456..., pst_ghi789...
+```
+
+### Deep Nested Writes
+
+```typescript
+// Create deeply nested structures with automatic ID generation
+const complexUser = await extendedPrisma.user.create({
+  data: {
+    name: 'Jane Smith',
+    email: 'jane@example.com',
+    posts: {
+      create: {
+        title: 'Post with Categories and Comments',
+        content: 'A comprehensive post...',
+        published: true,
+        categories: {
+          create: {
+            name: 'Technology',
+            description: 'Tech-related posts',
+          },
+        },
+        comments: {
+          createMany: {
+            data: [
+              { content: 'Great post!', authorName: 'Reader 1' },
+              { content: 'Very informative', authorName: 'Reader 2' },
+            ],
+          },
+        },
+      },
+    },
+  },
+  include: {
+    posts: {
+      include: {
+        categories: true,
+        comments: true,
+      },
+    },
+  },
+});
+
+// All related records automatically get prefixed IDs:
+// - User: usr_...
+// - Post: pst_...  
+// - Category: cat_...
+// - Comments: cmt_..., cmt_...
+```
+
+### Update Operations with Nested Creates
+
+```typescript
+// Update existing records and create new related records
+const updatedUser = await extendedPrisma.user.update({
+  where: { id: 'usr_existing123' },
+  data: {
+    name: 'Updated Name',
+    posts: {
+      create: [
+        {
+          title: 'New Post After Update',
+          content: 'Added after user update',
+        },
+      ],
+    },
+  },
+  include: { posts: true },
+});
+
+// Existing user keeps original ID, new posts get fresh prefixed IDs
+```
+
+### Upsert Operations
+
+```typescript
+// Upsert with nested creates
+const upsertedUser = await extendedPrisma.user.upsert({
+  where: { email: 'maybe@example.com' },
+  create: {
+    name: 'New User',
+    email: 'maybe@example.com',
+    posts: {
+      create: {
+        title: 'First Post',
+        content: 'Created during upsert',
+      },
+    },
+  },
+  update: {
+    name: 'Updated Existing User',
+  },
+  include: { posts: true },
+});
+
+// IDs are generated only for the create branch if record doesn't exist
+```
+
+### ConnectOrCreate Operations
+
+```typescript
+// Connect to existing or create new with automatic ID generation
+const postWithCategories = await extendedPrisma.post.create({
+  data: {
+    title: 'Post with Mixed Categories',
+    content: 'Some categories exist, others will be created',
+    categories: {
+      connectOrCreate: [
+        {
+          where: { name: 'Existing Category' },
+          create: { name: 'Should not be created' },
+        },
+        {
+          where: { name: 'New Category' },
+          create: { 
+            name: 'New Category',
+            description: 'Freshly created category',
+          },
+        },
+      ],
+    },
+  },
+  include: { categories: true },
+});
+
+// New categories get prefixed IDs, existing ones are connected as-is
+```
+
+### Supported Nested Operations
+
+The extension supports all Prisma nested write operations:
+
+- ✅ **`create`** - Single nested record creation
+- ✅ **`createMany`** - Multiple nested records creation  
+- ✅ **`connectOrCreate`** - Connect existing or create new records
+- ✅ **`upsert`** - Update existing or create new records
+- ✅ **Deeply nested structures** - Multiple levels of relationships
+- ✅ **Mixed operations** - Combining create, connect, disconnect in single query
+
+All nested records that are created (not connected to existing ones) will automatically receive prefixed IDs according to your configuration.
+
 ## Custom ID Generation
 
 You can customize how IDs are generated by providing your own ID generator function:
@@ -118,9 +291,30 @@ This package uses [nanoid](https://github.com/ai/nanoid) for ID generation inste
 5. **Better Performance**: nanoid is optimized for performance and generates IDs faster than UUID v4.
 
 For example, with a 24-character nanoid:
-- The chance of a collision is approximately 1 in 2^128 (same as UUID v4)
-- The ID length is 24 characters + prefix length (e.g., `usr_abc123...`)
-- The alphabet includes 36 characters (0-9, a-z), making it both readable and compact
+- The chance of a collision is approximately 1 in 2^142 (even better than UUID v4's 2^122)
+- The ID length is 24 characters + prefix length (e.g., `usr_abc123DEF...`)
+- The alphabet includes 62 characters (0-9, a-z, A-Z), providing high entropy while remaining readable
+
+## Development
+
+### Running Tests
+
+This project includes comprehensive unit and integration tests:
+
+```bash
+# Run all tests
+npm test
+
+# Run only unit tests (fast, no database)
+npm run test:unit
+
+# Run only integration tests (uses real SQLite database)
+npm run test:integration
+```
+
+The integration tests automatically download the Prisma query engine and set up a SQLite database as needed. No additional setup is required.
+
+For more detailed development information, see [DEVELOPMENT.md](./DEVELOPMENT.md).
 
 ## License
 

package/dist/index.cjs

@@ -1,13 +1,175 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.processNestedData = exports.findRelationModel = void 0;
 exports.createPrefixedIdsExtension = createPrefixedIdsExtension;
 exports.extendPrismaClient = extendPrismaClient;
+exports.getDMMF = getDMMF;
+exports.getModelNames = getModelNames;
 const nanoid_1 = require("nanoid");
 const defaultIdGenerator = (prefix) => {
     const nanoid = (0, nanoid_1.customAlphabet)("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", 24);
     return `${prefix}_${nanoid()}`;
 };
-function createPrefixedIdsExtension(config) {
+// All possible relation operations in Prisma
+const RELATION_OPERATIONS = [
+    "create",
+    "createMany",
+    "connectOrCreate",
+    "upsert",
+    "update",
+    "updateMany",
+];
+// Helper to find the relation model from DMMF
+const findRelationModel = (dmmf, parentModel, fieldName) => {
+    // Find the model in DMMF
+    const model = dmmf.datamodel.models.find((m) => m.name === parentModel);
+    if (!model) {
+        return null;
+    }
+    // Find the field that matches the relation name
+    const field = model.fields.find((f) => f.name === fieldName);
+    if (!field || field.kind !== "object") {
+        return null;
+    }
+    // Return the related model name
+    return field.type;
+};
+exports.findRelationModel = findRelationModel;
+// Helper function to check if key is a relation operation
+const isRelationOperation = (key) => {
+    return RELATION_OPERATIONS.includes(key);
+};
+// Helper function to process nested data with proper model detection
+const processNestedData = (data, model, prefixedId, dmmf, shouldAddRootId = true) => {
+    if (!data) {
+        return data;
+    }
+    // Handle array of items
+    if (Array.isArray(data)) {
+        return data.map((item) => (0, exports.processNestedData)(item, model, prefixedId, dmmf, shouldAddRootId));
+    }
+    // Handle object
+    if (typeof data === "object") {
+        const result = { ...data };
+        // Generate ID for the current model if needed (for nested creates)
+        if (shouldAddRootId && !result.id) {
+            const id = prefixedId(model);
+            if (id) {
+                result.id = id;
+            }
+        }
+        // Process nested relations by checking each key in the object
+        for (const [key, value] of Object.entries(result)) {
+            if (!value || typeof value !== "object")
+                continue;
+            // CASE 1: Key itself is a relation operation (root level operation)
+            if (isRelationOperation(key)) {
+                // Find which field this operation belongs to by looking at non-operation keys
+                const relationFields = Object.keys(result).filter((k) => !isRelationOperation(k));
+                for (const relationField of relationFields) {
+                    const relatedModel = (0, exports.findRelationModel)(dmmf, model, relationField);
+                    if (relatedModel) {
+                        if (key === "createMany" && "data" in value) {
+                            // Handle createMany operation
+                            const createManyOp = value;
+                            result[key] = {
+                                ...value,
+                                data: (0, exports.processNestedData)(createManyOp.data, relatedModel, prefixedId, dmmf),
+                            };
+                        }
+                        else if (key === "upsert") {
+                            // Handle upsert operation (has create and update)
+                            result[key] = {
+                                ...value,
+                                create: value.create
+                                    ? (0, exports.processNestedData)(value.create, relatedModel, prefixedId, dmmf)
+                                    : value.create,
+                                update: value.update,
+                            };
+                        }
+                        else if (key === "connectOrCreate") {
+                            // Handle connectOrCreate operation
+                            result[key] = {
+                                ...value,
+                                create: value.create
+                                    ? (0, exports.processNestedData)(value.create, relatedModel, prefixedId, dmmf)
+                                    : value.create,
+                            };
+                        }
+                        else if (key === "create" || key === "createMany") {
+                            // Only process create operations with ID generation
+                            result[key] = (0, exports.processNestedData)(value, relatedModel, prefixedId, dmmf);
+                        }
+                        else {
+                            // For other operations like update, just pass through the value
+                            result[key] = value;
+                        }
+                        break;
+                    }
+                }
+            }
+            // CASE 2: Key might be a relation field that contains operations
+            else {
+                const relatedModel = (0, exports.findRelationModel)(dmmf, model, key);
+                if (!relatedModel)
+                    continue;
+                // Process all possible operations in this relation field
+                const updatedValue = { ...value };
+                // Process each operation type
+                for (const op of RELATION_OPERATIONS) {
+                    if (!(op in value))
+                        continue;
+                    if (op === "createMany" && "data" in value[op]) {
+                        updatedValue[op] = {
+                            ...value[op],
+                            data: (0, exports.processNestedData)(value[op].data, relatedModel, prefixedId, dmmf),
+                        };
+                    }
+                    else if (op === "upsert") {
+                        updatedValue[op] = {
+                            ...value[op],
+                            create: value[op].create
+                                ? (0, exports.processNestedData)(value[op].create, relatedModel, prefixedId, dmmf)
+                                : value[op].create,
+                            update: value[op].update, // Don't process update
+                        };
+                    }
+                    else if (op === "connectOrCreate") {
+                        // Special handling for connectOrCreate - it's an array where each item has where/create
+                        if (Array.isArray(value[op])) {
+                            updatedValue[op] = value[op].map((connectOrCreateItem) => ({
+                                ...connectOrCreateItem,
+                                create: connectOrCreateItem.create
+                                    ? (0, exports.processNestedData)(connectOrCreateItem.create, relatedModel, prefixedId, dmmf, true)
+                                    : connectOrCreateItem.create,
+                            }));
+                        }
+                        else {
+                            // Fallback for non-array connectOrCreate (shouldn't happen in normal usage)
+                            updatedValue[op] = value[op];
+                        }
+                    }
+                    else if (op === "create" || op === "createMany") {
+                        // Only process create operations with ID generation
+                        updatedValue[op] = (0, exports.processNestedData)(value[op], relatedModel, prefixedId, dmmf);
+                    }
+                    else {
+                        // For other operations like update, just pass through the value
+                        updatedValue[op] = value[op];
+                    }
+                }
+                result[key] = updatedValue;
+            }
+        }
+        return result;
+    }
+    return data;
+};
+exports.processNestedData = processNestedData;
+function createPrefixedIdsExtension(config, dmmf) {
+    if (!dmmf) {
+        throw new Error("DMMF is required for prefixed IDs extension");
+    }
     const { prefixes, idGenerator = defaultIdGenerator } = config;
     const prefixedId = (modelName) => {
         if (modelName in prefixes) {
@@ -15,40 +177,124 @@ function createPrefixedIdsExtension(config) {
         }
         return null;
     };
-    return {
-        name: "prefixedIds",
-        query: {
-            $allModels: {
-                create: ({ args, query, model }) => {
-                    if (args.data && !args.data.id) {
-                        const id = prefixedId(model);
-                        if (id) {
-                            args.data.id = id;
-                        }
+    const createOperationHandler = (operation) => {
+        return ({ args, query, model }) => {
+            if (operation === "upsert") {
+                // For upsert operations, add ID to create branch only
+                if (args.create && !args.create.id) {
+                    const id = prefixedId(model);
+                    if (id) {
+                        args.create.id = id;
+                    }
+                }
+                // Process nested data in both create and update branches
+                if (dmmf) {
+                    if (args.create) {
+                        args.create = (0, exports.processNestedData)(args.create, model, prefixedId, dmmf, true);
                     }
-                    return query(args);
-                },
-                createMany: ({ args, query, model }) => {
-                    if (model in prefixes && args.data && Array.isArray(args.data)) {
+                    if (args.update) {
+                        args.update = (0, exports.processNestedData)(args.update, model, prefixedId, dmmf, false);
+                    }
+                }
+            }
+            else if (operation === "connectOrCreate") {
+                // For connectOrCreate operations, add ID to create branch only
+                if (args.create && !args.create.id) {
+                    const id = prefixedId(model);
+                    if (id) {
+                        args.create.id = id;
+                    }
+                }
+                // Process nested data in create branch
+                if (dmmf && args.create) {
+                    args.create = (0, exports.processNestedData)(args.create, model, prefixedId, dmmf, true);
+                }
+            }
+            else if (args.data) {
+                if (operation === "createMany") {
+                    // For createMany, data is an array
+                    if (Array.isArray(args.data)) {
                         args.data = args.data.map((item) => {
                             if (!item.id) {
                                 const id = prefixedId(model);
                                 if (id) {
-                                    return {
-                                        ...item,
-                                        id,
-                                    };
+                                    item.id = id;
                                 }
                             }
                             return item;
                         });
                     }
-                    return query(args);
-                },
+                }
+                else if (operation === "create") {
+                    // For regular create operations only
+                    if (!args.data.id) {
+                        const id = prefixedId(model);
+                        if (id) {
+                            args.data.id = id;
+                        }
+                    }
+                    // Process nested data to add IDs to nested creates
+                    if (dmmf) {
+                        args.data = (0, exports.processNestedData)(args.data, model, prefixedId, dmmf, true);
+                    }
+                }
+                else if (operation === "update" || operation === "updateMany") {
+                    // For update operations, only process nested creates, don't add ID to root
+                    if (dmmf) {
+                        args.data = (0, exports.processNestedData)(args.data, model, prefixedId, dmmf, false);
+                    }
+                }
+            }
+            return query(args);
+        };
+    };
+    return {
+        name: "prefixedIds",
+        query: {
+            $allModels: {
+                create: createOperationHandler("create"),
+                createMany: createOperationHandler("createMany"),
+                update: createOperationHandler("update"),
+                updateMany: createOperationHandler("updateMany"),
+                upsert: createOperationHandler("upsert"),
+                connectOrCreate: createOperationHandler("connectOrCreate"),
             },
         },
     };
 }
 function extendPrismaClient(prisma, config) {
-    return prisma.$extends(createPrefixedIdsExtension(config));
+    const dmmf = getDMMF(prisma);
+    return prisma.$extends(createPrefixedIdsExtension(config, dmmf));
+}
+// Helper function to get DMMF from a Prisma Client instance or query context
+function getDMMF(clientOrContext) {
+    // Try newer structure first (_runtimeDataModel)
+    if (clientOrContext._runtimeDataModel) {
+        const modelsEntries = Object.entries(clientOrContext._runtimeDataModel.models);
+        return {
+            datamodel: {
+                models: modelsEntries.map(([name, model]) => ({
+                    name: name,
+                    fields: model.fields.map((field) => ({
+                        name: field.name,
+                        kind: field.relationName ? "object" : "scalar",
+                        type: field.type,
+                        isList: field.isList,
+                    })),
+                })),
+            },
+        };
+    }
+    // Fallback to older structures
+    return (clientOrContext._baseDmmf ||
+        clientOrContext._dmmf ||
+        clientOrContext._client?._baseDmmf ||
+        clientOrContext._client?._dmmf);
+}
+// Helper function to get all model names from a Prisma Client instance
+function getModelNames(prismaClient) {
+    const dmmf = getDMMF(prismaClient);
+    if (!dmmf)
+        return [];
+    return dmmf.datamodel.models.map((model) => model.name);
 }

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import type { PrismaClient } from "@prisma/client";
-type ModelName = string;
+import { type PrismaClient } from "@prisma/client";
+export type ModelName = string;
 export type PrefixConfig<ModelName extends string> = {
     prefixes: Partial<Record<ModelName, string>>;
     idGenerator?: (prefix: string) => string;
@@ -9,16 +9,22 @@ type QueryArgs = {
     query: (args: any) => Promise<any>;
     model: ModelName;
 };
-export declare function createPrefixedIdsExtension<ModelName extends string>(config: PrefixConfig<ModelName>): {
+export declare const findRelationModel: (dmmf: any, parentModel: string, fieldName: string) => string | null;
+export declare const processNestedData: <T extends ModelName>(data: any, model: T, prefixedId: (model: T) => string | null, dmmf: any, shouldAddRootId?: boolean) => any;
+export declare function createPrefixedIdsExtension<ModelName extends string>(config: PrefixConfig<ModelName>, dmmf: any): {
     name: string;
     query: {
         $allModels: {
             create: (args: QueryArgs) => Promise<any>;
             createMany: (args: QueryArgs) => Promise<any>;
+            update: (args: QueryArgs) => Promise<any>;
+            updateMany: (args: QueryArgs) => Promise<any>;
+            upsert: (args: QueryArgs) => Promise<any>;
+            connectOrCreate: (args: QueryArgs) => Promise<any>;
         };
     };
 };
-export declare function extendPrismaClient<ModelName extends string = string, Client extends {
-    $extends: (extension: any) => any;
-} = PrismaClient>(prisma: Client, config: PrefixConfig<ModelName>): ReturnType<Client["$extends"]>;
+export declare function extendPrismaClient<ModelName extends string = string, Client extends PrismaClient = PrismaClient>(prisma: Client, config: PrefixConfig<ModelName>): Client;
+export declare function getDMMF(clientOrContext: PrismaClient | any): any;
+export declare function getModelNames(prismaClient: PrismaClient): string[];
 export {};

package/dist/index.js

@@ -3,7 +3,164 @@ const defaultIdGenerator = (prefix) => {
     const nanoid = customAlphabet("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", 24);
     return `${prefix}_${nanoid()}`;
 };
-export function createPrefixedIdsExtension(config) {
+// All possible relation operations in Prisma
+const RELATION_OPERATIONS = [
+    "create",
+    "createMany",
+    "connectOrCreate",
+    "upsert",
+    "update",
+    "updateMany",
+];
+// Helper to find the relation model from DMMF
+export const findRelationModel = (dmmf, parentModel, fieldName) => {
+    // Find the model in DMMF
+    const model = dmmf.datamodel.models.find((m) => m.name === parentModel);
+    if (!model) {
+        return null;
+    }
+    // Find the field that matches the relation name
+    const field = model.fields.find((f) => f.name === fieldName);
+    if (!field || field.kind !== "object") {
+        return null;
+    }
+    // Return the related model name
+    return field.type;
+};
+// Helper function to check if key is a relation operation
+const isRelationOperation = (key) => {
+    return RELATION_OPERATIONS.includes(key);
+};
+// Helper function to process nested data with proper model detection
+export const processNestedData = (data, model, prefixedId, dmmf, shouldAddRootId = true) => {
+    if (!data) {
+        return data;
+    }
+    // Handle array of items
+    if (Array.isArray(data)) {
+        return data.map((item) => processNestedData(item, model, prefixedId, dmmf, shouldAddRootId));
+    }
+    // Handle object
+    if (typeof data === "object") {
+        const result = { ...data };
+        // Generate ID for the current model if needed (for nested creates)
+        if (shouldAddRootId && !result.id) {
+            const id = prefixedId(model);
+            if (id) {
+                result.id = id;
+            }
+        }
+        // Process nested relations by checking each key in the object
+        for (const [key, value] of Object.entries(result)) {
+            if (!value || typeof value !== "object")
+                continue;
+            // CASE 1: Key itself is a relation operation (root level operation)
+            if (isRelationOperation(key)) {
+                // Find which field this operation belongs to by looking at non-operation keys
+                const relationFields = Object.keys(result).filter((k) => !isRelationOperation(k));
+                for (const relationField of relationFields) {
+                    const relatedModel = findRelationModel(dmmf, model, relationField);
+                    if (relatedModel) {
+                        if (key === "createMany" && "data" in value) {
+                            // Handle createMany operation
+                            const createManyOp = value;
+                            result[key] = {
+                                ...value,
+                                data: processNestedData(createManyOp.data, relatedModel, prefixedId, dmmf),
+                            };
+                        }
+                        else if (key === "upsert") {
+                            // Handle upsert operation (has create and update)
+                            result[key] = {
+                                ...value,
+                                create: value.create
+                                    ? processNestedData(value.create, relatedModel, prefixedId, dmmf)
+                                    : value.create,
+                                update: value.update,
+                            };
+                        }
+                        else if (key === "connectOrCreate") {
+                            // Handle connectOrCreate operation
+                            result[key] = {
+                                ...value,
+                                create: value.create
+                                    ? processNestedData(value.create, relatedModel, prefixedId, dmmf)
+                                    : value.create,
+                            };
+                        }
+                        else if (key === "create" || key === "createMany") {
+                            // Only process create operations with ID generation
+                            result[key] = processNestedData(value, relatedModel, prefixedId, dmmf);
+                        }
+                        else {
+                            // For other operations like update, just pass through the value
+                            result[key] = value;
+                        }
+                        break;
+                    }
+                }
+            }
+            // CASE 2: Key might be a relation field that contains operations
+            else {
+                const relatedModel = findRelationModel(dmmf, model, key);
+                if (!relatedModel)
+                    continue;
+                // Process all possible operations in this relation field
+                const updatedValue = { ...value };
+                // Process each operation type
+                for (const op of RELATION_OPERATIONS) {
+                    if (!(op in value))
+                        continue;
+                    if (op === "createMany" && "data" in value[op]) {
+                        updatedValue[op] = {
+                            ...value[op],
+                            data: processNestedData(value[op].data, relatedModel, prefixedId, dmmf),
+                        };
+                    }
+                    else if (op === "upsert") {
+                        updatedValue[op] = {
+                            ...value[op],
+                            create: value[op].create
+                                ? processNestedData(value[op].create, relatedModel, prefixedId, dmmf)
+                                : value[op].create,
+                            update: value[op].update, // Don't process update
+                        };
+                    }
+                    else if (op === "connectOrCreate") {
+                        // Special handling for connectOrCreate - it's an array where each item has where/create
+                        if (Array.isArray(value[op])) {
+                            updatedValue[op] = value[op].map((connectOrCreateItem) => ({
+                                ...connectOrCreateItem,
+                                create: connectOrCreateItem.create
+                                    ? processNestedData(connectOrCreateItem.create, relatedModel, prefixedId, dmmf, true)
+                                    : connectOrCreateItem.create,
+                            }));
+                        }
+                        else {
+                            // Fallback for non-array connectOrCreate (shouldn't happen in normal usage)
+                            updatedValue[op] = value[op];
+                        }
+                    }
+                    else if (op === "create" || op === "createMany") {
+                        // Only process create operations with ID generation
+                        updatedValue[op] = processNestedData(value[op], relatedModel, prefixedId, dmmf);
+                    }
+                    else {
+                        // For other operations like update, just pass through the value
+                        updatedValue[op] = value[op];
+                    }
+                }
+                result[key] = updatedValue;
+            }
+        }
+        return result;
+    }
+    return data;
+};
+export function createPrefixedIdsExtension(config, dmmf) {
+    if (!dmmf) {
+        throw new Error("DMMF is required for prefixed IDs extension");
+    }
     const { prefixes, idGenerator = defaultIdGenerator } = config;
     const prefixedId = (modelName) => {
         if (modelName in prefixes) {
@@ -11,40 +168,124 @@ export function createPrefixedIdsExtension(config) {
         }
         return null;
     };
-    return {
-        name: "prefixedIds",
-        query: {
-            $allModels: {
-                create: ({ args, query, model }) => {
-                    if (args.data && !args.data.id) {
-                        const id = prefixedId(model);
-                        if (id) {
-                            args.data.id = id;
-                        }
+    const createOperationHandler = (operation) => {
+        return ({ args, query, model }) => {
+            if (operation === "upsert") {
+                // For upsert operations, add ID to create branch only
+                if (args.create && !args.create.id) {
+                    const id = prefixedId(model);
+                    if (id) {
+                        args.create.id = id;
+                    }
+                }
+                // Process nested data in both create and update branches
+                if (dmmf) {
+                    if (args.create) {
+                        args.create = processNestedData(args.create, model, prefixedId, dmmf, true);
                     }
-                    return query(args);
-                },
-                createMany: ({ args, query, model }) => {
-                    if (model in prefixes && args.data && Array.isArray(args.data)) {
+                    if (args.update) {
+                        args.update = processNestedData(args.update, model, prefixedId, dmmf, false);
+                    }
+                }
+            }
+            else if (operation === "connectOrCreate") {
+                // For connectOrCreate operations, add ID to create branch only
+                if (args.create && !args.create.id) {
+                    const id = prefixedId(model);
+                    if (id) {
+                        args.create.id = id;
+                    }
+                }
+                // Process nested data in create branch
+                if (dmmf && args.create) {
+                    args.create = processNestedData(args.create, model, prefixedId, dmmf, true);
+                }
+            }
+            else if (args.data) {
+                if (operation === "createMany") {
+                    // For createMany, data is an array
+                    if (Array.isArray(args.data)) {
                         args.data = args.data.map((item) => {
                             if (!item.id) {
                                 const id = prefixedId(model);
                                 if (id) {
-                                    return {
-                                        ...item,
-                                        id,
-                                    };
+                                    item.id = id;
                                 }
                             }
                             return item;
                         });
                     }
-                    return query(args);
-                },
+                }
+                else if (operation === "create") {
+                    // For regular create operations only
+                    if (!args.data.id) {
+                        const id = prefixedId(model);
+                        if (id) {
+                            args.data.id = id;
+                        }
+                    }
+                    // Process nested data to add IDs to nested creates
+                    if (dmmf) {
+                        args.data = processNestedData(args.data, model, prefixedId, dmmf, true);
+                    }
+                }
+                else if (operation === "update" || operation === "updateMany") {
+                    // For update operations, only process nested creates, don't add ID to root
+                    if (dmmf) {
+                        args.data = processNestedData(args.data, model, prefixedId, dmmf, false);
+                    }
+                }
+            }
+            return query(args);
+        };
+    };
+    return {
+        name: "prefixedIds",
+        query: {
+            $allModels: {
+                create: createOperationHandler("create"),
+                createMany: createOperationHandler("createMany"),
+                update: createOperationHandler("update"),
+                updateMany: createOperationHandler("updateMany"),
+                upsert: createOperationHandler("upsert"),
+                connectOrCreate: createOperationHandler("connectOrCreate"),
             },
         },
     };
 }
 export function extendPrismaClient(prisma, config) {
-    return prisma.$extends(createPrefixedIdsExtension(config));
+    const dmmf = getDMMF(prisma);
+    return prisma.$extends(createPrefixedIdsExtension(config, dmmf));
+}
+// Helper function to get DMMF from a Prisma Client instance or query context
+export function getDMMF(clientOrContext) {
+    // Try newer structure first (_runtimeDataModel)
+    if (clientOrContext._runtimeDataModel) {
+        const modelsEntries = Object.entries(clientOrContext._runtimeDataModel.models);
+        return {
+            datamodel: {
+                models: modelsEntries.map(([name, model]) => ({
+                    name: name,
+                    fields: model.fields.map((field) => ({
+                        name: field.name,
+                        kind: field.relationName ? "object" : "scalar",
+                        type: field.type,
+                        isList: field.isList,
+                    })),
+                })),
+            },
+        };
+    }
+    // Fallback to older structures
+    return (clientOrContext._baseDmmf ||
+        clientOrContext._dmmf ||
+        clientOrContext._client?._baseDmmf ||
+        clientOrContext._client?._dmmf);
+}
+// Helper function to get all model names from a Prisma Client instance
+export function getModelNames(prismaClient) {
+    const dmmf = getDMMF(prismaClient);
+    if (!dmmf)
+        return [];
+    return dmmf.datamodel.models.map((model) => model.name);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-prefixed-ids",
-  "version": "1.4.0",
+  "version": "1.5.1",
   "description": "A Prisma extension that adds prefixed IDs to your models",
   "type": "module",
   "main": "./dist/index.js",
@@ -25,9 +25,17 @@
     "build:esm": "tsc -p tsconfig.json",
     "build:cjs": "tsc -p tsconfig.cjs.json && mv dist/cjs/index.js dist/index.cjs && rm -rf dist/cjs",
     "prepare": "npm run build",
-    "test": "jest",
+    "postinstall": "npm run clean:test-artifacts",
+    "clean:test-artifacts": "rm -rf test-client prisma/test.db prisma/test.db-journal",
+    "test": "npm run test:unit && npm run test:integration",
+    "test:unit": "jest --testPathIgnorePatterns=integration",
+    "test:integration": "npm run db:setup && jest --testPathPattern=integration",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage --collectCoverageFrom='src/**/*.ts' --coveragePathIgnorePatterns='src/__tests__'",
+    "db:setup": "npm run db:generate && npm run db:push",
+    "db:generate": "prisma generate",
+    "db:push": "prisma db push",
+    "db:reset": "prisma migrate reset --force",
     "lint": "eslint . --ext .ts",
     "lint:fix": "eslint . --ext .ts --fix",
     "format": "prettier --write \"src/**/*.ts\"",
@@ -57,10 +65,14 @@
     "eslint-config-prettier": "^9.0.0",
     "jest": "^29.0.0",
     "prettier": "^3.0.0",
+    "prisma": "^5.0.0",
     "ts-jest": "^29.0.0",
     "typescript": "^5.0.0"
   },
   "peerDependencies": {
     "@prisma/client": "^5.0.0 || ^6.0.0"
+  },
+  "prisma": {
+    "schema": "tests/prisma/schema.prisma"
   }
 }