@webiny/api-sync-system 0.0.0-unstable.e53eceafb5

package/sync/filter/createDefaultFilterOutRecordPlugins.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startsWithKeys = exports.skipModels = exports.equalKeys = exports.createDefaultFilterOutRecordPlugins = void 0;
+var _FilterOutRecordPlugin = require("../plugins/FilterOutRecordPlugin.js");
+/**
+ * Order keys by what is most like to be filtered out - most inserts/updates/deletes.
+ * This is out of my head, so it might not be the best order.
+ */
+const equalKeys = exports.equalKeys = [
+// Logging - every request
+"LOG",
+// P
+"PS#SETTINGS",
+// Websockets - on every user login
+"WS#CONNECTIONS",
+/**
+ * packages/db-dynamodb/src/DynamoDbDriver.ts
+ */
+//`W#INTERNAL`,
+/**
+ * APW settings
+ */
+"APW#SETTINGS",
+// Deployments - on every deployment
+"DEPLOYMENTS",
+// Admin
+"ADMIN#SETTINGS"].map(key => {
+  return key.toLowerCase();
+});
+const startsWithKeys = exports.startsWithKeys = [
+// Websockets - on every user login
+"WS#",
+// Migrations - on every deployment
+"MIGRATION_RUN#", "MIGRATION#",
+// Service Manifest - on deployment if something was changed in the service manifest
+"SERVICE_MANIFEST#",
+// Deployments - on every deployment
+"DEPLOYMENT#"].map(key => {
+  return key.toLowerCase();
+});
+/**
+ * TODO figure out a way to skip these models.
+ * When deleting a record, we do not have a modelId in the values.
+ */
+const skipModels = exports.skipModels = [
+// APW
+"apwChangeRequestModelDefinition", "apwCommentModelDefinition", "apwContentReviewModelDefinition", "apwReviewerModelDefinition", "apwWorkflowModelDefnition", "apwWorkflowModelDefinition",
+// AUDIT LOGS
+"acoSearchRecord-auditlogs",
+// RECORD LOCKING
+"wby_recordLocking",
+// TASKS
+"webinyTaskLog", "webinyTask"].map(key => {
+  return key.toLowerCase();
+});
+const createDefaultFilterOutRecordPlugins = () => {
+  return [(0, _FilterOutRecordPlugin.createFilterOutRecordPlugin)({
+    name: _FilterOutRecordPlugin.FilterOutRecordPlugin.createName("default"),
+    filterOut: record => {
+      const pk = record.PK.toLowerCase();
+      if (equalKeys.includes(pk)) {
+        return true;
+      }
+      for (const key of startsWithKeys) {
+        if (pk.startsWith(key)) {
+          return true;
+        }
+      }
+      /**
+       * TODO figure out a way to skip models without using expect-error.
+       */
+      // @ts-expect-error
+      const modelId = record.input?.input?.Item?.modelId?.toLowerCase();
+      if (!modelId) {
+        return false;
+      } else if (skipModels.includes(modelId)) {
+        return true;
+      }
+      return false;
+    }
+  })];
+};
+exports.createDefaultFilterOutRecordPlugins = createDefaultFilterOutRecordPlugins;
+
+//# sourceMappingURL=createDefaultFilterOutRecordPlugins.js.map

package/sync/filter/createDefaultFilterOutRecordPlugins.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_FilterOutRecordPlugin","require","equalKeys","exports","map","key","toLowerCase","startsWithKeys","skipModels","createDefaultFilterOutRecordPlugins","createFilterOutRecordPlugin","name","FilterOutRecordPlugin","createName","filterOut","record","pk","PK","includes","startsWith","modelId","input","Item"],"sources":["createDefaultFilterOutRecordPlugins.ts"],"sourcesContent":["import {\n    createFilterOutRecordPlugin,\n    FilterOutRecordPlugin\n} from \"~/sync/plugins/FilterOutRecordPlugin.js\";\n\n/**\n * Order keys by what is most like to be filtered out - most inserts/updates/deletes.\n * This is out of my head, so it might not be the best order.\n */\nexport const equalKeys: string[] = [\n    // Logging - every request\n    \"LOG\",\n    // P\n    \"PS#SETTINGS\",\n    // Websockets - on every user login\n    \"WS#CONNECTIONS\",\n    /**\n     * packages/db-dynamodb/src/DynamoDbDriver.ts\n     */\n    //`W#INTERNAL`,\n    /**\n     * APW settings\n     */\n    \"APW#SETTINGS\",\n    // Deployments - on every deployment\n    \"DEPLOYMENTS\",\n    // Admin\n    \"ADMIN#SETTINGS\"\n].map(key => {\n    return key.toLowerCase();\n});\n\nexport const startsWithKeys: string[] = [\n    // Websockets - on every user login\n    \"WS#\",\n    // Migrations - on every deployment\n    \"MIGRATION_RUN#\",\n    \"MIGRATION#\",\n    // Service Manifest - on deployment if something was changed in the service manifest\n    \"SERVICE_MANIFEST#\",\n    // Deployments - on every deployment\n    \"DEPLOYMENT#\"\n].map(key => {\n    return key.toLowerCase();\n});\n/**\n * TODO figure out a way to skip these models.\n * When deleting a record, we do not have a modelId in the values.\n */\nexport const skipModels: string[] = [\n    // APW\n    \"apwChangeRequestModelDefinition\",\n    \"apwCommentModelDefinition\",\n    \"apwContentReviewModelDefinition\",\n    \"apwReviewerModelDefinition\",\n    \"apwWorkflowModelDefnition\",\n    \"apwWorkflowModelDefinition\",\n    // AUDIT LOGS\n    \"acoSearchRecord-auditlogs\",\n    // RECORD LOCKING\n    \"wby_recordLocking\",\n    // TASKS\n    \"webinyTaskLog\",\n    \"webinyTask\"\n].map(key => {\n    return key.toLowerCase();\n});\n\nexport const createDefaultFilterOutRecordPlugins = (): FilterOutRecordPlugin[] => {\n    return [\n        createFilterOutRecordPlugin({\n            name: FilterOutRecordPlugin.createName(\"default\"),\n            filterOut: record => {\n                const pk = record.PK.toLowerCase();\n                if (equalKeys.includes(pk)) {\n                    return true;\n                }\n                for (const key of startsWithKeys) {\n                    if (pk.startsWith(key)) {\n                        return true;\n                    }\n                }\n                /**\n                 * TODO figure out a way to skip models without using expect-error.\n                 */\n                // @ts-expect-error\n                const modelId = record.input?.input?.Item?.modelId?.toLowerCase();\n                if (!modelId) {\n                    return false;\n                } else if (skipModels.includes(modelId)) {\n                    return true;\n                }\n                return false;\n            }\n        })\n    ];\n};\n"],"mappings":";;;;;;AAAA,IAAAA,sBAAA,GAAAC,OAAA;AAKA;AACA;AACA;AACA;AACO,MAAMC,SAAmB,GAAAC,OAAA,CAAAD,SAAA,GAAG;AAC/B;AACA,KAAK;AACL;AACA,aAAa;AACb;AACA,gBAAgB;AAChB;AACJ;AACA;AACI;AACA;AACJ;AACA;AACI,cAAc;AACd;AACA,aAAa;AACb;AACA,gBAAgB,CACnB,CAACE,GAAG,CAACC,GAAG,IAAI;EACT,OAAOA,GAAG,CAACC,WAAW,CAAC,CAAC;AAC5B,CAAC,CAAC;AAEK,MAAMC,cAAwB,GAAAJ,OAAA,CAAAI,cAAA,GAAG;AACpC;AACA,KAAK;AACL;AACA,gBAAgB,EAChB,YAAY;AACZ;AACA,mBAAmB;AACnB;AACA,aAAa,CAChB,CAACH,GAAG,CAACC,GAAG,IAAI;EACT,OAAOA,GAAG,CAACC,WAAW,CAAC,CAAC;AAC5B,CAAC,CAAC;AACF;AACA;AACA;AACA;AACO,MAAME,UAAoB,GAAAL,OAAA,CAAAK,UAAA,GAAG;AAChC;AACA,iCAAiC,EACjC,2BAA2B,EAC3B,iCAAiC,EACjC,4BAA4B,EAC5B,2BAA2B,EAC3B,4BAA4B;AAC5B;AACA,2BAA2B;AAC3B;AACA,mBAAmB;AACnB;AACA,eAAe,EACf,YAAY,CACf,CAACJ,GAAG,CAACC,GAAG,IAAI;EACT,OAAOA,GAAG,CAACC,WAAW,CAAC,CAAC;AAC5B,CAAC,CAAC;AAEK,MAAMG,mCAAmC,GAAGA,CAAA,KAA+B;EAC9E,OAAO,CACH,IAAAC,kDAA2B,EAAC;IACxBC,IAAI,EAAEC,4CAAqB,CAACC,UAAU,CAAC,SAAS,CAAC;IACjDC,SAAS,EAAEC,MAAM,IAAI;MACjB,MAAMC,EAAE,GAAGD,MAAM,CAACE,EAAE,CAACX,WAAW,CAAC,CAAC;MAClC,IAAIJ,SAAS,CAACgB,QAAQ,CAACF,EAAE,CAAC,EAAE;QACxB,OAAO,IAAI;MACf;MACA,KAAK,MAAMX,GAAG,IAAIE,cAAc,EAAE;QAC9B,IAAIS,EAAE,CAACG,UAAU,CAACd,GAAG,CAAC,EAAE;UACpB,OAAO,IAAI;QACf;MACJ;MACA;AAChB;AACA;MACgB;MACA,MAAMe,OAAO,GAAGL,MAAM,CAACM,KAAK,EAAEA,KAAK,EAAEC,IAAI,EAAEF,OAAO,EAAEd,WAAW,CAAC,CAAC;MACjE,IAAI,CAACc,OAAO,EAAE;QACV,OAAO,KAAK;MAChB,CAAC,MAAM,IAAIZ,UAAU,CAACU,QAAQ,CAACE,OAAO,CAAC,EAAE;QACrC,OAAO,IAAI;MACf;MACA,OAAO,KAAK;IAChB;EACJ,CAAC,CAAC,CACL;AACL,CAAC;AAACjB,OAAA,CAAAM,mCAAA,GAAAA,mCAAA","ignoreList":[]}

package/sync/handler/Handler.d.ts

@@ -0,0 +1,28 @@
+import type { IDynamoDbCommand, IHandler, IHandlerConverter, ISystem } from "../types.js";
+import type { EventBridgeClient, PutEventsCommandOutput } from "@webiny/aws-sdk/client-eventbridge";
+import type { FilterOutRecord } from "../FilterOutRecord.js";
+export interface IHandlerEventBus {
+    name: string;
+    arn: string;
+}
+export interface IHandlerParams {
+    getEventBridgeClient(): Pick<EventBridgeClient, "send">;
+    converter: IHandlerConverter;
+    eventBus: IHandlerEventBus;
+    system: ISystem;
+    filterOutRecord: FilterOutRecord;
+}
+export declare class Handler implements IHandler {
+    readonly id: string;
+    private readonly system;
+    private readonly getEventBridgeClient;
+    private commands;
+    private readonly converter;
+    private readonly eventBus;
+    private readonly filterOutRecord;
+    constructor(params: IHandlerParams);
+    add(input: IDynamoDbCommand): void;
+    flush(): Promise<PutEventsCommandOutput | null>;
+    private createEventBusEvent;
+}
+export declare const createSyncHandler: (params: IHandlerParams) => IHandler;

package/sync/handler/Handler.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSyncHandler = exports.Handler = void 0;
+var _clientEventbridge = require("@webiny/aws-sdk/client-eventbridge");
+var _utils = require("@webiny/utils");
+var _generateId = require("@webiny/utils/generateId.js");
+class Handler {
+  id = (0, _generateId.generateAlphaNumericId)();
+  commands = [];
+  constructor(params) {
+    this.getEventBridgeClient = params.getEventBridgeClient;
+    this.system = params.system;
+    this.converter = params.converter;
+    this.eventBus = params.eventBus;
+    this.filterOutRecord = params.filterOutRecord;
+  }
+  add(input) {
+    const cmd = this.converter.convert(input);
+    this.commands.push(cmd);
+  }
+  async flush() {
+    const items = this.createEventBusEvent();
+    if (!items?.length) {
+      return null;
+    }
+    const detail = {
+      /**
+       * We need a random ID because there can be multiple commands with same items sent - but that does not mean they are duplicates.
+       */
+      id: (0, _generateId.generateAlphaNumericId)(),
+      items,
+      source: this.system
+    };
+    const input = {
+      Entries: [{
+        DetailType: "synchronization-input",
+        Detail: JSON.stringify(detail),
+        Source: `webiny:${this.system.name}`,
+        EventBusName: this.eventBus.name
+      }]
+    };
+    const command = new _clientEventbridge.PutEventsCommand(input);
+    try {
+      const eventBridgeClient = this.getEventBridgeClient();
+      return await eventBridgeClient.send(command);
+    } catch (ex) {
+      console.log("Could not send events to Sync System EventBridge.");
+      console.error(ex.message);
+      console.error((0, _utils.convertException)(ex, ["message"]));
+      console.log(JSON.stringify({
+        event: items
+      }));
+      throw ex;
+    }
+  }
+  createEventBusEvent() {
+    const commands = Array.from(this.commands);
+    /**
+     * Remove all existing commands so we can start fresh.
+     */
+    this.commands = [];
+    const everything = commands.reduce((items, cmd) => {
+      const commandItems = cmd.getItems();
+      if (!commandItems?.length) {
+        return items;
+      }
+      for (const item of commandItems) {
+        if (this.filterOutRecord.filterOut(item)) {
+          continue;
+        }
+        items.push({
+          tableName: item.tableName,
+          command: item.command,
+          tableType: item.tableType,
+          PK: item.PK,
+          SK: item.SK
+        });
+      }
+      return items;
+    }, []);
+    return everything.length === 0 ? null : everything;
+  }
+}
+exports.Handler = Handler;
+const createSyncHandler = params => {
+  return new Handler(params);
+};
+exports.createSyncHandler = createSyncHandler;
+
+//# sourceMappingURL=Handler.js.map

package/sync/handler/Handler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_clientEventbridge","require","_utils","_generateId","Handler","id","generateAlphaNumericId","commands","constructor","params","getEventBridgeClient","system","converter","eventBus","filterOutRecord","add","input","cmd","convert","push","flush","items","createEventBusEvent","length","detail","source","Entries","DetailType","Detail","JSON","stringify","Source","name","EventBusName","command","PutEventsCommand","eventBridgeClient","send","ex","console","log","error","message","convertException","event","Array","from","everything","reduce","commandItems","getItems","item","filterOut","tableName","tableType","PK","SK","exports","createSyncHandler"],"sources":["Handler.ts"],"sourcesContent":["import type {\n    ICommandValue,\n    ICommandValueItem,\n    ICommandValueItemExtended,\n    IDynamoDbCommand,\n    IHandler,\n    IHandlerConverter,\n    ISystem\n} from \"../types.js\";\nimport type {\n    EventBridgeClient,\n    PutEventsCommandInput,\n    PutEventsCommandOutput\n} from \"@webiny/aws-sdk/client-eventbridge\";\nimport { PutEventsCommand } from \"@webiny/aws-sdk/client-eventbridge\";\nimport { convertException } from \"@webiny/utils\";\nimport { generateAlphaNumericId } from \"@webiny/utils/generateId.js\";\nimport type { IDetail } from \"~/sync/handler/types.js\";\nimport type { NonEmptyArray } from \"@webiny/api/types.js\";\nimport type { FilterOutRecord } from \"~/sync/FilterOutRecord.js\";\n\nexport interface IHandlerEventBus {\n    name: string;\n    arn: string;\n}\n\nexport interface IHandlerParams {\n    getEventBridgeClient(): Pick<EventBridgeClient, \"send\">;\n    converter: IHandlerConverter;\n    eventBus: IHandlerEventBus;\n    system: ISystem;\n    filterOutRecord: FilterOutRecord;\n}\n\nexport class Handler implements IHandler {\n    public readonly id = generateAlphaNumericId();\n    private readonly system: ISystem;\n    private readonly getEventBridgeClient: () => Pick<EventBridgeClient, \"send\">;\n    private commands: ICommandValue[] = [];\n    private readonly converter: IHandlerConverter;\n    private readonly eventBus: IHandlerEventBus;\n    private readonly filterOutRecord: FilterOutRecord;\n\n    public constructor(params: IHandlerParams) {\n        this.getEventBridgeClient = params.getEventBridgeClient;\n        this.system = params.system;\n        this.converter = params.converter;\n        this.eventBus = params.eventBus;\n        this.filterOutRecord = params.filterOutRecord;\n    }\n\n    public add(input: IDynamoDbCommand): void {\n        const cmd = this.converter.convert(input);\n        this.commands.push(cmd);\n    }\n\n    public async flush(): Promise<PutEventsCommandOutput | null> {\n        const items = this.createEventBusEvent();\n\n        if (!items?.length) {\n            return null;\n        }\n\n        const detail: IDetail = {\n            /**\n             * We need a random ID because there can be multiple commands with same items sent - but that does not mean they are duplicates.\n             */\n            id: generateAlphaNumericId(),\n            items,\n            source: this.system\n        };\n\n        const input: PutEventsCommandInput = {\n            Entries: [\n                {\n                    DetailType: \"synchronization-input\",\n                    Detail: JSON.stringify(detail),\n                    Source: `webiny:${this.system.name}`,\n                    EventBusName: this.eventBus.name\n                }\n            ]\n        };\n        const command = new PutEventsCommand(input);\n\n        try {\n            const eventBridgeClient = this.getEventBridgeClient();\n            return await eventBridgeClient.send(command);\n        } catch (ex) {\n            console.log(\"Could not send events to Sync System EventBridge.\");\n            console.error(ex.message);\n            console.error(convertException(ex, [\"message\"]));\n            console.log(\n                JSON.stringify({\n                    event: items\n                })\n            );\n            throw ex;\n        }\n    }\n\n    private createEventBusEvent(): NonEmptyArray<ICommandValueItem> | null {\n        const commands = Array.from(this.commands);\n        /**\n         * Remove all existing commands so we can start fresh.\n         */\n        this.commands = [];\n        const everything = commands.reduce<ICommandValueItem[]>((items, cmd) => {\n            const commandItems = cmd.getItems();\n            if (!commandItems?.length) {\n                return items;\n            }\n\n            for (const item of commandItems) {\n                if (this.filterOutRecord.filterOut(item)) {\n                    continue;\n                }\n                items.push({\n                    tableName: item.tableName,\n                    command: item.command,\n                    tableType: item.tableType,\n                    PK: item.PK,\n                    SK: item.SK\n                });\n            }\n\n            return items;\n        }, []);\n\n        return everything.length === 0\n            ? null\n            : (everything as NonEmptyArray<ICommandValueItemExtended>);\n    }\n}\n\nexport const createSyncHandler = (params: IHandlerParams): IHandler => {\n    return new Handler(params);\n};\n"],"mappings":"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","ignoreList":[]}

package/sync/handler/HandlerConverter.d.ts

@@ -0,0 +1,12 @@
+import type { ICommandConverter, ICommandValue, IDynamoDbCommand, IHandlerConverter } from "../types.js";
+export interface IHandlerConverterParams {
+    defaultValue: ICommandValue;
+}
+export declare class HandlerConverter implements IHandlerConverter {
+    private readonly defaultValue;
+    private readonly converters;
+    constructor(params: IHandlerConverterParams);
+    register(input: ICommandConverter | ICommandConverter[]): void;
+    convert(command: IDynamoDbCommand): ICommandValue;
+}
+export declare const createHandlerConverter: (params: IHandlerConverterParams) => IHandlerConverter;

package/sync/handler/HandlerConverter.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createHandlerConverter = exports.HandlerConverter = void 0;
+class HandlerConverter {
+  converters = [];
+  constructor(params) {
+    this.defaultValue = params.defaultValue;
+  }
+  register(input) {
+    if (Array.isArray(input)) {
+      this.converters.push(...input);
+      return;
+    }
+    this.converters.push(input);
+  }
+  convert(command) {
+    for (const converter of this.converters) {
+      if (converter.can(command)) {
+        return converter.convert(command);
+      }
+    }
+    if (process.env.DEBUG === "true") {
+      console.error(`Unknown command: ${command.constructor?.name || "unknown"}`);
+      if (!command.constructor?.name) {
+        console.error("Command is not an instance of a class, it might be a plain object. Stringified command is in next line.");
+        console.log(JSON.stringify({
+          command
+        }));
+      }
+    }
+    return this.defaultValue;
+  }
+}
+exports.HandlerConverter = HandlerConverter;
+const createHandlerConverter = params => {
+  return new HandlerConverter(params);
+};
+exports.createHandlerConverter = createHandlerConverter;
+
+//# sourceMappingURL=HandlerConverter.js.map

package/sync/handler/HandlerConverter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["HandlerConverter","converters","constructor","params","defaultValue","register","input","Array","isArray","push","convert","command","converter","can","process","env","DEBUG","console","error","name","log","JSON","stringify","exports","createHandlerConverter"],"sources":["HandlerConverter.ts"],"sourcesContent":["import type {\n    ICommandConverter,\n    ICommandValue,\n    IDynamoDbCommand,\n    IHandlerConverter\n} from \"../types.js\";\n\nexport interface IHandlerConverterParams {\n    defaultValue: ICommandValue;\n}\n\nexport class HandlerConverter implements IHandlerConverter {\n    private readonly defaultValue: ICommandValue;\n    private readonly converters: ICommandConverter[] = [];\n\n    public constructor(params: IHandlerConverterParams) {\n        this.defaultValue = params.defaultValue;\n    }\n\n    public register(input: ICommandConverter | ICommandConverter[]): void {\n        if (Array.isArray(input)) {\n            this.converters.push(...input);\n            return;\n        }\n\n        this.converters.push(input);\n    }\n\n    public convert(command: IDynamoDbCommand): ICommandValue {\n        for (const converter of this.converters) {\n            if (converter.can(command)) {\n                return converter.convert(command);\n            }\n        }\n        if (process.env.DEBUG === \"true\") {\n            console.error(`Unknown command: ${command.constructor?.name || \"unknown\"}`);\n            if (!command.constructor?.name) {\n                console.error(\n                    \"Command is not an instance of a class, it might be a plain object. Stringified command is in next line.\"\n                );\n                console.log(\n                    JSON.stringify({\n                        command\n                    })\n                );\n            }\n        }\n\n        return this.defaultValue;\n    }\n}\n\nexport const createHandlerConverter = (params: IHandlerConverterParams): IHandlerConverter => {\n    return new HandlerConverter(params);\n};\n"],"mappings":";;;;;;AAWO,MAAMA,gBAAgB,CAA8B;EAEtCC,UAAU,GAAwB,EAAE;EAE9CC,WAAWA,CAACC,MAA+B,EAAE;IAChD,IAAI,CAACC,YAAY,GAAGD,MAAM,CAACC,YAAY;EAC3C;EAEOC,QAAQA,CAACC,KAA8C,EAAQ;IAClE,IAAIC,KAAK,CAACC,OAAO,CAACF,KAAK,CAAC,EAAE;MACtB,IAAI,CAACL,UAAU,CAACQ,IAAI,CAAC,GAAGH,KAAK,CAAC;MAC9B;IACJ;IAEA,IAAI,CAACL,UAAU,CAACQ,IAAI,CAACH,KAAK,CAAC;EAC/B;EAEOI,OAAOA,CAACC,OAAyB,EAAiB;IACrD,KAAK,MAAMC,SAAS,IAAI,IAAI,CAACX,UAAU,EAAE;MACrC,IAAIW,SAAS,CAACC,GAAG,CAACF,OAAO,CAAC,EAAE;QACxB,OAAOC,SAAS,CAACF,OAAO,CAACC,OAAO,CAAC;MACrC;IACJ;IACA,IAAIG,OAAO,CAACC,GAAG,CAACC,KAAK,KAAK,MAAM,EAAE;MAC9BC,OAAO,CAACC,KAAK,CAAC,oBAAoBP,OAAO,CAACT,WAAW,EAAEiB,IAAI,IAAI,SAAS,EAAE,CAAC;MAC3E,IAAI,CAACR,OAAO,CAACT,WAAW,EAAEiB,IAAI,EAAE;QAC5BF,OAAO,CAACC,KAAK,CACT,yGACJ,CAAC;QACDD,OAAO,CAACG,GAAG,CACPC,IAAI,CAACC,SAAS,CAAC;UACXX;QACJ,CAAC,CACL,CAAC;MACL;IACJ;IAEA,OAAO,IAAI,CAACP,YAAY;EAC5B;AACJ;AAACmB,OAAA,CAAAvB,gBAAA,GAAAA,gBAAA;AAEM,MAAMwB,sBAAsB,GAAIrB,MAA+B,IAAwB;EAC1F,OAAO,IAAIH,gBAAgB,CAACG,MAAM,CAAC;AACvC,CAAC;AAACoB,OAAA,CAAAC,sBAAA,GAAAA,sBAAA","ignoreList":[]}

package/sync/handler/converter/BatchGetCommandConverter.d.ts

@@ -0,0 +1,8 @@
+import type { ICommandConverter, IDynamoDbCommand } from "../../types.js";
+import { NullCommandValue } from "./commands/NullCommandValue.js";
+export declare class BatchGetCommandConverter implements ICommandConverter {
+    readonly name: string;
+    can(input: IDynamoDbCommand): boolean;
+    convert(): NullCommandValue;
+}
+export declare const createBatchGetCommandConverter: () => ICommandConverter;

package/sync/handler/converter/BatchGetCommandConverter.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createBatchGetCommandConverter = exports.BatchGetCommandConverter = void 0;
+var _index = require("@webiny/aws-sdk/client-dynamodb/index.js");
+var _NullCommandValue = require("./commands/NullCommandValue.js");
+class BatchGetCommandConverter {
+  name = "batchGet";
+  can(input) {
+    return input instanceof _index.BatchGetCommand;
+  }
+  convert() {
+    return new _NullCommandValue.NullCommandValue();
+  }
+}
+exports.BatchGetCommandConverter = BatchGetCommandConverter;
+const createBatchGetCommandConverter = () => {
+  return new BatchGetCommandConverter();
+};
+exports.createBatchGetCommandConverter = createBatchGetCommandConverter;
+
+//# sourceMappingURL=BatchGetCommandConverter.js.map

package/sync/handler/converter/BatchGetCommandConverter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_index","require","_NullCommandValue","BatchGetCommandConverter","name","can","input","BatchGetCommand","convert","NullCommandValue","exports","createBatchGetCommandConverter"],"sources":["BatchGetCommandConverter.ts"],"sourcesContent":["import { BatchGetCommand } from \"@webiny/aws-sdk/client-dynamodb/index.js\";\nimport type { ICommandConverter, IDynamoDbCommand } from \"../../types.js\";\nimport { NullCommandValue } from \"./commands/NullCommandValue.js\";\n\nexport class BatchGetCommandConverter implements ICommandConverter {\n    public readonly name: string = \"batchGet\";\n\n    public can(input: IDynamoDbCommand): boolean {\n        return input instanceof BatchGetCommand;\n    }\n\n    public convert() {\n        return new NullCommandValue();\n    }\n}\n\nexport const createBatchGetCommandConverter = (): ICommandConverter => {\n    return new BatchGetCommandConverter();\n};\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,iBAAA,GAAAD,OAAA;AAEO,MAAME,wBAAwB,CAA8B;EAC/CC,IAAI,GAAW,UAAU;EAElCC,GAAGA,CAACC,KAAuB,EAAW;IACzC,OAAOA,KAAK,YAAYC,sBAAe;EAC3C;EAEOC,OAAOA,CAAA,EAAG;IACb,OAAO,IAAIC,kCAAgB,CAAC,CAAC;EACjC;AACJ;AAACC,OAAA,CAAAP,wBAAA,GAAAA,wBAAA;AAEM,MAAMQ,8BAA8B,GAAGA,CAAA,KAAyB;EACnE,OAAO,IAAIR,wBAAwB,CAAC,CAAC;AACzC,CAAC;AAACO,OAAA,CAAAC,8BAAA,GAAAA,8BAAA","ignoreList":[]}

package/sync/handler/converter/BatchWriteCommandConverter.d.ts

@@ -0,0 +1,9 @@
+import { BatchWriteCommand } from "@webiny/aws-sdk/client-dynamodb/index.js";
+import type { ICommandConverter, IDynamoDbCommand } from "../../types.js";
+import { BatchWriteCommandValue } from "./commands/BatchWriteCommandValue.js";
+export declare class BatchWriteCommandConverter implements ICommandConverter {
+    readonly name: string;
+    can(input: IDynamoDbCommand): boolean;
+    convert(input: BatchWriteCommand): BatchWriteCommandValue;
+}
+export declare const createBatchWriteCommandConverter: () => ICommandConverter;

package/sync/handler/converter/BatchWriteCommandConverter.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createBatchWriteCommandConverter = exports.BatchWriteCommandConverter = void 0;
+var _index = require("@webiny/aws-sdk/client-dynamodb/index.js");
+var _BatchWriteCommandValue = require("./commands/BatchWriteCommandValue.js");
+class BatchWriteCommandConverter {
+  name = "put";
+  can(input) {
+    return input instanceof _index.BatchWriteCommand;
+  }
+  convert(input) {
+    return new _BatchWriteCommandValue.BatchWriteCommandValue(input);
+  }
+}
+exports.BatchWriteCommandConverter = BatchWriteCommandConverter;
+const createBatchWriteCommandConverter = () => {
+  return new BatchWriteCommandConverter();
+};
+exports.createBatchWriteCommandConverter = createBatchWriteCommandConverter;
+
+//# sourceMappingURL=BatchWriteCommandConverter.js.map

package/sync/handler/converter/BatchWriteCommandConverter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_index","require","_BatchWriteCommandValue","BatchWriteCommandConverter","name","can","input","BatchWriteCommand","convert","BatchWriteCommandValue","exports","createBatchWriteCommandConverter"],"sources":["BatchWriteCommandConverter.ts"],"sourcesContent":["import { BatchWriteCommand } from \"@webiny/aws-sdk/client-dynamodb/index.js\";\nimport type { ICommandConverter, IDynamoDbCommand } from \"../../types.js\";\nimport { BatchWriteCommandValue } from \"./commands/BatchWriteCommandValue.js\";\n\nexport class BatchWriteCommandConverter implements ICommandConverter {\n    public readonly name: string = \"put\";\n\n    public can(input: IDynamoDbCommand): boolean {\n        return input instanceof BatchWriteCommand;\n    }\n    public convert(input: BatchWriteCommand) {\n        return new BatchWriteCommandValue(input);\n    }\n}\n\nexport const createBatchWriteCommandConverter = (): ICommandConverter => {\n    return new BatchWriteCommandConverter();\n};\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,uBAAA,GAAAD,OAAA;AAEO,MAAME,0BAA0B,CAA8B;EACjDC,IAAI,GAAW,KAAK;EAE7BC,GAAGA,CAACC,KAAuB,EAAW;IACzC,OAAOA,KAAK,YAAYC,wBAAiB;EAC7C;EACOC,OAAOA,CAACF,KAAwB,EAAE;IACrC,OAAO,IAAIG,8CAAsB,CAACH,KAAK,CAAC;EAC5C;AACJ;AAACI,OAAA,CAAAP,0BAAA,GAAAA,0BAAA;AAEM,MAAMQ,gCAAgC,GAAGA,CAAA,KAAyB;EACrE,OAAO,IAAIR,0BAA0B,CAAC,CAAC;AAC3C,CAAC;AAACO,OAAA,CAAAC,gCAAA,GAAAA,gCAAA","ignoreList":[]}

package/sync/handler/converter/DeleteCommandConverter.d.ts

@@ -0,0 +1,9 @@
+import { DeleteCommand } from "@webiny/aws-sdk/client-dynamodb/index.js";
+import type { ICommandConverter, IDynamoDbCommand } from "../../types.js";
+import { DeleteCommandValue } from "./commands/DeleteCommandValue.js";
+export declare class DeleteCommandConverter implements ICommandConverter {
+    readonly name: string;
+    can(input: IDynamoDbCommand): boolean;
+    convert(input: DeleteCommand): DeleteCommandValue;
+}
+export declare const createDeleteCommandConverter: () => ICommandConverter;

package/sync/handler/converter/DeleteCommandConverter.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDeleteCommandConverter = exports.DeleteCommandConverter = void 0;
+var _index = require("@webiny/aws-sdk/client-dynamodb/index.js");
+var _DeleteCommandValue = require("./commands/DeleteCommandValue.js");
+class DeleteCommandConverter {
+  name = "delete";
+  can(input) {
+    return input instanceof _index.DeleteCommand;
+  }
+  convert(input) {
+    return new _DeleteCommandValue.DeleteCommandValue(input);
+  }
+}
+exports.DeleteCommandConverter = DeleteCommandConverter;
+const createDeleteCommandConverter = () => {
+  return new DeleteCommandConverter();
+};
+exports.createDeleteCommandConverter = createDeleteCommandConverter;
+
+//# sourceMappingURL=DeleteCommandConverter.js.map

package/sync/handler/converter/DeleteCommandConverter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_index","require","_DeleteCommandValue","DeleteCommandConverter","name","can","input","DeleteCommand","convert","DeleteCommandValue","exports","createDeleteCommandConverter"],"sources":["DeleteCommandConverter.ts"],"sourcesContent":["import { DeleteCommand } from \"@webiny/aws-sdk/client-dynamodb/index.js\";\nimport type { ICommandConverter, IDynamoDbCommand } from \"../../types.js\";\nimport { DeleteCommandValue } from \"./commands/DeleteCommandValue.js\";\n\nexport class DeleteCommandConverter implements ICommandConverter {\n    public readonly name: string = \"delete\";\n\n    public can(input: IDynamoDbCommand): boolean {\n        return input instanceof DeleteCommand;\n    }\n    public convert(input: DeleteCommand) {\n        return new DeleteCommandValue(input);\n    }\n}\n\nexport const createDeleteCommandConverter = (): ICommandConverter => {\n    return new DeleteCommandConverter();\n};\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,mBAAA,GAAAD,OAAA;AAEO,MAAME,sBAAsB,CAA8B;EAC7CC,IAAI,GAAW,QAAQ;EAEhCC,GAAGA,CAACC,KAAuB,EAAW;IACzC,OAAOA,KAAK,YAAYC,oBAAa;EACzC;EACOC,OAAOA,CAACF,KAAoB,EAAE;IACjC,OAAO,IAAIG,sCAAkB,CAACH,KAAK,CAAC;EACxC;AACJ;AAACI,OAAA,CAAAP,sBAAA,GAAAA,sBAAA;AAEM,MAAMQ,4BAA4B,GAAGA,CAAA,KAAyB;EACjE,OAAO,IAAIR,sBAAsB,CAAC,CAAC;AACvC,CAAC;AAACO,OAAA,CAAAC,4BAAA,GAAAA,4BAAA","ignoreList":[]}

package/sync/handler/converter/GetCommandConverter.d.ts

@@ -0,0 +1,8 @@
+import type { ICommandConverter, IDynamoDbCommand } from "../../types.js";
+import { NullCommandValue } from "./commands/NullCommandValue.js";
+export declare class GetCommandConverter implements ICommandConverter {
+    readonly name: string;
+    can(input: IDynamoDbCommand): boolean;
+    convert(): NullCommandValue;
+}
+export declare const createGetCommandConverter: () => ICommandConverter;

package/sync/handler/converter/GetCommandConverter.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createGetCommandConverter = exports.GetCommandConverter = void 0;
+var _index = require("@webiny/aws-sdk/client-dynamodb/index.js");
+var _NullCommandValue = require("./commands/NullCommandValue.js");
+class GetCommandConverter {
+  name = "get";
+  can(input) {
+    return input instanceof _index.GetCommand;
+  }
+  convert() {
+    return new _NullCommandValue.NullCommandValue();
+  }
+}
+exports.GetCommandConverter = GetCommandConverter;
+const createGetCommandConverter = () => {
+  return new GetCommandConverter();
+};
+exports.createGetCommandConverter = createGetCommandConverter;
+
+//# sourceMappingURL=GetCommandConverter.js.map

package/sync/handler/converter/GetCommandConverter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_index","require","_NullCommandValue","GetCommandConverter","name","can","input","GetCommand","convert","NullCommandValue","exports","createGetCommandConverter"],"sources":["GetCommandConverter.ts"],"sourcesContent":["import { GetCommand } from \"@webiny/aws-sdk/client-dynamodb/index.js\";\nimport type { ICommandConverter, IDynamoDbCommand } from \"../../types.js\";\nimport { NullCommandValue } from \"./commands/NullCommandValue.js\";\n\nexport class GetCommandConverter implements ICommandConverter {\n    public readonly name: string = \"get\";\n\n    public can(input: IDynamoDbCommand): boolean {\n        return input instanceof GetCommand;\n    }\n\n    public convert() {\n        return new NullCommandValue();\n    }\n}\n\nexport const createGetCommandConverter = (): ICommandConverter => {\n    return new GetCommandConverter();\n};\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,iBAAA,GAAAD,OAAA;AAEO,MAAME,mBAAmB,CAA8B;EAC1CC,IAAI,GAAW,KAAK;EAE7BC,GAAGA,CAACC,KAAuB,EAAW;IACzC,OAAOA,KAAK,YAAYC,iBAAU;EACtC;EAEOC,OAAOA,CAAA,EAAG;IACb,OAAO,IAAIC,kCAAgB,CAAC,CAAC;EACjC;AACJ;AAACC,OAAA,CAAAP,mBAAA,GAAAA,mBAAA;AAEM,MAAMQ,yBAAyB,GAAGA,CAAA,KAAyB;EAC9D,OAAO,IAAIR,mBAAmB,CAAC,CAAC;AACpC,CAAC;AAACO,OAAA,CAAAC,yBAAA,GAAAA,yBAAA","ignoreList":[]}

package/sync/handler/converter/PutCommandConverter.d.ts

@@ -0,0 +1,9 @@
+import { PutCommand } from "@webiny/aws-sdk/client-dynamodb/index.js";
+import type { ICommandConverter, IDynamoDbCommand } from "../../types.js";
+import { PutCommandValue } from "./commands/PutCommandValue.js";
+export declare class PutCommandConverter implements ICommandConverter {
+    readonly name: string;
+    can(input: IDynamoDbCommand): boolean;
+    convert(input: PutCommand): PutCommandValue;
+}
+export declare const createPutCommandConverter: () => ICommandConverter;

package/sync/handler/converter/PutCommandConverter.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPutCommandConverter = exports.PutCommandConverter = void 0;
+var _index = require("@webiny/aws-sdk/client-dynamodb/index.js");
+var _PutCommandValue = require("./commands/PutCommandValue.js");
+class PutCommandConverter {
+  name = "put";
+  can(input) {
+    return input instanceof _index.PutCommand;
+  }
+  convert(input) {
+    return new _PutCommandValue.PutCommandValue(input);
+  }
+}
+exports.PutCommandConverter = PutCommandConverter;
+const createPutCommandConverter = () => {
+  return new PutCommandConverter();
+};
+exports.createPutCommandConverter = createPutCommandConverter;
+
+//# sourceMappingURL=PutCommandConverter.js.map

package/sync/handler/converter/PutCommandConverter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_index","require","_PutCommandValue","PutCommandConverter","name","can","input","PutCommand","convert","PutCommandValue","exports","createPutCommandConverter"],"sources":["PutCommandConverter.ts"],"sourcesContent":["import { PutCommand } from \"@webiny/aws-sdk/client-dynamodb/index.js\";\nimport type { ICommandConverter, IDynamoDbCommand } from \"../../types.js\";\nimport { PutCommandValue } from \"./commands/PutCommandValue.js\";\n\nexport class PutCommandConverter implements ICommandConverter {\n    public readonly name: string = \"put\";\n\n    public can(input: IDynamoDbCommand): boolean {\n        return input instanceof PutCommand;\n    }\n    public convert(input: PutCommand) {\n        return new PutCommandValue(input);\n    }\n}\n\nexport const createPutCommandConverter = (): ICommandConverter => {\n    return new PutCommandConverter();\n};\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,gBAAA,GAAAD,OAAA;AAEO,MAAME,mBAAmB,CAA8B;EAC1CC,IAAI,GAAW,KAAK;EAE7BC,GAAGA,CAACC,KAAuB,EAAW;IACzC,OAAOA,KAAK,YAAYC,iBAAU;EACtC;EACOC,OAAOA,CAACF,KAAiB,EAAE;IAC9B,OAAO,IAAIG,gCAAe,CAACH,KAAK,CAAC;EACrC;AACJ;AAACI,OAAA,CAAAP,mBAAA,GAAAA,mBAAA;AAEM,MAAMQ,yBAAyB,GAAGA,CAAA,KAAyB;EAC9D,OAAO,IAAIR,mBAAmB,CAAC,CAAC;AACpC,CAAC;AAACO,OAAA,CAAAC,yBAAA,GAAAA,yBAAA","ignoreList":[]}

package/sync/handler/converter/QueryCommandConverter.d.ts

@@ -0,0 +1,8 @@
+import type { ICommandConverter, IDynamoDbCommand } from "../../types.js";
+import { NullCommandValue } from "./commands/NullCommandValue.js";
+export declare class QueryCommandConverter implements ICommandConverter {
+    readonly name: string;
+    can(input: IDynamoDbCommand): boolean;
+    convert(): NullCommandValue;
+}
+export declare const createQueryCommandConverter: () => ICommandConverter;

package/sync/handler/converter/QueryCommandConverter.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createQueryCommandConverter = exports.QueryCommandConverter = void 0;
+var _index = require("@webiny/aws-sdk/client-dynamodb/index.js");
+var _NullCommandValue = require("./commands/NullCommandValue.js");
+class QueryCommandConverter {
+  name = "query";
+  can(input) {
+    return input instanceof _index.QueryCommand || input.constructor?.name === "QueryCommand";
+  }
+  convert() {
+    return new _NullCommandValue.NullCommandValue();
+  }
+}
+exports.QueryCommandConverter = QueryCommandConverter;
+const createQueryCommandConverter = () => {
+  return new QueryCommandConverter();
+};
+exports.createQueryCommandConverter = createQueryCommandConverter;
+
+//# sourceMappingURL=QueryCommandConverter.js.map

package/sync/handler/converter/QueryCommandConverter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_index","require","_NullCommandValue","QueryCommandConverter","name","can","input","QueryCommand","constructor","convert","NullCommandValue","exports","createQueryCommandConverter"],"sources":["QueryCommandConverter.ts"],"sourcesContent":["import { QueryCommand } from \"@webiny/aws-sdk/client-dynamodb/index.js\";\nimport type { ICommandConverter, IDynamoDbCommand } from \"../../types.js\";\nimport { NullCommandValue } from \"./commands/NullCommandValue.js\";\n\nexport class QueryCommandConverter implements ICommandConverter {\n    public readonly name: string = \"query\";\n\n    public can(input: IDynamoDbCommand): boolean {\n        return input instanceof QueryCommand || input.constructor?.name === \"QueryCommand\";\n    }\n\n    public convert() {\n        return new NullCommandValue();\n    }\n}\n\nexport const createQueryCommandConverter = (): ICommandConverter => {\n    return new QueryCommandConverter();\n};\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,iBAAA,GAAAD,OAAA;AAEO,MAAME,qBAAqB,CAA8B;EAC5CC,IAAI,GAAW,OAAO;EAE/BC,GAAGA,CAACC,KAAuB,EAAW;IACzC,OAAOA,KAAK,YAAYC,mBAAY,IAAID,KAAK,CAACE,WAAW,EAAEJ,IAAI,KAAK,cAAc;EACtF;EAEOK,OAAOA,CAAA,EAAG;IACb,OAAO,IAAIC,kCAAgB,CAAC,CAAC;EACjC;AACJ;AAACC,OAAA,CAAAR,qBAAA,GAAAA,qBAAA;AAEM,MAAMS,2BAA2B,GAAGA,CAAA,KAAyB;EAChE,OAAO,IAAIT,qBAAqB,CAAC,CAAC;AACtC,CAAC;AAACQ,OAAA,CAAAC,2BAAA,GAAAA,2BAAA","ignoreList":[]}

package/sync/handler/converter/ScanCommandConverter.d.ts

@@ -0,0 +1,8 @@
+import type { ICommandConverter, IDynamoDbCommand } from "../../types.js";
+import { NullCommandValue } from "./commands/NullCommandValue.js";
+export declare class ScanCommandConverter implements ICommandConverter {
+    readonly name: string;
+    can(input: IDynamoDbCommand): boolean;
+    convert(): NullCommandValue;
+}
+export declare const createScanCommandConverter: () => ICommandConverter;

package/sync/handler/converter/ScanCommandConverter.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createScanCommandConverter = exports.ScanCommandConverter = void 0;
+var _index = require("@webiny/aws-sdk/client-dynamodb/index.js");
+var _NullCommandValue = require("./commands/NullCommandValue.js");
+class ScanCommandConverter {
+  name = "query";
+  can(input) {
+    return input instanceof _index.ScanCommand;
+  }
+  convert() {
+    return new _NullCommandValue.NullCommandValue();
+  }
+}
+exports.ScanCommandConverter = ScanCommandConverter;
+const createScanCommandConverter = () => {
+  return new ScanCommandConverter();
+};
+exports.createScanCommandConverter = createScanCommandConverter;
+
+//# sourceMappingURL=ScanCommandConverter.js.map

package/sync/handler/converter/ScanCommandConverter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_index","require","_NullCommandValue","ScanCommandConverter","name","can","input","ScanCommand","convert","NullCommandValue","exports","createScanCommandConverter"],"sources":["ScanCommandConverter.ts"],"sourcesContent":["import { ScanCommand } from \"@webiny/aws-sdk/client-dynamodb/index.js\";\nimport type { ICommandConverter, IDynamoDbCommand } from \"../../types.js\";\nimport { NullCommandValue } from \"./commands/NullCommandValue.js\";\n\nexport class ScanCommandConverter implements ICommandConverter {\n    public readonly name: string = \"query\";\n\n    public can(input: IDynamoDbCommand): boolean {\n        return input instanceof ScanCommand;\n    }\n\n    public convert() {\n        return new NullCommandValue();\n    }\n}\n\nexport const createScanCommandConverter = (): ICommandConverter => {\n    return new ScanCommandConverter();\n};\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,iBAAA,GAAAD,OAAA;AAEO,MAAME,oBAAoB,CAA8B;EAC3CC,IAAI,GAAW,OAAO;EAE/BC,GAAGA,CAACC,KAAuB,EAAW;IACzC,OAAOA,KAAK,YAAYC,kBAAW;EACvC;EAEOC,OAAOA,CAAA,EAAG;IACb,OAAO,IAAIC,kCAAgB,CAAC,CAAC;EACjC;AACJ;AAACC,OAAA,CAAAP,oBAAA,GAAAA,oBAAA;AAEM,MAAMQ,0BAA0B,GAAGA,CAAA,KAAyB;EAC/D,OAAO,IAAIR,oBAAoB,CAAC,CAAC;AACrC,CAAC;AAACO,OAAA,CAAAC,0BAAA,GAAAA,0BAAA","ignoreList":[]}

package/sync/handler/converter/UpdateCommandConverter.d.ts

@@ -0,0 +1,9 @@
+import { UpdateCommand } from "@webiny/aws-sdk/client-dynamodb/index.js";
+import type { ICommandConverter, IDynamoDbCommand } from "../../types.js";
+import { UpdateCommandValue } from "./commands/UpdateCommandValue.js";
+export declare class UpdateCommandConverter implements ICommandConverter {
+    readonly name: string;
+    can(input: IDynamoDbCommand): boolean;
+    convert(input: UpdateCommand): UpdateCommandValue;
+}
+export declare const createUpdateCommandConverter: () => ICommandConverter;

package/sync/handler/converter/UpdateCommandConverter.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createUpdateCommandConverter = exports.UpdateCommandConverter = void 0;
+var _index = require("@webiny/aws-sdk/client-dynamodb/index.js");
+var _UpdateCommandValue = require("./commands/UpdateCommandValue.js");
+class UpdateCommandConverter {
+  name = "update";
+  can(input) {
+    return input instanceof _index.UpdateCommand;
+  }
+  convert(input) {
+    return new _UpdateCommandValue.UpdateCommandValue(input);
+  }
+}
+exports.UpdateCommandConverter = UpdateCommandConverter;
+const createUpdateCommandConverter = () => {
+  return new UpdateCommandConverter();
+};
+exports.createUpdateCommandConverter = createUpdateCommandConverter;
+
+//# sourceMappingURL=UpdateCommandConverter.js.map