@squidcloud/client 1.0.10 → 1.0.11

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/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,14 +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/transforms';
 export * from './utils/url';
-export * from './utils/id';
+export * from './utils/validation';

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 = 'backendBootstrapLatency' | 'backendFailureCount' | 'backendFailureFunctionCallCount' | 'backendSuccessFunctionCallCount' | 'backendFunctionCallCount' | 'backendFunctionCallLatency' | 'integrationConnectAttemptLatency' | 'integrationConnectionErrorCount' | 'integrationReadOperationLatency' | 'integrationWriteOperationLatency' | 'integrationOperationErrorCount';
-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,5 +1,5 @@
 import { ClientId, IntegrationId } from './communication.types';
-import { DocTimestamp, DocType, FieldName, FullDocId, FullDocIdStr } from './document.types';
+import { DocTimestamp, FieldName, SquidDocId, SquidDocIdObj, SquidDocument } from './document.types';
 export interface MutateRequest<T = any> {
     clientId: ClientId;
     integrationId: IntegrationId;
@@ -8,15 +8,15 @@ export interface MutateRequest<T = any> {
 export interface ExecuteMutationsResponse {
     timestamp: DocTimestamp;
     idResolutionMap?: IdResolutionMap;
-    afterDocs: Record<FullDocIdStr, DocType>;
+    afterDocs: Record<SquidDocId, SquidDocument>;
 }
 export type MutateResponse = Omit<ExecuteMutationsResponse, 'afterDocs'>;
-export type IdResolutionMap = Record<FullDocIdStr, FullDocIdStr>;
+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';
@@ -60,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"
+}

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

@@ -1,6 +1,8 @@
 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 type BasicFieldType = 'string' | 'integer' | 'number' | 'boolean' | 'map' | 'array' | 'any';
+export type CustomFieldType = 'date' | 'json';
+export type SupportedFieldType = BasicFieldType | CustomFieldType;
 export declare const SUPPORTED_FIELD_TYPES_ARRAY: Array<SupportedFieldType>;
 type ConvertDeep<T extends JSONSchema> = Exclude<T, boolean> & {
     properties?: Record<string, ConvertDeep<JSONSchema>>;
@@ -13,6 +15,7 @@ type ConvertDeep<T extends JSONSchema> = Exclude<T, boolean> & {
      */
     applyDefaultValueOn?: 'always' | 'empty' | 'updateOrEmpty';
     isDate?: boolean;
+    isJSON?: 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.
@@ -34,6 +37,12 @@ export type TopLevelPropertySchema = PropertySchema & {
      * 'Hello' which is a constant.
      */
     isDefaultComputed?: boolean;
+    /**
+     * The database data type that is represented by this property. This is often different from the actual property
+     * type, with is a Javascript primitive. For example, for a SMALLINT the dataType would be 'smallint', but the type
+     * would be 'integer'.
+     */
+    dataType?: string;
 };
 export type CollectionSchema = ConvertDeep<JSONSchema> & {
     properties?: Record<string, TopLevelPropertySchema>;

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

@@ -18,7 +18,15 @@ export interface SecretEntry extends SecretMetadata {
     value: SecretValue;
 }
 export type SetCustomSecretRequest = Omit<SecretEntry, 'lastUpdated'>;
-export type DeleteCustomSecretRequest = Pick<SecretMetadata, 'key'>;
+export interface DeleteCustomSecretRequest {
+    key: SecretKey;
+}
+export interface GetApiKeyRequest {
+    apiKeyName: ApiKeyName;
+}
+export interface GetApiKeyResponse {
+    apiKey: string | undefined;
+}
 export type DeleteApiKeyRequest = Pick<SecretMetadata, 'key'>;
 export interface ListApplicationSecretMetadataResponse {
     custom: SecretMetadata[];

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

@@ -1,5 +1,5 @@
 import { ClientId, ClientRequestId, IntegrationId } from './communication.types';
-import { CollectionName, DocTimestamp, DocType, FullDocIdStr } from './document.types';
+import { CollectionName, DocTimestamp, SquidDocId, SquidDocument } from './document.types';
 import { MutationType } from './mutation.types';
 export type MessageId = string;
 export type MessageFromClientType = 'acknowledge' | 'catchup' | 'kill';
@@ -47,14 +47,14 @@ export interface MutationsMessageToClient extends BaseMessageToClient {
     payload: Array<MutationResultData>;
 }
 export interface MutationResultData {
-    fullDocIdStr: FullDocIdStr;
+    squidDocId: SquidDocId;
     clientRequestId: ClientRequestId;
     mutationType: MutationType;
     mutationTimestamp: DocTimestamp;
-    doc: DocType | undefined;
+    doc: SquidDocument | undefined;
 }
 export interface QueryResultData {
-    docs: Array<DocType>;
+    docs: Array<SquidDocument>;
     integrationId: IntegrationId;
     collectionName: CollectionName;
     clientRequestId: ClientRequestId;

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

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

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

@@ -1,6 +1,8 @@
 import { StatusCode } from './validation';
 export type AssertErrorProvider = () => Error | string;
 export declare function assertTruthy(value: unknown, error?: string | Error | AssertErrorProvider): asserts value;
+export declare function assertDefined(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 defined<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/object.d.ts

@@ -1,6 +1,6 @@
-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 getInPath(obj: any, path: string, delimiter?: string): any;
+export declare function setInPath(obj: any, path: string, value: any, delimiter?: string): void;
+export declare function deleteInPath(obj: any, path: string, delimiter?: string): void;
 export declare function deepReplace(obj: any, keyName: string, replacer: (from: any) => any): void;
 export declare function replaceKeyInMap<K, T>(map: Map<K, T | undefined>, a: K, b: K): void;
 export declare function replaceKeyInRecord<K extends keyof any, T>(record: Record<K, T>, a: K, b: K): void;

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

@@ -3,3 +3,4 @@ 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;
+export declare function recodeValue(value: any): any;