prisma-mock 0.1.8 → 0.2.0

package/README.md

@@ -1,4 +1,3 @@
-
 # Prisma Mock
 
 This is a mock of the Prisma API intended for unit testing. All the data is stored in memory.
@@ -19,28 +18,26 @@ beforeEach(async () => {
 }
 ```
 
-
 An example how to mock a global prisma instance inside and schema a "db" directory (like blitzjs):
 
 ```js
-import createPrismaMock from "prisma-mock"
-import { mockDeep, mockReset } from "jest-mock-extended"
+import createPrismaMock from "prisma-mock";
+import { mockDeep, mockReset } from "jest-mock-extended";
 
 jest.mock("db", () => ({
   __esModule: true,
-  ...jest.requireActual('db'),
-  default: mockDeep()
-}))
+  ...jest.requireActual("db"),
+  default: mockDeep(),
+}));
 
-import db, { Prisma } from "db"
+import db, { Prisma } from "db";
 
 beforeEach(() => {
-  mockReset(db)
-  return createPrismaMock({}, Prisma.dmmf.datamodel, db)
-})
+  mockReset(db);
+  return createPrismaMock({}, Prisma.dmmf.datamodel, db);
+});
 ```
 
-
 # API
 
 ```ts
@@ -61,30 +58,32 @@ createPrismaMock({
     {
       id: 1,
       name: "John Doe",
-      accountId: 1
-    }
+      accountId: 1,
+    },
   ],
   account: [
     {
       id: 1,
       name: "Company",
-    }
-  ]
-})
+    },
+  ],
+});
 ```
 
-
 ## datamodel
+
 The datamodel of the prisma client, value of `Prisma.dmmf.datamodel`.
 
 ## client
-`jest-mock-extended` instance used. If not provided, a new instance is created.
 
+`jest-mock-extended` instance used. If not provided, a new instance is created.
 
 # Supported features
+
 Alot of the functionality is implemented, but parts are missing. Here is a list of the (missing) features:
 
 ## Model queries
+
 - findUnique,
 - findMany,
 - findFirst,
@@ -99,16 +98,17 @@ Alot of the functionality is implemented, but parts are missing. Here is a list
 - TODO: aggregate
 - TODO: groupBy
 
-
 ## Model query options
+
 - distinct
 - include
 - where
 - select
 - orderBy
-- TODO: select: _count
+- TODO: select: \_count
 
 ## Nested queries
+
 - create
 - createMany
 - update
@@ -121,8 +121,8 @@ Alot of the functionality is implemented, but parts are missing. Here is a list
 - TODO: connectOrCreate
 - TODO: upsert
 
-
 ## Filter conditions and operators
+
 - equals
 - gt
 - gte
@@ -141,18 +141,22 @@ Alot of the functionality is implemented, but parts are missing. Here is a list
 - TODO: mode
 
 ## Relation filters
+
 - some
 - every
 - none
 - TODO: is
 
 ## Scalar list methods
+
 TODO (set, push)
 
 ## Scalar list filters
+
 TODO (has, hasEvery, hasSome, isEmpty, equals)
 
 ## Atomic number operations
+
 - increment
 - decrement
 - multiply
@@ -160,26 +164,29 @@ TODO (has, hasEvery, hasSome, isEmpty, equals)
 - set
 
 ## JSON filters
+
 TODO (path, string_contains, string_starts_with, string_ends_with, array_contains, array_starts_with, array_ends_with)
 
 ## Attributes
+
 - @@id
 - @default
 - @unique (TODO: no error if duplicate)
 - @@unique (TODO: no error if duplicate)
 - @relation
-- TODO: @updatedAt
+- @updatedAt: Partially supported, value is set at creation (TODO: update value on update)
 
 ## Attribute functions
+
 - autoincrement()
 - TODO: auto()
-- TODO: cuid()
+- cuid()
 - TODO: uuid()
-- TODO: now()
+- now()
 - TODO: dbgenerated()
 
 ## Referential actions
+
 - onDelete (SetNull, Cascade)
 - TODO: onDelete: Restrict, NoAction, SetDefault
 - TODO: onUpdate
-

package/lib/defaults/autoincrement.d.ts

@@ -0,0 +1,4 @@
+import { Prisma } from "@prisma/client";
+import { PrismaMockData } from "..";
+export default function autoincrement<P>(prop: string, field: Prisma.DMMF.Field, data?: PrismaMockData<P>): Number;
+export declare function reset(): void;

package/lib/defaults/autoincrement.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reset = void 0;
+let autoincrement_cache = {};
+function autoincrement(prop, field, data = {}) {
+    const key = `${prop}_${field.name}`;
+    let m = autoincrement_cache?.[key];
+    if (m === undefined) {
+        m = 0;
+        data[prop].forEach((item) => {
+            m = Math.max(m, item[field.name]);
+        });
+    }
+    m += 1;
+    autoincrement_cache[key] = m;
+    return m;
+}
+exports.default = autoincrement;
+function reset() {
+    autoincrement_cache = {};
+}
+exports.reset = reset;

package/lib/defaults/cuid.d.ts

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

package/lib/defaults/cuid.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cuid2_1 = require("@paralleldrive/cuid2");
+const Cuid = () => (0, cuid2_1.createId)();
+exports.default = Cuid;

package/lib/defaults/index.d.ts

@@ -0,0 +1,4 @@
+import { Prisma } from "@prisma/client";
+import { PrismaMockData } from "..";
+export default function HandleDefault<P>(prop: string, field: Prisma.DMMF.Field, data: PrismaMockData<P>): any;
+export declare function ResetDefaults(): void;

package/lib/defaults/index.js

@@ -0,0 +1,47 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResetDefaults = void 0;
+const autoincrement_1 = __importStar(require("./autoincrement"));
+const cuid_1 = __importDefault(require("./cuid"));
+const now_1 = __importDefault(require("./now"));
+// const registry = new Map<string, (string, Prisma.DMMF.Field, PrismaMockData) => any>();
+const registry = new Map();
+registry.set("autoincrement", autoincrement_1.default);
+registry.set("cuid", cuid_1.default);
+registry.set("now", now_1.default);
+function HandleDefault(prop, field, data) {
+    const key = field.default.name;
+    const val = registry.get(key)?.(prop, field, data);
+    return val;
+}
+exports.default = HandleDefault;
+function ResetDefaults() {
+    (0, autoincrement_1.reset)();
+}
+exports.ResetDefaults = ResetDefaults;

package/lib/defaults/now.d.ts

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

package/lib/defaults/now.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Now = () => new Date();
+exports.default = Now;

package/lib/index.d.ts

@@ -1,4 +1,4 @@
-import { Prisma } from '@prisma/client';
+import { Prisma } from "@prisma/client";
 type UnwrapPromise<P extends any> = P extends Promise<infer R> ? R : P;
 type PrismaDelegate = {
     findUnique: (...args: Array<any>) => Promise<any>;
@@ -11,5 +11,7 @@ type PrismaList<P extends {
 export type PrismaMockData<P> = Partial<{
     [key in IsTable<Uncapitalize<IsString<keyof P>>>]: PrismaList<P, key>;
 }>;
-declare const createPrismaMock: <P>(data?: Partial<{ [key in IsTable<Uncapitalize<IsString<keyof P>>>]: PrismaList<P, key>; }>, datamodel?: Prisma.DMMF.Datamodel, client?: { [K in keyof P]: P[K] extends (...args: infer A) => infer B ? import("jest-mock-extended").CalledWithMock<B, A> & (P[K] extends infer T extends (...args: infer A) => infer B ? { [K_1 in keyof T]: P[K][K_1] extends (...args: infer A_1) => infer B_1 ? import("jest-mock-extended").CalledWithMock<B_1, A_1> & (P[K][K_1] extends infer T_1 extends (...args: infer A_1) => infer B_1 ? { [K_2 in keyof T_1]: P[K][K_1][K_2] extends (...args: infer A_2) => infer B_2 ? import("jest-mock-extended").CalledWithMock<B_2, A_2> & (P[K][K_1][K_2] extends infer T_2 extends (...args: infer A_2) => infer B_2 ? { [K_3 in keyof T_2]: P[K][K_1][K_2][K_3] extends (...args: infer A_3) => infer B_3 ? import("jest-mock-extended").CalledWithMock<B_3, A_3> & (P[K][K_1][K_2][K_3] extends infer T_3 extends (...args: infer A_3) => infer B_3 ? { [K_4 in keyof T_3]: P[K][K_1][K_2][K_3][K_4] extends (...args: infer A_4) => infer B_4 ? import("jest-mock-extended").CalledWithMock<B_4, A_4> & (P[K][K_1][K_2][K_3][K_4] extends infer T_4 extends (...args: infer A_4) => infer B_4 ? { [K_5 in keyof T_4]: P[K][K_1][K_2][K_3][K_4][K_5] extends (...args: infer A_5) => infer B_5 ? import("jest-mock-extended").CalledWithMock<B_5, A_5> & (P[K][K_1][K_2][K_3][K_4][K_5] extends infer T_5 extends (...args: infer A_5) => infer B_5 ? { [K_6 in keyof T_5]: P[K][K_1][K_2][K_3][K_4][K_5][K_6] extends (...args: infer A_6) => infer B_6 ? import("jest-mock-extended").CalledWithMock<B_6, A_6> & (P[K][K_1][K_2][K_3][K_4][K_5][K_6] extends infer T_6 extends (...args: infer A_6) => infer B_6 ? { [K_7 in keyof T_6]: P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7] extends (...args: infer A_7) => infer B_7 ? import("jest-mock-extended").CalledWithMock<B_7, A_7> & (P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7] extends infer T_7 extends (...args: infer A_7) => infer B_7 ? { [K_8 in keyof T_7]: P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8] extends (...args: infer A_8) => infer B_8 ? import("jest-mock-extended").CalledWithMock<B_8, A_8> & (P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8] extends infer T_8 extends (...args: infer A_8) => infer B_8 ? { [K_9 in keyof T_8]: P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8][K_9] extends (...args: infer A_9) => infer B_9 ? import("jest-mock-extended").CalledWithMock<B_9, A_9> & (P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8][K_9] extends infer T_9 extends (...args: infer A_9) => infer B_9 ? { [K_10 in keyof T_9]: P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8][K_9][K_10] extends (...args: infer A_10) => infer B_10 ? any : import("jest-mock-extended").DeepMockProxy<P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8][K_9][K_10]>; } : never) & P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8][K_9] : import("jest-mock-extended").DeepMockProxy<P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8][K_9]>; } : never) & P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8] : import("jest-mock-extended").DeepMockProxy<P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8]>; } : never) & P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7] : import("jest-mock-extended").DeepMockProxy<P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7]>; } : never) & P[K][K_1][K_2][K_3][K_4][K_5][K_6] : import("jest-mock-extended").DeepMockProxy<P[K][K_1][K_2][K_3][K_4][K_5][K_6]>; } : never) & P[K][K_1][K_2][K_3][K_4][K_5] : import("jest-mock-extended").DeepMockProxy<P[K][K_1][K_2][K_3][K_4][K_5]>; } : never) & P[K][K_1][K_2][K_3][K_4] : import("jest-mock-extended").DeepMockProxy<P[K][K_1][K_2][K_3][K_4]>; } : never) & P[K][K_1][K_2][K_3] : import("jest-mock-extended").DeepMockProxy<P[K][K_1][K_2][K_3]>; } : never) & P[K][K_1][K_2] : import("jest-mock-extended").DeepMockProxy<P[K][K_1][K_2]>; } : never) & P[K][K_1] : import("jest-mock-extended").DeepMockProxy<P[K][K_1]>; } : never) & P[K] : import("jest-mock-extended").DeepMockProxy<P[K]>; } & P) => P;
+declare const createPrismaMock: <P>(data?: Partial<{ [key in IsTable<Uncapitalize<IsString<keyof P>>>]: PrismaList<P, key>; }>, datamodel?: Prisma.DMMF.Datamodel, client?: { [K in keyof P]: P[K] extends (...args: infer A) => infer B ? import("jest-mock-extended").CalledWithMock<B, A> & (P[K] extends infer T extends (...args: infer A) => infer B ? { [K_1 in keyof T]: P[K][K_1] extends (...args: infer A_1) => infer B_1 ? import("jest-mock-extended").CalledWithMock<B_1, A_1> & (P[K][K_1] extends infer T_1 extends (...args: infer A_1) => infer B_1 ? { [K_2 in keyof T_1]: P[K][K_1][K_2] extends (...args: infer A_2) => infer B_2 ? import("jest-mock-extended").CalledWithMock<B_2, A_2> & (P[K][K_1][K_2] extends infer T_2 extends (...args: infer A_2) => infer B_2 ? { [K_3 in keyof T_2]: P[K][K_1][K_2][K_3] extends (...args: infer A_3) => infer B_3 ? import("jest-mock-extended").CalledWithMock<B_3, A_3> & (P[K][K_1][K_2][K_3] extends infer T_3 extends (...args: infer A_3) => infer B_3 ? { [K_4 in keyof T_3]: P[K][K_1][K_2][K_3][K_4] extends (...args: infer A_4) => infer B_4 ? import("jest-mock-extended").CalledWithMock<B_4, A_4> & (P[K][K_1][K_2][K_3][K_4] extends infer T_4 extends (...args: infer A_4) => infer B_4 ? { [K_5 in keyof T_4]: P[K][K_1][K_2][K_3][K_4][K_5] extends (...args: infer A_5) => infer B_5 ? import("jest-mock-extended").CalledWithMock<B_5, A_5> & (P[K][K_1][K_2][K_3][K_4][K_5] extends infer T_5 extends (...args: infer A_5) => infer B_5 ? { [K_6 in keyof T_5]: P[K][K_1][K_2][K_3][K_4][K_5][K_6] extends (...args: infer A_6) => infer B_6 ? import("jest-mock-extended").CalledWithMock<B_6, A_6> & (P[K][K_1][K_2][K_3][K_4][K_5][K_6] extends infer T_6 extends (...args: infer A_6) => infer B_6 ? { [K_7 in keyof T_6]: P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7] extends (...args: infer A_7) => infer B_7 ? import("jest-mock-extended").CalledWithMock<B_7, A_7> & (P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7] extends infer T_7 extends (...args: infer A_7) => infer B_7 ? { [K_8 in keyof T_7]: P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8] extends (...args: infer A_8) => infer B_8 ? import("jest-mock-extended").CalledWithMock<B_8, A_8> & (P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8] extends infer T_8 extends (...args: infer A_8) => infer B_8 ? { [K_9 in keyof T_8]: P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8][K_9] extends (...args: infer A_9) => infer B_9 ? import("jest-mock-extended").CalledWithMock<B_9, A_9> & (P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8][K_9] extends infer T_9 extends (...args: infer A_9) => infer B_9 ? { [K_10 in keyof T_9]: P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8][K_9][K_10] extends (...args: infer A_10) => infer B_10 ? any : import("jest-mock-extended").DeepMockProxy<P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8][K_9][K_10]>; } : never) & P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8][K_9] : import("jest-mock-extended").DeepMockProxy<P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8][K_9]>; } : never) & P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8] : import("jest-mock-extended").DeepMockProxy<P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7][K_8]>; } : never) & P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7] : import("jest-mock-extended").DeepMockProxy<P[K][K_1][K_2][K_3][K_4][K_5][K_6][K_7]>; } : never) & P[K][K_1][K_2][K_3][K_4][K_5][K_6] : import("jest-mock-extended").DeepMockProxy<P[K][K_1][K_2][K_3][K_4][K_5][K_6]>; } : never) & P[K][K_1][K_2][K_3][K_4][K_5] : import("jest-mock-extended").DeepMockProxy<P[K][K_1][K_2][K_3][K_4][K_5]>; } : never) & P[K][K_1][K_2][K_3][K_4] : import("jest-mock-extended").DeepMockProxy<P[K][K_1][K_2][K_3][K_4]>; } : never) & P[K][K_1][K_2][K_3] : import("jest-mock-extended").DeepMockProxy<P[K][K_1][K_2][K_3]>; } : never) & P[K][K_1][K_2] : import("jest-mock-extended").DeepMockProxy<P[K][K_1][K_2]>; } : never) & P[K][K_1] : import("jest-mock-extended").DeepMockProxy<P[K][K_1]>; } : never) & P[K] : import("jest-mock-extended").DeepMockProxy<P[K]>; } & P, options?: {
+    caseInsensitive: boolean;
+}) => P;
 export default createPrismaMock;

package/lib/index.js

@@ -1,49 +1,65 @@
 "use strict";
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const client_1 = require("@prisma/client");
 const runtime_1 = require("@prisma/client/runtime");
 const jest_mock_extended_1 = require("jest-mock-extended");
-const createPrismaMock = (data = {}, datamodel, client = (0, jest_mock_extended_1.mockDeep)()) => {
+const defaults_1 = __importStar(require("./defaults"));
+const shallowCompare_1 = require("./utils/shallowCompare");
+const deepEqual_1 = require("./utils/deepEqual");
+function IsFieldDefault(f) {
+    return f.name !== undefined;
+}
+const createPrismaMock = (data = {}, datamodel, client = (0, jest_mock_extended_1.mockDeep)(), options = { caseInsensitive: false }) => {
     if (!datamodel || typeof datamodel === "string") {
         datamodel = client_1.Prisma.dmmf.datamodel;
     }
-    let autoincrement = {};
+    (0, defaults_1.ResetDefaults)();
     const getCamelCase = (name) => {
         return name.substr(0, 1).toLowerCase() + name.substr(1);
     };
-    const shallowCompare = (a, b) => {
-        for (let key in b) {
-            if (a[key] !== b[key])
-                return false;
-        }
-        return true;
-    };
     const removeMultiFieldIds = (model, data) => {
-        var _a, _b;
         const c = getCamelCase(model.name);
-        const idFields = model.idFields || ((_a = model.primaryKey) === null || _a === void 0 ? void 0 : _a.fields);
+        const idFields = model.idFields || model.primaryKey?.fields;
         const removeId = (ids) => {
-            const id = ids.join('_');
-            data = Object.assign(Object.assign({}, data), { [c]: data[c].map(item => {
-                    const _a = item, _b = id, idVal = _a[_b], rest = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
-                    return Object.assign(Object.assign({}, rest), idVal);
-                }) });
+            const id = ids.join("_");
+            data = {
+                ...data,
+                [c]: data[c].map((item) => {
+                    const { [id]: idVal, ...rest } = item;
+                    return {
+                        ...rest,
+                        ...idVal,
+                    };
+                }),
+            };
         };
-        if ((idFields === null || idFields === void 0 ? void 0 : idFields.length) > 1) {
+        if (idFields?.length > 1) {
             removeId(idFields);
         }
-        if (((_b = model.uniqueFields) === null || _b === void 0 ? void 0 : _b.length) > 0) {
+        if (model.uniqueFields?.length > 0) {
             for (const uniqueField of model.uniqueFields) {
                 removeId(uniqueField);
             }
@@ -57,15 +73,15 @@ const createPrismaMock = (data = {}, datamodel, client = (0, jest_mock_extended_
                 [field.relationFromFields[0]]: item[field.relationToFields[0]],
             };
         }
-        return ({
+        return {
             [field.relationToFields[0]]: item[field.relationFromFields[0]],
-        });
+        };
     };
     const getJoinField = (field) => {
-        const joinmodel = datamodel.models.find(model => {
+        const joinmodel = datamodel.models.find((model) => {
             return model.name === field.type;
         });
-        const joinfield = joinmodel === null || joinmodel === void 0 ? void 0 : joinmodel.fields.find(f => {
+        const joinfield = joinmodel?.fields.find((f) => {
             return f.relationName === field.relationName;
         });
         return joinfield;
@@ -89,19 +105,21 @@ const createPrismaMock = (data = {}, datamodel, client = (0, jest_mock_extended_
             }
             const keys = Object.keys(orderBy);
             if (keys.length > 1) {
-                throw new runtime_1.PrismaClientValidationError(`Argument orderBy of needs exactly one argument, but you provided ${keys.join(' and ')}. Please choose one.`);
+                throw new runtime_1.PrismaClientValidationError(`Argument orderBy of needs exactly one argument, but you provided ${keys.join(" and ")}. Please choose one.`);
             }
-            const incl = includes({ include: keys.reduce((acc, key) => (Object.assign(Object.assign({}, acc), { [key]: true })), {}) });
+            const incl = includes({
+                include: keys.reduce((acc, key) => ({ ...acc, [key]: true }), {}),
+            });
             for (const key of keys) {
                 const dir = orderBy[key];
                 if (typeof dir === "object") {
-                    const schema = model.fields.find(field => {
+                    const schema = model.fields.find((field) => {
                         return field.name === key;
                     });
                     if (!schema) {
                         return 0;
                     }
-                    const submodel = datamodel.models.find(model => {
+                    const submodel = datamodel.models.find((model) => {
                         return model.name === schema.type;
                     });
                     const delegate = Delegate(getCamelCase(schema.type), submodel);
@@ -132,39 +150,79 @@ const createPrismaMock = (data = {}, datamodel, client = (0, jest_mock_extended_
         const nestedUpdate = (args, isCreating, item) => {
             let d = args.data;
             // Get field schema for default values
-            const model = datamodel.models.find(model => {
+            const model = datamodel.models.find((model) => {
                 return getCamelCase(model.name) === prop;
             });
-            model.fields.forEach(field => {
+            model.fields.forEach((field) => {
                 if (d[field.name]) {
                     const c = d[field.name];
-                    if (field.kind === 'object') {
+                    if (field.kind === "object") {
                         if (c.connect) {
-                            const _a = d, _b = field.name, { connect } = _a[_b], rest = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
-                            let connectionValue = connect[field.relationToFields[0]];
-                            const keyToMatch = Object.keys(connect)[0];
-                            const keyToGet = field.relationToFields[0];
-                            if (keyToMatch !== keyToGet) {
-                                const valueToMatch = connect[keyToMatch];
-                                const matchingRow = data[getCamelCase(field.type)].find(row => {
-                                    return row[keyToMatch] === valueToMatch;
-                                });
-                                if (!matchingRow) {
-                                    // 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)
-                                    if (runtime_1.PrismaClientKnownRequestError.length === 2) {
-                                        throw new runtime_1.PrismaClientKnownRequestError('An operation failed because it depends on one or more records that were required but not found. {cause}', { code: 'P2025', clientVersion: '1.2.3' });
+                            const { [field.name]: { connect }, ...rest } = d;
+                            const connections = connect instanceof Array ? connect : [connect];
+                            connections.forEach((connect, idx) => {
+                                const keyToMatch = Object.keys(connect)[0];
+                                if (field.relationToFields.length > 0) {
+                                    const keyToGet = field.relationToFields[0];
+                                    const targetKey = field.relationFromFields[0];
+                                    let connectionValue = connect[keyToGet];
+                                    if (keyToMatch !== keyToGet) {
+                                        const valueToMatch = connect[keyToMatch];
+                                        const matchingRow = data[getCamelCase(field.type)].find((row) => {
+                                            return row[keyToMatch] === valueToMatch;
+                                        });
+                                        if (!matchingRow) {
+                                            const message = "An operation failed because it depends on one or more records that were required but not found. {cause}";
+                                            const code = "P2025";
+                                            const clientVersion = "1.2.3";
+                                            // 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)
+                                            if (runtime_1.PrismaClientKnownRequestError.length === 2) {
+                                                // @ts-ignore
+                                                throw new runtime_1.PrismaClientKnownRequestError(message, {
+                                                    code,
+                                                    clientVersion,
+                                                });
+                                            }
+                                            // @ts-ignore
+                                            throw new runtime_1.PrismaClientKnownRequestError(message, code, 
+                                            // @ts-ignore
+                                            clientVersion);
+                                        }
+                                        connectionValue = matchingRow[keyToGet];
                                     }
-                                    // @ts-ignore
-                                    throw new runtime_1.PrismaClientKnownRequestError('An operation failed because it depends on one or more records that were required but not found. {cause}', 'P2025', '1.2.3');
+                                    d = {
+                                        ...rest,
+                                        [targetKey]: connectionValue,
+                                    };
                                 }
-                                connectionValue = matchingRow[keyToGet];
-                            }
-                            d = Object.assign(Object.assign({}, rest), { [field.relationFromFields[0]]: connectionValue });
+                                else {
+                                    d = rest;
+                                    const otherModel = datamodel.models.find((model) => {
+                                        return model.name === field.type;
+                                    });
+                                    const inverse = otherModel.fields.find((otherField) => field.relationName === otherField.relationName);
+                                    const targetKey = inverse.relationToFields[0];
+                                    const fromKey = inverse.relationFromFields[0];
+                                    const delegate = Delegate(getCamelCase(otherModel.name), otherModel);
+                                    delegate.update({
+                                        where: {
+                                            [fromKey]: connect[keyToMatch],
+                                        },
+                                        data: {
+                                            [getCamelCase(inverse.name)]: {
+                                                connect: {
+                                                    [targetKey]: d[targetKey],
+                                                },
+                                            },
+                                        },
+                                    });
+                                }
+                            });
                         }
                         if (c.create || c.createMany) {
-                            const _c = d, _d = field.name, create = _c[_d], rest = __rest(_c, [typeof _d === "symbol" ? _d : _d + ""]);
+                            const { [field.name]: create, ...rest } = d;
                             d = rest;
                             // @ts-ignore
                             const name = getCamelCase(field.type);
@@ -172,29 +230,47 @@ const createPrismaMock = (data = {}, datamodel, client = (0, jest_mock_extended_
                             const joinfield = getJoinField(field);
                             if (field.relationFromFields.length > 0) {
                                 const item = delegate.create({
-                                    data: create.create
+                                    data: create.create,
                                 });
-                                d = Object.assign(Object.assign({}, rest), { [field.relationFromFields[0]]: item[field.relationToFields[0]] });
+                                d = {
+                                    ...rest,
+                                    [field.relationFromFields[0]]: item[field.relationToFields[0]],
+                                };
                             }
                             else {
-                                const map = (val) => (Object.assign(Object.assign({}, val), { [joinfield.name]: {
+                                const map = (val) => ({
+                                    ...val,
+                                    [joinfield.name]: {
                                         connect: joinfield.relationToFields.reduce((prev, cur, index) => {
                                             let val = d[cur];
                                             if (!isCreating && !val) {
                                                 val = findOne(args)[cur];
                                             }
-                                            return Object.assign(Object.assign({}, prev), { [cur]: val });
+                                            return {
+                                                ...prev,
+                                                [cur]: val,
+                                            };
                                         }, {}),
-                                    } }));
+                                    },
+                                });
                                 if (c.createMany) {
-                                    delegate.createMany(Object.assign(Object.assign({}, c.createMany), { data: c.createMany.data.map(map) }));
+                                    delegate.createMany({
+                                        ...c.createMany,
+                                        data: c.createMany.data.map(map),
+                                    });
                                 }
                                 else {
                                     if (Array.isArray(c.create)) {
-                                        delegate.createMany(Object.assign(Object.assign({}, c.create), { data: c.create.map(map) }));
+                                        delegate.createMany({
+                                            ...c.create,
+                                            data: c.create.map(map),
+                                        });
                                     }
                                     else {
-                                        delegate.create(Object.assign(Object.assign({}, create.create), { data: map(create.create) }));
+                                        delegate.create({
+                                            ...create.create,
+                                            data: map(create.create),
+                                        });
                                     }
                                 }
                             }
@@ -203,7 +279,7 @@ const createPrismaMock = (data = {}, datamodel, client = (0, jest_mock_extended_
                         const delegate = Delegate(name, model);
                         if (c.updateMany) {
                             if (Array.isArray(c.updateMany)) {
-                                c.updateMany.forEach(updateMany => {
+                                c.updateMany.forEach((updateMany) => {
                                     delegate.updateMany(updateMany);
                                 });
                             }
@@ -213,18 +289,21 @@ const createPrismaMock = (data = {}, datamodel, client = (0, jest_mock_extended_
                         }
                         if (c.update) {
                             if (Array.isArray(c.update)) {
-                                c.update.forEach(update => {
+                                c.update.forEach((update) => {
                                     delegate.update(update);
                                 });
                             }
                             else {
                                 const item = findOne(args);
-                                delegate.update({ data: c.update, where: getFieldRelationshipWhere(item, field) });
+                                delegate.update({
+                                    data: c.update,
+                                    where: getFieldRelationshipWhere(item, field),
+                                });
                             }
                         }
                         if (c.deleteMany) {
                             if (Array.isArray(c.deleteMany)) {
-                                c.deleteMany.forEach(where => {
+                                c.deleteMany.forEach((where) => {
                                     delegate.deleteMany({ where });
                                 });
                             }
@@ -234,7 +313,7 @@ const createPrismaMock = (data = {}, datamodel, client = (0, jest_mock_extended_
                         }
                         if (c.delete) {
                             if (Array.isArray(c.delete)) {
-                                c.delete.forEach(where => {
+                                c.delete.forEach((where) => {
                                     delegate.delete({ where });
                                 });
                             }
@@ -244,64 +323,88 @@ const createPrismaMock = (data = {}, datamodel, client = (0, jest_mock_extended_
                         }
                         if (c.disconnect) {
                             if (field.relationFromFields.length > 0) {
-                                d = Object.assign(Object.assign({}, d), { [field.relationFromFields[0]]: null });
+                                d = {
+                                    ...d,
+                                    [field.relationFromFields[0]]: null,
+                                };
                             }
                             else {
                                 const joinfield = getJoinField(field);
                                 delegate.update({
                                     data: {
-                                        [joinfield.relationFromFields[0]]: null
+                                        [joinfield.relationFromFields[0]]: null,
                                     },
                                     where: {
-                                        [joinfield.relationFromFields[0]]: item[joinfield.relationToFields[0]]
-                                    }
+                                        [joinfield.relationFromFields[0]]: item[joinfield.relationToFields[0]],
+                                    },
                                 });
                             }
                         }
-                        const _e = d, _f = field.name, _update = _e[_f], rest = __rest(_e, [typeof _f === "symbol" ? _f : _f + ""]);
+                        const { [field.name]: _update, ...rest } = d;
                         d = rest;
                     }
                     if (c.increment) {
-                        d = Object.assign(Object.assign({}, d), { [field.name]: item[field.name] + c.increment });
+                        d = {
+                            ...d,
+                            [field.name]: item[field.name] + c.increment,
+                        };
                     }
                     if (c.decrement) {
-                        d = Object.assign(Object.assign({}, d), { [field.name]: item[field.name] - c.decrement });
+                        d = {
+                            ...d,
+                            [field.name]: item[field.name] - c.decrement,
+                        };
                     }
                     if (c.multiply) {
-                        d = Object.assign(Object.assign({}, d), { [field.name]: item[field.name] * c.multiply });
+                        d = {
+                            ...d,
+                            [field.name]: item[field.name] * c.multiply,
+                        };
                     }
                     if (c.divide) {
-                        d = Object.assign(Object.assign({}, d), { [field.name]: item[field.name] / c.divide });
+                        d = {
+                            ...d,
+                            [field.name]: item[field.name] / c.divide,
+                        };
                     }
                     if (c.set) {
-                        d = Object.assign(Object.assign({}, d), { [field.name]: c.set });
+                        d = {
+                            ...d,
+                            [field.name]: c.set,
+                        };
                     }
                 }
                 if ((isCreating || d[field.name] === null) &&
                     (d[field.name] === null || d[field.name] === undefined)) {
                     if (field.hasDefaultValue) {
-                        if (typeof field.default === 'object' && !Array.isArray(field.default)) {
-                            if (field.default.name === 'autoincrement') {
-                                const key = `${prop}_${field.name}`;
-                                let m = autoincrement === null || autoincrement === void 0 ? void 0 : autoincrement[key];
-                                if (m === undefined) {
-                                    m = 0;
-                                    data[prop].forEach(item => {
-                                        m = Math.max(m, item[field.name]);
-                                    });
-                                }
-                                m += 1;
-                                d = Object.assign(Object.assign({}, d), { [field.name]: m });
-                                autoincrement = Object.assign(Object.assign({}, autoincrement), { [key]: m });
+                        if (IsFieldDefault(field.default)) {
+                            const defaultValue = (0, defaults_1.default)(prop, field, data);
+                            if (defaultValue) {
+                                d = {
+                                    ...d,
+                                    [field.name]: defaultValue,
+                                };
                             }
                         }
                         else {
-                            d = Object.assign(Object.assign({}, d), { [field.name]: field.default });
+                            d = {
+                                ...d,
+                                [field.name]: field.default,
+                            };
                         }
                     }
+                    else if (field.isUpdatedAt) {
+                        d = {
+                            ...d,
+                            [field.name]: new Date(),
+                        };
+                    }
                     else {
                         if (field.kind !== "object") {
-                            d = Object.assign(Object.assign({}, d), { [field.name]: null });
+                            d = {
+                                ...d,
+                                [field.name]: null,
+                            };
                         }
                     }
                 }
@@ -310,8 +413,7 @@ const createPrismaMock = (data = {}, datamodel, client = (0, jest_mock_extended_
             return d;
         };
         const matchItem = (child, item, where) => {
-            var _a, _b;
-            const val = item[child];
+            let val = item[child];
             const filter = where[child];
             if (child === "OR") {
                 return matchOr(item, filter);
@@ -337,9 +439,9 @@ const createPrismaMock = (data = {}, datamodel, client = (0, jest_mock_extended_
                 }
             }
             else {
-                if (typeof filter === 'object') {
-                    const info = model.fields.find(field => field.name === child);
-                    if (info === null || info === void 0 ? void 0 : info.relationName) {
+                if (typeof filter === "object") {
+                    const info = model.fields.find((field) => field.name === child);
+                    if (info?.relationName) {
                         const childName = getCamelCase(info.type);
                         let childWhere = {};
                         if (filter.every) {
@@ -354,12 +456,15 @@ const createPrismaMock = (data = {}, datamodel, client = (0, jest_mock_extended_
                         else {
                             childWhere = filter;
                         }
-                        const submodel = datamodel.models.find(model => {
+                        const submodel = datamodel.models.find((model) => {
                             return getCamelCase(model.name) === childName;
                         });
                         const delegate = Delegate(getCamelCase(childName), submodel);
                         const res = delegate.findMany({
-                            where: Object.assign(Object.assign({}, childWhere), getFieldRelationshipWhere(item, info))
+                            where: {
+                                ...childWhere,
+                                ...getFieldRelationshipWhere(item, info),
+                            },
                         });
                         if (filter.every) {
                             if (res.length === 0)
@@ -368,7 +473,7 @@ const createPrismaMock = (data = {}, datamodel, client = (0, jest_mock_extended_
                             //   matchFnc(getFieldRelationshipWhere(item, info)),
                             // )
                             const all = delegate.findMany({
-                                where: getFieldRelationshipWhere(item, info)
+                                where: getFieldRelationshipWhere(item, info),
                             });
                             return res.length === all.length;
                         }
@@ -380,16 +485,16 @@ const createPrismaMock = (data = {}, datamodel, client = (0, jest_mock_extended_
                         }
                         return res.length > 0;
                     }
-                    const idFields = model.idFields || ((_a = model.primaryKey) === null || _a === void 0 ? void 0 : _a.fields);
-                    if ((idFields === null || idFields === void 0 ? void 0 : idFields.length) > 1) {
-                        if (child === idFields.join('_')) {
-                            return shallowCompare(item, filter);
+                    const idFields = model.idFields || model.primaryKey?.fields;
+                    if (idFields?.length > 1) {
+                        if (child === idFields.join("_")) {
+                            return (0, shallowCompare_1.shallowCompare)(item, filter);
                         }
                     }
-                    if (((_b = model.uniqueFields) === null || _b === void 0 ? void 0 : _b.length) > 0) {
+                    if (model.uniqueFields?.length > 0) {
                         for (const uniqueField of model.uniqueFields) {
-                            if (child === uniqueField.join('_')) {
-                                return shallowCompare(item, filter);
+                            if (child === uniqueField.join("_")) {
+                                return (0, shallowCompare_1.shallowCompare)(item, filter);
                             }
                         }
                     }
@@ -397,40 +502,53 @@ const createPrismaMock = (data = {}, datamodel, client = (0, jest_mock_extended_
                         return false;
                     }
                     let match = true;
-                    if ('equals' in filter && match) {
-                        match = filter.equals === val;
+                    const matchFilter = { ...filter };
+                    if (options.caseInsensitive) {
+                        val = val.toLowerCase ? val.toLowerCase() : val;
+                        Object.keys(matchFilter).forEach((key) => {
+                            const value = matchFilter[key];
+                            if (value.toLowerCase) {
+                                matchFilter[key] = value.toLowerCase();
+                            }
+                            else if (value instanceof Array) {
+                                matchFilter[key] = value.map((v) => v.toLowerCase ? v.toLowerCase() : v);
+                            }
+                        });
+                    }
+                    if ("equals" in matchFilter && match) {
+                        match = (0, deepEqual_1.deepEqual)(matchFilter.equals, val);
                     }
-                    if ('startsWith' in filter && match) {
-                        match = val.indexOf(filter.startsWith) === 0;
+                    if ("startsWith" in matchFilter && match) {
+                        match = val.indexOf(matchFilter.startsWith) === 0;
                     }
-                    if ('endsWith' in filter && match) {
+                    if ("endsWith" in matchFilter && match) {
                         match =
-                            val.indexOf(filter.endsWith) ===
-                                val.length - filter.endsWith.length;
+                            val.indexOf(matchFilter.endsWith) ===
+                                val.length - matchFilter.endsWith.length;
                     }
-                    if ('contains' in filter && match) {
-                        match = val.indexOf(filter.contains) > -1;
+                    if ("contains" in matchFilter && match) {
+                        match = val.indexOf(matchFilter.contains) > -1;
                     }
-                    if ('gt' in filter && match) {
-                        match = val > filter.gt;
+                    if ("gt" in matchFilter && match) {
+                        match = val > matchFilter.gt;
                     }
-                    if ('gte' in filter && match) {
-                        match = val >= filter.gte;
+                    if ("gte" in matchFilter && match) {
+                        match = val >= matchFilter.gte;
                     }
-                    if ('lt' in filter && match) {
-                        match = val < filter.lt;
+                    if ("lt" in matchFilter && match) {
+                        match = val < matchFilter.lt;
                     }
-                    if ('lte' in filter && match) {
-                        match = val <= filter.lte;
+                    if ("lte" in matchFilter && match) {
+                        match = val <= matchFilter.lte;
                     }
-                    if ('in' in filter && match) {
-                        match = filter.in.includes(val);
+                    if ("in" in matchFilter && match) {
+                        match = matchFilter.in.includes(val);
                     }
-                    if ('not' in filter && match) {
-                        match = val !== filter.not;
+                    if ("not" in matchFilter && match) {
+                        match = !(0, deepEqual_1.deepEqual)(matchFilter.not, val);
                     }
-                    if ('notIn' in filter && match) {
-                        match = !filter.notIn.includes(val);
+                    if ("notIn" in matchFilter && match) {
+                        match = !matchFilter.notIn.includes(val);
                     }
                     if (!match)
                         return false;
@@ -455,13 +573,13 @@ const createPrismaMock = (data = {}, datamodel, client = (0, jest_mock_extended_
         const matchOr = (item, where) => {
             return where.some((child) => matchItems(item, child));
         };
-        const matchFnc = where => item => {
+        const matchFnc = (where) => (item) => {
             if (where) {
                 return matchItems(item, where);
             }
             return true;
         };
-        const findOne = args => {
+        const findOne = (args) => {
             if (!data[prop])
                 return null;
             const items = findMany(args);
@@ -470,13 +588,13 @@ const createPrismaMock = (data = {}, datamodel, client = (0, jest_mock_extended_
             }
             return items[0];
         };
-        const findMany = args => {
-            let res = data[prop].filter(matchFnc(args === null || args === void 0 ? void 0 : args.where)).map(includes(args));
-            if (args === null || args === void 0 ? void 0 : args.distinct) {
+        const findMany = (args) => {
+            let res = data[prop].filter(matchFnc(args?.where)).map(includes(args));
+            if (args?.distinct) {
                 let values = {};
-                res = res.filter(item => {
+                res = res.filter((item) => {
                     let shouldInclude = true;
-                    args.distinct.forEach(key => {
+                    args.distinct.forEach((key) => {
                         const vals = values[key] || [];
                         if (vals.includes(item[key])) {
                             shouldInclude = false;
@@ -489,41 +607,50 @@ const createPrismaMock = (data = {}, datamodel, client = (0, jest_mock_extended_
                     return shouldInclude;
                 });
             }
-            if (args === null || args === void 0 ? void 0 : args.orderBy) {
-                res.sort(sortFunc(args === null || args === void 0 ? void 0 : args.orderBy));
+            if (args?.orderBy) {
+                res.sort(sortFunc(args?.orderBy));
             }
-            if (args === null || args === void 0 ? void 0 : args.select) {
-                res = res.map(item => {
+            if (args?.select) {
+                res = res.map((item) => {
                     const newItem = {};
-                    Object.keys(args.select).forEach(key => (newItem[key] = item[key]));
+                    Object.keys(args.select).forEach((key) => (newItem[key] = item[key]));
                     return newItem;
                 });
             }
-            if ((args === null || args === void 0 ? void 0 : args.skip) !== undefined || (args === null || args === void 0 ? void 0 : args.take) !== undefined) {
-                const start = (args === null || args === void 0 ? void 0 : args.skip) !== undefined ? args === null || args === void 0 ? void 0 : args.skip : 0;
-                const end = (args === null || args === void 0 ? void 0 : args.take) !== undefined ? start + args.take : undefined;
+            if (args?.skip !== undefined || args?.take !== undefined) {
+                const start = args?.skip !== undefined ? args?.skip : 0;
+                const end = args?.take !== undefined ? start + args.take : undefined;
                 res = res.slice(start, end);
             }
             return res;
         };
-        const updateMany = args => {
+        const updateMany = (args) => {
             // if (!Array.isArray(data[prop])) {
             //   throw new Error(`${prop} not found in data`)
             // }
-            const newItems = data[prop].map(e => {
+            const newItems = data[prop].map((e) => {
                 if (matchFnc(args.where)(e)) {
                     let data = nestedUpdate(args, false, e);
-                    return Object.assign(Object.assign({}, e), data);
+                    return {
+                        ...e,
+                        ...data,
+                    };
                 }
                 return e;
             });
-            data = Object.assign(Object.assign({}, data), { [prop]: newItems });
+            data = {
+                ...data,
+                [prop]: newItems,
+            };
             data = removeMultiFieldIds(model, data);
             return data;
         };
-        const create = args => {
+        const create = (args) => {
             const d = nestedUpdate(args, true, null);
-            data = Object.assign(Object.assign({}, data), { [prop]: [...data[prop], d] });
+            data = {
+                ...data,
+                [prop]: [...data[prop], d],
+            };
             data = removeMultiFieldIds(model, data);
             let where = {};
             for (const field of model.fields) {
@@ -531,23 +658,26 @@ const createPrismaMock = (data = {}, datamodel, client = (0, jest_mock_extended_
                     where[field.name] = d[field.name];
                 }
             }
-            return findOne(Object.assign({ where }, args));
+            return findOne({ where, ...args });
         };
-        const deleteMany = args => {
-            const model = datamodel.models.find(model => {
+        const deleteMany = (args) => {
+            const model = datamodel.models.find((model) => {
                 return getCamelCase(model.name) === prop;
             });
             const deleted = [];
-            data = Object.assign(Object.assign({}, data), { [prop]: data[prop].filter(e => {
-                    const shouldDelete = matchFnc(args === null || args === void 0 ? void 0 : args.where)(e);
+            data = {
+                ...data,
+                [prop]: data[prop].filter((e) => {
+                    const shouldDelete = matchFnc(args?.where)(e);
                     if (shouldDelete) {
                         deleted.push(e);
                     }
                     return !shouldDelete;
-                }) });
+                }),
+            };
             // Referential Actions
-            deleted.forEach(item => {
-                model.fields.forEach(field => {
+            deleted.forEach((item) => {
+                model.fields.forEach((field) => {
                     const joinfield = getJoinField(field);
                     if (!joinfield)
                         return;
@@ -559,65 +689,83 @@ const createPrismaMock = (data = {}, datamodel, client = (0, jest_mock_extended_
                             },
                             data: {
                                 [joinfield.relationFromFields[0]]: null,
-                            }
+                            },
                         });
                     }
                     else if (joinfield.relationOnDelete === "Cascade") {
                         delegate.delete({
                             where: {
                                 [joinfield.relationFromFields[0]]: item[joinfield.relationToFields[0]],
-                            }
+                            },
                         });
                     }
                 });
             });
             return deleted;
         };
-        const includes = args => item => {
-            if ((!(args === null || args === void 0 ? void 0 : args.include) && !(args === null || args === void 0 ? void 0 : args.select)) || !item)
+        const includes = (args) => (item) => {
+            if ((!args?.include && !args?.select) || !item)
                 return item;
             let newItem = item;
-            const obj = (args === null || args === void 0 ? void 0 : args.select) || (args === null || args === void 0 ? void 0 : args.include);
+            const obj = args?.select || args?.include;
             const keys = Object.keys(obj);
-            keys.forEach(key => {
+            keys.forEach((key) => {
                 // Get field schema for relation info
-                const model = datamodel.models.find(model => {
+                const model = datamodel.models.find((model) => {
                     return getCamelCase(model.name) === prop;
                 });
-                const schema = model.fields.find(field => {
+                const schema = model.fields.find((field) => {
                     return field.name === key;
                 });
-                if (!(schema === null || schema === void 0 ? void 0 : schema.relationName)) {
+                if (!schema?.relationName) {
                     return;
                 }
                 // Get delegate for relation
                 const delegate = Delegate(getCamelCase(schema.type), model);
                 // Construct arg for relation query
                 let subArgs = obj[key] === true ? {} : obj[key];
-                subArgs = Object.assign(Object.assign({}, subArgs), { where: Object.assign(Object.assign({}, subArgs.where), getFieldRelationshipWhere(item, schema)) });
+                subArgs = {
+                    ...subArgs,
+                    where: {
+                        ...subArgs.where,
+                        ...getFieldRelationshipWhere(item, schema),
+                    },
+                };
                 if (schema.isList) {
                     // Add relation
-                    newItem = Object.assign(Object.assign({}, newItem), { [key]: delegate.findMany(subArgs) });
+                    newItem = {
+                        ...newItem,
+                        [key]: delegate.findMany(subArgs),
+                    };
                 }
                 else {
-                    newItem = Object.assign(Object.assign({}, newItem), { [key]: delegate.findUnique(subArgs) });
+                    newItem = {
+                        ...newItem,
+                        [key]: delegate.findUnique(subArgs),
+                    };
                 }
             });
             return newItem;
         };
         const update = (args) => {
             let updatedItem;
-            const newItems = data[prop].map(e => {
+            const newItems = data[prop].map((e) => {
                 if (matchFnc(args.where)(e)) {
                     let data = nestedUpdate(args, false, e);
-                    updatedItem = Object.assign(Object.assign({}, e), data);
+                    updatedItem = {
+                        ...e,
+                        ...data,
+                    };
                     return updatedItem;
                 }
                 return e;
             });
-            data = Object.assign(Object.assign({}, data), { [prop]: newItems });
+            data = {
+                ...data,
+                [prop]: newItems,
+            };
             data = removeMultiFieldIds(model, data);
-            return findOne(Object.assign(Object.assign({}, args), { where: updatedItem }));
+            return findOne({ ...args, where: updatedItem });
         };
         return {
             findOne,
@@ -627,11 +775,20 @@ const createPrismaMock = (data = {}, datamodel, client = (0, jest_mock_extended_
             create,
             createMany: (args) => {
                 args.data.forEach((data) => {
-                    create(Object.assign(Object.assign({}, args), { data }));
+                    create({
+                        ...args,
+                        data,
+                    });
                 });
                 return findMany(args);
             },
-            delete: deleteMany,
+            delete: (args) => {
+                const deleted = deleteMany(args);
+                if (deleted.length) {
+                    return deleted[0];
+                }
+                return null;
+            },
             update,
             deleteMany,
             updateMany: (args) => {
@@ -641,10 +798,19 @@ const createPrismaMock = (data = {}, datamodel, client = (0, jest_mock_extended_
             upsert(args) {
                 const res = findOne(args);
                 if (res) {
-                    return update(Object.assign(Object.assign({}, args), { data: args.update }));
+                    return update({
+                        ...args,
+                        data: args.update,
+                    });
                 }
                 else {
-                    create(Object.assign(Object.assign({}, args), { data: Object.assign(Object.assign({}, args.where), args.create) }));
+                    create({
+                        ...args,
+                        data: {
+                            ...args.where,
+                            ...args.create,
+                        },
+                    });
                     return findOne(args);
                 }
             },
@@ -655,16 +821,19 @@ const createPrismaMock = (data = {}, datamodel, client = (0, jest_mock_extended_
             _sortFunc: sortFunc,
         };
     };
-    datamodel.models.forEach(model => {
+    datamodel.models.forEach((model) => {
         if (!model)
             return;
         const c = getCamelCase(model.name);
         if (!data[c]) {
-            data = Object.assign(Object.assign({}, (data || {})), { [c]: [] });
+            data = {
+                ...(data || {}),
+                [c]: [],
+            };
         }
         data = removeMultiFieldIds(model, data);
         const objs = Delegate(c, model);
-        Object.keys(objs).forEach(fncName => {
+        Object.keys(objs).forEach((fncName) => {
             if (fncName.indexOf("_") === 0)
                 return;
             client[c][fncName].mockImplementation(async (...params) => {

package/lib/utils/deepEqual.d.ts

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

package/lib/utils/deepEqual.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepEqual = void 0;
+// deepEqual
+function deepEqual(a, b) {
+    if ((typeof a == 'object' && a != null) &&
+        (typeof b == 'object' && b != null)) {
+        var count = [0, 0];
+        for (var key in a)
+            count[0]++;
+        for (var key in b)
+            count[1]++;
+        if (count[0] - count[1] != 0) {
+            return false;
+        }
+        for (var key in a) {
+            if (!(key in b) || !deepEqual(a[key], b[key])) {
+                return false;
+            }
+        }
+        for (var key in b) {
+            if (!(key in a) || !deepEqual(b[key], a[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return a === b;
+}
+exports.deepEqual = deepEqual;

package/lib/utils/shallowCompare.d.ts

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

package/lib/utils/shallowCompare.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shallowCompare = void 0;
+const shallowCompare = (a, b) => {
+    for (let key in b) {
+        if (a[key] !== b[key])
+            return false;
+    }
+    return true;
+};
+exports.shallowCompare = shallowCompare;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-mock",
-  "version": "0.1.8",
+  "version": "0.2.0",
   "description": "Mock prisma for unit testing database",
   "main": "lib/index.js",
   "repository": "https://github.com/demonsters/prisma-mock",
@@ -26,5 +26,8 @@
   },
   "peerDependencies": {
     "@prisma/client": "^3.5.0 || ^4.7.0"
+  },
+  "dependencies": {
+    "@paralleldrive/cuid2": "^2.0.0"
   }
 }