@connecttomahdi/rxdb 17.0.0-beta.17

package/src/plugins/test-utils/config.ts

@@ -0,0 +1,135 @@
+/// <reference path="../../../node_modules/@types/mocha/index.d.ts" />
+import {
+    ensureNotFalsy,
+    isPromise,
+    randomToken
+} from '../utils/index.ts';
+import {
+    enforceOptions as broadcastChannelEnforceOptions
+} from 'broadcast-channel';
+import type { RxStorage, RxTestStorage } from '../../types';
+import { wrappedKeyEncryptionCryptoJsStorage } from '../encryption-crypto-js/index.ts';
+
+export type TestConfig = {
+    storage: RxTestStorage;
+};
+
+export const isDeno = typeof Deno !== 'undefined' || (typeof window !== 'undefined' && 'Deno' in window);
+export const isBun = typeof process !== 'undefined' && typeof process.versions !== 'undefined' && !!process.versions.bun;
+export const isNode = !isDeno && !isBun && typeof window === 'undefined';
+
+let config: TestConfig;
+
+export function setConfig(newConfig: TestConfig) {
+    config = newConfig;
+}
+
+let initDone = false;
+export function getConfig() {
+    if (!initDone) {
+        initTestEnvironment();
+        initDone = true;
+    }
+    return ensureNotFalsy(config, 'testConfig not set')
+}
+
+
+declare const Deno: any;
+function getEnvVariables() {
+    if (isDeno) {
+        const ret: any = {};
+        [
+            'DEFAULT_STORAGE',
+            'NODE_ENV'
+        ].forEach(k => {
+            ret[k] = Deno.env.get(k);
+        });
+        return ret;
+    }
+
+    return isBun || isNode ? process.env : ((window as any).__karma__?.config?.env || {});
+}
+export const ENV_VARIABLES = getEnvVariables() || {};
+export const DEFAULT_STORAGE = ENV_VARIABLES.DEFAULT_STORAGE as string;
+
+export function isFastMode(): boolean {
+    try {
+        return ENV_VARIABLES.NODE_ENV === 'fast';
+    } catch (err) {
+        return false;
+    }
+}
+
+export function initTestEnvironment() {
+    if (ENV_VARIABLES.NODE_ENV === 'fast') {
+        broadcastChannelEnforceOptions({
+            type: 'simulate'
+        });
+    }
+
+    /**
+     * Overwrite the console for easier debugging
+     */
+    const oldConsoleLog = console.log.bind(console);
+    const oldConsoleDir = console.dir.bind(console);
+    function newLog(this: typeof console, value: any) {
+        if (isPromise(value)) {
+            oldConsoleDir(value);
+            throw new Error('cannot log Promise(), you should await it first');
+        }
+        if (typeof value === 'string' || typeof value === 'number') {
+            oldConsoleLog(value);
+            return;
+        }
+        try {
+            JSON.stringify(value);
+            oldConsoleLog(JSON.stringify(value, null, 4));
+        } catch (err) {
+            oldConsoleDir(value);
+        }
+    }
+    console.log = newLog.bind(console);
+    console.dir = newLog.bind(console);
+
+    console.log('DEFAULT_STORAGE: ' + DEFAULT_STORAGE);
+
+    if (isNode) {
+        process.setMaxListeners(100);
+
+        /**
+         * Add a global function to process, so we can debug timings
+         */
+        (process as any).startTime = performance.now();
+        (process as any).logTime = (msg: string = '') => {
+            const diff = performance.now() - (process as any).startTime;
+            console.log('process logTime(' + msg + ') ' + diff + 'ms');
+        };
+    }
+}
+
+export function getEncryptedStorage(baseStorage = getConfig().storage.getStorage()): RxStorage<any, any> {
+    const ret = config.storage.hasEncryption ?
+        baseStorage :
+        wrappedKeyEncryptionCryptoJsStorage({
+            storage: baseStorage
+        });
+    return ret;
+}
+
+export function isNotOneOfTheseStorages(storageNames: string[]) {
+    const isName = getConfig().storage.name;
+    if (storageNames.includes(isName)) {
+        return false;
+    } else {
+        return true;
+    }
+}
+
+
+export function getPassword(): Promise<string> {
+    if (getConfig().storage.hasEncryption) {
+        return ensureNotFalsy(getConfig().storage.hasEncryption)();
+    } else {
+        return Promise.resolve('test-password-' + randomToken(10));
+    }
+}

package/src/plugins/test-utils/humans-collection.ts

@@ -0,0 +1,557 @@
+import clone from 'clone';
+import * as schemas from './schemas.ts';
+import * as schemaObjects from './schema-objects.ts';
+import { getConfig } from './config.ts';
+import assert from 'assert';
+
+import {
+    createRxDatabase,
+    RxJsonSchema,
+    RxCollection,
+    RxDatabase,
+    randomToken,
+    MigrationStrategies,
+    RxAttachmentCreator,
+    RxStorage,
+    RxConflictHandler
+} from '../../index.ts';
+
+import { HumanDocumentType, PrimaryHumanDocType } from './schemas.ts';
+
+export async function create(
+    size: number = 20,
+    collectionName: string = 'human',
+    multiInstance: boolean = true,
+    eventReduce: boolean = true,
+    storage: RxStorage<any, any> = getConfig().storage.getStorage()
+
+): Promise<RxCollection<HumanDocumentType, {}, {}>> {
+    const db = await createRxDatabase<{ human: RxCollection<HumanDocumentType>; }>({
+        name: randomToken(10),
+        storage,
+        multiInstance,
+        eventReduce,
+        ignoreDuplicate: true,
+        localDocuments: true
+    });
+
+    const collections = await db.addCollections({
+        [collectionName]: {
+            schema: schemas.human,
+            localDocuments: true
+        }
+    });
+
+    // insert data
+    if (size > 0) {
+        const docsData = new Array(size)
+            .fill(0)
+            .map(() => schemaObjects.humanData());
+        const writeResult = await collections[collectionName].bulkInsert(docsData);
+        assert.deepStrictEqual(writeResult.error, []);
+    }
+    return collections[collectionName];
+}
+
+export async function createBySchema<RxDocumentType = {}>(
+    schema: RxJsonSchema<RxDocumentType>,
+    name = 'human',
+    storage = getConfig().storage.getStorage(),
+    migrationStrategies?: MigrationStrategies
+): Promise<RxCollection<RxDocumentType, {}, {}>> {
+    const db = await createRxDatabase<{ [prop: string]: RxCollection<RxDocumentType>; }>({
+        name: randomToken(10),
+        storage,
+        multiInstance: true,
+        eventReduce: true,
+        ignoreDuplicate: true
+    });
+
+    const collections = await db.addCollections({
+        [name]: {
+            schema,
+            migrationStrategies
+        }
+    });
+
+    return collections[name];
+}
+
+export async function createAttachments(
+    size = 20,
+    name = 'human',
+    multiInstance = true
+): Promise<RxCollection<HumanDocumentType, {}, {}>> {
+    if (!name) {
+        name = 'human';
+    }
+    const db = await createRxDatabase<{ [prop: string]: RxCollection<HumanDocumentType>; }>({
+        name: randomToken(10),
+        storage: getConfig().storage.getStorage(),
+        multiInstance,
+        eventReduce: true,
+        ignoreDuplicate: true
+    });
+
+    const schemaJson = clone(schemas.human);
+    schemaJson.attachments = {};
+
+    const collections = await db.addCollections({
+        [name]: {
+            schema: schemaJson
+        }
+    });
+
+    // insert data
+    if (size > 0) {
+        const docsData = new Array(size)
+            .fill(0)
+            .map(() => schemaObjects.humanData());
+        await collections[name].bulkInsert(docsData);
+    }
+
+    return collections[name];
+}
+
+export async function createNoCompression(
+    size = 20,
+    name = 'human'
+): Promise<RxCollection<HumanDocumentType>> {
+    const db = await createRxDatabase<{ [prop: string]: RxCollection<HumanDocumentType>; }>({
+        name: randomToken(10),
+        storage: getConfig().storage.getStorage(),
+        eventReduce: true,
+        ignoreDuplicate: true
+    });
+    const schemaJSON = clone(schemas.human);
+    schemaJSON.keyCompression = false;
+    // setTimeout(() => db.close(), dbLifetime);
+    const collections = await db.addCollections({
+        [name]: {
+            schema: schemaJSON
+        }
+    });
+
+    // insert data
+    if (size > 0) {
+        const docsData = new Array(size)
+            .fill(0)
+            .map(() => schemaObjects.humanData());
+        await collections[name].bulkInsert(docsData);
+    }
+
+    return collections[name];
+}
+
+export async function createAgeIndex(
+    amount = 20
+): Promise<RxCollection<HumanDocumentType>> {
+    const db = await createRxDatabase<{ humana: RxCollection<HumanDocumentType>; }>({
+        name: randomToken(10),
+        storage: getConfig().storage.getStorage(),
+        eventReduce: true,
+        ignoreDuplicate: true
+    });
+    // setTimeout(() => db.close(), dbLifetime);
+    const collections = await db.addCollections({
+        humana: {
+            schema: schemas.humanAgeIndex
+        }
+    });
+
+    // insert data
+    if (amount > 0) {
+        const docsData = new Array(amount)
+            .fill(0)
+            .map(() => schemaObjects.humanData());
+        await collections.humana.bulkInsert(docsData);
+    }
+
+    return collections.humana;
+}
+
+export async function multipleOnSameDB(
+    size = 10
+): Promise<{
+    db: RxDatabase<{
+        human: RxCollection<HumanDocumentType>;
+        human2: RxCollection<HumanDocumentType>;
+    }>;
+    collection: RxCollection<HumanDocumentType>;
+    collection2: RxCollection<HumanDocumentType>;
+}> {
+    const db = await createRxDatabase<{
+        human: RxCollection<HumanDocumentType>;
+        human2: RxCollection<HumanDocumentType>;
+    }>({
+        name: randomToken(10),
+        storage: getConfig().storage.getStorage(),
+        eventReduce: true,
+        ignoreDuplicate: true
+    });
+    // setTimeout(() => db.close(), dbLifetime);
+    const collections = await db.addCollections({
+        human: {
+            schema: schemas.human
+        },
+        human2: {
+            schema: schemas.human
+        }
+    });
+
+    // insert data
+    if (size > 0) {
+        const docsData = new Array(size)
+            .fill(0)
+            .map(() => schemaObjects.humanData());
+        await collections.human.bulkInsert(docsData);
+
+        const docsData2 = new Array(size)
+            .fill(0)
+            .map(() => schemaObjects.humanData());
+        await collections.human2.bulkInsert(docsData2);
+    }
+
+    return {
+        db,
+        collection: collections.human,
+        collection2: collections.human2
+    };
+}
+
+export async function createNested(
+    amount = 5
+): Promise<RxCollection<schemaObjects.NestedHumanDocumentType>> {
+    const db = await createRxDatabase<{ nestedhuman: RxCollection<schemaObjects.NestedHumanDocumentType>; }>({
+        name: randomToken(10),
+        storage: getConfig().storage.getStorage(),
+        eventReduce: true,
+        ignoreDuplicate: true
+    });
+    // setTimeout(() => db.close(), dbLifetime);
+    const collections = await db.addCollections({
+        nestedhuman: {
+            schema: schemas.nestedHuman
+        }
+    });
+
+    // insert data
+    if (amount > 0) {
+        const docsData = new Array(amount)
+            .fill(0)
+            .map(() => schemaObjects.nestedHumanData());
+        await collections.nestedhuman.bulkInsert(docsData);
+    }
+
+    return collections.nestedhuman;
+}
+
+export async function createDeepNested(
+    amount = 5
+): Promise<RxCollection<schemaObjects.DeepNestedHumanDocumentType>> {
+    const db = await createRxDatabase<{ nestedhuman: RxCollection<schemaObjects.DeepNestedHumanDocumentType>; }>({
+        name: randomToken(10),
+        storage: getConfig().storage.getStorage(),
+        eventReduce: true,
+    });
+    // setTimeout(() => db.close(), dbLifetime);
+    const collections = await db.addCollections({
+        nestedhuman: {
+            schema: schemas.deepNestedHuman
+        }
+    });
+
+    // insert data
+    if (amount > 0) {
+        const docsData = new Array(amount)
+            .fill(0)
+            .map(() => schemaObjects.deepNestedHumanData());
+        await collections.nestedhuman.bulkInsert(docsData);
+    }
+
+    return collections.nestedhuman;
+}
+
+export async function createMultiInstance(
+    name: string,
+    amount = 0,
+    password = undefined,
+    storage: RxStorage<any, any> = getConfig().storage.getStorage()
+): Promise<RxCollection<HumanDocumentType, {}, {}>> {
+    if (!getConfig().storage.hasMultiInstance) {
+        throw new Error('createMultiInstance() cannot be called on a storage with hasMultiInstance:false');
+    }
+
+    const db = await createRxDatabase<{ human: RxCollection<HumanDocumentType>; }>({
+        name,
+        storage,
+        password,
+        multiInstance: true,
+        eventReduce: true,
+        ignoreDuplicate: true,
+        localDocuments: true
+    });
+    // setTimeout(() => db.close(), dbLifetime);
+    const collections = await db.addCollections({
+        human: {
+            schema: schemas.human,
+            localDocuments: true
+        }
+    });
+    // insert data
+    if (amount > 0) {
+        const docsData = new Array(amount)
+            .fill(0)
+            .map(() => schemaObjects.humanData());
+        await collections.human.bulkInsert(docsData);
+    }
+
+    return collections.human;
+}
+
+export async function createPrimary(
+    amount = 10,
+    name = randomToken(10),
+    multiInstance = true
+): Promise<RxCollection<PrimaryHumanDocType>> {
+
+    const db = await createRxDatabase<{ human: RxCollection<schemaObjects.SimpleHumanDocumentType>; }>({
+        name,
+        storage: getConfig().storage.getStorage(),
+        multiInstance,
+        eventReduce: true,
+        ignoreDuplicate: true
+    });
+    // setTimeout(() => db.close(), dbLifetime);
+    const collections = await db.addCollections({
+        human: {
+            schema: schemas.primaryHuman
+        }
+    });
+
+    // insert data
+    if (amount > 0) {
+        const docsData = new Array(amount)
+            .fill(0)
+            .map(() => schemaObjects.simpleHumanData());
+        await collections.human.bulkInsert(docsData);
+    }
+
+    return collections.human;
+}
+
+export async function createHumanWithTimestamp(
+    amount = 0,
+    databaseName = randomToken(10),
+    multiInstance = true,
+    storage = getConfig().storage.getStorage(),
+    conflictHandler?: RxConflictHandler<any>
+
+): Promise<RxCollection<schemaObjects.HumanWithTimestampDocumentType>> {
+
+    const db = await createRxDatabase<{ humans: RxCollection<schemaObjects.HumanWithTimestampDocumentType>; }>({
+        name: databaseName,
+        storage,
+        multiInstance,
+        eventReduce: true,
+        ignoreDuplicate: true
+    });
+    // setTimeout(() => db.close(), dbLifetime);
+    const collections = await db.addCollections({
+        humans: {
+            conflictHandler,
+            schema: schemas.humanWithTimestamp
+        }
+    });
+
+    // insert data
+    if (amount > 0) {
+        const docsData = new Array(amount)
+            .fill(0)
+            .map(() => schemaObjects.humanWithTimestampData());
+        await collections.humans.bulkInsert(docsData);
+    }
+
+    return collections.humans;
+}
+
+export async function createMigrationCollection(
+    amount = 0,
+    addMigrationStrategies: MigrationStrategies = {},
+    name = randomToken(10),
+    autoMigrate = false,
+    attachment?: RxAttachmentCreator
+): Promise<RxCollection<schemaObjects.SimpleHumanV3DocumentType>> {
+
+    const migrationStrategies: any = Object.assign(
+        {
+            1: (doc: any) => doc,
+            2: (doc: any) => doc,
+            3: (doc: any) => {
+                doc.age = parseInt(doc.age, 10);
+                return doc;
+            }
+        },
+        addMigrationStrategies
+    );
+
+
+    const colName = 'human';
+    const db = await createRxDatabase<{ human: RxCollection<schemaObjects.SimpleHumanAgeDocumentType>; }>({
+        name,
+        storage: getConfig().storage.getStorage(),
+        eventReduce: true,
+        ignoreDuplicate: true
+    });
+    const cols = await db.addCollections({
+        [colName]: {
+            schema: attachment !== undefined ? { ...schemas.simpleHuman, attachments: {} } : schemas.simpleHuman,
+            autoMigrate: false
+        }
+    });
+
+    await Promise.all(
+        new Array(amount)
+            .fill(0)
+            .map(() => cols[colName].insert(schemaObjects.simpleHumanAge()).then(doc => {
+                if (attachment !== undefined) {
+                    return doc.putAttachment(attachment);
+                }
+            }))
+    );
+    await db.close();
+
+    const db2 = await createRxDatabase<{ human: RxCollection<schemaObjects.SimpleHumanV3DocumentType>; }>({
+        name,
+        storage: getConfig().storage.getStorage(),
+        eventReduce: true,
+        ignoreDuplicate: true
+    });
+    const cols2 = await db2.addCollections({
+        [colName]: {
+            schema: attachment !== undefined ? { ...schemas.simpleHumanV3, attachments: {} } : schemas.simpleHumanV3,
+            autoMigrate,
+            migrationStrategies
+        }
+    });
+
+    return cols2[colName];
+}
+
+export async function createRelated(
+    name = randomToken(10)
+): Promise<RxCollection<schemaObjects.RefHumanDocumentType>> {
+    const db = await createRxDatabase<{ human: RxCollection<schemaObjects.RefHumanDocumentType>; }>({
+        name,
+        storage: getConfig().storage.getStorage(),
+        multiInstance: true,
+        eventReduce: true,
+        ignoreDuplicate: true
+    });
+    // setTimeout(() => db.close(), dbLifetime);
+    const collections = await db.addCollections({
+        human: {
+            schema: schemas.refHuman
+        }
+    });
+
+    const doc1 = schemaObjects.refHumanData();
+    const doc2 = schemaObjects.refHumanData(doc1.name);
+    doc1.bestFriend = doc2.name; // cross-relation
+
+    await collections.human.insert(doc1);
+    await collections.human.insert(doc2);
+
+    return collections.human;
+}
+
+export async function createRelatedNested(
+    name = randomToken(10)
+): Promise<RxCollection<schemaObjects.RefHumanNestedDocumentType>> {
+
+    const db = await createRxDatabase<{ human: RxCollection<schemaObjects.RefHumanNestedDocumentType>; }>({
+        name,
+        storage: getConfig().storage.getStorage(),
+        multiInstance: true,
+        eventReduce: true,
+        ignoreDuplicate: true
+    });
+    // setTimeout(() => db.close(), dbLifetime);
+    const collections = await db.addCollections({
+        human: {
+            schema: schemas.refHumanNested
+        }
+    });
+
+    const doc1 = schemaObjects.refHumanNestedData();
+    const doc2 = schemaObjects.refHumanNestedData(doc1.name);
+    doc1.foo.bestFriend = doc2.name; // cross-relation
+
+    await collections.human.insert(doc1);
+    await collections.human.insert(doc2);
+
+    return collections.human;
+}
+
+export async function createIdAndAgeIndex(
+    amount = 20
+): Promise<RxCollection<schemaObjects.HumanWithIdAndAgeIndexDocumentType>> {
+    const db = await createRxDatabase<{ humana: RxCollection<schemaObjects.HumanWithIdAndAgeIndexDocumentType>; }>({
+        name: randomToken(10),
+        storage: getConfig().storage.getStorage(),
+        eventReduce: true,
+        ignoreDuplicate: true
+    });
+    // setTimeout(() => db.close(), dbLifetime);
+    const collections = await db.addCollections({
+        humana: {
+            schema: schemas.humanIdAndAgeIndex
+        }
+    });
+
+    // insert data
+    if (amount > 0) {
+        const docsData = new Array(amount)
+            .fill(0)
+            .map(() => schemaObjects.humanWithIdAndAgeIndexDocumentType());
+        await collections.humana.bulkInsert(docsData);
+    }
+
+    return collections.humana;
+}
+
+export async function createHumanWithOwnership(
+    amount = 20,
+    databaseName = randomToken(10),
+    multiInstance = true,
+    owner = "alice",
+    storage = getConfig().storage.getStorage(),
+    conflictHandler?: RxConflictHandler<any>,
+
+): Promise<RxCollection<schemaObjects.HumanWithOwnershipDocumentType>> {
+
+    const db = await createRxDatabase<{ humans: RxCollection<schemaObjects.HumanWithOwnershipDocumentType>; }>({
+        name: databaseName,
+        storage,
+        multiInstance,
+        eventReduce: true,
+        ignoreDuplicate: true
+    });
+    // setTimeout(() => db.close(), dbLifetime);
+    const collections = await db.addCollections({
+        humans: {
+            conflictHandler,
+            schema: schemas.humanWithOwnership
+        }
+    });
+
+    // insert data
+    if (amount > 0) {
+        const docsData = new Array(amount)
+            .fill(0)
+            .map(() => schemaObjects.humanWithOwnershipData({}, owner));
+        await collections.humans.bulkInsert(docsData);
+    }
+
+    return collections.humans;
+}

package/src/plugins/test-utils/index.ts

@@ -0,0 +1,24 @@
+/**
+ * This plugins contains thing that are needed for testing
+ * in RxDB related context. Mostly used in the unit tests and
+ * also in the tests for the premium and the server repository.
+ */
+
+export * from './config.ts';
+export * from './humans-collection.ts';
+export * from './revisions.ts';
+export * from './test-util.ts';
+
+export * from './schema-objects.ts';
+export * from './schemas.ts';
+export * from './replication.ts';
+export * from './replication-base-test-suite.ts';
+export * from './performance.ts';
+
+import * as humansCollectionConst from './humans-collection.ts';
+export const humansCollection = humansCollectionConst;
+
+import * as schemasConst from './schemas.ts';
+export const schemas = schemasConst;
+import * as schemaObjectsConst from './schema-objects.ts';
+export const schemaObjects = schemaObjectsConst;