@connecttomahdi/rxdb 17.0.0-beta.17

package/src/plugins/dev-mode/index.ts

@@ -0,0 +1,203 @@
+import type {
+    RxPlugin,
+    RxCollectionCreator,
+    RxDatabaseCreator,
+    RxErrorKey,
+    RxDocument,
+    RxDatabase
+} from '../../types/index.d.ts';
+
+import {
+    ERROR_MESSAGES
+} from './error-messages.ts';
+import {
+    checkSchema
+} from './check-schema.ts';
+import {
+    checkOrmDocumentMethods,
+    checkOrmMethods
+} from './check-orm.ts';
+import { checkMigrationStrategies } from './check-migration-strategies.ts';
+import {
+    ensureCollectionNameValid,
+    ensureDatabaseNameIsValid
+} from './unallowed-properties.ts';
+import { checkMangoQuery, checkQuery, isQueryAllowed } from './check-query.ts';
+import { newRxError } from '../../rx-error.ts';
+import { DeepReadonly } from '../../types/util.ts';
+import { deepFreeze } from '../../plugins/utils/index.ts';
+import { checkWriteRows, ensurePrimaryKeyValid } from './check-document.ts';
+import { addDevModeTrackingIframe } from './dev-mode-tracking.ts';
+
+export * from './check-schema.ts';
+export * from './unallowed-properties.ts';
+export * from './check-query.ts';
+
+let showDevModeWarning = true;
+
+/**
+ * Suppresses the warning message shown in the console, typically invoked once the developer (hello!) 
+ * has acknowledged it.
+ */
+export function disableWarnings() {
+    showDevModeWarning = false;
+}
+
+/**
+ * Deep freezes and object when in dev-mode.
+ * Deep-Freezing has the same performance as deep-cloning, so we only do that in dev-mode.
+ * Also we can ensure the readonly state via typescript
+ * @link https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze
+ */
+export function deepFreezeWhenDevMode<T>(obj: T): DeepReadonly<T> {
+    // direct return if not suitable for deepFreeze()
+    if (
+        !obj ||
+        typeof obj === 'string' ||
+        typeof obj === 'number'
+    ) {
+        return obj as any;
+    }
+
+    return deepFreeze(obj) as any;
+}
+
+
+export const DEV_MODE_PLUGIN_NAME = 'dev-mode';
+export const RxDBDevModePlugin: RxPlugin = {
+    name: DEV_MODE_PLUGIN_NAME,
+    rxdb: true,
+    init: () => {
+        addDevModeTrackingIframe();
+        if (showDevModeWarning) {
+            console.warn(
+                [
+                    '-------------- RxDB dev-mode warning -------------------------------',
+                    'you are seeing this because you use the RxDB dev-mode plugin https://rxdb.info/dev-mode.html?console=dev-mode ',
+                    'This is great in development mode, because it will run many checks to ensure',
+                    'that you use RxDB correct. If you see this in production mode,',
+                    'you did something wrong because the dev-mode plugin will decrease the performance.',
+                    '',
+                    '🤗 Hint: To get the most out of RxDB, check out the Premium Plugins',
+                    'to get access to faster storages and more professional features: https://rxdb.info/premium/?console=dev-mode ',
+                    '',
+                    'You can disable this warning by calling disableWarnings() from the dev-mode plugin.',
+                    // '',
+                    // 'Also take part in the RxDB User Survey: https://rxdb.info/survey.html',
+                    '---------------------------------------------------------------------'
+                ].join('\n')
+            );
+        }
+    },
+    overwritable: {
+        isDevMode() {
+            return true;
+        },
+        deepFreezeWhenDevMode,
+        tunnelErrorMessage(code: RxErrorKey) {
+            const err = ERROR_MESSAGES[code];
+            if (!err) {
+                console.error('RxDB: Error-Code not known: ' + code);
+                throw new Error('Error-Code ' + code + ' not known, contact the maintainer');
+            }
+            let errorMessage = `
+Error message: ${err.message}
+Error code: ${code}`;
+
+            if (err.cause) {
+                errorMessage += `
+Cause: ${err.cause}`;
+            }
+            if (err.fix) {
+                errorMessage += `
+Fix: ${err.fix}`;
+            }
+            if (err.docs) {
+                errorMessage += `
+Docs: ${err.docs}`;
+            }
+
+            return errorMessage;
+        }
+    },
+    hooks: {
+        preCreateRxSchema: {
+            after: checkSchema
+        },
+        preCreateRxDatabase: {
+            before: function (args: RxDatabaseCreator<any, any>) {
+                if (!args.storage.name.startsWith('validate-')) {
+                    throw newRxError('DVM1', {
+                        database: args.name,
+                        storage: args.storage.name
+                    });
+                }
+            },
+            after: function (args: RxDatabaseCreator<any, any>) {
+                ensureDatabaseNameIsValid(args);
+            }
+        },
+        createRxDatabase: {
+            after: async function (args) {
+            }
+        },
+        preCreateRxCollection: {
+            after: function (args: RxCollectionCreator<any> & { name: string; }) {
+                ensureCollectionNameValid(args);
+                checkOrmDocumentMethods(args.schema as any, args.methods);
+                if (args.name.charAt(0) === '_') {
+                    throw newRxError('DB2', {
+                        name: args.name
+                    });
+                }
+                if (!args.schema) {
+                    throw newRxError('DB4', {
+                        name: args.name,
+                        args
+                    });
+                }
+            }
+        },
+        createRxDocument: {
+            before: function (doc: RxDocument) {
+                ensurePrimaryKeyValid(doc.primary, doc.toJSON(true));
+            }
+        },
+        prePrepareRxQuery: {
+            after: function (args) {
+                isQueryAllowed(args);
+            }
+        },
+        preCreateRxQuery: {
+            after: function (args) {
+                checkQuery(args);
+            }
+        },
+        prePrepareQuery: {
+            after: (args) => {
+                checkMangoQuery(args);
+            }
+        },
+        preStorageWrite: {
+            before: (args) => {
+                checkWriteRows(args.storageInstance, args.rows);
+            }
+        },
+        createRxCollection: {
+            after: (args) => {
+                // check ORM-methods
+                checkOrmMethods(args.creator.statics);
+                checkOrmMethods(args.creator.methods);
+                checkOrmMethods(args.creator.attachments);
+
+                // check migration strategies
+                if (args.creator.schema && args.creator.migrationStrategies) {
+                    checkMigrationStrategies(
+                        args.creator.schema,
+                        args.creator.migrationStrategies
+                    );
+                }
+            }
+        }
+    }
+};

package/src/plugins/dev-mode/unallowed-properties.ts

@@ -0,0 +1,96 @@
+import type { RxCollectionCreator, RxDatabaseCreator } from '../../types/index.d.ts';
+import { newRxError, newRxTypeError } from '../../rx-error.ts';
+import { rxDatabaseProperties } from './entity-properties.ts';
+import { isFolderPath } from '../../plugins/utils/index.ts';
+
+/**
+ * if the name of a collection
+ * clashes with a property of RxDatabase,
+ * we get problems so this function prohibits this
+ */
+export function ensureCollectionNameValid(
+    args: RxCollectionCreator & { name: string; }
+) {
+    if (rxDatabaseProperties().includes(args.name)) {
+        throw newRxError('DB5', {
+            name: args.name
+        });
+    }
+    validateDatabaseName(args.name);
+}
+
+export function ensureDatabaseNameIsValid(args: RxDatabaseCreator<any, any>) {
+
+    validateDatabaseName(args.name);
+
+    if(args.name.includes('$')){
+        throw newRxError('DB13', {
+            name: args.name,
+        });
+    }
+
+    /**
+     * The server-plugin has problems when a path with and ending slash is given
+     * So we do not allow this.
+     * @link https://github.com/pubkey/rxdb/issues/2251
+     */
+    if (isFolderPath(args.name)) {
+        if (args.name.endsWith('/') || args.name.endsWith('\\')) {
+            throw newRxError('DB11', {
+                name: args.name,
+            });
+        }
+    }
+}
+
+
+
+/**
+ * In contrast to CouchDB, we still allow inner uppercase letters
+ * like the name fooBar. This makes it way less confusing when naming
+ * collections with a JavaScript variable name convention.
+ */
+const validCouchDBStringRegexStr = '^[a-z][_$a-zA-Z0-9\\-]*$';
+const validCouchDBStringRegex = new RegExp(validCouchDBStringRegexStr);
+
+/**
+ * Validates that a given string is ok to be used with couchdb-collection-names.
+ * We only allow these strings as database- or collection names because it ensures
+ * that you later do not get in trouble when you want to use the database together witch couchdb.
+ *
+ * @link https://docs.couchdb.org/en/stable/api/database/common.html
+ * @link https://neighbourhood.ie/blog/2020/10/13/everything-you-need-to-know-about-couchdb-database-names/
+ * @throws  {RxError}
+ */
+export function validateDatabaseName(name: string): true {
+    if (
+        typeof name !== 'string' ||
+        name.length === 0
+    ) {
+        throw newRxTypeError('UT1', {
+            name
+        });
+    }
+
+
+    // do not check, if foldername is given
+    if (isFolderPath(name)) {
+        return true;
+    }
+
+    if (
+        !name.match(validCouchDBStringRegex) &&
+        /**
+         * The string ':memory:' is used in the SQLite RxStorage
+         * to persist data into a memory state. Often used in tests.
+         */
+        name !== ':memory:'
+    ) {
+        throw newRxError('UT2', {
+            regex: validCouchDBStringRegexStr,
+            givenName: name,
+        });
+    }
+
+    return true;
+}

package/src/plugins/electron/electron-helper.ts

@@ -0,0 +1,2 @@
+export const IPC_RENDERER_KEY_PREFIX = 'rxdb-ipc-renderer-storage';
+export const IPC_RENDERER_TO_MAIN = 'rxdb-renderer-to-main';

package/src/plugins/electron/index.ts

@@ -0,0 +1,3 @@
+export * from './rx-storage-ipc-renderer.ts';
+export * from './rx-storage-ipc-main.ts';
+export * from './electron-helper.ts';

package/src/plugins/electron/rx-storage-ipc-main.ts

@@ -0,0 +1,58 @@
+/**
+ * This file contains everything
+ * that is supposed to run inside of the electron main process
+ */
+import type {
+    RxStorage
+} from '../../types/index.d.ts';
+import { Subject } from 'rxjs';
+import {
+    IPC_RENDERER_KEY_PREFIX
+} from './electron-helper.ts';
+import {
+    exposeRxStorageRemote,
+    RxStorageRemoteExposeSettings,
+    MessageToRemote
+} from '../storage-remote/index.ts';
+export function exposeIpcMainRxStorage<T, D>(
+    args: {
+        key: string;
+        storage: RxStorage<T, D>;
+        ipcMain: any;
+    }
+) {
+    const channelId = [
+        IPC_RENDERER_KEY_PREFIX,
+        args.key,
+    ].join('|');
+    const messages$ = new Subject<MessageToRemote>();
+    const openRenderers: Set<any> = new Set();
+    args.ipcMain.on(
+        channelId,
+        (event: any, message: any) => {
+            addOpenRenderer(event.sender);
+            if (message) {
+                messages$.next(message);
+            }
+        }
+    );
+    const addOpenRenderer = (renderer: any) => {
+        if (openRenderers.has(renderer)) return;
+        openRenderers.add(renderer);
+        renderer.on('destroyed', () => openRenderers.delete(renderer));
+    };
+    const send: RxStorageRemoteExposeSettings['send'] = (msg) => {
+        /**
+         * TODO we could improve performance
+         * by only sending the message to the 'correct' sender.
+         */
+        openRenderers.forEach(sender => {
+            sender.send(channelId, msg);
+        });
+    };
+    exposeRxStorageRemote({
+        storage: args.storage,
+        messages$,
+        send
+    });
+}

package/src/plugins/electron/rx-storage-ipc-renderer.ts

@@ -0,0 +1,62 @@
+import { Subject } from 'rxjs';
+import {
+    getRxStorageRemote,
+    RxStorageRemote,
+    RxStorageRemoteSettings,
+    MessageFromRemote
+} from '../storage-remote/index.ts';
+import {
+    IPC_RENDERER_KEY_PREFIX
+} from './electron-helper.ts';
+import { PROMISE_RESOLVE_VOID } from '../utils/index.ts';
+
+export type RxStorageIpcRendererSettings = {
+    /**
+     * Set the same key on both sides
+     * to ensure that messages do not get mixed
+     * up when you use more than one storage.
+     */
+    key: string;
+    ipcRenderer: any;
+    mode: RxStorageRemoteSettings['mode'];
+};
+
+export type RxStorageIpcRenderer = RxStorageRemote;
+export function getRxStorageIpcRenderer(
+    settings: RxStorageIpcRendererSettings
+): RxStorageIpcRenderer {
+    const channelId = [
+        IPC_RENDERER_KEY_PREFIX,
+        settings.key
+    ].join('|');
+
+    const storage = getRxStorageRemote({
+        identifier: 'electron-ipc-renderer',
+        mode: settings.mode,
+        messageChannelCreator() {
+            const messages$ = new Subject<MessageFromRemote>();
+            const listener = (_event: any, message: any) => {
+                messages$.next(message);
+            };
+            settings.ipcRenderer.on(channelId, listener);
+            settings.ipcRenderer.postMessage(
+                channelId,
+                false
+            );
+            return Promise.resolve({
+                messages$,
+                send(msg) {
+                    settings.ipcRenderer.postMessage(
+                        channelId,
+                        msg
+                    );
+                },
+                close() {
+                    settings.ipcRenderer.removeListener(channelId, listener);
+                    return PROMISE_RESOLVE_VOID;
+                }
+            });
+        },
+    });
+    return storage;
+}

package/src/plugins/encryption-crypto-js/index.ts

@@ -0,0 +1,220 @@
+/**
+ * this plugin adds the encryption-capabilities to rxdb
+ * It's using crypto-js/aes for password-encryption
+ * @link https://github.com/brix/crypto-js
+ */
+import pkg from 'crypto-js';
+const { AES, enc: cryptoEnc } = pkg;
+
+import { wrapRxStorageInstance } from '../../plugin-helpers.ts';
+import { newRxError, newRxTypeError } from '../../rx-error.ts';
+import { hasEncryption } from '../../rx-storage-helper.ts';
+import type {
+    InternalStoreDocType,
+    RxAttachmentWriteData,
+    RxDocumentData,
+    RxDocumentWriteData,
+    RxJsonSchema,
+    RxStorage,
+    RxStorageInstanceCreationParams
+} from '../../types/index.d.ts';
+import {
+    arrayBufferToBase64,
+    base64ToArrayBuffer,
+    clone,
+    ensureNotFalsy,
+    flatClone,
+    getProperty,
+    setProperty
+} from '../../plugins/utils/index.ts';
+
+export const MINIMUM_PASSWORD_LENGTH: 8 = 8;
+
+
+export function encryptString(value: string, password: string): string {
+    const encrypted = AES.encrypt(value, password);
+    return encrypted.toString();
+}
+
+export function decryptString(cipherText: string, password: any): string {
+    /**
+     * Trying to decrypt non-strings
+     * will cause no errors and will be hard to debug.
+     * So instead we do this check here.
+     */
+    if (typeof cipherText !== 'string') {
+        throw newRxError('SNH', {
+            args: {
+                cipherText
+            }
+        });
+    }
+
+    const decrypted = AES.decrypt(cipherText, password);
+    const ret = decrypted.toString(cryptoEnc.Utf8);
+    return ret;
+}
+
+export type InternalStorePasswordDocType = InternalStoreDocType<{
+    hash: string;
+}>;
+
+export function wrappedKeyEncryptionCryptoJsStorage<Internals, InstanceCreationOptions>(
+    args: {
+        storage: RxStorage<Internals, InstanceCreationOptions>;
+    }
+): RxStorage<Internals, InstanceCreationOptions> {
+    return Object.assign(
+        {},
+        args.storage,
+        {
+            async createStorageInstance<RxDocType>(
+                params: RxStorageInstanceCreationParams<RxDocType, any>
+            ) {
+                if (typeof params.password !== 'undefined') {
+                    validatePassword(params.password as any);
+                }
+
+                if (!hasEncryption(params.schema)) {
+                    const retInstance = await args.storage.createStorageInstance(params);
+                    return retInstance;
+                }
+
+                if (!params.password) {
+                    throw newRxError('EN3', {
+                        database: params.databaseName,
+                        collection: params.collectionName,
+                        schema: params.schema
+                    });
+                }
+                const password = params.password;
+
+                const schemaWithoutEncrypted: RxJsonSchema<RxDocumentData<RxDocType>> = clone(params.schema);
+                delete schemaWithoutEncrypted.encrypted;
+                if (schemaWithoutEncrypted.attachments) {
+                    schemaWithoutEncrypted.attachments.encrypted = false;
+                }
+
+                /**
+                 * Encrypted data is always stored as string
+                 * so we have to change the schema to have "type": "string"
+                 * on encrypted fields.
+                 */
+                ensureNotFalsy(params.schema.encrypted).forEach(key => {
+                    (schemaWithoutEncrypted as any).properties[key].type = 'string';
+                    delete (schemaWithoutEncrypted as any).properties[key].properties;
+                });
+
+                const instance = await args.storage.createStorageInstance(
+                    Object.assign(
+                        {},
+                        params,
+                        {
+                            schema: schemaWithoutEncrypted
+                        }
+                    )
+                );
+
+                async function modifyToStorage(docData: RxDocumentWriteData<RxDocType>) {
+                    docData = cloneWithoutAttachments(docData);
+                    ensureNotFalsy(params.schema.encrypted)
+                        .forEach(path => {
+                            const value = getProperty(docData, path);
+                            if (typeof value === 'undefined') {
+                                return;
+                            }
+
+                            const stringValue = JSON.stringify(value);
+                            const encrypted = encryptString(stringValue, password);
+                            setProperty(docData, path, encrypted);
+                        });
+
+                    // handle attachments
+                    if (
+                        params.schema.attachments &&
+                        params.schema.attachments.encrypted
+                    ) {
+                        const newAttachments: typeof docData._attachments = {};
+                        await Promise.all(
+                            Object.entries(docData._attachments).map(async ([id, attachment]) => {
+                                const useAttachment: RxAttachmentWriteData = flatClone(attachment) as any;
+                                if (useAttachment.data) {
+                                    const ab = await useAttachment.data.arrayBuffer();
+                                    const base64 = arrayBufferToBase64(ab);
+                                    const encrypted = encryptString(base64, password);
+                                    useAttachment.data = new Blob([encrypted], { type: useAttachment.type });
+                                }
+                                newAttachments[id] = useAttachment;
+                            })
+                        );
+                        docData._attachments = newAttachments;
+                    }
+                    return docData;
+                }
+                function modifyFromStorage(docData: RxDocumentData<any>): Promise<RxDocumentData<RxDocType>> {
+                    docData = cloneWithoutAttachments(docData);
+                    ensureNotFalsy(params.schema.encrypted)
+                        .forEach(path => {
+                            const value = getProperty(docData, path);
+                            if (typeof value === 'undefined') {
+                                return;
+                            }
+                            const decrypted = decryptString(value, password);
+                            const decryptedParsed = JSON.parse(decrypted);
+                            setProperty(docData, path, decryptedParsed);
+                        });
+                    return docData;
+                }
+
+                async function modifyAttachmentFromStorage(attachmentData: Blob): Promise<Blob> {
+                    if (
+                        params.schema.attachments &&
+                        params.schema.attachments.encrypted
+                    ) {
+                        const encryptedText = await attachmentData.text();
+                        const decryptedBase64 = decryptString(encryptedText, password);
+                        const ab = base64ToArrayBuffer(decryptedBase64);
+                        return new Blob([ab], attachmentData.type ? { type: attachmentData.type } : undefined);
+                    } else {
+                        return attachmentData;
+                    }
+                }
+
+                return wrapRxStorageInstance(
+                    params.schema,
+                    instance,
+                    modifyToStorage,
+                    modifyFromStorage,
+                    modifyAttachmentFromStorage
+                );
+            }
+        }
+    );
+}
+
+
+
+
+
+function cloneWithoutAttachments<T>(data: RxDocumentWriteData<T>): RxDocumentData<T> {
+    const attachments = data._attachments;
+    data = flatClone(data);
+    delete (data as any)._attachments;
+    data = clone(data);
+    data._attachments = attachments;
+    return data as any;
+}
+
+function validatePassword(password: string) {
+    if (typeof password !== 'string') {
+        throw newRxTypeError('EN1', {
+            password
+        });
+    }
+    if (password.length < MINIMUM_PASSWORD_LENGTH) {
+        throw newRxError('EN2', {
+            minPassLength: MINIMUM_PASSWORD_LENGTH,
+            password
+        });
+    }
+}

package/src/plugins/flutter/dart/analysis_options.yaml

@@ -0,0 +1,30 @@
+# This file configures the static analysis results for your project (errors,
+# warnings, and lints).
+#
+# This enables the 'recommended' set of lints from `package:lints`.
+# This set helps identify many issues that may lead to problems when running
+# or consuming Dart code, and enforces writing Dart using a single, idiomatic
+# style and format.
+#
+# If you want a smaller set of lints you can change this to specify
+# 'package:lints/core.yaml'. These are just the most critical lints
+# (the recommended set includes the core lints).
+# The core lints are also what is used by pub.dev for scoring packages.
+
+include: package:lints/recommended.yaml
+
+# Uncomment the following section to specify additional rules.
+
+# linter:
+#   rules:
+#     - camel_case_types
+
+# analyzer:
+#   exclude:
+#     - path/to/excluded/files/**
+
+# For more information about the core and recommended set of lints, see
+# https://dart.dev/go/core-lints
+
+# For additional information about configuring this file, see
+# https://dart.dev/guides/language/analysis-options

package/src/plugins/flutter/dart/example/rxdb_example.dart

@@ -0,0 +1,6 @@
+import 'package:rxdb/rxdb.dart';
+
+void main() {
+  var awesome = Awesome();
+  print('awesome: ${awesome.isAwesome}');
+}

package/src/plugins/flutter/dart/lib/rxdb.dart

@@ -0,0 +1,7 @@
+/// Support for doing something awesome.
+///
+/// More dartdocs go here.
+library rxdb;
+
+export 'src/rxdb_base.dart';
+