@wxn0brp/db-core 0.0.1 → 0.0.2

package/src/index.ts

@@ -1,25 +0,0 @@
-import genId from "./helpers/gen";
-import Relation from "./helpers/relation";
-import { RelationTypes } from "./types/relation";
-import { ValtheraCompatible } from "./types/valthera";
-import { ValtheraTypes } from "./types/export";
-import CustomFileCpu from "./customFileCpu";
-import ValtheraClass from "./db/valthera";
-import ValtheraMemory, { createMemoryValthera } from "./db/memory";
-
-export {
-    ValtheraClass,
-    ValtheraMemory,
-    createMemoryValthera,
-    Relation,
-    genId,
-    CustomFileCpu,
-}
-
-export type {
-    ValtheraCompatible,
-    RelationTypes,
-    ValtheraTypes
-}
-
-export type Id = import("./types/Id").Id;

package/src/types/Id.ts

@@ -1,3 +0,0 @@
-type Id = string;
-export default Id;
-export { Id };

package/src/types/arg.ts

@@ -1,15 +0,0 @@
-import Id from "./Id";
-import { SearchOptions } from "./searchOpts";
-import { VContext } from "./types";
-import { UpdaterArg } from "./updater";
-
-export interface Arg {
-    _id?: Id,
-    [key: string]: any
-}
-
-export type SearchFunc<T=any> = (data: T, context: VContext) => boolean;
-export type UpdaterFunc<T=any> = (data: T, context: VContext) => boolean;
-
-export type Search<T=any> = SearchOptions | SearchFunc<T>;
-export type Updater<T=any> = UpdaterArg | UpdaterArg[] | UpdaterFunc<T>;

package/src/types/data.ts

@@ -1,4 +0,0 @@
-export interface Data {
-    [key: string]: any;
-}
-export default Data;

package/src/types/export.ts

@@ -1,13 +0,0 @@
-export namespace ValtheraTypes {
-    export type Arg = import("./arg").Arg;
-    export type Search = import("./arg").Search;
-    export type Updater = import("./arg").Updater;
-    export type DbFindOpts = import("./options").DbFindOpts;
-    export type FindOpts = import("./options").FindOpts;
-    export type DbOpts = import("./options").DbOpts;
-    export type Data = import("./data").Data;
-    export type SearchOptions = import("./searchOpts").SearchOptions;
-    export type Id = import("./Id").Id;
-    export type Context = import("./types").VContext;
-    export type VContext = import("./types").VContext;
-}

package/src/types/fileCpu.ts

@@ -1,78 +0,0 @@
-import { Search, Updater } from "./arg";
-import Data from "./data";
-import { FindOpts } from "./options";
-import { VContext } from "./types";
-
-interface FileCpu {
-    /**
-     * Asynchronously adds an entry to a file.
-     * @param file The path to the file.
-     * @param data The data to add.
-     * @returns A promise resolving to `void`.
-     */
-    add(file: string, data: Data): Promise<void>;
-
-    /**
-     * Asynchronously finds multiple entries in a file based on search criteria.
-     * @param file The path to the file.
-     * @param arg The search criteria.
-     * @param context Additional context for the search.
-     * @param findOpts Additional options for searching.
-     * @returns A promise resolving to an array of found entries, or `false` if the file does not exist.
-     */
-    find(
-        file: string,
-        arg: Search,
-        context?: VContext,
-        findOpts?: FindOpts
-    ): Promise<any[] | false>;
-
-    /**
-     * Asynchronously finds one entry in a file based on search criteria.
-     * @param file The path to the file.
-     * @param arg The search criteria.
-     * @param context Additional context for the search.
-     * @param findOpts Additional options for searching.
-     * @returns A promise resolving to the found entry or `false` if not found.
-     */
-    findOne(
-        file: string,
-        arg: Search,
-        context?: VContext,
-        findOpts?: FindOpts
-    ): Promise<any | false>;
-
-    /**
-   * Asynchronously removes entries from a file based on search criteria.
-   * @param file The path to the file.
-   * @param arg The search criteria.
-   * @param context Additional context for the operation.
-   * @param one If `true`, removes only the first matching entry.
-   * @returns A promise resolving to `true` if at least one entry was removed, otherwise `false`.
-   */
-    remove(
-        file: string,
-        one: boolean,
-        arg: Search,
-        context?: VContext
-    ): Promise<boolean>;
-
-    /**
-     * Asynchronously updates entries in a file based on search criteria and an updater function or object.
-     * @param file The path to the file.
-     * @param arg The search criteria.
-     * @param updater The updater function or object.
-     * @param context Additional context for the operation.
-     * @param one If `true`, updates only the first matching entry.
-     * @returns A promise resolving to `true` if at least one entry was updated, otherwise `false`.
-     */
-    update(
-        file: string,
-        one: boolean,
-        arg: Search,
-        updater: Updater,
-        context?: VContext,
-    ): Promise<boolean>;
-}
-
-export default FileCpu;

package/src/types/options.ts

@@ -1,22 +0,0 @@
-import dbActionBase from "../base/actions";
-import executorC from "../helpers/executor";
-
-export interface DbOpts {
-    maxFileSize?: number;
-    dbAction?: dbActionBase;
-    executor?: executorC;
-}
-
-export interface DbFindOpts {
-    reverse?: boolean;
-    max?: number;
-    offset?: number;
-    sortBy?: string;
-    sortAsc?: boolean;
-}
-
-export interface FindOpts {
-    select?: string[];
-    exclude?: string[];
-    transform?: Function;
-}

package/src/types/query.ts

@@ -1,16 +0,0 @@
-import { VContext } from "./types";
-import { Arg, Search, Updater } from "./arg";
-import { DbFindOpts, FindOpts } from "./options";
-
-export interface VQuery {
-    collection?: string;
-    search?: Search;
-    context?: VContext;
-    dbFindOpts?: DbFindOpts;
-    findOpts?: FindOpts;
-    data?: Arg;
-    id_gen?: boolean;
-    limit?: number;
-    add_arg?: Arg;
-    updater?: Updater;
-}

package/src/types/relation.ts

@@ -1,34 +0,0 @@
-import { DbFindOpts } from "./options";
-import { ValtheraCompatible } from "./valthera";
-
-export namespace RelationTypes {
-    export type Path = [string, string];
-    export type FieldPath = string[];
-
-    export interface DBS {
-        [key: string]: ValtheraCompatible
-    }
-
-    export interface Relation {
-        [key: string]: RelationConfig
-    }
-
-    export interface RelationConfig {
-        path: Path;
-        pk?: string;
-        fk?: string;
-        as?: string;
-        select?: string[];
-
-        findOpts?: DbFindOpts;
-        type?: "1" | "11" | "1n" | "nm"
-        relations?: Relation;
-
-        through?: {
-            table: string;
-            db?: string;
-            pk: string; // local -> pivot
-            fk: string; // remote -> pivot
-        };
-    }
-}

package/src/types/searchOpts.ts

@@ -1,78 +0,0 @@
-/**
- * Predefined Search Options Quick Reference
- * 
- * This module defines the types and structures for search operators used
- * to validate and query data objects.
- */
-
-import { Arg } from "./arg";
-
-/** Logical Operators */
-export type LogicalOperators = {
-    /**
-     * Recursively applies multiple conditions, all of which must evaluate to true.
-     * Can include other operators such as $gt, $exists, or nested $and/$or conditions.
-     */
-    $and?: Array<SearchOptions>;
-
-    /**
-     * Recursively applies multiple conditions, at least one of which must evaluate to true.
-     * Can include other operators such as $lt, $type, or nested $and/$or conditions.
-     */
-    $or?: Array<SearchOptions>;
-
-    /**
-     * Negates a single condition.
-     * Can include any other operator as its value.
-     */
-    $not?: SearchOptions;
-};
-
-/** Comparison Operators */
-export type ComparisonOperators = {
-    $gt?: Record<string, number>;
-    $lt?: Record<string, number>;
-    $gte?: Record<string, number>;
-    $lte?: Record<string, number>;
-    $in?: Record<string, any[]>;
-    $nin?: Record<string, any[]>;
-    $between?: Record<string, [number, number]>;
-};
-
-/** Type and Existence Operators */
-export type TypeAndExistenceOperators = {
-    $exists?: Record<string, boolean>;
-    $type?: Record<string, string>;
-};
-
-/** Array Operators */
-export type ArrayOperators = {
-    $arrinc?: Record<string, any[]>;
-    $arrincall?: Record<string, any[]>;
-    $size?: Record<string, number>;
-};
-
-/** String Operators */
-export type StringOperators = {
-    $regex?: Record<string, RegExp>;
-    $startsWith?: Record<string, string>;
-    $endsWith?: Record<string, string>;
-};
-
-/** Other Operators */
-export type OtherOperators = {
-    $subset?: Record<string, any>;
-};
-
-/** Predefined Search Operators */
-export type PredefinedSearchOperators = LogicalOperators &
-    ComparisonOperators &
-    TypeAndExistenceOperators &
-    ArrayOperators &
-    StringOperators &
-    OtherOperators;
-
-/**
- * SearchOptions can be either a function or an object with predefined operators.
- */
-export type SearchOptions = PredefinedSearchOperators & Arg;

package/src/types/types.ts

@@ -1,3 +0,0 @@
-export interface VContext {
-    [key: string]: any
-}

package/src/types/updater.ts

@@ -1,33 +0,0 @@
-/**
- * Predefined type for updating data.
- */
-
-/** Arrays */
-export type ArrayUpdater = {
-    $push?: any,
-    /** Pushes items into an array and removes duplicates */
-    $pushset?: any,
-    $pull?: any,
-    $pullall?: any,
-}
-
-/** Objects */
-export type ObjectUpdater = {
-    $merge?: any,
-}
-
-/** Values */
-export type ValueUpdater = {
-    $set?: any,
-    $inc?: any,
-    $dec?: any,
-    $unset?: any,
-    $rename?: any,
-}
-
-
-export type UpdaterArg =
-    ArrayUpdater &
-    ObjectUpdater &
-    ValueUpdater &
-    { [key: string]: any };

package/src/types/valthera.ts

@@ -1,38 +0,0 @@
-import CollectionManager from "../helpers/CollectionManager";
-import { Arg, Search, Updater } from "./arg";
-import Data from "./data";
-import { DbFindOpts, FindOpts } from "./options";
-import { VQuery } from "./query";
-import { VContext } from "./types";
-
-export interface ValtheraCompatible {
-    c(collection: string): CollectionManager;
-    getCollections(): Promise<string[]>;
-    checkCollection(collection: string): Promise<boolean>;
-    issetCollection(collection: string): Promise<boolean>;
-    add<T = Data>(collection: string, data: Arg, id_gen?: boolean): Promise<T>;
-    find<T = Data>(collection: string, search: Search, context?: VContext, options?: DbFindOpts, findOpts?: FindOpts): Promise<T[]>;
-    findOne<T = Data>(collection: string, search: Search, context?: VContext, findOpts?: FindOpts): Promise<T | null>;
-    update(collection: string, search: Search, updater: Updater, context?: VContext): Promise<boolean>;
-    updateOne(collection: string, search: Search, updater: Updater, context?: VContext): Promise<boolean>;
-    remove(collection: string, search: Search, context?: VContext): Promise<boolean>;
-    removeOne(collection: string, search: Search, context?: VContext): Promise<boolean>;
-    removeCollection(collection: string): Promise<boolean>;
-    updateOneOrAdd(collection: string, search: Search, updater: Updater, add_arg?: Arg, context?: VContext, id_gen?: boolean): Promise<boolean>;
-}
-
-export interface ValtheraCompatibleInternal {
-    c(config: VQuery): CollectionManager;
-    getCollections(): Promise<string[]>;
-    checkCollection(config: VQuery): Promise<boolean>;
-    issetCollection(config: VQuery): Promise<boolean>;
-    add<T = Data>(config: VQuery): Promise<T>;
-    find<T = Data>(config: VQuery): Promise<T[]>;
-    findOne<T = Data>(config: VQuery): Promise<T | null>;
-    update(config: VQuery): Promise<boolean>;
-    updateOne(config: VQuery): Promise<boolean>;
-    remove(config: VQuery): Promise<boolean>;
-    removeOne(config: VQuery): Promise<boolean>;
-    removeCollection(config: VQuery): Promise<boolean>;
-    updateOneOrAdd(config: VQuery): Promise<boolean>;
-}

package/src/utils/hasFields.ts

@@ -1,18 +0,0 @@
-/**
- * Checks if an object matches the standard field comparison.
- * @param obj - The object to check.
- * @param fields - Criteria to compare.
- * @returns Whether the object matches the criteria.
- */
-export default function hasFields(obj: Object, fields: Object): boolean {
-    const keys = Object.keys(fields);
-    return keys.every(key => {
-        if (obj[key] !== undefined) {
-            if (typeof fields[key] === "object" && fields[key] !== null) {
-                return hasFields(obj[key], fields[key]);
-            }
-            return obj[key] === fields[key];
-        }
-        return false;
-    });
-}

package/src/utils/hasFieldsAdvanced.ts

@@ -1,181 +0,0 @@
-import { Arg } from "../types/arg";
-import hasFields from "./hasFields";
-
-/**
- * Checks if an object meets the criteria specified in the fields with operators.
- */
-export default function hasFieldsAdvanced(obj: Object, fields: Arg) {
-    if (typeof fields !== "object" || fields === null) {
-        throw new Error("Fields must be an object");
-    }
-
-    if ("$and" in fields) {
-        return fields["$and"].every(subFields => hasFieldsAdvanced(obj, subFields));
-    }
-
-    if ("$or" in fields) {
-        return fields["$or"].some(subFields => hasFieldsAdvanced(obj, subFields));
-    }
-
-    // Check various conditions
-    if (!checkConditions(obj, fields)) return false;
-    const fieldsSubset = removeAdvancedOperators({ ...fields });
-    return hasFields(obj, fieldsSubset);
-}
-
-function removeAdvancedOperators(fields: Object) {
-    const advancedOperators = [
-        "and", "or",
-        "gt", "lt", "gte", "lte", "in", "nin",
-        "exists",
-        "type",
-        "regex",
-        "arrinc", "arrincall", "size",
-        "startsWith", "endsWith",
-        "between",
-        "not",
-        "subset"
-    ].map(operator => "$" + operator);
-    advancedOperators.forEach(operator => delete fields[operator]);
-    return fields;
-}
-
-function checkConditions(obj: Object, fields: Object) {
-    return (
-        checkComparison(obj, fields) &&
-        checkExistence(obj, fields) &&
-        checkType(obj, fields) &&
-        checkRegex(obj, fields) &&
-        checkArrayConditions(obj, fields) &&
-        checkStringConditions(obj, fields) &&
-        checkBetween(obj, fields) &&
-        checkNot(obj, fields) &&
-        checkSubset(obj, fields)
-    );
-}
-
-function checkComparison(obj: Object, fields: Object) {
-    const comparisonOperators = ["$gt", "$lt", "$gte", "$lte", "$in", "$nin"];
-    for (const operator of comparisonOperators) {
-        if (operator in fields) {
-            for (const entries of Object.entries(fields[operator])) {
-                const [key, value]: [string, any] = entries;
-                switch (operator) {
-                    case "$gt":
-                        if (!(obj[key] > value)) return false;
-                        break;
-                    case "$lt":
-                        if (!(obj[key] < value)) return false;
-                        break;
-                    case "$gte":
-                        if (!(obj[key] >= value)) return false;
-                        break;
-                    case "$lte":
-                        if (!(obj[key] <= value)) return false;
-                        break;
-                    case "$in":
-                        if (!value.includes(obj[key])) return false;
-                        break;
-                    case "$nin":
-                        if (value.includes(obj[key])) return false;
-                        break;
-                }
-            }
-        }
-    }
-    return true;
-}
-
-function checkExistence(obj: Object, fields: Object) {
-    if ("$exists" in fields) {
-        for (const [key, shouldExist] of Object.entries(fields["$exists"])) {
-            if (shouldExist && !(key in obj)) return false;
-            if (!shouldExist && (key in obj)) return false;
-        }
-    }
-    return true;
-}
-
-function checkType(obj: Object, fields: Object) {
-    if ("$type" in fields) {
-        for (const [key, type] of Object.entries(fields["$type"])) {
-            if (typeof obj[key] !== type) return false;
-        }
-    }
-    return true;
-}
-
-function checkRegex(obj: Object, fields: Object) {
-    if ("$regex" in fields) {
-        for (const [key, regex] of Object.entries(fields["$regex"])) {
-            if (!regex.test(obj[key])) return false;
-        }
-    }
-    return true;
-}
-
-function checkArrayConditions(obj: Object, fields: Object) {
-    if ("$arrinc" in fields) {
-        for (const [key, values] of Object.entries(fields["$arrinc"])) {
-            if (!Array.isArray(obj[key]) || !values.some(val => obj[key].includes(val))) return false;
-        }
-    }
-
-    if ("$arrincall" in fields) {
-        for (const [key, values] of Object.entries(fields["$arrincall"])) {
-            if (!Array.isArray(obj[key]) || !values.every(val => obj[key].includes(val))) return false;
-        }
-    }
-
-    if ("$size" in fields) {
-        for (const [key, size] of Object.entries(fields["$size"])) {
-            if (Array.isArray(obj[key]) || typeof obj[key] === "string") {
-                if (obj[key].length !== size) return false;
-            } else {
-                return false;
-            }
-        }
-    }
-
-    return true;
-}
-
-function checkStringConditions(obj: Object, fields: Object) {
-    if ("$startsWith" in fields) {
-        for (const [key, value] of Object.entries(fields["$startsWith"])) {
-            if (typeof obj[key] !== "string" || !obj[key].startsWith(value)) return false;
-        }
-    }
-
-    if ("$endsWith" in fields) {
-        for (const [key, value] of Object.entries(fields["$endsWith"])) {
-            if (typeof obj[key] !== "string" || !obj[key].endsWith(value)) return false;
-        }
-    }
-
-    return true;
-}
-
-function checkBetween(obj: Object, fields: Object) {
-    if ("$between" in fields) {
-        for (const [key, [min, max]] of Object.entries(fields["$between"])) {
-            if (typeof obj[key] !== "number" || obj[key] < min || obj[key] > max) return false;
-        }
-    }
-    return true;
-}
-
-function checkNot(obj: Object, fields: Object) {
-    if ("$not" in fields) {
-        return !hasFieldsAdvanced(obj, fields["$not"]);
-    }
-    return true;
-}
-
-function checkSubset(obj: Object, fields: Object) {
-    if ("$subset" in fields) {
-        const setFields = fields["$subset"];
-        return hasFields(obj, setFields);
-    }
-    return true;
-}

package/src/utils/sort.ts

@@ -1,25 +0,0 @@
-export function compareSafe(a: any, b: any): -1 | 0 | 1 {
-    // Null/undefined at the end
-    if (a == null && b != null) return 1;
-    if (a != null && b == null) return -1;
-    if (a == null && b == null) return 0;
-
-    // Compare primitives and Date
-    const typeA = typeof a;
-    const typeB = typeof b;
-
-    if (typeA === "string" && typeB === "string") {
-        return a.localeCompare(b);
-    }
-
-    if ((typeA === "number" || a instanceof Date) && (typeB === "number" || b instanceof Date)) {
-        return (a < b) ? -1 : (a > b) ? 1 : 0;
-    }
-
-    if (typeA === "boolean" && typeB === "boolean") {
-        return (a === b) ? 0 : a ? 1 : -1;
-    }
-
-    // fallback: if both are objects/arrays or different types, consider equal
-    return 0;
-}

package/src/utils/updateFindObject.ts

@@ -1,35 +0,0 @@
-import { FindOpts } from "../types/options";
-
-/**
- * Updates an object with new values from a findOpts 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: Object, findOpts: FindOpts) {
-    const {
-        transform,
-        select,
-        exclude,
-    } = findOpts;
-
-    if (typeof transform === "function") obj = transform(obj);
-
-    if (Array.isArray(exclude)) {
-        exclude.forEach(field => {
-            if (obj.hasOwnProperty(field)) delete obj[field];
-        });
-    }
-
-    if (Array.isArray(select)) {
-        obj = select.reduce((acc, field) => {
-            if (obj.hasOwnProperty(field)) acc[field] = obj[field];
-            return acc;
-        }, {});
-    }
-
-    return obj;
-}