arkos 1.3.1-beta → 1.3.2-beta

package/dist/cjs/utils/prisma/prisma-schema-parser.js

@@ -1,4 +1,216 @@
-"use strict";var __importDefault=this&&this.__importDefault||function(l){return l&&l.__esModule?l:{default:l}};Object.defineProperty(exports,"__esModule",{value:!0}),exports.PrismaSchemaParser=void 0;const path_1=__importDefault(require("path")),change_case_helpers_1=require("../helpers/change-case.helpers"),fs_1=__importDefault(require("fs"));class PrismaSchemaParser{constructor(){this.enums=[],this.models=[],this.prismaSchemasContent="",this.parsed=!1,this.parse()}parse({override:s}={override:!1}){return(!this.parsed||s)&&(this.enums=this.extractEnums(),this.models=this.extractModels(),this.parsed=!0),{models:this.models,enums:this.enums}}extractEnums(){const s=[],i=(this.getPrismaSchemasContent()||"").match(/enum\s+\w+\s*\{[^}]*\}/g)||[];for(const t of i){const n=this.parseEnumBlock(t);n&&s.push(n)}return s}parseEnumBlock(s){const e=s.match(/enum\s+(\w+)/);if(!e)return null;const i=e[1],t=s.split(`
-`).map(n=>n.trim()).filter(n=>n&&!n.startsWith("enum")&&!n.startsWith("{")&&!n.startsWith("}")).map(n=>n.replace(/,$/,""));return{name:i,values:t}}extractModels(){const s=[],e=this.extractModelBlocks();for(const i of e){const t=this.parseModelBlock(i);t&&s.push(t)}return s}extractModelBlocks(){const s=/model\s+\w+\s*\{((?:[^{}]*(?:\{[^{}]*\}[^{}]*)*)*)\}/g;return(this.getPrismaSchemasContent()||"").match(s)||[]}parseModelBlock(s){const e=s.match(/model\s+(\w+)/);if(!e)return null;const i=e[1],t=this.parseFields(s),n=s.match(/@@map\s*\(\s*"([^"]+)"\s*\)/),r=n?n[1]:void 0;return{name:i,fields:t,mapName:r}}parseFields(s){const e=[],i=s.split(`
-`).map(t=>t.trim()).filter(t=>t&&!t.startsWith("model")&&!t.startsWith("{")&&!t.startsWith("}"));for(const t of i){if(t.startsWith("//")||t.startsWith("@@"))continue;const n=this.parseFieldLine(t);n&&e.push(n)}return e}parseFieldLine(s){const e=s.match(/^(\w+)\s+(\w+(?:\[\])?)\??\s*(.*)/);if(!e)return null;const[,i,t,n]=e,r=t.endsWith("[]"),c=r?t.slice(0,-2):t,a=s.includes("?"),m=n.split(/\s+/).filter(o=>o.startsWith("@"));let h;const u=n.match(/@default\(([^)]+)\)/);u&&(h=this.parseDefaultValue(u[1]));let d="";const p=n.match(/@relation\([^)]*fields:\s*\[([^\]]+)\]/);p&&(d=p[1].trim().replace(/['"]/g,""));const f=m.some(o=>o.startsWith("@id")),g=m.some(o=>o.startsWith("@unique")),M=this.models;return{name:i,type:c,isOptional:a,isRelation:M.map(o=>o.name).includes(c)||this.getPrismaSchemasContent().includes(`model ${c} {`),isArray:r,connectionField:d,defaultValue:h,isId:f,isUnique:g,attributes:m}}parseDefaultValue(s){if(s=s.trim(),s.startsWith('"')&&s.endsWith('"'))return s.slice(1,-1);if(s==="true")return!0;if(s==="false")return!1;if(/^-?\d+$/.test(s))return parseInt(s,10);if(/^-?\d+\.\d+$/.test(s))return parseFloat(s);if(!s.includes("("))return s;if(!s.includes("("))return s}getPrismaSchemasContent(){if(this.prismaSchemasContent)return this.prismaSchemasContent;const s=[],e=/model\s+(\w+)\s*{/g,i=[],t=path_1.default.resolve(process.cwd(),"prisma"),n=this.getAllPrismaFiles(t);for(const c of n){const a=fs_1.default.readFileSync(c,"utf-8");i?.includes?.(a)||i.push(a)}return i.join(`
-`).replace(e,(c,a)=>(s?.includes?.(a)||s.push((0,change_case_helpers_1.camelCase)(a.trim())),`model ${a} {`))}getAllPrismaFiles(s,e=[]){return fs_1.default.readdirSync(s)?.forEach(t=>{const n=path_1.default.join(s,t),r=fs_1.default.statSync(n);r.isDirectory()&&t!=="migrations"?e=this.getAllPrismaFiles(n,e):r.isFile()&&t.endsWith(".prisma")&&e.push(n)}),e}isEnum(s){return this.enums.some(e=>e.name===s)}isModel(s){return this.models.some(e=>e.name===s)}getModelUniqueFields(s){return this.models.find(({name:e})=>(0,change_case_helpers_1.pascalCase)(e)===(0,change_case_helpers_1.pascalCase)(s))?.fields.filter(({isUnique:e})=>e)}getModelRelations(s){return this.models.find(e=>(0,change_case_helpers_1.pascalCase)(e.name)===(0,change_case_helpers_1.pascalCase)(s))?.fields.filter(e=>e.isRelation)}getModelsAsArrayOfStrings(){return this.models.map(({name:s})=>s)}}exports.PrismaSchemaParser=PrismaSchemaParser;const prismaSchemaParser=new PrismaSchemaParser;exports.default=prismaSchemaParser;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaSchemaParser = void 0;
+const path_1 = __importDefault(require("path"));
+const change_case_helpers_1 = require("../helpers/change-case.helpers");
+const fs_1 = __importDefault(require("fs"));
+class PrismaSchemaParser {
+    constructor() {
+        this.enums = [];
+        this.models = [];
+        this.prismaSchemasContent = "";
+        this.parsed = false;
+        this.parse();
+    }
+    parse({ override } = { override: false }) {
+        if (!this.parsed || override) {
+            this.enums = this.extractEnums();
+            this.models = this.extractModels();
+            this.parsed = true;
+        }
+        return {
+            models: this.models,
+            enums: this.enums,
+        };
+    }
+    extractEnums() {
+        const enums = [];
+        const schema = this.getPrismaSchemasContent() || "";
+        const enumBlocks = schema.match(/enum\s+\w+\s*\{[^}]*\}/g) || [];
+        for (const block of enumBlocks) {
+            const enumObj = this.parseEnumBlock(block);
+            if (enumObj) {
+                enums.push(enumObj);
+            }
+        }
+        return enums;
+    }
+    parseEnumBlock(block) {
+        const nameMatch = block.match(/enum\s+(\w+)/);
+        if (!nameMatch)
+            return null;
+        const name = nameMatch[1];
+        const values = block
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line &&
+            !line.startsWith("enum") &&
+            !line.startsWith("{") &&
+            !line.startsWith("}"))
+            .map((line) => line.replace(/,$/, ""));
+        return { name, values };
+    }
+    extractModels() {
+        const models = [];
+        const modelBlocks = this.extractModelBlocks();
+        for (const block of modelBlocks) {
+            const model = this.parseModelBlock(block);
+            if (model) {
+                models.push(model);
+            }
+        }
+        return models;
+    }
+    extractModelBlocks() {
+        const modelRegex = /model\s+\w+\s*\{((?:[^{}]*(?:\{[^{}]*\}[^{}]*)*)*)\}/g;
+        const schema = this.getPrismaSchemasContent() || "";
+        return schema.match(modelRegex) || [];
+    }
+    parseModelBlock(block) {
+        const nameMatch = block.match(/model\s+(\w+)/);
+        if (!nameMatch)
+            return null;
+        const name = nameMatch[1];
+        const fields = this.parseFields(block);
+        const mapMatch = block.match(/@@map\s*\(\s*"([^"]+)"\s*\)/);
+        const mapName = mapMatch ? mapMatch[1] : undefined;
+        return { name, fields, mapName };
+    }
+    parseFields(block) {
+        const fields = [];
+        const fieldLines = block
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line &&
+            !line.startsWith("model") &&
+            !line.startsWith("{") &&
+            !line.startsWith("}"));
+        for (const line of fieldLines) {
+            if (line.startsWith("//") || line.startsWith("@@"))
+                continue;
+            const field = this.parseFieldLine(line);
+            if (field) {
+                fields.push(field);
+            }
+        }
+        return fields;
+    }
+    parseFieldLine(line) {
+        const fieldMatch = line.match(/^(\w+)\s+(\w+(?:\[\])?)\??\s*(.*)/);
+        if (!fieldMatch)
+            return null;
+        const [, name, typeWithArray, attributesStr] = fieldMatch;
+        const isArray = typeWithArray.endsWith("[]");
+        const type = isArray ? typeWithArray.slice(0, -2) : typeWithArray;
+        const isOptional = line.includes("?");
+        const attributes = attributesStr
+            .split(/\s+/)
+            .filter((attr) => attr.startsWith("@"));
+        let defaultValue = undefined;
+        const defaultMatch = attributesStr.match(/@default\(([^)]+)\)/);
+        if (defaultMatch) {
+            defaultValue = this.parseDefaultValue(defaultMatch[1]);
+        }
+        let connectionField = "";
+        const relationMatch = attributesStr.match(/@relation\([^)]*fields:\s*\[([^\]]+)\]/);
+        if (relationMatch) {
+            connectionField = relationMatch[1].trim().replace(/['"]/g, "");
+        }
+        const isId = attributes.some((attr) => attr.startsWith("@id"));
+        const isUnique = attributes.some((attr) => attr.startsWith("@unique"));
+        const models = this.models;
+        return {
+            name,
+            type,
+            isOptional,
+            isRelation: models.map((model) => model.name).includes(type) ||
+                this.getPrismaSchemasContent().includes(`model ${type} {`),
+            isArray,
+            connectionField,
+            defaultValue,
+            isId,
+            isUnique,
+            attributes,
+        };
+    }
+    parseDefaultValue(defaultStr) {
+        defaultStr = defaultStr.trim();
+        if (defaultStr.startsWith('"') && defaultStr.endsWith('"'))
+            return defaultStr.slice(1, -1);
+        if (defaultStr === "true")
+            return true;
+        if (defaultStr === "false")
+            return false;
+        if (/^-?\d+$/.test(defaultStr))
+            return parseInt(defaultStr, 10);
+        if (/^-?\d+\.\d+$/.test(defaultStr))
+            return parseFloat(defaultStr);
+        if (!defaultStr.includes("("))
+            return defaultStr;
+        if (defaultStr.includes("("))
+            return undefined;
+        return defaultStr;
+    }
+    getPrismaSchemasContent() {
+        if (this.prismaSchemasContent)
+            return this.prismaSchemasContent;
+        const models = [];
+        const modelRegex = /model\s+(\w+)\s*{/g;
+        const prismaContent = [];
+        const prismaPath = path_1.default.resolve(process.cwd(), "prisma");
+        const files = this.getAllPrismaFiles(prismaPath);
+        for (const file of files) {
+            const content = fs_1.default.readFileSync(file, "utf-8");
+            if (!prismaContent?.includes?.(content))
+                prismaContent.push(content);
+        }
+        const content = prismaContent
+            .join("\n")
+            .replace(modelRegex, (_, modelName) => {
+            if (!models?.includes?.(modelName))
+                models.push((0, change_case_helpers_1.camelCase)(modelName.trim()));
+            return `model ${modelName} {`;
+        });
+        return content;
+    }
+    getAllPrismaFiles(dirPath, fileList = []) {
+        const files = fs_1.default.readdirSync(dirPath);
+        files?.forEach((file) => {
+            const filePath = path_1.default.join(dirPath, file);
+            const stat = fs_1.default.statSync(filePath);
+            if (stat.isDirectory() && file !== "migrations") {
+                fileList = this.getAllPrismaFiles(filePath, fileList);
+            }
+            else if (stat.isFile() && file.endsWith(".prisma")) {
+                fileList.push(filePath);
+            }
+        });
+        return fileList;
+    }
+    isEnum(typeName) {
+        return this.enums.some((e) => e.name === typeName);
+    }
+    isModel(typeName) {
+        return this.models.some((m) => m.name === typeName);
+    }
+    getModelUniqueFields(modelName) {
+        return this.models
+            .find(({ name }) => (0, change_case_helpers_1.pascalCase)(name) === (0, change_case_helpers_1.pascalCase)(modelName))
+            ?.fields.filter(({ isUnique }) => isUnique);
+    }
+    getModelRelations(modelName) {
+        return this.models
+            .find((model) => (0, change_case_helpers_1.pascalCase)(model.name) === (0, change_case_helpers_1.pascalCase)(modelName))
+            ?.fields.filter((field) => field.isRelation);
+    }
+    getModelsAsArrayOfStrings() {
+        return this.models.map(({ name }) => name);
+    }
+}
+exports.PrismaSchemaParser = PrismaSchemaParser;
+const prismaSchemaParser = new PrismaSchemaParser();
+exports.default = prismaSchemaParser;
+//# sourceMappingURL=prisma-schema-parser.js.map

package/dist/cjs/utils/prisma/types.js

@@ -1 +1,3 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/cjs/utils/sheu.js

@@ -1 +1,120 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});class Sheu{getTimestamp(){return new Date().toTimeString().split(" ")[0]}formatText(t="",e={}){const r=e?.label?t||t===null?e?.label+" ":e?.label:"";let o=`${r}${t}`;if(e.timestamp){const m=this.getTimestamp();if(e.timestamp===!0)o=`${r}\x1B[90m${m}\x1B[0m ${t}`;else if(typeof e.timestamp=="string"){const l=this.getColorCode(e.timestamp);o=`${r}${l}${m}\x1B[0m ${t}`}}return e.bold&&(o=`\x1B[1m${o}\x1B[0m`),o}getColorCode(t){return{red:"\x1B[31m",blue:"\x1B[34m",green:"\x1B[32m",yellow:"\x1B[33m",cyan:"\x1B[36m",magenta:"\x1B[35m",white:"\x1B[37m",black:"\x1B[30m",gray:"\x1B[90m",orange:"\x1B[91m"}[t]||"\x1B[90m"}red(t,e){const r=`\x1B[31m${t}\x1B[0m`;return this.formatText(r,e||{})}blue(t,e){const r=`\x1B[34m${t}\x1B[0m`;return this.formatText(r,e||{})}green(t,e){const r=`\x1B[32m${t}\x1B[0m`;return this.formatText(r,e||{})}yellow(t,e){const r=`\x1B[33m${t}\x1B[0m`;return this.formatText(r,e||{})}cyan(t,e){const r=`\x1B[36m${t}\x1B[0m`;return this.formatText(r,e||{})}magenta(t,e){const r=`\x1B[35m${t}\x1B[0m`;return this.formatText(r,e||{})}white(t,e){const r=`\x1B[37m${t}\x1B[0m`;return this.formatText(r,e||{})}black(t,e){const r=`\x1B[30m${t}\x1B[0m`;return this.formatText(r,e||{})}gray(t,e){const r=`\x1B[90m${t}\x1B[0m`;return this.formatText(r,e||{})}orange(t,e){const r=`\x1B[91m${t}\x1B[0m`;return this.formatText(r,e||{})}bold(t,e){return this.formatText(t,{...e,bold:!0})}info(t,e){const o=this.formatText(t,{...e,label:"[\x1B[36mInfo\x1B[0m]"});return console.info(o),o}error(t,e){const o=this.formatText(t,{...e,label:"[\x1B[31mError\x1B[0m]"});return console.error(o),o}ready(t,e){const o=this.formatText(t,{...e,label:"[\x1B[32mReady\x1B[0m]"});return console.info(o),o}done(t,e){const o=this.formatText(t,{...e,label:"[\x1B[32mDone\x1B[0m]"});return console.info(o),o}warn(t,e){const o=this.formatText(t,{...e,label:"[\x1B[33mWarn\x1B[0m]"});return console.warn(o),o}}const sheu=new Sheu;exports.default=sheu;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Sheu {
+    getTimestamp() {
+        return new Date().toTimeString().split(" ")[0];
+    }
+    formatText(content = "", options = {}) {
+        const label = options?.label
+            ? content
+                ? options?.label + " "
+                : content === null
+                    ? options?.label + " "
+                    : options?.label
+            : "";
+        let result = `${label}${content}`;
+        if (options.timestamp) {
+            const timestamp = this.getTimestamp();
+            if (options.timestamp === true)
+                result = `${label}\x1b[90m${timestamp}\x1b[0m ${content}`;
+            else if (typeof options.timestamp === "string") {
+                const colorCode = this.getColorCode(options.timestamp);
+                result = `${label}${colorCode}${timestamp}\x1b[0m ${content}`;
+            }
+        }
+        if (options.bold)
+            result = `\x1b[1m${result}\x1b[0m`;
+        return result;
+    }
+    getColorCode(color) {
+        const colorMap = {
+            red: "\x1b[31m",
+            blue: "\x1b[34m",
+            green: "\x1b[32m",
+            yellow: "\x1b[33m",
+            cyan: "\x1b[36m",
+            magenta: "\x1b[35m",
+            white: "\x1b[37m",
+            black: "\x1b[30m",
+            gray: "\x1b[90m",
+            orange: "\x1b[91m",
+        };
+        return colorMap[color] || "\x1b[90m";
+    }
+    red(content, options) {
+        const coloredText = `\x1b[31m${content}\x1b[0m`;
+        return this.formatText(coloredText, options || {});
+    }
+    blue(content, options) {
+        const coloredText = `\x1b[34m${content}\x1b[0m`;
+        return this.formatText(coloredText, options || {});
+    }
+    green(content, options) {
+        const coloredText = `\x1b[32m${content}\x1b[0m`;
+        return this.formatText(coloredText, options || {});
+    }
+    yellow(content, options) {
+        const coloredText = `\x1b[33m${content}\x1b[0m`;
+        return this.formatText(coloredText, options || {});
+    }
+    cyan(content, options) {
+        const coloredText = `\x1b[36m${content}\x1b[0m`;
+        return this.formatText(coloredText, options || {});
+    }
+    magenta(content, options) {
+        const coloredText = `\x1b[35m${content}\x1b[0m`;
+        return this.formatText(coloredText, options || {});
+    }
+    white(content, options) {
+        const coloredText = `\x1b[37m${content}\x1b[0m`;
+        return this.formatText(coloredText, options || {});
+    }
+    black(content, options) {
+        const coloredText = `\x1b[30m${content}\x1b[0m`;
+        return this.formatText(coloredText, options || {});
+    }
+    gray(content, options) {
+        const coloredText = `\x1b[90m${content}\x1b[0m`;
+        return this.formatText(coloredText, options || {});
+    }
+    orange(content, options) {
+        const coloredText = `\x1b[91m${content}\x1b[0m`;
+        return this.formatText(coloredText, options || {});
+    }
+    bold(content, options) {
+        return this.formatText(content, { ...options, bold: true });
+    }
+    info(message, options) {
+        const label = `[\x1b[36mInfo\x1b[0m]`;
+        const result = this.formatText(message, { ...options, label });
+        console.info(result);
+        return result;
+    }
+    error(message, options) {
+        const label = `[\x1b[31mError\x1b[0m]`;
+        const result = this.formatText(message, { ...options, label });
+        console.error(result);
+        return result;
+    }
+    ready(message, options) {
+        const label = `[\x1b[32mReady\x1b[0m]`;
+        const result = this.formatText(message, { ...options, label });
+        console.info(result);
+        return result;
+    }
+    done(message, options) {
+        const label = `[\x1b[32mDone\x1b[0m]`;
+        const result = this.formatText(message, { ...options, label });
+        console.info(result);
+        return result;
+    }
+    warn(message, options) {
+        const label = `[\x1b[33mWarn\x1b[0m]`;
+        const result = this.formatText(message, { ...options, label });
+        console.warn(result);
+        return result;
+    }
+}
+const sheu = new Sheu();
+exports.default = sheu;
+//# sourceMappingURL=sheu.js.map

package/dist/cjs/utils/validate-dto.js

@@ -1 +1,17 @@
-"use strict";var __importDefault=this&&this.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0}),exports.default=validateDto;const class_transformer_1=require("class-transformer"),class_validator_1=require("class-validator"),app_error_1=__importDefault(require("../modules/error-handler/utils/app-error"));async function validateDto(e,a,s){const r=(0,class_transformer_1.plainToInstance)(e,a),t=await(0,class_validator_1.validate)(r,s);if(t.length>0)throw new app_error_1.default("Invalid request body",400,t,"InvalidRequestBody");return r}
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = validateDto;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const app_error_1 = __importDefault(require("../modules/error-handler/utils/app-error"));
+async function validateDto(DtoClass, data, validationOptions) {
+    const dataDto = (0, class_transformer_1.plainToInstance)(DtoClass, data);
+    const errors = await (0, class_validator_1.validate)(dataDto, validationOptions);
+    if (errors.length > 0)
+        throw new app_error_1.default("Invalid request body", 400, errors, "InvalidRequestBody");
+    return dataDto;
+}
+//# sourceMappingURL=validate-dto.js.map

package/dist/cjs/utils/validate-schema.js

@@ -1 +1,15 @@
-"use strict";var __importDefault=this&&this.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0}),exports.default=validateSchema;const app_error_1=__importDefault(require("../modules/error-handler/utils/app-error"));async function validateSchema(e,t){const r=e.safeParse(t);if(!r.success)throw new app_error_1.default("Invalid request body",400,r.error.format(),"InvalidRequestBody");return r.data}
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = validateSchema;
+const app_error_1 = __importDefault(require("../modules/error-handler/utils/app-error"));
+async function validateSchema(schema, data) {
+    const result = schema.safeParse(data);
+    if (!result.success) {
+        throw new app_error_1.default("Invalid request body", 400, result.error.format(), "InvalidRequestBody");
+    }
+    return result.data;
+}
+//# sourceMappingURL=validate-schema.js.map

package/dist/esm/app.js

@@ -1 +1,132 @@
-"use strict";import m from"express";import n from"cors";import c from"cookie-parser";import{getAuthRouter as w}from"./modules/auth/auth.router.js";import{getPrismaModelsRouter as f,getAvailableResourcesAndRoutesRouter as R}from"./modules/base/base.router.js";import P from"./modules/error-handler/error-handler.controller.js";import{rateLimit as h}from"express-rate-limit";import y from"compression";import{handleRequestLogs as A}from"./modules/base/base.middlewares.js";import{loadPrismaModule as b}from"./utils/helpers/prisma.helpers.js";import{getFileUploadRouter as q}from"./modules/file-upload/file-upload.router.js";import{queryParser as M}from"./utils/helpers/query-parser.helpers.js";import d from"./utils/helpers/deepmerge.helper.js";import{getSwaggerRouter as O}from"./modules/swagger/swagger.router.js";import{loadAllModuleComponents as E}from"./utils/dynamic-loader.js";export const app=m();export async function bootstrap(e){await Promise.all([b(),E(e),e?.configureApp&&await e?.configureApp(app)]);const p=e?.middlewares,t=p?.disable||[],o=p?.replace||{};t?.includes?.("compression")||app.use(o.compression||y(e?.compressionOptions)),t?.includes?.("global-rate-limit")||app.use(o.globalRateLimit||h(d({windowMs:60*1e3,limit:500,standardHeaders:"draft-7",legacyHeaders:!1,handler:(r,s)=>{s.status(429).json({message:"Too many requests, please try again later"})}},e?.globalRequestRateLimitOptions||{}))),t?.includes?.("cors")||app.use(o.cors||n(e?.cors?.customHandler?e.cors.customHandler:d({origin:(r,s)=>{const l=e?.cors?.allowedOrigins;l==="*"?s(null,!0):Array.isArray(l)?s(null,!r||l?.includes?.(r)):typeof l=="string"?s(null,!r||l===r):s(null,!1)},methods:["GET","POST","PUT","DELETE","PATCH","OPTIONS"],allowedHeaders:["Content-Type","Authorization","Connection"],credentials:!0},e?.cors?.options||{}))),t?.includes?.("express-json")||app.use(o.expressJson||m.json(e?.jsonBodyParserOptions)),t?.includes?.("cookie-parser")||app.use(o.cookieParser||c(...e?.cookieParserParameters||[])),t?.includes?.("query-parser")||app.use(o.queryParser||M(d({parseNull:!0,parseUndefined:!0,parseBoolean:!0},e?.queryParserOptions||{}))),t?.includes?.("request-logger")||app.use(o.requestLogger||A),e?.middlewares?.additional&&e.middlewares.additional.forEach(r=>{app.use(r)});const i=e?.routers,u=i?.disable||[],a=i?.replace||{};if(u?.includes?.("welcome-endpoint")||app.get("/api",a.welcomeEndpoint||((r,s)=>{s.status(200).json({message:e.welcomeMessage})})),!u?.includes?.("file-upload")){const r=a.fileUpload?await a.fileUpload(e):await q(e);app.use(r)}if(!u?.includes?.("auth-router")&&e.authentication){const r=a.authRouter?await a.authRouter(e):await w(e);app.use("/api",r)}if(!u?.includes?.("prisma-models-router")){const r=a.prismaModelsRouter?await a.prismaModelsRouter(e):await f(e);app.use("/api",r)}return app.use("/api",R()),e.swagger&&(process.env.ARKOS_BUILD!=="true"||e.swagger.enableAfterBuild===!0)&&app.use("/api",await O(e)),i?.additional&&i.additional.forEach(r=>{app.use(r)}),t?.includes?.("global-error-handler")||app.use(o.globalErrorHandler||P),app.use("*",(r,s)=>{s.status(404).json({message:"Route not found!"})}),app}
+import express from "express";
+import cors from "cors";
+import cookieParser from "cookie-parser";
+import { getAuthRouter } from "./modules/auth/auth.router.js";
+import { getPrismaModelsRouter, getAvailableResourcesAndRoutesRouter, } from "./modules/base/base.router.js";
+import errorHandler from "./modules/error-handler/error-handler.controller.js";
+import { rateLimit } from "express-rate-limit";
+import compression from "compression";
+import { handleRequestLogs } from "./modules/base/base.middlewares.js";
+import { loadPrismaModule } from "./utils/helpers/prisma.helpers.js";
+import { getFileUploadRouter } from "./modules/file-upload/file-upload.router.js";
+import { queryParser } from "./utils/helpers/query-parser.helpers.js";
+import deepmerge from "./utils/helpers/deepmerge.helper.js";
+import { getSwaggerRouter } from "./modules/swagger/swagger.router.js";
+import { loadAllModuleComponents } from "./utils/dynamic-loader.js";
+export const app = express();
+export async function bootstrap(arkosConfig) {
+    await Promise.all([
+        loadPrismaModule(),
+        loadAllModuleComponents(arkosConfig),
+        arkosConfig?.configureApp && (await arkosConfig?.configureApp(app)),
+    ]);
+    const middlewaresConfig = arkosConfig?.middlewares;
+    const disabledMiddlewares = middlewaresConfig?.disable || [];
+    const replacedMiddlewares = middlewaresConfig?.replace || {};
+    if (!disabledMiddlewares?.includes?.("compression"))
+        app.use(replacedMiddlewares.compression ||
+            compression(arkosConfig?.compressionOptions));
+    if (!disabledMiddlewares?.includes?.("global-rate-limit"))
+        app.use(replacedMiddlewares.globalRateLimit ||
+            rateLimit(deepmerge({
+                windowMs: 60 * 1000,
+                limit: 500,
+                standardHeaders: "draft-7",
+                legacyHeaders: false,
+                handler: (_, res) => {
+                    res.status(429).json({
+                        message: "Too many requests, please try again later",
+                    });
+                },
+            }, arkosConfig?.globalRequestRateLimitOptions || {})));
+    if (!disabledMiddlewares?.includes?.("cors"))
+        app.use(replacedMiddlewares.cors ||
+            cors(arkosConfig?.cors?.customHandler
+                ? arkosConfig.cors.customHandler
+                : deepmerge({
+                    origin: (origin, cb) => {
+                        const allowed = arkosConfig?.cors?.allowedOrigins;
+                        if (allowed === "*") {
+                            cb(null, true);
+                        }
+                        else if (Array.isArray(allowed)) {
+                            cb(null, !origin || allowed?.includes?.(origin));
+                        }
+                        else if (typeof allowed === "string") {
+                            cb(null, !origin || allowed === origin);
+                        }
+                        else {
+                            cb(null, false);
+                        }
+                    },
+                    methods: ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"],
+                    allowedHeaders: [
+                        "Content-Type",
+                        "Authorization",
+                        "Connection",
+                    ],
+                    credentials: true,
+                }, arkosConfig?.cors?.options || {})));
+    if (!disabledMiddlewares?.includes?.("express-json"))
+        app.use(replacedMiddlewares.expressJson ||
+            express.json(arkosConfig?.jsonBodyParserOptions));
+    if (!disabledMiddlewares?.includes?.("cookie-parser"))
+        app.use(replacedMiddlewares.cookieParser ||
+            cookieParser(...[...(arkosConfig?.cookieParserParameters || [])]));
+    if (!disabledMiddlewares?.includes?.("query-parser"))
+        app.use(replacedMiddlewares.queryParser ||
+            queryParser(deepmerge({
+                parseNull: true,
+                parseUndefined: true,
+                parseBoolean: true,
+            }, arkosConfig?.queryParserOptions || {})));
+    if (!disabledMiddlewares?.includes?.("request-logger"))
+        app.use(replacedMiddlewares.requestLogger || handleRequestLogs);
+    if (arkosConfig?.middlewares?.additional)
+        arkosConfig.middlewares.additional.forEach((middleware) => {
+            app.use(middleware);
+        });
+    const routersConfig = arkosConfig?.routers;
+    const disabledRouters = routersConfig?.disable || [];
+    const replacedRouters = routersConfig?.replace || {};
+    if (!disabledRouters?.includes?.("welcome-endpoint"))
+        app.get("/api", replacedRouters.welcomeEndpoint ||
+            ((_, res) => {
+                res.status(200).json({ message: arkosConfig.welcomeMessage });
+            }));
+    if (!disabledRouters?.includes?.("file-upload")) {
+        const fileUploadRouter = replacedRouters.fileUpload
+            ? await replacedRouters.fileUpload(arkosConfig)
+            : await getFileUploadRouter(arkosConfig);
+        app.use(fileUploadRouter);
+    }
+    if (!disabledRouters?.includes?.("auth-router") &&
+        arkosConfig.authentication) {
+        const authRouter = replacedRouters.authRouter
+            ? await replacedRouters.authRouter(arkosConfig)
+            : await getAuthRouter(arkosConfig);
+        app.use("/api", authRouter);
+    }
+    if (!disabledRouters?.includes?.("prisma-models-router")) {
+        const modelsRouter = replacedRouters.prismaModelsRouter
+            ? await replacedRouters.prismaModelsRouter(arkosConfig)
+            : await getPrismaModelsRouter(arkosConfig);
+        app.use("/api", modelsRouter);
+    }
+    app.use("/api", getAvailableResourcesAndRoutesRouter());
+    if (arkosConfig.swagger &&
+        (process.env.ARKOS_BUILD !== "true" ||
+            arkosConfig.swagger.enableAfterBuild === true))
+        app.use("/api", await getSwaggerRouter(arkosConfig));
+    if (routersConfig?.additional)
+        routersConfig.additional.forEach((router) => {
+            app.use(router);
+        });
+    if (!disabledMiddlewares?.includes?.("global-error-handler"))
+        app.use(replacedMiddlewares.globalErrorHandler || errorHandler);
+    app.use("*", (_, res) => {
+        res.status(404).json({ message: "Route not found!" });
+    });
+    return app;
+}
+//# sourceMappingURL=app.js.map

package/dist/esm/exports/auth/index.js

@@ -1 +1,2 @@
-"use strict";export{defaultExcludedUserFields}from"./../../modules/auth/auth.controller.js";
+export { defaultExcludedUserFields } from "./../../modules/auth/auth.controller.js";
+//# sourceMappingURL=index.js.map

package/dist/esm/exports/controllers/index.js

@@ -1 +1,4 @@
-"use strict";import{BaseController as o}from"./../../modules/base/base.controller.js";import r from"../../modules/file-upload/file-upload.controller.js";export{r as fileUploadController,o as BaseController};
+import { BaseController } from "./../../modules/base/base.controller.js";
+import fileUploadController from "../../modules/file-upload/file-upload.controller.js";
+export { fileUploadController, BaseController };
+//# sourceMappingURL=index.js.map

package/dist/esm/exports/error-handler/index.js

@@ -1 +1,4 @@
-"use strict";import r from"../../modules/error-handler/utils/catch-async.js";import o from"../../modules/error-handler/utils/app-error.js";export{r as catchAsync,o as AppError};
+import catchAsync from "../../modules/error-handler/utils/catch-async.js";
+import AppError from "../../modules/error-handler/utils/app-error.js";
+export { catchAsync, AppError };
+//# sourceMappingURL=index.js.map

package/dist/esm/exports/index.js

@@ -1 +1,8 @@
-"use strict";import{BaseController as o}from"./../modules/base/base.controller.js";import{initApp as r,getArkosConfig as t}from"../server.js";const i={init:r};export{o as BaseController,t as getArkosConfig};export default i;
+import { BaseController } from "./../modules/base/base.controller.js";
+import { initApp, getArkosConfig } from "../server.js";
+const arkos = {
+    init: initApp,
+};
+export { BaseController, getArkosConfig, };
+export default arkos;
+//# sourceMappingURL=index.js.map

package/dist/esm/exports/middlewares/index.js

@@ -1 +1,2 @@
-"use strict";export{addPrismaQueryOptionsToRequest,handleRequestBodyValidationAndTransformation}from"../../modules/base/base.middlewares.js";
+export { addPrismaQueryOptionsToRequest, handleRequestBodyValidationAndTransformation, } from "../../modules/base/base.middlewares.js";
+//# sourceMappingURL=index.js.map

package/dist/esm/exports/prisma/index.js

@@ -1 +1,6 @@
-"use strict";import r from"../../utils/prisma/prisma-schema-parser.js";export function getPrismaModels(){return r.models.map(({name:e})=>e)}export{r as prismaSchemaParser};
+import prismaSchemaParser from "../../utils/prisma/prisma-schema-parser.js";
+export function getPrismaModels() {
+    return prismaSchemaParser.models.map(({ name }) => name);
+}
+export { prismaSchemaParser };
+//# sourceMappingURL=index.js.map

package/dist/esm/exports/services/index.js

@@ -1 +1,9 @@
-"use strict";import{getFileUploadServices as e,FileUploadService as r}from"../../modules/file-upload/file-upload.service.js";import i,{AuthService as o}from"../../modules/auth/auth.service.js";import t,{EmailService as m}from"../../modules/email/email.service.js";import{BaseService as p}from"../../modules/base/base.service.js";export{i as authService,o as AuthService};export{p as BaseService};export{t as emailService,m as EmailService};export{e as getFileUploadServices,r as FileUploadService};
+import { getFileUploadServices, FileUploadService, } from "../../modules/file-upload/file-upload.service.js";
+import authService, { AuthService } from "../../modules/auth/auth.service.js";
+import emailService, { EmailService } from "../../modules/email/email.service.js";
+import { BaseService } from "../../modules/base/base.service.js";
+export { authService, AuthService };
+export { BaseService, };
+export { emailService, EmailService };
+export { getFileUploadServices, FileUploadService };
+//# sourceMappingURL=index.js.map

package/dist/esm/exports/utils/index.js

@@ -1 +1,4 @@
-"use strict";export*from"../../utils/helpers/change-case.helpers.js";import r,{apiFeatures as e}from"../../utils/features/api.features.js";export{r as APIFeatures,e as apiFeatures};
+export * from "../../utils/helpers/change-case.helpers.js";
+import APIFeatures, { apiFeatures } from "../../utils/features/api.features.js";
+export { APIFeatures, apiFeatures };
+//# sourceMappingURL=index.js.map

package/dist/esm/exports/validation/index.js

@@ -1 +1,4 @@
-"use strict";import o from"../../utils/validate-dto.js";import t from"../../utils/validate-schema.js";export{o as validateDto,t as validateSchema};
+import validateDto from "../../utils/validate-dto.js";
+import validateSchema from "../../utils/validate-schema.js";
+export { validateDto, validateSchema };
+//# sourceMappingURL=index.js.map