prisma-mock 0.0.0-20250808181135

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 De Monsters
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,344 @@
+# Prisma Mock
+
+A comprehensive mock of the Prisma API intended for unit testing. All data is stored in memory, providing fast and reliable test execution without external dependencies.
+
+The library uses `jest-mock-extended` or `vitest-mock-extended`, which means that if functionality you need is not implemented yet, you can mock it yourself.
+
+## Installation
+
+```bash
+npm install prisma-mock --save-dev
+# or
+yarn add prisma-mock --dev
+```
+
+## Usage
+
+### Basic Example
+
+Simple example of how to create a prisma mock instance:
+
+```js
+import createPrismaMock from "prisma-mock"
+
+let client
+
+beforeEach(() => {
+  client = createPrismaMock()
+})
+```
+
+### Mocking Global Prisma Instance
+
+Example of how to mock a global prisma instance, as the default export in a "db" directory (like BlitzJS):
+
+```js
+import createPrismaMock from "prisma-mock"
+import { mockDeep, mockReset } from "jest-mock-extended"
+
+jest.mock("db", () => ({
+  __esModule: true,
+  ...jest.requireActual("db"),
+  default: mockDeep(),
+}))
+
+import db, { Prisma } from "db"
+
+beforeEach(() => {
+  mockReset(db)
+  createPrismaMock({}, Prisma.dmmf.datamodel)
+})
+```
+
+### With Initial Data
+
+You can optionally start with pre-filled data:
+
+```js
+const client = createPrismaMock({
+  user: [
+    {
+      id: 1,
+      name: "John Doe",
+      accountId: 1,
+    },
+  ],
+  account: [
+    {
+      id: 1,
+      name: "Company",
+    },
+  ],
+})
+```
+
+## API
+
+```ts
+createPrismaMock(
+  data: PrismaMockData<P> = {},
+  datamodel?: Prisma.DMMF.Datamodel,
+  client = mockDeep<P>(),
+  options: {
+    caseInsensitive?: boolean
+    enableIndexes?: boolean
+  } = {}
+): Promise<P>
+```
+
+### Parameters
+
+#### `data` (optional)
+
+Initial mock data for the Prisma models. An object containing keys for tables and values as arrays of objects.
+
+#### `datamodel` (optional)
+
+The Prisma datamodel, typically `Prisma.dmmf.datamodel`. Defaults to the current Prisma client's datamodel.
+
+#### `client` (optional)
+
+A `jest-mock-extended` instance. If not provided, a new instance is created.
+
+#### `options` (optional)
+
+Configuration options for the mock client:
+
+- **`caseInsensitive`** (boolean, default: `false`): If true, all string comparisons are case insensitive
+- **`enableIndexes`** (boolean, default: `false`) Experimental: If true, enables indexing for better query performance on primary keys, unique fields, and foreign keys
+
+### Return Value
+
+Returns a mock Prisma client with all standard model methods plus:
+
+- `$getInternalState()`: Method to access the internal data state for testing/debugging
+
+## Supported Features
+
+### Model Queries ✅
+
+- `findUnique` / `findUniqueOrThrow`
+- `findMany`
+- `findFirst` / `findFirstOrThrow`
+- `create`
+- `createMany`
+- `delete`
+- `update`
+- `deleteMany`
+- `updateMany`
+- `upsert`
+- `count`
+- `aggregate`
+
+### Model Query Options ✅
+
+- `distinct`
+- `include`
+- `where`
+- `select`
+- `orderBy`
+- `select: _count`
+
+### Nested Queries ✅
+
+- `create`
+- `createMany`
+- `update`
+- `updateMany`
+- `delete`
+- `deleteMany`
+- `connect`
+- `disconnect`
+- `set`
+- `upsert`
+
+### Filter Conditions and Operators ✅
+
+- `equals`
+- `gt`, `gte`, `lt`, `lte`
+- `not`
+- `in`, `notIn`
+- `contains`, `startsWith`, `endsWith`
+- `AND`, `OR`, `NOT`
+- `mode` (for case-insensitive matching)
+
+### Relation Filters ✅
+
+- `some`
+- `every`
+- `none`
+
+### Atomic Number Operations ✅
+
+- `increment`
+- `decrement`
+- `multiply`
+- `divide`
+- `set`
+
+### JSON Filters ✅
+
+- `path`
+- `string_contains`
+- `string_starts_with`
+- `string_ends_with`
+- `array_contains`
+- `array_starts_with`
+- `array_ends_with`
+
+### Attributes ✅
+
+- `@@id` (Primary keys)
+- `@default` (Default values)
+- `@unique` (Unique constraints)
+- `@@unique` (Compound unique constraints)
+- `@relation` (Relationships)
+- `@updatedAt` (Partially supported - set at creation)
+
+### Attribute Functions ✅
+
+- `autoincrement()`
+- `cuid()`
+- `uuid()`
+- `now()`
+
+### Referential Actions ✅
+
+- `onDelete: SetNull`
+- `onDelete: Cascade`
+
+### Prisma Client Methods ✅
+
+- `$transaction` (Array of promises)
+- `$transaction` (Interactive transactions with rollback)
+- `$connect`
+- `$disconnect`
+
+## Not Yet Implemented
+
+The following features are planned but not yet implemented:
+
+### Model Queries
+
+- `groupBy`
+
+### Nested Queries
+
+- `connectOrCreate`
+
+### Filter Conditions
+
+- `search` (Full-text search)
+
+### Relation Filters
+
+- `is`
+
+### Scalar List Methods
+
+- `set`
+- `push`
+
+### Scalar List Filters
+
+- `has`
+- `hasEvery`
+- `hasSome`
+- `isEmpty`
+- `equals`
+
+### Attributes
+
+- `auto()`
+- `dbgenerated()`
+
+### Referential Actions
+
+- `onDelete: Restrict`
+- `onDelete: NoAction`
+- `onDelete: SetDefault`
+- `onUpdate` actions
+
+### Prisma Client Methods
+
+- `$transaction` (Isolation levels)
+- `$use` (Middleware)
+
+## Performance Features
+
+### Indexing (Experimental)
+
+Enable indexing for better query performance:
+
+```js
+const client = createPrismaMock({}, undefined, undefined, {
+  enableIndexes: true,
+})
+```
+
+When enabled, indexes are automatically created for:
+
+- Primary key fields
+- Unique fields
+- Foreign key fields
+
+This can significantly improve query performance for large datasets.
+
+## Error Handling
+
+The mock client throws appropriate Prisma errors with correct error codes:
+
+- `P2025`: Record not found (for `findUniqueOrThrow`, `findFirstOrThrow`)
+- `P2002`: Unique constraint violation
+- `P2003`: Foreign key constraint violation
+
+## Testing
+
+### Writing Tests
+
+Create your tests in the `__tests__` directory. You can use snapshot testing with either `expect(res).toMatchSnapshot()` or `expect(res).toMatchInlineSnapshot()`.
+
+**Note**: If you choose to use snapshot testing, make sure to first run your tests against the real database to create a snapshot of the expected result.
+
+### Running Tests
+
+To run tests against a PostgreSQL database:
+
+```bash
+yarn run test:postgres
+```
+
+To run tests against prisma-mock (in-memory database):
+
+```bash
+yarn test
+```
+
+## Development
+
+### Requirements
+
+Create a `.env-cmdrc` file in the root of your project with the following content:
+
+```json
+{
+  "postgres": {
+    "PROVIDER": "postgresql",
+    "DATABASE_URL": "postgresql://postgres:postgres@localhost:5432/postgres?schema=public"
+  }
+}
+```
+
+### Building
+
+```bash
+yarn build
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
+
+## License
+
+MIT

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 | BigInt;
+export declare function reset(): void;

package/lib/defaults/autoincrement.js

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

package/lib/defaults/cuid.d.ts

@@ -0,0 +1,3 @@
+declare const Cuid: () => string;
+export declare function ResetCuid(): void;
+export default Cuid;

package/lib/defaults/cuid.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pad_1 = __importDefault(require("../utils/pad"));
+// Format from: https://cuid.marcoonroad.dev/
+const createCuid = () => {
+    let ciud_cache = 0;
+    return () => {
+        ciud_cache++;
+        return `c00p6qup2${(0, pad_1.default)(String(ciud_cache), 4)}ckkzslahp5pn`;
+    };
+};
+exports.default = createCuid;

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,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const autoincrement_1 = __importDefault(require("./autoincrement"));
+const cuid_1 = __importDefault(require("./cuid"));
+const now_1 = __importDefault(require("./now"));
+const uuid_1 = __importDefault(require("./uuid"));
+function createHandleDefault() {
+    // const registry = new Map<string, (string, Prisma.DMMF.Field, PrismaMockData) => any>();
+    const registry = new Map();
+    registry.set("autoincrement", (0, autoincrement_1.default)());
+    registry.set("cuid", (0, cuid_1.default)());
+    registry.set("uuid", (0, uuid_1.default)());
+    registry.set("now", now_1.default);
+    registry.set("dbgenerated", (0, uuid_1.default)());
+    registry.set(`dbgenerated("gen_random_uuid()")`, (0, uuid_1.default)());
+    return (prop, field, ref) => {
+        const key = field.default.name;
+        const val = registry.get(key)?.(prop, field, ref.data);
+        return val;
+    };
+}
+exports.default = createHandleDefault;

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 createNow = () => new Date();
+exports.default = createNow;

package/lib/defaults/uuid.d.ts

@@ -0,0 +1,3 @@
+declare const Uuid: () => string;
+export declare function ResetUuid(): void;
+export default Uuid;

package/lib/defaults/uuid.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pad_1 = __importDefault(require("../utils/pad"));
+// https://en.wikipedia.org/wiki/Universally_unique_identifier
+const createUuid = () => {
+    let uuid_cache = 0;
+    return () => {
+        uuid_cache++;
+        return `123e4567-e89b-12d3-a456-${(0, pad_1.default)(String(uuid_cache), 12)}`;
+    };
+};
+exports.default = createUuid;