@naiv/flazy-api 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,202 @@
+### How to test
+
+0. Build project (on this project)
+```bash
+npm run build
+```
+
+build action will create `codegen-nodejs-typeorm` binary and accessible from terminal.
+
+1. Create testing folder
+```bash
+mkdir naiv-test-server
+cd naiv-test-server
+```
+
+2. Init Typescript Project
+```bash
+npm init -y
+npm install --save-dev typescript
+```
+
+3. Modify `package.json` script
+
+```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",
+    "codegen": "codegen-nodejs-typeorm -d design -o types",
+    "codegen-init": "npx ts-node ./generate-initial-api.ts",
+    "build": "rm -rf dist && tsc",
+    "start": "node dist",
+    "dev": "npm run build && npm start"
+  },
+```
+
+4. Create TS-Config file
+```json
+{
+  // Visit https://aka.ms/tsconfig to read more about this file
+  "compilerOptions": {
+
+    // Environment Settings
+    // See also https://aka.ms/tsconfig/module
+    "module": "nodenext",
+    "target": "esnext",
+    "types": ["node"],
+
+    // Stricter Typechecking Options
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+
+    // Recommended Options
+    "strict": true,
+    "jsx": "react-jsx",
+    "verbatimModuleSyntax": false,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "outDir": "dist"
+  }
+}
+```
+
+5. Install dependency
+```bash
+npm install --save express cors class-validator class-transformer
+npm install --save-dev @types/express @types/cors
+```
+
+6. Create `generate-initial-api.ts`
+
+```typescript
+import * as fs from 'fs';
+import * as path from 'path';
+
+function getAllTsFiles(dir: string): string[] {
+  const files = fs.readdirSync(dir, { withFileTypes: true });
+  const tsFiles: string[] = [];
+
+  for (const file of files) {
+    if (file.isFile() && file.name.endsWith('.ts')) {
+      tsFiles.push(file.name);
+      const filePath = path.resolve(`./implementation/${file.name}`);
+      if (fs.existsSync(filePath)) {
+        console.log(`✅ File already exists: ${filePath}`);
+      } else {
+        const [fn] = file.name.split('.');
+        const prefix = fn?.slice(0, 2);
+        const only_name = fn?.slice(2);
+        const is_streaming = prefix == 'S_';
+        fs.writeFileSync(filePath, `\
+import { ${prefix}${only_name} } from "../types/api/${prefix}${only_name}";
+
+export const ${prefix?.toLowerCase()}${only_name}: ${prefix}${only_name} = async ${is_streaming ? '(req, stream, res)' : '(req, res)'} => {
+  throw new Error('Implement this');
+}
+`, 'utf8');
+        console.log(`📝 File created: ${filePath}`);
+      }
+    }
+  }
+
+  return tsFiles;
+}
+
+console.log(getAllTsFiles('./types/api'));
+```
+
+7. Create simple api design `design/api.naiv`
+```
+schema Z {
+  data string required
+}
+
+api get /test-streaming {
+  alias testX
+  query {
+    q string
+  }
+  return stream of string required
+}
+
+api get /common-api {
+  alias getY
+  query {
+    limit number
+    offset number
+  }
+  return array string required
+}
+```
+
+8. Generate code
+```bash
+npm run codegen
+```
+
+9. Generate code-stub
+```bash
+npm run codegen-init
+```
+
+10. Copy `server.ts` from this project to `naiv-test-server` project
+
+11. Create `index.ts`
+```typescript
+import path from 'path';
+import { Server } from './server';
+
+const server = new Server();
+server.run({
+  port: +(process.env.PORT ?? 9415),
+  types_path: path.resolve(__dirname, 'types'),
+  implementation_path: path.resolve(__dirname, 'implementation'),
+  async beforeStart() {
+    console.log('before start script.')
+  }
+});
+```
+
+12. Implement logic
+```typescript
+import { S_testX } from "../types/api/S_testX";
+
+export const s_testX: S_testX = async (req, stream, res) => {
+  stream(req.query.q ?? 'no query');
+  stream('\n');
+  stream('aaa\n');
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  stream('ccc\n');
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  stream('bbb\n');
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  stream('eee\n');
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  stream('ddd\n');
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  stream('fff\n');
+  await new Promise(resolve => setTimeout(resolve, 1000));
+}
+```
+
+```typescript
+import { T_getY } from "../types/api/T_getY";
+
+export const t_getY: T_getY = async (req, res) => {
+  return ['nice'];
+}
+```
+
+13. `curl` testing
+```bash
+curl localhost:9415/test-streaming?q=lorem-ipsum -N
+```
+
+```bash
+curl localhost:9415/common-api
+```

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,110 @@
+"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) {
+    const is_streaming = api.data.return_type.kind === 'stream';
+    return `./api/${is_streaming ? 'S_' : 'T_'}${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;
+    const is_streaming = api.data.return_type.kind === 'stream';
+    const prefix = is_streaming ? 'S_' : 'T_';
+    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: `${prefix}${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: `${prefix}${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: `${prefix}${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: `${prefix}${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: [
+                    'import { Response } from "express";',
+                    `${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 ${prefix}${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: ${prefix}${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: ${prefix}${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: ${prefix}${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: ${prefix}${api.data.alias}_body` : '',
+                    ].filter(Boolean).join('\n')}
+${is_streaming
+                        ? `}, stream: (chunk: ${fake_return_type_field_result.type_only}${api.data.return_type.type.required ? '' : ' | null'}) => void, response: Response) => Promise<void>;`
+                        : `}, response: Response) => 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 = '${prefix}${api.data.alias}';
+export const is_streaming = ${is_streaming ? 'true' : 'false'};
+`
+                ].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,24 @@
+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 declare function getDecorators(item: NVSchemaItem): string[];
+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,207 @@
+"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.getDecorators = getDecorators;
+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([
+        `import { ClassConstructor, Transform, Type, plainToInstance } from "class-transformer";`,
+        `import { IsNotEmpty, IsNumber, IsObject, IsBoolean, IsOptional, IsISO8601, IsString, IsEnum, ValidateNested, IsArray, ValidationError, validateOrReject } from "class-validator";`,
+        ...buildSchemaDependency(schema, list_schema),
+        ...new_deps_lines
+    ].join('\n').split('\n'));
+    return {
+        deps: complete_deps,
+        content: [
+            ...new_class_lines,
+            `${no_export ? '' : 'export '}class ${schema.name} {`,
+            ...field_lines.map(line => '  ' + line),
+            `}`
+        ]
+    };
+}
+const transform_integer = `(param?: any): number | null => (param?.value === null || param?.value === undefined || param?.value === '') ? null : parseInt(param.value)`;
+const transform_arrayinteger = `(param?: any): (number | null)[] | null => !Array.isArray(param?.value) ? null : param?.value.map((value: any) => (value === null || value === undefined || value === '') ? null : parseInt(value))`;
+const transform_decimal = `(param?: any): number | null => (param?.value === null || param?.value === undefined || param?.value === '') ? null : parseFloat(param.value)`;
+const transform_arraydecimal = `(param?: any): (number | null)[] | null => !Array.isArray(param?.value) ? null : param?.value.map((value: any) => (value === null || value === undefined || value === '') ? null : parseFloat(value))`;
+const transform_boolean = `(param?: any): boolean | null => (param?.value === null || param?.value === undefined || param?.value === '') ? null : (param?.value === 'true' || ((typeof param?.value === 'boolean') && param?.value))`;
+const transform_arrayboolean = `(param?: any): (boolean | null)[] | null => !Array.isArray(param?.value) ? null : param?.value.map((value: any) => (value === null || value === undefined || value === '') ? null : (value === 'true' || ((typeof value === 'boolean') && value)))`;
+const transform_date = `(param?: any): Date | null => (param?.value === null || param?.value === undefined || param?.value === '') ? null : new Date(param?.value)`;
+const transform_arraydate = `(param?: any): (Date | null)[] | null => !Array.isArray(param?.value) ? null : param?.value.map((value: any) => (value === null || value === undefined || value === '') ? null : new Date(value))`;
+function getDecorators(item) {
+    const list_decorator = [];
+    if (item.type.required) {
+        list_decorator.push(`@IsNotEmpty({ message: '${item.key} cannot be empty' })`);
+    }
+    else {
+        list_decorator.push(`@IsOptional()`);
+    }
+    const is_array = item.type.array_dimension > 0;
+    if (item.type.type === 'native') {
+        const array_property = is_array ? ', each: true' : '';
+        switch (item.type.type_native) {
+            case 'number':
+                list_decorator.push(`@Transform(${is_array ? transform_arraydecimal : transform_decimal})`);
+                list_decorator.push(`@IsNumber({}, { message: '${item.key} must be a number (decimal)'${array_property} })`);
+                break;
+            case 'boolean':
+                list_decorator.push(`@Transform(${is_array ? transform_arrayboolean : transform_boolean})`);
+                list_decorator.push(`@IsBoolean({ message: '${item.key} must be a boolean'${array_property} })`);
+                break;
+            case 'string':
+                list_decorator.push(`@IsString({ message: '${item.key} must be a string'${array_property} })`);
+                break;
+        }
+    }
+    if (item.type.type === 'enum') {
+        const array_property = is_array ? ', each: true' : '';
+        list_decorator.push(`@IsEnum(${item.type.subtype_native}, { message: '${item.key} must be enum ${item.type.subtype_native}'${array_property} })`);
+    }
+    if (item.type.type === 'schema') {
+        if (is_array) {
+            list_decorator.push(`@IsArray()`);
+            list_decorator.push(`@ValidateNested({ each: true })`);
+        }
+        else {
+            list_decorator.push(`@IsObject()`);
+            list_decorator.push(`@ValidateNested()`);
+        }
+        list_decorator.push(`@Type(() => ${item.type.subtype_native})`);
+    }
+    if (item.type.type === 'table') {
+        if (is_array) {
+            list_decorator.push(`@IsArray()`);
+            list_decorator.push(`@ValidateNested({ each: true })`);
+        }
+        else {
+            list_decorator.push(`@IsObject()`);
+            list_decorator.push(`@ValidateNested()`);
+        }
+        list_decorator.push(`@Type(() => ${item.type.subtype_native})`);
+    }
+    return list_decorator;
+}
+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: [
+                    ...getDecorators(item),
+                    `${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: [
+                    ...getDecorators(item),
+                    `${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: [
+                    ...getDecorators(item),
+                    `${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: [
+                    ...getDecorators(item),
+                    `${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: [
+                    ...getDecorators(Object.assign(Object.assign({}, item), { type: Object.assign(Object.assign({}, item.type), { subtype_native: inline_schema_name, type: 'schema' }) })),
+                    `${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;