@squidcloud/client 1.0.130 → 1.0.132

package/dist/cjs/index.js

@@ -30692,6 +30692,7 @@ function createWebSocketWrapper(url, opts = {}) {
 
 
 
+
 
 
 
@@ -49213,10 +49214,6 @@ class RpcManager {
         for (const [key, value] of Object.entries(headers)) {
             this.setStaticHeader(key, value);
         }
-        const apiKey = this.authManager.getApiKey();
-        if (apiKey) {
-            this.setStaticHeader('Authorization', `ApiKey ${apiKey}`);
-        }
         this.clientIdService.observeClientId().subscribe(clientId => {
             if (clientId) {
                 this.setStaticHeader('x-squid-clientid', clientId);
@@ -49228,6 +49225,7 @@ class RpcManager {
         destructManager.onDestruct(async () => {
             await this.awaitAllSettled();
         });
+        const apiKey = this.authManager.getApiKey();
         const rateLimiterMultiplier = apiKey ? 5 : 1;
         this.rateLimiters = {
             default: new RateLimiter(60 * rateLimiterMultiplier, 5),
@@ -49236,6 +49234,10 @@ class RpcManager {
         };
     }
     async getAuthHeaders() {
+        const apiKey = this.authManager.getApiKey();
+        if (apiKey) {
+            return { Authorization: `ApiKey ${apiKey}` };
+        }
         const { token, integrationId } = await this.authManager.getAuthData();
         if (!token)
             return {};
@@ -49736,6 +49738,7 @@ class Squid {
      * @param options The options for initializing the Squid instance.
      */
     constructor(options) {
+        this.options = options;
         this.destructManager = new DestructManager();
         // Note: The following methods are bound using arrow functions to ensure that if a user accesses the methods via
         // destructuring (i.e. `{ setAuthIdToken } = squid`) then `this` will still be bound to the Squid class.
@@ -49834,6 +49837,30 @@ class Squid {
         this.executeNativeRelationalQuery = (integrationId, query, params = {}) => {
             return this.nativeQueryManager.executeNativeQuery(integrationId, { type: 'relational', query, params });
         };
+        /**
+         * Executes a native MongoDB aggregation pipeline with the given parameters and returns a promise with the result.
+         *
+         * Native queries allow you to execute raw MongoDB queries directly against the database.
+         * This can be particularly useful when you need to perform complex operations or aggregations that are not
+         * easily accomplished with standard query methods or other high-level abstractions provided by the database driver or ORM.
+         *
+         * @param {IntegrationId} integrationId - The id of the integration that the query is associated with.
+         * @param {string} collectionName - The name of the MongoDB collection to run the aggregation pipeline against.
+         * @param {Array<Record<string, any>>} [aggregationPipeline=[]] - The array of aggregation stages to be executed.
+         *        Each stage in the pipeline is an object specifying the operation to be performed.
+         * @returns {Promise<Array<T>>} A promise that resolves with an array of documents resulting from the aggregation pipeline.
+         *         Each document in the array is of the generic type T, which can be specified when calling the function.
+         * @template T - The type of the documents that are expected to be returned by the aggregation pipeline. If not specified,
+         *         any type is assumed by default.
+         * @type {Promise<Array<SquidDocument>>}
+         */
+        this.executeNativeMongoQuery = (integrationId, collectionName, aggregationPipeline = []) => {
+            return this.nativeQueryManager.executeNativeQuery(integrationId, {
+                type: 'mongo',
+                collectionName,
+                aggregationPipeline,
+            });
+        };
         /**
          * 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

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

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

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

@@ -118,7 +118,7 @@ export type ObservabilityIntegrationType = (typeof ObservabilityIntegrationTypes
 export type ObservabilityIntegrationConfig = IntegrationConfigTypes[ObservabilityIntegrationType];
 export type AuthIntegrationType = (typeof AuthIntegrationTypes)[number];
 export type AuthIntegrationConfig = IntegrationConfigTypes[AuthIntegrationType];
-export declare function isDataIntegrationType(type: IntegrationType): type is DatabaseIntegrationType;
+export declare function isDataIntegrationType(type: unknown): type is DatabaseIntegrationType;
 export declare function isDataIntegration(integration: any): integration is BaseDatabaseIntegrationConfig;
 export declare function isAuthIntegrationType(type: IntegrationType): type is AuthIntegrationType;
 export declare function isAuthIntegration(integration: any): integration is AuthIntegrationConfig;

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

@@ -0,0 +1,16 @@
+export type NativeQueryRequestType = 'relational' | 'mongo';
+interface BaseNativeQueryRequest {
+    type: NativeQueryRequestType;
+}
+export interface RelationalNativeQueryRequest extends BaseNativeQueryRequest {
+    type: 'relational';
+    query: string;
+    params: Record<string, any>;
+}
+export interface MongoNativeQueryRequest extends BaseNativeQueryRequest {
+    type: 'mongo';
+    collectionName: string;
+    aggregationPipeline: Array<any | undefined>;
+}
+export type NativeQueryRequest = RelationalNativeQueryRequest | MongoNativeQueryRequest;
+export {};

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

@@ -5,5 +5,6 @@ export interface ExecuteAiQueryRequest {
 }
 export interface ExecuteAiQueryResponse {
     answer: string;
+    explanation?: string;
     executedQuery?: string;
 }

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

@@ -1,18 +1,7 @@
-import { IntegrationId } from '@squidcloud/common';
+import { IntegrationId, NativeQueryRequest } 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/squid.d.ts

@@ -68,6 +68,7 @@ export type AuthTokenProvider = (integrationId?: string) => Promise<string | und
  * capabilities.
  */
 export declare class Squid {
+    readonly options: SquidOptions;
     private readonly socketManager;
     private readonly rpcManager;
     private readonly dataManager;
@@ -192,6 +193,24 @@ export declare class Squid {
      * @type {Promise<Array<SquidDocument>>}
      */
     executeNativeRelationalQuery: <T = any>(integrationId: IntegrationId, query: string, params?: Record<string, any>) => Promise<T[]>;
+    /**
+     * Executes a native MongoDB aggregation pipeline with the given parameters and returns a promise with the result.
+     *
+     * Native queries allow you to execute raw MongoDB queries directly against the database.
+     * This can be particularly useful when you need to perform complex operations or aggregations that are not
+     * easily accomplished with standard query methods or other high-level abstractions provided by the database driver or ORM.
+     *
+     * @param {IntegrationId} integrationId - The id of the integration that the query is associated with.
+     * @param {string} collectionName - The name of the MongoDB collection to run the aggregation pipeline against.
+     * @param {Array<Record<string, any>>} [aggregationPipeline=[]] - The array of aggregation stages to be executed.
+     *        Each stage in the pipeline is an object specifying the operation to be performed.
+     * @returns {Promise<Array<T>>} A promise that resolves with an array of documents resulting from the aggregation pipeline.
+     *         Each document in the array is of the generic type T, which can be specified when calling the function.
+     * @template T - The type of the documents that are expected to be returned by the aggregation pipeline. If not specified,
+     *         any type is assumed by default.
+     * @type {Promise<Array<SquidDocument>>}
+     */
+    executeNativeMongoQuery: <T = any>(integrationId: IntegrationId, collectionName: string, aggregationPipeline?: Array<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
@@ -232,6 +251,30 @@ export declare class Squid {
          * @returns An AI Assistant client.
          */
         assistant: (integrationId: IntegrationId) => AiAssistantClient;
+        /**
+         * Executes an AI query using a specific DB integration, sending a prompt to the AI and returning its response.
+         * This function allows for direct interaction with the AI's capabilities by sending text prompts and receiving
+         * the AI's responses, which can be used for various applications such as automating tasks, generating content,
+         * or obtaining information.
+         *
+         * @param integrationId The identifier for the DB integration which is used to direct the query to the
+         *                      appropriate DB.
+         * @param prompt        The text prompt to send to the AI. This should be formulated in a way that the AI can
+         *                      understand and respond to, taking into account the nature of the task or the information
+         *                      sought.
+         * @returns             A promise that resolves to an `ExecuteAiQueryResponse`. This response includes the AI's
+         *                      reply to the provided prompt, along with any other relevant information that is part of
+         *                      the AI's response. The promise can be awaited to handle the response asynchronously.
+         *
+         * @example
+         * ```
+         * const response = await ai().executeAiQuery(myDbIntegrationId, "How many transactions ran yesterday?");
+         * console.log(response);
+         * ```
+         *
+         * For more details on the usage and capabilities of the AI Assistant, refer to the documentation provided at
+         * {@link https://docs.squid.cloud/docs/ai}.
+         */
         executeAiQuery: (integrationId: IntegrationId, prompt: string) => Promise<ExecuteAiQueryResponse>;
     };
     get secrets(): SecretClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squidcloud/client",
-  "version": "1.0.130",
+  "version": "1.0.132",
   "description": "A typescript implementation of the Squid client",
   "main": "dist/cjs/index.js",
   "types": "dist/typescript-client/src/index.d.ts",
@@ -49,11 +49,7 @@
     "assertic": "^1.0.0",
     "copy-webpack-plugin": "^11.0.0",
     "cpx": "^1.5.0",
-    "eslint": "8.22.0",
-    "eslint-config-prettier": "^8.3.0",
-    "eslint-plugin-prettier": "^4.0.0",
     "generate-package-json-webpack-plugin": "^2.6.0",
-    "prettier": "^2.8.0",
     "tsconfig-paths-webpack-plugin": "^4.0.0",
     "tscpaths": "^0.0.9",
     "webpack": "^5.75.0",