@naiv/flazy-api 0.0.1 → 0.0.2

package/NAIV-INSTRUCTION.md

@@ -0,0 +1,221 @@
+## INSTRUCTION
+
+### 1. Database Design
+
+No comments on design files `//` or `/** */`.
+
+#### Table
+
+```naiv
+table User {
+    id bigint pk inc notnull
+    name varchar(255) notnull
+    email varchar(255) unique notnull
+    password varchar(255) notnull
+    created_at timestamp notnull default=NOW()
+    updated_at timestamp notnull default=NOW()
+}
+```
+
+- `inc` means auto increment.
+- `notnull` means not null.
+- `pk` means primary key.
+- `unique` means unique.
+- `default` means default value. `NOW()` is a function that returns current timestamp. If default value is string then write it with quote like `default="value"`. If number write it without quote like `default=123`.
+
+
+#### Relationship
+
+```naiv
+table User {
+    id bigint pk inc notnull
+    name varchar(255) notnull
+    email varchar(255) unique notnull
+    password varchar(255) notnull
+    created_at timestamp notnull default=NOW()
+    updated_at timestamp notnull default=NOW()
+}
+
+table Product {
+    id bigint pk inc notnull
+    id_user_owner User.id notnull
+    name varchar(255) notnull
+    price decimal(10,2) notnull
+    created_at timestamp notnull default=NOW()
+    updated_at timestamp notnull default=NOW()
+}
+```
+
+`User` has link to `Product` by `id_user_owner`.
+
+#### Enum
+
+```naiv
+enum ProductStatus {
+    DRAFT
+    PUBLISHED
+    ARCHIVED
+}
+
+table Product {
+    id bigint pk inc notnull
+    id_user_owner User.id notnull
+    name varchar(255) notnull
+    price decimal(10,2) notnull
+    status enum.ProductStatus notnull default=DRAFT
+    created_at timestamp notnull default=NOW()
+    updated_at timestamp notnull default=NOW()
+}
+```
+
+default value for enum is written without quote like `default=DRAFT`.
+
+### 2. API Design
+
+API design in NAIV accept only method GET, POST, PUT, DELETE, PATCH. Each API must have unique alias, alias will be used as function call in http client which consume this api design. No comments on design files `//` or `/** */`. Here is how to write it:
+
+#### GET
+
+```naiv
+api get /users {
+    alias getUsers
+    return array table.User required
+}
+```
+
+simple api design for get all users. `required` means this api will response list of users. If not required means this api will response either list users or null. `array` means this api will response array of users. `table.User` means this api will response table structure of User entity on database design above.
+
+Other possibility return type beside table reference are native types: `string`, `boolean`, `number`, and schema inline and schema reference (schema will be explained later).
+
+```naiv
+api get /users/:id {
+    alias getUserById
+    path {
+        id number required
+    }
+    return table.User required
+}
+```
+
+simple api design for get user by id. no `array` means this api will response single user. `path` means this api will accept path parameter, path parameter must be required if it has path parameter on the url. path parameter only accept native types: `string`, `number`, and `boolean`.
+
+```naiv
+api get /users {
+    alias getUsers
+    query {
+        name string
+        limit number required
+        offset number required
+    }
+    return array table.User required
+}
+```
+
+simple api design for get users by name. `query` means this api will accept query parameter, query parameter must be optional if it has query parameter on the url. `required` on query `limit` and `offset` means this api will accept query parameter `limit` and `offset` and it must be required. `name` on query is optional. query parameter only accept native types: `string`, `number`, and `boolean`.
+
+```naiv
+api get /profile {
+    alias getProfile
+    headers {
+        authorization string required
+    }
+    return table.User required
+}
+```
+
+simple api design for get profile. `headers` means this api will accept headers parameter, headers parameter must be required if it has headers parameter on the url. headers parameter only accept native types: `string`, `number`, and `boolean`.
+
+#### DELETE
+
+same like GET, DELETE also accept path, query, and headers parameter.
+
+#### POST
+
+```naiv
+api post /users {
+    alias createUser
+    body {
+        name string required
+        email string required
+        password string required
+    }
+    return table.User required
+}
+```
+
+simple api design for create user. `body` means this api will accept body parameter, body parameter must be required if it has body parameter on the url. body parameter accept native types: `string`, `number`, `boolean`, and schema inline and schema reference (schema will be explained later).
+
+```naiv
+api post /sample-complex-post {
+    alias sampleComplexPost
+    body {
+        foo {
+            bar string required
+            baz number required
+        } required
+        qux string required
+    }
+    return string required
+}
+```
+
+foo has type schema inline, it means foo is a schema that defined inside api design like inline object type in typescript.
+
+```naiv
+schema LoginRequest {
+    email string required
+    password string required
+}
+api post /login {
+    alias login
+    body {
+        data schema.LoginRequest required
+    }
+    return {
+        token string required
+        user table.User required
+    } required
+}
+```
+
+`data` has type schema reference `LoginRequest`, it means `data` is a schema that defined outside api design. Both schema reference and schema inline also supported for return type. If you want to have an array inside schema inline, you can use `array` keyword.
+
+```naiv
+schema Foo {
+    bar array string required
+    tuz string required
+}
+schema Buzz {
+    foo schema.Foo required
+}
+api post /sample-complex-post-2 {
+    alias sampleComplexPost2
+    body {
+        foo schema.Foo required
+        buzz array schema.Buzz required
+    }
+    return string required
+}
+```
+
+object inside array also supported on body and also return type.
+
+#### PATCH, PUT
+
+same like POST, PATCH and PUT also accept path, query, body, and headers parameter.
+
+#### Streaming response
+
+NAIV api design also support streaming response. Here is how to write it:
+
+```naiv
+api get /chat {
+    alias promptChat
+    query {
+        prompt string required
+    }
+    return stream of string required
+}
+```
+
+`stream of` keyword means this api will return stream of data. `stream of` accept native types: `string`, `number`, `boolean`, schema (inline or reference), and table reference.

package/dist/cmd-chat.d.ts

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

package/dist/cmd-chat.js

@@ -0,0 +1,130 @@
+"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.cmdChat = cmdChat;
+const enquirer_1 = require("enquirer");
+const listr2_1 = require("listr2");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const llm_runner_1 = require("@graf-research/llm-runner");
+const core_1 = require("@naiv/core");
+const process_1 = require("process");
+function cmdChat() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const filename = `api-specification.naiv`;
+        const file_abs_path = path_1.default.resolve((0, process_1.cwd)(), filename);
+        let code = '';
+        if (fs_1.default.existsSync(file_abs_path)) {
+            code = yield fs_1.default.promises.readFile(file_abs_path, 'utf-8');
+            console.warn(`File ${file_abs_path} is exist, this file will be modified by your instruction.`);
+        }
+        const answers = yield (0, enquirer_1.prompt)([{
+                type: "input",
+                name: "prompt",
+                message: `Explain briefly your API program`,
+            }]);
+        let success_compiled = false;
+        const secret_key = process.env.SK || '';
+        const llm_model = 'google/gemini-3-flash-preview';
+        const llm_endpoint = 'https://openrouter.ai/api/v1';
+        const llm = new llm_runner_1.ChatGPTLLM(secret_key, llm_model, undefined, llm_endpoint);
+        let attempt = 0;
+        let error_message = '';
+        do {
+            yield new listr2_1.Listr([{
+                    title: attempt > 0 ? "Fixing error specification NAIV DSL" : code ? "Updating existing NAIV file" : "Generating data & API specification",
+                    rendererOptions: {
+                        persistentOutput: true,
+                    },
+                    task: () => __awaiter(this, void 0, void 0, function* () {
+                        const prompt = yield generatePrompt(answers.prompt, code, error_message);
+                        const response = yield llm.askNoContext(prompt);
+                        code = extractCodeBlocks(response);
+                        try {
+                            success_compiled = Boolean((0, core_1.naiv_parser)(code));
+                        }
+                        catch (err) {
+                            error_message = (err === null || err === void 0 ? void 0 : err.message) || '';
+                            console.log(error_message);
+                        }
+                    })
+                }]).run();
+            attempt++;
+        } while (!success_compiled);
+        yield fs_1.default.promises.writeFile(file_abs_path, code);
+    });
+}
+function generatePrompt(instruction, generated_code, error_message) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const naiv_instruction = yield fs_1.default.promises.readFile(path_1.default.resolve(__dirname, '../NAIV-INSTRUCTION.md'), 'utf-8');
+        if (error_message && generated_code) {
+            return `
+Read this NAIV DSL carefully
+
+${naiv_instruction}
+
+--
+
+An LLM generated this code on the context "${instruction}".
+
+\`\`\`naiv
+${generated_code}
+\`\`\`
+
+but there is an error: ${error_message}.
+
+Your task: fix the error and create naiv database and api dsl code in a single file based on the context "${instruction}".
+
+please return only naiv code with code fence block without any other strings but typescript code! your code fence block must starts with "\`\`\`naiv" and ends with "\`\`\`"
+`.trim();
+        }
+        if (generated_code) {
+            return `
+Read this NAIV DSL carefully
+
+${naiv_instruction}
+
+--
+
+Your task: modify existing naiv database and api dsl code below based on the context "${instruction}".
+
+Existing naiv design
+
+\`\`\`naiv
+${generated_code}
+\`\`\`
+
+please return only naiv code with code fence block without any other strings but typescript code! your code fence block must starts with "\`\`\`naiv" and ends with "\`\`\`"
+`.trim();
+        }
+        return `
+Read this NAIV DSL carefully
+
+${naiv_instruction}
+
+--
+
+Your task: create naiv database and api dsl code in a single file based on the context "${instruction}".
+
+please return only naiv code with code fence block without any other strings but typescript code! your code fence block must starts with "\`\`\`naiv" and ends with "\`\`\`"
+`.trim();
+    });
+}
+function extractCodeBlocks(text) {
+    return /```(?:naiv|dsl)\b/i.test(text)
+        ? [...text.matchAll(/```(?:naiv|dsl)\s*([\s\S]*?)```/gi)]
+            .map(m => m[1])
+            .join('\n')
+        : '';
+}

package/dist/cmd-generate.d.ts

@@ -1 +1,2 @@
-export declare function cmdGenerate(design_file_abs_path: string, out_folder: string): Promise<void>;
+import { NVResult } from "@naiv/core";
+export declare function cmdGenerate(design_file_abs_path: string, out_folder: string): Promise<NVResult>;

package/dist/cmd-generate.js

@@ -15,10 +15,11 @@ 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_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 result = (0, naiv_parser_1.naiv_parse_folder)(design_file_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);
@@ -32,6 +33,7 @@ function cmdGenerate(design_file_abs_path, out_folder) {
         for (const f of typeorm_model.api.files) {
             writeFiles(f, out_folder);
         }
+        return result;
     });
 }
 function writeFiles(output_1) {

package/dist/cmd-run.d.ts

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

package/dist/cmd-run.js

@@ -14,21 +14,53 @@ var __importDefault = (this && this.__importDefault) || function (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 compile_folder_1 = require("./compile-folder");
 const server_1 = require("./server");
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
-function cmdRun(design_file) {
+const glob_1 = require("glob");
+function cmdRun(naiv_cwd) {
     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');
+        const list_naiv_file = (0, glob_1.globSync)("*.naiv", {
+            cwd: naiv_cwd,
+            absolute: true,
+            ignore: ["**/node_modules/**"]
+        });
+        if (list_naiv_file.length == 0) {
+            throw new Error(`No NAIV files is found. Create new data and API design with "--chat"`);
+        }
+        const working_directory = path_1.default.resolve(naiv_cwd, './__flazy');
+        if (!fs_1.default.existsSync(working_directory)) {
+            yield fs_1.default.promises.mkdir(working_directory);
+        }
+        const types_path = path_1.default.resolve(naiv_cwd, './__flazy/__types__');
         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({
+        let blueprint = [];
+        for (const naiv_file of list_naiv_file) {
+            blueprint.push(yield fs_1.default.promises.readFile(naiv_file, 'utf-8'));
+        }
+        const nv_result = yield (0, cmd_generate_1.cmdGenerate)(naiv_cwd, types_path);
+        yield (0, compile_folder_1.compileAndClean)({
+            source_abs_folder_path: types_path
+        });
+        const source_implementation_path = path_1.default.resolve(naiv_cwd, './__flazy/original-implementation');
+        const transp_implementation_path = path_1.default.resolve(naiv_cwd, './__flazy/__implementation__');
+        if (fs_1.default.existsSync(source_implementation_path)) {
+            yield fs_1.default.promises.rm(transp_implementation_path, { force: true, recursive: true });
+            yield (0, compile_folder_1.compileAndClean)({
+                source_abs_folder_path: source_implementation_path,
+                target_abs_folder_path: transp_implementation_path,
+            });
+        }
+        else {
+            yield fs_1.default.promises.mkdir(source_implementation_path);
+        }
+        yield (new server_1.XServer({ naivCwd: naiv_cwd })).run({
             port: 9000,
             types_path,
-            implementation_path
+            implementation_path: transp_implementation_path,
+            nv_result,
+            blueprint
         });
     });
 }

package/dist/compile-folder.d.ts

@@ -0,0 +1,16 @@
+interface CompileParam {
+    source_abs_folder_path: string;
+    target_abs_folder_path?: string;
+    clean_after_compiled?: boolean;
+    replace_keywords?: {
+        [key: string]: string;
+    };
+}
+export declare function compileAndClean(param: CompileParam): Promise<void>;
+interface CompileSingleFileParam {
+    source_root_folder_abs_path: string;
+    source_abs_file_path: string;
+    target_root_folder_abs_path: string;
+}
+export declare function compileSingleFile(param: CompileSingleFileParam): Promise<void>;
+export {};

package/dist/compile-folder.js

@@ -0,0 +1,119 @@
+"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;
+exports.compileSingleFile = compileSingleFile;
+const typescript_1 = __importDefault(require("typescript"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const glob_1 = require("glob");
+function compileAndClean(param) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const target_abs_folder_path = (_a = param.target_abs_folder_path) !== null && _a !== void 0 ? _a : param.source_abs_folder_path;
+        if (!path_1.default.isAbsolute(param.source_abs_folder_path)) {
+            throw new Error("Path must be absolute");
+        }
+        if (!fs_1.default.existsSync(param.source_abs_folder_path)) {
+            throw new Error("Folder does not exist");
+        }
+        console.log("Compiling:", param.source_abs_folder_path);
+        // Find all .ts files
+        const tsFiles = (0, glob_1.globSync)("**/*.ts", {
+            cwd: param.source_abs_folder_path,
+            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: target_abs_folder_path,
+            rootDir: param.source_abs_folder_path,
+            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.");
+        if (param.replace_keywords) {
+            const jsFiles = (0, glob_1.globSync)("**/*.js", {
+                cwd: param.target_abs_folder_path,
+                absolute: true,
+                ignore: ["**/node_modules/**"]
+            });
+            const keys = Object.keys(param.replace_keywords);
+            for (const file of jsFiles) {
+                let content = yield fs_1.default.promises.readFile(file, 'utf-8');
+                for (const key of keys) {
+                    content = content.replace(new RegExp(key, 'g'), param.replace_keywords[key]);
+                }
+                yield fs_1.default.promises.writeFile(file, content);
+            }
+        }
+        if (param.clean_after_compiled) {
+            // Remove .ts files
+            for (const file of tsFiles) {
+                yield fs_1.default.promises.rm(file);
+            }
+            console.log("TS files removed.");
+        }
+    });
+}
+function compileSingleFile(param) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!path_1.default.isAbsolute(param.source_abs_file_path)) {
+            throw new Error("Path must be absolute");
+        }
+        if (!fs_1.default.existsSync(param.source_abs_file_path)) {
+            throw new Error("This function is not implemented yet!");
+        }
+        console.log("Compiling:", param.source_abs_file_path);
+        const program = typescript_1.default.createProgram([param.source_abs_file_path], {
+            target: typescript_1.default.ScriptTarget.ES2020,
+            module: typescript_1.default.ModuleKind.CommonJS,
+            rootDir: param.source_root_folder_abs_path,
+            outDir: param.target_root_folder_abs_path,
+            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.");
+    });
+}

package/dist/exec.js

@@ -6,11 +6,26 @@ var __importDefault = (this && this.__importDefault) || function (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`);
+const cmd_chat_1 = require("./cmd-chat");
+try {
+    const args = (0, arg_1.default)({
+        "--run": String,
+        "-r": "--run",
+        "--chat": Boolean,
+        "-c": "--chat"
+    });
+    const dir_path = args['--run'];
+    const instruction = args['--chat'];
+    if (!dir_path && !instruction) {
+        throw new Error(`use "--run <folder path>" or "--chat" to begin.`);
+    }
+    if (dir_path) {
+        (0, cmd_run_1.cmdRun)(dir_path).then(() => console.log('completed.')).catch(console.error);
+    }
+    else if (instruction) {
+        (0, cmd_chat_1.cmdChat)();
+    }
+}
+catch (err) {
+    console.error(err === null || err === void 0 ? void 0 : err.toString());
 }
-(0, cmd_run_1.cmdRun)(args['--design']).then(() => console.log('completed.')).catch(console.error);

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { NVResult } from "@naiv/core";
 import { ItemOutput } from "./data-types";
-import { Server } from './server';
+import { XServer } from './server';
 export declare namespace TypeORMModel {
     interface Output {
         table: ItemOutput;
@@ -10,4 +10,4 @@ export declare namespace TypeORMModel {
     }
     function compile(source: NVResult): Output;
 }
-export { Server };
+export { XServer };

package/dist/index.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Server = exports.TypeORMModel = void 0;
+exports.XServer = 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; } });
+Object.defineProperty(exports, "XServer", { enumerable: true, get: function () { return server_1.XServer; } });
 var TypeORMModel;
 (function (TypeORMModel) {
     function compile(source) {

package/dist/prompt.d.ts

@@ -0,0 +1,10 @@
+export interface ImplPromptParam {
+    function_name: string;
+    types_relative_path: string;
+    target_implementation_path: string;
+    types_content: string;
+    description: string;
+    model_files_list: string[];
+    blueprint: string;
+}
+export declare function getImplPrompt(param: ImplPromptParam): string;

package/dist/prompt.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getImplPrompt = getImplPrompt;
+function codefence(code) {
+    return `\`\`\`\n${code.trim()}\n\`\`\``;
+}
+function getImplPrompt(param) {
+    const function_name_first_lowcase = `${param.function_name[0].toLowerCase()}${param.function_name.slice(1)}`;
+    return `
+This is a system blueprint that will related to the task
+
+${codefence(param.blueprint)}
+
+Look at this types and signature ${param.function_name} of an API:
+
+File location: ${param.types_relative_path}
+
+${codefence(param.types_content)}
+
+TypeORM models available on this files location:
+
+${param.model_files_list.map(x => `- ${x}`).join('\n')}
+
+Your task: implement function that satisfies that types and signature. This function should do: "${param.description}".
+
+This is an example of my expectation how you will implement the function:
+
+${codefence(`
+import { SomeModel } from "../__types__/model/table/SomeModel";
+
+export const ${function_name_first_lowcase}: ${param.function_name} = async req => {
+  // implement function here...
+}
+`)}
+
+You dont need to initialize AppDataSource or use getRepository to get model, just use the model directly since it already extends BaseEntity.
+Function name ${function_name_first_lowcase} is intentional and must be exactly same, do not change.
+
+Do not import third party library unless it built-in nodejs library and jsonwebtoken and bcrypt available, instead of other third party library use built-in alternative or just give mockup code/result.
+
+please return only typescript code with code fence block without any other strings but typescript code!
+
+`.trim();
+}
+// console.log(getImplPrompt({
+//   function_name: "T_getProductList",
+//   types_relative_path: "__flazy/__types__/api/T_getProductList.ts",
+//   target_implementation_path: "__flazy/original-implementation/T_getProductList.ts",
+//   types_content: `
+// import { Response } from "express";
+// import { ClassConstructor, Transform, Type, plainToInstance } from "class-transformer";
+// import { IsNotEmpty, IsNumber, IsObject, IsBoolean, IsOptional, IsISO8601, IsString, IsEnum, ValidateNested, IsArray, ValidationError, validateOrReject } from "class-validator";
+// import { Product } from '../model/table/Product'
+// class ReturnType_0 {
+//   @IsNotEmpty({ message: 'total cannot be empty' })
+//   @Transform((param?: any): number | null => (param?.value === null || param?.value === undefined || param?.value === '') ? null : parseFloat(param.value))
+//   @IsNumber({}, { message: 'total must be a number (decimal)' })
+//   total!: number
+//   @IsNotEmpty({ message: 'data cannot be empty' })
+//   @IsArray()
+//   @ValidateNested({ each: true })
+//   @Type(() => Product)
+//   data!: Product[]
+// }
+// export type T_getProductList = (request: {
+// }, response: Response) => Promise<ReturnType_0>;
+// export const method = 'get';
+// export const url_path = '/product';
+// export const alias = 'T_getProductList';
+// export const is_streaming = false;
+// `.trim(),
+//   description: "get list of products",
+//   model_files_list: [
+//     '__flazy/__types__/model/Product.ts',
+//     '__flazy/__types__/model/User.ts'
+//   ]
+// }))

package/dist/server.d.ts

@@ -1,21 +1,35 @@
 import 'reflect-metadata';
 import { Express } from 'express';
+import { NVResult } from '@naiv/core';
 export interface SystemParam {
     api_prefix?: string;
     port: number;
     types_path: string;
     implementation_path: string;
     beforeStart?(): Promise<void>;
+    nv_result: NVResult;
+    blueprint: string[];
 }
 export interface ServerConstructorParam {
     noCors?: boolean;
     noTrustProxy?: boolean;
+    naivCwd: string;
 }
-export declare class Server {
+export declare class XServer {
     express: Express;
+    private server_instance;
     private constructor_param;
+    private server_param;
+    private AppDataSource;
+    private secret_key;
+    private llm_model;
+    private llm_endpoint;
+    private llm;
     constructor(param?: ServerConstructorParam);
-    run(param: SystemParam): Promise<Server>;
+    private restart;
+    run(param: SystemParam): Promise<XServer>;
     private errorToString;
+    private getImplementationFunction;
+    private extractCodeBlocks;
     _run(types_folder_abs_path: string, implementation_folder: string, api_prefix?: string): Promise<void>;
 }

package/dist/server.js

@@ -45,14 +45,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Server = void 0;
+exports.XServer = void 0;
 require("reflect-metadata");
+const typeorm_1 = require("typeorm");
 const express_1 = __importStar(require("express"));
 const cors_1 = __importDefault(require("cors"));
 const class_transformer_1 = require("class-transformer");
 const class_validator_1 = require("class-validator");
 const path_1 = __importDefault(require("path"));
 const promises_1 = __importDefault(require("fs/promises"));
+const cmd_run_1 = require("./cmd-run");
+const compile_folder_1 = require("./compile-folder");
+const prompt_1 = require("./prompt");
+const fs_1 = __importDefault(require("fs"));
+const glob_1 = require("glob");
+const llm_runner_1 = require("@graf-research/llm-runner");
 const { createRequire } = require("module");
 const Module = require("module");
 // patch resolver
@@ -61,27 +68,80 @@ const nm = path_1.default.join(root, "node_modules");
 Module.globalPaths.push(nm);
 process.env.NODE_PATH = nm;
 Module._initPaths();
-class Server {
+class XServer {
     constructor(param) {
         this.express = (0, express_1.default)();
+        this.secret_key = process.env.SK || '';
+        this.llm_model = 'google/gemini-3-flash-preview';
+        this.llm_endpoint = 'https://openrouter.ai/api/v1';
+        this.llm = new llm_runner_1.ChatGPTLLM(this.secret_key, this.llm_model, undefined, this.llm_endpoint);
         this.constructor_param = param;
     }
+    restart() {
+        var _a;
+        console.log("Shutting down...");
+        (_a = this.server_instance) === null || _a === void 0 ? void 0 : _a.close(() => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            yield ((_a = this.AppDataSource) === null || _a === void 0 ? void 0 : _a.destroy());
+            console.log("HTTP server closed");
+            if (this.server_param) {
+                console.log("Restarting server...");
+                (0, cmd_run_1.cmdRun)(this.constructor_param.naivCwd);
+            }
+        }));
+    }
     run(param) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
-            if (!((_a = this.constructor_param) === null || _a === void 0 ? void 0 : _a.noCors)) {
+            var _a, _b, _c, _d, _e;
+            try {
+                const types_location = path_1.default.resolve(this.constructor_param.naivCwd, './__flazy/__types__/model/**/*.js');
+                console.log(`types loc: ${types_location}`);
+                this.AppDataSource = new typeorm_1.DataSource({
+                    type: 'mysql',
+                    host: 'zero-db.naiv.dev',
+                    port: 23306,
+                    username: 'uname_4982e1194bb34d2cbacba11dee',
+                    password: 'pwd_7a64c3d31b3445e4b1e945517100d796',
+                    database: 'db_7ff95570b7714369af4512ea287ca52d',
+                    synchronize: true,
+                    logging: false,
+                    // migrations: [
+                    //   param?.naivCwd + '/migration/**.ts'
+                    // ],
+                    entities: [
+                        types_location
+                    ]
+                });
+                const prefix_model = path_1.default.resolve(this.constructor_param.naivCwd, './__flazy/__types__/model');
+                Object.keys(require.cache).forEach((k) => {
+                    if (k.startsWith(prefix_model)) {
+                        delete require.cache[k];
+                    }
+                });
+                yield ((_a = this.AppDataSource) === null || _a === void 0 ? void 0 : _a.initialize());
+                console.log(`db initialized`);
+            }
+            catch (err) {
+                console.log(`Error initializing database: ${err === null || err === void 0 ? void 0 : err.toString()}`);
+            }
+            this.server_param = param;
+            if (!((_b = this.constructor_param) === null || _b === void 0 ? void 0 : _b.noCors)) {
                 this.express.use((0, cors_1.default)());
             }
             this.express.use(express_1.default.json({ limit: '5mb' }));
-            if (!((_b = this.constructor_param) === null || _b === void 0 ? void 0 : _b.noTrustProxy)) {
+            if (!((_c = this.constructor_param) === null || _c === void 0 ? void 0 : _c.noTrustProxy)) {
                 this.express.set('trust proxy', true);
             }
             if (param.beforeStart) {
                 yield param.beforeStart();
             }
             yield this._run(param.types_path, param.implementation_path, param.api_prefix);
-            const port = (_d = (_c = param === null || param === void 0 ? void 0 : param.port) !== null && _c !== void 0 ? _c : process.env.PORT) !== null && _d !== void 0 ? _d : 3000;
-            this.express.listen(port, () => {
+            const port = (_e = (_d = param === null || param === void 0 ? void 0 : param.port) !== null && _d !== void 0 ? _d : process.env.PORT) !== null && _e !== void 0 ? _e : 3000;
+            this.express.post('/__restart__', (req, res) => {
+                this.restart();
+                res.status(200).send('restarting...');
+            });
+            this.server_instance = this.express.listen(port, () => {
                 console.log(`\n⚡️[server]: Server is running at http://localhost:${port}`);
             });
             return this;
@@ -98,42 +158,86 @@ class Server {
             return keys.filter(key => constrains[key].length > 0).map(key => constrains[key]).join(', ');
         }).join(', ');
     }
+    getImplementationFunction(file, types_folder_abs_path, implementation_folder) {
+        const filename_without_ext = path_1.default.basename(file, path_1.default.extname(file));
+        const path_location = path_1.default.join(types_folder_abs_path, 'api', filename_without_ext);
+        delete require.cache[`${implementation_folder}/${file}`];
+        const types = require(path_location);
+        const method = types['method'];
+        const url_path = types['url_path'];
+        const alias = types['alias'];
+        const is_streaming = types['is_streaming'];
+        if (!alias) {
+            console.warn(`⚠️ api '${method} ${url_path}' doesnt have alias name, skip.`);
+            return {
+                fn: null,
+                types,
+                method,
+                url_path,
+                is_streaming,
+                alias
+            };
+        }
+        let f;
+        try {
+            f = require(path_1.default.join(implementation_folder, alias));
+        }
+        catch (err) {
+            if (err.code === "MODULE_NOT_FOUND") {
+                console.warn(`⚠️ implementation for api '${method} ${url_path}' not found, skip.`);
+                return {
+                    fn: null,
+                    types,
+                    method,
+                    url_path,
+                    is_streaming,
+                    alias
+                };
+            }
+            throw err;
+        }
+        const export_alias = alias.charAt(0).toLowerCase() + alias.slice(1);
+        const fn = f[export_alias];
+        if (!fn) {
+            console.warn(`⚠️ export function implementation for api '${method} ${url_path}' not found, skip.`);
+            return {
+                fn: null,
+                types,
+                method,
+                url_path,
+                is_streaming,
+                alias
+            };
+        }
+        return {
+            fn,
+            types,
+            method,
+            url_path,
+            is_streaming,
+            alias
+        };
+    }
+    extractCodeBlocks(text) {
+        return /```(?:js|javascript|ts|typescript)\b/i.test(text)
+            ? [...text.matchAll(/```(?:js|javascript|ts|typescript)\s*([\s\S]*?)```/gi)]
+                .map(m => m[1])
+                .join('\n')
+            : '';
+    }
     _run(types_folder_abs_path_1, implementation_folder_1) {
         return __awaiter(this, arguments, void 0, function* (types_folder_abs_path, implementation_folder, api_prefix = '/') {
+            var _a, _b, _c;
             if (!this.express) {
                 throw new Error('🚨 ExpressJS has not been initialized yet');
             }
             const router = (0, express_1.Router)();
             const files = yield promises_1.default.readdir(path_1.default.join(types_folder_abs_path, 'api'));
-            for (const file of files) {
-                const filename_without_ext = path_1.default.basename(file, path_1.default.extname(file));
-                const types = require(path_1.default.join(types_folder_abs_path, 'api', filename_without_ext));
-                const method = types['method'];
-                const url_path = types['url_path'];
-                const alias = types['alias'];
-                const is_streaming = types['is_streaming'];
-                if (!alias) {
-                    console.warn(`⚠️ api '${method} ${url_path}' doesnt have alias name, skip.`);
-                    continue;
-                }
-                let f;
-                try {
-                    f = require(path_1.default.join(implementation_folder, alias));
-                }
-                catch (err) {
-                    if (err.code === "MODULE_NOT_FOUND") {
-                        console.warn(`⚠️ implementation for api '${method} ${url_path}' not found, skip.`);
-                        continue;
-                    }
-                    throw err;
-                }
-                const export_alias = alias.charAt(0).toLowerCase() + alias.slice(1);
-                const fn = f[export_alias];
-                if (!fn) {
-                    console.warn(`⚠️ export function implementation for api '${method} ${url_path}' not found, skip.`);
-                    continue;
-                }
+            for (const file of files.filter(f => f.endsWith('.js'))) {
+                const { types, method, alias, url_path, is_streaming } = this.getImplementationFunction(file, types_folder_abs_path, implementation_folder);
+                const description = ((_c = (_b = (_a = this.server_param) === null || _a === void 0 ? void 0 : _a.nv_result.list_api.find(api => api.url_path == url_path)) === null || _b === void 0 ? void 0 : _b.data.descriptions) === null || _c === void 0 ? void 0 : _c.join('\n')) || '';
                 router[method.toLowerCase()](url_path, (req, res) => __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b;
                     const t_headers = types[`T_${alias}_headers`];
                     const t_query = types[`T_${alias}_query`];
                     const t_path = types[`T_${alias}_path`];
@@ -163,6 +267,49 @@ class Server {
                             path: req.params,
                             body: req.body,
                         };
+                        const prefix_source_path = path_1.default.resolve(this.constructor_param.naivCwd, './__flazy/original-implementation');
+                        const prefix_target_path = path_1.default.resolve(this.constructor_param.naivCwd, './__flazy/__implementation__');
+                        const types_abs_path = path_1.default.resolve(this.constructor_param.naivCwd, './__flazy/__types__/model');
+                        const filename_ts = `${file.slice(0, -3)}.ts`;
+                        const source_abs_file_path = `${prefix_source_path}/${filename_ts}`;
+                        if (!fs_1.default.existsSync(source_abs_file_path)) {
+                            try {
+                                yield (0, compile_folder_1.compileSingleFile)({
+                                    source_root_folder_abs_path: prefix_source_path,
+                                    source_abs_file_path,
+                                    target_root_folder_abs_path: prefix_target_path
+                                });
+                            }
+                            catch (_c) {
+                                const types_path_abs = path_1.default.resolve(this.constructor_param.naivCwd, `./__flazy/__types__/api/${filename_ts}`);
+                                const cwd = path_1.default.resolve(this.constructor_param.naivCwd) + '/';
+                                const impl_param = {
+                                    function_name: file.slice(0, -3),
+                                    types_relative_path: `__flazy/__types__/api/${filename_ts}`,
+                                    target_implementation_path: `__flazy/original-implementation/api/${filename_ts}`,
+                                    types_content: yield fs_1.default.promises.readFile(types_path_abs, 'utf-8'),
+                                    description,
+                                    model_files_list: (0, glob_1.globSync)("**/*.ts", {
+                                        cwd: types_abs_path,
+                                        absolute: true,
+                                        ignore: ["**/node_modules/**"]
+                                    }).map(x => x.replace(cwd, '')),
+                                    blueprint: (_b = (_a = this.server_param) === null || _a === void 0 ? void 0 : _a.blueprint.join('\n')) !== null && _b !== void 0 ? _b : ''
+                                };
+                                const llm_response = yield this.llm.askNoContext((0, prompt_1.getImplPrompt)(impl_param));
+                                const code = this.extractCodeBlocks(llm_response);
+                                yield fs_1.default.promises.writeFile(`${prefix_source_path}/${filename_ts}`, code);
+                                yield (0, compile_folder_1.compileSingleFile)({
+                                    source_root_folder_abs_path: prefix_source_path,
+                                    source_abs_file_path,
+                                    target_root_folder_abs_path: prefix_target_path
+                                });
+                            }
+                        }
+                        const { fn } = this.getImplementationFunction(file, types_folder_abs_path, implementation_folder);
+                        if (!fn) {
+                            throw new Error(`This function is not implemented yet!!`);
+                        }
                         if (is_streaming) {
                             res.status(200);
                             yield fn(request_params, (chunk) => res.write(chunk), res);
@@ -183,10 +330,9 @@ class Server {
                         res.status(500).send(err_msg);
                     }
                 }));
-                console.info(`✅api [${is_streaming ? 'stream' : 'normal'}] '${method} ${url_path}' (${alias}) is ready`);
             }
             this.express.use(api_prefix, router);
         });
     }
 }
-exports.Server = Server;
+exports.XServer = XServer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naiv/flazy-api",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "main": "dist/index.js",
   "publishConfig": {
     "access": "public"
@@ -16,7 +16,8 @@
   },
   "files": [
     "dist",
-    "package.json"
+    "package.json",
+    "NAIV-INSTRUCTION.md"
   ],
   "keywords": [],
   "author": "",
@@ -28,18 +29,26 @@
     "@types/express": "^5.0.3",
     "@types/lodash": "^4.17.13",
     "@types/node": "^22.8.1",
+    "@types/uuid": "^10.0.0",
     "typescript": "^5.6.3"
   },
   "dependencies": {
+    "@graf-research/llm-runner": "^0.0.21",
     "@naiv/core": "^0.0.15",
     "arg": "^5.0.2",
+    "bcrypt": "^6.0.0",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.2",
     "cors": "^2.8.5",
+    "enquirer": "^2.4.1",
     "express": "^5.1.0",
     "glob": "^13.0.2",
+    "jsonwebtoken": "^9.0.3",
+    "listr2": "^10.1.0",
     "lodash": "^4.17.21",
+    "mysql2": "^3.17.0",
     "reflect-metadata": "^0.2.2",
-    "typeorm": "^0.3.28"
+    "typeorm": "^0.3.28",
+    "uuid": "^13.0.0"
   }
 }

package/dist/compile-folter.d.ts

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

package/dist/compile-folter.js

@@ -1,70 +0,0 @@
-"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.");
-    });
-}