@naiv/flazy-api 0.0.1

package/dist/build-from-table.js

@@ -0,0 +1,253 @@
+"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') // only table relation or enum
+        .filter((tc) => !(tc.type.kind === 'relation' && tc.type.type == table.name)) // dont import yourself
+        .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':
+        case 'tinyint':
+            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':
+        case 'abstime':
+        case 'datetime':
+        case 'interval':
+        case 'reltime':
+        case 'timespan':
+            return 'Date';
+    }
+    throw new Error(`unsupported data type '${type.type}'`);
+}
+function buildDefaultValue(type, column) {
+    switch (typeof type.default_value) {
+        case "number":
+        case "boolean":
+            return String(type.default_value);
+        case "string":
+            if (column.type.kind === 'enum') {
+                return type.default_value;
+            }
+            if (type.default_value.startsWith("'") || type.default_value.startsWith('"')) {
+                return type.default_value;
+            }
+            return `() => "${type.default_value}"`;
+    }
+    return undefined;
+}
+function buildColumnNative(type, column, source) {
+    const default_value_attr = buildDefaultValue(type, column);
+    const is_required = !type.nullable;
+    const has_default_value = default_value_attr !== undefined;
+    const primary_key_attr = type.primary_key;
+    const unique_attr = type.unique;
+    const autoinc_attr = type.autoincrement;
+    const is_numeric_or_decimal = ['numeric', 'decimal'].includes(type.type);
+    const precision = is_numeric_or_decimal ? `precision: ${type.param1 || 'undefined'},` : '';
+    const scale = is_numeric_or_decimal ? `scale: ${type.param2 || 'undefined'},` : '';
+    const is_bit_varbit_char_varchar = ['bit', 'varbit', 'char', 'varchar'].includes(type.type);
+    const length = is_bit_varbit_char_varchar ? `length: ${type.param1 || 'undefined'},` : '';
+    const typeorm_decorator = [
+        `@Column({`,
+        ...[
+            `type: '${type.type}',`,
+            `nullable: ${is_required ? 'false' : 'true'},`,
+            precision,
+            scale,
+            length,
+            has_default_value ? `default: ${default_value_attr},` : ''
+        ].filter(Boolean).map(line => '  ' + line),
+        `})`,
+    ];
+    if (primary_key_attr) {
+        if (autoinc_attr) {
+            typeorm_decorator.push(`@PrimaryGeneratedColumn('increment')`);
+        }
+        else {
+            typeorm_decorator.push(`@PrimaryColumn()`);
+        }
+    }
+    if (unique_attr) {
+        // something to do with unique
+    }
+    return [
+        ...typeorm_decorator,
+        `${column.column_name}${is_required ? '!' : '?'}: ${mapSQLTypeToJSType(type)};`
+    ];
+}
+function buildColumnEnum(type, column) {
+    const default_value_attr = type.default_value;
+    const is_required = !type.nullable;
+    const has_default_value = default_value_attr !== undefined;
+    const typeorm_decorator = [
+        `@Column({`,
+        ...[
+            `type: 'enum',`,
+            `enum: ${type.subtype},`,
+            `nullable: ${is_required ? 'false' : 'true'},`,
+            has_default_value ? `default: '${default_value_attr}',` : ''
+        ].filter(Boolean).map(line => '  ' + line),
+        `})`,
+    ];
+    return [
+        ...typeorm_decorator,
+        `${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}"`);
+    }
+    const one_to_many_field_name = `otm_${column.column_name}`;
+    const typeorm_decorator = [
+        `@ManyToOne(() => ${foreign_table.name}, x => x.${foreign_column.column_name}, { nullable: ${is_required ? 'false' : 'true'} })`,
+        `@JoinColumn({ name: '${column.column_name}' })`,
+        `${one_to_many_field_name}${(is_required && false /** relation object always optional */) ? '!' : '?'}: ${foreign_table.name};`,
+        `@Column({`,
+        ...[
+            `name: '${column.column_name}',`,
+            `type: '${foreign_column.type.type}',`,
+            `nullable: ${is_required ? 'false' : 'true'},`,
+        ].filter(Boolean).map(line => '  ' + line),
+        `})`,
+    ];
+    return [
+        ...typeorm_decorator,
+        `${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: [
+                    'import { Column, CreateDateColumn, DeleteDateColumn, Entity, JoinColumn, ManyToOne, OneToMany, PrimaryColumn, PrimaryGeneratedColumn, UpdateDateColumn, BaseEntity } from "typeorm";',
+                    ...lodash_1.default.uniq(buildTableDependency(table, source)),
+                    '',
+                    `@Entity('${table.name}')`,
+                    `export class ${table.name} extends BaseEntity {`,
+                    ...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_file_abs_path: string, out_folder: string): Promise<void>;

package/dist/cmd-generate.js

@@ -0,0 +1,46 @@
+"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 _1 = require(".");
+function cmdGenerate(design_file_abs_path, out_folder) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = (0, naiv_parser_1.naiv_parser)(yield fs_1.default.promises.readFile(design_file_abs_path, 'utf-8'));
+        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);
+        }
+    });
+}
+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/cmd-run.d.ts

@@ -0,0 +1 @@
+export declare function cmdRun(design_file: string): Promise<void>;

package/dist/cmd-run.js

@@ -0,0 +1,34 @@
+"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.cmdRun = cmdRun;
+const cmd_generate_1 = require("./cmd-generate");
+const compile_folter_1 = require("./compile-folter");
+const server_1 = require("./server");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+function cmdRun(design_file) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const types_path = path_1.default.resolve('./zzz-types');
+        const implementation_path = path_1.default.resolve('./zzz-impl');
+        yield fs_1.default.promises.rm(types_path, { force: true, recursive: true });
+        yield (0, cmd_generate_1.cmdGenerate)(path_1.default.resolve(design_file), types_path);
+        yield (0, compile_folter_1.compileAndClean)(types_path);
+        yield (new server_1.Server()).run({
+            port: 9000,
+            types_path,
+            implementation_path
+        });
+    });
+}

package/dist/compile-folter.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Compile a TS folder and remove .ts files
+ */
+export declare function compileAndClean(absFolderPath: string): Promise<void>;

package/dist/compile-folter.js

@@ -0,0 +1,70 @@
+"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.compileAndClean = compileAndClean;
+const typescript_1 = __importDefault(require("typescript"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const glob_1 = require("glob");
+/**
+ * Compile a TS folder and remove .ts files
+ */
+function compileAndClean(absFolderPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!path_1.default.isAbsolute(absFolderPath)) {
+            throw new Error("Path must be absolute");
+        }
+        if (!fs_1.default.existsSync(absFolderPath)) {
+            throw new Error("Folder does not exist");
+        }
+        console.log("Compiling:", absFolderPath);
+        // Find all .ts files
+        const tsFiles = (0, glob_1.globSync)("**/*.ts", {
+            cwd: absFolderPath,
+            absolute: true,
+            ignore: ["**/node_modules/**"]
+        });
+        if (!tsFiles.length) {
+            console.log("No TypeScript files found.");
+            return;
+        }
+        // Create TS program
+        const program = typescript_1.default.createProgram(tsFiles, {
+            target: typescript_1.default.ScriptTarget.ES2020,
+            module: typescript_1.default.ModuleKind.CommonJS,
+            outDir: absFolderPath,
+            rootDir: absFolderPath,
+            experimentalDecorators: true,
+            emitDecoratorMetadata: true,
+            useDefineForClassFields: false,
+            strict: true,
+            noEmitOnError: false
+        });
+        // Compile
+        const emitResult = program.emit();
+        // const diagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+        // diagnostics.forEach(d => {
+        //   console.error(ts.flattenDiagnosticMessageText(d.messageText, "\n"));
+        // });
+        if (emitResult.emitSkipped) {
+            throw new Error("Compilation failed");
+        }
+        console.log("Compilation done.");
+        // Remove .ts files
+        for (const file of tsFiles) {
+            yield fs_1.default.promises.rm(file);
+        }
+        console.log("TS files removed.");
+    });
+}

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,16 @@
+#!/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_run_1 = require("./cmd-run");
+const args = (0, arg_1.default)({
+    "--design": String,
+    "-d": "--design",
+});
+if (!args['--design']) {
+    throw new Error(`--design/-d argument is required`);
+}
+(0, cmd_run_1.cmdRun)(args['--design']).then(() => console.log('completed.')).catch(console.error);

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Server = 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 server_1 = require("./server");
+Object.defineProperty(exports, "Server", { enumerable: true, get: function () { return server_1.Server; } });
+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));
+        return {
+            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/dist/server.d.ts

@@ -0,0 +1,21 @@
+import 'reflect-metadata';
+import { Express } from 'express';
+export interface SystemParam {
+    api_prefix?: string;
+    port: number;
+    types_path: string;
+    implementation_path: string;
+    beforeStart?(): Promise<void>;
+}
+export interface ServerConstructorParam {
+    noCors?: boolean;
+    noTrustProxy?: boolean;
+}
+export declare class Server {
+    express: Express;
+    private constructor_param;
+    constructor(param?: ServerConstructorParam);
+    run(param: SystemParam): Promise<Server>;
+    private errorToString;
+    _run(types_folder_abs_path: string, implementation_folder: string, api_prefix?: string): Promise<void>;
+}