@webiny/api-website-builder-workflows 0.0.0-unstable.9f53ea597d → 0.0.0-unstable.a85ef555b2

package/graphql/WebsiteBuilderWorkflowsSchemaFactory.js

@@ -0,0 +1,616 @@
+import { GraphQLSchemaFactory } from "@webiny/api-graphql/graphql/abstractions.js";
+import { staticSchemaKey } from "@webiny/api-graphql/graphql/staticSchemaKey.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { hasErrorSource } from "@webiny/api-workflows/domain/hasErrorSource.js";
+import { ErrorResponse, ListErrorResponse, ListResponse, Response } from "@webiny/api-graphql";
+import { parseIdentifier } from "@webiny/utils";
+import { ReviewValidationError } from "@webiny/api-workflows/domain/review/errors.js";
+import { isValidRevisionId } from "./isValidRevisionId.js";
+import { ListWebsiteBuilderPageWorkflowsUseCase } from "../features/wrappers/ListWebsiteBuilderPageWorkflows/index.js";
+import { GetWebsiteBuilderPageWorkflowUseCase } from "../features/wrappers/GetWebsiteBuilderPageWorkflow/index.js";
+import { StoreWebsiteBuilderPageWorkflowUseCase } from "../features/wrappers/StoreWebsiteBuilderPageWorkflow/index.js";
+import { DeleteWebsiteBuilderPageWorkflowUseCase } from "../features/wrappers/DeleteWebsiteBuilderPageWorkflow/index.js";
+import { GetWebsiteBuilderPageReviewUseCase } from "../features/wrappers/GetWebsiteBuilderPageReview/index.js";
+import { GetWebsiteBuilderPageTargetReviewUseCase } from "../features/wrappers/GetWebsiteBuilderPageTargetReview/index.js";
+import { GetWebsiteBuilderPageReviewStepRunUseCase } from "../features/wrappers/GetWebsiteBuilderPageReviewStepRun/index.js";
+import { ListWebsiteBuilderPageReviewsUseCase } from "../features/wrappers/ListWebsiteBuilderPageReviews/index.js";
+import { RequestWebsiteBuilderPageReviewUseCase } from "../features/wrappers/RequestWebsiteBuilderPageReview/index.js";
+import { StartWebsiteBuilderPageReviewStepUseCase } from "../features/wrappers/StartWebsiteBuilderPageReviewStep/index.js";
+import { TakeOverWebsiteBuilderPageReviewStepUseCase } from "../features/wrappers/TakeOverWebsiteBuilderPageReviewStep/index.js";
+import { ApproveWebsiteBuilderPageReviewStepUseCase } from "../features/wrappers/ApproveWebsiteBuilderPageReviewStep/index.js";
+import { RejectWebsiteBuilderPageReviewStepUseCase } from "../features/wrappers/RejectWebsiteBuilderPageReviewStep/index.js";
+import { CancelWebsiteBuilderPageReviewUseCase } from "../features/wrappers/CancelWebsiteBuilderPageReview/index.js";
+import { CancelWebsiteBuilderPageReviewsForDeleteUseCase } from "../features/wrappers/CancelWebsiteBuilderPageReviewsForDelete/index.js";
+import { ReassignWebsiteBuilderPageReviewStepUseCase } from "../features/wrappers/ReassignWebsiteBuilderPageReviewStep/index.js";
+import { RestartWebsiteBuilderPageReviewStepUseCase } from "../features/wrappers/RestartWebsiteBuilderPageReviewStep/index.js";
+import { ListWebsiteBuilderPageStepCandidatesUseCase } from "../features/wrappers/ListWebsiteBuilderPageStepCandidates/index.js";
+import { ListWebsiteBuilderPageReviewStepCandidatesUseCase } from "../features/wrappers/ListWebsiteBuilderPageReviewStepCandidates/index.js";
+import { InspectWebsiteBuilderPageRoutingUseCase } from "../features/wrappers/InspectWebsiteBuilderPageRouting/index.js";
+import { WebsiteBuilderPageFolderExistsUseCase } from "../features/wrappers/WebsiteBuilderPageFolderExists/index.js";
+const WB_WORKFLOWS_TYPE_DEFS = `
+    type WbPageWorkflowResponse {
+        data: WorkflowsWorkflow
+        error: WorkflowsError
+    }
+
+    type WbPageWorkflowListResponse {
+        data: [WorkflowsWorkflow!]
+        meta: WorkflowsListMeta
+        error: WorkflowsError
+    }
+
+    type WbPageReviewResponse {
+        data: WorkflowsReview
+        error: WorkflowsError
+    }
+
+    type WbPageReviewArrayResponse {
+        data: [WorkflowsReview!]
+        error: WorkflowsError
+    }
+
+    type WbPageReviewWithFlagsResponse {
+        data: WorkflowsReviewWithFlags
+        error: WorkflowsError
+    }
+
+    type WbPageReviewStepRunResponse {
+        data: WorkflowsStepRunInfo
+        error: WorkflowsError
+    }
+
+    type WbPageReviewListResponse {
+        data: [WorkflowsReviewWithFlags!]
+        meta: WorkflowsListMeta
+        error: WorkflowsError
+    }
+
+    type WbPageStepCandidateListResponse {
+        data: [WorkflowsStepCandidate!]
+        error: WorkflowsError
+    }
+
+    type WbPageRoutingInspectionResponse {
+        data: WorkflowsRoutingInspection
+        error: WorkflowsError
+    }
+
+    input WbPageReviewListWhere {
+        titleContains: String
+        "My requests only (R91)."
+        reviewState: WorkflowsReviewState
+        "My requests only (R91)."
+        stepState: WorkflowsStepState
+    }
+
+    extend type WbQuery {
+        listWebsiteBuilderPageWorkflows: WbPageWorkflowListResponse!
+        getWebsiteBuilderPageWorkflow(id: ID!): WbPageWorkflowResponse!
+        getWebsiteBuilderPageReview(id: ID!): WbPageReviewWithFlagsResponse!
+        "The active review of a page revision; data is null when it has none."
+        getWebsiteBuilderPageTargetReview(revisionId: ID!): WbPageReviewWithFlagsResponse!
+        "The background task of one step attempt; needs workflows editor or reassign (R258). data is null when the task is gone."
+        getWebsiteBuilderPageReviewStepRun(
+            reviewId: ID!
+            stepId: ID!
+            taskId: ID!
+        ): WbPageReviewStepRunResponse!
+        listWebsiteBuilderPageReviews(
+            list: WorkflowsReviewListKind!
+            where: WbPageReviewListWhere
+            sort: WorkflowsReviewListSort
+            limit: Int
+            after: String
+        ): WbPageReviewListResponse!
+        "Who could take a step of a review of this page revision (request dialog, R120)."
+        listWebsiteBuilderPageStepCandidates(
+            workflowId: ID!
+            stepId: ID!
+            revisionId: ID!
+        ): WbPageStepCandidateListResponse!
+        "Who a review step can be reassigned to (R120)."
+        listWebsiteBuilderPageReviewStepCandidates(
+            reviewId: ID!
+            stepId: ID!
+        ): WbPageStepCandidateListResponse!
+        "folderId: a page folder; omitted or null is the root (R121)."
+        inspectWebsiteBuilderPageRouting(
+            stepConfig: JSON!
+            requesterId: ID!
+            folderId: ID
+        ): WbPageRoutingInspectionResponse!
+        "Whether a page folder still exists; the answer only (D69)."
+        websiteBuilderPageFolderExists(id: ID!): WorkflowsBooleanResponse!
+    }
+
+    extend type WbMutation {
+        "savedOn: the value the editor loaded; omit when creating (D131, R104)."
+        storeWebsiteBuilderPageWorkflow(
+            data: WorkflowsWorkflowInput!
+            savedOn: String
+        ): WbPageWorkflowResponse!
+        deleteWebsiteBuilderPageWorkflow(id: ID!): WbPageWorkflowResponse!
+        requestWebsiteBuilderPageReview(
+            revisionId: ID!
+            title: String
+            picks: [WorkflowsReviewPickInput!]
+        ): WbPageReviewResponse!
+        startWebsiteBuilderPageReviewStep(reviewId: ID!, stepId: ID!): WbPageReviewResponse!
+        takeOverWebsiteBuilderPageReviewStep(
+            reviewId: ID!
+            stepId: ID!
+            notifyPreviousOwner: Boolean = true
+        ): WbPageReviewResponse!
+        reassignWebsiteBuilderPageReviewStep(
+            reviewId: ID!
+            stepId: ID!
+            userId: ID!
+        ): WbPageReviewResponse!
+        restartWebsiteBuilderPageReviewStep(reviewId: ID!, stepId: ID!): WbPageReviewResponse!
+        approveWebsiteBuilderPageReviewStep(
+            reviewId: ID!
+            stepId: ID!
+            comment: String
+        ): WbPageReviewResponse!
+        rejectWebsiteBuilderPageReviewStep(
+            reviewId: ID!
+            stepId: ID!
+            comment: String
+        ): WbPageReviewResponse!
+        cancelWebsiteBuilderPageReview(reviewId: ID!): WbPageReviewResponse!
+        "Cancels every in-progress review of the page, or of one revision when \`revisionId\` is given, before a trash or delete (D134)."
+        cancelWebsiteBuilderPageReviewsForDelete(
+            pageId: ID!
+            revisionId: ID
+            action: WorkflowsReviewsForDeleteAction!
+        ): WbPageReviewArrayResponse!
+    }
+`;
+class WebsiteBuilderWorkflowsSchemaFactoryImpl {
+    async execute(builder) {
+        builder.addTypeDefs(WB_WORKFLOWS_TYPE_DEFS);
+        builder.addResolver({
+            path: "WbQuery.listWebsiteBuilderPageWorkflows",
+            dependencies: [
+                ListWebsiteBuilderPageWorkflowsUseCase,
+                Logger
+            ],
+            resolver: (listWorkflows, logger)=>async ()=>{
+                    const result = await listWorkflows.execute();
+                    if (result.isFail()) {
+                        if (hasErrorSource(result.error)) logger.error({
+                            err: result.error.source
+                        }, result.error.message);
+                        return new ListErrorResponse(result.error);
+                    }
+                    return new ListResponse(result.value, {
+                        cursor: null,
+                        hasMoreItems: false
+                    });
+                }
+        });
+        builder.addResolver({
+            path: "WbQuery.getWebsiteBuilderPageWorkflow",
+            dependencies: [
+                GetWebsiteBuilderPageWorkflowUseCase,
+                Logger
+            ],
+            resolver: (getWorkflow, logger)=>async ({ args })=>{
+                    const result = await getWorkflow.execute({
+                        id: args.id
+                    });
+                    if (result.isFail()) {
+                        if (hasErrorSource(result.error)) logger.error({
+                            err: result.error.source
+                        }, result.error.message);
+                        return new ErrorResponse(result.error);
+                    }
+                    return new Response(result.value);
+                }
+        });
+        builder.addResolver({
+            path: "WbMutation.storeWebsiteBuilderPageWorkflow",
+            dependencies: [
+                StoreWebsiteBuilderPageWorkflowUseCase,
+                Logger
+            ],
+            resolver: (storeWorkflow, logger)=>async ({ args })=>{
+                    const result = await storeWorkflow.execute({
+                        workflow: args.data,
+                        savedOn: args.savedOn
+                    });
+                    if (result.isFail()) {
+                        if (hasErrorSource(result.error)) logger.error({
+                            err: result.error.source
+                        }, result.error.message);
+                        return new ErrorResponse(result.error);
+                    }
+                    return new Response(result.value);
+                }
+        });
+        builder.addResolver({
+            path: "WbMutation.deleteWebsiteBuilderPageWorkflow",
+            dependencies: [
+                DeleteWebsiteBuilderPageWorkflowUseCase,
+                Logger
+            ],
+            resolver: (deleteWorkflow, logger)=>async ({ args })=>{
+                    const result = await deleteWorkflow.execute({
+                        id: args.id
+                    });
+                    if (result.isFail()) {
+                        if (hasErrorSource(result.error)) logger.error({
+                            err: result.error.source
+                        }, result.error.message);
+                        return new ErrorResponse(result.error);
+                    }
+                    return new Response(result.value);
+                }
+        });
+        builder.addResolver({
+            path: "WbQuery.getWebsiteBuilderPageReview",
+            dependencies: [
+                GetWebsiteBuilderPageReviewUseCase,
+                Logger
+            ],
+            resolver: (getReview, logger)=>async ({ args })=>{
+                    const result = await getReview.execute({
+                        id: args.id
+                    });
+                    if (result.isFail()) {
+                        if (hasErrorSource(result.error)) logger.error({
+                            err: result.error.source
+                        }, result.error.message);
+                        return new ErrorResponse(result.error);
+                    }
+                    return new Response(result.value);
+                }
+        });
+        builder.addResolver({
+            path: "WbQuery.getWebsiteBuilderPageReviewStepRun",
+            dependencies: [
+                GetWebsiteBuilderPageReviewStepRunUseCase,
+                Logger
+            ],
+            resolver: (getStepRun, logger)=>async ({ args })=>{
+                    const result = await getStepRun.execute({
+                        reviewId: args.reviewId,
+                        stepId: args.stepId,
+                        taskId: args.taskId
+                    });
+                    if (result.isFail()) {
+                        if (hasErrorSource(result.error)) logger.error({
+                            err: result.error.source
+                        }, result.error.message);
+                        return new ErrorResponse(result.error);
+                    }
+                    return new Response(result.value);
+                }
+        });
+        builder.addResolver({
+            path: "WbQuery.getWebsiteBuilderPageTargetReview",
+            dependencies: [
+                GetWebsiteBuilderPageTargetReviewUseCase,
+                Logger
+            ],
+            resolver: (getTargetReview, logger)=>async ({ args })=>{
+                    if (!isValidRevisionId(args.revisionId)) return new ErrorResponse(new ReviewValidationError("The revision id is not valid."));
+                    const result = await getTargetReview.execute({
+                        targetRevisionId: args.revisionId
+                    });
+                    if (result.isFail()) {
+                        if (hasErrorSource(result.error)) logger.error({
+                            err: result.error.source
+                        }, result.error.message);
+                        return new ErrorResponse(result.error);
+                    }
+                    return new Response(result.value);
+                }
+        });
+        builder.addResolver({
+            path: "WbQuery.listWebsiteBuilderPageReviews",
+            dependencies: [
+                ListWebsiteBuilderPageReviewsUseCase,
+                Logger
+            ],
+            resolver: (listReviews, logger)=>async ({ args })=>{
+                    const result = await listReviews.execute({
+                        list: args.list,
+                        where: args.where,
+                        sort: args.sort,
+                        limit: args.limit,
+                        after: args.after
+                    });
+                    if (result.isFail()) {
+                        if (hasErrorSource(result.error)) logger.error({
+                            err: result.error.source
+                        }, result.error.message);
+                        return new ListErrorResponse(result.error);
+                    }
+                    return new ListResponse(result.value.items, result.value.meta);
+                }
+        });
+        builder.addResolver({
+            path: "WbMutation.requestWebsiteBuilderPageReview",
+            dependencies: [
+                RequestWebsiteBuilderPageReviewUseCase,
+                Logger
+            ],
+            resolver: (requestReview, logger)=>async ({ args })=>{
+                    if (!isValidRevisionId(args.revisionId)) return new ErrorResponse(new ReviewValidationError("The revision id is not valid."));
+                    const result = await requestReview.execute({
+                        targetId: parseIdentifier(args.revisionId).id,
+                        targetRevisionId: args.revisionId,
+                        title: args.title,
+                        picks: args.picks ?? void 0
+                    });
+                    if (result.isFail()) {
+                        if (hasErrorSource(result.error)) logger.error({
+                            err: result.error.source
+                        }, result.error.message);
+                        return new ErrorResponse(result.error);
+                    }
+                    return new Response(result.value);
+                }
+        });
+        builder.addResolver({
+            path: "WbMutation.startWebsiteBuilderPageReviewStep",
+            dependencies: [
+                StartWebsiteBuilderPageReviewStepUseCase,
+                Logger
+            ],
+            resolver: (startStep, logger)=>async ({ args })=>{
+                    const result = await startStep.execute({
+                        reviewId: args.reviewId,
+                        stepId: args.stepId
+                    });
+                    if (result.isFail()) {
+                        if (hasErrorSource(result.error)) logger.error({
+                            err: result.error.source
+                        }, result.error.message);
+                        return new ErrorResponse(result.error);
+                    }
+                    return new Response(result.value);
+                }
+        });
+        builder.addResolver({
+            path: "WbMutation.takeOverWebsiteBuilderPageReviewStep",
+            dependencies: [
+                TakeOverWebsiteBuilderPageReviewStepUseCase,
+                Logger
+            ],
+            resolver: (takeOverStep, logger)=>async ({ args })=>{
+                    const result = await takeOverStep.execute({
+                        reviewId: args.reviewId,
+                        stepId: args.stepId,
+                        notifyPreviousOwner: args.notifyPreviousOwner
+                    });
+                    if (result.isFail()) {
+                        if (hasErrorSource(result.error)) logger.error({
+                            err: result.error.source
+                        }, result.error.message);
+                        return new ErrorResponse(result.error);
+                    }
+                    return new Response(result.value);
+                }
+        });
+        builder.addResolver({
+            path: "WbMutation.reassignWebsiteBuilderPageReviewStep",
+            dependencies: [
+                ReassignWebsiteBuilderPageReviewStepUseCase,
+                Logger
+            ],
+            resolver: (reassignStep, logger)=>async ({ args })=>{
+                    const result = await reassignStep.execute({
+                        reviewId: args.reviewId,
+                        stepId: args.stepId,
+                        userId: args.userId
+                    });
+                    if (result.isFail()) {
+                        if (hasErrorSource(result.error)) logger.error({
+                            err: result.error.source
+                        }, result.error.message);
+                        return new ErrorResponse(result.error);
+                    }
+                    return new Response(result.value);
+                }
+        });
+        builder.addResolver({
+            path: "WbMutation.restartWebsiteBuilderPageReviewStep",
+            dependencies: [
+                RestartWebsiteBuilderPageReviewStepUseCase,
+                Logger
+            ],
+            resolver: (restartStep, logger)=>async ({ args })=>{
+                    const result = await restartStep.execute({
+                        reviewId: args.reviewId,
+                        stepId: args.stepId
+                    });
+                    if (result.isFail()) {
+                        if (hasErrorSource(result.error)) logger.error({
+                            err: result.error.source
+                        }, result.error.message);
+                        return new ErrorResponse(result.error);
+                    }
+                    return new Response(result.value);
+                }
+        });
+        builder.addResolver({
+            path: "WbMutation.approveWebsiteBuilderPageReviewStep",
+            dependencies: [
+                ApproveWebsiteBuilderPageReviewStepUseCase,
+                Logger
+            ],
+            resolver: (approveStep, logger)=>async ({ args })=>{
+                    const result = await approveStep.execute({
+                        reviewId: args.reviewId,
+                        stepId: args.stepId,
+                        comment: args.comment
+                    });
+                    if (result.isFail()) {
+                        if (hasErrorSource(result.error)) logger.error({
+                            err: result.error.source
+                        }, result.error.message);
+                        return new ErrorResponse(result.error);
+                    }
+                    return new Response(result.value);
+                }
+        });
+        builder.addResolver({
+            path: "WbMutation.rejectWebsiteBuilderPageReviewStep",
+            dependencies: [
+                RejectWebsiteBuilderPageReviewStepUseCase,
+                Logger
+            ],
+            resolver: (rejectStep, logger)=>async ({ args })=>{
+                    const result = await rejectStep.execute({
+                        reviewId: args.reviewId,
+                        stepId: args.stepId,
+                        comment: args.comment
+                    });
+                    if (result.isFail()) {
+                        if (hasErrorSource(result.error)) logger.error({
+                            err: result.error.source
+                        }, result.error.message);
+                        return new ErrorResponse(result.error);
+                    }
+                    return new Response(result.value);
+                }
+        });
+        builder.addResolver({
+            path: "WbMutation.cancelWebsiteBuilderPageReview",
+            dependencies: [
+                CancelWebsiteBuilderPageReviewUseCase,
+                Logger
+            ],
+            resolver: (cancelReview, logger)=>async ({ args })=>{
+                    const result = await cancelReview.execute({
+                        reviewId: args.reviewId
+                    });
+                    if (result.isFail()) {
+                        if (hasErrorSource(result.error)) logger.error({
+                            err: result.error.source
+                        }, result.error.message);
+                        return new ErrorResponse(result.error);
+                    }
+                    return new Response(result.value);
+                }
+        });
+        builder.addResolver({
+            path: "WbMutation.cancelWebsiteBuilderPageReviewsForDelete",
+            dependencies: [
+                CancelWebsiteBuilderPageReviewsForDeleteUseCase,
+                Logger
+            ],
+            resolver: (cancelForDelete, logger)=>async ({ args })=>{
+                    if (null !== args.revisionId && void 0 !== args.revisionId && !isValidRevisionId(args.revisionId)) return new ErrorResponse(new ReviewValidationError("The revision id is not valid."));
+                    const result = await cancelForDelete.execute({
+                        targetId: args.pageId,
+                        targetRevisionId: args.revisionId,
+                        action: args.action
+                    });
+                    if (result.isFail()) {
+                        if (hasErrorSource(result.error)) logger.error({
+                            err: result.error.source
+                        }, result.error.message);
+                        return new ErrorResponse(result.error);
+                    }
+                    return new Response(result.value);
+                }
+        });
+        builder.addResolver({
+            path: "WbQuery.listWebsiteBuilderPageStepCandidates",
+            dependencies: [
+                ListWebsiteBuilderPageStepCandidatesUseCase,
+                Logger
+            ],
+            resolver: (listCandidates, logger)=>async ({ args })=>{
+                    if (!isValidRevisionId(args.revisionId)) return new ErrorResponse(new ReviewValidationError("The revision id is not valid."));
+                    const result = await listCandidates.execute({
+                        workflowId: args.workflowId,
+                        stepId: args.stepId,
+                        targetId: parseIdentifier(args.revisionId).id,
+                        targetRevisionId: args.revisionId
+                    });
+                    if (result.isFail()) {
+                        if (hasErrorSource(result.error)) logger.error({
+                            err: result.error.source
+                        }, result.error.message);
+                        return new ErrorResponse(result.error);
+                    }
+                    return new Response(result.value);
+                }
+        });
+        builder.addResolver({
+            path: "WbQuery.listWebsiteBuilderPageReviewStepCandidates",
+            dependencies: [
+                ListWebsiteBuilderPageReviewStepCandidatesUseCase,
+                Logger
+            ],
+            resolver: (listCandidates, logger)=>async ({ args })=>{
+                    const result = await listCandidates.execute({
+                        reviewId: args.reviewId,
+                        stepId: args.stepId
+                    });
+                    if (result.isFail()) {
+                        if (hasErrorSource(result.error)) logger.error({
+                            err: result.error.source
+                        }, result.error.message);
+                        return new ErrorResponse(result.error);
+                    }
+                    return new Response(result.value);
+                }
+        });
+        builder.addResolver({
+            path: "WbQuery.inspectWebsiteBuilderPageRouting",
+            dependencies: [
+                InspectWebsiteBuilderPageRoutingUseCase,
+                Logger
+            ],
+            resolver: (inspectRouting, logger)=>async ({ args })=>{
+                    const result = await inspectRouting.execute({
+                        stepConfig: args.stepConfig,
+                        requesterId: args.requesterId,
+                        folderId: args.folderId
+                    });
+                    if (result.isFail()) {
+                        if (hasErrorSource(result.error)) logger.error({
+                            err: result.error.source
+                        }, result.error.message);
+                        return new ErrorResponse(result.error);
+                    }
+                    return new Response(result.value);
+                }
+        });
+        builder.addResolver({
+            path: "WbQuery.websiteBuilderPageFolderExists",
+            dependencies: [
+                WebsiteBuilderPageFolderExistsUseCase,
+                Logger
+            ],
+            resolver: (folderExists, logger)=>async ({ args })=>{
+                    const result = await folderExists.execute({
+                        id: args.id
+                    });
+                    if (result.isFail()) {
+                        if (hasErrorSource(result.error)) logger.error({
+                            err: result.error.source
+                        }, result.error.message);
+                        return new ErrorResponse(result.error);
+                    }
+                    return new Response(result.value);
+                }
+        });
+        return builder;
+    }
+    constructor(){
+        this.getSchemaKey = staticSchemaKey("api-website-builder-workflows/WebsiteBuilderWorkflowsSchemaFactoryImpl");
+    }
+}
+const WebsiteBuilderWorkflowsSchemaFactory = GraphQLSchemaFactory.createImplementation({
+    implementation: WebsiteBuilderWorkflowsSchemaFactoryImpl,
+    dependencies: []
+});
+export { WebsiteBuilderWorkflowsSchemaFactory };
+
+//# sourceMappingURL=WebsiteBuilderWorkflowsSchemaFactory.js.map