@squidcloud/client 1.0.128 → 1.0.130

package/dist/common/src/bundle-api.types.d.ts

@@ -10,9 +10,11 @@ import { DistributedLockContext } from './distributed-lock.context';
 import { AiAssistantChatContext, AiAssistantMutationContext } from './ai-assistant.context';
 import { ClientId } from './communication.types';
 import { ClientConnectionState } from './socket.types';
+import { NativeQueryContext } from './native-query.context';
 export type SecureDatabaseAction<T extends DatabaseActionType> = T extends 'all' ? () => boolean | Promise<boolean> : T extends 'read' ? ((context: QueryContext) => boolean | Promise<boolean>) | (() => boolean | Promise<boolean>) : ((context: MutationContext) => boolean | Promise<boolean>) | (() => boolean | Promise<boolean>);
 export type SecureApiAction = ((context: ApiCallContext) => boolean | Promise<boolean>) | (() => boolean | Promise<boolean>);
 export type SecureNamedQueryAction = ((context: NamedQueryContext) => boolean | Promise<boolean>) | (() => boolean | Promise<boolean>);
+export type SecureNativeQueryAction = ((context: NativeQueryContext) => boolean | Promise<boolean>) | (() => boolean | Promise<boolean>);
 export type SecureDistributedLockAction = ((context: DistributedLockContext) => boolean | Promise<boolean>) | (() => boolean | Promise<boolean>);
 export type SecureGraphQLAction = ((context: GraphqlContext) => boolean | Promise<boolean>) | (() => boolean | Promise<boolean>);
 export type SecureAiAssistantAction<T extends AiAssistantActionType> = T extends 'all' ? () => boolean | Promise<boolean> : T extends 'chat' ? ((context: AiAssistantChatContext) => boolean | Promise<boolean>) | (() => boolean | Promise<boolean>) : ((context: AiAssistantMutationContext) => boolean | Promise<boolean>) | (() => boolean | Promise<boolean>);
@@ -31,6 +33,7 @@ export type WebhookAction = ((request: WebhookRequest) => any) | (() => any);
 /** The context provided to a webhook function. */
 export interface WebhookRequest {
     body: any;
+    rawBody?: string;
     queryParams: Record<string, string>;
     headers: Record<string, string>;
     httpMethod: 'post' | 'get' | 'put' | 'delete';

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

@@ -25,6 +25,7 @@ export * from './mutation.types';
 export * from './named-query.context';
 export * from './named-query.schemas';
 export * from './named-query.types';
+export * from './native-query.context';
 export * from './query';
 export * from './query.types';
 export * from './regions';

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

@@ -23,6 +23,9 @@ export interface MongoConnectionOptions {
 export interface MySqlConnectionSecretOptions {
     password: string;
 }
+export interface BigQueryConnectionSecretOptions {
+    privateKey: string;
+}
 export interface OracleConnectionSecretOptions {
     password: string;
 }
@@ -44,6 +47,12 @@ export interface MySqlConnectionOptions {
     connectionLimit?: number;
     sslEnabled?: boolean;
 }
+export interface BigQueryConnectionOptions {
+    secrets: BigQueryConnectionSecretOptions;
+    projectId: string;
+    datasetId: string;
+    email: string;
+}
 export interface OracleConnectionOptions {
     secrets: OracleConnectionSecretOptions;
     host: string;
@@ -99,6 +108,9 @@ export interface BaseDatabaseIntegrationConfig extends BaseIntegrationConfig {
 export interface MySqlIntegrationConfiguration {
     connectionOptions: MySqlConnectionOptions;
 }
+export interface BigQueryIntegrationConfiguration {
+    connectionOptions: BigQueryConnectionOptions;
+}
 export interface OracleIntegrationConfiguration {
     connectionOptions: OracleConnectionOptions;
 }
@@ -121,6 +133,10 @@ export interface MySqlIntegrationConfig extends BaseDatabaseIntegrationConfig {
     type: IntegrationType.mysql;
     configuration: MySqlIntegrationConfiguration;
 }
+export interface BigQueryIntegrationConfig extends BaseDatabaseIntegrationConfig {
+    type: IntegrationType.bigquery;
+    configuration: BigQueryIntegrationConfiguration;
+}
 export interface OracleIntegrationConfig extends BaseDatabaseIntegrationConfig {
     type: IntegrationType.oracledb;
     configuration: OracleIntegrationConfiguration;
@@ -168,6 +184,12 @@ interface TestMysqlDataConnectionRequest {
         connectionOptions: MySqlConnectionOptions;
     };
 }
+interface TestBigQueryDataConnectionRequest {
+    type: IntegrationType.bigquery;
+    configuration: {
+        connectionOptions: BigQueryConnectionOptions;
+    };
+}
 interface TestOracleDataConnectionRequest {
     type: IntegrationType.oracledb;
     configuration: {
@@ -198,7 +220,7 @@ interface TestCockroachDataConnectionRequest {
         connectionOptions: PostgresConnectionOptions;
     };
 }
-export type TestDataConnectionRequest = TestMongoDataConnectionRequest | TestMysqlDataConnectionRequest | TestOracleDataConnectionRequest | TestMssqlDataConnectionRequest | TestCockroachDataConnectionRequest | TestPostgresDataConnectionRequest | TestSnowflakeDataConnectionRequest;
+export type TestDataConnectionRequest = TestMongoDataConnectionRequest | TestMysqlDataConnectionRequest | TestBigQueryDataConnectionRequest | TestOracleDataConnectionRequest | TestMssqlDataConnectionRequest | TestCockroachDataConnectionRequest | TestPostgresDataConnectionRequest | TestSnowflakeDataConnectionRequest;
 export interface CollectionReadiness {
     hasPermissions: boolean;
     grantPermissionsCommands: string[];
@@ -220,6 +242,10 @@ interface DiscoverMysqlDataConnectionSchemaRequest {
     integrationType: IntegrationType.mysql;
     connectionOptions: MySqlConnectionOptions;
 }
+interface DiscoverBigQueryDataConnectionSchemaRequest {
+    integrationType: IntegrationType.bigquery;
+    connectionOptions: BigQueryConnectionOptions;
+}
 interface DiscoverOracleDataConnectionSchemaRequest {
     integrationType: IntegrationType.oracledb;
     connectionOptions: OracleConnectionOptions;
@@ -244,5 +270,5 @@ export interface TestDataConnectionResponse {
     success: boolean;
     errorMessage?: string;
 }
-export type DiscoverDataConnectionSchemaRequest = DiscoverMongoDataConnectionSchemaRequest | DiscoverInternalDataConnectionSchemaRequest | DiscoverMysqlDataConnectionSchemaRequest | DiscoverOracleDataConnectionSchemaRequest | DiscoverMssqlDataConnectionSchemaRequest | DiscoverCockroachDataConnectionSchemaRequest | DiscoverPostgresDataConnectionSchemaRequest | DiscoverSnowflakeDataConnectionSchemaRequest;
+export type DiscoverDataConnectionSchemaRequest = DiscoverMongoDataConnectionSchemaRequest | DiscoverInternalDataConnectionSchemaRequest | DiscoverMysqlDataConnectionSchemaRequest | DiscoverBigQueryDataConnectionSchemaRequest | DiscoverOracleDataConnectionSchemaRequest | DiscoverMssqlDataConnectionSchemaRequest | DiscoverCockroachDataConnectionSchemaRequest | DiscoverPostgresDataConnectionSchemaRequest | DiscoverSnowflakeDataConnectionSchemaRequest;
 export {};

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

@@ -7,7 +7,7 @@ import { IntegrationId } from '../communication.types';
 import { AiAssistantIntegrationConfig } from './ai_assistant.types';
 import { GraphQLIntegrationConfig, HttpApiIntegrationConfig, IntegrationApiSchema, IntegrationGraphQLSchema, TestGraphQLDataConnectionRequest } from './api.types';
 import { Auth0IntegrationConfig, CognitoIntegrationConfig, JwtHmacIntegrationConfig, JwtRsaIntegrationConfig, OktaIntegrationConfig } from './auth.types';
-import { BaseDatabaseIntegrationConfig, CockroachIntegrationConfig, IntegrationDataSchema, InternalIntegrationConfig, MongoIntegrationConfig, MssqlIntegrationConfig, MySqlIntegrationConfig, OracleIntegrationConfig, PinotIntegrationConfig, PostgresIntegrationConfig, SnowflakeIntegrationConfig, TestDataConnectionRequest } from './database.types';
+import { BaseDatabaseIntegrationConfig, BigQueryIntegrationConfig, CockroachIntegrationConfig, IntegrationDataSchema, InternalIntegrationConfig, MongoIntegrationConfig, MssqlIntegrationConfig, MySqlIntegrationConfig, OracleIntegrationConfig, PinotIntegrationConfig, PostgresIntegrationConfig, SnowflakeIntegrationConfig, TestDataConnectionRequest } from './database.types';
 import { DatadogIntegrationConfig, NewRelicIntegrationConfig } from './observability.types';
 export declare enum IntegrationCategory {
     'database' = "database",
@@ -70,6 +70,7 @@ export interface IntegrationConfigTypes {
     [IntegrationType.built_in_db]: InternalIntegrationConfig;
     [IntegrationType.mongo]: MongoIntegrationConfig;
     [IntegrationType.mysql]: MySqlIntegrationConfig;
+    [IntegrationType.bigquery]: BigQueryIntegrationConfig;
     [IntegrationType.oracledb]: OracleIntegrationConfig;
     [IntegrationType.pinot]: PinotIntegrationConfig;
     [IntegrationType.mssql]: MssqlIntegrationConfig;
@@ -92,6 +93,7 @@ export interface IntegrationSchemaTypes {
     [IntegrationType.mongo]: IntegrationDataSchema;
     [IntegrationType.mysql]: IntegrationDataSchema;
     [IntegrationType.oracledb]: IntegrationDataSchema;
+    [IntegrationType.bigquery]: IntegrationDataSchema;
     [IntegrationType.pinot]: IntegrationDataSchema;
     [IntegrationType.mssql]: IntegrationDataSchema;
     [IntegrationType.postgres]: IntegrationDataSchema;
@@ -104,7 +106,7 @@ export type IntegrationTypeWithConfig = keyof IntegrationConfigTypes;
 export type IntegrationSchemaKeys = keyof IntegrationSchemaTypes;
 export type IntegrationConfig = IntegrationConfigTypes[IntegrationTypeWithConfig];
 export type IntegrationSchema = IntegrationSchemaTypes[IntegrationSchemaKeys];
-export declare const DatabaseIntegrationTypes: readonly [IntegrationType.built_in_db, IntegrationType.mongo, IntegrationType.mysql, IntegrationType.mssql, IntegrationType.postgres, IntegrationType.cockroach, IntegrationType.snowflake, IntegrationType.oracledb, IntegrationType.pinot];
+export declare const DatabaseIntegrationTypes: readonly [IntegrationType.built_in_db, IntegrationType.mongo, IntegrationType.mysql, IntegrationType.bigquery, IntegrationType.mssql, IntegrationType.postgres, IntegrationType.cockroach, IntegrationType.snowflake, IntegrationType.oracledb, IntegrationType.pinot];
 export type DatabaseIntegrationType = (typeof DatabaseIntegrationTypes)[number];
 export type DatabaseIntegrationConfig = IntegrationConfigTypes[DatabaseIntegrationType];
 export declare const ApiIntegrationTypes: readonly [IntegrationType.api, IntegrationType.graphql];

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

@@ -0,0 +1,7 @@
+import { ClientId } from './communication.types';
+/** The context provided to the secure native query function. */
+export declare class NativeQueryContext {
+    readonly query: string;
+    readonly params: Record<string, any>;
+    readonly clientId: ClientId;
+}

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

@@ -0,0 +1,9 @@
+import { IntegrationId } from '@squidcloud/common';
+export interface ExecuteAiQueryRequest {
+    integrationId: IntegrationId;
+    prompt: string;
+}
+export interface ExecuteAiQueryResponse {
+    answer: string;
+    executedQuery?: string;
+}

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

@@ -1,23 +1,37 @@
 import { ApiKey, AuthToken, IntegrationId } from '@squidcloud/common';
 import { Observable } from 'rxjs';
-import { DestructManager } from './destruct.manager';
-type AuthData = {
+import { AuthTokenProvider } from './squid';
+export interface AuthData {
     token: string | undefined;
     integrationId?: IntegrationId;
-};
+}
 export declare class AuthManager {
-    private readonly destructManager;
     private readonly apiKey;
-    private readonly authIdTokenSet;
-    private readonly authIdTokenObservableSubject;
-    private shouldWaitForAuth;
-    private idToken;
-    private integrationId;
-    constructor(destructManager: DestructManager, apiKey: ApiKey | undefined);
-    setAuthIdToken(idToken: string | undefined | Promise<string | undefined> | Observable<string | undefined>, integrationId?: IntegrationId): void;
+    private authDataProvider;
+    constructor(apiKey: ApiKey | undefined, authTokenProvider?: AuthTokenProvider);
+    /**
+     * Last used ID or Access token. Used for compatibility with the old Squid code
+     * and will be removed when `getAuthToken(): AuthToken | undefined {` is removed.
+     */
+    private lastUsedJwtTokenForDeprecatedCode;
+    private lastUsedIntegrationIdForDeprecatedCode;
+    /**
+     * Sets a new ID token or an ID token provider.
+     * Deprecated. Pass the provider via constructor parameters.
+     */
+    setAuthIdToken(tokenArg: string | undefined | Promise<string | undefined> | Observable<string | undefined> | AuthTokenProvider, integrationId?: IntegrationId): void;
+    private setAuthTokenProvider;
+    getAuthData(): Promise<AuthData>;
+    /**
+     * Returns an observable over AuthData.
+     * Deprecated: the method will be removed soon. Use getAuthData().
+     */
     observeAuthIdToken(): Observable<AuthData>;
-    waitForReadyState(): Promise<void>;
     getApiKey(): ApiKey | undefined;
+    /**
+     * Returns the last used Auth token.
+     * Deprecated. Use: `getToken()` instead.
+     */
     getAuthToken(): AuthToken | undefined;
+    getToken(): Promise<AuthToken | undefined>;
 }
-export {};

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

@@ -4,9 +4,8 @@ import { RpcManager } from './rpc.manager';
 import { SocketManager } from './socket.manager';
 export declare class NamedQueryManager {
     private readonly rpcManager;
-    private readonly socketManager;
     private readonly ongoingNamedQueryExecutions;
     constructor(rpcManager: RpcManager, socketManager: SocketManager);
-    executeNamedQueryAndSubscribe<T>(integrationId: IntegrationId, queryName: QueryName, params: Record<string, any>): Observable<T>;
+    executeNamedQueryAndSubscribe<T>(integrationId: IntegrationId, queryName: QueryName, params: Record<string, any>): Observable<Array<T>>;
     private handleNamedQueryResponse;
 }

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

@@ -0,0 +1,18 @@
+import { IntegrationId } from '@squidcloud/common';
+import { RpcManager } from './rpc.manager';
+export type NativeQueryRequestType = 'relational';
+interface BaseNativeQueryRequest {
+    type: NativeQueryRequestType;
+}
+export interface RelationalNativeQueryRequest extends BaseNativeQueryRequest {
+    type: 'relational';
+    query: string;
+    params: Record<string, any>;
+}
+export type NativeQueryRequest = RelationalNativeQueryRequest;
+export declare class NativeQueryManager {
+    private readonly rpcManager;
+    constructor(rpcManager: RpcManager);
+    executeNativeQuery<T>(integrationId: IntegrationId, request: NativeQueryRequest): Promise<T>;
+}
+export {};

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

@@ -11,11 +11,11 @@ export declare class RpcManager {
     private readonly onGoingRpcCounter;
     private readonly rateLimiters;
     constructor(region: SupportedSquidRegion, appId: string, destructManager: DestructManager, headers: Record<string, string> | undefined, authManager: AuthManager, clientIdService: ClientIdService);
+    private getAuthHeaders;
     awaitAllSettled(): Promise<void>;
     setStaticHeader(key: string, value: string): void;
     deleteStaticHeader(key: string): void;
     getStaticHeaders(): Record<string, string>;
-    private ready;
     post<T>(path: string, message: any, files?: File[]): Promise<T>;
     private parseResponse;
     private getRateLimiterBucket;

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

@@ -1,8 +1,8 @@
 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';
+import { DestructManager } from './destruct.manager';
 export declare class SocketManager {
     private readonly clientIdService;
     private readonly region;
@@ -16,6 +16,7 @@ export declare class SocketManager {
     private readonly seenMessageIds;
     private socket;
     private destructSubject;
+    private lastTick;
     /**
      * 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.
@@ -23,11 +24,18 @@ export declare class SocketManager {
      * Note: we make this a function so that we can easily override it in tests.
      */
     private clientTooOldThreshold;
+    private tickInterval;
     constructor(clientIdService: ClientIdService, region: SupportedSquidRegion, appId: string, messageNotificationWrapper: (fn: () => any) => any, destructManager: DestructManager, authManager: AuthManager);
+    refreshClient(): void;
+    tick(): void;
     observeNotifications<T extends MessageToClient>(): Observable<T>;
     observeConnectionReady(): Observable<boolean>;
     sendMessage(message: MessageFromClient): void;
+    private sendMessageAsync;
+    /**  Sends 'kill' message ignoring 'connectionReady' observable. */
+    private sendKillMessage;
     private connect;
+    disconnect(): void;
     private onConnectionReady;
     private onMessage;
     private setupMessageAcknowledgments;

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

@@ -7,6 +7,7 @@ import { DistributedLock } from './distributed-lock.manager';
 import { GraphQLClient } from './graphql-client';
 import { SecretClient } from './secret.client';
 import { TransactionId } from './types';
+import { ExecuteAiQueryResponse } from './ai.types';
 /** The different options that can be used to initialize a Squid instance. */
 export interface SquidOptions {
     /**
@@ -25,6 +26,17 @@ export interface SquidOptions {
      * The API key can be found in the Squid Cloud Console.
      */
     apiKey?: ApiKey;
+    /**
+     * Access token provider for the application.
+     * Used for managing the process of verifying the identity and authorization
+     * of users who attempt to access this application.
+     *
+     * When the authTokenProvider is set, the Squid service will fetch a token
+     * and include it with every request to the Squid backend.
+     *
+     * On the backend, Squid will validate the access token and extract the user details.
+     */
+    authTokenProvider?: AuthTokenProvider;
     /**
      * The region that the application is running in. This is used to determine the URL of the Squid Cloud API.
      */
@@ -43,6 +55,11 @@ export interface SquidOptions {
      */
     apiServerUrlOverrideMapping?: Record<IntegrationId, string>;
 }
+/**
+ * A function to retrieve a new and updated Access Token.
+ * Called by Squid every time a Squid client makes requests to the Squid backend.
+ */
+export type AuthTokenProvider = (integrationId?: string) => Promise<string | undefined>;
 /**
  * The main entry point to the Squid Client SDK.
  *
@@ -63,6 +80,7 @@ export declare class Squid {
     private readonly collectionReferenceFactory;
     private readonly backendFunctionManager;
     private readonly namedQueryManager;
+    private readonly nativeQueryManager;
     private readonly apiManager;
     private readonly graphqlClientFactory;
     private readonly destructManager;
@@ -96,15 +114,18 @@ export declare class Squid {
      */
     static getInstances(): Array<Squid>;
     /**
-     * Sets the auth id token (OpenId) that will be sent to the server and will be used for providing the `auth` object
-     * to the security rules.
+     * Sets the authorization access token (OAuth2.0) that will be sent to the server and will be used for providing the
+     * `auth` object to the security rules.
      *
-     * @param idToken The auth id token, a promise that resolves with the id token, or an observable that emits the id
-     * token. Undefined if the user is not authenticated.
+     * @deprecated: pass `AuthTokenProvider` in the constructor of the class.
+     *
+     * @param accessToken The OAuth2.0 access token or a promise that resolves with the access token.
+     * When undefined, no authorization information is sent.
+     * The Observable variant of the parameter is deprecated and will be removed soon.
      * @param integrationId The id of the integration.
      * @returns void
      */
-    setAuthIdToken: (idToken: string | undefined | Promise<string | undefined> | Observable<string | undefined>, integrationId?: IntegrationId) => void;
+    setAuthIdToken: (accessToken: string | undefined | Promise<string | undefined> | Observable<string | undefined> | AuthTokenProvider, integrationId?: IntegrationId) => void;
     /**
      * Returns a reference to the collection in the provided integration.
      *
@@ -156,7 +177,21 @@ export declare class Squid {
      * @returns A promise that resolves with the result of the named query.
      * @typeParam T The type of the result of the named query.
      */
-    executeNamedQuery: <T = any>(integrationId: IntegrationId, queryName: QueryName, params: Record<string, any>) => Promise<T>;
+    executeNamedQuery: <T = any>(integrationId: IntegrationId, queryName: QueryName, params: Record<string, any>) => Promise<T[]>;
+    /**
+     * Executes a native relational query with the given parameters and returns a promise with the result.
+     *
+     * Native queries allow you to execute raw SQL or other database-specific queries directly against the database.
+     * This can be useful when you need to perform operations that are not easily accomplished with named queries or
+     * other high-level abstractions.
+     *
+     * @param integrationId The id of the integration that the query is associated with.
+     * @param query The raw SQL or other database-specific query to execute.
+     * @param params (Optional) The parameters to pass to the query. Defaults to an empty object.
+     * @returns A promise that resolves with the result of the query.
+     * @type {Promise<Array<SquidDocument>>}
+     */
+    executeNativeRelationalQuery: <T = any>(integrationId: IntegrationId, query: string, params?: Record<string, any>) => Promise<T[]>;
     /**
      * Invokes the given HTTP API (defined by the integration ID and the endpoint ID) with the given request parameters
      * and returns a promise with the response. The structure of the request and the response is defined in the
@@ -197,6 +232,7 @@ export declare class Squid {
          * @returns An AI Assistant client.
          */
         assistant: (integrationId: IntegrationId) => AiAssistantClient;
+        executeAiQuery: (integrationId: IntegrationId, prompt: string) => Promise<ExecuteAiQueryResponse>;
     };
     get secrets(): SecretClient;
     /**

package/package.json

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