@squidcloud/client 1.0.59 → 1.0.60

package/dist/typescript-client/src/ai-assistant-client.d.ts

@@ -0,0 +1,66 @@
+import { AiAssistantMutateRequest, IntegrationId, OpenAiModelName } from '@squidcloud/common';
+import { Observable } from 'rxjs';
+import { RpcManager } from './rpc.manager';
+import { SocketManager } from './socket.manager';
+import { ClientIdService } from './client-id.service';
+export declare class AiAssistantClient {
+    private readonly clientIdService;
+    private readonly rpcManager;
+    private readonly socketManager;
+    private readonly integrationId;
+    private readonly ongoingChatRequests;
+    constructor(clientIdService: ClientIdService, rpcManager: RpcManager, socketManager: SocketManager, integrationId: IntegrationId);
+    profile(id: string): AiAssistantProfileClient;
+    mutate(request: AiAssistantMutateRequest): Promise<void>;
+    chat(profileId: string, prompt: string): Observable<string>;
+    private handleChatResponse;
+}
+declare class AiAssistantProfileClient {
+    private readonly client;
+    private readonly integrationId;
+    private readonly profileId;
+    constructor(client: AiAssistantClient, integrationId: IntegrationId, profileId: string);
+    chat(prompt: string): Observable<string>;
+    context(id?: string): AiAssistantContextClient;
+    instruction(id?: string): AiAssistantInstructionClient;
+    insert(data: {
+        modelName: OpenAiModelName;
+        strictContext: boolean;
+    }): Promise<void>;
+    update(data: {
+        modelName?: OpenAiModelName;
+        strictContext?: true;
+    }): Promise<void>;
+    delete(): Promise<void>;
+}
+declare class AiAssistantContextClient {
+    private readonly client;
+    private readonly integrationId;
+    private readonly profileId;
+    private readonly id;
+    constructor(client: AiAssistantClient, integrationId: IntegrationId, profileId: string, id?: string);
+    insert(data: {
+        title: string;
+        context: string;
+    }): Promise<void>;
+    update(data: {
+        title?: string;
+        context?: string;
+    }): Promise<void>;
+    delete(): Promise<void>;
+}
+declare class AiAssistantInstructionClient {
+    private readonly client;
+    private readonly integrationId;
+    private readonly profileId;
+    private readonly id;
+    constructor(client: AiAssistantClient, integrationId: IntegrationId, profileId: string, id?: string);
+    insert(data: {
+        instruction: string;
+    }): Promise<void>;
+    update(data: {
+        instruction: string;
+    }): Promise<void>;
+    delete(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,13 @@
+import { IntegrationId } from '@squidcloud/common';
+import { AiAssistantClient } from './ai-assistant-client';
+import { RpcManager } from './rpc.manager';
+import { SocketManager } from './socket.manager';
+import { ClientIdService } from './client-id.service';
+export declare class AiClientFactory {
+    private readonly clientIdService;
+    private readonly rpcManager;
+    private readonly socketManager;
+    private readonly assistantsMap;
+    constructor(clientIdService: ClientIdService, rpcManager: RpcManager, socketManager: SocketManager);
+    getAssistant(integrationId: IntegrationId): AiAssistantClient;
+}

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

@@ -1,14 +1,15 @@
-import { ApiEndpointId, ClientId, IntegrationId } from '@squidcloud/common';
+import { ApiEndpointId, IntegrationId } from '@squidcloud/common';
 import { Observable } from 'rxjs';
 import { RpcManager } from './rpc.manager';
 import { SocketManager } from './socket.manager';
+import { ClientIdService } from './client-id.service';
 export declare class ApiManager {
-    private readonly clientId;
+    private readonly clientIdService;
     private readonly rpcManager;
     private readonly socketManager;
     private readonly apiServerUrlOverrideMapping;
     private readonly ongoingApiExecutions;
-    constructor(clientId: ClientId, rpcManager: RpcManager, socketManager: SocketManager, apiServerUrlOverrideMapping?: Record<IntegrationId, string>);
+    constructor(clientIdService: ClientIdService, rpcManager: RpcManager, socketManager: SocketManager, apiServerUrlOverrideMapping?: Record<IntegrationId, string>);
     callApiAndSubscribe<T>(integrationId: IntegrationId, endpointId: ApiEndpointId, request: Record<string, any>): Observable<T>;
     private handleApiResponse;
 }

package/dist/typescript-client/src/backend-function.manager.d.ts

@@ -1,13 +1,13 @@
-import { ClientId } from '@squidcloud/common';
 import { Observable } from 'rxjs';
 import { RpcManager } from './rpc.manager';
 import { SocketManager } from './socket.manager';
+import { ClientIdService } from './client-id.service';
 export declare class BackendFunctionManager {
-    private readonly clientId;
+    private readonly clientIdService;
     private readonly rpcManager;
     private readonly socketManager;
     private readonly ongoingFunctionExecutions;
-    constructor(clientId: ClientId, rpcManager: RpcManager, socketManager: SocketManager);
+    constructor(clientIdService: ClientIdService, rpcManager: RpcManager, socketManager: SocketManager);
     executeFunctionAndSubscribe<T>(functionName: string, ...params: any[]): Observable<T>;
     private handleFunctionResponse;
 }

package/dist/typescript-client/src/client-id.service.d.ts

@@ -0,0 +1,24 @@
+import { Observable } from 'rxjs';
+import { ClientId } from '@squidcloud/common';
+import { DestructManager } from './destruct.manager';
+/**
+ * Whenever a squid client is created, it assigns itself a client id.
+ * Later on, if the squid client disconnects for a specified time interval, it will generate itself a new client id.
+ * The client id is generated before the socket is reconnected, so it is possible that the new client id is generated,
+ * but the socket has not connected yet.
+ *
+ * Short-term disconnects/reconnects of the socket do not cause the client id to be regenerated.
+ */
+export declare class ClientIdService {
+    private readonly destructManager;
+    private readonly clientTooOldSubject;
+    private clientId;
+    constructor(destructManager: DestructManager);
+    observeClientTooOld(): Observable<void>;
+    /**  there was a long-term disconnection of the socket */
+    notifyClientTooOld(): void;
+    notifyClientReadyToBeRegenerated(): void;
+    observeClientReadyToBeRegenerated(): Observable<void>;
+    getClientId(): ClientId;
+    isClientTooOld(): boolean;
+}

package/dist/typescript-client/src/mutation/mutation-sender.d.ts

@@ -1,11 +1,12 @@
-import { ClientId, IntegrationId, LockManager, MutateResponse, Mutation } from '@squidcloud/common';
+import { IntegrationId, LockManager, MutateResponse, Mutation } from '@squidcloud/common';
 import { QuerySubscriptionManager } from '../query/query-subscription.manager';
 import { RpcManager } from '../rpc.manager';
+import { ClientIdService } from '../client-id.service';
 export declare class MutationSender {
-    private readonly clientId;
+    private readonly clientIdService;
     private readonly rpcManager;
     private readonly lockManager;
     private readonly querySubscriptionManager;
-    constructor(clientId: ClientId, rpcManager: RpcManager, lockManager: LockManager, querySubscriptionManager: QuerySubscriptionManager);
+    constructor(clientIdService: ClientIdService, rpcManager: RpcManager, lockManager: LockManager, querySubscriptionManager: QuerySubscriptionManager);
     sendMutations(mutations: Array<Mutation>, integrationId: IntegrationId): Promise<MutateResponse>;
 }

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

@@ -1,13 +1,14 @@
-import { ClientId, IntegrationId, QueryName } from '@squidcloud/common';
+import { IntegrationId, QueryName } from '@squidcloud/common';
 import { Observable } from 'rxjs';
 import { RpcManager } from './rpc.manager';
 import { SocketManager } from './socket.manager';
+import { ClientIdService } from './client-id.service';
 export declare class NamedQueryManager {
-    private readonly clientId;
+    private readonly clientIdService;
     private readonly rpcManager;
     private readonly socketManager;
     private readonly ongoingNamedQueryExecutions;
-    constructor(clientId: ClientId, rpcManager: RpcManager, socketManager: SocketManager);
+    constructor(clientIdService: ClientIdService, rpcManager: RpcManager, socketManager: SocketManager);
     executeNamedQueryAndSubscribe<T>(integrationId: IntegrationId, queryName: QueryName, params: Record<string, any>): Observable<T>;
     private handleNamedQueryResponse;
 }

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

@@ -1,13 +1,14 @@
-import { ClientId, ClientRequestId, Query, QuerySubscriptionId, SquidDocId, SquidDocument } from '@squidcloud/common';
+import { ClientRequestId, Query, QuerySubscriptionId, SquidDocId, SquidDocument } from '@squidcloud/common';
 import { BehaviorSubject, Observable, 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 { Alias, JoinCondition } from './query.types';
+import { ClientIdService } from '../client-id.service';
 export declare class QuerySubscriptionManager {
     private readonly rpcManager;
-    private readonly clientId;
+    private readonly clientIdService;
     private readonly documentStore;
     private readonly destructManager;
     private readonly documentIdentityService;
@@ -22,7 +23,7 @@ export declare class QuerySubscriptionManager {
     private readonly clientRequestIdToLocalDocuments;
     private readonly localDocumentToClientRequestIds;
     private readonly queryMappingManager;
-    constructor(rpcManager: RpcManager, clientId: ClientId, documentStore: DocumentStore, destructManager: DestructManager, documentIdentityService: DocumentIdentityService);
+    constructor(rpcManager: RpcManager, clientIdService: ClientIdService, documentStore: DocumentStore, destructManager: DestructManager, documentIdentityService: DocumentIdentityService);
     hasOngoingQuery(clientRequestId: ClientRequestId): boolean;
     getQuery(clientRequestId: ClientRequestId): Query;
     setGotResponseFromServer(clientRequestId: ClientRequestId): void;
@@ -38,7 +39,7 @@ export declare class QuerySubscriptionManager {
     notifyAllSubscriptions(clientRequestIds: ClientRequestId[]): void;
     processQuery(query: Query, rootAlias: Alias, joins: Record<string, Query>, joinConditions: Record<Alias, JoinCondition>, subscribe: boolean): Observable<Array<Record<Alias, SquidDocument | undefined>>>;
     hasOngoingQueryForDocId(squidDocId: string): boolean;
-    private removeClientRequestId;
+    private removeClientRequestIdMapping;
     waitForAllQueriesToFinish(): Promise<void>;
     private registerQueryFinalizer;
     /** Creates a graph of ongoing queries and returns the root of the graph. */
@@ -55,5 +56,9 @@ export declare class QuerySubscriptionManager {
     hasSubscription(clientRequestId: ClientRequestId): boolean;
     /** Sends the query request to the server and makes sure to unsubscribe once the subject completes. */
     private sendQueryToServer;
+    /**
+     * naive way to refresh queries/subscriptions when we have a new client id
+     */
+    private refreshOngoingQueries;
     private migrateDocIds;
 }

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

@@ -1,4 +1,5 @@
 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 {
@@ -7,9 +8,10 @@ export declare class RpcManager {
     private readonly destructManager;
     private readonly headers;
     private readonly authManager;
+    private readonly clientIdService;
     private readonly staticHeaders;
     private readonly onGoingRpcCounter;
-    constructor(rpcEndpoint: string, socketManager: SocketManager, destructManager: DestructManager, headers: Record<string, string>, authManager: AuthManager);
+    constructor(rpcEndpoint: 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;
@@ -22,6 +24,5 @@ export declare class RpcError extends Error {
     readonly statusText: string;
     readonly headers: Headers;
     readonly url: string;
-    readonly body: string;
-    constructor(statusCode: number, statusText: string, headers: Headers, url: string, body: string);
+    constructor(statusCode: number, statusText: string, headers: Headers, url: string, message?: string);
 }

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

@@ -1,9 +1,10 @@
-import { ClientId, MessageFromClient, MessageToClient } from '@squidcloud/common';
+import { MessageFromClient, MessageToClient } 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 clientId;
+    private readonly clientIdService;
     private readonly socketIoEndpoint;
     private readonly messageNotificationWrapper;
     private readonly destructManager;
@@ -14,7 +15,14 @@ export declare class SocketManager {
     private readonly seenMessageIds;
     private socket;
     private firstConnection;
-    constructor(clientId: ClientId, socketIoEndpoint: string, messageNotificationWrapper: (fn: () => any) => any, destructManager: DestructManager, extraHeaders: Record<string, string> | undefined, authManager: AuthManager);
+    /**
+     * On a client disconnecting, we wait for a bit to see if the client reconnects,
+     * if no reconnect happens within the timeout, we consider the client to be too old.
+     * This value means we wait for 5 minutes before considering the client to be too old.
+     * 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);
     observeNotifications<T extends MessageToClient>(): Observable<T>;
     observeConnectionReady(): Observable<boolean>;
     sendMessage(message: MessageFromClient): void;

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

@@ -41,7 +41,6 @@ export interface SquidOptions {
  */
 export declare class Squid {
     private readonly socketManager;
-    private readonly clientId;
     private readonly rpcManager;
     private readonly dataManager;
     private readonly documentReferenceFactory;
@@ -59,6 +58,8 @@ export declare class Squid {
     private readonly documentIdentityService;
     private readonly distributedLockManager;
     private readonly authManager;
+    private readonly clientIdService;
+    private readonly aiClientFactory;
     private static readonly squidInstancesMap;
     /**
      * Creates a new instance of Squid with the given options.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squidcloud/client",
-  "version": "1.0.59",
+  "version": "1.0.60",
   "description": "A typescript implementation of the Squid client",
   "main": "dist/index.js",
   "types": "dist/typescript-client/src/index.d.ts",