@connecttomahdi/rxdb 17.0.0-beta.17

package/src/plugins/dev-mode/check-schema.ts

@@ -0,0 +1,564 @@
+/**
+ * does additional checks over the schema-json
+ * to ensure nothing is broken or not supported
+ */
+import {
+    newRxError
+} from '../../rx-error.ts';
+import {
+    getPrimaryFieldOfPrimaryKey,
+    getSchemaByObjectPath
+} from '../../rx-schema-helper.ts';
+import type {
+    CompositePrimaryKey,
+    JsonSchema,
+    JsonSchemaTypes,
+    RxJsonSchema,
+    TopLevelProperty
+} from '../../types/index.d.ts';
+import {
+    flattenObject,
+    getProperty,
+    isMaybeReadonlyArray,
+    trimDots
+} from '../../plugins/utils/index.ts';
+import { rxDocumentProperties } from './entity-properties.ts';
+
+/**
+ * checks if the fieldname is allowed
+ * this makes sure that the fieldnames can be transformed into javascript-vars
+ * and does not conquer the observe$ and populate_ fields
+ * @throws {Error}
+ */
+export function checkFieldNameRegex(fieldName: string) {
+    if (fieldName === '_deleted') {
+        return;
+    }
+
+    if (['properties'].includes(fieldName)) {
+        throw newRxError('SC23', {
+            fieldName
+        });
+    }
+
+    const regexStr = '^[a-zA-Z](?:[[a-zA-Z0-9_]*]?[a-zA-Z0-9])?$';
+    const regex = new RegExp(regexStr);
+    if (
+        /**
+         * It must be allowed to set _id as primaryKey.
+         * This makes it sometimes easier to work with RxDB+CouchDB
+         * @link https://github.com/pubkey/rxdb/issues/681
+         */
+        fieldName !== '_id' &&
+        !fieldName.match(regex)
+    ) {
+        throw newRxError('SC1', {
+            regex: regexStr,
+            fieldName
+        });
+    }
+}
+
+/**
+ * validate that all schema-related things are ok
+ */
+export function validateFieldsDeep(rxJsonSchema: RxJsonSchema<any>): true {
+
+    const primaryPath = getPrimaryFieldOfPrimaryKey(rxJsonSchema.primaryKey);
+
+    function checkField(
+        fieldName: string,
+        schemaObj: JsonSchema<any>,
+        path: string
+    ) {
+        if (
+            typeof fieldName === 'string' &&
+            typeof schemaObj === 'object' &&
+            !Array.isArray(schemaObj) &&
+            path.split('.').pop() !== 'patternProperties'
+        ) checkFieldNameRegex(fieldName);
+
+        // 'item' only allowed it type=='array'
+        if (Object.prototype.hasOwnProperty.call(schemaObj, 'item') && schemaObj.type !== 'array') {
+            throw newRxError('SC2', {
+                fieldName
+            });
+        }
+
+        /**
+         * required fields cannot be set via 'required: true',
+         * but must be set via required: []
+         */
+        if (
+            Object.prototype.hasOwnProperty.call(schemaObj, 'required') &&
+            typeof schemaObj.required === 'boolean'
+        ) {
+            throw newRxError('SC24', {
+                fieldName
+            });
+        }
+
+        // $ref is not allowed
+        if (Object.prototype.hasOwnProperty.call(schemaObj, '$ref')) {
+            throw newRxError('SC40', {
+                fieldName
+            });
+        }
+
+
+        // if ref given, must be type=='string', type=='array' with string-items or type==['string','null']
+        if (Object.prototype.hasOwnProperty.call(schemaObj, 'ref')) {
+            if (Array.isArray(schemaObj.type)) {
+                if (schemaObj.type.length > 2 || !schemaObj.type.includes('string') || !schemaObj.type.includes('null')) {
+                    throw newRxError('SC4', {
+                        fieldName
+                    });
+                }
+            } else {
+                switch (schemaObj.type) {
+                    case 'string':
+                        break;
+                    case 'array':
+                        if (
+                            !schemaObj.items ||
+                            !(schemaObj.items as any).type ||
+                            (schemaObj.items as any).type !== 'string'
+                        ) {
+                            throw newRxError('SC3', {
+                                fieldName
+                            });
+                        }
+                        break;
+                    default:
+                        throw newRxError('SC4', {
+                            fieldName
+                        });
+                }
+            }
+        }
+
+        const isNested = path.split('.').length >= 2;
+
+        // nested only
+        if (isNested) {
+            if ((schemaObj as any).default) {
+                throw newRxError('SC7', {
+                    path
+                });
+            }
+        }
+
+        // first level
+        if (!isNested) {
+
+            // if _id is used, it must be primaryKey
+            if (
+                fieldName === '_id' &&
+                primaryPath !== '_id'
+            ) {
+                throw newRxError('COL2', {
+                    fieldName
+                });
+            }
+
+            // check underscore fields
+            if (fieldName.charAt(0) === '_') {
+                if (
+                    // exceptional allow underscore on these fields.
+                    fieldName === '_id' ||
+                    fieldName === '_deleted'
+                ) {
+                    return;
+                }
+                throw newRxError('SC8', {
+                    fieldName
+                });
+            }
+        }
+    }
+
+    function traverse(currentObj: any, currentPath: any) {
+        if (!currentObj || typeof currentObj !== 'object') {
+            return;
+        }
+        Object.keys(currentObj).forEach(attributeName => {
+            const schemaObj = currentObj[attributeName];
+            if (
+                !currentObj.properties &&
+                schemaObj &&
+                typeof schemaObj === 'object' &&
+                !Array.isArray(currentObj)
+            ) {
+                checkField(
+                    attributeName,
+                    schemaObj,
+                    currentPath
+                );
+            }
+            let nextPath = currentPath;
+            if (attributeName !== 'properties') nextPath = nextPath + '.' + attributeName;
+            traverse(schemaObj, nextPath);
+        });
+    }
+    traverse(rxJsonSchema, '');
+    return true;
+}
+
+export function checkPrimaryKey(
+    jsonSchema: RxJsonSchema<any>
+) {
+    if (!jsonSchema.primaryKey) {
+        throw newRxError('SC30', { schema: jsonSchema });
+    }
+
+
+
+    function validatePrimarySchemaPart(
+        schemaPart: JsonSchema | TopLevelProperty
+    ) {
+        if (!schemaPart) {
+            throw newRxError('SC33', { schema: jsonSchema });
+        }
+
+        const type: string = schemaPart.type as any;
+        if (
+            !type ||
+            !['string', 'number', 'integer'].includes(type)
+        ) {
+            throw newRxError('SC32', { schema: jsonSchema, args: { schemaPart } });
+        }
+    }
+
+    if (typeof jsonSchema.primaryKey === 'string') {
+        const key = jsonSchema.primaryKey;
+        const schemaPart = jsonSchema.properties[key];
+        validatePrimarySchemaPart(schemaPart);
+    } else {
+        const compositePrimaryKey: CompositePrimaryKey<any> = jsonSchema.primaryKey as any;
+
+        const keySchemaPart = getSchemaByObjectPath(jsonSchema, compositePrimaryKey.key);
+        validatePrimarySchemaPart(keySchemaPart);
+
+        compositePrimaryKey.fields.forEach(field => {
+            const schemaPart = getSchemaByObjectPath(jsonSchema, field);
+            validatePrimarySchemaPart(schemaPart);
+        });
+    }
+
+
+    /**
+     * The primary key must have a maxLength set
+     * which is required by some RxStorage implementations
+     * to ensure we can craft custom index strings.
+     */
+    const primaryPath = getPrimaryFieldOfPrimaryKey(jsonSchema.primaryKey);
+    const primaryPathSchemaPart = jsonSchema.properties[primaryPath];
+    if (!primaryPathSchemaPart.maxLength) {
+        throw newRxError('SC39', { schema: jsonSchema, args: { primaryPathSchemaPart } });
+    } else if (!isFinite(primaryPathSchemaPart.maxLength)) {
+        throw newRxError('SC41', { schema: jsonSchema, args: { primaryPathSchemaPart } });
+    }
+}
+
+/**
+ * computes real path of the object path in the collection schema
+ */
+function getSchemaPropertyRealPath(shortPath: string) {
+    const pathParts = shortPath.split('.');
+    let realPath = '';
+    for (let i = 0; i < pathParts.length; i += 1) {
+        if (pathParts[i] !== '[]') {
+            realPath = realPath.concat('.properties.'.concat(pathParts[i]));
+        } else {
+            realPath = realPath.concat('.items');
+        }
+    }
+    return trimDots(realPath);
+}
+
+/**
+ * does the checking
+ * @throws {Error} if something is not ok
+ */
+export function checkSchema(jsonSchema: RxJsonSchema<any>) {
+
+    if (!jsonSchema.primaryKey) {
+        throw newRxError('SC30', {
+            schema: jsonSchema
+        });
+    }
+
+    if (!Object.prototype.hasOwnProperty.call(jsonSchema, 'properties')) {
+        throw newRxError('SC29', {
+            schema: jsonSchema
+        });
+    }
+
+    // _rev MUST NOT exist, it is added by RxDB
+    if (jsonSchema.properties._rev) {
+        throw newRxError('SC10', {
+            schema: jsonSchema
+        });
+    }
+
+    // check version
+    if (!Object.prototype.hasOwnProperty.call(jsonSchema, 'version') ||
+        typeof jsonSchema.version !== 'number' ||
+        jsonSchema.version < 0
+    ) {
+        throw newRxError('SC11', {
+            version: jsonSchema.version
+        });
+    }
+
+    validateFieldsDeep(jsonSchema);
+    checkPrimaryKey(jsonSchema);
+
+    Object.keys(jsonSchema.properties).forEach(key => {
+        const value: any = jsonSchema.properties[key];
+        // check primary
+        if (key === jsonSchema.primaryKey) {
+            if (jsonSchema.indexes && jsonSchema.indexes.includes(key)) {
+                throw newRxError('SC13', {
+                    value,
+                    schema: jsonSchema
+                });
+            }
+            if (value.unique) {
+                throw newRxError('SC14', {
+                    value,
+                    schema: jsonSchema
+                });
+            }
+            if (jsonSchema.encrypted && jsonSchema.encrypted.includes(key)) {
+                throw newRxError('SC15', {
+                    value,
+                    schema: jsonSchema
+                });
+            }
+            if (value.type !== 'string') {
+                throw newRxError('SC16', {
+                    value,
+                    schema: jsonSchema
+                });
+            }
+        }
+
+        // check if RxDocument-property
+        if (rxDocumentProperties().includes(key)) {
+            throw newRxError('SC17', {
+                key,
+                schema: jsonSchema
+            });
+        }
+    });
+
+    // check format of jsonSchema.indexes
+    if (jsonSchema.indexes) {
+        // should be an array
+        if (!isMaybeReadonlyArray(jsonSchema.indexes)) {
+            throw newRxError('SC18', {
+                indexes: jsonSchema.indexes,
+                schema: jsonSchema
+            });
+        }
+
+        jsonSchema.indexes.forEach(index => {
+            // should contain strings or array of strings
+            if (!(typeof index === 'string' || Array.isArray(index))) {
+                throw newRxError('SC19', { index, schema: jsonSchema });
+            }
+            // if is a compound index it must contain strings
+            if (Array.isArray(index)) {
+                for (let i = 0; i < index.length; i += 1) {
+                    if (typeof index[i] !== 'string') {
+                        throw newRxError('SC20', { index, schema: jsonSchema });
+                    }
+                }
+            }
+
+            /**
+             * To be able to craft custom indexable string with compound fields,
+             * we need to know the maximum fieldlength of the fields values
+             * when they are transformed to strings.
+             * Therefore we need to enforce some properties inside of the schema.
+             */
+            const indexAsArray = isMaybeReadonlyArray(index) ? index : [index];
+            indexAsArray.forEach(fieldName => {
+                const schemaPart = getSchemaByObjectPath(
+                    jsonSchema,
+                    fieldName
+                );
+
+
+                const type: JsonSchemaTypes = schemaPart.type as any;
+                switch (type) {
+                    case 'string':
+                        const maxLength = schemaPart.maxLength;
+                        if (!maxLength) {
+                            throw newRxError('SC34', {
+                                index,
+                                field: fieldName,
+                                schema: jsonSchema
+                            });
+                        }
+                        if (maxLength > 2048) {
+                            throw newRxError('SC42', {
+                                index,
+                                field: fieldName,
+                                schema: jsonSchema
+                            });
+                        }
+                        break;
+                    case 'number':
+                    case 'integer':
+                        const multipleOf = schemaPart.multipleOf;
+                        if (!multipleOf) {
+                            throw newRxError('SC35', {
+                                index,
+                                field: fieldName,
+                                schema: jsonSchema
+                            });
+                        }
+                        const maximum = schemaPart.maximum;
+                        const minimum = schemaPart.minimum;
+                        if (
+                            typeof maximum === 'undefined' ||
+                            typeof minimum === 'undefined'
+                        ) {
+                            throw newRxError('SC37', {
+                                index,
+                                field: fieldName,
+                                schema: jsonSchema
+                            });
+                        }
+
+                        if (
+                            !isFinite(maximum) ||
+                            !isFinite(minimum)
+                        ) {
+                            throw newRxError('SC41', {
+                                index,
+                                field: fieldName,
+                                schema: jsonSchema
+                            });
+                        }
+
+                        break;
+                    case 'boolean':
+                        /**
+                         * If a boolean field is used as an index,
+                         * it must be required.
+                         */
+                        let parentPath = '';
+                        let lastPathPart = fieldName;
+                        if (fieldName.includes('.')) {
+                            const partParts = fieldName.split('.');
+                            lastPathPart = partParts.pop();
+                            parentPath = partParts.join('.');
+                        }
+                        const parentSchemaPart = parentPath === '' ? jsonSchema : getSchemaByObjectPath(
+                            jsonSchema,
+                            parentPath
+                        );
+
+                        if (
+                            !parentSchemaPart.required ||
+                            !parentSchemaPart.required.includes(lastPathPart)
+                        ) {
+                            throw newRxError('SC38', {
+                                index,
+                                field: fieldName,
+                                schema: jsonSchema
+                            });
+                        }
+                        break;
+
+                    default:
+                        throw newRxError('SC36', {
+                            fieldName,
+                            type: schemaPart.type as any,
+                            schema: jsonSchema,
+                        });
+                }
+            });
+
+        });
+    }
+
+    // remove backward-compatibility for index: true
+    Object.keys(flattenObject(jsonSchema))
+        .map(key => {
+            // flattenObject returns only ending paths, we need all paths pointing to an object
+            const split = key.split('.');
+            split.pop(); // all but last
+            return split.join('.');
+        })
+        .filter(key => key !== '')
+        .filter((elem, pos, arr) => arr.indexOf(elem) === pos) // unique
+        .filter(key => { // check if this path defines an index
+            const value = getProperty(jsonSchema, key);
+            return value && !!value.index;
+        })
+        .forEach(key => { // replace inner properties
+            key = key.replace('properties.', ''); // first
+            key = key.replace(/\.properties\./g, '.'); // middle
+            throw newRxError('SC26', {
+                index: trimDots(key),
+                schema: jsonSchema
+            });
+        });
+
+    /* check types of the indexes */
+    (jsonSchema.indexes || [])
+        .reduce((indexPaths: string[], currentIndex) => {
+            if (isMaybeReadonlyArray(currentIndex)) {
+                indexPaths = indexPaths.concat(currentIndex);
+            } else {
+                indexPaths.push(currentIndex);
+            }
+            return indexPaths;
+        }, [])
+        .filter((elem, pos, arr) => arr.indexOf(elem) === pos) // from now on working only with unique indexes
+        .map(indexPath => {
+            const realPath = getSchemaPropertyRealPath(indexPath); // real path in the collection schema
+            const schemaObj = getProperty(jsonSchema, realPath); // get the schema of the indexed property
+            if (!schemaObj || typeof schemaObj !== 'object') {
+                throw newRxError('SC21', {
+                    index: indexPath,
+                    schema: jsonSchema
+                });
+            }
+            return { indexPath, schemaObj };
+        })
+        .filter(index =>
+            index.schemaObj.type !== 'string' &&
+            index.schemaObj.type !== 'integer' &&
+            index.schemaObj.type !== 'number' &&
+            index.schemaObj.type !== 'boolean'
+        )
+        .forEach(index => {
+            throw newRxError('SC22', {
+                key: index.indexPath,
+                type: index.schemaObj.type,
+                schema: jsonSchema
+            });
+        });
+
+    /* ensure encrypted fields exist in the schema */
+    if (jsonSchema.encrypted) {
+        jsonSchema.encrypted
+            .forEach(propPath => {
+                // real path in the collection schema
+                const realPath = getSchemaPropertyRealPath(propPath);
+                // get the schema of the indexed property
+                const schemaObj = getProperty(jsonSchema, realPath);
+                if (!schemaObj || typeof schemaObj !== 'object') {
+                    throw newRxError('SC28', {
+                        field: propPath,
+                        schema: jsonSchema
+                    });
+                }
+            });
+    }
+}

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

@@ -0,0 +1,125 @@
+import type { RxDatabase } from '../../types';
+import {
+    RXDB_VERSION,
+    hasPremiumFlag,
+    hashStringToNumber
+} from '../utils/index.ts';
+
+
+let iframeShown = false;
+
+const links: {
+    text: string;
+    url: string;
+}[] = [
+        {
+            text: 'JavaScript Database',
+            url: 'https://rxdb.info/'
+        },
+        {
+            text: 'React Native Database',
+            url: 'https://rxdb.info/react-native-database.html'
+        },
+        {
+            text: 'Local First',
+            url: 'https://rxdb.info/articles/local-first-future.html'
+        },
+        {
+            text: 'Angular IndexedDB',
+            url: 'https://rxdb.info/articles/angular-indexeddb.html'
+        },
+        {
+            text: 'React IndexedDB',
+            url: 'https://rxdb.info/articles/react-indexeddb.html'
+        },
+        {
+            text: 'Firestore Alternative',
+            url: 'https://rxdb.info/articles/firestore-alternative.html'
+        },
+        {
+            text: 'Offline Database',
+            url: 'https://rxdb.info/articles/offline-database.html'
+        },
+        {
+            text: 'JSON Database',
+            url: 'https://rxdb.info/articles/json-database.html'
+        },
+        {
+            text: 'NodeJS Database',
+            url: 'https://rxdb.info/nodejs-database.html'
+        }
+    ];
+
+
+/**
+ * Adds an iframe to track the results of marketing efforts.
+ */
+export async function addDevModeTrackingIframe() {
+    /**
+     * Only run this in browser AND localhost AND dev-mode.
+     * Make sure this is never used in production by someone.
+     */
+    if (
+        iframeShown ||
+        typeof window === 'undefined' ||
+        typeof location === 'undefined' ||
+        typeof document === 'undefined'
+        // !isLocalHost()
+    ) {
+        return;
+    }
+
+
+    // do not show if premium flag is set.
+    if (await hasPremiumFlag()) {
+        return;
+    }
+
+    iframeShown = true;
+
+    /**
+     * Do not use display:none
+     * @link https://medium.com/@zachcaceres/dont-use-display-none-to-hide-iframes-in-safari-b51715eb22c4
+     */
+    const containerDiv = document.createElement('div');
+    containerDiv.style.visibility = 'hidden';
+    containerDiv.style.position = 'absolute';
+    containerDiv.style.top = '0';
+    containerDiv.style.left = '0';
+    containerDiv.style.opacity = '0.1';
+    containerDiv.style.width = '1px';
+    containerDiv.style.height = '1px';
+    containerDiv.style.overflow = 'hidden';
+
+    const iframe = document.createElement('iframe');
+    iframe.width = '1px';
+    iframe.height = '1px';
+    iframe.src = 'https://rxdb.info/html/dev-mode-iframe.html?version=' + RXDB_VERSION;
+    containerDiv.appendChild(iframe);
+
+    const hashNr = hashStringToNumber(location.host);
+    const useLinkId = hashNr % links.length;
+    const useLink = links[useLinkId];
+    const link = document.createElement('a');
+    link.href = useLink.url;
+    link.target = '_blank';
+    link.innerText = useLink.text;
+
+    const p = document.createElement('p');
+    p.innerText = 'This is the iframe which is shown when the RxDB Dev-Mode is enabled. Also see ';
+    p.appendChild(link);
+    containerDiv.appendChild(p);
+
+    document.body.appendChild(containerDiv);
+}
+
+
+function isLocalHost() {
+    return (
+        location.hostname === 'localhost' ||
+        location.hostname.includes('localhost') ||
+        location.hostname === '127.0.0.1' ||
+        location.hostname === '0.0.0.0' ||
+        location.hostname === '[::1]'  // IPv6
+    );
+}