typeorm-dto-generator 1.0.1 → 1.0.3

package/dist/index.mjs

@@ -0,0 +1,803 @@
+// src/index.ts
+import fs from "fs";
+import path from "path";
+import { Project, Node } from "ts-morph";
+var TORMDTOGenerator = class {
+  config;
+  project;
+  sourceInfoByClassName = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = this.createConfig(config);
+    this.project = new Project({
+      skipAddingFilesFromTsConfig: true
+    });
+  }
+  async run() {
+    this.loadEntitySourceInfo();
+    const metas = await this.createEntityMetas();
+    fs.rmSync(this.config.dtoOutputDir, {
+      recursive: true,
+      force: true
+    });
+    fs.mkdirSync(this.config.dtoOutputDir, {
+      recursive: true
+    });
+    this.ensureCommonTypesFile(metas);
+    this.validateCommonTypeCoverage(metas);
+    for (const meta of metas) {
+      this.writeFile(
+        path.join(this.config.dtoOutputDir, meta.dtoFileName),
+        this.createDTOContent(meta, metas)
+      );
+    }
+    this.writeFile(
+      path.join(this.config.dtoOutputDir, `index.ts`),
+      `${this.createDTOIndexContent(metas)}
+`
+    );
+    this.writeFile(
+      this.config.mapperOutputFile,
+      this.createGeneratedMapperContent(metas)
+    );
+    this.log(`Generated DTO files: ${metas.length}`);
+    this.log(`Generated DTO directory: ${this.config.dtoOutputDir}`);
+    this.log(`Generated mapper file: ${this.config.mapperOutputFile}`);
+    return {
+      metas,
+      dtoOutputDir: this.config.dtoOutputDir,
+      mapperOutputFile: this.config.mapperOutputFile
+    };
+  }
+  log(message) {
+    if (this.config.debug)
+      console.log(message);
+  }
+  createConfig(config) {
+    if (!config.datasource)
+      throw new Error("datasource is required");
+    const root = process.cwd();
+    const dtoOutputDir = config.dtoOutputDir || path.join(root, "dto");
+    const mapperOutputFile = config.mapperOutputFile || path.join(root, "dto.mapper.ts");
+    const sharedDTOImportPath = config.sharedDTOImportPath || path.relative(path.parse(mapperOutputFile).dir, dtoOutputDir).replaceAll("\\", "/");
+    return {
+      debug: config.debug || false,
+      dtoOutputDir,
+      mapperOutputFile,
+      sharedDTOImportPath: sharedDTOImportPath.startsWith(".") ? sharedDTOImportPath : `./${sharedDTOImportPath}`,
+      includeExtensionOnImports: config.includeExtensionOnImports ?? true,
+      excludePropertyNames: config.excludePropertyNames ?? [
+        "password",
+        "passwordHash",
+        "secret",
+        "refreshToken",
+        "accessToken",
+        "keyHash",
+        "token",
+        "otp",
+        "salt"
+      ],
+      customScalarTypeMap: config.customScalarTypeMap ?? {
+        BigInt: "string",
+        bigint: "string",
+        Buffer: "string",
+        Decimal: "string"
+      },
+      ...config
+    };
+  }
+  writeFile(filePath, content) {
+    fs.mkdirSync(path.dirname(filePath), {
+      recursive: true
+    });
+    fs.writeFileSync(filePath, content);
+  }
+  toKebabCase(value) {
+    return value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+  }
+  unique(items) {
+    return [...new Set(items)];
+  }
+  createRelativeJSImportPath(fromFile, targetFile) {
+    const relativePath = path.relative(path.dirname(fromFile), targetFile).replace(/\\/g, "/").replace(/\.(ts|tsx|mts|cts)$/, this.config.includeExtensionOnImports ? ".ts" : "");
+    return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+  }
+  getCommonTypesFilePath() {
+    return path.join(this.config.dtoOutputDir, "common.dto.ts");
+  }
+  getCommonTypesImportSpecifier(dtoFilePath) {
+    return this.createRelativeJSImportPath(dtoFilePath, this.getCommonTypesFilePath());
+  }
+  getDatasourceEntities() {
+    const entities = this.config.datasource.options.entities ?? [];
+    if (Array.isArray(entities)) {
+      return entities;
+    }
+    return Object.values(entities);
+  }
+  normalizeEntityPattern(pattern) {
+    return pattern.replace(/\\/g, "/");
+  }
+  isSourceFilePath(filePath) {
+    return /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/.test(filePath);
+  }
+  isEntitySourceFilePath(filePath) {
+    return /\.entity\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/.test(filePath);
+  }
+  normalizeAbsolutePath(filePath) {
+    return path.resolve(filePath).replace(/\\/g, "/").toLowerCase();
+  }
+  isIgnoredSourcePath(filePath) {
+    const normalized = this.normalizeAbsolutePath(filePath);
+    const dtoOutputDir = this.normalizeAbsolutePath(this.config.dtoOutputDir);
+    const mapperOutputFile = this.normalizeAbsolutePath(this.config.mapperOutputFile);
+    const ignoredSegments = [
+      "/node_modules/",
+      "/.git/",
+      "/.next/",
+      "/dist/",
+      "/build/",
+      "/coverage/"
+    ];
+    if (ignoredSegments.some((segment) => normalized.includes(segment))) {
+      return true;
+    }
+    if (normalized === dtoOutputDir || normalized.startsWith(`${dtoOutputDir}/`)) {
+      return true;
+    }
+    return normalized === mapperOutputFile;
+  }
+  discoverProjectSourcePaths() {
+    const result = [];
+    const walk = (directory) => {
+      if (!fs.existsSync(directory)) {
+        return;
+      }
+      for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+        const fullPath = path.join(directory, entry.name);
+        const normalized = fullPath.replace(/\\/g, "/");
+        if (this.isIgnoredSourcePath(normalized)) {
+          continue;
+        }
+        if (entry.isDirectory()) {
+          walk(fullPath);
+          continue;
+        }
+        if (entry.isFile() && this.isSourceFilePath(fullPath)) {
+          result.push(fullPath);
+        }
+      }
+    };
+    walk(process.cwd());
+    return result;
+  }
+  addEntityOptionSourceFiles() {
+    const sourceFiles = [];
+    for (const entity of this.getDatasourceEntities()) {
+      if (typeof entity !== "string") {
+        continue;
+      }
+      sourceFiles.push(...this.project.addSourceFilesAtPaths(this.normalizeEntityPattern(entity)));
+    }
+    return sourceFiles;
+  }
+  addDiscoveredSourceFiles() {
+    const paths = this.discoverProjectSourcePaths();
+    return paths.map((filePath) => {
+      return this.project.addSourceFileAtPathIfExists(filePath);
+    }).filter((sourceFile) => {
+      return Boolean(sourceFile);
+    });
+  }
+  loadEntitySourceInfo() {
+    const fromEntityOptions = this.addEntityOptionSourceFiles();
+    this.addDiscoveredSourceFiles();
+    const candidateFiles = fromEntityOptions.length ? fromEntityOptions : this.project.getSourceFiles();
+    for (const sourceFile of candidateFiles) {
+      for (const classDeclaration of sourceFile.getClasses()) {
+        if (!this.isEntityClass(classDeclaration)) {
+          continue;
+        }
+        this.sourceInfoByClassName.set(classDeclaration.getNameOrThrow(), {
+          filePath: sourceFile.getFilePath(),
+          enumTypeByProperty: this.collectEnumTypesByProperty(classDeclaration),
+          typeByProperty: this.collectTypesByProperty(classDeclaration)
+        });
+      }
+    }
+  }
+  isEntityClass(classDeclaration) {
+    return classDeclaration.getDecorators().some((decorator) => {
+      return decorator.getName() === "Entity";
+    });
+  }
+  getDecoratorObjectLiteral(property) {
+    for (const decorator of property.getDecorators()) {
+      const objectLiteral = decorator.getArguments().find((argument) => {
+        return Node.isObjectLiteralExpression(argument);
+      });
+      if (objectLiteral && Node.isObjectLiteralExpression(objectLiteral)) {
+        return objectLiteral;
+      }
+    }
+    return null;
+  }
+  getColumnEnumInitializer(property) {
+    var _a;
+    const objectLiteral = this.getDecoratorObjectLiteral(property);
+    const enumProperty = objectLiteral == null ? void 0 : objectLiteral.getProperty("enum");
+    if (!enumProperty || !Node.isPropertyAssignment(enumProperty)) {
+      return null;
+    }
+    return ((_a = enumProperty.getInitializer()) == null ? void 0 : _a.getText()) ?? null;
+  }
+  getEnumTypeNameFromProperty(property) {
+    var _a;
+    const typeText = (_a = property.getTypeNode()) == null ? void 0 : _a.getText();
+    if (typeText && /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(typeText)) {
+      return typeText;
+    }
+    const enumInitializer = this.getColumnEnumInitializer(property);
+    if (enumInitializer && /^[A-Za-z_$][A-Za-z0-9_$.]*$/.test(enumInitializer)) {
+      return enumInitializer.split(".").pop() ?? enumInitializer;
+    }
+    return null;
+  }
+  collectEnumTypesByProperty(classDeclaration) {
+    const enumTypeByProperty = /* @__PURE__ */ new Map();
+    for (const property of this.collectProperties(classDeclaration)) {
+      const enumTypeName = this.getEnumTypeNameFromProperty(property);
+      if (enumTypeName) {
+        enumTypeByProperty.set(property.getName(), enumTypeName);
+      }
+    }
+    return enumTypeByProperty;
+  }
+  cleanTypeText(value) {
+    return value.replace(/import\(".*?"\)\./g, "").replace(/\s+/g, " ").trim();
+  }
+  collectTypesByProperty(classDeclaration) {
+    var _a;
+    const typeByProperty = /* @__PURE__ */ new Map();
+    for (const property of this.collectProperties(classDeclaration)) {
+      const typeText = (_a = property.getTypeNode()) == null ? void 0 : _a.getText();
+      if (typeText) {
+        typeByProperty.set(property.getName(), this.cleanTypeText(typeText));
+      }
+    }
+    return typeByProperty;
+  }
+  collectProperties(classDeclaration, visitedClassNames = /* @__PURE__ */ new Set()) {
+    const className = classDeclaration.getName();
+    if (className && visitedClassNames.has(className)) {
+      return [];
+    }
+    if (className) {
+      visitedClassNames.add(className);
+    }
+    const baseClass = classDeclaration.getBaseClass();
+    const baseProperties = baseClass ? this.collectProperties(baseClass, visitedClassNames) : [];
+    return [...baseProperties, ...classDeclaration.getProperties()];
+  }
+  getClassName(target, fallback) {
+    return typeof target === "function" ? target.name : fallback;
+  }
+  async ensureDatasourceMetadata() {
+    if (this.config.datasource.entityMetadatas.length) {
+      return;
+    }
+    const datasource = this.config.datasource;
+    if (typeof datasource.buildMetadatas !== "function") {
+      throw new Error("DTOGeneratorService config error: datasource cannot build entity metadata.");
+    }
+    await datasource.buildMetadatas();
+  }
+  isExcludedColumn(column) {
+    return this.config.excludePropertyNames.includes(column.propertyName) || column.isSelect === false || Boolean(column.relationMetadata);
+  }
+  isDateColumn(column) {
+    return column.type === Date || [
+      "date",
+      "datetime",
+      "datetime2",
+      "timestamp",
+      "timestamp with time zone",
+      "timestamp without time zone",
+      "time",
+      "time with time zone",
+      "time without time zone"
+    ].includes(String(column.type));
+  }
+  isJsonColumn(column) {
+    return ["json", "jsonb", "simple-json"].includes(String(column.type));
+  }
+  resolveEnumTypeName(entityName, column) {
+    var _a;
+    const enumTypeName = (_a = this.sourceInfoByClassName.get(entityName)) == null ? void 0 : _a.enumTypeByProperty.get(column.propertyName);
+    if (enumTypeName) {
+      return enumTypeName;
+    }
+    if (column.enumName) {
+      return column.enumName;
+    }
+    return `${entityName}${column.propertyName.charAt(0).toUpperCase()}${column.propertyName.slice(1)}`;
+  }
+  resolveSourcePropertyType(entityName, propertyName) {
+    var _a;
+    const sourceType = (_a = this.sourceInfoByClassName.get(entityName)) == null ? void 0 : _a.typeByProperty.get(propertyName);
+    if (!sourceType) {
+      return null;
+    }
+    return sourceType.split("|").map((item) => item.trim()).map((item) => item === "Date" ? "string" : item).join(" | ");
+  }
+  resolveColumnType(entityName, column) {
+    var _a;
+    if ((_a = column.enum) == null ? void 0 : _a.length) {
+      return this.resolveEnumTypeName(entityName, column);
+    }
+    const sourceType = this.resolveSourcePropertyType(entityName, column.propertyName);
+    if (sourceType) {
+      return sourceType;
+    }
+    const typeText = typeof column.type === "function" ? column.type.name : String(column.type);
+    if (this.config.customScalarTypeMap[typeText]) {
+      return this.config.customScalarTypeMap[typeText];
+    }
+    if (this.isDateColumn(column)) {
+      return "string";
+    }
+    if (column.type === String || [
+      "char",
+      "varchar",
+      "nvarchar",
+      "text",
+      "tinytext",
+      "mediumtext",
+      "longtext",
+      "uuid",
+      "simple-enum"
+    ].includes(typeText)) {
+      return "string";
+    }
+    if (column.type === Number || [
+      "int",
+      "integer",
+      "tinyint",
+      "smallint",
+      "mediumint",
+      "bigint",
+      "float",
+      "double",
+      "double precision",
+      "real",
+      "decimal",
+      "numeric"
+    ].includes(typeText)) {
+      return "number";
+    }
+    if (column.type === Boolean || ["bool", "boolean"].includes(typeText)) {
+      return "boolean";
+    }
+    if (this.isJsonColumn(column)) {
+      return "any";
+    }
+    if (typeText === "object") {
+      return "Record<string, unknown>";
+    }
+    return typeText;
+  }
+  appendNullType(typeText) {
+    if (typeText.split("|").map((item) => item.trim()).includes("null")) {
+      return typeText;
+    }
+    return `${typeText} | null`;
+  }
+  columnToMeta(entityName, column) {
+    const resolvedType = this.resolveColumnType(entityName, column);
+    return {
+      name: column.propertyName,
+      optional: false,
+      type: column.isNullable ? this.appendNullType(resolvedType) : resolvedType,
+      isDate: this.isDateColumn(column),
+      mapAsNumber: resolvedType === "number",
+      enumValues: column.enum ? [...column.enum] : void 0
+    };
+  }
+  relationToMeta(relation) {
+    const targetClassName = this.getClassName(relation.inverseEntityMetadata.target, relation.inverseEntityMetadata.name);
+    return {
+      name: relation.propertyName,
+      targetClassName,
+      targetDTOName: `${targetClassName}DTO`,
+      isArray: relation.isOneToMany || relation.isManyToMany,
+      nullable: relation.isNullable
+    };
+  }
+  async createEntityMetas() {
+    await this.ensureDatasourceMetadata();
+    const metas = this.config.datasource.entityMetadatas.map((metadata) => {
+      var _a;
+      const className = this.getClassName(metadata.target, metadata.name);
+      const moduleName = this.toKebabCase(className);
+      const columns = metadata.columns.filter((column) => !this.isExcludedColumn(column)).map((column) => this.columnToMeta(className, column));
+      const relations = metadata.relations.map((relation) => this.relationToMeta(relation));
+      return {
+        className,
+        dtoName: `${className}DTO`,
+        moduleName,
+        dtoFileName: `${moduleName}.dto.ts`,
+        mapperName: `parse${className}DTO`,
+        filePath: (_a = this.sourceInfoByClassName.get(className)) == null ? void 0 : _a.filePath,
+        columns,
+        relations
+      };
+    });
+    return metas.sort((a, b) => {
+      return a.className.localeCompare(b.className);
+    });
+  }
+  findMetaByClassName(metas, className) {
+    return metas.find((meta) => {
+      return meta.className === className;
+    });
+  }
+  getValidRelations(meta, metas) {
+    return meta.relations.filter((relation) => {
+      return Boolean(this.findMetaByClassName(metas, relation.targetClassName));
+    });
+  }
+  createDTOContent(meta, metas) {
+    var _a;
+    const dtoFilePath = path.join(this.config.dtoOutputDir, meta.dtoFileName);
+    const validRelations = this.getValidRelations(meta, metas);
+    const relationImports = this.unique(
+      validRelations.filter((relation) => relation.targetClassName !== meta.className).map((relation) => relation.targetClassName)
+    ).map((targetClassName) => {
+      const targetMeta = this.findMetaByClassName(metas, targetClassName);
+      if (!targetMeta) {
+        return null;
+      }
+      const targetPath = path.join(this.config.dtoOutputDir, targetMeta.dtoFileName);
+      return [targetMeta.dtoName, this.createRelativeJSImportPath(dtoFilePath, targetPath)];
+    }).filter((item) => {
+      return item !== null;
+    });
+    const relationTypeNames = new Set(validRelations.map((relation) => relation.targetDTOName));
+    const externalTypeImports = this.collectExternalTypeImports(meta, dtoFilePath, relationTypeNames);
+    const importMap = /* @__PURE__ */ new Map();
+    for (const [typeName, moduleSpecifier] of [...relationImports, ...externalTypeImports]) {
+      if (!importMap.has(moduleSpecifier)) {
+        importMap.set(moduleSpecifier, /* @__PURE__ */ new Set());
+      }
+      (_a = importMap.get(moduleSpecifier)) == null ? void 0 : _a.add(typeName);
+    }
+    const imports = [...importMap.entries()].sort((a, b) => a[0].localeCompare(b[0])).map(([moduleSpecifier, typeNames]) => {
+      let newModuleSpecifier = moduleSpecifier;
+      if (!this.config.includeExtensionOnImports) {
+        newModuleSpecifier = newModuleSpecifier.replace(".ts", "");
+      }
+      return `import type { ${[...typeNames].sort((a, b) => a.localeCompare(b)).join(", ")} } from '${newModuleSpecifier}'`;
+    });
+    const columnLines = meta.columns.map((column) => {
+      const optional = column.optional ? "?" : "";
+      return `    ${column.name}${optional}: ${column.type}`;
+    });
+    const relationLines = validRelations.map((relation) => {
+      const type = relation.isArray ? `${relation.targetDTOName}[]` : `${relation.targetDTOName}${relation.nullable ? " | null" : ""}`;
+      return `    ${relation.name}?: ${type}`;
+    });
+    const importBlock = imports.length ? `${imports.join("\n")}
+
+` : "";
+    const body = [...columnLines, ...relationLines].join("\n");
+    return `${importBlock}export type ${meta.dtoName} = {
+${body}
+}
+`;
+  }
+  collectExternalTypeImports(meta, dtoFilePath, relationTypeNames) {
+    const symbols = this.collectExternalTypeSymbols(meta, relationTypeNames);
+    const importSpecifier = this.getCommonTypesImportSpecifier(dtoFilePath);
+    return [...symbols].map((symbol) => {
+      return [symbol, importSpecifier];
+    });
+  }
+  collectExternalTypeSymbols(meta, relationTypeNames) {
+    const symbols = /* @__PURE__ */ new Set();
+    const ignoredNames = /* @__PURE__ */ new Set([
+      "string",
+      "number",
+      "boolean",
+      "null",
+      "undefined",
+      "unknown",
+      "any",
+      "object",
+      "bigint",
+      "never",
+      "void",
+      "true",
+      "false",
+      "Record",
+      "Array",
+      "Promise",
+      "ReadonlyArray"
+    ]);
+    for (const column of meta.columns) {
+      const identifiers = column.type.match(/\b[A-Za-z_][A-Za-z0-9_]*\b/g) ?? [];
+      for (const identifier of identifiers) {
+        if (ignoredNames.has(identifier)) {
+          continue;
+        }
+        if (relationTypeNames.has(identifier) || identifier === meta.dtoName) {
+          continue;
+        }
+        symbols.add(identifier);
+      }
+    }
+    return symbols;
+  }
+  collectAllExternalTypeSymbols(metas) {
+    const symbols = /* @__PURE__ */ new Set();
+    for (const meta of metas) {
+      const relationTypeNames = new Set(meta.relations.map((relation) => relation.targetDTOName));
+      const metaSymbols = this.collectExternalTypeSymbols(meta, relationTypeNames);
+      for (const symbol of metaSymbols) {
+        symbols.add(symbol);
+      }
+    }
+    return symbols;
+  }
+  findTypeDeclarationByName(typeName) {
+    for (const sourceFile of this.project.getSourceFiles()) {
+      if (this.isIgnoredSourcePath(sourceFile.getFilePath())) {
+        continue;
+      }
+      const enumDeclaration = sourceFile.getEnum(typeName);
+      if (enumDeclaration) {
+        return enumDeclaration;
+      }
+      const interfaceDeclaration = sourceFile.getInterface(typeName);
+      if (interfaceDeclaration) {
+        return interfaceDeclaration;
+      }
+      const typeAliasDeclaration = sourceFile.getTypeAlias(typeName);
+      if (typeAliasDeclaration) {
+        return typeAliasDeclaration;
+      }
+    }
+    return null;
+  }
+  findEnumDeclarationByName(typeName) {
+    for (const sourceFile of this.project.getSourceFiles()) {
+      if (this.isIgnoredSourcePath(sourceFile.getFilePath())) {
+        continue;
+      }
+      const enumDeclaration = sourceFile.getEnum(typeName);
+      if (enumDeclaration) {
+        return enumDeclaration;
+      }
+    }
+    return null;
+  }
+  normalizeDeclarationToExportText(typeName, preferEnum = false) {
+    const declaration = preferEnum ? this.findEnumDeclarationByName(typeName) ?? this.findTypeDeclarationByName(typeName) : this.findTypeDeclarationByName(typeName);
+    if (!declaration) {
+      return null;
+    }
+    const declarationText = declaration.getText().trim();
+    if (declarationText.startsWith("export ")) {
+      return declarationText;
+    }
+    return `export ${declarationText}`;
+  }
+  formatEnumKey(value) {
+    const normalized = String(value).replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^A-Za-z0-9]+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
+    return normalized || `VALUE_${String(value)}`;
+  }
+  formatEnumValue(value) {
+    return typeof value === "number" ? String(value) : `'${value.replace(/'/g, "\\'")}'`;
+  }
+  createCommonEnumDeclaration(typeName, values) {
+    const uniqueValues = this.unique(values);
+    const lines = uniqueValues.map((value) => {
+      return `    ${this.formatEnumKey(value)} = ${this.formatEnumValue(value)}`;
+    });
+    return `export enum ${typeName} {
+${lines.join(",\n")}
+}`;
+  }
+  ensureCommonTypesFile(metas) {
+    var _a;
+    const symbols = [...this.collectAllExternalTypeSymbols(metas)].sort((a, b) => a.localeCompare(b));
+    const enumBySymbol = /* @__PURE__ */ new Map();
+    for (const meta of metas) {
+      for (const column of meta.columns) {
+        if ((_a = column.enumValues) == null ? void 0 : _a.length) {
+          enumBySymbol.set(column.type, column.enumValues);
+        }
+      }
+    }
+    const lines = symbols.map((symbol) => {
+      const enumValues = enumBySymbol.get(symbol);
+      const declarationText = this.normalizeDeclarationToExportText(symbol, Boolean(enumValues));
+      if (declarationText) {
+        return declarationText.replace(/^export declare /, "export ");
+      }
+      if (!enumValues) {
+        throw new Error(`DTOGeneratorService config error: could not generate common type '${symbol}'.`);
+      }
+      return this.createCommonEnumDeclaration(symbol, enumValues);
+    });
+    this.writeFile(this.getCommonTypesFilePath(), `${lines.join("\n\n")}
+`);
+  }
+  resolveCommonTypesSourceContent() {
+    const commonTypesFilePath = this.getCommonTypesFilePath();
+    if (!fs.existsSync(commonTypesFilePath)) {
+      return null;
+    }
+    return fs.readFileSync(commonTypesFilePath, "utf-8");
+  }
+  validateCommonTypeCoverage(metas) {
+    const commonTypesContent = this.resolveCommonTypesSourceContent();
+    if (!commonTypesContent) {
+      throw new Error(`DTOGeneratorService config error: common.dto.ts was not generated in '${this.config.dtoOutputDir}'.`);
+    }
+    const missing = [];
+    for (const meta of metas) {
+      const relationTypeNames = new Set(meta.relations.map((relation) => relation.targetDTOName));
+      const symbols = this.collectExternalTypeSymbols(meta, relationTypeNames);
+      for (const symbol of symbols) {
+        const pattern = new RegExp(`export\\s+(?:enum|type|interface)\\s+${symbol}\\b`);
+        if (!pattern.test(commonTypesContent)) {
+          const columns = meta.columns.filter((column) => {
+            const identifiers = column.type.match(/\b[A-Za-z_][A-Za-z0-9_]*\b/g) ?? [];
+            return identifiers.includes(symbol);
+          }).map((column) => column.name);
+          const uniqueColumns = this.unique(columns);
+          missing.push(`${symbol} (used in ${meta.dtoName}.${uniqueColumns.join(", ")})`);
+        }
+      }
+    }
+    if (missing.length) {
+      const details = this.unique(missing).sort((a, b) => a.localeCompare(b)).join("\n- ");
+      throw new Error(
+        `DTOGeneratorService validation error: generated/common.dto.ts is missing exports for:
+- ${details}`
+      );
+    }
+  }
+  createDTOIndexContent(metas) {
+    const dtoTypeExports = metas.map((meta) => {
+      return `export type { ${meta.dtoName} } from './${meta.moduleName}.dto${this.config.includeExtensionOnImports ? ".ts" : ""}'`;
+    }).join("\n");
+    return `export * from './common.dto${this.config.includeExtensionOnImports ? ".ts" : ""}'
+${dtoTypeExports}`;
+  }
+  getMetasWithFilePath(metas) {
+    return metas.filter((meta) => {
+      return Boolean(meta.filePath);
+    });
+  }
+  createEntityImports(metas) {
+    var _a;
+    const metasWithFilePath = this.getMetasWithFilePath(metas);
+    if (metasWithFilePath.length !== metas.length) {
+      return "";
+    }
+    const importMap = /* @__PURE__ */ new Map();
+    for (const meta of metasWithFilePath) {
+      if (!meta.filePath) {
+        continue;
+      }
+      const moduleSpecifier = this.createRelativeJSImportPath(this.config.mapperOutputFile, meta.filePath);
+      if (!importMap.has(moduleSpecifier)) {
+        importMap.set(moduleSpecifier, /* @__PURE__ */ new Set());
+      }
+      (_a = importMap.get(moduleSpecifier)) == null ? void 0 : _a.add(meta.className);
+    }
+    return [...importMap.entries()].sort((a, b) => a[0].localeCompare(b[0])).map(([moduleSpecifier, classNames]) => {
+      let newModuleSpecifier = moduleSpecifier;
+      if (!this.config.includeExtensionOnImports) {
+        newModuleSpecifier = newModuleSpecifier.replace(".ts", "");
+      }
+      return `import { ${[...classNames].sort((a, b) => a.localeCompare(b)).join(", ")} } from '${newModuleSpecifier}'`;
+    }).join("\n");
+  }
+  getMapperEntityTypeName(meta) {
+    return meta.filePath ? meta.className : `${meta.className}EntityLike`;
+  }
+  createStructuralEntityTypes(metas) {
+    if (this.getMetasWithFilePath(metas).length === metas.length) {
+      return "";
+    }
+    return metas.map((meta) => {
+      return `type ${meta.className}EntityLike = Record<string, any>`;
+    }).join("\n");
+  }
+  createGeneratedMapperContent(metas) {
+    const entityImports = this.createEntityImports(metas);
+    const dtoImports = `import type { ${metas.map((meta) => meta.dtoName).join(", ")} } from '${this.config.sharedDTOImportPath}'`;
+    const structuralTypes = this.createStructuralEntityTypes(metas);
+    const mapperFunctions = metas.map((meta) => {
+      return this.createMapperFunctionContent(meta, metas);
+    });
+    const blocks = [
+      entityImports,
+      dtoImports,
+      structuralTypes,
+      mapperFunctions.join("\n\n")
+    ].filter(Boolean);
+    let contents = `${blocks.join("\n")}
+
+`;
+    const dtoDateContent = `export function toDTODate(value: Date | string): string
+export function toDTODate(value: Date | string | null | undefined): string | null
+export function toDTODate(value: Date | string | null | undefined) {
+    if (!value) {
+        return null
+    }
+
+    if (value instanceof Date) {
+        return value.toISOString()
+    }
+
+    return value
+}
+`;
+    contents += dtoDateContent;
+    return contents;
+  }
+  createMapperFunctionContent(meta, metas) {
+    const validRelations = this.getValidRelations(meta, metas);
+    const entityTypeName = this.getMapperEntityTypeName(meta);
+    const columnLines = meta.columns.map((column) => {
+      let value = `entity.${column.name}`;
+      if (column.isDate) {
+        value = `toDTODate(entity.${column.name})`;
+      } else if (column.mapAsNumber) {
+        value = column.type.includes("null") ? `entity.${column.name} === null || entity.${column.name} === undefined ? null : Number(entity.${column.name})` : `Number(entity.${column.name})`;
+      }
+      return `        ${column.name}: ${value}`;
+    });
+    const relationLines = validRelations.map((relation) => {
+      return this.createRelationMapperLine(relation, metas);
+    });
+    const relationBlock = relationLines.length ? `
+${relationLines.join("\n\n")}
+` : "";
+    return `export function ${meta.mapperName}(entity: ${entityTypeName}): ${meta.dtoName} {
+    const dto: ${meta.dtoName} = {
+${columnLines.join(",\n")}
+    }
+${relationBlock}
+    return dto
+}
+
+export function ${meta.mapperName}Array(entities: ${entityTypeName}[]): ${meta.dtoName}[] {
+    return entities.map(${meta.mapperName})
+
+}`;
+  }
+  createRelationMapperLine(relation, metas) {
+    const targetMeta = this.findMetaByClassName(metas, relation.targetClassName);
+    const parserName = targetMeta == null ? void 0 : targetMeta.mapperName;
+    if (relation.isArray) {
+      return `    if (Array.isArray(entity.${relation.name})) {
+        dto.${relation.name} = entity.${relation.name}.map(${parserName})
+    }`;
+    }
+    if (relation.nullable) {
+      return `    if (entity.${relation.name} !== undefined) {
+        dto.${relation.name} = entity.${relation.name} === null ? null : ${parserName}(entity.${relation.name})
+    }`;
+    }
+    return `    if (entity.${relation.name} !== undefined && entity.${relation.name} !== null) {
+        dto.${relation.name} = ${parserName}(entity.${relation.name})
+    }`;
+  }
+};
+export {
+  TORMDTOGenerator
+};
+//# sourceMappingURL=index.mjs.map