@tommasomeli/prisma-generator-nestjs-dto 0.1.3

package/dist/index.cjs

@@ -0,0 +1,1539 @@
+'use strict';
+
+var path = require('path');
+var fs3 = require('fs');
+var chalk = require('chalk');
+var prettier = require('prettier');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+var fs3__default = /*#__PURE__*/_interopDefault(fs3);
+var chalk__default = /*#__PURE__*/_interopDefault(chalk);
+var prettier__default = /*#__PURE__*/_interopDefault(prettier);
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/annotations.ts
+var DTO_IGNORE_MODEL = "DtoIgnoreModel";
+var DTO_API_EXTRA_MODELS = "DtoApiExtraModels";
+var DTO_READ_ONLY = "DtoReadOnly";
+var DTO_CREATE_HIDDEN = "DtoCreateHidden";
+var DTO_UPDATE_HIDDEN = "DtoUpdateHidden";
+var DTO_ENTITY_HIDDEN = "DtoEntityHidden";
+var DTO_API_HIDDEN = "DtoApiHidden";
+var DTO_HIDDEN = "DtoHidden";
+var DTO_CREATED_AT = "createdAt";
+var DTO_CREATE_OPTIONAL = "DtoCreateOptional";
+var DTO_CREATE_REQUIRED = "DtoCreateRequired";
+var DTO_UPDATE_OPTIONAL = "DtoUpdateOptional";
+var DTO_UPDATE_REQUIRED = "DtoUpdateRequired";
+var DTO_OVERRIDE_TYPE = "DtoOverrideType";
+var DTO_OVERRIDE_API_PROPERTY_TYPE = "DtoOverrideApiPropertyType";
+var DTO_CREATE_VALIDATE_IF = "DtoCreateValidateIf";
+var DTO_UPDATE_VALIDATE_IF = "DtoUpdateValidateIf";
+var ENTITY_HIDDEN_ANNOTATIONS = [DTO_HIDDEN, DTO_ENTITY_HIDDEN, DTO_API_HIDDEN];
+var ENTITY_HIDDEN_SET = new Set(ENTITY_HIDDEN_ANNOTATIONS);
+function isEntityHidden(field) {
+  if (field.annotations) return field.annotations.some((a) => ENTITY_HIDDEN_SET.has(a.name));
+  if (!field.documentation) return false;
+  return ENTITY_HIDDEN_ANNOTATIONS.some((name) => new RegExp(`@${name}\\b`).test(field.documentation));
+}
+
+// src/constants.ts
+var ANNOTATION_NAME_REGEX = /@([A-Za-z][A-Za-z0-9_]*)/g;
+var ANNOTATION_PARAMS_REGEX = /\(\s*((?:[^()]*|\([^()]*\))*)\s*\)/;
+var ANNOTATION_PARAMS_SPLIT_REGEX = /,(?![^{]*})/;
+var PRISMA_SCALAR = {
+  String: "string",
+  Boolean: "boolean",
+  Int: "number",
+  BigInt: "bigint",
+  Float: "number",
+  Decimal: "Prisma.Decimal",
+  DateTime: "Date",
+  Bytes: "Buffer",
+  Json: "Prisma.JsonValue",
+  Object: "{ [key: string]: any }"
+};
+var PRISMA_SCALAR_TYPE = {
+  ...PRISMA_SCALAR,
+  Decimal: "number",
+  DateTime: "() => Date",
+  Bytes: "() => Buffer",
+  Json: "() => Object",
+  Object: "() => Object"
+};
+var PRISMA_SCALAR_FORMAT = {
+  String: { type: "string" },
+  Boolean: { type: "boolean" },
+  Int: { type: "integer", format: "int32" },
+  BigInt: { type: "integer", format: "int64" },
+  Float: { type: "number", format: "float" },
+  Decimal: { type: "string", format: "Decimal.js" },
+  DateTime: { type: "string", format: "date-time" }
+};
+var SWAGGER_DECORATORS = ["ApiHideProperty", "ApiProperty", "ApiPropertyOptional", "ApiPropertyRequired", "ApiExtraModels"];
+var SWAGGER_API_PROPERTY_DECORATORS = ["description", "minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "minLength", "maxLength", "minItems", "maxItems", "example"];
+var CLASS_TRANSFORMER_DECORATORS = ["Type", "Transform"];
+var CLASS_VALIDATOR_DECORATORS = [
+  "Allow",
+  "ArrayContains",
+  "ArrayMaxSize",
+  "ArrayMinSize",
+  "ArrayNotContains",
+  "ArrayNotEmpty",
+  "ArrayUnique",
+  "Contains",
+  "Equals",
+  "IsAlpha",
+  "IsAlphanumeric",
+  "IsArray",
+  "IsAscii",
+  "IsBIC",
+  "IsBase32",
+  "IsBase58",
+  "IsBase64",
+  "IsBoolean",
+  "IsBooleanString",
+  "IsBtcAddress",
+  "IsByteLength",
+  "IsCreditCard",
+  "IsCurrency",
+  "IsDataURI",
+  "IsDate",
+  "IsDateString",
+  "IsDecimal",
+  "IsDefined",
+  "IsDivisibleBy",
+  "IsEAN",
+  "IsEmail",
+  "IsEmpty",
+  "IsEthereumAddress",
+  "IsFQDN",
+  "IsFirebasePushId",
+  "IsFullWidth",
+  "IsHash",
+  "IsHSLColor",
+  "IsHexadecimal",
+  "IsIBAN",
+  "IsISIN",
+  "IsISO31661Alpha2",
+  "IsISO31661Alpha3",
+  "IsISO4217CurrencyCode",
+  "IsISO8601",
+  "IsISRC",
+  "IsISSN",
+  "IsIdentityCard",
+  "IsImage",
+  "IsIn",
+  "IsInstance",
+  "IsInt",
+  "IsIP",
+  "IsISBN",
+  "IsIsHalfWidth",
+  "IsIsHexColor",
+  "IsIsVariableWidth",
+  "IsJWT",
+  "IsJSON",
+  "IsLatLong",
+  "IsLatitude",
+  "IsLocale",
+  "IsLongitude",
+  "IsLowercase",
+  "IsMACAddress",
+  "IsMagnetURI",
+  "IsMilitaryTime",
+  "IsMimeType",
+  "IsMobilePhone",
+  "IsMongoId",
+  "IsMultiByte",
+  "IsNegative",
+  "IsNotEmpty",
+  "IsNotEmptyObject",
+  "IsNotIn",
+  "IsNumber",
+  "IsNumberString",
+  "IsObject",
+  "IsOctal",
+  "IsOptional",
+  "IsPassportNumber",
+  "IsPhoneNumber",
+  "IsPort",
+  "IsPositive",
+  "IsPostalCode",
+  "IsRFC3339",
+  "IsRgbColor",
+  "IsSemVer",
+  "IsString",
+  "IsStrongPassword",
+  "IsSurrogatePair",
+  "IsTaxId",
+  "IsTimeZone",
+  "IsUppercase",
+  "IsUrl",
+  "IsUUID",
+  "Length",
+  "Max",
+  "MaxDate",
+  "MaxLength",
+  "Matches",
+  "Min",
+  "MinDate",
+  "MinLength",
+  "NotContains",
+  "NotEquals",
+  "ValidateIf",
+  "ValidateNested"
+];
+var Utility = class _Utility {
+  static prefix = "prisma-generator-nestjs-dto";
+  /** Override the global log prefix (defaults to the package name). */
+  static setLogPrefix(prefix) {
+    this.prefix = prefix;
+  }
+  static log(message, ...data) {
+    console.info(`${chalk__default.default.cyan(this.prefix)} ${message}`, ...data);
+  }
+  static warn(message, ...data) {
+    console.info(chalk__default.default.yellowBright(`${this.prefix} ${message}`), ...data);
+  }
+  static error(message, ...data) {
+    console.error(chalk__default.default.redBright(`${this.prefix} ${message}`), ...data);
+  }
+  /**
+   * Parses a string into a boolean. Accepts native booleans and the Prisma-style
+   * stringified values that come from `schema.prisma` config options.
+   */
+  static parseBoolean(value) {
+    if (typeof value === "boolean") return value;
+    if (typeof value === "string") return value === "true" || value === "1" || value === "yes" || value === "on";
+    return false;
+  }
+  /**
+   * Parses one or more import declarations from the value of an `extra*` config option.
+   * The only supported syntax is the compact inline form:
+   *
+   * ```prisma
+   * extraValidators = "IsUnique,IsBool:src/common/validators|IsAdult:src/common/validators/is-adult"
+   * ```
+   *
+   * - `Foo,Bar:path` — named imports.
+   * - `* as Foo:path` — namespace import.
+   * - `default as Foo:path` — default import.
+   * - `|` — separator for multiple groups (different paths).
+   *
+   * For anything more elaborate (rename, default + named, type-safe paths, ...) use a
+   * `configFile` with `ImportDescriptor` or the `from()` / `fromNamespace()` / `fromDefault()`
+   * helpers.
+   *
+   * Also accepts an array of strings, with each entry already containing one or more
+   * `|`-separated groups.
+   */
+  static parseImports(value) {
+    if (value === void 0 || value === null) return [];
+    const items = Array.isArray(value) ? value : [value];
+    const out = [];
+    for (const item of items) {
+      const trimmed = item.trim();
+      if (!trimmed) continue;
+      if (trimmed.startsWith("import")) {
+        this.warn(
+          `ES import syntax is no longer supported in extra* options. Use "Name:path|Other:path2" or move to a configFile with ImportDescriptor / from() helpers. Got: ${trimmed}`
+        );
+        continue;
+      }
+      for (const entry of this.parseInlineImport(trimmed)) this.mergeInto(out, entry);
+    }
+    return out;
+  }
+  /**
+   * Parses `extraAnnotations` into a deduplicated list of annotation names.
+   * Accepts a single comma/whitespace-separated string, a string array, or a mix:
+   * `"@DtoFoo, DtoBar"`, `["DtoFoo", "DtoBar"]`, `"DtoFoo DtoBar"`. Leading `@`
+   * characters are stripped so plugin authors can refer to them either way.
+   */
+  static parseAnnotationNames(value) {
+    if (value === void 0 || value === null) return [];
+    const raw = Array.isArray(value) ? value : [value];
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const entry of raw) {
+      if (typeof entry !== "string") continue;
+      for (const piece of entry.split(/[,\s]+/)) {
+        const name = piece.replace(/^@/, "").trim();
+        if (!name || seen.has(name)) continue;
+        seen.add(name);
+        out.push(name);
+      }
+    }
+    return out;
+  }
+  /**
+   * Parses the `extraScalars` config value. Accepts a JSON string (the form emitted by
+   * {@link applyConfigFile}) or an already-parsed `Record<string, ScalarOverride>` object.
+   * Invalid entries are skipped with a warning rather than throwing.
+   */
+  static parseExtraScalars(value) {
+    if (!value) return {};
+    let parsed = value;
+    if (typeof value === "string") {
+      try {
+        parsed = JSON.parse(value);
+      } catch (error) {
+        _Utility.warn("Failed to parse extraScalars JSON, ignoring.", error);
+        return {};
+      }
+    }
+    if (!parsed || typeof parsed !== "object") return {};
+    const out = {};
+    for (const [scalar, raw] of Object.entries(parsed)) {
+      if (!raw || typeof raw !== "object") continue;
+      const override = raw;
+      if (typeof override.ts !== "string") {
+        _Utility.warn(`extraScalars["${scalar}"] is missing a string \`ts\` field, ignoring.`);
+        continue;
+      }
+      out[scalar] = {
+        ts: override.ts,
+        from: typeof override.from === "string" ? override.from : void 0,
+        apiType: typeof override.apiType === "string" ? override.apiType : void 0,
+        format: typeof override.format === "string" ? override.format : void 0
+      };
+    }
+    return out;
+  }
+  /**
+   * @deprecated Use {@link parseImports} instead. Kept for sub-generators that
+   * relied on the public name in earlier releases.
+   */
+  static stringToImports(value) {
+    return this.parseImports(value);
+  }
+  /** Parses the inline `Name1,Name2:path|Other:path2` syntax. */
+  static parseInlineImport(value) {
+    const out = [];
+    for (const group of value.split("|")) {
+      const lastColonIndex = group.lastIndexOf(":");
+      if (lastColonIndex === -1) {
+        this.warn(`Invalid import format: ${group}. Missing path after colon.`);
+        continue;
+      }
+      const from2 = group.substring(lastColonIndex + 1).trim();
+      const names = group.substring(0, lastColonIndex).trim();
+      if (names.includes("* as ") || names.includes("default as ")) {
+        out.push({ from: from2, alias: names });
+        continue;
+      }
+      const destruct = names.split(",").map((n) => n.trim()).filter(Boolean);
+      if (destruct.length === 0) {
+        this.warn(`Invalid import format: ${group}. No import names found.`);
+        continue;
+      }
+      out.push({ from: from2, destruct });
+    }
+    return out;
+  }
+  /** Merges a new entry into an existing array, deduplicating named imports on the same path. */
+  static mergeInto(imports, next) {
+    if (next.alias) {
+      const existing = imports.find((i) => i.from === next.from && i.alias);
+      if (existing) {
+        existing.alias = next.alias;
+        return;
+      }
+      imports.push({ from: next.from, alias: next.alias });
+      return;
+    }
+    if (next.destruct && next.destruct.length) {
+      const existing = imports.find((i) => i.from === next.from && i.destruct);
+      if (existing) {
+        existing.destruct = Array.from(/* @__PURE__ */ new Set([...existing.destruct || [], ...next.destruct]));
+        return;
+      }
+      imports.push({ from: next.from, destruct: [...next.destruct] });
+    }
+  }
+};
+
+// src/base-generator.ts
+var BaseGenerator = class {
+  options;
+  config;
+  models;
+  constructor(options) {
+    this.options = options;
+    const raw = options.generator.config;
+    const asString = (value) => typeof value === "string" ? value : void 0;
+    this.config = {
+      provider: options.generator.provider?.value || "",
+      output: options.generator.output?.value || "",
+      outputType: asString(raw.outputType) || "class",
+      outputStructure: asString(raw.outputStructure) || "nestjs",
+      reExport: Utility.parseBoolean(asString(raw.reExport)),
+      fileNamingStrategy: asString(raw.fileNamingStrategy) || "camel",
+      classValidator: Utility.parseBoolean(asString(raw.classValidator)),
+      swaggerDocs: Utility.parseBoolean(asString(raw.swaggerDocs)),
+      prettier: Utility.parseBoolean(asString(raw.prettier)),
+      schemaDir: asString(raw.schemaDir),
+      emitManifest: Utility.parseBoolean(asString(raw.emitManifest)),
+      extraDecorators: Utility.parseImports(raw.extraDecorators),
+      extraValidators: Utility.parseImports(raw.extraValidators),
+      extraImports: Utility.parseImports(raw.extraImports),
+      extraGenerators: raw.extraGenerators,
+      extraScalars: Utility.parseExtraScalars(raw.extraScalars),
+      extraAnnotations: Utility.parseAnnotationNames(raw.extraAnnotations)
+    };
+    this.models = this.options.dmmf.datamodel.models.map((model) => ({
+      name: model.name,
+      dbName: model.dbName,
+      documentation: model.documentation,
+      primaryKey: model.primaryKey,
+      uniqueFields: model.uniqueFields,
+      uniqueIndexes: model.uniqueIndexes,
+      isGenerated: model.isGenerated,
+      annotations: this.extractAnnotations(model.documentation || ""),
+      outputType: this.config.outputType,
+      fields: [
+        ...model.fields.map((field) => ({
+          name: field.name,
+          type: field.type,
+          kind: field.kind,
+          isList: field.isList,
+          isRequired: field.isRequired,
+          isUnique: field.isUnique,
+          isId: field.isId,
+          isReadOnly: field.isReadOnly,
+          isGenerated: field.isGenerated,
+          isUpdatedAt: field.isUpdatedAt,
+          hasDefaultValue: field.hasDefaultValue,
+          default: field.default,
+          relationName: field.relationName,
+          relationFromFields: field.relationFromFields,
+          relationToFields: field.relationToFields,
+          relationOnDelete: field.relationOnDelete,
+          documentation: field.documentation,
+          isNullable: !field.isRequired || field.isList,
+          annotations: this.extractAnnotations(field.documentation || "")
+        })),
+        ...this.getIgnoredFields(model.name)
+      ]
+    })).filter((model) => !model.annotations.some((a) => a.name === DTO_IGNORE_MODEL));
+  }
+  /**
+   * Optional pre-pass invoked once before any built-in or plugin `generate()` runs.
+   * Receives the **shared** `Model[]` array (already filtered for `@DtoIgnoreModel`);
+   * mutating it (e.g. injecting synthetic fields, rewriting annotations) is supported
+   * and visible to every generator that runs afterwards. Defaults to no-op.
+   */
+  async beforeAll(_models) {
+  }
+  /**
+   * Optional post-pass invoked once after every generator's `generate()` completes,
+   * receiving the **complete** list of files produced in the run (built-ins + plugins).
+   * Return a non-empty `File[]` to append extra files (e.g. an aggregated barrel,
+   * audit report, schema export); return `void` to leave the run untouched. Defaults to no-op.
+   */
+  async afterAll(_files) {
+  }
+  /**
+   * Reads `@ignore` fields from `.prisma` files inside `schemaDir`. Prisma
+   * strips ignored fields from the DMMF but we still want them visible to
+   * annotations like `@DtoApiHidden`, so we re-parse the raw schema.
+   */
+  getIgnoredFields(modelName) {
+    try {
+      if (!this.config.schemaDir) return [];
+      const schemaDir = path__default.default.resolve(process.cwd(), this.config.schemaDir);
+      if (!fs3__default.default.existsSync(schemaDir)) {
+        Utility.warn(`Configured schemaDir does not exist: ${schemaDir}`);
+        return [];
+      }
+      const findPrismaFilesRecursively = (dir) => {
+        const files = [];
+        try {
+          const entries = fs3__default.default.readdirSync(dir, { withFileTypes: true });
+          for (const entry of entries) {
+            const fullPath = path__default.default.join(dir, entry.name);
+            if (entry.isDirectory()) files.push(...findPrismaFilesRecursively(fullPath));
+            else if (entry.isFile() && entry.name.endsWith(".prisma") && entry.name !== "schema.prisma") files.push(fullPath);
+          }
+        } catch (error) {
+          Utility.warn(`Could not read directory ${dir}:`, error);
+        }
+        return files;
+      };
+      const schemaFiles = findPrismaFilesRecursively(schemaDir);
+      const ignoredFields = [];
+      for (const schemaFile of schemaFiles) {
+        const schemaContent = fs3__default.default.readFileSync(schemaFile, "utf8");
+        const modelRegex = new RegExp(`model\\s+${modelName}\\s*\\{([\\s\\S]*?)\\}`, "g");
+        const modelMatch = modelRegex.exec(schemaContent);
+        if (!modelMatch) continue;
+        const modelContent = modelMatch[1];
+        const fieldRegex = /((?:[ \t]*\/\/\/[^\n]*\n)*)([ \t]*)([a-zA-Z_][a-zA-Z0-9_]*)\s+([a-zA-Z0-9\[\]?]+)([^@\n]*@ignore)/g;
+        let fieldMatch;
+        while ((fieldMatch = fieldRegex.exec(modelContent)) !== null) {
+          const documentation = fieldMatch[1]?.trim() || "";
+          const fieldName = fieldMatch[3];
+          const fieldType = fieldMatch[4];
+          const isOptional = fieldType.includes("?");
+          const isList = fieldType.includes("[]");
+          const cleanType = fieldType.replace(/[\[\]?]/g, "");
+          const kind = ["String", "Int", "Float", "Boolean", "DateTime", "Json", "Decimal", "BigInt", "Bytes"].includes(cleanType) ? "scalar" : "object";
+          ignoredFields.push({
+            name: fieldName,
+            type: cleanType,
+            kind,
+            isList,
+            isRequired: !isOptional,
+            isNullable: isOptional || isList,
+            annotations: this.extractAnnotations(documentation),
+            isId: false,
+            isUnique: false,
+            isReadOnly: false,
+            hasDefaultValue: false
+          });
+        }
+      }
+      return ignoredFields;
+    } catch (error) {
+      Utility.warn(`Could not read ignored fields for model ${modelName}:`, error);
+      return [];
+    }
+  }
+  /** Parses `/// @Foo(arg, {object})` documentation strings into structured annotations. */
+  extractAnnotations(documentation) {
+    const annotations = [];
+    let nameMatch;
+    while ((nameMatch = ANNOTATION_NAME_REGEX.exec(documentation)) !== null) {
+      const annotationName = nameMatch[1];
+      const startPosition = nameMatch.index + ("@" + annotationName).length;
+      const remainingText = documentation.substring(startPosition);
+      if (!remainingText.startsWith("(")) {
+        annotations.push({ name: annotationName, params: [] });
+        continue;
+      }
+      ANNOTATION_PARAMS_REGEX.lastIndex = 0;
+      const paramsMatch = ANNOTATION_PARAMS_REGEX.exec(remainingText);
+      let params = [];
+      if (paramsMatch && paramsMatch[1]) {
+        const paramsString = paramsMatch[1].trim();
+        params = paramsString.split(ANNOTATION_PARAMS_SPLIT_REGEX).map((param) => param.trim()).map((param) => {
+          if (param.startsWith("{") && param.endsWith("}")) return param;
+          return isNaN(Number(param)) ? param : Number(param);
+        }).filter(Boolean);
+      }
+      annotations.push({ name: annotationName, params });
+    }
+    return annotations;
+  }
+  /**
+   * Returns the first annotation matching `name` on a field or model, or `undefined`.
+   * Use from custom sub-generators to react to user-defined annotations declared via
+   * `extraAnnotations` (or any built-in `@Dto*` name).
+   */
+  getAnnotation(target, name) {
+    return target.annotations.find((a) => a.name === name);
+  }
+  /** Convenience boolean form of {@link getAnnotation}. */
+  hasAnnotation(target, name) {
+    return this.getAnnotation(target, name) !== void 0;
+  }
+  /**
+   * Adds (and merges) an import descriptor into an `ImportType[]` array, honouring
+   * the same dedup/merge rules used by the built-in pipeline. Repeated calls with
+   * the same `from` collapse named imports together; `alias` entries are stored
+   * separately from `destruct` entries on the same path.
+   */
+  addImport(imports, next) {
+    this.mergeImport(imports, next);
+  }
+  /**
+   * Renders an `ImportType[]` array as a multi-line `import ... from '...'` block.
+   * Absolute paths (e.g. produced by `getPath(relatedModel, outputPath)`) are rewritten
+   * as POSIX-style relative paths anchored at `outputPath`; TypeScript file extensions
+   * (`.ts` / `.mts` / `.cts` / `.tsx`) on the `from` path are stripped automatically
+   * since they are never desired in import statements.
+   */
+  formatImports(imports, outputPath) {
+    return imports.map((i) => {
+      const from2 = this.stripTsExtension(this.rewriteImportPath(i.from, outputPath));
+      return `import ${i.alias ? i.alias : `{ ${(i.destruct || []).join(", ")} }`} from '${from2}';`;
+    }).join("\n");
+  }
+  /**
+   * Returns the output path of a `model` formatted for use as an `import` specifier:
+   * same as {@link getPath} but with the TypeScript file extension stripped and a
+   * `./` prefix added when the result would otherwise look like a bare module specifier
+   * (`flat` outputStructure case). Use this when a custom sub-generator needs to
+   * reference a peer-generated file (e.g. for relations between models) and you would
+   * otherwise hand-strip `.ts` from `getPath`.
+   */
+  getImportPath(model, fromOutputPath) {
+    const stripped = this.stripTsExtension(this.getPath(model, fromOutputPath));
+    if (fromOutputPath && !stripped.startsWith(".") && !path__default.default.isAbsolute(stripped)) return `./${stripped}`;
+    return stripped;
+  }
+  /** Strips `.ts` / `.mts` / `.cts` / `.tsx` suffixes from an `import` specifier. */
+  stripTsExtension(from2) {
+    return from2.replace(/\.(ts|mts|cts|tsx)$/, "");
+  }
+  /** File / class name transformer. Defaults to camelCase. */
+  getModelName(name) {
+    switch (this.config.fileNamingStrategy) {
+      case "snake":
+        return name.charAt(0).toLowerCase() + name.slice(1).replace(/[A-Z]/g, (char) => "_" + char.toLowerCase());
+      case "kebab":
+        return name.charAt(0).toLowerCase() + name.slice(1).replace(/[A-Z]/g, (char) => "-" + char.toLowerCase()).replace(/_/g, "-");
+      default:
+      case "camel":
+        return name.charAt(0).toLowerCase() + name.slice(1).replace(/_(\w)/g, (_, char) => char.toUpperCase());
+    }
+  }
+  /**
+   * Applies `@DtoOverrideType(<type>)` non-destructively. The original `model`
+   * is left untouched; callers receive a model with cloned fields whose `kind`
+   * and `type` reflect the override.
+   */
+  applyOverrides(model) {
+    const fields = model.fields.map((field) => {
+      const overrideType = field.annotations.find((a) => a.name === DTO_OVERRIDE_TYPE);
+      if (overrideType && overrideType.params?.[0]) {
+        const clone = { ...field };
+        delete clone.kind;
+        clone.type = String(overrideType.params[0]);
+        return clone;
+      }
+      return field;
+    });
+    return { ...model, fields };
+  }
+  /**
+   * Merges a new `ImportType` into the existing array. Distinct concerns are kept
+   * as separate entries (i.e. an `alias` import and a `destruct` import from the
+   * same path will not collide).
+   */
+  mergeImport(imports, next) {
+    if (next.alias) {
+      const existing = imports.find((i) => i.from === next.from && i.alias);
+      if (existing) {
+        existing.alias = next.alias;
+        return;
+      }
+      imports.push({ from: next.from, alias: next.alias });
+      return;
+    }
+    if (next.destruct && next.destruct.length) {
+      const existing = imports.find((i) => i.from === next.from && i.destruct);
+      if (existing) {
+        existing.destruct = Array.from(/* @__PURE__ */ new Set([...existing.destruct || [], ...next.destruct]));
+        return;
+      }
+      imports.push({ from: next.from, destruct: [...next.destruct] });
+    }
+  }
+  /** Collects every import the rendered class will need. */
+  getImports(args) {
+    const { model, classValidator = Utility.parseBoolean(this.config.classValidator) || false, swaggerDocs = Utility.parseBoolean(this.config.swaggerDocs) || false } = args;
+    const imports = [];
+    const findOverride = (name) => [...this.config.extraValidators, ...this.config.extraDecorators, ...this.config.extraImports].find((v) => v.destruct?.includes(name));
+    const addImport = (importParams) => {
+      if (!importParams.destruct?.length || importParams.alias) {
+        this.mergeImport(imports, importParams);
+        return;
+      }
+      const grouped = /* @__PURE__ */ new Map();
+      importParams.destruct.forEach((name) => {
+        const from2 = findOverride(name)?.from ?? importParams.from;
+        grouped.set(from2, [...grouped.get(from2) ?? [], name]);
+      });
+      grouped.forEach((destruct, from2) => this.mergeImport(imports, { from: from2, destruct }));
+    };
+    const scalarOverrides = this.config.extraScalars ?? {};
+    model.fields.forEach((field) => {
+      if (field.kind === "object" && field.type && field.type !== `${this.classPrefix}${model.name}${this.classSuffix}`) {
+        const relationModel = this.models.find((m) => m.name === field.type);
+        if (relationModel) {
+          const importPath = this.getPath(relationModel, this.getPath(model));
+          addImport({ from: Utility.parseBoolean(this.config.reExport) ? path__default.default.dirname(importPath) : importPath, destruct: [relationModel.name] });
+        }
+      }
+      if (field.kind === "enum") addImport({ from: "@prisma/client", destruct: [field.type] });
+      const override = scalarOverrides[field.type];
+      if (override && override.from) addImport({ from: override.from, destruct: [override.ts] });
+      else if (field.type === "Json" || field.type === "Decimal") addImport({ from: "@prisma/client", destruct: ["Prisma"] });
+    });
+    if (this.config.outputType === "class" && swaggerDocs) {
+      const addSwaggerDecorator = (decorator) => addImport({ from: "@nestjs/swagger", destruct: [decorator] });
+      addSwaggerDecorator("ApiProperty");
+      const extraModelsAnnotation = model.annotations.find((a) => a.name === DTO_API_EXTRA_MODELS);
+      if (extraModelsAnnotation?.params?.length) addSwaggerDecorator("ApiExtraModels");
+      model.fields.forEach((field) => {
+        field.annotations.forEach((annotation) => {
+          if (SWAGGER_DECORATORS.includes(annotation.name)) addSwaggerDecorator(annotation.name);
+        });
+      });
+    }
+    if (this.config.outputType === "class" && classValidator) {
+      const addValidator = (decorator) => addImport({ from: "class-validator", destruct: [decorator] });
+      model.fields.forEach((field) => {
+        if (!field.isRequired) addValidator("IsOptional");
+        if (!field.isNullable) addValidator("IsNotEmpty");
+        if (field.isList) addValidator("IsArray");
+        switch (field.type) {
+          case "String":
+            addValidator("IsString");
+            break;
+          case "Int":
+            addValidator("IsInt");
+            break;
+          case "Float":
+            addValidator("IsNumber");
+            break;
+          case "Boolean":
+            addValidator("IsBoolean");
+            break;
+          case "DateTime":
+            addValidator("IsDateString");
+            break;
+          case "Json":
+            addValidator("IsObject");
+            break;
+        }
+        if (field.kind === "object") {
+          addValidator("ValidateNested");
+          addImport({ from: "class-transformer", destruct: ["Type"] });
+        }
+        field.annotations.forEach((annotation) => {
+          if (CLASS_VALIDATOR_DECORATORS.includes(annotation.name)) addValidator(annotation.name);
+        });
+        field.annotations.forEach((annotation) => {
+          if (CLASS_TRANSFORMER_DECORATORS.includes(annotation.name)) addImport({ from: "class-transformer", destruct: [annotation.name] });
+        });
+        if (this.config.extraValidators.length) {
+          field.annotations.forEach((annotation) => {
+            this.config.extraValidators.forEach((validatorImport) => {
+              if (annotation.name === validatorImport.alias || validatorImport.destruct && validatorImport.destruct.includes(annotation.name)) {
+                if (validatorImport.alias) addImport({ from: validatorImport.from, alias: validatorImport.alias });
+                else if (validatorImport.destruct) addImport({ from: validatorImport.from, destruct: [annotation.name] });
+              }
+            });
+          });
+        }
+      });
+    }
+    if (this.config.extraDecorators.length) {
+      model.fields.forEach((field) => {
+        field.annotations.forEach((annotation) => {
+          this.config.extraDecorators.forEach((decoratorImport) => {
+            if (annotation.name === decoratorImport.alias || decoratorImport.destruct && decoratorImport.destruct.includes(annotation.name)) {
+              if (decoratorImport.alias) addImport({ from: decoratorImport.from, alias: decoratorImport.alias });
+              else if (decoratorImport.destruct) addImport({ from: decoratorImport.from, destruct: [annotation.name] });
+            }
+          });
+        });
+      });
+    }
+    if (this.config.extraImports.length) {
+      model.fields.forEach((field) => {
+        field.annotations.forEach((annotation) => {
+          const isValidatorAnnotation = CLASS_VALIDATOR_DECORATORS.includes(annotation.name) || CLASS_TRANSFORMER_DECORATORS.includes(annotation.name) || this.config.extraValidators.some((v) => annotation.name === v.alias || v.destruct && v.destruct.includes(annotation.name));
+          const isSwaggerAnnotation = SWAGGER_DECORATORS.includes(annotation.name) || SWAGGER_API_PROPERTY_DECORATORS.includes(annotation.name);
+          if (isValidatorAnnotation && !classValidator || isSwaggerAnnotation && !swaggerDocs) return;
+          if (!annotation.params) return;
+          this.config.extraImports.forEach((importConfig) => {
+            if (importConfig.alias) {
+              const aliasName = importConfig.alias.split(" as ")[1] || importConfig.alias;
+              const isUsed = annotation.params.some((param) => typeof param === "string" && param.includes(aliasName));
+              if (isUsed) addImport({ from: importConfig.from, alias: importConfig.alias });
+            } else if (importConfig.destruct) {
+              importConfig.destruct.forEach((item) => {
+                const isUsed = annotation.params.some((param) => typeof param === "string" && param.includes(item));
+                if (isUsed) addImport({ from: importConfig.from, destruct: [item] });
+              });
+            }
+          });
+        });
+      });
+      const extraModelsAnnotation = model.annotations.find((a) => a.name === DTO_API_EXTRA_MODELS);
+      if (extraModelsAnnotation?.params?.length) {
+        extraModelsAnnotation.params.forEach((param) => {
+          if (typeof param !== "string") return;
+          const typeName = param.trim();
+          this.config.extraImports.forEach((importConfig) => {
+            if (importConfig.destruct && importConfig.destruct.includes(typeName)) addImport({ from: importConfig.from, destruct: [typeName] });
+          });
+        });
+      }
+    }
+    model.fields.forEach((field) => {
+      const overrideType = field.annotations.find((a) => a.name === DTO_OVERRIDE_TYPE);
+      if (overrideType && overrideType.params?.[0]) {
+        const overrideModel = this.models.find((m) => m.name === String(overrideType.params[0]));
+        if (overrideModel) {
+          const importPath = this.getPath(overrideModel, this.getPath(model));
+          addImport({ from: Utility.parseBoolean(this.config.reExport) ? path__default.default.dirname(importPath) : importPath, destruct: [overrideModel.name] });
+        }
+      }
+      const overrideApiPropertyType = field.annotations.find((a) => a.name === DTO_OVERRIDE_API_PROPERTY_TYPE);
+      if (overrideApiPropertyType && overrideApiPropertyType.params?.[0]) {
+        const overrideModel = this.models.find((m) => m.name === String(overrideApiPropertyType.params[0]));
+        if (overrideModel) {
+          const importPath = this.getPath(overrideModel, this.getPath(model));
+          addImport({ from: Utility.parseBoolean(this.config.reExport) ? path__default.default.dirname(importPath) : importPath, destruct: [overrideModel.name] });
+        }
+      }
+    });
+    return imports;
+  }
+  /**
+   * Resolves an import `from` value for the file being emitted. Absolute paths
+   * (typically produced when a relative `from` was declared in the external config file)
+   * are rewritten as POSIX-style relative paths anchored at the output file's directory.
+   */
+  rewriteImportPath(from2, outputPath) {
+    if (!outputPath || !path__default.default.isAbsolute(from2)) return from2;
+    const absoluteOutput = path__default.default.resolve(outputPath);
+    let relative = path__default.default.relative(path__default.default.dirname(absoluteOutput), from2);
+    if (!relative.startsWith(".") && !path__default.default.isAbsolute(relative)) relative = `./${relative}`;
+    return relative.split(path__default.default.sep).join("/");
+  }
+  /** Renders the `import ... from ...` block. */
+  getImportsTemplate(args) {
+    return this.formatImports(this.getImports(args), args.outputPath);
+  }
+  /**
+   * Renders the full class body (imports + class declaration with decorators and fields).
+   * Sub-generators usually feed it a `model` they already pre-filtered.
+   */
+  getTemplate(args) {
+    const classValidator = Utility.parseBoolean(args.classValidator ?? this.config.classValidator) || false;
+    const swaggerDocs = Utility.parseBoolean(args.swaggerDocs ?? this.config.swaggerDocs) || false;
+    const model = this.applyOverrides(args.model);
+    const scalarOverrides = this.config.extraScalars ?? {};
+    const getPropertyType = (field, isDecorator = false) => {
+      const override = field.kind === "scalar" ? scalarOverrides[field.type] : void 0;
+      if (override) {
+        if (!isDecorator) return override.ts;
+        if (override.apiType) return override.apiType;
+        return override.from ? `() => ${override.ts}` : `'${override.ts}'`;
+      }
+      const SCALAR_TYPE = isDecorator ? Object.fromEntries(Object.entries(PRISMA_SCALAR_TYPE).map(([key, value]) => [key, value.startsWith("() =>") ? value : `'${value}'`])) : PRISMA_SCALAR;
+      if (field.kind === "scalar") return SCALAR_TYPE[field.type] || "any";
+      else if ((field.kind === "enum" || field.kind === "object") && isDecorator) return `() => ${field.type}`;
+      return field.type;
+    };
+    const getDefaultValue = (field) => {
+      if (!field.hasDefaultValue) return void 0;
+      if (Array.isArray(field.default)) return JSON.stringify(field.default);
+      switch (typeof field.default) {
+        case "string":
+        case "number":
+        case "boolean":
+          if (field.type === "Decimal" && typeof field.default === "number") return `new Prisma.Decimal(${field.default})`;
+          return field.default;
+        case "object":
+          if (field.default && typeof field.default === "object" && "name" in field.default) {
+            if (field.default.name === "now" && field.type === "DateTime") return void 0;
+            if (field.default.name === "autoincrement") return void 0;
+            return field.default.name;
+          }
+          return void 0;
+        default:
+          return void 0;
+      }
+    };
+    const encapsulateString = (value) => {
+      if (value === "true" || value === "false" || value === "null" || /^-?\d+(?:\.\d+)?$/.test(value) || /^\[.*]$/.test(value)) return value;
+      return `'${value.replace(/'/g, "\\'")}'`;
+    };
+    const fields = model.fields.map((field) => {
+      const decorators = [];
+      if (this.config.outputType === "class" && swaggerDocs) {
+        if (field.annotations.some((a) => a.name === DTO_API_HIDDEN)) {
+          decorators.push("@ApiHideProperty()");
+        } else {
+          const apiPropertyParams = [];
+          if (field.kind === "enum") {
+            apiPropertyParams.push(`enum: ${field.type}`);
+            apiPropertyParams.push(`enumName: ${encapsulateString(field.type)}`);
+          } else {
+            const overrideApiPropertyType = field.annotations.find((a) => a.name === DTO_OVERRIDE_API_PROPERTY_TYPE);
+            if (overrideApiPropertyType && overrideApiPropertyType.params && overrideApiPropertyType.params.length > 0) {
+              apiPropertyParams.push(`type: () => ${overrideApiPropertyType.params[0]}`);
+            } else {
+              apiPropertyParams.push(`type: ${getPropertyType(field, true)}`);
+            }
+          }
+          if (field.isList) apiPropertyParams.push(`isArray: true`);
+          apiPropertyParams.push(`required: ${!field.isList && field.isRequired}`);
+          if (field.isNullable) apiPropertyParams.push(`nullable: ${field.isNullable}`);
+          const formatOverride = scalarOverrides[field.type]?.format;
+          const scalarFormat = formatOverride ?? PRISMA_SCALAR_FORMAT[field.type]?.format;
+          if (scalarFormat) apiPropertyParams.push(`format: ${encapsulateString(scalarFormat)}`);
+          const defaultValue2 = getDefaultValue(field);
+          if (defaultValue2 !== void 0) apiPropertyParams.push(`default: ${typeof defaultValue2 === "string" ? encapsulateString(defaultValue2) : defaultValue2}`);
+          SWAGGER_API_PROPERTY_DECORATORS.forEach((prop) => {
+            const annotation = field.annotations.find((a) => a.name === prop);
+            if (annotation) {
+              const value = annotation.params ? annotation.params[0] : "";
+              apiPropertyParams.push(`${prop}: ${encapsulateString(String(value))}`);
+            }
+          });
+          decorators.push(`@ApiProperty({ ${apiPropertyParams.join(", ")} })`);
+          field.annotations.filter((annotation) => SWAGGER_DECORATORS.includes(annotation.name)).forEach((annotation) => {
+            const params = annotation.params ? `(${annotation.params.join(", ")})` : "";
+            decorators.push(`@${annotation.name}${params}`);
+          });
+        }
+      }
+      if (this.config.outputType === "class" && classValidator) {
+        if (field.isList || !field.isRequired) decorators.push("@IsOptional()");
+        if (!field.isNullable) decorators.push("@IsNotEmpty()");
+        if (field.isList) decorators.push("@IsArray()");
+        switch (field.type) {
+          case "String":
+            decorators.push(field.isList ? "@IsString({ each: true })" : "@IsString()");
+            break;
+          case "Int":
+            decorators.push(field.isList ? "@IsInt({ each: true })" : "@IsInt()");
+            break;
+          case "Float":
+            decorators.push(field.isList ? "@IsNumber({}, { each: true })" : "@IsNumber()");
+            break;
+          case "Boolean":
+            decorators.push(field.isList ? "@IsBoolean({ each: true })" : "@IsBoolean()");
+            break;
+          case "DateTime":
+            decorators.push(field.isList ? "@IsDateString({}, { each: true })" : "@IsDateString()");
+            break;
+          case "Json":
+            decorators.push(field.isList ? "@IsObject({ each: true })" : "@IsObject()");
+            break;
+        }
+        if (field.kind === "object") {
+          decorators.push(field.isList ? "@ValidateNested({ each: true })" : "@ValidateNested()");
+          decorators.push(`@Type(() => ${field.type})`);
+        }
+        field.annotations.filter((annotation) => CLASS_VALIDATOR_DECORATORS.includes(annotation.name) || CLASS_TRANSFORMER_DECORATORS.includes(annotation.name)).forEach((annotation) => {
+          const params = annotation.params ? `(${annotation.params.join(", ")})` : "";
+          decorators.push(`@${annotation.name}${params}`);
+        });
+        if (this.config.extraValidators.length) {
+          field.annotations.forEach((annotation) => {
+            const validator = this.config.extraValidators.find((d) => annotation.name === d.alias || (d.destruct ? d.destruct.includes(annotation.name) : false));
+            if (validator) decorators.push(`@${annotation.name}(${annotation.params})`);
+          });
+        }
+      }
+      if (this.config.extraDecorators.length) {
+        field.annotations.forEach((annotation) => {
+          const decorator = this.config.extraDecorators.find((d) => annotation.name === d.alias || (d.destruct ? d.destruct.includes(annotation.name) : false));
+          if (decorator) decorators.push(`@${annotation.name}(${annotation.params})`);
+        });
+      }
+      const isReadOnly = field.annotations.some((a) => a.name === DTO_READ_ONLY);
+      const defaultValue = getDefaultValue(field);
+      const hasDefault = defaultValue !== void 0 && this.config.outputType === "class";
+      let fieldType = getPropertyType(field);
+      if (field.isList) fieldType += "[]";
+      if (field.isNullable && !hasDefault) fieldType += " | null";
+      return `	${decorators.length ? decorators.join("\n	") + "\n" : ""}	${isReadOnly ? " readonly" : ""} ${field.name}${!field.isRequired || field.isNullable && !hasDefault || hasDefault ? "?" : this.config.outputType === "class" ? "!" : ""}: ${fieldType}${hasDefault ? ` = ${typeof defaultValue === "string" && !defaultValue.startsWith("new") ? `'${defaultValue}'` : defaultValue}` : ""};
+`;
+    }).join("\n");
+    const className = `${this.classPrefix}${model.name}${this.classSuffix}`;
+    const classDecorators = [];
+    if (swaggerDocs) {
+      const extraModelsAnnotation = model.annotations.find((a) => a.name === DTO_API_EXTRA_MODELS);
+      if (extraModelsAnnotation?.params?.length) classDecorators.push(`@ApiExtraModels(${extraModelsAnnotation.params.join(", ")})`);
+    }
+    const decoratorsString = classDecorators.length ? `${classDecorators.join("\n")}
+` : "";
+    return `${this.getImportsTemplate({ model, classValidator, swaggerDocs, outputPath: args.outputPath })}
+
+${decoratorsString}export ${this.config.outputType} ${className.charAt(0).toUpperCase() + className.slice(1).replace(/_(\w)/g, (_, char) => char.toUpperCase())} {
+${fields}}`;
+  }
+  /** Returns the absolute (or relative-to-`relativeFrom`) output path for `model`. */
+  getPath(model, relativeFrom) {
+    const modelName = this.getModelName(model.name);
+    const fileName = `${this.filePrefix}${modelName}${this.fileSuffix}`;
+    let outputPath = "";
+    switch (this.config.outputStructure) {
+      case "nestjs":
+        outputPath = `${this.config.output}/${modelName}/${fileName}.ts`;
+        break;
+      default:
+      case "flat":
+        outputPath = `${this.config.output}/${fileName}.ts`;
+        break;
+    }
+    return relativeFrom ? path__default.default.relative(path__default.default.dirname(relativeFrom), outputPath) : outputPath;
+  }
+};
+var EXTRA_IMPORT_KEYS = /* @__PURE__ */ new Set(["extraDecorators", "extraValidators", "extraImports", "extraGenerators"]);
+var NATIVE_EXTS = /* @__PURE__ */ new Set([".js", ".cjs", ".mjs", ".json"]);
+var TS_EXTS = /* @__PURE__ */ new Set([".ts", ".cts", ".mts"]);
+function resolveConfigFilePath(value, options) {
+  if (path__default.default.isAbsolute(value)) return fs3__default.default.existsSync(value) ? value : null;
+  const candidates = [];
+  const schemaPath = options.schemaPath;
+  if (schemaPath) {
+    let schemaDir = path__default.default.dirname(schemaPath);
+    try {
+      if (fs3__default.default.statSync(schemaPath).isDirectory()) schemaDir = schemaPath;
+    } catch {
+    }
+    candidates.push(path__default.default.resolve(schemaDir, value));
+  }
+  candidates.push(path__default.default.resolve(process.cwd(), value));
+  for (const candidate of candidates) {
+    if (fs3__default.default.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+async function importWithJiti(filePath) {
+  const { createJiti } = await import('jiti');
+  const jiti = createJiti(filePath, { interopDefault: true, moduleCache: false });
+  return jiti.import(filePath, { default: true });
+}
+function pickConfig(mod) {
+  if (!mod || typeof mod !== "object") return null;
+  const candidate = mod.default ?? mod.config ?? mod;
+  if (!candidate || typeof candidate !== "object") return null;
+  return candidate;
+}
+async function loadConfigFile(options) {
+  const rawConfig = options.generator.config;
+  const configFile = typeof rawConfig.configFile === "string" ? rawConfig.configFile : void 0;
+  if (!configFile) return null;
+  const resolved = resolveConfigFilePath(configFile, options);
+  if (!resolved) {
+    Utility.error(`configFile not found: ${configFile}`);
+    return null;
+  }
+  const ext = path__default.default.extname(resolved).toLowerCase();
+  try {
+    let mod;
+    if (TS_EXTS.has(ext)) {
+      mod = await importWithJiti(resolved);
+    } else if (NATIVE_EXTS.has(ext)) {
+      delete __require.cache[resolved];
+      mod = __require(resolved);
+    } else {
+      Utility.error(`Unsupported configFile extension: ${ext}`);
+      return null;
+    }
+    const config = pickConfig(mod);
+    if (!config) {
+      Utility.error(`configFile ${resolved} did not export a configuration object`);
+      return null;
+    }
+    Utility.log(`Loaded configFile from ${resolved}`);
+    return { config, dir: path__default.default.dirname(resolved), file: resolved };
+  } catch (error) {
+    Utility.error(`Failed to load configFile ${resolved}:`, error);
+    return null;
+  }
+}
+function isImportDescriptor(value) {
+  return typeof value === "object" && value !== null && typeof value.from === "string";
+}
+function isRelativePath(value) {
+  return value.startsWith("./") || value.startsWith("../");
+}
+function resolveFrom(from2, configFileDir) {
+  if (!configFileDir || !isRelativePath(from2)) return from2;
+  return path__default.default.resolve(configFileDir, from2);
+}
+function rewriteRelativeInline(statement, configFileDir) {
+  if (!configFileDir) return statement;
+  return statement.split("|").map((group) => {
+    const idx = group.lastIndexOf(":");
+    if (idx === -1) return group;
+    const fromPath = group.substring(idx + 1).trim();
+    if (!isRelativePath(fromPath)) return group;
+    return `${group.substring(0, idx)}:${path__default.default.resolve(configFileDir, fromPath)}`;
+  }).join("|");
+}
+function descriptorToImportStatement(descriptor, configFileDir) {
+  const fromPath = resolveFrom(descriptor.from, configFileDir);
+  const groups = [];
+  if (descriptor.default) groups.push(`default as ${descriptor.default}:${fromPath}`);
+  if (descriptor.namespace) groups.push(`* as ${descriptor.namespace}:${fromPath}`);
+  if (descriptor.names && descriptor.names.length > 0) {
+    const named = descriptor.names.map((entry) => typeof entry === "string" ? entry : entry.as).join(",");
+    groups.push(`${named}:${fromPath}`);
+  }
+  if (groups.length === 0) {
+    Utility.warn(`Empty ImportDescriptor for '${descriptor.from}' \u2014 no names/default/namespace provided.`);
+    return "";
+  }
+  return groups.join("|");
+}
+function serializeExtraImport(value, configFileDir) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "string") return rewriteRelativeInline(value, configFileDir);
+  if (isImportDescriptor(value)) return descriptorToImportStatement(value, configFileDir);
+  if (Array.isArray(value)) {
+    const out = [];
+    for (const entry of value) {
+      if (typeof entry === "string") out.push(rewriteRelativeInline(entry, configFileDir));
+      else if (isImportDescriptor(entry)) out.push(descriptorToImportStatement(entry, configFileDir));
+    }
+    return out;
+  }
+  return void 0;
+}
+function applyConfigFile(rawConfig, configFile, configFileDir) {
+  if (!configFile) return rawConfig;
+  const merged = { ...rawConfig };
+  const stringify = (value) => {
+    if (value === void 0 || value === null) return void 0;
+    if (typeof value === "string") return value;
+    if (typeof value === "boolean") return String(value);
+    if (Array.isArray(value)) return value.map(String);
+    return String(value);
+  };
+  for (const [key, value] of Object.entries(configFile)) {
+    let coerced;
+    if (EXTRA_IMPORT_KEYS.has(key)) coerced = serializeExtraImport(value, configFileDir);
+    else if (key === "extraScalars" && value && typeof value === "object") coerced = serializeExtraScalars(value, configFileDir);
+    else coerced = stringify(value);
+    if (coerced !== void 0) merged[key] = coerced;
+  }
+  return merged;
+}
+function serializeExtraScalars(value, configFileDir) {
+  const out = {};
+  for (const [scalar, override] of Object.entries(value)) {
+    if (!override || typeof override !== "object") continue;
+    out[scalar] = { ...override, from: override.from ? resolveFrom(override.from, configFileDir) : void 0 };
+  }
+  return JSON.stringify(out);
+}
+function fromModule(from2, symbols) {
+  return { from: from2, names: Object.keys(symbols) };
+}
+var MODULE_PATH_REGEX = /(?:\bimport|\brequire|\bjitiImport|\b__webpack_require__|\b__nccwpck_require__|\b_?_importDefault)\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/;
+function extractModulePath(importer) {
+  const source = importer.toString();
+  const match = MODULE_PATH_REGEX.exec(source);
+  if (match && match[1]) return match[1];
+  const fallback = source.match(/['"`]([^'"`]+)['"`]/);
+  if (fallback && fallback[1]) return fallback[1];
+  throw new Error(`Could not extract module path from importer function. Source: ${source.slice(0, 200)}`);
+}
+function resolveSource(source) {
+  return typeof source === "function" ? extractModulePath(source) : source;
+}
+function toArray(value) {
+  return Array.isArray(value) ? [...value] : [value];
+}
+function from(source, names) {
+  return { from: resolveSource(source), names: toArray(names) };
+}
+function fromNamespace(source, alias) {
+  return { from: resolveSource(source), namespace: alias };
+}
+function fromDefault(source, defaultName, names) {
+  return {
+    from: resolveSource(source),
+    default: defaultName,
+    names: names === void 0 ? void 0 : toArray(names)
+  };
+}
+function namespaceFrom(from2, namespaceAlias) {
+  return { from: from2, namespace: namespaceAlias };
+}
+function defaultFrom(from2, defaultName, namedSymbols) {
+  return { from: from2, default: defaultName, names: namedSymbols ? Object.keys(namedSymbols) : void 0 };
+}
+
+// src/generators/entity-generator.ts
+var EntityDtoGenerator = class extends BaseGenerator {
+  filePrefix = "";
+  fileSuffix = ".entity";
+  classPrefix = "";
+  classSuffix = "";
+  async generate() {
+    return this.models.map((model) => {
+      const filteredFields = model.fields.filter((field) => !isEntityHidden(field));
+      const processedModel = { ...model, fields: filteredFields };
+      const outputPath = this.getPath(model);
+      return {
+        path: outputPath,
+        content: this.getTemplate({ model: processedModel, classValidator: false, outputPath })
+      };
+    });
+  }
+};
+
+// src/generators/create-dto-generator.ts
+var CreateDtoGenerator = class extends BaseGenerator {
+  filePrefix = "create-";
+  fileSuffix = ".dto";
+  classPrefix = "Create";
+  classSuffix = "Dto";
+  async generate() {
+    return this.models.map((model) => {
+      const filteredFields = model.fields.filter((field) => {
+        if (field.annotations.some((a) => a.name === DTO_HIDDEN)) return false;
+        if (field.annotations.some((a) => a.name === DTO_CREATE_HIDDEN)) return false;
+        if (field.annotations.some((a) => a.name === DTO_CREATED_AT)) return false;
+        const isRelationField = model.fields.some((f) => f.relationFromFields?.includes?.(field.name));
+        if (isRelationField) return false;
+        if (field.isId) return false;
+        if (field.isUpdatedAt) return false;
+        return true;
+      });
+      const processedFields = filteredFields.map((f) => {
+        const field = { ...f, annotations: [...f.annotations] };
+        if (field.annotations.some((a) => a.name === DTO_CREATE_OPTIONAL)) {
+          field.isRequired = false;
+          field.isNullable = true;
+        }
+        if (field.annotations.some((a) => a.name === DTO_CREATE_REQUIRED)) field.isRequired = true;
+        const validateIfAnnotation = field.annotations.find((a) => a.name === DTO_CREATE_VALIDATE_IF);
+        if (validateIfAnnotation && validateIfAnnotation.params && validateIfAnnotation.params.length > 0) {
+          const validateIfParams = validateIfAnnotation.params.join(", ");
+          field.annotations.push({ name: "ValidateIf", params: [validateIfParams] });
+        }
+        return field;
+      });
+      const processedModel = { ...model, fields: processedFields };
+      const outputPath = this.getPath(model);
+      return {
+        path: outputPath,
+        content: this.getTemplate({ model: processedModel, outputPath })
+      };
+    });
+  }
+};
+
+// src/generators/update-dto-generator.ts
+var UpdateDtoGenerator = class extends BaseGenerator {
+  filePrefix = "update-";
+  fileSuffix = ".dto";
+  classPrefix = "Update";
+  classSuffix = "Dto";
+  async generate() {
+    return this.models.map((model) => {
+      const filteredFields = model.fields.filter((field) => {
+        if (field.annotations.some((a) => a.name === DTO_HIDDEN)) return false;
+        if (field.annotations.some((a) => a.name === DTO_UPDATE_HIDDEN)) return false;
+        if (field.annotations.some((a) => a.name === DTO_CREATED_AT)) return false;
+        const isRelationField = model.fields.some((f) => f.relationFromFields?.includes?.(field.name));
+        if (isRelationField) return false;
+        if (field.isId) return true;
+        if (field.isUpdatedAt) return false;
+        return true;
+      });
+      const processedFields = filteredFields.map((f) => {
+        const field = { ...f, annotations: [...f.annotations] };
+        field.isRequired = field.isId ? true : false;
+        if (field.annotations.some((a) => a.name === DTO_UPDATE_OPTIONAL)) {
+          field.isRequired = false;
+          field.isNullable = true;
+        }
+        if (field.annotations.some((a) => a.name === DTO_UPDATE_REQUIRED)) field.isRequired = true;
+        const validateIfAnnotation = field.annotations.find((a) => a.name === DTO_UPDATE_VALIDATE_IF);
+        if (validateIfAnnotation && validateIfAnnotation.params && validateIfAnnotation.params.length > 0) {
+          const validateIfParams = validateIfAnnotation.params.join(", ");
+          field.annotations.push({ name: "ValidateIf", params: [validateIfParams] });
+        }
+        return field;
+      });
+      const processedModel = { ...model, fields: processedFields };
+      const outputPath = this.getPath(model);
+      return {
+        path: outputPath,
+        content: this.getTemplate({ model: processedModel, outputPath })
+      };
+    });
+  }
+};
+
+// src/generators/manifest-generator.ts
+var ManifestGenerator = class extends BaseGenerator {
+  filePrefix = "";
+  fileSuffix = "";
+  classPrefix = "";
+  classSuffix = "";
+  async generate() {
+    const map = {};
+    for (const model of this.models) {
+      const relations = {};
+      for (const f of model.fields) {
+        if (f.kind !== "object") continue;
+        relations[f.name] = { type: f.type, isList: Boolean(f.isList) };
+      }
+      map[model.name] = {
+        primaryKey: model.fields.find((f) => f.isId)?.name || "id",
+        entityFields: model.fields.filter((f) => !isEntityHidden(f)).map((f) => f.name),
+        relations
+      };
+    }
+    const manifestContent = `import type { Prisma } from '@prisma/client';
+
+export interface RelationDescriptor {
+    type: string;
+    isList: boolean;
+}
+
+export interface ModelManifest {
+    primaryKey: string;
+    entityFields: string[];
+    relations: Record<string, RelationDescriptor>;
+}
+
+export const PrismaManifest: Record<Prisma.ModelName, ModelManifest> = ${JSON.stringify(map, null, 4)};
+`;
+    const modelNames = this.models.map((m) => m.name);
+    const isFlat = this.config.outputStructure === "flat";
+    const importLines = modelNames.map((name) => {
+      const fileName = this.getModelName(name);
+      const importPath = isFlat ? `./${fileName}.entity` : `./${fileName}/${fileName}.entity`;
+      return `import type { ${name} as ${name}Entity } from '${importPath}';`;
+    }).join("\n");
+    const mapLines = modelNames.map((name) => `    ${name}: ${name}Entity;`).join("\n");
+    const entityMapContent = `${importLines}
+
+export interface ModelEntityMap {
+${mapLines}
+}
+`;
+    return [
+      { path: `${this.config.output}/manifest.ts`, content: manifestContent },
+      { path: `${this.config.output}/model-entity-map.ts`, content: entityMapContent }
+    ];
+  }
+};
+
+// src/generator.ts
+var BuiltInGenerators = { CreateDtoGenerator, EntityGenerator: EntityDtoGenerator, UpdateDtoGenerator };
+async function resolvePrettierConfig(enabled) {
+  if (!enabled) return null;
+  try {
+    const prettierConfigFile = await prettier__default.default.resolveConfigFile();
+    let config = {};
+    if (!prettierConfigFile) {
+      Utility.log("Stylizing output DTOs with the default Prettier config.");
+    } else {
+      Utility.log(`Stylizing output DTOs with found Prettier config. (${prettierConfigFile})`);
+      const resolved = await prettier__default.default.resolveConfig(prettierConfigFile, { config: prettierConfigFile });
+      if (resolved) config = resolved;
+    }
+    config.parser = "typescript";
+    return config;
+  } catch (error) {
+    Utility.warn("Failed to resolve Prettier config:", error);
+    return null;
+  }
+}
+var TS_PLUGIN_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".cts", ".mts", ".tsx"]);
+async function importPluginModule(absolutePath) {
+  const ext = path__default.default.extname(absolutePath).toLowerCase();
+  if (TS_PLUGIN_EXTENSIONS.has(ext)) {
+    const { createJiti } = await import('jiti');
+    const jiti = createJiti(absolutePath, { interopDefault: true, moduleCache: false });
+    const mod = await jiti.import(absolutePath);
+    if (mod && typeof mod === "object" && "default" in mod && mod.default && typeof mod.default === "object") {
+      return { ...mod.default, ...mod };
+    }
+    return mod;
+  }
+  return __require(absolutePath);
+}
+async function loadExtraGenerators(options) {
+  const extra = {};
+  const raw = options.generator.config.extraGenerators;
+  if (!raw) return extra;
+  try {
+    const imports = Utility.parseImports(raw);
+    for (const importInfo of imports) {
+      try {
+        const modulePath = path__default.default.isAbsolute(importInfo.from) ? importInfo.from : path__default.default.resolve(process.cwd(), importInfo.from);
+        const importedModule = await importPluginModule(modulePath);
+        if (importInfo.destruct && importInfo.destruct.length > 0) {
+          for (const generatorName of importInfo.destruct) {
+            if (importedModule[generatorName]) {
+              extra[generatorName] = importedModule[generatorName];
+              Utility.log(`Loaded generator ${generatorName} from ${importInfo.from}`);
+            } else {
+              Utility.warn(`Generator ${generatorName} not found in ${importInfo.from}`);
+            }
+          }
+        } else if (importInfo.alias) {
+          extra[importInfo.alias] = importedModule;
+          Utility.log(`Loaded generator ${importInfo.alias} from ${importInfo.from}`);
+        } else {
+          Object.entries(importedModule).forEach(([name, exported]) => {
+            extra[name] = exported;
+            Utility.log(`Loaded generator ${name} from ${importInfo.from}`);
+          });
+        }
+      } catch (error) {
+        Utility.error(`Failed to load generators from ${importInfo.from}:`, error);
+      }
+    }
+  } catch (error) {
+    Utility.error(`Failed to parse extraGenerators:`, error);
+  }
+  return extra;
+}
+function instantiateGenerators(registry, options) {
+  return Object.entries(registry).map(([name, Ctor]) => {
+    try {
+      if (typeof Ctor !== "function") {
+        Utility.warn(`Skipping ${name}: not a constructor function`);
+        return null;
+      }
+      const instance = new Ctor(options);
+      if (typeof instance.generate === "function" && typeof instance.getPath === "function") return instance;
+      Utility.warn(`Skipping ${name}: not a BaseGenerator-shaped object (missing generate/getPath)`);
+    } catch (error) {
+      Utility.error(`Error initializing generator ${name}:`, error);
+    }
+    return null;
+  }).filter((instance) => instance !== null);
+}
+async function maybeFormat(content, config, label) {
+  if (!config) return content;
+  try {
+    return await prettier__default.default.format(content, config);
+  } catch (error) {
+    Utility.warn(`Failed to format ${label} with Prettier:`, error);
+    return content;
+  }
+}
+async function generate(options) {
+  const outputDir = options.generator.output?.value;
+  if (!outputDir) {
+    Utility.error('Output directory is not set. Add `output = "..."` to the generator block in schema.prisma.');
+    return;
+  }
+  const externalConfig = await loadConfigFile(options);
+  const mergedConfig = applyConfigFile(options.generator.config, externalConfig?.config ?? null, externalConfig?.dir);
+  options.generator.config = mergedConfig;
+  const rawConfig = mergedConfig;
+  const extraGenerators = await loadExtraGenerators(options);
+  const allGenerators = { ...BuiltInGenerators, ...extraGenerators };
+  const generators = instantiateGenerators(allGenerators, options);
+  const sharedModels = generators[0]?.models ?? [];
+  for (const generator of generators) generator.models = sharedModels;
+  const applyPrettier = Utility.parseBoolean(typeof rawConfig.prettier === "string" ? rawConfig.prettier : void 0);
+  const prettierConfig = await resolvePrettierConfig(applyPrettier);
+  const outputStructure = typeof rawConfig.outputStructure === "string" ? rawConfig.outputStructure : "nestjs";
+  for (const generator of generators) {
+    try {
+      await generator.beforeAll(sharedModels);
+    } catch (error) {
+      Utility.error(`Error in ${generator.constructor.name}#beforeAll:`, error);
+    }
+  }
+  const exports = {};
+  const emittedFiles = [];
+  const persistFile = async (file, label) => {
+    const content = await maybeFormat(file.content, prettierConfig, label);
+    fs3__default.default.mkdirSync(path__default.default.dirname(file.path), { recursive: true });
+    fs3__default.default.writeFileSync(file.path, content);
+    const exportPath = outputStructure === "flat" ? file.path : path__default.default.dirname(file.path);
+    const exportLine = `export * from './${path__default.default.basename(file.path).replace(".ts", "")}';`;
+    exports[exportPath] = exports[exportPath] ? `${exports[exportPath]}
+${exportLine}` : exportLine;
+    emittedFiles.push(file);
+  };
+  for (const generator of generators) {
+    try {
+      Utility.log(`Executing generator: ${generator.constructor.name}`);
+      const files = await generator.generate();
+      for (const file of files) await persistFile(file, path__default.default.basename(file.path));
+    } catch (error) {
+      Utility.error(`Error while executing ${generator.constructor.name}:`, error);
+    }
+  }
+  for (const generator of generators) {
+    try {
+      const extra = await generator.afterAll(emittedFiles);
+      if (Array.isArray(extra)) for (const file of extra) await persistFile(file, path__default.default.basename(file.path));
+    } catch (error) {
+      Utility.error(`Error in ${generator.constructor.name}#afterAll:`, error);
+    }
+  }
+  if (Utility.parseBoolean(typeof rawConfig.reExport === "string" ? rawConfig.reExport : void 0)) {
+    if (outputStructure !== "flat") {
+      for (const [exportPath, content] of Object.entries(exports)) {
+        const indexContent = await maybeFormat(content, prettierConfig, "index file");
+        fs3__default.default.writeFileSync(`${exportPath}/index.ts`, indexContent);
+      }
+    }
+    const mainIndexContent = await maybeFormat(
+      Object.keys(exports).map((exportPath) => `export * from './${path__default.default.basename(exportPath).replace(".ts", "")}';`).join("\n"),
+      prettierConfig,
+      "main index file"
+    );
+    fs3__default.default.writeFileSync(`${outputDir}/index.ts`, mainIndexContent);
+  }
+  if (Utility.parseBoolean(typeof rawConfig.emitManifest === "string" ? rawConfig.emitManifest : void 0)) {
+    const manifestFiles = await new ManifestGenerator(options).generate();
+    for (const file of manifestFiles) {
+      const content = await maybeFormat(file.content, prettierConfig, path__default.default.basename(file.path));
+      fs3__default.default.writeFileSync(file.path, content);
+    }
+  }
+}
+
+exports.ANNOTATION_NAME_REGEX = ANNOTATION_NAME_REGEX;
+exports.ANNOTATION_PARAMS_REGEX = ANNOTATION_PARAMS_REGEX;
+exports.ANNOTATION_PARAMS_SPLIT_REGEX = ANNOTATION_PARAMS_SPLIT_REGEX;
+exports.BaseGenerator = BaseGenerator;
+exports.CLASS_TRANSFORMER_DECORATORS = CLASS_TRANSFORMER_DECORATORS;
+exports.CLASS_VALIDATOR_DECORATORS = CLASS_VALIDATOR_DECORATORS;
+exports.CreateDtoGenerator = CreateDtoGenerator;
+exports.DTO_API_EXTRA_MODELS = DTO_API_EXTRA_MODELS;
+exports.DTO_API_HIDDEN = DTO_API_HIDDEN;
+exports.DTO_CREATED_AT = DTO_CREATED_AT;
+exports.DTO_CREATE_HIDDEN = DTO_CREATE_HIDDEN;
+exports.DTO_CREATE_OPTIONAL = DTO_CREATE_OPTIONAL;
+exports.DTO_CREATE_REQUIRED = DTO_CREATE_REQUIRED;
+exports.DTO_CREATE_VALIDATE_IF = DTO_CREATE_VALIDATE_IF;
+exports.DTO_ENTITY_HIDDEN = DTO_ENTITY_HIDDEN;
+exports.DTO_HIDDEN = DTO_HIDDEN;
+exports.DTO_IGNORE_MODEL = DTO_IGNORE_MODEL;
+exports.DTO_OVERRIDE_API_PROPERTY_TYPE = DTO_OVERRIDE_API_PROPERTY_TYPE;
+exports.DTO_OVERRIDE_TYPE = DTO_OVERRIDE_TYPE;
+exports.DTO_READ_ONLY = DTO_READ_ONLY;
+exports.DTO_UPDATE_HIDDEN = DTO_UPDATE_HIDDEN;
+exports.DTO_UPDATE_OPTIONAL = DTO_UPDATE_OPTIONAL;
+exports.DTO_UPDATE_REQUIRED = DTO_UPDATE_REQUIRED;
+exports.DTO_UPDATE_VALIDATE_IF = DTO_UPDATE_VALIDATE_IF;
+exports.ENTITY_HIDDEN_ANNOTATIONS = ENTITY_HIDDEN_ANNOTATIONS;
+exports.EntityGenerator = EntityDtoGenerator;
+exports.ManifestGenerator = ManifestGenerator;
+exports.PRISMA_SCALAR = PRISMA_SCALAR;
+exports.PRISMA_SCALAR_FORMAT = PRISMA_SCALAR_FORMAT;
+exports.PRISMA_SCALAR_TYPE = PRISMA_SCALAR_TYPE;
+exports.SWAGGER_API_PROPERTY_DECORATORS = SWAGGER_API_PROPERTY_DECORATORS;
+exports.SWAGGER_DECORATORS = SWAGGER_DECORATORS;
+exports.UpdateDtoGenerator = UpdateDtoGenerator;
+exports.Utility = Utility;
+exports.applyConfigFile = applyConfigFile;
+exports.defaultFrom = defaultFrom;
+exports.descriptorToImportStatement = descriptorToImportStatement;
+exports.from = from;
+exports.fromDefault = fromDefault;
+exports.fromModule = fromModule;
+exports.fromNamespace = fromNamespace;
+exports.generate = generate;
+exports.isEntityHidden = isEntityHidden;
+exports.loadConfigFile = loadConfigFile;
+exports.namespaceFrom = namespaceFrom;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map