@connecttomahdi/rxdb 17.1.0 → 17.1.1

package/dist/types/types/rx-error.d.ts

@@ -0,0 +1,225 @@
+import type { RxJsonSchema } from './rx-schema.d.ts';
+import {
+    RxSchema
+} from '../rx-schema.ts';
+import type { RxPlugin } from './rx-plugin.d.ts';
+import { ERROR_MESSAGES } from '../plugins/dev-mode/error-messages.ts';
+import type { RxReplicationWriteToMasterRow } from './replication-protocol.d.ts';
+import type { BulkWriteRow, RxDocumentData } from './rx-storage.d.ts';
+
+type KeyOf<T extends object> = Extract<keyof T, string>;
+export type RxErrorKey = KeyOf<typeof ERROR_MESSAGES>;
+
+export type {
+    RxError,
+    RxTypeError
+} from '../rx-error.ts';
+
+/**
+ * this lists all possible parameters
+ */
+export interface RxErrorParameters {
+    readonly error?: PlainJsonError;
+    readonly errors?: PlainJsonError[];
+    readonly errorText?: string;
+    readonly writeError?: RxStorageWriteError<any>;
+    readonly schemaPath?: string;
+    readonly objPath?: string;
+    readonly rootPath?: string;
+    readonly childpath?: string;
+    readonly ids?: string[];
+    readonly duplicateIds?: string[];
+    readonly obj?: any;
+    readonly document?: any;
+    readonly schema?: Readonly<RxJsonSchema<any> | RxSchema>;
+    readonly schemaObj?: any;
+    readonly pluginKey?: string;
+    readonly originalDoc?: Readonly<any>;
+    readonly finalDoc?: Readonly<any>;
+    readonly regex?: string;
+    readonly fieldName?: string;
+    readonly id?: string;
+    readonly documentId?: string;
+    readonly data?: any;
+    readonly missingCollections?: string[];
+    readonly primaryPath?: string;
+    readonly primary?: string;
+    readonly primaryKey?: string;
+    readonly have?: any;
+    readonly should?: any;
+    readonly name?: string;
+    readonly adapter?: any;
+    readonly link?: string;
+    readonly path?: string;
+    readonly value?: any;
+    readonly givenName?: string;
+    readonly fromVersion?: number;
+    readonly toVersion?: number;
+    readonly version?: number;
+    readonly args?: any;
+    readonly opts?: any;
+    readonly dataBefore?: any;
+    readonly dataAfter?: any;
+    readonly pull?: boolean;
+    readonly push?: boolean;
+    readonly url?: string;
+    readonly key?: string;
+    readonly queryObj?: any;
+    readonly query?: any;
+    readonly op?: string;
+    readonly skip?: any;
+    readonly limit?: any;
+    readonly passwordHash?: string;
+    readonly existingPasswordHash?: string;
+    readonly password?: string | any;
+    readonly passwordType?: string;
+    readonly passwordLength?: number;
+    readonly minPassLength?: number;
+    readonly own?: any;
+    readonly source?: any;
+    readonly method?: any;
+    readonly field?: string;
+    readonly ref?: string;
+    readonly funName?: string;
+    readonly functionName?: string;
+    readonly schemaHash?: string;
+    readonly previousSchema?: Readonly<RxJsonSchema<any>>;
+    readonly previousSchemaHash?: string;
+    readonly type?: string;
+    readonly when?: string;
+    readonly parallel?: boolean;
+    readonly collection?: any;
+    readonly database?: any;
+    readonly storage?: string;
+    readonly indexes?: Array<string | string[]> | Readonly<Array<string | string[]>>;
+    readonly index?: string | string[] | readonly string[];
+    readonly plugin?: RxPlugin | any;
+    readonly plugins?: Set<RxPlugin | any>;
+
+    // used in the replication plugin
+
+    /**
+     * The checkpoint of the response from the last successful
+     * pull by the client.
+     * Null if there was no pull operation before
+     * so that there is no last pulled checkpoint.
+     */
+    readonly checkpoint?: any;
+    /**
+     * The documents that failed to be pushed.
+     * Typed as 'any' because they might be modified by the push modifier.
+     */
+    readonly pushRows?: RxReplicationWriteToMasterRow<any>[];
+    readonly direction?: 'pull' | 'push';
+
+    // google-drive-replication
+    readonly folderPath?: string;
+    readonly folderName?: string;
+    readonly file?: any;
+    readonly parentId?: string;
+
+    // fetch
+    readonly body?: any;
+    readonly status?: number;
+    readonly statusText?: string;
+    readonly headers?: Record<string, any>;
+    readonly code?: string;
+}
+
+/**
+ * Error-Items which are created by the jsonschema-validator
+ */
+export type RxValidationError = {
+    readonly field: string;
+    readonly message: string;
+};
+
+/**
+ * Use to have a transferable error object
+ * in plain json instead of a JavaScript Error instance.
+ */
+export type PlainJsonError = {
+    name: string;
+    message: string;
+    rxdb?: true;
+    code?: RxErrorKey;
+    url?: string;
+    extensions?: Record<string, any>;
+    parameters?: RxErrorParameters;
+    stack?: string;
+};
+
+
+
+
+
+/**
+ * Error that can happen per document when
+ * RxStorage.bulkWrite() is called
+ */
+export type RxStorageWriteErrorBase<RxDocType> = {
+    status: number
+    | 409 // conflict
+    | 422 // schema validation error
+    | 510 // attachment data missing
+    ;
+
+    /**
+     * set this property to make it easy
+     * to detect if the object is a RxStorageBulkWriteError
+     */
+    isError: true;
+
+    // primary key of the document
+    documentId: string;
+
+    // the original document data that should have been written.
+    writeRow: BulkWriteRow<RxDocType>;
+
+    /**
+     * The context which was given to bulkWrite(),
+     * used for debugging.
+     */
+    context: string;
+};
+
+export type RxStorageWriteErrorConflict<RxDocType> = RxStorageWriteErrorBase<RxDocType> & {
+    status: 409;
+    /**
+     * A conflict error state must contain the
+     * document state in the database.
+     * This ensures that we can continue resolving a conflict
+     * without having to pull the document out of the db first.
+     * Is not set if the error happens on an insert.
+     */
+    documentInDb: RxDocumentData<RxDocType>;
+};
+
+export type RxStorageWriteErrorValidation<RxDocType> = RxStorageWriteErrorBase<RxDocType> & {
+    status: 422;
+    /**
+     * Other properties that give
+     * information about the error,
+     * for example a schema validation error
+     * might contain the exact error from the validator here.
+     * Must be plain JSON!
+     */
+    validationErrors: RxValidationError[];
+    /**
+     * For easier debugging,
+     * we directly put the schema into the error.
+     */
+    schema: RxJsonSchema<RxDocumentData<RxDocType>>;
+};
+
+export type RxStorageWriteErrorAttachment<RxDocType> = RxStorageWriteErrorBase<RxDocType> & {
+    status: 510;
+    attachmentId: string;
+    documentInDb?: RxDocumentData<RxDocType>;
+};
+
+
+export type RxStorageWriteError<RxDocType> =
+    RxStorageWriteErrorConflict<RxDocType> |
+    RxStorageWriteErrorValidation<RxDocType> |
+    RxStorageWriteErrorAttachment<RxDocType>;

package/dist/types/types/rx-plugin.d.ts

@@ -0,0 +1,167 @@
+import type {
+    RxQuery,
+    RxQueryOP,
+    MangoQuery
+} from './rx-query.d.ts';
+import type {
+    RxCollection,
+    RxCollectionCreator
+} from './rx-collection.d.ts';
+import type {
+    RxStorageInstanceCreationParams
+} from './rx-storage.d.ts';
+import type {
+    DeepReadonly,
+    FilledMangoQuery,
+    RxDatabase,
+    RxDatabaseCreator,
+    RxDocument,
+    RxStorage,
+    RxReplicationWriteToMasterRow,
+    WithDeleted,
+    RxState,
+    BulkWriteRow,
+    RxStorageInstance
+} from './index.d.ts';
+import type { RxSchema } from '../rx-schema.d.ts';
+
+export type RxPluginPrePrepareRxQueryArgs = {
+    op: RxQueryOP;
+    queryObj: MangoQuery | string | number | Array<any>;
+    collection: RxCollection;
+};
+
+export type RxPluginPreCreateRxQueryArgs = {
+    op: RxQueryOP;
+    queryObj: MangoQuery;
+    collection: RxCollection;
+};
+
+export type RxPluginPreAddRxPluginArgs = {
+    // the plugin that is getting added
+    plugin: RxPlugin | any;
+    // previous added plugins
+    plugins: Set<RxPlugin | any>;
+};
+
+export type RxPluginPrePrepareQueryArgs = {
+    rxQuery: RxQuery<any>;
+    mangoQuery: FilledMangoQuery<any>;
+};
+
+
+/**
+ * Depending on which plugins are used together,
+ * it is important that the plugin is able to define if
+ * the hooks must be added as first or as last array item.
+ * For example the encryption plugin must run encryption
+ * before the key-compression changes the fieldnames.
+ */
+export type RxPluginHooks<Input> = {
+    /**
+     * Hook function that is added as first.
+     */
+    before?: (i: Input) => void;
+    /**
+     * Hook function that is added as last.
+     */
+    after?: (i: Input) => void;
+};
+
+export interface RxPlugin {
+    /**
+     * A string to uniquely identifies the plugin.
+     * Can be used to throw when different versions of the same plugin are used.
+     * And also other checks.
+     * Use kebab-case.
+     */
+    readonly name: string;
+
+    /**
+     * set this to true so RxDB
+     * knows that this object in a rxdb plugin
+     */
+    readonly rxdb: true;
+
+    /**
+     * Init function where dependent plugins could be added.
+     * (optional)
+     */
+    init?(): any;
+
+    prototypes?: {
+        RxSchema?: (proto: RxSchema) => void;
+        RxDocument?: (proto: RxDocument) => void;
+        RxQuery?: (proto: RxQuery) => void;
+        RxCollection?: (proto: RxCollection) => void;
+        RxDatabase?: (proto: RxDatabase) => void;
+    };
+    overwritable?: {
+        isDevMode?: () => boolean;
+        deepFreezeWhenDevMode?: <T>(obj: T) => DeepReadonly<T>;
+        validatePassword?: Function;
+        checkAdapter?: Function;
+        tunnelErrorMessage?: Function;
+    };
+    hooks?: {
+        preAddRxPlugin?: RxPluginHooks<RxPluginPreAddRxPluginArgs>;
+        preCreateRxDatabase?: RxPluginHooks<any>;
+        createRxDatabase?: RxPluginHooks<{
+            database: RxDatabase;
+            creator: RxDatabaseCreator;
+        }>;
+        preCloseRxDatabase?: RxPluginHooks<RxDatabase>;
+        postRemoveRxDatabase?: RxPluginHooks<{
+            databaseName: string;
+            storage: RxStorage<any, any>;
+        }>;
+        createRxCollection?: RxPluginHooks<{
+            collection: RxCollection;
+            creator: RxCollectionCreator;
+        }>;
+        createRxState?: RxPluginHooks<{
+            collection: RxCollection;
+            state: RxState<unknown, unknown>;
+        }>;
+        preCreateRxCollection?: RxPluginHooks<RxCollectionCreator<any> & {
+            name: string;
+            database: RxDatabase;
+        }>;
+        postCloseRxCollection?: RxPluginHooks<RxCollection>;
+        postRemoveRxCollection?: RxPluginHooks<{
+            storage: RxStorage<any, any>;
+            databaseName: string;
+            collectionName: string;
+        }>;
+        preCreateRxSchema?: RxPluginHooks<any>;
+        createRxSchema?: RxPluginHooks<any>;
+        prePrepareRxQuery?: RxPluginHooks<RxPluginPrePrepareRxQueryArgs>;
+        preCreateRxQuery?: RxPluginHooks<RxPluginPreCreateRxQueryArgs>;
+        prePrepareQuery?: RxPluginHooks<RxPluginPrePrepareQueryArgs>;
+        createRxQuery?: RxPluginHooks<RxQuery>;
+        createRxDocument?: RxPluginHooks<any>;
+        postCreateRxDocument?: RxPluginHooks<any>;
+        preCreateRxStorageInstance?: RxPluginHooks<RxStorageInstanceCreationParams<any, any>>;
+        /**
+         * Runs before a write to the storage instance of a RxCollection or RxDatabase.
+         */
+        preStorageWrite?: RxPluginHooks<{
+            storageInstance: RxStorageInstance<any, any, any, any>;
+            rows: BulkWriteRow<any>[];
+        }>;
+        preMigrateDocument?: RxPluginHooks<any>;
+        postMigrateDocument?: RxPluginHooks<any>;
+        postCleanup?: RxPluginHooks<{
+            databaseName: string;
+            collectionName: string;
+        }>;
+        preReplicationMasterWrite?: RxPluginHooks<{
+            rows: RxReplicationWriteToMasterRow<any>[];
+            collection: RxCollection;
+        }>;
+        preReplicationMasterWriteDocumentsHandle?: RxPluginHooks<{
+            result: WithDeleted<any>[];
+            collection: RxCollection;
+        }>;
+    };
+}

package/dist/types/types/rx-query.d.ts

@@ -0,0 +1,144 @@
+import type {
+    RxQueryBase
+} from '../rx-query.d.ts';
+import type { Paths, StringKeys } from './util.d.ts';
+
+/**
+ * Typed Mango Query Selector
+ * @link https://github.com/mongodb/node-mongodb-native/blob/26bce4a8debb65df5a42dc8599e886c9c83de10d/src/mongo_types.ts
+ * @link https://stackoverflow.com/a/58436959/3443137
+ */
+
+
+export type PropertyType<Type, Property extends string> = string extends Property
+    ? unknown
+    : Property extends keyof Type
+    ? Type[Property]
+    : Property extends `${number}`
+    ? Type extends ReadonlyArray<infer ArrayType>
+    ? ArrayType
+    : unknown
+    : Property extends `${infer Key}.${infer Rest}`
+    ? Key extends `${number}`
+    ? Type extends ReadonlyArray<infer ArrayType>
+    ? PropertyType<ArrayType, Rest>
+    : unknown
+    : Key extends keyof Type
+    ? Type[Key] extends Map<string, infer MapType>
+    ? MapType
+    : PropertyType<Type[Key], Rest>
+    : unknown
+    : unknown;
+
+
+export type MangoQueryRegexOptions = 'i' | 'g' | 'm' | 'gi' | 'ig' | 'igm' | string;
+
+/*
+ * 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 interface MangoQueryOperators<PathValueType> {
+    $eq?: PathValueType;
+    $gt?: PathValueType;
+    $gte?: PathValueType;
+    $lt?: PathValueType;
+    $lte?: PathValueType;
+    $ne?: PathValueType;
+    $in?: PathValueType[];
+    $nin?: PathValueType[];
+    $regex?: string;
+    $options?: MangoQueryRegexOptions;
+    $exists?: boolean;
+    $type?: 'null' | 'boolean' | 'number' | 'string' | 'array' | 'object';
+    $mod?: [number, number];
+    $not?: PathValueType;
+    $size?: number;
+    $elemMatch?: MangoQuerySelector<PathValueType>;
+}
+
+export type MangoQuerySelector<DocType> = Partial<{
+    [Property in Paths<DocType>]: MangoQueryOperators<any> | PropertyType<DocType, Property>;
+}> & {
+    $and?: MangoQuerySelector<DocType>[];
+    $or?: MangoQuerySelector<DocType>[];
+    $nor?: MangoQuerySelector<DocType>[];
+};
+
+/**
+ * Discussion was at:
+ * @link https://github.com/pubkey/rxdb/issues/1972
+ */
+export type MangoQuerySortDirection = 'asc' | 'desc';
+export type MangoQuerySortPart<RxDocType = any> = {
+    [k in StringKeys<RxDocType> | string]: MangoQuerySortDirection;
+};
+
+export type MangoQuerySelectorAndIndex<RxDocType = any> = {
+    /**
+     * Selector is optional,
+     * if not given, the query matches all documents
+     * that are not _deleted=true.
+     */
+    selector?: MangoQuerySelector<RxDocType>;
+    /**
+     * By default, the RxStorage implementation
+     * decides which index to use when running the query.
+     *
+     * For better performance, a different index might be defined
+     * by setting it in the query.
+     * How this improves performance and if the defined index is used,
+     * depends on the RxStorage implementation.
+     */
+    index?: string | string[];
+};
+
+export type MangoQueryNoLimit<RxDocType> = MangoQuerySelectorAndIndex<RxDocType> & {
+    /**
+     * Sorting of the results.
+     * If no sort is set, RxDB will sort by the primary key.
+     * Also if sort is set, RxDB will add primaryKey sorting
+     * if the primaryKey was not in the sort parameters before.
+     * This ensures that there is a deterministic sorting of the
+     * results, not mather at which order the documents have been
+     * inserted into the storage.
+     */
+    sort?: MangoQuerySortPart<RxDocType>[];
+};
+
+export type MangoQuery<RxDocType = any> = MangoQueryNoLimit<RxDocType> & {
+    skip?: number;
+    limit?: number;
+};
+
+export type RxQueryOP = 'find' | 'findOne' | 'count' | 'findByIds';
+
+export declare class RxQuery<
+    RxDocumentType = any,
+    RxQueryResult = any,
+    OrmMethods = {},
+    Reactivity = unknown
+> extends RxQueryBase<RxDocumentType, RxQueryResult, OrmMethods, Reactivity> {
+    equals(queryObj: any): RxQuery<RxDocumentType, RxQueryResult>;
+    eq(queryObj: any): RxQuery<RxDocumentType, RxQueryResult>;
+    or(queryObj: keyof RxDocumentType | string | any[]): RxQuery<RxDocumentType, RxQueryResult>;
+    nor(queryObj: keyof RxDocumentType | string | any[]): RxQuery<RxDocumentType, RxQueryResult>;
+    and(queryObj: keyof RxDocumentType | string | any[]): RxQuery<RxDocumentType, RxQueryResult>;
+    gt(queryObj: any): RxQuery<RxDocumentType, RxQueryResult>;
+    gte(queryObj: any): RxQuery<RxDocumentType, RxQueryResult>;
+    lt(queryObj: any): RxQuery<RxDocumentType, RxQueryResult>;
+    lte(queryObj: any): RxQuery<RxDocumentType, RxQueryResult>;
+    ne(queryObj: any): RxQuery<RxDocumentType, RxQueryResult>;
+    in(queryObj: any[]): RxQuery<RxDocumentType, RxQueryResult>;
+    nin(queryObj: any[]): RxQuery<RxDocumentType, RxQueryResult>;
+    all(queryObj: any): RxQuery<RxDocumentType, RxQueryResult>;
+    regex(queryObj: string | {
+        $regex: string;
+        $options: MangoQueryRegexOptions;
+    }): RxQuery<RxDocumentType, RxQueryResult>;
+    exists(queryObj: any): RxQuery<RxDocumentType, RxQueryResult>;
+    elemMatch(queryObj: any): RxQuery<RxDocumentType, RxQueryResult>;
+    mod(p1: any, p2: any, p3: any): RxQuery<RxDocumentType, RxQueryResult>;
+}