@webiny/api-page-builder-import-export 0.0.0-mt-1

package/importPages/process/index.d.ts

@@ -0,0 +1,25 @@
+import { HandlerPlugin } from "@webiny/handler/types";
+import { ArgsContext } from "@webiny/handler-args/types";
+import { PbPageImportExportContext } from "../../types";
+import { SecurityIdentity } from "@webiny/api-security/types";
+export declare type HandlerArgs = {
+    taskId: string;
+    subTaskIndex: number;
+    identity: SecurityIdentity;
+};
+export declare type HandlerResponse = {
+    data: string;
+    error: {
+        message: string;
+    };
+};
+interface Configuration {
+    handlers: {
+        process: string;
+    };
+}
+declare const _default: (configuration: Configuration) => HandlerPlugin<PbPageImportExportContext, ArgsContext<HandlerArgs>>;
+/**
+ * Handles the import page workflow.
+ */
+export default _default;

package/importPages/process/index.js

@@ -0,0 +1,183 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _types = require("../../types");
+
+var _utils = require("../utils");
+
+var _client = require("../client");
+
+var _mockSecurity = require("../../mockSecurity");
+
+/**
+ * Handles the import page workflow.
+ */
+var _default = configuration => ({
+  type: "handler",
+
+  async handle(context) {
+    const log = console.log;
+    let subTask;
+    let noPendingTask = true;
+    let prevStatusOfSubTask = _types.PageImportExportTaskStatus.PENDING;
+    log("RUNNING Import Page Queue Process");
+    const {
+      invocationArgs: args,
+      pageBuilder
+    } = context;
+    const {
+      taskId,
+      subTaskIndex,
+      identity
+    } = args; // Disable authorization; this is necessary because we call Page Builder CRUD methods which include authorization checks
+    // and this Lambda is invoked internally, without credentials.
+
+    (0, _mockSecurity.mockSecurity)(identity, context);
+
+    try {
+      /*
+       * Note: We're not going to DB for getting next sub-task to process,
+       * because the data might be out of sync due to GSI eventual consistency.
+       */
+      subTask = await pageBuilder.pageImportExportTask.getSubTask(taskId, (0, _utils.zeroPad)(subTaskIndex));
+      /**
+       * Base condition!!
+       * Bail out early, if task not found or task's status is not "pending".
+       */
+
+      if (!subTask || subTask.status !== _types.PageImportExportTaskStatus.PENDING) {
+        noPendingTask = true;
+        return;
+      } else {
+        noPendingTask = false;
+      }
+
+      prevStatusOfSubTask = subTask.status;
+      log(`Fetched sub task => ${subTask.id}`);
+      const {
+        pageKey,
+        category,
+        zipFileKey,
+        input
+      } = subTask.data;
+      const {
+        fileUploadsData
+      } = input;
+      log(`Processing page key "${pageKey}"`); // Mark task status as PROCESSING
+
+      subTask = await pageBuilder.pageImportExportTask.updateSubTask(taskId, subTask.id, {
+        status: _types.PageImportExportTaskStatus.PROCESSING
+      }); // Update stats in main task
+
+      await pageBuilder.pageImportExportTask.updateStats(taskId, {
+        prevStatus: prevStatusOfSubTask,
+        nextStatus: _types.PageImportExportTaskStatus.PROCESSING
+      });
+      prevStatusOfSubTask = subTask.status; // Real job
+
+      const page = await (0, _utils.importPage)({
+        context,
+        pageKey,
+        key: zipFileKey,
+        fileUploadsData
+      }); // Create a page
+
+      let pbPage = await context.pageBuilder.pages.create(category); // Update page with data
+
+      pbPage = await context.pageBuilder.pages.update(pbPage.id, {
+        content: page.content,
+        title: page.title,
+        path: page.path,
+        settings: page.settings
+      }); // TODO: Publish page
+      // Update task record in DB
+
+      subTask = await pageBuilder.pageImportExportTask.updateSubTask(taskId, subTask.id, {
+        status: _types.PageImportExportTaskStatus.COMPLETED,
+        data: {
+          message: "Done",
+          page: {
+            id: pbPage.id,
+            title: pbPage.title,
+            version: pbPage.version,
+            status: pbPage.status
+          }
+        }
+      }); // Update stats in main task
+
+      await pageBuilder.pageImportExportTask.updateStats(taskId, {
+        prevStatus: prevStatusOfSubTask,
+        nextStatus: _types.PageImportExportTaskStatus.COMPLETED
+      });
+      prevStatusOfSubTask = subTask.status;
+    } catch (e) {
+      log("[IMPORT_PAGES_PROCESS] Error => ", e);
+
+      if (subTask && subTask.id) {
+        /**
+         * In case of error, we'll update the task status to "failed",
+         * so that, client can show notify the user appropriately.
+         */
+        const {
+          invocationArgs: args,
+          pageBuilder
+        } = context;
+        const {
+          taskId
+        } = args;
+        subTask = await pageBuilder.pageImportExportTask.updateSubTask(taskId, subTask.id, {
+          status: _types.PageImportExportTaskStatus.FAILED,
+          error: {
+            name: e.name,
+            message: e.message,
+            stack: e.stack,
+            code: "IMPORT_FAILED"
+          }
+        }); // Update stats in main task
+
+        await pageBuilder.pageImportExportTask.updateStats(taskId, {
+          prevStatus: prevStatusOfSubTask,
+          nextStatus: _types.PageImportExportTaskStatus.FAILED
+        });
+        prevStatusOfSubTask = subTask.status;
+      }
+
+      return {
+        data: null,
+        error: {
+          message: e.message
+        }
+      };
+    } finally {
+      // Base condition!
+      if (noPendingTask) {
+        log(`No pending sub-task for task ${taskId}`);
+        await pageBuilder.pageImportExportTask.updateTask(taskId, {
+          status: _types.PageImportExportTaskStatus.COMPLETED,
+          data: {
+            message: `Finish importing pages.`
+          }
+        });
+      } else {
+        log(`Invoking PROCESS for task "${subTaskIndex + 1}"`); // We want to continue with Self invocation no matter if current page error out.
+
+        await (0, _client.invokeHandlerClient)({
+          context,
+          name: configuration.handlers.process,
+          payload: {
+            taskId,
+            subTaskIndex: subTaskIndex + 1,
+            identity: context.security.getIdentity()
+          }
+        });
+      }
+    }
+  }
+
+});
+
+exports.default = _default;

package/importPages/utils.d.ts

@@ -0,0 +1,43 @@
+import { PageImportExportTaskStatus } from "../types";
+import { PbPageImportExportContext } from "../graphql/types";
+import { ExportedPageData } from "../exportPages/utils";
+interface UploadPageAssetsParams {
+    context: PbPageImportExportContext;
+    filesData: Record<string, any>[];
+    fileUploadsData: FileUploadsData;
+}
+interface UploadPageAssetsReturnType {
+    fileIdToKeyMap?: Map<string, string>;
+}
+export declare const uploadPageAssets: ({ context, filesData, fileUploadsData }: UploadPageAssetsParams) => Promise<UploadPageAssetsReturnType>;
+interface FileUploadsData {
+    data: string;
+    assets: Record<string, string>;
+}
+interface ImportPageParams {
+    key: string;
+    pageKey: string;
+    context: PbPageImportExportContext;
+    fileUploadsData: FileUploadsData;
+}
+export declare function importPage({ pageKey, context, fileUploadsData }: ImportPageParams): Promise<ExportedPageData["page"]>;
+interface PageImportData {
+    assets: Record<string, string>;
+    data: string;
+    key: string;
+}
+/**
+ * Function will read the given zip file from S3 via stream, extract its content and upload it to S3 bucket.
+ * @param zipFileKey
+ * @return PageImportData S3 file keys for all uploaded assets group by page.
+ */
+export declare function readExtractAndUploadZipFileContents(zipFileKey: string): Promise<PageImportData[]>;
+export declare const zeroPad: (version: any) => string;
+export declare function initialStats(total: any): {
+    pending: any;
+    processing: number;
+    completed: number;
+    failed: number;
+    total: any;
+};
+export {};