prisma-mock 0.10.0 → 0.11.0-alpha.2

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,6 +33,7 @@ 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;
 }
@@ -62,6 +63,7 @@ const createPrismaMock = (data = {}, datamodel = client_1.Prisma.dmmf.datamodel,
     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;
@@ -71,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) => {
@@ -335,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({
@@ -594,6 +600,7 @@ const createPrismaMock = (data = {}, datamodel = client_1.Prisma.dmmf.datamodel,
                         if (!joinWhere) {
                             return false;
                         }
+                        // return true
                         const res = delegate.findMany({
                             where: {
                                 AND: [
@@ -823,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) => {
@@ -886,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;
             });
@@ -913,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 = [];
@@ -951,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 {
@@ -1065,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,
@@ -1160,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,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function createIndexes() {
+    let items = new Map();
+    let indexedFieldNames = new Map();
+    let fields = new Map();
+    let idFieldNames = new Map();
+    const addIndexFieldIfNeeded = (tableName, field) => {
+        if (!indexedFieldNames.has(tableName)) {
+            indexedFieldNames.set(tableName, []);
+        }
+        if (!fields.has(tableName)) {
+            fields.set(tableName, new Map());
+        }
+        if (!idFieldNames.has(tableName)) {
+            idFieldNames.set(tableName, []);
+        }
+        let thisFields = fields.get(tableName);
+        let thisFieldNames = indexedFieldNames.get(tableName);
+        let thisIdFieldNames = idFieldNames.get(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.set(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.has(tableName)) {
+                if (indexedFieldNames.get(tableName).includes(field)) {
+                    return items.get(tableName)?.get(field)?.get(where[field]);
+                }
+            }
+        }
+    };
+    const updateItem = (tableName, item) => {
+        if (!items.has(tableName)) {
+            items.set(tableName, new Map());
+        }
+        if (!indexedFieldNames.has(tableName)) {
+            throw new Error(`No indexed fields for table ${tableName}`);
+        }
+        const tableItems = items.get(tableName);
+        for (const fieldName of indexedFieldNames.get(tableName)) {
+            if (!tableItems.has(fieldName)) {
+                tableItems.set(fieldName, new Map());
+            }
+            const thisItems = tableItems.get(fieldName);
+            if (!thisItems.has(item[fieldName])) {
+                thisItems.set(item[fieldName], [item]);
+            }
+            else {
+                const field = fields.get(tableName).get(fieldName);
+                if (field && (field.isId || field.isUnique)) {
+                    thisItems.set(item[fieldName], [item]);
+                }
+                else {
+                    const array = thisItems.get(item[fieldName]);
+                    if (array.length === 0) {
+                        array.push(item);
+                    }
+                    else {
+                        const thisIdFieldNames = idFieldNames.get(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.has(tableName)) {
+            if (indexedFieldNames.get(tableName).includes(field.name)) {
+                items.get(tableName)?.get(field.name)?.delete(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.10.0",
+  "version": "0.11.0-alpha.2",
   "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",