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

package/resolver/app/transform/TransformHandler.d.ts

@@ -0,0 +1,34 @@
+import type { ITable } from "../../../sync/types";
+import type { IDeployment } from "../../deployment/types.js";
+import type { PluginsContainer } from "@webiny/plugins/types";
+import type { IStoreItem } from "../storer/types";
+export interface IMiddlewareParams {
+    readonly plugins: PluginsContainer;
+    readonly record: IStoreItem;
+    readonly sourceDeployment: IDeployment;
+    readonly targetDeployment: IDeployment;
+    readonly sourceTable: ITable;
+    readonly targetTable: ITable;
+}
+export interface ITransformHandlerTransformParams {
+    readonly sourceTable: ITable;
+    readonly sourceDeployment: IDeployment;
+    readonly targetTable: ITable;
+    readonly targetDeployment: IDeployment;
+    readonly items: IStoreItem[];
+}
+export interface ITransformHandlerTransformResult {
+    items: IStoreItem[];
+}
+export interface ITransformHandler {
+    transform(params: ITransformHandlerTransformParams): Promise<ITransformHandlerTransformResult>;
+}
+export interface ITransformHandlerParams {
+    readonly plugins: PluginsContainer;
+}
+export declare class TransformHandler implements ITransformHandler {
+    private readonly pluginsContainer;
+    private readonly plugins;
+    constructor(params: ITransformHandlerParams);
+    transform(params: ITransformHandlerTransformParams): Promise<ITransformHandlerTransformResult>;
+}

package/resolver/app/transform/TransformHandler.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TransformHandler = void 0;
+var _TransformRecordPlugin = require("../../plugins/TransformRecordPlugin.js");
+var _middleware = require("./middleware.js");
+class TransformHandler {
+  constructor(params) {
+    this.pluginsContainer = params.plugins;
+    this.plugins = params.plugins.byType(_TransformRecordPlugin.TransformRecordPlugin.type);
+  }
+  async transform(params) {
+    const {
+      sourceTable,
+      sourceDeployment,
+      targetDeployment,
+      targetTable,
+      items
+    } = params;
+    if (this.plugins.length === 0) {
+      process.env.DEBUG === "true" && console.log("There are no transform plugins registered in the system.");
+      return {
+        items
+      };
+    }
+    const plugins = this.plugins.filter(plugin => {
+      if (plugin.isForTableType(sourceTable.type) === false) {
+        return false;
+      }
+      return plugin.canTransform({
+        from: sourceDeployment,
+        to: targetDeployment
+      });
+    });
+    if (plugins.length === 0) {
+      process.env.DEBUG === "true" && console.log("There are no transform plugins registered for the given deployment versions or sourceTable type.", {
+        sourceVersion: sourceDeployment.version.format(),
+        targetVersion: targetDeployment.version.format(),
+        sourceTable
+      });
+      return {
+        items
+      };
+    }
+    const runner = (0, _middleware.middleware)(plugins.map(plugin => {
+      return async (params, next) => {
+        return await plugin.transform(params, next);
+      };
+    }));
+    const results = await Promise.all(items.map(async input => {
+      const record = Object.freeze(input);
+      return await runner({
+        plugins: this.pluginsContainer,
+        sourceTable,
+        sourceDeployment,
+        targetDeployment,
+        targetTable,
+        record
+      }, record);
+    }));
+    return {
+      items: results.filter(item => !!item)
+    };
+  }
+}
+exports.TransformHandler = TransformHandler;
+
+//# sourceMappingURL=TransformHandler.js.map

package/resolver/app/transform/TransformHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_TransformRecordPlugin","require","_middleware","TransformHandler","constructor","params","pluginsContainer","plugins","byType","TransformRecordPlugin","type","transform","sourceTable","sourceDeployment","targetDeployment","targetTable","items","length","process","env","DEBUG","console","log","filter","plugin","isForTableType","canTransform","from","to","sourceVersion","version","format","targetVersion","runner","middleware","map","next","results","Promise","all","input","record","Object","freeze","item","exports"],"sources":["TransformHandler.ts"],"sourcesContent":["import type { ITable } from \"~/sync/types\";\nimport type { IDeployment } from \"~/resolver/deployment/types.js\";\nimport type { PluginsContainer } from \"@webiny/plugins/types\";\nimport { TransformRecordPlugin } from \"~/resolver/plugins/TransformRecordPlugin.js\";\nimport { middleware } from \"./middleware.js\";\nimport type { IStoreItem } from \"../storer/types\";\n\nexport interface IMiddlewareParams {\n    readonly plugins: PluginsContainer;\n    readonly record: IStoreItem;\n    readonly sourceDeployment: IDeployment;\n    readonly targetDeployment: IDeployment;\n    readonly sourceTable: ITable;\n    readonly targetTable: ITable;\n}\n\nexport interface ITransformHandlerTransformParams {\n    readonly sourceTable: ITable;\n    readonly sourceDeployment: IDeployment;\n    readonly targetTable: ITable;\n    readonly targetDeployment: IDeployment;\n    readonly items: IStoreItem[];\n}\n\nexport interface ITransformHandlerTransformResult {\n    items: IStoreItem[];\n}\n\nexport interface ITransformHandler {\n    transform(params: ITransformHandlerTransformParams): Promise<ITransformHandlerTransformResult>;\n}\n\nexport interface ITransformHandlerParams {\n    readonly plugins: PluginsContainer;\n}\n\nexport class TransformHandler implements ITransformHandler {\n    private readonly pluginsContainer: PluginsContainer;\n    private readonly plugins: TransformRecordPlugin[];\n\n    public constructor(params: ITransformHandlerParams) {\n        this.pluginsContainer = params.plugins;\n        this.plugins = params.plugins.byType<TransformRecordPlugin>(TransformRecordPlugin.type);\n    }\n\n    public async transform(\n        params: ITransformHandlerTransformParams\n    ): Promise<ITransformHandlerTransformResult> {\n        const { sourceTable, sourceDeployment, targetDeployment, targetTable, items } = params;\n\n        if (this.plugins.length === 0) {\n            process.env.DEBUG === \"true\" &&\n                console.log(\"There are no transform plugins registered in the system.\");\n            return {\n                items\n            };\n        }\n\n        const plugins = this.plugins.filter(plugin => {\n            if (plugin.isForTableType(sourceTable.type) === false) {\n                return false;\n            }\n            return plugin.canTransform({\n                from: sourceDeployment,\n                to: targetDeployment\n            });\n        });\n\n        if (plugins.length === 0) {\n            process.env.DEBUG === \"true\" &&\n                console.log(\n                    \"There are no transform plugins registered for the given deployment versions or sourceTable type.\",\n                    {\n                        sourceVersion: sourceDeployment.version.format(),\n                        targetVersion: targetDeployment.version.format(),\n                        sourceTable\n                    }\n                );\n            return {\n                items\n            };\n        }\n\n        const runner = middleware<IMiddlewareParams, IStoreItem>(\n            plugins.map(plugin => {\n                return async (params, next) => {\n                    return await plugin.transform(params, next);\n                };\n            })\n        );\n\n        const results = await Promise.all(\n            items.map(async input => {\n                const record = Object.freeze(input);\n                return await runner(\n                    {\n                        plugins: this.pluginsContainer,\n                        sourceTable,\n                        sourceDeployment,\n                        targetDeployment,\n                        targetTable,\n                        record\n                    },\n                    record\n                );\n            })\n        );\n        return {\n            items: results.filter((item): item is IStoreItem => !!item)\n        };\n    }\n}\n"],"mappings":";;;;;;AAGA,IAAAA,sBAAA,GAAAC,OAAA;AACA,IAAAC,WAAA,GAAAD,OAAA;AAgCO,MAAME,gBAAgB,CAA8B;EAIhDC,WAAWA,CAACC,MAA+B,EAAE;IAChD,IAAI,CAACC,gBAAgB,GAAGD,MAAM,CAACE,OAAO;IACtC,IAAI,CAACA,OAAO,GAAGF,MAAM,CAACE,OAAO,CAACC,MAAM,CAAwBC,4CAAqB,CAACC,IAAI,CAAC;EAC3F;EAEA,MAAaC,SAASA,CAClBN,MAAwC,EACC;IACzC,MAAM;MAAEO,WAAW;MAAEC,gBAAgB;MAAEC,gBAAgB;MAAEC,WAAW;MAAEC;IAAM,CAAC,GAAGX,MAAM;IAEtF,IAAI,IAAI,CAACE,OAAO,CAACU,MAAM,KAAK,CAAC,EAAE;MAC3BC,OAAO,CAACC,GAAG,CAACC,KAAK,KAAK,MAAM,IACxBC,OAAO,CAACC,GAAG,CAAC,0DAA0D,CAAC;MAC3E,OAAO;QACHN;MACJ,CAAC;IACL;IAEA,MAAMT,OAAO,GAAG,IAAI,CAACA,OAAO,CAACgB,MAAM,CAACC,MAAM,IAAI;MAC1C,IAAIA,MAAM,CAACC,cAAc,CAACb,WAAW,CAACF,IAAI,CAAC,KAAK,KAAK,EAAE;QACnD,OAAO,KAAK;MAChB;MACA,OAAOc,MAAM,CAACE,YAAY,CAAC;QACvBC,IAAI,EAAEd,gBAAgB;QACtBe,EAAE,EAAEd;MACR,CAAC,CAAC;IACN,CAAC,CAAC;IAEF,IAAIP,OAAO,CAACU,MAAM,KAAK,CAAC,EAAE;MACtBC,OAAO,CAACC,GAAG,CAACC,KAAK,KAAK,MAAM,IACxBC,OAAO,CAACC,GAAG,CACP,kGAAkG,EAClG;QACIO,aAAa,EAAEhB,gBAAgB,CAACiB,OAAO,CAACC,MAAM,CAAC,CAAC;QAChDC,aAAa,EAAElB,gBAAgB,CAACgB,OAAO,CAACC,MAAM,CAAC,CAAC;QAChDnB;MACJ,CACJ,CAAC;MACL,OAAO;QACHI;MACJ,CAAC;IACL;IAEA,MAAMiB,MAAM,GAAG,IAAAC,sBAAU,EACrB3B,OAAO,CAAC4B,GAAG,CAACX,MAAM,IAAI;MAClB,OAAO,OAAOnB,MAAM,EAAE+B,IAAI,KAAK;QAC3B,OAAO,MAAMZ,MAAM,CAACb,SAAS,CAACN,MAAM,EAAE+B,IAAI,CAAC;MAC/C,CAAC;IACL,CAAC,CACL,CAAC;IAED,MAAMC,OAAO,GAAG,MAAMC,OAAO,CAACC,GAAG,CAC7BvB,KAAK,CAACmB,GAAG,CAAC,MAAMK,KAAK,IAAI;MACrB,MAAMC,MAAM,GAAGC,MAAM,CAACC,MAAM,CAACH,KAAK,CAAC;MACnC,OAAO,MAAMP,MAAM,CACf;QACI1B,OAAO,EAAE,IAAI,CAACD,gBAAgB;QAC9BM,WAAW;QACXC,gBAAgB;QAChBC,gBAAgB;QAChBC,WAAW;QACX0B;MACJ,CAAC,EACDA,MACJ,CAAC;IACL,CAAC,CACL,CAAC;IACD,OAAO;MACHzB,KAAK,EAAEqB,OAAO,CAACd,MAAM,CAAEqB,IAAI,IAAyB,CAAC,CAACA,IAAI;IAC9D,CAAC;EACL;AACJ;AAACC,OAAA,CAAA1C,gBAAA,GAAAA,gBAAA","ignoreList":[]}

package/resolver/app/transform/middleware.d.ts

@@ -0,0 +1,3 @@
+import type { GenericRecord } from "@webiny/api/types";
+export type Middleware<Input, Output> = (input: Input, next: () => Promise<Output>) => Promise<Output>;
+export declare function middleware<Input = GenericRecord, Output = GenericRecord>(middlewares: Middleware<Input, Output>[]): (input: Input, defaultValue: Output) => Promise<Output>;

package/resolver/app/transform/middleware.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.middleware = middleware;
+function middleware(middlewares) {
+  return async function runner(input, defaultValue) {
+    let current = -1;
+    async function dispatch(index) {
+      /**
+       * Should not be possible to run next multiple times.
+       * Or do we want to allow it? What are possible downsides except something being done multiple times?
+       */
+      if (index <= current) {
+        throw new Error("next() called multiple times");
+      }
+      current = index;
+      const fn = middlewares[index];
+      if (!fn) {
+        return defaultValue;
+      }
+      return fn(input, () => dispatch(index + 1));
+    }
+    return dispatch(0);
+  };
+}
+
+//# sourceMappingURL=middleware.js.map

package/resolver/app/transform/middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["middleware","middlewares","runner","input","defaultValue","current","dispatch","index","Error","fn"],"sources":["middleware.ts"],"sourcesContent":["import type { GenericRecord } from \"@webiny/api/types\";\n\nexport type Middleware<Input, Output> = (\n    input: Input,\n    next: () => Promise<Output>\n) => Promise<Output>;\n\nexport function middleware<Input = GenericRecord, Output = GenericRecord>(\n    middlewares: Middleware<Input, Output>[]\n) {\n    return async function runner(input: Input, defaultValue: Output): Promise<Output> {\n        let current = -1;\n\n        async function dispatch(index: number): Promise<Output> {\n            /**\n             * Should not be possible to run next multiple times.\n             * Or do we want to allow it? What are possible downsides except something being done multiple times?\n             */\n            if (index <= current) {\n                throw new Error(\"next() called multiple times\");\n            }\n            current = index;\n\n            const fn = middlewares[index];\n            if (!fn) {\n                return defaultValue;\n            }\n\n            return fn(input, () => dispatch(index + 1));\n        }\n\n        return dispatch(0);\n    };\n}\n"],"mappings":";;;;;;AAOO,SAASA,UAAUA,CACtBC,WAAwC,EAC1C;EACE,OAAO,eAAeC,MAAMA,CAACC,KAAY,EAAEC,YAAoB,EAAmB;IAC9E,IAAIC,OAAO,GAAG,CAAC,CAAC;IAEhB,eAAeC,QAAQA,CAACC,KAAa,EAAmB;MACpD;AACZ;AACA;AACA;MACY,IAAIA,KAAK,IAAIF,OAAO,EAAE;QAClB,MAAM,IAAIG,KAAK,CAAC,8BAA8B,CAAC;MACnD;MACAH,OAAO,GAAGE,KAAK;MAEf,MAAME,EAAE,GAAGR,WAAW,CAACM,KAAK,CAAC;MAC7B,IAAI,CAACE,EAAE,EAAE;QACL,OAAOL,YAAY;MACvB;MAEA,OAAOK,EAAE,CAACN,KAAK,EAAE,MAAMG,QAAQ,CAACC,KAAK,GAAG,CAAC,CAAC,CAAC;IAC/C;IAEA,OAAOD,QAAQ,CAAC,CAAC,CAAC;EACtB,CAAC;AACL","ignoreList":[]}

package/resolver/app/utils/Retry.d.ts

@@ -0,0 +1,18 @@
+export interface IRetryableRetryOptions {
+    onFail?: (error: Error) => Promise<void> | void;
+}
+export interface IRetryable {
+    retry<T>(fn: () => Promise<T>, options: IRetryableRetryOptions): Promise<T>;
+}
+export interface IRetryParams {
+    maxRetries: number;
+    retryDelay: number;
+}
+export declare class Retry implements IRetryable {
+    private readonly maxRetries;
+    private readonly retryDelay;
+    private retryCount;
+    constructor(params: IRetryParams);
+    retry<T>(fn: () => Promise<T>, options?: IRetryableRetryOptions): Promise<T>;
+}
+export declare const createRetry: (params: IRetryParams) => IRetryable;

package/resolver/app/utils/Retry.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRetry = exports.Retry = void 0;
+var _sleep = require("./sleep");
+class Retry {
+  retryCount = 0;
+  constructor(params) {
+    this.maxRetries = params.maxRetries;
+    this.retryDelay = params.retryDelay;
+  }
+  async retry(fn, options) {
+    try {
+      return await fn();
+    } catch (ex) {
+      if (this.retryCount >= this.maxRetries) {
+        if (options?.onFail) {
+          await options.onFail(ex);
+        }
+        throw ex;
+      }
+    }
+    this.retryCount++;
+    await (0, _sleep.sleep)(this.retryDelay);
+    const result = await this.retry(fn, options);
+    this.retryCount = 0;
+    return result;
+  }
+}
+exports.Retry = Retry;
+const createRetry = params => {
+  return new Retry(params);
+};
+exports.createRetry = createRetry;
+
+//# sourceMappingURL=Retry.js.map

package/resolver/app/utils/Retry.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_sleep","require","Retry","retryCount","constructor","params","maxRetries","retryDelay","retry","fn","options","ex","onFail","sleep","result","exports","createRetry"],"sources":["Retry.ts"],"sourcesContent":["import { sleep } from \"./sleep\";\n\nexport interface IRetryableRetryOptions {\n    onFail?: (error: Error) => Promise<void> | void;\n}\n\nexport interface IRetryable {\n    retry<T>(fn: () => Promise<T>, options: IRetryableRetryOptions): Promise<T>;\n}\n\nexport interface IRetryParams {\n    maxRetries: number;\n    retryDelay: number;\n}\n\nexport class Retry implements IRetryable {\n    private readonly maxRetries: number;\n    private readonly retryDelay: number;\n    private retryCount: number = 0;\n\n    public constructor(params: IRetryParams) {\n        this.maxRetries = params.maxRetries;\n        this.retryDelay = params.retryDelay;\n    }\n\n    public async retry<T>(fn: () => Promise<T>, options?: IRetryableRetryOptions): Promise<T> {\n        try {\n            return await fn();\n        } catch (ex) {\n            if (this.retryCount >= this.maxRetries) {\n                if (options?.onFail) {\n                    await options.onFail(ex as Error);\n                }\n                throw ex;\n            }\n        }\n        this.retryCount++;\n        await sleep(this.retryDelay);\n        const result = await this.retry<T>(fn, options);\n        this.retryCount = 0;\n        return result;\n    }\n}\n\nexport const createRetry = (params: IRetryParams): IRetryable => {\n    return new Retry(params);\n};\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAeO,MAAMC,KAAK,CAAuB;EAG7BC,UAAU,GAAW,CAAC;EAEvBC,WAAWA,CAACC,MAAoB,EAAE;IACrC,IAAI,CAACC,UAAU,GAAGD,MAAM,CAACC,UAAU;IACnC,IAAI,CAACC,UAAU,GAAGF,MAAM,CAACE,UAAU;EACvC;EAEA,MAAaC,KAAKA,CAAIC,EAAoB,EAAEC,OAAgC,EAAc;IACtF,IAAI;MACA,OAAO,MAAMD,EAAE,CAAC,CAAC;IACrB,CAAC,CAAC,OAAOE,EAAE,EAAE;MACT,IAAI,IAAI,CAACR,UAAU,IAAI,IAAI,CAACG,UAAU,EAAE;QACpC,IAAII,OAAO,EAAEE,MAAM,EAAE;UACjB,MAAMF,OAAO,CAACE,MAAM,CAACD,EAAW,CAAC;QACrC;QACA,MAAMA,EAAE;MACZ;IACJ;IACA,IAAI,CAACR,UAAU,EAAE;IACjB,MAAM,IAAAU,YAAK,EAAC,IAAI,CAACN,UAAU,CAAC;IAC5B,MAAMO,MAAM,GAAG,MAAM,IAAI,CAACN,KAAK,CAAIC,EAAE,EAAEC,OAAO,CAAC;IAC/C,IAAI,CAACP,UAAU,GAAG,CAAC;IACnB,OAAOW,MAAM;EACjB;AACJ;AAACC,OAAA,CAAAb,KAAA,GAAAA,KAAA;AAEM,MAAMc,WAAW,GAAIX,MAAoB,IAAiB;EAC7D,OAAO,IAAIH,KAAK,CAACG,MAAM,CAAC;AAC5B,CAAC;AAACU,OAAA,CAAAC,WAAA,GAAAA,WAAA","ignoreList":[]}

package/resolver/app/utils/sleep.d.ts

@@ -0,0 +1 @@
+export declare const sleep: (ms: number) => Promise<void>;

package/resolver/app/utils/sleep.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sleep = void 0;
+const sleep = ms => {
+  return new Promise(resolve => {
+    setTimeout(resolve, ms);
+  });
+};
+exports.sleep = sleep;
+
+//# sourceMappingURL=sleep.js.map

package/resolver/app/utils/sleep.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["sleep","ms","Promise","resolve","setTimeout","exports"],"sources":["sleep.ts"],"sourcesContent":["export const sleep = (ms: number) => {\n    return new Promise<void>(resolve => {\n        setTimeout(resolve, ms);\n    });\n};\n"],"mappings":";;;;;;AAAO,MAAMA,KAAK,GAAIC,EAAU,IAAK;EACjC,OAAO,IAAIC,OAAO,CAAOC,OAAO,IAAI;IAChCC,UAAU,CAACD,OAAO,EAAEF,EAAE,CAAC;EAC3B,CAAC,CAAC;AACN,CAAC;AAACI,OAAA,CAAAL,KAAA,GAAAA,KAAA","ignoreList":[]}

package/resolver/app/validation/body.d.ts

@@ -0,0 +1,142 @@
+import zod from "zod";
+export declare const createBodyValidation: () => zod.ZodObject<{
+    version: zod.ZodEffects<zod.ZodString, `${number}`, string>;
+    id: zod.ZodString;
+    "detail-type": zod.ZodEffects<zod.ZodString, "synchronization-input", string>;
+    source: zod.ZodEffects<zod.ZodString, `webiny:${string}`, string>;
+    account: zod.ZodEffects<zod.ZodString, `${number}`, string>;
+    time: zod.ZodEffects<zod.ZodString, Date, string>;
+    region: zod.ZodString;
+    resources: zod.ZodArray<zod.ZodString, "many">;
+    detail: zod.ZodObject<{
+        items: zod.ZodEffects<zod.ZodEffects<zod.ZodArray<zod.ZodObject<{
+            PK: zod.ZodString;
+            SK: zod.ZodString;
+            tableName: zod.ZodString;
+            tableType: zod.ZodEffects<zod.ZodEnum<["regular", "elasticsearch", "log", "unknown"]>, import("../../../types.js").DynamoDBTableType, "unknown" | "log" | "regular" | "elasticsearch">;
+            command: zod.ZodEnum<["update", "put", "delete"]>;
+        }, "strip", zod.ZodTypeAny, {
+            PK: string;
+            SK: string;
+            tableName: string;
+            tableType: import("../../../types.js").DynamoDBTableType;
+            command: "update" | "delete" | "put";
+        }, {
+            PK: string;
+            SK: string;
+            tableName: string;
+            tableType: "unknown" | "log" | "regular" | "elasticsearch";
+            command: "update" | "delete" | "put";
+        }>, "many">, {
+            PK: string;
+            SK: string;
+            tableName: string;
+            tableType: import("../../../types.js").DynamoDBTableType;
+            command: "update" | "delete" | "put";
+        }[], {
+            PK: string;
+            SK: string;
+            tableName: string;
+            tableType: "unknown" | "log" | "regular" | "elasticsearch";
+            command: "update" | "delete" | "put";
+        }[]>, import("@webiny/api/types.js").NonEmptyArray<import("../abstractions/ResolverRecord.js").IResolverRecordBodyItem>, {
+            PK: string;
+            SK: string;
+            tableName: string;
+            tableType: "unknown" | "log" | "regular" | "elasticsearch";
+            command: "update" | "delete" | "put";
+        }[]>;
+        source: zod.ZodObject<{
+            name: zod.ZodString;
+            env: zod.ZodString;
+            variant: zod.ZodEffects<zod.ZodOptional<zod.ZodNullable<zod.ZodOptional<zod.ZodString>>>, string | undefined, string | null | undefined>;
+            region: zod.ZodString;
+            version: zod.ZodString;
+        }, "strip", zod.ZodTypeAny, {
+            name: string;
+            region: string;
+            version: string;
+            env: string;
+            variant?: string | undefined;
+        }, {
+            name: string;
+            region: string;
+            version: string;
+            env: string;
+            variant?: string | null | undefined;
+        }>;
+        id: zod.ZodString;
+    }, "strip", zod.ZodTypeAny, {
+        id: string;
+        source: {
+            name: string;
+            region: string;
+            version: string;
+            env: string;
+            variant?: string | undefined;
+        };
+        items: import("@webiny/api/types.js").NonEmptyArray<import("../abstractions/ResolverRecord.js").IResolverRecordBodyItem>;
+    }, {
+        id: string;
+        source: {
+            name: string;
+            region: string;
+            version: string;
+            env: string;
+            variant?: string | null | undefined;
+        };
+        items: {
+            PK: string;
+            SK: string;
+            tableName: string;
+            tableType: "unknown" | "log" | "regular" | "elasticsearch";
+            command: "update" | "delete" | "put";
+        }[];
+    }>;
+}, "strip", zod.ZodTypeAny, {
+    time: Date;
+    detail: {
+        id: string;
+        source: {
+            name: string;
+            region: string;
+            version: string;
+            env: string;
+            variant?: string | undefined;
+        };
+        items: import("@webiny/api/types.js").NonEmptyArray<import("../abstractions/ResolverRecord.js").IResolverRecordBodyItem>;
+    };
+    id: string;
+    source: `webiny:${string}`;
+    region: string;
+    "detail-type": "synchronization-input";
+    version: `${number}`;
+    account: `${number}`;
+    resources: string[];
+}, {
+    time: string;
+    detail: {
+        id: string;
+        source: {
+            name: string;
+            region: string;
+            version: string;
+            env: string;
+            variant?: string | null | undefined;
+        };
+        items: {
+            PK: string;
+            SK: string;
+            tableName: string;
+            tableType: "unknown" | "log" | "regular" | "elasticsearch";
+            command: "update" | "delete" | "put";
+        }[];
+    };
+    id: string;
+    source: string;
+    region: string;
+    "detail-type": string;
+    version: string;
+    account: string;
+    resources: string[];
+}>;

package/resolver/app/validation/body.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createBodyValidation = void 0;
+var _zod = _interopRequireDefault(require("zod"));
+var _detail = require("./detail.js");
+var _constants = require("../../../constants.js");
+var _numericString = require("./numericString.js");
+const detailValidation = (0, _detail.createDetailValidation)();
+const createBodyValidation = () => {
+  return _zod.default.object({
+    version: (0, _numericString.createNumericStringValidation)("version"),
+    id: _zod.default.string(),
+    "detail-type": _zod.default.string().transform((value, ctx) => {
+      if (value === _constants.SQS_EVENT_NAME) {
+        return _constants.SQS_EVENT_NAME;
+      }
+      ctx.addIssue({
+        code: _zod.default.ZodIssueCode.custom,
+        message: `"detail-type" must be "${_constants.SQS_EVENT_NAME}".`
+      });
+      return _zod.default.NEVER;
+    }),
+    source: _zod.default.string().transform((value, ctx) => {
+      if (value.startsWith("webiny:")) {
+        return value;
+      }
+      ctx.addIssue({
+        code: _zod.default.ZodIssueCode.custom,
+        message: `"source" must start with "webiny:".`
+      });
+      return _zod.default.NEVER;
+    }),
+    account: (0, _numericString.createNumericStringValidation)("account"),
+    time: _zod.default.string().transform(value => new Date(value)),
+    region: _zod.default.string(),
+    resources: _zod.default.array(_zod.default.string()),
+    detail: detailValidation
+  });
+};
+exports.createBodyValidation = createBodyValidation;
+
+//# sourceMappingURL=body.js.map

package/resolver/app/validation/body.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_zod","_interopRequireDefault","require","_detail","_constants","_numericString","detailValidation","createDetailValidation","createBodyValidation","zod","object","version","createNumericStringValidation","id","string","transform","value","ctx","SQS_EVENT_NAME","addIssue","code","ZodIssueCode","custom","message","NEVER","source","startsWith","account","time","Date","region","resources","array","detail","exports"],"sources":["body.ts"],"sourcesContent":["import zod from \"zod\";\nimport { createDetailValidation } from \"./detail.js\";\nimport { SQS_EVENT_NAME } from \"~/constants.js\";\nimport { createNumericStringValidation } from \"~/resolver/app/validation/numericString.js\";\n\nconst detailValidation = createDetailValidation();\n\nexport const createBodyValidation = () => {\n    return zod.object({\n        version: createNumericStringValidation(\"version\"),\n        id: zod.string(),\n        \"detail-type\": zod.string().transform((value, ctx) => {\n            if (value === SQS_EVENT_NAME) {\n                return SQS_EVENT_NAME;\n            }\n            ctx.addIssue({\n                code: zod.ZodIssueCode.custom,\n                message: `\"detail-type\" must be \"${SQS_EVENT_NAME}\".`\n            });\n            return zod.NEVER;\n        }),\n        source: zod.string().transform((value, ctx) => {\n            if (value.startsWith(\"webiny:\")) {\n                return value as `webiny:${string}`;\n            }\n            ctx.addIssue({\n                code: zod.ZodIssueCode.custom,\n                message: `\"source\" must start with \"webiny:\".`\n            });\n            return zod.NEVER;\n        }),\n        account: createNumericStringValidation(\"account\"),\n        time: zod.string().transform(value => new Date(value)),\n        region: zod.string(),\n        resources: zod.array(zod.string()),\n        detail: detailValidation\n    });\n};\n"],"mappings":";;;;;;;AAAA,IAAAA,IAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AACA,IAAAE,UAAA,GAAAF,OAAA;AACA,IAAAG,cAAA,GAAAH,OAAA;AAEA,MAAMI,gBAAgB,GAAG,IAAAC,8BAAsB,EAAC,CAAC;AAE1C,MAAMC,oBAAoB,GAAGA,CAAA,KAAM;EACtC,OAAOC,YAAG,CAACC,MAAM,CAAC;IACdC,OAAO,EAAE,IAAAC,4CAA6B,EAAC,SAAS,CAAC;IACjDC,EAAE,EAAEJ,YAAG,CAACK,MAAM,CAAC,CAAC;IAChB,aAAa,EAAEL,YAAG,CAACK,MAAM,CAAC,CAAC,CAACC,SAAS,CAAC,CAACC,KAAK,EAAEC,GAAG,KAAK;MAClD,IAAID,KAAK,KAAKE,yBAAc,EAAE;QAC1B,OAAOA,yBAAc;MACzB;MACAD,GAAG,CAACE,QAAQ,CAAC;QACTC,IAAI,EAAEX,YAAG,CAACY,YAAY,CAACC,MAAM;QAC7BC,OAAO,EAAE,0BAA0BL,yBAAc;MACrD,CAAC,CAAC;MACF,OAAOT,YAAG,CAACe,KAAK;IACpB,CAAC,CAAC;IACFC,MAAM,EAAEhB,YAAG,CAACK,MAAM,CAAC,CAAC,CAACC,SAAS,CAAC,CAACC,KAAK,EAAEC,GAAG,KAAK;MAC3C,IAAID,KAAK,CAACU,UAAU,CAAC,SAAS,CAAC,EAAE;QAC7B,OAAOV,KAAK;MAChB;MACAC,GAAG,CAACE,QAAQ,CAAC;QACTC,IAAI,EAAEX,YAAG,CAACY,YAAY,CAACC,MAAM;QAC7BC,OAAO,EAAE;MACb,CAAC,CAAC;MACF,OAAOd,YAAG,CAACe,KAAK;IACpB,CAAC,CAAC;IACFG,OAAO,EAAE,IAAAf,4CAA6B,EAAC,SAAS,CAAC;IACjDgB,IAAI,EAAEnB,YAAG,CAACK,MAAM,CAAC,CAAC,CAACC,SAAS,CAACC,KAAK,IAAI,IAAIa,IAAI,CAACb,KAAK,CAAC,CAAC;IACtDc,MAAM,EAAErB,YAAG,CAACK,MAAM,CAAC,CAAC;IACpBiB,SAAS,EAAEtB,YAAG,CAACuB,KAAK,CAACvB,YAAG,CAACK,MAAM,CAAC,CAAC,CAAC;IAClCmB,MAAM,EAAE3B;EACZ,CAAC,CAAC;AACN,CAAC;AAAC4B,OAAA,CAAA1B,oBAAA,GAAAA,oBAAA","ignoreList":[]}

package/resolver/app/validation/createJsonTransform.d.ts

@@ -0,0 +1,2 @@
+import zod from "zod";
+export declare const createJsonTransform: (name: string) => zod.ZodEffects<zod.ZodString, any, string>;

package/resolver/app/validation/createJsonTransform.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createJsonTransform = void 0;
+var _zod = _interopRequireDefault(require("zod"));
+const createJsonTransform = name => {
+  return _zod.default.string().transform((value, ctx) => {
+    try {
+      return JSON.parse(value);
+    } catch (e) {
+      ctx.addIssue({
+        code: _zod.default.ZodIssueCode.custom,
+        message: `${name} must be a valid JSON string.`
+      });
+      return _zod.default.NEVER;
+    }
+  });
+};
+exports.createJsonTransform = createJsonTransform;
+
+//# sourceMappingURL=createJsonTransform.js.map

package/resolver/app/validation/createJsonTransform.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_zod","_interopRequireDefault","require","createJsonTransform","name","zod","string","transform","value","ctx","JSON","parse","e","addIssue","code","ZodIssueCode","custom","message","NEVER","exports"],"sources":["createJsonTransform.ts"],"sourcesContent":["import zod from \"zod\";\n\nexport const createJsonTransform = (name: string) => {\n    return zod.string().transform((value, ctx) => {\n        try {\n            return JSON.parse(value);\n        } catch (e) {\n            ctx.addIssue({\n                code: zod.ZodIssueCode.custom,\n                message: `${name} must be a valid JSON string.`\n            });\n            return zod.NEVER;\n        }\n    });\n};\n"],"mappings":";;;;;;;AAAA,IAAAA,IAAA,GAAAC,sBAAA,CAAAC,OAAA;AAEO,MAAMC,mBAAmB,GAAIC,IAAY,IAAK;EACjD,OAAOC,YAAG,CAACC,MAAM,CAAC,CAAC,CAACC,SAAS,CAAC,CAACC,KAAK,EAAEC,GAAG,KAAK;IAC1C,IAAI;MACA,OAAOC,IAAI,CAACC,KAAK,CAACH,KAAK,CAAC;IAC5B,CAAC,CAAC,OAAOI,CAAC,EAAE;MACRH,GAAG,CAACI,QAAQ,CAAC;QACTC,IAAI,EAAET,YAAG,CAACU,YAAY,CAACC,MAAM;QAC7BC,OAAO,EAAE,GAAGb,IAAI;MACpB,CAAC,CAAC;MACF,OAAOC,YAAG,CAACa,KAAK;IACpB;EACJ,CAAC,CAAC;AACN,CAAC;AAACC,OAAA,CAAAhB,mBAAA,GAAAA,mBAAA","ignoreList":[]}

package/resolver/app/validation/detail.d.ts

@@ -0,0 +1,89 @@
+import zod from "zod";
+import type { NonEmptyArray } from "@webiny/api/types.js";
+import type { IResolverRecordBodyItem } from "../abstractions/ResolverRecord.js";
+import { DynamoDBTableType } from "../../../types.js";
+export declare const createDetailValidation: () => zod.ZodObject<{
+    items: zod.ZodEffects<zod.ZodEffects<zod.ZodArray<zod.ZodObject<{
+        PK: zod.ZodString;
+        SK: zod.ZodString;
+        tableName: zod.ZodString;
+        tableType: zod.ZodEffects<zod.ZodEnum<["regular", "elasticsearch", "log", "unknown"]>, DynamoDBTableType, "unknown" | "log" | "regular" | "elasticsearch">;
+        command: zod.ZodEnum<["update", "put", "delete"]>;
+    }, "strip", zod.ZodTypeAny, {
+        PK: string;
+        SK: string;
+        tableName: string;
+        tableType: DynamoDBTableType;
+        command: "update" | "delete" | "put";
+    }, {
+        PK: string;
+        SK: string;
+        tableName: string;
+        tableType: "unknown" | "log" | "regular" | "elasticsearch";
+        command: "update" | "delete" | "put";
+    }>, "many">, {
+        PK: string;
+        SK: string;
+        tableName: string;
+        tableType: DynamoDBTableType;
+        command: "update" | "delete" | "put";
+    }[], {
+        PK: string;
+        SK: string;
+        tableName: string;
+        tableType: "unknown" | "log" | "regular" | "elasticsearch";
+        command: "update" | "delete" | "put";
+    }[]>, NonEmptyArray<IResolverRecordBodyItem>, {
+        PK: string;
+        SK: string;
+        tableName: string;
+        tableType: "unknown" | "log" | "regular" | "elasticsearch";
+        command: "update" | "delete" | "put";
+    }[]>;
+    source: zod.ZodObject<{
+        name: zod.ZodString;
+        env: zod.ZodString;
+        variant: zod.ZodEffects<zod.ZodOptional<zod.ZodNullable<zod.ZodOptional<zod.ZodString>>>, string | undefined, string | null | undefined>;
+        region: zod.ZodString;
+        version: zod.ZodString;
+    }, "strip", zod.ZodTypeAny, {
+        name: string;
+        region: string;
+        version: string;
+        env: string;
+        variant?: string | undefined;
+    }, {
+        name: string;
+        region: string;
+        version: string;
+        env: string;
+        variant?: string | null | undefined;
+    }>;
+    id: zod.ZodString;
+}, "strip", zod.ZodTypeAny, {
+    id: string;
+    source: {
+        name: string;
+        region: string;
+        version: string;
+        env: string;
+        variant?: string | undefined;
+    };
+    items: NonEmptyArray<IResolverRecordBodyItem>;
+}, {
+    id: string;
+    source: {
+        name: string;
+        region: string;
+        version: string;
+        env: string;
+        variant?: string | null | undefined;
+    };
+    items: {
+        PK: string;
+        SK: string;
+        tableName: string;
+        tableType: "unknown" | "log" | "regular" | "elasticsearch";
+        command: "update" | "delete" | "put";
+    }[];
+}>;

package/resolver/app/validation/detail.js

@@ -0,0 +1,50 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDetailValidation = void 0;
+var _zod = _interopRequireDefault(require("zod"));
+var _system = require("./system.js");
+var _types = require("../../../types.js");
+const convert = input => {
+  /**
+   * We can safely cast as NonEmptyArray<IResolverRecordBodyItem> here because we already validated that the array is not empty.
+   */
+  return input;
+};
+const transformTableType = input => {
+  const keys = Object.keys(_types.DynamoDBTableType);
+  for (const key of keys) {
+    const value = _types.DynamoDBTableType[key];
+    if (value === input) {
+      return value;
+    }
+  }
+  return _types.DynamoDBTableType.UNKNOWN;
+};
+const createDetailValidation = () => {
+  return _zod.default.object({
+    items: _zod.default.array(_zod.default.object({
+      PK: _zod.default.string(),
+      SK: _zod.default.string(),
+      tableName: _zod.default.string(),
+      tableType: _zod.default.enum(["regular", "elasticsearch", "log", "unknown"]).transform(input => {
+        return transformTableType(input);
+      }),
+      command: _zod.default.enum(["update", "put", "delete"])
+    })).refine(values => {
+      return values.length > 0;
+    }, {
+      message: `"items" array must not be empty.`
+    }).transform(values => {
+      return convert(values);
+    }),
+    source: (0, _system.createSystemValidation)(),
+    id: _zod.default.string()
+  });
+};
+exports.createDetailValidation = createDetailValidation;
+
+//# sourceMappingURL=detail.js.map

package/resolver/app/validation/detail.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_zod","_interopRequireDefault","require","_system","_types","convert","input","transformTableType","keys","Object","DynamoDBTableType","key","value","UNKNOWN","createDetailValidation","zod","object","items","array","PK","string","SK","tableName","tableType","enum","transform","command","refine","values","length","message","source","createSystemValidation","id","exports"],"sources":["detail.ts"],"sourcesContent":["import zod from \"zod\";\nimport type { NonEmptyArray } from \"@webiny/api/types.js\";\nimport type { IResolverRecordBodyItem } from \"~/resolver/app/abstractions/ResolverRecord.js\";\nimport { createSystemValidation } from \"./system.js\";\nimport { DynamoDBTableType } from \"~/types.js\";\n\nconst convert = (input: IResolverRecordBodyItem[]) => {\n    /**\n     * We can safely cast as NonEmptyArray<IResolverRecordBodyItem> here because we already validated that the array is not empty.\n     */\n    return input as NonEmptyArray<IResolverRecordBodyItem>;\n};\n\nconst transformTableType = (input: string): DynamoDBTableType => {\n    const keys = Object.keys(DynamoDBTableType) as (keyof typeof DynamoDBTableType)[];\n    for (const key of keys) {\n        const value = DynamoDBTableType[key];\n        if (value === input) {\n            return value;\n        }\n    }\n    return DynamoDBTableType.UNKNOWN;\n};\n\nexport const createDetailValidation = () => {\n    return zod.object({\n        items: zod\n            .array(\n                zod.object({\n                    PK: zod.string(),\n                    SK: zod.string(),\n                    tableName: zod.string(),\n                    tableType: zod\n                        .enum([\"regular\", \"elasticsearch\", \"log\", \"unknown\"])\n                        .transform(input => {\n                            return transformTableType(input);\n                        }),\n                    command: zod.enum([\"update\", \"put\", \"delete\"])\n                })\n            )\n            .refine(\n                values => {\n                    return values.length > 0;\n                },\n                {\n                    message: `\"items\" array must not be empty.`\n                }\n            )\n            .transform(values => {\n                return convert(values);\n            }),\n        source: createSystemValidation(),\n        id: zod.string()\n    });\n};\n"],"mappings":";;;;;;;AAAA,IAAAA,IAAA,GAAAC,sBAAA,CAAAC,OAAA;AAGA,IAAAC,OAAA,GAAAD,OAAA;AACA,IAAAE,MAAA,GAAAF,OAAA;AAEA,MAAMG,OAAO,GAAIC,KAAgC,IAAK;EAClD;AACJ;AACA;EACI,OAAOA,KAAK;AAChB,CAAC;AAED,MAAMC,kBAAkB,GAAID,KAAa,IAAwB;EAC7D,MAAME,IAAI,GAAGC,MAAM,CAACD,IAAI,CAACE,wBAAiB,CAAuC;EACjF,KAAK,MAAMC,GAAG,IAAIH,IAAI,EAAE;IACpB,MAAMI,KAAK,GAAGF,wBAAiB,CAACC,GAAG,CAAC;IACpC,IAAIC,KAAK,KAAKN,KAAK,EAAE;MACjB,OAAOM,KAAK;IAChB;EACJ;EACA,OAAOF,wBAAiB,CAACG,OAAO;AACpC,CAAC;AAEM,MAAMC,sBAAsB,GAAGA,CAAA,KAAM;EACxC,OAAOC,YAAG,CAACC,MAAM,CAAC;IACdC,KAAK,EAAEF,YAAG,CACLG,KAAK,CACFH,YAAG,CAACC,MAAM,CAAC;MACPG,EAAE,EAAEJ,YAAG,CAACK,MAAM,CAAC,CAAC;MAChBC,EAAE,EAAEN,YAAG,CAACK,MAAM,CAAC,CAAC;MAChBE,SAAS,EAAEP,YAAG,CAACK,MAAM,CAAC,CAAC;MACvBG,SAAS,EAAER,YAAG,CACTS,IAAI,CAAC,CAAC,SAAS,EAAE,eAAe,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC,CACpDC,SAAS,CAACnB,KAAK,IAAI;QAChB,OAAOC,kBAAkB,CAACD,KAAK,CAAC;MACpC,CAAC,CAAC;MACNoB,OAAO,EAAEX,YAAG,CAACS,IAAI,CAAC,CAAC,QAAQ,EAAE,KAAK,EAAE,QAAQ,CAAC;IACjD,CAAC,CACL,CAAC,CACAG,MAAM,CACHC,MAAM,IAAI;MACN,OAAOA,MAAM,CAACC,MAAM,GAAG,CAAC;IAC5B,CAAC,EACD;MACIC,OAAO,EAAE;IACb,CACJ,CAAC,CACAL,SAAS,CAACG,MAAM,IAAI;MACjB,OAAOvB,OAAO,CAACuB,MAAM,CAAC;IAC1B,CAAC,CAAC;IACNG,MAAM,EAAE,IAAAC,8BAAsB,EAAC,CAAC;IAChCC,EAAE,EAAElB,YAAG,CAACK,MAAM,CAAC;EACnB,CAAC,CAAC;AACN,CAAC;AAACc,OAAA,CAAApB,sBAAA,GAAAA,sBAAA","ignoreList":[]}