@kidus.dev/flowdb 1.0.0

package/dist/core/collection/query/compares.js

@@ -0,0 +1,362 @@
+// TypeScript version of compares.dart logic
+export const compareMap = {
+    gt: (value) => new Gt(value),
+    gte: (value) => new Gte(value),
+    lt: (value) => new Lt(value),
+    lte: (value) => new Lte(value),
+    eq: (value) => new Eq(value),
+    neq: (value) => new Neq(value),
+    startsWith: (value) => new StartsWith(value),
+    endsWith: (value) => new EndsWith(value),
+    contains: (value) => new Contains(value),
+    doesNotContain: (value) => new DoesNotContain(value),
+    regexMatch: (value) => new RegexMatch(value),
+    between: (value) => new Between(value),
+    betweenStartInclusive: (value) => new Between(value, true, false),
+    betweenEndInclusive: (value) => new Between(value, false, true),
+    betweenBothInclusive: (value) => new Between(value, true, true),
+    isNull: () => new IsNull(),
+    isNotNull: () => new IsNotNull(),
+    isEmpty: () => new Empty(),
+    isNotEmpty: () => new NotEmpty(),
+    filter: (func) => new Filter(func),
+};
+export class Filter {
+    predicate;
+    constructor(predicate) {
+        this.predicate = predicate;
+    }
+    compare(other) {
+        try {
+            return this.predicate(other);
+        }
+        catch {
+            return false;
+        }
+    }
+}
+export class Gt {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    compare(other) {
+        try {
+            if ((typeof other === "number" && typeof this.value === "number") ||
+                (typeof other === "string" && typeof this.value === "string")) {
+                return other > this.value;
+            }
+            if (other instanceof Date && this.value instanceof Date) {
+                return other.getTime() > this.value.getTime();
+            }
+            if (other != null && typeof other.compareTo === "function") {
+                return other.compareTo(this.value) > 0;
+            }
+        }
+        catch { }
+        return false;
+    }
+}
+export class Gte {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    compare(other) {
+        try {
+            if ((typeof other === "number" && typeof this.value === "number") ||
+                (typeof other === "string" && typeof this.value === "string")) {
+                return other >= this.value;
+            }
+            if (other instanceof Date && this.value instanceof Date) {
+                return other.getTime() >= this.value.getTime();
+            }
+            if (other != null && typeof other.compareTo === "function") {
+                return other.compareTo(this.value) >= 0;
+            }
+        }
+        catch { }
+        return false;
+    }
+}
+export class Lt {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    compare(other) {
+        try {
+            if ((typeof other === "number" && typeof this.value === "number") ||
+                (typeof other === "string" && typeof this.value === "string")) {
+                return other < this.value;
+            }
+            if (other instanceof Date && this.value instanceof Date) {
+                return other.getTime() < this.value.getTime();
+            }
+            if (other != null && typeof other.compareTo === "function") {
+                return other.compareTo(this.value) < 0;
+            }
+        }
+        catch { }
+        return false;
+    }
+}
+export class Lte {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    compare(other) {
+        try {
+            if ((typeof other === "number" && typeof this.value === "number") ||
+                (typeof other === "string" && typeof this.value === "string")) {
+                return other <= this.value;
+            }
+            if (other instanceof Date && this.value instanceof Date) {
+                return other.getTime() <= this.value.getTime();
+            }
+            if (other != null && typeof other.compareTo === "function") {
+                return other.compareTo(this.value) <= 0;
+            }
+        }
+        catch { }
+        return false;
+    }
+}
+export class Eq {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    compare(other) {
+        if (other instanceof Date && this.value instanceof Date) {
+            return other.getTime() === this.value.getTime();
+        }
+        return other === this.value;
+    }
+}
+export class Neq {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    compare(other) {
+        if (other instanceof Date && this.value instanceof Date) {
+            return other.getTime() !== this.value.getTime();
+        }
+        return other !== this.value;
+    }
+}
+export class Contains {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    compare(other) {
+        if (Array.isArray(other)) {
+            return other.includes(this.value);
+        }
+        if (typeof other === "string" && typeof this.value === "string") {
+            return other.includes(this.value);
+        }
+        if (other instanceof Set) {
+            return other.has(this.value);
+        }
+        if (typeof other === "object" &&
+            other !== null &&
+            !(other instanceof Set) &&
+            !Array.isArray(other)) {
+            return Object.prototype.hasOwnProperty.call(other, this.value);
+        }
+        return false;
+    }
+}
+export class DoesNotContain {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    compare(other) {
+        if (Array.isArray(other)) {
+            return !other.includes(this.value);
+        }
+        if (typeof other === "string" && typeof this.value === "string") {
+            return !other.includes(this.value);
+        }
+        if (other instanceof Set) {
+            return !other.has(this.value);
+        }
+        if (typeof other === "object" &&
+            other !== null &&
+            !(other instanceof Set) &&
+            !Array.isArray(other)) {
+            return !Object.prototype.hasOwnProperty.call(other, this.value);
+        }
+        return false;
+    }
+}
+export class StartsWith {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    compare(other) {
+        if (typeof other === "string" && typeof this.value === "string") {
+            return other.startsWith(this.value);
+        }
+        if (Array.isArray(other) && other.length > 0) {
+            return other[0] === this.value;
+        }
+        if (other && typeof other[Symbol.iterator] === "function") {
+            const iter = Array.from(other);
+            return iter.length > 0 && iter[0] === this.value;
+        }
+        return false;
+    }
+}
+export class EndsWith {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    compare(other) {
+        if (typeof other === "string" && typeof this.value === "string") {
+            return other.endsWith(this.value);
+        }
+        if (Array.isArray(other) && other.length > 0) {
+            return other[other.length - 1] === this.value;
+        }
+        if (other && typeof other[Symbol.iterator] === "function") {
+            const iter = Array.from(other);
+            return iter.length > 0 && iter[iter.length - 1] === this.value;
+        }
+        return false;
+    }
+}
+export class RegexMatch {
+    pattern;
+    caseSensitive;
+    multiLine;
+    constructor(pattern, caseSensitive = true, multiLine = false) {
+        this.pattern = pattern;
+        this.caseSensitive = caseSensitive;
+        this.multiLine = multiLine;
+    }
+    compare(value) {
+        if (typeof value !== "string")
+            return false;
+        try {
+            const flags = (this.caseSensitive ? "" : "i") + (this.multiLine ? "m" : "");
+            return new RegExp(this.pattern, flags).test(value);
+        }
+        catch {
+            return false;
+        }
+    }
+}
+export class Between {
+    range;
+    includeLower;
+    includeUpper;
+    constructor(range, includeLower = false, includeUpper = false) {
+        this.range = range;
+        this.includeLower = includeLower;
+        this.includeUpper = includeUpper;
+        // If a tuple/array is not passed, try to parse from string/array.
+        if (!Array.isArray(this.range) && typeof this.range === "string") {
+            const parsed = JSON.parse(this.range);
+            if (Array.isArray(parsed) && parsed.length === 2) {
+                this.range = [parsed[0], parsed[1]];
+            }
+            else {
+                this.range = [undefined, undefined];
+            }
+        }
+        // If the range is a date, convert it to a number
+        if (this.range[0] instanceof Date && this.range[1] instanceof Date) {
+            this.range[0] = this.range[0].getTime();
+            this.range[1] = this.range[1].getTime();
+            if (this.includeLower) {
+                this.range[0] = this.range[0] - 1;
+            }
+            if (this.includeUpper) {
+                this.range[1] = this.range[1] + 1;
+            }
+        }
+    }
+    compare(value) {
+        try {
+            const v = value;
+            const low = this.range[0];
+            const high = this.range[1];
+            if ((typeof v === "number" &&
+                typeof low === "number" &&
+                typeof high === "number") ||
+                (typeof v === "string" &&
+                    typeof low === "string" &&
+                    typeof high === "string")) {
+                if (low > high)
+                    return false;
+                const lowComp = v < low ? -1 : v > low ? 1 : 0;
+                const highComp = v < high ? -1 : v > high ? 1 : 0;
+                const lowOk = this.includeLower ? lowComp >= 0 : lowComp > 0;
+                const highOk = this.includeUpper ? highComp <= 0 : highComp < 0;
+                return lowOk && highOk;
+            }
+            if (v instanceof Date && low instanceof Date && high instanceof Date) {
+                return v.getTime() >= low.getTime() && v.getTime() <= high.getTime();
+            }
+            if (v != null && typeof v.compareTo === "function") {
+                return v.compareTo(low) >= 0 && v.compareTo(high) <= 0;
+            }
+        }
+        catch { }
+        return false;
+    }
+}
+export class IsNull {
+    compare(value) {
+        return value == null;
+    }
+}
+export class IsNotNull {
+    compare(value) {
+        return value != null;
+    }
+}
+export class Empty {
+    compare(value) {
+        if (value == null)
+            return false;
+        if (typeof value === "string" || Array.isArray(value)) {
+            return value.length === 0;
+        }
+        if (value instanceof Set || value instanceof Map) {
+            return value.size === 0;
+        }
+        if (typeof value === "object") {
+            return Object.keys(value).length === 0;
+        }
+        return false;
+    }
+}
+export class NotEmpty {
+    compare(value) {
+        if (value == null)
+            return false;
+        if (typeof value === "string" || Array.isArray(value)) {
+            return value.length > 0;
+        }
+        if (value instanceof Set || value instanceof Map) {
+            return value.size > 0;
+        }
+        if (typeof value === "object") {
+            return Object.keys(value).length > 0;
+        }
+        return false;
+    }
+}
+// Factory for creating Compare from key/value
+export function compareFromJson(key, value) {
+    return compareMap[key]?.(value) ?? new Filter(() => true);
+}

package/dist/core/collection/query/filtering.d.ts

@@ -0,0 +1,14 @@
+import Document from "../document";
+import Relation from "./relation";
+import { type SortOrder } from "./compares";
+export declare class Filtering {
+    static matchedDocuments(documents: Document[], conditions: Array<{
+        [key: string]: any;
+    }>): Document[];
+    static sortedDocuments(documents: Document[], orderBys: Record<string, SortOrder>): Document[];
+    static skipAndTakeDocuments(documents: Document[], skip?: number | null, take?: number | null): Document[];
+    static pickAndOmitDocuments(documents: Document[], pick: Set<string>, omit: Set<string>): Document[];
+    static includedDocumentsSync(documents: Document[], includes: Record<string, Relation>): Document[];
+    static includedDocuments(documents: Iterable<Document>, includes: Record<string, Relation>): Promise<Document[]>;
+}
+//# sourceMappingURL=filtering.d.ts.map

package/dist/core/collection/query/filtering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filtering.d.ts","sourceRoot":"","sources":["../../../../src/core/collection/query/filtering.ts"],"names":[],"mappings":"AAEA,OAAO,QAAQ,MAAM,aAAa,CAAC;AACnC,OAAO,QAAQ,MAAM,YAAY,CAAC;AAClC,OAAO,EAAc,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAExD,qBAAa,SAAS;IACpB,MAAM,CAAC,gBAAgB,CACrB,SAAS,EAAE,QAAQ,EAAE,EACrB,UAAU,EAAE,KAAK,CAAC;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAC,GACxC,QAAQ,EAAE;IAsCb,MAAM,CAAC,eAAe,CACpB,SAAS,EAAE,QAAQ,EAAE,EACrB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAClC,QAAQ,EAAE;IA6Cb,MAAM,CAAC,oBAAoB,CACzB,SAAS,EAAE,QAAQ,EAAE,EACrB,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,EACpB,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,GACnB,QAAQ,EAAE;IAOb,MAAM,CAAC,oBAAoB,CACzB,SAAS,EAAE,QAAQ,EAAE,EACrB,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,EACjB,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,GAChB,QAAQ,EAAE;IA8Bb,MAAM,CAAC,qBAAqB,CAC1B,SAAS,EAAE,QAAQ,EAAE,EACrB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,GACjC,QAAQ,EAAE;WAiCA,iBAAiB,CAC5B,SAAS,EAAE,QAAQ,CAAC,QAAQ,CAAC,EAC7B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,GACjC,OAAO,CAAC,QAAQ,EAAE,CAAC;CAgCvB"}

package/dist/core/collection/query/filtering.js

@@ -0,0 +1,176 @@
+// Ported from Filtering.dart
+import Document from "../document";
+import Relation from "./relation";
+import { compareMap } from "./compares";
+export class Filtering {
+    static matchedDocuments(documents, conditions) {
+        const documentsPassed = [];
+        for (const doc of documents) {
+            const results = [];
+            for (const condition of conditions) {
+                const field = condition["field"];
+                const type = condition["type"];
+                const value = doc.data[field];
+                const comparers = Object.entries(condition).filter(([key, val]) => key !== "field" && key !== "type" && val != null);
+                for (const [compKey, compValue] of comparers) {
+                    const compareClass = compareMap[compKey];
+                    if (!compareClass)
+                        continue;
+                    const passed = compareClass(compValue).compare(value);
+                    results.push({ passed, type });
+                }
+            }
+            const hasOrTrue = results.some((res) => res.type === "or" && res.passed === true);
+            const allAndTrue = results
+                .filter((res) => res.type === "and")
+                .every((res) => res.passed === true);
+            if (hasOrTrue || allAndTrue)
+                documentsPassed.push(doc);
+        }
+        return documentsPassed;
+    }
+    static sortedDocuments(documents, orderBys) {
+        const result = [...documents];
+        result.sort((a, b) => {
+            let cmp = 0;
+            for (const [key, order] of Object.entries(orderBys)) {
+                const av = a.data[key];
+                const bv = b.data[key];
+                if (av == null && bv != null) {
+                    cmp = 1;
+                }
+                else if (av != null && bv == null) {
+                    cmp = -1;
+                }
+                else if (av == null && bv == null) {
+                    cmp = 0;
+                }
+                else if ((typeof av === "number" || typeof av === "string") &&
+                    (typeof bv === "number" || typeof bv === "string")) {
+                    cmp =
+                        av > bv ? 1 : av < bv ? -1 : 0;
+                }
+                else if (av instanceof Date && bv instanceof Date) {
+                    cmp =
+                        av.getTime() > bv.getTime()
+                            ? 1
+                            : av.getTime() < bv.getTime()
+                                ? -1
+                                : 0;
+                }
+                else if (av != null &&
+                    typeof av.compareTo === "function" &&
+                    bv != null &&
+                    typeof bv.compareTo === "function") {
+                    cmp = av.compareTo(bv) > 0 ? 1 : av.compareTo(bv) < 0 ? -1 : 0;
+                }
+                else {
+                    cmp = 0;
+                }
+                if (order === "desc")
+                    cmp = -cmp;
+                if (cmp !== 0)
+                    break;
+            }
+            return cmp;
+        });
+        return result;
+    }
+    static skipAndTakeDocuments(documents, skip, take) {
+        let result = [...documents];
+        if (skip != null)
+            result = documents.slice(skip);
+        if (take != null)
+            result = result.slice(0, take);
+        return result;
+    }
+    static pickAndOmitDocuments(documents, pick, omit) {
+        if (pick.size > 0 && omit.size > 0) {
+            throw new Error("Pick and Omit cannot be used together");
+        }
+        if (pick.size > 0) {
+            return Array.from(documents).map((doc) => {
+                const filteredData = {};
+                for (const k of pick) {
+                    if (doc.data.hasOwnProperty(k)) {
+                        filteredData[k] = doc.data[k];
+                    }
+                }
+                // Assume Document.fromJson equivalent is Document.fromJson in JS/TS
+                return Document.fromJson(filteredData);
+            });
+        }
+        if (omit.size > 0) {
+            return Array.from(documents).map((doc) => {
+                const filteredData = {};
+                for (const [k, v] of Object.entries(doc.data)) {
+                    if (!omit.has(k)) {
+                        filteredData[k] = v;
+                    }
+                }
+                return Document.fromJson(filteredData);
+            });
+        }
+        return documents;
+    }
+    static includedDocumentsSync(documents, includes) {
+        for (const document of documents) {
+            for (const relation of Object.values(includes)) {
+                const name = relation.name;
+                const localKey = relation.localKey;
+                const foreignCollection = relation.foreignCollection;
+                const foreignKey = relation.foreignKey;
+                const relationType = relation.type;
+                const collection = foreignCollection;
+                const localKeyValue = document.data[localKey];
+                if (localKeyValue == null)
+                    continue;
+                if (relationType === "oneToOne") {
+                    // getFirstSync must be implemented on collection
+                    const includedRecord = collection
+                        .where(foreignKey, { eq: localKeyValue })
+                        .getFirstSync();
+                    document.data[name] = includedRecord;
+                }
+                else if (relationType === "oneToMany" ||
+                    relationType === "manyToMany") {
+                    const includedDocuments = collection
+                        .where(foreignKey, { eq: localKeyValue })
+                        .getSync();
+                    document.data[name] = includedDocuments;
+                }
+            }
+        }
+        return documents;
+    }
+    static async includedDocuments(documents, includes) {
+        const docs = Array.isArray(documents) ? documents : Array.from(documents);
+        for (const document of docs) {
+            for (const relation of Object.values(includes)) {
+                const name = relation.name;
+                const localKey = relation.localKey;
+                const foreignCollection = relation.foreignCollection;
+                const foreignKey = relation.foreignKey;
+                const relationType = relation.type;
+                const collection = foreignCollection;
+                const localKeyValue = document.data[localKey];
+                if (localKeyValue == null)
+                    continue;
+                if (relationType === "oneToOne") {
+                    const includedRecord = await collection
+                        .where(foreignKey, { eq: localKeyValue })
+                        .getFirst();
+                    document.data[name] = includedRecord;
+                }
+                else if (relationType === "oneToMany" ||
+                    relationType === "manyToMany") {
+                    const includedDocuments = await collection
+                        .where(foreignKey, { eq: localKeyValue })
+                        .get();
+                    document.data[name] = includedDocuments;
+                }
+            }
+        }
+        return docs;
+    }
+}

package/dist/core/collection/query/query_builder.d.ts

@@ -0,0 +1,145 @@
+import Collection from "../collection";
+import Document from "../document";
+import CollectionOperations from "../driver/collection_operations";
+import QueryExecutor from "./query_executor";
+type BetweenArg = [any, any];
+export default class QueryBuilder {
+    private readonly _executor;
+    constructor({ debug, safe, collection, collectionOperations, }: {
+        debug?: boolean;
+        safe?: boolean;
+        collection: Collection;
+        collectionOperations: CollectionOperations;
+    });
+    get executor(): QueryExecutor;
+    where(field: string, opts?: {
+        eq?: any;
+        neq?: any;
+        gt?: any;
+        gte?: any;
+        lt?: any;
+        lte?: any;
+        contains?: any;
+        doesNotContain?: any;
+        startsWith?: string;
+        endsWith?: string;
+        regexMatch?: string;
+        between?: BetweenArg;
+        betweenStartInclusive?: BetweenArg;
+        betweenEndInclusive?: BetweenArg;
+        betweenBothInclusive?: BetweenArg;
+        isNull?: boolean;
+        isNotNull?: boolean;
+        isEmpty?: boolean;
+        isNotEmpty?: boolean;
+        filter?: (value: any) => boolean;
+    }): this;
+    and(field: string, opts?: {
+        eq?: any;
+        neq?: any;
+        gt?: any;
+        gte?: any;
+        lt?: any;
+        lte?: any;
+        contains?: any;
+        doesNotContain?: any;
+        startsWith?: string;
+        endsWith?: string;
+        regexMatch?: string;
+        between?: BetweenArg;
+        betweenStartInclusive?: BetweenArg;
+        betweenEndInclusive?: BetweenArg;
+        betweenBothInclusive?: BetweenArg;
+        isNull?: boolean;
+        isNotNull?: boolean;
+        isEmpty?: boolean;
+        isNotEmpty?: boolean;
+        filter?: (value: any) => boolean;
+    }): this;
+    or(field: string, opts?: {
+        eq?: any;
+        neq?: any;
+        gt?: any;
+        gte?: any;
+        lt?: any;
+        lte?: any;
+        contains?: any;
+        doesNotContain?: any;
+        startsWith?: string;
+        endsWith?: string;
+        regexMatch?: string;
+        between?: BetweenArg;
+        betweenStartInclusive?: BetweenArg;
+        betweenEndInclusive?: BetweenArg;
+        betweenBothInclusive?: BetweenArg;
+        isNull?: boolean;
+        isNotNull?: boolean;
+        isEmpty?: boolean;
+        isNotEmpty?: boolean;
+        filter?: (value: any) => boolean;
+    }): this;
+    pick(field: string): this;
+    pickMany(fields: string[]): this;
+    omit(field: string): this;
+    omitMany(fields: string[]): this;
+    skip(skip: number): this;
+    limit(limit: number): this;
+    take(take: number): this;
+    skipAndTake({ skip, take }?: {
+        skip?: number;
+        take?: number;
+    }): this;
+    orderBy(field: string, { desc }?: {
+        desc?: boolean;
+    }): this;
+    include(name: string): this;
+    includeMany(names: string[]): this;
+    get(): Promise<Document[]>;
+    getSync(): Document[];
+    getRandom(): Promise<Document | undefined>;
+    getRandomSync(): Document | undefined;
+    getShuffled(): Promise<Document[]>;
+    getShuffledSync(): Document[];
+    getRandomMany(count?: number): Promise<Document[]>;
+    getRandomManySync(count?: number): Document[];
+    getFirst(): Promise<Document | undefined>;
+    getFirstSync(): Document | undefined;
+    getLast(): Promise<Document | undefined>;
+    getLastSync(): Document | undefined;
+    getAt(index: number): Promise<Document | undefined>;
+    getAtSync(index: number): Document | undefined;
+    count(): Promise<number>;
+    countSync(): number;
+    update(data: Record<string, any>): Promise<Document | undefined>;
+    updateSync(data: Record<string, any>): Document | undefined;
+    updateFrom(update: (data: Record<string, any>) => Record<string, any>): Promise<Document | undefined>;
+    updateFromSync(update: (data: Record<string, any>) => Record<string, any>): Document | undefined;
+    updateMany(data: Record<string, any>, { count }?: {
+        count?: number;
+    }): Promise<Document[]>;
+    updateManySync(data: Record<string, any>, { count }?: {
+        count?: number;
+    }): Document[];
+    updateManyFrom(update: (data: Record<string, any>) => Record<string, any>, { count }?: {
+        count?: number;
+    }): Promise<Document[]>;
+    updateManyFromSync(update: (data: Record<string, any>) => Record<string, any>, { count }?: {
+        count?: number;
+    }): Document[];
+    delete(): Promise<Document | undefined>;
+    deleteSync(): Document | undefined;
+    deleteMany(): Promise<Document[]>;
+    deleteManySync(): Document[];
+    upsert({ update, insert, }: {
+        update: Record<string, any>;
+        insert: Record<string, any>;
+    }): Promise<Document | undefined>;
+    upsertSync({ update, insert, }: {
+        update: Record<string, any>;
+        insert: Record<string, any>;
+    }): Document | undefined;
+    addIfAbsent(data: Record<string, any>): Promise<Document | undefined>;
+    addIfAbsentSync(data: Record<string, any>): Document | undefined;
+}
+export {};
+//# sourceMappingURL=query_builder.d.ts.map