@squidcloud/client 1.0.79 → 1.0.81

package/dist/typescript-client/src/collection-reference.d.ts

@@ -1,7 +1,7 @@
 import { DocId, DocIdObj, DocumentData } from '@squidcloud/common';
 import { DocumentReference } from './document-reference';
 import { JoinQueryBuilder } from './query/join-query-builder.factory';
-import { QueryActions, QueryBuilder } from './query/query-builder.factory';
+import { QueryBuilder } from './query/query-builder.factory';
 import { Alias } from './query/query.types';
 /**
  *  Holds a reference to a data collection. a collection reference is a reference to a collection in a database. You
@@ -18,10 +18,9 @@ export declare class CollectionReference<T extends DocumentData> {
     private integrationId;
     private readonly documentReferenceFactory;
     private readonly queryBuilderFactory;
-    private readonly joinQueryBuilderFactory;
+    private readonly querySubscriptionManager;
     /** A string that uniquely identifies this collection reference. */
     refId: string;
-    private readonly documents;
     /**
      * Returns a document reference for the given document id.
      * The document id is an object that maps the primary keys of the collection (as defined in the Squid Cloud Console)
@@ -38,13 +37,15 @@ export declare class CollectionReference<T extends DocumentData> {
      * ```typescript
      * // For a collection in the built_in_db that does not have a schema
      * const docRef = collectionRef.doc('my-doc-id');
+     * const docRef = collectionRef.doc({id: my-doc-id'});
      *
      * // For a collection with a single primary key field called "id"
      * const docRef = collectionRef.doc({id: 'my-doc-id'});
      *
      * // For a collection with a composite primary key
      * const docRef = collectionRef.doc({id1: 'my-doc-id1', id2: 'my-doc-id2'});
-     * const docRef = collectionRef.doc({id1: 'my-doc-id1'}); // id2 will be generated on the server if the integration supports it
+     * const docRef = collectionRef.doc({id1: 'my-doc-id1'}); // id2 will be generated on the server if the integration
+     * supports it
      *
      * // For a collection from the `built_in_db` without a defined schema when an id is not provided
      *  const docRef = collectionRef.doc(); // The id will be generated on the server
@@ -68,14 +69,14 @@ export declare class CollectionReference<T extends DocumentData> {
      * @param alias The alias for the query.
      * @returns A `JoinQueryBuilder` that can be used to query the collection and joins with other queries.
      */
-    joinQuery<A extends Alias>(alias: A): JoinQueryBuilder<T, A, Record<A, DocumentReference<T>>>;
+    joinQuery<A extends Alias>(alias: A): JoinQueryBuilder<Record<A, []>, Record<A, T>, A, A>;
     /**
      * Performs `or` on a list of queries. All the queries need to be on the same collection.
      * The result will be a merge of all the queries sorted by the same sort condition of the first query.
      * Duplicate items will be removed.
      * @param builders The list of query builders to merge. (A query builder can be returned from the {@link query}
-     *   method.
+     *   method).
      * @returns A query builder that can be used to perform the `or` operation.
      */
-    or(...builders: QueryActions<T>[]): QueryActions<T>;
+    or(...builders: QueryBuilder<T>[]): MergedQueryBuilder<T>;
 }

package/dist/typescript-client/src/collection-reference.factory.d.ts

@@ -1,16 +1,13 @@
 import { CollectionName, DocumentData, IntegrationId } from '@squidcloud/common';
 import { CollectionReference } from './collection-reference';
-import DocumentIdentityService from './document-identity.service';
 import { DocumentReferenceFactory } from './document-reference.factory';
-import { JoinQueryBuilderFactory } from './query/join-query-builder.factory';
 import { QueryBuilderFactory } from './query/query-builder.factory';
+import { QuerySubscriptionManager } from './query/query-subscription.manager';
 export declare class CollectionReferenceFactory {
     private readonly documentReferenceFactory;
     private readonly queryBuilderFactory;
-    private readonly joinQueryBuilderFactory;
-    private readonly documentIdentityService;
+    private readonly querySubscriptionManager;
     private readonly collections;
-    constructor(documentReferenceFactory: DocumentReferenceFactory, queryBuilderFactory: QueryBuilderFactory, joinQueryBuilderFactory: JoinQueryBuilderFactory, documentIdentityService: DocumentIdentityService);
+    constructor(documentReferenceFactory: DocumentReferenceFactory, queryBuilderFactory: QueryBuilderFactory, querySubscriptionManager: QuerySubscriptionManager);
     get<T extends DocumentData>(collectionName: CollectionName, integrationId: IntegrationId): CollectionReference<T>;
-    private migrateDocIds;
 }

package/dist/typescript-client/src/data.manager.d.ts

@@ -5,8 +5,8 @@ import { DocumentStore } from './document-store';
 import { MutationSender } from './mutation/mutation-sender';
 import { QueryBuilderFactory } from './query/query-builder.factory';
 import { QuerySubscriptionManager } from './query/query-subscription.manager';
-import { TransactionId } from './types';
 import { SocketManager } from './socket.manager';
+import { TransactionId } from './types';
 export interface DocTimestampMetadata {
     timestamp: DocTimestamp;
     expireTimestamp?: number;

package/dist/typescript-client/src/document-reference.factory.d.ts

@@ -1,9 +1,12 @@
 import { SquidDocId } from '@squidcloud/common';
 import { DataManager } from './data.manager';
+import DocumentIdentityService from './document-identity.service';
 import { DocumentReference } from './document-reference';
 import { QueryBuilderFactory } from './query/query-builder.factory';
 export declare class DocumentReferenceFactory {
+    private readonly documentIdentityService;
     private dataManager;
+    constructor(documentIdentityService: DocumentIdentityService);
     create(squidDocId: SquidDocId, queryBuilderFactory: QueryBuilderFactory): DocumentReference;
     setDataManager(dataManager: DataManager): void;
 }

package/dist/typescript-client/src/query/join-query-builder.factory.d.ts

@@ -1,24 +1,49 @@
-import { BaseQueryBuilderInterface, DocumentData, FieldName, Operator, PrimitiveFieldType } from '@squidcloud/common';
+import { BaseQueryBuilder, DocumentData, FieldName, HasDereference, Operator, PrimitiveFieldType, SnapshotEmitter } from '@squidcloud/common';
 import { Observable } from 'rxjs';
 import { DocumentReference } from '../document-reference';
+import { QueryBuilder } from './query-builder.factory';
 import { Alias } from './query.types';
+type SimpleJoinQueryBuilder<Aliases extends Record<Alias, Alias[]>, ReturnType extends Record<Alias, DocumentData>, LatestAlias extends Alias, RootAlias extends Alias> = Pick<JoinQueryBuilder<Aliases, ReturnType, LatestAlias, RootAlias>, 'join' | 'snapshot' | 'snapshots' | 'grouped' | 'dereference'>;
+type WithDocumentReferences<T extends Record<any, DocumentData>> = {
+    [k in keyof T]: DocumentReference<Required<T>[k]>;
+};
+type Grouped<Aliases extends Record<Alias, Alias[]>, ReturnType extends Record<Alias, any>, RootAlias extends Alias> = Aliases[RootAlias] extends [] ? Required<ReturnType>[RootAlias] : Record<RootAlias, Required<ReturnType>[RootAlias]> & OtherGroups<Aliases, ReturnType, Aliases[RootAlias]>;
+type OtherGroups<Aliases extends Record<Alias, Alias[]>, ReturnType extends Record<Alias, any>, ManyRootAliases extends Alias[]> = ManyRootAliases extends [infer First extends Alias, ...infer Rest extends Alias[]] ? Record<First, Array<Grouped<Aliases, ReturnType, First>>> & OtherGroups<Aliases, ReturnType, Rest> : Record<Alias, never>;
+interface HasGrouped {
+    /**
+     * Transforms this join query result to a nested data structure. For example, a join between teachers and students
+     * normally returns a result of the form:
+     *   [
+     *     { teacher: {name: 'Mr. Smith'}, student: {name: 'John Doe'} },
+     *     { teacher: {name: 'Mr. Smith'}, student: {name: 'Jane Smith'} },
+     *     { teacher: {name: 'Mr. EmptyClass'}, student: undefined },
+     *   ]
+     * into a result of the form:
+     *   [
+     *    { teacher: {name: 'Mr. Smith'}, students: [
+     *      { name: 'John Doe' },
+     *      { name: 'Jane Smith' },
+     *    ]},
+     *    { teacher: {name: 'Mr. EmptyClass'}, students: [] },
+     *   ]
+     */
+    grouped(): any;
+}
 /**
  * A query builder that can participate in a join.
  * To learn more about join queries, see
  * {@link https://docs.squid.cloud/docs/client-sdk/queries#joining-data-across-collections-and-integrations}.
  */
-export declare class JoinQueryBuilder<DocumentType extends DocumentData, MyAlias extends Alias, ReturnType extends Record<MyAlias, DocumentReference<DocumentType> | undefined>> extends BaseQueryBuilderInterface<ReturnType> {
+export declare class JoinQueryBuilder<Aliases extends Record<Alias, Alias[]>, ReturnType extends Record<Alias, DocumentData>, LatestAlias extends Alias, RootAlias extends Alias> extends BaseQueryBuilder<ReturnType> implements SnapshotEmitter<WithDocumentReferences<ReturnType>>, HasGrouped, HasDereference {
     private readonly collectionName;
     private readonly integrationId;
     private readonly querySubscriptionManager;
     private readonly documentReferenceFactory;
-    private readonly alias;
-    private readonly joinQueryBuilderFactory;
     private readonly queryBuilderFactory;
-    private readonly simpleQueryBuilder;
+    private readonly latestAlias;
     private readonly joins;
-    /** Record that maps the right alias to the left condition */
     private readonly joinConditions;
+    private readonly queryBuilder;
     /**
      * Adds a condition to the query.
      *
@@ -27,7 +52,7 @@ export declare class JoinQueryBuilder<DocumentType extends DocumentData, MyAlias
      * @param value The value to compare against
      * @returns The query builder
      */
-    where(fieldName: (keyof DocumentType & FieldName) | string, operator: Operator | 'in' | 'not in', value: PrimitiveFieldType | Array<PrimitiveFieldType>): this;
+    where(fieldName: (keyof ReturnType[LatestAlias] & FieldName) | string, operator: Operator | 'in' | 'not in', value: PrimitiveFieldType | Array<PrimitiveFieldType>): this;
     /**
      * Sets a limit to the number of results returned by the query. The maximum limit is 20,000 and the default is 1,000
      * if none is provided.
@@ -48,25 +73,38 @@ export declare class JoinQueryBuilder<DocumentType extends DocumentData, MyAlias
      * Joins this query with another join query and return a new query builder that can be used to query the joined
      * documents.
      * @param queryBuilder The query builder to join with
-     * @param leftFieldName The name of the field on the left side of the join
-     * @param rightFieldName The name of the field on the right side of the join
+     * @param alias TODO
+     * @param joinFields TODO
+     * @param options TODO
      * @returns A new query builder that can be used to query the joined documents
      */
-    join<J extends DocumentData, RightAlias extends Alias, RightReturnType extends Record<RightAlias, DocumentReference<J> | undefined>>(queryBuilder: JoinQueryBuilder<J, RightAlias, RightReturnType>, leftFieldName: keyof DocumentType & FieldName, rightFieldName: keyof J & FieldName): JoinQueryBuilder<DocumentType, MyAlias, ReturnType & Partial<RightReturnType>>;
-    /**
-     * Returns a promise that resolves to the query results.
-     *
-     * @returns A promise that resolves to the query results
-     */
+    join<NewAlias extends string, NewReturnType extends DocumentData, LeftAlias extends Extract<keyof ReturnType, Alias>>(queryBuilder: QueryBuilder<NewReturnType>, alias: Exclude<NewAlias, keyof ReturnType>, joinFields: {
+        left: keyof Required<ReturnType>[LeftAlias] & FieldName;
+        right: keyof NewReturnType & FieldName;
+    }, options: {
+        leftAlias: LeftAlias;
+    }): SimpleJoinQueryBuilder<Omit<Aliases, LeftAlias> & Record<LeftAlias, [...Aliases[LeftAlias], NewAlias]> & Record<NewAlias, []>, ReturnType & Partial<Record<NewAlias, NewReturnType>>, NewAlias, RootAlias>;
+    join<NewAlias extends string, NewReturnType extends DocumentData>(queryBuilder: QueryBuilder<NewReturnType>, alias: Exclude<NewAlias, keyof ReturnType>, joinFields: {
+        left: keyof Required<ReturnType>[LatestAlias] & FieldName;
+        right: keyof NewReturnType & FieldName;
+    }): SimpleJoinQueryBuilder<Omit<Aliases, LatestAlias> & Record<LatestAlias, [...Aliases[LatestAlias], NewAlias]> & Record<NewAlias, []>, ReturnType & Partial<Record<NewAlias, NewReturnType>>, NewAlias, RootAlias>;
+    /** @inheritDoc */
+    snapshot(): Promise<Array<WithDocumentReferences<ReturnType>>>;
+    /** @inheritDoc */
+    snapshots(subscribe?: boolean): Observable<Array<WithDocumentReferences<ReturnType>>>;
+    /** @inheritDoc */
+    grouped(): GroupedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
+    /** @inheritDoc */
+    dereference(): DereferencedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
+}
+declare class DereferencedJoin<Aliases extends Record<Alias, Alias[]>, ReturnType extends Record<Alias, DocumentData>, RootAlias extends Alias, LatestAlias extends Alias> implements SnapshotEmitter<ReturnType>, HasGrouped {
+    private readonly joinQueryBuilder;
+    constructor(joinQueryBuilder: JoinQueryBuilder<Aliases, ReturnType, LatestAlias, RootAlias>);
+    /** @inheritDoc */
+    grouped(): SnapshotEmitter<Grouped<Aliases, ReturnType, RootAlias>>;
+    /** @inheritDoc */
     snapshot(): Promise<Array<ReturnType>>;
-    /**
-     * Returns an observable that emits the query results and updates whenever the query results change unless
-     * `subscribe=false` is provided.
-     *
-     * Important: Make sure to unsubscribe from the observable when you are done with it.
-     *
-     * @param subscribe Whether to subscribe to the query. Defaults to true.
-     * @returns An observable for the query results
-     */
+    /** @inheritDoc */
     snapshots(subscribe?: boolean): Observable<Array<ReturnType>>;
 }
+export {};

package/dist/typescript-client/src/query/query-builder.factory.d.ts

@@ -1,50 +1,23 @@
-import { CollectionName, DocumentData, FieldSort, IntegrationId, SimpleQueryBuilder, SquidDocId } from '@squidcloud/common';
+import { BaseQueryBuilder, DocumentData, FieldName, FieldSort, HasDereference, Operator, PrimitiveFieldType, Query, SnapshotEmitter } from '@squidcloud/common';
 import { Observable } from 'rxjs';
-import DocumentIdentityService from '../document-identity.service';
 import { DocumentReference } from '../document-reference';
-import { DocumentReferenceFactory } from '../document-reference.factory';
-import { QuerySubscriptionManager } from './query-subscription.manager';
-export declare class QueryBuilderFactory {
-    private readonly querySubscriptionManager;
-    private readonly documentReferenceFactory;
-    private readonly documentIdentityService;
-    constructor(querySubscriptionManager: QuerySubscriptionManager, documentReferenceFactory: DocumentReferenceFactory, documentIdentityService: DocumentIdentityService);
-    getForDocument<DocumentType extends DocumentData>(squidDocId: SquidDocId): QueryBuilder<DocumentType>;
-    get<DocumentType extends DocumentData>(collectionName: CollectionName, integrationId: IntegrationId): QueryBuilder<DocumentType>;
-}
-/** An interface for the different actions that can be performed on a query. */
-export interface QueryActions<DocumentType extends DocumentData> {
-    /**
-     * Returns a promise that resolves to the query results.
-     *
-     * @returns A promise that resolves to the query results.
-     */
-    snapshot(): Promise<Array<DocumentReference<DocumentType>>>;
-    /**
-     * Returns an observable that emits the query results and updates whenever the query results change unless
-     * `subscribe=false` is provided.
-     *
-     * Important: Make sure to unsubscribe from the observable when you are done with it.
-     *
-     * @param subscribe Whether to subscribe to changes to the query results. Defaults to `true`.
-     * @returns An observable for the query results.
-     */
-    snapshots(subscribe?: boolean): Observable<Array<DocumentReference<DocumentType>>>;
-    /**
-     * Similar to `snapshots` but returns an observable that emits the changes to the query results. The first result
-     * will contain only inserts.
-     *
-     * @returns An observable for the query changes.
-     */
-    changes(): Observable<Changes<DocumentType>>;
-}
 /** A query builder that can be used to build a query that returns a list of documents. */
-export declare class QueryBuilder<DocumentType extends DocumentData> extends SimpleQueryBuilder<DocumentType> implements QueryActions<DocumentType> {
+export declare class QueryBuilder<DocumentType extends DocumentData> extends BaseQueryBuilder<DocumentType> implements SnapshotEmitter<DocumentReference<DocumentType>>, HasDereference {
+    private readonly collectionName;
+    private readonly integrationId;
     private readonly querySubscriptionManager;
     private readonly documentReferenceFactory;
     private readonly queryBuilderFactory;
     private readonly documentIdentityService;
     private forceFetchFromServer;
+    protected readonly query: Query<DocumentType>;
+    /** @inheritDoc */
+    where(fieldName: (keyof DocumentType & FieldName) | string, operator: Operator | 'in' | 'not in', value: PrimitiveFieldType | Array<PrimitiveFieldType>): this;
+    /** @inheritDoc */
+    limit(limit: number): this;
+    /** @inheritDoc */
+    sortBy(fieldName: keyof DocumentType & FieldName, asc?: boolean): this;
+    private mergeConditions;
     getSortOrder(): FieldSort<DocumentType>[];
     /**
      * @inheritDoc
@@ -70,6 +43,8 @@ export declare class QueryBuilder<DocumentType extends DocumentData> extends Sim
      * @returns The query's hash string.
      */
     get hash(): string;
+    /** @inheritDoc */
+    dereference(): SnapshotEmitter<DocumentType>;
 }
 /** Describes the changes to a query result. */
 export declare class Changes<DocumentType extends DocumentData> {

package/dist/typescript-client/src/query/query.types.d.ts

@@ -9,6 +9,6 @@ export type Alias = string;
  */
 export interface JoinCondition {
     leftAlias: Alias;
-    leftFieldName: FieldName;
-    rightFieldName: FieldName;
+    left: FieldName;
+    right: FieldName;
 }

package/dist/typescript-client/src/squid.d.ts

@@ -58,7 +58,6 @@ export declare class Squid {
     private readonly lockManager;
     private readonly querySubscriptionManager;
     private readonly queryBuilderFactory;
-    private readonly joinQueryBuilderFactory;
     private readonly collectionReferenceFactory;
     private readonly backendFunctionManager;
     private readonly namedQueryManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squidcloud/client",
-  "version": "1.0.79",
+  "version": "1.0.81",
   "description": "A typescript implementation of the Squid client",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",