@squidcloud/client 1.0.28 → 1.0.30

package/dist/common/src/api-call.context.d.ts

@@ -1,17 +1,12 @@
-import { ApiEndpoint, ApiEndpointId, ApiIntegration } from './integration.types';
-interface ApiRequest {
-    endpointId: ApiEndpointId;
-    endpoint: ApiEndpoint;
-    apiIntegration: ApiIntegration;
-    request: Record<string, any>;
-    serverUrlOverride: string | undefined;
-}
+import { ApiHeaders } from './api.types';
+import { ApiEndpointId, HttpMethod } from './integration.types';
 export declare class ApiCallContext {
     readonly endpointId: ApiEndpointId;
-    readonly endpoint: ApiEndpoint;
-    readonly apiIntegration: ApiIntegration;
+    readonly url: string;
+    readonly method: HttpMethod;
+    readonly headers: ApiHeaders;
+    readonly body: Record<string, any>;
+    readonly queryParams: Record<string, string | number | boolean>;
+    readonly pathParams: Record<string, string>;
     readonly serverUrlOverride: string | undefined;
-    readonly request: Record<string, any>;
-    constructor(apiRequest: ApiRequest);
 }
-export {};

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

@@ -1,5 +1,6 @@
 import { ClientId, ClientRequestId, IntegrationId } from './communication.types';
-import { ApiEndpointId } from './integration.types';
+import { ApiEndpointId, HttpMethod } from './integration.types';
+export type ApiHeaders = Record<string, string | number | boolean>;
 export interface CallApiRequest {
     integrationId: IntegrationId;
     clientId: ClientId;
@@ -8,3 +9,15 @@ export interface CallApiRequest {
     serverUrlOverride?: string;
     request: Record<string, any>;
 }
+export interface ExtractedApiParams {
+    headers: ApiHeaders;
+    queryParams: Record<string, string | number | boolean>;
+    body: Record<string, any>;
+    pathParams: Record<string, string>;
+}
+export interface SecureApiRequest extends ExtractedApiParams {
+    endpointId: ApiEndpointId;
+    url: string;
+    method: HttpMethod;
+    serverUrlOverride: string | undefined;
+}

package/dist/common/src/application.schemas.d.ts

@@ -28,8 +28,7 @@ export declare const UpsertIntegrationRequestSchema: {
             };
             supportsExternalChanges?: undefined;
             configuration?: undefined;
-            baseUrl?: undefined;
-            endpoints?: undefined;
+            schema?: undefined;
         };
     } | {
         type: string;
@@ -82,10 +81,14 @@ export declare const UpsertIntegrationRequestSchema: {
                             };
                         };
                     };
+                    discoveryOptions?: undefined;
+                    apiKey?: undefined;
+                    appKey?: undefined;
+                    datadogRegion?: undefined;
+                    newRelicRegion?: undefined;
                 };
             };
-            baseUrl?: undefined;
-            endpoints?: undefined;
+            schema?: undefined;
         };
     } | {
         type: string;
@@ -164,67 +167,77 @@ export declare const UpsertIntegrationRequestSchema: {
                             };
                         };
                     };
+                    discoveryOptions?: undefined;
+                    apiKey?: undefined;
+                    appKey?: undefined;
+                    datadogRegion?: undefined;
+                    newRelicRegion?: undefined;
                 };
             };
-            baseUrl?: undefined;
-            endpoints?: undefined;
+            schema?: undefined;
         };
     } | {
         type: string;
-        required: string[];
+        required: never[];
         properties: {
             type: {
                 const: IntegrationType;
             };
-            baseUrl: {
-                type: string;
-                nullable: boolean;
-                format: string;
-            };
-            endpoints: {
+            schema: {
                 type: string;
-                patternProperties: {
-                    '^\\S+$': {
+                required: never[];
+                properties: {
+                    baseUrl: {
                         type: string;
-                        required: string[];
-                        properties: {
-                            relativePath: {
-                                type: string;
-                            };
-                            method: {
-                                type: string;
-                                enum: string[];
-                            };
-                            requestSchema: {
+                        nullable: boolean;
+                        format: string;
+                    };
+                    endpoints: {
+                        type: string;
+                        patternProperties: {
+                            '^\\S+$': {
                                 type: string;
-                                patternProperties: {
-                                    '^\\S+$': {
+                                required: string[];
+                                properties: {
+                                    relativePath: {
                                         type: string;
-                                        properties: {
-                                            paramLocation: {
-                                                type: string;
-                                                enum: string[];
-                                            };
-                                            fieldNameInRequest: {
+                                    };
+                                    method: {
+                                        type: string;
+                                        enum: string[];
+                                    };
+                                    requestSchema: {
+                                        type: string;
+                                        patternProperties: {
+                                            '^\\S+$': {
                                                 type: string;
+                                                properties: {
+                                                    location: {
+                                                        type: string;
+                                                        enum: string[];
+                                                    };
+                                                    fieldNameInRequest: {
+                                                        type: string;
+                                                    };
+                                                };
                                             };
                                         };
                                     };
-                                };
-                            };
-                            responseSchema: {
-                                type: string;
-                                patternProperties: {
-                                    '^\\S+$': {
+                                    responseSchema: {
                                         type: string;
-                                        required: string[];
-                                        properties: {
-                                            paramLocation: {
-                                                type: string;
-                                                enum: string[];
-                                            };
-                                            fieldPathInResponse: {
+                                        patternProperties: {
+                                            '^\\S+$': {
                                                 type: string;
+                                                required: string[];
+                                                properties: {
+                                                    location: {
+                                                        type: string;
+                                                        enum: string[];
+                                                    };
+                                                    path: {
+                                                        type: string;
+                                                    };
+                                                };
                                             };
                                         };
                                     };
@@ -237,6 +250,39 @@ export declare const UpsertIntegrationRequestSchema: {
             supportsExternalChanges?: undefined;
             configuration?: undefined;
         };
+    } | {
+        type: string;
+        required: string[];
+        properties: {
+            type: {
+                const: IntegrationType;
+            };
+            configuration: {
+                type: string;
+                nullable: boolean;
+                required: string[];
+                properties: {
+                    discoveryOptions: {
+                        type: string;
+                        nullable: boolean;
+                        required: string[];
+                        properties: {
+                            openApiSpecUrl: {
+                                type: string;
+                                nullable: boolean;
+                            };
+                        };
+                    };
+                    connectionOptions?: undefined;
+                    apiKey?: undefined;
+                    appKey?: undefined;
+                    datadogRegion?: undefined;
+                    newRelicRegion?: undefined;
+                };
+            };
+            supportsExternalChanges?: undefined;
+            schema?: undefined;
+        };
     } | {
         type: string;
         required: string[];
@@ -261,11 +307,145 @@ export declare const UpsertIntegrationRequestSchema: {
                             };
                         };
                     };
+                    discoveryOptions?: undefined;
+                    apiKey?: undefined;
+                    appKey?: undefined;
+                    datadogRegion?: undefined;
+                    newRelicRegion?: undefined;
+                };
+            };
+            supportsExternalChanges?: undefined;
+            schema?: undefined;
+        };
+    } | {
+        type: string;
+        required: string[];
+        properties: {
+            type: {
+                const: IntegrationType;
+            };
+            configuration: {
+                type: string;
+                nullable: boolean;
+                required: string[];
+                properties: {
+                    connectionOptions: {
+                        type: string;
+                        required: never[];
+                        properties: {
+                            account: {
+                                type: string;
+                                nullable: boolean;
+                            };
+                            username: {
+                                type: string;
+                                nullable: boolean;
+                            };
+                            database: {
+                                type: string;
+                                nullable: boolean;
+                            };
+                            schema: {
+                                type: string;
+                                nullable: boolean;
+                            };
+                            warehouse: {
+                                type: string;
+                                nullable: boolean;
+                            };
+                            role: {
+                                type: string;
+                                nullable: boolean;
+                            };
+                            secrets: {
+                                type: string;
+                                required: string[];
+                                nullable: boolean;
+                                properties: {
+                                    password: {
+                                        type: string;
+                                        nullable: boolean;
+                                        isSecret: {};
+                                    };
+                                };
+                            };
+                        };
+                    };
+                    discoveryOptions?: undefined;
+                    apiKey?: undefined;
+                    appKey?: undefined;
+                    datadogRegion?: undefined;
+                    newRelicRegion?: undefined;
+                };
+            };
+            supportsExternalChanges?: undefined;
+            schema?: undefined;
+        };
+    } | {
+        type: string;
+        required: string[];
+        properties: {
+            type: {
+                const: IntegrationType;
+            };
+            configuration: {
+                type: string;
+                nullable: boolean;
+                required: string[];
+                properties: {
+                    apiKey: {
+                        type: string;
+                        nullable: boolean;
+                        isSecret: {};
+                    };
+                    appKey: {
+                        type: string;
+                        nullable: boolean;
+                        isSecret: {};
+                    };
+                    datadogRegion: {
+                        type: string;
+                        nullable: boolean;
+                        enum: string[];
+                    };
+                    connectionOptions?: undefined;
+                    discoveryOptions?: undefined;
+                    newRelicRegion?: undefined;
+                };
+            };
+            supportsExternalChanges?: undefined;
+            schema?: undefined;
+        };
+    } | {
+        type: string;
+        required: string[];
+        properties: {
+            type: {
+                const: IntegrationType;
+            };
+            configuration: {
+                type: string;
+                nullable: boolean;
+                required: string[];
+                properties: {
+                    apiKey: {
+                        type: string;
+                        nullable: boolean;
+                        isSecret: {};
+                    };
+                    newRelicRegion: {
+                        type: string;
+                        nullable: boolean;
+                        enum: string[];
+                    };
+                    connectionOptions?: undefined;
+                    discoveryOptions?: undefined;
+                    appKey?: undefined;
+                    datadogRegion?: undefined;
                 };
             };
             supportsExternalChanges?: undefined;
-            baseUrl?: undefined;
-            endpoints?: undefined;
+            schema?: undefined;
         };
     })[];
 };
@@ -406,6 +586,62 @@ export declare const TestDataConnectionRequestSchema: {
                 };
             };
         };
+    } | {
+        type: string;
+        required: string[];
+        properties: {
+            type: {
+                const: IntegrationType;
+            };
+            configuration: {
+                type: string;
+                required: string[];
+                properties: {
+                    connectionOptions: {
+                        type: string;
+                        required: never[];
+                        properties: {
+                            account: {
+                                type: string;
+                                nullable: boolean;
+                            };
+                            username: {
+                                type: string;
+                                nullable: boolean;
+                            };
+                            database: {
+                                type: string;
+                                nullable: boolean;
+                            };
+                            schema: {
+                                type: string;
+                                nullable: boolean;
+                            };
+                            warehouse: {
+                                type: string;
+                                nullable: boolean;
+                            };
+                            role: {
+                                type: string;
+                                nullable: boolean;
+                            };
+                            secrets: {
+                                type: string;
+                                required: string[];
+                                nullable: boolean;
+                                properties: {
+                                    password: {
+                                        type: string;
+                                        nullable: boolean;
+                                        isSecret: {};
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
     } | {
         type: string;
         required: string[];
@@ -480,6 +716,56 @@ export declare const DiscoverDataConnectionSchemaRequestSchema: {
                 };
             };
         };
+    } | {
+        type: string;
+        required: string[];
+        properties: {
+            integrationType: {
+                const: IntegrationType;
+            };
+            connectionOptions: {
+                type: string;
+                required: never[];
+                properties: {
+                    account: {
+                        type: string;
+                        nullable: boolean;
+                    };
+                    username: {
+                        type: string;
+                        nullable: boolean;
+                    };
+                    database: {
+                        type: string;
+                        nullable: boolean;
+                    };
+                    schema: {
+                        type: string;
+                        nullable: boolean;
+                    };
+                    warehouse: {
+                        type: string;
+                        nullable: boolean;
+                    };
+                    role: {
+                        type: string;
+                        nullable: boolean;
+                    };
+                    secrets: {
+                        type: string;
+                        required: string[];
+                        nullable: boolean;
+                        properties: {
+                            password: {
+                                type: string;
+                                nullable: boolean;
+                                isSecret: {};
+                            };
+                        };
+                    };
+                };
+            };
+        };
     } | {
         type: string;
         required: string[];
@@ -596,13 +882,19 @@ export declare const UpdateAllowedHostsRequestSchema: {
         };
     };
 };
-export declare const DiscoverOpenApiEndpointsRequestSchema: {
+export declare const DiscoverOpenApiSchemaRequestSchema: {
     type: string;
     required: string[];
     properties: {
-        openApiSpecUrl: {
+        discoveryOptions: {
             type: string;
-            format: string;
+            required: string[];
+            properties: {
+                openApiSpecUrl: {
+                    type: string;
+                    format: string;
+                };
+            };
         };
     };
 };

package/dist/common/src/application.types.d.ts

@@ -1,7 +1,7 @@
 import { ApplicationBundleData, ServiceFunctionName } from './bundle-data.types';
 import { AppId, IntegrationId } from './communication.types';
 import { CollectionName } from './document.types';
-import { ApiEndpoint, ApiEndpointId, GraphQLConnectionOptions, Integration, IntegrationDataSchema, IntegrationGraphQLSchema, IntegrationType, MongoConnectionOptions, MssqlConnectionOptions, MySqlConnectionOptions, PostgresConnectionOptions } from './integration.types';
+import { GraphQLConnectionOptions, Integration, IntegrationApiSchema, IntegrationDataSchema, IntegrationGraphQLSchema, IntegrationType, MongoConnectionOptions, MssqlConnectionOptions, MySqlConnectionOptions, PostgresConnectionOptions, SnowflakeConnectionOptions } from './integration.types';
 export type WebhookId = string;
 export type QueryName = string;
 export type TriggerId = string;
@@ -128,7 +128,7 @@ export interface CreateApplicationResponse {
     appId: AppId;
 }
 export type UpsertIntegrationRequest = UpsertDataIntegrationRequest | UpsertGraphQLIntegrationRequest | UpsertApiIntegrationRequest;
-export type UpsertDataIntegrationRequest = UpsertInternalIntegrationRequest | UpsertMongoDbIntegrationRequest | UpsertMssqlIntegrationRequest | UpsertMySqlIntegrationRequest | UpsertPostgresIntegrationRequest | UpsertCockroachIntegrationRequest;
+export type UpsertDataIntegrationRequest = UpsertInternalIntegrationRequest | UpsertMongoDbIntegrationRequest | UpsertMssqlIntegrationRequest | UpsertMySqlIntegrationRequest | UpsertPostgresIntegrationRequest | UpsertCockroachIntegrationRequest | UpsertSnowflakeIntegrationRequest;
 interface BaseUpsertIntegrationRequest {
     id: IntegrationId;
     type: IntegrationType;
@@ -176,6 +176,13 @@ export interface UpsertCockroachIntegrationRequest extends BaseUpsertDataIntegra
         connectionOptions: PostgresConnectionOptions;
     };
 }
+export interface UpsertSnowflakeIntegrationRequest extends BaseUpsertDataIntegrationRequest {
+    type: IntegrationType.snowflake;
+    schema?: IntegrationDataSchema;
+    configuration: {
+        connectionOptions: SnowflakeConnectionOptions;
+    };
+}
 export interface UpsertGraphQLIntegrationRequest extends BaseUpsertIntegrationRequest {
     type: IntegrationType.graphql;
     schema?: IntegrationGraphQLSchema;
@@ -185,8 +192,7 @@ export interface UpsertGraphQLIntegrationRequest extends BaseUpsertIntegrationRe
 }
 export interface UpsertApiIntegrationRequest extends BaseUpsertIntegrationRequest {
     type: IntegrationType.api;
-    baseUrl: string;
-    endpoints: Record<ApiEndpointId, ApiEndpoint>;
+    schema?: IntegrationApiSchema;
 }
 export interface DeleteIntegrationRequest {
     integrationId: IntegrationId;

package/dist/common/src/backend-run.types.d.ts

@@ -53,7 +53,6 @@ export type WorkerActionType = 'loadJs' | 'executeFunction' | 'ping' | 'terminat
 export interface ActionRequest {
     action: WorkerActionType;
     payload?: LoadJsPayload | ExecuteFunctionPayload;
-    traceContext?: any;
 }
 export type LoadJsResponse = GeneralResponse;
 export type TerminateResponse = GeneralResponse;

package/dist/common/src/context.types.d.ts

@@ -1,19 +1,29 @@
 export type AuthType = 'Bearer' | 'ApiKey';
+/**
+ * The payload of a JWT token in case an auth token was used.
+ */
 export interface AuthWithBearer {
     type: 'Bearer';
     userId: string;
     expiration: number;
     attributes: Record<string, any>;
 }
+/**
+ * The authentication object for the current request in case an API key is used.
+ */
 export interface AuthWithApiKey {
     type: 'ApiKey';
     apiKey: string;
 }
+/** The authentication object for the current request. */
 export type Auth = AuthWithBearer | AuthWithApiKey;
 export interface AuthToken {
     type: AuthType;
     token: string;
 }
+/**
+ * The context of a request to a service.
+ */
 export interface RunContext {
     appId: string;
     sourceIp?: string;

package/dist/common/src/graphql.context.d.ts

@@ -1,14 +1,6 @@
-interface GraphQlRequest {
-    isGraphiQL: boolean;
-    query?: string;
-    operationName?: string;
-    variables?: string | Record<string, any>;
-}
 export declare class GraphqlContext {
     readonly isGraphiQL: boolean;
     readonly query: string | undefined;
     readonly variables: string | Record<string, any> | undefined;
     readonly operationName: string | undefined;
-    constructor(graphQlRequest: GraphQlRequest);
 }
-export {};

package/dist/common/src/graphql.types.d.ts

@@ -1,8 +1,16 @@
 import { IntrospectionQuery } from 'graphql';
+import { ApiHeaders } from './api.types';
 export { ExecutionResult, IntrospectionQuery } from 'graphql';
+export interface ExtractedGraphQLParams {
+    headers: ApiHeaders;
+}
 export interface GraphQLRequest {
     operationName?: string;
     query?: string;
     variables?: string | Record<string, any>;
 }
+export interface SecureGraphQLRequest extends GraphQLRequest {
+    isGraphiQL: boolean;
+    headers: ApiHeaders;
+}
 export declare const EmptyIntrospection: IntrospectionQuery;

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

@@ -15,7 +15,6 @@ export * from './graphql.types';
 export * from './http-status.enum';
 export * from './integration.types';
 export * from './logger.types';
-export * from './metrics.schemas';
 export * from './metrics.types';
 export * from './mutation.context';
 export * from './mutation.schemas';
@@ -30,6 +29,7 @@ export * from './regions';
 export * from './schema/schema.types';
 export * from './secret.schemas';
 export * from './secret.types';
+export * from './security.types';
 export * from './socket.schemas';
 export * from './socket.types';
 export * from './time-units';