@webiny/api-page-builder-import-export 0.0.0-unstable.1e66d121db → 0.0.0-unstable.2aaa1916d9

package/export/pages/ExportPagesController.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ExportPagesController = void 0;
+var _ProcessZipPagesTasks = require("./controller/ProcessZipPagesTasks");
+var _CreateZipPagesTasks = require("./controller/CreateZipPagesTasks");
+class ExportPagesController {
+  async execute(params) {
+    const {
+      input
+    } = params;
+    /**
+     * In case subtasks for zipping pages are already created, we need to wait for them to finish.
+     * After they are done, we can combine all zip files into a single one.
+     */
+    if (input.zippingPages) {
+      const processZipPagesTasks = new _ProcessZipPagesTasks.ProcessZipPagesTasks();
+      return await processZipPagesTasks.execute(params);
+    }
+    /**
+     * On the first run of the task, we need to create subtasks for zipping pages in batches.
+     */
+    const createZipPagesTasks = new _CreateZipPagesTasks.CreateZipPagesTasks();
+    return await createZipPagesTasks.execute(params);
+  }
+}
+exports.ExportPagesController = ExportPagesController;
+
+//# sourceMappingURL=ExportPagesController.js.map

package/export/pages/ExportPagesController.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_ProcessZipPagesTasks","require","_CreateZipPagesTasks","ExportPagesController","execute","params","input","zippingPages","processZipPagesTasks","ProcessZipPagesTasks","createZipPagesTasks","CreateZipPagesTasks","exports"],"sources":["ExportPagesController.ts"],"sourcesContent":["import type { IExportPagesControllerTaskParams } from \"./types\";\nimport type { ITaskResponseResult } from \"@webiny/tasks\";\nimport { ProcessZipPagesTasks } from \"./controller/ProcessZipPagesTasks\";\nimport { CreateZipPagesTasks } from \"./controller/CreateZipPagesTasks\";\n\nexport class ExportPagesController {\n    public async execute(params: IExportPagesControllerTaskParams): Promise<ITaskResponseResult> {\n        const { input } = params;\n        /**\n         * In case subtasks for zipping pages are already created, we need to wait for them to finish.\n         * After they are done, we can combine all zip files into a single one.\n         */\n        if (input.zippingPages) {\n            const processZipPagesTasks = new ProcessZipPagesTasks();\n            return await processZipPagesTasks.execute(params);\n        }\n        /**\n         * On the first run of the task, we need to create subtasks for zipping pages in batches.\n         */\n        const createZipPagesTasks = new CreateZipPagesTasks();\n        return await createZipPagesTasks.execute(params);\n    }\n}\n"],"mappings":";;;;;;AAEA,IAAAA,qBAAA,GAAAC,OAAA;AACA,IAAAC,oBAAA,GAAAD,OAAA;AAEO,MAAME,qBAAqB,CAAC;EAC/B,MAAaC,OAAOA,CAACC,MAAwC,EAAgC;IACzF,MAAM;MAAEC;IAAM,CAAC,GAAGD,MAAM;IACxB;AACR;AACA;AACA;IACQ,IAAIC,KAAK,CAACC,YAAY,EAAE;MACpB,MAAMC,oBAAoB,GAAG,IAAIC,0CAAoB,CAAC,CAAC;MACvD,OAAO,MAAMD,oBAAoB,CAACJ,OAAO,CAACC,MAAM,CAAC;IACrD;IACA;AACR;AACA;IACQ,MAAMK,mBAAmB,GAAG,IAAIC,wCAAmB,CAAC,CAAC;IACrD,OAAO,MAAMD,mBAAmB,CAACN,OAAO,CAACC,MAAM,CAAC;EACpD;AACJ;AAACO,OAAA,CAAAT,qBAAA,GAAAA,qBAAA","ignoreList":[]}

package/export/pages/ExportPagesZipPages.d.ts

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

package/export/pages/ExportPagesZipPages.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ExportPagesZipPages = void 0;
+var _ZipPages = require("./zipPages/ZipPages");
+class ExportPagesZipPages {
+  async execute(params) {
+    const {
+      isAborted,
+      response
+    } = params;
+    if (isAborted()) {
+      return response.aborted();
+    }
+    const zipPages = new _ZipPages.ZipPages();
+    return await zipPages.execute(params);
+  }
+}
+exports.ExportPagesZipPages = ExportPagesZipPages;
+
+//# sourceMappingURL=ExportPagesZipPages.js.map

package/export/pages/ExportPagesZipPages.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_ZipPages","require","ExportPagesZipPages","execute","params","isAborted","response","aborted","zipPages","ZipPages","exports"],"sources":["ExportPagesZipPages.ts"],"sourcesContent":["import type { IExportPagesZipPagesTaskParams } from \"~/export/pages/types\";\nimport type { ITaskResponseResult } from \"@webiny/tasks\";\nimport { ZipPages } from \"./zipPages/ZipPages\";\n\nexport class ExportPagesZipPages {\n    public async execute(params: IExportPagesZipPagesTaskParams): Promise<ITaskResponseResult> {\n        const { isAborted, response } = params;\n        if (isAborted()) {\n            return response.aborted();\n        }\n\n        const zipPages = new ZipPages();\n        return await zipPages.execute(params);\n    }\n}\n"],"mappings":";;;;;;AAEA,IAAAA,SAAA,GAAAC,OAAA;AAEO,MAAMC,mBAAmB,CAAC;EAC7B,MAAaC,OAAOA,CAACC,MAAsC,EAAgC;IACvF,MAAM;MAAEC,SAAS;MAAEC;IAAS,CAAC,GAAGF,MAAM;IACtC,IAAIC,SAAS,CAAC,CAAC,EAAE;MACb,OAAOC,QAAQ,CAACC,OAAO,CAAC,CAAC;IAC7B;IAEA,MAAMC,QAAQ,GAAG,IAAIC,kBAAQ,CAAC,CAAC;IAC/B,OAAO,MAAMD,QAAQ,CAACL,OAAO,CAACC,MAAM,CAAC;EACzC;AACJ;AAACM,OAAA,CAAAR,mBAAA,GAAAA,mBAAA","ignoreList":[]}

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

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

package/export/pages/controller/CombineZippedPages.js

@@ -0,0 +1,75 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CombineZippedPages = void 0;
+var _s3Stream = require("../../s3Stream");
+var _utils = require("../utils");
+var _ZipFiles = require("../../../utils/ZipFiles");
+var _uniqid = _interopRequireDefault(require("uniqid"));
+class CombineZippedPages {
+  async execute(params) {
+    const {
+      response,
+      store
+    } = params;
+    /**
+     * 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.
+     * Current task must have a parent for this to work.
+     */
+    const taskId = store.getTask().id;
+
+    /**
+     * When we have all the pages IDs and their zip files, we can continue to combine the zip files into one.
+     */
+    const exportPagesDataKey = (0, _utils.createExportPagesDataKey)(taskId);
+    let listObjectResponse;
+    try {
+      listObjectResponse = await _s3Stream.s3Stream.listObject(exportPagesDataKey);
+      if (!Array.isArray(listObjectResponse.Contents)) {
+        return response.error({
+          message: "There is no Contents defined on S3 Stream while combining pages."
+        });
+      } else if (listObjectResponse.Contents.length === 0) {
+        return response.done("No zip files to combine.");
+      }
+    } catch (ex) {
+      return response.error(ex);
+    }
+    const zipFileKeys = listObjectResponse.Contents.reduce((files, file) => {
+      if (!file.Key) {
+        return files;
+      } else if (file.Key === exportPagesDataKey) {
+        return files;
+      }
+      files.push(file.Key);
+      return files;
+    }, []);
+    let key;
+    try {
+      const zipOfZip = new _ZipFiles.ZipFiles();
+      const target = (0, _uniqid.default)("EXPORTS/", "-WEBINY_PAGE_EXPORT.zip");
+      const pageExportUpload = await zipOfZip.process(target, zipFileKeys);
+      if (!pageExportUpload?.Key) {
+        return response.error({
+          message: "There is no Key defined on pageExportUpload."
+        });
+      }
+      key = pageExportUpload.Key;
+    } catch (ex) {
+      console.error(`Error while combining zip files into a single zip: ${ex.message}`);
+      console.log(ex);
+      return response.error(ex);
+    }
+    const url = await _s3Stream.s3Stream.getPresignedUrl(key);
+    return response.done("Done combining pages.", {
+      key,
+      url
+    });
+  }
+}
+exports.CombineZippedPages = CombineZippedPages;
+
+//# sourceMappingURL=CombineZippedPages.js.map

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;
+}