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

package/graphql/crud/pages.crud.js

@@ -0,0 +1,162 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _handlerGraphql = require("@webiny/handler-graphql");
+
+var _ContextPlugin = require("@webiny/handler/plugins/ContextPlugin");
+
+var _checkBasePermissions = _interopRequireDefault(require("@webiny/api-page-builder/graphql/crud/utils/checkBasePermissions"));
+
+var _types = require("../../types");
+
+var _client = require("../../importPages/client");
+
+var _utils = require("../../importPages/utils");
+
+var _utils2 = require("../../exportPages/utils");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+const PERMISSION_NAME = "pb.page";
+const EXPORT_PAGES_PROCESS_HANDLER = process.env.EXPORT_PAGES_PROCESS_HANDLER;
+const IMPORT_PAGES_CREATE_HANDLER = process.env.IMPORT_PAGES_CREATE_HANDLER;
+
+var _default = new _ContextPlugin.ContextPlugin(context => {
+  const importExportCrud = {
+    async importPages({
+      category: categorySlug,
+      zipFileKey,
+      zipFileUrl
+    }) {
+      await (0, _checkBasePermissions.default)(context, PERMISSION_NAME, {
+        rwd: "w"
+      }); // Bail out early if category not found
+
+      const category = await context.pageBuilder.categories.get(categorySlug);
+
+      if (!category) {
+        throw new _handlerGraphql.NotFoundError(`Category with slug "${categorySlug}" not found.`);
+      } // Create a task for import page
+
+
+      const task = await context.pageBuilder.pageImportExportTask.createTask({
+        status: _types.PageImportExportTaskStatus.PENDING,
+        input: {
+          category: categorySlug,
+          zipFileKey,
+          zipFileUrl
+        }
+      });
+      await (0, _client.invokeHandlerClient)({
+        context,
+        name: IMPORT_PAGES_CREATE_HANDLER,
+        payload: {
+          category: categorySlug,
+          zipFileKey,
+          zipFileUrl,
+          task,
+          identity: context.security.getIdentity()
+        }
+      });
+      return {
+        task
+      };
+    },
+
+    async exportPages({
+      ids: initialPageIds,
+      revisionType,
+      where,
+      sort,
+      search
+    }) {
+      await (0, _checkBasePermissions.default)(context, PERMISSION_NAME, {
+        rwd: "w"
+      });
+      let pageIds = initialPageIds; // If no ids are provided then it means we want to export all pages
+
+      if (!initialPageIds || Array.isArray(initialPageIds) && initialPageIds.length === 0) {
+        pageIds = [];
+        let pages = [];
+        let meta = {
+          hasMoreItems: true,
+          cursor: null
+        }; // Paginate pages
+
+        while (meta.hasMoreItems) {
+          [pages, meta] = await context.pageBuilder.pages.listLatest({
+            after: meta.cursor,
+            where: where,
+            sort: sort,
+            search: search
+          }); // Save page ids
+
+          pages.forEach(page => pageIds.push(page.id));
+        }
+      }
+
+      if (pageIds.length === 0) {
+        throw new _error.default("Cannot export pages - no pages found for provided inputs.", "EMPTY_EXPORT_NO_PAGES_FOUND");
+      } // Create the main task for page export.
+
+
+      const task = await context.pageBuilder.pageImportExportTask.createTask({
+        status: _types.PageImportExportTaskStatus.PENDING
+      });
+      const exportPagesDataKey = `${_utils2.EXPORT_PAGES_FOLDER_KEY}/${task.id}`; // For each page create a sub task and invoke the process handler.
+
+      for (let i = 0; i < pageIds.length; i++) {
+        const pageId = pageIds[i]; // Create sub task.
+
+        await context.pageBuilder.pageImportExportTask.createSubTask(task.id, (0, _utils.zeroPad)(i + 1), {
+          status: _types.PageImportExportTaskStatus.PENDING,
+          input: {
+            pageId,
+            exportPagesDataKey,
+            revisionType
+          }
+        });
+      } // Update main task status.
+
+
+      await context.pageBuilder.pageImportExportTask.updateTask(task.id, {
+        status: _types.PageImportExportTaskStatus.PROCESSING,
+        stats: (0, _utils.initialStats)(pageIds.length),
+        input: {
+          exportPagesDataKey,
+          revisionType
+        }
+      }); // Invoke handler.
+
+      await (0, _client.invokeHandlerClient)({
+        context,
+        name: EXPORT_PAGES_PROCESS_HANDLER,
+        payload: {
+          taskId: task.id,
+          subTaskIndex: 1,
+          identity: context.security.getIdentity()
+        }
+      });
+      return {
+        task
+      };
+    }
+
+  }; // Modify context
+
+  context.pageBuilder.pages = _objectSpread(_objectSpread({}, context.pageBuilder.pages), importExportCrud);
+});
+
+exports.default = _default;

package/graphql/crud.d.ts

@@ -0,0 +1,3 @@
+import { PageImportExportPluginsParams } from "./types";
+declare const _default: (params: PageImportExportPluginsParams) => import("@webiny/handler/plugins/ContextPlugin").ContextPlugin<import("./types").PbPageImportExportContext>[];
+export default _default;

package/graphql/crud.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _pages = _interopRequireDefault(require("./crud/pages.crud"));
+
+var _pageImportExportTasks = _interopRequireDefault(require("./crud/pageImportExportTasks.crud"));
+
+var _default = params => [_pages.default, (0, _pageImportExportTasks.default)(params)];
+
+exports.default = _default;

package/graphql/graphql/pageImportExportTasks.gql.d.ts

@@ -0,0 +1,4 @@
+import { GraphQLSchemaPlugin } from "@webiny/handler-graphql/types";
+import { PbPageImportExportContext } from "../types";
+declare const plugin: GraphQLSchemaPlugin<PbPageImportExportContext>;
+export default plugin;

package/graphql/graphql/pageImportExportTasks.gql.js

@@ -0,0 +1,80 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _resolve = _interopRequireDefault(require("./utils/resolve"));
+
+const plugin = {
+  type: "graphql-schema",
+  schema: {
+    typeDefs:
+    /* GraphQL */
+    `
+            enum PbPageImportExportTaskStatus {
+                pending
+                processing
+                completed
+                failed
+            }
+
+            type PbPageImportExportTaskStats {
+                pending: Int
+                processing: Int
+                completed: Int
+                failed: Int
+                total: Int
+            }
+
+            type PbPageImportExportTask {
+                id: ID
+                createdOn: DateTime
+                createdBy: PbCreatedBy
+                status: PbPageImportExportTaskStatus
+                data: JSON
+                stats: PbPageImportExportTaskStats
+                error: JSON
+            }
+
+            # Response types
+            type PbPageImportExportTaskResponse {
+                data: PbPageImportExportTask
+                error: PbError
+            }
+
+            type PbPageImportExportTaskListResponse {
+                data: [PbPageImportExportTask]
+                error: PbError
+            }
+
+            extend type PbQuery {
+                getPageImportExportTask(id: ID!): PbPageImportExportTaskResponse
+                listPageImportExportSubTask(
+                    id: ID!
+                    status: PbPageImportExportTaskStatus
+                    limit: Int
+                ): PbPageImportExportTaskListResponse
+            }
+        `,
+    resolvers: {
+      PbQuery: {
+        getPageImportExportTask: async (_, args, context) => {
+          return (0, _resolve.default)(() => {
+            return context.pageBuilder.pageImportExportTask.getTask(args.id);
+          });
+        },
+        listPageImportExportSubTask: async (_, args, context) => {
+          return (0, _resolve.default)(() => {
+            return context.pageBuilder.pageImportExportTask.listSubTasks(args.id, args.status, args.limit);
+          });
+        }
+      }
+    }
+  }
+};
+var _default = plugin;
+exports.default = _default;

package/graphql/graphql/pages.gql.d.ts

@@ -0,0 +1,4 @@
+import { GraphQLSchemaPlugin } from "@webiny/handler-graphql/types";
+import { PbPageImportExportContext } from "../types";
+declare const plugin: GraphQLSchemaPlugin<PbPageImportExportContext>;
+export default plugin;

package/graphql/graphql/pages.gql.js

@@ -0,0 +1,72 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _resolve = _interopRequireDefault(require("./utils/resolve"));
+
+const plugin = {
+  type: "graphql-schema",
+  schema: {
+    typeDefs:
+    /* GraphQL */
+    `
+            type PbExportPageData {
+                task: PbPageImportExportTask
+            }
+
+            type PbExportPageResponse {
+                data: PbExportPageData
+                error: PbError
+            }
+
+            type PbImportPageData {
+                task: PbPageImportExportTask
+            }
+
+            type PbImportPageResponse {
+                data: PbImportPageData
+                error: PbError
+            }
+
+            enum PbExportPageRevisionType {
+                published
+                latest
+            }
+
+            extend type PbMutation {
+                # Export pages
+                exportPages(
+                    ids: [ID!]
+                    revisionType: PbExportPageRevisionType!
+                    where: PbListPagesWhereInput
+                    sort: [PbListPagesSort!]
+                    search: PbListPagesSearchInput
+                ): PbExportPageResponse
+
+                # Import pages
+                importPages(
+                    category: String!
+                    zipFileKey: String
+                    zipFileUrl: String
+                ): PbImportPageResponse
+            }
+        `,
+    resolvers: {
+      PbMutation: {
+        exportPages: async (_, args, context) => {
+          return (0, _resolve.default)(() => context.pageBuilder.pages.exportPages(args));
+        },
+        importPages: async (_, args, context) => {
+          return (0, _resolve.default)(() => context.pageBuilder.pages.importPages(args));
+        }
+      }
+    }
+  }
+};
+var _default = plugin;
+exports.default = _default;

package/graphql/graphql/utils/resolve.d.ts

@@ -0,0 +1,3 @@
+import { Response, ErrorResponse } from "@webiny/handler-graphql";
+declare const _default: (fn: any) => Promise<ErrorResponse | Response<any>>;
+export default _default;

package/graphql/graphql/utils/resolve.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _handlerGraphql = require("@webiny/handler-graphql");
+
+var _default = async fn => {
+  try {
+    return new _handlerGraphql.Response(await fn());
+  } catch (e) {
+    return new _handlerGraphql.ErrorResponse(e);
+  }
+};
+
+exports.default = _default;

package/graphql/graphql.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLSchemaPlugin } from "@webiny/handler-graphql/types";
+declare const _default: GraphQLSchemaPlugin<import("@webiny/handler/types").ContextInterface>[];
+export default _default;

package/graphql/graphql.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _pages = _interopRequireDefault(require("./graphql/pages.gql"));
+
+var _pageImportExportTasks = _interopRequireDefault(require("./graphql/pageImportExportTasks.gql"));
+
+var _default = [_pages.default, _pageImportExportTasks.default];
+exports.default = _default;

package/graphql/index.d.ts

@@ -0,0 +1,3 @@
+import { PageImportExportPluginsParams } from "./types";
+declare const _default: (params: PageImportExportPluginsParams) => (import("@webiny/handler/plugins/ContextPlugin").ContextPlugin<import("./types").PbPageImportExportContext>[] | import("@webiny/handler-graphql/types").GraphQLSchemaPlugin<import("@webiny/handler/types").ContextInterface>[])[];
+export default _default;

package/graphql/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _crud = _interopRequireDefault(require("./crud"));
+
+var _graphql = _interopRequireDefault(require("./graphql"));
+
+var _default = params => [(0, _crud.default)(params), _graphql.default];
+
+exports.default = _default;

package/graphql/types.d.ts

@@ -0,0 +1,63 @@
+import { PagesCrud, PbContext } from "@webiny/api-page-builder/types";
+import { PageExportRevisionType, PageImportExportTask, PageImportExportTaskStatus, PageImportExportTaskStorageOperations, PageImportExportTaskStorageOperationsListParams } from "../types";
+export interface ExportPagesParams {
+    ids?: string[];
+    revisionType: PageExportRevisionType;
+    where?: {
+        category?: string;
+        status?: string;
+        tags?: {
+            query: string[];
+            rule?: "any" | "all";
+        };
+        [key: string]: any;
+    };
+    search?: {
+        query?: string;
+    };
+    sort?: string[];
+}
+export interface ImportPagesParams {
+    category: string;
+    zipFileKey?: string;
+    zipFileUrl?: string;
+}
+export declare type PagesImportExportCrud = {
+    exportPages(params: ExportPagesParams): Promise<{
+        task: PageImportExportTask;
+    }>;
+    importPages(params: ImportPagesParams): Promise<{
+        task: PageImportExportTask;
+    }>;
+};
+declare type PageImportExportTaskCreateData = Omit<PageImportExportTask, "id" | "createdOn" | "createdBy">;
+export declare type PageImportExportTaskCrud = {
+    /**
+     * To be used internally in our code.
+     * @internal
+     */
+    storageOperations: PageImportExportTaskStorageOperations;
+    getTask(id: string): Promise<PageImportExportTask>;
+    listTasks(params?: PageImportExportTaskStorageOperationsListParams): Promise<PageImportExportTask[]>;
+    createTask(data: Partial<PageImportExportTaskCreateData>): Promise<PageImportExportTask>;
+    updateTask(id: string, data: Partial<PageImportExportTaskCreateData>): Promise<PageImportExportTask>;
+    updateStats(id: string, data: {
+        prevStatus: PageImportExportTaskStatus;
+        nextStatus: PageImportExportTaskStatus;
+    }): Promise<PageImportExportTask>;
+    deleteTask(id: string): Promise<PageImportExportTask>;
+    getSubTask(id: string, subtaskId: string): Promise<PageImportExportTask>;
+    listSubTasks(id: string, status: PageImportExportTaskStatus, limit: number): Promise<PageImportExportTask[]>;
+    createSubTask(id: string, subTaskId: string, data: Partial<PageImportExportTaskCreateData>): Promise<PageImportExportTask>;
+    updateSubTask(id: string, subTaskId: string, data: Partial<PageImportExportTaskCreateData>): Promise<PageImportExportTask>;
+};
+export interface PbPageImportExportContext extends PbContext {
+    pageBuilder: PbContext["pageBuilder"] & {
+        pages: PagesCrud & PagesImportExportCrud;
+        pageImportExportTask: PageImportExportTaskCrud;
+    };
+}
+export interface PageImportExportPluginsParams {
+    storageOperations: PageImportExportTaskStorageOperations;
+}
+export {};

package/graphql/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/importPages/client.d.ts

@@ -0,0 +1,7 @@
+import { PbPageImportExportContext } from "../graphql/types";
+export interface InvokeHandlerClientParams<TParams> {
+    context: PbPageImportExportContext;
+    name: string;
+    payload: TParams;
+}
+export declare function invokeHandlerClient<TParams>({ context, name, payload }: InvokeHandlerClientParams<TParams>): Promise<void>;

package/importPages/client.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.invokeHandlerClient = invokeHandlerClient;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+async function invokeHandlerClient({
+  context,
+  name,
+  payload
+}) {
+  /*
+   * Prepare "invocationArgs", we're hacking our wat here.
+   * They are necessary to setup the "context.pageBuilder" object among other things in IMPORT_PAGE_FUNCTION
+   */
+  const {
+    request
+  } = context.http;
+  const invocationArgs = {
+    httpMethod: request.method,
+    body: request.body,
+    headers: request.headers,
+    cookies: request.cookies
+  }; // Invoke handler
+
+  await context.handlerClient.invoke({
+    name: name,
+    payload: _objectSpread(_objectSpread({}, payload), invocationArgs),
+    await: false
+  });
+}

package/importPages/create/index.d.ts

@@ -0,0 +1,27 @@
+import { HandlerPlugin } from "@webiny/handler/types";
+import { ArgsContext } from "@webiny/handler-args/types";
+import { PageImportExportTask, PbPageImportExportContext } from "../../types";
+import { SecurityIdentity } from "@webiny/api-security/types";
+export declare type HandlerArgs = {
+    category: string;
+    zipFileKey?: string;
+    zipFileUrl?: string;
+    task: PageImportExportTask;
+    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/create/index.js

@@ -0,0 +1,109 @@
+"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;
+
+    try {
+      log("RUNNING Import Pages Create");
+      const {
+        invocationArgs: args,
+        pageBuilder
+      } = context;
+      const {
+        task,
+        category,
+        zipFileKey,
+        zipFileUrl,
+        identity
+      } = args;
+      (0, _mockSecurity.mockSecurity)(identity, context); // Step 1: Read the zip file
+
+      const pageImportDataList = await (0, _utils.readExtractAndUploadZipFileContents)(zipFileKey || zipFileUrl); // Once we have map we can start processing each page
+      // For each page create a sub task and invoke the process handler
+
+      for (let i = 0; i < pageImportDataList.length; i++) {
+        const pagesDirMap = pageImportDataList[i]; // Create sub task
+
+        const subtask = await pageBuilder.pageImportExportTask.createSubTask(task.id, (0, _utils.zeroPad)(i + 1), {
+          status: _types.PageImportExportTaskStatus.PENDING,
+          data: {
+            pageKey: pagesDirMap.key,
+            category,
+            zipFileKey,
+            zipFileUrl,
+            input: {
+              fileUploadsData: pagesDirMap
+            }
+          }
+        });
+        log(`Added SUB_TASK "${subtask.id}" to queue.`);
+      } // Update main task status
+
+
+      await pageBuilder.pageImportExportTask.updateTask(task.id, {
+        status: _types.PageImportExportTaskStatus.PROCESSING,
+        stats: (0, _utils.initialStats)(pageImportDataList.length)
+      });
+      await (0, _client.invokeHandlerClient)({
+        context,
+        name: configuration.handlers.process,
+        payload: {
+          taskId: task.id,
+          // Execute "Process" for the first sub task.
+          subTaskIndex: 1,
+          identity: context.security.getIdentity()
+        }
+      });
+    } catch (e) {
+      log("[IMPORT_PAGES_CREATE] Error => ", e);
+      /**
+       * 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 {
+        task
+      } = args;
+      await pageBuilder.pageImportExportTask.updateTask(task.id, {
+        status: _types.PageImportExportTaskStatus.FAILED,
+        error: {
+          name: e.name,
+          message: e.message,
+          code: e.code || "EXPORT_FAILED"
+        }
+      });
+      return {
+        data: null,
+        error: {
+          message: e.message
+        }
+      };
+    }
+  }
+
+});
+
+exports.default = _default;