inibase 1.2.7 → 1.2.9

package/dist/file.d.ts

@@ -111,34 +111,7 @@ export declare const remove: (filePath: string, linesToDelete: number | number[]
 export declare const search: (filePath: string, operator: ComparisonOperator | ComparisonOperator[], comparedAtValue: string | number | boolean | null | (string | number | boolean | null)[], logicalOperator?: "and" | "or", searchIn?: Set<number>, field?: Field & {
     databasePath?: string;
 }, limit?: number, offset?: number, readWholeFile?: boolean) => Promise<[Record<number, string | number | boolean | null | (string | number | boolean | null)[]> | null, number, Set<number> | null]>;
-/**
- * Asynchronously calculates the sum of numerical values from specified lines in a file.
- *
- * @param filePath - Path of the file to read.
- * @param lineNumbers - Optional specific line number(s) to include in the sum. If not provided, sums all lines.
- * @returns Promise<number>. The sum of numerical values from the specified lines.
- *
- * Note: Decodes each line as a number using the 'decode' function. Non-numeric lines contribute 0 to the sum.
- */
-export declare const sum: (filePath: string, lineNumbers?: number | number[]) => Promise<number>;
-/**
- * Asynchronously finds the maximum numerical value from specified lines in a file.
- *
- * @param filePath - Path of the file to read.
- * @param lineNumbers - Optional specific line number(s) to consider for finding the maximum value. If not provided, considers all lines.
- * @returns Promise<number>. The maximum numerical value found in the specified lines.
- *
- * Note: Decodes each line as a number using the 'decode' function. Considers only numerical values for determining the maximum.
- */
-export declare const max: (filePath: string, lineNumbers?: number | number[]) => Promise<number>;
-/**
- * Asynchronously finds the minimum numerical value from specified lines in a file.
- *
- * @param filePath - Path of the file to read.
- * @param lineNumbers - Optional specific line number(s) to consider for finding the minimum value. If not provided, considers all lines.
- * @returns Promise<number>. The minimum numerical value found in the specified lines.
- *
- * Note: Decodes each line as a number using the 'decode' function. Considers only numerical values for determining the minimum.
- */
-export declare const min: (filePath: string, lineNumbers?: number | number[]) => Promise<number>;
+export declare const sum: (fp: string, ln?: number | number[]) => Promise<number>;
+export declare const min: (fp: string, ln?: number | number[]) => Promise<number>;
+export declare const max: (fp: string, ln?: number | number[]) => Promise<number>;
 export declare const getFileDate: (path: string) => Promise<Date>;

package/dist/file.js

@@ -581,127 +581,66 @@ export const search = async (filePath, operator, comparedAtValue, logicalOperato
     }
 };
 /**
- * Asynchronously calculates the sum of numerical values from specified lines in a file.
+ * Reads the file once and returns either the sum, min or max of the
+ * (optionally-selected) numeric lines.
  *
- * @param filePath - Path of the file to read.
- * @param lineNumbers - Optional specific line number(s) to include in the sum. If not provided, sums all lines.
- * @returns Promise<number>. The sum of numerical values from the specified lines.
+ * @param filePath   Absolute path of the column file (may be .gz-compressed).
+ * @param wanted     Metric to compute: "sum" (default), "min" or "max".
+ * @param lineNumbers Specific line-number(s) to restrict the scan to.
  *
- * Note: Decodes each line as a number using the 'decode' function. Non-numeric lines contribute 0 to the sum.
+ * @returns Promise<number>  The requested metric, or 0 if no numeric value found.
  */
-export const sum = async (filePath, lineNumbers) => {
+async function reduceNumbers(filePath, wanted = "sum", lineNumbers) {
+    /* optional subset */
+    const filter = lineNumbers
+        ? new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers])
+        : null;
+    /* running aggregators */
     let sum = 0;
-    let fileHandle = null;
+    let min = Infinity;
+    let max = -Infinity;
+    let processed = 0; // count of numeric lines we actually used
+    let seen = 0; // count of filtered lines we have visited
+    let line = 0;
+    const fh = await open(filePath, "r");
+    const rl = createReadLineInternface(filePath, fh);
     try {
-        fileHandle = await open(filePath, "r");
-        const rl = createReadLineInternface(filePath, fileHandle);
-        if (lineNumbers) {
-            let linesCount = 0;
-            const lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
-            for await (const line of rl) {
-                linesCount++;
-                if (!lineNumbersArray.has(linesCount))
-                    continue;
-                sum += +(decode(line, { key: "BLABLA", type: "number" }) ?? 0);
-                lineNumbersArray.delete(linesCount);
-                if (!lineNumbersArray.size)
-                    break;
-            }
-        }
-        else
-            for await (const line of rl)
-                sum += +(decode(line, { key: "BLABLA", type: "number" }) ?? 0);
-        return sum;
-    }
-    finally {
-        await fileHandle?.close();
-    }
-};
-/**
- * Asynchronously finds the maximum numerical value from specified lines in a file.
- *
- * @param filePath - Path of the file to read.
- * @param lineNumbers - Optional specific line number(s) to consider for finding the maximum value. If not provided, considers all lines.
- * @returns Promise<number>. The maximum numerical value found in the specified lines.
- *
- * Note: Decodes each line as a number using the 'decode' function. Considers only numerical values for determining the maximum.
- */
-export const max = async (filePath, lineNumbers) => {
-    let max = 0;
-    let fileHandle = null;
-    let rl = null;
-    try {
-        fileHandle = await open(filePath, "r");
-        rl = createReadLineInternface(filePath, fileHandle);
-        if (lineNumbers) {
-            let linesCount = 0;
-            const lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
-            for await (const line of rl) {
-                linesCount++;
-                if (!lineNumbersArray.has(linesCount))
-                    continue;
-                const lineContentNum = +(decode(line, { key: "BLABLA", type: "number" }) ?? 0);
-                if (lineContentNum > max)
-                    max = lineContentNum;
-                lineNumbersArray.delete(linesCount);
-                if (!lineNumbersArray.size)
-                    break;
+        for await (const txt of rl) {
+            line++;
+            /* skip unwanted lines */
+            if (filter && !filter.has(line))
+                continue;
+            const num = Number(decode(txt, { key: "BLABLA", type: "number" })); // ← your existing decode()
+            if (isNaN(num))
+                continue;
+            processed++;
+            if (wanted === "sum") {
+                sum += num;
             }
-        }
-        else
-            for await (const line of rl) {
-                const lineContentNum = +(decode(line, { key: "BLABLA", type: "number" }) ?? 0);
-                if (lineContentNum > max)
-                    max = lineContentNum;
+            else if (wanted === "min") {
+                if (num < min)
+                    min = num;
             }
-        return max;
-    }
-    finally {
-        await fileHandle?.close();
-    }
-};
-/**
- * Asynchronously finds the minimum numerical value from specified lines in a file.
- *
- * @param filePath - Path of the file to read.
- * @param lineNumbers - Optional specific line number(s) to consider for finding the minimum value. If not provided, considers all lines.
- * @returns Promise<number>. The minimum numerical value found in the specified lines.
- *
- * Note: Decodes each line as a number using the 'decode' function. Considers only numerical values for determining the minimum.
- */
-export const min = async (filePath, lineNumbers) => {
-    let min = 0;
-    let fileHandle = null;
-    try {
-        fileHandle = await open(filePath, "r");
-        const rl = createReadLineInternface(filePath, fileHandle);
-        if (lineNumbers) {
-            let linesCount = 0;
-            const lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
-            for await (const line of rl) {
-                linesCount++;
-                if (!lineNumbersArray.has(linesCount))
-                    continue;
-                const lineContentNum = +(decode(line, { key: "BLABLA", type: "number" }) ?? 0);
-                if (lineContentNum < min)
-                    min = lineContentNum;
-                lineNumbersArray.delete(linesCount);
-                if (!lineNumbersArray.size)
-                    break;
+            else if (wanted === "max") {
+                if (num > max)
+                    max = num;
             }
+            /* early break when we have consumed all requested lines */
+            if (filter && ++seen === filter.size)
+                break;
         }
-        else
-            for await (const line of rl) {
-                const lineContentNum = +(decode(line, { key: "BLABLA", type: "number" }) ?? 0);
-                if (lineContentNum < min)
-                    min = lineContentNum;
-            }
-        return min;
     }
     finally {
-        await fileHandle?.close();
+        await fh.close();
     }
-};
+    if (processed === 0)
+        return 0; // nothing numeric found
+    return wanted === "sum" ? sum : wanted === "min" ? min : max;
+}
+/* Optional convenience wrappers (signatures unchanged) */
+export const sum = (fp, ln) => reduceNumbers(fp, "sum", ln);
+export const min = (fp, ln) => reduceNumbers(fp, "min", ln);
+export const max = (fp, ln) => reduceNumbers(fp, "max", ln);
 export const getFileDate = (path) => stat(path)
     .then((s) => s.mtime || s.birthtime)
     .catch(() => new Date());

package/dist/index.d.ts

@@ -122,7 +122,6 @@ export default class Inibase {
     private processObjectField;
     private isTableField;
     private processTableField;
-    private _setNestedKey;
     private applyCriteria;
     private _filterSchemaByColumns;
     /**

package/dist/index.js

@@ -440,11 +440,12 @@ export default class Inibase {
     formatField(value, field, _formatOnlyAvailiableKeys) {
         if (value === null || value === undefined || value === "")
             return value;
-        if (Array.isArray(field.type))
-            field.type = Utils.detectFieldType(value, field.type) ?? field.type[0];
-        if (Array.isArray(value) && !["array", "json"].includes(field.type))
+        let _fieldType = field.type;
+        if (Array.isArray(_fieldType))
+            _fieldType = Utils.detectFieldType(value, _fieldType) ?? _fieldType[0];
+        if (Array.isArray(value) && !["array", "json"].includes(_fieldType))
             value = value[0];
-        switch (field.type) {
+        switch (_fieldType) {
             case "array":
                 if (!field.children)
                     return null;
@@ -759,8 +760,9 @@ export default class Inibase {
                 await this.processTableField(tableName, field, linesNumber, RETURN, options, prefix);
             }
             else {
+                let _fieldChildren = field.children;
                 // Handling array of objects and filtering nested arrays
-                const nestedArrayFields = field.children.filter((children) => children.type === "array" &&
+                const nestedArrayFields = _fieldChildren.filter((children) => children.type === "array" &&
                     Utils.isArrayOfObjects(children.children));
                 if (nestedArrayFields.length > 0) {
                     // one of children has array field type and has children array of object = Schema
@@ -769,10 +771,10 @@ export default class Inibase {
                         for (const [index, item] of Object.entries(childItems))
                             this._processSchemaDataHelper(RETURN, item, index, field);
                     // Remove nested arrays after processing
-                    field.children = field.children.filter((children) => !nestedArrayFields.map(({ key }) => key).includes(children.key));
+                    _fieldChildren = _fieldChildren.filter((children) => !nestedArrayFields.map(({ key }) => key).includes(children.key));
                 }
                 // Process remaining items for the field's children
-                const items = await this.processSchemaData(tableName, field.children, linesNumber, options, `${(prefix ?? "") + field.key}.`);
+                const items = await this.processSchemaData(tableName, _fieldChildren, linesNumber, options, `${(prefix ?? "") + field.key}.`);
                 // Process the items after retrieval
                 if (items) {
                     for (const [index, item] of Object.entries(items)) {
@@ -925,141 +927,124 @@ export default class Inibase {
             }
         }
     }
-    _setNestedKey(obj, path, value) {
-        const keys = path.split(".");
-        let current = obj;
-        keys.forEach((key, index) => {
-            if (index === keys.length - 1) {
-                current[key] = value; // Set the value at the last key
-            }
-            else {
-                current[key] = current[key] || {}; // Ensure the object structure exists
-                current = current[key];
-            }
-        });
-    }
     async applyCriteria(tableName, options, criteria, allTrue, searchIn) {
         const tablePath = join(this.databasePath, tableName);
-        let RETURN = {};
-        if (!criteria)
-            return [null, null];
+        /** result container – we mutate rows in-place instead of deep-merging */
+        const RETURN = {};
+        /* ---------- fast exit ---------- */
+        if (!criteria || Object.keys(criteria).length === 0)
+            return null;
+        /* ---------- split top-level logical groups ---------- */
         const criteriaAND = criteria.and;
+        const criteriaOR = criteria.or;
         if (criteriaAND)
             delete criteria.and;
-        const criteriaOR = criteria.or;
         if (criteriaOR)
             delete criteria.or;
-        if (Object.keys(criteria).length > 0) {
+        /** cache table schema once – Utils.getField() is cheap but we call it a lot */
+        const schema = globalConfig[this.databasePath].tables.get(tableName).schema;
+        /* ---------- MAIN LOOP  (top-level criteria only) ---------- */
+        if (Object.keys(criteria).length) {
             if (allTrue === undefined)
                 allTrue = true;
-            criteria = Utils.toDotNotation(criteria, ["or", "and"]);
-            let index = -1;
-            for await (const [key, value] of Object.entries(criteria)) {
-                const field = Utils.getField(key, globalConfig[this.databasePath].tables.get(tableName).schema);
+            for (const [key, rawValue] of Object.entries(criteria)) {
+                /* bail early if no candidates left for an “AND” chain */
+                if (allTrue && searchIn && searchIn.size === 0)
+                    return null;
+                const field = Utils.getField(key, schema);
                 if (!field)
                     continue;
-                index++;
-                let searchOperator = undefined;
-                let searchComparedAtValue = undefined;
-                let searchLogicalOperator = undefined;
+                let value = rawValue;
+                /* ----- resolve relational sub-queries ----- */
+                if (field.table && Utils.isObject(value)) {
+                    const rel = await this.get(field.table, value, {
+                        columns: "id",
+                    });
+                    value = rel?.length ? `[]${rel.map(({ id }) => id)}` : undefined; //  ⟵  no match → abort whole AND-chain
+                    if (value === undefined && allTrue)
+                        return null;
+                }
+                /* ----- determine operator / compare value ----- */
+                let searchOperator;
+                let searchComparedAtValue;
+                let searchLogicalOperator;
                 if (Utils.isObject(value)) {
-                    if (value?.or &&
-                        Array.isArray(value?.or)) {
-                        const searchCriteria = (value?.or)
-                            .map((single_or) => typeof single_or === "string"
-                            ? Utils.FormatObjectCriteriaValue(single_or)
-                            : ["=", single_or])
-                            .filter((a) => a);
-                        if (searchCriteria.length > 0) {
-                            searchOperator = searchCriteria.map((single_or) => single_or[0]);
-                            searchComparedAtValue = searchCriteria.map((single_or) => single_or[1]);
-                            searchLogicalOperator = "or";
-                        }
-                        delete value.or;
-                    }
-                    if (value?.and &&
-                        Array.isArray(value?.and)) {
-                        const searchCriteria = (value?.and)
-                            .map((single_and) => typeof single_and === "string"
-                            ? Utils.FormatObjectCriteriaValue(single_and)
-                            : ["=", single_and])
-                            .filter((a) => a);
-                        if (searchCriteria.length > 0) {
-                            searchOperator = searchCriteria.map((single_and) => single_and[0]);
-                            searchComparedAtValue = searchCriteria.map((single_and) => single_and[1]);
-                            searchLogicalOperator = "and";
+                    /* nested object with .and / .or inside */
+                    const nestedAnd = value.and;
+                    const nestedOr = value.or;
+                    if (nestedAnd || nestedOr) {
+                        const logicalChild = nestedAnd ?? nestedOr;
+                        const logic = nestedAnd ? "and" : "or";
+                        const crit = Object.entries(logicalChild)
+                            .map((item) => typeof item[1] === "string"
+                            ? Utils.FormatObjectCriteriaValue(item[1])
+                            : ["=", item[1]])
+                            .filter(Boolean);
+                        if (crit.length) {
+                            searchOperator = crit.map((c) => c[0]);
+                            searchComparedAtValue = crit.map((c) => c[1]);
+                            searchLogicalOperator = logic;
                         }
-                        delete value.and;
                     }
                 }
                 else if (Array.isArray(value)) {
-                    const searchCriteria = value
-                        .map((single) => typeof single === "string"
-                        ? Utils.FormatObjectCriteriaValue(single)
-                        : ["=", single])
-                        .filter((a) => a);
-                    if (searchCriteria.length > 0) {
-                        searchOperator = searchCriteria.map((single) => single[0]);
-                        searchComparedAtValue = searchCriteria.map((single) => single[1]);
-                        searchLogicalOperator = "and";
-                    }
+                    const crit = value
+                        .map((v) => typeof v === "string"
+                        ? Utils.FormatObjectCriteriaValue(v)
+                        : ["=", v])
+                        .filter(Boolean);
+                    searchOperator = crit.map((c) => c[0]);
+                    searchComparedAtValue = crit.map((c) => c[1]);
+                    searchLogicalOperator = "or";
                 }
                 else if (typeof value === "string") {
-                    const ComparisonOperatorValue = Utils.FormatObjectCriteriaValue(value);
-                    if (ComparisonOperatorValue) {
-                        searchOperator = ComparisonOperatorValue[0];
-                        searchComparedAtValue = ComparisonOperatorValue[1];
-                    }
+                    const [op, val] = Utils.FormatObjectCriteriaValue(value);
+                    searchOperator = op;
+                    searchComparedAtValue = val;
                 }
                 else {
                     searchOperator = "=";
                     searchComparedAtValue = value;
                 }
-                const [searchResult, totalLines, linesNumbers] = await File.search(join(tablePath, `${key}${this.getFileExtension(tableName)}`), searchOperator ?? "=", searchComparedAtValue ?? null, searchLogicalOperator, searchIn, {
+                /* ---------- disk search ---------- */
+                const [hitRows, totalLines, lineSet] = await File.search(join(tablePath, `${key}${this.getFileExtension(tableName)}`), searchOperator ?? "=", searchComparedAtValue ?? null, searchLogicalOperator, searchIn, {
                     ...field,
                     databasePath: this.databasePath,
                     table: field.table ?? tableName,
                 }, options.perPage, (options.page - 1) * options.perPage +
                     (options.page > 1 ? 1 : 0), true);
-                if (searchResult) {
-                    const formatedSearchResult = Object.fromEntries(Object.entries(searchResult).map(([id, value]) => {
-                        const nestedObj = {};
-                        this._setNestedKey(nestedObj, key, value);
-                        return [id, nestedObj];
-                    }));
-                    RETURN = allTrue
-                        ? formatedSearchResult
-                        : Utils.deepMerge(RETURN, formatedSearchResult);
-                    this.totalItems.set(`${tableName}-${key}`, totalLines);
-                    if (linesNumbers?.size && allTrue)
-                        searchIn = linesNumbers;
+                if (!hitRows) {
+                    if (allTrue)
+                        return null; // AND-chain broken
+                    continue; // OR-chain: just skip
                 }
-                else if (allTrue)
-                    return null;
+                /* ---------- map rows into RETURN without deep-merge ---------- */
+                for (const [lnStr, val] of Object.entries(hitRows)) {
+                    const ln = +lnStr;
+                    const row = (RETURN[ln] ??= {});
+                    row[key] = val;
+                }
+                this.totalItems.set(`${tableName}-${key}`, totalLines);
+                /* shrink search domain for next AND condition */
+                if (lineSet?.size && allTrue)
+                    searchIn = lineSet;
             }
         }
+        /* ---------- process nested .and / .or recursively (unchanged) ---------- */
         if (criteriaAND && Utils.isObject(criteriaAND)) {
-            const searchResult = await this.applyCriteria(tableName, options, criteriaAND, true, searchIn);
-            if (searchResult) {
-                RETURN = Utils.deepMerge(RETURN, Object.fromEntries(Object.entries(searchResult).filter(([_k, v], _i) => Object.keys(v).filter((key) => Object.keys(criteriaAND).includes(key)).length)));
-            }
-            else
+            const res = await this.applyCriteria(tableName, options, criteriaAND, true, searchIn);
+            if (!res)
                 return null;
+            for (const [lnStr, data] of Object.entries(res))
+                (RETURN[+lnStr] ??= {}), Object.assign(RETURN[+lnStr], data);
         }
         if (criteriaOR && Utils.isObject(criteriaOR)) {
-            const searchResult = await this.applyCriteria(tableName, options, criteriaOR, false, searchIn);
-            if (searchResult) {
-                RETURN = Utils.deepMerge(RETURN, searchResult);
-                if (!Object.keys(RETURN).length)
-                    RETURN = {};
-                RETURN = Object.fromEntries(Object.entries(RETURN).filter(([_index, item]) => Object.keys(item).filter((key) => Object.keys(criteriaOR).includes(key) ||
-                    Object.keys(criteriaOR).some((criteriaKey) => criteriaKey.startsWith(`${key}.`))).length));
-                if (!Object.keys(RETURN).length)
-                    RETURN = {};
-            }
-            else
-                RETURN = {};
+            const res = await this.applyCriteria(tableName, options, criteriaOR, false, undefined);
+            if (res)
+                for (const [lnStr, data] of Object.entries(res))
+                    (RETURN[+lnStr] ??= {}), Object.assign(RETURN[+lnStr], data);
         }
+        /* ---------- final answer ---------- */
         return Object.keys(RETURN).length ? RETURN : null;
     }
     _filterSchemaByColumns(schema, columns) {

package/dist/utils.js

@@ -427,8 +427,11 @@ export const FormatObjectCriteriaValue = (value) => {
         case "[":
             return value[1] === "]"
                 ? [
-                    value.slice(0, 2),
-                    value.slice(2).toString().split(","),
+                    "[]",
+                    value.slice(2)
+                        .toString()
+                        .split(",")
+                        .map((v) => (isNumber(v) ? Number(v) : v)),
                 ]
                 : ["[]", value.slice(1)];
         case "!":
@@ -439,23 +442,20 @@ export const FormatObjectCriteriaValue = (value) => {
                 ]
                 : value[1] === "["
                     ? [
-                        value.slice(0, 3),
-                        value.slice(3),
+                        "![]",
+                        value.slice(3)
+                            .toString()
+                            .split(",")
+                            .map((v) => (isNumber(v) ? Number(v) : v)),
                     ]
                     : [
                         `${value.slice(0, 1)}=`,
                         value.slice(1),
                     ];
         case "=":
-            return [
-                value.slice(0, 1),
-                value.slice(1),
-            ];
+            return ["=", value.slice(1)];
         case "*":
-            return [
-                value.slice(0, 1),
-                value.slice(1),
-            ];
+            return ["*", value.slice(1)];
         default:
             return ["=", value];
     }

package/dist/utils.server.js

@@ -95,10 +95,10 @@ export const addIdToSchema = (schema, startWithID) => {
     function _addIdToField(field) {
         if (!field.id) {
             startWithID.value++;
-            field.id = encodeID(startWithID.value);
+            field.id = startWithID.value;
         }
-        else
-            field.id = isValidID(field.id) ? decodeID(field.id) : encodeID(field.id);
+        else if (isValidID(field.id))
+            field.id = decodeID(field.id);
         if ((field.type === "array" || field.type === "object") &&
             isArrayOfObjects(field.children))
             field.children = _addIdToSchema(field.children);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inibase",
-  "version": "1.2.7",
+  "version": "1.2.9",
   "type": "module",
   "author": {
     "name": "Karim Amahtil",
@@ -69,22 +69,24 @@
   },
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
-    "@types/bun": "^1.1.10",
-    "@types/node": "^22.7.4",
-    "lefthook": "^1.10.1",
-    "tinybench": "^3.0.7",
-    "typescript": "^5.7.2"
+    "@types/bun": "^1.2.10",
+    "@types/node": "^22.15.2",
+    "lefthook": "^1.11.11",
+    "tinybench": "^4.0.1",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.3"
   },
   "dependencies": {
-    "dotenv": "^16.4.5",
+    "dotenv": "^16.5.0",
     "inison": "^2.0.1",
     "re2": "^1.21.4"
   },
   "scripts": {
-    "prepublish": "npx -q tsc",
-    "build": "npx -q tsc",
+    "prepublish": "tsc",
+    "prebuild": "biome check --write src",
+    "build": "tsc",
     "benchmark": "./benchmark/run.js",
-    "test": "npx -q tsx ./tests/inibase.test.ts",
-    "test:utils": "npx -q tsx ./tests/utils.test.ts"
+    "test": "tsx ./tests/inibase.test.ts",
+    "test:utils": "tsx ./tests/utils.test.ts"
   }
 }