arkos 1.3.1-beta → 1.3.2-beta

package/dist/esm/utils/dynamic-loader.js

@@ -1,9 +1,254 @@
-"use strict";import{z as b}from"zod";import h from"path";import{killServerChildProcess as p}from"./cli/utils/cli.helpers.js";import g from"./sheu.js";import{applyStrictRoutingRules as v,pathExists as d}from"./helpers/dynamic-loader.helpers.js";import{kebabCase as $,pascalCase as y}from"./helpers/change-case.helpers.js";import{crd as C,getUserFileExtension as P}from"./helpers/fs.helpers.js";import{importModule as x}from"./helpers/global.helpers.js";import S from"./prisma/prisma-schema-parser.js";let M={};export function setModuleComponents(o,t){M[y(o)]=t}export function getModuleComponents(o){return M[y(o)]}export function getFileModuleComponentsFileStructure(o){const t=$(o).toLowerCase(),r=o.toLowerCase()==="auth",e=P();return{core:{hooks:`${t}.hooks.${e}`,interceptors:`${t}.middlewares.${e}`,authConfigs:`${t}.auth-configs.${e}`,authConfigsNew:`${t}.auth.${e}`,prismaQueryOptions:`${t}.prisma-query-options.${e}`,prismaQueryOptionsNew:`${t}.query.${e}`,router:`${t}.router.${e}`},dtos:r?{login:`login.dto.${e}`,signup:`signup.dto.${e}`,getMe:`get-me.dto.${e}`,updateMe:`update-me.dto.${e}`,updatePassword:`update-password.dto.${e}`}:{model:`${t}.dto.${e}`,create:`create-${t}.dto.${e}`,createOne:`create-${t}.dto.${e}`,createMany:"",update:`update-${t}.dto.${e}`,updateOne:`update-${t}.dto.${e}`,updateMany:"",query:`query-${t}.dto.${e}`,findOne:"",findMany:""},schemas:r?{login:`login.schema.${e}`,signup:`signup.schema.${e}`,getMe:`get-me.schema.${e}`,updateMe:`update-me.schema.${e}`,updatePassword:`update-password.schema.${e}`}:{model:`${t}.schema.${e}`,create:`create-${t}.schema.${e}`,createOne:`create-${t}.schema.${e}`,createMany:"",update:`update-${t}.schema.${e}`,updateOne:`update-${t}.schema.${e}`,updateMany:"",query:`query-${t}.schema.${e}`,findOne:"",findMany:""}}}export function isClass(o){return typeof o=="function"&&/^class\s/.test(Function.prototype.toString.call(o))}export function isZodSchema(o){return o instanceof b.ZodType}export async function processSubdir(o,t){const r=h.resolve(C(),"src","modules",$(o)),e=h.join(r,t),a=getFileModuleComponentsFileStructure(o),f={};if(!await d(e))return f;try{await Promise.all(Object.entries(a[t]).map(async([u,s])=>{const m=h.join(e,s);if(!(!s||!await d(m)))try{const n=await x(m).catch(async l=>{await d(m)&&(g.error(`Failed to import ${s}: `),console.error(l),p(),process.exit(1))}),i=`src/modules/${$(o)}/${s}`;if(t==="dtos"&&!isClass(n?.default))throw Error(`ValidationError: Please export as default a valid class under ${i}, in order to use as Dto.`);if(t==="schemas"&&!isZodSchema(n?.default))throw Error(`ValidationError: Please export as default a valid zod schema under ${i}, in order to use as Schema`);n&&n?.default&&(f[u]=n.default)}catch(n){if(n?.message?.includes("ValidationError"))throw n;console.error(n)}}))}catch(u){if(u?.message?.includes("ValidationError"))throw u;console.error(u)}return f}export function validateNamingConventions(o,t,r){if(o==="prismaQueryOptions"){if(g.warn(`Found ${t} which will be deprecated from 1.4.0-beta, consider switching to ${t.replace("prisma-query-options","query")}.`),r.prismaQueryOptions)throw p(),new Error(`
- Cannot use both ${t} and ${t.replace("prisma-query-options","query")} at once, please choose only one name convention. 
-`)}else if(o==="prismaQueryOptionsNew"){if(r.prismaQueryOptions)throw p(),new Error(`
- Cannot use both ${t} and ${t.replace("query","prisma-query-options")} at once, please choose only one name convention. 
-`)}else if(o==="authConfigs"){if(g.warn(`Found ${t} which will be deprecated from 1.4.0-beta, consider switching to ${t.replace("auth-configs","auth")}.`),r.authConfigs)throw p(),new Error(`
- Cannot use both ${t} and ${t.replace("auth-configs","auth")} at once, please choose only one name convention. 
-`)}else if(o==="authConfigsNew"&&r.authConfigs)throw p(),new Error(`
- Cannot use both ${t} and ${t.replace("auth","auth-configs")} at once, please choose only one name convention. 
-`)}export function assignModuleToResult(o,t,r,e,a){t==="prismaQueryOptions"||t==="prismaQueryOptionsNew"?e.prismaQueryOptions=r.default||r:t==="authConfigs"||t==="authConfigsNew"?e.authConfigs=r.default||r:t==="interceptors"?e[t]=r:t==="router"?e[t]={...r,config:v(o,a,r?.config||{})}:e[t]=r.default||r}export async function importModuleComponents(o,t,r){const e={dtos:{},schemas:{}},a=t.routers?.strict;if(!r&&!a)return e;if(getModuleComponents(o))return getModuleComponents(o);const f=h.resolve(C(),"src","modules",$(o)),u=getFileModuleComponentsFileStructure(o),s=t.validation?.resolver?t.validation.resolver==="zod"?"schemas":"dtos":null,[m,n]=await Promise.all([Object.entries(u.core).map(async([i,l])=>{if(["createMany","findMany","findOne","updateMany"].includes(i)||!l)return;const w=h.join(f,l);if(!(i==="router"&&!a&&!await d(w))&&!(i!=="router"&&a&&!await d(w)))try{let c=await x(w).catch(async O=>{try{await d(w)&&(g.error(`Failed to import ${l}`),console.error(O),p(),process.exit(1))}catch{}});!c&&i==="router"&&a&&(c={}),c&&(validateNamingConventions(i,l,e),assignModuleToResult(o,i,c,e,t))}catch(c){if(c.message?.includes("Cannot use both"))throw c;console.error(c),p()}}),s&&processSubdir(o,s)]);return M[y(o)]={...e,...s&&{[s]:n}},{...e,...s&&{[s]:n}}}export const appModules=Array.from(new Set([...S.getModelsAsArrayOfStrings(),"auth","file-upload"]));export async function loadAllModuleComponents(o){const t=[];await Promise.all(appModules.map(async e=>{const a=h.resolve(C(),"src","modules",$(e));await d(a)&&t.push(e)}));const r=appModules.map(async e=>await importModuleComponents(e,o,t.includes(e)));await Promise.all(r)}
+import { z } from "zod";
+import path from "path";
+import { killServerChildProcess } from "./cli/utils/cli.helpers.js";
+import sheu from "./sheu.js";
+import { applyStrictRoutingRules, pathExists, } from "./helpers/dynamic-loader.helpers.js";
+import { kebabCase, pascalCase } from "./helpers/change-case.helpers.js";
+import { crd, getUserFileExtension } from "./helpers/fs.helpers.js";
+import { importModule } from "./helpers/global.helpers.js";
+import prismaSchemaParser from "./prisma/prisma-schema-parser.js";
+let prismaModelsModules = {};
+export function setModuleComponents(modelName, modules) {
+    prismaModelsModules[pascalCase(modelName)] = modules;
+}
+export function getModuleComponents(modelName) {
+    return prismaModelsModules[pascalCase(modelName)];
+}
+export function getFileModuleComponentsFileStructure(modelName) {
+    const kebabModelName = kebabCase(modelName).toLowerCase();
+    const isAuthModule = modelName.toLowerCase() === "auth";
+    const ext = getUserFileExtension();
+    return {
+        core: {
+            hooks: `${kebabModelName}.hooks.${ext}`,
+            interceptors: `${kebabModelName}.middlewares.${ext}`,
+            authConfigs: `${kebabModelName}.auth-configs.${ext}`,
+            authConfigsNew: `${kebabModelName}.auth.${ext}`,
+            prismaQueryOptions: `${kebabModelName}.prisma-query-options.${ext}`,
+            prismaQueryOptionsNew: `${kebabModelName}.query.${ext}`,
+            router: `${kebabModelName}.router.${ext}`,
+        },
+        dtos: isAuthModule
+            ? {
+                login: `login.dto.${ext}`,
+                signup: `signup.dto.${ext}`,
+                getMe: `get-me.dto.${ext}`,
+                updateMe: `update-me.dto.${ext}`,
+                updatePassword: `update-password.dto.${ext}`,
+            }
+            : {
+                model: `${kebabModelName}.dto.${ext}`,
+                create: `create-${kebabModelName}.dto.${ext}`,
+                createOne: `create-${kebabModelName}.dto.${ext}`,
+                createMany: ``,
+                update: `update-${kebabModelName}.dto.${ext}`,
+                updateOne: `update-${kebabModelName}.dto.${ext}`,
+                updateMany: ``,
+                query: `query-${kebabModelName}.dto.${ext}`,
+                findOne: ``,
+                findMany: ``,
+            },
+        schemas: isAuthModule
+            ? {
+                login: `login.schema.${ext}`,
+                signup: `signup.schema.${ext}`,
+                getMe: `get-me.schema.${ext}`,
+                updateMe: `update-me.schema.${ext}`,
+                updatePassword: `update-password.schema.${ext}`,
+            }
+            : {
+                model: `${kebabModelName}.schema.${ext}`,
+                create: `create-${kebabModelName}.schema.${ext}`,
+                createOne: `create-${kebabModelName}.schema.${ext}`,
+                createMany: ``,
+                update: `update-${kebabModelName}.schema.${ext}`,
+                updateOne: `update-${kebabModelName}.schema.${ext}`,
+                updateMany: ``,
+                query: `query-${kebabModelName}.schema.${ext}`,
+                findOne: ``,
+                findMany: ``,
+            },
+    };
+}
+export function isClass(value) {
+    return (typeof value === "function" &&
+        /^class\s/.test(Function.prototype.toString.call(value)));
+}
+export function isZodSchema(value) {
+    return value instanceof z.ZodType;
+}
+export async function processSubdir(modelName, type) {
+    const moduleDir = path.resolve(crd(), "src", "modules", kebabCase(modelName));
+    const subdir = path.join(moduleDir, type);
+    const fileStructure = getFileModuleComponentsFileStructure(modelName);
+    const result = {};
+    if (!(await pathExists(subdir)))
+        return result;
+    try {
+        await Promise.all(Object.entries(fileStructure[type]).map(async ([key, fileName]) => {
+            const filePath = path.join(subdir, fileName);
+            if (!fileName || !(await pathExists(filePath)))
+                return;
+            try {
+                const module = await importModule(filePath).catch(async (err) => {
+                    if (await pathExists(filePath)) {
+                        sheu.error(`Failed to import ${fileName}: `);
+                        console.error(err);
+                        killServerChildProcess();
+                        process.exit(1);
+                    }
+                });
+                const cleanFilePath = `src/modules/${kebabCase(modelName)}/${fileName}`;
+                if (type === "dtos" && !isClass(module?.default))
+                    throw Error(`ValidationError: Please export as default a valid class under ${cleanFilePath}, in order to use as Dto.`);
+                else if (type === "schemas" && !isZodSchema(module?.default))
+                    throw Error(`ValidationError: Please export as default a valid zod schema under ${cleanFilePath}, in order to use as Schema`);
+                if (module && module?.default)
+                    result[key] = module.default;
+            }
+            catch (err) {
+                if (err?.message?.includes("ValidationError"))
+                    throw err;
+                console.error(err);
+            }
+        }));
+    }
+    catch (err) {
+        if (err?.message?.includes("ValidationError"))
+            throw err;
+        console.error(err);
+    }
+    return result;
+}
+export function validateNamingConventions(key, fileName, result) {
+    if (key === "prismaQueryOptions") {
+        sheu.warn(`Found ${fileName} which will be deprecated from 1.4.0-beta, consider switching to ${fileName.replace("prisma-query-options", "query")}.`);
+        if (result.prismaQueryOptions) {
+            killServerChildProcess();
+            throw new Error(`\n Cannot use both ${fileName} and ${fileName.replace("prisma-query-options", "query")} at once, please choose only one name convention. \n`);
+        }
+    }
+    else if (key === "prismaQueryOptionsNew") {
+        if (result.prismaQueryOptions) {
+            killServerChildProcess();
+            throw new Error(`\n Cannot use both ${fileName} and ${fileName.replace("query", "prisma-query-options")} at once, please choose only one name convention. \n`);
+        }
+    }
+    else if (key === "authConfigs") {
+        sheu.warn(`Found ${fileName} which will be deprecated from 1.4.0-beta, consider switching to ${fileName.replace("auth-configs", "auth")}.`);
+        if (result.authConfigs) {
+            killServerChildProcess();
+            throw new Error(`\n Cannot use both ${fileName} and ${fileName.replace("auth-configs", "auth")} at once, please choose only one name convention. \n`);
+        }
+    }
+    else if (key === "authConfigsNew") {
+        if (result.authConfigs) {
+            killServerChildProcess();
+            throw new Error(`\n Cannot use both ${fileName} and ${fileName.replace("auth", "auth-configs")} at once, please choose only one name convention. \n`);
+        }
+    }
+}
+export function assignModuleToResult(appModule, key, module, result, arkosConfig) {
+    if (key === "prismaQueryOptions" || key === "prismaQueryOptionsNew") {
+        result.prismaQueryOptions = module.default || module;
+    }
+    else if (key === "authConfigs" || key === "authConfigsNew") {
+        result.authConfigs = module.default || module;
+    }
+    else if (key === "interceptors") {
+        result[key] = module;
+    }
+    else if (key === "router") {
+        result[key] = {
+            ...module,
+            config: applyStrictRoutingRules(appModule, arkosConfig, module?.config || {}),
+        };
+    }
+    else {
+        result[key] = module.default || module;
+    }
+}
+export async function importModuleComponents(modelName, arkosConfig, moduleDirExists) {
+    const result = {
+        dtos: {},
+        schemas: {},
+    };
+    const usingStrictRouting = arkosConfig.routers?.strict;
+    if (!moduleDirExists && !usingStrictRouting)
+        return result;
+    if (getModuleComponents(modelName))
+        return getModuleComponents(modelName);
+    const moduleDir = path.resolve(crd(), "src", "modules", kebabCase(modelName));
+    const fileStructure = getFileModuleComponentsFileStructure(modelName);
+    const validationSubdir = arkosConfig.validation?.resolver
+        ? arkosConfig.validation.resolver === "zod"
+            ? "schemas"
+            : "dtos"
+        : null;
+    const [_, validators] = await Promise.all([
+        Object.entries(fileStructure.core).map(async ([key, fileName]) => {
+            if (["createMany", "findMany", "findOne", "updateMany"].includes(key) ||
+                !fileName)
+                return;
+            const filePath = path.join(moduleDir, fileName);
+            if (key === "router" &&
+                !usingStrictRouting &&
+                !(await pathExists(filePath)))
+                return;
+            else if (key !== "router" &&
+                usingStrictRouting &&
+                !(await pathExists(filePath)))
+                return;
+            try {
+                let module = await importModule(filePath).catch(async (err) => {
+                    try {
+                        if (await pathExists(filePath)) {
+                            sheu.error(`Failed to import ${fileName}`);
+                            console.error(err);
+                            killServerChildProcess();
+                            process.exit(1);
+                        }
+                    }
+                    catch (err) { }
+                });
+                if (!module && key === "router" && usingStrictRouting)
+                    module = {};
+                if (module) {
+                    validateNamingConventions(key, fileName, result);
+                    assignModuleToResult(modelName, key, module, result, arkosConfig);
+                }
+            }
+            catch (err) {
+                if (err.message?.includes("Cannot use both"))
+                    throw err;
+                console.error(err);
+                killServerChildProcess();
+            }
+        }),
+        validationSubdir && processSubdir(modelName, validationSubdir),
+    ]);
+    prismaModelsModules[pascalCase(modelName)] = {
+        ...result,
+        ...(validationSubdir && { [validationSubdir]: validators }),
+    };
+    return {
+        ...result,
+        ...(validationSubdir && { [validationSubdir]: validators }),
+    };
+}
+export const appModules = Array.from(new Set([
+    ...prismaSchemaParser.getModelsAsArrayOfStrings(),
+    "auth",
+    "file-upload",
+]));
+export async function loadAllModuleComponents(arkosConfig) {
+    const moduleDirExists = [];
+    await Promise.all(appModules.map(async (appModule) => {
+        const moduleDir = path.resolve(crd(), "src", "modules", kebabCase(appModule));
+        if (await pathExists(moduleDir))
+            moduleDirExists.push(appModule);
+    }));
+    const modulesComponentsImportPromises = appModules.map(async (appModule) => await importModuleComponents(appModule, arkosConfig, moduleDirExists.includes(appModule)));
+    await Promise.all(modulesComponentsImportPromises);
+}
+//# sourceMappingURL=dynamic-loader.js.map

package/dist/esm/utils/features/api.features.js

@@ -1 +1,162 @@
-"use strict";import l from"../helpers/deepmerge.helper.js";import{parseQueryParamsWithModifiers as c}from"../helpers/api.features.helpers.js";import f from"../../modules/error-handler/utils/app-error.js";import{getPrismaInstance as m}from"../helpers/prisma.helpers.js";export default class d{constructor(s,e){if(this.filters={},this.reqFiltersSearchParam={},this.excludedFields=["page","filters","sort","limit","fields","addFields","removeFields","search","include","filterMode","where","prismaQueryOptions","ignoredFields"],s){const{filters:r="{}",...h}=s.query;this.req=s,this.searchParams=l(c(h),c(JSON.parse(r))),s.finalPrismaQueryOptions=this.searchParams}e&&(this.modelName=e),this.filters={...this.filters}}setup(s,e){if(s){const{filters:r="{}",...h}=s.query;this.req=s,this.searchParams=l(c(h),c(JSON.parse(r))),s.finalPrismaQueryOptions=this.searchParams}return e&&(this.modelName=e),this.filters={...this.filters},this}filter(){if(!this.req)throw new Error("Trying to use APIFeatures.filter() without passing request on class constructor or APIFeatures.setup() method. read more about at www.arkosjs.com/docs/advanced-guide/api-features-class");const s=[],e={...this.searchParams};this.excludedFields.forEach(a=>delete e[a]);const r={...this.req.params,...e},h=Object.keys(r).map(a=>({[a]:r[a]}));let i=h.length>0?{[this.req.query?.filterMode??"OR"]:h}:{};if(this.searchParams.search){const a=m();this.modelName&&Object.keys(a[this.modelName].fields).forEach(o=>{const n=a[this.modelName].fields[o];n?.typeName==="String"&&o!=="id"&&o!=="password"&&!n.isList&&!o?.includes?.("Id")&&!o?.includes?.("ID")&&s.push({[`${o}`]:{contains:this.searchParams.search,mode:"insensitive"}})}),i=l({OR:s},i)}const t=l({where:i},this.req.prismaQueryOptions||{});return this.filters=l(t,this.filters),this}search(){this.searchParams?.search&&(this.filters=l(this.filters,{where:{OR:[]}}))}sort(){if(this.searchParams.sort){const s=this.searchParams?.sort?.split(",")?.map(e=>({[e.startsWith("-")?e.substring(1):e]:e.startsWith("-")?"desc":"asc"}));this.filters=l(this.filters,{orderBy:s})}return this}limitFields(){if(this.searchParams?.fields){const s=this.searchParams.fields.split(","),e=s.filter(t=>!t.startsWith("+")&&!t.startsWith("-")),r=s.filter(t=>t.startsWith("+")).map(t=>t.substring(1)),h=s.filter(t=>t.startsWith("-")).map(t=>t.substring(1));let i={};e.length>0?i=e.reduce((t,a)=>(t[a]=!0,t),{}):(i=this.filters.include||{},r.forEach(t=>{i[t]=!0}),h.forEach(t=>{i[t]=!1})),this.filters={...this.filters,select:i},this.filters.include&&delete this.filters.include}if(this.searchParams?.addFields||this.searchParams?.removeFields)throw new f("The addFields and removeFields parameters are deprecated. Please use fields with + and - prefixes instead.",400);return this}paginate(){const s=parseInt(this.searchParams.page,10)||1,e=parseInt(this.searchParams.limit,10)||30,r=(s-1)*e;return this.filters={...this.filters,skip:r,take:e},this}}export const apiFeatures=new d;
+import deepmerge from "../helpers/deepmerge.helper.js";
+import { parseQueryParamsWithModifiers } from "../helpers/api.features.helpers.js";
+import AppError from "../../modules/error-handler/utils/app-error.js";
+import { getPrismaInstance } from "../helpers/prisma.helpers.js";
+export default class APIFeatures {
+    constructor(req, modelName) {
+        this.filters = {};
+        this.reqFiltersSearchParam = {};
+        this.excludedFields = [
+            "page",
+            "filters",
+            "sort",
+            "limit",
+            "fields",
+            "addFields",
+            "removeFields",
+            "search",
+            "include",
+            "filterMode",
+            "where",
+            "prismaQueryOptions",
+            "ignoredFields",
+        ];
+        if (req) {
+            const { filters = "{}", ...restOfQuery } = req.query;
+            this.req = req;
+            this.searchParams = deepmerge(parseQueryParamsWithModifiers(restOfQuery), parseQueryParamsWithModifiers(JSON.parse(filters)));
+            req.finalPrismaQueryOptions = this.searchParams;
+        }
+        if (modelName)
+            this.modelName = modelName;
+        this.filters = { ...this.filters };
+    }
+    setup(req, modelName) {
+        if (req) {
+            const { filters = "{}", ...restOfQuery } = req.query;
+            this.req = req;
+            this.searchParams = deepmerge(parseQueryParamsWithModifiers(restOfQuery), parseQueryParamsWithModifiers(JSON.parse(filters)));
+            req.finalPrismaQueryOptions = this.searchParams;
+        }
+        if (modelName)
+            this.modelName = modelName;
+        this.filters = { ...this.filters };
+        return this;
+    }
+    filter() {
+        if (!this.req)
+            throw new Error("Trying to use APIFeatures.filter() without passing request on class constructor or APIFeatures.setup() method. read more about at www.arkosjs.com/docs/advanced-guide/api-features-class");
+        const searchableFields = [];
+        const queryObj = { ...this.searchParams };
+        this.excludedFields.forEach((el) => delete queryObj[el]);
+        const whereObj = { ...this.req.params, ...queryObj };
+        const whereLogicalOperatorFilters = Object.keys(whereObj).map((key) => ({
+            [key]: whereObj[key],
+        }));
+        let whereOptions = whereLogicalOperatorFilters.length > 0
+            ? {
+                [this.req.query?.filterMode ?? "OR"]: whereLogicalOperatorFilters,
+            }
+            : {};
+        if (!!this.searchParams.search) {
+            const prisma = getPrismaInstance();
+            if (this.modelName)
+                Object.keys(prisma[this.modelName].fields).forEach((key) => {
+                    const field = prisma[this.modelName].fields[key];
+                    if (field?.typeName === "String" &&
+                        key !== "id" &&
+                        key !== "password" &&
+                        !field.isList &&
+                        !key?.includes?.("Id") &&
+                        !key?.includes?.("ID")) {
+                        searchableFields.push({
+                            [`${key}`]: {
+                                contains: this.searchParams.search,
+                                mode: "insensitive",
+                            },
+                        });
+                    }
+                });
+            whereOptions = deepmerge({
+                OR: searchableFields,
+            }, whereOptions);
+        }
+        const firstMerge = deepmerge({
+            where: whereOptions,
+        }, this.req.prismaQueryOptions || {});
+        this.filters = deepmerge(firstMerge, this.filters);
+        return this;
+    }
+    search() {
+        if (this.searchParams?.search) {
+            this.filters = deepmerge(this.filters, {
+                where: {
+                    OR: [],
+                },
+            });
+        }
+    }
+    sort() {
+        if (this.searchParams.sort) {
+            const sortBy = this.searchParams?.sort
+                ?.split(",")
+                ?.map((field) => ({
+                [field.startsWith("-") ? field.substring(1) : field]: field.startsWith("-") ? "desc" : "asc",
+            }));
+            this.filters = deepmerge(this.filters, { orderBy: sortBy });
+        }
+        return this;
+    }
+    limitFields() {
+        if (this.searchParams?.fields) {
+            const fields = this.searchParams.fields.split(",");
+            const regularFields = fields.filter((field) => !field.startsWith("+") && !field.startsWith("-"));
+            const includeFields = fields
+                .filter((field) => field.startsWith("+"))
+                .map((field) => field.substring(1));
+            const excludeFields = fields
+                .filter((field) => field.startsWith("-"))
+                .map((field) => field.substring(1));
+            let selection = {};
+            if (regularFields.length > 0) {
+                selection = regularFields.reduce((acc, field) => {
+                    acc[field] = true;
+                    return acc;
+                }, {});
+            }
+            else {
+                selection = this.filters.include || {};
+                includeFields.forEach((field) => {
+                    selection[field] = true;
+                });
+                excludeFields.forEach((field) => {
+                    selection[field] = false;
+                });
+            }
+            this.filters = {
+                ...this.filters,
+                select: selection,
+            };
+            if (this.filters.include) {
+                delete this.filters.include;
+            }
+        }
+        if (this.searchParams?.addFields || this.searchParams?.removeFields) {
+            throw new AppError("The addFields and removeFields parameters are deprecated. Please use fields with + and - prefixes instead.", 400);
+        }
+        return this;
+    }
+    paginate() {
+        const page = parseInt(this.searchParams.page, 10) || 1;
+        const limit = parseInt(this.searchParams.limit, 10) || 30;
+        const skip = (page - 1) * limit;
+        this.filters = {
+            ...this.filters,
+            skip,
+            take: limit,
+        };
+        return this;
+    }
+}
+export const apiFeatures = new APIFeatures();
+//# sourceMappingURL=api.features.js.map

package/dist/esm/utils/features/change-case.features.js

@@ -1 +1,31 @@
-"use strict";import*as e from"../helpers/change-case.helpers.js";const u=t=>t!==null&&typeof t=="object";function a(t){return function r(s,c=1,o){if(c===0||!u(s))return s;if(Array.isArray(s))return s.map(n=>r(n,c-1,o));const C=Object.create(Object.getPrototypeOf(s));return Object.keys(s).forEach(n=>{const p=s[n],l=t(n,o),x=r(p,c-1,o);C[l]=x}),C}}export const camelCase=a(e.camelCase),capitalCase=a(e.capitalCase),constantCase=a(e.constantCase),dotCase=a(e.dotCase),trainCase=a(e.trainCase),noCase=a(e.noCase),kebabCase=a(e.kebabCase),pascalCase=a(e.pascalCase),pathCase=a(e.pathCase),sentenceCase=a(e.sentenceCase),snakeCase=a(e.snakeCase);
+import * as changeCase from "../helpers/change-case.helpers.js";
+const isObject = (object) => object !== null && typeof object === "object";
+function changeKeysFactory(changeCase) {
+    return function changeKeys(object, depth = 1, options) {
+        if (depth === 0 || !isObject(object))
+            return object;
+        if (Array.isArray(object)) {
+            return object.map((item) => changeKeys(item, depth - 1, options));
+        }
+        const result = Object.create(Object.getPrototypeOf(object));
+        Object.keys(object).forEach((key) => {
+            const value = object[key];
+            const changedKey = changeCase(key, options);
+            const changedValue = changeKeys(value, depth - 1, options);
+            result[changedKey] = changedValue;
+        });
+        return result;
+    };
+}
+export const camelCase = changeKeysFactory(changeCase.camelCase);
+export const capitalCase = changeKeysFactory(changeCase.capitalCase);
+export const constantCase = changeKeysFactory(changeCase.constantCase);
+export const dotCase = changeKeysFactory(changeCase.dotCase);
+export const trainCase = changeKeysFactory(changeCase.trainCase);
+export const noCase = changeKeysFactory(changeCase.noCase);
+export const kebabCase = changeKeysFactory(changeCase.kebabCase);
+export const pascalCase = changeKeysFactory(changeCase.pascalCase);
+export const pathCase = changeKeysFactory(changeCase.pathCase);
+export const sentenceCase = changeKeysFactory(changeCase.sentenceCase);
+export const snakeCase = changeKeysFactory(changeCase.snakeCase);
+//# sourceMappingURL=change-case.features.js.map

package/dist/esm/utils/features/port-and-host-allocator.js

@@ -1 +1,67 @@
-"use strict";import*as l from"net";import i from"../sheu.js";class c{constructor(){this.prevWarnings=new Set}getCorrectHostAndPortToUse(o,s){const r=o?.CLI_HOST||s?.host||o?.HOST||"localhost",n=o?.CLI_PORT||s?.port||o?.PORT||"8000";return{host:String(r),port:String(n)}}async getHostAndAvailablePort(o,s){if(this.port&&this.host)return s?.logWarning&&this.prevWarnings.size>0&&(console.info(""),Array.from(this.prevWarnings).forEach(e=>i.warn(e))),{port:this.port,host:this.host};const{host:r,port:n}=this.getCorrectHostAndPortToUse(o,s);let t=parseInt(n,10);for(;;){if(await this.isPortAvailable(r,t))return this.port=t.toString(),this.host=r,{host:r,port:t.toString()};const a=`Port ${t} is in use, trying port ${t+1} instead...`;this.prevWarnings.add(a),s?.logWarning&&i.warn(`${a}`),t++}}async isPortAvailable(o,s){return new Promise(r=>{const n=["localhost","127.0.0.1"].includes(o)?"localhost":o,t=l.createConnection({host:n,port:s,timeout:100});t.on("connect",()=>{t.destroy(),r(!1)}),t.on("error",()=>{r(!0)}),t.on("timeout",()=>{t.destroy(),r(!0)})})}logWarnings(){console.info(""),Array.from(this.prevWarnings).forEach(o=>i.warn(o))}}const h=new c;export default h;
+import * as net from "net";
+import sheu from "../sheu.js";
+class PortAndHostAllocator {
+    constructor() {
+        this.prevWarnings = new Set();
+    }
+    getCorrectHostAndPortToUse(env, config) {
+        const host = env?.CLI_HOST || config?.host || env?.HOST || "localhost";
+        const port = env?.CLI_PORT || config?.port || env?.PORT || "8000";
+        return { host: String(host), port: String(port) };
+    }
+    async getHostAndAvailablePort(env, config) {
+        if (this.port && this.host) {
+            if (config?.logWarning && this.prevWarnings.size > 0) {
+                console.info("");
+                Array.from(this.prevWarnings).forEach((msg) => sheu.warn(msg));
+            }
+            return { port: this.port, host: this.host };
+        }
+        const { host, port: initialPort } = this.getCorrectHostAndPortToUse(env, config);
+        let currentPort = parseInt(initialPort, 10);
+        while (true) {
+            const isAvailable = await this.isPortAvailable(host, currentPort);
+            if (isAvailable) {
+                this.port = currentPort.toString();
+                this.host = host;
+                return { host, port: currentPort.toString() };
+            }
+            const msg = `Port ${currentPort} is in use, trying port ${currentPort + 1} instead...`;
+            this.prevWarnings.add(msg);
+            if (config?.logWarning) {
+                sheu.warn(`${msg}`);
+            }
+            currentPort++;
+        }
+    }
+    async isPortAvailable(host, port) {
+        return new Promise((resolve) => {
+            const actualHost = !["localhost", "127.0.0.1"].includes(host)
+                ? host
+                : "localhost";
+            const socket = net.createConnection({
+                host: actualHost,
+                port,
+                timeout: 100,
+            });
+            socket.on("connect", () => {
+                socket.destroy();
+                resolve(false);
+            });
+            socket.on("error", () => {
+                resolve(true);
+            });
+            socket.on("timeout", () => {
+                socket.destroy();
+                resolve(true);
+            });
+        });
+    }
+    logWarnings() {
+        console.info("");
+        Array.from(this.prevWarnings).forEach((msg) => sheu.warn(msg));
+    }
+}
+const portAndHostAllocator = new PortAndHostAllocator();
+export default portAndHostAllocator;
+//# sourceMappingURL=port-and-host-allocator.js.map

package/dist/esm/utils/helpers/api.features.helpers.js

@@ -1 +1,106 @@
-"use strict";import h from"./deepmerge.helper.js";const F={dateFields:["createdAt","updatedAt","deletedAt","date"],booleanFields:["isActive","isDeleted","isPublished","isArchived"],numericFields:["age","price","quantity","amount","rating"]};export function parseQueryParamsWithModifiers(s,r=F){const c=Object.entries(JSON.parse(JSON.stringify(s)));let p={};for(const[f,n]of c){const e=f.split("__");if(!n&&n!==!1&&n!=="false"&&e.length<2)continue;const t=Array.isArray(n)?n[0]?.toString():n;let o={};if(e.length<2)o[f]=typeof n=="string"&&!Number.isNaN(n)?d(t,e[0],r):n;else{const l=e[0];if(l==="orderBy"&&e.length===2)o.orderBy={},o.orderBy[e[1]]=t;else if(e.length===1)o[l]={equals:d(t,l,r)};else{let m={},i=m,a=l;for(let u=1;u<e.length-1;u++)i[a]={},i=i[a],a=e[u];const b=e[e.length-1];switch(b){case"icontains":i[a]={contains:t,mode:"insensitive"};break;case"contains":i[a]={contains:t,mode:"sensitive"};break;case"in":case"notIn":i[a]={[b]:t.split(",").map(y=>d(y.trim(),l,r))};break;case"or":const u=t.split(",");m.OR=u.map(y=>({[l]:{equals:d(y.trim(),l,r)}}));break;case"isNull":i[a]={equals:t.toLowerCase()==="true"?null:void 0};break;case"isEmpty":i[a]={equals:t.toLowerCase()==="true"?"":void 0};break;default:i[a]={[b]:d(t,l,r)}}o=m}}p=h(p,o)}return p}function d(s,r,c){return c.dateFields?.includes?.(r)&&s?new Date(s):c.booleanFields?.includes?.(r)&&s?s.toLowerCase()==="true":c.numericFields?.includes?.(r)&&s?Number(s):s}
+import deepmerge from "./deepmerge.helper.js";
+const DEFAULT_FIELD_CONFIG = {
+    dateFields: ["createdAt", "updatedAt", "deletedAt", "date"],
+    booleanFields: ["isActive", "isDeleted", "isPublished", "isArchived"],
+    numericFields: ["age", "price", "quantity", "amount", "rating"],
+};
+export function parseQueryParamsWithModifiers(query, fieldConfig = DEFAULT_FIELD_CONFIG) {
+    const entries = Object.entries(JSON.parse(JSON.stringify(query)));
+    let result = {};
+    for (const [key, value] of entries) {
+        const parts = key.split("__");
+        if (!value && value !== false && value !== "false" && parts.length < 2)
+            continue;
+        const stringValue = Array.isArray(value) ? value[0]?.toString() : value;
+        let currentResult = {};
+        if (parts.length < 2) {
+            currentResult[key] =
+                typeof value === "string" && !Number.isNaN(value)
+                    ? convertValue(stringValue, parts[0], fieldConfig)
+                    : value;
+        }
+        else {
+            const fieldName = parts[0];
+            if (fieldName === "orderBy" && parts.length === 2) {
+                currentResult.orderBy = {};
+                currentResult.orderBy[parts[1]] = stringValue;
+            }
+            else if (parts.length === 1) {
+                currentResult[fieldName] = {
+                    equals: convertValue(stringValue, fieldName, fieldConfig),
+                };
+            }
+            else {
+                let nestedObj = {};
+                let currentLevel = nestedObj;
+                let currentKey = fieldName;
+                for (let i = 1; i < parts.length - 1; i++) {
+                    currentLevel[currentKey] = {};
+                    currentLevel = currentLevel[currentKey];
+                    currentKey = parts[i];
+                }
+                const lastOperator = parts[parts.length - 1];
+                switch (lastOperator) {
+                    case "icontains":
+                        currentLevel[currentKey] = {
+                            contains: stringValue,
+                            mode: "insensitive",
+                        };
+                        break;
+                    case "contains":
+                        currentLevel[currentKey] = {
+                            contains: stringValue,
+                            mode: "sensitive",
+                        };
+                        break;
+                    case "in":
+                    case "notIn":
+                        currentLevel[currentKey] = {
+                            [lastOperator]: stringValue
+                                .split(",")
+                                .map((v) => convertValue(v.trim(), fieldName, fieldConfig)),
+                        };
+                        break;
+                    case "or":
+                        const values = stringValue.split(",");
+                        nestedObj.OR = values.map((val) => ({
+                            [fieldName]: {
+                                equals: convertValue(val.trim(), fieldName, fieldConfig),
+                            },
+                        }));
+                        break;
+                    case "isNull":
+                        currentLevel[currentKey] = {
+                            equals: stringValue.toLowerCase() === "true" ? null : undefined,
+                        };
+                        break;
+                    case "isEmpty":
+                        currentLevel[currentKey] = {
+                            equals: stringValue.toLowerCase() === "true" ? "" : undefined,
+                        };
+                        break;
+                    default:
+                        currentLevel[currentKey] = {
+                            [lastOperator]: convertValue(stringValue, fieldName, fieldConfig),
+                        };
+                }
+                currentResult = nestedObj;
+            }
+        }
+        result = deepmerge(result, currentResult);
+    }
+    return result;
+}
+function convertValue(value, fieldName, config) {
+    if (config.dateFields?.includes?.(fieldName) && value) {
+        return new Date(value);
+    }
+    if (config.booleanFields?.includes?.(fieldName) && value) {
+        return value.toLowerCase() === "true";
+    }
+    if (config.numericFields?.includes?.(fieldName) && value) {
+        return Number(value);
+    }
+    return value;
+}
+//# sourceMappingURL=api.features.helpers.js.map