@naiv/flazy-api 0.0.1

package/dist/server.js

@@ -0,0 +1,192 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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.Server = void 0;
+require("reflect-metadata");
+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 { createRequire } = require("module");
+const Module = require("module");
+// patch resolver
+const root = path_1.default.resolve(__dirname, "..");
+const nm = path_1.default.join(root, "node_modules");
+Module.globalPaths.push(nm);
+process.env.NODE_PATH = nm;
+Module._initPaths();
+class Server {
+    constructor(param) {
+        this.express = (0, express_1.default)();
+        this.constructor_param = param;
+    }
+    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)) {
+                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)) {
+                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, () => {
+                console.log(`\n⚡️[server]: Server is running at http://localhost:${port}`);
+            });
+            return this;
+        });
+    }
+    errorToString(list_error) {
+        return list_error.map(err => {
+            const children = err.children;
+            if (children && children.length > 0) {
+                return this.errorToString(children);
+            }
+            const constrains = err.constraints;
+            const keys = Object.keys(constrains);
+            return keys.filter(key => constrains[key].length > 0).map(key => constrains[key]).join(', ');
+        }).join(', ');
+    }
+    _run(types_folder_abs_path_1, implementation_folder_1) {
+        return __awaiter(this, arguments, void 0, function* (types_folder_abs_path, implementation_folder, api_prefix = '/') {
+            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;
+                }
+                router[method.toLowerCase()](url_path, (req, res) => __awaiter(this, void 0, void 0, function* () {
+                    const t_headers = types[`T_${alias}_headers`];
+                    const t_query = types[`T_${alias}_query`];
+                    const t_path = types[`T_${alias}_path`];
+                    const t_body = types[`T_${alias}_body`];
+                    try {
+                        if (t_headers) {
+                            yield (0, class_validator_1.validateOrReject)((0, class_transformer_1.plainToInstance)(t_headers, req.headers));
+                        }
+                        if (t_query) {
+                            yield (0, class_validator_1.validateOrReject)((0, class_transformer_1.plainToInstance)(t_query, req.query));
+                        }
+                        if (t_path) {
+                            yield (0, class_validator_1.validateOrReject)((0, class_transformer_1.plainToInstance)(t_path, req.params));
+                        }
+                        if (t_body) {
+                            yield (0, class_validator_1.validateOrReject)((0, class_transformer_1.plainToInstance)(t_body, req.body));
+                        }
+                    }
+                    catch (err_validation) {
+                        res.status(400).send(this.errorToString(err_validation));
+                        return;
+                    }
+                    try {
+                        const request_params = {
+                            headers: req.headers,
+                            query: req.query,
+                            path: req.params,
+                            body: req.body,
+                        };
+                        if (is_streaming) {
+                            res.status(200);
+                            yield fn(request_params, (chunk) => res.write(chunk), res);
+                            res.end(null);
+                        }
+                        else {
+                            const result = yield fn(request_params, res);
+                            res.status(200).json(result);
+                        }
+                    }
+                    catch (err) {
+                        const err_msg = err.toString();
+                        if (/^s*d{3}s*:/.test(err_msg)) {
+                            const [err_code, msg] = err_msg.split(':');
+                            res.status(+err_code.trim()).send(msg);
+                            return;
+                        }
+                        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;

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@naiv/flazy-api",
+  "version": "0.0.1",
+  "main": "dist/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc && npm unlink -g && npm link",
+    "start": "node dist",
+    "dev": "npm run build && npm start",
+    "test": "rm -rf test/api && npm run build && flazy-api -d test -o test"
+  },
+  "bin": {
+    "flazy-api": "dist/exec.js"
+  },
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "devDependencies": {
+    "@types/axios": "^0.9.36",
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.3",
+    "@types/lodash": "^4.17.13",
+    "@types/node": "^22.8.1",
+    "typescript": "^5.6.3"
+  },
+  "dependencies": {
+    "@naiv/core": "^0.0.15",
+    "arg": "^5.0.2",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.2",
+    "cors": "^2.8.5",
+    "express": "^5.1.0",
+    "glob": "^13.0.2",
+    "lodash": "^4.17.21",
+    "reflect-metadata": "^0.2.2",
+    "typeorm": "^0.3.28"
+  }
+}