@connecttomahdi/rxdb 17.0.0-beta.17

package/src/rx-error.ts

@@ -0,0 +1,190 @@
+/**
+ * here we use custom errors with the additional field 'parameters'
+ */
+
+import { overwritable } from './overwritable.ts';
+import type {
+    RxErrorParameters,
+    RxErrorKey,
+    RxStorageWriteError,
+    RxStorageWriteErrorConflict
+} from './types/index.d.ts';
+
+/**
+ * transform an object of parameters to a presentable string
+ */
+function parametersToString(parameters: any): string {
+    let ret = '';
+    if (Object.keys(parameters).length === 0)
+        return ret;
+    ret += '-'.repeat(20) + '\n';
+    ret += 'Parameters:\n';
+    ret += Object.keys(parameters)
+        .map(k => {
+            let paramStr = '[object Object]';
+            try {
+                if (k === 'errors') {
+                    paramStr = parameters[k].map((err: any) => JSON.stringify(err, Object.getOwnPropertyNames(err)));
+                } else {
+                    paramStr = JSON.stringify(parameters[k], function (_k, v) {
+                        return v === undefined ? null : v;
+                    }, 2);
+                }
+            } catch (e) { }
+            return k + ': ' + paramStr;
+        })
+        .join('\n');
+    ret += '\n';
+    return ret;
+}
+
+function messageForError(
+    message: string,
+    code: string,
+    parameters: any
+): string {
+    return '' + '\n' +
+        message + '\n' +
+        parametersToString(parameters);
+}
+
+export class RxError extends Error {
+    public code: RxErrorKey;
+    public message: string;
+    public url: string;
+    public parameters: RxErrorParameters;
+    // always true, use this to detect if it's an rxdb-error
+    public rxdb: true;
+    constructor(
+        code: RxErrorKey,
+        message: string,
+        parameters: RxErrorParameters = {}
+    ) {
+        const mes = messageForError(message, code, parameters);
+        super(mes);
+        this.code = code;
+        this.message = mes;
+        this.url = getErrorUrl(code);
+        this.parameters = parameters;
+        this.rxdb = true; // tag them as internal
+    }
+    get name(): string {
+        return 'RxError (' + this.code + ')';
+    }
+    toString(): string {
+        return this.message;
+    }
+    get typeError(): boolean {
+        return false;
+    }
+}
+
+export class RxTypeError extends TypeError {
+    public code: RxErrorKey;
+    public message: string;
+    public url: string;
+    public parameters: RxErrorParameters;
+    // always true, use this to detect if it's an rxdb-error
+    public rxdb: true;
+    constructor(
+        code: RxErrorKey,
+        message: string,
+        parameters: RxErrorParameters = {}
+    ) {
+        const mes = messageForError(message, code, parameters);
+        super(mes);
+        this.code = code;
+        this.message = mes;
+        this.url = getErrorUrl(code);
+        this.parameters = parameters;
+        this.rxdb = true; // tag them as internal
+    }
+    get name(): string {
+        return 'RxTypeError (' + this.code + ')';
+    }
+    toString(): string {
+        return this.message;
+    }
+    get typeError(): boolean {
+        return true;
+    }
+}
+
+
+export function getErrorUrl(code: RxErrorKey) {
+    return 'https://rxdb.info/errors.html?console=errors#' + code;
+}
+
+export function errorUrlHint(code: RxErrorKey) {
+    return '\nFind out more about this error here: ' + getErrorUrl(code) + ' \n';
+}
+
+export function newRxError(
+    code: RxErrorKey,
+    parameters?: RxErrorParameters
+): RxError {
+    return new RxError(
+        code,
+        overwritable.tunnelErrorMessage(code) + errorUrlHint(code),
+        parameters
+    );
+}
+
+export function newRxTypeError(
+    code: RxErrorKey,
+    parameters?: RxErrorParameters
+): RxTypeError {
+    return new RxTypeError(
+        code,
+        overwritable.tunnelErrorMessage(code) + errorUrlHint(code),
+        parameters
+    );
+}
+
+
+/**
+ * Returns the error if it is a 409 conflict,
+ * return false if it is another error.
+ */
+export function isBulkWriteConflictError<RxDocType>(
+    err?: RxStorageWriteError<RxDocType> | any
+): RxStorageWriteErrorConflict<RxDocType> | false {
+    if (
+        err &&
+        err.status === 409
+    ) {
+        return err;
+    } else {
+        return false;
+    }
+}
+
+
+const STORAGE_WRITE_ERROR_CODE_TO_MESSAGE: { [k: number]: string; } = {
+    409: 'document write conflict',
+    422: 'schema validation error',
+    510: 'attachment data missing'
+};
+
+export function rxStorageWriteErrorToRxError(err: RxStorageWriteError<any>): RxError {
+    return newRxError('COL20', {
+        name: STORAGE_WRITE_ERROR_CODE_TO_MESSAGE[err.status],
+        document: err.documentId,
+        writeError: err
+    });
+}
+
+export async function newRxFetchError(
+    input: Response,
+    additionalParameters?: RxErrorParameters
+): Promise<RxError> {
+    const errorText = await input.text().catch(() => '');
+    const parameters: RxErrorParameters = {
+        ...additionalParameters,
+        ...(input.url ? { url: input.url } : {}),
+        ...(input.status ? { status: input.status } : {}),
+        ...(input.statusText ? { statusText: input.statusText } : {}),
+        ...(errorText ? { errorText } : {})
+    };
+    return newRxError('FETCH', parameters);
+}

package/src/rx-query-helper.ts

@@ -0,0 +1,317 @@
+import { LOGICAL_OPERATORS, getQueryPlan } from './query-planner.ts';
+import { getPrimaryFieldOfPrimaryKey } from './rx-schema-helper.ts';
+import type {
+    DeepReadonly,
+    DeterministicSortComparator,
+    FilledMangoQuery,
+    MangoQuery,
+    MangoQuerySortDirection,
+    PreparedQuery,
+    QueryMatcher,
+    RxDocument,
+    RxDocumentData,
+    RxJsonSchema,
+    RxQuery
+} from './types/index.d.ts';
+import {
+    clone,
+    firstPropertyNameOfObject,
+    toArray,
+    isMaybeReadonlyArray,
+    objectPathMonad,
+    ObjectPathMonadFunction
+} from './plugins/utils/index.ts';
+import {
+    compare as mingoSortComparator
+} from 'mingo/util';
+import { newRxError } from './rx-error.ts';
+import { getMingoQuery } from './rx-query-mingo.ts';
+
+/**
+ * Normalize the query to ensure we have all fields set
+ * and queries that represent the same query logic are detected as equal by the caching.
+ */
+export function normalizeMangoQuery<RxDocType>(
+    schema: RxJsonSchema<RxDocumentData<RxDocType>>,
+    mangoQuery: MangoQuery<RxDocType>,
+    /**
+     * @performance
+     * Count queries do not need sort order.
+     * Skipping the sort computation avoids iterating over schema indexes
+     * and comparing fields, which improves count query performance.
+     */
+    skipSort?: boolean
+): FilledMangoQuery<RxDocType> {
+    const primaryKey: string = getPrimaryFieldOfPrimaryKey(schema.primaryKey);
+
+    const normalizedMangoQuery: FilledMangoQuery<RxDocType> = clone(mangoQuery) as any;
+    if (typeof normalizedMangoQuery.skip !== 'number') {
+        normalizedMangoQuery.skip = 0;
+    }
+
+    if (!normalizedMangoQuery.selector) {
+        normalizedMangoQuery.selector = {};
+    } else {
+        normalizedMangoQuery.selector = normalizedMangoQuery.selector;
+        /**
+         * In mango query, it is possible to have an
+         * equals comparison by directly assigning a value
+         * to a property, without the '$eq' operator.
+         * Like:
+         * selector: {
+         *   foo: 'bar'
+         * }
+         * For normalization, we have to normalize this
+         * so our checks can perform properly.
+         *
+         *
+         * TODO this must work recursive with nested queries that
+         * contain multiple selectors via $and or $or etc.
+         */
+        Object
+            .entries(normalizedMangoQuery.selector)
+            .forEach(([field, matcher]) => {
+                if (typeof matcher !== 'object' || matcher === null) {
+                    (normalizedMangoQuery as any).selector[field] = {
+                        $eq: matcher
+                    };
+                }
+            });
+    }
+
+    /**
+     * Ensure that if an index is specified,
+     * the primaryKey is inside of it.
+     */
+    if (normalizedMangoQuery.index) {
+        const indexAr = toArray(normalizedMangoQuery.index);
+        if (!indexAr.includes(primaryKey)) {
+            indexAr.push(primaryKey);
+        }
+        normalizedMangoQuery.index = indexAr;
+    }
+
+    /**
+     * To ensure a deterministic sorting,
+     * we have to ensure the primary key is always part
+     * of the sort query.
+     * Primary sorting is added as last sort parameter,
+     * similar to how we add the primary key to indexes that do not have it.
+     *
+     */
+    if (skipSort && !normalizedMangoQuery.sort) {
+        /**
+         * @performance
+         * Count queries do not need sorted results.
+         * Use a simple primary key sort to avoid the expensive
+         * index-matching sort computation.
+         */
+        normalizedMangoQuery.sort = [{ [primaryKey]: 'asc' }] as any;
+    } else if (!normalizedMangoQuery.sort) {
+        /**
+         * If no sort is given at all,
+         * we can assume that the user does not care about sort order at al.
+         *
+         * we cannot just use the primary key as sort parameter
+         * because it would likely cause the query to run over the primary key index
+         * which has a bad performance in most cases.
+         */
+        if (normalizedMangoQuery.index) {
+            normalizedMangoQuery.sort = normalizedMangoQuery.index.map((field: string) => {
+                return { [field as any]: 'asc' } as any;
+            });
+        } else {
+            /**
+             * Find the index that best matches the fields with the logical operators
+             */
+            if (schema.indexes) {
+                const fieldsWithLogicalOperator: Set<string> = new Set();
+                Object.entries(normalizedMangoQuery.selector).forEach(([field, matcher]) => {
+                    let hasLogical;
+                    if (typeof matcher === 'object' && matcher !== null) {
+                        hasLogical = !!Object.keys(matcher).find(operator => LOGICAL_OPERATORS.has(operator));
+                    } else {
+                        hasLogical = true;
+                    }
+                    if (hasLogical) {
+                        fieldsWithLogicalOperator.add(field);
+                    }
+                });
+
+
+                let currentFieldsAmount = -1;
+                let currentBestIndexForSort: string[] | readonly string[] | undefined;
+                schema.indexes.forEach(index => {
+                    const useIndex = isMaybeReadonlyArray(index) ? index : [index];
+                    const firstWrongIndex = useIndex.findIndex(indexField => !fieldsWithLogicalOperator.has(indexField));
+                    if (
+                        firstWrongIndex > 0 &&
+                        firstWrongIndex > currentFieldsAmount
+                    ) {
+                        currentFieldsAmount = firstWrongIndex;
+                        currentBestIndexForSort = useIndex;
+                    }
+                });
+                if (currentBestIndexForSort) {
+                    normalizedMangoQuery.sort = currentBestIndexForSort.map((field: string) => {
+                        return { [field as any]: 'asc' } as any;
+                    });
+                }
+
+            }
+
+            /**
+             * If no good index was found as default sort-order,
+             * just use the first index of the schema.
+             * If no index is in the schema, use the default-index which
+             * is created by RxDB ONLY if there is no other index defined.
+             */
+            if (!normalizedMangoQuery.sort) {
+                if (schema.indexes && schema.indexes.length > 0) {
+                    const firstIndex = schema.indexes[0];
+                    const useIndex = isMaybeReadonlyArray(firstIndex) ? firstIndex : [firstIndex];
+                    normalizedMangoQuery.sort = useIndex.map(field => ({ [field]: 'asc' })) as any;
+                } else {
+                    normalizedMangoQuery.sort = [{ [primaryKey]: 'asc' }] as any;
+                }
+            }
+        }
+    } else {
+        const isPrimaryInSort = normalizedMangoQuery.sort
+            .find(p => firstPropertyNameOfObject(p) === primaryKey);
+        if (!isPrimaryInSort) {
+            normalizedMangoQuery.sort = normalizedMangoQuery.sort.slice(0);
+            normalizedMangoQuery.sort.push({ [primaryKey]: 'asc' } as any);
+        }
+    }
+
+    return normalizedMangoQuery;
+}
+
+/**
+ * Returns the sort-comparator,
+ * which is able to sort documents in the same way
+ * a query over the db would do.
+ */
+export function getSortComparator<RxDocType>(
+    schema: RxJsonSchema<RxDocumentData<RxDocType>>,
+    query: FilledMangoQuery<RxDocType>
+): DeterministicSortComparator<RxDocType> {
+    if (!query.sort) {
+        throw newRxError('SNH', { query });
+    }
+    const sortParts: {
+        key: string;
+        direction: MangoQuerySortDirection;
+        getValueFn: ObjectPathMonadFunction<RxDocType>;
+    }[] = [];
+    query.sort.forEach(sortBlock => {
+        const key = Object.keys(sortBlock)[0];
+        const direction = Object.values(sortBlock)[0];
+        sortParts.push({
+            key,
+            direction,
+            getValueFn: objectPathMonad(key)
+        });
+    });
+    const fun: DeterministicSortComparator<RxDocType> = (a: RxDocType, b: RxDocType) => {
+        for (let i = 0; i < sortParts.length; ++i) {
+            const sortPart = sortParts[i];
+            const valueA = sortPart.getValueFn(a);
+            const valueB = sortPart.getValueFn(b);
+            if (valueA !== valueB) {
+                /**
+                 * @performance
+                 * Use a fast inline comparison for common types (string, number)
+                 * instead of the more general mingoSortComparator.
+                 * Mingo's compare does extra type checks that are unnecessary
+                 * when both values share the same primitive type.
+                 */
+                const dirMultiplier = sortPart.direction === 'asc' ? 1 : -1;
+                const typeA = typeof valueA;
+                if (typeA === typeof valueB && (typeA === 'string' || typeA === 'number')) {
+                    return ((valueA < valueB ? -1 : 1) * dirMultiplier) as any;
+                }
+                const ret = sortPart.direction === 'asc' ? mingoSortComparator(valueA, valueB) : mingoSortComparator(valueB, valueA);
+                return ret as any;
+            }
+        }
+    };
+
+    return fun;
+}
+
+
+/**
+ * Returns a function
+ * that can be used to check if a document
+ * matches the query.
+ */
+export function getQueryMatcher<RxDocType>(
+    _schema: RxJsonSchema<RxDocType> | RxJsonSchema<RxDocumentData<RxDocType>>,
+    query: FilledMangoQuery<RxDocType>
+): QueryMatcher<RxDocumentData<RxDocType>> {
+    if (!query.sort) {
+        throw newRxError('SNH', { query });
+    }
+
+    const mingoQuery = getMingoQuery(query.selector as any);
+    const fun: QueryMatcher<RxDocumentData<RxDocType>> = (doc: RxDocumentData<RxDocType> | DeepReadonly<RxDocumentData<RxDocType>>) => {
+        return mingoQuery.test(doc);
+    };
+    return fun;
+}
+
+
+export async function runQueryUpdateFunction<RxDocType, RxQueryResult>(
+    rxQuery: RxQuery<RxDocType, RxQueryResult>,
+    fn: (doc: RxDocument<RxDocType>) => Promise<RxDocument<RxDocType>>
+): Promise<RxQueryResult> {
+    const docs = await rxQuery.exec();
+    if (!docs) {
+        // only findOne() queries can return null
+        return null as any;
+    }
+    if (Array.isArray(docs)) {
+        return Promise.all(
+            docs.map(doc => fn(doc))
+        ) as any;
+    } else if (docs instanceof Map) {
+        return Promise.all(
+            [...docs.values()].map((doc) => fn(doc))
+        ) as any;
+    } else {
+        // via findOne()
+        const result = await fn(docs as any);
+        return result as any;
+    }
+}
+
+/**
+ * @returns a format of the query that can be used with the storage
+ * when calling RxStorageInstance().query()
+ */
+export function prepareQuery<RxDocType>(
+    schema: RxJsonSchema<RxDocumentData<RxDocType>>,
+    mutateableQuery: FilledMangoQuery<RxDocType>
+): PreparedQuery<RxDocType> {
+    if (!mutateableQuery.sort) {
+        throw newRxError('SNH', {
+            query: mutateableQuery
+        });
+    }
+
+    /**
+     * Store the query plan together with the
+     * prepared query to save performance.
+     */
+    const queryPlan = getQueryPlan(
+        schema,
+        mutateableQuery
+    );
+
+    return {
+        query: mutateableQuery,
+        queryPlan
+    };
+}

package/src/rx-query-mingo.ts

@@ -0,0 +1,87 @@
+import { Context } from 'mingo/core';
+import { Query } from 'mingo/query';
+import type { MangoQuerySelector } from './types/index.d.ts';
+import {
+    $project,
+    $sort
+} from 'mingo/operators/pipeline';
+import {
+
+} from 'mingo/operators/expression';
+import {
+} from 'mingo/operators/projection';
+import {
+    $elemMatch,
+    $eq,
+    $nor,
+    $exists,
+    $regex,
+    $ne,
+    $gte,
+    $lt,
+    $lte,
+    $nin,
+    $in,
+    $gt,
+    $or,
+    $and,
+    $not,
+    $type,
+    $size,
+    $mod
+} from 'mingo/operators/query';
+import {
+} from 'mingo/operators/query/evaluation';
+import {
+} from 'mingo/operators/query/array';
+import {
+} from 'mingo/operators/query/element';
+
+let mingoInitDone = false;
+let context: Context;
+
+
+/**
+ * The MongoDB query library is huge and we do not need all the operators.
+ * If you add an operator here, make sure that you properly add a test in
+ * the file /test/unit/rx-storage-query-correctness.test.ts
+ *
+ * @link https://github.com/kofrasa/mingo#es6
+ */
+export function getMingoQuery<RxDocType>(
+    selector?: MangoQuerySelector<RxDocType>
+) {
+    if (!mingoInitDone) {
+        context = Context.init({
+            pipeline: {
+                $sort,
+                $project
+            },
+            query: {
+                $elemMatch,
+                $eq,
+                $nor,
+                $exists,
+                $regex,
+                $and,
+                $gt,
+                $gte,
+                $in,
+                $lt,
+                $lte,
+                $ne,
+                $nin,
+                $mod,
+                $not,
+                $or,
+                $size,
+                $type,
+            },
+        });
+        mingoInitDone = true;
+    }
+
+    return new Query(selector as any, {
+        context
+    });
+}

package/src/rx-query-single-result.ts

@@ -0,0 +1,110 @@
+import { mapDocumentsDataToCacheDocs } from './doc-cache.ts';
+import { now, overwriteGetterForCaching } from './plugins/utils/index.ts';
+import { newRxError } from './rx-error.ts';
+import { RxQueryBase } from './rx-query.ts';
+import type {
+    RxDocument,
+    RxDocumentData
+} from './types';
+
+/**
+ * RxDB needs the query results in multiple formats.
+ * Sometimes as a Map or an array with only the documentData.
+ * For better performance we work with this class
+ * that initializes stuff lazily so that
+ * we can directly work with the query results after RxQuery.exec()
+ */
+export class RxQuerySingleResult<RxDocType> {
+    /**
+     * Time at which the current _result state was created.
+     * Used to determine if the result set has changed since X
+     * so that we do not emit the same result multiple times on subscription.
+     */
+    public readonly time = now();
+    public readonly documents: RxDocument<RxDocType>[];
+    constructor(
+        public readonly query: RxQueryBase<RxDocType, unknown>,
+        // only used internally, do not use outside, use this.docsData instead
+        docsDataFromStorageInstance: RxDocumentData<RxDocType>[],
+        // can be overwritten for count-queries
+        public readonly count: number,
+    ) {
+        /**
+         * @performance Skip document mapping for count queries
+         * since they only need the count number and pass an empty array.
+         */
+        if (query.op === 'count') {
+            this.documents = [];
+        } else {
+            this.documents = mapDocumentsDataToCacheDocs<RxDocType, any>(this.query.collection._docCache, docsDataFromStorageInstance);
+        }
+    }
+
+
+    /**
+     * Instead of using the newResultData in the result cache,
+     * we directly use the objects that are stored in the RxDocument
+     * to ensure we do not store the same data twice and fill up the memory.
+     * @overwrites itself with the actual value
+     */
+    get docsData(): RxDocumentData<RxDocType>[] {
+        return overwriteGetterForCaching(
+            this,
+            'docsData',
+            this.documents.map(d => d._data)
+        );
+    }
+
+
+    // A key->document map, used in the event reduce optimization.
+    get docsDataMap(): Map<string, RxDocumentData<RxDocType>> {
+        const map = new Map<string, RxDocumentData<RxDocType>>();
+        this.documents.forEach(d => {
+            map.set(d.primary, d._data);
+        });
+        return overwriteGetterForCaching(
+            this,
+            'docsDataMap',
+            map
+        );
+    }
+
+    get docsMap(): Map<string, RxDocument<RxDocType>> {
+        const map = new Map<string, RxDocument<RxDocType>>();
+        const documents = this.documents;
+        for (let i = 0; i < documents.length; i++) {
+            const doc = documents[i];
+            map.set(doc.primary, doc);
+        }
+        return overwriteGetterForCaching(
+            this,
+            'docsMap',
+            map
+        );
+    }
+
+    getValue(throwIfMissing?: boolean) {
+        const op = this.query.op;
+        if (op === 'count') {
+            return this.count;
+        } else if (op === 'findOne') {
+            // findOne()-queries emit RxDocument or null
+            const doc = this.documents.length === 0 ? null : this.documents[0];
+            if (!doc && throwIfMissing) {
+                throw newRxError('QU10', {
+                    collection: this.query.collection.name,
+                    query: this.query.mangoQuery,
+                    op
+                });
+            } else {
+                return doc;
+            }
+        } else if (op === 'findByIds') {
+            return this.docsMap;
+        } else {
+            // find()-queries emit RxDocument[]
+            // Flat copy the array so it won't matter if the user modifies it.
+            return this.documents.slice(0);
+        }
+    }
+}