@prisma/client-common 6.6.0-integration-push-xmzqvqxpztks.1

package/dist/client-config.d.ts

@@ -0,0 +1,83 @@
+import { ActiveConnectorType, EnvValue, GeneratorConfig } from '@prisma/generator';
+import { LoadedEnv } from '@prisma/internals';
+import { CompilerWasmLoadingConfig } from './QueryCompiler';
+import { EngineWasmLoadingConfig } from './QueryEngine';
+import { RuntimeDataModel } from './runtimeDataModel';
+/**
+ * Config that is stored into the generated client. When the generated client is
+ * loaded, this same config is passed to {@link getPrismaClient} which creates a
+ * closure with that config around a non-instantiated [[PrismaClient]].
+ */
+export type GetPrismaClientConfig = {
+    runtimeDataModel: RuntimeDataModel;
+    generator?: GeneratorConfig;
+    relativeEnvPaths: {
+        rootEnvPath?: string | null;
+        schemaEnvPath?: string | null;
+    };
+    relativePath: string;
+    dirname: string;
+    filename?: string;
+    clientVersion: string;
+    engineVersion: string;
+    datasourceNames: string[];
+    activeProvider: ActiveConnectorType;
+    /**
+     * The contents of the schema encoded into a string
+     * @remarks only used for the purpose of data proxy
+     */
+    inlineSchema: string;
+    /**
+     * A special env object just for the data proxy edge runtime.
+     * Allows bundlers to inject their own env variables (Vercel).
+     * Allows platforms to declare global variables as env (Workers).
+     * @remarks only used for the purpose of data proxy
+     */
+    injectableEdgeEnv?: () => LoadedEnv;
+    /**
+     * The contents of the datasource url saved in a string.
+     * This can either be an env var name or connection string.
+     * It is needed by the client to connect to the Data Proxy.
+     * @remarks only used for the purpose of data proxy
+     */
+    inlineDatasources: {
+        [name in string]: {
+            url: EnvValue;
+        };
+    };
+    /**
+     * The string hash that was produced for a given schema
+     * @remarks only used for the purpose of data proxy
+     */
+    inlineSchemaHash: string;
+    /**
+     * A marker to indicate that the client was not generated via `prisma
+     * generate` but was generated via `generate --postinstall` script instead.
+     * @remarks used to error for Vercel/Netlify for schema caching issues
+     */
+    postinstall?: boolean;
+    /**
+     * Information about the CI where the Prisma Client has been generated. The
+     * name of the CI environment is stored at generation time because CI
+     * information is not always available at runtime. Moreover, the edge client
+     * has no notion of environment variables, so this works around that.
+     * @remarks used to error for Vercel/Netlify for schema caching issues
+     */
+    ciName?: string;
+    /**
+     * Information about whether we have not found a schema.prisma file in the
+     * default location, and that we fell back to finding the schema.prisma file
+     * in the current working directory. This usually means it has been bundled.
+     */
+    isBundled?: boolean;
+    /**
+     * A boolean that is `false` when the client was generated with --no-engine. At
+     * runtime, this means the client will be bound to be using the Data Proxy.
+     */
+    copyEngine?: boolean;
+    /**
+     * Optional wasm loading configuration
+     */
+    engineWasm?: EngineWasmLoadingConfig;
+    compilerWasm?: CompilerWasmLoadingConfig;
+};

package/dist/client-config.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var client_config_exports = {};
+module.exports = __toCommonJS(client_config_exports);

package/dist/dmmf.d.ts

@@ -0,0 +1,4 @@
+import * as DMMF from '@prisma/dmmf';
+export type BaseDMMF = {
+    readonly datamodel: Omit<DMMF.Datamodel, 'indexes'>;
+};

package/dist/dmmf.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dmmf_exports = {};
+module.exports = __toCommonJS(dmmf_exports);

package/dist/enums.d.ts

@@ -0,0 +1,8 @@
+/**
+ * List of Prisma enums that must be strict enums because they can be used in optional fields.
+ */
+export declare const strictEnumNames: string[];
+/**
+ * List of Prisma enums that must use unique objects instead of strings as their values.
+ */
+export declare const objectEnumNames: string[];

package/dist/enums.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var enums_exports = {};
+__export(enums_exports, {
+  objectEnumNames: () => objectEnumNames,
+  strictEnumNames: () => strictEnumNames
+});
+module.exports = __toCommonJS(enums_exports);
+const strictEnumNames = ["TransactionIsolationLevel"];
+const objectEnumNames = ["JsonNullValueInput", "NullableJsonNullValueInput", "JsonNullValueFilter"];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  objectEnumNames,
+  strictEnumNames
+});

package/dist/enums.mjs

@@ -0,0 +1,6 @@
+const strictEnumNames = ["TransactionIsolationLevel"];
+const objectEnumNames = ["JsonNullValueInput", "NullableJsonNullValueInput", "JsonNullValueFilter"];
+export {
+  objectEnumNames,
+  strictEnumNames
+};

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export * from './Cache';
+export * from './casing';
+export * from './client-config';
+export * from './Dictionary';
+export * from './dmmf';
+export * from './enums';
+export * from './lazyProperty';
+export * from './omit';
+export * from './operations';
+export * from './QueryCompiler';
+export * from './QueryEngine';
+export * from './runtimeDataModel';
+export * from './uniqueBy';

package/dist/index.js

@@ -0,0 +1,46 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./Cache"), module.exports);
+__reExport(index_exports, require("./casing"), module.exports);
+__reExport(index_exports, require("./client-config"), module.exports);
+__reExport(index_exports, require("./Dictionary"), module.exports);
+__reExport(index_exports, require("./dmmf"), module.exports);
+__reExport(index_exports, require("./enums"), module.exports);
+__reExport(index_exports, require("./lazyProperty"), module.exports);
+__reExport(index_exports, require("./omit"), module.exports);
+__reExport(index_exports, require("./operations"), module.exports);
+__reExport(index_exports, require("./QueryCompiler"), module.exports);
+__reExport(index_exports, require("./QueryEngine"), module.exports);
+__reExport(index_exports, require("./runtimeDataModel"), module.exports);
+__reExport(index_exports, require("./uniqueBy"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./Cache"),
+  ...require("./casing"),
+  ...require("./client-config"),
+  ...require("./Dictionary"),
+  ...require("./dmmf"),
+  ...require("./enums"),
+  ...require("./lazyProperty"),
+  ...require("./omit"),
+  ...require("./operations"),
+  ...require("./QueryCompiler"),
+  ...require("./QueryEngine"),
+  ...require("./runtimeDataModel"),
+  ...require("./uniqueBy")
+});

package/dist/index.mjs

@@ -0,0 +1,13 @@
+export * from "./Cache";
+export * from "./casing";
+export * from "./client-config";
+export * from "./Dictionary";
+export * from "./dmmf";
+export * from "./enums";
+export * from "./lazyProperty";
+export * from "./omit";
+export * from "./operations";
+export * from "./QueryCompiler";
+export * from "./QueryEngine";
+export * from "./runtimeDataModel";
+export * from "./uniqueBy";

package/dist/lazyProperty.d.ts

@@ -0,0 +1,4 @@
+export type LazyProperty<T> = {
+    get: () => T;
+};
+export declare function lazyProperty<T>(compute: () => T): LazyProperty<T>;

package/dist/lazyProperty.js

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lazyProperty_exports = {};
+__export(lazyProperty_exports, {
+  lazyProperty: () => lazyProperty
+});
+module.exports = __toCommonJS(lazyProperty_exports);
+function lazyProperty(compute) {
+  let resultContainer;
+  return {
+    get() {
+      if (resultContainer) {
+        return resultContainer.value;
+      }
+      resultContainer = { value: compute() };
+      return resultContainer.value;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  lazyProperty
+});

package/dist/lazyProperty.mjs

@@ -0,0 +1,15 @@
+function lazyProperty(compute) {
+  let resultContainer;
+  return {
+    get() {
+      if (resultContainer) {
+        return resultContainer.value;
+      }
+      resultContainer = { value: compute() };
+      return resultContainer.value;
+    }
+  };
+}
+export {
+  lazyProperty
+};

package/dist/lazyProperty.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lazyProperty.test.js

@@ -0,0 +1,28 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_lazyProperty = require("./lazyProperty");
+(0, import_vitest.test)("returns callback value", () => {
+  const prop = (0, import_lazyProperty.lazyProperty)(import_vitest.vi.fn().mockReturnValue(123));
+  (0, import_vitest.expect)(prop.get()).toBe(123);
+});
+(0, import_vitest.test)("computes property only once", () => {
+  const compute = import_vitest.vi.fn().mockReturnValue(123);
+  const prop = (0, import_lazyProperty.lazyProperty)(compute);
+  prop.get();
+  prop.get();
+  (0, import_vitest.expect)(compute).toHaveBeenCalledTimes(1);
+});
+(0, import_vitest.test)("caches undefined values", () => {
+  const compute = import_vitest.vi.fn().mockReturnValue(void 0);
+  const prop = (0, import_lazyProperty.lazyProperty)(compute);
+  prop.get();
+  prop.get();
+  (0, import_vitest.expect)(compute).toHaveBeenCalledTimes(1);
+});
+(0, import_vitest.test)("caches null values", () => {
+  const compute = import_vitest.vi.fn().mockReturnValue(null);
+  const prop = (0, import_lazyProperty.lazyProperty)(compute);
+  prop.get();
+  prop.get();
+  (0, import_vitest.expect)(compute).toHaveBeenCalledTimes(1);
+});

package/dist/lazyProperty.test.mjs

@@ -0,0 +1,27 @@
+import { expect, test, vi } from "vitest";
+import { lazyProperty } from "./lazyProperty";
+test("returns callback value", () => {
+  const prop = lazyProperty(vi.fn().mockReturnValue(123));
+  expect(prop.get()).toBe(123);
+});
+test("computes property only once", () => {
+  const compute = vi.fn().mockReturnValue(123);
+  const prop = lazyProperty(compute);
+  prop.get();
+  prop.get();
+  expect(compute).toHaveBeenCalledTimes(1);
+});
+test("caches undefined values", () => {
+  const compute = vi.fn().mockReturnValue(void 0);
+  const prop = lazyProperty(compute);
+  prop.get();
+  prop.get();
+  expect(compute).toHaveBeenCalledTimes(1);
+});
+test("caches null values", () => {
+  const compute = vi.fn().mockReturnValue(null);
+  const prop = lazyProperty(compute);
+  prop.get();
+  prop.get();
+  expect(compute).toHaveBeenCalledTimes(1);
+});

package/dist/omit.d.ts

@@ -0,0 +1 @@
+export declare function omit<T extends object, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;

package/dist/omit.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var omit_exports = {};
+__export(omit_exports, {
+  omit: () => omit
+});
+module.exports = __toCommonJS(omit_exports);
+function omit(obj, keys) {
+  return Object.fromEntries(Object.entries(obj).filter(([key, _]) => !keys.includes(key)));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  omit
+});

package/dist/omit.mjs

@@ -0,0 +1,6 @@
+function omit(obj, keys) {
+  return Object.fromEntries(Object.entries(obj).filter(([key, _]) => !keys.includes(key)));
+}
+export {
+  omit
+};

package/dist/omit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/omit.test.js

@@ -0,0 +1,46 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_omit = require("./omit");
+(0, import_vitest.describe)("omit", () => {
+  (0, import_vitest.it)("should remove specified keys from an object", () => {
+    const obj = { a: 1, b: 2, c: 3 };
+    const result = (0, import_omit.omit)(obj, ["a", "c"]);
+    (0, import_vitest.expect)(result).toEqual({ b: 2 });
+    (0, import_vitest.expect)(result).not.toHaveProperty("a");
+    (0, import_vitest.expect)(result).not.toHaveProperty("c");
+  });
+  (0, import_vitest.it)("should return the original object when no keys are provided", () => {
+    const obj = { a: 1, b: 2, c: 3 };
+    const result = (0, import_omit.omit)(obj, []);
+    (0, import_vitest.expect)(result).toEqual(obj);
+  });
+  (0, import_vitest.it)("should handle when keys to omit do not exist in the object", () => {
+    const obj = { a: 1, b: 2 };
+    const result = (0, import_omit.omit)(obj, ["c"]);
+    (0, import_vitest.expect)(result).toEqual(obj);
+  });
+  (0, import_vitest.it)("should work with complex object values", () => {
+    const obj = {
+      a: { nested: true },
+      b: [1, 2, 3],
+      c: "string",
+      d: null
+    };
+    const result = (0, import_omit.omit)(obj, ["b", "d"]);
+    (0, import_vitest.expect)(result).toEqual({
+      a: { nested: true },
+      c: "string"
+    });
+  });
+  (0, import_vitest.it)("should preserve the reference of non-primitive values", () => {
+    const nestedObj = { nested: true };
+    const obj = { a: nestedObj, b: 2 };
+    const result = (0, import_omit.omit)(obj, ["b"]);
+    (0, import_vitest.expect)(result.a).toBe(nestedObj);
+  });
+  (0, import_vitest.it)("should handle empty objects", () => {
+    const obj = {};
+    const result = (0, import_omit.omit)(obj, ["a"]);
+    (0, import_vitest.expect)(result).toEqual({});
+  });
+});

package/dist/omit.test.mjs

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+import { omit } from "./omit";
+describe("omit", () => {
+  it("should remove specified keys from an object", () => {
+    const obj = { a: 1, b: 2, c: 3 };
+    const result = omit(obj, ["a", "c"]);
+    expect(result).toEqual({ b: 2 });
+    expect(result).not.toHaveProperty("a");
+    expect(result).not.toHaveProperty("c");
+  });
+  it("should return the original object when no keys are provided", () => {
+    const obj = { a: 1, b: 2, c: 3 };
+    const result = omit(obj, []);
+    expect(result).toEqual(obj);
+  });
+  it("should handle when keys to omit do not exist in the object", () => {
+    const obj = { a: 1, b: 2 };
+    const result = omit(obj, ["c"]);
+    expect(result).toEqual(obj);
+  });
+  it("should work with complex object values", () => {
+    const obj = {
+      a: { nested: true },
+      b: [1, 2, 3],
+      c: "string",
+      d: null
+    };
+    const result = omit(obj, ["b", "d"]);
+    expect(result).toEqual({
+      a: { nested: true },
+      c: "string"
+    });
+  });
+  it("should preserve the reference of non-primitive values", () => {
+    const nestedObj = { nested: true };
+    const obj = { a: nestedObj, b: 2 };
+    const result = omit(obj, ["b"]);
+    expect(result.a).toBe(nestedObj);
+  });
+  it("should handle empty objects", () => {
+    const obj = {};
+    const result = omit(obj, ["a"]);
+    expect(result).toEqual({});
+  });
+});

package/dist/operations.d.ts

@@ -0,0 +1,3 @@
+export type Operation = 'findFirst' | 'findFirstOrThrow' | 'findUnique' | 'findUniqueOrThrow' | 'findMany' | 'create' | 'createMany' | 'createManyAndReturn' | 'update' | 'updateMany' | 'updateManyAndReturn' | 'upsert' | 'delete' | 'deleteMany' | 'aggregate' | 'count' | 'groupBy' | '$queryRaw' | '$executeRaw' | '$queryRawUnsafe' | '$executeRawUnsafe' | 'findRaw' | 'aggregateRaw' | '$runCommandRaw';
+export type FluentOperation = 'findUnique' | 'findUniqueOrThrow' | 'findFirst' | 'findFirstOrThrow' | 'create' | 'update' | 'upsert' | 'delete';
+export type NonModelOperation = '$queryRaw' | '$queryRawTyped' | '$queryRawUnsafe' | '$executeRaw' | '$executeRawUnsafe' | '$runCommandRaw';

package/dist/operations.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var operations_exports = {};
+module.exports = __toCommonJS(operations_exports);

package/dist/runtimeDataModel.d.ts

@@ -0,0 +1,28 @@
+import type * as DMMF from '@prisma/dmmf';
+export type RuntimeModel = Omit<DMMF.Model, 'name'>;
+export type RuntimeEnum = Omit<DMMF.DatamodelEnum, 'name'>;
+export type RuntimeDataModel = {
+    readonly models: Record<string, RuntimeModel>;
+    readonly enums: Record<string, RuntimeEnum>;
+    readonly types: Record<string, RuntimeModel>;
+};
+export type PrunedRuntimeModel = {
+    readonly dbName: RuntimeModel['dbName'];
+    readonly fields: Pick<RuntimeModel['fields'][number], 'name' | 'kind' | 'type' | 'relationName' | 'dbName'>[];
+};
+export type PrunedRuntimeDataModel = {
+    readonly models: Record<string, PrunedRuntimeModel>;
+    readonly enums: {};
+    readonly types: {};
+};
+export declare function dmmfToRuntimeDataModel(dmmfDataModel: DMMF.Datamodel): RuntimeDataModel;
+/**
+ * Minimal version of the runtime datamodel for the Client to work
+ * @param runtimeDataModel
+ * @returns
+ */
+export declare function pruneRuntimeDataModel({ models }: RuntimeDataModel): {
+    models: Record<string, PrunedRuntimeModel>;
+    enums: {};
+    types: {};
+};

package/dist/runtimeDataModel.js

@@ -0,0 +1,53 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var runtimeDataModel_exports = {};
+__export(runtimeDataModel_exports, {
+  dmmfToRuntimeDataModel: () => dmmfToRuntimeDataModel,
+  pruneRuntimeDataModel: () => pruneRuntimeDataModel
+});
+module.exports = __toCommonJS(runtimeDataModel_exports);
+function dmmfToRuntimeDataModel(dmmfDataModel) {
+  return {
+    models: buildMapForRuntime(dmmfDataModel.models),
+    enums: buildMapForRuntime(dmmfDataModel.enums),
+    types: buildMapForRuntime(dmmfDataModel.types)
+  };
+}
+function pruneRuntimeDataModel({ models }) {
+  const prunedModels = {};
+  for (const modelName of Object.keys(models)) {
+    prunedModels[modelName] = { fields: [], dbName: models[modelName].dbName };
+    for (const { name, kind, type, relationName, dbName } of models[modelName].fields) {
+      prunedModels[modelName].fields.push({ name, kind, type, relationName, dbName });
+    }
+  }
+  return { models: prunedModels, enums: {}, types: {} };
+}
+function buildMapForRuntime(list) {
+  const result = {};
+  for (const { name, ...rest } of list) {
+    result[name] = rest;
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dmmfToRuntimeDataModel,
+  pruneRuntimeDataModel
+});

package/dist/runtimeDataModel.mjs

@@ -0,0 +1,28 @@
+function dmmfToRuntimeDataModel(dmmfDataModel) {
+  return {
+    models: buildMapForRuntime(dmmfDataModel.models),
+    enums: buildMapForRuntime(dmmfDataModel.enums),
+    types: buildMapForRuntime(dmmfDataModel.types)
+  };
+}
+function pruneRuntimeDataModel({ models }) {
+  const prunedModels = {};
+  for (const modelName of Object.keys(models)) {
+    prunedModels[modelName] = { fields: [], dbName: models[modelName].dbName };
+    for (const { name, kind, type, relationName, dbName } of models[modelName].fields) {
+      prunedModels[modelName].fields.push({ name, kind, type, relationName, dbName });
+    }
+  }
+  return { models: prunedModels, enums: {}, types: {} };
+}
+function buildMapForRuntime(list) {
+  const result = {};
+  for (const { name, ...rest } of list) {
+    result[name] = rest;
+  }
+  return result;
+}
+export {
+  dmmfToRuntimeDataModel,
+  pruneRuntimeDataModel
+};

package/dist/uniqueBy.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns unique elements of array
+ * @param arr Array
+ */
+export declare function uniqueBy<T>(arr: readonly T[], callee: (element: T) => string): T[];