@squidcloud/client 1.0.84 → 1.0.86

package/dist/common/src/index.d.ts

@@ -26,7 +26,6 @@ export * from './named-query.context';
 export * from './named-query.schemas';
 export * from './named-query.types';
 export * from './query';
-export * from './query.schemas';
 export * from './query.types';
 export * from './regions';
 export * from './schema/schema.types';

package/dist/common/src/query/base-query-builder.d.ts

@@ -18,6 +18,12 @@ export interface SnapshotEmitter<ReturnType> {
      * @returns An observable for the query results.
      */
     snapshots(subscribe?: boolean): Observable<Array<ReturnType>>;
+    limit(limit: number): SnapshotEmitter<ReturnType>;
+    /**
+     * Returns a pagination wrapper for this query.
+     * @param options The pagination options. Defaults to `{ subscribe: true, pageSize: 100 }`.
+     */
+    paginate(options?: Partial<PaginationOptions>): Pagination<ReturnType>;
 }
 /** Query builder base class. */
 export declare abstract class BaseQueryBuilder<MyDocType extends DocumentData> {
@@ -120,3 +126,61 @@ export declare abstract class BaseQueryBuilder<MyDocType extends DocumentData> {
      */
     abstract sortBy(fieldName: keyof MyDocType & FieldName, asc?: boolean): this;
 }
+export interface HasDereference {
+    /**
+     * Dereferences the document references in the result of this query. For example, collection.query().snapshot()
+     * returns an array of DocumentReference objects, but collection.query().dereference().snapshot() returns an array of
+     * the actual document data.
+     */
+    dereference(): any;
+}
+/** The state of a pagination. */
+export interface PaginationState<ReturnType> {
+    data: Array<ReturnType>;
+    hasNext: boolean;
+    hasPrev: boolean;
+    isLoading: boolean;
+}
+/** Pagination options */
+export interface PaginationOptions {
+    /** Whether to show real-time updates. Defaults to true. */
+    subscribe: boolean;
+    /** The number of items in a page. Defaults to 100. */
+    pageSize: number;
+}
+/** A query wrapper that provides pagination functionality. */
+export declare class Pagination<ReturnType> {
+    private readonly templateSnapshotEmitter;
+    /**
+     * The first page data - only available when subscribe is true.
+     * It is used for:
+     * 1 - Telling whether there is a previous page
+     * 2 - Used as the data when the current page has less than page size and hasNext = true
+     */
+    private readonly firstPageSnapshotEmitterWrapper;
+    private readonly firstPageDataAvailable;
+    /**
+     * The last page data - only available when subscribe is true. Lazily initialized when calling prev.
+     * It is used for telling whether there is a next result after calling prev.
+     */
+    private lastPageSnapshotEmitterWrapper;
+    private lastPageDataAvailable;
+    private readonly isDestroyed;
+    private readonly destroyedObs;
+    private readonly _observeState;
+    /** The current snapshot emitter wrapper. */
+    private readonly currentPageSnapshotEmitterWrapperSubject;
+    private readonly options;
+    /** Requests the next page. */
+    next(): Promise<PaginationState<ReturnType>>;
+    /** Requests the previous page. */
+    prev(): Promise<PaginationState<ReturnType>>;
+    /** Unsubscribe from the pagination object and from the query. */
+    unsubscribe(): void;
+    /** The current pagination state and data. */
+    observeState(): Observable<PaginationState<ReturnType>>;
+    /** Wait for the data to be available (the isLoading flag to be false). */
+    waitForData(): Promise<PaginationState<ReturnType>>;
+    private createLastPageSnapshotEmitterWrapper;
+    private resetToFirstPageData;
+}

package/dist/common/src/query/query-context.d.ts

@@ -1,8 +1,8 @@
 import { IntegrationId } from '../communication.types';
-import { CollectionName, DocumentData, FieldName } from '../document.types';
-import { AllOperators, ContextConditions, FieldSort, GeneralCondition, GeneralConditions, GenericValue, Query } from '../query.types';
-import { PartialBy, Paths } from '../types';
-export declare class QueryContext<T = any> {
+import { CollectionName, DocumentData } from '../document.types';
+import { FieldSort, Operator, Query, SimpleCondition } from '../query.types';
+import { DeepRecord, FieldOf, PartialBy, Paths } from '../types';
+export declare class QueryContext<T extends DocumentData = any> {
     readonly query: Query<T>;
     private readonly parsedConditions;
     /**
@@ -45,7 +45,7 @@ export declare class QueryContext<T = any> {
      * @param value The value of the condition.
      * @returns Whether the query is a subquery of the parent condition.
      */
-    isSubqueryOf<F extends FieldName<T>, O extends AllOperators>(fieldName: F, operator: O, value: GenericValue<T, F, O> | null): boolean;
+    isSubqueryOf<F extends Paths<T>, O extends AllOperators>(fieldName: F, operator: O, value: GenericValue<T, F, O> | null): boolean;
     /**
      * Verifies that the query is a subquery of the specified condition. A subquery is defined as a query that evaluates
      * to a subset of the results that would be obtained by applying the parent condition. The subquery may also include
@@ -79,7 +79,7 @@ export declare class QueryContext<T = any> {
      * @param fieldNames The field names for which to retrieve conditions.
      * @returns An array of conditions that involve any of the specified field names.
      */
-    getConditionsFor<K extends FieldName<T>>(...fieldNames: K[]): ContextConditions<T, K>;
+    getConditionsFor<K extends Paths<T>>(...fieldNames: Array<K>): ContextConditions<T, K>;
     /**
      * Returns all conditions that apply to the specified field name. This method provides
      * a convenient way to retrieve all conditions that involve a specific field.
@@ -107,3 +107,31 @@ export declare class QueryContext<T = any> {
     private evaluateIncludes;
     private parseConditions;
 }
+/** A list of context conditions */
+type ContextConditions<Doc extends DocumentData = any, F extends Paths<Doc> = Paths<Doc>> = Array<ContextCondition<Doc, F>>;
+/** A Context condition - a condition that replaces multiple '==' or '!=' conditions with 'in' and 'not in'. */
+type ContextCondition<Doc extends DocumentData = any, F extends Paths<Doc> = Paths<Doc>> = InContextCondition<Doc, F> | NotInContextCondition<Doc, F> | OtherContextCondition<Doc, F>;
+interface InContextCondition<Doc extends DocumentData = any, F extends Paths<Doc> = Paths<Doc>> extends SimpleCondition<Doc, F, 'in'> {
+    operator: 'in';
+    value: Array<FieldOf<DeepRecord<Doc>, Paths<Doc>> | any>;
+}
+interface NotInContextCondition<Doc extends DocumentData = any, F extends Paths<Doc> = Paths<Doc>> extends SimpleCondition<Doc, F, 'not in'> {
+    operator: 'not in';
+    value: Array<FieldOf<DeepRecord<Doc>, Paths<Doc>> | any>;
+}
+interface OtherContextCondition<Doc extends DocumentData = any, F extends Paths<Doc> = Paths<Doc>> extends SimpleCondition<Doc, F, Exclude<ContextOperator, 'in' | 'not in'>> {
+    operator: Exclude<ContextOperator, 'in' | 'not in'>;
+    value: FieldOf<DeepRecord<Doc>, Paths<Doc>> | any;
+}
+/** A condition that includes the 'in' and 'not in' operators. */
+interface GeneralCondition<Doc extends DocumentData = any, F extends Paths<Doc> = Paths<Doc>> extends SimpleCondition<Doc, F, AllOperators> {
+    operator: AllOperators;
+    value: any;
+}
+/** A list of general conditions. */
+type GeneralConditions<Doc extends DocumentData = any, F extends Paths<Doc> = Paths<Doc>> = Array<GeneralCondition<Doc, F>>;
+type ContextOperator = Exclude<Operator, '==' | '!='> | 'in' | 'not in';
+type AllOperators = Operator | 'in' | 'not in';
+/** A generic value that can exist in a query. */
+type GenericValue<Doc = any, F extends Paths<Doc> = Paths<Doc>, O extends AllOperators = any> = O extends 'in' ? Array<DeepRecord<Doc>[F]> | null : O extends 'not in' ? Array<DeepRecord<Doc>[F]> | null : DeepRecord<Doc>[F] | null;
+export {};

package/dist/common/src/query.types.d.ts

@@ -1,48 +1,36 @@
 import { ClientRequestId } from './communication.types';
-import { CollectionName, FieldName } from './document.types';
+import { CollectionName, DocumentData, FieldName } from './document.types';
+import { Paths } from './types';
 /** A list of query conditions. */
-export type Conditions<Doc = any, F extends FieldName<Doc> = any> = Array<Condition<Doc, F>>;
-/** A single query condition. */
-export interface Condition<Doc = any, F extends FieldName<Doc> = any> {
+export type Condition<Doc extends DocumentData = any> = SimpleCondition<Doc> | CompositeCondition<Doc>;
+export type Conditions<Doc extends DocumentData = any> = Array<Condition<Doc>>;
+/** A single field query condition. */
+export interface SimpleCondition<Doc extends DocumentData = any, F extends Paths<Doc> = Paths<Doc>, MyOperator = Operator> {
     fieldName: F;
-    operator: Operator;
-    value: Doc[F] | null;
-}
-/** An operator in a query condition. */
-export type Operator = '==' | '>=' | '<=' | '>' | '<' | '!=' | 'like' | 'not like' | 'like_cs' | 'not like_cs';
-/** A list of context conditions */
-export type ContextConditions<Doc = any, F extends FieldName<Doc> = any> = Array<ContextCondition<Doc, F>>;
-/** A generic value that can exist in a query. */
-export type GenericValue<Doc = any, F extends FieldName<Doc> = any, O extends AllOperators = any> = O extends 'in' ? Array<Doc[F]> | null : O extends 'not in' ? Array<Doc[F]> | null : Doc[F] | null;
-/** A Context condition - a condition that replaces multiple '==' or '!=' conditions with 'in' and 'not in'. */
-export type ContextCondition<Doc = any, F extends FieldName<Doc> = any> = InContextCondition<Doc, F> | NotInContextCondition<Doc, F> | OtherContextCondition<Doc, F>;
-interface InContextCondition<Doc = any, F extends FieldName<Doc> = any> extends Omit<Condition<Doc, F>, 'operator' | 'value'> {
-    operator: 'in';
-    value: Array<Doc[F]>;
-}
-interface NotInContextCondition<Doc = any, F extends FieldName<Doc> = any> extends Omit<Condition<Doc, F>, 'operator' | 'value'> {
-    operator: 'not in';
-    value: Array<Doc[F]>;
-}
-export interface OtherContextCondition<Doc = any, F extends FieldName<Doc> = any> extends Omit<Condition<Doc, F>, 'operator'> {
-    operator: Exclude<ContextOperator, 'in' | 'not in'>;
-}
-/** A condition that includes the 'in' and 'not in' operators. */
-export interface GeneralCondition<Doc = any, F extends FieldName<Doc> = any> extends Omit<Condition<Doc, F>, 'operator' | 'value'> {
-    operator: AllOperators;
+    operator: MyOperator;
     value: any;
 }
-/** A list of general conditions. */
-export type GeneralConditions<Doc = any, F extends FieldName<Doc> = any> = Array<GeneralCondition<Doc, F>>;
-export type ContextOperator = Exclude<Operator, '==' | '!='> | 'in' | 'not in';
-export type AllOperators = Operator | 'in' | 'not in';
+/**
+ * A composite fields query condition.
+ * Just a list of simple conditions with specific set of operators. It should be
+ * evaluated this way:
+ * If A, B, C are the conditions and A` = A with '==' operator:
+ * A || (A' && B) || (A' && B' && C)
+ */
+export interface CompositeCondition<Doc extends DocumentData = any> {
+    fields: Array<SimpleCondition<Doc, Paths<Doc>, CompositeConditionOperator>>;
+}
+export declare function isSimpleCondition(condition: Condition): condition is SimpleCondition;
+type CompositeConditionOperator = '>=' | '<=' | '>' | '<';
+/** An operator in a query condition. */
+export type Operator = '==' | '!=' | CompositeConditionOperator | 'like' | 'not like' | 'like_cs' | 'not like_cs';
 /** A definition of a sort by a filed. */
 export interface FieldSort<Doc> {
     fieldName: FieldName<Doc>;
     asc: boolean;
 }
 /** A query object. */
-export interface Query<Doc = any> {
+export interface Query<Doc extends DocumentData = any> {
     collectionName: CollectionName;
     integrationId: string;
     conditions: Conditions<Doc>;

package/dist/common/src/types.d.ts

@@ -1,8 +1,14 @@
 export interface Type<T> extends Function {
     new (...args: any[]): T;
 }
+type PropertiesWithPrefix<Prefix extends string> = {
+    [key in `${Prefix}${string}`]: any;
+};
 type Pred = [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-export type Paths<T, RemainingDepth extends number & keyof Pred = 5, Prefix extends string = ''> = RemainingDepth extends 0 ? `${Prefix}${string}` : {
-    [k in keyof T]-?: k extends string | number ? `${Prefix}${k}` | (Required<T>[k] extends any[] ? never : Required<T>[k] extends object ? Paths<Required<T>[k], Pred[RemainingDepth], `${Prefix}${k}.`> : never) : never;
+export type DeepRecord<T, RemainingDepth extends number & keyof Pred = 5, Prefix extends string = ''> = RemainingDepth extends 0 ? PropertiesWithPrefix<Prefix> : {
+    [k in keyof T]-?: k extends string | number ? Record<`${Prefix}${k}`, T[k]> | (Required<T>[k] extends any[] ? never : Required<T>[k] extends object ? DeepRecord<Required<T>[k], Pred[RemainingDepth], `${Prefix}${k}.`> : never) : never;
 }[keyof T];
+export type UnionKeys<T> = T extends any ? keyof T : never;
+export type FieldOf<T, K extends UnionKeys<T>> = Extract<T, Record<K, any>>[K];
+export type Paths<T> = UnionKeys<DeepRecord<T>>;
 export {};