@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/types/plugins/dev-mode/index.d.ts

@@ -0,0 +1,19 @@
+import type { RxPlugin } from '../../types/index.d.ts';
+import { DeepReadonly } from '../../types/util.ts';
+export * from './check-schema.ts';
+export * from './unallowed-properties.ts';
+export * from './check-query.ts';
+/**
+ * Suppresses the warning message shown in the console, typically invoked once the developer (hello!)
+ * has acknowledged it.
+ */
+export declare function disableWarnings(): void;
+/**
+ * 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 declare function deepFreezeWhenDevMode<T>(obj: T): DeepReadonly<T>;
+export declare const DEV_MODE_PLUGIN_NAME = "dev-mode";
+export declare const RxDBDevModePlugin: RxPlugin;

package/dist/types/plugins/dev-mode/unallowed-properties.d.ts

@@ -0,0 +1,20 @@
+import type { RxCollectionCreator, RxDatabaseCreator } from '../../types/index.d.ts';
+/**
+ * if the name of a collection
+ * clashes with a property of RxDatabase,
+ * we get problems so this function prohibits this
+ */
+export declare function ensureCollectionNameValid(args: RxCollectionCreator & {
+    name: string;
+}): void;
+export declare function ensureDatabaseNameIsValid(args: RxDatabaseCreator<any, any>): void;
+/**
+ * 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 declare function validateDatabaseName(name: string): true;

package/dist/types/plugins/electron/electron-helper.d.ts

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

package/dist/types/plugins/electron/index.d.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/dist/types/plugins/electron/rx-storage-ipc-main.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This file contains everything
+ * that is supposed to run inside of the electron main process
+ */
+import type { RxStorage } from '../../types/index.d.ts';
+export declare function exposeIpcMainRxStorage<T, D>(args: {
+    key: string;
+    storage: RxStorage<T, D>;
+    ipcMain: any;
+}): void;

package/dist/types/plugins/electron/rx-storage-ipc-renderer.d.ts

@@ -0,0 +1,13 @@
+import { RxStorageRemote, RxStorageRemoteSettings } from '../storage-remote/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 declare function getRxStorageIpcRenderer(settings: RxStorageIpcRendererSettings): RxStorageIpcRenderer;

package/dist/types/plugins/encryption-crypto-js/index.d.ts

@@ -0,0 +1,10 @@
+import type { InternalStoreDocType, RxStorage } from '../../types/index.d.ts';
+export declare const MINIMUM_PASSWORD_LENGTH: 8;
+export declare function encryptString(value: string, password: string): string;
+export declare function decryptString(cipherText: string, password: any): string;
+export type InternalStorePasswordDocType = InternalStoreDocType<{
+    hash: string;
+}>;
+export declare function wrappedKeyEncryptionCryptoJsStorage<Internals, InstanceCreationOptions>(args: {
+    storage: RxStorage<Internals, InstanceCreationOptions>;
+}): RxStorage<Internals, InstanceCreationOptions>;

package/dist/types/plugins/flutter/index.d.ts

@@ -0,0 +1,11 @@
+import type { RxDatabase } from '../../types/index.d.ts';
+export type CreateRxDatabaseFunctionType = (databaseName: string) => Promise<RxDatabase>;
+export declare function setFlutterRxDatabaseConnector(createDB: CreateRxDatabaseFunctionType): void;
+/**
+ * Create a simple lokijs adapter so that we can persist string via flutter
+ * @link https://github.com/techfort/LokiJS/blob/master/tutorials/Persistence%20Adapters.md#creating-your-own-basic-persistence-adapter
+ */
+export declare function getLokijsAdapterFlutter(): {
+    loadDatabase(databaseName: string, callback: (v: string | Error) => {}): Promise<void>;
+    saveDatabase(databaseName: string, dbstring: string, callback: (v: string | Error | null) => {}): Promise<void>;
+};

package/dist/types/plugins/json-dump/index.d.ts

@@ -0,0 +1,2 @@
+import type { RxPlugin } from '../../types/index.d.ts';
+export declare const RxDBJsonDumpPlugin: RxPlugin;

package/dist/types/plugins/key-compression/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * this plugin adds the keycompression-capabilities to rxdb
+ * if you don't use this, ensure that you set disableKeyCompression to false in your schema
+ */
+import { CompressionTable } from 'jsonschema-key-compression';
+import type { RxJsonSchema, RxStorage, RxDocumentData } from '../../types/index.d.ts';
+declare type CompressionState = {
+    table: CompressionTable;
+    schema: RxJsonSchema<any>;
+    compressedSchema: RxJsonSchema<any>;
+};
+export declare function getCompressionStateByRxJsonSchema(schema: RxJsonSchema<any>): CompressionState;
+export declare function wrappedKeyCompressionStorage<Internals, InstanceCreationOptions>(args: {
+    storage: RxStorage<Internals, InstanceCreationOptions>;
+}): RxStorage<Internals, InstanceCreationOptions>;
+export declare function compressDocumentData(compressionState: CompressionState, docData: RxDocumentData<any>): RxDocumentData<any>;
+export declare function decompressDocumentData(compressionState: CompressionState, docData: RxDocumentData<any>): RxDocumentData<any>;
+export {};

package/dist/types/plugins/leader-election/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * this plugin adds the leader-election-capabilities to rxdb
+ */
+import { LeaderElector, BroadcastChannel } from 'broadcast-channel';
+import type { RxDatabase, RxPlugin } from '../../types/index.d.ts';
+/**
+ * Returns the leader elector of a broadcast channel.
+ * Used to ensure we reuse the same elector for the channel each time.
+ */
+export declare function getLeaderElectorByBroadcastChannel(broadcastChannel: BroadcastChannel): LeaderElector;
+/**
+ * @overwrites RxDatabase().leaderElector for caching
+ */
+export declare function getForDatabase(this: RxDatabase): LeaderElector;
+export declare function isLeader(this: RxDatabase): boolean;
+export declare function waitForLeadership(this: RxDatabase): Promise<boolean>;
+/**
+ * runs when the database gets closed
+ */
+export declare function onClose(db: RxDatabase): void;
+export declare const rxdb = true;
+export declare const prototypes: {
+    RxDatabase: (proto: any) => void;
+};
+export declare const RxDBLeaderElectionPlugin: RxPlugin;

package/dist/types/plugins/local-documents/index.d.ts

@@ -0,0 +1,6 @@
+import type { RxPlugin } from '../../types/index.d.ts';
+export * from './local-documents-helper.ts';
+export * from './local-documents.ts';
+export * from './rx-local-document.ts';
+export type { LocalDocumentParent, LocalDocumentState, RxLocalDocument, RxLocalDocumentData } from '../../types/plugins/local-documents.d.ts';
+export declare const RxDBLocalDocumentsPlugin: RxPlugin;

package/dist/types/plugins/local-documents/local-documents-helper.d.ts

@@ -0,0 +1,9 @@
+import type { LocalDocumentParent, LocalDocumentState, RxDocumentData, RxJsonSchema, RxLocalDocumentData, RxStorage } from '../../types/index.d.ts';
+export declare const LOCAL_DOC_STATE_BY_PARENT: WeakMap<LocalDocumentParent, Promise<LocalDocumentState>>;
+export declare const LOCAL_DOC_STATE_BY_PARENT_RESOLVED: WeakMap<LocalDocumentParent, LocalDocumentState>;
+export declare function getLocalDocStateByParent(parent: LocalDocumentParent): Promise<LocalDocumentState>;
+export declare function createLocalDocumentStorageInstance(databaseInstanceToken: string, storage: RxStorage<any, any>, databaseName: string, collectionName: string, instanceCreationOptions: any, multiInstance: boolean): Promise<import("../../index.ts").RxStorageInstance<RxLocalDocumentData, any, any, any>>;
+export declare function closeStateByParent(parent: LocalDocumentParent): Promise<void> | undefined;
+export declare function removeLocalDocumentsStorageInstance(storage: RxStorage<any, any>, databaseName: string, collectionName: string): Promise<void>;
+export declare function getCollectionLocalInstanceName(collectionName: string): string;
+export declare const RX_LOCAL_DOCUMENT_SCHEMA: RxJsonSchema<RxDocumentData<RxLocalDocumentData>>;

package/dist/types/plugins/local-documents/local-documents.d.ts

@@ -0,0 +1,14 @@
+import type { RxCollection, RxDatabase, RxLocalDocument } from '../../types/index.d.ts';
+import { Observable } from 'rxjs';
+/**
+ * save the local-document-data
+ * throws if already exists
+ */
+export declare function insertLocal<DocData extends Record<string, any> = any, Reactivity = unknown>(this: RxDatabase | RxCollection, id: string, data: DocData): Promise<RxLocalDocument<DocData, any, Reactivity>>;
+/**
+ * save the local-document-data
+ * overwrites existing if exists
+ */
+export declare function upsertLocal<DocData extends Record<string, any> = any, Reactivity = unknown>(this: any, id: string, data: DocData): Promise<RxLocalDocument<DocData, any, Reactivity>>;
+export declare function getLocal<DocData = any, Reactivity = unknown>(this: any, id: string): Promise<RxLocalDocument<DocData, any, Reactivity> | null>;
+export declare function getLocal$<DocData = any, Reactivity = unknown>(this: RxCollection, id: string): Observable<RxLocalDocument<DocData, any, Reactivity> | null>;

package/dist/types/plugins/local-documents/rx-local-document.d.ts

@@ -0,0 +1,11 @@
+import type { LocalDocumentParent, RxCollection, RxDatabase, RxDocumentData, RxLocalDocument, RxLocalDocumentData } from '../../types/';
+declare const RxDocumentParent: any;
+declare class RxLocalDocumentClass<DocData = any> extends RxDocumentParent {
+    readonly id: string;
+    readonly parent: RxCollection | RxDatabase;
+    constructor(id: string, jsonData: DocData, parent: RxCollection | RxDatabase);
+}
+export declare function createRxLocalDocument<DocData>(data: RxDocumentData<RxLocalDocumentData<DocData>>, parent: any): RxLocalDocument<DocData>;
+export declare function getRxDatabaseFromLocalDocument(doc: RxLocalDocument<any> | RxLocalDocumentClass): RxDatabase<import("../../index.ts").CollectionsOfDatabase, any, {}, unknown> | import("../../rx-database.ts").RxDatabaseBase<any, any, any, any>;
+export declare function createLocalDocStateByParent(parent: LocalDocumentParent): void;
+export {};

package/dist/types/plugins/migration-schema/index.d.ts

@@ -0,0 +1,8 @@
+import type { RxPlugin, RxCollection } from '../../types/index.d.ts';
+import { RxMigrationState } from './rx-migration-state.ts';
+export declare const DATA_MIGRATOR_BY_COLLECTION: WeakMap<RxCollection, RxMigrationState>;
+export declare const RxDBMigrationPlugin: RxPlugin;
+export declare const RxDBMigrationSchemaPlugin: RxPlugin;
+export * from './rx-migration-state.ts';
+export * from './migration-helpers.ts';
+export * from './migration-types.ts';

package/dist/types/plugins/migration-schema/migration-helpers.d.ts

@@ -0,0 +1,29 @@
+import { BehaviorSubject } from 'rxjs';
+import type { InternalStoreCollectionDocType, RxCollection, RxDatabase, RxDocumentData } from '../../types/index.d.ts';
+import { RxMigrationState } from './rx-migration-state.ts';
+export declare function getOldCollectionMeta(migrationState: RxMigrationState): Promise<RxDocumentData<InternalStoreCollectionDocType> | undefined>;
+/**
+ * runs the doc-data through all following migrationStrategies
+ * so it will match the newest schema.
+ * @throws Error if final doc does not match final schema or migrationStrategy crashes
+ * @return final object or null if migrationStrategy deleted it
+ */
+export declare function migrateDocumentData(collection: RxCollection, docSchemaVersion: number, docData: any): Promise<any | null>;
+export declare function runStrategyIfNotNull(collection: RxCollection, version: number, docOrNull: any | null): Promise<any | null>;
+/**
+ * returns true if a migration is needed
+ */
+export declare function mustMigrate(migrationState: RxMigrationState): Promise<boolean>;
+export declare const MIGRATION_DEFAULT_BATCH_SIZE = 200;
+export type MigrationStateWithCollection = {
+    collection: RxCollection;
+    migrationState: RxMigrationState;
+};
+export declare const DATA_MIGRATION_STATE_SUBJECT_BY_DATABASE: WeakMap<RxDatabase, BehaviorSubject<RxMigrationState[]>>;
+export declare function addMigrationStateToDatabase(migrationState: RxMigrationState): void;
+export declare function getMigrationStateByDatabase(database: RxDatabase): BehaviorSubject<RxMigrationState[]>;
+/**
+ * Complete on database close
+ * so people do not have to unsubscribe
+ */
+export declare function onDatabaseClose(database: RxDatabase): void;

package/dist/types/plugins/migration-schema/migration-types.d.ts

@@ -0,0 +1,33 @@
+import type { InternalStoreDocType, PlainJsonError } from '../../types/index.d.ts';
+export type RxMigrationStatus = {
+    collectionName: string;
+    status: 'RUNNING' | 'DONE' | 'ERROR';
+    error?: PlainJsonError;
+    /**
+     * Counters so that you can display
+     * the migration state to your user in the UI
+     * and show a loading bar.
+     */
+    count: {
+        /**
+         * Total amount of documents that
+         * have to be migrated
+         */
+        total: number;
+        /**
+         * Amount of documents that have been migrated already
+         * = success + purged
+         */
+        handled: number;
+        /**
+         * Total percentage [0-100]
+         */
+        percent: number;
+    };
+};
+/**
+ * To be shared between browser tabs,
+ * the migration status is written into a document in the internal storage of the database.
+ */
+export type RxMigrationStatusDocument = InternalStoreDocType<RxMigrationStatus>;
+export type MigrationStatusUpdate = (before: RxMigrationStatus) => RxMigrationStatus;

package/dist/types/plugins/migration-schema/rx-migration-state.d.ts

@@ -0,0 +1,50 @@
+import { Observable } from 'rxjs';
+import type { NumberFunctionMap, RxCollection, RxDatabase, RxStorageInstance, RxStorageInstanceReplicationState } from '../../types/index.d.ts';
+import { getOldCollectionMeta, mustMigrate } from './migration-helpers.ts';
+import type { MigrationStatusUpdate, RxMigrationStatus } from './migration-types.ts';
+import { BroadcastChannel } from 'broadcast-channel';
+export declare class RxMigrationState {
+    readonly collection: RxCollection;
+    readonly migrationStrategies: NumberFunctionMap;
+    readonly statusDocKey: string;
+    database: RxDatabase;
+    private started;
+    readonly oldCollectionMeta: ReturnType<typeof getOldCollectionMeta>;
+    readonly mustMigrate: ReturnType<typeof mustMigrate>;
+    readonly statusDocId: string;
+    readonly $: Observable<RxMigrationStatus>;
+    /**
+     * Contains ALL replication states
+     * that are ever used in this migration state.
+     */
+    replicationStates: Set<RxStorageInstanceReplicationState<any>>;
+    canceled: boolean;
+    broadcastChannel?: BroadcastChannel;
+    constructor(collection: RxCollection, migrationStrategies: NumberFunctionMap, statusDocKey?: string);
+    getStatus(): Promise<RxMigrationStatus>;
+    /**
+     * Starts the migration.
+     * Returns void so that people to not get the idea to await
+     * this function.
+     * Instead use migratePromise() if you want to await
+     * the migration. This ensures it works even if the migration
+     * is run on a different browser tab.
+     */
+    startMigration(batchSize?: number): Promise<void>;
+    updateStatusHandlers: MigrationStatusUpdate[];
+    updateStatusQueue: Promise<any>;
+    updateStatus(handler: MigrationStatusUpdate): Promise<any>;
+    migrateStorage(oldStorage: RxStorageInstance<any, any, any>, newStorage: RxStorageInstance<any, any, any>, batchSize: number): Promise<void>;
+    /**
+     * Stops the migration.
+     * Mostly used in tests to simulate what happens
+     * when the user reloads the page during a migration.
+     */
+    cancel(): Promise<void>;
+    countAllDocuments(storageInstances: RxStorageInstance<any, any, any>[]): Promise<number>;
+    getConnectedStorageInstances(): Promise<{
+        oldStorage: RxStorageInstance<any, any, any>;
+        newStorage: RxStorageInstance<any, any, any>;
+    }[]>;
+    migratePromise(batchSize?: number): Promise<RxMigrationStatus>;
+}

package/dist/types/plugins/migration-storage/index.d.ts

@@ -0,0 +1,32 @@
+import { RxDatabase, RxCollection, BulkWriteRow, RxStorageBulkWriteResponse, RxStorage } from '../../index.ts';
+export type RxStorageOld<A, B> = RxStorage<A, B> | any;
+export type AfterMigrateBatchHandlerInput = {
+    databaseName: string;
+    collectionName: string;
+    oldDatabaseName: string;
+    insertToNewWriteRows: BulkWriteRow<any>[];
+    writeToNewResult: RxStorageBulkWriteResponse<any>;
+};
+export type AfterMigrateBatchHandler = (input: AfterMigrateBatchHandlerInput) => any | Promise<any>;
+export type MigrateStorageParams = {
+    database: RxDatabase;
+    /**
+     * Using the migration plugin requires you
+     * to rename your new old database.
+     * The original name of the v11 database must be provided here.
+     */
+    oldDatabaseName: string;
+    oldStorage: RxStorageOld<any, any>;
+    batchSize?: number;
+    parallel?: boolean;
+    afterMigrateBatch?: AfterMigrateBatchHandler;
+    logFunction?: (message: string) => void;
+};
+/**
+ * Migrates collections of RxDB version A and puts them
+ * into a RxDatabase that is created with version B.
+ * This function only works from the previous major version upwards.
+ * Do not use it to migrate like rxdb v9 to v14.
+ */
+export declare function migrateStorage(params: MigrateStorageParams): Promise<void>;
+export declare function migrateCollection<RxDocType>(collection: RxCollection<RxDocType>, oldDatabaseName: string, oldStorage: RxStorageOld<any, any>, batchSize: number, afterMigrateBatch?: AfterMigrateBatchHandler, logFunction?: (message: string) => void): Promise<void>;

package/dist/types/plugins/pipeline/flagged-functions.d.ts

@@ -0,0 +1,69 @@
+/**
+ * This is the most hacky thing we do in RxDB.
+ * When a pipeline "transaction" is running,
+ * we have to make all calls to the collection from the outside
+ * wait while still make it possible to run reads and writes
+ * from inside the transaction.
+ *
+ * We can decide where the call came from by checking the stack `new Error().stack`
+ * for a random "flag".
+ * But creating random flagged functions requires eval which we should not use.
+ * Instead we have a list of some flagged functions here
+ * that can be used and checked for in the stacktrace.
+ *
+ *
+ * When doing this with eval() instead it would look like:
+ * ```ts
+ * eval(`
+ *     async function ${this.secretFunctionName}(docs){ const x = await _this.handler(docs); return x; }
+ *     o.${this.secretFunctionName} = ${this.secretFunctionName};
+ *   `);
+ * await o[this.secretFunctionName](rxDocuments);
+ *
+ * ```
+ */
+declare function rx_pipeline_fn_1_(fn: any): Promise<any>;
+declare function rx_pipeline_fn_2_(fn: any): Promise<any>;
+declare function rx_pipeline_fn_3_(fn: any): Promise<any>;
+declare function rx_pipeline_fn_4_(fn: any): Promise<any>;
+declare function rx_pipeline_fn_5_(fn: any): Promise<any>;
+declare function rx_pipeline_fn_6_(fn: any): Promise<any>;
+declare function rx_pipeline_fn_7_(fn: any): Promise<any>;
+declare function rx_pipeline_fn_8_(fn: any): Promise<any>;
+declare function rx_pipeline_fn_9_(fn: any): Promise<any>;
+declare function rx_pipeline_fn_10_(fn: any): Promise<any>;
+declare function rx_pipeline_fn_11_(fn: any): Promise<any>;
+declare function rx_pipeline_fn_12_(fn: any): Promise<any>;
+declare function rx_pipeline_fn_13_(fn: any): Promise<any>;
+declare function rx_pipeline_fn_14_(fn: any): Promise<any>;
+declare function rx_pipeline_fn_15_(fn: any): Promise<any>;
+declare function rx_pipeline_fn_16_(fn: any): Promise<any>;
+declare function rx_pipeline_fn_17_(fn: any): Promise<any>;
+declare function rx_pipeline_fn_18_(fn: any): Promise<any>;
+declare function rx_pipeline_fn_19_(fn: any): Promise<any>;
+declare function rx_pipeline_fn_20_(fn: any): Promise<any>;
+export declare const FLAGGED_FUNCTIONS: {
+    readonly rx_pipeline_fn_1_: typeof rx_pipeline_fn_1_;
+    readonly rx_pipeline_fn_2_: typeof rx_pipeline_fn_2_;
+    readonly rx_pipeline_fn_3_: typeof rx_pipeline_fn_3_;
+    readonly rx_pipeline_fn_4_: typeof rx_pipeline_fn_4_;
+    readonly rx_pipeline_fn_5_: typeof rx_pipeline_fn_5_;
+    readonly rx_pipeline_fn_6_: typeof rx_pipeline_fn_6_;
+    readonly rx_pipeline_fn_7_: typeof rx_pipeline_fn_7_;
+    readonly rx_pipeline_fn_8_: typeof rx_pipeline_fn_8_;
+    readonly rx_pipeline_fn_9_: typeof rx_pipeline_fn_9_;
+    readonly rx_pipeline_fn_10_: typeof rx_pipeline_fn_10_;
+    readonly rx_pipeline_fn_11_: typeof rx_pipeline_fn_11_;
+    readonly rx_pipeline_fn_12_: typeof rx_pipeline_fn_12_;
+    readonly rx_pipeline_fn_13_: typeof rx_pipeline_fn_13_;
+    readonly rx_pipeline_fn_14_: typeof rx_pipeline_fn_14_;
+    readonly rx_pipeline_fn_15_: typeof rx_pipeline_fn_15_;
+    readonly rx_pipeline_fn_16_: typeof rx_pipeline_fn_16_;
+    readonly rx_pipeline_fn_17_: typeof rx_pipeline_fn_17_;
+    readonly rx_pipeline_fn_18_: typeof rx_pipeline_fn_18_;
+    readonly rx_pipeline_fn_19_: typeof rx_pipeline_fn_19_;
+    readonly rx_pipeline_fn_20_: typeof rx_pipeline_fn_20_;
+};
+export declare function blockFlaggedFunctionKey(): keyof typeof FLAGGED_FUNCTIONS;
+export declare function releaseFlaggedFunctionKey(key: keyof typeof FLAGGED_FUNCTIONS): void;
+export {};

package/dist/types/plugins/pipeline/index.d.ts

@@ -0,0 +1,5 @@
+import type { RxPlugin } from '../../types/index.d.ts';
+export type * from './types.ts';
+export * from './flagged-functions.ts';
+export * from './rx-pipeline.ts';
+export declare const RxDBPipelinePlugin: RxPlugin;

package/dist/types/plugins/pipeline/rx-pipeline.d.ts

@@ -0,0 +1,37 @@
+import { BehaviorSubject, Subject, Subscription } from 'rxjs';
+import type { InternalStoreDocType, RxCollection, RxDocumentData } from '../../types';
+import type { CheckpointDocData, RxPipelineHandler, RxPipelineOptions } from './types';
+export declare class RxPipeline<RxDocType> {
+    readonly identifier: string;
+    readonly source: RxCollection<RxDocType>;
+    readonly destination: RxCollection<any>;
+    readonly handler: RxPipelineHandler<RxDocType>;
+    readonly batchSize: number;
+    processQueue: Promise<void>;
+    subs: Subscription[];
+    stopped: boolean;
+    toRun: number;
+    checkpointId: string;
+    lastSourceDocTime: BehaviorSubject<number>;
+    lastProcessedDocTime: BehaviorSubject<number>;
+    somethingChanged: Subject<unknown>;
+    secretFunctionName: string;
+    waitBeforeWriteFn: () => Promise<void>;
+    /**
+     * The handler of the pipeline must never throw.
+     * If it did anyway, the pipeline will be stuck and always
+     * throw the previous error on all operations.
+     */
+    error: any;
+    constructor(identifier: string, source: RxCollection<RxDocType>, destination: RxCollection<any>, handler: RxPipelineHandler<RxDocType>, batchSize?: number);
+    trigger(): void;
+    awaitIdle(): Promise<void>;
+    close(): Promise<void>;
+    /**
+     * Remove the pipeline and all metadata which it has stored
+     */
+    remove(): Promise<void>;
+}
+export declare function getCheckpointDoc<RxDocType>(pipeline: RxPipeline<RxDocType>): Promise<RxDocumentData<InternalStoreDocType<CheckpointDocData>> | undefined>;
+export declare function setCheckpointDoc<RxDocType>(pipeline: RxPipeline<RxDocType>, newCheckpoint: CheckpointDocData, previous?: RxDocumentData<InternalStoreDocType>): Promise<void>;
+export declare function addPipeline<RxDocType>(this: RxCollection<RxDocType>, options: RxPipelineOptions<RxDocType>): Promise<RxPipeline<RxDocType>>;

package/dist/types/plugins/pipeline/types.d.ts

@@ -0,0 +1,17 @@
+import type { MaybePromise, RxCollection, RxDocument } from '../../types';
+export type RxPipelineHandler<RxDocType> = (docs: RxDocument<RxDocType>[]) => MaybePromise<any>;
+export type RxPipelineOptions<RxDocType> = {
+    /**
+     * The identifier of the pipeline. Used when
+     * metadata of the pipeline is stored. Changing the identifier.
+     */
+    identifier: string;
+    destination: RxCollection<any>;
+    handler: RxPipelineHandler<RxDocType>;
+    waitForLeadership?: boolean;
+    batchSize?: number;
+};
+export type CheckpointDocData<CheckpointType = any> = {
+    checkpoint: CheckpointType;
+    lastDocTime: number;
+};

package/dist/types/plugins/query-builder/index.d.ts

@@ -0,0 +1,5 @@
+import type { RxPlugin, RxQuery } from '../../types/index.d.ts';
+export declare function runBuildingStep<RxDocumentType, RxQueryResult>(rxQuery: RxQuery<RxDocumentType, RxQueryResult>, functionName: string, value: any): RxQuery<RxDocumentType, RxQueryResult>;
+export declare function applyBuildingStep(proto: any, functionName: string): void;
+export * from './mquery/nosql-query-builder.ts';
+export declare const RxDBQueryBuilderPlugin: RxPlugin;

package/dist/types/plugins/query-builder/mquery/mquery-utils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * this is copied from
+ * @link https://github.com/aheckmann/mquery/blob/master/lib/utils.js
+ */
+/**
+ * Merges 'from' into 'to' without overwriting existing properties.
+ */
+export declare function merge(to: any, from: any): any;
+/**
+ * Determines if `arg` is an object.
+ */
+export declare function isObject(arg: Object | any[] | String | Function | RegExp | any): boolean;