arkos 1.3.1-beta → 1.3.2-beta

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

@@ -1 +1,161 @@
-"use strict";const d=/([\p{Ll}\d])(\p{Lu})/gu,_=/(\p{Lu})([\p{Lu}][\p{Ll}])/gu,E=/(\d)\p{Ll}|(\p{L})\d/u,h=/[^\p{L}\d]+/giu,m="$1\0$2",L="";export function split(r){let e=r.trim();e=e.replace(d,m).replace(_,m),e=e.replace(h,"\0");let t=0,c=e.length;for(;e.charAt(t)==="\0";)t++;if(t===c)return[];for(;e.charAt(c-1)==="\0";)c--;return e.slice(t,c).split(/\0/g)}export function splitSeparateNumbers(r){const e=split(r);for(let t=0;t<e.length;t++){const c=e[t],n=E.exec(c);if(n){const a=n.index+(n[1]??n[2]).length;e.splice(t,1,c.slice(0,a),c.slice(a))}}return e}export function noCase(r,e){const[t,c,n]=o(r,e);return t+c.map(u(e?.locale)).join(e?.delimiter??" ")+n}export function camelCase(r,e){const[t,c,n]=o(r,e),a=u(e?.locale),s=f(e?.locale),i=e?.mergeAmbiguousCharacters?x(a,s):C(a,s);return t+c.map((l,p)=>p===0?a(l):i(l,p)).join(e?.delimiter??"")+n}export function pascalCase(r,e){const[t,c,n]=o(r,e),a=u(e?.locale),s=f(e?.locale),i=e?.mergeAmbiguousCharacters?x(a,s):C(a,s);return t+c.map(i).join(e?.delimiter??"")+n}export function pascalSnakeCase(r,e){return capitalCase(r,{delimiter:"_",...e})}export function capitalCase(r,e){const[t,c,n]=o(r,e),a=u(e?.locale),s=f(e?.locale);return t+c.map(x(a,s)).join(e?.delimiter??" ")+n}export function constantCase(r,e){const[t,c,n]=o(r,e);return t+c.map(f(e?.locale)).join(e?.delimiter??"_")+n}export function dotCase(r,e){return noCase(r,{delimiter:".",...e})}export function kebabCase(r,e){return noCase(r,{delimiter:"-",...e})}export function pathCase(r,e){return noCase(r,{delimiter:"/",...e})}export function sentenceCase(r,e){const[t,c,n]=o(r,e),a=u(e?.locale),s=f(e?.locale),i=x(a,s);return t+c.map((l,p)=>p===0?i(l):a(l)).join(e?.delimiter??" ")+n}export function snakeCase(r,e){return noCase(r,{delimiter:"_",...e})}export function trainCase(r,e){return capitalCase(r,{delimiter:"-",...e})}function u(r){return r===!1?e=>e.toLowerCase():e=>e.toLocaleLowerCase(r)}function f(r){return r===!1?e=>e.toUpperCase():e=>e.toLocaleUpperCase(r)}function x(r,e){return t=>`${e(t[0])}${r(t.slice(1))}`}function C(r,e){return(t,c)=>{const n=t[0];return(c>0&&n>="0"&&n<="9"?"_"+n:e(n))+r(t.slice(1))}}function o(r,e={}){const t=e.split??(e.separateNumbers?splitSeparateNumbers:split),c=e.prefixCharacters??"",n=e.suffixCharacters??"";let a=0,s=r.length;for(;a<r.length;){const i=r.charAt(a);if(!c?.includes?.(i))break;a++}for(;s>a;){const i=s-1,l=r.charAt(i);if(!n?.includes?.(l))break;s=i}return[r.slice(0,a),t(r.slice(a,s)),r.slice(s)]}
+const SPLIT_LOWER_UPPER_RE = /([\p{Ll}\d])(\p{Lu})/gu;
+const SPLIT_UPPER_UPPER_RE = /(\p{Lu})([\p{Lu}][\p{Ll}])/gu;
+const SPLIT_SEPARATE_NUMBER_RE = /(\d)\p{Ll}|(\p{L})\d/u;
+const DEFAULT_STRIP_REGEXP = /[^\p{L}\d]+/giu;
+const SPLIT_REPLACE_VALUE = "$1\0$2";
+const DEFAULT_PREFIX_SUFFIX_CHARACTERS = "";
+export function split(value) {
+    let result = value.trim();
+    result = result
+        .replace(SPLIT_LOWER_UPPER_RE, SPLIT_REPLACE_VALUE)
+        .replace(SPLIT_UPPER_UPPER_RE, SPLIT_REPLACE_VALUE);
+    result = result.replace(DEFAULT_STRIP_REGEXP, "\0");
+    let start = 0;
+    let end = result.length;
+    while (result.charAt(start) === "\0")
+        start++;
+    if (start === end)
+        return [];
+    while (result.charAt(end - 1) === "\0")
+        end--;
+    return result.slice(start, end).split(/\0/g);
+}
+export function splitSeparateNumbers(value) {
+    const words = split(value);
+    for (let i = 0; i < words.length; i++) {
+        const word = words[i];
+        const match = SPLIT_SEPARATE_NUMBER_RE.exec(word);
+        if (match) {
+            const offset = match.index + (match[1] ?? match[2]).length;
+            words.splice(i, 1, word.slice(0, offset), word.slice(offset));
+        }
+    }
+    return words;
+}
+export function noCase(input, options) {
+    const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+    return (prefix +
+        words.map(lowerFactory(options?.locale)).join(options?.delimiter ?? " ") +
+        suffix);
+}
+export function camelCase(input, options) {
+    const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    const transform = options?.mergeAmbiguousCharacters
+        ? capitalCaseTransformFactory(lower, upper)
+        : pascalCaseTransformFactory(lower, upper);
+    return (prefix +
+        words
+            .map((word, index) => {
+            if (index === 0)
+                return lower(word);
+            return transform(word, index);
+        })
+            .join(options?.delimiter ?? "") +
+        suffix);
+}
+export function pascalCase(input, options) {
+    const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    const transform = options?.mergeAmbiguousCharacters
+        ? capitalCaseTransformFactory(lower, upper)
+        : pascalCaseTransformFactory(lower, upper);
+    return prefix + words.map(transform).join(options?.delimiter ?? "") + suffix;
+}
+export function pascalSnakeCase(input, options) {
+    return capitalCase(input, { delimiter: "_", ...options });
+}
+export function capitalCase(input, options) {
+    const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    return (prefix +
+        words
+            .map(capitalCaseTransformFactory(lower, upper))
+            .join(options?.delimiter ?? " ") +
+        suffix);
+}
+export function constantCase(input, options) {
+    const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+    return (prefix +
+        words.map(upperFactory(options?.locale)).join(options?.delimiter ?? "_") +
+        suffix);
+}
+export function dotCase(input, options) {
+    return noCase(input, { delimiter: ".", ...options });
+}
+export function kebabCase(input, options) {
+    return noCase(input, { delimiter: "-", ...options });
+}
+export function pathCase(input, options) {
+    return noCase(input, { delimiter: "/", ...options });
+}
+export function sentenceCase(input, options) {
+    const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    const transform = capitalCaseTransformFactory(lower, upper);
+    return (prefix +
+        words
+            .map((word, index) => {
+            if (index === 0)
+                return transform(word);
+            return lower(word);
+        })
+            .join(options?.delimiter ?? " ") +
+        suffix);
+}
+export function snakeCase(input, options) {
+    return noCase(input, { delimiter: "_", ...options });
+}
+export function trainCase(input, options) {
+    return capitalCase(input, { delimiter: "-", ...options });
+}
+function lowerFactory(locale) {
+    return locale === false
+        ? (input) => input.toLowerCase()
+        : (input) => input.toLocaleLowerCase(locale);
+}
+function upperFactory(locale) {
+    return locale === false
+        ? (input) => input.toUpperCase()
+        : (input) => input.toLocaleUpperCase(locale);
+}
+function capitalCaseTransformFactory(lower, upper) {
+    return (word) => `${upper(word[0])}${lower(word.slice(1))}`;
+}
+function pascalCaseTransformFactory(lower, upper) {
+    return (word, index) => {
+        const char0 = word[0];
+        const initial = index > 0 && char0 >= "0" && char0 <= "9" ? "_" + char0 : upper(char0);
+        return initial + lower(word.slice(1));
+    };
+}
+function splitPrefixSuffix(input, options = {}) {
+    const splitFn = options.split ?? (options.separateNumbers ? splitSeparateNumbers : split);
+    const prefixCharacters = options.prefixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
+    const suffixCharacters = options.suffixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
+    let prefixIndex = 0;
+    let suffixIndex = input.length;
+    while (prefixIndex < input.length) {
+        const char = input.charAt(prefixIndex);
+        if (!prefixCharacters?.includes?.(char))
+            break;
+        prefixIndex++;
+    }
+    while (suffixIndex > prefixIndex) {
+        const index = suffixIndex - 1;
+        const char = input.charAt(index);
+        if (!suffixCharacters?.includes?.(char))
+            break;
+        suffixIndex = index;
+    }
+    return [
+        input.slice(0, prefixIndex),
+        splitFn(input.slice(prefixIndex, suffixIndex)),
+        input.slice(suffixIndex),
+    ];
+}
+//# sourceMappingURL=change-case.helpers.js.map

package/dist/esm/utils/helpers/deepmerge.helper.js

@@ -1 +1,113 @@
-"use strict";function f(e){return a(e)&&!o(e)}function a(e){return!!e&&typeof e=="object"}function o(e){const r=Object.prototype.toString.call(e);return r==="[object RegExp]"||r==="[object Date]"}function b(e){return Array.isArray(e)?[]:{}}function i(e){const r=Object.keys(e),n=O(e);return[...r,...n]}function O(e){return Object.getOwnPropertySymbols?Object.getOwnPropertySymbols(e).filter(function(r){return Object.propertyIsEnumerable.call(e,r)}):[]}function y(e,r){return r.clone!==!1&&r.isMergeableObject?.(e)?s(b(e),e,r):e}function g(e,r,n){return e.concat(r).map(function(t){return n.cloneUnlessOtherwiseSpecified(t,n)})}function j(e,r){if(!r.customMerge)return s;const n=r.customMerge(e);return typeof n=="function"?n:s}function l(e,r){try{return r in e}catch{return!1}}function m(e,r){return l(e,r)&&!(Object.hasOwnProperty.call(e,r)&&Object.propertyIsEnumerable.call(e,r))}function d(e,r,n){const t={};return n.isMergeableObject?.(e)&&i(e).forEach(function(c){t[c]=n.cloneUnlessOtherwiseSpecified?n.cloneUnlessOtherwiseSpecified(e[c],n):e[c]}),i(r).forEach(function(c){m(e,c)||(l(e,c)&&n.isMergeableObject?.(r[c])?t[c]=j(c,n)(e[c],r[c],n):t[c]=n.cloneUnlessOtherwiseSpecified?n.cloneUnlessOtherwiseSpecified(r[c],n):r[c])}),t}function s(e,r,n){n=n||{};const t={arrayMerge:n.arrayMerge||g,isMergeableObject:n.isMergeableObject||f,cloneUnlessOtherwiseSpecified:n.cloneUnlessOtherwiseSpecified||y,clone:n.clone,customMerge:n.customMerge},c=Array.isArray(r),u=Array.isArray(e);return c===u?c?t.arrayMerge?.(e,r,t):d(e,r,t):t.cloneUnlessOtherwiseSpecified(r,t)}function M(e,r){if(!Array.isArray(e))throw new Error("first argument should be an array");return e.reduce((n,t)=>s(n,t,r),{})}s.all=M;export default s;
+function isMergeableObject(value) {
+    return isNonNullObject(value) && !isSpecial(value);
+}
+function isNonNullObject(value) {
+    return !!value && typeof value === "object";
+}
+function isSpecial(value) {
+    const stringValue = Object.prototype.toString.call(value);
+    return stringValue === "[object RegExp]" || stringValue === "[object Date]";
+}
+function emptyTarget(val) {
+    return Array.isArray(val) ? [] : {};
+}
+function getKeys(target) {
+    const objectKeys = Object.keys(target);
+    const symbolKeys = getEnumerableOwnPropertySymbols(target);
+    return [...objectKeys, ...symbolKeys];
+}
+function getEnumerableOwnPropertySymbols(target) {
+    return Object.getOwnPropertySymbols
+        ? Object.getOwnPropertySymbols(target).filter(function (symbol) {
+            return Object.propertyIsEnumerable.call(target, symbol);
+        })
+        : [];
+}
+function cloneUnlessOtherwiseSpecified(value, options) {
+    return options.clone !== false && options.isMergeableObject?.(value)
+        ? deepmerge(emptyTarget(value), value, options)
+        : value;
+}
+function defaultArrayMerge(target, source, options) {
+    return target.concat(source).map(function (element) {
+        return options.cloneUnlessOtherwiseSpecified(element, options);
+    });
+}
+function getMergeFunction(key, options) {
+    if (!options.customMerge) {
+        return deepmerge;
+    }
+    const customMerge = options.customMerge(key);
+    return typeof customMerge === "function" ? customMerge : deepmerge;
+}
+function propertyIsOnObject(object, property) {
+    try {
+        return property in object;
+    }
+    catch (_) {
+        return false;
+    }
+}
+function propertyIsUnsafe(target, key) {
+    return (propertyIsOnObject(target, key) &&
+        !(Object.hasOwnProperty.call(target, key) &&
+            Object.propertyIsEnumerable.call(target, key)));
+}
+function mergeObject(target, source, options) {
+    const destination = {};
+    if (options.isMergeableObject?.(target)) {
+        getKeys(target).forEach(function (key) {
+            destination[key] = options.cloneUnlessOtherwiseSpecified
+                ? options.cloneUnlessOtherwiseSpecified(target[key], options)
+                : target[key];
+        });
+    }
+    getKeys(source).forEach(function (key) {
+        if (propertyIsUnsafe(target, key)) {
+            return;
+        }
+        if (propertyIsOnObject(target, key) &&
+            options.isMergeableObject?.(source[key])) {
+            destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
+        }
+        else {
+            destination[key] = options.cloneUnlessOtherwiseSpecified
+                ? options.cloneUnlessOtherwiseSpecified(source[key], options)
+                : source[key];
+        }
+    });
+    return destination;
+}
+function deepmerge(target, source, options) {
+    options = options || {};
+    const mergeOptions = {
+        arrayMerge: options.arrayMerge || defaultArrayMerge,
+        isMergeableObject: options.isMergeableObject || isMergeableObject,
+        cloneUnlessOtherwiseSpecified: options.cloneUnlessOtherwiseSpecified || cloneUnlessOtherwiseSpecified,
+        clone: options.clone,
+        customMerge: options.customMerge,
+    };
+    const sourceIsArray = Array.isArray(source);
+    const targetIsArray = Array.isArray(target);
+    const sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
+    if (!sourceAndTargetTypesMatch) {
+        return mergeOptions.cloneUnlessOtherwiseSpecified(source, mergeOptions);
+    }
+    else if (sourceIsArray) {
+        return mergeOptions.arrayMerge?.(target, source, mergeOptions);
+    }
+    else {
+        return mergeObject(target, source, mergeOptions);
+    }
+}
+function deepmergeAll(array, options) {
+    if (!Array.isArray(array)) {
+        throw new Error("first argument should be an array");
+    }
+    return array.reduce((prev, next) => {
+        return deepmerge(prev, next, options);
+    }, {});
+}
+deepmerge.all = deepmergeAll;
+export default deepmerge;
+//# sourceMappingURL=deepmerge.helper.js.map

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

@@ -1 +1,69 @@
-"use strict";import i from"fs";export function applyStrictRoutingRules(t,r,a){const u=r?.routers?.strict||!1,e=a||{};return t=t.toLowerCase(),u===!0?{...e,disable:typeof e.disable=="boolean"?e.disable:t==="auth"?{getMe:!0,updateMe:!0,deleteMe:!0,login:!0,logout:!0,signup:!0,updatePassword:!0,findManyAuthAction:!0,...typeof e.disable=="object"?e.disable:{}}:t==="file-upload"?{findFile:!0,uploadFile:!0,updateFile:!0,deleteFile:!0,...typeof e.disable=="object"?e.disable:{}}:{createOne:!0,findOne:!0,updateOne:!0,deleteOne:!0,createMany:!0,findMany:!0,updateMany:!0,deleteMany:!0,...typeof e.disable=="object"?e.disable:{}}}:u==="no-bulk"&&!["auth","file-upload"].includes(t.toLowerCase())?{...e,disable:typeof e.disable=="boolean"?e.disable:{createMany:!0,updateMany:!0,deleteMany:!0,...typeof e.disable=="object"?e.disable:{}}}:e}export async function pathExists(t){try{return await i.promises.stat(t),!0}catch{return!1}}
+import fs from "fs";
+export function applyStrictRoutingRules(appModule, arkosConfig, moduleConfig) {
+    const strictMode = arkosConfig?.routers?.strict || false;
+    const config = moduleConfig || {};
+    appModule = appModule.toLowerCase();
+    if (strictMode === true) {
+        return {
+            ...config,
+            disable: typeof config.disable === "boolean"
+                ? config.disable
+                : appModule === "auth"
+                    ? {
+                        getMe: true,
+                        updateMe: true,
+                        deleteMe: true,
+                        login: true,
+                        logout: true,
+                        signup: true,
+                        updatePassword: true,
+                        findManyAuthAction: true,
+                        ...(typeof config.disable === "object" ? config.disable : {}),
+                    }
+                    : appModule === "file-upload"
+                        ? {
+                            findFile: true,
+                            uploadFile: true,
+                            updateFile: true,
+                            deleteFile: true,
+                            ...(typeof config.disable === "object" ? config.disable : {}),
+                        }
+                        : {
+                            createOne: true,
+                            findOne: true,
+                            updateOne: true,
+                            deleteOne: true,
+                            createMany: true,
+                            findMany: true,
+                            updateMany: true,
+                            deleteMany: true,
+                            ...(typeof config.disable === "object" ? config.disable : {}),
+                        },
+        };
+    }
+    else if (strictMode === "no-bulk" &&
+        !["auth", "file-upload"].includes(appModule.toLowerCase())) {
+        return {
+            ...config,
+            disable: typeof config.disable === "boolean"
+                ? config.disable
+                : {
+                    createMany: true,
+                    updateMany: true,
+                    deleteMany: true,
+                    ...(typeof config.disable === "object" ? config.disable : {}),
+                },
+        };
+    }
+    return config;
+}
+export async function pathExists(path) {
+    try {
+        await fs.promises.stat(path);
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+}
+//# sourceMappingURL=dynamic-loader.helpers.js.map

package/dist/esm/utils/helpers/fs.helpers.js

@@ -1 +1,48 @@
-"use strict";import r from"fs";import t from"path";export const crd=()=>process.env.ARKOS_BUILD==="true"?process.cwd()+"/.build/":process.cwd();export function fullCleanCwd(s){if(typeof s!="string")throw new Error("Path must be a string");const e=process.cwd().replace(/\/+$/,"").replace(/[.*+?^${}()|[\]\\]/g,"\\$&");return s.replace(new RegExp(`${e}/?`,"g"),"")}export let userFileExtension;export const getUserFileExtension=()=>{if(userFileExtension)return userFileExtension;try{const s=process.cwd(),c=r.existsSync(t.join(s,"tsconfig.json")),e=r.existsSync(t.join(s,"src","app.ts")),n=r.existsSync(t.join(s,"src","app.js"));return process.env.ARKOS_BUILD==="true"?userFileExtension="js":c&&e||e&&!n?userFileExtension="ts":userFileExtension="js",userFileExtension}catch{return userFileExtension="js",userFileExtension}};export function checkFileExists(s){try{return r.existsSync(t.resolve(s))}catch{return!1}}
+import fs from "fs";
+import path from "path";
+export const crd = () => process.env.ARKOS_BUILD === "true"
+    ? process.cwd() + "/.build/"
+    : process.cwd();
+export function fullCleanCwd(path) {
+    if (typeof path !== "string")
+        throw new Error("Path must be a string");
+    const cwd = process.cwd().replace(/\/+$/, "");
+    const escapedCwd = cwd.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return path.replace(new RegExp(`${escapedCwd}/?`, "g"), "");
+}
+export let userFileExtension;
+export const getUserFileExtension = () => {
+    if (userFileExtension)
+        return userFileExtension;
+    try {
+        const currentDir = process.cwd();
+        const hasTsConfig = fs.existsSync(path.join(currentDir, "tsconfig.json"));
+        const hasAppTs = fs.existsSync(path.join(currentDir, "src", "app.ts"));
+        const hasAppJs = fs.existsSync(path.join(currentDir, "src", "app.js"));
+        const isBuildMode = process.env.ARKOS_BUILD === "true";
+        if (isBuildMode)
+            userFileExtension = "js";
+        else if (hasTsConfig && hasAppTs)
+            userFileExtension = "ts";
+        else if (hasAppTs && !hasAppJs)
+            userFileExtension = "ts";
+        else if (hasAppJs)
+            userFileExtension = "js";
+        else
+            userFileExtension = "js";
+        return userFileExtension;
+    }
+    catch (e) {
+        userFileExtension = "js";
+        return userFileExtension;
+    }
+};
+export function checkFileExists(filePath) {
+    try {
+        return fs.existsSync(path.resolve(filePath));
+    }
+    catch (error) {
+        return false;
+    }
+}
+//# sourceMappingURL=fs.helpers.js.map

package/dist/esm/utils/helpers/global.helpers.js

@@ -1 +1,51 @@
-"use strict";import e from"fs";import i from"path";import{createRequire as c}from"module";import{pathToFileURL as t}from"url";export function getPackageJson(){try{const n=i.join(process.cwd(),"package.json");if(e.existsSync(n))return JSON.parse(e.readFileSync(n,"utf8"))}catch(n){console.error("Error checking package.json:",n)}}export function isEsm(){return getPackageJson()?.type==="module"}const s=c(t(process.cwd()+"/package.json"));export async function importModule(n,r={fixExtension:!0}){if(!r.fixExtension||n.endsWith(".ts")||!isEsm())return await import(n);const o=s.resolve(n);return await import(t(o))}export async function importEsmPreventingTsTransformation(n){return await new Function("path","return import(path)")(n)}export function detectPackageManagerFromUserAgent(){const n=process.env.npm_config_user_agent||"";return n?n.includes("cnpm")?"cnpm":n.includes("pnpm")?"pnpm":n.includes("yarn")?"yarn":n.includes("npm")?"npm":n.includes("bun")?"bun":n.includes("corepack")?"corepack":n.includes("deno")?"deno":"npm":"npm"}
+import fs from "fs";
+import path from "path";
+import { createRequire } from "module";
+import { pathToFileURL } from "url";
+export function getPackageJson() {
+    try {
+        const pkgPath = path.join(process.cwd(), "package.json");
+        if (fs.existsSync(pkgPath)) {
+            return JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        }
+    }
+    catch (err) {
+        console.error("Error checking package.json:", err);
+    }
+}
+export function isEsm() {
+    const pkg = getPackageJson();
+    return pkg?.type === "module";
+}
+const userRequire = createRequire(pathToFileURL(process.cwd() + "/package.json"));
+export async function importModule(modulePath, options = { fixExtension: true }) {
+    if (!options.fixExtension || modulePath.endsWith(".ts") || !isEsm())
+        return await import(modulePath);
+    const resolved = userRequire.resolve(modulePath);
+    return await import(pathToFileURL(resolved));
+}
+export async function importEsmPreventingTsTransformation(path) {
+    const importFn = new Function("path", "return import(path)");
+    return await importFn(path);
+}
+export function detectPackageManagerFromUserAgent() {
+    const userAgent = process.env.npm_config_user_agent || "";
+    if (!userAgent)
+        return "npm";
+    if (userAgent.includes("cnpm"))
+        return "cnpm";
+    if (userAgent.includes("pnpm"))
+        return "pnpm";
+    if (userAgent.includes("yarn"))
+        return "yarn";
+    if (userAgent.includes("npm"))
+        return "npm";
+    if (userAgent.includes("bun"))
+        return "bun";
+    if (userAgent.includes("corepack"))
+        return "corepack";
+    if (userAgent.includes("deno"))
+        return "deno";
+    return "npm";
+}
+//# sourceMappingURL=global.helpers.js.map

package/dist/esm/utils/helpers/prisma.helpers.js

@@ -1 +1,32 @@
-"use strict";import o from"fs";import i from"../../modules/error-handler/utils/app-error.js";import{crd as s,getUserFileExtension as t}from"./fs.helpers.js";import{importModule as n}from"./global.helpers.js";export let prismaInstance=null;export async function loadPrismaModule(){if(!prismaInstance)try{let r=`${s()}/src/utils/prisma.${t()}`;if(o.existsSync(r)||(r=`${s()}/src/utils/prisma/index.${t()}`),!o.existsSync(r))throw new Error(`Could not found exported prisma insteance at ${r}`);const e=await n(r,{fixExtension:!1});if(prismaInstance=e.default||e.prisma,!prismaInstance)throw new Error("Prisma not found")}catch(r){throw r.message==="Prisma not found"?new i(`Could not initialize Prisma module. Make sure your prisma instance is exported under src/utils/prisma.${t()} or src/utils/prisma/index.${t()}, read more about Arkos.js Project Structure under https://www.arkosjs.com/docs/getting-started/project-structure#utilities-directory`,500,{},"PrismaInstanceNotFound"):r}return prismaInstance}export function getPrismaInstance(){return prismaInstance}
+import fs from "fs";
+import AppError from "../../modules/error-handler/utils/app-error.js";
+import { crd, getUserFileExtension as ext } from "./fs.helpers.js";
+import { importModule } from "./global.helpers.js";
+export let prismaInstance = null;
+export async function loadPrismaModule() {
+    if (!prismaInstance) {
+        try {
+            let prismaPath = `${crd()}/src/utils/prisma.${ext()}`;
+            if (!fs.existsSync(prismaPath))
+                prismaPath = `${crd()}/src/utils/prisma/index.${ext()}`;
+            if (!fs.existsSync(prismaPath))
+                throw new Error(`Could not found exported prisma insteance at ${prismaPath}`);
+            const prismaModule = await importModule(prismaPath, {
+                fixExtension: false,
+            });
+            prismaInstance = prismaModule.default || prismaModule.prisma;
+            if (!prismaInstance)
+                throw new Error("Prisma not found");
+        }
+        catch (error) {
+            if (error.message === "Prisma not found")
+                throw new AppError(`Could not initialize Prisma module. Make sure your prisma instance is exported under src/utils/prisma.${ext()} or src/utils/prisma/index.${ext()}, read more about Arkos.js Project Structure under https://www.arkosjs.com/docs/getting-started/project-structure#utilities-directory`, 500, {}, "PrismaInstanceNotFound");
+            throw error;
+        }
+    }
+    return prismaInstance;
+}
+export function getPrismaInstance() {
+    return prismaInstance;
+}
+//# sourceMappingURL=prisma.helpers.js.map

package/dist/esm/utils/helpers/query-parser.helpers.js

@@ -1 +1,40 @@
-"use strict";export const parse=(e,r)=>{switch(typeof e){case"string":return e===""?"":r.parseNull&&e==="null"?null:r.parseUndefined&&e==="undefined"?void 0:r.parseBoolean&&(e==="true"||e==="false")?e==="true":r.parseNumber&&!isNaN(Number(e))?Number(e):e;case"object":if(Array.isArray(e))return e.map(u=>parse(u,r));{const u=e;return Object.keys(u).map(s=>u[s]=parse(e[s],r)),u}default:return e}},queryParser=e=>(r,u,s)=>{r.query=parse(r.query,e),s()};
+export const parse = (target, options) => {
+    switch (typeof target) {
+        case "string":
+            if (target === "") {
+                return "";
+            }
+            else if (options.parseNull && target === "null") {
+                return null;
+            }
+            else if (options.parseUndefined && target === "undefined") {
+                return undefined;
+            }
+            else if (options.parseBoolean &&
+                (target === "true" || target === "false")) {
+                return target === "true";
+            }
+            else if (options.parseNumber && !isNaN(Number(target))) {
+                return Number(target);
+            }
+            else {
+                return target;
+            }
+        case "object":
+            if (Array.isArray(target)) {
+                return target.map((x) => parse(x, options));
+            }
+            else {
+                const obj = target;
+                Object.keys(obj).map((key) => (obj[key] = parse(target[key], options)));
+                return obj;
+            }
+        default:
+            return target;
+    }
+};
+export const queryParser = (options) => (req, res, next) => {
+    req.query = parse(req.query, options);
+    next();
+};
+//# sourceMappingURL=query-parser.helpers.js.map

package/dist/esm/utils/helpers/routers.helpers.js

@@ -1 +1,29 @@
-"use strict";import c from"../../modules/error-handler/utils/catch-async.js";function n(t){if(t&&typeof t!="function")throw Error(`Validation Error: Invalid interceptor of type ${typeof t}, they must be a function or an array of function. checkout https://arkosjs.com/docs/core-concepts/interceptor-middlewares`)}export const safeCatchAsync=(t,o={type:"normal"})=>{if(t&&typeof t!="function")throw Error(`Validation Error: Invalid interceptor of type ${typeof t}, they must be a function or an array of function. checkout https://arkosjs.com/docs/core-concepts/interceptor-middlewares`);return t?c(t,o):void 0},processMiddleware=(t,o={type:"normal"})=>t?Array.isArray(t)?t.filter(r=>!!r).map(r=>(n(r),safeCatchAsync(r,o))):(n(t),[safeCatchAsync(t,o)]):[];
+import catchAsync from "../../modules/error-handler/utils/catch-async.js";
+function throwErrorIfInterceptorIsNotAFunction(middleware) {
+    if (middleware && typeof middleware !== "function") {
+        throw Error(`Validation Error: Invalid interceptor of type ${typeof middleware}, they must be a function or an array of function. checkout https://arkosjs.com/docs/core-concepts/interceptor-middlewares`);
+    }
+}
+export const safeCatchAsync = (middleware, options = { type: "normal" }) => {
+    if (middleware && typeof middleware !== "function") {
+        throw Error(`Validation Error: Invalid interceptor of type ${typeof middleware}, they must be a function or an array of function. checkout https://arkosjs.com/docs/core-concepts/interceptor-middlewares`);
+    }
+    return middleware ? catchAsync(middleware, options) : undefined;
+};
+export const processMiddleware = (middleware, options = { type: "normal" }) => {
+    if (!middleware)
+        return [];
+    if (Array.isArray(middleware)) {
+        return middleware
+            .filter((mw) => !!mw)
+            .map((mw) => {
+            throwErrorIfInterceptorIsNotAFunction(mw);
+            return safeCatchAsync(mw, options);
+        });
+    }
+    else {
+        throwErrorIfInterceptorIsNotAFunction(middleware);
+        return [safeCatchAsync(middleware, options)];
+    }
+};
+//# sourceMappingURL=routers.helpers.js.map

package/dist/esm/utils/helpers/text.helpers.js

@@ -1 +1,22 @@
-"use strict";export function capitalize(e){return e?e.split(" ").map(n=>n.charAt(0).toUpperCase()+n.slice(1).toLowerCase()).join(" "):""}export function removeBeginningSlash(e){return e.startsWith("/")?e.substring(1):e}export function removeEndingSlash(e){return e.endsWith("/")?e.substring(0,e.length-1):e}export function removeBothSlashes(e){return removeEndingSlash(removeBeginningSlash(e))}
+export function capitalize(text) {
+    if (!text)
+        return "";
+    return text
+        .split(" ")
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join(" ");
+}
+export function removeBeginningSlash(str) {
+    if (str.startsWith("/"))
+        return str.substring(1);
+    return str;
+}
+export function removeEndingSlash(str) {
+    if (str.endsWith("/"))
+        return str.substring(0, str.length - 1);
+    return str;
+}
+export function removeBothSlashes(str) {
+    return removeEndingSlash(removeBeginningSlash(str));
+}
+//# sourceMappingURL=text.helpers.js.map