@pkgverse/prismock 2.0.5-beta.0 → 2.0.5-beta.1

package/dist/lib/client.d.ts

@@ -5,6 +5,7 @@ import { Data } from "./prismock";
 import { type ExtensionsDefinition } from "./extensions";
 import type { PGlite } from "@electric-sql/pglite";
 import type { PrismaPGlite } from "pglite-prisma-adapter";
+import { type PrismaDMMF } from "./globals";
 type GetData = () => Promise<Data>;
 type SetData = (data: Data) => Promise<void>;
 export interface PrismockData {
@@ -20,6 +21,8 @@ export type PrismockOptions = {
 };
 export declare class Prismock {
     schemaPath: string;
+    datamodel?: DMMF.Document;
+    PrismaDMMF?: PrismaDMMF;
     private genPromise;
     protected constructor(schemaPath: string);
     static create<PC = PrismaClient>(schemaPath: string): Promise<PrismockClientType<PC>>;

package/dist/lib/delegate.d.ts

@@ -1,4 +1,4 @@
-import { DMMF } from '@prisma/generator-helper';
+import type { DMMF } from '@prisma/generator-helper';
 import { CreateArgs, CreateManyArgs, FindArgs, GroupByArgs, UpsertArgs } from './types';
 import { DeleteArgs, UpdateArgs } from './operations';
 import { Data, Delegates, Properties } from './prismock';
@@ -39,4 +39,4 @@ export type DelegateContext = {
     data: Data;
     properties: Record<string, DelegateProperties>;
 };
-export declare function generateDelegate(model: DMMF.Model, data: Data, name: string, properties: Properties, delegates: Delegates, onChange: (items: Item[]) => void): Delegate;
+export declare function generateDelegate(model: DMMF.Model, data: Data, name: string, properties: Properties, delegates: Delegates, onChange: (items: Item[]) => void): Promise<Delegate>;

package/dist/lib/extensions/index.d.ts

@@ -3,6 +3,8 @@ import { applyModelExtensions } from './model';
 import { applyQueryExtensions } from './query';
 import { applyResultExtensions } from './result';
 import type { ExtendsHook, DefaultArgs } from '@prisma/client/runtime/library';
+import type { DMMF } from '@prisma/generator-helper-v7';
+import type { PrismaDMMF } from '../globals';
 export { applyModelExtensions, applyQueryExtensions, applyResultExtensions };
 export type ExtensionsDefinition = Parameters<ExtendsHook<"define", Prisma.TypeMapCb, DefaultArgs>>[0];
-export declare function applyExtensions(client: PrismaClient, extensions: ExtensionsDefinition): PrismaClient<Prisma.PrismaClientOptions, never, DefaultArgs>;
+export declare function applyExtensions(client: PrismaClient, extensions: ExtensionsDefinition, datamodel: DMMF.Document, PrismaDMMF: PrismaDMMF): PrismaClient<Prisma.PrismaClientOptions, never, DefaultArgs>;

package/dist/lib/extensions/result.d.ts

@@ -1,3 +1,5 @@
-import { Prisma, type PrismaClient } from "@prisma/client";
-import { type DefaultArgs, type ExtendsHook } from "@prisma/client/runtime/library";
-export declare function applyResultExtensions(client: PrismaClient, extensions: Parameters<ExtendsHook<"define", Prisma.TypeMapCb, DefaultArgs>>[0]): PrismaClient;
+import type { Prisma, PrismaClient } from "@prisma/client";
+import type { DefaultArgs, ExtendsHook } from "@prisma/client/runtime/library";
+import type { DMMF } from "@prisma/generator-helper-v7";
+import type { PrismaDMMF } from "../globals";
+export declare function applyResultExtensions(client: PrismaClient, extensions: Parameters<ExtendsHook<"define", Prisma.TypeMapCb, DefaultArgs>>[0], datamodel: DMMF.Document, PrismaDMMF: PrismaDMMF): PrismaClient;

package/dist/lib/globals.d.ts

@@ -0,0 +1,6 @@
+export type PrismaDMMF = Awaited<ReturnType<typeof getGlobals>>["DMMF"];
+export declare function getGlobals(): Promise<{
+    PrismaClientKnownRequestError: typeof import("@prisma/client-runtime-utils").PrismaClientKnownRequestError;
+    Decimal: typeof import("@prisma/client-runtime-utils").Decimal;
+    DMMF: typeof import("@prisma/dmmf-v7") | typeof import("@prisma/dmmf-v6");
+}>;

package/dist/lib/operations/create.d.ts

@@ -1,4 +1,4 @@
-import { DMMF } from '@prisma/generator-helper';
+import type { DMMF } from '@prisma/generator-helper';
 import { Delegate, DelegateProperties, Item } from '../delegate';
 import { Delegates } from '../prismock';
 import { CreateArgs } from '../types';

package/dist/lib/operations/find/find.d.ts

@@ -1,4 +1,4 @@
-import { DMMF } from '@prisma/generator-helper';
+import type { DMMF } from '@prisma/generator-helper';
 import { FindArgs, GroupByFieldArg, Order, OrderedValue } from '../../types';
 import { Delegate, DelegateProperties, Item } from '../../delegate';
 import { Delegates } from '../../prismock';

package/dist/lib/prismock.d.ts

@@ -1,5 +1,5 @@
-import type { ActiveConnectorType } from '@prisma/generator-helper';
-import { Delegate, DelegateProperties, Item } from './delegate';
+import type { ActiveConnectorType } from "@prisma/generator-helper";
+import { Delegate, DelegateProperties, Item } from "./delegate";
 import type { Model } from "@prisma/dmmf";
 type OptionsSync = {
     models: Model[];
@@ -8,9 +8,9 @@ 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 generateDelegates(options: OptionsSync): {
+export declare function generateDelegates(options: OptionsSync): Promise<{
     delegates: Delegates;
     getData: () => Promise<Data>;
     setData: (d: Data) => Promise<void>;
-};
+}>;
 export {};

package/dist/lib/types/Find.d.ts

@@ -1,4 +1,4 @@
-import { Prisma } from '@prisma/client';
+import type { Prisma } from '@prisma/client';
 export type SelectArgs = Record<string, boolean | Record<string, boolean>>;
 export type FindWhereFieldRelationArg = {
     equals?: FindWhereFieldArg;

package/dist/lib/types/GroupBy.d.ts

@@ -1,4 +1,4 @@
-import { Prisma } from '@prisma/client';
+import type { Prisma } from '@prisma/client';
 import { FindWhereArgs } from './Find';
 export type GroupByArgs = {
     by: string | string[];

package/dist/v6/index.cjs

@@ -1290,9 +1290,6 @@ function mergeAggregateArg(aggregation, aggregate2, value) {
     [aggregation]: Object.fromEntries(Object.keys(valueToProcess).map((k) => [k, true]))
   };
 }
-// src/lib/operations/create.ts
-var import_library = require("@prisma/client/runtime/library");
-
 // node_modules/bson/lib/bson.node.mjs
 var import_crypto = require("crypto");
 var TypedArrayPrototypeGetSymbolToStringTag = (() => {
@@ -4416,6 +4413,7 @@ var buffer = ByteUtils.allocate(MAXSIZE);
 
 // src/lib/operations/create.ts
 var import_cuid2 = __toESM(require_cuid2());
+var import_client_runtime_utils = require("@prisma/client-runtime-utils");
 var isAutoIncrement = (field) => {
   return field.default?.name === "autoincrement";
 };
@@ -4468,7 +4466,7 @@ function calculateDefaultFieldValue(field, properties) {
   if (field.type === "Json" && typeof field.default === "string")
     return JSON.parse(field.default);
   if (field.type === "Decimal" && typeof field.default === "number")
-    return new import_library.Decimal(field.default);
+    return new import_client_runtime_utils.Decimal(field.default);
   if (["string", "number", "boolean"].includes(typeof field.default))
     return field.default;
   return;
@@ -4802,15 +4800,29 @@ function updateMany(args, current, delegates, onChange) {
 // node_modules/@prisma/client/package.json
 var version = "6.12.0";
 
+// src/lib/globals.ts
+async function getGlobals() {
+  const { PrismaClientKnownRequestError, Decimal: Decimal2 } = await import("@prisma/client-runtime-utils");
+  const DMMF = await (async () => {
+    if (false) {}
+    return await import("@prisma/dmmf-v6");
+  })();
+  return {
+    PrismaClientKnownRequestError,
+    Decimal: Decimal2,
+    DMMF
+  };
+}
+
 // src/lib/delegate.ts
-var import_library2 = require("@prisma/client/runtime/library");
-function generateDelegate(model, data, name, properties, delegates, onChange) {
+async function generateDelegate(model, data, name, properties, delegates, onChange) {
+  const { PrismaClientKnownRequestError } = await getGlobals();
   const delegate = {};
   Object.assign(delegate, {
     delete: (args = {}) => {
       const deleted = deleteMany(args, delegate, delegates, onChange);
       if (deleted.length === 0)
-        return Promise.reject(new import_library2.PrismaClientKnownRequestError(`No record was found for a delete on ${delegate.model.name}`, {
+        return Promise.reject(new PrismaClientKnownRequestError(`No record was found for a delete on ${delegate.model.name}`, {
           code: "P2025",
           clientVersion: version,
           meta: {
@@ -4827,7 +4839,7 @@ function generateDelegate(model, data, name, properties, delegates, onChange) {
     update: (args) => {
       const updated = updateMany(args, delegate, delegates, onChange);
       const [update3] = updated;
-      return update3 ? Promise.resolve(update3) : Promise.reject(new import_library2.PrismaClientKnownRequestError(`No record was found for an update on ${delegate.model.name}`, {
+      return update3 ? Promise.resolve(update3) : Promise.reject(new PrismaClientKnownRequestError(`No record was found for an update on ${delegate.model.name}`, {
         code: "P2025",
         clientVersion: version,
         meta: {
@@ -4873,7 +4885,7 @@ function generateDelegate(model, data, name, properties, delegates, onChange) {
     findUniqueOrThrow: (args = {}) => {
       const found = findOne(args, delegate, delegates);
       if (!found)
-        return Promise.reject(new import_library2.PrismaClientKnownRequestError(`No record was found for a query on ${delegate.model.name}`, {
+        return Promise.reject(new PrismaClientKnownRequestError(`No record was found for a query on ${delegate.model.name}`, {
           code: "P2025",
           clientVersion: version
         }));
@@ -4882,7 +4894,7 @@ function generateDelegate(model, data, name, properties, delegates, onChange) {
     findFirstOrThrow: (args = {}) => {
       const found = findOne(args, delegate, delegates);
       if (!found)
-        return Promise.reject(new import_library2.PrismaClientKnownRequestError(`No record was found for a query on ${delegate.model.name}`, {
+        return Promise.reject(new PrismaClientKnownRequestError(`No record was found for a query on ${delegate.model.name}`, {
           code: "P2025",
           clientVersion: version
         }));
@@ -4934,7 +4946,7 @@ async function generateDMMF(schemaPath) {
 }
 
 // src/lib/prismock.ts
-function generateDelegates(options) {
+async function generateDelegates(options) {
   const models = options.models ?? [];
   const data = {};
   const properties = {};
@@ -4960,18 +4972,19 @@ function generateDelegates(options) {
       };
     }, {}));
   }
-  models.forEach((model) => {
+  await Promise.all(models.map(async (model) => {
     const name = camelize(model.name);
     data[name] = [];
     properties[name] = {
       increment: {}
     };
+    const delegate = await generateDelegate(model, data, name, properties, delegates, (items) => {
+      Object.assign(data, { [name]: items });
+    });
     Object.assign(delegates, {
-      [name]: generateDelegate(model, data, name, properties, delegates, (items) => {
-        Object.assign(data, { [name]: items });
-      })
+      [name]: delegate
     });
-  }, {});
+  }, {}));
   const clientDelegates = Object.entries(delegates).reduce((accumulator, [delegateKey, delegateValue]) => {
     return {
       ...accumulator,
@@ -5119,25 +5132,23 @@ function applyQueryExtensions(client, extensions) {
 }
 
 // src/lib/extensions/result.ts
-var import_client = require("@prisma/client");
-var import_library3 = require("@prisma/client/runtime/library");
-function buildResultExtendedModel(client, proxiedModels, modelExtensions, modelName) {
+function buildResultExtendedModel(client, proxiedModels, modelExtensions, modelName, PrismaDMMF) {
   const model = proxiedModels[modelName] ?? client[modelName];
   if (Object.keys(modelExtensions).length === 0) {
     return model;
   }
   const singleResultActions = [
-    import_library3.DMMF.ModelAction.findFirst,
-    import_library3.DMMF.ModelAction.findFirstOrThrow,
-    import_library3.DMMF.ModelAction.findUnique,
-    import_library3.DMMF.ModelAction.findUniqueOrThrow,
-    import_library3.DMMF.ModelAction.create,
-    import_library3.DMMF.ModelAction.update,
-    import_library3.DMMF.ModelAction.upsert
+    PrismaDMMF.ModelAction.findFirst,
+    PrismaDMMF.ModelAction.findFirstOrThrow,
+    PrismaDMMF.ModelAction.findUnique,
+    PrismaDMMF.ModelAction.findUniqueOrThrow,
+    PrismaDMMF.ModelAction.create,
+    PrismaDMMF.ModelAction.update,
+    PrismaDMMF.ModelAction.upsert
   ];
   const multipleResultActions = [
-    import_library3.DMMF.ModelAction.findMany,
-    import_library3.DMMF.ModelAction.createManyAndReturn
+    PrismaDMMF.ModelAction.findMany,
+    PrismaDMMF.ModelAction.createManyAndReturn
   ];
   const allResultActions = [...singleResultActions, ...multipleResultActions];
   const proxyMethod = (actionName) => {
@@ -5212,7 +5223,7 @@ function buildResultExtendedModel(client, proxiedModels, modelExtensions, modelN
   });
   return proxiedModel;
 }
-function applyResultExtensions(client, extensions) {
+function applyResultExtensions(client, extensions, datamodel, PrismaDMMF) {
   if (typeof extensions === "function") {
     const extendedClient = extensions(client);
     return extendedClient;
@@ -5226,7 +5237,7 @@ function applyResultExtensions(client, extensions) {
     if (!originalModel) {
       return;
     }
-    const proxiedModel = buildResultExtendedModel(client, proxiedModels, resultExtendedModelMap[modelName], modelName);
+    const proxiedModel = buildResultExtendedModel(client, proxiedModels, resultExtendedModelMap[modelName], modelName, PrismaDMMF);
     proxiedModels[modelName] = proxiedModel;
     return proxiedModel;
   }
@@ -5240,12 +5251,12 @@ function applyResultExtensions(client, extensions) {
     proxyModel(modelName);
   }
   if (hasAllModelsExtension && resultExtendedModelMap["$allModels"]) {
-    for (const model of import_client.Prisma.dmmf.datamodel.models) {
+    for (const model of datamodel.datamodel.models) {
       const modelName = model.name;
       if (!(modelName in client)) {
         continue;
       }
-      const proxiedModel = buildResultExtendedModel(client, proxiedModels, resultExtendedModelMap["$allModels"], modelName);
+      const proxiedModel = buildResultExtendedModel(client, proxiedModels, resultExtendedModelMap["$allModels"], modelName, PrismaDMMF);
       proxiedModels[modelName] = proxiedModel;
     }
   }
@@ -5260,8 +5271,8 @@ function applyResultExtensions(client, extensions) {
 }
 
 // src/lib/extensions/index.ts
-function applyExtensions(client, extensions) {
-  const resultExtended = applyResultExtensions(client, extensions);
+function applyExtensions(client, extensions, datamodel, PrismaDMMF) {
+  const resultExtended = applyResultExtensions(client, extensions, datamodel, PrismaDMMF);
   const queryExtended = applyQueryExtensions(resultExtended, extensions);
   const modelExtended = applyModelExtensions(queryExtended, extensions);
   return modelExtended;
@@ -5270,19 +5281,29 @@ function applyExtensions(client, extensions) {
 // src/lib/client.ts
 class Prismock {
   schemaPath;
+  datamodel;
+  PrismaDMMF;
   genPromise;
   constructor(schemaPath) {
     this.schemaPath = schemaPath;
-    this.genPromise = this.generate();
+    this.genPromise = this.generate().then(({ datamodel, PrismaDMMF }) => {
+      this.datamodel = datamodel;
+      this.PrismaDMMF = PrismaDMMF;
+      return { datamodel, PrismaDMMF };
+    });
   }
   static async create(schemaPath) {
     const p = new Prismock(schemaPath);
-    await p.genPromise;
+    const { datamodel, PrismaDMMF } = await p.genPromise;
+    p.datamodel = datamodel;
+    p.PrismaDMMF = PrismaDMMF;
     return p;
   }
   static async createDefault(schemaPath) {
     const p = new Prismock(schemaPath);
-    await p.genPromise;
+    const { datamodel, PrismaDMMF } = await p.genPromise;
+    p.datamodel = datamodel;
+    p.PrismaDMMF = PrismaDMMF;
     return p;
   }
   async reset() {
@@ -5290,7 +5311,7 @@ class Prismock {
   }
   async generate() {
     const datamodel = await generateDMMF(this.schemaPath);
-    const { delegates, setData, getData } = generateDelegates({
+    const { delegates, setData, getData } = await generateDelegates({
       models: [
         ...datamodel.datamodel.models
       ]
@@ -5301,6 +5322,8 @@ class Prismock {
       else
         Object.assign(this, { [key]: value });
     });
+    const { DMMF: PrismaDMMF } = await getGlobals();
+    return { datamodel, PrismaDMMF };
   }
   async $connect() {
     await this.genPromise;
@@ -5326,7 +5349,13 @@ class Prismock {
     return Promise.resolve([]);
   }
   $extends(extensionDefs) {
-    return applyExtensions(this, extensionDefs);
+    if (!this.datamodel) {
+      throw new Error("Datamodel not loaded");
+    }
+    if (!this.PrismaDMMF) {
+      throw new Error("PrismaDMMF not loaded");
+    }
+    return applyExtensions(this, extensionDefs, this.datamodel, this.PrismaDMMF);
   }
   async $transaction(args) {
     if (Array.isArray(args)) {