dto2ts 0.1.0

package/dist/parsers/openapi.js

@@ -0,0 +1,218 @@
+"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.parseOpenApi = parseOpenApi;
+const fs = __importStar(require("fs"));
+const naming_1 = require("../utils/naming");
+const resources_1 = require("./resources");
+async function loadDoc(input) {
+    if (/^https?:\/\//i.test(input)) {
+        const res = await fetch(input);
+        if (!res.ok)
+            throw new Error(`OpenAPI indirilemedi (${res.status}): ${input}`);
+        return (await res.json());
+    }
+    return JSON.parse(fs.readFileSync(input, "utf8"));
+}
+function refName(ref) {
+    return ref.split("/").pop() ?? ref;
+}
+function isNullable(schema) {
+    if (!schema)
+        return false;
+    if (schema.nullable === true)
+        return true; // OpenAPI 3.0
+    if (Array.isArray(schema.type) && schema.type.includes("null"))
+        return true; // 3.1
+    return false;
+}
+/** Bir şemayı TS tip ifadesine çevir (inline nested objeleri type literal olarak). */
+function schemaToTsType(schema, config) {
+    if (!schema)
+        return "unknown";
+    if (schema.$ref)
+        return refName(schema.$ref);
+    // allOf: ilk $ref'i temel al; yoksa unknown.
+    if (Array.isArray(schema.allOf)) {
+        const ref = schema.allOf.find((s) => s.$ref);
+        if (ref)
+            return refName(ref.$ref);
+        return "unknown";
+    }
+    if (Array.isArray(schema.oneOf) || Array.isArray(schema.anyOf)) {
+        const variants = (schema.oneOf ?? schema.anyOf);
+        const parts = variants.filter((s) => s && !s.$ref?.includes("null")).map((s) => schemaToTsType(s, config));
+        return parts.length ? [...new Set(parts)].join(" | ") : "unknown";
+    }
+    // type bir dizi olabilir (3.1): ["string","null"]
+    const type = Array.isArray(schema.type)
+        ? schema.type.find((t) => t !== "null")
+        : schema.type;
+    if (schema.enum && Array.isArray(schema.enum)) {
+        return schema.enum
+            .map((v) => (typeof v === "string" ? JSON.stringify(v) : String(v)))
+            .join(" | ");
+    }
+    switch (type) {
+        case "string":
+            if (["date-time", "date", "time"].includes(schema.format)) {
+                return config.dateAsString ? "string" : "Date";
+            }
+            return "string";
+        case "integer":
+        case "number":
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "array":
+            return `${schemaToTsType(schema.items, config)}[]`;
+        case "object":
+        default: {
+            if (schema.properties) {
+                const props = Object.entries(schema.properties).map(([key, val]) => {
+                    const req = Array.isArray(schema.required) && schema.required.includes(key);
+                    const opt = !req || isNullable(val) ? "?" : "";
+                    const name = config.camelCase ? (0, naming_1.toCamelCase)(key) : key;
+                    return `${name}${opt}: ${schemaToTsType(val, config)}`;
+                });
+                return `{ ${props.join("; ")} }`;
+            }
+            if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+                return `Record<string, ${schemaToTsType(schema.additionalProperties, config)}>`;
+            }
+            if (schema.additionalProperties === true)
+                return "Record<string, unknown>";
+            return "unknown";
+        }
+    }
+}
+function schemaToModel(name, schema, config) {
+    // Enum modeli
+    if (schema.enum && Array.isArray(schema.enum) && (schema.type === "string" || schema.type === "integer")) {
+        const members = schema.enum.map((v, i) => {
+            if (typeof v === "number")
+                return { name: `Value${v}`, value: v };
+            const raw = String(v);
+            const memberName = (0, naming_1.toPascalCase)(raw.replace(/[^A-Za-z0-9_]/g, "_")) || `Value${i}`;
+            return { name: memberName, value: raw };
+        });
+        return { name, kind: "enum", properties: [], members };
+    }
+    // allOf ile kalıtım
+    let extendsList = [];
+    let effective = schema;
+    if (Array.isArray(schema.allOf)) {
+        extendsList = schema.allOf.filter((s) => s.$ref).map((s) => refName(s.$ref));
+        const objPart = schema.allOf.find((s) => s.properties);
+        if (objPart)
+            effective = objPart;
+    }
+    if (!effective.properties) {
+        // Alanı olmayan obje -> boş interface (yine de üret).
+        return { name, kind: "interface", properties: [], members: [], extends: extendsList };
+    }
+    const required = Array.isArray(effective.required) ? effective.required : [];
+    const properties = Object.entries(effective.properties).map(([key, val]) => {
+        const optional = !required.includes(key) || isNullable(val);
+        return {
+            name: config.camelCase ? (0, naming_1.toCamelCase)(key) : key,
+            originalName: key,
+            type: schemaToTsType(val, config),
+            optional,
+            description: val.description,
+        };
+    });
+    return { name, kind: "interface", properties, members: [], extends: extendsList, description: schema.description };
+}
+/** paths bölümünden kaynak (resource) base path'lerini türet. */
+function resourcesFromPaths(doc, models, config) {
+    const paths = doc.paths;
+    if (!paths || typeof paths !== "object")
+        return [];
+    // path -> bu path'te referans verilen şema adları
+    const modelNames = new Set(models.filter((m) => m.kind === "interface").map((m) => m.name));
+    const byResource = new Map();
+    const collectRefModels = (obj, acc) => {
+        if (!obj || typeof obj !== "object")
+            return;
+        if (typeof obj.$ref === "string")
+            acc.add(refName(obj.$ref));
+        for (const v of Object.values(obj))
+            collectRefModels(v, acc);
+    };
+    for (const [rawPath, ops] of Object.entries(paths)) {
+        // "/api/products" veya "/api/products/{id}" -> kök "/api/products"
+        const base = rawPath.replace(/\/\{[^}]+\}.*$/, "");
+        const refs = new Set();
+        collectRefModels(ops, refs);
+        const model = [...refs].find((r) => modelNames.has(r));
+        const existing = byResource.get(base);
+        if (!existing) {
+            byResource.set(base, { basePath: base, model });
+        }
+        else if (!existing.model && model) {
+            existing.model = model;
+        }
+    }
+    const resources = [];
+    for (const { basePath, model } of byResource.values()) {
+        if (!model)
+            continue;
+        if (config.entities && config.entities.length && !config.entities.includes(model))
+            continue;
+        const segment = basePath.split("/").filter(Boolean).pop() ?? model;
+        const name = (0, naming_1.toPascalCase)(segment.replace(/s$/, "")); // kaba tekilleştirme
+        const modelDef = models.find((m) => m.name === model);
+        const idProp = modelDef?.properties.find((p) => p.originalName.toLowerCase() === "id");
+        const idType = idProp && (idProp.type === "number" || idProp.type === "string") ? idProp.type : config.idType ?? "number";
+        resources.push({ model, name: name || model, basePath, idType });
+    }
+    return resources;
+}
+async function parseOpenApi(config) {
+    const doc = await loadDoc(config.input);
+    const schemas = doc.components?.schemas ?? doc.definitions ?? {};
+    const models = [];
+    for (const [name, schema] of Object.entries(schemas)) {
+        const model = schemaToModel(name, schema, config);
+        if (model)
+            models.push(model);
+    }
+    // Önce paths'ten kaynak türetmeyi dene; boşsa convention fallback.
+    let resources = resourcesFromPaths(doc, models, config);
+    if (!resources.length)
+        resources = (0, resources_1.buildResources)(models, config);
+    return { models, resources };
+}

package/dist/parsers/resources.d.ts

@@ -0,0 +1,10 @@
+import { GenConfig } from "../config";
+import { ModelDef, ResourceDef } from "../ir";
+/**
+ * Modellerden CRUD service üretilecek "resource"ları türet.
+ *
+ * - config.entities verilmişse yalnızca onlar.
+ * - verilmemişse: id alanı olan tüm interface modelleri aday kabul edilir.
+ * - base path: config.basePaths override'ı > convention (/api/<çoğul>).
+ */
+export declare function buildResources(models: ModelDef[], config: GenConfig): ResourceDef[];

package/dist/parsers/resources.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildResources = buildResources;
+const naming_1 = require("../utils/naming");
+/** Bir modelin "id" alanının TS tipini tahmin et. */
+function guessIdType(model, fallback) {
+    const idProp = model.properties.find((p) => p.originalName.toLowerCase() === "id" || p.originalName.toLowerCase() === `${model.name.toLowerCase()}id`);
+    if (idProp && (idProp.type === "number" || idProp.type === "string"))
+        return idProp.type;
+    return fallback;
+}
+/**
+ * Modellerden CRUD service üretilecek "resource"ları türet.
+ *
+ * - config.entities verilmişse yalnızca onlar.
+ * - verilmemişse: id alanı olan tüm interface modelleri aday kabul edilir.
+ * - base path: config.basePaths override'ı > convention (/api/<çoğul>).
+ */
+function buildResources(models, config) {
+    if (config.generateServices === false)
+        return [];
+    const interfaces = models.filter((m) => m.kind === "interface");
+    const wanted = config.entities;
+    const candidates = interfaces.filter((m) => {
+        if (wanted && wanted.length)
+            return wanted.includes(m.name);
+        // convention: id alanı olanlar entity sayılır.
+        return m.properties.some((p) => p.originalName.toLowerCase() === "id");
+    });
+    return candidates.map((m) => {
+        const resourceName = (0, naming_1.stripEntitySuffix)(m.name) || m.name;
+        const override = config.basePaths?.[m.name];
+        const basePath = override ?? `/api/${(0, naming_1.pluralize)(resourceName)}`;
+        return {
+            model: m.name,
+            name: resourceName,
+            basePath,
+            idType: guessIdType(m, config.idType ?? "number"),
+        };
+    });
+}

package/dist/utils/fs.d.ts

@@ -0,0 +1,4 @@
+export declare function ensureDir(dir: string): void;
+export declare function writeFile(filePath: string, content: string): void;
+/** Verilen yol bir dizinse, içindeki tüm .cs dosyalarını (recursive) döndür. Dosyaysa kendisini. */
+export declare function collectCsFiles(input: string): string[];

package/dist/utils/fs.js

@@ -0,0 +1,69 @@
+"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.ensureDir = ensureDir;
+exports.writeFile = writeFile;
+exports.collectCsFiles = collectCsFiles;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function ensureDir(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+}
+function writeFile(filePath, content) {
+    ensureDir(path.dirname(filePath));
+    fs.writeFileSync(filePath, content, "utf8");
+}
+/** Verilen yol bir dizinse, içindeki tüm .cs dosyalarını (recursive) döndür. Dosyaysa kendisini. */
+function collectCsFiles(input) {
+    const stat = fs.statSync(input);
+    if (stat.isFile())
+        return [input];
+    const out = [];
+    const walk = (dir) => {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name === "bin" || entry.name === "obj" || entry.name === "node_modules")
+                    continue;
+                walk(full);
+            }
+            else if (entry.isFile() && entry.name.endsWith(".cs")) {
+                out.push(full);
+            }
+        }
+    };
+    walk(input);
+    return out;
+}

package/dist/utils/naming.d.ts

@@ -0,0 +1,10 @@
+/** İlk harfi küçük yap (PascalCase -> camelCase). */
+export declare function toCamelCase(name: string): string;
+/** İlk harfi büyük yap (camelCase -> PascalCase). */
+export declare function toPascalCase(name: string): string;
+/** "ProductDto" / "Product" -> "products" gibi kaba bir çoğullama (base path için). */
+export declare function pluralize(word: string): string;
+/** Model adından "Dto"/"Model"/"Entity" son eklerini at: "ProductDto" -> "Product". */
+export declare function stripEntitySuffix(name: string): string;
+/** Dosya adı için: PascalCase -> kebab-case. "ProductDto" -> "product-dto". */
+export declare function toKebabCase(name: string): string;

package/dist/utils/naming.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCamelCase = toCamelCase;
+exports.toPascalCase = toPascalCase;
+exports.pluralize = pluralize;
+exports.stripEntitySuffix = stripEntitySuffix;
+exports.toKebabCase = toKebabCase;
+/** İlk harfi küçük yap (PascalCase -> camelCase). */
+function toCamelCase(name) {
+    if (!name)
+        return name;
+    // Ardışık büyük harf bloklarını da düzgün ele al: "ID" -> "id", "URLName" -> "urlName"
+    if (/^[A-Z0-9]+$/.test(name))
+        return name.toLowerCase();
+    return name.charAt(0).toLowerCase() + name.slice(1);
+}
+/** İlk harfi büyük yap (camelCase -> PascalCase). */
+function toPascalCase(name) {
+    if (!name)
+        return name;
+    return name.charAt(0).toUpperCase() + name.slice(1);
+}
+/** "ProductDto" / "Product" -> "products" gibi kaba bir çoğullama (base path için). */
+function pluralize(word) {
+    const lower = word.toLowerCase();
+    if (/[^aeiou]y$/.test(lower))
+        return lower.slice(0, -1) + "ies";
+    if (/(s|x|z|ch|sh)$/.test(lower))
+        return lower + "es";
+    return lower + "s";
+}
+/** Model adından "Dto"/"Model"/"Entity" son eklerini at: "ProductDto" -> "Product". */
+function stripEntitySuffix(name) {
+    return name.replace(/(Dto|DTO|Model|Entity|ViewModel|Vm|Response|Request)$/, (m, _g, offset) => (offset > 0 ? "" : m));
+}
+/** Dosya adı için: PascalCase -> kebab-case. "ProductDto" -> "product-dto". */
+function toKebabCase(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2")
+        .toLowerCase();
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "dto2ts",
+  "version": "0.1.0",
+  "description": "C# API (OpenAPI/Swagger veya .cs DTO) kaynaklarından TypeScript model ve fetch tabanlı CRUD service kodu üreten CLI.",
+  "keywords": [
+    "csharp",
+    "dotnet",
+    "openapi",
+    "swagger",
+    "codegen",
+    "typescript",
+    "dto",
+    "crud",
+    "fetch"
+  ],
+  "license": "MIT",
+  "type": "commonjs",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "dto2ts": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsc -p tsconfig.json --watch",
+    "prepublishOnly": "npm run build",
+    "start": "node ./dist/cli.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "typescript": "^5.5.0"
+  }
+}