dto2ts 0.1.0

package/dist/generators/models.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelFileBase = modelFileBase;
+exports.generateModelFiles = generateModelFiles;
+const naming_1 = require("../utils/naming");
+const HEADER = "// Bu dosya dto2ts tarafından otomatik üretildi. Elle düzenlemeyin.\n";
+function isValidIdentifier(name) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
+}
+function propKey(name) {
+    return isValidIdentifier(name) ? name : JSON.stringify(name);
+}
+/** Bir modelin uzantısız dosya adı tabanı. */
+function modelFileBase(m) {
+    const kebab = (0, naming_1.toKebabCase)(m.name);
+    return m.kind === "enum" ? `${kebab}.enum` : `${kebab}.model`;
+}
+function emitEnum(model) {
+    const lines = model.members.map((m) => {
+        const value = typeof m.value === "number" ? String(m.value) : JSON.stringify(m.value);
+        const key = isValidIdentifier(m.name) ? m.name : JSON.stringify(m.name);
+        return `  ${key} = ${value},`;
+    });
+    return `export enum ${model.name} {\n${lines.join("\n")}\n}\n`;
+}
+function emitInterface(model, knownInterfaces) {
+    const ext = (model.extends ?? []).filter((e) => knownInterfaces.has(e));
+    const extendsClause = ext.length ? ` extends ${ext.join(", ")}` : "";
+    const body = model.properties
+        .map((p) => {
+        const doc = p.description ? `  /** ${p.description.replace(/\*\//g, "*\\/")} */\n` : "";
+        const opt = p.optional ? "?" : "";
+        return `${doc}  ${propKey(p.name)}${opt}: ${p.type};`;
+    })
+        .join("\n");
+    const doc = model.description ? `/** ${model.description.replace(/\*\//g, "*\\/")} */\n` : "";
+    return `${doc}export interface ${model.name}${extendsClause} {\n${body}\n}\n`;
+}
+/** Bir modelin, TS tiplerinde referans verdiği diğer model adlarını bul. */
+function referencedNames(model, allNames) {
+    const refs = new Set();
+    for (const e of model.extends ?? [])
+        if (allNames.has(e))
+            refs.add(e);
+    for (const p of model.properties) {
+        for (const name of allNames) {
+            if (name === model.name)
+                continue;
+            if (new RegExp(`\\b${name}\\b`).test(p.type))
+                refs.add(name);
+        }
+    }
+    return refs;
+}
+/** Her modeli kendi dosyasına derle (models/<ad>.model.ts | <ad>.enum.ts) + barrel. */
+function generateModelFiles(api) {
+    const knownInterfaces = new Set(api.models.filter((m) => m.kind === "interface").map((m) => m.name));
+    const allNames = new Set(api.models.map((m) => m.name));
+    const byName = new Map(api.models.map((m) => [m.name, m]));
+    const files = [];
+    for (const model of api.models) {
+        const refs = [...referencedNames(model, allNames)].sort();
+        const importLines = refs
+            .map((r) => `import type { ${r} } from "./${modelFileBase(byName.get(r))}";`)
+            .join("\n");
+        const decl = model.kind === "enum" ? emitEnum(model) : emitInterface(model, knownInterfaces);
+        const content = HEADER + (importLines ? "\n" + importLines + "\n" : "") + "\n" + decl;
+        files.push({ path: `models/${modelFileBase(model)}.ts`, content });
+    }
+    // models/index.ts barrel
+    const barrel = HEADER +
+        "\n" +
+        api.models.map((m) => `export * from "./${modelFileBase(m)}";`).join("\n") +
+        "\n";
+    files.push({ path: "models/index.ts", content: barrel });
+    return files;
+}

package/dist/generators/services.d.ts

@@ -0,0 +1,6 @@
+import { ApiModel, ResourceDef } from "../ir";
+import { GeneratedFile } from "./models";
+/** Bir kaynağın uzantısız service dosya adı tabanı. Örn. "product.service". */
+export declare function serviceFileBase(r: ResourceDef): string;
+/** Her kaynak için service dosyası (services/<ad>.service.ts) + barrel. */
+export declare function generateServiceFiles(api: ApiModel): GeneratedFile[];

package/dist/generators/services.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serviceFileBase = serviceFileBase;
+exports.generateServiceFiles = generateServiceFiles;
+const naming_1 = require("../utils/naming");
+const HEADER = "// Bu dosya dto2ts tarafından otomatik üretildi. Elle düzenlemeyin.\n";
+/** Bir kaynağın uzantısız service dosya adı tabanı. Örn. "product.service". */
+function serviceFileBase(r) {
+    return `${(0, naming_1.toKebabCase)(r.name)}.service`;
+}
+function emitService(r) {
+    const cls = `${r.name}Service`;
+    const model = r.model;
+    const idT = r.idType;
+    return `/**
+ * ${r.name} kaynağı için CRUD service.
+ * Base path: ${r.basePath}
+ */
+export class ${cls} {
+  constructor(
+    private readonly http: HttpClient,
+    private readonly basePath: string = ${JSON.stringify(r.basePath)}
+  ) {}
+
+  /** Tüm kayıtları getir. */
+  list(options?: RequestOptions): Promise<${model}[]> {
+    return this.http.get<${model}[]>(this.basePath, options);
+  }
+
+  /** Id ile tek kayıt getir. */
+  getById(id: ${idT}, options?: RequestOptions): Promise<${model}> {
+    return this.http.get<${model}>(\`\${this.basePath}/\${id}\`, options);
+  }
+
+  /** Yeni kayıt oluştur. */
+  create(payload: ${model}, options?: RequestOptions): Promise<${model}> {
+    return this.http.post<${model}>(this.basePath, payload, options);
+  }
+
+  /** Var olan kaydı tümüyle güncelle. */
+  update(id: ${idT}, payload: ${model}, options?: RequestOptions): Promise<${model}> {
+    return this.http.put<${model}>(\`\${this.basePath}/\${id}\`, payload, options);
+  }
+
+  /** Kaydı kısmi güncelle. */
+  patch(id: ${idT}, payload: Partial<${model}>, options?: RequestOptions): Promise<${model}> {
+    return this.http.patch<${model}>(\`\${this.basePath}/\${id}\`, payload, options);
+  }
+
+  /** Kaydı sil. */
+  remove(id: ${idT}, options?: RequestOptions): Promise<void> {
+    return this.http.delete<void>(\`\${this.basePath}/\${id}\`, options);
+  }
+}
+`;
+}
+/** Her kaynak için service dosyası (services/<ad>.service.ts) + barrel. */
+function generateServiceFiles(api) {
+    if (!api.resources.length)
+        return [];
+    const files = [];
+    for (const r of api.resources) {
+        const content = HEADER +
+            "\n" +
+            `import { HttpClient } from "../http-client";\n` +
+            `import type { RequestOptions } from "../http-client";\n` +
+            `import type { ${r.model} } from "../models";\n\n` +
+            emitService(r);
+        files.push({ path: `services/${serviceFileBase(r)}.ts`, content });
+    }
+    const barrel = HEADER +
+        "\n" +
+        api.resources.map((r) => `export * from "./${serviceFileBase(r)}";`).join("\n") +
+        "\n";
+    files.push({ path: "services/index.ts", content: barrel });
+    return files;
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * dto2ts — programatik API.
+ *
+ * CLI için `dto2ts` binary'sini kullanın; kodun içinden çağırmak için `generate`.
+ */
+export { generate, parseSource } from "./generate";
+export type { GenerateResult } from "./generate";
+export { GenConfig, DEFAULT_CONFIG, loadConfigFile, resolveConfig, } from "./config";
+export type { ApiModel, ModelDef, PropertyDef, EnumMemberDef, ResourceDef, } from "./ir";

package/dist/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfig = exports.loadConfigFile = exports.DEFAULT_CONFIG = exports.parseSource = exports.generate = void 0;
+/**
+ * dto2ts — programatik API.
+ *
+ * CLI için `dto2ts` binary'sini kullanın; kodun içinden çağırmak için `generate`.
+ */
+var generate_1 = require("./generate");
+Object.defineProperty(exports, "generate", { enumerable: true, get: function () { return generate_1.generate; } });
+Object.defineProperty(exports, "parseSource", { enumerable: true, get: function () { return generate_1.parseSource; } });
+var config_1 = require("./config");
+Object.defineProperty(exports, "DEFAULT_CONFIG", { enumerable: true, get: function () { return config_1.DEFAULT_CONFIG; } });
+Object.defineProperty(exports, "loadConfigFile", { enumerable: true, get: function () { return config_1.loadConfigFile; } });
+Object.defineProperty(exports, "resolveConfig", { enumerable: true, get: function () { return config_1.resolveConfig; } });

package/dist/ir.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Ara model (Intermediate Representation).
+ *
+ * Hem OpenAPI parser'ı hem C# parser'ı çıktı olarak bu yapıyı üretir.
+ * Generator'lar yalnızca bu yapıya bakar; böylece kaynak formatından bağımsızdır.
+ */
+/** Tek bir modelin (interface veya enum) tanımı. */
+export interface ModelDef {
+    /** TS tip adı (PascalCase). Örn. "ProductDto". */
+    name: string;
+    kind: "interface" | "enum";
+    description?: string;
+    properties: PropertyDef[];
+    /** Kalıtım: bu model başka bir modeli genişletiyorsa (extends). */
+    extends?: string[];
+    members: EnumMemberDef[];
+}
+export interface PropertyDef {
+    /** TS/JSON içindeki alan adı (varsayılan camelCase). */
+    name: string;
+    /** Kaynaktaki orijinal ad (C#'ta PascalCase olabilir). */
+    originalName: string;
+    /** Çözülmüş TS tip ifadesi. Örn. "string", "Foo[]", "Record<string, number>". */
+    type: string;
+    /** null/undefined olabilir mi (opsiyonel alan). */
+    optional: boolean;
+    description?: string;
+}
+export interface EnumMemberDef {
+    name: string;
+    value: string | number;
+}
+/** Bir CRUD kaynağı (entity) için service üretim bilgisi. */
+export interface ResourceDef {
+    /** Service'in dayandığı model adı. Örn. "ProductDto". */
+    model: string;
+    /** Service sınıf adı için kök. Örn. "Product". */
+    name: string;
+    /** API base path. Örn. "/api/products". */
+    basePath: string;
+    /** Id alanının TS tipi. Örn. "number" | "string". */
+    idType: string;
+}
+/** Parser'ların ürettiği, generator'ların tükettiği tam model. */
+export interface ApiModel {
+    models: ModelDef[];
+    resources: ResourceDef[];
+}

package/dist/ir.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Ara model (Intermediate Representation).
+ *
+ * Hem OpenAPI parser'ı hem C# parser'ı çıktı olarak bu yapıyı üretir.
+ * Generator'lar yalnızca bu yapıya bakar; böylece kaynak formatından bağımsızdır.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/parsers/csharp-types.d.ts

@@ -0,0 +1,9 @@
+import { GenConfig } from "../config";
+export interface MappedType {
+    /** TS tip ifadesi. */
+    tsType: string;
+    /** C# nullable işareti (Type? / Nullable<Type>) bulundu mu. */
+    nullable: boolean;
+}
+/** Bir C# tip ifadesini TS'ye çevir. */
+export declare function mapCsharpType(rawInput: string, config: GenConfig): MappedType;

package/dist/parsers/csharp-types.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapCsharpType = mapCsharpType;
+const PRIMITIVES = {
+    string: "string",
+    char: "string",
+    guid: "string",
+    bool: "boolean",
+    boolean: "boolean",
+    byte: "number",
+    sbyte: "number",
+    short: "number",
+    ushort: "number",
+    int: "number",
+    int16: "number",
+    int32: "number",
+    int64: "number",
+    uint: "number",
+    long: "number",
+    ulong: "number",
+    decimal: "number",
+    double: "number",
+    float: "number",
+    single: "number",
+    object: "unknown",
+    dynamic: "unknown",
+};
+function splitGenericArgs(inner) {
+    // "string, List<int>" -> ["string", "List<int>"] (iç içe generic'e dikkat).
+    const args = [];
+    let depth = 0;
+    let current = "";
+    for (const ch of inner) {
+        if (ch === "<")
+            depth++;
+        if (ch === ">")
+            depth--;
+        if (ch === "," && depth === 0) {
+            args.push(current.trim());
+            current = "";
+        }
+        else {
+            current += ch;
+        }
+    }
+    if (current.trim())
+        args.push(current.trim());
+    return args;
+}
+/** Bir C# tip ifadesini TS'ye çevir. */
+function mapCsharpType(rawInput, config) {
+    let raw = rawInput.trim();
+    let nullable = false;
+    // Task<T> / ValueTask<T> sar-çöz
+    const taskMatch = /^(?:Task|ValueTask)<(.+)>$/.exec(raw);
+    if (taskMatch)
+        return mapCsharpType(taskMatch[1], config);
+    // Nullable<T>
+    const nullableGeneric = /^Nullable<(.+)>$/.exec(raw);
+    if (nullableGeneric) {
+        const inner = mapCsharpType(nullableGeneric[1], config);
+        return { tsType: inner.tsType, nullable: true };
+    }
+    // Trailing "?"  (int?, string?)
+    if (raw.endsWith("?")) {
+        nullable = true;
+        raw = raw.slice(0, -1).trim();
+    }
+    // Diziler: T[]
+    if (raw.endsWith("[]")) {
+        const inner = mapCsharpType(raw.slice(0, -2), config);
+        return { tsType: `${inner.tsType}[]`, nullable };
+    }
+    // Generic koleksiyonlar / sözlük
+    const generic = /^([A-Za-z0-9_.]+)<(.+)>$/.exec(raw);
+    if (generic) {
+        const container = generic[1].split(".").pop(); // namespace at
+        const args = splitGenericArgs(generic[2]);
+        const listLike = ["List", "IList", "IEnumerable", "ICollection", "IReadOnlyList",
+            "IReadOnlyCollection", "Collection", "HashSet", "ISet", "Queue", "Stack"];
+        if (listLike.includes(container) && args.length === 1) {
+            const inner = mapCsharpType(args[0], config);
+            return { tsType: `${inner.tsType}[]`, nullable };
+        }
+        const dictLike = ["Dictionary", "IDictionary", "IReadOnlyDictionary", "SortedDictionary"];
+        if (dictLike.includes(container) && args.length === 2) {
+            const key = mapCsharpType(args[0], config).tsType;
+            const val = mapCsharpType(args[1], config).tsType;
+            const keyType = key === "number" ? "number" : "string";
+            return { tsType: `Record<${keyType}, ${val}>`, nullable };
+        }
+        // Bilinmeyen generic: sadece kök adı kullan (custom tip varsayımı).
+        return { tsType: container, nullable };
+    }
+    // Namespace'i at (System.String -> String)
+    const shortName = raw.split(".").pop();
+    const key = shortName.toLowerCase();
+    if (key in PRIMITIVES) {
+        // byte[] zaten yukarıda; primitive
+        return { tsType: PRIMITIVES[key], nullable };
+    }
+    // Tarih/zaman tipleri
+    if (["datetime", "datetimeoffset", "dateonly", "timeonly", "timespan"].includes(key)) {
+        return { tsType: config.dateAsString ? "string" : "Date", nullable };
+    }
+    // Referans tipleri (string, custom class) TS'de null olabilir ama C# non-nullable ref
+    // olarak işaretlenmemişse çoğu API camelCase JSON'da alan gönderir; optional'ı
+    // yalnızca açık nullable işaretinden belirliyoruz.
+    // Aksi halde custom tip: adını olduğu gibi bırak (PascalCase model referansı).
+    return { tsType: shortName, nullable };
+}

package/dist/parsers/csharp.d.ts

@@ -0,0 +1,3 @@
+import { GenConfig } from "../config";
+import { ApiModel } from "../ir";
+export declare function parseCsharp(config: GenConfig): ApiModel;

package/dist/parsers/csharp.js

@@ -0,0 +1,224 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCsharp = parseCsharp;
+const fs = __importStar(require("fs"));
+const fs_1 = require("../utils/fs");
+const naming_1 = require("../utils/naming");
+const csharp_types_1 = require("./csharp-types");
+const resources_1 = require("./resources");
+/** Yorumları temizle (satır ve blok). String literalleri kabaca korur. */
+function stripComments(src) {
+    return src
+        .replace(/\/\*[\s\S]*?\*\//g, "")
+        .replace(/\/\/[^\n]*/g, "");
+}
+/** index'teki açılış `{` için eşleşen kapanış `}` indeksini bul. */
+function matchBrace(src, openIndex) {
+    let depth = 0;
+    for (let i = openIndex; i < src.length; i++) {
+        if (src[i] === "{")
+            depth++;
+        else if (src[i] === "}") {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}
+function parseEnumBody(name, body) {
+    const members = [];
+    let auto = 0;
+    for (const rawMember of body.split(",")) {
+        const member = rawMember.trim();
+        if (!member)
+            continue;
+        const eq = member.split("=");
+        const memberName = eq[0].trim();
+        if (!memberName)
+            continue;
+        if (eq.length > 1) {
+            const rawVal = eq[1].trim();
+            const num = Number(rawVal);
+            if (!Number.isNaN(num)) {
+                members.push({ name: memberName, value: num });
+                auto = num + 1;
+                continue;
+            }
+            members.push({ name: memberName, value: rawVal });
+            continue;
+        }
+        members.push({ name: memberName, value: auto });
+        auto++;
+    }
+    return { name, kind: "enum", properties: [], members };
+}
+const PROP_RE = /public\s+(?:virtual\s+|override\s+|required\s+|static\s+|readonly\s+)*([A-Za-z0-9_.<>,\[\]?\s]+?)\s+([A-Za-z_][A-Za-z0-9_]*)\s*\{\s*get\b/g;
+function parseClassBody(name, extendsList, body, config) {
+    const properties = [];
+    PROP_RE.lastIndex = 0;
+    let m;
+    while ((m = PROP_RE.exec(body)) !== null) {
+        const rawType = m[1].trim();
+        const propName = m[2];
+        const mapped = (0, csharp_types_1.mapCsharpType)(rawType, config);
+        properties.push({
+            name: config.camelCase ? (0, naming_1.toCamelCase)(propName) : propName,
+            originalName: propName,
+            type: mapped.tsType,
+            optional: mapped.nullable,
+        });
+    }
+    return { name, kind: "interface", properties, members: [], extends: extendsList };
+}
+/** Positional record: record PersonDto(string Name, int Age); */
+function parseRecordParams(name, extendsList, params, config) {
+    const properties = [];
+    // Parametreleri virgülden ayır (generic'e dikkat).
+    let depth = 0;
+    let current = "";
+    const parts = [];
+    for (const ch of params) {
+        if (ch === "<" || ch === "(")
+            depth++;
+        else if (ch === ">" || ch === ")")
+            depth--;
+        if (ch === "," && depth === 0) {
+            parts.push(current);
+            current = "";
+        }
+        else
+            current += ch;
+    }
+    if (current.trim())
+        parts.push(current);
+    for (const part of parts) {
+        const tokens = part.trim().split(/\s+/);
+        if (tokens.length < 2)
+            continue;
+        const propName = tokens[tokens.length - 1];
+        const rawType = tokens.slice(0, -1).join(" ");
+        const mapped = (0, csharp_types_1.mapCsharpType)(rawType, config);
+        properties.push({
+            name: config.camelCase ? (0, naming_1.toCamelCase)(propName) : propName,
+            originalName: propName,
+            type: mapped.tsType,
+            optional: mapped.nullable,
+        });
+    }
+    return { name, kind: "interface", properties, members: [], extends: extendsList };
+}
+function parseInheritance(clause) {
+    if (!clause)
+        return [];
+    return clause
+        .split(",")
+        .map((s) => s.trim().split("<")[0].trim()) // generic argümanları at
+        .filter((s) => /^[A-Z][A-Za-z0-9_]*$/.test(s)); // interface (IFoo) gibi olanları da bırak; generator filtreler
+}
+function parseSource(src, config, models) {
+    const clean = stripComments(src);
+    // Enumlar
+    const enumRe = /\benum\s+([A-Za-z_][A-Za-z0-9_]*)\s*(?::\s*[A-Za-z0-9_.]+)?\s*\{/g;
+    let em;
+    while ((em = enumRe.exec(clean)) !== null) {
+        const open = clean.indexOf("{", em.index);
+        const close = matchBrace(clean, open);
+        if (close === -1)
+            continue;
+        const body = clean.slice(open + 1, close);
+        models.push(parseEnumBody(em[1], body));
+    }
+    // class / struct / record (gövdeli)
+    const typeRe = /\b(?:public\s+|internal\s+|abstract\s+|sealed\s+|partial\s+)*\b(class|struct|record(?:\s+class|\s+struct)?)\s+([A-Za-z_][A-Za-z0-9_]*)\s*(?:<[^>{(]+>)?\s*(?:\(([^)]*)\))?\s*(?::\s*([^{;]+?))?\s*(\{|;)/g;
+    let tm;
+    while ((tm = typeRe.exec(clean)) !== null) {
+        const typeName = tm[2];
+        const recordParams = tm[3];
+        const inheritance = parseInheritance(tm[4]);
+        const terminator = tm[5];
+        if (terminator === ";") {
+            // Gövdesiz positional record: record Foo(...);
+            if (recordParams !== undefined) {
+                models.push(parseRecordParams(typeName, inheritance, recordParams, config));
+            }
+            continue;
+        }
+        const open = clean.indexOf("{", tm.index);
+        const close = matchBrace(clean, open);
+        if (close === -1)
+            continue;
+        const body = clean.slice(open + 1, close);
+        const classModel = parseClassBody(typeName, inheritance, body, config);
+        // Positional record hem parametre hem gövde içerebilir -> birleştir.
+        if (recordParams !== undefined) {
+            const posModel = parseRecordParams(typeName, inheritance, recordParams, config);
+            const seen = new Set(classModel.properties.map((p) => p.originalName));
+            for (const p of posModel.properties) {
+                if (!seen.has(p.originalName))
+                    classModel.properties.push(p);
+            }
+        }
+        models.push(classModel);
+        // Sonraki aramayı gövdeden sonra sürdür (iç içe tipleri atlar).
+        typeRe.lastIndex = close;
+    }
+}
+function parseCsharp(config) {
+    const files = (0, fs_1.collectCsFiles)(config.input);
+    const models = [];
+    for (const file of files) {
+        const src = fs.readFileSync(file, "utf8");
+        parseSource(src, config, models);
+    }
+    // Aynı isimli modelleri tekilleştir (partial class'lar vb.).
+    const byName = new Map();
+    for (const model of models) {
+        const existing = byName.get(model.name);
+        if (!existing) {
+            byName.set(model.name, model);
+        }
+        else if (model.kind === "interface" && existing.kind === "interface") {
+            const seen = new Set(existing.properties.map((p) => p.originalName));
+            for (const p of model.properties) {
+                if (!seen.has(p.originalName))
+                    existing.properties.push(p);
+            }
+        }
+    }
+    const deduped = [...byName.values()];
+    return { models: deduped, resources: (0, resources_1.buildResources)(deduped, config) };
+}

package/dist/parsers/openapi.d.ts

@@ -0,0 +1,3 @@
+import { GenConfig } from "../config";
+import { ApiModel } from "../ir";
+export declare function parseOpenApi(config: GenConfig): Promise<ApiModel>;