typeorm-dto-generator 1.0.1 → 1.0.3

package/dist/index.js

@@ -1,772 +1,837 @@
-import fs from 'fs';
-import path from 'path';
-import { Node, Project } from 'ts-morph';
-export class TORMDTOGenerator {
-    config;
-    project;
-    constructor(config = {}) {
-        this.config = this.createConfig(config);
-        this.project = new Project({
-            tsConfigFilePath: this.config.apiTsConfigPath
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  TORMDTOGenerator: () => TORMDTOGenerator
+});
+module.exports = __toCommonJS(index_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_ts_morph = require("ts-morph");
+var TORMDTOGenerator = class {
+  config;
+  project;
+  sourceInfoByClassName = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = this.createConfig(config);
+    this.project = new import_ts_morph.Project({
+      skipAddingFilesFromTsConfig: true
+    });
+  }
+  async run() {
+    this.loadEntitySourceInfo();
+    const metas = await this.createEntityMetas();
+    import_fs.default.rmSync(this.config.dtoOutputDir, {
+      recursive: true,
+      force: true
+    });
+    import_fs.default.mkdirSync(this.config.dtoOutputDir, {
+      recursive: true
+    });
+    this.ensureCommonTypesFile(metas);
+    this.validateCommonTypeCoverage(metas);
+    for (const meta of metas) {
+      this.writeFile(
+        import_path.default.join(this.config.dtoOutputDir, meta.dtoFileName),
+        this.createDTOContent(meta, metas)
+      );
+    }
+    this.writeFile(
+      import_path.default.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 || import_path.default.join(root, "dto");
+    const mapperOutputFile = config.mapperOutputFile || import_path.default.join(root, "dto.mapper.ts");
+    const sharedDTOImportPath = config.sharedDTOImportPath || import_path.default.relative(import_path.default.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) {
+    import_fs.default.mkdirSync(import_path.default.dirname(filePath), {
+      recursive: true
+    });
+    import_fs.default.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 = import_path.default.relative(import_path.default.dirname(fromFile), targetFile).replace(/\\/g, "/").replace(/\.(ts|tsx|mts|cts)$/, this.config.includeExtensionOnImports ? ".ts" : "");
+    return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+  }
+  getCommonTypesFilePath() {
+    return import_path.default.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 import_path.default.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 (!import_fs.default.existsSync(directory)) {
+        return;
+      }
+      for (const entry of import_fs.default.readdirSync(directory, { withFileTypes: true })) {
+        const fullPath = import_path.default.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)
         });
-    }
-    run() {
-        const entitySourceFiles = this.project.addSourceFilesAtPaths(this.config.entityGlob);
-        const metas = this.createEntityMetas(entitySourceFiles);
-        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)}\n`);
-        this.writeFile(this.config.mapperOutputFile, this.createGeneratedMapperContent(metas));
-        console.log(`Generated DTO files: ${metas.length}`);
-        console.log(`Generated DTO directory: ${this.config.dtoOutputDir}`);
-        console.log(`Generated mapper file: ${this.config.mapperOutputFile}`);
-        return {
-            metas,
-            dtoOutputDir: this.config.dtoOutputDir,
-            mapperOutputFile: this.config.mapperOutputFile
-        };
-    }
-    createConfig(config) {
-        const root = process.cwd();
-        const resolvedConfig = {
-            apiTsConfigPath: path.join(root, 'packages/api/tsconfig.json'),
-            entityGlob: path.join(root, 'packages/api/src/databases/livingkostpro/entities/**/*.ts'),
-            dtoOutputDir: path.join(root, 'packages/lib/src/dto/generated'),
-            mapperOutputFile: path.join(root, 'packages/api/src/common/dto/generated-dto.mapper.ts'),
-            sharedDTOImportPath: '@livingkostpro/lib/dto',
-            includeGetters: false,
-            excludePropertyNames: [
-                'password',
-                'passwordHash',
-                'secret',
-                'refreshToken',
-                'accessToken',
-                'keyHash',
-                'token',
-                'otp',
-                'salt'
-            ],
-            columnDecorators: [
-                'Column',
-                'PrimaryColumn',
-                'PrimaryGeneratedColumn',
-                'CreateDateColumn',
-                'UpdateDateColumn',
-                'DeleteDateColumn',
-                'VersionColumn',
-                'RelationId',
-                'DatetimeUTCTimestampColumn',
-                'DatetimeColumn',
-                'DatetimeNullColumn',
-                'BooleanFalseColumn',
-                'DecimalColumn',
-                'CurrencyColumn',
-                'SortOrderColumn',
-                'DescriptionNullColumn',
-                'DescriptionColumn',
-                'NameColumn',
-                'NameNullColumn',
-                'CodeColumn',
-                'JSONNullColumn',
-                'UUIDNullColumn'
-            ],
-            relationDecorators: [
-                'OneToOne',
-                'OneToMany',
-                'ManyToOne',
-                'ManyToMany'
-            ],
-            arrayRelationDecorators: [
-                'OneToMany',
-                'ManyToMany'
-            ],
-            customScalarTypeMap: {
-                BigInt: 'string',
-                bigint: 'string',
-                Buffer: 'string',
-                Decimal: 'string'
-            },
-            ...config
-        };
-        return resolvedConfig;
-    }
-    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)];
-    }
-    cleanTypeText(value) {
-        return value
-            .replace(/import\(".*?"\)\./g, '')
-            .replace(/\s+/g, ' ')
-            .trim();
-    }
-    createRelativeJSImportPath(fromFile, targetFile) {
-        const relativePath = path
-            .relative(path.dirname(fromFile), targetFile)
-            .replace(/\\/g, '/')
-            .replace(/\.(ts|tsx|mts|cts)$/, '.ts');
-        return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
-    }
-    getCommonTypesFilePath() {
-        return path.join(this.config.dtoOutputDir, 'common.dto.ts');
-    }
-    getCommonTypesImportSpecifier(dtoFilePath) {
-        return this.createRelativeJSImportPath(dtoFilePath, this.getCommonTypesFilePath());
-    }
-    getDecorator(property, names) {
-        return property.getDecorators().find((decorator) => {
-            return names.includes(decorator.getName());
-        });
-    }
-    hasDecorator(property, names) {
-        return Boolean(this.getDecorator(property, names));
-    }
-    isEntityClass(classDeclaration) {
-        return classDeclaration.getDecorators().some((decorator) => {
-            return decorator.getName() === 'Entity';
-        });
-    }
-    getDecoratorArgumentsText(decorator) {
-        return decorator?.getArguments().map((argument) => argument.getText()) ?? [];
-    }
-    getDecoratorObjectLiteral(decorator) {
-        const argument = decorator?.getArguments().find((item) => {
-            return Node.isObjectLiteralExpression(item);
-        });
-        return argument && Node.isObjectLiteralExpression(argument) ? argument : null;
-    }
-    getObjectLiteralProperty(objectLiteral, propertyName) {
-        const property = objectLiteral?.getProperty(propertyName);
-        return property && Node.isPropertyAssignment(property) ? property : null;
-    }
-    getPropertyAssignmentInitializerText(property) {
-        return property?.getInitializer()?.getText() ?? null;
-    }
-    hasDecoratorOption(property, decoratorNames, optionName, optionValue) {
-        const decorator = this.getDecorator(property, decoratorNames);
-        const objectLiteral = this.getDecoratorObjectLiteral(decorator);
-        const option = this.getObjectLiteralProperty(objectLiteral, optionName);
-        const initializerText = this.getPropertyAssignmentInitializerText(option);
-        if (initializerText) {
-            return initializerText === optionValue;
-        }
-        const argumentsText = this.getDecoratorArgumentsText(decorator);
-        const pattern = new RegExp(`${optionName}\\s*:\\s*${optionValue}`);
-        return argumentsText.some((text) => {
-            return pattern.test(text);
-        });
-    }
-    hasSelectFalse(property) {
-        return this.hasDecoratorOption(property, this.config.columnDecorators, 'select', 'false');
-    }
-    isExcludedProperty(property) {
-        return this.config.excludePropertyNames.includes(property.getName()) || this.hasSelectFalse(property);
-    }
-    isColumnProperty(property) {
-        if (this.isExcludedProperty(property)) {
-            return false;
-        }
-        if (this.hasDecorator(property, this.config.relationDecorators)) {
-            return false;
-        }
-        return this.hasDecorator(property, this.config.columnDecorators);
-    }
-    isRelationProperty(property) {
-        if (this.isExcludedProperty(property)) {
-            return false;
-        }
-        return this.hasDecorator(property, this.config.relationDecorators);
-    }
-    collectProperties(classDeclaration, visitedClassNames = new Set()) {
-        const className = classDeclaration.getName();
-        if (className && visitedClassNames.has(className)) {
-            return [];
-        }
-        if (className) {
-            visitedClassNames.add(className);
-        }
-        const baseClass = this.getBaseClass(classDeclaration);
-        const baseProperties = baseClass ? this.collectProperties(baseClass, visitedClassNames) : [];
-        const ownProperties = classDeclaration.getProperties();
-        return [...baseProperties, ...ownProperties];
-    }
-    getBaseClass(classDeclaration) {
-        const resolvedBaseClass = classDeclaration.getBaseClass();
-        if (resolvedBaseClass) {
-            return resolvedBaseClass;
-        }
-        const extendsExpression = classDeclaration.getExtends()?.getExpression().getText();
-        if (!extendsExpression) {
-            return null;
-        }
-        return this.findClassDeclarationByName(extendsExpression);
-    }
-    findClassDeclarationByName(className) {
-        for (const sourceFile of this.project.getSourceFiles()) {
-            const classDeclaration = sourceFile.getClass(className);
-            if (classDeclaration) {
-                return 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 import_ts_morph.Node.isObjectLiteralExpression(argument);
+      });
+      if (objectLiteral && import_ts_morph.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 || !import_ts_morph.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 = import_path.default.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;
-    }
-    isNullishTypeText(typeText) {
-        return typeText === 'null' || typeText === 'undefined';
-    }
-    isNullableTypeText(typeText) {
-        return typeText.split('|').map((item) => item.trim()).includes('null');
-    }
-    getPropertyTypeText(property) {
-        return this.cleanTypeText(property.getTypeNode()?.getText() ?? property.getType().getText(property));
-    }
-    getAccessorTypeText(accessor) {
-        return this.cleanTypeText(accessor.getReturnTypeNode()?.getText() ?? accessor.getReturnType().getText(accessor));
-    }
-    isDateColumn(property) {
-        const typeText = this.getPropertyTypeText(property);
-        return typeText === 'Date' || typeText.includes('Date |') || typeText.includes('| Date');
-    }
-    isNullableColumn(property) {
-        const typeText = this.getPropertyTypeText(property);
-        return this.isNullableTypeText(typeText) || this.hasDecoratorOption(property, this.config.columnDecorators, 'nullable', 'true');
-    }
-    resolveEnumType(type) {
-        const symbol = type.getSymbol() ?? type.getAliasSymbol();
-        const declarations = symbol?.getDeclarations() ?? [];
-        const enumDeclaration = declarations.find((declaration) => {
-            return Node.isEnumDeclaration(declaration);
-        });
-        if (!enumDeclaration || !Node.isEnumDeclaration(enumDeclaration)) {
-            return null;
-        }
-        return enumDeclaration.getName();
-    }
-    resolveEnumTypeFromProperty(property) {
-        const typeText = this.getPropertyTypeText(property);
-        const normalizedTypeText = this.unwrapNullishType(typeText);
-        const enumByType = this.findEnumDeclarationByName(normalizedTypeText);
-        if (enumByType) {
-            return enumByType.getName();
-        }
-        const columnDecorator = this.getDecorator(property, this.config.columnDecorators);
-        const objectLiteral = this.getDecoratorObjectLiteral(columnDecorator);
-        const enumProperty = this.getObjectLiteralProperty(objectLiteral, 'enum');
-        const enumInitializerText = this.getPropertyAssignmentInitializerText(enumProperty);
-        if (!enumInitializerText) {
-            return null;
-        }
-        const enumName = enumInitializerText.split('.').pop() ?? enumInitializerText;
-        const enumDeclaration = this.findEnumDeclarationByName(enumName);
-        if (!enumDeclaration) {
-            return null;
-        }
-        return enumDeclaration.getName();
-    }
-    findEnumDeclarationByName(enumName) {
-        for (const sourceFile of this.project.getSourceFiles()) {
-            const enumDeclaration = sourceFile.getEnum(enumName);
-            if (enumDeclaration) {
-                return enumDeclaration;
-            }
-        }
-        return null;
-    }
-    unwrapNullishType(typeText) {
-        return typeText
-            .split('|')
-            .map((item) => item.trim())
-            .filter((item) => item !== 'null' && item !== 'undefined')
-            .join(' | ');
-    }
-    resolveSingleColumnType(type, fallback) {
-        const typeText = this.cleanTypeText(fallback);
-        if (this.isNullishTypeText(typeText)) {
-            return typeText;
-        }
-        if (this.config.customScalarTypeMap[typeText]) {
-            return this.config.customScalarTypeMap[typeText];
-        }
-        if (typeText === 'Date') {
-            return 'string';
-        }
-        if (type.isString()) {
-            return 'string';
-        }
-        if (type.isNumber()) {
-            return 'number';
-        }
-        if (type.isBoolean()) {
-            return 'boolean';
-        }
-        if (type.isStringLiteral()) {
-            return JSON.stringify(type.getLiteralValue());
-        }
-        if (type.isNumberLiteral()) {
-            return String(type.getLiteralValue());
-        }
-        if (typeText === 'true' || typeText === 'false') {
-            return typeText;
-        }
-        const enumType = this.resolveEnumType(type);
-        if (enumType) {
-            return enumType;
-        }
-        if (typeText.includes('Date')) {
-            return typeText.replace(/\bDate\b/g, 'string');
-        }
-        if (typeText.endsWith('[]')) {
-            return 'unknown[]';
-        }
-        if (typeText.startsWith('Array<')) {
-            return 'unknown[]';
-        }
-        if (typeText === 'object') {
-            return 'Record<string, unknown>';
-        }
-        return typeText;
-    }
-    resolveColumnType(property) {
-        const enumType = this.resolveEnumTypeFromProperty(property);
-        if (enumType) {
-            return enumType;
-        }
-        const typeNodeText = this.getPropertyTypeText(property);
-        const type = property.getType();
-        if (typeNodeText.includes('|')) {
-            const result = typeNodeText.split('|').map((item) => {
-                return this.resolveSingleColumnType(type, item.trim());
-            });
-            return this.unique(result).join(' | ');
-        }
-        return this.resolveSingleColumnType(type, typeNodeText);
-    }
-    resolveAccessorType(accessor) {
-        const typeNodeText = this.getAccessorTypeText(accessor);
-        const type = accessor.getReturnType();
-        if (typeNodeText.includes('|')) {
-            const result = typeNodeText.split('|').map((item) => {
-                return this.resolveSingleColumnType(type, item.trim());
-            });
-            return this.unique(result).join(' | ');
-        }
-        return this.resolveSingleColumnType(type, typeNodeText);
-    }
-    appendNullType(typeText) {
-        if (typeText.split('|').map((item) => item.trim()).includes('null')) {
-            return typeText;
-        }
-        return `${typeText} | null`;
-    }
-    propertyToColumnMeta(property) {
-        const resolvedType = this.resolveColumnType(property);
-        const nullable = this.isNullableColumn(property);
-        return {
-            name: property.getName(),
-            optional: property.hasQuestionToken(),
-            type: nullable ? this.appendNullType(resolvedType) : resolvedType,
-            isDate: this.isDateColumn(property)
-        };
-    }
-    accessorToColumnMeta(accessor) {
-        const resolvedType = this.resolveAccessorType(accessor);
-        return {
-            name: accessor.getName(),
-            optional: false,
-            type: resolvedType,
-            isDate: this.getAccessorTypeText(accessor).includes('Date')
-        };
-    }
-    isExcludedGetter(accessor) {
-        return this.config.excludePropertyNames.includes(accessor.getName());
-    }
-    collectGetAccessors(classDeclaration, visitedClassNames = new Set()) {
-        const className = classDeclaration.getName();
-        if (className && visitedClassNames.has(className)) {
-            return [];
-        }
-        if (className) {
-            visitedClassNames.add(className);
-        }
-        const baseClass = this.getBaseClass(classDeclaration);
-        const baseGetters = baseClass ? this.collectGetAccessors(baseClass, visitedClassNames) : [];
-        const ownGetters = classDeclaration.getGetAccessors();
-        return [...baseGetters, ...ownGetters];
-    }
-    unwrapRelationType(typeText) {
-        return this.cleanTypeText(typeText)
-            .replace(/^Promise<(.+)>$/, '$1')
-            .replace(/^Array<(.+)>$/, '$1')
-            .replace(/\[\]$/, '')
-            .split('|')
-            .map((item) => item.trim())
-            .filter((item) => item !== 'null' && item !== 'undefined')
-            .join(' | ');
-    }
-    getRelationTargetClassName(property) {
-        const decorator = this.getDecorator(property, this.config.relationDecorators);
-        const firstArgument = decorator?.getArguments()[0]?.getText() ?? '';
-        const arrowMatch = firstArgument.match(/=>\s*([A-Za-z0-9_]+)/);
-        const returnMatch = firstArgument.match(/return\s+([A-Za-z0-9_]+)/);
-        if (arrowMatch?.[1]) {
-            return arrowMatch[1];
-        }
-        if (returnMatch?.[1]) {
-            return returnMatch[1];
-        }
-        return this.unwrapRelationType(this.getPropertyTypeText(property));
-    }
-    isArrayRelation(property) {
-        const decorator = this.getDecorator(property, this.config.relationDecorators);
-        const decoratorName = decorator?.getName() ?? '';
-        const typeText = this.getPropertyTypeText(property);
-        return this.config.arrayRelationDecorators.includes(decoratorName)
-            || typeText.includes('[]')
-            || typeText.startsWith('Array<')
-            || typeText.startsWith('Promise<Array<')
-            || typeText.includes('Promise<') && typeText.includes('[]>');
-    }
-    isNullableRelation(property) {
-        const typeText = this.getPropertyTypeText(property);
-        return this.isNullableTypeText(typeText) || this.hasDecoratorOption(property, this.config.relationDecorators, 'nullable', 'true');
-    }
-    propertyToRelationMeta(property) {
-        const targetClassName = this.getRelationTargetClassName(property);
-        return {
-            name: property.getName(),
-            targetClassName,
-            targetDTOName: `${targetClassName}DTO`,
-            isArray: this.isArrayRelation(property),
-            nullable: this.isNullableRelation(property)
-        };
-    }
-    createEntityMetas(entitySourceFiles) {
-        const metas = [];
-        for (const sourceFile of entitySourceFiles) {
-            for (const classDeclaration of sourceFile.getClasses()) {
-                if (!this.isEntityClass(classDeclaration)) {
-                    continue;
-                }
-                const className = classDeclaration.getNameOrThrow();
-                const moduleName = this.toKebabCase(className);
-                const properties = this.collectProperties(classDeclaration);
-                const columns = properties
-                    .filter((property) => this.isColumnProperty(property))
-                    .map((property) => this.propertyToColumnMeta(property));
-                const relations = properties
-                    .filter((property) => this.isRelationProperty(property))
-                    .map((property) => this.propertyToRelationMeta(property));
-                const takenNames = new Set([
-                    ...columns.map((column) => column.name),
-                    ...relations.map((relation) => relation.name)
-                ]);
-                const getterColumns = this.config.includeGetters
-                    ? this.collectGetAccessors(classDeclaration)
-                        .filter((getter) => getter.getParameters().length === 0)
-                        .filter((getter) => !this.isExcludedGetter(getter))
-                        .filter((getter) => !takenNames.has(getter.getName()))
-                        .map((getter) => this.accessorToColumnMeta(getter))
-                    : [];
-                metas.push({
-                    className,
-                    dtoName: `${className}DTO`,
-                    moduleName,
-                    filePath: classDeclaration.getSourceFile().getFilePath(),
-                    sourceFilePath: sourceFile.getFilePath(),
-                    dtoFileName: `${moduleName}.dto.ts`,
-                    mapperName: `parse${className}DTO`,
-                    columns: [...columns, ...getterColumns],
-                    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) {
-        const dtoFilePath = path.join(this.config.dtoOutputDir, meta.dtoFileName);
-        const validRelations = this.getValidRelations(meta, metas);
-        const relationImports = this.unique(validRelations
-            .filter((relation) => {
-            return relation.targetClassName !== meta.className;
-        })
-            .map((relation) => {
-            return 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 = new Map();
-        for (const [typeName, moduleSpecifier] of [...relationImports, ...externalTypeImports]) {
-            if (!importMap.has(moduleSpecifier)) {
-                importMap.set(moduleSpecifier, new Set());
-            }
-            importMap.get(moduleSpecifier)?.add(typeName);
-        }
-        const imports = [...importMap.entries()]
-            .sort((a, b) => {
-            return a[0].localeCompare(b[0]);
-        })
-            .map(([moduleSpecifier, typeNames]) => {
-            return `import type { ${[...typeNames].sort((a, b) => a.localeCompare(b)).join(', ')} } from '${moduleSpecifier}'`;
-        });
-        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')}\n\n` : '';
-        const body = [...columnLines, ...relationLines].join('\n');
-        return `${importBlock}export type ${meta.dtoName} = {\n${body}\n}\n`;
-    }
-    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 = new Set();
-        const ignoredNames = 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 targetPath = import_path.default.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 (!import_fs.default.existsSync(commonTypesFilePath)) {
+      return null;
+    }
+    return import_fs.default.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) ?? [];
-            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 = 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()) {
-            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;
-    }
-    getCommonTypeReExportModuleSpecifier(typeName, commonTypesFilePath) {
-        const knownLibTypeFiles = [
-            path.join(process.cwd(), 'packages/lib/src/midtrans-client.ts'),
-            path.join(process.cwd(), 'packages/lib/src/common.ts')
-        ];
-        for (const filePath of knownLibTypeFiles) {
-            const sourceFile = this.project.addSourceFileAtPathIfExists(filePath);
-            const symbolNames = sourceFile?.getExportSymbols().map((symbol) => symbol.getName()) ?? [];
-            if (symbolNames.includes(typeName)) {
-                const enumDeclaration = sourceFile?.getEnum(typeName);
-                return {
-                    moduleSpecifier: this.createRelativeJSImportPath(commonTypesFilePath, filePath),
-                    isTypeOnly: !enumDeclaration
-                };
-            }
-        }
-        return null;
-    }
-    normalizeDeclarationToExportText(typeName) {
-        const declaration = this.findTypeDeclarationByName(typeName);
-        if (!declaration) {
-            return null;
-        }
-        const declarationText = declaration.getText().trim();
-        if (declarationText.startsWith('export ')) {
-            return declarationText;
-        }
-        return `export ${declarationText}`;
-    }
-    ensureCommonTypesFile(metas) {
-        const commonTypesFilePath = this.getCommonTypesFilePath();
-        const symbols = [...this.collectAllExternalTypeSymbols(metas)].sort((a, b) => a.localeCompare(b));
-        const lines = [
-            'export type SearchDTO = {',
-            '    title: string',
-            '    subtitle?: string | null',
-            '    path: string',
-            '}'
-        ];
-        for (const symbol of symbols) {
-            const reExportModule = this.getCommonTypeReExportModuleSpecifier(symbol, commonTypesFilePath);
-            if (reExportModule) {
-                const exportKeyword = reExportModule.isTypeOnly ? 'export type' : 'export';
-                lines.push(`${exportKeyword} { ${symbol} } from '${reExportModule.moduleSpecifier}'`);
-                continue;
-            }
-            const declarationText = this.normalizeDeclarationToExportText(symbol);
-            if (!declarationText) {
-                throw new Error(`DTOGeneratorService config error: could not generate common type '${symbol}'.`);
-            }
-            lines.push(declarationText.replace(/^export declare /, 'export '));
-        }
-        const content = `${lines.join('\n\n')}\n`;
-        this.writeFile(commonTypesFilePath, content);
-        this.project.addSourceFileAtPathIfExists(commonTypesFilePath);
-    }
-    resolveCommonTypesSourceFile() {
-        const commonTypesFilePath = this.getCommonTypesFilePath();
-        if (!fs.existsSync(commonTypesFilePath)) {
-            return null;
-        }
-        return this.project.addSourceFileAtPathIfExists(commonTypesFilePath) ?? null;
-    }
-    validateCommonTypeCoverage(metas) {
-        const commonTypesSource = this.resolveCommonTypesSourceFile();
-        if (!commonTypesSource) {
-            throw new Error(`DTOGeneratorService config error: common.dto.ts was not generated in '${this.config.dtoOutputDir}'.`);
-        }
-        const exportedSymbols = new Set(commonTypesSource.getExportSymbols().map((symbol) => symbol.getName()));
-        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) {
-                if (!exportedSymbols.has(symbol)) {
-                    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:\n- ${details}`);
-        }
-    }
-    createDTOIndexContent(metas) {
-        const dtoTypeExports = metas
-            .map((meta) => {
-            return `export type { ${meta.dtoName} } from './${meta.moduleName}.dto.ts'`;
-        })
-            .join('\n');
-        return `export * from './common.dto.ts'\n${dtoTypeExports}`;
-    }
-    createGeneratedMapperContent(metas) {
-        const hasDateColumn = metas.some((meta) => {
-            return meta.columns.some((column) => {
-                return column.isDate;
-            });
-        });
-        const helperImport = hasDateColumn ? `import { toDTODate } from './dto-date.util.ts'\n` : '';
-        const entityImports = metas.map((meta) => {
-            return `import { ${meta.className} } from '${this.createRelativeJSImportPath(this.config.mapperOutputFile, meta.filePath)}'`;
-        });
-        const dtoImports = `import type { ${metas.map((meta) => meta.dtoName).join(', ')} } from '${this.config.sharedDTOImportPath}'`;
-        const mapperFunctions = metas.map((meta) => {
-            return this.createMapperFunctionContent(meta, metas);
-        });
-        return `${helperImport}${entityImports.join('\n')}\n${dtoImports}\n\n${mapperFunctions.join('\n\n')}\n`;
-    }
-    createMapperFunctionContent(meta, metas) {
-        const validRelations = this.getValidRelations(meta, metas);
-        const columnLines = meta.columns.map((column) => {
-            const value = column.isDate ? `toDTODate(entity.${column.name})` : `entity.${column.name}`;
-            return `        ${column.name}: ${value}`;
-        });
-        const relationLines = validRelations.map((relation) => {
-            return this.createRelationMapperLine(relation, metas);
-        });
-        const relationBlock = relationLines.length ? `\n${relationLines.join('\n\n')}\n` : '';
-        return `export function ${meta.mapperName}(entity: ${meta.className}): ${meta.dtoName} {\n    const dto: ${meta.dtoName} = {\n${columnLines.join(',\n')}\n    }\n${relationBlock}\n    return dto\n}\n\nexport function ${meta.mapperName}Array(entities: ${meta.className}[]): ${meta.dtoName}[] {\n    return entities.map(${meta.mapperName})\n}`;
-    }
-    createRelationMapperLine(relation, metas) {
-        const targetMeta = this.findMetaByClassName(metas, relation.targetClassName);
-        const parserName = targetMeta?.mapperName;
-        if (relation.isArray) {
-            return `    if (Array.isArray(entity.${relation.name})) {\n        dto.${relation.name} = entity.${relation.name}.map(${parserName})\n    }`;
-        }
-        if (relation.nullable) {
-            return `    if (entity.${relation.name} !== undefined) {\n        dto.${relation.name} = entity.${relation.name} === null ? null : ${parserName}(entity.${relation.name})\n    }`;
-        }
-        return `    if (entity.${relation.name} !== undefined && entity.${relation.name} !== null) {\n        dto.${relation.name} = ${parserName}(entity.${relation.name})\n    }`;
-    }
+            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})
+    }`;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TORMDTOGenerator
+});
+//# sourceMappingURL=index.js.map