prisma-mock 0.12.2 → 1.0.0-alpha.1

package/lib/client.d.ts

@@ -0,0 +1,6 @@
+import type { Prisma, PrismaClient } from "@prisma/client";
+import { MockPrismaOptions, PrismaMockData } from "./types";
+declare const createPrismaMock: <PClient extends PrismaClient<Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>, P extends typeof Prisma>(prisma: P, options?: MockPrismaOptions<P>) => P & {
+    $getInternalState: () => Required<Partial<{ [key in import("./types").IsTable<Uncapitalize<import("./types").IsString<keyof PClient>>>]: import("./types").PrismaList<PClient, key>; }>>;
+};
+export default createPrismaMock;

package/lib/client.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const delegate_1 = require("./delegate");
+const indexes_1 = __importDefault(require("./indexes"));
+const deepCopy_1 = require("./utils/deepCopy");
+const fieldHelpers_1 = require("./utils/fieldHelpers");
+// Creates a mock Prisma client.
+// @param prisma - The Prisma namespace or client constructor.
+// @param options - Options for configuring the mock client:
+//   - data: Initial mock data for your models (default: {}).
+//   - caseInsensitive: If true, string matching is case-insensitive (default: false).
+//   - enableIndexes: If true, enables index lookups for performance (default: false).
+//   - mockClient: Optionally provide your own mock client (jest-mock-extended or vitest-mock-extended) instance to use.
+// @returns A mock Prisma client with all model methods and access to internal state.
+const createPrismaMock = (prisma, options = {
+    datamodel: prisma.dmmf.datamodel,
+    caseInsensitive: false,
+    enableIndexes: false,
+    data: {}
+}) => {
+    // Reference object to hold the mock data state
+    let ref = {
+        data: options.data || {},
+    };
+    // Initialize the mock client (either use provided one or create new)
+    let client = options.mockClient ? options.mockClient : {};
+    /**
+     * Helper function to implement mock methods consistently
+     * @param name - Method name to mock
+     * @param fnc - Function implementation
+     */
+    const mockImplementation = (name, fnc) => {
+        if (options.mockClient) {
+            client[name].mockImplementation(fnc);
+        }
+        else {
+            client[name] = fnc;
+        }
+    };
+    // Create indexes if enabled in options
+    const indexes = (0, indexes_1.default)(!!options.enableIndexes, prisma);
+    // Determine if case-insensitive matching should be used
+    const caseInsensitive = options.caseInsensitive || false;
+    // Mock $transaction method for handling database transactions
+    mockImplementation("$transaction", async (actions) => {
+        const res = [];
+        if (Array.isArray(actions)) {
+            // Handle array of promises (parallel execution)
+            for (const action of actions) {
+                res.push(await action);
+            }
+            return res;
+        }
+        else {
+            // Handle callback function (serial execution with rollback on error)
+            const snapshot = (0, deepCopy_1.deepCopy)(ref.data);
+            try {
+                // @ts-ignore
+                return await actions(client);
+            }
+            catch (error) {
+                // Rollback data on error
+                ref.data = snapshot;
+                throw error;
+            }
+        }
+    });
+    // Mock connection methods
+    mockImplementation("$connect", async () => { });
+    mockImplementation("$disconnect", async () => { });
+    mockImplementation("$use", async () => {
+        throw new Error("$use is not yet implemented in prisma-mock");
+    });
+    // Create delegate functions for model operations
+    const Delegate = (0, delegate_1.createDelegate)({ ref, prisma, datamodel: options.datamodel, caseInsensitive, indexes });
+    // Initialize each model in the datamodel
+    prisma.dmmf.datamodel.models.forEach((model) => {
+        if (!model)
+            return;
+        // Convert model name to camelCase for consistency
+        const c = (0, fieldHelpers_1.getCamelCase)(model.name);
+        // Initialize empty array for model if it doesn't exist
+        if (!ref.data[c]) {
+            ref.data = {
+                ...(ref.data || {}),
+                [c]: [],
+            };
+        }
+        // Remove multi-field IDs from the data structure
+        ref.data = (0, fieldHelpers_1.removeMultiFieldIds)(model, ref.data);
+        // Set up indexes for each field in the model
+        model.fields.forEach((field) => {
+            const isPrimaryKey = !!model.primaryKey?.fields.includes(field.name);
+            indexes.addIndexFieldIfNeeded(c, field, isPrimaryKey);
+        });
+        // Update indexes with existing data
+        ref.data[c].forEach((item) => {
+            indexes.updateItem(c, item, null);
+        });
+        // Create delegate functions for this model
+        const objs = Delegate(c, model);
+        // Bind delegate functions to the client
+        Object.keys(objs).forEach((fncName) => {
+            // Skip private methods (those starting with underscore)
+            if (fncName.indexOf("_") === 0)
+                return;
+            // Initialize model namespace if it doesn't exist
+            if (!client[c])
+                client[c] = {};
+            // Bind the delegate function to the client
+            if (options.mockClient) {
+                client[c][fncName].mockImplementation(async (...params) => {
+                    return objs[fncName](...params);
+                });
+            }
+            else {
+                client[c][fncName] = async (...params) => {
+                    return objs[fncName](...params);
+                };
+            }
+        });
+    });
+    // Add method to access internal state for testing/debugging
+    client['$getInternalState'] = () => ref.data;
+    // @ts-ignore
+    return client;
+};
+exports.default = createPrismaMock;

package/lib/defaults/autoincrement.d.ts

@@ -0,0 +1,3 @@
+import type { Prisma } from "@prisma/client";
+import { PrismaMockData } from "../types";
+export default function createAutoincrement(): <P>(prop: string, field: Prisma.DMMF.Field, data?: Partial<{ [key in import("../types").IsTable<Uncapitalize<import("../types").IsString<keyof P>>>]: import("../types").PrismaList<P, key>; }>) => Number | BigInt;

package/lib/defaults/cuid.d.ts

@@ -0,0 +1,2 @@
+declare const createCuid: () => () => string;
+export default createCuid;

package/lib/defaults/index.d.ts

@@ -0,0 +1,5 @@
+import type { Prisma } from "@prisma/client";
+import { PrismaMockData } from "../types";
+export default function createHandleDefault(): <P>(prop: string, field: Prisma.DMMF.Field, ref: {
+    data: Partial<{ [key in import("../types").IsTable<Uncapitalize<import("../types").IsString<keyof P>>>]: import("../types").PrismaList<P, key>; }>;
+}) => any;

package/lib/defaults/now.d.ts

@@ -0,0 +1,2 @@
+declare const createNow: () => Date;
+export default createNow;

package/lib/defaults/uuid.d.ts

@@ -0,0 +1,2 @@
+declare const createUuid: () => () => string;
+export default createUuid;

package/lib/delegate.d.ts

@@ -0,0 +1,48 @@
+import type { Prisma } from "@prisma/client";
+import createIndexes from "./indexes";
+import { CreateArgs } from "./types";
+/**
+ * Creates a delegate function that handles Prisma-like operations for a specific model
+ * This is the main factory function that generates model-specific CRUD operations
+ */
+export declare const createDelegate: <P extends typeof Prisma>({ ref, prisma, datamodel, caseInsensitive, indexes }: {
+    ref: any;
+    prisma: P;
+    datamodel: P["dmmf"]["datamodel"];
+    caseInsensitive: boolean;
+    indexes: ReturnType<typeof createIndexes>;
+}) => (prop: string, model: Prisma.DMMF.Model) => {
+    aggregate: (args: any) => any;
+    groupBy: (args: any) => any[];
+    findOne: (args: any) => any;
+    findUnique: (args: any) => any;
+    findUniqueOrThrow: (args: any) => any;
+    findMany: (args: any) => any[];
+    findFirst: (args: any) => any;
+    findFirstOrThrow: (args: any) => any;
+    create: (args: CreateArgs) => any;
+    createMany: (args: any) => {
+        count: any;
+    };
+    createManyAndReturn: (args: any) => any;
+    delete: (args: any) => any;
+    update: (args: any) => any;
+    deleteMany: (args: any) => {
+        count: number;
+    };
+    updateMany: (args: any) => {
+        count: number;
+    };
+    updateManyAndReturn: (args: any) => any[];
+    /**
+     * Upsert operation: update if exists, create if not
+     */
+    upsert(args: any): any;
+    /**
+     * Count operation: returns the number of records matching the criteria
+     */
+    count(args: any): number;
+    _sortFunc: (orderBy: any) => (a: any, b: any) => any;
+    _findMany: (args: any) => any[];
+    _createMany: (args: any) => any;
+};

package/lib/delegate.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDelegate = void 0;
-const client_1 = require("@prisma/client");
 const defaults_1 = __importDefault(require("./defaults"));
 const errors_1 = require("./errors");
 const fieldHelpers_1 = require("./utils/fieldHelpers");
@@ -15,10 +14,7 @@ const getWhereOnIds_1 = __importDefault(require("./utils/getWhereOnIds"));
  * Creates a delegate function that handles Prisma-like operations for a specific model
  * This is the main factory function that generates model-specific CRUD operations
  */
-const createDelegate = (ref, // Reference to the mock data store
-datamodel, // Prisma datamodel definition
-caseInsensitive, // Whether string comparisons should be case insensitive
-indexes) => {
+const createDelegate = ({ ref, prisma, datamodel = prisma.dmmf.datamodel, caseInsensitive, indexes }) => {
     // Initialize default value handler
     const handleDefaults = (0, defaults_1.default)();
     // Store many-to-many relationship data separately from the main data store
@@ -52,7 +48,7 @@ indexes) => {
             return Delegate(name, otherModel);
         };
         // Create matching function for WHERE clauses
-        const matchFnc = (0, queryMatching_1.default)({ getFieldRelationshipWhere, getDelegateForFieldName, model, datamodel, caseInsensitive });
+        const matchFnc = (0, queryMatching_1.default)({ prisma, getFieldRelationshipWhere, getDelegateForFieldName, model, datamodel, caseInsensitive });
         /**
          * Sorting function that handles both simple and nested orderBy clauses
          * Supports multiple sort criteria and nested relation sorting
@@ -71,7 +67,7 @@ indexes) => {
             // Validate that only one sort field is provided
             const keys = Object.keys(orderBy);
             if (keys.length > 1) {
-                (0, errors_1.throwValidationError)(`Argument orderBy of needs exactly one argument, but you provided ${keys.join(" and ")}. Please choose one.`);
+                (0, errors_1.throwValidationError)(prisma, `Argument orderBy of needs exactly one argument, but you provided ${keys.join(" and ")}. Please choose one.`);
             }
             // Create include function to handle nested relations during sorting
             const incl = includes({
@@ -138,7 +134,7 @@ indexes) => {
                     if (isCreating && (field.isUnique || field.isId)) {
                         const existing = findOne({ where: { [field.name]: inputFieldData } });
                         if (existing) {
-                            (0, errors_1.throwKnownError)(`Unique constraint failed on the fields: (\`${field.name}\`)`, { code: 'P2002', meta: { target: [field.name] } });
+                            (0, errors_1.throwKnownError)(prisma, `Unique constraint failed on the fields: (\`${field.name}\`)`, { code: 'P2002', meta: { target: [field.name] } });
                         }
                     }
                     // Handle relation fields (object type)
@@ -155,7 +151,7 @@ indexes) => {
                                 where
                             })).filter(Boolean);
                             if (items.length !== inputFieldData.set.length) {
-                                (0, errors_1.throwKnownError)(`An operation failed because it depends on one or more records that were required but not found. Expected ${inputFieldData.set.length} records to be connected, found only ${items.length}.`);
+                                (0, errors_1.throwKnownError)(prisma, `An operation failed because it depends on one or more records that were required but not found. Expected ${inputFieldData.set.length} records to be connected, found only ${items.length}.`);
                             }
                             // Update many-to-many data store
                             const idField = model?.fields.find((f) => f.isId)?.name;
@@ -200,7 +196,7 @@ indexes) => {
                                                 return (0, shallowCompare_1.shallowCompare)(target, valueToMatch);
                                             });
                                             if (!matchingRow) {
-                                                (0, errors_1.throwKnownError)("An operation failed because it depends on one or more records that were required but not found. {cause}");
+                                                (0, errors_1.throwKnownError)(prisma, "An operation failed because it depends on one or more records that were required but not found. {cause}");
                                             }
                                         }
                                         connectionValue = matchingRow[keyToGet];
@@ -525,7 +521,7 @@ indexes) => {
         const findOrThrow = (args) => {
             const found = findOne(args);
             if (!found) {
-                (0, errors_1.throwKnownError)(`No ${prop.slice(0, 1).toUpperCase()}${prop.slice(1)} found`);
+                (0, errors_1.throwKnownError)(prisma, `No ${prop.slice(0, 1).toUpperCase()}${prop.slice(1)} found`);
             }
             return found;
         };
@@ -589,7 +585,7 @@ indexes) => {
             res = res.map((item) => {
                 const newItem = {};
                 Object.keys(item).forEach((key) => {
-                    if (item[key] === client_1.Prisma.JsonNull || item[key] === client_1.Prisma.DbNull) {
+                    if (item[key] === prisma.JsonNull || item[key] === prisma.DbNull) {
                         newItem[key] = null;
                     }
                     else {
@@ -840,7 +836,7 @@ indexes) => {
             if (!hasMatch) {
                 if (args.skipForeignKeysChecks)
                     return;
-                (0, errors_1.throwKnownError)("An operation failed because it depends on one or more records that were required but not found. Record to update not found.", { meta: { cause: "Record to update not found." } });
+                (0, errors_1.throwKnownError)(prisma, "An operation failed because it depends on one or more records that were required but not found. Record to update not found.", { meta: { cause: "Record to update not found." } });
             }
             ref.data = {
                 ...ref.data,
@@ -1079,7 +1075,7 @@ indexes) => {
             delete: (args) => {
                 const item = findOne(args);
                 if (!item) {
-                    (0, errors_1.throwKnownError)("An operation failed because it depends on one or more records that were required but not found. Record to delete does not exist.", { meta: { cause: "Record to delete does not exist." } });
+                    (0, errors_1.throwKnownError)(prisma, "An operation failed because it depends on one or more records that were required but not found. Record to delete does not exist.", { meta: { cause: "Record to delete does not exist." } });
                 }
                 const deleted = deleteMany(args);
                 if (deleted.length) {

package/lib/errors.d.ts

@@ -0,0 +1,9 @@
+import type { Prisma } from "@prisma/client";
+export declare const throwKnownError: (prisma: typeof Prisma, message: string, { code, meta }?: {
+    code?: string;
+    meta?: any;
+}) => void;
+export declare const throwValidationError: (prisma: typeof Prisma, message: string, { code, meta }?: {
+    code?: string;
+    meta?: any;
+}) => void;

package/lib/errors.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.throwValidationError = exports.throwKnownError = void 0;
-const client_1 = require("@prisma/client");
-const throwPrismaError = (message, { code = "P2025", meta } = {}, errorClass = client_1.Prisma.PrismaClientKnownRequestError) => {
-    const clientVersion = client_1.Prisma.prismaVersion.client;
+const throwPrismaError = (prisma, message, { code = "P2025", meta } = {}, errorClass = prisma.PrismaClientKnownRequestError) => {
+    const clientVersion = prisma.prismaVersion.client;
     // PrismaClientKnownRequestError prototype changed in version 4.7.0
     // from: constructor(message: string, code: string, clientVersion: string, meta?: any)
     // to: constructor(message: string, { code, clientVersion, meta, batchRequestIdx }: KnownErrorParams)
@@ -26,11 +25,11 @@ const throwPrismaError = (message, { code = "P2025", meta } = {}, errorClass = c
     error.meta = meta;
     throw error;
 };
-const throwKnownError = (message, { code = "P2025", meta } = {}) => {
-    throwPrismaError(message, { code, meta }, client_1.Prisma.PrismaClientKnownRequestError);
+const throwKnownError = (prisma, message, { code = "P2025", meta } = {}) => {
+    throwPrismaError(prisma, message, { code, meta }, prisma.PrismaClientKnownRequestError);
 };
 exports.throwKnownError = throwKnownError;
-const throwValidationError = (message, { code = "P2025", meta } = {}) => {
-    throwPrismaError(message, { code, meta }, client_1.Prisma.PrismaClientValidationError);
+const throwValidationError = (prisma, message, { code = "P2025", meta } = {}) => {
+    throwPrismaError(prisma, message, { code, meta }, prisma.PrismaClientValidationError);
 };
 exports.throwValidationError = throwValidationError;

package/lib/index.d.ts

@@ -0,0 +1,73 @@
+import { Prisma } from "@prisma/client/default";
+import { MockPrismaOptions } from "./types";
+export default function createPrismaClient(options?: MockPrismaOptions<typeof Prisma>): typeof Prisma & {
+    $getInternalState: () => Required<Partial<{
+        account: Partial<{
+            name: string;
+            id: number;
+            sort: number;
+        }>[];
+        user: Partial<{
+            name: string;
+            id: number;
+            sort: number;
+            accountId: number;
+            role: import(".prisma/client").$Enums.Role;
+            clicks: number;
+            deleted: boolean;
+            uniqueField: string;
+            age: number;
+        }>[];
+        stripe: Partial<{
+            id: number;
+            sort: number;
+            accountId: number;
+            customerId: string;
+            active: boolean;
+        }>[];
+        answers: Partial<{
+            id: number;
+            title: string;
+        }>[];
+        userAnswers: Partial<{
+            value: string;
+            answerId: number;
+            userId: number;
+        }>[];
+        element: Partial<{
+            value: string;
+            userId: number;
+            e_id: number;
+            json: Prisma.JsonValue;
+        }>[];
+        document: Partial<{
+            name: string;
+            id: string;
+        }>[];
+        post: Partial<{
+            id: number;
+            title: string;
+            published: boolean;
+            authorId: number;
+            updated: Date;
+            created: Date;
+        }>[];
+        pet: Partial<{
+            name: string;
+            id: number;
+            ownerId: number;
+        }>[];
+        toy: Partial<{
+            name: string;
+            id: number;
+            ownerId: number;
+        }>[];
+        transaction: Partial<{
+            id: string;
+            initiator: string;
+        }>[];
+        dbGeneratedId: Partial<{
+            id: string;
+        }>[];
+    }>>;
+};

package/lib/index.js

@@ -3,128 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const client_1 = require("@prisma/client");
-const delegate_1 = require("./delegate");
-const indexes_1 = __importDefault(require("./indexes"));
-const deepCopy_1 = require("./utils/deepCopy");
-const fieldHelpers_1 = require("./utils/fieldHelpers");
-/**
- * Creates a mock Prisma client with the specified data and options
- * @param data - Initial mock data for the Prisma models
- * @param datamodel - Prisma datamodel (defaults to Prisma.dmmf.datamodel)
- * @param mockClient - Optional existing mock client to extend
- * @param options - Configuration options for the mock client
- * @returns A mock Prisma client with all model methods and internal state access
- */
-const createPrismaMock = (data = {}, datamodel = client_1.Prisma.dmmf.datamodel, mockClient, options = {
-    caseInsensitive: false,
-    enableIndexes: false,
-}) => {
-    // Reference object to hold the mock data state
-    let ref = {
-        data,
-    };
-    // Initialize the mock client (either use provided one or create new)
-    let client = mockClient ? mockClient : {};
-    /**
-     * Helper function to implement mock methods consistently
-     * @param name - Method name to mock
-     * @param fnc - Function implementation
-     */
-    const mockImplementation = (name, fnc) => {
-        if (mockClient) {
-            client[name].mockImplementation(fnc);
-        }
-        else {
-            client[name] = fnc;
-        }
-    };
-    // Create indexes if enabled in options
-    const indexes = (0, indexes_1.default)(!!options.enableIndexes);
-    // Determine if case-insensitive matching should be used
-    const caseInsensitive = options.caseInsensitive || false;
-    // Mock $transaction method for handling database transactions
-    mockImplementation("$transaction", async (actions) => {
-        const res = [];
-        if (Array.isArray(actions)) {
-            // Handle array of promises (parallel execution)
-            for (const action of actions) {
-                res.push(await action);
-            }
-            return res;
-        }
-        else {
-            // Handle callback function (serial execution with rollback on error)
-            const snapshot = (0, deepCopy_1.deepCopy)(ref.data);
-            try {
-                // @ts-ignore
-                return await actions(client);
-            }
-            catch (error) {
-                // Rollback data on error
-                ref.data = snapshot;
-                throw error;
-            }
-        }
-    });
-    // Mock connection methods
-    mockImplementation("$connect", async () => { });
-    mockImplementation("$disconnect", async () => { });
-    mockImplementation("$use", async () => {
-        throw new Error("$use is not yet implemented in prisma-mock");
-    });
-    // Create delegate functions for model operations
-    const Delegate = (0, delegate_1.createDelegate)(ref, datamodel, caseInsensitive, indexes);
-    // Initialize each model in the datamodel
-    datamodel.models.forEach((model) => {
-        if (!model)
-            return;
-        // Convert model name to camelCase for consistency
-        const c = (0, fieldHelpers_1.getCamelCase)(model.name);
-        // Initialize empty array for model if it doesn't exist
-        if (!ref.data[c]) {
-            ref.data = {
-                ...(ref.data || {}),
-                [c]: [],
-            };
-        }
-        // Remove multi-field IDs from the data structure
-        ref.data = (0, fieldHelpers_1.removeMultiFieldIds)(model, ref.data);
-        // Set up indexes for each field in the model
-        model.fields.forEach((field) => {
-            const isPrimaryKey = !!model.primaryKey?.fields.includes(field.name);
-            indexes.addIndexFieldIfNeeded(c, field, isPrimaryKey);
-        });
-        // Update indexes with existing data
-        ref.data[c].forEach((item) => {
-            indexes.updateItem(c, item, null);
-        });
-        // Create delegate functions for this model
-        const objs = Delegate(c, model);
-        // Bind delegate functions to the client
-        Object.keys(objs).forEach((fncName) => {
-            // Skip private methods (those starting with underscore)
-            if (fncName.indexOf("_") === 0)
-                return;
-            // Initialize model namespace if it doesn't exist
-            if (!client[c])
-                client[c] = {};
-            // Bind the delegate function to the client
-            if (mockClient) {
-                client[c][fncName].mockImplementation(async (...params) => {
-                    return objs[fncName](...params);
-                });
-            }
-            else {
-                client[c][fncName] = async (...params) => {
-                    return objs[fncName](...params);
-                };
-            }
-        });
-    });
-    // Add method to access internal state for testing/debugging
-    client['$getInternalState'] = () => ref.data;
-    // @ts-ignore
-    return client;
-};
-exports.default = createPrismaMock;
+const default_1 = require("@prisma/client/default");
+const client_1 = __importDefault(require("./client"));
+function createPrismaClient(options) {
+    return (0, client_1.default)(default_1.Prisma, options);
+}
+exports.default = createPrismaClient;

package/lib/indexes.d.ts

@@ -0,0 +1,15 @@
+import type { Prisma } from "@prisma/client";
+/**
+ * Creates an indexing system for Prisma mock data to improve query performance.
+ * This module maintains in-memory indexes on specified fields to enable fast lookups
+ * instead of scanning all records.
+ *
+ * @param isEnabled - Whether indexing is enabled. When false, all operations are no-ops.
+ * @returns Object containing methods for managing indexes and performing indexed lookups
+ */
+export default function createIndexes(isEnabled: boolean, prisma: typeof Prisma): {
+    addIndexFieldIfNeeded: (tableName: string, field: Prisma.DMMF.Field, isPrimary: boolean) => void;
+    getIndexedItems: (tableName: string, where: any) => any;
+    updateItem: (tableName: string, item: any, oldItem: any | null) => void;
+    deleteItemByField: (tableName: string, field: Prisma.DMMF.Field, item: any) => void;
+};

package/lib/indexes.js

@@ -8,7 +8,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * @param isEnabled - Whether indexing is enabled. When false, all operations are no-ops.
  * @returns Object containing methods for managing indexes and performing indexed lookups
  */
-function createIndexes(isEnabled = true) {
+function createIndexes(isEnabled = true, prisma) {
     // Main data structures for storing indexed data
     // items: tableName -> fieldName -> fieldValue -> array of items with that value
     let items = {};

package/lib/legacy.d.ts

@@ -0,0 +1,76 @@
+import { Prisma, PrismaClient } from "@prisma/client";
+import { DeepMockApi, MockPrismaOptions, PrismaMockData } from "./types";
+/**
+ * @deprecated Use default export instead
+ */
+export default function createPrismaClient(data?: PrismaMockData<PrismaClient>, datamodel?: Prisma.DMMF.Datamodel, mockClient?: DeepMockApi, options?: Omit<MockPrismaOptions<typeof Prisma>, "data">): typeof Prisma & {
+    $getInternalState: () => Required<Partial<{
+        account: Partial<{
+            name: string;
+            id: number;
+            sort: number;
+        }>[];
+        user: Partial<{
+            name: string;
+            id: number;
+            sort: number;
+            accountId: number;
+            role: import(".prisma/client").$Enums.Role;
+            clicks: number;
+            deleted: boolean;
+            uniqueField: string;
+            age: number;
+        }>[];
+        stripe: Partial<{
+            id: number;
+            sort: number;
+            accountId: number;
+            customerId: string;
+            active: boolean;
+        }>[];
+        answers: Partial<{
+            id: number;
+            title: string;
+        }>[];
+        userAnswers: Partial<{
+            value: string;
+            answerId: number;
+            userId: number;
+        }>[];
+        element: Partial<{
+            value: string;
+            userId: number;
+            e_id: number;
+            json: Prisma.JsonValue;
+        }>[];
+        document: Partial<{
+            name: string;
+            id: string;
+        }>[];
+        post: Partial<{
+            id: number;
+            title: string;
+            published: boolean;
+            authorId: number;
+            updated: Date;
+            created: Date;
+        }>[];
+        pet: Partial<{
+            name: string;
+            id: number;
+            ownerId: number;
+        }>[];
+        toy: Partial<{
+            name: string;
+            id: number;
+            ownerId: number;
+        }>[];
+        transaction: Partial<{
+            id: string;
+            initiator: string;
+        }>[];
+        dbGeneratedId: Partial<{
+            id: string;
+        }>[];
+    }>>;
+};

package/lib/legacy.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("@prisma/client");
+const client_2 = __importDefault(require("./client"));
+const jest_mock_extended_1 = require("jest-mock-extended");
+/**
+ * @deprecated Use default export instead
+ */
+function createPrismaClient(data = {}, datamodel, mockClient, options) {
+    if (datamodel !== client_1.Prisma.dmmf.datamodel) {
+        throw new Error("datamodel !== Prisma.dmmf.datamodel is not supported, please use createPrismaMock instead");
+    }
+    let client = (0, client_2.default)(client_1.Prisma, {
+        data,
+        // @ts-ignore
+        mockClient: mockClient || (0, jest_mock_extended_1.mockDeep)(),
+        ...options
+    });
+    return client;
+}
+exports.default = createPrismaClient;

package/lib/types.d.ts

@@ -0,0 +1,27 @@
+import type { Prisma } from "@prisma/client";
+export type DeepMockApi = {
+    mockImplementation: (fnc: any) => void;
+};
+export type UnwrapPromise<P extends any> = P extends Promise<infer R> ? R : P;
+export type PrismaDelegate = {
+    findUnique: (...args: Array<any>) => Promise<any>;
+};
+export type IsTable<S> = S extends `\$${infer fnc}` ? never : S;
+export type IsString<S extends any> = S extends string ? S : never;
+export type PrismaList<P extends {
+    [key: string]: any;
+}, K extends string> = P[K] extends PrismaDelegate ? Array<Partial<UnwrapPromise<ReturnType<P[K]["findUnique"]>>>> : never;
+export type PrismaMockData<P> = Partial<{
+    [key in IsTable<Uncapitalize<IsString<keyof P>>>]: PrismaList<P, key>;
+}>;
+export type Where = any;
+export type Item = any;
+export type Args = any;
+export type CreateArgs = any;
+export type MockPrismaOptions<P extends typeof Prisma> = {
+    datamodel: P["dmmf"]["datamodel"];
+    mockClient?: DeepMockApi;
+    caseInsensitive?: boolean;
+    enableIndexes?: boolean;
+    data?: any;
+};

package/lib/utils/deepCopy.d.ts

@@ -0,0 +1 @@
+export declare function deepCopy<T>(source: T): T;

package/lib/utils/deepEqual.d.ts

@@ -0,0 +1 @@
+export declare function deepEqual(a: any, b: any): boolean;

package/lib/utils/fieldHelpers.d.ts

@@ -0,0 +1,13 @@
+import type { Prisma } from "@prisma/client";
+import { Item } from "../types";
+export declare function isFieldDefault(f: Prisma.DMMF.FieldDefault | readonly Prisma.DMMF.FieldDefaultScalar[] | Prisma.DMMF.FieldDefaultScalar): f is Prisma.DMMF.FieldDefault;
+export declare function isDefinedWithValue<T extends object>(v: T, key: string): boolean;
+export declare const getCamelCase: (name: any) => any;
+export declare const removeMultiFieldIds: (model: Prisma.DMMF.Model, data: any) => any;
+export declare const createGetFieldRelationshipWhere: (datamodel: Omit<Prisma.DMMF.Datamodel, 'indexes'>, manyToManyData: {
+    [relationName: string]: {
+        [type: string]: any;
+    }[];
+}) => (item: any, field: Prisma.DMMF.Field, model: Prisma.DMMF.Model) => {
+    [x: string]: any;
+};

package/lib/utils/getNestedValue.d.ts

@@ -0,0 +1 @@
+export default function getNestedValue(keys: string[], values: any): any;

package/lib/utils/getWhereOnIds.d.ts

@@ -0,0 +1,2 @@
+import type { Prisma } from "@prisma/client";
+export default function getWhereOnIds(model: Prisma.DMMF.Model, item: any): {};

package/lib/utils/pad.d.ts

@@ -0,0 +1 @@
+export default function pad(s: string, size: number): string;

package/lib/utils/queryMatching.d.ts

@@ -0,0 +1,13 @@
+import type { Prisma } from "@prisma/client";
+import { createGetFieldRelationshipWhere } from "./fieldHelpers";
+import { Where } from "../types";
+type Props = {
+    getFieldRelationshipWhere: ReturnType<typeof createGetFieldRelationshipWhere>;
+    getDelegateForFieldName: (field: Prisma.DMMF.Field["type"]) => any;
+    model: Prisma.DMMF.Model;
+    datamodel: Omit<Prisma.DMMF.Datamodel, 'indexes'>;
+    caseInsensitive: boolean;
+    prisma: typeof Prisma;
+};
+export default function createMatch({ prisma, getFieldRelationshipWhere, getDelegateForFieldName, model, datamodel, caseInsensitive }: Props): (where: Where) => (item: any) => boolean;
+export {};

package/lib/utils/queryMatching.js

@@ -3,12 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const client_1 = require("@prisma/client");
 const deepEqual_1 = require("./deepEqual");
 const shallowCompare_1 = require("./shallowCompare");
 const getNestedValue_1 = __importDefault(require("./getNestedValue"));
 const fieldHelpers_1 = require("./fieldHelpers");
-function createMatch({ getFieldRelationshipWhere, getDelegateForFieldName, model, datamodel, caseInsensitive }) {
+function createMatch({ prisma, getFieldRelationshipWhere, getDelegateForFieldName, model, datamodel, caseInsensitive }) {
     const matchItem = (child, item, where) => {
         let val = item[child];
         const filter = where[child];
@@ -134,16 +133,16 @@ function createMatch({ getFieldRelationshipWhere, getDelegateForFieldName, model
                 }
                 if ("equals" in matchFilter && match) {
                     // match = deepEqual(matchFilter.equals, val)
-                    if (matchFilter.equals === client_1.Prisma.DbNull) {
-                        if (val === client_1.Prisma.DbNull) {
+                    if (matchFilter.equals === prisma.DbNull) {
+                        if (val === prisma.DbNull) {
                         }
-                        match = val === client_1.Prisma.DbNull;
+                        match = val === prisma.DbNull;
                     }
-                    else if (matchFilter.equals === client_1.Prisma.AnyNull) {
-                        match = val === client_1.Prisma.DbNull || val === client_1.Prisma.JsonNull;
+                    else if (matchFilter.equals === prisma.AnyNull) {
+                        match = val === prisma.DbNull || val === prisma.JsonNull;
                     }
                     else {
-                        if (val === client_1.Prisma.DbNull) {
+                        if (val === prisma.DbNull) {
                             match = false;
                         }
                         else {
@@ -205,11 +204,11 @@ function createMatch({ getFieldRelationshipWhere, getDelegateForFieldName, model
                     match = matchFilter.in.includes(val);
                 }
                 if ("not" in matchFilter && match) {
-                    if (matchFilter.not === client_1.Prisma.DbNull) {
-                        match = val !== client_1.Prisma.DbNull;
+                    if (matchFilter.not === prisma.DbNull) {
+                        match = val !== prisma.DbNull;
                     }
                     else {
-                        if (val === client_1.Prisma.DbNull) {
+                        if (val === prisma.DbNull) {
                             match = false;
                         }
                         else {

package/lib/utils/shallowCompare.d.ts

@@ -0,0 +1,5 @@
+export declare const shallowCompare: (a: {
+    [key: string]: any;
+}, b: {
+    [key: string]: any;
+}) => boolean;

package/package.json

@@ -1,17 +1,34 @@
 {
   "name": "prisma-mock",
-  "version": "0.12.2",
+  "version": "1.0.0-alpha.1",
   "description": "Mock prisma for unit testing database",
   "main": "lib/index.js",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/demonsters/prisma-mock.git"
   },
+  "bin": {
+    "prisma-mock": "./prisma-dmmf-generator.mjs"
+  },
   "license": "MIT",
   "types": "lib/",
   "files": [
     "lib/"
   ],
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./legacy": {
+      "types": "./lib/legacy.d.ts",
+      "default": "./lib/legacy.js"
+    },
+    "./client": {
+      "types": "./lib/client.d.ts",
+      "default": "./lib/client.js"
+    }
+  },
   "devDependencies": {
     "@changesets/cli": "^2.29.5",
     "@prisma/client": "6.11.1",
@@ -42,6 +59,5 @@
   },
   "dependencies": {
     "jest-mock-extended": "^3.0.6"
-  },
-  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
+  }
 }

package/prisma-dmmf-generator.mjs

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { writeFile } from "fs/promises"
+import helper from "@prisma/generator-helper"
+
+helper.generatorHandler({
+  onManifest: () => ({
+    prettyName: "prisma-mock",
+    version: "1.0.0",
+  }),
+  onGenerate({ generator, dmmf }) {
+    if (!generator.output?.value)
+      throw new Error("Missing output path in generator configuration")
+
+    const exports = Object.entries(dmmf.datamodel).reduce(
+      (acc, [k, v], idx, arr) =>
+        acc +
+        `export const ${k} = ${JSON.stringify(v, null, 2)};\n${
+          arr[idx + 1] ? "\n" : ""
+        }`,
+      ""
+    )
+
+    return writeFile(generator.output.value, exports, "utf8")
+  },
+})