@squidcloud/backend 1.0.0 → 1.0.2

package/dist/backend/src/service.d.ts

@@ -1,10 +1,17 @@
 import { Squid } from '@squidcloud/client';
-import { Logger, RunContext, SecretKey, SecretValue, ServiceConfig } from '@squidcloud/common';
+import { AuthWithApiKey, AuthWithBearer, Logger, RunContext, SecretKey, SecretValue, ServiceConfig, SquidRegion } from '@squidcloud/common';
 export declare class SquidService {
     readonly secrets: Record<SecretKey, SecretValue>;
     readonly logger: Logger;
     private readonly backendApiKey;
     readonly context: RunContext;
+    readonly codeDir: string;
+    readonly region: SquidRegion;
+    private readonly auth;
     constructor(config: ServiceConfig);
     get squid(): Squid;
+    get assetsDirectory(): string;
+    getUserAuth(): AuthWithBearer | undefined;
+    getApiKeyAuth(): AuthWithApiKey | undefined;
+    isAuthenticated(): boolean;
 }

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

@@ -0,0 +1,17 @@
+import { ApiEndpoint, ApiEndpointId, ApiIntegration } from './integration.types';
+interface ApiRequest {
+    endpointId: ApiEndpointId;
+    endpoint: ApiEndpoint;
+    apiIntegration: ApiIntegration;
+    request: Record<string, any>;
+    serverUrlOverride: string | undefined;
+}
+export declare class ApiCallContext {
+    readonly endpointId: ApiEndpointId;
+    readonly endpoint: ApiEndpoint;
+    readonly apiIntegration: ApiIntegration;
+    readonly serverUrlOverride: string | undefined;
+    readonly request: Record<string, any>;
+    constructor(apiRequest: ApiRequest);
+}
+export {};

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, MongoConnectionSecretOptions, MssqlConnectionSecretOptions, MySqlConnectionSecretOptions, PostgresConnectionSecretOptions } from './integration.types';
+import { ApiEndpoint, ApiEndpointId, GraphQLConnectionOptions, Integration, IntegrationDataSchema, IntegrationGraphQLSchema, IntegrationType, MongoConnectionOptions, MssqlConnectionOptions, MySqlConnectionOptions, PostgresConnectionOptions } from './integration.types';
 export type WebhookId = string;
 export type QueryName = string;
 export type TriggerId = string;
@@ -33,6 +33,7 @@ export interface Application {
     allowedHosts: string[];
     openIdProvider?: OpenIdProvider;
     integrations: Record<IntegrationId, Integration>;
+    codeUrl?: string;
     bundleMetadata?: ApplicationBundleData;
 }
 export interface UpdateOpenIdProviderRequest {
@@ -41,7 +42,8 @@ export interface UpdateOpenIdProviderRequest {
 export interface CreateApplicationResponse {
     appId: AppId;
 }
-export type UpsertIntegrationRequest = UpsertMongoDbIntegrationRequest | UpsertMssqlIntegrationRequest | UpsertMySqlIntegrationRequest | UpsertPostgresIntegrationRequest | UpsertCockroachIntegrationRequest | UpsertGraphQLIntegrationRequest | UpsertApiIntegrationRequest;
+export type UpsertIntegrationRequest = UpsertDataIntegrationRequest | UpsertGraphQLIntegrationRequest | UpsertApiIntegrationRequest;
+export type UpsertDataIntegrationRequest = UpsertInternalIntegrationRequest | UpsertMongoDbIntegrationRequest | UpsertMssqlIntegrationRequest | UpsertMySqlIntegrationRequest | UpsertPostgresIntegrationRequest | UpsertCockroachIntegrationRequest;
 interface BaseUpsertIntegrationRequest {
     id: IntegrationId;
     type: IntegrationType;
@@ -50,53 +52,43 @@ interface BaseUpsertIntegrationRequest {
 interface BaseUpsertDataIntegrationRequest extends BaseUpsertIntegrationRequest {
     supportsExternalChanges?: boolean;
 }
+export interface UpsertInternalIntegrationRequest extends BaseUpsertDataIntegrationRequest {
+    type: IntegrationType.internal;
+    schema?: IntegrationDataSchema;
+}
 export interface UpsertMongoDbIntegrationRequest extends BaseUpsertDataIntegrationRequest {
     type: IntegrationType.mongo;
     schema?: IntegrationDataSchema;
     configuration: {
-        connectionOptions: {
-            secrets: MongoConnectionSecretOptions;
-            ssl?: {
-                certificateFile: string;
-                validate: boolean;
-            };
-        };
+        connectionOptions: MongoConnectionOptions;
     };
 }
 export interface UpsertMySqlIntegrationRequest extends BaseUpsertDataIntegrationRequest {
     type: IntegrationType.mysql;
     schema?: IntegrationDataSchema;
     configuration: {
-        connectionOptions: {
-            secrets: MySqlConnectionSecretOptions;
-        };
+        connectionOptions: MySqlConnectionOptions;
     };
 }
 export interface UpsertMssqlIntegrationRequest extends BaseUpsertDataIntegrationRequest {
     type: IntegrationType.mssql;
     schema?: IntegrationDataSchema;
     configuration: {
-        connectionOptions: {
-            secrets: MssqlConnectionSecretOptions;
-        };
+        connectionOptions: MssqlConnectionOptions;
     };
 }
 export interface UpsertPostgresIntegrationRequest extends BaseUpsertDataIntegrationRequest {
     type: IntegrationType.postgres;
     schema?: IntegrationDataSchema;
     configuration: {
-        connectionOptions: {
-            secrets: PostgresConnectionSecretOptions;
-        };
+        connectionOptions: PostgresConnectionOptions;
     };
 }
 export interface UpsertCockroachIntegrationRequest extends BaseUpsertDataIntegrationRequest {
     type: IntegrationType.cockroach;
     schema?: IntegrationDataSchema;
     configuration: {
-        connectionOptions: {
-            secrets: PostgresConnectionSecretOptions;
-        };
+        connectionOptions: PostgresConnectionOptions;
     };
 }
 export interface UpsertGraphQLIntegrationRequest extends BaseUpsertIntegrationRequest {

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

@@ -0,0 +1,60 @@
+import { Auth, RunContext } from './context.types';
+import { ServiceFunctionName } from './bundle-data.types';
+import { SecretKey, SecretValue } from './secret.types';
+export interface RunPermissions {
+    hosts: Array<string>;
+}
+export interface ErrorResponse extends GeneralResponse {
+    ok: false;
+    error: string;
+    details?: string;
+}
+export interface GeneralResponse {
+    ok: boolean;
+}
+export interface RunConfiguration {
+    codeUrl: string;
+    codeUrlId: string;
+    isSecurityRules: boolean;
+    permissions: RunPermissions;
+}
+export interface RunConfigurationRequest {
+    configuration: RunConfiguration;
+    context: RunContext;
+    auth: Auth | undefined;
+    functionToRun: string;
+    params: Array<unknown>;
+    secrets?: RunSecrets;
+}
+export type EvaluateRulesFunctionRequest = {
+    functionName: ServiceFunctionName;
+    params: Array<any>;
+};
+export interface LoadJsPayload {
+    codeUrl: string;
+}
+export interface ExecuteFunctionPayload {
+    functionName: string;
+    params: Array<unknown>;
+    context: RunContext;
+    auth: Auth | undefined;
+    secrets?: Record<SecretKey, SecretValue>;
+    backendApiKey: string;
+    codeDir: string;
+}
+export type WorkerActionType = 'loadJs' | 'executeFunction' | 'ping' | 'terminate';
+export interface ActionRequest {
+    action: WorkerActionType;
+    payload?: LoadJsPayload | ExecuteFunctionPayload;
+    traceContext?: any;
+}
+export type LoadJsResponse = GeneralResponse;
+export type TerminateResponse = GeneralResponse;
+export interface ExecuteFunctionResponse extends GeneralResponse {
+    ok: true;
+    functionResponse: unknown;
+}
+export interface RunSecrets {
+    custom: Record<SecretKey, SecretValue>;
+    backendApiKey: string;
+}

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

@@ -1,15 +1,18 @@
 import { ActionType } from './bundle-data.types';
-import { DocType, FullDocIdStr, UserFacingDocType } from './document.types';
-import { ApiEndpoint, ApiEndpointId, ApiIntegration } from './integration.types';
-import { Mutation, MutationType } from './mutation.types';
-import { RunContext } from './context.types';
+import { Auth, RunContext } from './context.types';
+import { DocumentData, SquidDocId, SquidDocument } from './document.types';
 import { Logger } from './logger.types';
-import { SecretKey } from './secret.types';
-import { QueryContext } from './query';
 import { MutationContext } from './mutation.context';
+import { Mutation, MutationType } from './mutation.types';
+import { QueryContext } from './query';
+import { SecretKey } from './secret.types';
+import { ExecutableContext } from './executable.context';
+import { ApiCallContext } from './api-call.context';
+import { NamedQueryContext } from './named-query.context';
+import { GraphqlContext } from './graphql.context';
 export type DocHash = string;
 export type SecurityResponse = {
-    docsToHash: Record<FullDocIdStr, DocHash | undefined>;
+    docsToHash: Record<SquidDocId, DocHash | undefined>;
     rulesPassed: true;
 } | {
     rulesPassed: false;
@@ -19,50 +22,27 @@ export interface ServiceConfig {
     logger: Logger;
     secrets: Record<SecretKey, any>;
     backendApiKey: string;
+    codeDir: string;
+    auth: Auth | undefined;
 }
-export type SecureDatabaseAction<T extends ActionType> = T extends 'all' ? () => boolean | Promise<boolean> : T extends 'read' ? (request?: SecureDatabaseReadRequest) => boolean | Promise<boolean> : (request?: SecureDatabaseWriteRequest) => boolean | Promise<boolean>;
-export interface SecureDatabaseReadRequest<T = any> {
-    queryContext: QueryContext<T>;
-}
-export interface SecureDatabaseWriteRequest<T extends UserFacingDocType = any> {
-    mutationContext: MutationContext<T>;
-}
-export type SecureApiAction = (request?: SecureApiRequest) => boolean | Promise<boolean>;
-export interface SecureApiRequest {
-    endpointId: ApiEndpointId;
-    endpoint: ApiEndpoint;
-    apiIntegration: ApiIntegration;
-    request: Record<string, any>;
-    serverUrlOverride: string | undefined;
-}
-export type SecureExecutableAction = (request?: SecureExecutableRequest) => boolean | Promise<boolean>;
-export interface SecureExecutableRequest {
-    params: any[];
-}
-export type SecureNamedQueryAction = (request?: SecureNamedQueryRequest) => boolean | Promise<boolean>;
-export interface SecureNamedQueryRequest {
-    params: Record<string, any>;
-}
-export type SecureGraphQLAction = (request?: SecureGraphQLRequest) => boolean | Promise<boolean>;
-export interface SecureGraphQLRequest {
-    isGraphiQL: boolean;
-    query?: string;
-    operationName?: string;
-    variables?: string | Record<string, any>;
-}
+export type SecureDatabaseAction<T extends ActionType> = T extends 'all' ? () => boolean | Promise<boolean> : T extends 'read' ? (context?: QueryContext) => boolean | Promise<boolean> : (context?: MutationContext) => boolean | Promise<boolean>;
+export type SecureApiAction = (context?: ApiCallContext) => boolean | Promise<boolean>;
+export type SecureExecutableAction = (context?: ExecutableContext) => boolean | Promise<boolean>;
+export type SecureNamedQueryAction = (context?: NamedQueryContext) => boolean | Promise<boolean>;
+export type SecureGraphQLAction = (context?: GraphqlContext) => boolean | Promise<boolean>;
 export type TransformDatabaseAction<T extends ActionType> = T extends 'read' ? (request?: TransformDatabaseReadRequest) => TransformDatabaseReadResponse | Promise<TransformDatabaseReadResponse> : (request?: TransformDatabaseWriteRequest) => TransformDatabaseWriteResponse | Promise<TransformDatabaseWriteResponse>;
 export interface TransformDatabaseReadRequest {
-    documents: Array<DocType>;
+    documents: Array<SquidDocument>;
 }
 export interface TransformDatabaseWriteRequest {
     mutations: Array<Mutation>;
 }
-export type TransformDatabaseReadResponse = Array<DocType>;
+export type TransformDatabaseReadResponse = Array<SquidDocument>;
 export type TransformDatabaseWriteResponse = Array<Mutation>;
 export type ExecutableAction = (...args: any[]) => any;
 export type TriggerAction = (request?: TriggerRequest) => void | Promise<void>;
-export interface TriggerRequest<T extends UserFacingDocType = any> {
-    fullDocId: FullDocIdStr;
+export interface TriggerRequest<T extends DocumentData = any> {
+    squidDocId: SquidDocId;
     mutationType: MutationType;
     docBefore?: T;
     docAfter?: T;

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

@@ -18,5 +18,4 @@ export interface RunContext {
     appId: string;
     sourceIp?: string;
     headers?: Record<string, any>;
-    auth?: Auth;
 }

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

@@ -8,22 +8,22 @@ export type DocId = string;
 export type DocIdObj = Record<FieldName, any>;
 export type CollectionName = string;
 export type DocTimestamp = number;
-export interface FullDocId {
+export interface SquidDocIdObj {
     collectionName: CollectionName;
     docId: DocId;
     integrationId: IntegrationId;
 }
-export interface BeforeAndAfterDocs<T = DocType> {
+export interface BeforeAndAfterDocs<T = SquidDocument> {
     before: T | undefined;
     after: T | undefined;
 }
-export type FullDocIdStr = string;
-export interface DocType {
+export type SquidDocId = string;
+export interface SquidDocument {
     __docId__: DocId;
     __ts__: DocTimestamp;
     [fieldName: string]: FieldType | undefined;
 }
-export type UserFacingDocType = Record<FieldName, any | undefined>;
-export declare function parseFullDocId(fullDocIdStr: FullDocIdStr): FullDocId;
-export declare function getFullDocIdStr(fullDocId: FullDocId): FullDocIdStr;
-export declare function getFullDocIdStr(docId: DocId, collectionName: CollectionName, integrationId: IntegrationId): FullDocIdStr;
+export type DocumentData = Record<FieldName, any | undefined>;
+export declare function parseSquidDocId(squidDocId: SquidDocId): SquidDocIdObj;
+export declare function getSquidDocId(squidDocIdObj: SquidDocIdObj): SquidDocId;
+export declare function getSquidDocId(docId: DocId, collectionName: CollectionName, integrationId: IntegrationId): SquidDocId;

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

@@ -0,0 +1,4 @@
+export declare class ExecutableContext<F extends (...args: any[]) => any = (...args: any[]) => any> {
+    readonly params: Parameters<F>;
+    constructor(params: Parameters<F>);
+}

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

@@ -0,0 +1,14 @@
+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/index.d.ts

@@ -3,8 +3,6 @@ export * from './application.schemas';
 export * from './application.types';
 export * from './backend-function.schemas';
 export * from './backend-function.types';
-export * from './named-query.schemas';
-export * from './named-query.types';
 export * from './bundle-api.types';
 export * from './bundle-data.types';
 export * from './communication.types';
@@ -14,14 +12,21 @@ 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 './named-query.context';
+export * from './graphql.context';
+export * from './executable.context';
+export * from './api-call.context';
 export * from './mutation.schemas';
 export * from './mutation.types';
-export * from './mutation.context';
-export * from './metrics.types';
-export * from './metrics.schemas';
+export * from './named-query.schemas';
+export * from './named-query.types';
 export * from './query';
 export * from './query.schemas';
 export * from './query.types';
+export * from './regions';
 export * from './schema/schema.types';
 export * from './secret.schemas';
 export * from './secret.types';
@@ -29,12 +34,16 @@ export * from './socket.schemas';
 export * from './socket.types';
 export * from './time-units';
 export * from './trigger.types';
+export * from './backend-run.types';
 export * from './types';
 export * from './utils/array';
 export * from './utils/assert';
+export * from './utils/error';
+export * from './utils/id';
+export * from './utils/isDefined';
 export * from './utils/lock.manager';
 export * from './utils/object';
 export * from './utils/serialization';
-export * from './utils/validation';
-export * from './utils/error';
+export * from './utils/transforms';
 export * from './utils/url';
+export * from './utils/validation';

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

@@ -77,6 +77,7 @@ export interface IntegrationDataSchema {
 export interface IntegrationGraphQLSchema {
     introspection: IntrospectionQuery;
 }
+export type IntegrationApiEndpoints = Record<ApiEndpointId, ApiEndpoint>;
 export type IntegrationSchema = IntegrationDataSchema | IntegrationGraphQLSchema;
 interface BaseIntegration {
     id: IntegrationId;
@@ -90,6 +91,7 @@ export interface BaseDataIntegration extends BaseIntegration {
     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';
@@ -111,7 +113,7 @@ export interface ApiEndpoint {
 export interface ApiIntegration extends BaseIntegration {
     type: IntegrationType.api;
     baseUrl: string;
-    endpoints: Record<ApiEndpointId, ApiEndpoint>;
+    endpoints: IntegrationApiEndpoints;
 }
 export interface GraphQLIntegration extends BaseIntegration {
     type: IntegrationType.graphql;

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

@@ -1,52 +1,65 @@
-export type MetricRate = '1m' | '5m' | '1h' | '3h' | '1d';
-export type MetricStep = string | number;
+export type MetricRate = string;
+export type MetricResolution = string;
 export type MetricTimeWindow = {
-    startTime?: number;
-    endTime?: number;
-};
-export type MetricName = 'backendBootstrapLatencySum' | 'backendFailureCount' | 'backendFailureFunctionCallCount' | 'backendSuccessFunctionCallCount' | 'backendFunctionCallCount' | 'backendFunctionCallLatencySum';
-export type MetricAggregationFunction = 'sum' | 'avg';
-export type MetricAggregation = 'none' | {
-    groupByFields: string[];
-    functionName: MetricAggregationFunction;
+    startTimeMs: number;
+    endTimeMs: number;
 };
+export type MetricType = 'latency' | 'successful' | 'failure' | 'total';
+export type MetricUnit = 'millisecond' | 'count';
+export type MetricGroupName = 'backendBootstrap' | 'backendFunctionCall' | 'integrationConnectAttempt' | 'integrationReadOperation' | 'integrationWriteOperation';
 /**
- * By default, metrics are aggregated by `avg` function so if the `aggregation`
- * is set as `null`, the `avg` aggregation function will be applied. In the case
- * _no_ aggregation is to be applied then `aggregation` must be set to `"none"`.
+ * 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 interface GetMetricDataRequest {
-    metricNames: MetricName[];
-    rate?: MetricRate;
-    step?: MetricStep;
-    timeWindow?: MetricTimeWindow;
-    aggregation?: MetricAggregation;
-}
-export type MetricQueryResultStatus = 'success' | 'error';
-export type MetricQueryResultType = 'matrix';
-export type MetricQueryDate = Date | number | string;
-export interface MetricQueryResultDataEntry<V> {
-    metric: {
-        __name__: string | undefined;
-        [key: string]: string | undefined;
+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;
     };
-    values: V;
-}
-export interface MetricQueryResultData<T extends MetricQueryResultType, V> {
-    resultType: T;
-    result: MetricQueryResultDataEntry<V>[];
 }
-export interface MetricQueryResult<T extends MetricQueryResultType, V> {
-    status: MetricQueryResultStatus;
-    data: MetricQueryResultData<T, V>;
-    errorType?: string;
-    error?: string;
-    warnings?: string;
+export interface GetMetricDataRequest {
+    requests: Array<{
+        filters: MetricFilters<MetricFilterKey>;
+        metricGroup: MetricGroupName;
+        metrics: {
+            [key in MetricType]?: MetricRequest;
+        };
+    }>;
+    timeWindow: MetricTimeWindow;
 }
-export type MetricMatrixResult = MetricQueryResult<'matrix', [number, string]>;
-export type GetMetricDataResponse<T extends MetricQueryResult<any, any>> = {
+export type MetricHistogram = Array<{
+    timestamp: Date;
+    value: number;
+}>;
+export type MetricResponse = {
+    unit: MetricUnit;
+    summary?: number;
+    histogram?: MetricHistogram;
+};
+export type GetMetricDataResponse = {
     results: Array<{
-        metricName: MetricName;
-        result: T;
+        metricGroup: MetricGroupName;
+        metrics: {
+            [key in MetricType]?: MetricResponse;
+        };
     }>;
 };

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

@@ -1,14 +1,11 @@
 import { Mutation, MutationType } from './mutation.types';
 import { BeforeAndAfterDocs } from './document.types';
 import { Paths } from './types';
-import { Auth, AuthWithBearer } from './context.types';
 export declare class MutationContext<T = any> {
     readonly mutation: Mutation<T>;
     readonly beforeAndAfterDocs: BeforeAndAfterDocs<T>;
     readonly serverTimeStamp: Date;
-    private readonly auth;
-    constructor(mutation: Mutation<T>, beforeAndAfterDocs: BeforeAndAfterDocs<T>, serverTimeStamp: Date, auth: Auth | undefined);
-    getUserAuth(): AuthWithBearer | undefined;
+    constructor(mutation: Mutation<T>, beforeAndAfterDocs: BeforeAndAfterDocs<T>, serverTimeStamp: Date);
     getMutationType(): MutationType;
     affectsPath(path: Paths<T>): boolean;
 }

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

@@ -1,18 +1,22 @@
 import { ClientId, IntegrationId } from './communication.types';
-import { DocTimestamp, DocType, FieldName, FullDocId } from './document.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 MutateResponse {
+export interface ExecuteMutationsResponse {
     timestamp: DocTimestamp;
+    idResolutionMap?: IdResolutionMap;
+    afterDocs: Record<SquidDocId, SquidDocument>;
 }
+export type MutateResponse = Omit<ExecuteMutationsResponse, 'afterDocs'>;
+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;
-    fullDocId: FullDocId;
+    squidDocIdObj: SquidDocIdObj;
 }
 export interface DeleteMutation extends BaseMutation {
     type: 'delete';
@@ -56,7 +60,7 @@ export type ApplyStringFnPropertyMutation = ApplyExtendString | ApplyTrimString;
  */
 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 DocType>(doc: T, updateMutation: UpdateMutation<T>): T | undefined;
+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

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

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

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

@@ -2,13 +2,10 @@ import { IntegrationId } from '../communication.types';
 import { CollectionName, FieldName } from '../document.types';
 import { AllOperators, ContextCondition, ContextConditions, FieldSort, GeneralCondition, GeneralConditions, GenericValue, Query } from '../query.types';
 import { Paths } from '../types';
-import { Auth, AuthWithBearer } from '../context.types';
 export declare class QueryContext<T = any> {
     readonly query: Query<T>;
-    private readonly auth;
     private readonly parsedConditions;
-    constructor(query: Query<T>, auth: Auth | undefined);
-    getUserAuth(): AuthWithBearer | undefined;
+    constructor(query: Query<T>);
     get integrationId(): IntegrationId;
     get collectionName(): CollectionName;
     get limit(): number;

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

@@ -1,7 +1,7 @@
 import { IntegrationId } from '../communication.types';
-import { CollectionName, FieldName, PrimitiveFieldType, UserFacingDocType } from '../document.types';
+import { CollectionName, DocumentData, FieldName, PrimitiveFieldType } from '../document.types';
 import { Operator, Query } from '../query.types';
-export declare class SimpleQueryBuilder<MyDocType extends UserFacingDocType> {
+export declare class SimpleQueryBuilder<MyDocType extends DocumentData> {
     protected readonly collectionName: CollectionName;
     protected readonly integrationId: IntegrationId;
     protected readonly query: Query<MyDocType>;

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

@@ -1,6 +1,6 @@
 import { TriggerId } from './application.types';
 import { AppId, ClientId, ClientRequestId, IntegrationId } from './communication.types';
-import { CollectionName, DocType, FieldName, PrimitiveFieldType } from './document.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;
@@ -101,13 +101,13 @@ export type QueryMapping<T extends string> = {
 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: DocType, collectionName: CollectionName, integrationId: IntegrationId): Promise<Array<T> | 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: DocType, collectionName: CollectionName, integrationId: IntegrationId): Promise<Array<T>>;
+    findQueriesForDocument(appId: AppId, doc: SquidDocument, collectionName: CollectionName, integrationId: IntegrationId): Promise<Array<T>>;
 }
-export declare function findQueriesForDocumentSync<T extends string>(mapping: QueryMapping<T>, doc: DocType): 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;

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

@@ -0,0 +1,4 @@
+export declare enum SquidRegion {
+    AWS_US_EAST_1 = "us-east-1.aws",
+    LOCAL = "local"
+}