@squidcloud/client 1.0.28 → 1.0.30

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

@@ -58,6 +58,21 @@ export interface PostgresConnectionOptions {
 export interface GraphQLConnectionOptions {
     baseUrl: string;
 }
+export interface OpenApiDiscoveryOptions {
+    openApiSpecUrl: string;
+}
+export interface SnowflakeConnectionSecretOptions {
+    password: string;
+}
+export interface SnowflakeConnectionOptions {
+    secrets: SnowflakeConnectionSecretOptions;
+    account: string;
+    username: string;
+    database: string;
+    schema: string;
+    warehouse: string;
+    role: string;
+}
 export declare enum IntegrationType {
     'built_in_db' = "built_in_db",
     'mongo' = "mongo",
@@ -66,16 +81,26 @@ export declare enum IntegrationType {
     'postgres' = "postgres",
     'cockroach' = "cockroach",
     'api' = "api",
-    'graphql' = "graphql"
-}
-export type DataIntegration = MySqlIntegration | MssqlIntegration | MongoIntegration | InternalIntegration | PostgresIntegration | CockroachIntegration;
-export type Integration = DataIntegration | ApiIntegration | GraphQLIntegration;
+    'openapi' = "openapi",
+    'graphql' = "graphql",
+    'snowflake' = "snowflake",
+    'datadog' = "datadog",
+    'newrelic' = "newrelic"
+}
+export type DataIntegration = MySqlIntegration | MssqlIntegration | MongoIntegration | InternalIntegration | PostgresIntegration | CockroachIntegration | SnowflakeIntegration;
+export type Integration = DataIntegration | ApiIntegration | OpenApiIntegration | GraphQLIntegration | DatadogIntegration | NewRelicIntegration;
 type TableName = string;
 export interface IntegrationDataSchema {
     collections: Record<TableName, CollectionSchema>;
 }
 export interface IntegrationGraphQLSchema {
     introspection: IntrospectionQuery;
+    injectionSchema?: Record<FieldName, ApiInjectionField>;
+}
+export interface IntegrationApiSchema {
+    baseUrl: string;
+    endpoints: IntegrationApiEndpoints;
+    injectionSchema?: Record<FieldName, ApiInjectionField>;
 }
 export type IntegrationApiEndpoints = Record<ApiEndpointId, ApiEndpoint>;
 export type IntegrationSchema = IntegrationDataSchema | IntegrationGraphQLSchema;
@@ -86,6 +111,27 @@ interface BaseIntegration {
     updateDate: Date;
     secured: boolean;
 }
+export interface DatadogIntegration extends BaseIntegration {
+    type: IntegrationType.datadog;
+    configuration: DatadogIntegrationConfiguration;
+}
+export interface NewRelicIntegration extends BaseIntegration {
+    type: IntegrationType.newrelic;
+    configuration: NewRelicIntegrationConfiguration;
+}
+export type DatadogRegion = 'us1' | 'us3' | 'us5' | 'eu1' | 'us1-fed';
+export declare const datadogRegionMap: Record<DatadogRegion, string>;
+export interface DatadogIntegrationConfiguration {
+    apiKey: string;
+    appKey: string;
+    datadogRegion: DatadogRegion;
+}
+export type NewRelicRegion = 'worldwide' | 'eu';
+export declare const newRelicRegionMap: Record<NewRelicRegion, string>;
+export interface NewRelicIntegrationConfiguration {
+    apiKey: string;
+    newRelicRegion: NewRelicRegion;
+}
 export interface BaseDataIntegration extends BaseIntegration {
     schema?: IntegrationDataSchema;
     supportsExternalChanges: boolean;
@@ -95,25 +141,41 @@ export declare function isDataIntegrationType(type: IntegrationType): boolean;
 export type HttpMethod = 'post' | 'get' | 'delete' | 'patch' | 'put';
 export type ApiEndpointId = string;
 export type ApiParameterLocation = 'query' | 'body' | 'header' | 'path';
+export type ApiResponseParameterLocation = 'header' | 'body';
+export type ApiInjectionParameterLocation = 'header';
 export type FieldPath = string;
 export interface ApiRequestField {
-    paramLocation?: ApiParameterLocation;
-    fieldNameInRequest?: FieldName;
+    location: ApiParameterLocation;
 }
 export interface ApiResponseField {
-    paramLocation: 'body' | 'header';
-    fieldPathInResponse?: FieldPath;
+    location: ApiResponseParameterLocation;
+    path?: FieldPath;
+}
+export type ApiInjectionFieldType = 'secret' | 'regular';
+export interface ApiInjectionField {
+    value: string;
+    type: ApiInjectionFieldType;
+    location: ApiInjectionParameterLocation;
 }
 export interface ApiEndpoint {
     relativePath: string;
     method: HttpMethod;
     requestSchema?: Record<FieldName, ApiRequestField>;
     responseSchema?: Record<FieldPath, ApiResponseField>;
+    injectionSchema?: Record<FieldName, ApiInjectionField>;
+}
+export interface BaseApiIntegration extends BaseIntegration {
+    type: IntegrationType.api | IntegrationType.openapi;
+    schema: IntegrationApiSchema;
 }
-export interface ApiIntegration extends BaseIntegration {
+export interface ApiIntegration extends BaseApiIntegration {
     type: IntegrationType.api;
-    baseUrl: string;
-    endpoints: IntegrationApiEndpoints;
+}
+export interface OpenApiIntegration extends BaseApiIntegration {
+    type: IntegrationType.openapi;
+    configuration: {
+        discoveryOptions: OpenApiDiscoveryOptions;
+    };
 }
 export interface GraphQLIntegration extends BaseIntegration {
     type: IntegrationType.graphql;
@@ -134,6 +196,9 @@ export interface PostgresIntegrationConfiguration {
 export interface MongoIntegrationConfiguration {
     connectionOptions: MongoConnectionOptions;
 }
+export interface SnowflakeIntegrationConfiguration {
+    connectionOptions: SnowflakeConnectionOptions;
+}
 export interface MySqlIntegration extends BaseDataIntegration {
     type: IntegrationType.mysql;
     configuration: MySqlIntegrationConfiguration;
@@ -167,6 +232,11 @@ export interface MongoIntegration extends BaseDataIntegration {
     configuration: MongoIntegrationConfiguration;
     supportsExternalChanges: true;
 }
+export interface SnowflakeIntegration extends BaseDataIntegration {
+    type: IntegrationType.snowflake;
+    configuration: SnowflakeIntegrationConfiguration;
+    schema: IntegrationDataSchema;
+}
 export interface InternalIntegration extends BaseDataIntegration {
     type: IntegrationType.built_in_db;
 }
@@ -198,19 +268,28 @@ interface TestPostgresDataConnectionRequest {
         connectionOptions: PostgresConnectionOptions;
     };
 }
+interface TestSnowflakeDataConnectionRequest {
+    type: IntegrationType.snowflake;
+    configuration: {
+        connectionOptions: SnowflakeConnectionOptions;
+    };
+}
 interface TestCockroachDataConnectionRequest {
     type: IntegrationType.cockroach;
     configuration: {
         connectionOptions: PostgresConnectionOptions;
     };
 }
-export type TestDataConnectionRequest = TestMongoDataConnectionRequest | TestMysqlDataConnectionRequest | TestMssqlDataConnectionRequest | TestCockroachDataConnectionRequest | TestPostgresDataConnectionRequest;
+export type TestDataConnectionRequest = TestMongoDataConnectionRequest | TestMysqlDataConnectionRequest | TestMssqlDataConnectionRequest | TestCockroachDataConnectionRequest | TestPostgresDataConnectionRequest | TestSnowflakeDataConnectionRequest;
 export interface DiscoverDataConnectionSchemaResponse {
     schema: IntegrationDataSchema;
 }
 export interface DiscoverGraphQLConnectionSchemaResponse {
     schema: IntegrationGraphQLSchema;
 }
+export interface DiscoverOpenApiSchemaResponse {
+    schema: IntegrationApiSchema;
+}
 interface DiscoverMongoDataConnectionSchemaRequest {
     integrationType: IntegrationType.mongo;
     connectionOptions: MongoConnectionOptions;
@@ -226,24 +305,25 @@ interface DiscoverMssqlDataConnectionSchemaRequest {
     integrationType: IntegrationType.mssql;
     connectionOptions: MssqlConnectionOptions;
 }
-export interface DiscoverGraphQLConnectionSchemaRequest {
-    integrationType: IntegrationType.graphql;
-    connectionOptions: GraphQLConnectionOptions;
-}
 interface DiscoverPostgresDataConnectionSchemaRequest {
     integrationType: IntegrationType.postgres;
     connectionOptions: PostgresConnectionOptions;
 }
+interface DiscoverSnowflakeDataConnectionSchemaRequest {
+    integrationType: IntegrationType.snowflake;
+    connectionOptions: SnowflakeConnectionOptions;
+}
 interface DiscoverCockroachDataConnectionSchemaRequest {
     integrationType: IntegrationType.cockroach;
     connectionOptions: PostgresConnectionOptions;
 }
-export type DiscoverDataConnectionSchemaRequest = DiscoverMongoDataConnectionSchemaRequest | DiscoverInternalDataConnectionSchemaRequest | DiscoverMysqlDataConnectionSchemaRequest | DiscoverMssqlDataConnectionSchemaRequest | DiscoverCockroachDataConnectionSchemaRequest | DiscoverPostgresDataConnectionSchemaRequest;
-export interface DiscoverOpenApiEndpointsRequest {
-    openApiSpecUrl: string;
+export type DiscoverDataConnectionSchemaRequest = DiscoverMongoDataConnectionSchemaRequest | DiscoverInternalDataConnectionSchemaRequest | DiscoverMysqlDataConnectionSchemaRequest | DiscoverMssqlDataConnectionSchemaRequest | DiscoverCockroachDataConnectionSchemaRequest | DiscoverPostgresDataConnectionSchemaRequest | DiscoverSnowflakeDataConnectionSchemaRequest;
+export interface DiscoverGraphQLConnectionSchemaRequest {
+    integrationType: IntegrationType.graphql;
+    connectionOptions: GraphQLConnectionOptions;
 }
-export interface DiscoverOpenApiEndpointsResponse {
-    baseUrl: string;
-    endpoints: Record<ApiEndpointId, ApiEndpoint>;
+export interface DiscoverOpenApiSchemaRequest {
+    integrationType: IntegrationType.openapi;
+    discoveryOptions: OpenApiDiscoveryOptions;
 }
 export {};

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

@@ -5,7 +5,6 @@ export interface Logger {
     info(message: string, context?: LoggerContext): void;
     warn(message: string, context?: LoggerContext): void;
     error(message: string, context?: LoggerContext): void;
-    child(context: LoggerContext): Logger;
     log(record: LogRecord): void;
 }
 export declare enum LogLevel {

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

@@ -1,65 +1,58 @@
-export type MetricRate = string;
-export type MetricResolution = string;
-export type MetricTimeWindow = {
-    startTimeMs: number;
-    endTimeMs: number;
-};
-export type MetricType = 'latency' | 'successful' | 'failure' | 'total';
-export type MetricUnit = 'millisecond' | 'count';
-export type MetricGroupName = 'backendBootstrap' | 'backendFunctionCall' | 'integrationConnectAttempt' | 'integrationReadOperation' | 'integrationWriteOperation';
-/**
- * Filter key descriptions:
- * - `functionName` - Only supported by 'backendFunctionCall' metric. The name of the function.
- * - `integrationId` - Only supported by `integration*` metrics. The id of the integration.
- * - `resultType` - Only supported by all metrics. The result of the operation being either 'success' or 'failure'.
- */
-export type MetricFilterKey = 'functionName' | 'integrationId' | 'resultType';
-/**
- * Internal filters are automatically assigned and are not configurable through the open API.
- */
-export type MetricInternalFilterKey = MetricFilterKey | 'appId' | 'operationType';
-export type MetricFilterValue = string | number | boolean;
-export type MetricFilterOperationType = 'read' | 'write';
-export type MetricFilterResultType = 'success' | 'failure';
-export type MetricInternalFilters = MetricFilters<MetricInternalFilterKey> & {
-    operationType?: MetricFilterOperationType;
-};
-export type MetricFilters<T extends string> = {
-    [key in T]?: MetricFilterValue;
-} & {
-    resultType?: MetricFilterResultType;
-};
-export interface MetricRequest {
-    summary?: boolean;
-    histogram?: {
-        rate: MetricRate;
-        resolution: MetricResolution;
-    };
+export type MetricType = 'count' | 'gauge';
+export type AggregationPeriod = '1m' | '5m' | '15m' | '1h' | '1d' | '1w';
+export declare const aggregationPeriodMap: Record<AggregationPeriod, number>;
+export interface CountMetricHistogramData {
+    stepInterval: number;
+    sumInStep: number;
+    cumulativeSum: number;
+    rate: number;
 }
-export interface GetMetricDataRequest {
-    requests: Array<{
-        filters: MetricFilters<MetricFilterKey>;
-        metricGroup: MetricGroupName;
-        metrics: {
-            [key in MetricType]?: MetricRequest;
-        };
-    }>;
-    timeWindow: MetricTimeWindow;
+export interface CountMetricSummary {
+    cumulativeRate: number;
+    cumulativeSum: number;
 }
-export type MetricHistogram = Array<{
-    timestamp: Date;
-    value: number;
-}>;
-export type MetricResponse = {
-    unit: MetricUnit;
-    summary?: number;
-    histogram?: MetricHistogram;
-};
-export type GetMetricDataResponse = {
-    results: Array<{
-        metricGroup: MetricGroupName;
-        metrics: {
-            [key in MetricType]?: MetricResponse;
-        };
-    }>;
-};
+export interface GaugeMetricHistogramData {
+    stepInterval: number;
+    sumInStep: number;
+    countInStep: number;
+    minInStep: number;
+    maxInStep: number;
+    avgInStep: number;
+    medianInStep: number;
+}
+export interface GaugeMetricSummary {
+    cumulativeSum: number;
+    cumulativeMin: number;
+    cumulativeMax: number;
+    cumulativeAvg: number;
+    cumulativeCount: number;
+}
+interface BaseMetricResponse {
+    type: MetricType;
+}
+export interface CountMetricResponse extends BaseMetricResponse {
+    type: 'count';
+    histogram: Array<CountMetricHistogramData>;
+    summary: CountMetricSummary;
+}
+export interface GaugeMetricResponse extends BaseMetricResponse {
+    type: 'gauge';
+    histogram: Array<GaugeMetricHistogramData>;
+    summary: GaugeMetricSummary;
+}
+export type MetricResponse = CountMetricResponse | GaugeMetricResponse;
+export interface GetSingleMetricRequest {
+    metricName: string;
+    tagFilters: Record<string, string | Array<string>>;
+    metricType: MetricType;
+}
+export interface GetMetricsRequest {
+    requests: Array<GetSingleMetricRequest>;
+    from: number;
+    to: number;
+    aggregationPeriod: AggregationPeriod;
+}
+export interface GetMetricsResponse {
+    responses: Array<MetricResponse>;
+}
+export {};

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

@@ -5,7 +5,6 @@ export declare class MutationContext<T = any> {
     readonly mutation: Mutation<T>;
     readonly beforeAndAfterDocs: BeforeAndAfterDocs<T>;
     readonly serverTimeStamp: Date;
-    constructor(mutation: Mutation<T>, beforeAndAfterDocs: BeforeAndAfterDocs<T>, serverTimeStamp: Date);
     getMutationType(): MutationType;
     affectsPath(path: Paths<T>): boolean;
 }

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

@@ -5,7 +5,6 @@ import { PartialBy, Paths } from '../types';
 export declare class QueryContext<T = any> {
     readonly query: Query<T>;
     private readonly parsedConditions;
-    constructor(query: Query<T>);
     get integrationId(): IntegrationId;
     get collectionName(): CollectionName;
     get limit(): number;

package/dist/common/src/query/simple-query-builder.d.ts

@@ -1,14 +1,90 @@
 import { IntegrationId } from '../communication.types';
 import { CollectionName, DocumentData, FieldName, PrimitiveFieldType } from '../document.types';
 import { Operator, Query } from '../query.types';
+/** A query builder that can be used to build a query that returns a list of documents. */
 export declare class SimpleQueryBuilder<MyDocType extends DocumentData> {
     protected readonly collectionName: CollectionName;
     protected readonly integrationId: IntegrationId;
     protected readonly query: Query<MyDocType>;
-    constructor(collectionName: CollectionName, integrationId: IntegrationId);
+    /**
+     * Adds a condition to the query.
+     * @param fieldName The name of the field to query.
+     * @param operator The operator to use.
+     * @param value The value to compare against.
+     * @returns The query builder.
+     */
     where(fieldName: (keyof MyDocType & FieldName) | string, operator: Operator | 'in' | 'not in', value: PrimitiveFieldType | Array<PrimitiveFieldType>): this;
+    /**
+     * A shortcut for where(fieldName, '==', value)
+     *
+     * @param fieldName The name of the field to query.
+     * @param value The value to compare against.
+     * @returns The query builder.
+     */
+    eq(fieldName: (keyof MyDocType & FieldName) | string, value: PrimitiveFieldType): this;
+    /**
+     * A shortcut for where(fieldName, '!=', value)
+     * @param fieldName The name of the field to query.
+     * @param value The value to compare against.
+     * @returns The query builder.
+     */
+    neq(fieldName: (keyof MyDocType & FieldName) | string, value: PrimitiveFieldType): this;
+    /**
+     * A shortcut for where(fieldName, 'in', value)
+     * @param fieldName The name of the field to query.
+     * @param value An array of values to compare against.
+     * @returns The query builder.
+     */
+    in(fieldName: (keyof MyDocType & FieldName) | string, value: Array<PrimitiveFieldType>): this;
+    /**
+     * A shortcut for where(fieldName, 'not in', value)
+     * @param fieldName The name of the field to query.
+     * @param value An array of values to compare against.
+     * @returns The query builder.
+     */
+    nin(fieldName: (keyof MyDocType & FieldName) | string, value: Array<PrimitiveFieldType>): this;
+    /**
+     * A shortcut for where(fieldName, '>', value)
+     * @param fieldName The name of the field to query.
+     * @param value The value to compare against.
+     * @returns The query builder.
+     */
+    gt(fieldName: (keyof MyDocType & FieldName) | string, value: PrimitiveFieldType): this;
+    /**
+     * A shortcut for where(fieldName, '>=', value)
+     * @param fieldName The name of the field to query.
+     * @param value The value to compare against.
+     * @returns The query builder.
+     */
+    gte(fieldName: (keyof MyDocType & FieldName) | string, value: PrimitiveFieldType): this;
+    /**
+     * A shortcut for where(fieldName, '<', value)
+     * @param fieldName The name of the field to query.
+     * @param value The value to compare against.
+     * @returns The query builder.
+     */
+    lt(fieldName: (keyof MyDocType & FieldName) | string, value: PrimitiveFieldType): this;
+    /**
+     * A shortcut for where(fieldName, '<=', value)
+     * @param fieldName The name of the field to query.
+     * @param value The value to compare against.
+     *  @returns The query builder.
+     */
+    lte(fieldName: (keyof MyDocType & FieldName) | string, value: PrimitiveFieldType): this;
+    /**
+     * Sets a limit to the number of results returned by the query. The maximum limit is 1000 and this is the default if
+     * none is provided.
+     * @param limit The limit to set.
+     * @returns The query builder.
+     */
     limit(limit: number): this;
+    /**
+     * Adds a sort order to the query. You can add multiple sort orders to the query. The order in which you add them
+     * determines the order in which they are applied.
+     * @param fieldName The name of the field to sort by.
+     * @param asc Whether to sort in ascending order. Defaults to true.
+     * @returns The query builder.
+     */
     sortBy(fieldName: keyof MyDocType & FieldName, asc?: boolean): this;
-    build(): Query;
     private mergeConditions;
 }

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

@@ -1,4 +1,5 @@
 export type SquidCloudId = 'aws' | 'gcp' | 'azure';
+/** The list of supported Squid regions. */
 export type SupportedSquidRegion = 'us-east-1.aws' | 'local';
 export declare const supportedSquidRegions: Array<SupportedSquidRegion>;
 export interface SquidCloudRegion {

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

@@ -1,4 +1,6 @@
+/** The secret key, an alias for a string. */
 export type SecretKey = string;
+/** The secret value. */
 export type SecretValue = string | number | boolean;
 export type SecretTimestamp = number;
 export type ApiKeyName = string;

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

@@ -0,0 +1,3 @@
+export interface SecureNamedQueryRequest {
+    params: Record<string, any>;
+}

package/dist/common/src/utils/validation.d.ts

@@ -20,7 +20,7 @@ export declare function validateQueryLimit(limit: any): void;
 export declare function isNotEmpty(value: string | undefined | null): value is string;
 /**
  * All type names returned by 'typeof' supported by JavaScript:
- * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof.
+ * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof}.
  * and a few other supported types.
  */
 export type JavascriptTypeName = 'undefined' | 'object' | 'boolean' | 'number' | 'bigint' | 'string' | 'symbol' | 'function';