@squidcloud/backend 1.0.0

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

@@ -0,0 +1,22 @@
+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

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

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

@@ -0,0 +1,52 @@
+export type MetricRate = '1m' | '5m' | '1h' | '3h' | '1d';
+export type MetricStep = string | number;
+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;
+};
+/**
+ * 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"`.
+ */
+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;
+    };
+    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 type MetricMatrixResult = MetricQueryResult<'matrix', [number, string]>;
+export type GetMetricDataResponse<T extends MetricQueryResult<any, any>> = {
+    results: Array<{
+        metricName: MetricName;
+        result: T;
+    }>;
+};

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

@@ -0,0 +1,14 @@
+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;
+    getMutationType(): MutationType;
+    affectsPath(path: Paths<T>): boolean;
+}

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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,66 @@
+import { ClientId, IntegrationId } from './communication.types';
+import { DocTimestamp, DocType, FieldName, FullDocId } from './document.types';
+export interface MutateRequest<T = any> {
+    clientId: ClientId;
+    integrationId: IntegrationId;
+    mutations: Array<Mutation<T>>;
+}
+export interface MutateResponse {
+    timestamp: DocTimestamp;
+}
+export type Mutation<T = any> = UpdateMutation<T> | InsertMutation<T> | DeleteMutation;
+export type MutationType = 'insert' | 'update' | 'delete';
+interface BaseMutation {
+    type: MutationType;
+    fullDocId: FullDocId;
+}
+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 DocType>(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.schemas.d.ts

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,9 @@
+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

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

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

@@ -0,0 +1,41 @@
+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;
+    get integrationId(): IntegrationId;
+    get collectionName(): CollectionName;
+    get limit(): number;
+    includesSorts(sorts: Array<FieldSort<T>>): boolean;
+    matchesSorts(sorts: Array<FieldSort<T>>): 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

@@ -0,0 +1,14 @@
+import { IntegrationId } from '../communication.types';
+import { CollectionName, FieldName, PrimitiveFieldType, UserFacingDocType } from '../document.types';
+import { Operator, Query } from '../query.types';
+export declare class SimpleQueryBuilder<MyDocType extends UserFacingDocType> {
+    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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,118 @@
+import { TriggerId } from './application.types';
+import { AppId, ClientId, ClientRequestId, IntegrationId } from './communication.types';
+import { CollectionName, DocType, FieldName, PrimitiveFieldType } 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: DocType, 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>>;
+}
+export declare function findQueriesForDocumentSync<T extends string>(mapping: QueryMapping<T>, doc: DocType): 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/schema/schema.types.d.ts

@@ -0,0 +1,34 @@
+import { JSONSchema } from 'json-schema-typed';
+export type FieldPlaceholder = '__SQUID_SERVER_TIMESTAMP__' | '__SQUID_CLIENT_IP__' | '__SQUID_USER_ID__' | '__SQUID_API_KEY__';
+export type SupportedFieldType = 'string' | 'integer' | 'number' | 'date' | 'boolean' | 'map' | 'array' | 'any';
+export declare const SUPPORTED_FIELD_TYPES_ARRAY: Array<SupportedFieldType>;
+type ConvertDeep<T extends JSONSchema> = Exclude<T, boolean> & {
+    properties?: Record<string, ConvertDeep<JSONSchema>>;
+    patternProperties?: Record<string, ConvertDeep<JSONSchema>>;
+    /**
+     * The default value will be applied (default to 'empty'):
+     * 'always' - no matter what the client sent, both on update and insert. In case of readOnly - applies only on insert.
+     * 'empty' - only if the value of the filed is empty (undefined)
+     * 'updateOrEmpty' - no matter what the client sent, updating the record will use the default value
+     */
+    applyDefaultValueOn?: 'always' | 'empty' | 'updateOrEmpty';
+    isDate?: boolean;
+    /**
+     * Applies to the top level schema, a record in a nested object, or a regular property.
+     * Basically, whether this property can participate in an insert mutation.
+     */
+    insertable?: boolean;
+    /** Applies to the top level schema or a record in a nested object. */
+    deletable?: boolean;
+};
+export type PropertySchema = ConvertDeep<JSONSchema>;
+export type TopLevelPropertySchema = PropertySchema & {
+    primaryKey?: boolean;
+};
+export type CollectionSchema = ConvertDeep<JSONSchema> & {
+    properties?: Record<string, TopLevelPropertySchema>;
+};
+export declare function compileSchema<S extends CollectionSchema>(schema: S): any;
+export declare function validateSchema<S extends CollectionSchema>(schema: S, data: any, updatedPaths?: Array<string>, dataBefore?: any): void;
+export declare function findMatchingPropertiesForKey<S extends CollectionSchema | PropertySchema>(schema: S, key: string): Array<PropertySchema>;
+export {};

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

@@ -0,0 +1,6 @@
+import { JSONSchemaType } from 'ajv';
+import { DeleteApiKeyRequest, DeleteCustomSecretRequest, GenerateNewApiKeyRequest, SetCustomSecretRequest } from './secret.types';
+export declare const SetCustomSecretRequestSchema: JSONSchemaType<SetCustomSecretRequest>;
+export declare const DeleteCustomSecretRequestSchema: JSONSchemaType<DeleteCustomSecretRequest>;
+export declare const DeleteApiKeyRequestSchema: JSONSchemaType<DeleteApiKeyRequest>;
+export declare const GenerateNewApiKeyRequestSchema: JSONSchemaType<GenerateNewApiKeyRequest>;

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

@@ -0,0 +1,30 @@
+export type SecretKey = string;
+export type SecretValue = string | number | boolean;
+export type SecretTimestamp = number;
+export type ApiKeyName = string;
+export type ApiKey = string;
+export interface ApplicationSecrets {
+    custom: Record<SecretKey, SecretEntry>;
+    apiKeys: Record<SecretKey, SecretEntry>;
+}
+export interface SystemSecrets {
+    sharedMongo: Record<SecretKey, SecretValue>;
+}
+export interface SecretMetadata {
+    key: SecretKey;
+    lastUpdated: SecretTimestamp;
+}
+export interface SecretEntry extends SecretMetadata {
+    value: SecretValue;
+}
+export type SetCustomSecretRequest = Omit<SecretEntry, 'lastUpdated'>;
+export type DeleteCustomSecretRequest = Pick<SecretMetadata, 'key'>;
+export type DeleteApiKeyRequest = Pick<SecretMetadata, 'key'>;
+export interface ListApplicationSecretMetadataResponse {
+    custom: SecretMetadata[];
+    apiKeys: SecretMetadata[];
+}
+export type GenerateNewApiKeyRequest = Pick<SecretMetadata, 'key'>;
+export interface GenerateNewApiKeyResponse {
+    apiKey: string;
+}

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

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

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

@@ -0,0 +1,68 @@
+import { ClientId, ClientRequestId, IntegrationId } from './communication.types';
+import { CollectionName, DocTimestamp, DocType, FullDocIdStr } from './document.types';
+import { MutationType } from './mutation.types';
+export type MessageId = string;
+export type MessageFromClientType = 'acknowledge' | 'catchup' | 'kill';
+interface BaseMessageFromClient {
+    type: MessageFromClientType;
+    payload?: unknown;
+}
+export interface AcknowledgeMessage extends BaseMessageFromClient {
+    type: 'acknowledge';
+    payload: Array<MessageId>;
+}
+export interface CatchupMessage extends BaseMessageFromClient {
+    type: 'catchup';
+}
+export interface KillMessage extends BaseMessageFromClient {
+    type: 'kill';
+}
+export type MessageFromClient = AcknowledgeMessage | CatchupMessage | KillMessage;
+export type MessageToClientType = 'mutations' | 'query' | 'backendFunction' | 'api' | 'namedQuery';
+interface BaseMessageToClient {
+    type: MessageToClientType;
+    messageId: MessageId;
+    payload: unknown;
+}
+export interface BackendFunctionMessageToClient extends BaseMessageToClient {
+    type: 'backendFunction';
+    clientRequestId: ClientRequestId;
+    payload: string;
+}
+export interface NamedQueryMessageToClient extends BaseMessageToClient {
+    type: 'namedQuery';
+    clientRequestId: ClientRequestId;
+    payload: string;
+}
+export interface ApiResponseMessageToClient extends BaseMessageToClient {
+    type: 'api';
+    clientRequestId: ClientRequestId;
+    success: boolean;
+    httpStatus: number;
+    payload: string;
+}
+export type MessageToClient = MutationsMessageToClient | QueryResultMessageToClient | BackendFunctionMessageToClient | NamedQueryMessageToClient | ApiResponseMessageToClient;
+export interface MutationsMessageToClient extends BaseMessageToClient {
+    type: 'mutations';
+    payload: Array<MutationResultData>;
+}
+export interface MutationResultData {
+    fullDocIdStr: FullDocIdStr;
+    clientRequestId: ClientRequestId;
+    mutationType: MutationType;
+    mutationTimestamp: DocTimestamp;
+    doc: DocType | undefined;
+}
+export interface QueryResultData {
+    docs: Array<DocType>;
+    integrationId: IntegrationId;
+    collectionName: CollectionName;
+    clientRequestId: ClientRequestId;
+}
+export interface QueryResultMessageToClient extends BaseMessageToClient {
+    type: 'query';
+    payload: QueryResultData;
+}
+export type PendingMessage = Omit<MessageToClient, 'messageId'>;
+export type PendingMessages = Record<ClientId, Array<PendingMessage>>;
+export {};

package/dist/common/src/time-units.d.ts

@@ -0,0 +1,5 @@
+export declare const SECONDS_PER_MINUTE = 60;
+export declare const SECONDS_PER_HOUR: number;
+export declare const SECONDS_PER_DAY: number;
+export declare const SECONDS_PER_WEEK: number;
+export declare const SECONDS_PER_MONTH: number;

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

@@ -0,0 +1,17 @@
+import { ServiceFunctionName } from './bundle-data.types';
+import { AppId } from './communication.types';
+import { Auth } from './context.types';
+import { DocType, FullDocIdStr } from './document.types';
+import { MutationType } from './mutation.types';
+export interface DocTriggerParams {
+    fullDocId: FullDocIdStr;
+    mutationType: MutationType;
+    docBefore?: DocType;
+    docAfter?: DocType;
+    auth: Auth | undefined;
+}
+export interface TriggerMessage {
+    params: DocTriggerParams;
+    functionName: ServiceFunctionName;
+    appId: AppId;
+}

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

@@ -0,0 +1,15 @@
+export interface Type<T> extends Function {
+    new (...args: any[]): T;
+}
+export type Replace<TypeToBeChecked, KeyToBeReplaced extends keyof TypeToBeChecked, NewValueToUse> = Omit<TypeToBeChecked, KeyToBeReplaced> & {
+    [P in KeyToBeReplaced]: NewValueToUse;
+};
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type WithRequired<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+type Pred = [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+export type Paths<T, RemainingDepth extends number & keyof Pred = 5, Prefix extends string = ''> = RemainingDepth extends 0 ? `${Prefix}${string}` : {
+    [k in keyof T]-?: k extends string | number ? `${Prefix}${k}` | (Required<T>[k] extends any[] ? never : Required<T>[k] extends object ? Paths<Required<T>[k], Pred[RemainingDepth], `${Prefix}${k}.`> : never) : never;
+}[keyof T];
+export {};

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

@@ -0,0 +1,7 @@
+export declare function binarySearch<T>(arr: T[], key: T, comparator?: (a: T, b: T) => number, low?: number, high?: number): number;
+export declare function insertSorted<T>(arr: T[], key: T, comparator?: (a: T, b: T) => number): void;
+export declare function removeSorted<T>(arr: T[], key: T, comparator?: (a: T, b: T) => number): void;
+export interface Grouped<T> {
+    [key: string]: T[];
+}
+export declare function asyncGroupBy<T>(arr: T[], groupNamer: (element: T) => Promise<string>): Promise<Grouped<T>>;

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

@@ -0,0 +1,6 @@
+import { StatusCode } from './validation';
+export type AssertErrorProvider = () => Error | string;
+export declare function assertTruthy(value: unknown, error?: string | Error | AssertErrorProvider): asserts value;
+export declare function assertValidateTruthy(value: unknown, message: string, statusCode?: StatusCode, details?: Record<string, any>): asserts value;
+export declare function truthy<T>(value: T, error?: string | Error | AssertErrorProvider): NonNullable<T>;
+export declare function validateTruthy<T>(value: T, message: string, statusCode?: StatusCode, details?: Record<string, any>): NonNullable<T>;

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

@@ -0,0 +1,4 @@
+export declare class CodeExecutionError extends Error {
+    readonly details?: string | undefined;
+    constructor(error: string, details?: string | undefined);
+}

package/dist/common/src/utils/lock.manager.d.ts

@@ -0,0 +1,14 @@
+type LockMutex = string;
+/**
+ * A simple lock manager that locks a list of mutexes.
+ * When locking a list of mutexes, the lock will start only when all the mutexes are available - preventing partial lock
+ * and potential deadlocks.
+ */
+export declare class LockManager {
+    private readonly locks;
+    lock(...mutexes: LockMutex[]): Promise<void>;
+    release(...mutexes: LockMutex[]): void;
+    canGetLock(...mutexes: LockMutex[]): boolean;
+    lockSync(...mutexes: LockMutex[]): void;
+}
+export {};

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

@@ -0,0 +1,4 @@
+export declare function getInPath(obj: any, path: string): any;
+export declare function setInPath(obj: any, path: string, value: any): void;
+export declare function deleteInPath(obj: any, path: string): void;
+export declare function deepReplace(obj: any, keyName: string, replacer: (from: any) => any): void;

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

@@ -0,0 +1,5 @@
+export declare function normalizeJsonAsString(json: any): string;
+export declare function serializeObj(obj: any): string;
+export declare function deserializeObj<T = any>(serializedObj: string): T;
+export declare function encodeValueForMapping(value: any): string;
+export declare function decodeValueForMapping(encodedString: string): any;

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

@@ -0,0 +1 @@
+export declare function getApplicationUrl(baseUrl: string, appId: string): string;

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

@@ -0,0 +1,30 @@
+/**
+ * This file contains general validators for the different objects being received from the client. The parameters are
+ * usually of type 'any' to make sure there are no assumptions that the object has the correct type.
+ * Also, this file should avoid importing from other files that are not for validation to avoid circular deps.
+ */
+import { OpenIdProvider } from '../application.types';
+import { HttpStatus } from '../http-status.enum';
+export type StatusCode = HttpStatus.BAD_REQUEST | HttpStatus.NOT_FOUND | HttpStatus.FORBIDDEN | HttpStatus.UNAUTHORIZED;
+export declare class ValidationError extends Error {
+    readonly statusCode: StatusCode;
+    readonly details?: any;
+    constructor(error: string, statusCode: StatusCode, details?: Record<string, any>);
+}
+export declare function validateFieldSort(fieldSort: any): void;
+export declare function validateOpenIdProvider(openIdProvider: OpenIdProvider | undefined): OpenIdProvider;
+export declare function validateOpenIdProviderType(providerType: any): void;
+export declare function validateMutations(mutations: any): void;
+export declare function validateQueryLimit(limit: any): void;
+/** Returns true if the value is not an empty string (undefined/null are considered empty). */
+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.
+ * and a few other supported types.
+ */
+export type JavascriptTypeName = 'undefined' | 'object' | 'boolean' | 'number' | 'bigint' | 'string' | 'symbol' | 'function';
+/** Returns true if 'typeof' of the 'value' is 'type' or 'type[]'. */
+export declare function isRightType(value: unknown, type: JavascriptTypeName): boolean;
+/** Returns true if 'obj' has only keys listed in the 'keys'. Object can't be an array. */
+export declare function hasOnlyKeys(obj: object, keys: string[]): boolean;