@squidcloud/backend 1.0.7 → 1.0.9

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

@@ -1,249 +0,0 @@
-import { IntegrationId } from './communication.types';
-import { FieldName } from './document.types';
-import { IntrospectionQuery } from './graphql.types';
-import { CollectionSchema } from './schema/schema.types';
-export interface MongoConnectionSecretOptions {
-    password?: string;
-}
-export interface MongoConnectionOptions {
-    secrets: MongoConnectionSecretOptions;
-    connectionString: string;
-    user?: string;
-    replicaSet?: string;
-    ssl?: {
-        certificateFile: string;
-        validate: boolean;
-    };
-    maxPoolSize?: number;
-    minPoolSize?: number;
-    socketTimeoutMS?: number;
-    serverSelectionTimeoutMS?: number;
-    keepAlive?: boolean;
-    directConnection?: boolean;
-}
-export interface MySqlConnectionSecretOptions {
-    password: string;
-}
-export interface MssqlConnectionSecretOptions {
-    password: string;
-}
-export interface PostgresConnectionSecretOptions {
-    password: string;
-    sslCertificate?: string;
-}
-export interface MySqlConnectionOptions {
-    secrets: MySqlConnectionSecretOptions;
-    host: string;
-    user: string;
-    database: string;
-    connectionLimit?: number;
-}
-export interface MssqlConnectionOptions {
-    secrets: MssqlConnectionSecretOptions;
-    host: string;
-    user: string;
-    schema: string;
-    database: string;
-    connectionLimit?: number;
-    sslEnabled?: boolean;
-}
-export interface PostgresConnectionOptions {
-    host: string;
-    user: string;
-    database: string;
-    schema?: string;
-    sslEnabled?: boolean;
-    secrets: PostgresConnectionSecretOptions;
-}
-export interface GraphQLConnectionOptions {
-    baseUrl: string;
-}
-export declare enum IntegrationType {
-    'internal' = "internal",
-    'mongo' = "mongo",
-    'mysql' = "mysql",
-    'mssql' = "mssql",
-    'postgres' = "postgres",
-    'cockroach' = "cockroach",
-    'api' = "api",
-    'graphql' = "graphql"
-}
-export type DataIntegration = MySqlIntegration | MssqlIntegration | MongoIntegration | InternalIntegration | PostgresIntegration | CockroachIntegration;
-export type Integration = DataIntegration | ApiIntegration | GraphQLIntegration;
-type TableName = string;
-export interface IntegrationDataSchema {
-    collections: Record<TableName, CollectionSchema>;
-}
-export interface IntegrationGraphQLSchema {
-    introspection: IntrospectionQuery;
-}
-export type IntegrationApiEndpoints = Record<ApiEndpointId, ApiEndpoint>;
-export type IntegrationSchema = IntegrationDataSchema | IntegrationGraphQLSchema;
-interface BaseIntegration {
-    id: IntegrationId;
-    type: IntegrationType;
-    creationDate: Date;
-    updateDate: Date;
-    secured: boolean;
-}
-export interface BaseDataIntegration extends BaseIntegration {
-    schema?: IntegrationDataSchema;
-    supportsExternalChanges: boolean;
-}
-export declare function isDataIntegration(integration: any): integration is BaseDataIntegration;
-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 FieldPath = string;
-export interface ApiRequestField {
-    paramLocation?: ApiParameterLocation;
-    fieldNameInRequest?: FieldName;
-}
-export interface ApiResponseField {
-    paramLocation: 'body' | 'header';
-    fieldPathInResponse?: FieldPath;
-}
-export interface ApiEndpoint {
-    relativePath: string;
-    method: HttpMethod;
-    requestSchema?: Record<FieldName, ApiRequestField>;
-    responseSchema?: Record<FieldPath, ApiResponseField>;
-}
-export interface ApiIntegration extends BaseIntegration {
-    type: IntegrationType.api;
-    baseUrl: string;
-    endpoints: IntegrationApiEndpoints;
-}
-export interface GraphQLIntegration extends BaseIntegration {
-    type: IntegrationType.graphql;
-    schema?: IntegrationGraphQLSchema;
-    configuration: {
-        connectionOptions: GraphQLConnectionOptions;
-    };
-}
-export interface MySqlIntegrationConfiguration {
-    connectionOptions: MySqlConnectionOptions;
-}
-export interface MssqlIntegrationConfiguration {
-    connectionOptions: MssqlConnectionOptions;
-}
-export interface PostgresIntegrationConfiguration {
-    connectionOptions: PostgresConnectionOptions;
-}
-export interface MongoIntegrationConfiguration {
-    connectionOptions: MongoConnectionOptions;
-}
-export interface MySqlIntegration extends BaseDataIntegration {
-    type: IntegrationType.mysql;
-    configuration: MySqlIntegrationConfiguration;
-    schema: IntegrationDataSchema;
-    supportsExternalChanges: true;
-}
-export interface MssqlIntegration extends BaseDataIntegration {
-    type: IntegrationType.mssql;
-    configuration: MssqlIntegrationConfiguration;
-    schema: IntegrationDataSchema;
-    supportsExternalChanges: true;
-}
-export interface BasePostgresIntegration extends BaseDataIntegration {
-    type: IntegrationType.postgres | IntegrationType.cockroach;
-    configuration: PostgresIntegrationConfiguration;
-    schema: IntegrationDataSchema;
-}
-export interface PostgresIntegration extends BasePostgresIntegration {
-    type: IntegrationType.postgres;
-    supportsExternalChanges: true;
-}
-export interface CockroachIntegration extends BasePostgresIntegration {
-    type: IntegrationType.cockroach;
-    supportsExternalChanges: false;
-}
-export interface InternalIntegration extends BaseDataIntegration {
-    type: IntegrationType.internal;
-}
-export interface MongoIntegration extends BaseDataIntegration {
-    type: IntegrationType.mongo;
-    configuration: MongoIntegrationConfiguration;
-    supportsExternalChanges: true;
-}
-export interface InternalIntegration extends BaseDataIntegration {
-    type: IntegrationType.internal;
-}
-export interface TestDataConnectionResponse {
-    success: boolean;
-    errorMessage?: string;
-}
-interface TestMongoDataConnectionRequest {
-    type: IntegrationType.mongo;
-    configuration: {
-        connectionOptions: MongoConnectionOptions;
-    };
-}
-interface TestMysqlDataConnectionRequest {
-    type: IntegrationType.mysql;
-    configuration: {
-        connectionOptions: MySqlConnectionOptions;
-    };
-}
-interface TestMssqlDataConnectionRequest {
-    type: IntegrationType.mssql;
-    configuration: {
-        connectionOptions: MssqlConnectionOptions;
-    };
-}
-interface TestPostgresDataConnectionRequest {
-    type: IntegrationType.postgres;
-    configuration: {
-        connectionOptions: PostgresConnectionOptions;
-    };
-}
-interface TestCockroachDataConnectionRequest {
-    type: IntegrationType.cockroach;
-    configuration: {
-        connectionOptions: PostgresConnectionOptions;
-    };
-}
-export type TestDataConnectionRequest = TestMongoDataConnectionRequest | TestMysqlDataConnectionRequest | TestMssqlDataConnectionRequest | TestCockroachDataConnectionRequest | TestPostgresDataConnectionRequest;
-export interface DiscoverDataConnectionSchemaResponse {
-    schema: IntegrationDataSchema;
-}
-export interface DiscoverGraphQLConnectionSchemaResponse {
-    schema: IntegrationGraphQLSchema;
-}
-interface DiscoverMongoDataConnectionSchemaRequest {
-    integrationType: IntegrationType.mongo;
-    connectionOptions: MongoConnectionOptions;
-}
-interface DiscoverInternalDataConnectionSchemaRequest {
-    integrationType: IntegrationType.internal;
-}
-interface DiscoverMysqlDataConnectionSchemaRequest {
-    integrationType: IntegrationType.mysql;
-    connectionOptions: MySqlConnectionOptions;
-}
-interface DiscoverMssqlDataConnectionSchemaRequest {
-    integrationType: IntegrationType.mssql;
-    connectionOptions: MssqlConnectionOptions;
-}
-export interface DiscoverGraphQLConnectionSchemaRequest {
-    integrationType: IntegrationType.graphql;
-    connectionOptions: GraphQLConnectionOptions;
-}
-interface DiscoverPostgresDataConnectionSchemaRequest {
-    integrationType: IntegrationType.postgres;
-    connectionOptions: PostgresConnectionOptions;
-}
-interface DiscoverCockroachDataConnectionSchemaRequest {
-    integrationType: IntegrationType.cockroach;
-    connectionOptions: PostgresConnectionOptions;
-}
-export type DiscoverDataConnectionSchemaRequest = DiscoverMongoDataConnectionSchemaRequest | DiscoverInternalDataConnectionSchemaRequest | DiscoverMysqlDataConnectionSchemaRequest | DiscoverMssqlDataConnectionSchemaRequest | DiscoverCockroachDataConnectionSchemaRequest | DiscoverPostgresDataConnectionSchemaRequest;
-export interface DiscoverOpenApiEndpointsRequest {
-    openApiSpecUrl: string;
-}
-export interface DiscoverOpenApiEndpointsResponse {
-    baseUrl: string;
-    endpoints: Record<ApiEndpointId, ApiEndpoint>;
-}
-export {};

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

@@ -1,22 +0,0 @@
-export type LoggerContext = Record<string, any>;
-export interface Logger {
-    trace(message: string, context?: LoggerContext): void;
-    debug(message: string, context?: LoggerContext): void;
-    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 {
-    TRACE = "trace",
-    DEBUG = "debug",
-    INFO = "info",
-    WARN = "warn",
-    ERROR = "error"
-}
-export interface LogRecord {
-    level?: LogLevel;
-    message?: string;
-    [key: string]: any;
-}

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

@@ -1,3 +0,0 @@
-import { JSONSchemaType } from 'ajv';
-import { GetMetricDataRequest } from './metrics.types';
-export declare const GetMetricDataRequestSchema: JSONSchemaType<GetMetricDataRequest>;

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

@@ -1,65 +0,0 @@
-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 interface GetMetricDataRequest {
-    requests: Array<{
-        filters: MetricFilters<MetricFilterKey>;
-        metricGroup: MetricGroupName;
-        metrics: {
-            [key in MetricType]?: MetricRequest;
-        };
-    }>;
-    timeWindow: MetricTimeWindow;
-}
-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;
-        };
-    }>;
-};

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

@@ -1,11 +0,0 @@
-import { Mutation, MutationType } from './mutation.types';
-import { BeforeAndAfterDocs } from './document.types';
-import { Paths } from './types';
-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/mutation.schemas.d.ts

@@ -1,5 +0,0 @@
-import { JSONSchemaType } from 'ajv';
-import { MutateRequest } from './mutation.types';
-type DocumentBase = Record<string, any>;
-export declare const MutationRequestSchema: JSONSchemaType<MutateRequest<DocumentBase>>;
-export {};

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

@@ -1,72 +0,0 @@
-import { ClientId, IntegrationId } from './communication.types';
-import { DocTimestamp, FieldName, SquidDocId, SquidDocIdObj, SquidDocument } from './document.types';
-export interface MutateRequest<T = any> {
-    clientId: ClientId;
-    integrationId: IntegrationId;
-    mutations: Array<Mutation<T>>;
-}
-export interface ExecuteMutationsResponse {
-    timestamp: DocTimestamp;
-    idResolutionMap?: IdResolutionMap;
-    afterDocs: Record<SquidDocId, SquidDocument>;
-}
-export interface MutateResponse extends Omit<ExecuteMutationsResponse, 'afterDocs'> {
-    refreshList: Array<SquidDocId>;
-}
-export type IdResolutionMap = Record<SquidDocId, SquidDocId>;
-export type Mutation<T = any> = UpdateMutation<T> | InsertMutation<T> | DeleteMutation;
-export type MutationType = 'insert' | 'update' | 'delete';
-interface BaseMutation {
-    type: MutationType;
-    squidDocIdObj: SquidDocIdObj;
-}
-export interface DeleteMutation extends BaseMutation {
-    type: 'delete';
-}
-export interface UpdateMutation<T = any> extends BaseMutation {
-    type: 'update';
-    properties: {
-        [key in keyof T & string]?: Array<PropertyMutation<T[key]>>;
-    };
-}
-export interface InsertMutation<T = any> extends BaseMutation {
-    type: 'insert';
-    properties: T;
-}
-export type PropertyMutation<Value = any> = ApplyNumericFnPropertyMutation | ApplyStringFnPropertyMutation | ValueUpdatePropertyMutation<Value> | RemovePropertyMutation;
-export interface ValueUpdatePropertyMutation<Value = any> {
-    type: 'update';
-    value: Value;
-}
-export interface ApplyNumericFnPropertyMutation {
-    type: 'applyNumericFn';
-    fn: 'increment';
-    value: number;
-}
-export interface RemovePropertyMutation {
-    type: 'removeProperty';
-}
-interface ApplyExtendString {
-    type: 'applyStringFn';
-    fn: 'extendString';
-    value: string;
-}
-interface ApplyTrimString {
-    type: 'applyStringFn';
-    fn: 'trim';
-}
-export type ApplyStringFnPropertyMutation = ApplyExtendString | ApplyTrimString;
-/**
- * Sorts the update mutation properties in the order the properties should be applied. If the update mutation has
- * updates for both 'a' and 'a.b', the update should be applied first to 'a' and then to 'a.b'.
- */
-export declare function sortUpdateMutationProperties(updateMutation: UpdateMutation): Array<[FieldName, Array<PropertyMutation>]>;
-export declare function mergeMutations(mutationA: Mutation, mutationB: Mutation): Mutation;
-export declare function applyUpdateMutation<T extends SquidDocument>(doc: T, updateMutation: UpdateMutation<T>): T | undefined;
-export declare function convertInsertToUpdate(insertMutation: InsertMutation): UpdateMutation;
-/**
- * Reduces the list of mutations such that each document will have a single mutation. If for example there are multiple
- * updates to the same document, those will be merged and a single update will be returned.
- */
-export declare function reduceMutations(mutations: Array<Mutation<unknown>>): Array<Mutation<unknown>>;
-export {};

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

@@ -1,4 +0,0 @@
-export declare class NamedQueryContext {
-    readonly params: Record<string, any>;
-    constructor(params: Record<string, any>);
-}

package/dist/common/src/named-query.schemas.d.ts

@@ -1,3 +0,0 @@
-import { JSONSchemaType } from 'ajv';
-import { ExecuteNamedQueryRequest } from './named-query.types';
-export declare const ExecuteNamedQueryRequestSchema: JSONSchemaType<ExecuteNamedQueryRequest>;

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

@@ -1,9 +0,0 @@
-import { ClientId, ClientRequestId, IntegrationId } from './communication.types';
-import { QueryName } from './application.types';
-export interface ExecuteNamedQueryRequest {
-    integrationId: IntegrationId;
-    queryName: QueryName;
-    paramsRecordStr: string;
-    clientRequestId: ClientRequestId;
-    clientId: ClientId;
-}

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

@@ -1,2 +0,0 @@
-export * from './query-context';
-export * from './simple-query-builder';

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

@@ -1,38 +0,0 @@
-import { IntegrationId } from '../communication.types';
-import { CollectionName, FieldName } from '../document.types';
-import { AllOperators, ContextCondition, ContextConditions, FieldSort, GeneralCondition, GeneralConditions, GenericValue, Query } from '../query.types';
-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;
-    sortedBy(sorts: Array<PartialBy<FieldSort<T>, 'asc'>>): boolean;
-    sortedByExact(sorts: Array<PartialBy<FieldSort<T>, 'asc'>>): boolean;
-    includes<F extends FieldName<T>, O extends AllOperators>(fieldName: F, operator: O, value: GenericValue<T, F, O>): boolean;
-    includesCondition(condition: ContextCondition<T>): boolean;
-    includesConditions(conditions: GeneralConditions<T>): boolean;
-    matchesConditions(conditions: GeneralConditions<T>): boolean;
-    matchesQuery(query: Query<T>): boolean;
-    isSubsetOf<F extends FieldName<T>, O extends AllOperators>(fieldName: F, operator: O, value: GenericValue<T, F, O> | null): boolean;
-    isSubsetOfCondition(condition: GeneralCondition<T>): boolean;
-    isSubsetOfConditions(conditions: GeneralConditions<T>): boolean;
-    isSubsetOfQuery(query: Query<T>): boolean;
-    getConditionsFor<K extends FieldName<T>>(...fieldNames: K[]): ContextConditions<T, K>;
-    getConditionsForField<K extends Paths<T>>(fieldName: K): ContextConditions<T>;
-    /**
-     * Compares a condition against a given operator and value to determine if the
-     * provided condition is a subset of the operator and value. A condition is
-     * considered a subset if all values that satisfy (return true for) the
-     * condition also satisfy the operator and value.
-     *
-     * This is done using the underlying CompareTable, which provides a comparison
-     * function for each operator pair, or undefined if the comparison would
-     * always be false, regardless of the values.
-     */
-    private evaluateSubset;
-    private evaluateIncludes;
-    private parseConditions;
-}

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

@@ -1,14 +0,0 @@
-import { IntegrationId } from '../communication.types';
-import { CollectionName, DocumentData, FieldName, PrimitiveFieldType } from '../document.types';
-import { Operator, Query } from '../query.types';
-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);
-    where(fieldName: (keyof MyDocType & FieldName) | string, operator: Operator | 'in' | 'not in', value: PrimitiveFieldType | Array<PrimitiveFieldType>): this;
-    limit(limit: number): this;
-    sortBy(fieldName: keyof MyDocType & FieldName, asc?: boolean): this;
-    build(): Query;
-    private mergeConditions;
-}

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

@@ -1,5 +0,0 @@
-import { JSONSchemaType } from 'ajv';
-import { Query, QueryRequest, QueryUnsubscribeRequest } from './query.types';
-export declare const QuerySchema: JSONSchemaType<Query>;
-export declare const QueryRequestSchema: JSONSchemaType<QueryRequest>;
-export declare const QueryUnsubscribeRequestSchema: JSONSchemaType<QueryUnsubscribeRequest>;

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

@@ -1,118 +0,0 @@
-import { TriggerId } from './application.types';
-import { AppId, ClientId, ClientRequestId, IntegrationId } from './communication.types';
-import { CollectionName, FieldName, PrimitiveFieldType, SquidDocument } from './document.types';
-export type Conditions<Doc = any, F extends FieldName<Doc> = any> = Array<Condition<Doc, F>>;
-export interface Condition<Doc = any, F extends FieldName<Doc> = any> {
-    fieldName: F;
-    operator: Operator;
-    value: Doc[F] | null;
-}
-export type Operator = '==' | '>=' | '<=' | '>' | '<' | '!=';
-export type ContextConditions<Doc = any, F extends FieldName<Doc> = any> = Array<ContextCondition<Doc, F>>;
-export type GenericValue<Doc = any, F extends FieldName<Doc> = any, O extends AllOperators = any> = O extends 'in' ? Array<Doc[F]> | null : O extends 'not in' ? Array<Doc[F]> | null : Doc[F] | null;
-export type ContextCondition<Doc = any, F extends FieldName<Doc> = any> = InContextCondition<Doc, F> | NotInContextCondition<Doc, F> | OtherContextCondition<Doc, F>;
-interface InContextCondition<Doc = any, F extends FieldName<Doc> = any> extends Omit<Condition<Doc, F>, 'operator' | 'value'> {
-    operator: 'in';
-    value: Array<Doc[F]>;
-}
-interface NotInContextCondition<Doc = any, F extends FieldName<Doc> = any> extends Omit<Condition<Doc, F>, 'operator' | 'value'> {
-    operator: 'not in';
-    value: Array<Doc[F]>;
-}
-interface OtherContextCondition<Doc = any, F extends FieldName<Doc> = any> extends Omit<Condition<Doc, F>, 'operator'> {
-    operator: Exclude<ContextOperator, 'in' | 'not in'>;
-}
-export interface GeneralCondition<Doc = any, F extends FieldName<Doc> = any> extends Omit<Condition<Doc, F>, 'operator' | 'value'> {
-    operator: AllOperators;
-    value: any;
-}
-export type GeneralConditions<Doc = any, F extends FieldName<Doc> = any> = Array<GeneralCondition<Doc, F>>;
-export type ContextOperator = Exclude<Operator, '==' | '!='> | 'in' | 'not in';
-export type AllOperators = Operator | 'in' | 'not in';
-export interface FieldSort<Doc> {
-    fieldName: FieldName<Doc>;
-    asc: boolean;
-}
-interface RegularQueryKey {
-    queryType: 'query';
-    clientId: string;
-    clientRequestId: string;
-}
-interface TriggerKey {
-    queryType: 'trigger';
-    triggerId: TriggerId;
-}
-export type QueryKey = RegularQueryKey | TriggerKey;
-export interface Query<Doc = any> {
-    collectionName: CollectionName;
-    integrationId: string;
-    conditions: Conditions<Doc>;
-    sortOrder: Array<FieldSort<Doc>>;
-    limit: number;
-}
-export type QuerySubscriptionId = `${ClientId}_${ClientRequestId}`;
-export interface QueryRequest {
-    clientId: ClientId;
-    clientRequestId: ClientRequestId;
-    query: Query;
-    subscribe: boolean;
-}
-export interface QueryUnsubscribeRequest {
-    clientId: ClientId;
-    clientRequestId: ClientRequestId;
-}
-interface QueryMetadata {
-    condCount: number;
-}
-/**
- * Example query mapping:
- * {
- *   unconditional: ['cid_123'],
- *   conditional: {
- *     age: {
- *       '==': {
- *         10: ['cid2_321'],
- *         11: ['cid2_321'],
- *         12: ['cid2_321'],
- *       },
- *       '>': {
- *         20: ['cid_456']
- *       }
- *     }
- *   },
- *   queriesMetadata: {
- *     'cid_123': {
- *       condCount: 0
- *     },
- *     'cid2_321': {
- *       condCount: 1
- *     },
- *     'cid2_456': {
- *       condCount: 1
- *     }
- *   }
- * }
- */
-export type QueryMapping<T extends string> = {
-    unconditional: Array<T>;
-    conditional: Record<FieldName, Record<Operator, Record<PrimitiveFieldType & string, Array<T>>>>;
-    queriesMetadata: Record<T, QueryMetadata>;
-};
-export declare abstract class QueryMappingManager<T> {
-    abstract addQuery(appId: AppId, query: Query, key: T): Promise<void>;
-    abstract removeQuery(appId: AppId, key: T): Promise<Query | undefined>;
-    abstract findQueriesForDocument(appId: AppId, doc: SquidDocument, collectionName: CollectionName, integrationId: IntegrationId): Promise<Array<T> | undefined>;
-}
-export declare abstract class SimpleQueryMappingManager<T extends string> extends QueryMappingManager<T> {
-    abstract getMapping(appId: AppId, collectionName: CollectionName, integrationId: IntegrationId): Promise<QueryMapping<T> | undefined> | (QueryMapping<T> | undefined);
-    findQueriesForDocument(appId: AppId, doc: SquidDocument, collectionName: CollectionName, integrationId: IntegrationId): Promise<Array<T>>;
-}
-export declare function findQueriesForDocumentSync<T extends string>(mapping: QueryMapping<T>, doc: SquidDocument): Array<T>;
-export declare function compareOperator(conditionValue: PrimitiveFieldType, valueInDocument: PrimitiveFieldType, operator: Operator): boolean;
-/** Returns a unique identifier for the query which includes both the client id and the client request id. */
-export declare function getQuerySubscriptionId(clientId: string, clientRequestId: string): QuerySubscriptionId;
-export declare function parseQuerySubscriptionId(querySubscriptionId: QuerySubscriptionId): {
-    clientId: string;
-    clientRequestId: string;
-};
-export {};

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

@@ -1,17 +0,0 @@
-export type SquidCloudId = 'aws' | 'gcp' | 'azure';
-export type SupportedSquidRegion = 'us-east-1.aws' | 'local';
-export declare const supportedSquidRegions: Array<SupportedSquidRegion>;
-export interface SquidCloudRegion {
-    id: string;
-    name: string;
-}
-export interface SquidSupportedCloud {
-    id: SquidCloudId;
-    name: string;
-    icon: string;
-    regions: Array<SquidCloudRegion>;
-    tooltip?: string;
-}
-export declare const squidSupportedCloudMap: Record<SquidCloudId, SquidSupportedCloud>;
-export declare function convertToSquidRegion(cloudId: SquidCloudId, region: string, isDev?: boolean): SupportedSquidRegion;
-export declare const squidSupportedClouds: Array<SquidSupportedCloud>;