@graf-research/adf-codegen-model-typeorm 0.0.1

package/dist/exec.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const adf_core_1 = require("@graf-research/adf-core");
+const axios_1 = __importDefault(require("axios"));
+const _1 = require(".");
+const url_regex = /https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)/;
+if (!process.argv[2]) {
+    throw new Error(`argv[2] cannot be empty`);
+}
+if (!process.argv[3]) {
+    throw new Error(`argv[3] cannot be empty`);
+}
+exec(process.argv[2], process.argv[3]);
+function exec(input_file_or_url, out_folder) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let code = '';
+        if (url_regex.test(input_file_or_url)) {
+            console.log(`downloading file '${input_file_or_url}'...`);
+            const response = yield axios_1.default.get(input_file_or_url, { responseType: 'text' });
+            code = response.data;
+            console.log(`download complete.`);
+        }
+        else {
+            const readFromFile = (f) => new Promise((resolve, reject) => fs_1.default.readFile(f, 'utf-8', (err, data) => err ? reject(err) : resolve(data)));
+            code = yield readFromFile(input_file_or_url);
+        }
+        const result = (0, adf_core_1.parse)(code);
+        const typeorm_model = _1.TypeORMModel.compile([...result.list_table, ...result.list_enum]);
+        for (const f of typeorm_model.enum.files) {
+            writeFiles(f, out_folder);
+        }
+        for (const f of typeorm_model.table.files) {
+            writeFiles(f, out_folder);
+        }
+    });
+}
+function writeFiles(output_1) {
+    return __awaiter(this, arguments, void 0, function* (output, main_project_location = 'project') {
+        const folder = main_project_location + '/' + output.filename.split('/').slice(0, -1).join('/');
+        if (!fs_1.default.existsSync(folder)) {
+            fs_1.default.mkdirSync(folder, { recursive: true });
+        }
+        const filename = main_project_location + '/' + output.filename;
+        fs_1.default.writeFileSync(filename, output.content);
+    });
+}

package/dist/index.js

@@ -0,0 +1,275 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeORMModel = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+var TypeORMModel;
+(function (TypeORMModel) {
+    function compile(list_model) {
+        const list_table_output = list_model.filter(i => i.type === 'table').map((t) => buildFromTable(t, list_model));
+        const list_enume_output = list_model.filter(i => i.type === 'enum').map((t) => buildFromEnum(t));
+        return {
+            table: {
+                files: list_table_output.reduce((accumulator, o) => [...accumulator, ...o.files], []),
+                map: list_table_output.reduce((accumulator, o) => (Object.assign(Object.assign({}, accumulator), o.map)), {})
+            },
+            enum: {
+                files: list_enume_output.reduce((accumulator, o) => [...accumulator, ...o.files], []),
+                map: list_enume_output.reduce((accumulator, o) => (Object.assign(Object.assign({}, accumulator), o.map)), {})
+            }
+        };
+    }
+    TypeORMModel.compile = compile;
+    function sqlTypeToJSType(type) {
+        switch (type.kind) {
+            case "common":
+                switch (type.type) {
+                    case 'text':
+                    case "varchar":
+                        return 'string';
+                    case 'int':
+                    case 'float':
+                    case 'bigint':
+                    case "tinyint":
+                    case "smallint":
+                    case "real":
+                    case "decimal":
+                        return 'number';
+                    case 'boolean':
+                        return 'boolean';
+                    case 'timestamp':
+                    case "date":
+                        return 'Date';
+                }
+            case "decimal":
+                switch (type.type) {
+                    case 'decimal':
+                        return 'number';
+                }
+            case "chars":
+                switch (type.type) {
+                    case 'varchar':
+                        return 'string';
+                }
+            case "enum":
+                switch (type.type) {
+                    case 'enum':
+                        return type.enum_name;
+                }
+            case "relation":
+                switch (type.type) {
+                    case 'relation':
+                        return type.table_name;
+                }
+        }
+    }
+    TypeORMModel.sqlTypeToJSType = sqlTypeToJSType;
+    function getModelFileName(item, extension) {
+        switch (item.type) {
+            case "table": return `./model/table/${item.name}${extension !== null && extension !== void 0 ? extension : ''}`;
+            case "enum": return `./model/enum/${item.name}${extension !== null && extension !== void 0 ? extension : ''}`;
+        }
+    }
+    function buildTableDependency(table, list_model) {
+        return table.columns
+            .filter((tc) => tc.type.type === 'relation' || tc.type.type === 'enum')
+            .map((tc) => {
+            const type = tc.type;
+            switch (type.type) {
+                case 'enum':
+                    const enum_item = list_model.find((m) => m.type === 'enum' && m.name === type.enum_name);
+                    if (!enum_item) {
+                        throw new Error(`Enum "${tc.name}" is not available on models`);
+                    }
+                    return `import { ${enum_item.name} } from '../.${getModelFileName(enum_item)}'`;
+                case 'relation':
+                    const table_item = list_model.find((m) => m.type === 'table' && m.name === type.table_name);
+                    if (!table_item) {
+                        throw new Error(`Table "${tc.name}" is not available on models`);
+                    }
+                    return `import { ${table_item.name} } from '../.${getModelFileName(table_item)}'`;
+            }
+        });
+    }
+    function isIsoDate(str) {
+        if (!/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z/.test(str))
+            return false;
+        const d = new Date(str);
+        return !isNaN(d.getTime()) && d.toISOString() === str;
+    }
+    function getDefaultValue(default_value) {
+        switch (default_value.type) {
+            case "string":
+                return `'${default_value.data}'`;
+            case "number":
+                return String(default_value.data);
+            case "boolean":
+                return `'${String(default_value.data)}'`;
+            case "enum":
+                return `'${default_value.enum_value}'`;
+        }
+    }
+    function buildColumnCommon(type, column, list_model) {
+        var _a, _b;
+        const null_attr = ((_a = column.attributes) !== null && _a !== void 0 ? _a : []).find((attr) => attr.type === 'null');
+        const default_value_attr = ((_b = column.attributes) !== null && _b !== void 0 ? _b : []).find((attr) => attr.type === 'default');
+        const is_required = null_attr ? !null_attr.value : false;
+        const has_default_value = Boolean(default_value_attr);
+        const typeorm_decorator = [
+            `@Column({`,
+            ...[
+                `type: '${type.type}',`,
+                `nullable: ${is_required ? 'false' : 'true'},`,
+                has_default_value ? `default: ${getDefaultValue(default_value_attr.value)},` : ''
+            ].filter(Boolean).map(line => '  ' + line),
+            `})`,
+        ];
+        return [
+            ...typeorm_decorator,
+            `${column.name}${is_required ? '!' : '?'}: ${sqlTypeToJSType(type)};`
+        ];
+    }
+    function buildColumnDecimal(type, column) {
+        var _a, _b;
+        const null_attr = ((_a = column.attributes) !== null && _a !== void 0 ? _a : []).find((attr) => attr.type === 'null');
+        const default_value_attr = ((_b = column.attributes) !== null && _b !== void 0 ? _b : []).find((attr) => attr.type === 'default');
+        const is_required = null_attr ? !null_attr.value : false;
+        const has_default_value = Boolean(default_value_attr);
+        const typeorm_decorator = [
+            `@Column({`,
+            ...[
+                `type: '${type.type}',`,
+                type.precision ? `precision: ${type.precision},` : '',
+                type.scale ? `scale: ${type.scale},` : '',
+                `nullable: ${is_required ? 'false' : 'true'},`,
+                has_default_value ? `default: ${getDefaultValue(default_value_attr.value)},` : ''
+            ].filter(Boolean).map(line => '  ' + line),
+            `})`,
+        ];
+        return [
+            ...typeorm_decorator,
+            `${column.name}${is_required ? '!' : '?'}: ${sqlTypeToJSType(type)};`
+        ];
+    }
+    function buildColumnChars(type, column) {
+        var _a, _b;
+        const null_attr = ((_a = column.attributes) !== null && _a !== void 0 ? _a : []).find((attr) => attr.type === 'null');
+        const default_value_attr = ((_b = column.attributes) !== null && _b !== void 0 ? _b : []).find((attr) => attr.type === 'default');
+        const is_required = null_attr ? !null_attr.value : false;
+        const has_default_value = Boolean(default_value_attr);
+        const typeorm_decorator = [
+            `@Column({`,
+            ...[
+                `type: '${type.type}',`,
+                type.size ? `length: ${type.size},` : '',
+                `nullable: ${is_required ? 'false' : 'true'},`,
+                has_default_value ? `default: ${getDefaultValue(default_value_attr.value)},` : ''
+            ].filter(Boolean).map(line => '  ' + line),
+            `})`,
+        ];
+        return [
+            ...typeorm_decorator,
+            `${column.name}${is_required ? '!' : '?'}: ${sqlTypeToJSType(type)};`
+        ];
+    }
+    function buildColumnEnum(type, column) {
+        var _a, _b;
+        const null_attr = ((_a = column.attributes) !== null && _a !== void 0 ? _a : []).find((attr) => attr.type === 'null');
+        const default_value_attr = ((_b = column.attributes) !== null && _b !== void 0 ? _b : []).find((attr) => attr.type === 'default');
+        const is_required = null_attr ? !null_attr.value : false;
+        const has_default_value = Boolean(default_value_attr);
+        const typeorm_decorator = [
+            `@Column({`,
+            ...[
+                `type: 'enum',`,
+                `enum: ${type.enum_name},`,
+                `nullable: ${is_required ? 'false' : 'true'},`,
+                has_default_value ? `default: ${getDefaultValue(default_value_attr.value)},` : ''
+            ].filter(Boolean).map(line => '  ' + line),
+            `})`,
+        ];
+        return [
+            ...typeorm_decorator,
+            `${column.name}${is_required ? '!' : '?'}: ${sqlTypeToJSType(type)};`
+        ];
+    }
+    function buildColumnRelation(type, column, table, list_model) {
+        var _a;
+        const null_attr = ((_a = column.attributes) !== null && _a !== void 0 ? _a : []).find((attr) => attr.type === 'null');
+        const is_required = null_attr ? !null_attr.value : false;
+        const foreign_table = list_model.find((item) => item.type === 'table' && item.name === type.table_name);
+        if (!foreign_table) {
+            throw new Error(`Table "${type.table_name}" not found on relation "${table.name}.${column.name}"`);
+        }
+        const foreign_column = foreign_table.columns.find((fc) => fc.name === type.foreign_key);
+        if (!foreign_column) {
+            throw new Error(`Column "${type.foreign_key}" on foreight table "${type.table_name}" not found on relation "${table.name}.${column.name}"`);
+        }
+        const one_to_many_field_name = `otm_${column.name}`;
+        const typeorm_decorator = [
+            `@ManyToOne(() => ${foreign_table.name}, x => x.${foreign_column.name}, { nullable: ${is_required ? 'false' : 'true'} })`,
+            `@JoinColumn({ name: '${column.name}' })`,
+            `${one_to_many_field_name}${is_required ? '!' : '?'}: ${foreign_table.name};`,
+            `@Column({`,
+            ...[
+                `name: '${column.name}',`,
+                `type: '${foreign_column.type.type}',`,
+                `nullable: ${is_required ? 'false' : 'true'},`,
+            ].filter(Boolean).map(line => '  ' + line),
+            `})`,
+        ];
+        return [
+            ...typeorm_decorator,
+            `${column.name}${is_required ? '!' : '?'}: ${sqlTypeToJSType(foreign_column.type)};`
+        ];
+    }
+    function buildColumn(column, table, list_model) {
+        switch (column.type.kind) {
+            case "common": return buildColumnCommon(column.type, column, list_model);
+            case "decimal": return buildColumnDecimal(column.type, column);
+            case "chars": return buildColumnChars(column.type, column);
+            case "enum": return buildColumnEnum(column.type, column);
+            case "relation": return buildColumnRelation(column.type, column, table, list_model);
+        }
+    }
+    function buildFromTable(table, list_model) {
+        return {
+            files: [{
+                    filename: getModelFileName(table, '.ts'),
+                    content: [
+                        'import { Column, CreateDateColumn, DeleteDateColumn, Entity, JoinColumn, ManyToOne, OneToMany, PrimaryGeneratedColumn, UpdateDateColumn, BaseEntity } from "typeorm";',
+                        ...lodash_1.default.uniq(buildTableDependency(table, list_model)),
+                        '',
+                        `@Entity('${table.name}')`,
+                        `export class ${table.name} extends BaseEntity {`,
+                        ...table.columns
+                            .reduce((acc, c) => [...acc, ...buildColumn(c, table, list_model)], [])
+                            .map(line => '  ' + line),
+                        `}`
+                    ].join('\n')
+                }],
+            map: {
+                [table.name]: getModelFileName(table)
+            }
+        };
+    }
+    function buildFromEnum(enume) {
+        return {
+            files: [{
+                    filename: getModelFileName(enume, '.ts'),
+                    content: [
+                        `export enum ${enume.name} {`,
+                        ...enume.items
+                            .map(s => `'${s}' = '${s}',`)
+                            .map(line => '  ' + line),
+                        `};`
+                    ].join('\n')
+                }],
+            map: {
+                [enume.name]: getModelFileName(enume)
+            }
+        };
+    }
+})(TypeORMModel || (exports.TypeORMModel = TypeORMModel = {}));

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@graf-research/adf-codegen-model-typeorm",
+  "version": "0.0.1",
+  "main": "index.js",
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "start": "node dist",
+    "dev": "npm run build && npm start",
+    "test": "npm run dev"
+  },
+  "bin": {
+    "adf-codegen-model-typeorm": "dist/exec.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "package.json"
+  ],
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "devDependencies": {
+    "@types/axios": "^0.9.36",
+    "@types/lodash": "^4.17.13",
+    "@types/node": "^22.8.1",
+    "typescript": "^5.6.3"
+  },
+  "dependencies": {
+    "@graf-research/adf-core": "^0.0.4",
+    "axios": "^1.7.7",
+    "lodash": "^4.17.21"
+  }
+}