@connecttomahdi/rxdb 17.0.0-beta.17

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

@@ -0,0 +1,274 @@
+import { Observable } from 'rxjs';
+import type { RxDocument, RxCollection, RxDocumentData, RxDocumentWriteData, UpdateQuery, CRDTEntry, ModifyFunction } from './types/index.d.ts';
+export declare const basePrototype: {
+    readonly primaryPath: import("./index.ts").StringKeys<{
+        _deleted: boolean;
+        _attachments: {
+            [attachmentId: string]: import("./index.ts").RxAttachmentData;
+        };
+        _rev: string;
+        _meta: import("./index.ts").RxDocumentMeta;
+    }> | undefined;
+    readonly primary: any;
+    readonly revision: string | undefined;
+    readonly deleted$: any;
+    readonly deleted$$: unknown;
+    readonly deleted: boolean | undefined;
+    getLatest(this: RxDocument): RxDocument;
+    /**
+     * returns the observable which emits the plain-data of this document
+     */
+    readonly $: Observable<RxDocumentData<any>>;
+    readonly $$: any;
+    /**
+     * returns observable of the value of the given path
+     */
+    get$(this: RxDocument, path: string): Observable<any>;
+    get$$(this: RxDocument, path: string): unknown;
+    /**
+     * populate the given path
+     */
+    populate(this: RxDocument, path: string): Promise<RxDocument | null>;
+    /**
+     * get data by objectPath
+     * @hotPath Performance here is really important,
+     * run some tests before changing anything.
+     */
+    get(this: RxDocument, objPath: string): any | null;
+    toJSON(this: RxDocument, withMetaFields?: boolean): import("./index.ts").DeepReadonlyObject<{
+        _deleted: boolean;
+        _attachments: {
+            [attachmentId: string]: import("./index.ts").RxAttachmentData;
+        };
+        _rev: string;
+        _meta: import("./index.ts").RxDocumentMeta;
+    }>;
+    toMutableJSON(this: RxDocument, withMetaFields?: boolean): {
+        _deleted: boolean;
+        _attachments: {
+            [attachmentId: string]: import("./index.ts").RxAttachmentData;
+        };
+        _rev: string;
+        _meta: import("./index.ts").RxDocumentMeta;
+    };
+    /**
+     * updates document
+     * @overwritten by plugin (optional)
+     * @param updateObj mongodb-like syntax
+     */
+    update(_updateObj: UpdateQuery<any>): never;
+    incrementalUpdate(_updateObj: UpdateQuery<any>): never;
+    updateCRDT(_updateObj: CRDTEntry<any> | CRDTEntry<any>[]): never;
+    putAttachment(): never;
+    putAttachmentBase64(): never;
+    getAttachment(): never;
+    allAttachments(): never;
+    readonly allAttachments$: void;
+    modify<RxDocType>(this: RxDocument<RxDocType>, mutationFunction: ModifyFunction<RxDocType>, _context?: string): Promise<RxDocument>;
+    /**
+     * runs an incremental update over the document
+     * @param function that takes the document-data and returns a new data-object
+     */
+    incrementalModify(this: RxDocument, mutationFunction: ModifyFunction<any>, _context?: string): Promise<RxDocument>;
+    patch<RxDocType>(this: RxDocument<RxDocType>, patch: Partial<RxDocType>): Promise<RxDocument<RxDocType, {}, unknown>>;
+    /**
+     * patches the given properties
+     */
+    incrementalPatch<RxDocumentType = any>(this: RxDocument<RxDocumentType>, patch: Partial<RxDocumentType>): Promise<RxDocument<RxDocumentType>>;
+    /**
+     * saves the new document-data
+     * and handles the events
+     */
+    _saveData<RxDocType>(this: RxDocument<RxDocType>, newData: RxDocumentWriteData<RxDocType>, oldData: RxDocumentData<RxDocType>): Promise<RxDocument<RxDocType>>;
+    /**
+     * Remove the document.
+     * Notice that there is no hard delete,
+     * instead deleted documents get flagged with _deleted=true.
+     */
+    remove(this: RxDocument): Promise<RxDocument>;
+    incrementalRemove(this: RxDocument): Promise<RxDocument>;
+    close(): never;
+};
+export declare function createRxDocumentConstructor(proto?: {
+    readonly primaryPath: import("./index.ts").StringKeys<{
+        _deleted: boolean;
+        _attachments: {
+            [attachmentId: string]: import("./index.ts").RxAttachmentData;
+        };
+        _rev: string;
+        _meta: import("./index.ts").RxDocumentMeta;
+    }> | undefined;
+    readonly primary: any;
+    readonly revision: string | undefined;
+    readonly deleted$: any;
+    readonly deleted$$: unknown;
+    readonly deleted: boolean | undefined;
+    getLatest(this: RxDocument): RxDocument;
+    /**
+     * returns the observable which emits the plain-data of this document
+     */
+    readonly $: Observable<RxDocumentData<any>>;
+    readonly $$: any;
+    /**
+     * returns observable of the value of the given path
+     */
+    get$(this: RxDocument, path: string): Observable<any>;
+    get$$(this: RxDocument, path: string): unknown;
+    /**
+     * populate the given path
+     */
+    populate(this: RxDocument, path: string): Promise<RxDocument | null>;
+    /**
+     * get data by objectPath
+     * @hotPath Performance here is really important,
+     * run some tests before changing anything.
+     */
+    get(this: RxDocument, objPath: string): any | null;
+    toJSON(this: RxDocument, withMetaFields?: boolean): import("./index.ts").DeepReadonlyObject<{
+        _deleted: boolean;
+        _attachments: {
+            [attachmentId: string]: import("./index.ts").RxAttachmentData;
+        };
+        _rev: string;
+        _meta: import("./index.ts").RxDocumentMeta;
+    }>;
+    toMutableJSON(this: RxDocument, withMetaFields?: boolean): {
+        _deleted: boolean;
+        _attachments: {
+            [attachmentId: string]: import("./index.ts").RxAttachmentData;
+        };
+        _rev: string;
+        _meta: import("./index.ts").RxDocumentMeta;
+    };
+    /**
+     * updates document
+     * @overwritten by plugin (optional)
+     * @param updateObj mongodb-like syntax
+     */
+    update(_updateObj: UpdateQuery<any>): never;
+    incrementalUpdate(_updateObj: UpdateQuery<any>): never;
+    updateCRDT(_updateObj: CRDTEntry<any> | CRDTEntry<any>[]): never;
+    putAttachment(): never;
+    putAttachmentBase64(): never;
+    getAttachment(): never;
+    allAttachments(): never;
+    readonly allAttachments$: void;
+    modify<RxDocType>(this: RxDocument<RxDocType>, mutationFunction: ModifyFunction<RxDocType>, _context?: string): Promise<RxDocument>;
+    /**
+     * runs an incremental update over the document
+     * @param function that takes the document-data and returns a new data-object
+     */
+    incrementalModify(this: RxDocument, mutationFunction: ModifyFunction<any>, _context?: string): Promise<RxDocument>;
+    patch<RxDocType>(this: RxDocument<RxDocType>, patch: Partial<RxDocType>): Promise<RxDocument<RxDocType, {}, unknown>>;
+    /**
+     * patches the given properties
+     */
+    incrementalPatch<RxDocumentType = any>(this: RxDocument<RxDocumentType>, patch: Partial<RxDocumentType>): Promise<RxDocument<RxDocumentType>>;
+    /**
+     * saves the new document-data
+     * and handles the events
+     */
+    _saveData<RxDocType>(this: RxDocument<RxDocType>, newData: RxDocumentWriteData<RxDocType>, oldData: RxDocumentData<RxDocType>): Promise<RxDocument<RxDocType>>;
+    /**
+     * Remove the document.
+     * Notice that there is no hard delete,
+     * instead deleted documents get flagged with _deleted=true.
+     */
+    remove(this: RxDocument): Promise<RxDocument>;
+    incrementalRemove(this: RxDocument): Promise<RxDocument>;
+    close(): never;
+}): {
+    (this: RxDocument, collection: RxCollection, docData: RxDocumentData<any>): void;
+    prototype: {
+        readonly primaryPath: import("./index.ts").StringKeys<{
+            _deleted: boolean;
+            _attachments: {
+                [attachmentId: string]: import("./index.ts").RxAttachmentData;
+            };
+            _rev: string;
+            _meta: import("./index.ts").RxDocumentMeta;
+        }> | undefined;
+        readonly primary: any;
+        readonly revision: string | undefined;
+        readonly deleted$: any;
+        readonly deleted$$: unknown;
+        readonly deleted: boolean | undefined;
+        getLatest(this: RxDocument): RxDocument;
+        /**
+         * returns the observable which emits the plain-data of this document
+         */
+        readonly $: Observable<RxDocumentData<any>>;
+        readonly $$: any;
+        /**
+         * returns observable of the value of the given path
+         */
+        get$(this: RxDocument, path: string): Observable<any>;
+        get$$(this: RxDocument, path: string): unknown;
+        /**
+         * populate the given path
+         */
+        populate(this: RxDocument, path: string): Promise<RxDocument | null>;
+        /**
+         * get data by objectPath
+         * @hotPath Performance here is really important,
+         * run some tests before changing anything.
+         */
+        get(this: RxDocument, objPath: string): any | null;
+        toJSON(this: RxDocument, withMetaFields?: boolean): import("./index.ts").DeepReadonlyObject<{
+            _deleted: boolean;
+            _attachments: {
+                [attachmentId: string]: import("./index.ts").RxAttachmentData;
+            };
+            _rev: string;
+            _meta: import("./index.ts").RxDocumentMeta;
+        }>;
+        toMutableJSON(this: RxDocument, withMetaFields?: boolean): {
+            _deleted: boolean;
+            _attachments: {
+                [attachmentId: string]: import("./index.ts").RxAttachmentData;
+            };
+            _rev: string;
+            _meta: import("./index.ts").RxDocumentMeta;
+        };
+        /**
+         * updates document
+         * @overwritten by plugin (optional)
+         * @param updateObj mongodb-like syntax
+         */
+        update(_updateObj: UpdateQuery<any>): never;
+        incrementalUpdate(_updateObj: UpdateQuery<any>): never;
+        updateCRDT(_updateObj: CRDTEntry<any> | CRDTEntry<any>[]): never;
+        putAttachment(): never;
+        putAttachmentBase64(): never;
+        getAttachment(): never;
+        allAttachments(): never;
+        readonly allAttachments$: void;
+        modify<RxDocType>(this: RxDocument<RxDocType>, mutationFunction: ModifyFunction<RxDocType>, _context?: string): Promise<RxDocument>;
+        /**
+         * runs an incremental update over the document
+         * @param function that takes the document-data and returns a new data-object
+         */
+        incrementalModify(this: RxDocument, mutationFunction: ModifyFunction<any>, _context?: string): Promise<RxDocument>;
+        patch<RxDocType>(this: RxDocument<RxDocType>, patch: Partial<RxDocType>): Promise<RxDocument<RxDocType, {}, unknown>>;
+        /**
+         * patches the given properties
+         */
+        incrementalPatch<RxDocumentType = any>(this: RxDocument<RxDocumentType>, patch: Partial<RxDocumentType>): Promise<RxDocument<RxDocumentType>>;
+        /**
+         * saves the new document-data
+         * and handles the events
+         */
+        _saveData<RxDocType>(this: RxDocument<RxDocType>, newData: RxDocumentWriteData<RxDocType>, oldData: RxDocumentData<RxDocType>): Promise<RxDocument<RxDocType>>;
+        /**
+         * Remove the document.
+         * Notice that there is no hard delete,
+         * instead deleted documents get flagged with _deleted=true.
+         */
+        remove(this: RxDocument): Promise<RxDocument>;
+        incrementalRemove(this: RxDocument): Promise<RxDocument>;
+        close(): never;
+    };
+};
+export declare function createWithConstructor<RxDocType>(constructor: any, collection: RxCollection<RxDocType>, jsonData: RxDocumentData<RxDocType>): RxDocument<RxDocType> | null;
+export declare function isRxDocument(obj: any): boolean;
+export declare function beforeDocumentUpdateWrite<RxDocType>(collection: RxCollection<RxDocType>, newData: RxDocumentWriteData<RxDocType>, oldData: RxDocumentData<RxDocType>): Promise<any>;

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

@@ -0,0 +1,37 @@
+/**
+ * here we use custom errors with the additional field 'parameters'
+ */
+import type { RxErrorParameters, RxErrorKey, RxStorageWriteError, RxStorageWriteErrorConflict } from './types/index.d.ts';
+export declare class RxError extends Error {
+    code: RxErrorKey;
+    message: string;
+    url: string;
+    parameters: RxErrorParameters;
+    rxdb: true;
+    constructor(code: RxErrorKey, message: string, parameters?: RxErrorParameters);
+    get name(): string;
+    toString(): string;
+    get typeError(): boolean;
+}
+export declare class RxTypeError extends TypeError {
+    code: RxErrorKey;
+    message: string;
+    url: string;
+    parameters: RxErrorParameters;
+    rxdb: true;
+    constructor(code: RxErrorKey, message: string, parameters?: RxErrorParameters);
+    get name(): string;
+    toString(): string;
+    get typeError(): boolean;
+}
+export declare function getErrorUrl(code: RxErrorKey): string;
+export declare function errorUrlHint(code: RxErrorKey): string;
+export declare function newRxError(code: RxErrorKey, parameters?: RxErrorParameters): RxError;
+export declare function newRxTypeError(code: RxErrorKey, parameters?: RxErrorParameters): RxTypeError;
+/**
+ * Returns the error if it is a 409 conflict,
+ * return false if it is another error.
+ */
+export declare function isBulkWriteConflictError<RxDocType>(err?: RxStorageWriteError<RxDocType> | any): RxStorageWriteErrorConflict<RxDocType> | false;
+export declare function rxStorageWriteErrorToRxError(err: RxStorageWriteError<any>): RxError;
+export declare function newRxFetchError(input: Response, additionalParameters?: RxErrorParameters): Promise<RxError>;

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

@@ -0,0 +1,31 @@
+import type { DeterministicSortComparator, FilledMangoQuery, MangoQuery, PreparedQuery, QueryMatcher, RxDocument, RxDocumentData, RxJsonSchema, RxQuery } from './types/index.d.ts';
+/**
+ * Normalize the query to ensure we have all fields set
+ * and queries that represent the same query logic are detected as equal by the caching.
+ */
+export declare function normalizeMangoQuery<RxDocType>(schema: RxJsonSchema<RxDocumentData<RxDocType>>, mangoQuery: MangoQuery<RxDocType>, 
+/**
+ * @performance
+ * Count queries do not need sort order.
+ * Skipping the sort computation avoids iterating over schema indexes
+ * and comparing fields, which improves count query performance.
+ */
+skipSort?: boolean): FilledMangoQuery<RxDocType>;
+/**
+ * Returns the sort-comparator,
+ * which is able to sort documents in the same way
+ * a query over the db would do.
+ */
+export declare function getSortComparator<RxDocType>(schema: RxJsonSchema<RxDocumentData<RxDocType>>, query: FilledMangoQuery<RxDocType>): DeterministicSortComparator<RxDocType>;
+/**
+ * Returns a function
+ * that can be used to check if a document
+ * matches the query.
+ */
+export declare function getQueryMatcher<RxDocType>(_schema: RxJsonSchema<RxDocType> | RxJsonSchema<RxDocumentData<RxDocType>>, query: FilledMangoQuery<RxDocType>): QueryMatcher<RxDocumentData<RxDocType>>;
+export declare function runQueryUpdateFunction<RxDocType, RxQueryResult>(rxQuery: RxQuery<RxDocType, RxQueryResult>, fn: (doc: RxDocument<RxDocType>) => Promise<RxDocument<RxDocType>>): Promise<RxQueryResult>;
+/**
+ * @returns a format of the query that can be used with the storage
+ * when calling RxStorageInstance().query()
+ */
+export declare function prepareQuery<RxDocType>(schema: RxJsonSchema<RxDocumentData<RxDocType>>, mutateableQuery: FilledMangoQuery<RxDocType>): PreparedQuery<RxDocType>;

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

@@ -0,0 +1,10 @@
+import { Query } from 'mingo/query';
+import type { MangoQuerySelector } from './types/index.d.ts';
+/**
+ * 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 declare function getMingoQuery<RxDocType>(selector?: MangoQuerySelector<RxDocType>): Query<import("mingo/types").AnyObject>;

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

@@ -0,0 +1,31 @@
+import { RxQueryBase } from './rx-query.ts';
+import type { RxDocument, RxDocumentData } from './types';
+/**
+ * RxDB needs the query results in multiple formats.
+ * Sometimes as a Map or an array with only the documentData.
+ * For better performance we work with this class
+ * that initializes stuff lazily so that
+ * we can directly work with the query results after RxQuery.exec()
+ */
+export declare class RxQuerySingleResult<RxDocType> {
+    readonly query: RxQueryBase<RxDocType, unknown>;
+    readonly count: number;
+    /**
+     * Time at which the current _result state was created.
+     * Used to determine if the result set has changed since X
+     * so that we do not emit the same result multiple times on subscription.
+     */
+    readonly time: number;
+    readonly documents: RxDocument<RxDocType>[];
+    constructor(query: RxQueryBase<RxDocType, unknown>, docsDataFromStorageInstance: RxDocumentData<RxDocType>[], count: number);
+    /**
+     * Instead of using the newResultData in the result cache,
+     * we directly use the objects that are stored in the RxDocument
+     * to ensure we do not store the same data twice and fill up the memory.
+     * @overwrites itself with the actual value
+     */
+    get docsData(): RxDocumentData<RxDocType>[];
+    get docsDataMap(): Map<string, RxDocumentData<RxDocType>>;
+    get docsMap(): Map<string, RxDocument<RxDocType>>;
+    getValue(throwIfMissing?: boolean): number | RxDocument<RxDocType> | RxDocument<RxDocType>[] | Map<string, RxDocument<RxDocType>> | null;
+}

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

@@ -0,0 +1,153 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import type { RxCollection, RxDocument, RxQueryOP, RxQuery, MangoQuery, MangoQuerySortPart, MangoQuerySelector, PreparedQuery, FilledMangoQuery, RxDocumentWriteData, RxDocumentData, QueryMatcher, ModifyFunction, Reactified } from './types/index.d.ts';
+import { RxQuerySingleResult } from './rx-query-single-result.ts';
+export declare class RxQueryBase<RxDocType, RxQueryResult, OrmMethods = {}, Reactivity = unknown> {
+    op: RxQueryOP;
+    mangoQuery: Readonly<MangoQuery<RxDocType>>;
+    collection: RxCollection<RxDocType>;
+    other: any;
+    id: number;
+    /**
+     * Some stats then are used for debugging and cache replacement policies
+     */
+    _execOverDatabaseCount: number;
+    /**
+     * @performance
+     * Use Date.now() instead of now() for creation time.
+     * The monotonic uniqueness guarantee of now() is not needed here
+     * since _creationTime is only used by the cache replacement policy
+     * for rough lifetime comparisons.
+     */
+    _creationTime: number;
+    _lastEnsureEqual: number;
+    uncached: boolean;
+    refCount$: BehaviorSubject<null>;
+    isFindOneByIdQuery: false | string | string[];
+    /**
+     * Contains the current result state
+     * or null if query has not run yet.
+     */
+    _result: RxQuerySingleResult<RxDocType> | null;
+    constructor(op: RxQueryOP, mangoQuery: Readonly<MangoQuery<RxDocType>>, collection: RxCollection<RxDocType>, other?: any);
+    get $(): Observable<RxQueryResult>;
+    get $$(): Reactified<Reactivity, RxQueryResult>;
+    _latestChangeEvent: -1 | number;
+    /**
+     * ensures that the exec-runs
+     * are not run in parallel
+     */
+    _ensureEqualQueue: Promise<boolean>;
+    /**
+     * Returns an observable that emits the results
+     * This should behave like an rxjs-BehaviorSubject which means:
+     * - Emit the current result-set on subscribe
+     * - Emit the new result-set when an RxChangeEvent comes in
+     * - Do not emit anything before the first result-set was created (no null)
+     */
+    _$?: Observable<RxQueryResult>;
+    /**
+     * set the new result-data as result-docs of the query
+     * @param newResultData json-docs that were received from the storage
+     */
+    _setResultData(newResultData: RxDocumentData<RxDocType>[] | number | Map<string, RxDocumentData<RxDocType>>): void;
+    /**
+     * executes the query on the database
+     * @return results-array with document-data
+     */
+    _execOverDatabase(rerunCount?: number): Promise<{
+        result: RxDocumentData<RxDocType>[] | number;
+        counter: number;
+    }>;
+    /**
+     * Execute the query
+     * To have an easier implementations,
+     * just subscribe and use the first result
+     */
+    exec(throwIfMissing: true): Promise<RxDocument<RxDocType, OrmMethods, Reactivity>>;
+    exec(): Promise<RxQueryResult>;
+    /**
+     * Returns the normalized query.
+     * Caches the result so that multiple calls to
+     * queryMatcher, toString() and getPreparedQuery()
+     * do not have to run the normalization again.
+     * @overwrites itself with the actual value.
+     */
+    get normalizedQuery(): FilledMangoQuery<RxDocType>;
+    /**
+     * cached call to get the queryMatcher
+     * @overwrites itself with the actual value
+     */
+    get queryMatcher(): QueryMatcher<RxDocumentWriteData<RxDocType>>;
+    /**
+     * returns a string that is used for equal-comparisons
+     * @overwrites itself with the actual value
+     */
+    toString(): string;
+    /**
+     * returns the prepared query
+     * which can be sent to the storage instance to query for documents.
+     * @overwrites itself with the actual value.
+     */
+    getPreparedQuery(): PreparedQuery<RxDocType>;
+    /**
+     * returns true if the document matches the query,
+     * does not use the 'skip' and 'limit'
+     */
+    doesDocumentDataMatch(docData: RxDocType | any): boolean;
+    /**
+     * deletes all found documents
+     * @return promise with deleted documents
+     */
+    remove(): Promise<RxQueryResult>;
+    incrementalRemove(): Promise<RxQueryResult>;
+    /**
+     * helper function to transform RxQueryBase to RxQuery type
+     */
+    get asRxQuery(): RxQuery<RxDocType, RxQueryResult>;
+    /**
+     * updates all found documents
+     * @overwritten by plugin (optional)
+     */
+    update(_updateObj: any): Promise<RxQueryResult>;
+    patch(patch: Partial<RxDocType>): Promise<RxQueryResult>;
+    incrementalPatch(patch: Partial<RxDocType>): Promise<RxQueryResult>;
+    modify(mutationFunction: ModifyFunction<RxDocType>): Promise<RxQueryResult>;
+    incrementalModify(mutationFunction: ModifyFunction<RxDocType>): Promise<RxQueryResult>;
+    where(_queryObj: MangoQuerySelector<RxDocType> | keyof RxDocType | string): RxQuery<RxDocType, RxQueryResult>;
+    sort(_params: string | MangoQuerySortPart<RxDocType>): RxQuery<RxDocType, RxQueryResult>;
+    skip(_amount: number | null): RxQuery<RxDocType, RxQueryResult>;
+    limit(_amount: number | null): RxQuery<RxDocType, RxQueryResult>;
+}
+export declare function _getDefaultQuery<RxDocType>(): MangoQuery<RxDocType>;
+/**
+ * run this query through the QueryCache
+ */
+export declare function tunnelQueryCache<RxDocumentType, RxQueryResult>(rxQuery: RxQueryBase<RxDocumentType, RxQueryResult>): RxQuery<RxDocumentType, RxQueryResult>;
+export declare function createRxQuery<RxDocType>(op: RxQueryOP, queryObj: MangoQuery<RxDocType>, collection: RxCollection<RxDocType>, other?: any): RxQueryBase<RxDocType, any, {}, unknown>;
+/**
+ * Runs the query over the storage instance
+ * of the collection.
+ * Does some optimizations to ensure findById is used
+ * when specific queries are used.
+ */
+export declare function queryCollection<RxDocType>(rxQuery: RxQuery<RxDocType> | RxQueryBase<RxDocType, any>): Promise<{
+    docs: RxDocumentData<RxDocType>[];
+    /**
+     * We need to remember the counter directly here
+     * because getting if after the returned Promise is resolved,
+     * can result in a value that no longer matches the result set.
+     */
+    counter: number;
+}>;
+/**
+ * Returns true if the given query
+ * selects documents by primary key using $eq or $in.
+ * Used to optimize performance: these queries use get-by-id
+ * instead of a full index scan. Additional operators beyond
+ * $eq/$in are handled via the queryMatcher after fetching.
+ * Skip, limit, and sort are also applied after fetching.
+ * Returns false if no such optimization is possible.
+ * Returns the document id (string) or ids (string[]) otherwise.
+ */
+export declare function isFindOneByIdQuery(primaryPath: string, query: MangoQuery<any>): false | string | string[];
+export declare function isRxQuery(obj: any): boolean;

package/dist/types/rx-schema-helper.d.ts

@@ -0,0 +1,57 @@
+import type { DeepReadonly, JsonSchema, PrimaryKey, RxDocumentData, RxJsonSchema, RxStorageDefaultCheckpoint, StringKeys } from './types/index.d.ts';
+import type { RxSchema } from './rx-schema.ts';
+/**
+ * Helper function to create a valid RxJsonSchema
+ * with a given version.
+ */
+export declare function getPseudoSchemaForVersion<T = any>(version: number, primaryKey: StringKeys<T>): RxJsonSchema<RxDocumentData<T>>;
+/**
+ * Returns the sub-schema for a given path.
+ * Results are cached per schema reference and path
+ * to avoid redundant string operations and property lookups.
+ */
+export declare function getSchemaByObjectPath<T = any>(rxJsonSchema: RxJsonSchema<T>, path: keyof T | string): JsonSchema;
+export declare function fillPrimaryKey<T>(primaryPath: keyof T, jsonSchema: RxJsonSchema<T>, documentData: RxDocumentData<T>): RxDocumentData<T>;
+export declare function getPrimaryFieldOfPrimaryKey<RxDocType>(primaryKey: PrimaryKey<RxDocType>): StringKeys<RxDocType>;
+export declare function getLengthOfPrimaryKey<RxDocType>(schema: RxJsonSchema<RxDocumentData<RxDocType>>): number;
+/**
+ * Returns the composed primaryKey of a document by its data.
+ */
+export declare function getComposedPrimaryKeyOfDocumentData<RxDocType>(jsonSchema: RxJsonSchema<RxDocType> | RxJsonSchema<RxDocumentData<RxDocType>>, documentData: Partial<RxDocType>): string;
+/**
+ * Normalize the RxJsonSchema.
+ * We need this to ensure everything is set up properly
+ * and we have the same hash on schemas that represent the same value but
+ * have different json.
+ *
+ * - Orders the schemas attributes by alphabetical order
+ * - Adds the primaryKey to all indexes that do not contain the primaryKey
+ * - We need this for deterministic sort order on all queries, which is required for event-reduce to work.
+ *
+ * @return RxJsonSchema - ordered and filled
+ */
+export declare function normalizeRxJsonSchema<T>(jsonSchema: RxJsonSchema<T>): RxJsonSchema<T>;
+/**
+ * If the schema does not specify any index,
+ * we add this index so we at least can run RxQuery()
+ * and only select non-deleted fields.
+ */
+export declare function getDefaultIndex(primaryPath: string): string[];
+/**
+ * fills the schema-json with default-settings
+ * @return cloned schemaObj
+ */
+export declare function fillWithDefaultSettings<T = any>(schemaObj: RxJsonSchema<T>): RxJsonSchema<RxDocumentData<T>>;
+export declare const META_LWT_UNIX_TIME_MAX = 1000000000000000;
+export declare const RX_META_SCHEMA: JsonSchema;
+/**
+ * returns the final-fields of the schema
+ * @return field-names of the final-fields
+ */
+export declare function getFinalFields<T = any>(jsonSchema: RxJsonSchema<T>): string[];
+/**
+ * fills all unset fields with default-values if set
+ * @hotPath
+ */
+export declare function fillObjectWithDefaults(rxSchema: RxSchema<any>, obj: any): any;
+export declare const DEFAULT_CHECKPOINT_SCHEMA: DeepReadonly<JsonSchema<RxStorageDefaultCheckpoint>>;

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

@@ -0,0 +1,43 @@
+import type { DeepMutable, DeepReadonly, HashFunction, MaybeReadonly, RxDocumentData, RxJsonSchema, StringKeys } from './types/index.d.ts';
+export declare class RxSchema<RxDocType = any> {
+    readonly jsonSchema: RxJsonSchema<RxDocumentData<RxDocType>>;
+    readonly hashFunction: HashFunction;
+    indexes: MaybeReadonly<string[]>[];
+    readonly primaryPath: StringKeys<RxDocumentData<RxDocType>>;
+    finalFields: string[];
+    constructor(jsonSchema: RxJsonSchema<RxDocumentData<RxDocType>>, hashFunction: HashFunction);
+    get version(): number;
+    get defaultValues(): {
+        [P in keyof RxDocType]: RxDocType[P];
+    };
+    getJsonSchemaWithoutMeta(): RxJsonSchema<RxDocumentData<RxDocType>>;
+    /**
+     * @overrides itself on the first call
+     */
+    get hash(): Promise<string>;
+    /**
+     * checks if a given change on a document is allowed
+     * Ensures that:
+     * - final fields are not modified
+     * @throws {Error} if not valid
+     */
+    validateChange(dataBefore: any, dataAfter: any): void;
+    /**
+     * creates the schema-based document-prototype,
+     * see RxCollection.getDocumentPrototype()
+     */
+    getDocumentPrototype(): any;
+    getPrimaryOfDocumentData(documentData: Partial<RxDocType>): string;
+}
+export declare function getIndexes<RxDocType = any>(jsonSchema: RxJsonSchema<RxDocType>): MaybeReadonly<string[]>[];
+/**
+ * array with previous version-numbers
+ */
+export declare function getPreviousVersions(schema: RxJsonSchema<any>): number[];
+export declare function createRxSchema<T>(jsonSchema: RxJsonSchema<T>, hashFunction: HashFunction, runPreCreateHooks?: boolean): RxSchema<T>;
+export declare function isRxSchema(obj: any): boolean;
+/**
+ * Used as helper function the generate the document type out of the schema via typescript.
+ * @link https://github.com/pubkey/rxdb/discussions/3467
+ */
+export declare function toTypedRxJsonSchema<T extends DeepReadonly<RxJsonSchema<any>>>(schema: T): DeepMutable<T>;