@webiny/api-page-builder-import-export 0.0.0-unstable.df6d94b531 → 0.0.0-unstable.e0bfc55d5a

package/export/pages/controller/CombineZippedPages.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_s3Stream","require","_utils","_ZipFiles","_uniqid","_interopRequireDefault","CombineZippedPages","execute","params","response","store","taskId","getTask","id","exportPagesDataKey","createExportPagesDataKey","listObjectResponse","s3Stream","listObject","Array","isArray","Contents","error","message","length","done","ex","zipFileKeys","reduce","files","file","Key","push","key","zipOfZip","ZipFiles","target","uniqueId","pageExportUpload","process","console","log","url","getPresignedUrl","exports"],"sources":["CombineZippedPages.ts"],"sourcesContent":["import type { IExportPagesCombineZippedPagesParams } from \"~/export/pages/types\";\nimport type { ITaskResponseResult } from \"@webiny/tasks\";\nimport type { ListObjectsOutput } from \"~/export/s3Stream\";\nimport { s3Stream } from \"~/export/s3Stream\";\nimport { createExportPagesDataKey } from \"~/export/pages/utils\";\nimport { ZipFiles } from \"~/utils/ZipFiles\";\nimport uniqueId from \"uniqid\";\n\nexport class CombineZippedPages {\n    public async execute(\n        params: IExportPagesCombineZippedPagesParams\n    ): Promise<ITaskResponseResult> {\n        const { response, store } = params;\n        /**\n         * We need to get all the subtasks of the PageExportTask.ZipPages type, so we can get all the zip files and combine them into one.\n         * Current task must have a parent for this to work.\n         */\n        const taskId = store.getTask().id;\n\n        /**\n         * When we have all the pages IDs and their zip files, we can continue to combine the zip files into one.\n         */\n        const exportPagesDataKey = createExportPagesDataKey(taskId);\n\n        let listObjectResponse: ListObjectsOutput;\n        try {\n            listObjectResponse = await s3Stream.listObject(exportPagesDataKey);\n            if (!Array.isArray(listObjectResponse.Contents)) {\n                return response.error({\n                    message: \"There is no Contents defined on S3 Stream while combining pages.\"\n                });\n            } else if (listObjectResponse.Contents.length === 0) {\n                return response.done(\"No zip files to combine.\");\n            }\n        } catch (ex) {\n            return response.error(ex);\n        }\n\n        const zipFileKeys = listObjectResponse.Contents.reduce<string[]>((files, file) => {\n            if (!file.Key) {\n                return files;\n            } else if (file.Key === exportPagesDataKey) {\n                return files;\n            }\n            files.push(file.Key);\n\n            return files;\n        }, []);\n\n        let key: string;\n\n        try {\n            const zipOfZip = new ZipFiles();\n            const target = uniqueId(\"EXPORTS/\", \"-WEBINY_PAGE_EXPORT.zip\");\n            const pageExportUpload = await zipOfZip.process(target, zipFileKeys);\n\n            if (!pageExportUpload?.Key) {\n                return response.error({\n                    message: \"There is no Key defined on pageExportUpload.\"\n                });\n            }\n            key = pageExportUpload.Key;\n        } catch (ex) {\n            console.error(`Error while combining zip files into a single zip: ${ex.message}`);\n            console.log(ex);\n            return response.error(ex);\n        }\n\n        const url = await s3Stream.getPresignedUrl(key);\n\n        return response.done(\"Done combining pages.\", {\n            key,\n            url\n        });\n    }\n}\n"],"mappings":";;;;;;;AAGA,IAAAA,SAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AACA,IAAAE,SAAA,GAAAF,OAAA;AACA,IAAAG,OAAA,GAAAC,sBAAA,CAAAJ,OAAA;AAEO,MAAMK,kBAAkB,CAAC;EAC5B,MAAaC,OAAOA,CAChBC,MAA4C,EAChB;IAC5B,MAAM;MAAEC,QAAQ;MAAEC;IAAM,CAAC,GAAGF,MAAM;IAClC;AACR;AACA;AACA;IACQ,MAAMG,MAAM,GAAGD,KAAK,CAACE,OAAO,CAAC,CAAC,CAACC,EAAE;;IAEjC;AACR;AACA;IACQ,MAAMC,kBAAkB,GAAG,IAAAC,+BAAwB,EAACJ,MAAM,CAAC;IAE3D,IAAIK,kBAAqC;IACzC,IAAI;MACAA,kBAAkB,GAAG,MAAMC,kBAAQ,CAACC,UAAU,CAACJ,kBAAkB,CAAC;MAClE,IAAI,CAACK,KAAK,CAACC,OAAO,CAACJ,kBAAkB,CAACK,QAAQ,CAAC,EAAE;QAC7C,OAAOZ,QAAQ,CAACa,KAAK,CAAC;UAClBC,OAAO,EAAE;QACb,CAAC,CAAC;MACN,CAAC,MAAM,IAAIP,kBAAkB,CAACK,QAAQ,CAACG,MAAM,KAAK,CAAC,EAAE;QACjD,OAAOf,QAAQ,CAACgB,IAAI,CAAC,0BAA0B,CAAC;MACpD;IACJ,CAAC,CAAC,OAAOC,EAAE,EAAE;MACT,OAAOjB,QAAQ,CAACa,KAAK,CAACI,EAAE,CAAC;IAC7B;IAEA,MAAMC,WAAW,GAAGX,kBAAkB,CAACK,QAAQ,CAACO,MAAM,CAAW,CAACC,KAAK,EAAEC,IAAI,KAAK;MAC9E,IAAI,CAACA,IAAI,CAACC,GAAG,EAAE;QACX,OAAOF,KAAK;MAChB,CAAC,MAAM,IAAIC,IAAI,CAACC,GAAG,KAAKjB,kBAAkB,EAAE;QACxC,OAAOe,KAAK;MAChB;MACAA,KAAK,CAACG,IAAI,CAACF,IAAI,CAACC,GAAG,CAAC;MAEpB,OAAOF,KAAK;IAChB,CAAC,EAAE,EAAE,CAAC;IAEN,IAAII,GAAW;IAEf,IAAI;MACA,MAAMC,QAAQ,GAAG,IAAIC,kBAAQ,CAAC,CAAC;MAC/B,MAAMC,MAAM,GAAG,IAAAC,eAAQ,EAAC,UAAU,EAAE,yBAAyB,CAAC;MAC9D,MAAMC,gBAAgB,GAAG,MAAMJ,QAAQ,CAACK,OAAO,CAACH,MAAM,EAAET,WAAW,CAAC;MAEpE,IAAI,CAACW,gBAAgB,EAAEP,GAAG,EAAE;QACxB,OAAOtB,QAAQ,CAACa,KAAK,CAAC;UAClBC,OAAO,EAAE;QACb,CAAC,CAAC;MACN;MACAU,GAAG,GAAGK,gBAAgB,CAACP,GAAG;IAC9B,CAAC,CAAC,OAAOL,EAAE,EAAE;MACTc,OAAO,CAAClB,KAAK,CAAC,sDAAsDI,EAAE,CAACH,OAAO,EAAE,CAAC;MACjFiB,OAAO,CAACC,GAAG,CAACf,EAAE,CAAC;MACf,OAAOjB,QAAQ,CAACa,KAAK,CAACI,EAAE,CAAC;IAC7B;IAEA,MAAMgB,GAAG,GAAG,MAAMzB,kBAAQ,CAAC0B,eAAe,CAACV,GAAG,CAAC;IAE/C,OAAOxB,QAAQ,CAACgB,IAAI,CAAC,uBAAuB,EAAE;MAC1CQ,GAAG;MACHS;IACJ,CAAC,CAAC;EACN;AACJ;AAACE,OAAA,CAAAtC,kBAAA,GAAAA,kBAAA","ignoreList":[]}

package/export/pages/controller/CreateZipPagesTasks.d.ts

@@ -0,0 +1,8 @@
+import type { IExportPagesControllerTaskParams } from "../types";
+import type { ITaskResponseResult } from "@webiny/tasks/types";
+/**
+ * Go through all the pages and create subtasks for zipping pages in batches.
+ */
+export declare class CreateZipPagesTasks {
+    execute({ response, input, isAborted, isCloseToTimeout, context, store }: IExportPagesControllerTaskParams): Promise<ITaskResponseResult>;
+}

package/export/pages/controller/CreateZipPagesTasks.js

@@ -0,0 +1,103 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CreateZipPagesTasks = void 0;
+var _ProcessZipPagesTasks = require("./ProcessZipPagesTasks");
+var _types = require("../types");
+const PAGES_IN_BATCH = 25;
+
+/**
+ * Go through all the pages and create subtasks for zipping pages in batches.
+ */
+class CreateZipPagesTasks {
+  async execute({
+    response,
+    input,
+    isAborted,
+    isCloseToTimeout,
+    context,
+    store
+  }) {
+    const listPagesParams = {
+      where: input.where,
+      after: input.after,
+      limit: PAGES_IN_BATCH
+    };
+    let currentBatch = input.currentBatch || 1;
+    let result;
+    while (result = await context.pageBuilder.listLatestPages(listPagesParams)) {
+      if (isAborted()) {
+        return response.aborted();
+      } else if (isCloseToTimeout()) {
+        return response.continue({
+          ...input,
+          ...listPagesParams,
+          currentBatch
+        });
+      }
+      const [pages, meta] = result;
+      listPagesParams.after = meta.cursor;
+      /**
+       * If no pages are returned there are two options:
+       * * mark task as done because there are no pages at all
+       * * continue with the control task, but in zippingPages mode
+       */
+      if (meta.totalCount === 0) {
+        return response.done("No pages to export.");
+      } else if (pages.length === 0) {
+        return response.continue({
+          ...input,
+          ...listPagesParams,
+          currentBatch,
+          totalPages: meta.totalCount,
+          zippingPages: true
+        }, {
+          seconds: _ProcessZipPagesTasks.ZIP_PAGES_WAIT_TIME
+        });
+      }
+      const queue = pages.map(page => page.id);
+      /**
+       * Trigger a task for each of the loaded pages batch.
+       */
+      await context.tasks.trigger({
+        name: `Page Builder - Export Pages - Zip Pages #${currentBatch}`,
+        parent: store.getTask(),
+        definition: _types.PageExportTask.ZipPages,
+        input: {
+          queue,
+          type: input.type
+        }
+      });
+      /**
+       * If there are no more pages to load, we can continue the controller task in a zippingPages mode, with some delay.
+       */
+      if (!meta.hasMoreItems || !meta.cursor) {
+        return response.continue({
+          ...input,
+          ...listPagesParams,
+          currentBatch,
+          totalPages: meta.totalCount,
+          zippingPages: true
+        }, {
+          seconds: _ProcessZipPagesTasks.ZIP_PAGES_WAIT_TIME
+        });
+      }
+      currentBatch++;
+    }
+    /**
+     * Should not be possible to exit the loop without returning a response, but let's have a continue response here just in case.
+     */
+    return response.continue({
+      ...input,
+      ...listPagesParams,
+      currentBatch
+    }, {
+      seconds: _ProcessZipPagesTasks.ZIP_PAGES_WAIT_TIME
+    });
+  }
+}
+exports.CreateZipPagesTasks = CreateZipPagesTasks;
+
+//# sourceMappingURL=CreateZipPagesTasks.js.map

package/export/pages/controller/CreateZipPagesTasks.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_ProcessZipPagesTasks","require","_types","PAGES_IN_BATCH","CreateZipPagesTasks","execute","response","input","isAborted","isCloseToTimeout","context","store","listPagesParams","where","after","limit","currentBatch","result","pageBuilder","listLatestPages","aborted","continue","pages","meta","cursor","totalCount","done","length","totalPages","zippingPages","seconds","ZIP_PAGES_WAIT_TIME","queue","map","page","id","tasks","trigger","name","parent","getTask","definition","PageExportTask","ZipPages","type","hasMoreItems","exports"],"sources":["CreateZipPagesTasks.ts"],"sourcesContent":["import type { ListMeta, ListPagesParams, Page } from \"@webiny/api-page-builder/types\";\nimport { ZIP_PAGES_WAIT_TIME } from \"./ProcessZipPagesTasks\";\nimport type {\n    IExportPagesControllerTaskParams,\n    IExportPagesZipPagesInput\n} from \"~/export/pages/types\";\nimport { PageExportTask } from \"~/export/pages/types\";\nimport type { ITaskResponseResult } from \"@webiny/tasks/types\";\n\nconst PAGES_IN_BATCH = 25;\n\n/**\n * Go through all the pages and create subtasks for zipping pages in batches.\n */\nexport class CreateZipPagesTasks {\n    public async execute({\n        response,\n        input,\n        isAborted,\n        isCloseToTimeout,\n        context,\n        store\n    }: IExportPagesControllerTaskParams): Promise<ITaskResponseResult> {\n        const listPagesParams: ListPagesParams = {\n            where: input.where,\n            after: input.after,\n            limit: PAGES_IN_BATCH\n        };\n\n        let currentBatch = input.currentBatch || 1;\n        let result: [Page[], ListMeta];\n        while ((result = await context.pageBuilder.listLatestPages(listPagesParams))) {\n            if (isAborted()) {\n                return response.aborted();\n            } else if (isCloseToTimeout()) {\n                return response.continue({\n                    ...input,\n                    ...listPagesParams,\n                    currentBatch\n                });\n            }\n            const [pages, meta] = result;\n\n            listPagesParams.after = meta.cursor;\n            /**\n             * If no pages are returned there are two options:\n             * * mark task as done because there are no pages at all\n             * * continue with the control task, but in zippingPages mode\n             */\n            if (meta.totalCount === 0) {\n                return response.done(\"No pages to export.\");\n            } else if (pages.length === 0) {\n                return response.continue(\n                    {\n                        ...input,\n                        ...listPagesParams,\n                        currentBatch,\n                        totalPages: meta.totalCount,\n                        zippingPages: true\n                    },\n                    {\n                        seconds: ZIP_PAGES_WAIT_TIME\n                    }\n                );\n            }\n\n            const queue = pages.map(page => page.id);\n            /**\n             * Trigger a task for each of the loaded pages batch.\n             */\n            await context.tasks.trigger<IExportPagesZipPagesInput>({\n                name: `Page Builder - Export Pages - Zip Pages #${currentBatch}`,\n                parent: store.getTask(),\n                definition: PageExportTask.ZipPages,\n                input: {\n                    queue,\n                    type: input.type\n                }\n            });\n            /**\n             * If there are no more pages to load, we can continue the controller task in a zippingPages mode, with some delay.\n             */\n            if (!meta.hasMoreItems || !meta.cursor) {\n                return response.continue(\n                    {\n                        ...input,\n                        ...listPagesParams,\n                        currentBatch,\n                        totalPages: meta.totalCount,\n                        zippingPages: true\n                    },\n                    {\n                        seconds: ZIP_PAGES_WAIT_TIME\n                    }\n                );\n            }\n            currentBatch++;\n        }\n        /**\n         * Should not be possible to exit the loop without returning a response, but let's have a continue response here just in case.\n         */\n        return response.continue(\n            {\n                ...input,\n                ...listPagesParams,\n                currentBatch\n            },\n            {\n                seconds: ZIP_PAGES_WAIT_TIME\n            }\n        );\n    }\n}\n"],"mappings":";;;;;;AACA,IAAAA,qBAAA,GAAAC,OAAA;AAKA,IAAAC,MAAA,GAAAD,OAAA;AAGA,MAAME,cAAc,GAAG,EAAE;;AAEzB;AACA;AACA;AACO,MAAMC,mBAAmB,CAAC;EAC7B,MAAaC,OAAOA,CAAC;IACjBC,QAAQ;IACRC,KAAK;IACLC,SAAS;IACTC,gBAAgB;IAChBC,OAAO;IACPC;EAC8B,CAAC,EAAgC;IAC/D,MAAMC,eAAgC,GAAG;MACrCC,KAAK,EAAEN,KAAK,CAACM,KAAK;MAClBC,KAAK,EAAEP,KAAK,CAACO,KAAK;MAClBC,KAAK,EAAEZ;IACX,CAAC;IAED,IAAIa,YAAY,GAAGT,KAAK,CAACS,YAAY,IAAI,CAAC;IAC1C,IAAIC,MAA0B;IAC9B,OAAQA,MAAM,GAAG,MAAMP,OAAO,CAACQ,WAAW,CAACC,eAAe,CAACP,eAAe,CAAC,EAAG;MAC1E,IAAIJ,SAAS,CAAC,CAAC,EAAE;QACb,OAAOF,QAAQ,CAACc,OAAO,CAAC,CAAC;MAC7B,CAAC,MAAM,IAAIX,gBAAgB,CAAC,CAAC,EAAE;QAC3B,OAAOH,QAAQ,CAACe,QAAQ,CAAC;UACrB,GAAGd,KAAK;UACR,GAAGK,eAAe;UAClBI;QACJ,CAAC,CAAC;MACN;MACA,MAAM,CAACM,KAAK,EAAEC,IAAI,CAAC,GAAGN,MAAM;MAE5BL,eAAe,CAACE,KAAK,GAAGS,IAAI,CAACC,MAAM;MACnC;AACZ;AACA;AACA;AACA;MACY,IAAID,IAAI,CAACE,UAAU,KAAK,CAAC,EAAE;QACvB,OAAOnB,QAAQ,CAACoB,IAAI,CAAC,qBAAqB,CAAC;MAC/C,CAAC,MAAM,IAAIJ,KAAK,CAACK,MAAM,KAAK,CAAC,EAAE;QAC3B,OAAOrB,QAAQ,CAACe,QAAQ,CACpB;UACI,GAAGd,KAAK;UACR,GAAGK,eAAe;UAClBI,YAAY;UACZY,UAAU,EAAEL,IAAI,CAACE,UAAU;UAC3BI,YAAY,EAAE;QAClB,CAAC,EACD;UACIC,OAAO,EAAEC;QACb,CACJ,CAAC;MACL;MAEA,MAAMC,KAAK,GAAGV,KAAK,CAACW,GAAG,CAACC,IAAI,IAAIA,IAAI,CAACC,EAAE,CAAC;MACxC;AACZ;AACA;MACY,MAAMzB,OAAO,CAAC0B,KAAK,CAACC,OAAO,CAA4B;QACnDC,IAAI,EAAE,4CAA4CtB,YAAY,EAAE;QAChEuB,MAAM,EAAE5B,KAAK,CAAC6B,OAAO,CAAC,CAAC;QACvBC,UAAU,EAAEC,qBAAc,CAACC,QAAQ;QACnCpC,KAAK,EAAE;UACHyB,KAAK;UACLY,IAAI,EAAErC,KAAK,CAACqC;QAChB;MACJ,CAAC,CAAC;MACF;AACZ;AACA;MACY,IAAI,CAACrB,IAAI,CAACsB,YAAY,IAAI,CAACtB,IAAI,CAACC,MAAM,EAAE;QACpC,OAAOlB,QAAQ,CAACe,QAAQ,CACpB;UACI,GAAGd,KAAK;UACR,GAAGK,eAAe;UAClBI,YAAY;UACZY,UAAU,EAAEL,IAAI,CAACE,UAAU;UAC3BI,YAAY,EAAE;QAClB,CAAC,EACD;UACIC,OAAO,EAAEC;QACb,CACJ,CAAC;MACL;MACAf,YAAY,EAAE;IAClB;IACA;AACR;AACA;IACQ,OAAOV,QAAQ,CAACe,QAAQ,CACpB;MACI,GAAGd,KAAK;MACR,GAAGK,eAAe;MAClBI;IACJ,CAAC,EACD;MACIc,OAAO,EAAEC;IACb,CACJ,CAAC;EACL;AACJ;AAACe,OAAA,CAAA1C,mBAAA,GAAAA,mBAAA","ignoreList":[]}

package/export/pages/controller/ProcessZipPagesTasks.d.ts

@@ -0,0 +1,6 @@
+import type { ITaskResponseResult } from "@webiny/tasks";
+import type { IExportPagesControllerTaskParams } from "../types";
+export declare const ZIP_PAGES_WAIT_TIME = 5;
+export declare class ProcessZipPagesTasks {
+    execute(params: IExportPagesControllerTaskParams): Promise<ITaskResponseResult>;
+}

package/export/pages/controller/ProcessZipPagesTasks.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ZIP_PAGES_WAIT_TIME = exports.ProcessZipPagesTasks = void 0;
+var _tasks = require("@webiny/tasks");
+var _types = require("../types");
+var _CombineZippedPages = require("./CombineZippedPages");
+const ZIP_PAGES_WAIT_TIME = exports.ZIP_PAGES_WAIT_TIME = 5;
+class ProcessZipPagesTasks {
+  async execute(params) {
+    const {
+      response,
+      input,
+      isAborted,
+      isCloseToTimeout,
+      context,
+      store
+    } = params;
+    if (isAborted()) {
+      return response.aborted();
+    } else if (isCloseToTimeout()) {
+      return response.continue({
+        ...input
+      });
+    }
+    /**
+     * TODO: implement subtasks and subtask management into the base tasks package.
+     */
+    const result = await context.tasks.listTasks({
+      where: {
+        parentId: store.getTask().id,
+        definitionId: _types.PageExportTask.ZipPages,
+        taskStatus_in: [_tasks.TaskDataStatus.RUNNING, _tasks.TaskDataStatus.PENDING]
+      },
+      limit: 1
+    });
+    /**
+     * Do we still need to wait until all subtasks (Zip Pages) are done?
+     */
+    if (result.items.length > 0) {
+      return response.continue({
+        ...input
+      }, {
+        seconds: ZIP_PAGES_WAIT_TIME
+      });
+    }
+    /**
+     * If all subtasks (Zip Pages) are done, we can continue with zipping all zip files into a single one.
+     */
+    const combineZippedPages = new _CombineZippedPages.CombineZippedPages();
+    return combineZippedPages.execute({
+      store,
+      response
+    });
+  }
+}
+exports.ProcessZipPagesTasks = ProcessZipPagesTasks;
+
+//# sourceMappingURL=ProcessZipPagesTasks.js.map

package/export/pages/controller/ProcessZipPagesTasks.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_tasks","require","_types","_CombineZippedPages","ZIP_PAGES_WAIT_TIME","exports","ProcessZipPagesTasks","execute","params","response","input","isAborted","isCloseToTimeout","context","store","aborted","continue","result","tasks","listTasks","where","parentId","getTask","id","definitionId","PageExportTask","ZipPages","taskStatus_in","TaskDataStatus","RUNNING","PENDING","limit","items","length","seconds","combineZippedPages","CombineZippedPages"],"sources":["ProcessZipPagesTasks.ts"],"sourcesContent":["import type { ITaskResponseResult } from \"@webiny/tasks\";\nimport { TaskDataStatus } from \"@webiny/tasks\";\nimport type { IExportPagesControllerTaskParams } from \"../types\";\nimport { PageExportTask } from \"../types\";\nimport { CombineZippedPages } from \"~/export/pages/controller/CombineZippedPages\";\n\nexport const ZIP_PAGES_WAIT_TIME = 5;\n\nexport class ProcessZipPagesTasks {\n    public async execute(params: IExportPagesControllerTaskParams): Promise<ITaskResponseResult> {\n        const { response, input, isAborted, isCloseToTimeout, context, store } = params;\n\n        if (isAborted()) {\n            return response.aborted();\n        } else if (isCloseToTimeout()) {\n            return response.continue({\n                ...input\n            });\n        }\n        /**\n         * TODO: implement subtasks and subtask management into the base tasks package.\n         */\n        const result = await context.tasks.listTasks({\n            where: {\n                parentId: store.getTask().id,\n                definitionId: PageExportTask.ZipPages,\n                taskStatus_in: [TaskDataStatus.RUNNING, TaskDataStatus.PENDING]\n            },\n            limit: 1\n        });\n        /**\n         * Do we still need to wait until all subtasks (Zip Pages) are done?\n         */\n        if (result.items.length > 0) {\n            return response.continue(\n                {\n                    ...input\n                },\n                {\n                    seconds: ZIP_PAGES_WAIT_TIME\n                }\n            );\n        }\n        /**\n         * If all subtasks (Zip Pages) are done, we can continue with zipping all zip files into a single one.\n         */\n        const combineZippedPages = new CombineZippedPages();\n\n        return combineZippedPages.execute({\n            store,\n            response\n        });\n    }\n}\n"],"mappings":";;;;;;AACA,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,MAAA,GAAAD,OAAA;AACA,IAAAE,mBAAA,GAAAF,OAAA;AAEO,MAAMG,mBAAmB,GAAAC,OAAA,CAAAD,mBAAA,GAAG,CAAC;AAE7B,MAAME,oBAAoB,CAAC;EAC9B,MAAaC,OAAOA,CAACC,MAAwC,EAAgC;IACzF,MAAM;MAAEC,QAAQ;MAAEC,KAAK;MAAEC,SAAS;MAAEC,gBAAgB;MAAEC,OAAO;MAAEC;IAAM,CAAC,GAAGN,MAAM;IAE/E,IAAIG,SAAS,CAAC,CAAC,EAAE;MACb,OAAOF,QAAQ,CAACM,OAAO,CAAC,CAAC;IAC7B,CAAC,MAAM,IAAIH,gBAAgB,CAAC,CAAC,EAAE;MAC3B,OAAOH,QAAQ,CAACO,QAAQ,CAAC;QACrB,GAAGN;MACP,CAAC,CAAC;IACN;IACA;AACR;AACA;IACQ,MAAMO,MAAM,GAAG,MAAMJ,OAAO,CAACK,KAAK,CAACC,SAAS,CAAC;MACzCC,KAAK,EAAE;QACHC,QAAQ,EAAEP,KAAK,CAACQ,OAAO,CAAC,CAAC,CAACC,EAAE;QAC5BC,YAAY,EAAEC,qBAAc,CAACC,QAAQ;QACrCC,aAAa,EAAE,CAACC,qBAAc,CAACC,OAAO,EAAED,qBAAc,CAACE,OAAO;MAClE,CAAC;MACDC,KAAK,EAAE;IACX,CAAC,CAAC;IACF;AACR;AACA;IACQ,IAAId,MAAM,CAACe,KAAK,CAACC,MAAM,GAAG,CAAC,EAAE;MACzB,OAAOxB,QAAQ,CAACO,QAAQ,CACpB;QACI,GAAGN;MACP,CAAC,EACD;QACIwB,OAAO,EAAE9B;MACb,CACJ,CAAC;IACL;IACA;AACR;AACA;IACQ,MAAM+B,kBAAkB,GAAG,IAAIC,sCAAkB,CAAC,CAAC;IAEnD,OAAOD,kBAAkB,CAAC5B,OAAO,CAAC;MAC9BO,KAAK;MACLL;IACJ,CAAC,CAAC;EACN;AACJ;AAACJ,OAAA,CAAAC,oBAAA,GAAAA,oBAAA","ignoreList":[]}

package/export/pages/types.d.ts

@@ -0,0 +1,53 @@
+import type { ITaskResponseDoneResultOutput, ITaskRunParams } from "@webiny/tasks";
+import type { PbImportExportContext } from "../../types";
+export declare enum PageExportTask {
+    Controller = "pageBuilderExportPagesController",
+    ZipPages = "pageBuilderExportPagesZipPages",
+    Cleanup = "pageBuilderExportPagesCleanup"
+}
+/**
+ * Controller
+ */
+export interface IExportPagesControllerInput {
+    type: "published" | "latest";
+    where?: Record<string, any>;
+    totalPages: number;
+    after?: string | null;
+    currentBatch?: number;
+    zippingPages?: boolean;
+}
+export interface IExportPagesControllerOutput extends ITaskResponseDoneResultOutput {
+    key: string;
+    url: string;
+}
+export type IExportPagesControllerTaskParams = ITaskRunParams<PbImportExportContext, IExportPagesControllerInput, IExportPagesControllerOutput>;
+/**
+ * Zip Pages
+ */
+export interface IExportPagesZipPagesDone {
+    [pageId: string]: string;
+}
+export interface IExportPagesZipPagesInput {
+    type: "published" | "latest";
+    queue: string[];
+    done?: IExportPagesZipPagesDone;
+    failed?: string[];
+}
+export interface IExportPagesZipPagesOutput extends ITaskResponseDoneResultOutput {
+    done: IExportPagesZipPagesDone;
+    failed: string[];
+}
+export type IExportPagesZipPagesTaskParams = ITaskRunParams<PbImportExportContext, IExportPagesZipPagesInput, IExportPagesZipPagesOutput>;
+/**
+ * Combine Zipped Pages
+ */
+export interface IExportPagesCombineZippedPagesOutput extends ITaskResponseDoneResultOutput {
+    key: string;
+    url: string;
+}
+export type IExportPagesCombineZippedPagesParams = Pick<ITaskRunParams<PbImportExportContext, IExportPagesControllerInput, IExportPagesCombineZippedPagesOutput>, "store" | "response">;
+/**
+ * Cleanup Zip files
+ */
+export type IExportPagesCleanupInput = Record<string, boolean>;
+export type IExportPagesCleanupTaskParams = ITaskRunParams<PbImportExportContext, IExportPagesCleanupInput>;

package/export/pages/types.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PageExportTask = void 0;
+let PageExportTask = exports.PageExportTask = /*#__PURE__*/function (PageExportTask) {
+  PageExportTask["Controller"] = "pageBuilderExportPagesController";
+  PageExportTask["ZipPages"] = "pageBuilderExportPagesZipPages";
+  PageExportTask["Cleanup"] = "pageBuilderExportPagesCleanup";
+  return PageExportTask;
+}({});
+/**
+ * Controller
+ */
+/**
+ * Zip Pages
+ */
+/**
+ * Combine Zipped Pages
+ */
+/**
+ * Cleanup Zip files
+ */
+
+//# sourceMappingURL=types.js.map

package/export/pages/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["PageExportTask","exports"],"sources":["types.ts"],"sourcesContent":["import type { ITaskResponseDoneResultOutput, ITaskRunParams } from \"@webiny/tasks\";\nimport type { PbImportExportContext } from \"~/types\";\n\nexport enum PageExportTask {\n    Controller = \"pageBuilderExportPagesController\",\n    ZipPages = \"pageBuilderExportPagesZipPages\",\n    Cleanup = \"pageBuilderExportPagesCleanup\"\n}\n\n/**\n * Controller\n */\nexport interface IExportPagesControllerInput {\n    type: \"published\" | \"latest\";\n    where?: Record<string, any>;\n    totalPages: number;\n    after?: string | null;\n    currentBatch?: number;\n    zippingPages?: boolean;\n}\n\nexport interface IExportPagesControllerOutput extends ITaskResponseDoneResultOutput {\n    key: string;\n    url: string;\n}\n\nexport type IExportPagesControllerTaskParams = ITaskRunParams<\n    PbImportExportContext,\n    IExportPagesControllerInput,\n    IExportPagesControllerOutput\n>;\n\n/**\n * Zip Pages\n */\nexport interface IExportPagesZipPagesDone {\n    [pageId: string]: string;\n}\nexport interface IExportPagesZipPagesInput {\n    type: \"published\" | \"latest\";\n    queue: string[];\n    done?: IExportPagesZipPagesDone;\n    failed?: string[];\n}\n\nexport interface IExportPagesZipPagesOutput extends ITaskResponseDoneResultOutput {\n    done: IExportPagesZipPagesDone;\n    failed: string[];\n}\n\nexport type IExportPagesZipPagesTaskParams = ITaskRunParams<\n    PbImportExportContext,\n    IExportPagesZipPagesInput,\n    IExportPagesZipPagesOutput\n>;\n\n/**\n * Combine Zipped Pages\n */\n\nexport interface IExportPagesCombineZippedPagesOutput extends ITaskResponseDoneResultOutput {\n    key: string;\n    url: string;\n}\n\nexport type IExportPagesCombineZippedPagesParams = Pick<\n    ITaskRunParams<\n        PbImportExportContext,\n        IExportPagesControllerInput,\n        IExportPagesCombineZippedPagesOutput\n    >,\n    \"store\" | \"response\"\n>;\n\n/**\n * Cleanup Zip files\n */\nexport type IExportPagesCleanupInput = Record<string, boolean>;\n\nexport type IExportPagesCleanupTaskParams = ITaskRunParams<\n    PbImportExportContext,\n    IExportPagesCleanupInput\n>;\n"],"mappings":";;;;;;IAGYA,cAAc,GAAAC,OAAA,CAAAD,cAAA,0BAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAA,OAAdA,cAAc;AAAA;AAM1B;AACA;AACA;AAqBA;AACA;AACA;AAsBA;AACA;AACA;AAgBA;AACA;AACA","ignoreList":[]}

package/export/pages/utils.d.ts

@@ -0,0 +1,2 @@
+export declare const EXPORT_PAGES_FOLDER_KEY = "WEBINY_PB_EXPORT_PAGES";
+export declare const createExportPagesDataKey: (taskId: string) => string;

package/export/pages/utils.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createExportPagesDataKey = exports.EXPORT_PAGES_FOLDER_KEY = void 0;
+const EXPORT_PAGES_FOLDER_KEY = exports.EXPORT_PAGES_FOLDER_KEY = "WEBINY_PB_EXPORT_PAGES";
+const createExportPagesDataKey = taskId => {
+  return `${EXPORT_PAGES_FOLDER_KEY}/${taskId}`;
+};
+exports.createExportPagesDataKey = createExportPagesDataKey;
+
+//# sourceMappingURL=utils.js.map

package/export/pages/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["EXPORT_PAGES_FOLDER_KEY","exports","createExportPagesDataKey","taskId"],"sources":["utils.ts"],"sourcesContent":["export const EXPORT_PAGES_FOLDER_KEY = \"WEBINY_PB_EXPORT_PAGES\";\n\nexport const createExportPagesDataKey = (taskId: string) => {\n    return `${EXPORT_PAGES_FOLDER_KEY}/${taskId}`;\n};\n"],"mappings":";;;;;;AAAO,MAAMA,uBAAuB,GAAAC,OAAA,CAAAD,uBAAA,GAAG,wBAAwB;AAExD,MAAME,wBAAwB,GAAIC,MAAc,IAAK;EACxD,OAAO,GAAGH,uBAAuB,IAAIG,MAAM,EAAE;AACjD,CAAC;AAACF,OAAA,CAAAC,wBAAA,GAAAA,wBAAA","ignoreList":[]}

package/export/pages/zipPages/ZipPages.d.ts

@@ -0,0 +1,5 @@
+import type { ITaskResponseResult } from "@webiny/tasks";
+import type { IExportPagesZipPagesTaskParams } from "../types";
+export declare class ZipPages {
+    execute(params: IExportPagesZipPagesTaskParams): Promise<ITaskResponseResult>;
+}

package/export/pages/zipPages/ZipPages.js

@@ -0,0 +1,100 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ZipPages = void 0;
+var _PageExporter = require("../../process/exporters/PageExporter");
+var _ZipPagesDataManager = require("./ZipPagesDataManager");
+var _getPageFactory = require("./getPageFactory");
+var _utils = require("../utils");
+/**
+ * We will pause the execution of the task if there is less than CLOSE_TO_TIMEOUT_SECONDS left on the Lambda execution time.
+ */
+const CLOSE_TO_TIMEOUT_SECONDS = 300;
+class ZipPages {
+  async execute(params) {
+    const {
+      response,
+      input,
+      isAborted,
+      isCloseToTimeout,
+      context,
+      store
+    } = params;
+    const parentId = store.getTask().parentId;
+    if (!parentId) {
+      return response.error({
+        message: `Could not find parent task ID.`
+      });
+    }
+    const exportPageDataKey = (0, _utils.createExportPagesDataKey)(parentId);
+    const dataManager = new _ZipPagesDataManager.ZipPagesDataManager(input);
+    if (dataManager.hasMore() === false) {
+      return response.done("Task done.", {
+        done: dataManager.getDone(),
+        failed: dataManager.getFailed()
+      });
+    }
+    const getPage = (0, _getPageFactory.getPageFactory)(context, store, input.type === "published");
+    /**
+     * We will go page by page and zip them.
+     * We are using the input.queue here because we are removing page from the ZipPagesDataManager queue as it is processed.
+     *
+     */
+    for (const pageId of input.queue) {
+      /**
+       * Check for a possibility that the task was aborted.
+       */
+      if (isAborted()) {
+        return response.aborted();
+      }
+      /**
+       * We need to check if there is enough time left to finish the task.
+       */
+      if (isCloseToTimeout(CLOSE_TO_TIMEOUT_SECONDS)) {
+        /**
+         * If there is not enough time left, we will pause the task and return the current state.
+         */
+        return response.continue(dataManager.getInput());
+      }
+      const page = await getPage(pageId);
+      if (!page) {
+        await store.addErrorLog({
+          message: `Could not load page "${pageId}".`,
+          error: {
+            message: `Could not load page "${pageId}".`
+          }
+        });
+        dataManager.addFailed(pageId);
+        continue;
+      }
+      try {
+        const pageExporter = new _PageExporter.PageExporter(context.fileManager);
+        const pageDataZip = await pageExporter.execute(page, exportPageDataKey);
+        if (!pageDataZip.Key) {
+          throw new Error(`Failed to export page "${pageId}" into a zip file.`);
+        }
+        dataManager.addDone(pageId, pageDataZip.Key);
+      } catch (ex) {
+        const message = ex.message || `Failed to export page "${pageId}" into a zip file.`;
+        try {
+          await store.addErrorLog({
+            message,
+            error: ex
+          });
+        } catch {
+          console.error(`Failed to add error log: "${message}"`);
+        }
+        dataManager.addFailed(pageId);
+      }
+    }
+    return response.done("Task done.", {
+      done: dataManager.getDone(),
+      failed: dataManager.getFailed()
+    });
+  }
+}
+exports.ZipPages = ZipPages;
+
+//# sourceMappingURL=ZipPages.js.map

package/export/pages/zipPages/ZipPages.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_PageExporter","require","_ZipPagesDataManager","_getPageFactory","_utils","CLOSE_TO_TIMEOUT_SECONDS","ZipPages","execute","params","response","input","isAborted","isCloseToTimeout","context","store","parentId","getTask","error","message","exportPageDataKey","createExportPagesDataKey","dataManager","ZipPagesDataManager","hasMore","done","getDone","failed","getFailed","getPage","getPageFactory","type","pageId","queue","aborted","continue","getInput","page","addErrorLog","addFailed","pageExporter","PageExporter","fileManager","pageDataZip","Key","Error","addDone","ex","console","exports"],"sources":["ZipPages.ts"],"sourcesContent":["import type { ITaskResponseResult } from \"@webiny/tasks\";\nimport type { IExportPagesZipPagesTaskParams } from \"~/export/pages/types\";\nimport { PageExporter } from \"~/export/process/exporters/PageExporter\";\nimport { ZipPagesDataManager } from \"./ZipPagesDataManager\";\nimport { getPageFactory } from \"./getPageFactory\";\nimport { createExportPagesDataKey } from \"~/export/pages/utils\";\n\n/**\n * We will pause the execution of the task if there is less than CLOSE_TO_TIMEOUT_SECONDS left on the Lambda execution time.\n */\nconst CLOSE_TO_TIMEOUT_SECONDS = 300;\n\nexport class ZipPages {\n    public async execute(params: IExportPagesZipPagesTaskParams): Promise<ITaskResponseResult> {\n        const { response, input, isAborted, isCloseToTimeout, context, store } = params;\n\n        const parentId = store.getTask().parentId;\n        if (!parentId) {\n            return response.error({\n                message: `Could not find parent task ID.`\n            });\n        }\n        const exportPageDataKey = createExportPagesDataKey(parentId);\n\n        const dataManager = new ZipPagesDataManager(input);\n        if (dataManager.hasMore() === false) {\n            return response.done(\"Task done.\", {\n                done: dataManager.getDone(),\n                failed: dataManager.getFailed()\n            });\n        }\n\n        const getPage = getPageFactory(context, store, input.type === \"published\");\n        /**\n         * We will go page by page and zip them.\n         * We are using the input.queue here because we are removing page from the ZipPagesDataManager queue as it is processed.\n         *\n         */\n        for (const pageId of input.queue) {\n            /**\n             * Check for a possibility that the task was aborted.\n             */\n            if (isAborted()) {\n                return response.aborted();\n            }\n            /**\n             * We need to check if there is enough time left to finish the task.\n             */\n            if (isCloseToTimeout(CLOSE_TO_TIMEOUT_SECONDS)) {\n                /**\n                 * If there is not enough time left, we will pause the task and return the current state.\n                 */\n                return response.continue(dataManager.getInput());\n            }\n\n            const page = await getPage(pageId);\n            if (!page) {\n                await store.addErrorLog({\n                    message: `Could not load page \"${pageId}\".`,\n                    error: {\n                        message: `Could not load page \"${pageId}\".`\n                    }\n                });\n                dataManager.addFailed(pageId);\n                continue;\n            }\n            try {\n                const pageExporter = new PageExporter(context.fileManager);\n                const pageDataZip = await pageExporter.execute(page, exportPageDataKey);\n                if (!pageDataZip.Key) {\n                    throw new Error(`Failed to export page \"${pageId}\" into a zip file.`);\n                }\n                dataManager.addDone(pageId, pageDataZip.Key);\n            } catch (ex) {\n                const message = ex.message || `Failed to export page \"${pageId}\" into a zip file.`;\n                try {\n                    await store.addErrorLog({\n                        message,\n                        error: ex\n                    });\n                } catch {\n                    console.error(`Failed to add error log: \"${message}\"`);\n                }\n                dataManager.addFailed(pageId);\n            }\n        }\n\n        return response.done(\"Task done.\", {\n            done: dataManager.getDone(),\n            failed: dataManager.getFailed()\n        });\n    }\n}\n"],"mappings":";;;;;;AAEA,IAAAA,aAAA,GAAAC,OAAA;AACA,IAAAC,oBAAA,GAAAD,OAAA;AACA,IAAAE,eAAA,GAAAF,OAAA;AACA,IAAAG,MAAA,GAAAH,OAAA;AAEA;AACA;AACA;AACA,MAAMI,wBAAwB,GAAG,GAAG;AAE7B,MAAMC,QAAQ,CAAC;EAClB,MAAaC,OAAOA,CAACC,MAAsC,EAAgC;IACvF,MAAM;MAAEC,QAAQ;MAAEC,KAAK;MAAEC,SAAS;MAAEC,gBAAgB;MAAEC,OAAO;MAAEC;IAAM,CAAC,GAAGN,MAAM;IAE/E,MAAMO,QAAQ,GAAGD,KAAK,CAACE,OAAO,CAAC,CAAC,CAACD,QAAQ;IACzC,IAAI,CAACA,QAAQ,EAAE;MACX,OAAON,QAAQ,CAACQ,KAAK,CAAC;QAClBC,OAAO,EAAE;MACb,CAAC,CAAC;IACN;IACA,MAAMC,iBAAiB,GAAG,IAAAC,+BAAwB,EAACL,QAAQ,CAAC;IAE5D,MAAMM,WAAW,GAAG,IAAIC,wCAAmB,CAACZ,KAAK,CAAC;IAClD,IAAIW,WAAW,CAACE,OAAO,CAAC,CAAC,KAAK,KAAK,EAAE;MACjC,OAAOd,QAAQ,CAACe,IAAI,CAAC,YAAY,EAAE;QAC/BA,IAAI,EAAEH,WAAW,CAACI,OAAO,CAAC,CAAC;QAC3BC,MAAM,EAAEL,WAAW,CAACM,SAAS,CAAC;MAClC,CAAC,CAAC;IACN;IAEA,MAAMC,OAAO,GAAG,IAAAC,8BAAc,EAAChB,OAAO,EAAEC,KAAK,EAAEJ,KAAK,CAACoB,IAAI,KAAK,WAAW,CAAC;IAC1E;AACR;AACA;AACA;AACA;IACQ,KAAK,MAAMC,MAAM,IAAIrB,KAAK,CAACsB,KAAK,EAAE;MAC9B;AACZ;AACA;MACY,IAAIrB,SAAS,CAAC,CAAC,EAAE;QACb,OAAOF,QAAQ,CAACwB,OAAO,CAAC,CAAC;MAC7B;MACA;AACZ;AACA;MACY,IAAIrB,gBAAgB,CAACP,wBAAwB,CAAC,EAAE;QAC5C;AAChB;AACA;QACgB,OAAOI,QAAQ,CAACyB,QAAQ,CAACb,WAAW,CAACc,QAAQ,CAAC,CAAC,CAAC;MACpD;MAEA,MAAMC,IAAI,GAAG,MAAMR,OAAO,CAACG,MAAM,CAAC;MAClC,IAAI,CAACK,IAAI,EAAE;QACP,MAAMtB,KAAK,CAACuB,WAAW,CAAC;UACpBnB,OAAO,EAAE,wBAAwBa,MAAM,IAAI;UAC3Cd,KAAK,EAAE;YACHC,OAAO,EAAE,wBAAwBa,MAAM;UAC3C;QACJ,CAAC,CAAC;QACFV,WAAW,CAACiB,SAAS,CAACP,MAAM,CAAC;QAC7B;MACJ;MACA,IAAI;QACA,MAAMQ,YAAY,GAAG,IAAIC,0BAAY,CAAC3B,OAAO,CAAC4B,WAAW,CAAC;QAC1D,MAAMC,WAAW,GAAG,MAAMH,YAAY,CAAChC,OAAO,CAAC6B,IAAI,EAAEjB,iBAAiB,CAAC;QACvE,IAAI,CAACuB,WAAW,CAACC,GAAG,EAAE;UAClB,MAAM,IAAIC,KAAK,CAAC,0BAA0Bb,MAAM,oBAAoB,CAAC;QACzE;QACAV,WAAW,CAACwB,OAAO,CAACd,MAAM,EAAEW,WAAW,CAACC,GAAG,CAAC;MAChD,CAAC,CAAC,OAAOG,EAAE,EAAE;QACT,MAAM5B,OAAO,GAAG4B,EAAE,CAAC5B,OAAO,IAAI,0BAA0Ba,MAAM,oBAAoB;QAClF,IAAI;UACA,MAAMjB,KAAK,CAACuB,WAAW,CAAC;YACpBnB,OAAO;YACPD,KAAK,EAAE6B;UACX,CAAC,CAAC;QACN,CAAC,CAAC,MAAM;UACJC,OAAO,CAAC9B,KAAK,CAAC,6BAA6BC,OAAO,GAAG,CAAC;QAC1D;QACAG,WAAW,CAACiB,SAAS,CAACP,MAAM,CAAC;MACjC;IACJ;IAEA,OAAOtB,QAAQ,CAACe,IAAI,CAAC,YAAY,EAAE;MAC/BA,IAAI,EAAEH,WAAW,CAACI,OAAO,CAAC,CAAC;MAC3BC,MAAM,EAAEL,WAAW,CAACM,SAAS,CAAC;IAClC,CAAC,CAAC;EACN;AACJ;AAACqB,OAAA,CAAA1C,QAAA,GAAAA,QAAA","ignoreList":[]}

package/export/pages/zipPages/ZipPagesDataManager.d.ts

@@ -0,0 +1,14 @@
+import type { IExportPagesZipPagesDone, IExportPagesZipPagesInput } from "../types";
+export declare class ZipPagesDataManager {
+    private readonly input;
+    private readonly queue;
+    private readonly done;
+    private readonly failed;
+    constructor(input: IExportPagesZipPagesInput);
+    hasMore(): boolean;
+    addDone(pageId: string, key: string): void;
+    addFailed(pageId: string): void;
+    getFailed(): string[];
+    getDone(): IExportPagesZipPagesDone;
+    getInput(): IExportPagesZipPagesInput;
+}

package/export/pages/zipPages/ZipPagesDataManager.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ZipPagesDataManager = void 0;
+class ZipPagesDataManager {
+  constructor(input) {
+    this.input = input;
+    this.queue = new Set(input.queue);
+    this.done = {
+      ...input.done
+    };
+    this.failed = new Set(input.failed || []);
+  }
+  hasMore() {
+    return this.queue.size > 0;
+  }
+  addDone(pageId, key) {
+    this.queue.delete(pageId);
+    this.failed.delete(pageId);
+    this.done[pageId] = key;
+  }
+  addFailed(pageId) {
+    this.queue.delete(pageId);
+    this.failed.add(pageId);
+    delete this.done[pageId];
+  }
+  getFailed() {
+    return Array.from(this.failed);
+  }
+  getDone() {
+    return this.done;
+  }
+  getInput() {
+    return {
+      ...this.input,
+      queue: Array.from(this.queue),
+      failed: Array.from(this.failed),
+      done: this.done
+    };
+  }
+}
+exports.ZipPagesDataManager = ZipPagesDataManager;
+
+//# sourceMappingURL=ZipPagesDataManager.js.map

package/export/pages/zipPages/ZipPagesDataManager.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ZipPagesDataManager","constructor","input","queue","Set","done","failed","hasMore","size","addDone","pageId","key","delete","addFailed","add","getFailed","Array","from","getDone","getInput","exports"],"sources":["ZipPagesDataManager.ts"],"sourcesContent":["import type { IExportPagesZipPagesDone, IExportPagesZipPagesInput } from \"~/export/pages/types\";\n\nexport class ZipPagesDataManager {\n    private readonly input: IExportPagesZipPagesInput;\n    private readonly queue: Set<string>;\n    private readonly done: IExportPagesZipPagesDone;\n    private readonly failed: Set<string>;\n\n    public constructor(input: IExportPagesZipPagesInput) {\n        this.input = input;\n        this.queue = new Set(input.queue);\n        this.done = {\n            ...input.done\n        };\n        this.failed = new Set(input.failed || []);\n    }\n\n    public hasMore(): boolean {\n        return this.queue.size > 0;\n    }\n\n    public addDone(pageId: string, key: string): void {\n        this.queue.delete(pageId);\n        this.failed.delete(pageId);\n        this.done[pageId] = key;\n    }\n\n    public addFailed(pageId: string): void {\n        this.queue.delete(pageId);\n        this.failed.add(pageId);\n        delete this.done[pageId];\n    }\n\n    public getFailed() {\n        return Array.from(this.failed);\n    }\n\n    public getDone() {\n        return this.done;\n    }\n\n    public getInput(): IExportPagesZipPagesInput {\n        return {\n            ...this.input,\n            queue: Array.from(this.queue),\n            failed: Array.from(this.failed),\n            done: this.done\n        };\n    }\n}\n"],"mappings":";;;;;;AAEO,MAAMA,mBAAmB,CAAC;EAMtBC,WAAWA,CAACC,KAAgC,EAAE;IACjD,IAAI,CAACA,KAAK,GAAGA,KAAK;IAClB,IAAI,CAACC,KAAK,GAAG,IAAIC,GAAG,CAACF,KAAK,CAACC,KAAK,CAAC;IACjC,IAAI,CAACE,IAAI,GAAG;MACR,GAAGH,KAAK,CAACG;IACb,CAAC;IACD,IAAI,CAACC,MAAM,GAAG,IAAIF,GAAG,CAACF,KAAK,CAACI,MAAM,IAAI,EAAE,CAAC;EAC7C;EAEOC,OAAOA,CAAA,EAAY;IACtB,OAAO,IAAI,CAACJ,KAAK,CAACK,IAAI,GAAG,CAAC;EAC9B;EAEOC,OAAOA,CAACC,MAAc,EAAEC,GAAW,EAAQ;IAC9C,IAAI,CAACR,KAAK,CAACS,MAAM,CAACF,MAAM,CAAC;IACzB,IAAI,CAACJ,MAAM,CAACM,MAAM,CAACF,MAAM,CAAC;IAC1B,IAAI,CAACL,IAAI,CAACK,MAAM,CAAC,GAAGC,GAAG;EAC3B;EAEOE,SAASA,CAACH,MAAc,EAAQ;IACnC,IAAI,CAACP,KAAK,CAACS,MAAM,CAACF,MAAM,CAAC;IACzB,IAAI,CAACJ,MAAM,CAACQ,GAAG,CAACJ,MAAM,CAAC;IACvB,OAAO,IAAI,CAACL,IAAI,CAACK,MAAM,CAAC;EAC5B;EAEOK,SAASA,CAAA,EAAG;IACf,OAAOC,KAAK,CAACC,IAAI,CAAC,IAAI,CAACX,MAAM,CAAC;EAClC;EAEOY,OAAOA,CAAA,EAAG;IACb,OAAO,IAAI,CAACb,IAAI;EACpB;EAEOc,QAAQA,CAAA,EAA8B;IACzC,OAAO;MACH,GAAG,IAAI,CAACjB,KAAK;MACbC,KAAK,EAAEa,KAAK,CAACC,IAAI,CAAC,IAAI,CAACd,KAAK,CAAC;MAC7BG,MAAM,EAAEU,KAAK,CAACC,IAAI,CAAC,IAAI,CAACX,MAAM,CAAC;MAC/BD,IAAI,EAAE,IAAI,CAACA;IACf,CAAC;EACL;AACJ;AAACe,OAAA,CAAApB,mBAAA,GAAAA,mBAAA","ignoreList":[]}

package/export/pages/zipPages/getPageFactory.d.ts

@@ -0,0 +1,4 @@
+import type { PbImportExportContext } from "../../../graphql/types";
+import type { ITaskManagerStore } from "@webiny/tasks";
+import type { IExportPagesZipPagesInput } from "../types";
+export declare const getPageFactory: (context: PbImportExportContext, store: ITaskManagerStore<IExportPagesZipPagesInput>, published: boolean) => (pageId: string) => Promise<import("@webiny/api-page-builder/types").Page<Record<string, any> | null> | null>;

package/export/pages/zipPages/getPageFactory.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPageFactory = void 0;
+const getPageFactory = (context, store, published) => {
+  return async pageId => {
+    if (published) {
+      try {
+        return await context.pageBuilder.getPublishedPageById({
+          id: pageId
+        });
+      } catch (ex) {
+        /**
+         * We do not need to do anything on exception because we will fetch the latest version.
+         */
+      }
+    }
+    try {
+      return await context.pageBuilder.getPage(pageId);
+    } catch (ex) {
+      const message = `There is no page with ID ${pageId}.`;
+      try {
+        await store.addErrorLog({
+          message,
+          error: ex
+        });
+      } catch {
+        console.error(`Failed to add error log: "${message}"`);
+      }
+      return null;
+    }
+  };
+};
+exports.getPageFactory = getPageFactory;
+
+//# sourceMappingURL=getPageFactory.js.map

package/export/pages/zipPages/getPageFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getPageFactory","context","store","published","pageId","pageBuilder","getPublishedPageById","id","ex","getPage","message","addErrorLog","error","console","exports"],"sources":["getPageFactory.ts"],"sourcesContent":["import type { PbImportExportContext } from \"~/graphql/types\";\nimport type { ITaskManagerStore } from \"@webiny/tasks\";\nimport type { IExportPagesZipPagesInput } from \"~/export/pages/types\";\n\nexport const getPageFactory = (\n    context: PbImportExportContext,\n    store: ITaskManagerStore<IExportPagesZipPagesInput>,\n    published: boolean\n) => {\n    return async (pageId: string) => {\n        if (published) {\n            try {\n                return await context.pageBuilder.getPublishedPageById({\n                    id: pageId\n                });\n            } catch (ex) {\n                /**\n                 * We do not need to do anything on exception because we will fetch the latest version.\n                 */\n            }\n        }\n        try {\n            return await context.pageBuilder.getPage(pageId);\n        } catch (ex) {\n            const message = `There is no page with ID ${pageId}.`;\n            try {\n                await store.addErrorLog({\n                    message,\n                    error: ex\n                });\n            } catch {\n                console.error(`Failed to add error log: \"${message}\"`);\n            }\n            return null;\n        }\n    };\n};\n"],"mappings":";;;;;;AAIO,MAAMA,cAAc,GAAGA,CAC1BC,OAA8B,EAC9BC,KAAmD,EACnDC,SAAkB,KACjB;EACD,OAAO,MAAOC,MAAc,IAAK;IAC7B,IAAID,SAAS,EAAE;MACX,IAAI;QACA,OAAO,MAAMF,OAAO,CAACI,WAAW,CAACC,oBAAoB,CAAC;UAClDC,EAAE,EAAEH;QACR,CAAC,CAAC;MACN,CAAC,CAAC,OAAOI,EAAE,EAAE;QACT;AAChB;AACA;MAFgB;IAIR;IACA,IAAI;MACA,OAAO,MAAMP,OAAO,CAACI,WAAW,CAACI,OAAO,CAACL,MAAM,CAAC;IACpD,CAAC,CAAC,OAAOI,EAAE,EAAE;MACT,MAAME,OAAO,GAAG,4BAA4BN,MAAM,GAAG;MACrD,IAAI;QACA,MAAMF,KAAK,CAACS,WAAW,CAAC;UACpBD,OAAO;UACPE,KAAK,EAAEJ;QACX,CAAC,CAAC;MACN,CAAC,CAAC,MAAM;QACJK,OAAO,CAACD,KAAK,CAAC,6BAA6BF,OAAO,GAAG,CAAC;MAC1D;MACA,OAAO,IAAI;IACf;EACJ,CAAC;AACL,CAAC;AAACI,OAAA,CAAAd,cAAA,GAAAA,cAAA","ignoreList":[]}

package/export/process/blocksHandler.d.ts

@@ -1,5 +1,5 @@
-import { PbImportExportContext } from "../../types";
-import { Configuration, Payload, Response } from ".";
+import type { PbImportExportContext } from "../../types";
+import type { Configuration, Payload, Response } from "./";
 /**
  * Handles the export blocks process workflow.
  */

package/export/process/blocksHandler.js

@@ -7,9 +7,9 @@ exports.blocksHandler = void 0;
 var _types = require("../../types");
 var _client = require("../../client");
 var _handlerGraphql = require("@webiny/handler-graphql");
-var _utils = require("../utils");
 var _mockSecurity = require("../../mockSecurity");
-var _utils2 = require("@webiny/utils");
+var _utils = require("@webiny/utils");
+var _BlockExporter = require("./exporters/BlockExporter");
 /**
  * Handles the export blocks process workflow.
  */
@@ -37,7 +37,7 @@ const blocksHandler = async (configuration, payload, context) => {
      * Note: We're not going to DB for finding the next sub-task to process,
      * because the data might be out of sync due to GSI eventual consistency.
      */
-    subTask = await pageBuilder.importExportTask.getSubTask(taskId, (0, _utils2.zeroPad)(subTaskIndex, 5));
+    subTask = await pageBuilder.importExportTask.getSubTask(taskId, (0, _utils.zeroPad)(subTaskIndex, 5));
     /**
      * Base condition!!
      * Bail out early, if task not found or task's status is not "pending".
@@ -65,6 +65,11 @@ const blocksHandler = async (configuration, payload, context) => {
       throw new _handlerGraphql.NotFoundError(`Unable to load block "${blockId}"`);
     }
     log(`Processing block key "${blockId}"`);
+    const blockCategory = await pageBuilder.getBlockCategory(block.blockCategory);
+    if (!blockCategory) {
+      log(`Unable to load block category "${block.blockCategory}"`);
+      throw new _handlerGraphql.NotFoundError(`Unable to load block category "${block.blockCategory}"`);
+    }
 
     // Mark task status as PROCESSING
     subTask = await pageBuilder.importExportTask.updateSubTask(taskId, subTask.id, {
@@ -77,8 +82,8 @@ const blocksHandler = async (configuration, payload, context) => {
     });
     prevStatusOfSubTask = subTask.status;
     log(`Extracting block data and uploading to storage...`);
-    // Extract Block
-    const blockDataZip = await (0, _utils.exportBlock)(block, exportBlocksDataKey, fileManager);
+    const blockExporter = new _BlockExporter.BlockExporter(fileManager);
+    const blockDataZip = await blockExporter.execute(block, blockCategory, exportBlocksDataKey);
     log(`Finish uploading zip...`);
     // Update task record in DB
     subTask = await pageBuilder.importExportTask.updateSubTask(taskId, subTask.id, {
@@ -159,4 +164,6 @@ const blocksHandler = async (configuration, payload, context) => {
     error: null
   };
 };
-exports.blocksHandler = blocksHandler;
+exports.blocksHandler = blocksHandler;
+
+//# sourceMappingURL=blocksHandler.js.map