@pkgverse/prismock 2.0.1-beta.6 → 2.0.1-beta.8

package/README.md

@@ -1,7 +1,7 @@
 # prismock
 
 [![npm](https://img.shields.io/npm/v/@pkgverse/prismock)](https://www.npmjs.com/package/@pkgverse/prismock)
-[![npm](https://img.shields.io/npm/dm/@pkgverse/prismock)](https://www.npmjs.com/package/prismock)
+[![npm](https://img.shields.io/npm/dm/@pkgverse/prismock)](https://www.npmjs.com/package/@pkgverse/prismock)
 
 ## NOTE
 Originally forked from https://github.com/morintd/prismock. This library is awesome, and I felt it could use some modernization to work with newer versions of prisma and add support for
@@ -43,12 +43,11 @@ $ bun add -E -D @pkgverse/prismock
 # Usage
 
 ```ts
-import { Prisma, PrismaClient } from "${your_prisma_client_directory}"
+import { PrismaClient } from "${your_prisma_client_directory}"
 import { getClient } from 'prismock';
 
 // Pass in the Prisma namespace, and manually define the type of your prisma client
 let mockedClient = await getClient({
-  prismaModule: Prisma,
   prismaClient: PrismaClient,
   schemaPath: "prisma/schema.prisma",
 })
@@ -64,12 +63,10 @@ That's it, prisma will be mocked in all your tests (tested with ViTest)
 If you're using prisma with postgres, you can optionally choose to have the mocked prisma client use PgLite for more 'true-to-life' tests.
 
 ```ts
-import { Prisma, PrismaClient } from "${your_prisma_client_directory}"
+import { PrismaClient } from "${your_prisma_client_directory}"
 import { getClient } from 'prismock';
 
-// Pass in the Prisma namespace, and manually define the type of your prisma client
 let mockedClient = await getClient({
-  prismaModule: Prisma,
   prismaClient: PrismaClient,
   schemaPath: "prisma/schema.prisma",
   usePgLite: true,
@@ -100,7 +97,6 @@ vi.mock('@prisma/client', async () => {
   return {
     ...actual,
     PrismaClient: await actualPrismock.getClientClass({
-      prismaModule: actual.Prisma,
       prismaClient: actual.PrismaClient,
       schemaPath: "prisma/schema.prisma",
     }),
@@ -113,11 +109,10 @@ vi.mock('@prisma/client', async () => {
 You can instantiate a `PrismockClient` directly and use it in your test, or pass it to a test version of your app.
 
 ```ts
-import { Prisma, PrismaClient } from '${your_prisma_client_directory}';
+import { PrismaClient } from '${your_prisma_client_directory}';
 import { getClient } from 'prismock';
 
 const client = await getClient({
-  prismaModule: Prisma,
   PrismaClient,
   schemaPath: "prisma/schema.prisma",
 });

package/dist/index.d.ts

@@ -1,2 +1 @@
-export { generatePrismock, generatePrismockSync } from './lib/prismock';
-export { createPrismock, Prismock, type PrismaModule, PrismockClientType, getClient, getClientClass, getDefaultClient, getDefaultClientClass } from './lib/client';
+export { createPrismock, Prismock, PrismockClientType, getClient, getClientClass, getDefaultClient, getDefaultClientClass } from './lib/client';

package/dist/index.mjs

@@ -627,6 +627,10 @@ var require_src = __commonJS((exports, module) => {
   exports.isCuid = isCuid;
 });
 
+// src/lib/client.ts
+import * as path2 from "path";
+import * as fs from "fs";
+
 // src/lib/operations/aggregate.ts
 function aggregate(args, items) {
   const aggregated = {};
@@ -4869,9 +4873,63 @@ function generateDelegate(model, data, name, properties, delegates, onChange) {
   return delegate;
 }
 
-// src/lib/client.ts
-import * as path2 from "path";
-import * as fs from "fs";
+// src/lib/dmmf.ts
+import * as path from "path";
+var PrismaInternals = await import("@prisma/internals");
+var { getDMMF, getSchemaWithPath, getConfig } = PrismaInternals.default;
+async function generateDMMF(schemaPath) {
+  const pathToModule = schemaPath ?? __require.resolve(path.resolve(process.cwd(), "prisma/schema.prisma"));
+  const datamodel = await getSchemaWithPath(pathToModule);
+  return await getDMMF({ datamodel: datamodel.schemas });
+}
+
+// src/lib/prismock.ts
+function generateDelegates(options) {
+  const models = options.models ?? [];
+  const data = {};
+  const properties = {};
+  const delegates = {};
+  async function getData() {
+    return data;
+  }
+  async function setData(d) {
+    console.log('Deprecation notice: setData will be removed in a future version and should not be used anymore. Please use a mix of "reset" and create/createMany to achieve the same result');
+    Object.assign(data, d);
+    Object.assign(properties, Object.entries(d).reduce((accumulator, [currentKey]) => {
+      const model = models.find((m) => camelize(m.name) === currentKey);
+      return {
+        ...accumulator,
+        [currentKey]: {
+          increment: model.fields.reduce((propertiesAccumulator, currentField) => {
+            if (isAutoIncrement(currentField)) {
+              return { ...propertiesAccumulator, [currentField.name]: d[currentKey].length };
+            }
+            return propertiesAccumulator;
+          }, {})
+        }
+      };
+    }, {}));
+  }
+  models.forEach((model) => {
+    const name = camelize(model.name);
+    data[name] = [];
+    properties[name] = {
+      increment: {}
+    };
+    Object.assign(delegates, {
+      [name]: generateDelegate(model, data, name, properties, delegates, (items) => {
+        Object.assign(data, { [name]: items });
+      })
+    });
+  }, {});
+  const clientDelegates = Object.entries(delegates).reduce((accumulator, [delegateKey, delegateValue]) => {
+    return {
+      ...accumulator,
+      [delegateKey]: omit(delegateValue, ["model", "properties", "getItems"])
+    };
+  }, {});
+  return { delegates: clientDelegates, getData, setData };
+}
 
 // src/lib/extensions/model.ts
 function applyModelExtensions(client, extensions) {
@@ -5159,36 +5217,33 @@ function applyExtensions(client, extensions) {
   return modelExtended;
 }
 
-// src/lib/dmmf.ts
-import * as path from "path";
-var PrismaInternals = await import("@prisma/internals");
-var { getDMMF, getSchemaWithPath, getConfig } = PrismaInternals.default;
-async function generateDMMF(schemaPath) {
-  const pathToModule = schemaPath ?? __require.resolve(path.resolve(process.cwd(), "prisma/schema.prisma"));
-  const datamodel = await getSchemaWithPath(pathToModule);
-  return await getDMMF({ datamodel: datamodel.schemas });
-}
-
 // src/lib/client.ts
 class Prismock {
-  __prismaModule;
-  constructor(prismaModule) {
-    this.__prismaModule = prismaModule;
-    this.generate();
-  }
-  static async create(prismaModule) {
-    return new Prismock(prismaModule);
-  }
-  static async createDefault() {
-    const { Prisma: Prisma2, PrismaClient } = await import("@prisma/client");
-    return new Prismock(Prisma2);
-  }
-  reset() {
-    this.generate();
-  }
-  generate() {
+  schemaPath;
+  genPromise;
+  constructor(schemaPath) {
+    this.schemaPath = schemaPath;
+    this.genPromise = this.generate();
+  }
+  static async create(schemaPath) {
+    const p = new Prismock(schemaPath);
+    await p.genPromise;
+    return p;
+  }
+  static async createDefault(schemaPath) {
+    const p = new Prismock(schemaPath);
+    await p.genPromise;
+    return p;
+  }
+  async reset() {
+    await this.generate();
+  }
+  async generate() {
+    const datamodel = await generateDMMF(this.schemaPath);
     const { delegates, setData, getData } = generateDelegates({
-      models: this.__prismaModule.dmmf.datamodel.models
+      models: [
+        ...datamodel.datamodel.models
+      ]
     });
     Object.entries({ ...delegates, setData, getData }).forEach(([key, value]) => {
       if (key in this)
@@ -5198,7 +5253,8 @@ class Prismock {
     });
   }
   async $connect() {
-    return Promise.resolve();
+    await this.genPromise;
+    return this;
   }
   $disconnect() {
     return Promise.resolve();
@@ -5229,31 +5285,6 @@ class Prismock {
     return args(this);
   }
 }
-function generateClient(delegates, getData, setData) {
-  console.log("Deprecation notice: generatePrismock and generatePrismockSync should be replaced with PrismockClient. See https://github.com/morintd/prismock/blob/master/docs/generate-prismock-deprecated.md");
-  const client = {
-    $connect: () => Promise.resolve(),
-    $disconnect: () => Promise.resolve(),
-    $on: () => {},
-    $use: () => {},
-    $executeRaw: () => Promise.resolve(0),
-    $executeRawUnsafe: () => Promise.resolve(0),
-    $queryRaw: () => Promise.resolve([]),
-    $queryRawUnsafe: () => Promise.resolve([]),
-    getData,
-    setData,
-    ...delegates
-  };
-  return {
-    ...client,
-    $transaction: async (args) => {
-      if (Array.isArray(args)) {
-        return Promise.all(args);
-      }
-      return args(client);
-    }
-  };
-}
 function getPgLitePrismockData(options) {
   const schemaPathDir = path2.dirname(options.schemaPath);
   const migrationsPath = path2.join(schemaPathDir, "migrations");
@@ -5333,7 +5364,7 @@ async function getClient(options) {
     await prismockData.reset();
     return Object.assign(prisma2, prismockData);
   }
-  return await Prismock.create(options.prismaModule);
+  return await Prismock.create(options.schemaPath);
 }
 async function getClientClass(options) {
   const datamodel = await generateDMMF(options.schemaPath);
@@ -5385,93 +5416,33 @@ async function getClientClass(options) {
 
   class PrismaClientMocked extends Prismock {
     constructor() {
-      super(options.prismaModule);
+      super(options.schemaPath);
     }
   }
   return PrismaClientMocked;
 }
 async function getDefaultClient() {
-  const { Prisma: Prisma2, PrismaClient } = await import("@prisma/client");
+  const { PrismaClient } = await import("@prisma/client");
   return await getClient({
-    prismaModule: Prisma2,
     prismaClient: PrismaClient,
     schemaPath: "./prisma/schema.prisma",
     usePgLite: process.env.PRISMOCK_USE_PG_LITE ? true : undefined
   });
 }
 async function getDefaultClientClass() {
-  const { Prisma: Prisma2, PrismaClient } = await import("@prisma/client");
+  const { PrismaClient } = await import("@prisma/client");
   return await getClientClass({
-    prismaModule: Prisma2,
     PrismaClient,
     schemaPath: "./prisma/schema.prisma",
     usePgLite: process.env.PRISMOCK_USE_PG_LITE ? true : undefined
   });
 }
 var createPrismock = getDefaultClient;
-
-// src/lib/prismock.ts
-async function generatePrismock(options = {}) {
-  const schema = await generateDMMF(options.schemaPath);
-  return generatePrismockSync({ models: schema.datamodel.models });
-}
-function generatePrismockSync(options) {
-  const { delegates, getData, setData } = generateDelegates(options);
-  return generateClient(delegates, getData, setData);
-}
-function generateDelegates(options) {
-  const models = options.models ?? [];
-  const data = {};
-  const properties = {};
-  const delegates = {};
-  async function getData() {
-    return data;
-  }
-  async function setData(d) {
-    console.log('Deprecation notice: setData will be removed in a future version and should not be used anymore. Please use a mix of "reset" and create/createMany to achieve the same result');
-    Object.assign(data, d);
-    Object.assign(properties, Object.entries(d).reduce((accumulator, [currentKey]) => {
-      const model = models.find((m) => camelize(m.name) === currentKey);
-      return {
-        ...accumulator,
-        [currentKey]: {
-          increment: model.fields.reduce((propertiesAccumulator, currentField) => {
-            if (isAutoIncrement(currentField)) {
-              return { ...propertiesAccumulator, [currentField.name]: d[currentKey].length };
-            }
-            return propertiesAccumulator;
-          }, {})
-        }
-      };
-    }, {}));
-  }
-  models.forEach((model) => {
-    const name = camelize(model.name);
-    data[name] = [];
-    properties[name] = {
-      increment: {}
-    };
-    Object.assign(delegates, {
-      [name]: generateDelegate(model, data, name, properties, delegates, (items) => {
-        Object.assign(data, { [name]: items });
-      })
-    });
-  }, {});
-  const clientDelegates = Object.entries(delegates).reduce((accumulator, [delegateKey, delegateValue]) => {
-    return {
-      ...accumulator,
-      [delegateKey]: omit(delegateValue, ["model", "properties", "getItems"])
-    };
-  }, {});
-  return { delegates: clientDelegates, getData, setData };
-}
 export {
   getDefaultClientClass,
   getDefaultClient,
   getClientClass,
   getClient,
-  generatePrismockSync,
-  generatePrismock,
   createPrismock,
   Prismock
 };

package/dist/lib/client.d.ts

@@ -1,7 +1,6 @@
 import type { PrismaClient } from "@prisma/client";
 import type { DMMF } from "@prisma/generator-helper";
 import type * as runtime from "@prisma/client/runtime/library";
-import type { Delegate } from "./delegate";
 import { Data } from "./prismock";
 import { type ExtensionsDefinition } from "./extensions";
 import type { PGlite } from "@electric-sql/pglite";
@@ -19,14 +18,15 @@ export type PrismockOptions = {
         schemaPath: string;
     };
 };
-export declare class Prismock<PC = PrismaClient> {
-    __prismaModule: PrismaModule<PC>;
-    protected constructor(prismaModule: PrismaModule<PC>);
-    static create<PC = PrismaClient>(prismaModule: PrismaModule<PC>): Promise<PrismockClientType<PC>>;
-    static createDefault(): Promise<PrismaClient<import(".prisma").Prisma.PrismaClientOptions, never, runtime.DefaultArgs> & PrismockData>;
-    reset(): void;
+export declare class Prismock {
+    schemaPath: string;
+    private genPromise;
+    protected constructor(schemaPath: string);
+    static create<PC = PrismaClient>(schemaPath: string): Promise<PrismockClientType<PC>>;
+    static createDefault(schemaPath: string): Promise<PrismaClient<import(".prisma").Prisma.PrismaClientOptions, never, runtime.DefaultArgs> & PrismockData>;
+    reset(): Promise<void>;
     private generate;
-    $connect(): Promise<void>;
+    $connect(): Promise<this>;
     $disconnect(): Promise<void>;
     $on(): void;
     $use(): this;
@@ -37,10 +37,6 @@ export declare class Prismock<PC = PrismaClient> {
     $extends(extensionDefs: ExtensionsDefinition): PrismaClient<import(".prisma").Prisma.PrismaClientOptions, never, runtime.DefaultArgs>;
     $transaction(args: any): Promise<any>;
 }
-export declare function generateClient<T = PrismaClient>(delegates: Record<string, Delegate>, getData: GetData, setData: SetData): PrismockClientType<T>;
-export type PrismaModule<PC = PrismaClient> = {
-    dmmf: runtime.BaseDMMF;
-};
 export declare function getPgLitePrismockData(options: {
     schemaPath: string;
     pglite: InstanceType<typeof PGlite>;
@@ -53,7 +49,6 @@ export declare function getPgLitePrismockData(options: {
     setData: (data: Data) => Promise<void>;
 };
 type GetClientOptions<PrismaClientClassType extends new (...args: any[]) => any> = {
-    prismaModule: PrismaModule<InstanceType<PrismaClientClassType>>;
     prismaClient: PrismaClientClassType;
     schemaPath: string;
     usePgLite?: boolean | null | undefined;
@@ -62,7 +57,6 @@ export declare function getClient<PrismaClientType extends new (options: {
     adapter?: runtime.SqlDriverAdapterFactory | null;
 }, ...args: any[]) => any>(options: GetClientOptions<PrismaClientType>): Promise<PrismockClientType<InstanceType<PrismaClientType>>>;
 type GetClientClassOptions<PrismaClientClassType extends new (...args: any[]) => any> = {
-    prismaModule: PrismaModule<InstanceType<PrismaClientClassType>>;
     PrismaClient: PrismaClientClassType;
     schemaPath: string;
     usePgLite?: boolean | null | undefined;

package/dist/lib/prismock.d.ts

@@ -1,21 +1,15 @@
-import { PrismaClient } from '@prisma/client';
-import { DMMF, type ActiveConnectorType } from '@prisma/generator-helper';
+import { type ActiveConnectorType } from '@prisma/generator-helper';
 import type { Generator } from '@prisma/internals';
 import { Delegate, DelegateProperties, Item } from './delegate';
-import { PrismockClientType } from './client';
-type Options = {
-    schemaPath?: string;
-};
+import type { Model } from "@prisma/dmmf";
 type OptionsSync = {
-    models: DMMF.Model[];
+    models: Model[];
 };
 export type Data = Record<string, Item[]>;
 export type Properties = Record<string, DelegateProperties>;
 export type Delegates = Record<string, Delegate>;
 export declare function fetchProvider(schemaPath?: string): Promise<ActiveConnectorType>;
 export declare function getProvider(generator: Generator): ActiveConnectorType | undefined;
-export declare function generatePrismock<T = PrismaClient>(options?: Options): Promise<PrismockClientType<T>>;
-export declare function generatePrismockSync<T = PrismockClientType>(options: OptionsSync): PrismockClientType<T>;
 export declare function generateDelegates(options: OptionsSync): {
     delegates: Delegates;
     getData: () => Promise<Data>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pkgverse/prismock",
-  "version": "2.0.1-beta.6",
+  "version": "2.0.1-beta.8",
   "description": "A mock for PrismaClient, dedicated to unit testing.",
   "repository": {
     "url": "https://github.com/JQuezada0/prismock"
@@ -44,6 +44,7 @@
     "@commitlint/cli": "19.8.1",
     "@commitlint/config-conventional": "19.8.1",
     "@prisma/client": "6.12.0",
+    "@prisma/dmmf": "6.12.0",
     "@semantic-release/changelog": "6.0.3",
     "@semantic-release/commit-analyzer": "13.0.1",
     "@semantic-release/git": "10.0.1",