@pkgverse/prismock 2.0.1-beta.0 → 2.0.1-beta.2

package/dist/index.d.ts

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

package/dist/index.mjs

@@ -627,9 +627,6 @@ var require_src = __commonJS((exports, module) => {
   exports.isCuid = isCuid;
 });
 
-// src/lib/prismock.ts
-import * as path from "path";
-
 // src/lib/operations/aggregate.ts
 function aggregate(args, items) {
   const aggregated = {};
@@ -4759,7 +4756,7 @@ function updateMany(args, current, delegates, onChange) {
   return toUpdate;
 }
 // node_modules/@prisma/client/package.json
-var version = "5.22.0";
+var version = "6.10.0";
 
 // src/lib/delegate.ts
 import { PrismaClientKnownRequestError } from "@prisma/client/runtime/library";
@@ -4769,7 +4766,7 @@ function generateDelegate(model, data, name, properties, delegates, onChange) {
     delete: (args = {}) => {
       const deleted = deleteMany(args, delegate, delegates, onChange);
       if (deleted.length === 0)
-        return Promise.reject(new PrismaClientKnownRequestError(`No ${delegate.model.name} found`, {
+        return Promise.reject(new PrismaClientKnownRequestError(`No record was found for a delete on ${delegate.model.name}`, {
           code: "P2025",
           clientVersion: version,
           meta: {
@@ -4786,7 +4783,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 PrismaClientKnownRequestError(`No ${delegate.model.name} found`, {
+      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: {
@@ -4832,7 +4829,7 @@ function generateDelegate(model, data, name, properties, delegates, onChange) {
     findUniqueOrThrow: (args = {}) => {
       const found = findOne(args, delegate, delegates);
       if (!found)
-        return Promise.reject(new PrismaClientKnownRequestError(`No ${delegate.model.name} found`, {
+        return Promise.reject(new PrismaClientKnownRequestError(`No record was found for a query on ${delegate.model.name}`, {
           code: "P2025",
           clientVersion: version
         }));
@@ -4841,7 +4838,7 @@ function generateDelegate(model, data, name, properties, delegates, onChange) {
     findFirstOrThrow: (args = {}) => {
       const found = findOne(args, delegate, delegates);
       if (!found)
-        return Promise.reject(new PrismaClientKnownRequestError(`No ${delegate.model.name} found`, {
+        return Promise.reject(new PrismaClientKnownRequestError(`No record was found for a query on ${delegate.model.name}`, {
           code: "P2025",
           clientVersion: version
         }));
@@ -5158,6 +5155,19 @@ function applyExtensions(client, extensions) {
   return modelExtended;
 }
 
+// src/lib/client.ts
+import { execSync } from "child_process";
+
+// 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;
@@ -5176,7 +5186,9 @@ class Prismock {
     this.generate();
   }
   generate() {
-    const { delegates, setData, getData } = generateDelegates({ models: this.__prismaModule.dmmf.datamodel.models });
+    const { delegates, setData, getData } = generateDelegates({
+      models: this.__prismaModule.dmmf.datamodel.models
+    });
     Object.entries({ ...delegates, setData, getData }).forEach(([key, value]) => {
       if (key in this)
         Object.assign(this[key], value);
@@ -5241,36 +5253,150 @@ function generateClient(delegates, getData, setData) {
     }
   };
 }
-async function createPrismockClass(prismaModuleInput) {
-  const prismaModule = await (async () => {
-    if (prismaModuleInput) {
-      return prismaModuleInput;
-    }
-    const { Prisma: Prisma2 } = await import("@prisma/client");
-    return Prisma2;
-  })();
-  const c = class PrismockClientDefault extends Prismock {
-    constructor() {
-      super(prismaModule);
+function getPgLitePrismockData(options) {
+  const sql = execSync(`bun prisma migrate diff --from-empty --to-schema-datamodel=${options.schemaPath} --script`, {
+    encoding: "utf-8"
+  });
+  const connectionPromise = options.adapter.connect();
+  const reset = async () => {
+    const connection = await connectionPromise;
+    await connection.executeScript(`
+      DROP SCHEMA public CASCADE;
+      CREATE SCHEMA public;
+    `);
+    await connection.executeScript(sql);
+  };
+  const getData = async () => {
+    const data = {};
+    for (const model of options.datamodel.datamodel.models) {
+      const tableName = model.dbName ?? model.name;
+      const idColumn = model.fields.find((field) => field.isId);
+      const defaultOrderBy = [];
+      if (idColumn) {
+        defaultOrderBy.push({ [idColumn.dbName ?? idColumn.name]: "asc" });
+      }
+      const orderBy = model.primaryKey?.fields.map((field) => ({ [field]: "asc" })) ?? defaultOrderBy;
+      const items = await options.prismaClient[camelize(model.name)].findMany({
+        orderBy
+      });
+      data[camelize(model.name)] = items;
+    }
+    return data;
+  };
+  const setData = async (data) => {
+    for (const model in data) {
+      const items = data[model];
+      const prismaModel = options.datamodel.datamodel.models.find((m) => camelize(m.name) === camelize(model) || m.dbName === model);
+      if (!prismaModel) {
+        continue;
+      }
+      const tableName = prismaModel.dbName ?? prismaModel.name;
+      await prisma[camelize(model)].createMany({
+        data: items
+      });
     }
   };
-  return c;
+  return {
+    reset,
+    getData,
+    setData
+  };
 }
-async function createPrismock() {
-  return await Prismock.createDefault();
+async function getClient(options) {
+  const datamodel = await generateDMMF(options.schemaPath);
+  if (options.usePgLite) {
+    const { PGlite } = await import("@electric-sql/pglite");
+    const { PrismaPGlite } = await import("pglite-prisma-adapter");
+    const pglite = new PGlite("memory://");
+    const adapter = new PrismaPGlite(pglite);
+    const prisma2 = new options.prismaClient({
+      adapter
+    });
+    const prismockData = getPgLitePrismockData({
+      schemaPath: options.schemaPath,
+      pglite,
+      adapter,
+      datamodel,
+      prismaClient: prisma2
+    });
+    await prismockData.reset();
+    return Object.assign(prisma2, prismockData);
+  }
+  return await Prismock.create(options.prismaModule);
 }
-async function createPrismockClient(prismaModule) {
-  return await Prismock.create(prismaModule);
+async function getClientClass(options) {
+  const datamodel = await generateDMMF(options.schemaPath);
+  if (options.usePgLite) {
+    const { PGlite } = await import("@electric-sql/pglite");
+    const { PrismaPGlite } = await import("pglite-prisma-adapter");
+
+    class PrismaClientMocked2 extends options.PrismaClient {
+      pglite;
+      adapter;
+      datamodel;
+      prismockData;
+      constructor(...args) {
+        const pglite = new PGlite("memory://");
+        const adapter = new PrismaPGlite(pglite);
+        const prismaOptions = args[0] ?? {};
+        super({ ...prismaOptions, adapter });
+        this.pglite = pglite;
+        this.adapter = adapter;
+        this.datamodel = datamodel;
+        this.prismockData = getPgLitePrismockData({
+          schemaPath: options.schemaPath,
+          pglite,
+          adapter,
+          datamodel,
+          prismaClient: this
+        });
+      }
+      async $connect() {
+        await this.reset();
+        return super.$connect();
+      }
+      async reset() {
+        await this.prismockData.reset();
+      }
+      async getData() {
+        return this.prismockData.getData();
+      }
+      async setData(data) {
+        return this.prismockData.setData(data);
+      }
+    }
+    return PrismaClientMocked2;
+  }
+
+  class PrismaClientMocked extends Prismock {
+    constructor() {
+      super(options.prismaModule);
+    }
+  }
+  return PrismaClientMocked;
+}
+async function getDefaultClient() {
+  const { Prisma: Prisma2, 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");
+  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
-var PrismaInternals = await import("@prisma/internals");
-var { getDMMF, getGenerator, getSchema } = PrismaInternals;
-async function generateDMMF(schemaPath) {
-  const pathToModule = schemaPath ?? __require.resolve(path.resolve(process.cwd(), "prisma/schema.prisma"));
-  const datamodel = await getSchema(pathToModule);
-  return getDMMF({ datamodel });
-}
+var PrismaInternals2 = await import("@prisma/internals");
 async function generatePrismock(options = {}) {
   const schema = await generateDMMF(options.schemaPath);
   return generatePrismockSync({ models: schema.datamodel.models });
@@ -5284,10 +5410,10 @@ function generateDelegates(options) {
   const data = {};
   const properties = {};
   const delegates = {};
-  function getData() {
+  async function getData() {
     return data;
   }
-  function setData(d) {
+  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]) => {
@@ -5326,10 +5452,12 @@ function generateDelegates(options) {
   return { delegates: clientDelegates, getData, setData };
 }
 export {
+  getDefaultClientClass,
+  getDefaultClient,
+  getClientClass,
+  getClient,
   generatePrismockSync,
   generatePrismock,
-  createPrismockClient,
-  createPrismockClass,
   createPrismock,
   Prismock
 };

package/dist/lib/client.d.ts

@@ -1,21 +1,26 @@
-import type { PrismaClient } from '@prisma/client';
-import type * as runtime from '@prisma/client/runtime/library';
-import { Delegate } from './delegate';
-import { Data } from './prismock';
-import { type ExtensionsDefinition } from './extensions';
-type GetData = () => Data;
-type SetData = (data: Data) => void;
+import type { Prisma, PrismaClient } from "@prisma/client";
+import type * as runtime from "@prisma/client/runtime/library";
+import type { Delegate } from "./delegate";
+import { Data } from "./prismock";
+import { type ExtensionsDefinition } from "./extensions";
+type GetData = () => Promise<Data>;
+type SetData = (data: Data) => Promise<void>;
 export interface PrismockData {
     getData: GetData;
     setData: SetData;
-    reset: () => void;
+    reset: () => Promise<void>;
 }
 export type PrismockClientType<T = PrismaClient> = T & PrismockData;
+export type PrismockOptions = {
+    usePgLite?: undefined | null | {
+        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>;
+    static createDefault(): Promise<PrismaClient<Prisma.PrismaClientOptions, never, runtime.DefaultArgs> & PrismockData>;
     reset(): void;
     private generate;
     $connect(): Promise<void>;
@@ -26,14 +31,35 @@ export declare class Prismock<PC = PrismaClient> {
     $executeRawUnsafe(): Promise<number>;
     $queryRaw(): Promise<never[]>;
     $queryRawUnsafe(): Promise<never[]>;
-    $extends(extensionDefs: ExtensionsDefinition): PrismaClient<import(".prisma").Prisma.PrismaClientOptions, never, runtime.DefaultArgs>;
+    $extends(extensionDefs: ExtensionsDefinition): PrismaClient<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 createPrismockClass<PC extends (new (...args: any[]) => any) = typeof PrismaClient>(prismaModuleInput?: PrismaModule): Promise<typeof PrismaClient>;
-export declare function createPrismock(): Promise<PrismaClient<import(".prisma").Prisma.PrismaClientOptions, never, runtime.DefaultArgs> & PrismockData>;
-export declare function createPrismockClient<PC = PrismaClient>(prismaModule: PrismaModule<PC>): Promise<PrismockClientType<PC>>;
+type GetClientOptions<PrismaClientClassType extends new (...args: any[]) => any> = {
+    prismaModule: PrismaModule<InstanceType<PrismaClientClassType>>;
+    prismaClient: PrismaClientClassType;
+    schemaPath: string;
+    usePgLite?: boolean | null | undefined;
+};
+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;
+};
+type PrismaClientClassMocked<PrismaClientType extends new (...args: any[]) => any> = PrismaClientType extends new (...args: infer Args) => infer Instance ? (new (...args: Args) => Instance & PrismockData) & PrismaClientType : never;
+export declare function getClientClass<PrismaClientType extends new (...args: any[]) => any>(options: GetClientClassOptions<PrismaClientType>): Promise<PrismaClientClassMocked<PrismaClientType>>;
+export declare function getDefaultClient(): Promise<PrismockClientType<PrismaClient<Prisma.PrismaClientOptions, unknown, runtime.InternalArgs>>>;
+export declare function getDefaultClientClass(): Promise<(new (optionsArg?: Prisma.Subset<Prisma.PrismaClientOptions, Prisma.PrismaClientOptions> | undefined) => PrismaClient<Prisma.PrismaClientOptions, unknown, runtime.InternalArgs> & PrismockData) & typeof import(".prisma").PrismaClient>;
+/**
+ * For backwards compatibility
+ */
+export declare const createPrismock: typeof getDefaultClient;
+export declare const createPrismockClass: typeof getDefaultClientClass;
 export {};

package/dist/lib/dmmf.d.ts

@@ -0,0 +1,4 @@
+import type { DMMF } from '@prisma/generator-helper';
+import type { ConfigMetaFormat } from '@prisma/internals/dist/engine-commands/getConfig';
+export declare function generateDMMF(schemaPath?: string): Promise<DMMF.Document>;
+export declare function generateConfig(schemaPath: string): Promise<ConfigMetaFormat>;

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

@@ -2,29 +2,7 @@ import { DMMF } from '@prisma/generator-helper';
 import { Delegate, DelegateProperties, Item } from '../delegate';
 import { Delegates } from '../prismock';
 import { CreateArgs } from '../types';
-export declare const isAutoIncrement: (field: import("@prisma/generator-helper").ReadonlyDeep<{
-    kind: DMMF.FieldKind;
-    name: string;
-    isRequired: boolean;
-    isList: boolean;
-    isUnique: boolean;
-    isId: boolean;
-    isReadOnly: boolean;
-    isGenerated?: boolean | undefined;
-    isUpdatedAt?: boolean | undefined;
-    type: string;
-    dbName?: string | null | undefined;
-    hasDefaultValue: boolean;
-    default?: DMMF.FieldDefaultScalar[] | import("@prisma/generator-helper").ReadonlyDeep<{
-        name: string;
-        args: any[];
-    }> | DMMF.FieldDefaultScalar | undefined;
-    relationFromFields?: string[] | undefined;
-    relationToFields?: string[] | undefined;
-    relationOnDelete?: string | undefined;
-    relationName?: string | undefined;
-    documentation?: string | undefined;
-}>) => boolean;
+export declare const isAutoIncrement: (field: DMMF.Field) => boolean;
 export declare function calculateDefaultFieldValue(field: DMMF.Field, properties: DelegateProperties): unknown;
 export declare function createDefaultValues(fields: DMMF.Field[], properties: DelegateProperties): Record<string, unknown>;
 export declare function connectOrCreate(delegate: Delegate, delegates: Delegates): (item: Item) => Item;

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

@@ -11,145 +11,9 @@ export declare function order(args: FindArgs, delegate: Delegate, delegates: Del
 export declare function paginate(skip?: number, take?: number): (items: Item[]) => Item[];
 export declare function includes(args: FindArgs, current: Delegate, delegates: Delegates): (item: Item) => Item;
 export declare function select(selectArgs: FindArgs['select']): (item: Item) => Item;
-export declare const getJoinField: (field: import("@prisma/generator-helper").ReadonlyDeep<{
-    kind: DMMF.FieldKind;
-    name: string;
-    isRequired: boolean;
-    isList: boolean;
-    isUnique: boolean;
-    isId: boolean;
-    isReadOnly: boolean;
-    isGenerated?: boolean | undefined;
-    isUpdatedAt?: boolean | undefined;
-    type: string;
-    dbName?: string | null | undefined;
-    hasDefaultValue: boolean;
-    default?: DMMF.FieldDefaultScalar[] | import("@prisma/generator-helper").ReadonlyDeep<{
-        name: string;
-        args: any[];
-    }> | DMMF.FieldDefaultScalar | undefined;
-    relationFromFields?: string[] | undefined;
-    relationToFields?: string[] | undefined;
-    relationOnDelete?: string | undefined;
-    relationName?: string | undefined;
-    documentation?: string | undefined;
-}>, delegates: Delegates) => import("@prisma/generator-helper").ReadonlyDeep<import("@prisma/generator-helper").ReadonlyDeep<{
-    kind: DMMF.FieldKind;
-    name: string;
-    isRequired: boolean;
-    isList: boolean;
-    isUnique: boolean;
-    isId: boolean;
-    isReadOnly: boolean;
-    isGenerated?: boolean | undefined;
-    isUpdatedAt?: boolean | undefined;
-    type: string;
-    dbName?: string | null | undefined;
-    hasDefaultValue: boolean;
-    default?: DMMF.FieldDefaultScalar[] | import("@prisma/generator-helper").ReadonlyDeep<{
-        name: string;
-        args: any[];
-    }> | DMMF.FieldDefaultScalar | undefined;
-    relationFromFields?: string[] | undefined;
-    relationToFields?: string[] | undefined;
-    relationOnDelete?: string | undefined;
-    relationName?: string | undefined;
-    documentation?: string | undefined;
-}>> | undefined;
-export declare const getDelegateFromField: (field: import("@prisma/generator-helper").ReadonlyDeep<{
-    kind: DMMF.FieldKind;
-    name: string;
-    isRequired: boolean;
-    isList: boolean;
-    isUnique: boolean;
-    isId: boolean;
-    isReadOnly: boolean;
-    isGenerated?: boolean | undefined;
-    isUpdatedAt?: boolean | undefined;
-    type: string;
-    dbName?: string | null | undefined;
-    hasDefaultValue: boolean;
-    default?: DMMF.FieldDefaultScalar[] | import("@prisma/generator-helper").ReadonlyDeep<{
-        name: string;
-        args: any[];
-    }> | DMMF.FieldDefaultScalar | undefined;
-    relationFromFields?: string[] | undefined;
-    relationToFields?: string[] | undefined;
-    relationOnDelete?: string | undefined;
-    relationName?: string | undefined;
-    documentation?: string | undefined;
-}>, delegates: Delegates) => Delegate;
-export declare const getFieldRelationshipWhere: (item: Item, field: import("@prisma/generator-helper").ReadonlyDeep<{
-    kind: DMMF.FieldKind;
-    name: string;
-    isRequired: boolean;
-    isList: boolean;
-    isUnique: boolean;
-    isId: boolean;
-    isReadOnly: boolean;
-    isGenerated?: boolean | undefined;
-    isUpdatedAt?: boolean | undefined;
-    type: string;
-    dbName?: string | null | undefined;
-    hasDefaultValue: boolean;
-    default?: DMMF.FieldDefaultScalar[] | import("@prisma/generator-helper").ReadonlyDeep<{
-        name: string;
-        args: any[];
-    }> | DMMF.FieldDefaultScalar | undefined;
-    relationFromFields?: string[] | undefined;
-    relationToFields?: string[] | undefined;
-    relationOnDelete?: string | undefined;
-    relationName?: string | undefined;
-    documentation?: string | undefined;
-}>, delegates: Delegates) => Record<string, GroupByFieldArg>;
-export declare const getFieldFromRelationshipWhere: (item: Item, field: import("@prisma/generator-helper").ReadonlyDeep<{
-    kind: DMMF.FieldKind;
-    name: string;
-    isRequired: boolean;
-    isList: boolean;
-    isUnique: boolean;
-    isId: boolean;
-    isReadOnly: boolean;
-    isGenerated?: boolean | undefined;
-    isUpdatedAt?: boolean | undefined;
-    type: string;
-    dbName?: string | null | undefined;
-    hasDefaultValue: boolean;
-    default?: DMMF.FieldDefaultScalar[] | import("@prisma/generator-helper").ReadonlyDeep<{
-        name: string;
-        args: any[];
-    }> | DMMF.FieldDefaultScalar | undefined;
-    relationFromFields?: string[] | undefined;
-    relationToFields?: string[] | undefined;
-    relationOnDelete?: string | undefined;
-    relationName?: string | undefined;
-    documentation?: string | undefined;
-}>) => {
-    [x: string]: GroupByFieldArg;
-};
-export declare const getFieldToRelationshipWhere: (item: Item, field: import("@prisma/generator-helper").ReadonlyDeep<{
-    kind: DMMF.FieldKind;
-    name: string;
-    isRequired: boolean;
-    isList: boolean;
-    isUnique: boolean;
-    isId: boolean;
-    isReadOnly: boolean;
-    isGenerated?: boolean | undefined;
-    isUpdatedAt?: boolean | undefined;
-    type: string;
-    dbName?: string | null | undefined;
-    hasDefaultValue: boolean;
-    default?: DMMF.FieldDefaultScalar[] | import("@prisma/generator-helper").ReadonlyDeep<{
-        name: string;
-        args: any[];
-    }> | DMMF.FieldDefaultScalar | undefined;
-    relationFromFields?: string[] | undefined;
-    relationToFields?: string[] | undefined;
-    relationOnDelete?: string | undefined;
-    relationName?: string | undefined;
-    documentation?: string | undefined;
-}>) => {
-    [x: string]: GroupByFieldArg;
-};
+export declare const getJoinField: (field: DMMF.Field, delegates: Delegates) => DMMF.Field | undefined;
+export declare const getDelegateFromField: (field: DMMF.Field, delegates: Delegates) => Delegate;
+export declare const getFieldRelationshipWhere: (item: Item, field: DMMF.Field, delegates: Delegates) => Record<string, GroupByFieldArg>;
+export declare const getFieldFromRelationshipWhere: (item: Item, field: DMMF.Field) => Record<string, GroupByFieldArg>;
+export declare const getFieldToRelationshipWhere: (item: Item, field: DMMF.Field) => Record<string, GroupByFieldArg>;
 export declare function findMany(args: FindArgs, current: Delegate, delegates: Delegates): Item[];

package/dist/lib/prismock.d.ts

@@ -12,279 +12,20 @@ type OptionsSync = {
 export type Data = Record<string, Item[]>;
 export type Properties = Record<string, DelegateProperties>;
 export type Delegates = Record<string, Delegate>;
-export declare function generateDMMF(schemaPath?: string): Promise<import("@prisma/generator-helper").ReadonlyDeep<{
-    datamodel: import("@prisma/generator-helper").ReadonlyDeep<{
-        models: import("@prisma/generator-helper").ReadonlyDeep<{
-            name: string;
-            dbName: string | null;
-            fields: import("@prisma/generator-helper").ReadonlyDeep<{
-                kind: DMMF.FieldKind;
-                name: string;
-                isRequired: boolean;
-                isList: boolean;
-                isUnique: boolean;
-                isId: boolean;
-                isReadOnly: boolean;
-                isGenerated?: boolean | undefined;
-                isUpdatedAt?: boolean | undefined;
-                type: string;
-                dbName?: string | null | undefined;
-                hasDefaultValue: boolean;
-                default?: DMMF.FieldDefaultScalar[] | import("@prisma/generator-helper").ReadonlyDeep<{
-                    name: string;
-                    args: any[];
-                }> | DMMF.FieldDefaultScalar | undefined;
-                relationFromFields?: string[] | undefined;
-                relationToFields?: string[] | undefined;
-                relationOnDelete?: string | undefined;
-                relationName?: string | undefined;
-                documentation?: string | undefined;
-            }>[];
-            uniqueFields: string[][];
-            uniqueIndexes: import("@prisma/generator-helper").ReadonlyDeep<{
-                name: string;
-                fields: string[];
-            }>[];
-            documentation?: string | undefined;
-            primaryKey: import("@prisma/generator-helper").ReadonlyDeep<{
-                name: string | null;
-                fields: string[];
-            }> | null;
-            isGenerated?: boolean | undefined;
-        }>[];
-        enums: import("@prisma/generator-helper").ReadonlyDeep<{
-            name: string;
-            values: import("@prisma/generator-helper").ReadonlyDeep<{
-                name: string;
-                dbName: string | null;
-            }>[];
-            dbName?: string | null | undefined;
-            documentation?: string | undefined;
-        }>[];
-        types: import("@prisma/generator-helper").ReadonlyDeep<{
-            name: string;
-            dbName: string | null;
-            fields: import("@prisma/generator-helper").ReadonlyDeep<{
-                kind: DMMF.FieldKind;
-                name: string;
-                isRequired: boolean;
-                isList: boolean;
-                isUnique: boolean;
-                isId: boolean;
-                isReadOnly: boolean;
-                isGenerated?: boolean | undefined;
-                isUpdatedAt?: boolean | undefined;
-                type: string;
-                dbName?: string | null | undefined;
-                hasDefaultValue: boolean;
-                default?: DMMF.FieldDefaultScalar[] | import("@prisma/generator-helper").ReadonlyDeep<{
-                    name: string;
-                    args: any[];
-                }> | DMMF.FieldDefaultScalar | undefined;
-                relationFromFields?: string[] | undefined;
-                relationToFields?: string[] | undefined;
-                relationOnDelete?: string | undefined;
-                relationName?: string | undefined;
-                documentation?: string | undefined;
-            }>[];
-            uniqueFields: string[][];
-            uniqueIndexes: import("@prisma/generator-helper").ReadonlyDeep<{
-                name: string;
-                fields: string[];
-            }>[];
-            documentation?: string | undefined;
-            primaryKey: import("@prisma/generator-helper").ReadonlyDeep<{
-                name: string | null;
-                fields: string[];
-            }> | null;
-            isGenerated?: boolean | undefined;
-        }>[];
-        indexes: import("@prisma/generator-helper").ReadonlyDeep<{
-            model: string;
-            type: DMMF.IndexType;
-            isDefinedOnField: boolean;
-            name?: string | undefined;
-            dbName?: string | undefined;
-            algorithm?: string | undefined;
-            clustered?: boolean | undefined;
-            fields: import("@prisma/generator-helper").ReadonlyDeep<{
-                name: string;
-                sortOrder?: DMMF.SortOrder | undefined;
-                length?: number | undefined;
-                operatorClass?: string | undefined;
-            }>[];
-        }>[];
-    }>;
-    schema: import("@prisma/generator-helper").ReadonlyDeep<{
-        rootQueryType?: string | undefined;
-        rootMutationType?: string | undefined;
-        inputObjectTypes: {
-            model?: import("@prisma/generator-helper").ReadonlyDeep<{
-                name: string;
-                constraints: {
-                    maxNumFields: number | null;
-                    minNumFields: number | null;
-                    fields?: string[] | undefined;
-                };
-                meta?: {
-                    source?: string | undefined;
-                } | undefined;
-                fields: import("@prisma/generator-helper").ReadonlyDeep<{
-                    name: string;
-                    comment?: string | undefined;
-                    isNullable: boolean;
-                    isRequired: boolean;
-                    inputTypes: DMMF.InputTypeRef[];
-                    deprecation?: import("@prisma/generator-helper").ReadonlyDeep<{
-                        sinceVersion: string;
-                        reason: string;
-                        plannedRemovalVersion?: string | undefined;
-                    }> | undefined;
-                }>[];
-            }>[] | undefined;
-            prisma: import("@prisma/generator-helper").ReadonlyDeep<{
-                name: string;
-                constraints: {
-                    maxNumFields: number | null;
-                    minNumFields: number | null;
-                    fields?: string[] | undefined;
-                };
-                meta?: {
-                    source?: string | undefined;
-                } | undefined;
-                fields: import("@prisma/generator-helper").ReadonlyDeep<{
-                    name: string;
-                    comment?: string | undefined;
-                    isNullable: boolean;
-                    isRequired: boolean;
-                    inputTypes: DMMF.InputTypeRef[];
-                    deprecation?: import("@prisma/generator-helper").ReadonlyDeep<{
-                        sinceVersion: string;
-                        reason: string;
-                        plannedRemovalVersion?: string | undefined;
-                    }> | undefined;
-                }>[];
-            }>[];
-        };
-        outputObjectTypes: {
-            model: import("@prisma/generator-helper").ReadonlyDeep<{
-                name: string;
-                fields: import("@prisma/generator-helper").ReadonlyDeep<{
-                    name: string;
-                    isNullable?: boolean | undefined;
-                    outputType: DMMF.OutputTypeRef;
-                    args: import("@prisma/generator-helper").ReadonlyDeep<{
-                        name: string;
-                        comment?: string | undefined;
-                        isNullable: boolean;
-                        isRequired: boolean;
-                        inputTypes: DMMF.InputTypeRef[];
-                        deprecation?: import("@prisma/generator-helper").ReadonlyDeep<{
-                            sinceVersion: string;
-                            reason: string;
-                            plannedRemovalVersion?: string | undefined;
-                        }> | undefined;
-                    }>[];
-                    deprecation?: import("@prisma/generator-helper").ReadonlyDeep<{
-                        sinceVersion: string;
-                        reason: string;
-                        plannedRemovalVersion?: string | undefined;
-                    }> | undefined;
-                    documentation?: string | undefined;
-                }>[];
-            }>[];
-            prisma: import("@prisma/generator-helper").ReadonlyDeep<{
-                name: string;
-                fields: import("@prisma/generator-helper").ReadonlyDeep<{
-                    name: string;
-                    isNullable?: boolean | undefined;
-                    outputType: DMMF.OutputTypeRef;
-                    args: import("@prisma/generator-helper").ReadonlyDeep<{
-                        name: string;
-                        comment?: string | undefined;
-                        isNullable: boolean;
-                        isRequired: boolean;
-                        inputTypes: DMMF.InputTypeRef[];
-                        deprecation?: import("@prisma/generator-helper").ReadonlyDeep<{
-                            sinceVersion: string;
-                            reason: string;
-                            plannedRemovalVersion?: string | undefined;
-                        }> | undefined;
-                    }>[];
-                    deprecation?: import("@prisma/generator-helper").ReadonlyDeep<{
-                        sinceVersion: string;
-                        reason: string;
-                        plannedRemovalVersion?: string | undefined;
-                    }> | undefined;
-                    documentation?: string | undefined;
-                }>[];
-            }>[];
-        };
-        enumTypes: {
-            model?: import("@prisma/generator-helper").ReadonlyDeep<{
-                name: string;
-                values: string[];
-            }>[] | undefined;
-            prisma: import("@prisma/generator-helper").ReadonlyDeep<{
-                name: string;
-                values: string[];
-            }>[];
-        };
-        fieldRefTypes: {
-            prisma?: import("@prisma/generator-helper").ReadonlyDeep<{
-                name: string;
-                allowTypes: DMMF.FieldRefAllowType[];
-                fields: import("@prisma/generator-helper").ReadonlyDeep<{
-                    name: string;
-                    comment?: string | undefined;
-                    isNullable: boolean;
-                    isRequired: boolean;
-                    inputTypes: DMMF.InputTypeRef[];
-                    deprecation?: import("@prisma/generator-helper").ReadonlyDeep<{
-                        sinceVersion: string;
-                        reason: string;
-                        plannedRemovalVersion?: string | undefined;
-                    }> | undefined;
-                }>[];
-            }>[] | undefined;
-        };
-    }>;
-    mappings: import("@prisma/generator-helper").ReadonlyDeep<{
-        modelOperations: import("@prisma/generator-helper").ReadonlyDeep<{
-            model: string;
-            plural: string;
-            findUnique?: string | null | undefined;
-            findUniqueOrThrow?: string | null | undefined;
-            findFirst?: string | null | undefined;
-            findFirstOrThrow?: string | null | undefined;
-            findMany?: string | null | undefined;
-            create?: string | null | undefined;
-            createMany?: string | null | undefined;
-            createManyAndReturn?: string | null | undefined;
-            update?: string | null | undefined;
-            updateMany?: string | null | undefined;
-            upsert?: string | null | undefined;
-            delete?: string | null | undefined;
-            deleteMany?: string | null | undefined;
-            aggregate?: string | null | undefined;
-            groupBy?: string | null | undefined;
-            count?: string | null | undefined;
-            findRaw?: string | null | undefined;
-            aggregateRaw?: string | null | undefined;
-        }>[];
-        otherOperations: {
-            read: string[];
-            write: string[];
-        };
-    }>;
-}>>;
-export declare function fetchGenerator(schemaPath?: string): Promise<Generator>;
-export declare function getProvider(generator: Generator): import("@prisma/generator-helper").ActiveConnectorType | undefined;
+// export async function fetchGenerator(schemaPath?: string) {
+//   const pathToModule = schemaPath ?? require.resolve(path.resolve(process.cwd(), 'prisma/schema.prisma'));
+//   const config = await generateConfig(pathToModule);
+//   return getGenerator({
+//     schemaPath: pathToModule,
+//   });
+// }
+export declare function fetchProvider(schemaPath?: string): Promise<string>;
+export declare function getProvider(generator: Generator): import("@prisma/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: () => Data;
-    setData: (d: Data) => void;
+    getData: () => Promise<Data>;
+    setData: (d: Data) => Promise<void>;
 };
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pkgverse/prismock",
-  "version": "2.0.1-beta.0",
+  "version": "2.0.1-beta.2",
   "description": "A mock for PrismaClient, dedicated to unit testing.",
   "repository": {
     "url": "https://github.com/JQuezada0/prismock"
@@ -43,7 +43,8 @@
   "devDependencies": {
     "@commitlint/cli": "19.8.1",
     "@commitlint/config-conventional": "19.8.1",
-    "@prisma/client": "5.22.0",
+    "@electric-sql/pglite": "0.3.14",
+    "@prisma/client": "6.10.0",
     "@semantic-release/changelog": "6.0.3",
     "@semantic-release/commit-analyzer": "13.0.1",
     "@semantic-release/git": "10.0.1",
@@ -72,8 +73,9 @@
     "fs-jetpack": "5.1.0",
     "husky": "9.1.7",
     "lint-staged": "16.1.6",
+    "pglite-prisma-adapter": "0.6.1",
     "prettier": "2.8.8",
-    "prisma": "5.22.0",
+    "prisma": "6.10.0",
     "release-it": "19.0.6",
     "semantic-release": "24.2.7",
     "ts-node": "10.9.2",
@@ -101,12 +103,12 @@
   },
   "dependencies": {
     "@paralleldrive/cuid2": "2.2.2",
-    "@prisma/generator-helper": "5.22.0",
-    "@prisma/internals": "5.22.0",
+    "@prisma/generator-helper": "6.10.0",
+    "@prisma/internals": "6.10.0",
     "bson": "6.10.4"
   },
   "peerDependencies": {
-    "@prisma/client": "*",
-    "prisma": "*"
+    "@prisma/client": ">= 6.10.0",
+    "prisma": ">= 6.10.0"
   }
 }