@connecttomahdi/rxdb 17.0.0-beta.17

package/src/plugins/utils/utils-other.ts

@@ -0,0 +1,58 @@
+export function runXTimes(xTimes: number, fn: (idx: number) => void) {
+    new Array(xTimes).fill(0).forEach((_v, idx) => fn(idx));
+}
+
+export function ensureNotFalsy<T>(obj: T | false | undefined | null, message?: string): T {
+    if (!obj) {
+        if (!message) {
+            message = '';
+        }
+        throw new Error('ensureNotFalsy() is falsy: ' + message);
+    }
+    return obj;
+}
+
+export function ensureInteger(obj: unknown): number {
+    if (!Number.isInteger(obj)) {
+        throw new Error('ensureInteger() is falsy');
+    }
+    return obj as number;
+}
+
+/**
+ * Using shareReplay() without settings will not unsubscribe
+ * if there are no more subscribers.
+ * So we use these defaults.
+ * @link https://cartant.medium.com/rxjs-whats-changed-with-sharereplay-65c098843e95
+ */
+export const RXJS_SHARE_REPLAY_DEFAULTS = {
+    bufferSize: 1,
+    refCount: true
+};
+
+
+
+/**
+ * Dynamically add a name to a function
+ * so that it can later be found in the stack.
+ * @link https://stackoverflow.com/a/41854075/3443137
+ */
+export function nameFunction<T>(name: string, body: T): T {
+    // @ts-ignore
+    return { [name](...args) { return body.apply(this, args) } }[name];
+}
+
+
+export function customFetchWithFixedHeaders(headers: any){
+    function customFetch(url: string | URL, options: any = {}) {
+        // Ensure options object exists and headers property is initialized
+        options.headers = {
+            ...headers,              // include default custom headers
+            ...(options.headers || {})            // merge any headers passed in the function call
+        };
+
+        // Call the original fetch with the modified options
+        return fetch(url, options);
+    }
+    return customFetch;
+}

package/src/plugins/utils/utils-premium.ts

@@ -0,0 +1,37 @@
+import { RXDB_UTILS_GLOBAL } from './utils-global.ts';
+import { defaultHashSha256 } from './utils-hash.ts';
+import { PROMISE_RESOLVE_FALSE } from './utils-promise.ts';
+
+export const PREMIUM_FLAG_HASH = '6da4936d1425ff3a5c44c02342c6daf791d266be3ae8479b8ec59e261df41b93';
+export const NON_PREMIUM_COLLECTION_LIMIT = 999;
+
+let hasPremiumPromise: Promise<boolean> = PROMISE_RESOLVE_FALSE;
+let premiumChecked = false;
+
+/**
+ * Here we check if the premium flag has been set.
+ * This code exists in the open source version of RxDB.
+ * Yes you are allowed to fork the repo and just overwrite this function.
+ * However you might better spend this time developing your real project
+ * and supporting the RxDB efforts by buying premium.
+ */
+export async function hasPremiumFlag() {
+    if (premiumChecked) {
+        return hasPremiumPromise;
+    }
+    premiumChecked = true;
+
+    hasPremiumPromise = (async () => {
+        if (
+            RXDB_UTILS_GLOBAL.premium &&
+            typeof RXDB_UTILS_GLOBAL.premium === 'string' &&
+            (await defaultHashSha256(RXDB_UTILS_GLOBAL.premium) === PREMIUM_FLAG_HASH)
+        ) {
+            return true;
+        } else {
+            return false;
+        }
+    })();
+
+    return hasPremiumPromise;
+}

package/src/plugins/utils/utils-promise.ts

@@ -0,0 +1,171 @@
+/**
+ * returns a promise that resolves on the next tick
+ */
+export function nextTick(): Promise<void> {
+    return new Promise(res => setTimeout(res, 0));
+}
+
+export function promiseWait(ms: number = 0): Promise<void> {
+    return new Promise(res => setTimeout(res, ms));
+}
+
+export function promiseWaitSkippable(
+    ms: number = 0
+): {
+    promise: Promise<void>;
+    skip: () => void;
+} {
+    let timeoutId: ReturnType<typeof setTimeout> | undefined;
+    let settled = false;
+
+    let resolveFn!: () => void;
+
+    const promise = new Promise<void>((resolve) => {
+        resolveFn = resolve;
+
+        timeoutId = setTimeout(() => {
+            if (settled) return;
+            settled = true;
+            cleanup();
+            resolve();
+        }, ms);
+    });
+
+    function cleanup() {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            timeoutId = undefined;
+        }
+    }
+
+    function skip() {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        resolveFn();
+    }
+
+    return {
+        promise,
+        skip
+    };
+}
+
+export function toPromise<T>(maybePromise: Promise<T> | T): Promise<T> {
+    if (maybePromise && typeof (maybePromise as any).then === 'function') {
+        // is promise
+        return maybePromise as any;
+    } else {
+        return Promise.resolve(maybePromise);
+    }
+}
+
+/**
+ * returns true if promise is given
+ */
+export function isPromise(value: any): boolean {
+    if (
+        typeof value !== 'undefined' &&
+        typeof value.then === 'function'
+    ) {
+        return true;
+    }
+    return false;
+}
+
+/**
+ * Reusing resolved promises has a better
+ * performance than creating new ones each time.
+ */
+export const PROMISE_RESOLVE_TRUE: Promise<true> = Promise.resolve(true);
+export const PROMISE_RESOLVE_FALSE: Promise<false> = Promise.resolve(false);
+export const PROMISE_RESOLVE_NULL: Promise<null> = Promise.resolve(null);
+export const PROMISE_RESOLVE_VOID: Promise<void> = Promise.resolve();
+
+
+export function requestIdlePromiseNoQueue(
+    /**
+     * We always set a timeout!
+     * RxDB might be used on the server side where the
+     * server runs 24/4 on 99% CPU. So without a timeout
+     * this would never resolve which could cause a memory leak.
+     */
+    timeout: number | undefined = 10000
+) {
+    /**
+     * Do not use window.requestIdleCallback
+     * because some javascript runtimes like react-native,
+     * do not have a window object, but still have a global
+     * requestIdleCallback function.
+     * @link https://github.com/pubkey/rxdb/issues/4804
+    */
+    if (
+        typeof requestIdleCallback === 'function'
+    ) {
+        return new Promise<void>(res => {
+            requestIdleCallback(
+                () => res(),
+                {
+                    timeout
+                }
+            );
+        });
+    } else {
+        return promiseWait(0);
+    }
+}
+
+/**
+ * If multiple operations wait for an requestIdlePromise
+ * we do not want them to resolve all at the same time.
+ * So we have to queue the calls.
+ */
+let idlePromiseQueue = PROMISE_RESOLVE_VOID;
+export function requestIdlePromise(
+    timeout: number | undefined = undefined
+) {
+    idlePromiseQueue = idlePromiseQueue.then(() => {
+        return requestIdlePromiseNoQueue(timeout);
+    });
+    return idlePromiseQueue;
+}
+
+
+/**
+ * run the callback if requestIdleCallback available
+ * do nothing if not
+ * @link https://developer.mozilla.org/de/docs/Web/API/Window/requestIdleCallback
+ */
+export function requestIdleCallbackIfAvailable(fun: Function): void {
+    /**
+     * Do not use window.requestIdleCallback
+     * because some javascript runtimes like react-native,
+     * do not have a window object, but still have a global
+     * requestIdleCallback function.
+     * @link https://github.com/pubkey/rxdb/issues/4804
+    */
+    if (
+        typeof requestIdleCallback === 'function'
+    ) {
+        requestIdleCallback(() => {
+            fun();
+        });
+    }
+}
+
+
+/**
+ * like Promise.all() but runs in series instead of parallel
+ * @link https://github.com/egoist/promise.series/blob/master/index.js
+ * @param tasks array with functions that return a promise
+ */
+export function promiseSeries(
+    tasks: Function[],
+    initial?: any
+): Promise<any[]> {
+    return tasks
+        .reduce(
+            (current, next) => (current as any).then(next),
+            Promise.resolve(initial)
+        );
+}

package/src/plugins/utils/utils-regex.ts

@@ -0,0 +1,2 @@
+export const REGEX_ALL_DOTS = /\./g;
+export const REGEX_ALL_PIPES = /\|/g;

package/src/plugins/utils/utils-revision.ts

@@ -0,0 +1,55 @@
+import type {
+    RxDocumentData
+} from '../../types/index.d.ts';
+import { newRxError } from '../../rx-error.ts';
+
+/**
+ * Parses the full revision.
+ * Do NOT use this if you only need the revision height,
+ * then use getHeightOfRevision() instead which is faster.
+ */
+export function parseRevision(revision: string): { height: number; hash: string; } {
+    const split = revision.split('-');
+    if (split.length !== 2) {
+        throw new Error('malformatted revision: ' + revision);
+    }
+    return {
+        height: parseInt(split[0], 10),
+        hash: split[1]
+    };
+}
+
+/**
+ * @hotPath Performance is very important here
+ * because we need to parse the revision height very often.
+ * Uses indexOf + charCodeAt for maximum performance.
+ * Single-digit heights (most common) use a fast path
+ * that avoids parseInt entirely.
+ */
+export function getHeightOfRevision(revision: string): number {
+    const dashIndex = revision.indexOf('-');
+    if (dashIndex === -1) {
+        throw newRxError('SNH', { args: { revision } });
+    }
+    // Fast path for single-digit revision heights (most common case)
+    if (dashIndex === 1) {
+        const code = revision.charCodeAt(0);
+        if (code >= 48 && code <= 57) { // '0'-'9'
+            return code - 48;
+        }
+    }
+    return parseInt(revision.substring(0, dashIndex), 10);
+}
+
+
+/**
+ * Creates the next write revision for a given document.
+ */
+export function createRevision<RxDocType>(
+    databaseInstanceToken: string,
+    previousDocData?: RxDocumentData<RxDocType>
+): string {
+    const newRevisionHeight = !previousDocData ? 1 : getHeightOfRevision(previousDocData._rev) + 1
+    return newRevisionHeight + '-' + databaseInstanceToken;
+}
+

package/src/plugins/utils/utils-rxdb-version.template.ts

@@ -0,0 +1,4 @@
+/**
+ * This file is replaced in the 'npm run build:version' script.
+ */
+export const RXDB_VERSION = '|PLACEHOLDER|';

package/src/plugins/utils/utils-rxdb-version.ts

@@ -0,0 +1,4 @@
+/**
+ * This file is replaced in the 'npm run build:version' script.
+ */
+export const RXDB_VERSION = '17.0.0-beta.17';

package/src/plugins/utils/utils-string.ts

@@ -0,0 +1,91 @@
+const COUCH_NAME_CHARS = 'abcdefghijklmnopqrstuvwxyz';
+
+/**
+ * Get a random string which can be used for many things in RxDB.
+ * The returned string is guaranteed to be a valid database name or collection name
+ * and also to be a valid JavaScript variable name.
+ * 
+ * @link http://stackoverflow.com/a/1349426/3443137
+ */
+export function randomToken(length: number = 10): string {
+    let text = '';
+
+    for (let i = 0; i < length; i++) {
+        text += COUCH_NAME_CHARS.charAt(Math.floor(Math.random() * COUCH_NAME_CHARS.length));
+    }
+
+    return text;
+}
+
+
+/**
+ * A random string that is never inside of any storage
+ */
+export const RANDOM_STRING = 'Fz7SZXPmYJujkzjY1rpXWvlWBqoGAfAX';
+
+/**
+ * uppercase first char
+ */
+export function ucfirst(str: string): string {
+    str += '';
+    const f = str.charAt(0)
+        .toUpperCase();
+    return f + str.substr(1);
+}
+
+/**
+ * removes trailing and ending dots from the string
+ */
+export function trimDots(str: string): string {
+    // start
+    while (str.charAt(0) === '.') {
+        str = str.substr(1);
+    }
+
+    // end
+    while (str.slice(-1) === '.') {
+        str = str.slice(0, -1);
+    }
+
+    return str;
+}
+
+/**
+ * @link https://stackoverflow.com/a/44950500/3443137
+ */
+export function lastCharOfString(str: string): string {
+    return str.charAt(str.length - 1);
+}
+
+/**
+ * returns true if the given name is likely a folder path
+ */
+export function isFolderPath(name: string) {
+    // do not check, if foldername is given
+    if (
+        name.includes('/') || // unix
+        name.includes('\\') // windows
+    ) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+
+/**
+ * @link https://gist.github.com/andreburgaud/6f73fd2d690b629346b8
+ * @link https://stackoverflow.com/a/76240378/3443137
+ */
+export function arrayBufferToString(arrayBuffer: Uint8Array<ArrayBuffer>) {
+    return new TextDecoder().decode(arrayBuffer);
+}
+
+export function stringToArrayBuffer(str: string): Uint8Array<ArrayBuffer> {
+    return new TextEncoder().encode(str);
+}
+
+
+export function normalizeString(str: string): string {
+    return str.trim().replace(/[\n\s]+/g, '');
+}

package/src/plugins/utils/utils-time.ts

@@ -0,0 +1,37 @@
+
+/**
+ * Returns the current unix time in milliseconds (with two decimals!)
+ * Because the accuracy of getTime() in javascript is bad,
+ * and we cannot rely on performance.now() on all platforms,
+ * this method implements a way to never return the same value twice.
+ * This ensures that when now() is called often, we do not loose the information
+ * about which call came first and which came after.
+ *
+ * We had to move from having no decimals, to having two decimal
+ * because it turned out that some storages are such fast that
+ * calling this method too often would return 'the future'.
+ */
+let _lastNow: number = 0;
+/**
+ * Returns the current time in milliseconds,
+ * also ensures to not return the same value twice.
+ */
+export function now(): number {
+    let ret = Date.now();
+    ret = ret + 0.01;
+    if (ret <= _lastNow) {
+        ret = _lastNow + 0.01;
+    }
+
+    /**
+     * Strip the returned number to max two decimals.
+     * In theory we would not need this but
+     * in practice JavaScript has no such good number precision
+     * so rounding errors could add another decimal place.
+     * Use Math.round instead of toFixed(2)+parseFloat for better performance.
+     */
+    const twoDecimals = Math.round(ret * 100) / 100;
+
+    _lastNow = twoDecimals;
+    return twoDecimals;
+}

package/src/plugins/validate-ajv/index.ts

@@ -0,0 +1,61 @@
+/**
+ * this plugin validates documents before they can be inserted into the RxCollection.
+ * It's using ajv as jsonschema-validator
+ * @link https://github.com/epoberezkin/ajv
+ * @link https://github.com/ajv-validator/ajv/issues/2132#issuecomment-1537224620
+ */
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import type {
+    RxDocumentData,
+    RxJsonSchema
+} from '../../types/index.d.ts';
+import { wrappedValidateStorageFactory } from '../../plugin-helpers.ts';
+
+
+let ajv: Ajv;
+
+
+export function getAjv() {
+    if (!ajv) {
+        ajv = new Ajv({
+            strict: true
+        });
+        ajv.addKeyword('version');
+        ajv.addKeyword('keyCompression');
+        ajv.addKeyword('primaryKey');
+        ajv.addKeyword('indexes');
+        ajv.addKeyword('encrypted');
+        ajv.addKeyword('final');
+        ajv.addKeyword('sharding');
+        ajv.addKeyword('internalIndexes');
+        ajv.addKeyword('attachments');
+        ajv.addKeyword('ref');
+        ajv.addKeyword('crdt');
+        addFormats(ajv);
+    }
+    return ajv;
+}
+
+
+
+export function getValidator(
+    schema: RxJsonSchema<any>
+) {
+    const validator = getAjv().compile(schema);
+    return (docData: RxDocumentData<any>) => {
+        const isValid = validator(docData);
+        if (isValid) {
+            return [];
+        } else {
+            return validator.errors as any;
+        }
+    };
+}
+
+
+
+export const wrappedValidateAjvStorage = wrappedValidateStorageFactory(
+    getValidator,
+    'ajv'
+);

package/src/plugins/validate-is-my-json-valid/index.ts

@@ -0,0 +1,30 @@
+/**
+ * this plugin validates documents before they can be inserted into the RxCollection.
+ * It's using is-my-json-valid as jsonschema-validator
+ * @link https://github.com/mafintosh/is-my-json-valid
+ */
+import isMyJsonValid from 'is-my-json-valid';
+import type {
+    RxJsonSchema
+} from '../../types/index.d.ts';
+import { wrappedValidateStorageFactory } from '../../plugin-helpers.ts';
+
+
+export function getValidator(
+    schema: RxJsonSchema<any>
+) {
+    const validator = isMyJsonValid(schema as any);
+    return (docData: any) => {
+        const isValid = validator(docData);
+        if (isValid) {
+            return [];
+        } else {
+            return validator.errors as any;
+        }
+    };
+}
+
+export const wrappedValidateIsMyJsonValidStorage = wrappedValidateStorageFactory(
+    getValidator,
+    'is-my-json-valid'
+);

package/src/plugins/validate-z-schema/index.ts

@@ -0,0 +1,58 @@
+/**
+ * this plugin validates documents before they can be inserted into the RxCollection.
+ * It's using z-schema as jsonschema-validator
+ * @link https://github.com/zaggino/z-schema
+ */
+import ZSchema, { SchemaErrorDetail } from 'z-schema';
+import type { RxJsonSchema } from '../../types/index.d.ts';
+import { wrappedValidateStorageFactory } from '../../plugin-helpers.ts';
+
+
+export const ZSchemaClass = ZSchema;
+
+let zSchema: ZSchema;
+
+export function getZSchema() {
+    if (!zSchema) {
+        zSchema = ZSchema.create({
+            strictMode: false
+        });
+    }
+    return zSchema;
+}
+
+export function getValidator(
+    schema: RxJsonSchema<any>
+) {
+    const validator = (obj: any) => {
+        return getZSchema().validateSafe(obj, schema as any);
+    };
+    return (docData: any) => {
+        const useValidator = validator(docData);
+        if (useValidator.valid) {
+            return [];
+        }
+        const errors: SchemaErrorDetail[] = (useValidator as any).error?.details || (useValidator as any).err?.details || [];
+        if (errors) {
+            const formattedZSchemaErrors = (errors as any).map(({
+                title,
+                description,
+                message,
+                path
+            }: any) => ({
+                title,
+                description,
+                message,
+                path
+            }));
+            return formattedZSchemaErrors;
+        } else {
+            return [];
+        }
+    };
+}
+
+export const wrappedValidateZSchemaStorage = wrappedValidateStorageFactory(
+    getValidator,
+    'z-schema'
+);

package/src/plugins/vector/index.ts

@@ -0,0 +1,2 @@
+export type * from './types.ts';
+export * from './vector-distance.ts';

package/src/plugins/vector/types.ts

@@ -0,0 +1 @@
+export type Vector = number[];

package/src/plugins/vector/vector-distance.ts

@@ -0,0 +1,34 @@
+import type { Vector } from './types';
+
+/**
+ * Vector comparison methods
+ * @link https://www.restack.io/p/vector-database-knowledge-answer-javascript-cat-ai
+ * @returns 
+ */
+export function euclideanDistance(A: Vector, B: Vector): number {
+    return Math.sqrt(A.reduce((sum, a, i) => sum + Math.pow(a - B[i], 2), 0));
+}
+export function manhattanDistance(A: Vector, B: Vector) {
+    return A.reduce((sum, a, i) => sum + Math.abs(a - B[i]), 0);
+}
+
+
+export function cosineSimilarity(A: Vector, B: Vector): number {
+    const dotProduct = A.reduce((sum, a, i) => sum + a * B[i], 0);
+    const magnitudeA = Math.sqrt(A.reduce((sum, a) => sum + a * a, 0));
+    const magnitudeB = Math.sqrt(B.reduce((sum, b) => sum + b * b, 0));
+    return dotProduct / (magnitudeA * magnitudeB);
+}
+
+
+/**
+ * @link https://github.com/vector5ai/vector5db/blob/main/src/metrics/JaccardSimilarity.ts
+ */
+export function jaccardSimilarity(a: number[], b: number[]): number {
+    const setA = new Set(a);
+    const setB = new Set(b);
+    const intersection = new Set([...setA].filter((x) => setB.has(x))).size;
+    const union = new Set([...setA, ...setB]).size;
+
+    return 1 - (intersection / union);
+}

package/src/plugins/webmcp/index.ts

@@ -0,0 +1,2 @@
+export * from './webmcp.ts';
+export * from './nosql-query-schema.ts';