@prisma/dmmf 0.1.26 → 6.6.0-dev.50

package/dist/index.d.mts

@@ -0,0 +1,279 @@
+export declare type Datamodel = ReadonlyDeep<{
+    models: Model[];
+    enums: DatamodelEnum[];
+    types: Model[];
+    indexes: Index[];
+}>;
+
+export declare type DatamodelEnum = ReadonlyDeep<{
+    name: string;
+    values: EnumValue[];
+    dbName?: string | null;
+    documentation?: string;
+}>;
+
+export declare function datamodelEnumToSchemaEnum(datamodelEnum: DatamodelEnum): SchemaEnum;
+
+export declare type Deprecation = ReadonlyDeep<{
+    sinceVersion: string;
+    reason: string;
+    plannedRemovalVersion?: string;
+}>;
+
+declare type Document_2 = ReadonlyDeep<{
+    datamodel: Datamodel;
+    schema: Schema;
+    mappings: Mappings;
+}>;
+export { Document_2 as Document }
+
+export declare type EnumValue = ReadonlyDeep<{
+    name: string;
+    dbName: string | null;
+}>;
+
+export declare type Field = ReadonlyDeep<{
+    kind: FieldKind;
+    name: string;
+    isRequired: boolean;
+    isList: boolean;
+    isUnique: boolean;
+    isId: boolean;
+    isReadOnly: boolean;
+    isGenerated?: boolean;
+    isUpdatedAt?: boolean;
+    /**
+     * Describes the data type in the same the way it is defined in the Prisma schema:
+     * BigInt, Boolean, Bytes, DateTime, Decimal, Float, Int, JSON, String, $ModelName
+     */
+    type: string;
+    /**
+     * Native database type, if specified.
+     * For example, `@db.VarChar(191)` is encoded as `['VarChar', ['191']]`,
+     * `@db.Text` is encoded as `['Text', []]`.
+     */
+    nativeType?: [string, string[]] | null;
+    dbName?: string | null;
+    hasDefaultValue: boolean;
+    default?: FieldDefault | FieldDefaultScalar | FieldDefaultScalar[];
+    relationFromFields?: string[];
+    relationToFields?: string[];
+    relationOnDelete?: string;
+    relationOnUpdate?: string;
+    relationName?: string;
+    documentation?: string;
+}>;
+
+export declare type FieldDefault = ReadonlyDeep<{
+    name: string;
+    args: Array<string | number>;
+}>;
+
+export declare type FieldDefaultScalar = string | boolean | number;
+
+export declare type FieldKind = 'scalar' | 'object' | 'enum' | 'unsupported';
+
+export declare type FieldLocation = 'scalar' | 'inputObjectTypes' | 'outputObjectTypes' | 'enumTypes' | 'fieldRefTypes';
+
+export declare type FieldNamespace = 'model' | 'prisma';
+
+export declare type FieldRefAllowType = TypeRef<'scalar' | 'enumTypes'>;
+
+export declare type FieldRefType = ReadonlyDeep<{
+    name: string;
+    allowTypes: FieldRefAllowType[];
+    fields: SchemaArg[];
+}>;
+
+export declare type Index = ReadonlyDeep<{
+    model: string;
+    type: IndexType;
+    isDefinedOnField: boolean;
+    name?: string;
+    dbName?: string;
+    algorithm?: string;
+    clustered?: boolean;
+    fields: IndexField[];
+}>;
+
+export declare type IndexField = ReadonlyDeep<{
+    name: string;
+    sortOrder?: SortOrder;
+    length?: number;
+    operatorClass?: string;
+}>;
+
+export declare type IndexType = 'id' | 'normal' | 'unique' | 'fulltext';
+
+export declare type InputType = ReadonlyDeep<{
+    name: string;
+    constraints: {
+        maxNumFields: number | null;
+        minNumFields: number | null;
+        fields?: string[];
+    };
+    meta?: {
+        source?: string;
+    };
+    fields: SchemaArg[];
+}>;
+
+export declare type InputTypeRef = TypeRef<'scalar' | 'inputObjectTypes' | 'enumTypes' | 'fieldRefTypes'>;
+
+export declare type Mappings = ReadonlyDeep<{
+    modelOperations: ModelMapping[];
+    otherOperations: {
+        read: string[];
+        write: string[];
+    };
+}>;
+
+export declare type Model = ReadonlyDeep<{
+    name: string;
+    dbName: string | null;
+    schema: string | null;
+    fields: Field[];
+    uniqueFields: string[][];
+    uniqueIndexes: uniqueIndex[];
+    documentation?: string;
+    primaryKey: PrimaryKey | null;
+    isGenerated?: boolean;
+}>;
+
+export declare enum ModelAction {
+    findUnique = "findUnique",
+    findUniqueOrThrow = "findUniqueOrThrow",
+    findFirst = "findFirst",
+    findFirstOrThrow = "findFirstOrThrow",
+    findMany = "findMany",
+    create = "create",
+    createMany = "createMany",
+    createManyAndReturn = "createManyAndReturn",
+    update = "update",
+    updateMany = "updateMany",
+    updateManyAndReturn = "updateManyAndReturn",
+    upsert = "upsert",
+    delete = "delete",
+    deleteMany = "deleteMany",
+    groupBy = "groupBy",
+    count = "count",// TODO: count does not actually exist in DMMF
+    aggregate = "aggregate",
+    findRaw = "findRaw",
+    aggregateRaw = "aggregateRaw"
+}
+
+export declare type ModelMapping = ReadonlyDeep<{
+    model: string;
+    plural: string;
+    findUnique?: string | null;
+    findUniqueOrThrow?: string | null;
+    findFirst?: string | null;
+    findFirstOrThrow?: string | null;
+    findMany?: string | null;
+    create?: string | null;
+    createMany?: string | null;
+    createManyAndReturn?: string | null;
+    update?: string | null;
+    updateMany?: string | null;
+    updateManyAndReturn?: string | null;
+    upsert?: string | null;
+    delete?: string | null;
+    deleteMany?: string | null;
+    aggregate?: string | null;
+    groupBy?: string | null;
+    count?: string | null;
+    findRaw?: string | null;
+    aggregateRaw?: string | null;
+}>;
+
+export declare type OtherOperationMappings = ReadonlyDeep<{
+    read: string[];
+    write: string[];
+}>;
+
+export declare type OutputType = ReadonlyDeep<{
+    name: string;
+    fields: SchemaField[];
+}>;
+
+export declare type OutputTypeRef = TypeRef<'scalar' | 'outputObjectTypes' | 'enumTypes'>;
+
+export declare type PrimaryKey = ReadonlyDeep<{
+    name: string | null;
+    fields: string[];
+}>;
+
+export declare type Query = ReadonlyDeep<{
+    name: string;
+    args: SchemaArg[];
+    output: QueryOutput;
+}>;
+
+export declare type QueryOutput = ReadonlyDeep<{
+    name: string;
+    isRequired: boolean;
+    isList: boolean;
+}>;
+
+declare type ReadonlyDeep<O> = {
+    +readonly [K in keyof O]: ReadonlyDeep<O[K]>;
+};
+
+export declare type Schema = ReadonlyDeep<{
+    rootQueryType?: string;
+    rootMutationType?: string;
+    inputObjectTypes: {
+        model?: InputType[];
+        prisma: InputType[];
+    };
+    outputObjectTypes: {
+        model: OutputType[];
+        prisma: OutputType[];
+    };
+    enumTypes: {
+        model?: SchemaEnum[];
+        prisma: SchemaEnum[];
+    };
+    fieldRefTypes: {
+        prisma?: FieldRefType[];
+    };
+}>;
+
+export declare type SchemaArg = ReadonlyDeep<{
+    name: string;
+    comment?: string;
+    isNullable: boolean;
+    isRequired: boolean;
+    inputTypes: InputTypeRef[];
+    deprecation?: Deprecation;
+}>;
+
+export declare type SchemaEnum = ReadonlyDeep<{
+    name: string;
+    values: string[];
+}>;
+
+export declare type SchemaField = ReadonlyDeep<{
+    name: string;
+    isNullable?: boolean;
+    outputType: OutputTypeRef;
+    args: SchemaArg[];
+    deprecation?: Deprecation;
+    documentation?: string;
+}>;
+
+export declare type SortOrder = 'asc' | 'desc';
+
+export declare type TypeRef<AllowedLocations extends FieldLocation> = {
+    isList: boolean;
+    type: string;
+    location: AllowedLocations;
+    namespace?: FieldNamespace;
+};
+
+export declare type uniqueIndex = ReadonlyDeep<{
+    name: string;
+    fields: string[];
+}>;
+
+export { }

package/dist/index.d.ts

@@ -1 +1,279 @@
-export { DMMF } from './DMMF';
+export declare type Datamodel = ReadonlyDeep<{
+    models: Model[];
+    enums: DatamodelEnum[];
+    types: Model[];
+    indexes: Index[];
+}>;
+
+export declare type DatamodelEnum = ReadonlyDeep<{
+    name: string;
+    values: EnumValue[];
+    dbName?: string | null;
+    documentation?: string;
+}>;
+
+export declare function datamodelEnumToSchemaEnum(datamodelEnum: DatamodelEnum): SchemaEnum;
+
+export declare type Deprecation = ReadonlyDeep<{
+    sinceVersion: string;
+    reason: string;
+    plannedRemovalVersion?: string;
+}>;
+
+declare type Document_2 = ReadonlyDeep<{
+    datamodel: Datamodel;
+    schema: Schema;
+    mappings: Mappings;
+}>;
+export { Document_2 as Document }
+
+export declare type EnumValue = ReadonlyDeep<{
+    name: string;
+    dbName: string | null;
+}>;
+
+export declare type Field = ReadonlyDeep<{
+    kind: FieldKind;
+    name: string;
+    isRequired: boolean;
+    isList: boolean;
+    isUnique: boolean;
+    isId: boolean;
+    isReadOnly: boolean;
+    isGenerated?: boolean;
+    isUpdatedAt?: boolean;
+    /**
+     * Describes the data type in the same the way it is defined in the Prisma schema:
+     * BigInt, Boolean, Bytes, DateTime, Decimal, Float, Int, JSON, String, $ModelName
+     */
+    type: string;
+    /**
+     * Native database type, if specified.
+     * For example, `@db.VarChar(191)` is encoded as `['VarChar', ['191']]`,
+     * `@db.Text` is encoded as `['Text', []]`.
+     */
+    nativeType?: [string, string[]] | null;
+    dbName?: string | null;
+    hasDefaultValue: boolean;
+    default?: FieldDefault | FieldDefaultScalar | FieldDefaultScalar[];
+    relationFromFields?: string[];
+    relationToFields?: string[];
+    relationOnDelete?: string;
+    relationOnUpdate?: string;
+    relationName?: string;
+    documentation?: string;
+}>;
+
+export declare type FieldDefault = ReadonlyDeep<{
+    name: string;
+    args: Array<string | number>;
+}>;
+
+export declare type FieldDefaultScalar = string | boolean | number;
+
+export declare type FieldKind = 'scalar' | 'object' | 'enum' | 'unsupported';
+
+export declare type FieldLocation = 'scalar' | 'inputObjectTypes' | 'outputObjectTypes' | 'enumTypes' | 'fieldRefTypes';
+
+export declare type FieldNamespace = 'model' | 'prisma';
+
+export declare type FieldRefAllowType = TypeRef<'scalar' | 'enumTypes'>;
+
+export declare type FieldRefType = ReadonlyDeep<{
+    name: string;
+    allowTypes: FieldRefAllowType[];
+    fields: SchemaArg[];
+}>;
+
+export declare type Index = ReadonlyDeep<{
+    model: string;
+    type: IndexType;
+    isDefinedOnField: boolean;
+    name?: string;
+    dbName?: string;
+    algorithm?: string;
+    clustered?: boolean;
+    fields: IndexField[];
+}>;
+
+export declare type IndexField = ReadonlyDeep<{
+    name: string;
+    sortOrder?: SortOrder;
+    length?: number;
+    operatorClass?: string;
+}>;
+
+export declare type IndexType = 'id' | 'normal' | 'unique' | 'fulltext';
+
+export declare type InputType = ReadonlyDeep<{
+    name: string;
+    constraints: {
+        maxNumFields: number | null;
+        minNumFields: number | null;
+        fields?: string[];
+    };
+    meta?: {
+        source?: string;
+    };
+    fields: SchemaArg[];
+}>;
+
+export declare type InputTypeRef = TypeRef<'scalar' | 'inputObjectTypes' | 'enumTypes' | 'fieldRefTypes'>;
+
+export declare type Mappings = ReadonlyDeep<{
+    modelOperations: ModelMapping[];
+    otherOperations: {
+        read: string[];
+        write: string[];
+    };
+}>;
+
+export declare type Model = ReadonlyDeep<{
+    name: string;
+    dbName: string | null;
+    schema: string | null;
+    fields: Field[];
+    uniqueFields: string[][];
+    uniqueIndexes: uniqueIndex[];
+    documentation?: string;
+    primaryKey: PrimaryKey | null;
+    isGenerated?: boolean;
+}>;
+
+export declare enum ModelAction {
+    findUnique = "findUnique",
+    findUniqueOrThrow = "findUniqueOrThrow",
+    findFirst = "findFirst",
+    findFirstOrThrow = "findFirstOrThrow",
+    findMany = "findMany",
+    create = "create",
+    createMany = "createMany",
+    createManyAndReturn = "createManyAndReturn",
+    update = "update",
+    updateMany = "updateMany",
+    updateManyAndReturn = "updateManyAndReturn",
+    upsert = "upsert",
+    delete = "delete",
+    deleteMany = "deleteMany",
+    groupBy = "groupBy",
+    count = "count",// TODO: count does not actually exist in DMMF
+    aggregate = "aggregate",
+    findRaw = "findRaw",
+    aggregateRaw = "aggregateRaw"
+}
+
+export declare type ModelMapping = ReadonlyDeep<{
+    model: string;
+    plural: string;
+    findUnique?: string | null;
+    findUniqueOrThrow?: string | null;
+    findFirst?: string | null;
+    findFirstOrThrow?: string | null;
+    findMany?: string | null;
+    create?: string | null;
+    createMany?: string | null;
+    createManyAndReturn?: string | null;
+    update?: string | null;
+    updateMany?: string | null;
+    updateManyAndReturn?: string | null;
+    upsert?: string | null;
+    delete?: string | null;
+    deleteMany?: string | null;
+    aggregate?: string | null;
+    groupBy?: string | null;
+    count?: string | null;
+    findRaw?: string | null;
+    aggregateRaw?: string | null;
+}>;
+
+export declare type OtherOperationMappings = ReadonlyDeep<{
+    read: string[];
+    write: string[];
+}>;
+
+export declare type OutputType = ReadonlyDeep<{
+    name: string;
+    fields: SchemaField[];
+}>;
+
+export declare type OutputTypeRef = TypeRef<'scalar' | 'outputObjectTypes' | 'enumTypes'>;
+
+export declare type PrimaryKey = ReadonlyDeep<{
+    name: string | null;
+    fields: string[];
+}>;
+
+export declare type Query = ReadonlyDeep<{
+    name: string;
+    args: SchemaArg[];
+    output: QueryOutput;
+}>;
+
+export declare type QueryOutput = ReadonlyDeep<{
+    name: string;
+    isRequired: boolean;
+    isList: boolean;
+}>;
+
+declare type ReadonlyDeep<O> = {
+    +readonly [K in keyof O]: ReadonlyDeep<O[K]>;
+};
+
+export declare type Schema = ReadonlyDeep<{
+    rootQueryType?: string;
+    rootMutationType?: string;
+    inputObjectTypes: {
+        model?: InputType[];
+        prisma: InputType[];
+    };
+    outputObjectTypes: {
+        model: OutputType[];
+        prisma: OutputType[];
+    };
+    enumTypes: {
+        model?: SchemaEnum[];
+        prisma: SchemaEnum[];
+    };
+    fieldRefTypes: {
+        prisma?: FieldRefType[];
+    };
+}>;
+
+export declare type SchemaArg = ReadonlyDeep<{
+    name: string;
+    comment?: string;
+    isNullable: boolean;
+    isRequired: boolean;
+    inputTypes: InputTypeRef[];
+    deprecation?: Deprecation;
+}>;
+
+export declare type SchemaEnum = ReadonlyDeep<{
+    name: string;
+    values: string[];
+}>;
+
+export declare type SchemaField = ReadonlyDeep<{
+    name: string;
+    isNullable?: boolean;
+    outputType: OutputTypeRef;
+    args: SchemaArg[];
+    deprecation?: Deprecation;
+    documentation?: string;
+}>;
+
+export declare type SortOrder = 'asc' | 'desc';
+
+export declare type TypeRef<AllowedLocations extends FieldLocation> = {
+    isList: boolean;
+    type: string;
+    location: AllowedLocations;
+    namespace?: FieldNamespace;
+};
+
+export declare type uniqueIndex = ReadonlyDeep<{
+    name: string;
+    fields: string[];
+}>;
+
+export { }

package/dist/index.js

@@ -1,5 +1,63 @@
 "use strict";
-exports.__esModule = true;
-var DMMF_1 = require("./DMMF");
-exports.DMMF = DMMF_1.DMMF;
-//# sourceMappingURL=index.js.map
+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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ModelAction: () => ModelAction,
+  datamodelEnumToSchemaEnum: () => datamodelEnumToSchemaEnum
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/convert.ts
+function datamodelEnumToSchemaEnum(datamodelEnum) {
+  return {
+    name: datamodelEnum.name,
+    values: datamodelEnum.values.map((v) => v.name)
+  };
+}
+
+// src/dmmf.ts
+var ModelAction = /* @__PURE__ */ ((ModelAction2) => {
+  ModelAction2["findUnique"] = "findUnique";
+  ModelAction2["findUniqueOrThrow"] = "findUniqueOrThrow";
+  ModelAction2["findFirst"] = "findFirst";
+  ModelAction2["findFirstOrThrow"] = "findFirstOrThrow";
+  ModelAction2["findMany"] = "findMany";
+  ModelAction2["create"] = "create";
+  ModelAction2["createMany"] = "createMany";
+  ModelAction2["createManyAndReturn"] = "createManyAndReturn";
+  ModelAction2["update"] = "update";
+  ModelAction2["updateMany"] = "updateMany";
+  ModelAction2["updateManyAndReturn"] = "updateManyAndReturn";
+  ModelAction2["upsert"] = "upsert";
+  ModelAction2["delete"] = "delete";
+  ModelAction2["deleteMany"] = "deleteMany";
+  ModelAction2["groupBy"] = "groupBy";
+  ModelAction2["count"] = "count";
+  ModelAction2["aggregate"] = "aggregate";
+  ModelAction2["findRaw"] = "findRaw";
+  ModelAction2["aggregateRaw"] = "aggregateRaw";
+  return ModelAction2;
+})(ModelAction || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ModelAction,
+  datamodelEnumToSchemaEnum
+});

package/dist/index.mjs

@@ -0,0 +1,35 @@
+// src/convert.ts
+function datamodelEnumToSchemaEnum(datamodelEnum) {
+  return {
+    name: datamodelEnum.name,
+    values: datamodelEnum.values.map((v) => v.name)
+  };
+}
+
+// src/dmmf.ts
+var ModelAction = /* @__PURE__ */ ((ModelAction2) => {
+  ModelAction2["findUnique"] = "findUnique";
+  ModelAction2["findUniqueOrThrow"] = "findUniqueOrThrow";
+  ModelAction2["findFirst"] = "findFirst";
+  ModelAction2["findFirstOrThrow"] = "findFirstOrThrow";
+  ModelAction2["findMany"] = "findMany";
+  ModelAction2["create"] = "create";
+  ModelAction2["createMany"] = "createMany";
+  ModelAction2["createManyAndReturn"] = "createManyAndReturn";
+  ModelAction2["update"] = "update";
+  ModelAction2["updateMany"] = "updateMany";
+  ModelAction2["updateManyAndReturn"] = "updateManyAndReturn";
+  ModelAction2["upsert"] = "upsert";
+  ModelAction2["delete"] = "delete";
+  ModelAction2["deleteMany"] = "deleteMany";
+  ModelAction2["groupBy"] = "groupBy";
+  ModelAction2["count"] = "count";
+  ModelAction2["aggregate"] = "aggregate";
+  ModelAction2["findRaw"] = "findRaw";
+  ModelAction2["aggregateRaw"] = "aggregateRaw";
+  return ModelAction2;
+})(ModelAction || {});
+export {
+  ModelAction,
+  datamodelEnumToSchemaEnum
+};

package/dist/util.d.ts

@@ -1,7 +1,3 @@
-import Enum from './Enum';
-import { EnumMap } from './types';
-export declare type Dictionary<T> = {
-    [key: string]: T;
+export type ReadonlyDeep<O> = {
+    +readonly [K in keyof O]: ReadonlyDeep<O[K]>;
 };
-export declare const keyBy: <T>(collection: Array<T>, iteratee: (value: T) => string) => Dictionary<T>;
-export declare function getEnumMap(enums: Enum[]): EnumMap;