@squidcloud/client 1.0.195 → 1.0.196

package/dist/cjs/index.js

@@ -28258,7 +28258,10 @@ function map(project, thisArg) {
     });
 }
 //# sourceMappingURL=map.js.map
+// EXTERNAL MODULE: ../node_modules/assertic/dist/index.js
+var dist = __webpack_require__(8975);
 ;// CONCATENATED MODULE: ../internal-common/src/public-utils/id-utils.ts
+
 /** Generates a UUID-style ID. */
 function generateId() {
     let dt = new Date().getTime();
@@ -28270,12 +28273,19 @@ function generateId() {
 }
 /** Default length if ID produced by `generateShortId`. */
 const DEFAULT_SHORT_ID_LENGTH = 18;
-/** Generates an ID of the given `length` using lowercase latin letters and digits.. */
-function generateShortId(length = DEFAULT_SHORT_ID_LENGTH) {
-    const characters = 'abcdefghijklmnopqrstuvwxyz0123456789';
+const SHORT_ID_CHARACTERS = 'abcdefghijklmnopqrstuvwxyz0123456789';
+/**
+ * Generates an ID of the given `length` using lowercase latin letters and digits.
+ * If the 'prefix' provided replaces the first generated characters with the prefix.
+ */
+function generateShortId(length = DEFAULT_SHORT_ID_LENGTH, prefix = '') {
+    (0,dist.assertTruthy)(prefix.length < length, 'ID prefix is too long');
     let id = '';
     for (let i = 0; i < length; i++) {
-        id += characters.charAt(Math.floor(Math.random() * characters.length));
+        id += SHORT_ID_CHARACTERS.charAt(Math.floor(Math.random() * SHORT_ID_CHARACTERS.length));
+    }
+    if (prefix.length > 0) {
+        id = prefix + id.substring(prefix.length);
     }
     return id;
 }
@@ -28433,7 +28443,7 @@ class AiChatbotProfileReference {
      * Adds a new profile to the chatbot. This will result in an error if a profile already exists with the same id.
      *
      * @param data An object containing options for creating the profile.
-     * @param data.modelName - The name of the OpenAI model (`gpt-3.5, `gpt-4` or `claude-2`).
+     * @param data.modelName - The name of the OpenAI model (`gpt-3.5, `gpt-4`, `claude-3-opus-20240229`, `claude-3-sonnet-20240229` or `claude-3-haiku-20240307`).
      * @param data.isPublic - Whether the chat functionality of the profile can be accessed without security rules.
      * @returns A promise that resolves when the profile is successfully created.
      */
@@ -28458,7 +28468,7 @@ class AiChatbotProfileReference {
      * current profile id.
      *
      * @param data An object containing options for updating the profile.
-     * @param data.modelName - The name of the OpenAI model (`gpt-3.5, `gpt-4` or `claude-2`).
+     * @param data.modelName - The name of the OpenAI model (`gpt-3.5, `gpt-4`, `claude-3-opus-20240229`, `claude-3-sonnet-20240229` or `claude-3-haiku-20240307`).
      * @param data.isPublic - Whether the chat functionality of the profile can be accessed without security rules.
      * @returns A promise that resolves when the profile is successfully updated.
      */
@@ -28777,8 +28787,6 @@ class ApiClient {
 
 // EXTERNAL MODULE: ../node_modules/lodash/lodash.js
 var lodash = __webpack_require__(8784);
-// EXTERNAL MODULE: ../node_modules/assertic/dist/index.js
-var dist = __webpack_require__(8975);
 // EXTERNAL MODULE: ../node_modules/rfdc/index.js
 var rfdc = __webpack_require__(7795);
 var rfdc_default = /*#__PURE__*/__webpack_require__.n(rfdc);
@@ -29355,7 +29363,9 @@ const AI_MODEL_NAMES = [
     'gpt-3.5-turbo',
     'gpt-3.5-turbo-1106',
     'gpt-4',
-    'claude-2',
+    'claude-3-opus-20240229',
+    'claude-3-sonnet-20240229',
+    'claude-3-haiku-20240307',
     'gpt-4-turbo-preview',
 ];
 
@@ -29612,6 +29622,7 @@ var IntegrationType;
     IntegrationType["cognito"] = "cognito";
     IntegrationType["okta"] = "okta";
     IntegrationType["descope"] = "descope";
+    IntegrationType["firebase_auth"] = "firebase_auth";
     IntegrationType["kafka"] = "kafka";
     IntegrationType["confluent"] = "confluent";
     IntegrationType["built_in_queue"] = "built_in_queue";
@@ -30174,235 +30185,6 @@ var ClientConnectionState;
 
 
 
-
-;// CONCATENATED MODULE: ../internal-common/src/utils/assert.ts
-
-
-
-/** @internal */
-function assertValidateTruthy(value, message, statusCode = HttpStatus.BAD_REQUEST, details) {
-    assertTruthy(value, () => new ValidationError(message, statusCode, details));
-}
-/** @internal */
-function assert_validateTruthy(value, message, statusCode = HttpStatus.BAD_REQUEST, details) {
-    return truthy(value, () => new ValidationError(message, statusCode, details));
-}
-
-;// CONCATENATED MODULE: ../internal-common/src/utils/validation.ts
-/**
- * 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.
- */
-
-
-
-class validation_ValidationError extends Error {
-    constructor(error, statusCode, details) {
-        super(error);
-        this.statusCode = statusCode;
-        this.details = details;
-    }
-}
-function validatePathPart(part) {
-    if (!part || !part.match(/^[a-zA-Z][a-zA-Z0-9!@#$%^&*~_]{0,49}$/)) {
-        throw new Error('A document id and a collection id can contain only a-z, A-Z, 0-9,!@#$%^&*~_, starting' +
-            'with a letter, at least one character, and up to 50.');
-    }
-}
-function validateCollectionName(collectionName) {
-    if (typeof collectionName !== 'string' || !collectionName) {
-        throw new Error('Collection path has to be a non empty string');
-    }
-    validatePathPart(collectionName);
-}
-function validateFieldName(fieldName) {
-    if (!fieldName || typeof fieldName !== 'string') {
-        throw new Error('Field name has to be a non-empty string');
-    }
-    if (fieldName === '__docId__') {
-        // __docId__ is the only valid fieldName that can start with '_'
-        return;
-    }
-    if (!fieldName.match(/^[a-zA-Z_$][a-zA-Z0-9!@#$%^&*~_ ]{0,49}$/)) {
-        throw new Error('A Field name can contain only a-z, A-Z, 0-9,!@#$%^&*~_, starting with a letter, at least one character, and up to 50. Field name: ' +
-            fieldName);
-    }
-}
-function isValidId(id) {
-    return typeof id === 'string' && !!id && id.length <= 50 && /^[a-zA-Z0-9_-]+$/.test(id);
-}
-function validateId(id, message) {
-    validateTruthy(isValidId(id), message, HttpStatus.BAD_REQUEST);
-}
-function validateFieldSort(fieldSort) {
-    if (!(fieldSort instanceof Object)) {
-        throw new Error('Field sort has to be an object');
-    }
-    const safeFieldSort = fieldSort;
-    (0,dist.assertTruthy)(hasOnlyKeys(safeFieldSort, ['fieldName', 'asc']), 'Field sort should only contain a fieldName and asc');
-    (0,dist.assertTruthy)(isRightType(safeFieldSort.asc, 'boolean'), 'Asc needs to be boolean');
-    validateFieldName(safeFieldSort.fieldName);
-}
-/** @internal */
-function validateOpenIdProvider(openIdProvider) {
-    assertTruthy(openIdProvider, 'INVALID_PROVIDER');
-    validateOpenIdProviderType(openIdProvider.providerType);
-    assertTruthy(openIdProvider.providerType, 'INVALID_CLIENT_ID');
-    assertTruthy(openIdProvider.clientId, 'INVALID_CLIENT_ID');
-    assertTruthy(openIdProvider.domain, 'INVALID_DOMAIN');
-    return openIdProvider;
-}
-/** @internal */
-function validateOpenIdProviderType(providerType) {
-    const providerArray = ['auth0'];
-    assertTruthy(providerArray.includes(providerType), 'INVALID_OPEN_ID_PROVIDER_TYPE');
-}
-function validateDeleteMutation(mutation) {
-    if (!mutation || mutation.type !== 'delete') {
-        throw new Error('Mutation has to be non empty with type delete.');
-    }
-    // Not much to validate for delete.
-}
-function validateInsertMutation(mutation) {
-    if (!mutation || mutation.type !== 'insert') {
-        throw new Error('Mutation has to be non empty with type insert.');
-    }
-    if (!mutation.properties || typeof mutation.properties !== 'object') {
-        throw new Error('The properties in insert mutation need to be a JSON object.');
-    }
-    for (const [fieldName] of Object.entries(mutation.properties)) {
-        validateFieldName(fieldName);
-        // TODO - figure out how to validate the value
-    }
-}
-function validateUpdatePropertyMutation(propertyMutation) {
-    if (!propertyMutation || propertyMutation.type !== 'update') {
-        throw new Error('Update value property mutation has to be of type update');
-    }
-    if (propertyMutation.value === undefined) {
-        throw new Error('Value has to exist in an update value property mutation..');
-    }
-}
-function validateApplyNumericFnPropertyMutation(propertyMutation) {
-    if (!propertyMutation || propertyMutation.type !== 'applyNumericFn') {
-        throw new Error('Apply numeric fn mutation has to be of type applyNumericFn');
-    }
-    if (!['increment'].includes(propertyMutation.fn)) {
-        throw new Error('Invalid fn for apply numeric fn.');
-    }
-    if (typeof propertyMutation.value !== 'number') {
-        throw new Error('The value in an apply numeric fn function has to be numeric.');
-    }
-}
-function validateApplyStringFnPropertyMutation(propertyMutation) {
-    if (!propertyMutation || propertyMutation.type !== 'applyStringFn') {
-        throw new Error('Apply string fn mutation has to be of type applyStringFn');
-    }
-    if (!['trim', 'extendString'].includes(propertyMutation.fn)) {
-        throw new Error('Invalid fn for apply string fn.');
-    }
-    if (typeof propertyMutation.value !== 'string') {
-        throw new Error('The value in an apply string fn function has to be a string.');
-    }
-}
-function validatePropertyMutation(propertyMutation) {
-    if (!propertyMutation || typeof propertyMutation !== 'object') {
-        throw new Error('Property mutation need to be a JSON object.');
-    }
-    if (!['update', 'applyNumericFn', 'applyStringFn'].includes(propertyMutation.type)) {
-        throw new Error(`Property mutation can be of type 'update', 'applyNumericFn', 'applyStringFn'`);
-    }
-    switch (propertyMutation.type) {
-        case 'update':
-            validateUpdatePropertyMutation(propertyMutation);
-            break;
-        case 'applyNumericFn':
-            validateApplyNumericFnPropertyMutation(propertyMutation);
-            break;
-        case 'applyStringFn':
-            validateApplyStringFnPropertyMutation(propertyMutation);
-            break;
-    }
-}
-function validateUpdateMutation(mutation) {
-    if (!mutation || mutation.type !== 'update') {
-        throw new Error('Mutation has to be non empty with type update.');
-    }
-    if (!mutation.properties || typeof mutation.properties !== 'object') {
-        throw new Error('The properties in update mutation need to be a JSON object.');
-    }
-    const entries = Object.entries(mutation.properties);
-    for (const [fieldName, propertyMutations] of entries) {
-        validateFieldName(fieldName);
-        for (const propertyMutation of propertyMutations) {
-            validatePropertyMutation(propertyMutation);
-        }
-    }
-}
-function validateMutation(mutation) {
-    if (!mutation) {
-        throw new Error('Mutation cannot be empty');
-    }
-    if (!['insert', 'delete', 'update'].includes(mutation.type)) {
-        throw new Error(`Mutation type has to be one of 'insert', 'delete', or 'update'`);
-    }
-    validateCollectionName(mutation.squidDocIdObj.collectionName);
-    validatePathPart(mutation.squidDocIdObj.docId);
-    switch (mutation.type) {
-        case 'delete':
-            validateDeleteMutation(mutation);
-            break;
-        case 'insert':
-            validateInsertMutation(mutation);
-            break;
-        case 'update':
-            validateUpdateMutation(mutation);
-            break;
-    }
-}
-function validateMutations(mutations) {
-    if (!mutations || !(mutations instanceof Array) || !mutations.length) {
-        throw new Error('The list of mutations has to be a non-empty array.');
-    }
-    for (const mutation of mutations) {
-        validateMutation(mutation);
-    }
-}
-function validateQueryLimit(limit) {
-    (0,dist.assertNumber)(limit, 'Limit needs to be a number');
-    if (limit === -1)
-        return;
-    (0,dist.assertTruthy)(limit > 0, 'query limit has to be greater than 0');
-    (0,dist.assertTruthy)(Math.floor(limit) === limit, 'query limit has to be an integer');
-    (0,dist.assertTruthy)(limit <= 20000, 'Limit can be maximum 20000');
-}
-/** Returns true if the value is not an empty string (undefined/null are considered empty). */
-function isNotEmpty(value) {
-    validateCorrectStringType(value);
-    return typeof value === 'string' && !!value;
-}
-/**
- * TODO: deprecated: this method is used in both validate...() and is...() methods.
- *  The validate...() must throw an error, while is...() must not.
- */
-function validateCorrectStringType(value) {
-    if (value !== null && value !== undefined && typeof value !== 'string') {
-        throw new Error(`Unexpected input type ${typeof value}`);
-    }
-}
-/** Returns true if 'typeof' of the 'value' is 'type' or 'type[]'. */
-function isRightType(value, type) {
-    // TODO: the method is ambiguous when the value is an empty array and will return 'true' for any type.
-    if (Array.isArray(value)) {
-        return value.every(element => typeof element === type);
-    }
-    return typeof value === type;
-}
-/** Returns true if 'obj' has only keys listed in the 'keys'. Object can't be an array. */
-function hasOnlyKeys(obj, keys) {
-    return !Array.isArray(obj) && [...Object.keys(obj)].every(key => keys.includes(key));
-}
 
 ;// CONCATENATED MODULE: ../internal-common/src/types/document.types.ts
 
@@ -30428,27 +30210,545 @@ function getSquidDocId(...args) {
     return normalizeJsonAsString(squidDocIdObjObj);
 }
 
-;// CONCATENATED MODULE: ./src/query/pagination.ts
+;// CONCATENATED MODULE: ./src/document-reference.ts
 
 
 
-class Pagination {
-    /** @internal */
-    constructor(snapshotEmitter, options = {}) {
-        /* Invariants:
-        internalStateObserver.value.data
-        - always contains the pageSize elements that are on the page (fewer if we're on the last page)
-        - always contains some elements before the first one on the page and some elements after
-          the last one on the page, unless at the beginning/end.
-        Note: it is possible that all the elements before/after the page get deleted. Our current strategy is to grab
-        a full page of them and hope they don't all get deleted. An alternative strategy would be to check in dataReceived
-        if numBefore and numAfter are getting low, and rerun the query in that case. However, in order to do that we would need to be
-        able to check if we are at the next-to-last page, because numAfter can be as low as 1 in that case, and similarly for numBefore.
-      
-        firstElement
-        - is an extracted document that may or may not be part of the data
-        - the page consists of the first pageSize elements of data that are >= firstElement
-        - firstElement === null refers to a hypothetical document that is ordered before all other documents.
+
+
+
+
+/**
+ * Holds a reference to a document. A document reference is a reference to a specific record in a collection. You can
+ * use it to read or write data to the document. A document can refer to a row in a table in a relational database or a
+ * document in a NoSQL database. Additionally, a document reference can refer to a non-existent document, which you can
+ * use to create a new document.
+ *
+ * Read more about document references in the
+ * {@link https://docs.squid.cloud/docs/development-tools/client-sdk/document-reference documentation}.
+ * @typeParam T The type of the document data.
+ */
+class DocumentReference {
+    /**
+     * @internal
+     */
+    constructor(_squidDocId, dataManager, queryBuilderFactory) {
+        this._squidDocId = _squidDocId;
+        this.dataManager = dataManager;
+        this.queryBuilderFactory = queryBuilderFactory;
+        this.refId = generateId();
+    }
+    /**
+     * @internal
+     */
+    get squidDocId() {
+        return this._squidDocId;
+    }
+    /**
+     * Returns the document data. Throws an error if the document does not exist.
+     *
+     * @returns The document data.
+     * @throws Error if the document does not exist.
+     */
+    get data() {
+        return cloneDeep(this.dataRef);
+    }
+    /**
+     * Returns a read-only internal copy of the document data. This works similar to `this.data`, except it does not
+     * perform a defensive copy. The caller may not modify this object, on penalty of unexpected behavior.
+     *
+     * @returns The document data.
+     * @throws Error if the document does not exist.
+     */
+    get dataRef() {
+        const getError = () => {
+            const { collectionName, integrationId, docId } = parseSquidDocId(this.squidDocId);
+            return `No data found for document reference: ${JSON.stringify({
+                docId,
+                collectionName,
+                integrationId,
+            }, null, 2)}`;
+        };
+        return (0,dist.truthy)(this.dataManager.getProperties(this.squidDocId), getError);
+    }
+    /**
+     * Returns whether data has been populated for this document reference. Data
+     * will not present if a document has not been queried, does not exist, or
+     * has been deleted.
+     *
+     * @returns Whether the document has data.
+     */
+    get hasData() {
+        return !!this.dataManager.getProperties(this.squidDocId);
+    }
+    /**
+     * A promise that resolves with the latest data from the server or undefined if the document does not exist on the
+     * server.
+     *
+     * @returns A promise that resolves with latest data from the server or undefined if the document does not exist on
+     * the server.
+     */
+    async snapshot() {
+        if (this.hasSquidPlaceholderId()) {
+            throw new Error('Cannot invoke snapshot of a document that was created locally without storing it on the server.');
+        }
+        if (this.isTracked() && this.hasData)
+            return this.data;
+        const results = await this.queryBuilderFactory.getForDocument(this.squidDocId).dereference().snapshot();
+        (0,dist.truthy)(results.length <= 1, 'Got more than one doc for the same id:' + this.squidDocId);
+        return results.length ? results[0] : undefined;
+    }
+    /**
+     * Returns an observable that emits the latest data from the server or undefined if the document is deleted or does
+     * not exist on the server.
+     *
+     * @returns An observable that emits the latest data from the server or undefined if the document is deleted or does
+     * not exist on the server.
+     */
+    snapshots() {
+        return this.queryBuilderFactory
+            .getForDocument(this.squidDocId)
+            .dereference()
+            .snapshots()
+            .pipe((0,external_rxjs_.map)(results => {
+            (0,dist.truthy)(results.length <= 1, 'Got more than one doc for the same id:' + this.squidDocId);
+            return results.length ? results[0] : undefined;
+        }));
+    }
+    /**
+     * Returns the data that is currently available on the client or undefined if data has not yet been populated.
+     *
+     * @returns The data that is currently available on the client or undefined if data has not yet been populated.
+     */
+    peek() {
+        return this.isTracked() && this.hasData ? this.data : undefined;
+    }
+    /**
+     * Returns whether the locally available version of the document may not be the latest version on the server.
+     *
+     * @returns Whether the locally available version of the document may not be the latest version on the server.
+     */
+    isDirty() {
+        return this.dataManager.isDirty(this.squidDocId);
+    }
+    isTracked() {
+        return this.dataManager.isTracked(this.squidDocId);
+    }
+    /**
+     * Updates the document with the given data.
+     * The `update` will be reflected optimistically locally and will be applied to the server later.
+     * If a transactionId is provided, the `update` will be applied to the server as an atomic operation together with
+     * the rest of the operations in the transaction and the `update` will not reflect locally until the transaction is
+     * completed locally.
+     *
+     * The returned promise will resolve once the `update` has been applied to the server or immediately if the `update`
+     * is part of a transaction.
+     *
+     * @param data The data to update - can be partial.
+     * @param transactionId The transaction to use for this operation. If not provided, the operation will be applied
+     *   immediately.
+     */
+    async update(data, transactionId) {
+        const properties = {};
+        Object.entries(data).forEach(([fieldName, value]) => {
+            const propertyMutation = value !== undefined
+                ? {
+                    type: 'update',
+                    value: value,
+                }
+                : {
+                    type: 'removeProperty',
+                };
+            properties[fieldName] = [propertyMutation];
+        });
+        const mutation = {
+            type: 'update',
+            squidDocIdObj: parseSquidDocId(this.squidDocId),
+            properties,
+        };
+        return this.dataManager.applyOutgoingMutation(mutation, transactionId);
+    }
+    /**
+     * Similar to {@link update}, but only updates the given path.
+     * @param path The path to update.
+     * @param value The value to set at the given path.
+     * @param transactionId The transaction to use for this operation. If not provided, the operation will be applied
+     *   immediately.
+     */
+    async setInPath(path, value, transactionId) {
+        // Not sure why TypeScript doesn't understand that `path` below is restricted, but we need the explicit type
+        // assertion to make it compile.
+        return this.update({ [path]: cloneDeep(value) }, transactionId);
+    }
+    /**
+     * Similar to `update`, but only deletes the given path.
+     * @param path The path to delete.
+     * @param transactionId The transaction to use for this operation. If not provided, the operation will be applied
+     *   immediately.
+     */
+    async deleteInPath(path, transactionId) {
+        return this.update({ [path]: undefined }, transactionId);
+    }
+    /**
+     * Increments the value at the given path by the given value. The value may be both positive and negative.
+     * @param path The path to the value to increment.
+     * @param value The value to increment by.
+     * @param transactionId The transaction to use for this operation. If not provided, the operation will be applied
+     *   immediately.
+     */
+    incrementInPath(path, value, transactionId) {
+        const propertyMutation = {
+            type: 'applyNumericFn',
+            fn: 'increment',
+            value,
+        };
+        const mutation = {
+            type: 'update',
+            squidDocIdObj: parseSquidDocId(this.squidDocId),
+            properties: {
+                [path]: [propertyMutation],
+            },
+        };
+        return this.dataManager.applyOutgoingMutation(mutation, transactionId);
+    }
+    /**
+     * Decrements the value at the given path by the given value. The value may be both positive and negative.
+     * @param path The path to the value to decrement.
+     * @param value The value to decrement by.
+     * @param transactionId The transaction to use for this operation. If not provided, the operation will be applied
+     *   immediately.
+     */
+    decrementInPath(path, value, transactionId) {
+        return this.incrementInPath(path, -value, transactionId);
+    }
+    /**
+     * Inserts the document with the given data. If the document already exists, the operation will be treated as
+     * `upsert`. The `insert` will be reflected optimistically locally and will be applied to the server later. If a
+     * transactionId is provided, the `insert` will be applied to the server as an atomic operation together with the
+     * rest
+     * of the operations in the transaction and the `insert` will not reflect locally until the transaction is completed
+     * locally.
+     *
+     * The returned promise will resolve once the `insert` has been applied to the server or immediately if the `insert`
+     * is part of a transaction.
+     *
+     * @param data The data to insert.
+     * @param transactionId The transaction to use for this operation. If not provided, the operation will be applied
+     *   immediately.
+     */
+    async insert(data, transactionId) {
+        const squidDocIdObj = parseSquidDocId(this.squidDocId);
+        const integrationId = squidDocIdObj.integrationId;
+        // Exclude the generated client id from the mutation properties.
+        let docIdProps = deserializeObj(squidDocIdObj.docId);
+        if (docIdProps[SquidPlaceholderId])
+            docIdProps = {};
+        // Destructure composite __ids for the built_in_db.
+        if (integrationId === IntegrationType.built_in_db && docIdProps.__id) {
+            try {
+                const idProps = deserializeObj(docIdProps.__id);
+                docIdProps = Object.assign(Object.assign({}, docIdProps), idProps);
+            }
+            catch (_a) { }
+        }
+        const mutation = {
+            type: 'insert',
+            squidDocIdObj,
+            properties: Object.assign(Object.assign(Object.assign({}, data), { __docId__: squidDocIdObj.docId }), docIdProps),
+        };
+        return this.dataManager.applyOutgoingMutation(mutation, transactionId);
+    }
+    /**
+     * Deletes the document.
+     * The `delete` will be reflected optimistically locally and will be applied to the server later.
+     * If a transactionId is provided, the `delete` will be applied to the server as an atomic operation together with
+     * the rest of the operations in the transaction and the `delete` will not reflect locally until the transaction is
+     * completed locally.
+     *
+     * The returned promise will resolve once the `delete` has been applied to the server or immediately if the `delete`
+     * is part of a transaction.
+     *
+     * @param transactionId The transaction to use for this operation. If not provided, the operation will be applied
+     *   immediately.
+     */
+    async delete(transactionId) {
+        const mutation = {
+            type: 'delete',
+            squidDocIdObj: parseSquidDocId(this.squidDocId),
+        };
+        return this.dataManager.applyOutgoingMutation(mutation, transactionId);
+    }
+    /**
+     * @internal
+     */
+    migrateDocIds(idResolutionMap) {
+        const newSquidDocId = idResolutionMap[this.squidDocId];
+        if (newSquidDocId) {
+            this._squidDocId = newSquidDocId;
+        }
+    }
+    hasSquidPlaceholderId() {
+        const obj = deserializeObj(this._squidDocId);
+        if (typeof obj === 'object' && !!obj.docId) {
+            const docIdObj = deserializeObj(obj.docId);
+            if (typeof docIdObj === 'object' && Object.keys(docIdObj).includes(SquidPlaceholderId)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+
+;// CONCATENATED MODULE: ../internal-common/src/utils/assert.ts
+
+
+
+/** @internal */
+function assertValidateTruthy(value, message, statusCode = HttpStatus.BAD_REQUEST, details) {
+    assertTruthy(value, () => new ValidationError(message, statusCode, details));
+}
+/** @internal */
+function assert_validateTruthy(value, message, statusCode = HttpStatus.BAD_REQUEST, details) {
+    return truthy(value, () => new ValidationError(message, statusCode, details));
+}
+
+;// CONCATENATED MODULE: ../internal-common/src/utils/validation.ts
+/**
+ * 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.
+ */
+
+
+
+class validation_ValidationError extends Error {
+    constructor(error, statusCode, details) {
+        super(error);
+        this.statusCode = statusCode;
+        this.details = details;
+    }
+}
+function validatePathPart(part) {
+    if (!part || !part.match(/^[a-zA-Z][a-zA-Z0-9!@#$%^&*~_]{0,49}$/)) {
+        throw new Error('A document id and a collection id can contain only a-z, A-Z, 0-9,!@#$%^&*~_, starting' +
+            'with a letter, at least one character, and up to 50.');
+    }
+}
+function validateCollectionName(collectionName) {
+    if (typeof collectionName !== 'string' || !collectionName) {
+        throw new Error('Collection path has to be a non empty string');
+    }
+    validatePathPart(collectionName);
+}
+function validateFieldName(fieldName) {
+    if (!fieldName || typeof fieldName !== 'string') {
+        throw new Error('Field name has to be a non-empty string');
+    }
+    if (fieldName === '__docId__') {
+        // __docId__ is the only valid fieldName that can start with '_'
+        return;
+    }
+    if (!fieldName.match(/^[a-zA-Z_$][a-zA-Z0-9!@#$%^&*~_ ]{0,49}$/)) {
+        throw new Error('A Field name can contain only a-z, A-Z, 0-9,!@#$%^&*~_, starting with a letter, at least one character, and up to 50. Field name: ' +
+            fieldName);
+    }
+}
+function isValidId(id) {
+    return typeof id === 'string' && !!id && id.length <= 50 && /^[a-zA-Z0-9_-]+$/.test(id);
+}
+function validateId(id, message) {
+    validateTruthy(isValidId(id), message, HttpStatus.BAD_REQUEST);
+}
+function validateFieldSort(fieldSort) {
+    if (!(fieldSort instanceof Object)) {
+        throw new Error('Field sort has to be an object');
+    }
+    const safeFieldSort = fieldSort;
+    (0,dist.assertTruthy)(hasOnlyKeys(safeFieldSort, ['fieldName', 'asc']), 'Field sort should only contain a fieldName and asc');
+    (0,dist.assertTruthy)(isRightType(safeFieldSort.asc, 'boolean'), 'Asc needs to be boolean');
+    validateFieldName(safeFieldSort.fieldName);
+}
+/** @internal */
+function validateOpenIdProvider(openIdProvider) {
+    assertTruthy(openIdProvider, 'INVALID_PROVIDER');
+    validateOpenIdProviderType(openIdProvider.providerType);
+    assertTruthy(openIdProvider.providerType, 'INVALID_CLIENT_ID');
+    assertTruthy(openIdProvider.clientId, 'INVALID_CLIENT_ID');
+    assertTruthy(openIdProvider.domain, 'INVALID_DOMAIN');
+    return openIdProvider;
+}
+/** @internal */
+function validateOpenIdProviderType(providerType) {
+    const providerArray = ['auth0'];
+    assertTruthy(providerArray.includes(providerType), 'INVALID_OPEN_ID_PROVIDER_TYPE');
+}
+function validateDeleteMutation(mutation) {
+    if (!mutation || mutation.type !== 'delete') {
+        throw new Error('Mutation has to be non empty with type delete.');
+    }
+    // Not much to validate for delete.
+}
+function validateInsertMutation(mutation) {
+    if (!mutation || mutation.type !== 'insert') {
+        throw new Error('Mutation has to be non empty with type insert.');
+    }
+    if (!mutation.properties || typeof mutation.properties !== 'object') {
+        throw new Error('The properties in insert mutation need to be a JSON object.');
+    }
+    for (const [fieldName] of Object.entries(mutation.properties)) {
+        validateFieldName(fieldName);
+        // TODO - figure out how to validate the value
+    }
+}
+function validateUpdatePropertyMutation(propertyMutation) {
+    if (!propertyMutation || propertyMutation.type !== 'update') {
+        throw new Error('Update value property mutation has to be of type update');
+    }
+    if (propertyMutation.value === undefined) {
+        throw new Error('Value has to exist in an update value property mutation..');
+    }
+}
+function validateApplyNumericFnPropertyMutation(propertyMutation) {
+    if (!propertyMutation || propertyMutation.type !== 'applyNumericFn') {
+        throw new Error('Apply numeric fn mutation has to be of type applyNumericFn');
+    }
+    if (!['increment'].includes(propertyMutation.fn)) {
+        throw new Error('Invalid fn for apply numeric fn.');
+    }
+    if (typeof propertyMutation.value !== 'number') {
+        throw new Error('The value in an apply numeric fn function has to be numeric.');
+    }
+}
+function validateApplyStringFnPropertyMutation(propertyMutation) {
+    if (!propertyMutation || propertyMutation.type !== 'applyStringFn') {
+        throw new Error('Apply string fn mutation has to be of type applyStringFn');
+    }
+    if (!['trim', 'extendString'].includes(propertyMutation.fn)) {
+        throw new Error('Invalid fn for apply string fn.');
+    }
+    if (typeof propertyMutation.value !== 'string') {
+        throw new Error('The value in an apply string fn function has to be a string.');
+    }
+}
+function validatePropertyMutation(propertyMutation) {
+    if (!propertyMutation || typeof propertyMutation !== 'object') {
+        throw new Error('Property mutation need to be a JSON object.');
+    }
+    if (!['update', 'applyNumericFn', 'applyStringFn'].includes(propertyMutation.type)) {
+        throw new Error(`Property mutation can be of type 'update', 'applyNumericFn', 'applyStringFn'`);
+    }
+    switch (propertyMutation.type) {
+        case 'update':
+            validateUpdatePropertyMutation(propertyMutation);
+            break;
+        case 'applyNumericFn':
+            validateApplyNumericFnPropertyMutation(propertyMutation);
+            break;
+        case 'applyStringFn':
+            validateApplyStringFnPropertyMutation(propertyMutation);
+            break;
+    }
+}
+function validateUpdateMutation(mutation) {
+    if (!mutation || mutation.type !== 'update') {
+        throw new Error('Mutation has to be non empty with type update.');
+    }
+    if (!mutation.properties || typeof mutation.properties !== 'object') {
+        throw new Error('The properties in update mutation need to be a JSON object.');
+    }
+    const entries = Object.entries(mutation.properties);
+    for (const [fieldName, propertyMutations] of entries) {
+        validateFieldName(fieldName);
+        for (const propertyMutation of propertyMutations) {
+            validatePropertyMutation(propertyMutation);
+        }
+    }
+}
+function validateMutation(mutation) {
+    if (!mutation) {
+        throw new Error('Mutation cannot be empty');
+    }
+    if (!['insert', 'delete', 'update'].includes(mutation.type)) {
+        throw new Error(`Mutation type has to be one of 'insert', 'delete', or 'update'`);
+    }
+    validateCollectionName(mutation.squidDocIdObj.collectionName);
+    validatePathPart(mutation.squidDocIdObj.docId);
+    switch (mutation.type) {
+        case 'delete':
+            validateDeleteMutation(mutation);
+            break;
+        case 'insert':
+            validateInsertMutation(mutation);
+            break;
+        case 'update':
+            validateUpdateMutation(mutation);
+            break;
+    }
+}
+function validateMutations(mutations) {
+    if (!mutations || !(mutations instanceof Array) || !mutations.length) {
+        throw new Error('The list of mutations has to be a non-empty array.');
+    }
+    for (const mutation of mutations) {
+        validateMutation(mutation);
+    }
+}
+function validateQueryLimit(limit) {
+    (0,dist.assertNumber)(limit, 'Limit needs to be a number');
+    if (limit === -1)
+        return;
+    (0,dist.assertTruthy)(limit > 0, 'query limit has to be greater than 0');
+    (0,dist.assertTruthy)(Math.floor(limit) === limit, 'query limit has to be an integer');
+    (0,dist.assertTruthy)(limit <= 20000, 'Limit can be maximum 20000');
+}
+/** Returns true if the value is not an empty string (undefined/null are considered empty). */
+function isNotEmpty(value) {
+    validateCorrectStringType(value);
+    return typeof value === 'string' && !!value;
+}
+/**
+ * TODO: deprecated: this method is used in both validate...() and is...() methods.
+ *  The validate...() must throw an error, while is...() must not.
+ */
+function validateCorrectStringType(value) {
+    if (value !== null && value !== undefined && typeof value !== 'string') {
+        throw new Error(`Unexpected input type ${typeof value}`);
+    }
+}
+/** Returns true if 'typeof' of the 'value' is 'type' or 'type[]'. */
+function isRightType(value, type) {
+    // TODO: the method is ambiguous when the value is an empty array and will return 'true' for any type.
+    if (Array.isArray(value)) {
+        return value.every(element => typeof element === type);
+    }
+    return typeof value === type;
+}
+/** Returns true if 'obj' has only keys listed in the 'keys'. Object can't be an array. */
+function hasOnlyKeys(obj, keys) {
+    return !Array.isArray(obj) && [...Object.keys(obj)].every(key => keys.includes(key));
+}
+
+;// CONCATENATED MODULE: ./src/query/pagination.ts
+
+
+
+class Pagination {
+    /** @internal */
+    constructor(snapshotEmitter, options = {}) {
+        /* Invariants:
+        internalStateObserver.value.data
+        - always contains the pageSize elements that are on the page (fewer if we're on the last page)
+        - always contains some elements before the first one on the page and some elements after
+          the last one on the page, unless at the beginning/end.
+        Note: it is possible that all the elements before/after the page get deleted. Our current strategy is to grab
+        a full page of them and hope they don't all get deleted. An alternative strategy would be to check in dataReceived
+        if numBefore and numAfter are getting low, and rerun the query in that case. However, in order to do that we would need to be
+        able to check if we are at the next-to-last page, because numAfter can be as low as 1 in that case, and similarly for numBefore.
+      
+        firstElement
+        - is an extracted document that may or may not be part of the data
+        - the page consists of the first pageSize elements of data that are >= firstElement
+        - firstElement === null refers to a hypothetical document that is ordered before all other documents.
         */
         this.internalStateObserver = new external_rxjs_.BehaviorSubject(null);
         this.firstElement = null;
@@ -31526,6 +31826,7 @@ class GroupedJoin {
 
 
 
+
 /**
  *  Holds a reference to a data collection. A collection reference is a reference to a collection in a database. You
  * can use it to read or write data to the collection. A collection can refer to a table in a relational database or a
@@ -31539,12 +31840,13 @@ class CollectionReference {
     /**
      * @internal
      */
-    constructor(collectionName, integrationId, documentReferenceFactory, queryBuilderFactory, querySubscriptionManager) {
+    constructor(collectionName, integrationId, documentReferenceFactory, queryBuilderFactory, querySubscriptionManager, dataManager) {
         this.collectionName = collectionName;
         this.integrationId = integrationId;
         this.documentReferenceFactory = documentReferenceFactory;
         this.queryBuilderFactory = queryBuilderFactory;
         this.querySubscriptionManager = querySubscriptionManager;
+        this.dataManager = dataManager;
         this.refId = generateId();
     }
     /**
@@ -31602,6 +31904,31 @@ class CollectionReference {
         const squidDocId = getSquidDocId(docIdAsJsonString, this.collectionName, this.integrationId);
         return this.documentReferenceFactory.create(squidDocId, this.queryBuilderFactory);
     }
+    /**
+     * Inserts multiple documents into the collection.
+     */
+    async insertMany(docs, txId) {
+        await this.dataManager.runInTransaction(async (innerTxId) => {
+            for (const doc of docs) {
+                await this.doc(doc.id).insert(doc.data, innerTxId);
+            }
+        }, txId);
+    }
+    /**
+     * Deletes multiple documents from the collection.
+     */
+    async deleteMany(docIdsOrReferences, txId) {
+        await this.dataManager.runInTransaction(async (innerTxId) => {
+            for (const idOrRef of docIdsOrReferences) {
+                if (idOrRef instanceof DocumentReference) {
+                    await idOrRef.delete(innerTxId);
+                }
+                else {
+                    await this.doc(idOrRef).delete(innerTxId);
+                }
+            }
+        }, txId);
+    }
     /**
      * Creates a `QueryBuilder` that can be used to query the collection.
      *
@@ -31748,10 +32075,11 @@ class MergedQueryBuilder {
 
 /** @internal */
 class CollectionReferenceFactory {
-    constructor(documentReferenceFactory, queryBuilderFactory, querySubscriptionManager) {
+    constructor(documentReferenceFactory, queryBuilderFactory, querySubscriptionManager, dataManager) {
         this.documentReferenceFactory = documentReferenceFactory;
         this.queryBuilderFactory = queryBuilderFactory;
         this.querySubscriptionManager = querySubscriptionManager;
+        this.dataManager = dataManager;
         this.collections = new Map();
     }
     get(collectionName, integrationId) {
@@ -31762,7 +32090,7 @@ class CollectionReferenceFactory {
         }
         let collectionRef = integrationCollectionMap.get(collectionName);
         if (!collectionRef) {
-            collectionRef = new CollectionReference(collectionName, integrationId, this.documentReferenceFactory, this.queryBuilderFactory, this.querySubscriptionManager);
+            collectionRef = new CollectionReference(collectionName, integrationId, this.documentReferenceFactory, this.queryBuilderFactory, this.querySubscriptionManager, this.dataManager);
             integrationCollectionMap.set(collectionName, collectionRef);
         }
         return collectionRef;
@@ -32565,537 +32893,248 @@ class DataManager {
         }
         return Object.entries(outgoingMutationsByIntegrationId);
     }
-    /**
-     * Handles the case that due to some change (an incoming or outgoing change to a document), a document becomes orphan.
-     * That is, there are no ongoing queries that will keep it up-to-date.
-     * An orphan document should not stay locally since it may be stale after some time.
-     */
-    handleOrphanDocs() {
-        this.querySubscriptionManager.onOrphanDocuments.subscribe(orphanDocs => {
-            for (const squidDocId of orphanDocs) {
-                if (!this.isTracked(squidDocId)) {
-                    this.forgetDocument(squidDocId);
-                }
-            }
-        });
-    }
-    acknowledgeDocument(squidDocId, timestamp, expires = false) {
-        this.docIdToServerTimestamp.set(squidDocId, { timestamp });
-        this.setExpiration(squidDocId, expires);
-    }
-    setExpiration(squidDocId, expires) {
-        const docTimestamp = this.docIdToServerTimestamp.get(squidDocId);
-        if (docTimestamp) {
-            docTimestamp.expireTimestamp = expires ? Date.now() + 20000 : undefined;
-        }
-    }
-    forgetDocument(squidDocId) {
-        this.docIdToLocalTimestamp.delete(squidDocId);
-        /**
-         * Keep the document timestamp for a bit more just to make sure there is nothing in-flight that will be accepted
-         * with the wrong timestamp.
-         */
-        this.setExpiration(squidDocId, true);
-    }
-    migrateDocIds(idResolutionMap) {
-        this.pendingOutgoingMutations.forEach(outgoingMutations => {
-            outgoingMutations.forEach(outgoingMutation => {
-                const squidDocId = getSquidDocId(outgoingMutation.mutation.squidDocIdObj);
-                const resolvedId = idResolutionMap[squidDocId];
-                if (resolvedId) {
-                    outgoingMutation.mutation.squidDocIdObj = parseSquidDocId(resolvedId);
-                }
-            });
-        });
-        Object.entries(idResolutionMap).forEach(([squidDocId, newSquidDocId]) => {
-            replaceKeyInMap(this.pendingOutgoingMutations, squidDocId, newSquidDocId);
-            replaceKeyInMap(this.docIdToLocalTimestamp, squidDocId, newSquidDocId);
-            replaceKeyInMap(this.docIdToServerTimestamp, squidDocId, newSquidDocId);
-        });
-    }
-    hasPendingSentMutations() {
-        for (const outgoingMutationsForDoc of this.pendingOutgoingMutations.values()) {
-            for (const outgoingMutation of outgoingMutationsForDoc) {
-                if (outgoingMutation.sentToServer) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-}
-/** A constant used to differentiate undefined values provided by user from the real undefined variable state. */
-const UNSET_VALUE = Symbol('undefined');
-
-;// CONCATENATED MODULE: ./src/destruct.manager.ts
-
-
-class DestructManager {
-    constructor() {
-        this.preDestructors = [];
-        this.destructors = [];
-        this.isDestructedSubject = new external_rxjs_.BehaviorSubject(false);
-    }
-    get isDestructing() {
-        return this.isDestructedSubject.value;
-    }
-    observeIsDestructing() {
-        return this.isDestructedSubject.asObservable().pipe((0,external_rxjs_.filter)(Boolean), map(() => undefined));
-    }
-    onPreDestruct(fn) {
-        this.preDestructors.push(fn);
-    }
-    onDestruct(fn) {
-        this.destructors.push(fn);
-    }
-    async destruct() {
-        this.reportDestructed();
-        const fns = this.preDestructors.concat(this.destructors);
-        let fn = fns.shift();
-        while (fn) {
-            try {
-                await fn();
-            }
-            catch (e) {
-                console.error('Error while destructing Squid', e);
-            }
-            fn = fns.shift();
-        }
-    }
-    reportDestructed() {
-        if (this.isDestructing) {
-            return;
-        }
-        this.isDestructedSubject.next(true);
-    }
-}
-
-;// CONCATENATED MODULE: ./src/distributed-lock.manager.ts
-
-
-
-/**
- * @internal
- */
-class DistributedLockManager {
-    constructor(socketManager, destructManager) {
-        this.socketManager = socketManager;
-        this.destructManager = destructManager;
-        this.ongoingLocks = {};
-        this.acquireLockMessagesFromServer = this.socketManager
-            .observeNotifications()
-            .pipe((0,external_rxjs_.filter)(message => message.type === 'lockAcquired'));
-        this.releaseLockMessagesFromServer = this.socketManager
-            .observeNotifications()
-            .pipe((0,external_rxjs_.filter)(message => message.type === 'lockReleased'));
-        // we may override this value in tests
-        this.lockWaitForConnectionThreshold = 2000;
-        destructManager.onPreDestruct(() => {
-            this.releaseAllLocks();
-        });
-        this.socketManager.observeConnectionReady().subscribe(ready => {
-            if (ready)
-                return;
-            this.releaseAllLocks();
-        });
-        this.releaseLockMessagesFromServer.subscribe(message => {
-            const lock = this.ongoingLocks[message.payload.clientRequestId];
-            if (lock === undefined)
-                return;
-            lock.release();
-        });
-    }
-    async lock(mutex) {
-        /**
-         * Wait up to 2 seconds for the connection to be ready and if it is not, consider the client to be not connected.
-         * This is useful because right after the Squid client is created, the socket is still not connected but the user
-         * may want to acquire a lock; it is a valid situation. Also, there may be short disconnect and in this case we
-         * still want to wait for the connection to be ready.
-         */
-        const isConnected = await (0,external_rxjs_.firstValueFrom)((0,external_rxjs_.race)((0,external_rxjs_.timer)(this.lockWaitForConnectionThreshold).pipe(map(() => false)), this.socketManager.observeConnectionReady().pipe((0,external_rxjs_.filter)(Boolean)), this.destructManager.observeIsDestructing()));
-        if (!isConnected) {
-            return Promise.reject('CLIENT_NOT_CONNECTED');
-        }
-        const clientRequestId = generateId();
-        const acquireLockMessage = {
-            type: 'acquireLock',
-            payload: {
-                mutex,
-                clientRequestId,
-            },
-        };
-        this.socketManager.sendMessage(acquireLockMessage);
-        const result = await (0,external_rxjs_.firstValueFrom)((0,external_rxjs_.race)((0,external_rxjs_.timer)(5000).pipe((0,external_rxjs_.take)(1), map(() => {
-            return {
-                payload: {
-                    error: 'TIMEOUT_GETTING_LOCK',
-                    lockId: undefined,
-                },
-            };
-        })), this.acquireLockMessagesFromServer.pipe((0,external_rxjs_.filter)(message => message.payload.clientRequestId === clientRequestId))));
-        if (this.destructManager.isDestructing) {
-            throw new Error('Destructing');
-        }
-        if (!result.payload.lockId) {
-            throw new Error(`Failed to acquire lock: ${result.payload.error}`);
-        }
-        const lockId = result.payload.lockId;
-        const lock = new DistributedLockImpl(lockId, clientRequestId, this.ongoingLocks, this.socketManager);
-        this.ongoingLocks[lockId] = lock;
-        return lock;
-    }
-    releaseAllLocks() {
-        for (const [lockId, lock] of Object.entries(this.ongoingLocks)) {
-            lock.release();
-            delete this.ongoingLocks[lockId];
-        }
-    }
-}
-/**
- * @internal
- */
-class DistributedLockImpl {
-    constructor(lockId, clientRequestId, ongoingLocks, socketManager) {
-        this.lockId = lockId;
-        this.clientRequestId = clientRequestId;
-        this.ongoingLocks = ongoingLocks;
-        this.socketManager = socketManager;
-        this.released = false;
-        this.onReleaseSubject = new external_rxjs_.Subject();
+    /**
+     * Handles the case that due to some change (an incoming or outgoing change to a document), a document becomes orphan.
+     * That is, there are no ongoing queries that will keep it up-to-date.
+     * An orphan document should not stay locally since it may be stale after some time.
+     */
+    handleOrphanDocs() {
+        this.querySubscriptionManager.onOrphanDocuments.subscribe(orphanDocs => {
+            for (const squidDocId of orphanDocs) {
+                if (!this.isTracked(squidDocId)) {
+                    this.forgetDocument(squidDocId);
+                }
+            }
+        });
     }
-    release() {
-        if (this.released)
-            return;
-        this.released = true;
-        delete this.ongoingLocks[this.lockId];
-        const releaseLockMessage = {
-            type: 'releaseLock',
-            payload: {
-                lockId: this.lockId,
-                clientRequestId: this.clientRequestId,
-            },
-        };
-        this.socketManager.sendMessage(releaseLockMessage);
-        this.onReleaseSubject.next();
+    acknowledgeDocument(squidDocId, timestamp, expires = false) {
+        this.docIdToServerTimestamp.set(squidDocId, { timestamp });
+        this.setExpiration(squidDocId, expires);
     }
-    observeRelease() {
-        return this.onReleaseSubject.asObservable();
+    setExpiration(squidDocId, expires) {
+        const docTimestamp = this.docIdToServerTimestamp.get(squidDocId);
+        if (docTimestamp) {
+            docTimestamp.expireTimestamp = expires ? Date.now() + 20000 : undefined;
+        }
     }
-    isReleased() {
-        return this.released;
+    forgetDocument(squidDocId) {
+        this.docIdToLocalTimestamp.delete(squidDocId);
+        /**
+         * Keep the document timestamp for a bit more just to make sure there is nothing in-flight that will be accepted
+         * with the wrong timestamp.
+         */
+        this.setExpiration(squidDocId, true);
     }
-}
-
-;// CONCATENATED MODULE: ./src/document-identity.service.ts
-
-/** @internal */
-class DocumentIdentityService {
-    constructor(documentStore, destructManager) {
-        this.documentStore = documentStore;
-        this.destructManager = destructManager;
-        this.changeNotifier = new external_rxjs_.BehaviorSubject({});
-        this.destructManager.onDestruct(() => {
-            this.changeNotifier.complete();
+    migrateDocIds(idResolutionMap) {
+        this.pendingOutgoingMutations.forEach(outgoingMutations => {
+            outgoingMutations.forEach(outgoingMutation => {
+                const squidDocId = getSquidDocId(outgoingMutation.mutation.squidDocIdObj);
+                const resolvedId = idResolutionMap[squidDocId];
+                if (resolvedId) {
+                    outgoingMutation.mutation.squidDocIdObj = parseSquidDocId(resolvedId);
+                }
+            });
         });
-    }
-    migrate(idResolutionMap) {
-        // Update the document in the database before notifying any other subscribers.
         Object.entries(idResolutionMap).forEach(([squidDocId, newSquidDocId]) => {
-            this.documentStore.migrateDocId(squidDocId, newSquidDocId);
+            replaceKeyInMap(this.pendingOutgoingMutations, squidDocId, newSquidDocId);
+            replaceKeyInMap(this.docIdToLocalTimestamp, squidDocId, newSquidDocId);
+            replaceKeyInMap(this.docIdToServerTimestamp, squidDocId, newSquidDocId);
         });
-        this.changeNotifier.next(idResolutionMap);
     }
-    observeChanges() {
-        return this.changeNotifier.asObservable();
+    hasPendingSentMutations() {
+        for (const outgoingMutationsForDoc of this.pendingOutgoingMutations.values()) {
+            for (const outgoingMutation of outgoingMutationsForDoc) {
+                if (outgoingMutation.sentToServer) {
+                    return true;
+                }
+            }
+        }
+        return false;
     }
 }
+/** A constant used to differentiate undefined values provided by user from the real undefined variable state. */
+const UNSET_VALUE = Symbol('undefined');
 
-;// CONCATENATED MODULE: ./src/document-reference.ts
-
-
-
-
-
+;// CONCATENATED MODULE: ./src/destruct.manager.ts
 
 
-/**
- * Holds a reference to a document. A document reference is a reference to a specific record in a collection. You can
- * use it to read or write data to the document. A document can refer to a row in a table in a relational database or a
- * document in a NoSQL database. Additionally, a document reference can refer to a non-existent document, which you can
- * use to create a new document.
- *
- * Read more about document references in the
- * {@link https://docs.squid.cloud/docs/development-tools/client-sdk/document-reference documentation}.
- * @typeParam T The type of the document data.
- */
-class DocumentReference {
-    /**
-     * @internal
-     */
-    constructor(_squidDocId, dataManager, queryBuilderFactory) {
-        this._squidDocId = _squidDocId;
-        this.dataManager = dataManager;
-        this.queryBuilderFactory = queryBuilderFactory;
-        this.refId = generateId();
+class DestructManager {
+    constructor() {
+        this.preDestructors = [];
+        this.destructors = [];
+        this.isDestructedSubject = new external_rxjs_.BehaviorSubject(false);
     }
-    /**
-     * @internal
-     */
-    get squidDocId() {
-        return this._squidDocId;
+    get isDestructing() {
+        return this.isDestructedSubject.value;
     }
-    /**
-     * Returns the document data. Throws an error if the document does not exist.
-     *
-     * @returns The document data.
-     * @throws Error if the document does not exist.
-     */
-    get data() {
-        return cloneDeep(this.dataRef);
+    observeIsDestructing() {
+        return this.isDestructedSubject.asObservable().pipe((0,external_rxjs_.filter)(Boolean), map(() => undefined));
     }
-    /**
-     * Returns a read-only internal copy of the document data. This works similar to `this.data`, except it does not
-     * perform a defensive copy. The caller may not modify this object, on penalty of unexpected behavior.
-     *
-     * @returns The document data.
-     * @throws Error if the document does not exist.
-     */
-    get dataRef() {
-        const getError = () => {
-            const { collectionName, integrationId, docId } = parseSquidDocId(this.squidDocId);
-            return `No data found for document reference: ${JSON.stringify({
-                docId,
-                collectionName,
-                integrationId,
-            }, null, 2)}`;
-        };
-        return (0,dist.truthy)(this.dataManager.getProperties(this.squidDocId), getError);
+    onPreDestruct(fn) {
+        this.preDestructors.push(fn);
     }
-    /**
-     * Returns whether data has been populated for this document reference. Data
-     * will not present if a document has not been queried, does not exist, or
-     * has been deleted.
-     *
-     * @returns Whether the document has data.
-     */
-    get hasData() {
-        return !!this.dataManager.getProperties(this.squidDocId);
+    onDestruct(fn) {
+        this.destructors.push(fn);
     }
-    /**
-     * A promise that resolves with the latest data from the server or undefined if the document does not exist on the
-     * server.
-     *
-     * @returns A promise that resolves with latest data from the server or undefined if the document does not exist on
-     * the server.
-     */
-    async snapshot() {
-        if (this.hasSquidPlaceholderId()) {
-            throw new Error('Cannot invoke snapshot of a document that was created locally without storing it on the server.');
+    async destruct() {
+        this.reportDestructed();
+        const fns = this.preDestructors.concat(this.destructors);
+        let fn = fns.shift();
+        while (fn) {
+            try {
+                await fn();
+            }
+            catch (e) {
+                console.error('Error while destructing Squid', e);
+            }
+            fn = fns.shift();
         }
-        if (this.isTracked() && this.hasData)
-            return this.data;
-        const results = await this.queryBuilderFactory.getForDocument(this.squidDocId).dereference().snapshot();
-        (0,dist.truthy)(results.length <= 1, 'Got more than one doc for the same id:' + this.squidDocId);
-        return results.length ? results[0] : undefined;
-    }
-    /**
-     * Returns an observable that emits the latest data from the server or undefined if the document is deleted or does
-     * not exist on the server.
-     *
-     * @returns An observable that emits the latest data from the server or undefined if the document is deleted or does
-     * not exist on the server.
-     */
-    snapshots() {
-        return this.queryBuilderFactory
-            .getForDocument(this.squidDocId)
-            .dereference()
-            .snapshots()
-            .pipe((0,external_rxjs_.map)(results => {
-            (0,dist.truthy)(results.length <= 1, 'Got more than one doc for the same id:' + this.squidDocId);
-            return results.length ? results[0] : undefined;
-        }));
-    }
-    /**
-     * Returns the data that is currently available on the client or undefined if data has not yet been populated.
-     *
-     * @returns The data that is currently available on the client or undefined if data has not yet been populated.
-     */
-    peek() {
-        return this.isTracked() && this.hasData ? this.data : undefined;
-    }
-    /**
-     * Returns whether the locally available version of the document may not be the latest version on the server.
-     *
-     * @returns Whether the locally available version of the document may not be the latest version on the server.
-     */
-    isDirty() {
-        return this.dataManager.isDirty(this.squidDocId);
-    }
-    isTracked() {
-        return this.dataManager.isTracked(this.squidDocId);
     }
-    /**
-     * Updates the document with the given data.
-     * The `update` will be reflected optimistically locally and will be applied to the server later.
-     * If a transactionId is provided, the `update` will be applied to the server as an atomic operation together with
-     * the rest of the operations in the transaction and the `update` will not reflect locally until the transaction is
-     * completed locally.
-     *
-     * The returned promise will resolve once the `update` has been applied to the server or immediately if the `update`
-     * is part of a transaction.
-     *
-     * @param data The data to update - can be partial.
-     * @param transactionId The transaction to use for this operation. If not provided, the operation will be applied
-     *   immediately.
-     */
-    async update(data, transactionId) {
-        const properties = {};
-        Object.entries(data).forEach(([fieldName, value]) => {
-            const propertyMutation = value !== undefined
-                ? {
-                    type: 'update',
-                    value: value,
-                }
-                : {
-                    type: 'removeProperty',
-                };
-            properties[fieldName] = [propertyMutation];
+    reportDestructed() {
+        if (this.isDestructing) {
+            return;
+        }
+        this.isDestructedSubject.next(true);
+    }
+}
+
+;// CONCATENATED MODULE: ./src/distributed-lock.manager.ts
+
+
+
+/**
+ * @internal
+ */
+class DistributedLockManager {
+    constructor(socketManager, destructManager) {
+        this.socketManager = socketManager;
+        this.destructManager = destructManager;
+        this.ongoingLocks = {};
+        this.acquireLockMessagesFromServer = this.socketManager
+            .observeNotifications()
+            .pipe((0,external_rxjs_.filter)(message => message.type === 'lockAcquired'));
+        this.releaseLockMessagesFromServer = this.socketManager
+            .observeNotifications()
+            .pipe((0,external_rxjs_.filter)(message => message.type === 'lockReleased'));
+        // we may override this value in tests
+        this.lockWaitForConnectionThreshold = 2000;
+        destructManager.onPreDestruct(() => {
+            this.releaseAllLocks();
         });
-        const mutation = {
-            type: 'update',
-            squidDocIdObj: parseSquidDocId(this.squidDocId),
-            properties,
+        this.socketManager.observeConnectionReady().subscribe(ready => {
+            if (ready)
+                return;
+            this.releaseAllLocks();
+        });
+        this.releaseLockMessagesFromServer.subscribe(message => {
+            const lock = this.ongoingLocks[message.payload.clientRequestId];
+            if (lock === undefined)
+                return;
+            lock.release();
+        });
+    }
+    async lock(mutex) {
+        /**
+         * Wait up to 2 seconds for the connection to be ready and if it is not, consider the client to be not connected.
+         * This is useful because right after the Squid client is created, the socket is still not connected but the user
+         * may want to acquire a lock; it is a valid situation. Also, there may be short disconnect and in this case we
+         * still want to wait for the connection to be ready.
+         */
+        const isConnected = await (0,external_rxjs_.firstValueFrom)((0,external_rxjs_.race)((0,external_rxjs_.timer)(this.lockWaitForConnectionThreshold).pipe(map(() => false)), this.socketManager.observeConnectionReady().pipe((0,external_rxjs_.filter)(Boolean)), this.destructManager.observeIsDestructing()));
+        if (!isConnected) {
+            return Promise.reject('CLIENT_NOT_CONNECTED');
+        }
+        const clientRequestId = generateId();
+        const acquireLockMessage = {
+            type: 'acquireLock',
+            payload: {
+                mutex,
+                clientRequestId,
+            },
         };
-        return this.dataManager.applyOutgoingMutation(mutation, transactionId);
+        this.socketManager.sendMessage(acquireLockMessage);
+        const result = await (0,external_rxjs_.firstValueFrom)((0,external_rxjs_.race)((0,external_rxjs_.timer)(5000).pipe((0,external_rxjs_.take)(1), map(() => {
+            return {
+                payload: {
+                    error: 'TIMEOUT_GETTING_LOCK',
+                    lockId: undefined,
+                },
+            };
+        })), this.acquireLockMessagesFromServer.pipe((0,external_rxjs_.filter)(message => message.payload.clientRequestId === clientRequestId))));
+        if (this.destructManager.isDestructing) {
+            throw new Error('Destructing');
+        }
+        if (!result.payload.lockId) {
+            throw new Error(`Failed to acquire lock: ${result.payload.error}`);
+        }
+        const lockId = result.payload.lockId;
+        const lock = new DistributedLockImpl(lockId, clientRequestId, this.ongoingLocks, this.socketManager);
+        this.ongoingLocks[lockId] = lock;
+        return lock;
     }
-    /**
-     * Similar to {@link update}, but only updates the given path.
-     * @param path The path to update.
-     * @param value The value to set at the given path.
-     * @param transactionId The transaction to use for this operation. If not provided, the operation will be applied
-     *   immediately.
-     */
-    async setInPath(path, value, transactionId) {
-        // Not sure why TypeScript doesn't understand that `path` below is restricted, but we need the explicit type
-        // assertion to make it compile.
-        return this.update({ [path]: cloneDeep(value) }, transactionId);
+    releaseAllLocks() {
+        for (const [lockId, lock] of Object.entries(this.ongoingLocks)) {
+            lock.release();
+            delete this.ongoingLocks[lockId];
+        }
     }
-    /**
-     * Similar to `update`, but only deletes the given path.
-     * @param path The path to delete.
-     * @param transactionId The transaction to use for this operation. If not provided, the operation will be applied
-     *   immediately.
-     */
-    async deleteInPath(path, transactionId) {
-        return this.update({ [path]: undefined }, transactionId);
+}
+/**
+ * @internal
+ */
+class DistributedLockImpl {
+    constructor(lockId, clientRequestId, ongoingLocks, socketManager) {
+        this.lockId = lockId;
+        this.clientRequestId = clientRequestId;
+        this.ongoingLocks = ongoingLocks;
+        this.socketManager = socketManager;
+        this.released = false;
+        this.onReleaseSubject = new external_rxjs_.Subject();
     }
-    /**
-     * Increments the value at the given path by the given value. The value may be both positive and negative.
-     * @param path The path to the value to increment.
-     * @param value The value to increment by.
-     * @param transactionId The transaction to use for this operation. If not provided, the operation will be applied
-     *   immediately.
-     */
-    incrementInPath(path, value, transactionId) {
-        const propertyMutation = {
-            type: 'applyNumericFn',
-            fn: 'increment',
-            value,
-        };
-        const mutation = {
-            type: 'update',
-            squidDocIdObj: parseSquidDocId(this.squidDocId),
-            properties: {
-                [path]: [propertyMutation],
+    release() {
+        if (this.released)
+            return;
+        this.released = true;
+        delete this.ongoingLocks[this.lockId];
+        const releaseLockMessage = {
+            type: 'releaseLock',
+            payload: {
+                lockId: this.lockId,
+                clientRequestId: this.clientRequestId,
             },
         };
-        return this.dataManager.applyOutgoingMutation(mutation, transactionId);
+        this.socketManager.sendMessage(releaseLockMessage);
+        this.onReleaseSubject.next();
     }
-    /**
-     * Decrements the value at the given path by the given value. The value may be both positive and negative.
-     * @param path The path to the value to decrement.
-     * @param value The value to decrement by.
-     * @param transactionId The transaction to use for this operation. If not provided, the operation will be applied
-     *   immediately.
-     */
-    decrementInPath(path, value, transactionId) {
-        return this.incrementInPath(path, -value, transactionId);
+    observeRelease() {
+        return this.onReleaseSubject.asObservable();
     }
-    /**
-     * Inserts the document with the given data. If the document already exists, the operation will be treated as
-     * `upsert`. The `insert` will be reflected optimistically locally and will be applied to the server later. If a
-     * transactionId is provided, the `insert` will be applied to the server as an atomic operation together with the
-     * rest
-     * of the operations in the transaction and the `insert` will not reflect locally until the transaction is completed
-     * locally.
-     *
-     * The returned promise will resolve once the `insert` has been applied to the server or immediately if the `insert`
-     * is part of a transaction.
-     *
-     * @param data The data to insert.
-     * @param transactionId The transaction to use for this operation. If not provided, the operation will be applied
-     *   immediately.
-     */
-    async insert(data, transactionId) {
-        const squidDocIdObj = parseSquidDocId(this.squidDocId);
-        const integrationId = squidDocIdObj.integrationId;
-        // Exclude the generated client id from the mutation properties.
-        let docIdProps = deserializeObj(squidDocIdObj.docId);
-        if (docIdProps[SquidPlaceholderId])
-            docIdProps = {};
-        // Destructure composite __ids for the built_in_db.
-        if (integrationId === IntegrationType.built_in_db && docIdProps.__id) {
-            try {
-                const idProps = deserializeObj(docIdProps.__id);
-                docIdProps = Object.assign(Object.assign({}, docIdProps), idProps);
-            }
-            catch (_a) { }
-        }
-        const mutation = {
-            type: 'insert',
-            squidDocIdObj,
-            properties: Object.assign(Object.assign(Object.assign({}, data), { __docId__: squidDocIdObj.docId }), docIdProps),
-        };
-        return this.dataManager.applyOutgoingMutation(mutation, transactionId);
+    isReleased() {
+        return this.released;
     }
-    /**
-     * Deletes the document.
-     * The `delete` will be reflected optimistically locally and will be applied to the server later.
-     * If a transactionId is provided, the `delete` will be applied to the server as an atomic operation together with
-     * the rest of the operations in the transaction and the `delete` will not reflect locally until the transaction is
-     * completed locally.
-     *
-     * The returned promise will resolve once the `delete` has been applied to the server or immediately if the `delete`
-     * is part of a transaction.
-     *
-     * @param transactionId The transaction to use for this operation. If not provided, the operation will be applied
-     *   immediately.
-     */
-    async delete(transactionId) {
-        const mutation = {
-            type: 'delete',
-            squidDocIdObj: parseSquidDocId(this.squidDocId),
-        };
-        return this.dataManager.applyOutgoingMutation(mutation, transactionId);
+}
+
+;// CONCATENATED MODULE: ./src/document-identity.service.ts
+
+/** @internal */
+class DocumentIdentityService {
+    constructor(documentStore, destructManager) {
+        this.documentStore = documentStore;
+        this.destructManager = destructManager;
+        this.changeNotifier = new external_rxjs_.BehaviorSubject({});
+        this.destructManager.onDestruct(() => {
+            this.changeNotifier.complete();
+        });
     }
-    /**
-     * @internal
-     */
-    migrateDocIds(idResolutionMap) {
-        const newSquidDocId = idResolutionMap[this.squidDocId];
-        if (newSquidDocId) {
-            this._squidDocId = newSquidDocId;
-        }
+    migrate(idResolutionMap) {
+        // Update the document in the database before notifying any other subscribers.
+        Object.entries(idResolutionMap).forEach(([squidDocId, newSquidDocId]) => {
+            this.documentStore.migrateDocId(squidDocId, newSquidDocId);
+        });
+        this.changeNotifier.next(idResolutionMap);
     }
-    hasSquidPlaceholderId() {
-        const obj = deserializeObj(this._squidDocId);
-        if (typeof obj === 'object' && !!obj.docId) {
-            const docIdObj = deserializeObj(obj.docId);
-            if (typeof docIdObj === 'object' && Object.keys(docIdObj).includes(SquidPlaceholderId)) {
-                return true;
-            }
-        }
-        return false;
+    observeChanges() {
+        return this.changeNotifier.asObservable();
     }
 }
 
@@ -49132,6 +49171,7 @@ const kotlinControllers = [
     'mutation',
     'application',
     'storage',
+    'internalCodeExecutor',
 ];
 function getApplicationUrl(regionPrefix, appId, path) {
     const baseUrl = 'https://squid.cloud';
@@ -51410,8 +51450,8 @@ class Squid {
         this.localQueryManager = new LocalQueryManager(this.documentStore, this.documentReferenceFactory, this.querySubscriptionManager);
         const mutationSender = new MutationSender(this.rpcManager, this.lockManager, this.querySender);
         this.queryBuilderFactory = new QueryBuilderFactory(this.querySubscriptionManager, this.localQueryManager, this.documentReferenceFactory, this.documentIdentityService);
-        this.collectionReferenceFactory = new CollectionReferenceFactory(this.documentReferenceFactory, this.queryBuilderFactory, this.querySubscriptionManager);
         this.dataManager = new DataManager(this.documentStore, mutationSender, this.socketManager, this.querySubscriptionManager, this.queryBuilderFactory, this.lockManager, this.destructManager, this.documentIdentityService, this.querySender);
+        this.collectionReferenceFactory = new CollectionReferenceFactory(this.documentReferenceFactory, this.queryBuilderFactory, this.querySubscriptionManager, this.dataManager);
         this.documentReferenceFactory.setDataManager(this.dataManager);
         this.backendFunctionManager = new BackendFunctionManager(this.clientIdService, this.rpcManager);
         this.nativeQueryManager = new NativeQueryManager(this.rpcManager);