@naiv/codegen-axios-client 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2024 ADF Language. https://adf-lang.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,110 @@
+# TypeORM - ADF Code Generator
+
+Generator kode [ADF](https://github.com/Graf-Research/adf-core) untuk model [TypeORM](https://github.com/typeorm/typeorm) dalam format Typescript.
+
+**Modul ADF yang digunakan**
+
+`Table` `Enum`
+
+**Penggunaan CLI (Command Line)**
+
+```bash
+npx @graf-research/adf-codegen-model-typeorm <file/url ADF> <folder output>
+```
+
+## Instalasi
+
+```bash
+npm install --save @graf-research/adf-codegen-model-typeorm
+```
+
+## Fungsi
+
+```typescript
+import { Model } from "@graf-research/adf-core";
+
+type MapModelNameFilePath = {[key: string]: string};
+
+interface CodegenFileOutput {
+  filename: string
+  content: string
+}
+
+interface ItemOutput {
+  files: CodegenFileOutput[]
+  map: MapModelNameFilePath
+}
+
+interface Output {
+  table: ItemOutput
+  enum: ItemOutput
+}
+
+function TypeORMModel.compile(list_model: Model.Item[]): Output
+```
+
+## Paduan TypeORM
+
+Untuk menggunakan fitur auto generated-migration TypeORM konfigurasi antara data source harus sesuai. Pada generator ini kode yang di-generate akan muncul pada dua folder besar yaitu:
+- &lt;folder output&gt;/model/table/*.ts
+- &lt;folder output&gt;/model/enum/*.ts
+
+Berikut salah satu contoh kofigurasi Data Source dan Script `package.json`
+
+#### data-source.ts
+```typescript
+import { DataSource, DataSourceOptions } from "typeorm";
+ 
+const config: DataSourceOptions = {
+  type: "postgres",
+  host: 'localhost',
+  port: 5432,
+  username: '<username>',
+  password: '<password>',
+  database: '<database name>',
+  synchronize: false,
+  logging: false,
+  migrations: [
+    __dirname + '/migration/**.ts'
+  ],
+  entities: [
+    __dirname + '/<folder output>/model/**/*.{ts,js}'
+  ]
+};
+
+export const AppDataSource = new DataSource(config);
+```
+
+#### package.json
+```json
+{
+  ...
+  "scripts": {
+    ...
+    "typeorm": "typeorm-ts-node-commonjs",
+    "generate-migration": "npm run typeorm migration:generate -- $1 -d ./data-source.ts",
+    "migrate": "npm run typeorm migration:run -- -d ./data-source.ts"
+  },
+  ...
+}
+```
+
+##### Generate Migration
+
+Untuk men-generate file migration TypeORM gunakan script `generate-migration` dengan output folder `migration` seperti konfigurasi pada `data-source.ts`, misalnya sebuah file migration dengan nama `Init.ts`:
+
+```bash
+npm run generate-migration migration/Init
+```
+
+akan menghasilkan file migration `migration/Init.ts`
+
+##### Menjalankan Migration
+
+Untuk menjalankan file migration TypeORM gunakan script `migrate`, contoh:
+
+```bash
+npm run migrate
+```
+
+akan mengeksekusi sql script dari file-file migration.

package/dist/build-api-client.d.ts

@@ -0,0 +1,3 @@
+import { NVAPI } from "@naiv/core/build/semantic-checker/check_api";
+import { ItemOutput } from "./data-types";
+export declare function buildAPIClient(list_api: NVAPI[]): ItemOutput;

package/dist/build-api-client.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAPIClient = buildAPIClient;
+function buildAPIClient(list_api) {
+    return {
+        files: [{
+                filename: './AxiosClient.ts',
+                content: createAPIClientNamespace(list_api)
+            }],
+        map: {}
+    };
+}
+function createAPIClientNamespace(list_api) {
+    const list_api_import = list_api.filter((api) => api.data.alias).map((api) => [
+        `import { T_${api.data.alias} } from "./api/${api.data.alias}";`,
+    ].join('\n'));
+    const list_api_str = list_api.filter((api) => api.data.alias).map((api) => {
+        var _a, _b, _c, _d;
+        return [
+            `  export const ${api.data.alias}: T_${api.data.alias} = async (req, base_url: string = BaseURL.instance.base_url) => {`,
+            `    const final_url = __build_path(base_url, '${api.url_path}', ${(((_b = (_a = api.data.path) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0) ? 'req.path' : '{}'});`,
+            (['get', 'delete'].includes(api.method)
+                ? `    return (await axios['${api.method.toLowerCase()}'](final_url, ${createAPIParams(api)})).data as any;`
+                : `    return (await axios['${api.method.toLowerCase()}'](final_url, ${((_d = (_c = api.data.body) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0) > 0 ? 'req.body' : '{}'}, ${createAPIParams(api)})).data as any;`),
+            `  }`,
+        ].join('\n');
+    });
+    return [
+        list_api_import.join('\n'),
+        '',
+        'export namespace AxiosClient {',
+        utility_functions,
+        list_api_str.join('\n'),
+        '}'
+    ].join('\n');
+}
+function createAPIParams(api) {
+    var _a, _b, _c, _d;
+    let result = '{';
+    if (((_b = (_a = api.data.headers) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0) {
+        result = `${result} headers: req.headers,`;
+    }
+    if (((_d = (_c = api.data.query) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0) > 0) {
+        result = `${result} params: req.query,`;
+    }
+    result = `${result} }`;
+    return result;
+}
+const utility_functions = `
+  function __build_path(base_url: string, url_path: string, path_param: { [key: string]: any }) {
+    const build_path = url_path.replace(/:([a-zA-Z_]\w*)/g, (_, key) => {
+      if (path_param[key] === undefined) {
+        throw new Error(\`Missing param: \${key}\`);
+      }
+      return encodeURIComponent(String(path_param[key]));
+    });
+    const url = new URL(build_path, base_url);
+    return url.toString();
+  }
+  export class BaseURL {
+    public base_url: string = '';
+    static _instance: BaseURL | undefined;
+    public static get instance(): BaseURL {
+      if (!BaseURL._instance) {
+        BaseURL._instance = new BaseURL();
+      }
+      return BaseURL._instance;
+    }
+    private constructor(){}
+    public set(_base_url: string) {
+      this.base_url = _base_url;
+    }
+  }
+`;

package/dist/build-from-api.d.ts

@@ -0,0 +1,5 @@
+import { NVAPI } from "@naiv/core/build/semantic-checker/check_api";
+import { ItemOutput } from "./data-types";
+import { NVSchema } from "@naiv/core/build/semantic-checker/check_schema";
+export declare function getAPIFileName(api_alias: string, api: NVAPI, extension?: string): string;
+export declare function buildFromAPI(api: NVAPI, list_schema: NVSchema[]): ItemOutput;

package/dist/build-from-api.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAPIFileName = getAPIFileName;
+exports.buildFromAPI = buildFromAPI;
+const build_from_schema_1 = require("./build-from-schema");
+const lodash_1 = __importDefault(require("lodash"));
+function getAPIFileName(api_alias, api, extension) {
+    return `./api/${api_alias}${extension !== null && extension !== void 0 ? extension : ''}`;
+}
+function buildFromAPI(api, list_schema) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1;
+    if (!api.data.alias) {
+        throw new Error(`no api alias`);
+    }
+    let header_schema;
+    if (((_b = (_a = api.data.headers) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0) {
+        const s = {
+            name: `T_${api.data.alias}_headers`,
+            items: (_c = api.data.headers) !== null && _c !== void 0 ? _c : []
+        };
+        header_schema = (0, build_from_schema_1.getSchemaContent)(s, list_schema);
+    }
+    let query_schema;
+    if (((_e = (_d = api.data.query) === null || _d === void 0 ? void 0 : _d.length) !== null && _e !== void 0 ? _e : 0) > 0) {
+        const s = {
+            name: `T_${api.data.alias}_query`,
+            items: (_f = api.data.query) !== null && _f !== void 0 ? _f : []
+        };
+        query_schema = (0, build_from_schema_1.getSchemaContent)(s, list_schema);
+    }
+    let path_schema;
+    if (((_h = (_g = api.data.path) === null || _g === void 0 ? void 0 : _g.length) !== null && _h !== void 0 ? _h : 0) > 0) {
+        const s = {
+            name: `T_${api.data.alias}_path`,
+            items: (_j = api.data.path) !== null && _j !== void 0 ? _j : []
+        };
+        path_schema = (0, build_from_schema_1.getSchemaContent)(s, list_schema);
+    }
+    let body_schema;
+    if (((_l = (_k = api.data.body) === null || _k === void 0 ? void 0 : _k.length) !== null && _l !== void 0 ? _l : 0) > 0) {
+        const s = {
+            name: `T_${api.data.alias}_body`,
+            items: (_m = api.data.body) !== null && _m !== void 0 ? _m : []
+        };
+        body_schema = (0, build_from_schema_1.getSchemaContent)(s, list_schema);
+    }
+    const fake_return_type_schema = {
+        name: 'ReturnType',
+        items: [{
+                key: 'rrr',
+                type: api.data.return_type.type
+            }]
+    };
+    const fake_return_type_schema_result = (0, build_from_schema_1.getSchemaContent)(fake_return_type_schema, list_schema);
+    const fake_return_type = {
+        key: 'rrr',
+        type: api.data.return_type.type
+    };
+    const fake_return_type_field_result = (0, build_from_schema_1.buildField)(fake_return_type, 0, { name: 'ReturnType', items: [] }, list_schema);
+    return {
+        files: [{
+                filename: getAPIFileName(api.data.alias, api, '.ts'),
+                content: [
+                    `${lodash_1.default.uniq([
+                        ...((_o = header_schema === null || header_schema === void 0 ? void 0 : header_schema.deps) !== null && _o !== void 0 ? _o : []),
+                        ...((_p = query_schema === null || query_schema === void 0 ? void 0 : query_schema.deps) !== null && _p !== void 0 ? _p : []),
+                        ...((_q = path_schema === null || path_schema === void 0 ? void 0 : path_schema.deps) !== null && _q !== void 0 ? _q : []),
+                        ...((_r = body_schema === null || body_schema === void 0 ? void 0 : body_schema.deps) !== null && _r !== void 0 ? _r : []),
+                        ...((_s = fake_return_type_schema_result.deps) !== null && _s !== void 0 ? _s : []),
+                        ...((_t = fake_return_type_field_result.new_deps_lines) !== null && _t !== void 0 ? _t : []),
+                    ].join('\n').split('\n')).join('\n')}
+
+${[
+                        ...((_u = header_schema === null || header_schema === void 0 ? void 0 : header_schema.content) !== null && _u !== void 0 ? _u : []),
+                        ...((_v = query_schema === null || query_schema === void 0 ? void 0 : query_schema.content) !== null && _v !== void 0 ? _v : []),
+                        ...((_w = path_schema === null || path_schema === void 0 ? void 0 : path_schema.content) !== null && _w !== void 0 ? _w : []),
+                        ...((_x = body_schema === null || body_schema === void 0 ? void 0 : body_schema.content) !== null && _x !== void 0 ? _x : []),
+                        ...fake_return_type_field_result.new_class_lines,
+                    ].join('\n')}
+
+export type T_${api.data.alias} = (request: {
+${[
+                        ((_y = header_schema === null || header_schema === void 0 ? void 0 : header_schema.content.length) !== null && _y !== void 0 ? _y : 0) > 0 ? `  headers: T_${api.data.alias}_headers` : '',
+                        ((_z = query_schema === null || query_schema === void 0 ? void 0 : query_schema.content.length) !== null && _z !== void 0 ? _z : 0) > 0 ? `  query: T_${api.data.alias}_query` : '',
+                        ((_0 = path_schema === null || path_schema === void 0 ? void 0 : path_schema.content.length) !== null && _0 !== void 0 ? _0 : 0) > 0 ? `  path: T_${api.data.alias}_path` : '',
+                        ((_1 = body_schema === null || body_schema === void 0 ? void 0 : body_schema.content.length) !== null && _1 !== void 0 ? _1 : 0) > 0 ? `  body: T_${api.data.alias}_body` : '',
+                    ].filter(Boolean).join('\n')}
+}) => Promise<${fake_return_type_field_result.type_only}${api.data.return_type.type.required ? '' : ' | null'}>;
+
+export const method = '${api.method.toLowerCase()}';
+export const url_path = '${api.url_path}';
+export const alias = '${api.data.alias}';
+`
+                ].join('\n')
+            }],
+        map: {
+            [api.data.alias]: getAPIFileName(api.data.alias, api)
+        }
+    };
+}

package/dist/build-from-enum.d.ts

@@ -0,0 +1,4 @@
+import { NVEnum } from "@naiv/core";
+import { ItemOutput } from "./data-types";
+export declare function getEnumFileName(item: NVEnum, extension?: string): string;
+export declare function buildFromEnum(enume: NVEnum): ItemOutput;

package/dist/build-from-enum.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnumFileName = getEnumFileName;
+exports.buildFromEnum = buildFromEnum;
+function getEnumFileName(item, extension) {
+    return `./model/enum/${item.name}${extension !== null && extension !== void 0 ? extension : ''}`;
+}
+function buildFromEnum(enume) {
+    return {
+        files: [{
+                filename: getEnumFileName(enume, '.ts'),
+                content: [
+                    `export enum ${enume.name} {`,
+                    ...enume.items
+                        .map(s => `'${s}' = '${s}',`)
+                        .map(line => '  ' + line),
+                    `};`
+                ].join('\n')
+            }],
+        map: {
+            [enume.name]: getEnumFileName(enume)
+        }
+    };
+}

package/dist/build-from-schema.d.ts

@@ -0,0 +1,23 @@
+import { NVSchema } from "@naiv/core/build/semantic-checker/check_schema";
+import { ItemOutput } from "./data-types";
+import { NVSchemaItem } from "@naiv/core/build/semantic-checker/check_schema_item";
+export declare function getSchemaFileName(schema: NVSchema, extension?: string): string;
+export declare function buildSchemaDependency(schema: NVSchema, list_schema: NVSchema[]): string[];
+export declare function buildFromSchema(schema: NVSchema, list_schema: NVSchema[]): ItemOutput;
+export interface SchemaContentResult {
+    deps: string[];
+    content: string[];
+}
+export declare function getSchemaContent(schema: NVSchema, list_schema: NVSchema[], no_export?: boolean): SchemaContentResult;
+export interface BuildFieldResult {
+    field_lines: string[];
+    type_only: string;
+    new_class_lines: string[];
+    new_deps_lines: string[];
+}
+export declare function buildField(item: NVSchemaItem, index: number, schema: NVSchema, list_schema: NVSchema[]): BuildFieldResult;
+export declare function buildInlineSchemaClass(items: NVSchemaItem[], parent_schema_name: string, index: number, list_schema: NVSchema[]): {
+    new_class_deps: string[];
+    new_class_content: string[];
+    inline_schema_name: string;
+};

package/dist/build-from-schema.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchemaFileName = getSchemaFileName;
+exports.buildSchemaDependency = buildSchemaDependency;
+exports.buildFromSchema = buildFromSchema;
+exports.getSchemaContent = getSchemaContent;
+exports.buildField = buildField;
+exports.buildInlineSchemaClass = buildInlineSchemaClass;
+const lodash_1 = __importDefault(require("lodash"));
+function getSchemaFileName(schema, extension) {
+    return `./schema/${schema.name}${extension !== null && extension !== void 0 ? extension : ''}`;
+}
+function buildSchemaDependency(schema, list_schema) {
+    return schema.items
+        .filter((item) => item.type.type === 'schema' || item.type.type === 'table' || item.type.type === 'enum')
+        .map((item) => {
+        switch (item.type.type) {
+            case 'schema':
+                const schema_item = list_schema.find((s) => item.type.type === 'schema' && s.name === item.type.subtype_native);
+                if (!schema_item) {
+                    throw new Error(`Schema "${item.type.subtype_native}" is not available`);
+                }
+                return `import { ${schema_item.name} } from '.${getSchemaFileName(schema_item)}'`;
+            case 'table':
+                return `import { ${item.type.subtype_native} } from '../model/table/${item.type.subtype_native}'`;
+            case 'enum':
+                return `import { ${item.type.subtype_native} } from '../model/enum/${item.type.subtype_native}'`;
+            default:
+                return '';
+        }
+    });
+}
+function buildFromSchema(schema, list_schema) {
+    const { deps, content } = getSchemaContent(schema, list_schema);
+    return {
+        files: [{
+                filename: getSchemaFileName(schema, '.ts'),
+                content: [
+                    ...deps,
+                    '',
+                    ...content,
+                ].join('\n')
+            }],
+        map: {
+            [schema.name]: getSchemaFileName(schema)
+        }
+    };
+}
+function getSchemaContent(schema, list_schema, no_export) {
+    const field_lines = [];
+    const new_class_lines = [];
+    const new_deps_lines = [];
+    let i = 0;
+    for (const c of schema.items) {
+        const field_result = buildField(c, i, schema, list_schema);
+        field_lines.push(...field_result.field_lines);
+        new_class_lines.push(...field_result.new_class_lines);
+        new_deps_lines.push(...field_result.new_deps_lines);
+        i++;
+    }
+    const complete_deps = lodash_1.default.uniq([
+        ...buildSchemaDependency(schema, list_schema),
+        ...new_deps_lines
+    ].join('\n').split('\n'));
+    return {
+        deps: complete_deps,
+        content: [
+            ...new_class_lines,
+            `${no_export ? '' : 'export '}interface ${schema.name} {`,
+            ...field_lines.map(line => '  ' + line),
+            `}`
+        ]
+    };
+}
+function buildField(item, index, schema, list_schema) {
+    var _a;
+    const is_array = item.type.array_dimension > 0;
+    const array_token = Array(item.type.array_dimension).fill('[]').join('');
+    switch (item.type.type) {
+        case "native":
+            return {
+                field_lines: [
+                    `${item.key}${item.type.required ? '' : '?'}: ${item.type.type_native}${is_array ? array_token : ''}`
+                ],
+                type_only: `${item.type.type_native}${is_array ? array_token : ''}`,
+                new_class_lines: [],
+                new_deps_lines: []
+            };
+        case "schema":
+            return {
+                field_lines: [
+                    `${item.key}${item.type.required ? '' : '?'}: ${item.type.subtype_native}${is_array ? array_token : ''}`
+                ],
+                type_only: `${item.type.subtype_native}${is_array ? array_token : ''}`,
+                new_class_lines: [],
+                new_deps_lines: []
+            };
+        case "table":
+            return {
+                field_lines: [
+                    `${item.key}${item.type.required ? '' : '?'}: ${item.type.subtype_native}${is_array ? array_token : ''}`
+                ],
+                type_only: `${item.type.subtype_native}${is_array ? array_token : ''}`,
+                new_class_lines: [],
+                new_deps_lines: []
+            };
+        case "enum":
+            return {
+                field_lines: [
+                    `${item.key}${item.type.required ? '' : '?'}: ${item.type.subtype_native}${is_array ? array_token : ''}`
+                ],
+                type_only: `${item.type.subtype_native}${is_array ? array_token : ''}`,
+                new_class_lines: [],
+                new_deps_lines: []
+            };
+        case "inline-schema":
+            const { new_class_deps, new_class_content, inline_schema_name } = buildInlineSchemaClass(((_a = item.type.type_inline_schema) !== null && _a !== void 0 ? _a : []), schema.name, index, list_schema);
+            return {
+                field_lines: [
+                    `${item.key}${item.type.required ? '' : '?'}: ${inline_schema_name}${is_array ? array_token : ''}`
+                ],
+                type_only: `${inline_schema_name}${is_array ? array_token : ''}`,
+                new_class_lines: new_class_content,
+                new_deps_lines: new_class_deps
+            };
+    }
+}
+function buildInlineSchemaClass(items, parent_schema_name, index, list_schema) {
+    const inline_schema = {
+        name: [parent_schema_name, index].join('_'),
+        items
+    };
+    const new_class = getSchemaContent(inline_schema, list_schema, true);
+    return { new_class_deps: new_class.deps, new_class_content: new_class.content, inline_schema_name: inline_schema.name };
+}

package/dist/build-from-table.d.ts

@@ -0,0 +1,10 @@
+import { NVResult, NVTable, NVTableField, NVTableFieldType } from "@naiv/core";
+import { ItemOutput } from "./data-types";
+export declare function getTableFileName(item: NVTable, extension?: string): string;
+export declare function buildTableDependency(table: NVTable, source: NVResult): string[];
+export declare function mapSQLTypeToJSType(type: NVTableFieldType): string;
+export declare function buildColumnNative(type: NVTableFieldType, column: NVTableField, source: NVResult): string[];
+export declare function buildColumnEnum(type: NVTableFieldType, column: NVTableField): string[];
+export declare function buildColumnRelation(type: NVTableFieldType, column: NVTableField, table: NVTable, source: NVResult): string[];
+export declare function buildColumn(column: NVTableField, table: NVTable, source: NVResult): string[];
+export declare function buildFromTable(table: NVTable, source: NVResult): ItemOutput;

package/dist/build-from-table.js

@@ -0,0 +1,167 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTableFileName = getTableFileName;
+exports.buildTableDependency = buildTableDependency;
+exports.mapSQLTypeToJSType = mapSQLTypeToJSType;
+exports.buildColumnNative = buildColumnNative;
+exports.buildColumnEnum = buildColumnEnum;
+exports.buildColumnRelation = buildColumnRelation;
+exports.buildColumn = buildColumn;
+exports.buildFromTable = buildFromTable;
+const build_from_enum_1 = require("./build-from-enum");
+const lodash_1 = __importDefault(require("lodash"));
+function getTableFileName(item, extension) {
+    return `./model/table/${item.name}${extension !== null && extension !== void 0 ? extension : ''}`;
+}
+function buildTableDependency(table, source) {
+    return table.fields
+        .filter((tc) => tc.type.kind === 'relation' || tc.type.kind === 'enum')
+        .map((tc) => {
+        const type = tc.type;
+        switch (type.kind) {
+            case "native":
+            case "enum":
+                const enum_item = source.list_enum.find((m) => m.name === type.subtype);
+                if (!enum_item) {
+                    throw new Error(`Enum "${type.subtype}" is not available on models`);
+                }
+                return `import { ${enum_item.name} } from '../.${(0, build_from_enum_1.getEnumFileName)(enum_item)}'`;
+            case 'relation':
+                const table_item = source.list_table.find((m) => m.name === type.type);
+                if (!table_item) {
+                    throw new Error(`Table "${type.type}" is not available on models`);
+                }
+                return `import { ${table_item.name} } from '../.${getTableFileName(table_item)}'`;
+        }
+    });
+}
+function mapSQLTypeToJSType(type) {
+    switch (type.type) {
+        case 'bigint':
+        case 'int8':
+        case 'bigserial':
+        case 'serial8':
+            return 'number';
+        case 'boolean':
+        case 'bool':
+            return 'boolean';
+        case 'box':
+        case 'bytea':
+        case 'cidr':
+        case 'circle':
+            return 'number';
+        case 'date':
+            return 'Date';
+        case 'float':
+        case 'float8':
+            return 'number';
+        case 'inet':
+            return 'string';
+        case 'integer':
+        case 'int':
+        case 'int4':
+            return 'number';
+        case 'json':
+        case 'jsonb':
+        case 'line':
+        case 'lseg':
+        case 'macaddr':
+        case 'macaddr8':
+            return 'string';
+        case 'money':
+            return 'number';
+        case 'path':
+            return 'string';
+        case 'pg_lsn':
+        case 'pg_snapshot':
+        case 'point':
+        case 'polygon':
+            return 'string';
+        case 'real':
+        case 'float4':
+        case 'smallint':
+        case 'int2':
+        case 'smallserial':
+        case 'serial2':
+        case 'serial':
+        case 'serial4':
+            return 'number';
+        case 'text':
+            return 'string';
+        case 'timetz':
+        case 'timestamptz':
+            return 'Date';
+        case 'tsquery':
+        case 'tsvector':
+        case 'txid_snapshot':
+        case 'uuid':
+        case 'xml':
+        case 'bit':
+        case 'varbit':
+        case 'char':
+        case 'varchar':
+            return 'string';
+        case 'numeric':
+        case 'decimal':
+            return 'number';
+        case 'time':
+        case 'timestamp':
+            return 'Date';
+    }
+    throw new Error(`unsupported data type '${type.type}'`);
+}
+function buildColumnNative(type, column, source) {
+    const is_required = !type.nullable;
+    return [
+        `${column.column_name}${is_required ? '' : '?'}: ${mapSQLTypeToJSType(type)};`
+    ];
+}
+function buildColumnEnum(type, column) {
+    const is_required = !type.nullable;
+    return [
+        `${column.column_name}${is_required ? '' : '?'}: ${type.subtype};`
+    ];
+}
+function buildColumnRelation(type, column, table, source) {
+    const is_required = !type.nullable;
+    const foreign_table = source.list_table.find((item) => item.name === type.type);
+    if (!foreign_table) {
+        throw new Error(`Table "${type.type}" not found on relation "${table.name}.${column.column_name}"`);
+    }
+    const foreign_column = foreign_table.fields.find((fc) => fc.column_name === type.subtype);
+    if (!foreign_column) {
+        throw new Error(`Column "${type.subtype}" on table "${type.type}" not found on relation "${table.name}.${column.column_name}"`);
+    }
+    return [
+        `${column.column_name}${is_required ? '' : '?'}: ${mapSQLTypeToJSType(foreign_column.type)};`
+    ];
+}
+function buildColumn(column, table, source) {
+    switch (column.type.kind) {
+        case "native": return buildColumnNative(column.type, column, source);
+        case "enum": return buildColumnEnum(column.type, column);
+        case "relation": return buildColumnRelation(column.type, column, table, source);
+    }
+}
+function buildFromTable(table, source) {
+    return {
+        files: [{
+                filename: getTableFileName(table, '.ts'),
+                content: [
+                    ...lodash_1.default.uniq(buildTableDependency(table, source)),
+                    '',
+                    `export interface ${table.name} {`,
+                    ...table.fields
+                        .reduce((acc, c) => [...acc, ...buildColumn(c, table, source)], [])
+                        .map(line => '  ' + line),
+                    `}`
+                ].join('\n')
+            }],
+        map: {
+            [table.name]: getTableFileName(table)
+        }
+    };
+}

package/dist/cmd-generate.d.ts

@@ -0,0 +1 @@
+export declare function cmdGenerate(design_folder_abs_path: string, out_folder: string): Promise<void>;

package/dist/cmd-generate.js

@@ -0,0 +1,50 @@
+"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 });
+exports.cmdGenerate = cmdGenerate;
+const naiv_parser_1 = require("@naiv/core/build/naiv_parser");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const _1 = require(".");
+function cmdGenerate(design_folder_abs_path, out_folder) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = (0, naiv_parser_1.naiv_parse_folder)(design_folder_abs_path, { fs: fs_1.default, path: path_1.default });
+        const typeorm_model = _1.TypeORMModel.compile(result);
+        for (const f of typeorm_model.enum.files) {
+            writeFiles(f, out_folder);
+        }
+        for (const f of typeorm_model.table.files) {
+            writeFiles(f, out_folder);
+        }
+        for (const f of typeorm_model.schema.files) {
+            writeFiles(f, out_folder);
+        }
+        for (const f of typeorm_model.api.files) {
+            writeFiles(f, out_folder);
+        }
+        for (const f of typeorm_model.http_client.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/data-types.d.ts

@@ -0,0 +1,11 @@
+export type MapModelNameFilePath = {
+    [key: string]: string;
+};
+export interface CodegenFileOutput {
+    filename: string;
+    content: string;
+}
+export interface ItemOutput {
+    files: CodegenFileOutput[];
+    map: MapModelNameFilePath;
+}

package/dist/data-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/exec.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/exec.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const arg_1 = __importDefault(require("arg"));
+const cmd_generate_1 = require("./cmd-generate");
+const args = (0, arg_1.default)({
+    "--design": String,
+    "--out": String,
+    "-d": "--design",
+    "-o": "--out"
+});
+if (!args['--design']) {
+    throw new Error(`--design/-d argument is required`);
+}
+if (args['--out']) {
+    (0, cmd_generate_1.cmdGenerate)(args['--design'], args['--out']);
+    process.exit(0);
+}
+throw new Error(`use --out/-o to generate axios client in typescript`);

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import { NVResult } from "@naiv/core";
+import { ItemOutput } from "./data-types";
+export declare namespace TypeORMModel {
+    interface Output {
+        table: ItemOutput;
+        enum: ItemOutput;
+        schema: ItemOutput;
+        api: ItemOutput;
+        http_client: ItemOutput;
+    }
+    function compile(source: NVResult): Output;
+}

package/dist/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeORMModel = void 0;
+const build_from_table_1 = require("./build-from-table");
+const build_from_enum_1 = require("./build-from-enum");
+const build_from_schema_1 = require("./build-from-schema");
+const build_from_api_1 = require("./build-from-api");
+const build_api_client_1 = require("./build-api-client");
+var TypeORMModel;
+(function (TypeORMModel) {
+    function compile(source) {
+        const list_api_output = source.list_api.map((t) => (0, build_from_api_1.buildFromAPI)(t, source.list_schema));
+        const list_schema_output = source.list_schema.map((t) => (0, build_from_schema_1.buildFromSchema)(t, source.list_schema));
+        const list_table_output = source.list_table.map((t) => (0, build_from_table_1.buildFromTable)(t, source));
+        const list_enume_output = source.list_enum.map((t) => (0, build_from_enum_1.buildFromEnum)(t));
+        const http_client = (0, build_api_client_1.buildAPIClient)(source.list_api);
+        return {
+            http_client,
+            api: {
+                files: list_api_output.reduce((accumulator, o) => [...accumulator, ...o.files], []),
+                map: list_api_output.reduce((accumulator, o) => (Object.assign(Object.assign({}, accumulator), o.map)), {})
+            },
+            schema: {
+                files: list_schema_output.reduce((accumulator, o) => [...accumulator, ...o.files], []),
+                map: list_schema_output.reduce((accumulator, o) => (Object.assign(Object.assign({}, accumulator), o.map)), {})
+            },
+            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;
+})(TypeORMModel || (exports.TypeORMModel = TypeORMModel = {}));

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@naiv/codegen-axios-client",
+  "version": "0.0.1",
+  "main": "dist/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc && npm unlink -g && npm link",
+    "start": "node dist",
+    "dev": "npm run build && npm start",
+    "test": "npm run dev"
+  },
+  "bin": {
+    "codegen-axios-client": "dist/exec.js"
+  },
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "devDependencies": {
+    "@types/lodash": "^4.17.13",
+    "@types/node": "^22.8.1",
+    "typescript": "^5.6.3"
+  },
+  "dependencies": {
+    "@naiv/core": "^0.0.10",
+    "arg": "^5.0.2",
+    "lodash": "^4.17.21"
+  }
+}