@squidcloud/client 1.0.90 → 1.0.92

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

@@ -9,4 +9,5 @@ export declare class DocumentReferenceFactory {
     constructor(documentIdentityService: DocumentIdentityService);
     create(squidDocId: SquidDocId, queryBuilderFactory: QueryBuilderFactory): DocumentReference;
     setDataManager(dataManager: DataManager): void;
+    private getCollectionKey;
 }

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

@@ -1,10 +1,12 @@
-import { GraphQLRequest, IntegrationId } from '@squidcloud/common';
+import { GraphQLRequest, IntegrationId, SupportedSquidRegion } from '@squidcloud/common';
 import { RpcManager } from './rpc.manager';
 /** A GraphQL client that can be used to query and mutate data. */
 export declare class GraphQLClient {
     private readonly rpcManager;
+    private readonly region;
+    private readonly appId;
     private readonly client;
-    constructor(rpcManager: RpcManager, integrationId: IntegrationId);
+    constructor(rpcManager: RpcManager, integrationId: IntegrationId, region: SupportedSquidRegion, appId: string);
     /** Executes a GraphQL query and returns a promise with the result. */
     query<T = any>(request: GraphQLRequest): Promise<T>;
     /** Executes a GraphQL mutation and returns a promise with the result. */

package/dist/typescript-client/src/graphql-client.factory.d.ts

@@ -1,9 +1,11 @@
-import { IntegrationId } from '@squidcloud/common';
+import { IntegrationId, SupportedSquidRegion } from '@squidcloud/common';
 import { GraphQLClient } from './graphql-client';
 import { RpcManager } from './rpc.manager';
 export declare class GraphQLClientFactory {
     private readonly rpcManager;
+    private readonly region;
+    private readonly appId;
     private readonly clientsMap;
-    constructor(rpcManager: RpcManager);
+    constructor(rpcManager: RpcManager, region: SupportedSquidRegion, appId: string);
     get(integrationId: IntegrationId): GraphQLClient;
 }

package/dist/typescript-client/src/query/local-query-manager.d.ts

@@ -0,0 +1,9 @@
+import { DocumentReferenceFactory } from '../document-reference.factory';
+import { DocumentStore } from '../document-store';
+import { QuerySubscriptionManager } from './query-subscription.manager';
+export declare class LocalQueryManager {
+    private readonly documentStore;
+    private readonly documentReferenceFactory;
+    private readonly querySubscriptionManager;
+    constructor(documentStore: DocumentStore, documentReferenceFactory: DocumentReferenceFactory, querySubscriptionManager: QuerySubscriptionManager);
+}

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

@@ -6,6 +6,7 @@ export declare class QueryBuilder<DocumentType extends DocumentData> extends Bas
     private readonly collectionName;
     private readonly integrationId;
     private readonly querySubscriptionManager;
+    private readonly localQueryManager;
     private readonly documentReferenceFactory;
     private readonly queryBuilderFactory;
     private readonly documentIdentityService;
@@ -28,6 +29,14 @@ export declare class QueryBuilder<DocumentType extends DocumentData> extends Bas
      * result.
      */
     setForceFetchFromServer(): this;
+    /**
+     * Returns the results of the query based on the data that is currently available on the client. This method is useful
+     * for synchronously accessing data that has already been fetched by another query. The method will return an empty
+     * array if data has not yet been populated.
+     *
+     * @returns An array of query results.
+     */
+    peek(): Array<DocumentReference<DocumentType>>;
     /**
      * @inheritDoc
      */

package/dist/typescript-client/src/query/query-subscription.manager.d.ts

@@ -1,10 +1,43 @@
 import { Alias, ClientRequestId, JoinCondition, Query, QuerySubscriptionId, SquidDocId, SquidDocument } from '@squidcloud/common';
-import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { BehaviorSubject, Observable, ReplaySubject, Subject } from 'rxjs';
 import { DestructManager } from '../destruct.manager';
 import DocumentIdentityService from '../document-identity.service';
 import { DocumentStore } from '../document-store';
 import { RpcManager } from '../rpc.manager';
 import { ClientIdService } from '../client-id.service';
+interface OngoingQuery {
+    clientRequestId: ClientRequestId;
+    query: Query;
+    supportedQueries: Array<OngoingQuery>;
+    supportingOngoingQuery?: OngoingQuery;
+    gotInitialResponse: boolean;
+    activated: boolean;
+    joinCondition?: JoinCondition;
+    alias: Alias;
+    dataSubject: BehaviorSubject<Array<SquidDocument> | null>;
+    queryRegistered: BehaviorSubject<boolean>;
+    /**
+     * In case that this query is a parent of another query (that is, the other query is a subset of this query), this
+     * query should not be unsubscribed from the server until we registered the child query in the server.
+     */
+    unsubscribeBlockerCount: BehaviorSubject<number>;
+    subscribe: boolean;
+    /**
+     * In case of joins, and if this ongoing query is the root, this field emits all the supported observables
+     * for example A.join(B, {..some join condition..}).join(C, {...some join condition}.
+     * This field will emit [A.subject.pipe(), B.subject.pipe(), C.subject.pipe()]. Any new supported queries will be
+     * added here.
+     */
+    allObservables?: ReplaySubject<Array<Observable<DocsAndAlias>>>;
+    isEmptyForJoin: boolean;
+    done: boolean;
+    isInFlight: boolean;
+    forceFetchFromServer: boolean;
+}
+interface DocsAndAlias {
+    docs: Array<SquidDocument>;
+    alias: Alias;
+}
 export declare class QuerySubscriptionManager {
     private readonly rpcManager;
     private readonly clientIdService;
@@ -76,13 +109,15 @@ export declare class QuerySubscriptionManager {
     errorOutAllQueries(squidDocId: SquidDocId, err: any): void;
     /** Notifies to all the given queries (identified by their clientRequestId) with the updated query result. */
     notifyAllSubscriptions(clientRequestIds: ClientRequestId[]): void;
+    private isValidParent;
     /**
      * Given an ongoing query, search for candidate ongoing queries that can serve as a parent.
      * If there is a parent query, the result of that query can be used for serving the current query.
      * We will still register the current query on the server, but we do not need to run the query, apply security rules,
      * etc.
      */
-    private findValidParentQuery;
+    private findValidParentOfOngoingQuery;
+    findValidParentOfQuery(query: Query): OngoingQuery | undefined;
     processQuery(query: Query, rootAlias: Alias, joins: Record<string, Query>, joinConditions: Record<Alias, JoinCondition>, subscribe: boolean, forceFetchFromServer: boolean): Observable<Array<Record<Alias, SquidDocument | undefined>>>;
     /**
      * Returns whether the given document ID has a query that has this document ID as a result.
@@ -132,3 +167,4 @@ export declare class QuerySubscriptionManager {
     private refreshOngoingQueries;
     private migrateDocIds;
 }
+export {};

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

@@ -1,9 +1,11 @@
+import { SupportedSquidRegion } from '@squidcloud/common';
 import { AuthManager } from './auth.manager';
 import { ClientIdService } from './client-id.service';
 import { DestructManager } from './destruct.manager';
 import { SocketManager } from './socket.manager';
 export declare class RpcManager {
-    private readonly rpcEndpoint;
+    private readonly region;
+    private readonly appId;
     private readonly socketManager;
     private readonly destructManager;
     private readonly headers;
@@ -11,11 +13,10 @@ export declare class RpcManager {
     private readonly clientIdService;
     private readonly staticHeaders;
     private readonly onGoingRpcCounter;
-    constructor(rpcEndpoint: string, socketManager: SocketManager, destructManager: DestructManager, headers: Record<string, string>, authManager: AuthManager, clientIdService: ClientIdService);
+    constructor(region: SupportedSquidRegion, appId: string, socketManager: SocketManager, destructManager: DestructManager, headers: Record<string, string>, authManager: AuthManager, clientIdService: ClientIdService);
     awaitAllSettled(): Promise<void>;
     setStaticHeader(key: string, value: string): void;
     deleteStaticHeader(key: string): void;
-    getEndpoint(): string;
     getStaticHeaders(): Record<string, string>;
     post<T>(path: string, message: any): Promise<T>;
 }

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

@@ -1,11 +1,12 @@
-import { MessageFromClient, MessageToClient } from '@squidcloud/common';
+import { MessageFromClient, MessageToClient, SupportedSquidRegion } from '@squidcloud/common';
 import { Observable } from 'rxjs';
 import { DestructManager } from './destruct.manager';
 import { AuthManager } from './auth.manager';
 import { ClientIdService } from './client-id.service';
 export declare class SocketManager {
     private readonly clientIdService;
-    private readonly socketIoEndpoint;
+    private readonly region;
+    private readonly appId;
     private readonly messageNotificationWrapper;
     private readonly destructManager;
     private readonly authManager;
@@ -22,7 +23,7 @@ export declare class SocketManager {
      * Note: we make this a function so that we can easily override it in tests.
      */
     private clientTooOldThreshold;
-    constructor(clientIdService: ClientIdService, socketIoEndpoint: string, messageNotificationWrapper: (fn: () => any) => any, destructManager: DestructManager, extraHeaders: Record<string, string> | undefined, authManager: AuthManager);
+    constructor(clientIdService: ClientIdService, region: SupportedSquidRegion, appId: string, messageNotificationWrapper: (fn: () => any) => any, destructManager: DestructManager, extraHeaders: Record<string, string> | undefined, authManager: AuthManager);
     observeNotifications<T extends MessageToClient>(): Observable<T>;
     observeConnectionReady(): Observable<boolean>;
     sendMessage(message: MessageFromClient): void;

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

@@ -2,10 +2,10 @@ import { ApiEndpointId, ApiKey, AppId, CollectionName, DocumentData, Environment
 import { Observable } from 'rxjs';
 import { AiAssistantClient } from './ai-assistant-client';
 import { CollectionReference } from './collection-reference';
+import { ConnectionDetails } from './connection-details';
 import { DistributedLock } from './distributed-lock.manager';
 import { GraphQLClient } from './graphql-client';
 import { TransactionId } from './types';
-import { ConnectionDetails } from './connection-details';
 /** The different options that can be used to initialize a Squid instance. */
 export interface SquidOptions {
     /**
@@ -57,6 +57,7 @@ export declare class Squid {
     private readonly documentStore;
     private readonly lockManager;
     private readonly querySubscriptionManager;
+    private readonly localQueryManager;
     private readonly queryBuilderFactory;
     private readonly collectionReferenceFactory;
     private readonly backendFunctionManager;

package/package.json

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