@webiny/api-sync-system 0.0.0-unstable.06b2ede40f

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

@@ -0,0 +1 @@
+{"version":3,"names":["_index","require","_UpdateCommandValue","UpdateCommandConverter","name","can","input","UpdateCommand","convert","UpdateCommandValue","exports","createUpdateCommandConverter"],"sources":["UpdateCommandConverter.ts"],"sourcesContent":["import { UpdateCommand } from \"@webiny/aws-sdk/client-dynamodb/index.js\";\nimport type { ICommandConverter, IDynamoDbCommand } from \"../../types.js\";\nimport { UpdateCommandValue } from \"./commands/UpdateCommandValue.js\";\n\nexport class UpdateCommandConverter implements ICommandConverter {\n    public readonly name: string = \"update\";\n\n    public can(input: IDynamoDbCommand): boolean {\n        return input instanceof UpdateCommand;\n    }\n    public convert(input: UpdateCommand) {\n        return new UpdateCommandValue(input);\n    }\n}\n\nexport const createUpdateCommandConverter = (): ICommandConverter => {\n    return new UpdateCommandConverter();\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/commands/BatchWriteCommandValue.d.ts

@@ -0,0 +1,9 @@
+import type { BatchWriteCommand } from "@webiny/aws-sdk/client-dynamodb";
+import type { ICommandValue, ICommandValueItemExtended } from "../../../types.js";
+import type { NonEmptyArray } from "@webiny/api/types.js";
+export declare class BatchWriteCommandValue implements ICommandValue {
+    readonly command = "batchWrite";
+    readonly items: ICommandValueItemExtended[];
+    constructor(input: BatchWriteCommand);
+    getItems(): NonEmptyArray<ICommandValueItemExtended> | null;
+}

package/sync/handler/converter/commands/BatchWriteCommandValue.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BatchWriteCommandValue = void 0;
+var _getTableType = require("../../../utils/getTableType.js");
+const convert = items => {
+  if (items.length === 0) {
+    return null;
+  }
+  return items;
+};
+class BatchWriteCommandValue {
+  command = "batchWrite";
+  items = [];
+  constructor(input) {
+    for (const tableName in input.input.RequestItems) {
+      const values = input.input.RequestItems[tableName];
+      for (const value of values) {
+        if (value.PutRequest?.Item) {
+          const item = value.PutRequest.Item;
+          this.items.push({
+            command: "put",
+            PK: item.PK,
+            SK: item.SK,
+            tableName,
+            tableType: (0, _getTableType.getTableType)(tableName),
+            input
+          });
+        } else if (value.DeleteRequest?.Key) {
+          const item = value.DeleteRequest.Key;
+          this.items.push({
+            command: "delete",
+            PK: item.PK,
+            SK: item.SK,
+            tableName,
+            tableType: (0, _getTableType.getTableType)(tableName),
+            input
+          });
+        }
+      }
+    }
+  }
+  getItems() {
+    return convert(this.items);
+  }
+}
+exports.BatchWriteCommandValue = BatchWriteCommandValue;
+
+//# sourceMappingURL=BatchWriteCommandValue.js.map

package/sync/handler/converter/commands/BatchWriteCommandValue.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_getTableType","require","convert","items","length","BatchWriteCommandValue","command","constructor","input","tableName","RequestItems","values","value","PutRequest","Item","item","push","PK","SK","tableType","getTableType","DeleteRequest","Key","getItems","exports"],"sources":["BatchWriteCommandValue.ts"],"sourcesContent":["import type { BatchWriteCommand } from \"@webiny/aws-sdk/client-dynamodb\";\nimport type { ICommandValue, ICommandValueItemExtended } from \"~/sync/types.js\";\nimport type { NonEmptyArray } from \"@webiny/api/types.js\";\nimport { getTableType } from \"~/sync/utils/getTableType.js\";\n\nconst convert = (\n    items: ICommandValueItemExtended[]\n): NonEmptyArray<ICommandValueItemExtended> | null => {\n    if (items.length === 0) {\n        return null;\n    }\n    return items as NonEmptyArray<ICommandValueItemExtended>;\n};\n\nexport class BatchWriteCommandValue implements ICommandValue {\n    public readonly command = \"batchWrite\";\n    public readonly items: ICommandValueItemExtended[] = [];\n\n    public constructor(input: BatchWriteCommand) {\n        for (const tableName in input.input.RequestItems) {\n            const values = input.input.RequestItems[tableName];\n            for (const value of values) {\n                if (value.PutRequest?.Item) {\n                    const item = value.PutRequest.Item;\n\n                    this.items.push({\n                        command: \"put\",\n                        PK: item.PK,\n                        SK: item.SK,\n                        tableName,\n                        tableType: getTableType(tableName),\n                        input\n                    });\n                } else if (value.DeleteRequest?.Key) {\n                    const item = value.DeleteRequest.Key;\n\n                    this.items.push({\n                        command: \"delete\",\n                        PK: item.PK,\n                        SK: item.SK,\n                        tableName,\n                        tableType: getTableType(tableName),\n                        input\n                    });\n                }\n            }\n        }\n    }\n\n    public getItems(): NonEmptyArray<ICommandValueItemExtended> | null {\n        return convert(this.items);\n    }\n}\n"],"mappings":";;;;;;AAGA,IAAAA,aAAA,GAAAC,OAAA;AAEA,MAAMC,OAAO,GACTC,KAAkC,IACgB;EAClD,IAAIA,KAAK,CAACC,MAAM,KAAK,CAAC,EAAE;IACpB,OAAO,IAAI;EACf;EACA,OAAOD,KAAK;AAChB,CAAC;AAEM,MAAME,sBAAsB,CAA0B;EACzCC,OAAO,GAAG,YAAY;EACtBH,KAAK,GAAgC,EAAE;EAEhDI,WAAWA,CAACC,KAAwB,EAAE;IACzC,KAAK,MAAMC,SAAS,IAAID,KAAK,CAACA,KAAK,CAACE,YAAY,EAAE;MAC9C,MAAMC,MAAM,GAAGH,KAAK,CAACA,KAAK,CAACE,YAAY,CAACD,SAAS,CAAC;MAClD,KAAK,MAAMG,KAAK,IAAID,MAAM,EAAE;QACxB,IAAIC,KAAK,CAACC,UAAU,EAAEC,IAAI,EAAE;UACxB,MAAMC,IAAI,GAAGH,KAAK,CAACC,UAAU,CAACC,IAAI;UAElC,IAAI,CAACX,KAAK,CAACa,IAAI,CAAC;YACZV,OAAO,EAAE,KAAK;YACdW,EAAE,EAAEF,IAAI,CAACE,EAAE;YACXC,EAAE,EAAEH,IAAI,CAACG,EAAE;YACXT,SAAS;YACTU,SAAS,EAAE,IAAAC,0BAAY,EAACX,SAAS,CAAC;YAClCD;UACJ,CAAC,CAAC;QACN,CAAC,MAAM,IAAII,KAAK,CAACS,aAAa,EAAEC,GAAG,EAAE;UACjC,MAAMP,IAAI,GAAGH,KAAK,CAACS,aAAa,CAACC,GAAG;UAEpC,IAAI,CAACnB,KAAK,CAACa,IAAI,CAAC;YACZV,OAAO,EAAE,QAAQ;YACjBW,EAAE,EAAEF,IAAI,CAACE,EAAE;YACXC,EAAE,EAAEH,IAAI,CAACG,EAAE;YACXT,SAAS;YACTU,SAAS,EAAE,IAAAC,0BAAY,EAACX,SAAS,CAAC;YAClCD;UACJ,CAAC,CAAC;QACN;MACJ;IACJ;EACJ;EAEOe,QAAQA,CAAA,EAAoD;IAC/D,OAAOrB,OAAO,CAAC,IAAI,CAACC,KAAK,CAAC;EAC9B;AACJ;AAACqB,OAAA,CAAAnB,sBAAA,GAAAA,sBAAA","ignoreList":[]}

package/sync/handler/converter/commands/DeleteCommandValue.d.ts

@@ -0,0 +1,9 @@
+import type { DeleteCommand } from "@webiny/aws-sdk/client-dynamodb";
+import type { ICommandValue, ICommandValueItemExtended } from "../../../types.js";
+import type { NonEmptyArray } from "@webiny/api/types.js";
+export declare class DeleteCommandValue implements ICommandValue {
+    readonly command = "delete";
+    readonly item: ICommandValueItemExtended;
+    constructor(input: DeleteCommand);
+    getItems(): NonEmptyArray<ICommandValueItemExtended>;
+}

package/sync/handler/converter/commands/DeleteCommandValue.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DeleteCommandValue = void 0;
+var _getTableType = require("../../../utils/getTableType.js");
+class DeleteCommandValue {
+  command = "delete";
+  constructor(input) {
+    const tableName = input.input.TableName;
+    this.item = {
+      command: this.command,
+      PK: input.input.Key.PK,
+      SK: input.input.Key.SK,
+      tableName,
+      tableType: (0, _getTableType.getTableType)(tableName),
+      input
+    };
+  }
+  getItems() {
+    return [this.item];
+  }
+}
+exports.DeleteCommandValue = DeleteCommandValue;
+
+//# sourceMappingURL=DeleteCommandValue.js.map

package/sync/handler/converter/commands/DeleteCommandValue.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_getTableType","require","DeleteCommandValue","command","constructor","input","tableName","TableName","item","PK","Key","SK","tableType","getTableType","getItems","exports"],"sources":["DeleteCommandValue.ts"],"sourcesContent":["import type { DeleteCommand } from \"@webiny/aws-sdk/client-dynamodb\";\nimport type { ICommandValue, ICommandValueItemExtended } from \"~/sync/types.js\";\nimport type { NonEmptyArray } from \"@webiny/api/types.js\";\nimport { getTableType } from \"~/sync/utils/getTableType.js\";\n\nexport class DeleteCommandValue implements ICommandValue {\n    public readonly command = \"delete\";\n    public readonly item: ICommandValueItemExtended;\n\n    public constructor(input: DeleteCommand) {\n        const tableName = input.input.TableName as string;\n        this.item = {\n            command: this.command,\n            PK: input.input.Key!.PK,\n            SK: input.input.Key!.SK,\n            tableName,\n            tableType: getTableType(tableName),\n            input\n        };\n    }\n\n    public getItems(): NonEmptyArray<ICommandValueItemExtended> {\n        return [this.item];\n    }\n}\n"],"mappings":";;;;;;AAGA,IAAAA,aAAA,GAAAC,OAAA;AAEO,MAAMC,kBAAkB,CAA0B;EACrCC,OAAO,GAAG,QAAQ;EAG3BC,WAAWA,CAACC,KAAoB,EAAE;IACrC,MAAMC,SAAS,GAAGD,KAAK,CAACA,KAAK,CAACE,SAAmB;IACjD,IAAI,CAACC,IAAI,GAAG;MACRL,OAAO,EAAE,IAAI,CAACA,OAAO;MACrBM,EAAE,EAAEJ,KAAK,CAACA,KAAK,CAACK,GAAG,CAAED,EAAE;MACvBE,EAAE,EAAEN,KAAK,CAACA,KAAK,CAACK,GAAG,CAAEC,EAAE;MACvBL,SAAS;MACTM,SAAS,EAAE,IAAAC,0BAAY,EAACP,SAAS,CAAC;MAClCD;IACJ,CAAC;EACL;EAEOS,QAAQA,CAAA,EAA6C;IACxD,OAAO,CAAC,IAAI,CAACN,IAAI,CAAC;EACtB;AACJ;AAACO,OAAA,CAAAb,kBAAA,GAAAA,kBAAA","ignoreList":[]}

package/sync/handler/converter/commands/NullCommandValue.d.ts

@@ -0,0 +1,8 @@
+import type { ICommandValue } from "../../../types.js";
+export declare class NullCommandValue implements ICommandValue {
+    /**
+     * Does not matter what will be here, we will not use it.
+     */
+    readonly command = "null";
+    getItems(): null;
+}

package/sync/handler/converter/commands/NullCommandValue.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NullCommandValue = void 0;
+class NullCommandValue {
+  /**
+   * Does not matter what will be here, we will not use it.
+   */
+  command = "null";
+  getItems() {
+    return null;
+  }
+}
+exports.NullCommandValue = NullCommandValue;
+
+//# sourceMappingURL=NullCommandValue.js.map

package/sync/handler/converter/commands/NullCommandValue.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NullCommandValue","command","getItems","exports"],"sources":["NullCommandValue.ts"],"sourcesContent":["import type { ICommandValue } from \"~/sync/types.js\";\n\nexport class NullCommandValue implements ICommandValue {\n    /**\n     * Does not matter what will be here, we will not use it.\n     */\n    public readonly command = \"null\";\n\n    public getItems(): null {\n        return null;\n    }\n}\n"],"mappings":";;;;;;AAEO,MAAMA,gBAAgB,CAA0B;EACnD;AACJ;AACA;EACoBC,OAAO,GAAG,MAAM;EAEzBC,QAAQA,CAAA,EAAS;IACpB,OAAO,IAAI;EACf;AACJ;AAACC,OAAA,CAAAH,gBAAA,GAAAA,gBAAA","ignoreList":[]}

package/sync/handler/converter/commands/PutCommandValue.d.ts

@@ -0,0 +1,9 @@
+import type { PutCommand } from "@webiny/aws-sdk/client-dynamodb";
+import type { ICommandValue, ICommandValueItemExtended } from "../../../types.js";
+import type { NonEmptyArray } from "@webiny/api/types.js";
+export declare class PutCommandValue implements ICommandValue {
+    readonly command = "put";
+    readonly item: ICommandValueItemExtended;
+    constructor(input: PutCommand);
+    getItems(): NonEmptyArray<ICommandValueItemExtended>;
+}

package/sync/handler/converter/commands/PutCommandValue.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PutCommandValue = void 0;
+var _getTableType = require("../../../utils/getTableType.js");
+class PutCommandValue {
+  command = "put";
+  constructor(input) {
+    const tableName = input.input.TableName;
+    this.item = {
+      command: this.command,
+      PK: input.input.Item.PK,
+      SK: input.input.Item.SK,
+      tableName,
+      tableType: (0, _getTableType.getTableType)(tableName),
+      input
+    };
+  }
+  getItems() {
+    return [this.item];
+  }
+}
+exports.PutCommandValue = PutCommandValue;
+
+//# sourceMappingURL=PutCommandValue.js.map

package/sync/handler/converter/commands/PutCommandValue.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_getTableType","require","PutCommandValue","command","constructor","input","tableName","TableName","item","PK","Item","SK","tableType","getTableType","getItems","exports"],"sources":["PutCommandValue.ts"],"sourcesContent":["import type { PutCommand } from \"@webiny/aws-sdk/client-dynamodb\";\nimport type { ICommandValue, ICommandValueItemExtended } from \"~/sync/types.js\";\nimport type { NonEmptyArray } from \"@webiny/api/types.js\";\nimport { getTableType } from \"~/sync/utils/getTableType.js\";\n\nexport class PutCommandValue implements ICommandValue {\n    public readonly command = \"put\";\n    public readonly item: ICommandValueItemExtended;\n\n    public constructor(input: PutCommand) {\n        const tableName = input.input.TableName as string;\n        this.item = {\n            command: this.command,\n            PK: input.input.Item!.PK,\n            SK: input.input.Item!.SK,\n            tableName,\n            tableType: getTableType(tableName),\n            input\n        };\n    }\n\n    public getItems(): NonEmptyArray<ICommandValueItemExtended> {\n        return [this.item];\n    }\n}\n"],"mappings":";;;;;;AAGA,IAAAA,aAAA,GAAAC,OAAA;AAEO,MAAMC,eAAe,CAA0B;EAClCC,OAAO,GAAG,KAAK;EAGxBC,WAAWA,CAACC,KAAiB,EAAE;IAClC,MAAMC,SAAS,GAAGD,KAAK,CAACA,KAAK,CAACE,SAAmB;IACjD,IAAI,CAACC,IAAI,GAAG;MACRL,OAAO,EAAE,IAAI,CAACA,OAAO;MACrBM,EAAE,EAAEJ,KAAK,CAACA,KAAK,CAACK,IAAI,CAAED,EAAE;MACxBE,EAAE,EAAEN,KAAK,CAACA,KAAK,CAACK,IAAI,CAAEC,EAAE;MACxBL,SAAS;MACTM,SAAS,EAAE,IAAAC,0BAAY,EAACP,SAAS,CAAC;MAClCD;IACJ,CAAC;EACL;EAEOS,QAAQA,CAAA,EAA6C;IACxD,OAAO,CAAC,IAAI,CAACN,IAAI,CAAC;EACtB;AACJ;AAACO,OAAA,CAAAb,eAAA,GAAAA,eAAA","ignoreList":[]}

package/sync/handler/converter/commands/UpdateCommandValue.d.ts

@@ -0,0 +1,9 @@
+import type { UpdateCommand } from "@webiny/aws-sdk/client-dynamodb";
+import type { ICommandValue, ICommandValueItemExtended } from "../../../types.js";
+import type { NonEmptyArray } from "@webiny/api/types.js";
+export declare class UpdateCommandValue implements ICommandValue {
+    readonly command = "update";
+    readonly item: ICommandValueItemExtended;
+    constructor(input: UpdateCommand);
+    getItems(): NonEmptyArray<ICommandValueItemExtended>;
+}

package/sync/handler/converter/commands/UpdateCommandValue.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UpdateCommandValue = void 0;
+var _getTableType = require("../../../utils/getTableType.js");
+class UpdateCommandValue {
+  command = "update";
+  constructor(input) {
+    const tableName = input.input.TableName;
+    this.item = {
+      command: this.command,
+      PK: input.input.Key.PK,
+      SK: input.input.Key.SK,
+      tableName,
+      tableType: (0, _getTableType.getTableType)(tableName),
+      input
+    };
+  }
+  getItems() {
+    return [this.item];
+  }
+}
+exports.UpdateCommandValue = UpdateCommandValue;
+
+//# sourceMappingURL=UpdateCommandValue.js.map

package/sync/handler/converter/commands/UpdateCommandValue.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_getTableType","require","UpdateCommandValue","command","constructor","input","tableName","TableName","item","PK","Key","SK","tableType","getTableType","getItems","exports"],"sources":["UpdateCommandValue.ts"],"sourcesContent":["import type { UpdateCommand } from \"@webiny/aws-sdk/client-dynamodb\";\nimport type { ICommandValue, ICommandValueItemExtended } from \"~/sync/types.js\";\nimport type { NonEmptyArray } from \"@webiny/api/types.js\";\nimport { getTableType } from \"~/sync/utils/getTableType.js\";\n\nexport class UpdateCommandValue implements ICommandValue {\n    public readonly command = \"update\";\n    public readonly item: ICommandValueItemExtended;\n\n    public constructor(input: UpdateCommand) {\n        const tableName = input.input.TableName as string;\n        this.item = {\n            command: this.command,\n            PK: input.input.Key!.PK,\n            SK: input.input.Key!.SK,\n            tableName,\n            tableType: getTableType(tableName),\n            input\n        };\n    }\n\n    public getItems(): NonEmptyArray<ICommandValueItemExtended> {\n        return [this.item];\n    }\n}\n"],"mappings":";;;;;;AAGA,IAAAA,aAAA,GAAAC,OAAA;AAEO,MAAMC,kBAAkB,CAA0B;EACrCC,OAAO,GAAG,QAAQ;EAG3BC,WAAWA,CAACC,KAAoB,EAAE;IACrC,MAAMC,SAAS,GAAGD,KAAK,CAACA,KAAK,CAACE,SAAmB;IACjD,IAAI,CAACC,IAAI,GAAG;MACRL,OAAO,EAAE,IAAI,CAACA,OAAO;MACrBM,EAAE,EAAEJ,KAAK,CAACA,KAAK,CAACK,GAAG,CAAED,EAAE;MACvBE,EAAE,EAAEN,KAAK,CAACA,KAAK,CAACK,GAAG,CAAEC,EAAE;MACvBL,SAAS;MACTM,SAAS,EAAE,IAAAC,0BAAY,EAACP,SAAS,CAAC;MAClCD;IACJ,CAAC;EACL;EAEOS,QAAQA,CAAA,EAA6C;IACxD,OAAO,CAAC,IAAI,CAACN,IAAI,CAAC;EACtB;AACJ;AAACO,OAAA,CAAAb,kBAAA,GAAAA,kBAAA","ignoreList":[]}

package/sync/handler/types.d.ts

@@ -0,0 +1,18 @@
+import type { NonEmptyArray } from "@webiny/api/types";
+import type { DynamoDBTableType, ExtendedCommandType } from "../../types.js";
+import type { ISystem } from "../types";
+export interface IDetailItem {
+    PK: string;
+    SK: string;
+    command: ExtendedCommandType;
+    /**
+     * There will be multiple tables that will get populated through the system (regular table and elasticsearch for start).
+     */
+    tableName: string;
+    tableType: DynamoDBTableType;
+}
+export interface IDetail {
+    items: NonEmptyArray<IDetailItem>;
+    source: ISystem;
+    id: string;
+}

package/sync/handler/types.js

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+//# sourceMappingURL=types.js.map

package/sync/handler/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import type { NonEmptyArray } from \"@webiny/api/types\";\nimport type { DynamoDBTableType, ExtendedCommandType } from \"~/types.js\";\nimport type { ISystem } from \"../types\";\n\nexport interface IDetailItem {\n    PK: string;\n    SK: string;\n    command: ExtendedCommandType;\n    /**\n     * There will be multiple tables that will get populated through the system (regular table and elasticsearch for start).\n     */\n    tableName: string;\n    tableType: DynamoDBTableType;\n}\n\nexport interface IDetail {\n    items: NonEmptyArray<IDetailItem>;\n    source: ISystem;\n    id: string;\n}\n"],"mappings":"","ignoreList":[]}

package/sync/plugins/FilterOutRecordPlugin.d.ts

@@ -0,0 +1,23 @@
+import { Plugin } from "@webiny/plugins/Plugin.js";
+import type { ICommandValueItemExtended } from "../types.js";
+export interface IFilterOutRecordPluginCallable {
+    (record: ICommandValueItemExtended): boolean;
+}
+export interface IFilterOutRecordPluginParams {
+    /**
+     * Filter out returns true if the record should be filtered out.
+     */
+    filterOut: IFilterOutRecordPluginCallable;
+    name: string;
+}
+export declare class FilterOutRecordPlugin extends Plugin {
+    static readonly type: string;
+    private readonly cb;
+    constructor(params: IFilterOutRecordPluginParams);
+    /**
+     * If method returns `true`, the record will be filtered out.
+     */
+    execute(item: ICommandValueItemExtended): boolean;
+    static createName(name: string): string;
+}
+export declare const createFilterOutRecordPlugin: (params: IFilterOutRecordPluginParams) => FilterOutRecordPlugin;

package/sync/plugins/FilterOutRecordPlugin.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFilterOutRecordPlugin = exports.FilterOutRecordPlugin = void 0;
+var _Plugin = require("@webiny/plugins/Plugin.js");
+class FilterOutRecordPlugin extends _Plugin.Plugin {
+  static type = "sync.filterOut.record";
+  constructor(params) {
+    super();
+    this.name = params.name;
+    this.cb = params.filterOut;
+  }
+  /**
+   * If method returns `true`, the record will be filtered out.
+   */
+  execute(item) {
+    return this.cb(item);
+  }
+  static createName(name) {
+    return `${FilterOutRecordPlugin.type}.${name}`;
+  }
+}
+exports.FilterOutRecordPlugin = FilterOutRecordPlugin;
+const createFilterOutRecordPlugin = params => {
+  return new FilterOutRecordPlugin(params);
+};
+exports.createFilterOutRecordPlugin = createFilterOutRecordPlugin;
+
+//# sourceMappingURL=FilterOutRecordPlugin.js.map

package/sync/plugins/FilterOutRecordPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_Plugin","require","FilterOutRecordPlugin","Plugin","type","constructor","params","name","cb","filterOut","execute","item","createName","exports","createFilterOutRecordPlugin"],"sources":["FilterOutRecordPlugin.ts"],"sourcesContent":["import { Plugin } from \"@webiny/plugins/Plugin.js\";\nimport type { ICommandValueItemExtended } from \"~/sync/types.js\";\n\nexport interface IFilterOutRecordPluginCallable {\n    (record: ICommandValueItemExtended): boolean;\n}\n\nexport interface IFilterOutRecordPluginParams {\n    /**\n     * Filter out returns true if the record should be filtered out.\n     */\n    filterOut: IFilterOutRecordPluginCallable;\n    name: string;\n}\n\nexport class FilterOutRecordPlugin extends Plugin {\n    public static override readonly type: string = \"sync.filterOut.record\";\n\n    private readonly cb: IFilterOutRecordPluginCallable;\n\n    public constructor(params: IFilterOutRecordPluginParams) {\n        super();\n        this.name = params.name;\n        this.cb = params.filterOut;\n    }\n    /**\n     * If method returns `true`, the record will be filtered out.\n     */\n    public execute(item: ICommandValueItemExtended): boolean {\n        return this.cb(item);\n    }\n\n    public static createName(name: string): string {\n        return `${FilterOutRecordPlugin.type}.${name}`;\n    }\n}\n\nexport const createFilterOutRecordPlugin = (\n    params: IFilterOutRecordPluginParams\n): FilterOutRecordPlugin => {\n    return new FilterOutRecordPlugin(params);\n};\n"],"mappings":";;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AAeO,MAAMC,qBAAqB,SAASC,cAAM,CAAC;EAC9C,OAAgCC,IAAI,GAAW,uBAAuB;EAI/DC,WAAWA,CAACC,MAAoC,EAAE;IACrD,KAAK,CAAC,CAAC;IACP,IAAI,CAACC,IAAI,GAAGD,MAAM,CAACC,IAAI;IACvB,IAAI,CAACC,EAAE,GAAGF,MAAM,CAACG,SAAS;EAC9B;EACA;AACJ;AACA;EACWC,OAAOA,CAACC,IAA+B,EAAW;IACrD,OAAO,IAAI,CAACH,EAAE,CAACG,IAAI,CAAC;EACxB;EAEA,OAAcC,UAAUA,CAACL,IAAY,EAAU;IAC3C,OAAO,GAAGL,qBAAqB,CAACE,IAAI,IAAIG,IAAI,EAAE;EAClD;AACJ;AAACM,OAAA,CAAAX,qBAAA,GAAAA,qBAAA;AAEM,MAAMY,2BAA2B,GACpCR,MAAoC,IACZ;EACxB,OAAO,IAAIJ,qBAAqB,CAACI,MAAM,CAAC;AAC5C,CAAC;AAACO,OAAA,CAAAC,2BAAA,GAAAA,2BAAA","ignoreList":[]}

package/sync/requestPlugin.d.ts

@@ -0,0 +1,9 @@
+import type { DynamoDBDocument } from "@webiny/aws-sdk/client-dynamodb/index.js";
+import type { ICommandConverter, IGetEventBridgeCallable, ISystem } from "./types.js";
+export interface ICreateSyncSystemHandlerOnRequestPluginParams {
+    getDocumentClient(): Pick<DynamoDBDocument, "send">;
+    getEventBridgeClient: IGetEventBridgeCallable;
+    system: ISystem;
+    commandConverters?: ICommandConverter[];
+}
+export declare const createSyncSystemHandlerOnRequestPlugin: (params: ICreateSyncSystemHandlerOnRequestPluginParams) => import("@webiny/handler").HandlerOnRequestPlugin<import("@webiny/handler/types.js").Context>;

package/sync/requestPlugin.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSyncSystemHandlerOnRequestPlugin = void 0;
+var _handler = require("@webiny/handler");
+var _manifest = require("./utils/manifest.js");
+var _attachToDynamoDbDocument = require("./attachToDynamoDbDocument.js");
+var _createSendDataToEventBridgeOnRequestEnd = require("./createSendDataToEventBridgeOnRequestEnd.js");
+var _createHandler = require("./createHandler.js");
+var _exception = require("@webiny/utils/exception.js");
+const createSyncSystemHandlerOnRequestPlugin = params => {
+  return (0, _handler.createHandlerOnRequest)(async (_, __, context) => {
+    const {
+      data: manifest,
+      error
+    } = await (0, _manifest.getManifest)(params);
+    if (error) {
+      console.error("Error happened when fetching manifest.");
+      console.log(JSON.stringify({
+        error: (0, _exception.convertException)(error)
+      }));
+      return;
+    } else if (!manifest?.sync?.region) {
+      console.error("There is no manifest.");
+      console.log(JSON.stringify({
+        manifest
+      }));
+      return;
+    }
+    const {
+      handler
+    } = (0, _createHandler.createHandler)({
+      getEventBridgeClient: () => {
+        return params.getEventBridgeClient({
+          region: manifest.sync.region
+        });
+      },
+      system: params.system,
+      manifest,
+      commandConverters: params.commandConverters,
+      getPlugins: () => {
+        return context.plugins;
+      }
+    });
+    (0, _attachToDynamoDbDocument.attachToDynamoDbDocument)({
+      handler
+    });
+    context.plugins.register([
+    /**
+     * When request ends, send the data to the EventBridge.
+     */
+    (0, _createSendDataToEventBridgeOnRequestEnd.createSendDataToEventBridgeOnRequestEnd)(handler)]);
+  });
+};
+exports.createSyncSystemHandlerOnRequestPlugin = createSyncSystemHandlerOnRequestPlugin;
+
+//# sourceMappingURL=requestPlugin.js.map

package/sync/requestPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_handler","require","_manifest","_attachToDynamoDbDocument","_createSendDataToEventBridgeOnRequestEnd","_createHandler","_exception","createSyncSystemHandlerOnRequestPlugin","params","createHandlerOnRequest","_","__","context","data","manifest","error","getManifest","console","log","JSON","stringify","convertException","sync","region","handler","createHandler","getEventBridgeClient","system","commandConverters","getPlugins","plugins","attachToDynamoDbDocument","register","createSendDataToEventBridgeOnRequestEnd","exports"],"sources":["requestPlugin.ts"],"sourcesContent":["import type { DynamoDBDocument } from \"@webiny/aws-sdk/client-dynamodb/index.js\";\nimport type { ICommandConverter, IGetEventBridgeCallable, ISystem } from \"~/sync/types.js\";\nimport { createHandlerOnRequest } from \"@webiny/handler\";\nimport { getManifest } from \"~/sync/utils/manifest.js\";\nimport { attachToDynamoDbDocument } from \"~/sync/attachToDynamoDbDocument.js\";\nimport { createSendDataToEventBridgeOnRequestEnd } from \"~/sync/createSendDataToEventBridgeOnRequestEnd.js\";\nimport { createHandler } from \"./createHandler.js\";\nimport { convertException } from \"@webiny/utils/exception.js\";\n\nexport interface ICreateSyncSystemHandlerOnRequestPluginParams {\n    getDocumentClient(): Pick<DynamoDBDocument, \"send\">;\n    getEventBridgeClient: IGetEventBridgeCallable;\n    system: ISystem;\n    commandConverters?: ICommandConverter[];\n}\n\nexport const createSyncSystemHandlerOnRequestPlugin = (\n    params: ICreateSyncSystemHandlerOnRequestPluginParams\n) => {\n    return createHandlerOnRequest(async (_, __, context) => {\n        const { data: manifest, error } = await getManifest(params);\n        if (error) {\n            console.error(\"Error happened when fetching manifest.\");\n            console.log(\n                JSON.stringify({\n                    error: convertException(error)\n                })\n            );\n            return;\n        } else if (!manifest?.sync?.region) {\n            console.error(\"There is no manifest.\");\n            console.log(\n                JSON.stringify({\n                    manifest\n                })\n            );\n            return;\n        }\n\n        const { handler } = createHandler({\n            getEventBridgeClient: () => {\n                return params.getEventBridgeClient({\n                    region: manifest.sync.region\n                });\n            },\n            system: params.system,\n            manifest,\n            commandConverters: params.commandConverters,\n            getPlugins: () => {\n                return context.plugins;\n            }\n        });\n\n        attachToDynamoDbDocument({\n            handler\n        });\n        context.plugins.register([\n            /**\n             * When request ends, send the data to the EventBridge.\n             */\n            createSendDataToEventBridgeOnRequestEnd(handler)\n        ]);\n    });\n};\n"],"mappings":";;;;;;AAEA,IAAAA,QAAA,GAAAC,OAAA;AACA,IAAAC,SAAA,GAAAD,OAAA;AACA,IAAAE,yBAAA,GAAAF,OAAA;AACA,IAAAG,wCAAA,GAAAH,OAAA;AACA,IAAAI,cAAA,GAAAJ,OAAA;AACA,IAAAK,UAAA,GAAAL,OAAA;AASO,MAAMM,sCAAsC,GAC/CC,MAAqD,IACpD;EACD,OAAO,IAAAC,+BAAsB,EAAC,OAAOC,CAAC,EAAEC,EAAE,EAAEC,OAAO,KAAK;IACpD,MAAM;MAAEC,IAAI,EAAEC,QAAQ;MAAEC;IAAM,CAAC,GAAG,MAAM,IAAAC,qBAAW,EAACR,MAAM,CAAC;IAC3D,IAAIO,KAAK,EAAE;MACPE,OAAO,CAACF,KAAK,CAAC,wCAAwC,CAAC;MACvDE,OAAO,CAACC,GAAG,CACPC,IAAI,CAACC,SAAS,CAAC;QACXL,KAAK,EAAE,IAAAM,2BAAgB,EAACN,KAAK;MACjC,CAAC,CACL,CAAC;MACD;IACJ,CAAC,MAAM,IAAI,CAACD,QAAQ,EAAEQ,IAAI,EAAEC,MAAM,EAAE;MAChCN,OAAO,CAACF,KAAK,CAAC,uBAAuB,CAAC;MACtCE,OAAO,CAACC,GAAG,CACPC,IAAI,CAACC,SAAS,CAAC;QACXN;MACJ,CAAC,CACL,CAAC;MACD;IACJ;IAEA,MAAM;MAAEU;IAAQ,CAAC,GAAG,IAAAC,4BAAa,EAAC;MAC9BC,oBAAoB,EAAEA,CAAA,KAAM;QACxB,OAAOlB,MAAM,CAACkB,oBAAoB,CAAC;UAC/BH,MAAM,EAAET,QAAQ,CAACQ,IAAI,CAACC;QAC1B,CAAC,CAAC;MACN,CAAC;MACDI,MAAM,EAAEnB,MAAM,CAACmB,MAAM;MACrBb,QAAQ;MACRc,iBAAiB,EAAEpB,MAAM,CAACoB,iBAAiB;MAC3CC,UAAU,EAAEA,CAAA,KAAM;QACd,OAAOjB,OAAO,CAACkB,OAAO;MAC1B;IACJ,CAAC,CAAC;IAEF,IAAAC,kDAAwB,EAAC;MACrBP;IACJ,CAAC,CAAC;IACFZ,OAAO,CAACkB,OAAO,CAACE,QAAQ,CAAC;IACrB;AACZ;AACA;IACY,IAAAC,gFAAuC,EAACT,OAAO,CAAC,CACnD,CAAC;EACN,CAAC,CAAC;AACN,CAAC;AAACU,OAAA,CAAA3B,sCAAA,GAAAA,sCAAA","ignoreList":[]}

package/sync/types.d.ts

@@ -0,0 +1,64 @@
+import type { NonEmptyArray } from "@webiny/api/types.js";
+import type { BatchGetCommand, BatchWriteCommand, DeleteCommand, GetCommand, PutCommand, QueryCommand, ScanCommand, UpdateCommand } from "@webiny/aws-sdk/client-dynamodb/index.js";
+import type { EventBridgeClient, EventBridgeClientConfig, PutEventsCommandOutput } from "@webiny/aws-sdk/client-eventbridge/index.js";
+import type { AllCommandType, DynamoDBTableType, ExtendedCommandType } from "../types.js";
+export interface IManifestData {
+    region: string;
+    eventBusName: string;
+    eventBusArn: string;
+}
+export interface IManifest {
+    sync: IManifestData;
+}
+export type IDynamoDbCommand = PutCommand | QueryCommand | ScanCommand | DeleteCommand | BatchWriteCommand | BatchGetCommand | GetCommand | UpdateCommand;
+export interface ICommandValueItem {
+    PK: string;
+    SK: string;
+    command: ExtendedCommandType;
+    tableName: string;
+    tableType: DynamoDBTableType;
+}
+export interface ICommandValueItemExtended extends ICommandValueItem {
+    input: IDynamoDbCommand;
+}
+export interface ICommandValue {
+    readonly command: AllCommandType;
+    getItems(): NonEmptyArray<ICommandValueItemExtended> | null;
+}
+export interface ICommand<Result extends ICommandValue = ICommandValue> {
+    name: string;
+    can(input: IDynamoDbCommand): boolean;
+    convert(input: IDynamoDbCommand): Result;
+}
+export interface ITable {
+    name: string;
+    arn: string;
+    type: DynamoDBTableType;
+}
+export interface ISystem {
+    name: string;
+    env: string;
+    variant?: string | undefined;
+    region: string;
+    version: string;
+}
+export interface IHandler {
+    readonly id: string;
+    flush(): Promise<PutEventsCommandOutput | null>;
+    add(input: IDynamoDbCommand): void;
+}
+export interface ICommandConverter<Result extends ICommandValue = ICommandValue> {
+    name: string;
+    can(input: IDynamoDbCommand): boolean;
+    convert(input: IDynamoDbCommand): Result;
+}
+export interface IHandlerConverter {
+    register(input: ICommandConverter | ICommandConverter[]): void;
+    convert(input: IDynamoDbCommand): ICommandValue;
+}
+export interface IGetEventBridgeCallableParams extends Omit<Partial<EventBridgeClientConfig>, "region"> {
+    region: string;
+}
+export interface IGetEventBridgeCallable {
+    (params: IGetEventBridgeCallableParams): Pick<EventBridgeClient, "send">;
+}

package/sync/types.js

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+//# sourceMappingURL=types.js.map

package/sync/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import type { NonEmptyArray } from \"@webiny/api/types.js\";\nimport type {\n    BatchGetCommand,\n    BatchWriteCommand,\n    DeleteCommand,\n    GetCommand,\n    PutCommand,\n    QueryCommand,\n    ScanCommand,\n    UpdateCommand\n} from \"@webiny/aws-sdk/client-dynamodb/index.js\";\nimport type {\n    EventBridgeClient,\n    EventBridgeClientConfig,\n    PutEventsCommandOutput\n} from \"@webiny/aws-sdk/client-eventbridge/index.js\";\nimport type { AllCommandType, DynamoDBTableType, ExtendedCommandType } from \"~/types.js\";\n\nexport interface IManifestData {\n    region: string;\n    eventBusName: string;\n    eventBusArn: string;\n}\n\nexport interface IManifest {\n    sync: IManifestData;\n}\n\nexport type IDynamoDbCommand =\n    | PutCommand\n    | QueryCommand\n    | ScanCommand\n    | DeleteCommand\n    | BatchWriteCommand\n    | BatchGetCommand\n    | GetCommand\n    | UpdateCommand;\n\nexport interface ICommandValueItem {\n    PK: string;\n    SK: string;\n    command: ExtendedCommandType;\n    tableName: string;\n    tableType: DynamoDBTableType;\n}\n\nexport interface ICommandValueItemExtended extends ICommandValueItem {\n    input: IDynamoDbCommand;\n}\n\nexport interface ICommandValue {\n    readonly command: AllCommandType;\n    getItems(): NonEmptyArray<ICommandValueItemExtended> | null;\n}\n\nexport interface ICommand<Result extends ICommandValue = ICommandValue> {\n    name: string;\n    can(input: IDynamoDbCommand): boolean;\n    convert(input: IDynamoDbCommand): Result;\n}\n\nexport interface ITable {\n    name: string;\n    arn: string;\n    type: DynamoDBTableType;\n}\n\nexport interface ISystem {\n    name: string;\n    env: string;\n    variant?: string | undefined;\n    region: string;\n    version: string;\n}\n\nexport interface IHandler {\n    readonly id: string;\n    flush(): Promise<PutEventsCommandOutput | null>;\n    add(input: IDynamoDbCommand): void;\n}\n\nexport interface ICommandConverter<Result extends ICommandValue = ICommandValue> {\n    name: string;\n    can(input: IDynamoDbCommand): boolean;\n    convert(input: IDynamoDbCommand): Result;\n}\n\nexport interface IHandlerConverter {\n    register(input: ICommandConverter | ICommandConverter[]): void;\n    convert(input: IDynamoDbCommand): ICommandValue;\n}\n\nexport interface IGetEventBridgeCallableParams\n    extends Omit<Partial<EventBridgeClientConfig>, \"region\"> {\n    region: string;\n}\n\nexport interface IGetEventBridgeCallable {\n    (params: IGetEventBridgeCallableParams): Pick<EventBridgeClient, \"send\">;\n}\n"],"mappings":"","ignoreList":[]}

package/sync/utils/getTableType.d.ts

@@ -0,0 +1,2 @@
+import { DynamoDBTableType } from "../../types.js";
+export declare const getTableType: (tableName: string) => DynamoDBTableType;

package/sync/utils/getTableType.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTableType = void 0;
+var _types = require("../../types.js");
+const getTableType = tableName => {
+  switch (tableName) {
+    case process.env.DB_TABLE:
+      return _types.DynamoDBTableType.REGULAR;
+    case process.env.DB_TABLE_ELASTICSEARCH:
+      return _types.DynamoDBTableType.ELASTICSEARCH;
+    case process.env.DB_TABLE_LOG:
+      return _types.DynamoDBTableType.LOG;
+    default:
+      return _types.DynamoDBTableType.UNKNOWN;
+  }
+};
+exports.getTableType = getTableType;
+
+//# sourceMappingURL=getTableType.js.map

package/sync/utils/getTableType.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_types","require","getTableType","tableName","process","env","DB_TABLE","DynamoDBTableType","REGULAR","DB_TABLE_ELASTICSEARCH","ELASTICSEARCH","DB_TABLE_LOG","LOG","UNKNOWN","exports"],"sources":["getTableType.ts"],"sourcesContent":["import { DynamoDBTableType } from \"~/types.js\";\n\nexport const getTableType = (tableName: string): DynamoDBTableType => {\n    switch (tableName) {\n        case process.env.DB_TABLE:\n            return DynamoDBTableType.REGULAR;\n        case process.env.DB_TABLE_ELASTICSEARCH:\n            return DynamoDBTableType.ELASTICSEARCH;\n        case process.env.DB_TABLE_LOG:\n            return DynamoDBTableType.LOG;\n        default:\n            return DynamoDBTableType.UNKNOWN;\n    }\n};\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEO,MAAMC,YAAY,GAAIC,SAAiB,IAAwB;EAClE,QAAQA,SAAS;IACb,KAAKC,OAAO,CAACC,GAAG,CAACC,QAAQ;MACrB,OAAOC,wBAAiB,CAACC,OAAO;IACpC,KAAKJ,OAAO,CAACC,GAAG,CAACI,sBAAsB;MACnC,OAAOF,wBAAiB,CAACG,aAAa;IAC1C,KAAKN,OAAO,CAACC,GAAG,CAACM,YAAY;MACzB,OAAOJ,wBAAiB,CAACK,GAAG;IAChC;MACI,OAAOL,wBAAiB,CAACM,OAAO;EACxC;AACJ,CAAC;AAACC,OAAA,CAAAZ,YAAA,GAAAA,YAAA","ignoreList":[]}

package/sync/utils/manifest.d.ts

@@ -0,0 +1,17 @@
+import type { DynamoDBDocument } from "@webiny/aws-sdk/client-dynamodb";
+export interface IGetManifestParams {
+    getDocumentClient(): Pick<DynamoDBDocument, "send">;
+}
+export declare const getManifest: (params: IGetManifestParams) => Promise<{
+    data: {
+        sync: {
+            region: string;
+            eventBusArn: string;
+            eventBusName: string;
+        };
+    };
+    error?: undefined;
+} | {
+    error: any;
+    data?: undefined;
+}>;

package/sync/utils/manifest.js

@@ -0,0 +1,52 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getManifest = void 0;
+var _api = require("@webiny/api");
+var _zod = _interopRequireDefault(require("zod"));
+var _utils = require("@webiny/utils");
+const validateManifest = _zod.default.object({
+  sync: _zod.default.object({
+    eventBusArn: _zod.default.string(),
+    eventBusName: _zod.default.string(),
+    region: _zod.default.string()
+  })
+});
+const getManifest = async params => {
+  const documentClient = params.getDocumentClient();
+  try {
+    _api.ServiceDiscovery.setDocumentClient(documentClient);
+    const manifest = await _api.ServiceDiscovery.load();
+    if (!manifest?.sync) {
+      return {
+        /**
+         * This error will be silent. We do not want to log or throw at this point.
+         */
+        error: new Error("Sync System Manifest not found. Probably Sync System is not turned on.")
+      };
+    }
+    const {
+      data,
+      error
+    } = validateManifest.safeParse(manifest);
+    if (error) {
+      const err = (0, _utils.createZodError)(error);
+      return {
+        error: err
+      };
+    }
+    return {
+      data
+    };
+  } catch (ex) {
+    return {
+      error: ex
+    };
+  }
+};
+exports.getManifest = getManifest;
+
+//# sourceMappingURL=manifest.js.map

package/sync/utils/manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_api","require","_zod","_interopRequireDefault","_utils","validateManifest","zod","object","sync","eventBusArn","string","eventBusName","region","getManifest","params","documentClient","getDocumentClient","ServiceDiscovery","setDocumentClient","manifest","load","error","Error","data","safeParse","err","createZodError","ex","exports"],"sources":["manifest.ts"],"sourcesContent":["import { ServiceDiscovery } from \"@webiny/api\";\nimport zod from \"zod\";\nimport { createZodError } from \"@webiny/utils\";\nimport type { DynamoDBDocument } from \"@webiny/aws-sdk/client-dynamodb\";\n\nconst validateManifest = zod.object({\n    sync: zod.object({\n        eventBusArn: zod.string(),\n        eventBusName: zod.string(),\n        region: zod.string()\n    })\n});\n\nexport interface IGetManifestParams {\n    getDocumentClient(): Pick<DynamoDBDocument, \"send\">;\n}\n\nexport const getManifest = async (params: IGetManifestParams) => {\n    const documentClient = params.getDocumentClient();\n    try {\n        ServiceDiscovery.setDocumentClient(documentClient);\n        const manifest = await ServiceDiscovery.load();\n        if (!manifest?.sync) {\n            return {\n                /**\n                 * This error will be silent. We do not want to log or throw at this point.\n                 */\n                error: new Error(\n                    \"Sync System Manifest not found. Probably Sync System is not turned on.\"\n                )\n            };\n        }\n        const { data, error } = validateManifest.safeParse(manifest);\n        if (error) {\n            const err = createZodError(error);\n            return {\n                error: err\n            };\n        }\n        return {\n            data\n        };\n    } catch (ex) {\n        return {\n            error: ex\n        };\n    }\n};\n"],"mappings":";;;;;;;AAAA,IAAAA,IAAA,GAAAC,OAAA;AACA,IAAAC,IAAA,GAAAC,sBAAA,CAAAF,OAAA;AACA,IAAAG,MAAA,GAAAH,OAAA;AAGA,MAAMI,gBAAgB,GAAGC,YAAG,CAACC,MAAM,CAAC;EAChCC,IAAI,EAAEF,YAAG,CAACC,MAAM,CAAC;IACbE,WAAW,EAAEH,YAAG,CAACI,MAAM,CAAC,CAAC;IACzBC,YAAY,EAAEL,YAAG,CAACI,MAAM,CAAC,CAAC;IAC1BE,MAAM,EAAEN,YAAG,CAACI,MAAM,CAAC;EACvB,CAAC;AACL,CAAC,CAAC;AAMK,MAAMG,WAAW,GAAG,MAAOC,MAA0B,IAAK;EAC7D,MAAMC,cAAc,GAAGD,MAAM,CAACE,iBAAiB,CAAC,CAAC;EACjD,IAAI;IACAC,qBAAgB,CAACC,iBAAiB,CAACH,cAAc,CAAC;IAClD,MAAMI,QAAQ,GAAG,MAAMF,qBAAgB,CAACG,IAAI,CAAC,CAAC;IAC9C,IAAI,CAACD,QAAQ,EAAEX,IAAI,EAAE;MACjB,OAAO;QACH;AAChB;AACA;QACgBa,KAAK,EAAE,IAAIC,KAAK,CACZ,wEACJ;MACJ,CAAC;IACL;IACA,MAAM;MAAEC,IAAI;MAAEF;IAAM,CAAC,GAAGhB,gBAAgB,CAACmB,SAAS,CAACL,QAAQ,CAAC;IAC5D,IAAIE,KAAK,EAAE;MACP,MAAMI,GAAG,GAAG,IAAAC,qBAAc,EAACL,KAAK,CAAC;MACjC,OAAO;QACHA,KAAK,EAAEI;MACX,CAAC;IACL;IACA,OAAO;MACHF;IACJ,CAAC;EACL,CAAC,CAAC,OAAOI,EAAE,EAAE;IACT,OAAO;MACHN,KAAK,EAAEM;IACX,CAAC;EACL;AACJ,CAAC;AAACC,OAAA,CAAAf,WAAA,GAAAA,WAAA","ignoreList":[]}

package/sync/utils/validateSystemInput.d.ts

@@ -0,0 +1,11 @@
+import type { ISystem } from "../types.js";
+export interface IValidResponse {
+    system: ISystem;
+    error?: never;
+}
+export interface IErrorResponse {
+    error: string;
+    system?: never;
+}
+export type ValidateSystemInputResponse = IValidResponse | IErrorResponse;
+export declare const validateSystemInput: (input: Partial<ISystem>) => ValidateSystemInputResponse;