@wxn0brp/db 0.0.8 → 0.1.0

package/dist/cjs/format.d.ts

@@ -2,17 +2,11 @@
  * Parses given string into a JSON object. If the string does not start with
  * a {, it is wrapped in one. This allows for a shorthand when
  * storing/reading data from a file.
- *
- * @param {string} data
- * @returns {Object}
  */
-export declare function parse(data: any): any;
+export declare function parse(data: string): any;
 /**
  * Converts given object to a string. If the string is a valid json5, it is
  * returned as is. If it is a valid json5 wrapped in {}, the curly brackets
  * are removed. Otherwise the string is wrapped in {}.
- *
- * @param {Object} data
- * @return {String}
  */
 export declare function stringify(data: any): any;

package/dist/cjs/format.js

@@ -10,9 +10,6 @@ const json5_1 = __importDefault(require("json5"));
  * Parses given string into a JSON object. If the string does not start with
  * a {, it is wrapped in one. This allows for a shorthand when
  * storing/reading data from a file.
- *
- * @param {string} data
- * @returns {Object}
  */
 function parse(data) {
     if (!data.startsWith("{"))
@@ -23,9 +20,6 @@ function parse(data) {
  * Converts given object to a string. If the string is a valid json5, it is
  * returned as is. If it is a valid json5 wrapped in {}, the curly brackets
  * are removed. Otherwise the string is wrapped in {}.
- *
- * @param {Object} data
- * @return {String}
  */
 function stringify(data) {
     data = json5_1.default.stringify(data);

package/dist/cjs/gen.d.ts

@@ -1,5 +1,8 @@
-import Id from "./types/Id";
+import Id from "./types/Id.js";
 /**
- * Generates a unique identifier based on specified parts.
+ * Generates a unique random identifier based on time and parts.
+ *
+ * @param {number[]} [parts] - an array of lengths of parts of the identifier
+ * @returns {Id} - a new unique identifier
  */
-export default function genId(parts?: number | number[], fill?: number): Id;
+export default function genId(parts?: number[]): Id;

package/dist/cjs/gen.js

@@ -2,77 +2,136 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = genId;
 const usedIdsMap = new Map();
+let lastId;
+const recentIdsTimestamps = [];
+let startIndex = 0;
+let lastGeneratedMs = 0;
+let lastRandomValue = 0;
 /**
- * Generates a unique identifier based on specified parts.
+ * Generates a unique random identifier based on time and parts.
+ *
+ * @param {number[]} [parts] - an array of lengths of parts of the identifier
+ * @returns {Id} - a new unique identifier
  */
-function genId(parts = null, fill = 1) {
-    parts = changeInputToPartsArray(parts, fill);
+function genId(parts = null) {
+    if (parts === null)
+        parts = [1, 1];
     const time = getTime();
-    const id = getUniqueRandom(time, parts);
+    const id = getUniqueRandom({
+        time,
+        partsSchema: parts,
+        s: 0,
+    });
     return id;
 }
 /**
  * Generates a unique random identifier based on time and parts.
- * @param time - The current time in a base36 string format.
- * @param parts - An array of parts to be used for generating the identifier.
- * @param s - Recursion counter for handling collision (default: 0).
- * @returns {string} The unique random identifier.
  */
-function getUniqueRandom(time, partsA, s = 0) {
-    const parts = partsA.map(l => getRandom(l));
-    const id = [time, ...parts].join("-");
-    if (usedIdsMap.has(id)) {
-        s++;
-        if (s < 25)
-            return getUniqueRandom(time, partsA, s);
-        partsA = addOneToPods(partsA);
-        time = getTime();
-        return getUniqueRandom(time, partsA);
+function getUniqueRandom(opts) {
+    while (true) {
+        let minValue = 0;
+        if (lastId) {
+            const parts = lastId.split("-");
+            const lastTime = parts.shift();
+            if (lastTime === opts.time) {
+                const int36 = parts.join("");
+                minValue = parseInt(int36, 36) + 1;
+            }
+        }
+        const partsLengthSum = opts.partsSchema.reduce((acc, num) => acc + num, 0);
+        const partsData = generateBase36InRange(minValue, partsLengthSum);
+        const parts = splitStringByArray(opts.partsSchema, partsData);
+        const id = [opts.time, ...parts].join("-");
+        if (!usedIdsMap.has(id)) {
+            usedIdsMap.set(id, true);
+            setTimeout(() => usedIdsMap.delete(id), 1000);
+            lastId = id;
+            return id;
+        }
+        opts.s++;
+        if (opts.s >= partsLengthSum) {
+            opts.time = getTime();
+            opts.s = 0;
+        }
     }
-    usedIdsMap.set(id, Date.now() + 2000);
-    usedIdsMap.forEach((value, key) => {
-        if (value < Date.now())
-            usedIdsMap.delete(key);
-    });
-    return id;
 }
 /**
- * Generates a random string of base36 characters.
+ * Tracks the current load of the application by counting the number of ids that have been generated in the last second.
+ * @returns The number of ids that have been generated in the last second.
  */
-function getRandom(unix) {
-    return (Math.floor(Math.random() * Math.pow(36, unix))).toString(36);
+function trackLoad() {
+    const now = Date.now();
+    recentIdsTimestamps.push(now);
+    while (startIndex < recentIdsTimestamps.length && recentIdsTimestamps[startIndex] < now - 1) {
+        startIndex++;
+    }
+    return recentIdsTimestamps.length - startIndex;
 }
 /**
- * Gets the current time in a base36 string format.
+ * Generates a base-36 encoded string with a specified length based on a random value within a range.
+ *
+ * The function calculates a random value within the base-36 range determined by the provided
+ * `minValue` and `length`. It uses a bias mechanism to adjust the randomness based on the
+ * current load, ensuring unique generation over short periods. If the system load is low or
+ * the current millisecond has changed, a new random value is generated. Otherwise, the random
+ * value is incremented by a small amount with certain probabilities.
+ *
+ * @param minValue - The minimum value for the base-36 encoded number.
+ * @param length - The length of the resulting base-36 string.
+ * @returns A base-36 encoded string representation of the random value, padded to the specified length.
  */
-function getTime() {
-    return Math.floor(new Date().getTime() / 1000).toString(36);
+function generateBase36InRange(minValue, length) {
+    const maxValue = Math.pow(36, length) - 1;
+    const load = trackLoad();
+    const currentMs = Date.now();
+    if (load < 3 || currentMs !== lastGeneratedMs) {
+        lastRandomValue = biasedRandomInRange(minValue, maxValue);
+        lastGeneratedMs = currentMs;
+    }
+    else {
+        const rand = Math.random();
+        if (rand < 0.6) {
+            lastRandomValue += 1;
+        }
+        else if (rand < 0.9) {
+            lastRandomValue += 2;
+        }
+        else {
+            lastRandomValue = biasedRandomInRange(lastRandomValue, maxValue);
+        }
+    }
+    return lastRandomValue.toString(36).padStart(length, "0");
 }
 /**
- * Adds one to each part of the input array.
+ * Generates a random number between the specified range, but with a bias towards the lower
+ * end of the range. The bias is calculated as the cube root of the random value, which
+ * will make the random value more likely to be closer to the minimum value.
+ * @param min - The minimum value of the range.
+ * @param max - The maximum value of the range.
+ * @returns A random number between the specified range, with a bias towards the lower end.
  */
-function addOneToPods(array) {
-    const sum = array.reduce((acc, current) => acc + current, 0);
-    const num = sum + 1;
-    const len = array.length;
-    const result = [];
-    const quotient = Math.floor(num / len);
-    const remainder = num % len;
-    for (let i = 0; i < len; i++) {
-        if (i < remainder)
-            result.push(quotient + 1);
-        else
-            result.push(quotient);
-    }
-    return result;
+function biasedRandomInRange(min, max) {
+    let randomValue = min;
+    const bias = Math.pow(Math.random(), 3);
+    randomValue = Math.floor(min + (max - min) * bias);
+    return Math.min(randomValue, max);
 }
 /**
- * Converts input to an array of parts.
+ * Splits a string into an array of substrings, where each substring is determined by
+ * the values in the provided array.
+ *
+ * @param arr - An array of numbers, where each number represents the length of a substring.
+ * @param str - The string to split.
+ * @returns An array of substrings, where each element is a substring of the original string,
+ *          determined by the corresponding element in the provided array.
  */
-function changeInputToPartsArray(parts = null, fill = 1) {
-    if (Array.isArray(parts))
-        return parts;
-    if (typeof parts == "number")
-        return Array(parts).fill(fill);
-    return [1, 1];
+function splitStringByArray(arr, str) {
+    let start = 0;
+    return arr.map(length => str.slice(start, start += length));
+}
+/**
+ * Gets the current time in a base36 string format.
+ */
+function getTime() {
+    return new Date().getTime().toString(36);
 }

package/dist/cjs/graph.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const database_js_1 = __importDefault(require("./database.js"));
+const database_1 = __importDefault(require("./database.js"));
 /**
  * A class representing a graph database.
  * @class
@@ -11,7 +11,7 @@ const database_js_1 = __importDefault(require("./database.js"));
 class Graph {
     db;
     constructor(databaseFolder) {
-        this.db = new database_js_1.default(databaseFolder);
+        this.db = new database_1.default(databaseFolder);
     }
     /**
      * Adds an edge between two nodes.

package/dist/cjs/index.js

@@ -4,15 +4,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.genId = exports.Relation = exports.GraphRemote = exports.DataBaseRemote = exports.Graph = exports.DataBase = void 0;
-const database_js_1 = __importDefault(require("./database.js"));
-exports.DataBase = database_js_1.default;
-const graph_js_1 = __importDefault(require("./graph.js"));
-exports.Graph = graph_js_1.default;
-const database_js_2 = __importDefault(require("./client/database.js"));
-exports.DataBaseRemote = database_js_2.default;
-const graph_js_2 = __importDefault(require("./client/graph.js"));
-exports.GraphRemote = graph_js_2.default;
-const gen_js_1 = __importDefault(require("./gen.js"));
-exports.genId = gen_js_1.default;
-const relation_js_1 = __importDefault(require("./relation.js"));
-exports.Relation = relation_js_1.default;
+const database_1 = __importDefault(require("./database.js"));
+exports.DataBase = database_1.default;
+const graph_1 = __importDefault(require("./graph.js"));
+exports.Graph = graph_1.default;
+const database_2 = __importDefault(require("./client/database.js"));
+exports.DataBaseRemote = database_2.default;
+const graph_2 = __importDefault(require("./client/graph.js"));
+exports.GraphRemote = graph_2.default;
+const gen_1 = __importDefault(require("./gen.js"));
+exports.genId = gen_1.default;
+const relation_1 = __importDefault(require("./relation.js"));
+exports.Relation = relation_1.default;

package/dist/cjs/relation.d.ts

@@ -4,61 +4,31 @@ import { DbFindOpts } from "./types/options.js";
 export interface Databases {
     [key: string]: DataBase;
 }
+interface RelationConfig {
+    from: string;
+    localField: string;
+    foreignField: string;
+    as?: string;
+    multiple?: boolean;
+}
 declare class Relation {
-    databases: Databases;
+    private databases;
     constructor(databases: Databases);
     /**
-    * Resolves the relation path in format 'dbName.collectionName'
-    */
-    _resolvePath(path: string): {
-        db: DataBase;
-        collection: string;
-    };
+     * Resolves the relation path in format 'dbName.collectionName'.
+     */
+    private _resolvePath;
     /**
-     * Processes relations for a single item
-     * @param {Object} item - Item to process relations for
-     * @param {Object} relations - Relations configuration
-     * @returns {Promise<Object>} Processed item with resolved relations
+     * Processes relations for a single item.
      */
-    _processItemRelations(item: Object, relations: Object): Promise<{
-        constructor: Function;
-        toString(): string;
-        toLocaleString(): string;
-        valueOf(): Object;
-        hasOwnProperty(v: PropertyKey): boolean;
-        isPrototypeOf(v: Object): boolean;
-        propertyIsEnumerable(v: PropertyKey): boolean;
-    }>;
+    private _processItemRelations;
     /**
-     * Finds items with relations
-     * @param path - Path in format 'dbName.collectionName'
-     * @param search - Search query or function
-     * @param relations - Relations configuration
-     * @param options - Search options
+     * Finds multiple items with relations.
      */
-    find(path: string, search: Search, relations?: {}, options?: DbFindOpts): Promise<{
-        constructor: Function;
-        toString(): string;
-        toLocaleString(): string;
-        valueOf(): Object;
-        hasOwnProperty(v: PropertyKey): boolean;
-        isPrototypeOf(v: Object): boolean;
-        propertyIsEnumerable(v: PropertyKey): boolean;
-    }[]>;
+    find(path: string, search: Search, relations?: Record<string, RelationConfig>, options?: DbFindOpts): Promise<Record<string, any>[]>;
     /**
-     * Finds one item with relations
-     * @param path - Path in format 'dbName.collectionName'
-     * @param search - Search query or function
-     * @param relations - Relations configuration
+     * Finds a single item with relations.
      */
-    findOne(path: string, search: Search, relations?: Object): Promise<{
-        constructor: Function;
-        toString(): string;
-        toLocaleString(): string;
-        valueOf(): Object;
-        hasOwnProperty(v: PropertyKey): boolean;
-        isPrototypeOf(v: Object): boolean;
-        propertyIsEnumerable(v: PropertyKey): boolean;
-    }>;
+    findOne(path: string, search: Search, relations?: Record<string, RelationConfig>): Promise<Record<string, any> | null>;
 }
 export default Relation;

package/dist/cjs/relation.js

@@ -6,62 +6,59 @@ class Relation {
         this.databases = databases;
     }
     /**
-    * Resolves the relation path in format 'dbName.collectionName'
-    */
+     * Resolves the relation path in format 'dbName.collectionName'.
+     */
     _resolvePath(path) {
-        const sanitizedPath = path.replace(/\\\./g, '\uffff');
-        const separatorIndex = sanitizedPath.indexOf('.');
-        if (separatorIndex === -1)
+        if (!path.includes(".")) {
             throw new Error(`Invalid path format "${path}". Expected format 'dbName.collectionName'.`);
-        const dbName = sanitizedPath.slice(0, separatorIndex).replace(/\uffff/g, '.');
-        const collectionName = sanitizedPath.slice(separatorIndex + 1).replace(/\uffff/g, '.');
-        if (!this.databases[dbName])
-            throw new Error(`Database "${dbName}" not found`);
-        return { db: this.databases[dbName], collection: collectionName };
+        }
+        const sanitizedPath = path.replace(/\\\./g, "\uffff");
+        const [dbName, collectionName] = sanitizedPath.split(".", 2).map(part => part.replace(/\uffff/g, "."));
+        const db = this.databases[dbName];
+        if (!db) {
+            throw new Error(`Database "${dbName}" not found.`);
+        }
+        return { db, collection: collectionName };
     }
     /**
-     * Processes relations for a single item
-     * @param {Object} item - Item to process relations for
-     * @param {Object} relations - Relations configuration
-     * @returns {Promise<Object>} Processed item with resolved relations
+     * Processes relations for a single item.
      */
     async _processItemRelations(item, relations) {
+        if (!item || typeof item !== "object")
+            return item;
         const result = { ...item };
         for (const [field, relationConfig] of Object.entries(relations)) {
-            const { from, localField, foreignField, as, multiple = false } = relationConfig;
-            const { db, collection } = this._resolvePath(from);
-            const searchQuery = { [foreignField]: item[localField] };
-            const fn = multiple ? db.find : db.findOne;
-            const relatedItem = await fn(collection, searchQuery);
-            result[as || field] = relatedItem;
+            if (!relationConfig.from || !relationConfig.localField || !relationConfig.foreignField) {
+                console.warn(`Skipping invalid relation configuration for field: "${field}"`);
+                continue;
+            }
+            try {
+                const { db, collection } = this._resolvePath(relationConfig.from);
+                const searchQuery = { [relationConfig.foreignField]: item[relationConfig.localField] };
+                const fetchFn = relationConfig.multiple ? db.find.bind(db) : db.findOne.bind(db);
+                result[relationConfig.as || field] = await fetchFn(collection, searchQuery) || null;
+            }
+            catch (error) {
+                console.error(`Error processing relation for field "${field}":`, error);
+            }
         }
         return result;
     }
     /**
-     * Finds items with relations
-     * @param path - Path in format 'dbName.collectionName'
-     * @param search - Search query or function
-     * @param relations - Relations configuration
-     * @param options - Search options
+     * Finds multiple items with relations.
      */
     async find(path, search, relations = {}, options = {}) {
         const { db, collection } = this._resolvePath(path);
         const items = await db.find(collection, search, {}, options);
-        const results = await Promise.all(items.map(item => this._processItemRelations(item, relations)));
-        return results;
+        return Promise.all(items.map(item => this._processItemRelations(item, relations)));
     }
     /**
-     * Finds one item with relations
-     * @param path - Path in format 'dbName.collectionName'
-     * @param search - Search query or function
-     * @param relations - Relations configuration
+     * Finds a single item with relations.
      */
     async findOne(path, search, relations = {}) {
         const { db, collection } = this._resolvePath(path);
         const item = await db.findOne(collection, search);
-        if (!item)
-            return null;
-        return await this._processItemRelations(item, relations);
+        return item ? this._processItemRelations(item, relations) : null;
     }
 }
 exports.default = Relation;

package/dist/cjs/types/arg.d.ts

@@ -1,7 +1,7 @@
-import Id from "./Id";
-import { SearchOptions } from "./searchOpts";
-import { Context } from "./types";
-import { UpdaterArg } from "./updater";
+import Id from "./Id.js";
+import { SearchOptions } from "./searchOpts.js";
+import { Context } from "./types.js";
+import { UpdaterArg } from "./updater.js";
 export interface Arg {
     _id?: Id;
     [key: string]: any;

package/dist/cjs/types/searchOpts.d.ts

@@ -4,7 +4,7 @@
  * This module defines the types and structures for search operators used
  * to validate and query data objects.
  */
-import { Arg } from "./arg";
+import { Arg } from "./arg.js";
 /** Logical Operators */
 export type LogicalOperators = {
     /**

package/dist/cjs/utils/hasFields.d.ts

@@ -1,8 +1,7 @@
 /**
  * Checks if an object matches the standard field comparison.
- * @function
- * @param {Object} obj - The object to check.
- * @param {Object} fields - Criteria to compare.
- * @returns {boolean} - Whether the object matches the criteria.
+ * @param obj - The object to check.
+ * @param fields - Criteria to compare.
+ * @returns Whether the object matches the criteria.
  */
-export default function hasFields(obj: any, fields: any): any;
+export default function hasFields(obj: Object, fields: Object): boolean;

package/dist/cjs/utils/hasFields.js

@@ -3,10 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = hasFields;
 /**
  * Checks if an object matches the standard field comparison.
- * @function
- * @param {Object} obj - The object to check.
- * @param {Object} fields - Criteria to compare.
- * @returns {boolean} - Whether the object matches the criteria.
+ * @param obj - The object to check.
+ * @param fields - Criteria to compare.
+ * @returns Whether the object matches the criteria.
  */
 function hasFields(obj, fields) {
     const keys = Object.keys(fields);

package/dist/cjs/utils/hasFieldsAdvanced.d.ts

@@ -1,4 +1,4 @@
-import { Arg } from "../types/arg";
+import { Arg } from "../types/arg.js";
 /**
  * Checks if an object meets the criteria specified in the fields with operators.
  */

package/dist/cjs/utils/hasFieldsAdvanced.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = hasFieldsAdvanced;
-const hasFields_js_1 = __importDefault(require("./hasFields.js"));
+const hasFields_1 = __importDefault(require("./hasFields.js"));
 /**
  * Checks if an object meets the criteria specified in the fields with operators.
  */
@@ -22,7 +22,7 @@ function hasFieldsAdvanced(obj, fields) {
     if (!checkConditions(obj, fields))
         return false;
     const fieldsSubset = removeAdvancedOperators({ ...fields });
-    return (0, hasFields_js_1.default)(obj, fieldsSubset);
+    return (0, hasFields_1.default)(obj, fieldsSubset);
 }
 function removeAdvancedOperators(fields) {
     const advancedOperators = [
@@ -176,7 +176,7 @@ function checkNot(obj, fields) {
 function checkSubset(obj, fields) {
     if ("$subset" in fields) {
         const setFields = fields["$subset"];
-        return (0, hasFields_js_1.default)(obj, setFields);
+        return (0, hasFields_1.default)(obj, setFields);
     }
     return true;
 }

package/dist/cjs/utils/updateFindObject.d.ts

@@ -1,11 +1,11 @@
+import { FindOpts } from "../types/options.js";
 /**
  * Updates an object with new values from a findOpts object.
- * @function
- * @param {Object} obj - The object to update.
- * @param {Object} findOpts - An object containing options to update the target object.
- * @param {function} [findOpts.transform] - A function to transform the object before applying the other options.
- * @param {string[]} [findOpts.select] - An array of fields to select from the target object.
- * @param {string[]} [findOpts.exclude] - An array of fields to exclude from the target object.
- * @returns {Object} The updated object.
+ * @param obj - The object to update.
+ * @param findOpts - An object containing options to update the target object.
+ * @param [findOpts.transform] - A function to transform the object before applying the other options.
+ * @param [findOpts.select] - An array of fields to select from the target object.
+ * @param [findOpts.exclude] - An array of fields to exclude from the target object.
+ * @returns The updated object.
  */
-export default function updateFindObject(obj: any, findOpts: any): any;
+export default function updateFindObject(obj: Object, findOpts: FindOpts): Object;

package/dist/cjs/utils/updateFindObject.js

@@ -3,13 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = updateFindObject;
 /**
  * Updates an object with new values from a findOpts object.
- * @function
- * @param {Object} obj - The object to update.
- * @param {Object} findOpts - An object containing options to update the target object.
- * @param {function} [findOpts.transform] - A function to transform the object before applying the other options.
- * @param {string[]} [findOpts.select] - An array of fields to select from the target object.
- * @param {string[]} [findOpts.exclude] - An array of fields to exclude from the target object.
- * @returns {Object} The updated object.
+ * @param obj - The object to update.
+ * @param findOpts - An object containing options to update the target object.
+ * @param [findOpts.transform] - A function to transform the object before applying the other options.
+ * @param [findOpts.select] - An array of fields to select from the target object.
+ * @param [findOpts.exclude] - An array of fields to exclude from the target object.
+ * @returns The updated object.
  */
 function updateFindObject(obj, findOpts) {
     const { transform, select, exclude, } = findOpts;

package/dist/cjs/utils/updateObject.d.ts

@@ -4,4 +4,4 @@ import { UpdaterArg } from "../types/updater.js";
  * @param obj - The object to update.
  * @param fields - An object containing new values to update in the target object.
  */
-export default function updateObjectAdvanced(obj: any, fields: UpdaterArg | UpdaterArg[]): any;
+export default function updateObjectAdvanced(obj: Object, fields: UpdaterArg | UpdaterArg[]): Object;

package/dist/esm/CollectionManager.d.ts

@@ -39,6 +39,6 @@ declare class CollectionManager {
     /**
      * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
      */
-    updateOneOrAdd(search: Search, arg: Search, add_arg?: Arg, context?: Context, id_gen?: boolean): Promise<boolean>;
+    updateOneOrAdd(search: Search, updater: Updater, add_arg?: Arg, context?: Context, id_gen?: boolean): Promise<boolean>;
 }
 export default CollectionManager;

package/dist/esm/CollectionManager.js

@@ -50,8 +50,8 @@ class CollectionManager {
     /**
      * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
      */
-    async updateOneOrAdd(search, arg, add_arg = {}, context = {}, id_gen = true) {
-        return await this.db.updateOneOrAdd(this.collection, search, arg, add_arg, context, id_gen);
+    async updateOneOrAdd(search, updater, add_arg = {}, context = {}, id_gen = true) {
+        return await this.db.updateOneOrAdd(this.collection, search, updater, add_arg, context, id_gen);
     }
 }
 export default CollectionManager;

package/dist/esm/action.d.ts

@@ -1,6 +1,6 @@
 import { Arg, Search, Updater } from "./types/arg.js";
 import { DbFindOpts, DbOpts, FindOpts } from "./types/options.js";
-import { Context } from "./types/types";
+import { Context } from "./types/types.js";
 import { SearchOptions } from "./types/searchOpts.js";
 import Data from "./types/data.js";
 /**

package/dist/esm/action.js

@@ -1,6 +1,6 @@
-import { existsSync, mkdirSync, readdirSync, appendFileSync, rmSync, writeFileSync, statSync } from "fs";
 import gen from "./gen.js";
 import { stringify } from "./format.js";
+import { existsSync, mkdirSync, readdirSync, appendFileSync, rmSync, writeFileSync, statSync } from "fs";
 import { find as _find, findOne as _findOne, update as _update, remove as _remove } from "./file/index.js";
 /**
  * A class representing database actions on files.