@webiny/api-page-builder-import-export 5.39.2-beta.3 → 5.39.3-beta.0

package/export/combine/index.js

@@ -7,7 +7,6 @@ exports.default = void 0;
 var _handlerAws = require("@webiny/handler-aws");
 var _blocksHandler = require("./blocksHandler");
 var _formsHandler = require("./formsHandler");
-var _pagesHandler = require("./pagesHandler");
 var _templatesHandler = require("./templatesHandler");
 /**
  * Handles the export pages combine workflow.
@@ -33,7 +32,8 @@ var _default = () => {
           }
         default:
           {
-            return (0, _pagesHandler.pagesHandler)(payload, context);
+            console.log("Export PB combine", JSON.stringify(payload));
+            throw new Error("Invalid type provided: pb combine.");
           }
       }
     });

package/export/combine/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_handlerAws","require","_blocksHandler","_formsHandler","_pagesHandler","_templatesHandler","_default","createRawEventHandler","payload","context","security","withoutAuthorization","type","blocksHandler","formsHandler","templatesHandler","pagesHandler","exports","default"],"sources":["index.ts"],"sourcesContent":["import { PbImportExportContext } from \"~/types\";\nimport { SecurityIdentity } from \"@webiny/api-security/types\";\nimport { createRawEventHandler } from \"@webiny/handler-aws\";\nimport { blocksHandler } from \"~/export/combine/blocksHandler\";\nimport { formsHandler } from \"~/export/combine/formsHandler\";\nimport { pagesHandler } from \"~/export/combine/pagesHandler\";\nimport { templatesHandler } from \"~/export/combine/templatesHandler\";\n\nexport interface Payload {\n    taskId: string;\n    type: string;\n    identity: SecurityIdentity;\n}\n\nexport interface Response {\n    data: string | null;\n    error: Partial<Error> | null;\n}\n\n/**\n * Handles the export pages combine workflow.\n */\nexport default () => {\n    return createRawEventHandler<Payload, PbImportExportContext, Response>(\n        async ({ payload, context }) => {\n            return context.security.withoutAuthorization(() => {\n                switch (payload.type) {\n                    case \"block\": {\n                        return blocksHandler(payload, context);\n                    }\n                    case \"form\": {\n                        return formsHandler(payload, context);\n                    }\n                    case \"template\": {\n                        return templatesHandler(payload, context);\n                    }\n                    default: {\n                        return pagesHandler(payload, context);\n                    }\n                }\n            });\n        }\n    );\n};\n"],"mappings":";;;;;;AAEA,IAAAA,WAAA,GAAAC,OAAA;AACA,IAAAC,cAAA,GAAAD,OAAA;AACA,IAAAE,aAAA,GAAAF,OAAA;AACA,IAAAG,aAAA,GAAAH,OAAA;AACA,IAAAI,iBAAA,GAAAJ,OAAA;AAaA;AACA;AACA;AAFA,IAAAK,QAAA,GAGeA,CAAA,KAAM;EACjB,OAAO,IAAAC,iCAAqB,EACxB,OAAO;IAAEC,OAAO;IAAEC;EAAQ,CAAC,KAAK;IAC5B,OAAOA,OAAO,CAACC,QAAQ,CAACC,oBAAoB,CAAC,MAAM;MAC/C,QAAQH,OAAO,CAACI,IAAI;QAChB,KAAK,OAAO;UAAE;YACV,OAAO,IAAAC,4BAAa,EAACL,OAAO,EAAEC,OAAO,CAAC;UAC1C;QACA,KAAK,MAAM;UAAE;YACT,OAAO,IAAAK,0BAAY,EAACN,OAAO,EAAEC,OAAO,CAAC;UACzC;QACA,KAAK,UAAU;UAAE;YACb,OAAO,IAAAM,kCAAgB,EAACP,OAAO,EAAEC,OAAO,CAAC;UAC7C;QACA;UAAS;YACL,OAAO,IAAAO,0BAAY,EAACR,OAAO,EAAEC,OAAO,CAAC;UACzC;MACJ;IACJ,CAAC,CAAC;EACN,CACJ,CAAC;AACL,CAAC;AAAAQ,OAAA,CAAAC,OAAA,GAAAZ,QAAA"}
+{"version":3,"names":["_handlerAws","require","_blocksHandler","_formsHandler","_templatesHandler","_default","createRawEventHandler","payload","context","security","withoutAuthorization","type","blocksHandler","formsHandler","templatesHandler","console","log","JSON","stringify","Error","exports","default"],"sources":["index.ts"],"sourcesContent":["import { PbImportExportContext } from \"~/types\";\nimport { SecurityIdentity } from \"@webiny/api-security/types\";\nimport { createRawEventHandler } from \"@webiny/handler-aws\";\nimport { blocksHandler } from \"~/export/combine/blocksHandler\";\nimport { formsHandler } from \"~/export/combine/formsHandler\";\nimport { templatesHandler } from \"~/export/combine/templatesHandler\";\n\nexport interface Payload {\n    taskId: string;\n    type: string;\n    identity: SecurityIdentity;\n}\n\nexport interface Response {\n    data: string | null;\n    error: Partial<Error> | null;\n}\n\n/**\n * Handles the export pages combine workflow.\n */\nexport default () => {\n    return createRawEventHandler<Payload, PbImportExportContext, Response>(\n        async ({ payload, context }) => {\n            return context.security.withoutAuthorization(() => {\n                switch (payload.type) {\n                    case \"block\": {\n                        return blocksHandler(payload, context);\n                    }\n                    case \"form\": {\n                        return formsHandler(payload, context);\n                    }\n                    case \"template\": {\n                        return templatesHandler(payload, context);\n                    }\n                    default: {\n                        console.log(\"Export PB combine\", JSON.stringify(payload));\n                        throw new Error(\"Invalid type provided: pb combine.\");\n                    }\n                }\n            });\n        }\n    );\n};\n"],"mappings":";;;;;;AAEA,IAAAA,WAAA,GAAAC,OAAA;AACA,IAAAC,cAAA,GAAAD,OAAA;AACA,IAAAE,aAAA,GAAAF,OAAA;AACA,IAAAG,iBAAA,GAAAH,OAAA;AAaA;AACA;AACA;AAFA,IAAAI,QAAA,GAGeA,CAAA,KAAM;EACjB,OAAO,IAAAC,iCAAqB,EACxB,OAAO;IAAEC,OAAO;IAAEC;EAAQ,CAAC,KAAK;IAC5B,OAAOA,OAAO,CAACC,QAAQ,CAACC,oBAAoB,CAAC,MAAM;MAC/C,QAAQH,OAAO,CAACI,IAAI;QAChB,KAAK,OAAO;UAAE;YACV,OAAO,IAAAC,4BAAa,EAACL,OAAO,EAAEC,OAAO,CAAC;UAC1C;QACA,KAAK,MAAM;UAAE;YACT,OAAO,IAAAK,0BAAY,EAACN,OAAO,EAAEC,OAAO,CAAC;UACzC;QACA,KAAK,UAAU;UAAE;YACb,OAAO,IAAAM,kCAAgB,EAACP,OAAO,EAAEC,OAAO,CAAC;UAC7C;QACA;UAAS;YACLO,OAAO,CAACC,GAAG,CAAC,mBAAmB,EAAEC,IAAI,CAACC,SAAS,CAACX,OAAO,CAAC,CAAC;YACzD,MAAM,IAAIY,KAAK,CAAC,oCAAoC,CAAC;UACzD;MACJ;IACJ,CAAC,CAAC;EACN,CACJ,CAAC;AACL,CAAC;AAAAC,OAAA,CAAAC,OAAA,GAAAhB,QAAA"}

package/export/pages/ExportPagesCleanup.d.ts

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

package/export/pages/ExportPagesCleanup.js

@@ -0,0 +1,82 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ExportPagesCleanup = void 0;
+var _types = require("./types");
+var _clientS = require("@webiny/aws-sdk/client-s3");
+var _chunk = _interopRequireDefault(require("lodash/chunk"));
+class ExportPagesCleanup {
+  async execute(params) {
+    const {
+      context,
+      response,
+      store
+    } = params;
+    /**
+     * This task must have a parent one. If it does not, just end with error.
+     * This should not happen as we trigger this task from a parent one, not directly.
+     *
+     * But let's just make sure.
+     */
+    const task = store.getTask();
+    if (!task.parentId) {
+      return response.error(`Missing task "${task.id}" parent id.`);
+    }
+    const parent = await context.tasks.getTask(task.parentId);
+    if (!parent) {
+      return response.error(`Missing parent task "${task.parentId}" in the database.`);
+    }
+    /**
+     * We need to find all the tasks that created zip files, so we can have a list of files to delete.
+     */
+    const {
+      items: subTasks
+    } = await context.tasks.listTasks({
+      where: {
+        parentId: parent.id,
+        definitionId: _types.PageExportTask.ZipPages
+      },
+      limit: 10000
+    });
+    if (subTasks.length === 0) {
+      return response.done("No subtasks found - nothing to cleanup.");
+    }
+    const files = subTasks.reduce((collection, subTask) => {
+      const done = subTask.output?.done;
+      if (!done) {
+        return collection;
+      }
+      const results = Object.values(done).filter(Boolean);
+      collection.push(...results);
+      return collection;
+    }, []);
+    const s3 = (0, _clientS.createS3Client)({
+      region: process.env.AWS_REGION
+    });
+    const parentKey = parent.output?.key;
+    if (typeof parentKey === "string") {
+      await s3.deleteObject({
+        Bucket: process.env.S3_BUCKET,
+        Key: parentKey
+      });
+    }
+    const chunks = (0, _chunk.default)(files, 500);
+    for (const chunk of chunks) {
+      await s3.deleteObjects({
+        Bucket: process.env.S3_BUCKET,
+        Delete: {
+          Objects: chunk.map(Key => ({
+            Key
+          }))
+        }
+      });
+    }
+    return response.done("Done with cleanup!");
+  }
+}
+exports.ExportPagesCleanup = ExportPagesCleanup;
+
+//# sourceMappingURL=ExportPagesCleanup.js.map

package/export/pages/ExportPagesCleanup.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_types","require","_clientS","_chunk","_interopRequireDefault","ExportPagesCleanup","execute","params","context","response","store","task","getTask","parentId","error","id","parent","tasks","items","subTasks","listTasks","where","definitionId","PageExportTask","ZipPages","limit","length","done","files","reduce","collection","subTask","output","results","Object","values","filter","Boolean","push","s3","createS3Client","region","process","env","AWS_REGION","parentKey","key","deleteObject","Bucket","S3_BUCKET","Key","chunks","lodashChunk","chunk","deleteObjects","Delete","Objects","map","exports"],"sources":["ExportPagesCleanup.ts"],"sourcesContent":["import {\n    IExportPagesCleanupTaskParams,\n    IExportPagesControllerOutput,\n    IExportPagesZipPagesOutput,\n    PageExportTask\n} from \"~/export/pages/types\";\nimport { ITaskResponseResult } from \"@webiny/tasks\";\nimport { createS3Client } from \"@webiny/aws-sdk/client-s3\";\nimport lodashChunk from \"lodash/chunk\";\n\nexport class ExportPagesCleanup {\n    public async execute(params: IExportPagesCleanupTaskParams): Promise<ITaskResponseResult> {\n        const { context, response, store } = params;\n        /**\n         * This task must have a parent one. If it does not, just end with error.\n         * This should not happen as we trigger this task from a parent one, not directly.\n         *\n         * But let's just make sure.\n         */\n        const task = store.getTask();\n        if (!task.parentId) {\n            return response.error(`Missing task \"${task.id}\" parent id.`);\n        }\n\n        const parent = await context.tasks.getTask<IExportPagesControllerOutput>(task.parentId);\n        if (!parent) {\n            return response.error(`Missing parent task \"${task.parentId}\" in the database.`);\n        }\n        /**\n         * We need to find all the tasks that created zip files, so we can have a list of files to delete.\n         */\n        const { items: subTasks } = await context.tasks.listTasks<any, IExportPagesZipPagesOutput>({\n            where: {\n                parentId: parent.id,\n                definitionId: PageExportTask.ZipPages\n            },\n            limit: 10000\n        });\n        if (subTasks.length === 0) {\n            return response.done(\"No subtasks found - nothing to cleanup.\");\n        }\n\n        const files = subTasks.reduce<string[]>((collection, subTask) => {\n            const done = subTask.output?.done;\n            if (!done) {\n                return collection;\n            }\n            const results = Object.values(done).filter(Boolean);\n            collection.push(...results);\n            return collection;\n        }, []);\n\n        const s3 = createS3Client({\n            region: process.env.AWS_REGION\n        });\n\n        const parentKey = parent.output?.key;\n        if (typeof parentKey === \"string\") {\n            await s3.deleteObject({\n                Bucket: process.env.S3_BUCKET,\n                Key: parentKey\n            });\n        }\n\n        const chunks = lodashChunk(files, 500);\n\n        for (const chunk of chunks) {\n            await s3.deleteObjects({\n                Bucket: process.env.S3_BUCKET,\n                Delete: {\n                    Objects: chunk.map(Key => ({ Key }))\n                }\n            });\n        }\n\n        return response.done(\"Done with cleanup!\");\n    }\n}\n"],"mappings":";;;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAOA,IAAAC,QAAA,GAAAD,OAAA;AACA,IAAAE,MAAA,GAAAC,sBAAA,CAAAH,OAAA;AAEO,MAAMI,kBAAkB,CAAC;EAC5B,MAAaC,OAAOA,CAACC,MAAqC,EAAgC;IACtF,MAAM;MAAEC,OAAO;MAAEC,QAAQ;MAAEC;IAAM,CAAC,GAAGH,MAAM;IAC3C;AACR;AACA;AACA;AACA;AACA;IACQ,MAAMI,IAAI,GAAGD,KAAK,CAACE,OAAO,CAAC,CAAC;IAC5B,IAAI,CAACD,IAAI,CAACE,QAAQ,EAAE;MAChB,OAAOJ,QAAQ,CAACK,KAAK,CAAE,iBAAgBH,IAAI,CAACI,EAAG,cAAa,CAAC;IACjE;IAEA,MAAMC,MAAM,GAAG,MAAMR,OAAO,CAACS,KAAK,CAACL,OAAO,CAA+BD,IAAI,CAACE,QAAQ,CAAC;IACvF,IAAI,CAACG,MAAM,EAAE;MACT,OAAOP,QAAQ,CAACK,KAAK,CAAE,wBAAuBH,IAAI,CAACE,QAAS,oBAAmB,CAAC;IACpF;IACA;AACR;AACA;IACQ,MAAM;MAAEK,KAAK,EAAEC;IAAS,CAAC,GAAG,MAAMX,OAAO,CAACS,KAAK,CAACG,SAAS,CAAkC;MACvFC,KAAK,EAAE;QACHR,QAAQ,EAAEG,MAAM,CAACD,EAAE;QACnBO,YAAY,EAAEC,qBAAc,CAACC;MACjC,CAAC;MACDC,KAAK,EAAE;IACX,CAAC,CAAC;IACF,IAAIN,QAAQ,CAACO,MAAM,KAAK,CAAC,EAAE;MACvB,OAAOjB,QAAQ,CAACkB,IAAI,CAAC,yCAAyC,CAAC;IACnE;IAEA,MAAMC,KAAK,GAAGT,QAAQ,CAACU,MAAM,CAAW,CAACC,UAAU,EAAEC,OAAO,KAAK;MAC7D,MAAMJ,IAAI,GAAGI,OAAO,CAACC,MAAM,EAAEL,IAAI;MACjC,IAAI,CAACA,IAAI,EAAE;QACP,OAAOG,UAAU;MACrB;MACA,MAAMG,OAAO,GAAGC,MAAM,CAACC,MAAM,CAACR,IAAI,CAAC,CAACS,MAAM,CAACC,OAAO,CAAC;MACnDP,UAAU,CAACQ,IAAI,CAAC,GAAGL,OAAO,CAAC;MAC3B,OAAOH,UAAU;IACrB,CAAC,EAAE,EAAE,CAAC;IAEN,MAAMS,EAAE,GAAG,IAAAC,uBAAc,EAAC;MACtBC,MAAM,EAAEC,OAAO,CAACC,GAAG,CAACC;IACxB,CAAC,CAAC;IAEF,MAAMC,SAAS,GAAG7B,MAAM,CAACgB,MAAM,EAAEc,GAAG;IACpC,IAAI,OAAOD,SAAS,KAAK,QAAQ,EAAE;MAC/B,MAAMN,EAAE,CAACQ,YAAY,CAAC;QAClBC,MAAM,EAAEN,OAAO,CAACC,GAAG,CAACM,SAAS;QAC7BC,GAAG,EAAEL;MACT,CAAC,CAAC;IACN;IAEA,MAAMM,MAAM,GAAG,IAAAC,cAAW,EAACxB,KAAK,EAAE,GAAG,CAAC;IAEtC,KAAK,MAAMyB,KAAK,IAAIF,MAAM,EAAE;MACxB,MAAMZ,EAAE,CAACe,aAAa,CAAC;QACnBN,MAAM,EAAEN,OAAO,CAACC,GAAG,CAACM,SAAS;QAC7BM,MAAM,EAAE;UACJC,OAAO,EAAEH,KAAK,CAACI,GAAG,CAACP,GAAG,KAAK;YAAEA;UAAI,CAAC,CAAC;QACvC;MACJ,CAAC,CAAC;IACN;IAEA,OAAOzC,QAAQ,CAACkB,IAAI,CAAC,oBAAoB,CAAC;EAC9C;AACJ;AAAC+B,OAAA,CAAArD,kBAAA,GAAAA,kBAAA"}

package/export/pages/ExportPagesController.d.ts

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

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 { IExportPagesControllerTaskParams } from \"./types\";\nimport { 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"}

package/export/pages/ExportPagesZipPages.d.ts

@@ -0,0 +1,5 @@
+import { IExportPagesZipPagesTaskParams } from "./types";
+import { 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 { IExportPagesZipPagesTaskParams } from \"~/export/pages/types\";\nimport { 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"}

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

@@ -0,0 +1,5 @@
+import { IExportPagesCombineZippedPagesParams } from "../types";
+import { 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 { IExportPagesCombineZippedPagesParams } from \"~/export/pages/types\";\nimport { ITaskResponseResult } from \"@webiny/tasks\";\nimport { ListObjectsOutput, 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":";;;;;;;AAEA,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,CAAE,sDAAqDI,EAAE,CAACH,OAAQ,EAAC,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"}

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

@@ -0,0 +1,8 @@
+import { IExportPagesControllerTaskParams } from "../types";
+import { 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 { ListMeta, ListPagesParams, Page } from \"@webiny/api-page-builder/types\";\nimport { ZIP_PAGES_WAIT_TIME } from \"./ProcessZipPagesTasks\";\nimport {\n    IExportPagesControllerTaskParams,\n    IExportPagesZipPagesInput,\n    PageExportTask\n} from \"~/export/pages/types\";\nimport { 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;AACA,IAAAC,MAAA,GAAAD,OAAA;AAOA,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,EAAG,4CAA2CtB,YAAa,EAAC;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"}

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

@@ -0,0 +1,6 @@
+import { ITaskResponseResult } from "@webiny/tasks";
+import { 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,62 @@
+"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 = 5;
+exports.ZIP_PAGES_WAIT_TIME = ZIP_PAGES_WAIT_TIME;
+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 { ITaskResponseResult, TaskDataStatus } from \"@webiny/tasks\";\nimport { IExportPagesControllerTaskParams, 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":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AACA,IAAAE,mBAAA,GAAAF,OAAA;AAEO,MAAMG,mBAAmB,GAAG,CAAC;AAACC,OAAA,CAAAD,mBAAA,GAAAA,mBAAA;AAE9B,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"}

package/export/pages/types.d.ts

@@ -0,0 +1,53 @@
+import { ITaskResponseDoneResultOutput, ITaskRunParams } from "@webiny/tasks";
+import { 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 declare 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 declare type IExportPagesZipPagesTaskParams = ITaskRunParams<PbImportExportContext, IExportPagesZipPagesInput, IExportPagesZipPagesOutput>;
+/**
+ * Combine Zipped Pages
+ */
+export interface IExportPagesCombineZippedPagesOutput extends ITaskResponseDoneResultOutput {
+    key: string;
+    url: string;
+}
+export declare type IExportPagesCombineZippedPagesParams = Pick<ITaskRunParams<PbImportExportContext, IExportPagesControllerInput, IExportPagesCombineZippedPagesOutput>, "store" | "response">;
+/**
+ * Cleanup Zip files
+ */
+export declare type IExportPagesCleanupInput = Record<string, boolean>;
+export declare type IExportPagesCleanupTaskParams = ITaskRunParams<PbImportExportContext, IExportPagesCleanupInput>;

package/export/pages/types.js

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

package/export/pages/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["PageExportTask","exports"],"sources":["types.ts"],"sourcesContent":["import { ITaskResponseDoneResultOutput, ITaskRunParams } from \"@webiny/tasks\";\nimport { 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,0BAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAA,OAAdA,cAAc;AAAA;AAM1B;AACA;AACA;AAqBA;AACA;AACA;AAsBA;AACA;AACA;AAgBA;AACA;AACA;AAFAC,OAAA,CAAAD,cAAA,GAAAA,cAAA"}

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,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createExportPagesDataKey = exports.EXPORT_PAGES_FOLDER_KEY = void 0;
+const EXPORT_PAGES_FOLDER_KEY = "WEBINY_PB_EXPORT_PAGES";
+exports.EXPORT_PAGES_FOLDER_KEY = EXPORT_PAGES_FOLDER_KEY;
+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,GAAG,wBAAwB;AAACC,OAAA,CAAAD,uBAAA,GAAAA,uBAAA;AAEzD,MAAME,wBAAwB,GAAIC,MAAc,IAAK;EACxD,OAAQ,GAAEH,uBAAwB,IAAGG,MAAO,EAAC;AACjD,CAAC;AAACF,OAAA,CAAAC,wBAAA,GAAAA,wBAAA"}