@aws-amplify/datastore 4.7.6-api-v6-models.b3abc9b.0 → 5.0.0

package/lib/sync/merger.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var types_1 = require("../types");
-var utils_1 = require("./utils");
+exports.ModelMerger = void 0;
+const types_1 = require("../types");
+const utils_1 = require("./utils");
 // https://github.com/aws-amplify/amplify-js/blob/datastore-docs/packages/datastore/docs/sync-engine.md#merger
-var ModelMerger = /** @class */ (function () {
-    function ModelMerger(outbox, ownSymbol) {
+class ModelMerger {
+    constructor(outbox, ownSymbol) {
         this.outbox = outbox;
         this.ownSymbol = ownSymbol;
     }
@@ -15,62 +15,30 @@ var ModelMerger = /** @class */ (function () {
      * @param model The model from an outbox mutation.
      * @returns The type of operation (INSERT/UPDATE/DELETE)
      */
-    ModelMerger.prototype.merge = function (storage, model, modelDefinition) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var result, mutationsForModel, isDelete;
-            var _a, _b;
-            return tslib_1.__generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0: return [4 /*yield*/, this.outbox.getForModel(storage, model, modelDefinition)];
-                    case 1:
-                        mutationsForModel = _c.sent();
-                        isDelete = model._deleted;
-                        if (!(mutationsForModel.length === 0)) return [3 /*break*/, 5];
-                        if (!isDelete) return [3 /*break*/, 3];
-                        result = types_1.OpType.DELETE;
-                        return [4 /*yield*/, storage.delete(model, undefined, this.ownSymbol)];
-                    case 2:
-                        _c.sent();
-                        return [3 /*break*/, 5];
-                    case 3: return [4 /*yield*/, storage.save(model, undefined, this.ownSymbol)];
-                    case 4:
-                        _a = tslib_1.__read.apply(void 0, [_c.sent(), 1]), _b = tslib_1.__read(_a[0], 2), result = _b[1];
-                        _c.label = 5;
-                    case 5: return [2 /*return*/, result];
-                }
-            });
-        });
-    };
-    ModelMerger.prototype.mergePage = function (storage, modelConstructor, items, modelDefinition) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var itemsMap, items_1, items_1_1, item, modelId, page;
-            var e_1, _a;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        itemsMap = new Map();
-                        try {
-                            for (items_1 = tslib_1.__values(items), items_1_1 = items_1.next(); !items_1_1.done; items_1_1 = items_1.next()) {
-                                item = items_1_1.value;
-                                modelId = utils_1.getIdentifierValue(modelDefinition, item);
-                                itemsMap.set(modelId, item);
-                            }
-                        }
-                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                        finally {
-                            try {
-                                if (items_1_1 && !items_1_1.done && (_a = items_1.return)) _a.call(items_1);
-                            }
-                            finally { if (e_1) throw e_1.error; }
-                        }
-                        page = tslib_1.__spread(itemsMap.values());
-                        return [4 /*yield*/, storage.batchSave(modelConstructor, page, this.ownSymbol)];
-                    case 1: return [2 /*return*/, _b.sent()];
-                }
-            });
-        });
-    };
-    return ModelMerger;
-}());
+    async merge(storage, model, modelDefinition) {
+        let result;
+        const mutationsForModel = await this.outbox.getForModel(storage, model, modelDefinition);
+        const isDelete = model._deleted;
+        if (mutationsForModel.length === 0) {
+            if (isDelete) {
+                result = types_1.OpType.DELETE;
+                await storage.delete(model, undefined, this.ownSymbol);
+            }
+            else {
+                [[, result]] = await storage.save(model, undefined, this.ownSymbol);
+            }
+        }
+        return result;
+    }
+    async mergePage(storage, modelConstructor, items, modelDefinition) {
+        const itemsMap = new Map();
+        for (const item of items) {
+            // merge items by model id. Latest record for a given id remains.
+            const modelId = (0, utils_1.getIdentifierValue)(modelDefinition, item);
+            itemsMap.set(modelId, item);
+        }
+        const page = [...itemsMap.values()];
+        return await storage.batchSave(modelConstructor, page, this.ownSymbol);
+    }
+}
 exports.ModelMerger = ModelMerger;
-//# sourceMappingURL=merger.js.map

package/lib/sync/outbox.js

@@ -1,245 +1,164 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var predicates_1 = require("../predicates");
-var types_1 = require("../types");
-var util_1 = require("../util");
-var utils_1 = require("./utils");
+exports.MutationEventOutbox = void 0;
+const predicates_1 = require("../predicates");
+const types_1 = require("../types");
+const util_1 = require("../util");
+const utils_1 = require("./utils");
 // TODO: Persist deleted ids
 // https://github.com/aws-amplify/amplify-js/blob/datastore-docs/packages/datastore/docs/sync-engine.md#outbox
-var MutationEventOutbox = /** @class */ (function () {
-    function MutationEventOutbox(schema, MutationEvent, modelInstanceCreator, ownSymbol) {
+class MutationEventOutbox {
+    constructor(schema, MutationEvent, modelInstanceCreator, ownSymbol) {
         this.schema = schema;
         this.MutationEvent = MutationEvent;
         this.modelInstanceCreator = modelInstanceCreator;
         this.ownSymbol = ownSymbol;
     }
-    MutationEventOutbox.prototype.enqueue = function (storage, mutationEvent) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, storage.runExclusive(function (s) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                            var mutationEventModelDefinition, predicate, _a, first, incomingMutationType, merged_1, incomingConditionJSON, incomingCondition, merged;
-                            return tslib_1.__generator(this, function (_b) {
-                                switch (_b.label) {
-                                    case 0:
-                                        mutationEventModelDefinition = this.schema.namespaces[util_1.SYNC].models['MutationEvent'];
-                                        predicate = predicates_1.ModelPredicateCreator.createFromAST(mutationEventModelDefinition, {
-                                            and: [
-                                                { modelId: { eq: mutationEvent.modelId } },
-                                                { id: { ne: this.inProgressMutationEventId } },
-                                            ],
-                                        });
-                                        return [4 /*yield*/, s.query(this.MutationEvent, predicate)];
-                                    case 1:
-                                        _a = tslib_1.__read.apply(void 0, [_b.sent(), 1]), first = _a[0];
-                                        if (!(first === undefined)) return [3 /*break*/, 3];
-                                        return [4 /*yield*/, s.save(mutationEvent, undefined, this.ownSymbol)];
-                                    case 2:
-                                        _b.sent();
-                                        return [2 /*return*/];
-                                    case 3:
-                                        incomingMutationType = mutationEvent.operation;
-                                        if (!(first.operation === utils_1.TransformerMutationType.CREATE)) return [3 /*break*/, 8];
-                                        if (!(incomingMutationType === utils_1.TransformerMutationType.DELETE)) return [3 /*break*/, 5];
-                                        return [4 /*yield*/, s.delete(this.MutationEvent, predicate)];
-                                    case 4:
-                                        _b.sent();
-                                        return [3 /*break*/, 7];
-                                    case 5:
-                                        merged_1 = this.mergeUserFields(first, mutationEvent);
-                                        return [4 /*yield*/, s.save(this.MutationEvent.copyOf(first, function (draft) {
-                                                draft.data = merged_1.data;
-                                            }), undefined, this.ownSymbol)];
-                                    case 6:
-                                        _b.sent();
-                                        _b.label = 7;
-                                    case 7: return [3 /*break*/, 12];
-                                    case 8:
-                                        incomingConditionJSON = mutationEvent.condition;
-                                        incomingCondition = JSON.parse(incomingConditionJSON);
-                                        merged = void 0;
-                                        if (!(Object.keys(incomingCondition).length === 0)) return [3 /*break*/, 10];
-                                        merged = this.mergeUserFields(first, mutationEvent);
-                                        // delete all for model
-                                        return [4 /*yield*/, s.delete(this.MutationEvent, predicate)];
-                                    case 9:
-                                        // delete all for model
-                                        _b.sent();
-                                        _b.label = 10;
-                                    case 10:
-                                        merged = merged || mutationEvent;
-                                        // Enqueue new one
-                                        return [4 /*yield*/, s.save(merged, undefined, this.ownSymbol)];
-                                    case 11:
-                                        // Enqueue new one
-                                        _b.sent();
-                                        _b.label = 12;
-                                    case 12: return [2 /*return*/];
-                                }
-                            });
-                        }); })];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
+    async enqueue(storage, mutationEvent) {
+        await storage.runExclusive(async (s) => {
+            const mutationEventModelDefinition = this.schema.namespaces[util_1.SYNC].models['MutationEvent'];
+            // `id` is the key for the record in the mutationEvent;
+            // `modelId` is the key for the actual record that was mutated
+            const predicate = predicates_1.ModelPredicateCreator.createFromAST(mutationEventModelDefinition, {
+                and: [
+                    { modelId: { eq: mutationEvent.modelId } },
+                    { id: { ne: this.inProgressMutationEventId } },
+                ],
             });
-        });
-    };
-    MutationEventOutbox.prototype.dequeue = function (storage, record, recordOp) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var head;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.peek(storage)];
-                    case 1:
-                        head = _a.sent();
-                        if (!record) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.syncOutboxVersionsOnDequeue(storage, record, head, recordOp)];
-                    case 2:
-                        _a.sent();
-                        _a.label = 3;
-                    case 3: return [4 /*yield*/, storage.delete(head)];
-                    case 4:
-                        _a.sent();
-                        this.inProgressMutationEventId = undefined;
-                        return [2 /*return*/, head];
+            // Check if there are any other records with same id
+            const [first] = await s.query(this.MutationEvent, predicate);
+            // No other record with same modelId, so enqueue
+            if (first === undefined) {
+                await s.save(mutationEvent, undefined, this.ownSymbol);
+                return;
+            }
+            // There was an enqueued mutation for the modelId, so continue
+            const { operation: incomingMutationType } = mutationEvent;
+            if (first.operation === utils_1.TransformerMutationType.CREATE) {
+                if (incomingMutationType === utils_1.TransformerMutationType.DELETE) {
+                    await s.delete(this.MutationEvent, predicate);
                 }
-            });
+                else {
+                    // first gets updated with the incoming mutation's data, condition intentionally skipped
+                    // we need to merge the fields for a create and update mutation to prevent
+                    // data loss, since update mutations only include changed fields
+                    const merged = this.mergeUserFields(first, mutationEvent);
+                    await s.save(this.MutationEvent.copyOf(first, draft => {
+                        draft.data = merged.data;
+                    }), undefined, this.ownSymbol);
+                }
+            }
+            else {
+                const { condition: incomingConditionJSON } = mutationEvent;
+                const incomingCondition = JSON.parse(incomingConditionJSON);
+                let merged;
+                // If no condition
+                if (Object.keys(incomingCondition).length === 0) {
+                    merged = this.mergeUserFields(first, mutationEvent);
+                    // delete all for model
+                    await s.delete(this.MutationEvent, predicate);
+                }
+                merged = merged || mutationEvent;
+                // Enqueue new one
+                await s.save(merged, undefined, this.ownSymbol);
+            }
         });
-    };
+    }
+    async dequeue(storage, record, recordOp) {
+        const head = await this.peek(storage);
+        if (record) {
+            await this.syncOutboxVersionsOnDequeue(storage, record, head, recordOp);
+        }
+        await storage.delete(head);
+        this.inProgressMutationEventId = undefined;
+        return head;
+    }
     /**
      * Doing a peek() implies that the mutation goes "inProgress"
      *
      * @param storage
      */
-    MutationEventOutbox.prototype.peek = function (storage) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var head;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, storage.queryOne(this.MutationEvent, types_1.QueryOne.FIRST)];
-                    case 1:
-                        head = _a.sent();
-                        this.inProgressMutationEventId = head ? head.id : undefined;
-                        return [2 /*return*/, head];
-                }
-            });
-        });
-    };
-    MutationEventOutbox.prototype.getForModel = function (storage, model, userModelDefinition) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var mutationEventModelDefinition, modelId, mutationEvents;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        mutationEventModelDefinition = this.schema.namespaces[util_1.SYNC].models.MutationEvent;
-                        modelId = utils_1.getIdentifierValue(userModelDefinition, model);
-                        return [4 /*yield*/, storage.query(this.MutationEvent, predicates_1.ModelPredicateCreator.createFromAST(mutationEventModelDefinition, {
-                                and: { modelId: { eq: modelId } },
-                            }))];
-                    case 1:
-                        mutationEvents = _a.sent();
-                        return [2 /*return*/, mutationEvents];
-                }
-            });
-        });
-    };
-    MutationEventOutbox.prototype.getModelIds = function (storage) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var mutationEvents, result;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, storage.query(this.MutationEvent)];
-                    case 1:
-                        mutationEvents = _a.sent();
-                        result = new Set();
-                        mutationEvents.forEach(function (_a) {
-                            var modelId = _a.modelId;
-                            return result.add(modelId);
-                        });
-                        return [2 /*return*/, result];
-                }
-            });
-        });
-    };
+    async peek(storage) {
+        const head = await storage.queryOne(this.MutationEvent, types_1.QueryOne.FIRST);
+        this.inProgressMutationEventId = head ? head.id : undefined;
+        return head;
+    }
+    async getForModel(storage, model, userModelDefinition) {
+        const mutationEventModelDefinition = this.schema.namespaces[util_1.SYNC].models.MutationEvent;
+        const modelId = (0, utils_1.getIdentifierValue)(userModelDefinition, model);
+        const mutationEvents = await storage.query(this.MutationEvent, predicates_1.ModelPredicateCreator.createFromAST(mutationEventModelDefinition, {
+            and: { modelId: { eq: modelId } },
+        }));
+        return mutationEvents;
+    }
+    async getModelIds(storage) {
+        const mutationEvents = await storage.query(this.MutationEvent);
+        const result = new Set();
+        mutationEvents.forEach(({ modelId }) => result.add(modelId));
+        return result;
+    }
     // applies _version from the AppSync mutation response to other items
     // in the mutation queue with the same id
     // see https://github.com/aws-amplify/amplify-js/pull/7354 for more details
-    MutationEventOutbox.prototype.syncOutboxVersionsOnDequeue = function (storage, record, head, recordOp) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var _version, _lastChangedAt, _deleted, _incomingData, incomingData, data, __version, __lastChangedAt, __deleted, _outgoingData, outgoingData, mutationEventModelDefinition, userModelDefinition, recordId, predicate, outdatedMutations, reconciledMutations;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (head.operation !== recordOp) {
-                            return [2 /*return*/];
-                        }
-                        _version = record._version, _lastChangedAt = record._lastChangedAt, _deleted = record._deleted, _incomingData = tslib_1.__rest(record, ["_version", "_lastChangedAt", "_deleted"]);
-                        incomingData = this.removeTimestampFields(head.model, _incomingData);
-                        data = JSON.parse(head.data);
-                        if (!data) {
-                            return [2 /*return*/];
-                        }
-                        __version = data._version, __lastChangedAt = data._lastChangedAt, __deleted = data._deleted, _outgoingData = tslib_1.__rest(data, ["_version", "_lastChangedAt", "_deleted"]);
-                        outgoingData = this.removeTimestampFields(head.model, _outgoingData);
-                        // Don't sync the version when the data in the response does not match the data
-                        // in the request, i.e., when there's a handled conflict
-                        //
-                        // NOTE: `incomingData` contains all the fields in the record, and `outgoingData`
-                        // only contains updated fields, resulting in an error when doing a comparison
-                        // of two equal mutations. Fix this, or mitigate otherwise.
-                        if (!util_1.valuesEqual(incomingData, outgoingData, true)) {
-                            return [2 /*return*/];
-                        }
-                        mutationEventModelDefinition = this.schema.namespaces[util_1.SYNC].models['MutationEvent'];
-                        userModelDefinition = this.schema.namespaces['user'].models[head.model];
-                        recordId = utils_1.getIdentifierValue(userModelDefinition, record);
-                        predicate = predicates_1.ModelPredicateCreator.createFromAST(mutationEventModelDefinition, {
-                            and: [
-                                { modelId: { eq: recordId } },
-                                { id: { ne: this.inProgressMutationEventId } },
-                            ],
-                        });
-                        return [4 /*yield*/, storage.query(this.MutationEvent, predicate)];
-                    case 1:
-                        outdatedMutations = _a.sent();
-                        if (!outdatedMutations.length) {
-                            return [2 /*return*/];
-                        }
-                        reconciledMutations = outdatedMutations.map(function (m) {
-                            var oldData = JSON.parse(m.data);
-                            var newData = tslib_1.__assign(tslib_1.__assign({}, oldData), { _version: _version, _lastChangedAt: _lastChangedAt });
-                            return _this.MutationEvent.copyOf(m, function (draft) {
-                                draft.data = JSON.stringify(newData);
-                            });
-                        });
-                        return [4 /*yield*/, storage.delete(this.MutationEvent, predicate)];
-                    case 2:
-                        _a.sent();
-                        return [4 /*yield*/, Promise.all(reconciledMutations.map(function (m) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, storage.save(m, undefined, this.ownSymbol)];
-                                    case 1: return [2 /*return*/, _a.sent()];
-                                }
-                            }); }); }))];
-                    case 3:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
+    async syncOutboxVersionsOnDequeue(storage, record, head, recordOp) {
+        if (head.operation !== recordOp) {
+            return;
+        }
+        const { _version, _lastChangedAt, _deleted, ..._incomingData } = record;
+        const incomingData = this.removeTimestampFields(head.model, _incomingData);
+        const data = JSON.parse(head.data);
+        if (!data) {
+            return;
+        }
+        const { _version: __version, _lastChangedAt: __lastChangedAt, _deleted: __deleted, ..._outgoingData } = data;
+        const outgoingData = this.removeTimestampFields(head.model, _outgoingData);
+        // Don't sync the version when the data in the response does not match the data
+        // in the request, i.e., when there's a handled conflict
+        //
+        // NOTE: `incomingData` contains all the fields in the record, and `outgoingData`
+        // only contains updated fields, resulting in an error when doing a comparison
+        // of two equal mutations. Fix this, or mitigate otherwise.
+        if (!(0, util_1.valuesEqual)(incomingData, outgoingData, true)) {
+            return;
+        }
+        const mutationEventModelDefinition = this.schema.namespaces[util_1.SYNC].models['MutationEvent'];
+        const userModelDefinition = this.schema.namespaces['user'].models[head.model];
+        const recordId = (0, utils_1.getIdentifierValue)(userModelDefinition, record);
+        const predicate = predicates_1.ModelPredicateCreator.createFromAST(mutationEventModelDefinition, {
+            and: [
+                { modelId: { eq: recordId } },
+                { id: { ne: this.inProgressMutationEventId } },
+            ],
+        });
+        const outdatedMutations = await storage.query(this.MutationEvent, predicate);
+        if (!outdatedMutations.length) {
+            return;
+        }
+        const reconciledMutations = outdatedMutations.map(m => {
+            const oldData = JSON.parse(m.data);
+            const newData = { ...oldData, _version, _lastChangedAt };
+            return this.MutationEvent.copyOf(m, draft => {
+                draft.data = JSON.stringify(newData);
             });
         });
-    };
-    MutationEventOutbox.prototype.mergeUserFields = function (previous, current) {
-        var _a = JSON.parse(previous.data), _version = _a._version, _lastChangedAt = _a._lastChangedAt, _deleted = _a._deleted, previousData = tslib_1.__rest(_a, ["_version", "_lastChangedAt", "_deleted"]);
-        var _b = JSON.parse(current.data), __version = _b._version, __lastChangedAt = _b._lastChangedAt, __deleted = _b._deleted, currentData = tslib_1.__rest(_b, ["_version", "_lastChangedAt", "_deleted"]);
-        var data = JSON.stringify(tslib_1.__assign(tslib_1.__assign({ _version: _version,
-            _lastChangedAt: _lastChangedAt,
-            _deleted: _deleted }, previousData), currentData));
-        return this.modelInstanceCreator(this.MutationEvent, tslib_1.__assign(tslib_1.__assign({}, current), { data: data }));
-    };
+        await storage.delete(this.MutationEvent, predicate);
+        await Promise.all(reconciledMutations.map(async (m) => await storage.save(m, undefined, this.ownSymbol)));
+    }
+    mergeUserFields(previous, current) {
+        const { _version, _lastChangedAt, _deleted, ...previousData } = JSON.parse(previous.data);
+        const { _version: __version, _lastChangedAt: __lastChangedAt, _deleted: __deleted, ...currentData } = JSON.parse(current.data);
+        const data = JSON.stringify({
+            _version,
+            _lastChangedAt,
+            _deleted,
+            ...previousData,
+            ...currentData,
+        });
+        return this.modelInstanceCreator(this.MutationEvent, {
+            ...current,
+            data,
+        });
+    }
     /*
     if a model is using custom timestamp fields
     the custom field names will be stored in the model attributes
@@ -257,14 +176,13 @@ var MutationEventOutbox = /** @class */ (function () {
     }
     ]
     */
-    MutationEventOutbox.prototype.removeTimestampFields = function (model, record) {
-        var _a, _b;
-        var CREATED_AT_DEFAULT_KEY = 'createdAt';
-        var UPDATED_AT_DEFAULT_KEY = 'updatedAt';
-        var createdTimestampKey = CREATED_AT_DEFAULT_KEY;
-        var updatedTimestampKey = UPDATED_AT_DEFAULT_KEY;
-        var modelAttributes = (_a = this.schema.namespaces[util_1.USER].models[model].attributes) === null || _a === void 0 ? void 0 : _a.find(function (attr) { return attr.type === 'model'; });
-        var timestampFieldsMap = (_b = modelAttributes === null || modelAttributes === void 0 ? void 0 : modelAttributes.properties) === null || _b === void 0 ? void 0 : _b.timestamps;
+    removeTimestampFields(model, record) {
+        const CREATED_AT_DEFAULT_KEY = 'createdAt';
+        const UPDATED_AT_DEFAULT_KEY = 'updatedAt';
+        let createdTimestampKey = CREATED_AT_DEFAULT_KEY;
+        let updatedTimestampKey = UPDATED_AT_DEFAULT_KEY;
+        const modelAttributes = this.schema.namespaces[util_1.USER].models[model].attributes?.find(attr => attr.type === 'model');
+        const timestampFieldsMap = modelAttributes?.properties?.timestamps;
         if (timestampFieldsMap) {
             createdTimestampKey = timestampFieldsMap[CREATED_AT_DEFAULT_KEY];
             updatedTimestampKey = timestampFieldsMap[UPDATED_AT_DEFAULT_KEY];
@@ -272,8 +190,6 @@ var MutationEventOutbox = /** @class */ (function () {
         delete record[createdTimestampKey];
         delete record[updatedTimestampKey];
         return record;
-    };
-    return MutationEventOutbox;
-}());
+    }
+}
 exports.MutationEventOutbox = MutationEventOutbox;
-//# sourceMappingURL=outbox.js.map

package/lib/sync/processors/errorMaps.d.ts

@@ -1,5 +1,5 @@
 import { ErrorType } from '../../types';
-export declare type ErrorMap = Partial<{
+export type ErrorMap = Partial<{
     [key in ErrorType]: (error: Error) => boolean;
 }>;
 export declare const mutationErrorMap: ErrorMap;