prisma-mock 0.9.3 → 0.11.0-alpha.1

package/README.md

@@ -188,7 +188,7 @@ TODO (has, hasEvery, hasSome, isEmpty, equals)
 
 - @@id
 - @default
-- @unique (TODO: no error if duplicate)
+- @unique
 - @@unique (TODO: no error if duplicate)
 - @relation
 - @updatedAt: Partially supported, value is set at creation (TODO: update value on update)

package/lib/index.js

@@ -33,11 +33,11 @@ const shallowCompare_1 = require("./utils/shallowCompare");
 const deepEqual_1 = require("./utils/deepEqual");
 const deepCopy_1 = require("./utils/deepCopy");
 const getNestedValue_1 = __importDefault(require("./utils/getNestedValue"));
+const indexes_1 = __importDefault(require("./indexes"));
 function IsFieldDefault(f) {
     return f.name !== undefined;
 }
-const throwKnownError = (message, cause) => {
-    const code = "P2025";
+const throwKnownError = (message, { code = "P2025", meta } = {}) => {
     const clientVersion = client_1.Prisma.prismaVersion.client;
     // PrismaClientKnownRequestError prototype changed in version 4.7.0
     // from: constructor(message: string, code: string, clientVersion: string, meta?: any)
@@ -56,15 +56,14 @@ const throwKnownError = (message, cause) => {
         // @ts-ignore
         clientVersion);
     }
-    error.meta = {
-        cause,
-    };
+    error.meta = meta;
     throw error;
 };
 const createPrismaMock = (data = {}, datamodel = client_1.Prisma.dmmf.datamodel, client = (0, jest_mock_extended_1.mockDeep)(), options = {
     caseInsensitive: false,
 }) => {
     const manyToManyData = {};
+    const indexes = (0, indexes_1.default)();
     // let data = options.data || {}
     // const datamodel = options.datamodel || Prisma.dmmf.datamodel
     const caseInsensitive = options.caseInsensitive || false;
@@ -74,6 +73,7 @@ const createPrismaMock = (data = {}, datamodel = client_1.Prisma.dmmf.datamodel,
         return name.substr(0, 1).toLowerCase() + name.substr(1);
     };
     const removeMultiFieldIds = (model, data) => {
+        /// [tableName][field][value] = Array
         const c = getCamelCase(model.name);
         const idFields = model.idFields || model.primaryKey?.fields;
         const removeId = (ids) => {
@@ -150,8 +150,9 @@ const createPrismaMock = (data = {}, datamodel = client_1.Prisma.dmmf.datamodel,
             try {
                 return await actions(client);
             }
-            catch {
+            catch (error) {
                 data = snapshot;
+                throw error;
             }
         }
     });
@@ -232,6 +233,12 @@ const createPrismaMock = (data = {}, datamodel = client_1.Prisma.dmmf.datamodel,
             model.fields.forEach((field) => {
                 if (d[field.name]) {
                     const c = d[field.name];
+                    if (isCreating && (field.isUnique || field.isId)) {
+                        const existing = findOne({ where: { [field.name]: c } });
+                        if (existing) {
+                            throwKnownError(`Unique constraint failed on the fields: (\`${field.name}\`)`, { code: 'P2002', meta: { target: [field.name] } });
+                        }
+                    }
                     if (field.kind === "object") {
                         if (c.set) {
                             const { [field.name]: { set }, ...rest } = d;
@@ -331,11 +338,14 @@ const createPrismaMock = (data = {}, datamodel = client_1.Prisma.dmmf.datamodel,
                             });
                         }
                         if (c.create || c.createMany) {
+                            const otherModel = datamodel.models.find((model) => {
+                                return model.name === field.type;
+                            });
                             const { [field.name]: create, ...rest } = d;
                             d = rest;
                             // @ts-ignore
                             const name = getCamelCase(field.type);
-                            const delegate = Delegate(name, model);
+                            const delegate = Delegate(name, otherModel);
                             const joinfield = getJoinField(field);
                             if (field.relationFromFields.length > 0) {
                                 const item = delegate.create({
@@ -548,13 +558,7 @@ const createPrismaMock = (data = {}, datamodel = client_1.Prisma.dmmf.datamodel,
                 return matchAnd(item, filter);
             }
             if (child === "NOT") {
-                if (Array.isArray(filter)) {
-                    return !matchOr(item, filter);
-                }
-                item; //?
-                filter; //?
-                matchItems(item, filter); //?
-                return !matchItems(item, filter);
+                return matchNot(item, filter);
             }
             if (filter == null || filter === undefined) {
                 if (filter === null) {
@@ -596,6 +600,7 @@ const createPrismaMock = (data = {}, datamodel = client_1.Prisma.dmmf.datamodel,
                         if (!joinWhere) {
                             return false;
                         }
+                        // return true
                         const res = delegate.findMany({
                             where: {
                                 AND: [
@@ -642,6 +647,9 @@ const createPrismaMock = (data = {}, datamodel = client_1.Prisma.dmmf.datamodel,
                     if (val === undefined) {
                         return false;
                     }
+                    if (val === null) {
+                        return false;
+                    }
                     let match = true;
                     const matchFilter = { ...filter };
                     if (caseInsensitive ||
@@ -766,6 +774,33 @@ const createPrismaMock = (data = {}, datamodel = client_1.Prisma.dmmf.datamodel,
             }
             return true;
         };
+        const matchNot = (item, where) => {
+            if (Array.isArray(where)) {
+                let hasNull = false;
+                let res = !where.some((w) => {
+                    for (let child in w) {
+                        if (item[child] === null) {
+                            hasNull = true;
+                            return false;
+                        }
+                        if (matchItem(child, item, w)) {
+                            return true;
+                        }
+                    }
+                    return false;
+                });
+                return hasNull ? caseInsensitive : res;
+            }
+            for (let child in where) {
+                if (item[child] === null) {
+                    return false;
+                }
+                if (!matchItem(child, item, where)) {
+                    return true;
+                }
+            }
+            return false;
+        };
         const matchAnd = (item, where) => {
             return where.filter((child) => matchItems(item, child)).length === where.length;
         };
@@ -795,9 +830,19 @@ const createPrismaMock = (data = {}, datamodel = client_1.Prisma.dmmf.datamodel,
             return found;
         };
         const findMany = (args) => {
-            let res = data[prop]
-                .filter(matchFnc(args?.where))
-                .map(includes(args));
+            const match = matchFnc(args?.where);
+            const inc = includes(args);
+            // let res = data[prop]
+            //   .filter(matchFnc(args?.where))
+            //   .map(includes(args))
+            let items = indexes.getIndexedItems(prop, args?.where) || data[prop];
+            let res = [];
+            for (const item of items) {
+                if (match(item)) {
+                    const i = inc(item);
+                    res.push(i);
+                }
+            }
             if (args?.distinct) {
                 let values = {};
                 res = res.filter((item) => {
@@ -858,10 +903,12 @@ const createPrismaMock = (data = {}, datamodel = client_1.Prisma.dmmf.datamodel,
                 if (matchFnc(args.where)(e)) {
                     let data = nestedUpdate(args, false, e);
                     nbUpdated++;
-                    return {
+                    const newItem = {
                         ...e,
                         ...data,
                     };
+                    indexes.updateItem(prop, newItem);
+                    return newItem;
                 }
                 return e;
             });
@@ -885,7 +932,9 @@ const createPrismaMock = (data = {}, datamodel = client_1.Prisma.dmmf.datamodel,
                     where[field.name] = d[field.name];
                 }
             }
-            return findOne({ where, ...args });
+            const item = findOne({ where, ...args });
+            indexes.updateItem(prop, item);
+            return item;
         };
         const createMany = (args) => {
             const createdItems = [];
@@ -923,19 +972,23 @@ const createPrismaMock = (data = {}, datamodel = client_1.Prisma.dmmf.datamodel,
             // Referential Actions
             deleted.forEach((item) => {
                 model.fields.forEach((field) => {
+                    indexes.deleteItemByField(prop, field, item);
                     const joinfield = getJoinField(field);
                     if (!joinfield)
                         return;
                     const delegate = Delegate(getCamelCase(field.type), model);
                     if (joinfield.relationOnDelete === "SetNull") {
-                        delegate.update({
-                            where: {
-                                [joinfield.relationFromFields[0]]: item[joinfield.relationToFields[0]],
-                            },
-                            data: {
-                                [joinfield.relationFromFields[0]]: null,
-                            },
-                        });
+                        try {
+                            delegate.update({
+                                where: {
+                                    [joinfield.relationFromFields[0]]: item[joinfield.relationToFields[0]],
+                                },
+                                data: {
+                                    [joinfield.relationFromFields[0]]: null,
+                                },
+                            });
+                        }
+                        catch (e) { }
                     }
                     else if (joinfield.relationOnDelete === "Cascade") {
                         try {
@@ -1037,18 +1090,24 @@ const createPrismaMock = (data = {}, datamodel = client_1.Prisma.dmmf.datamodel,
         };
         const update = (args) => {
             let updatedItem;
+            let hasMatch = false;
+            const match = matchFnc(args.where);
             const newItems = data[prop].map((e) => {
-                if (matchFnc(args.where)(e)) {
+                if (match(e)) {
+                    hasMatch = true;
                     let data = nestedUpdate(args, false, e);
-                    data; //?
                     updatedItem = {
                         ...e,
                         ...data,
                     };
+                    indexes.updateItem(prop, updatedItem);
                     return updatedItem;
                 }
                 return e;
             });
+            if (!hasMatch) {
+                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." } });
+            }
             data = {
                 ...data,
                 [prop]: newItems,
@@ -1076,7 +1135,7 @@ const createPrismaMock = (data = {}, datamodel = client_1.Prisma.dmmf.datamodel,
             delete: (args) => {
                 const item = findOne(args);
                 if (!item) {
-                    throwKnownError("An operation failed because it depends on one or more records that were required but not found. Record to delete does not exist.", "Record to delete does not exist.");
+                    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." } });
                 }
                 const deleted = deleteMany(args);
                 if (deleted.length) {
@@ -1132,6 +1191,12 @@ const createPrismaMock = (data = {}, datamodel = client_1.Prisma.dmmf.datamodel,
             };
         }
         data = removeMultiFieldIds(model, data);
+        model.fields.forEach((field) => {
+            indexes.addIndexFieldIfNeeded(c, field);
+        });
+        data[c].forEach((item) => {
+            indexes.updateItem(c, item);
+        });
         const objs = Delegate(c, model);
         Object.keys(objs).forEach((fncName) => {
             if (fncName.indexOf("_") === 0)

package/lib/indexes.d.ts

@@ -0,0 +1,7 @@
+import { Prisma } from "@prisma/client";
+export default function createIndexes(): {
+    addIndexFieldIfNeeded: (tableName: string, field: Prisma.DMMF.Field) => void;
+    getIndexedItems: (tableName: string, where: any) => any;
+    updateItem: (tableName: string, item: any) => void;
+    deleteItemByField: (tableName: string, field: Prisma.DMMF.Field, item: any) => void;
+};

package/lib/indexes.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function createIndexes() {
+    let items = {};
+    let indexedFieldNames = {};
+    let fields = {};
+    let idFieldNames = {};
+    const addIndexFieldIfNeeded = (tableName, field) => {
+        if (!indexedFieldNames[tableName]) {
+            indexedFieldNames[tableName] = [];
+        }
+        if (!fields[tableName]) {
+            fields[tableName] = {};
+        }
+        if (!idFieldNames[tableName]) {
+            idFieldNames[tableName] = [];
+        }
+        let thisFields = fields[tableName];
+        let thisFieldNames = indexedFieldNames[tableName];
+        let thisIdFieldNames = idFieldNames[tableName];
+        if (thisFieldNames.includes(field.name))
+            return;
+        if (field.isId || field.isUnique) {
+            thisFieldNames.push(field.name);
+        }
+        if (field.isId) {
+            thisIdFieldNames.push(field.name);
+        }
+        if (!!field.relationFromFields?.length) {
+            const fieldName = field.relationFromFields[0];
+            thisFieldNames.push(fieldName);
+        }
+        thisFields[field.name] = field;
+    };
+    const getIndexedItems = (tableName, where) => {
+        for (const field in where) {
+            if (field === "AND") {
+                const subWhere = where.AND;
+                if (Array.isArray(subWhere)) {
+                    for (const subWhereItem of subWhere) {
+                        const items = getIndexedItems(tableName, subWhereItem);
+                        if (items) {
+                            return items;
+                        }
+                    }
+                }
+            }
+            if (indexedFieldNames[tableName]) {
+                if (indexedFieldNames[tableName].includes(field)) {
+                    return items[tableName]?.[field]?.[where[field]];
+                }
+            }
+        }
+    };
+    const updateItem = (tableName, item) => {
+        if (!items[tableName]) {
+            items[tableName] = {};
+        }
+        if (!indexedFieldNames[tableName]) {
+            throw new Error(`No indexed fields for table ${tableName}`);
+        }
+        for (const fieldName of indexedFieldNames[tableName]) {
+            if (!items[tableName][fieldName]) {
+                items[tableName][fieldName] = {};
+            }
+            if (!items[tableName][fieldName][item[fieldName]]) {
+                items[tableName][fieldName][item[fieldName]] = [item];
+            }
+            else {
+                const field = fields[tableName][fieldName];
+                if (field && (field.isId || field.isUnique)) {
+                    items[tableName][fieldName][item[fieldName]] = [item];
+                }
+                else {
+                    const array = items[tableName][fieldName][item[fieldName]];
+                    if (array.length === 0) {
+                        array.push(item);
+                    }
+                    else {
+                        const thisIdFieldNames = idFieldNames[tableName] || [];
+                        let hasFound = false;
+                        for (let i = 0; i < array.length; i++) {
+                            const oldItem = array[i];
+                            for (const thisIdFieldName of thisIdFieldNames) {
+                                if (item[thisIdFieldName] === oldItem[thisIdFieldName]) {
+                                    hasFound = true;
+                                    array[i] = item;
+                                    return;
+                                }
+                            }
+                        }
+                        if (!hasFound) {
+                            array.push(item);
+                        }
+                    }
+                }
+            }
+        }
+    };
+    const deleteItemByField = (tableName, field, item) => {
+        if (indexedFieldNames[tableName]) {
+            if (indexedFieldNames[tableName].includes(field.name)) {
+                delete items[tableName]?.[field.name]?.[item[field.name]];
+            }
+        }
+    };
+    return {
+        addIndexFieldIfNeeded,
+        getIndexedItems,
+        updateItem,
+        deleteItemByField
+    };
+}
+exports.default = createIndexes;

package/lib/indexes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/indexes.test.js

@@ -0,0 +1,52 @@
+"use strict";
+// @ts-nocheck
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const indexes_1 = __importDefault(require("./indexes"));
+test("createIndexes", () => {
+    const indexes = (0, indexes_1.default)();
+    indexes.addIndexFieldIfNeeded("User", {
+        name: "id",
+        isId: true
+    });
+    indexes.addIndexFieldIfNeeded("User", {
+        name: "account",
+        relationFromFields: ["accountId"]
+    });
+    indexes.updateItem("User", {
+        id: 1,
+        name: "Alice",
+        accountId: 1
+    });
+    const items1 = indexes.getIndexedItems("User", {
+        accountId: 1
+    });
+    expect(items1).toMatchInlineSnapshot(`
+Array [
+  Object {
+    "accountId": 1,
+    "id": 1,
+    "name": "Alice",
+  },
+]
+`);
+    indexes.updateItem("User", {
+        id: 1,
+        name: "Alice 2",
+        accountId: 1
+    });
+    const items2 = indexes.getIndexedItems("User", {
+        accountId: 1
+    });
+    expect(items2).toMatchInlineSnapshot(`
+Array [
+  Object {
+    "accountId": 1,
+    "id": 1,
+    "name": "Alice 2",
+  },
+]
+`);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-mock",
-  "version": "0.9.3",
+  "version": "0.11.0-alpha.1",
   "description": "Mock prisma for unit testing database",
   "main": "lib/index.js",
   "repository": "https://github.com/demonsters/prisma-mock",
@@ -21,7 +21,7 @@
     "uuid": "^9.0.0"
   },
   "scripts": {
-    "preversion": "tsc",
+    "preversion": "jest && tsc",
     "build": "tsc",
     "test": "jest",
     "watch": "tsc --watch",