@webiny/api-headless-cms-scheduler 0.0.0-unstable.06b2ede40f

package/manifest.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getManifest = void 0;
+var _api = require("@webiny/api");
+var _utils = require("@webiny/utils");
+var _zod = _interopRequireDefault(require("zod"));
+const schema = _zod.default.object({
+  scheduler: _zod.default.object({
+    lambdaArn: _zod.default.string(),
+    roleArn: _zod.default.string()
+  })
+});
+const getManifest = async params => {
+  try {
+    _api.ServiceDiscovery.setDocumentClient(params.client);
+    const manifest = await _api.ServiceDiscovery.load();
+    if (!manifest) {
+      return {
+        error: new Error("Manifest could not be loaded.")
+      };
+    } else if (!manifest.scheduler) {
+      return {
+        error: new Error("Scheduler not found in the Manifest.")
+      };
+    }
+    const result = await schema.safeParseAsync(manifest);
+    if (!result.success) {
+      return {
+        error: (0, _utils.createZodError)(result.error)
+      };
+    }
+    return {
+      data: result.data.scheduler
+    };
+  } catch (ex) {
+    return {
+      error: ex
+    };
+  }
+};
+exports.getManifest = getManifest;
+
+//# sourceMappingURL=manifest.js.map

package/manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_api","require","_utils","_zod","_interopRequireDefault","schema","zod","object","scheduler","lambdaArn","string","roleArn","getManifest","params","ServiceDiscovery","setDocumentClient","client","manifest","load","error","Error","result","safeParseAsync","success","createZodError","data","ex","exports"],"sources":["manifest.ts"],"sourcesContent":["import { ServiceDiscovery } from \"@webiny/api\";\nimport type { DynamoDBDocument } from \"@webiny/aws-sdk/client-dynamodb\";\nimport { createZodError } from \"@webiny/utils\";\nimport zod from \"zod\";\n\nconst schema = zod.object({\n    scheduler: zod.object({\n        lambdaArn: zod.string(),\n        roleArn: zod.string()\n    })\n});\n\nexport interface IGetManifestErrorResult {\n    error: Error;\n    data?: never;\n}\n\nexport interface IGetManifestSuccessResult {\n    data: {\n        lambdaArn: string;\n        roleArn: string;\n    };\n    error?: never;\n}\n\nexport type IGetManifestResult = IGetManifestSuccessResult | IGetManifestErrorResult;\n\nexport interface IGetManifestParams {\n    client: DynamoDBDocument;\n}\n\nexport const getManifest = async (params: IGetManifestParams): Promise<IGetManifestResult> => {\n    try {\n        ServiceDiscovery.setDocumentClient(params.client);\n        const manifest = await ServiceDiscovery.load();\n        if (!manifest) {\n            return {\n                error: new Error(\"Manifest could not be loaded.\")\n            };\n        } else if (!manifest.scheduler) {\n            return {\n                error: new Error(\"Scheduler not found in the Manifest.\")\n            };\n        }\n\n        const result = await schema.safeParseAsync(manifest);\n        if (!result.success) {\n            return {\n                error: createZodError(result.error)\n            };\n        }\n\n        return {\n            data: result.data.scheduler\n        };\n    } catch (ex) {\n        return {\n            error: ex\n        };\n    }\n};\n"],"mappings":";;;;;;;AAAA,IAAAA,IAAA,GAAAC,OAAA;AAEA,IAAAC,MAAA,GAAAD,OAAA;AACA,IAAAE,IAAA,GAAAC,sBAAA,CAAAH,OAAA;AAEA,MAAMI,MAAM,GAAGC,YAAG,CAACC,MAAM,CAAC;EACtBC,SAAS,EAAEF,YAAG,CAACC,MAAM,CAAC;IAClBE,SAAS,EAAEH,YAAG,CAACI,MAAM,CAAC,CAAC;IACvBC,OAAO,EAAEL,YAAG,CAACI,MAAM,CAAC;EACxB,CAAC;AACL,CAAC,CAAC;AAqBK,MAAME,WAAW,GAAG,MAAOC,MAA0B,IAAkC;EAC1F,IAAI;IACAC,qBAAgB,CAACC,iBAAiB,CAACF,MAAM,CAACG,MAAM,CAAC;IACjD,MAAMC,QAAQ,GAAG,MAAMH,qBAAgB,CAACI,IAAI,CAAC,CAAC;IAC9C,IAAI,CAACD,QAAQ,EAAE;MACX,OAAO;QACHE,KAAK,EAAE,IAAIC,KAAK,CAAC,+BAA+B;MACpD,CAAC;IACL,CAAC,MAAM,IAAI,CAACH,QAAQ,CAACT,SAAS,EAAE;MAC5B,OAAO;QACHW,KAAK,EAAE,IAAIC,KAAK,CAAC,sCAAsC;MAC3D,CAAC;IACL;IAEA,MAAMC,MAAM,GAAG,MAAMhB,MAAM,CAACiB,cAAc,CAACL,QAAQ,CAAC;IACpD,IAAI,CAACI,MAAM,CAACE,OAAO,EAAE;MACjB,OAAO;QACHJ,KAAK,EAAE,IAAAK,qBAAc,EAACH,MAAM,CAACF,KAAK;MACtC,CAAC;IACL;IAEA,OAAO;MACHM,IAAI,EAAEJ,MAAM,CAACI,IAAI,CAACjB;IACtB,CAAC;EACL,CAAC,CAAC,OAAOkB,EAAE,EAAE;IACT,OAAO;MACHP,KAAK,EAAEO;IACX,CAAC;EACL;AACJ,CAAC;AAACC,OAAA,CAAAf,WAAA,GAAAA,WAAA","ignoreList":[]}

package/package.json

@@ -0,0 +1,45 @@
+{
+	"name": "@webiny/api-headless-cms-scheduler",
+	"version": "0.0.0-unstable.06b2ede40f",
+	"main": "index.js",
+	"description": "Schedule for Webiny Headless CMS",
+	"keywords": [
+		"api-headless-cms-scheduler:base"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git",
+		"directory": "packages/api-headless-cms-scheduler"
+	},
+	"license": "MIT",
+	"dependencies": {
+		"@webiny/api": "0.0.0-unstable.06b2ede40f",
+		"@webiny/api-headless-cms": "0.0.0-unstable.06b2ede40f",
+		"@webiny/aws-sdk": "0.0.0-unstable.06b2ede40f",
+		"@webiny/error": "0.0.0-unstable.06b2ede40f",
+		"@webiny/handler-graphql": "0.0.0-unstable.06b2ede40f",
+		"@webiny/utils": "0.0.0-unstable.06b2ede40f",
+		"zod": "3.23.8"
+	},
+	"devDependencies": {
+		"@webiny/api-i18n": "0.0.0-unstable.06b2ede40f",
+		"@webiny/api-security": "0.0.0-unstable.06b2ede40f",
+		"@webiny/api-tenancy": "0.0.0-unstable.06b2ede40f",
+		"@webiny/api-wcp": "0.0.0-unstable.06b2ede40f",
+		"@webiny/handler": "0.0.0-unstable.06b2ede40f",
+		"@webiny/handler-aws": "0.0.0-unstable.06b2ede40f",
+		"@webiny/plugins": "0.0.0-unstable.06b2ede40f",
+		"@webiny/project-utils": "0.0.0-unstable.06b2ede40f",
+		"aws-sdk-client-mock": "4.1.0",
+		"typescript": "5.3.3"
+	},
+	"scripts": {
+		"build": "node ../cli/bin.js run build",
+		"watch": "node ../cli/bin.js run watch"
+	},
+	"publishConfig": {
+		"access": "public",
+		"directory": "dist"
+	},
+	"gitHead": "06b2ede40fc2212a70eeafd74afd50b56fb0ce82"
+}

package/scheduler/ScheduleExecutor.d.ts

@@ -0,0 +1,16 @@
+import { type IScheduleAction, type IScheduleExecutor, type IScheduleFetcher, type IScheduleRecord, type ISchedulerInput } from "./types.js";
+import type { PublishScheduleActionCms } from "./actions/PublishScheduleAction.js";
+import type { UnpublishScheduleActionCms } from "./actions/UnpublishScheduleAction.js";
+export type ScheduleExecutorCms = UnpublishScheduleActionCms & PublishScheduleActionCms;
+export interface IScheduleExecutorParams {
+    actions: IScheduleAction[];
+    fetcher: IScheduleFetcher;
+}
+export declare class ScheduleExecutor implements IScheduleExecutor {
+    private readonly actions;
+    private readonly fetcher;
+    constructor(params: IScheduleExecutorParams);
+    schedule(targetId: string, input: ISchedulerInput): Promise<IScheduleRecord>;
+    cancel(initialId: string): Promise<IScheduleRecord>;
+    private getAction;
+}

package/scheduler/ScheduleExecutor.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ScheduleExecutor = void 0;
+var _createScheduleRecordId = require("./createScheduleRecordId.js");
+var _error = require("@webiny/error");
+class ScheduleExecutor {
+  constructor(params) {
+    this.actions = params.actions;
+    this.fetcher = params.fetcher;
+  }
+  async schedule(targetId, input) {
+    const scheduleRecordId = (0, _createScheduleRecordId.createScheduleRecordIdWithVersion)(targetId);
+    const original = await this.fetcher.getScheduled(targetId);
+    const action = this.getAction(input.type);
+    if (original) {
+      return action.reschedule(original, input);
+    }
+    return await action.schedule({
+      scheduleRecordId,
+      targetId,
+      input
+    });
+  }
+  async cancel(initialId) {
+    const id = (0, _createScheduleRecordId.createScheduleRecordIdWithVersion)(initialId);
+    const original = await this.fetcher.getScheduled(id);
+    if (!original) {
+      throw new _error.WebinyError(`No scheduled record found for ID "${id}".`, "SCHEDULED_RECORD_NOT_FOUND", {
+        id
+      });
+    }
+    const action = this.getAction(original.type);
+    await action.cancel(original.id);
+    return original;
+  }
+  getAction(type) {
+    const action = this.actions.find(action => {
+      return action.canHandle({
+        type
+      });
+    });
+    if (action) {
+      return action;
+    }
+    throw new _error.WebinyError(`No action found for input type "${type}".`, "NO_ACTION_FOUND", {
+      type
+    });
+  }
+}
+exports.ScheduleExecutor = ScheduleExecutor;
+
+//# sourceMappingURL=ScheduleExecutor.js.map

package/scheduler/ScheduleExecutor.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_createScheduleRecordId","require","_error","ScheduleExecutor","constructor","params","actions","fetcher","schedule","targetId","input","scheduleRecordId","createScheduleRecordIdWithVersion","original","getScheduled","action","getAction","type","reschedule","cancel","initialId","id","WebinyError","find","canHandle","exports"],"sources":["ScheduleExecutor.ts"],"sourcesContent":["import type { ScheduleType } from \"~/scheduler/types.js\";\nimport {\n    type IScheduleAction,\n    type IScheduleExecutor,\n    type IScheduleFetcher,\n    type IScheduleRecord,\n    type ISchedulerInput\n} from \"~/scheduler/types.js\";\nimport { createScheduleRecordIdWithVersion } from \"~/scheduler/createScheduleRecordId.js\";\nimport type { PublishScheduleActionCms } from \"~/scheduler/actions/PublishScheduleAction.js\";\nimport type { UnpublishScheduleActionCms } from \"~/scheduler/actions/UnpublishScheduleAction.js\";\nimport { WebinyError } from \"@webiny/error\";\n\nexport type ScheduleExecutorCms = UnpublishScheduleActionCms & PublishScheduleActionCms;\n\nexport interface IScheduleExecutorParams {\n    actions: IScheduleAction[];\n    fetcher: IScheduleFetcher;\n}\n\nexport class ScheduleExecutor implements IScheduleExecutor {\n    private readonly actions: IScheduleAction[];\n    private readonly fetcher: Pick<IScheduleFetcher, \"getScheduled\">;\n\n    constructor(params: IScheduleExecutorParams) {\n        this.actions = params.actions;\n        this.fetcher = params.fetcher;\n    }\n\n    public async schedule(targetId: string, input: ISchedulerInput): Promise<IScheduleRecord> {\n        const scheduleRecordId = createScheduleRecordIdWithVersion(targetId);\n        const original = await this.fetcher.getScheduled(targetId);\n\n        const action = this.getAction(input.type);\n\n        if (original) {\n            return action.reschedule(original, input);\n        }\n\n        return await action.schedule({\n            scheduleRecordId,\n            targetId,\n            input\n        });\n    }\n\n    public async cancel(initialId: string): Promise<IScheduleRecord> {\n        const id = createScheduleRecordIdWithVersion(initialId);\n        const original = await this.fetcher.getScheduled(id);\n        if (!original) {\n            throw new WebinyError(\n                `No scheduled record found for ID \"${id}\".`,\n                \"SCHEDULED_RECORD_NOT_FOUND\",\n                {\n                    id\n                }\n            );\n        }\n\n        const action = this.getAction(original.type);\n        await action.cancel(original.id);\n        return original;\n    }\n\n    private getAction(type: ScheduleType): IScheduleAction {\n        const action = this.actions.find(action => {\n            return action.canHandle({\n                type\n            });\n        });\n        if (action) {\n            return action;\n        }\n        throw new WebinyError(`No action found for input type \"${type}\".`, \"NO_ACTION_FOUND\", {\n            type\n        });\n    }\n}\n"],"mappings":";;;;;;AAQA,IAAAA,uBAAA,GAAAC,OAAA;AAGA,IAAAC,MAAA,GAAAD,OAAA;AASO,MAAME,gBAAgB,CAA8B;EAIvDC,WAAWA,CAACC,MAA+B,EAAE;IACzC,IAAI,CAACC,OAAO,GAAGD,MAAM,CAACC,OAAO;IAC7B,IAAI,CAACC,OAAO,GAAGF,MAAM,CAACE,OAAO;EACjC;EAEA,MAAaC,QAAQA,CAACC,QAAgB,EAAEC,KAAsB,EAA4B;IACtF,MAAMC,gBAAgB,GAAG,IAAAC,yDAAiC,EAACH,QAAQ,CAAC;IACpE,MAAMI,QAAQ,GAAG,MAAM,IAAI,CAACN,OAAO,CAACO,YAAY,CAACL,QAAQ,CAAC;IAE1D,MAAMM,MAAM,GAAG,IAAI,CAACC,SAAS,CAACN,KAAK,CAACO,IAAI,CAAC;IAEzC,IAAIJ,QAAQ,EAAE;MACV,OAAOE,MAAM,CAACG,UAAU,CAACL,QAAQ,EAAEH,KAAK,CAAC;IAC7C;IAEA,OAAO,MAAMK,MAAM,CAACP,QAAQ,CAAC;MACzBG,gBAAgB;MAChBF,QAAQ;MACRC;IACJ,CAAC,CAAC;EACN;EAEA,MAAaS,MAAMA,CAACC,SAAiB,EAA4B;IAC7D,MAAMC,EAAE,GAAG,IAAAT,yDAAiC,EAACQ,SAAS,CAAC;IACvD,MAAMP,QAAQ,GAAG,MAAM,IAAI,CAACN,OAAO,CAACO,YAAY,CAACO,EAAE,CAAC;IACpD,IAAI,CAACR,QAAQ,EAAE;MACX,MAAM,IAAIS,kBAAW,CACjB,qCAAqCD,EAAE,IAAI,EAC3C,4BAA4B,EAC5B;QACIA;MACJ,CACJ,CAAC;IACL;IAEA,MAAMN,MAAM,GAAG,IAAI,CAACC,SAAS,CAACH,QAAQ,CAACI,IAAI,CAAC;IAC5C,MAAMF,MAAM,CAACI,MAAM,CAACN,QAAQ,CAACQ,EAAE,CAAC;IAChC,OAAOR,QAAQ;EACnB;EAEQG,SAASA,CAACC,IAAkB,EAAmB;IACnD,MAAMF,MAAM,GAAG,IAAI,CAACT,OAAO,CAACiB,IAAI,CAACR,MAAM,IAAI;MACvC,OAAOA,MAAM,CAACS,SAAS,CAAC;QACpBP;MACJ,CAAC,CAAC;IACN,CAAC,CAAC;IACF,IAAIF,MAAM,EAAE;MACR,OAAOA,MAAM;IACjB;IACA,MAAM,IAAIO,kBAAW,CAAC,mCAAmCL,IAAI,IAAI,EAAE,iBAAiB,EAAE;MAClFA;IACJ,CAAC,CAAC;EACN;AACJ;AAACQ,OAAA,CAAAtB,gBAAA,GAAAA,gBAAA","ignoreList":[]}

package/scheduler/ScheduleFetcher.d.ts

@@ -0,0 +1,16 @@
+import type { CmsModel, HeadlessCms } from "@webiny/api-headless-cms/types";
+import type { IScheduleFetcher, IScheduleRecord, ISchedulerListParams, ISchedulerListResponse } from "./types.js";
+export type ScheduleFetcherCms = Pick<HeadlessCms, "getEntryById" | "listLatestEntries">;
+export interface IScheduleFetcherParams {
+    cms: ScheduleFetcherCms;
+    targetModel: CmsModel;
+    schedulerModel: CmsModel;
+}
+export declare class ScheduleFetcher implements IScheduleFetcher {
+    private readonly cms;
+    private readonly targetModel;
+    private readonly schedulerModel;
+    constructor(params: IScheduleFetcherParams);
+    getScheduled(targetId: string): Promise<IScheduleRecord | null>;
+    listScheduled(params: ISchedulerListParams): Promise<ISchedulerListResponse>;
+}

package/scheduler/ScheduleFetcher.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ScheduleFetcher = void 0;
+var _handlerGraphql = require("@webiny/handler-graphql");
+var _createScheduleRecordId = require("./createScheduleRecordId.js");
+var _ScheduleRecord = require("./ScheduleRecord.js");
+var _utils = require("@webiny/utils");
+class ScheduleFetcher {
+  constructor(params) {
+    this.cms = params.cms;
+    this.schedulerModel = params.schedulerModel;
+    this.targetModel = params.targetModel;
+  }
+  async getScheduled(targetId) {
+    const scheduleRecordId = (0, _createScheduleRecordId.createScheduleRecordIdWithVersion)(targetId);
+    try {
+      const entry = await this.cms.getEntryById(this.schedulerModel, scheduleRecordId);
+      return (0, _ScheduleRecord.transformScheduleEntry)(this.targetModel, entry);
+    } catch (ex) {
+      if (ex.code === "NOT_FOUND" || ex instanceof _handlerGraphql.NotFoundError) {
+        return null;
+      }
+      console.error(`Error while fetching scheduled record: ${targetId}.`);
+      console.log((0, _utils.convertException)(ex));
+      throw ex;
+    }
+  }
+  async listScheduled(params) {
+    const [data, meta] = await this.cms.listLatestEntries(this.schedulerModel, {
+      sort: params.sort,
+      limit: params.limit,
+      /**
+       * When params
+       */
+      where: {
+        ...params.where
+      },
+      after: params.after
+    });
+    return {
+      data: data.map(item => (0, _ScheduleRecord.transformScheduleEntry)(this.targetModel, item)),
+      meta
+    };
+  }
+}
+exports.ScheduleFetcher = ScheduleFetcher;
+
+//# sourceMappingURL=ScheduleFetcher.js.map

package/scheduler/ScheduleFetcher.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_handlerGraphql","require","_createScheduleRecordId","_ScheduleRecord","_utils","ScheduleFetcher","constructor","params","cms","schedulerModel","targetModel","getScheduled","targetId","scheduleRecordId","createScheduleRecordIdWithVersion","entry","getEntryById","transformScheduleEntry","ex","code","NotFoundError","console","error","log","convertException","listScheduled","data","meta","listLatestEntries","sort","limit","where","after","map","item","exports"],"sources":["ScheduleFetcher.ts"],"sourcesContent":["import type { CmsModel, HeadlessCms } from \"@webiny/api-headless-cms/types\";\nimport type {\n    IScheduleEntryValues,\n    IScheduleFetcher,\n    IScheduleRecord,\n    ISchedulerListParams,\n    ISchedulerListResponse\n} from \"~/scheduler/types.js\";\nimport { NotFoundError } from \"@webiny/handler-graphql\";\nimport { createScheduleRecordIdWithVersion } from \"~/scheduler/createScheduleRecordId.js\";\nimport { transformScheduleEntry } from \"~/scheduler/ScheduleRecord.js\";\nimport { convertException } from \"@webiny/utils\";\n\nexport type ScheduleFetcherCms = Pick<HeadlessCms, \"getEntryById\" | \"listLatestEntries\">;\n\nexport interface IScheduleFetcherParams {\n    cms: ScheduleFetcherCms;\n    targetModel: CmsModel;\n    schedulerModel: CmsModel;\n}\n\nexport class ScheduleFetcher implements IScheduleFetcher {\n    private readonly cms: ScheduleFetcherCms;\n    private readonly targetModel: CmsModel;\n    private readonly schedulerModel: CmsModel;\n\n    constructor(params: IScheduleFetcherParams) {\n        this.cms = params.cms;\n        this.schedulerModel = params.schedulerModel;\n        this.targetModel = params.targetModel;\n    }\n\n    public async getScheduled(targetId: string): Promise<IScheduleRecord | null> {\n        const scheduleRecordId = createScheduleRecordIdWithVersion(targetId);\n        try {\n            const entry = await this.cms.getEntryById<IScheduleEntryValues>(\n                this.schedulerModel,\n                scheduleRecordId\n            );\n            return transformScheduleEntry(this.targetModel, entry);\n        } catch (ex) {\n            if (ex.code === \"NOT_FOUND\" || ex instanceof NotFoundError) {\n                return null;\n            }\n            console.error(`Error while fetching scheduled record: ${targetId}.`);\n            console.log(convertException(ex));\n            throw ex;\n        }\n    }\n\n    public async listScheduled(params: ISchedulerListParams): Promise<ISchedulerListResponse> {\n        const [data, meta] = await this.cms.listLatestEntries<IScheduleEntryValues>(\n            this.schedulerModel,\n            {\n                sort: params.sort,\n                limit: params.limit,\n                /**\n                 * When params\n                 */\n                where: {\n                    ...params.where\n                },\n                after: params.after\n            }\n        );\n\n        return {\n            data: data.map(item => transformScheduleEntry(this.targetModel, item)),\n            meta\n        };\n    }\n}\n"],"mappings":";;;;;;AAQA,IAAAA,eAAA,GAAAC,OAAA;AACA,IAAAC,uBAAA,GAAAD,OAAA;AACA,IAAAE,eAAA,GAAAF,OAAA;AACA,IAAAG,MAAA,GAAAH,OAAA;AAUO,MAAMI,eAAe,CAA6B;EAKrDC,WAAWA,CAACC,MAA8B,EAAE;IACxC,IAAI,CAACC,GAAG,GAAGD,MAAM,CAACC,GAAG;IACrB,IAAI,CAACC,cAAc,GAAGF,MAAM,CAACE,cAAc;IAC3C,IAAI,CAACC,WAAW,GAAGH,MAAM,CAACG,WAAW;EACzC;EAEA,MAAaC,YAAYA,CAACC,QAAgB,EAAmC;IACzE,MAAMC,gBAAgB,GAAG,IAAAC,yDAAiC,EAACF,QAAQ,CAAC;IACpE,IAAI;MACA,MAAMG,KAAK,GAAG,MAAM,IAAI,CAACP,GAAG,CAACQ,YAAY,CACrC,IAAI,CAACP,cAAc,EACnBI,gBACJ,CAAC;MACD,OAAO,IAAAI,sCAAsB,EAAC,IAAI,CAACP,WAAW,EAAEK,KAAK,CAAC;IAC1D,CAAC,CAAC,OAAOG,EAAE,EAAE;MACT,IAAIA,EAAE,CAACC,IAAI,KAAK,WAAW,IAAID,EAAE,YAAYE,6BAAa,EAAE;QACxD,OAAO,IAAI;MACf;MACAC,OAAO,CAACC,KAAK,CAAC,0CAA0CV,QAAQ,GAAG,CAAC;MACpES,OAAO,CAACE,GAAG,CAAC,IAAAC,uBAAgB,EAACN,EAAE,CAAC,CAAC;MACjC,MAAMA,EAAE;IACZ;EACJ;EAEA,MAAaO,aAAaA,CAAClB,MAA4B,EAAmC;IACtF,MAAM,CAACmB,IAAI,EAAEC,IAAI,CAAC,GAAG,MAAM,IAAI,CAACnB,GAAG,CAACoB,iBAAiB,CACjD,IAAI,CAACnB,cAAc,EACnB;MACIoB,IAAI,EAAEtB,MAAM,CAACsB,IAAI;MACjBC,KAAK,EAAEvB,MAAM,CAACuB,KAAK;MACnB;AAChB;AACA;MACgBC,KAAK,EAAE;QACH,GAAGxB,MAAM,CAACwB;MACd,CAAC;MACDC,KAAK,EAAEzB,MAAM,CAACyB;IAClB,CACJ,CAAC;IAED,OAAO;MACHN,IAAI,EAAEA,IAAI,CAACO,GAAG,CAACC,IAAI,IAAI,IAAAjB,sCAAsB,EAAC,IAAI,CAACP,WAAW,EAAEwB,IAAI,CAAC,CAAC;MACtEP;IACJ,CAAC;EACL;AACJ;AAACQ,OAAA,CAAA9B,eAAA,GAAAA,eAAA","ignoreList":[]}

package/scheduler/ScheduleRecord.d.ts

@@ -0,0 +1,31 @@
+import { type IScheduleEntryValues, type IScheduleRecord, type ScheduledOnType, ScheduleType } from "./types.js";
+import type { CmsEntry, CmsIdentity, CmsModel } from "@webiny/api-headless-cms/types/index.js";
+export interface IScheduleRecordParams {
+    id: string;
+    targetId: string;
+    model: CmsModel;
+    scheduledBy: CmsIdentity;
+    /**
+     * The date when the schedule is to be executed.
+     */
+    scheduledOn: ScheduledOnType;
+    /**
+     * The date when the action is to be set as done.
+     * User can set publishedOn (and other relevant dates) with this parameter.
+     */
+    type: ScheduleType;
+    title: string;
+}
+export declare class ScheduleRecord implements IScheduleRecord {
+    readonly id: string;
+    readonly targetId: string;
+    readonly model: CmsModel;
+    readonly scheduledBy: CmsIdentity;
+    readonly publishOn: ScheduledOnType | undefined;
+    readonly unpublishOn: ScheduledOnType | undefined;
+    readonly type: ScheduleType;
+    readonly title: string;
+    constructor(record: IScheduleRecordParams);
+}
+export declare const createScheduleRecord: (record: IScheduleRecordParams) => IScheduleRecord;
+export declare const transformScheduleEntry: (targetModel: CmsModel, entry: CmsEntry<IScheduleEntryValues>) => IScheduleRecord;

package/scheduler/ScheduleRecord.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformScheduleEntry = exports.createScheduleRecord = exports.ScheduleRecord = void 0;
+var _types = require("./types.js");
+var _error = require("@webiny/error");
+class ScheduleRecord {
+  // public readonly dateOn: DateOnType | undefined;
+
+  constructor(record) {
+    this.id = record.id;
+    this.targetId = record.targetId;
+    this.model = record.model;
+    this.scheduledBy = record.scheduledBy;
+    // this.dateOn = record.dateOn;
+    this.publishOn = record.type === _types.ScheduleType.publish ? record.scheduledOn : undefined;
+    this.unpublishOn = record.type === _types.ScheduleType.unpublish ? record.scheduledOn : undefined;
+    this.type = record.type;
+    this.title = record.title;
+  }
+}
+exports.ScheduleRecord = ScheduleRecord;
+const createScheduleRecord = record => {
+  return new ScheduleRecord(record);
+};
+exports.createScheduleRecord = createScheduleRecord;
+const transformScheduleEntry = (targetModel, entry) => {
+  let type;
+  switch (entry.values.type) {
+    case _types.ScheduleType.publish:
+      type = _types.ScheduleType.publish;
+      break;
+    case _types.ScheduleType.unpublish:
+      type = _types.ScheduleType.unpublish;
+      break;
+    default:
+      throw new _error.WebinyError(`Unsupported schedule type "${entry.values.type}".`, "UNSUPPORTED_SCHEDULE_TYPE", {
+        type: entry.values.type,
+        entry
+      });
+  }
+  return createScheduleRecord({
+    id: entry.id,
+    type,
+    title: entry.values.title,
+    targetId: entry.values.targetId,
+    scheduledOn: new Date(entry.values.scheduledOn),
+    // dateOn: isoStringToDate(entry.values.dateOn),
+    scheduledBy: entry.savedBy,
+    model: targetModel
+  });
+};
+exports.transformScheduleEntry = transformScheduleEntry;
+
+//# sourceMappingURL=ScheduleRecord.js.map

package/scheduler/ScheduleRecord.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_types","require","_error","ScheduleRecord","constructor","record","id","targetId","model","scheduledBy","publishOn","type","ScheduleType","publish","scheduledOn","undefined","unpublishOn","unpublish","title","exports","createScheduleRecord","transformScheduleEntry","targetModel","entry","values","WebinyError","Date","savedBy"],"sources":["ScheduleRecord.ts"],"sourcesContent":["import {\n    type IScheduleEntryValues,\n    type IScheduleRecord,\n    type ScheduledOnType,\n    ScheduleType\n} from \"~/scheduler/types.js\";\nimport type { CmsEntry, CmsIdentity, CmsModel } from \"@webiny/api-headless-cms/types/index.js\";\nimport { WebinyError } from \"@webiny/error\";\n\nexport interface IScheduleRecordParams {\n    id: string;\n    targetId: string;\n    model: CmsModel;\n    scheduledBy: CmsIdentity;\n    /**\n     * The date when the schedule is to be executed.\n     */\n    scheduledOn: ScheduledOnType;\n    /**\n     * The date when the action is to be set as done.\n     * User can set publishedOn (and other relevant dates) with this parameter.\n     */\n    // dateOn: DateOnType | undefined;\n    type: ScheduleType;\n    title: string;\n}\n\nexport class ScheduleRecord implements IScheduleRecord {\n    public readonly id: string;\n    public readonly targetId: string;\n    public readonly model: CmsModel;\n    public readonly scheduledBy: CmsIdentity;\n    public readonly publishOn: ScheduledOnType | undefined;\n    public readonly unpublishOn: ScheduledOnType | undefined;\n    // public readonly dateOn: DateOnType | undefined;\n    public readonly type: ScheduleType;\n    public readonly title: string;\n\n    public constructor(record: IScheduleRecordParams) {\n        this.id = record.id;\n        this.targetId = record.targetId;\n        this.model = record.model;\n        this.scheduledBy = record.scheduledBy;\n        // this.dateOn = record.dateOn;\n        this.publishOn = record.type === ScheduleType.publish ? record.scheduledOn : undefined;\n        this.unpublishOn = record.type === ScheduleType.unpublish ? record.scheduledOn : undefined;\n        this.type = record.type;\n        this.title = record.title;\n    }\n}\n\nexport const createScheduleRecord = (record: IScheduleRecordParams): IScheduleRecord => {\n    return new ScheduleRecord(record);\n};\n\nexport const transformScheduleEntry = (\n    targetModel: CmsModel,\n    entry: CmsEntry<IScheduleEntryValues>\n): IScheduleRecord => {\n    let type: ScheduleType;\n    switch (entry.values.type) {\n        case ScheduleType.publish:\n            type = ScheduleType.publish;\n            break;\n        case ScheduleType.unpublish:\n            type = ScheduleType.unpublish;\n            break;\n        default:\n            throw new WebinyError(\n                `Unsupported schedule type \"${entry.values.type}\".`,\n                \"UNSUPPORTED_SCHEDULE_TYPE\",\n                {\n                    type: entry.values.type,\n                    entry\n                }\n            );\n    }\n    return createScheduleRecord({\n        id: entry.id,\n        type,\n        title: entry.values.title,\n        targetId: entry.values.targetId,\n        scheduledOn: new Date(entry.values.scheduledOn),\n        // dateOn: isoStringToDate(entry.values.dateOn),\n        scheduledBy: entry.savedBy,\n        model: targetModel\n    });\n};\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAOA,IAAAC,MAAA,GAAAD,OAAA;AAoBO,MAAME,cAAc,CAA4B;EAOnD;;EAIOC,WAAWA,CAACC,MAA6B,EAAE;IAC9C,IAAI,CAACC,EAAE,GAAGD,MAAM,CAACC,EAAE;IACnB,IAAI,CAACC,QAAQ,GAAGF,MAAM,CAACE,QAAQ;IAC/B,IAAI,CAACC,KAAK,GAAGH,MAAM,CAACG,KAAK;IACzB,IAAI,CAACC,WAAW,GAAGJ,MAAM,CAACI,WAAW;IACrC;IACA,IAAI,CAACC,SAAS,GAAGL,MAAM,CAACM,IAAI,KAAKC,mBAAY,CAACC,OAAO,GAAGR,MAAM,CAACS,WAAW,GAAGC,SAAS;IACtF,IAAI,CAACC,WAAW,GAAGX,MAAM,CAACM,IAAI,KAAKC,mBAAY,CAACK,SAAS,GAAGZ,MAAM,CAACS,WAAW,GAAGC,SAAS;IAC1F,IAAI,CAACJ,IAAI,GAAGN,MAAM,CAACM,IAAI;IACvB,IAAI,CAACO,KAAK,GAAGb,MAAM,CAACa,KAAK;EAC7B;AACJ;AAACC,OAAA,CAAAhB,cAAA,GAAAA,cAAA;AAEM,MAAMiB,oBAAoB,GAAIf,MAA6B,IAAsB;EACpF,OAAO,IAAIF,cAAc,CAACE,MAAM,CAAC;AACrC,CAAC;AAACc,OAAA,CAAAC,oBAAA,GAAAA,oBAAA;AAEK,MAAMC,sBAAsB,GAAGA,CAClCC,WAAqB,EACrBC,KAAqC,KACnB;EAClB,IAAIZ,IAAkB;EACtB,QAAQY,KAAK,CAACC,MAAM,CAACb,IAAI;IACrB,KAAKC,mBAAY,CAACC,OAAO;MACrBF,IAAI,GAAGC,mBAAY,CAACC,OAAO;MAC3B;IACJ,KAAKD,mBAAY,CAACK,SAAS;MACvBN,IAAI,GAAGC,mBAAY,CAACK,SAAS;MAC7B;IACJ;MACI,MAAM,IAAIQ,kBAAW,CACjB,8BAA8BF,KAAK,CAACC,MAAM,CAACb,IAAI,IAAI,EACnD,2BAA2B,EAC3B;QACIA,IAAI,EAAEY,KAAK,CAACC,MAAM,CAACb,IAAI;QACvBY;MACJ,CACJ,CAAC;EACT;EACA,OAAOH,oBAAoB,CAAC;IACxBd,EAAE,EAAEiB,KAAK,CAACjB,EAAE;IACZK,IAAI;IACJO,KAAK,EAAEK,KAAK,CAACC,MAAM,CAACN,KAAK;IACzBX,QAAQ,EAAEgB,KAAK,CAACC,MAAM,CAACjB,QAAQ;IAC/BO,WAAW,EAAE,IAAIY,IAAI,CAACH,KAAK,CAACC,MAAM,CAACV,WAAW,CAAC;IAC/C;IACAL,WAAW,EAAEc,KAAK,CAACI,OAAO;IAC1BnB,KAAK,EAAEc;EACX,CAAC,CAAC;AACN,CAAC;AAACH,OAAA,CAAAE,sBAAA,GAAAA,sBAAA","ignoreList":[]}

package/scheduler/Scheduler.d.ts

@@ -0,0 +1,14 @@
+import type { IScheduleExecutor, IScheduleFetcher, IScheduler, IScheduleRecord, ISchedulerInput, ISchedulerListParams, ISchedulerListResponse } from "./types.js";
+export interface ISchedulerParams {
+    fetcher: IScheduleFetcher;
+    executor: IScheduleExecutor;
+}
+export declare class Scheduler implements IScheduler {
+    private readonly fetcher;
+    private readonly executor;
+    constructor(params: ISchedulerParams);
+    getScheduled(targetId: string): Promise<IScheduleRecord | null>;
+    listScheduled(params: ISchedulerListParams): Promise<ISchedulerListResponse>;
+    schedule(targetId: string, input: ISchedulerInput): Promise<IScheduleRecord>;
+    cancel(id: string): Promise<IScheduleRecord>;
+}

package/scheduler/Scheduler.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Scheduler = void 0;
+class Scheduler {
+  constructor(params) {
+    this.fetcher = params.fetcher;
+    this.executor = params.executor;
+  }
+  async getScheduled(targetId) {
+    return this.fetcher.getScheduled(targetId);
+  }
+  async listScheduled(params) {
+    return this.fetcher.listScheduled(params);
+  }
+  async schedule(targetId, input) {
+    return this.executor.schedule(targetId, input);
+  }
+  async cancel(id) {
+    return this.executor.cancel(id);
+  }
+}
+exports.Scheduler = Scheduler;
+
+//# sourceMappingURL=Scheduler.js.map

package/scheduler/Scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Scheduler","constructor","params","fetcher","executor","getScheduled","targetId","listScheduled","schedule","input","cancel","id","exports"],"sources":["Scheduler.ts"],"sourcesContent":["import type {\n    IScheduleExecutor,\n    IScheduleFetcher,\n    IScheduler,\n    IScheduleRecord,\n    ISchedulerInput,\n    ISchedulerListParams,\n    ISchedulerListResponse\n} from \"~/scheduler/types.js\";\n\nexport interface ISchedulerParams {\n    fetcher: IScheduleFetcher;\n    executor: IScheduleExecutor;\n}\n\nexport class Scheduler implements IScheduler {\n    private readonly fetcher: IScheduleFetcher;\n    private readonly executor: IScheduleExecutor;\n\n    public constructor(params: ISchedulerParams) {\n        this.fetcher = params.fetcher;\n        this.executor = params.executor;\n    }\n\n    public async getScheduled(targetId: string): Promise<IScheduleRecord | null> {\n        return this.fetcher.getScheduled(targetId);\n    }\n\n    public async listScheduled(params: ISchedulerListParams): Promise<ISchedulerListResponse> {\n        return this.fetcher.listScheduled(params);\n    }\n\n    public async schedule(targetId: string, input: ISchedulerInput): Promise<IScheduleRecord> {\n        return this.executor.schedule(targetId, input);\n    }\n\n    public async cancel(id: string): Promise<IScheduleRecord> {\n        return this.executor.cancel(id);\n    }\n}\n"],"mappings":";;;;;;AAeO,MAAMA,SAAS,CAAuB;EAIlCC,WAAWA,CAACC,MAAwB,EAAE;IACzC,IAAI,CAACC,OAAO,GAAGD,MAAM,CAACC,OAAO;IAC7B,IAAI,CAACC,QAAQ,GAAGF,MAAM,CAACE,QAAQ;EACnC;EAEA,MAAaC,YAAYA,CAACC,QAAgB,EAAmC;IACzE,OAAO,IAAI,CAACH,OAAO,CAACE,YAAY,CAACC,QAAQ,CAAC;EAC9C;EAEA,MAAaC,aAAaA,CAACL,MAA4B,EAAmC;IACtF,OAAO,IAAI,CAACC,OAAO,CAACI,aAAa,CAACL,MAAM,CAAC;EAC7C;EAEA,MAAaM,QAAQA,CAACF,QAAgB,EAAEG,KAAsB,EAA4B;IACtF,OAAO,IAAI,CAACL,QAAQ,CAACI,QAAQ,CAACF,QAAQ,EAAEG,KAAK,CAAC;EAClD;EAEA,MAAaC,MAAMA,CAACC,EAAU,EAA4B;IACtD,OAAO,IAAI,CAACP,QAAQ,CAACM,MAAM,CAACC,EAAE,CAAC;EACnC;AACJ;AAACC,OAAA,CAAAZ,SAAA,GAAAA,SAAA","ignoreList":[]}

package/scheduler/actions/PublishScheduleAction.d.ts

@@ -0,0 +1,26 @@
+import type { IScheduleAction, IScheduleActionScheduleParams, IScheduleFetcher, IScheduleRecord, ISchedulerInput } from "../types.js";
+import type { CmsIdentity, CmsModel, HeadlessCms } from "@webiny/api-headless-cms/types";
+import type { ISchedulerService } from "../../service/types.js";
+export type PublishScheduleActionCms = Pick<HeadlessCms, "getEntryById" | "publishEntry" | "createEntry" | "updateEntry" | "deleteEntry">;
+export interface IPublishScheduleActionParams {
+    service: ISchedulerService;
+    cms: PublishScheduleActionCms;
+    targetModel: CmsModel;
+    schedulerModel: CmsModel;
+    getIdentity: () => CmsIdentity;
+    fetcher: IScheduleFetcher;
+}
+export declare class PublishScheduleAction implements IScheduleAction {
+    private readonly service;
+    private readonly cms;
+    private readonly targetModel;
+    private readonly schedulerModel;
+    private readonly getIdentity;
+    private readonly fetcher;
+    constructor(params: IPublishScheduleActionParams);
+    canHandle(input: ISchedulerInput): boolean;
+    schedule(params: IScheduleActionScheduleParams): Promise<IScheduleRecord>;
+    reschedule(original: IScheduleRecord, input: ISchedulerInput): Promise<IScheduleRecord>;
+    cancel(id: string): Promise<void>;
+    private getTargetEntry;
+}

package/scheduler/actions/PublishScheduleAction.js

@@ -0,0 +1,196 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PublishScheduleAction = void 0;
+var _types = require("../types.js");
+var _ScheduleRecord = require("../ScheduleRecord.js");
+var _utils = require("@webiny/utils");
+var _dates = require("../dates.js");
+var _handlerGraphql = require("@webiny/handler-graphql");
+var _dateInTheFuture = require("../../utils/dateInTheFuture.js");
+var _parseIdentifier = require("@webiny/utils/parseIdentifier.js");
+class PublishScheduleAction {
+  constructor(params) {
+    this.service = params.service;
+    this.cms = params.cms;
+    this.targetModel = params.targetModel;
+    this.schedulerModel = params.schedulerModel;
+    this.getIdentity = params.getIdentity;
+    this.fetcher = params.fetcher;
+  }
+  canHandle(input) {
+    return input.type === _types.ScheduleType.publish;
+  }
+  async schedule(params) {
+    const {
+      targetId,
+      input,
+      scheduleRecordId
+    } = params;
+    const targetEntry = await this.getTargetEntry(targetId);
+    const title = targetEntry.values[this.targetModel.titleFieldId] || "Unknown entry title";
+    const identity = this.getIdentity();
+    const currentDate = new Date();
+    /**
+     * Immediately publish the entry if requested.
+     * No need to create a schedule entry or the service event.
+     */
+    if (input.immediately) {
+      const publishedEntry = await this.cms.publishEntry(this.targetModel, targetId);
+      return (0, _ScheduleRecord.createScheduleRecord)({
+        id: scheduleRecordId,
+        targetId,
+        model: this.targetModel,
+        scheduledBy: publishedEntry.savedBy,
+        scheduledOn: new Date(publishedEntry.savedOn),
+        // dateOn: currentDate,
+        type: _types.ScheduleType.publish,
+        title
+      });
+    }
+    /**
+     * If the entry is scheduled for a date in the past, we need to update it with publish information, if user sent something.
+     * No need to create a schedule entry or the service event.
+     */
+    //
+    else if ((0, _dateInTheFuture.dateInTheFuture)(input.scheduleOn) === false) {
+      /**
+       * We need to update the entry with publish information because we cannot update it in the publishing process.
+       */
+      await this.cms.updateEntry(this.targetModel, targetId, {
+        firstPublishedBy: identity,
+        firstPublishedOn: (0, _dates.dateToISOString)(input.scheduleOn),
+        lastPublishedOn: (0, _dates.dateToISOString)(input.scheduleOn),
+        lastPublishedBy: identity
+      });
+      const publishedEntry = await this.cms.publishEntry(this.targetModel, targetId);
+      return (0, _ScheduleRecord.createScheduleRecord)({
+        id: scheduleRecordId,
+        targetId,
+        model: this.targetModel,
+        scheduledBy: publishedEntry.savedBy,
+        scheduledOn: currentDate,
+        type: _types.ScheduleType.publish,
+        title
+      });
+    }
+    const {
+      id: scheduleEntryId
+    } = (0, _parseIdentifier.parseIdentifier)(scheduleRecordId);
+    const scheduleEntry = await this.cms.createEntry(this.schedulerModel, {
+      id: scheduleEntryId,
+      targetId,
+      targetModelId: this.targetModel.modelId,
+      title,
+      type: _types.ScheduleType.publish,
+      scheduledOn: (0, _dates.dateToISOString)(input.scheduleOn),
+      scheduledBy: identity
+    });
+    try {
+      await this.service.create({
+        id: scheduleRecordId,
+        scheduleOn: input.scheduleOn
+      });
+    } catch (ex) {
+      console.error(`Could not create service event for schedule entry: ${scheduleRecordId}. Deleting the schedule entry...`);
+      console.log((0, _utils.convertException)(ex));
+      try {
+        await this.cms.deleteEntry(this.schedulerModel, scheduleRecordId);
+      } catch (err) {
+        console.error(`Error while deleting schedule entry: ${scheduleRecordId}.`);
+        console.log((0, _utils.convertException)(err));
+        throw err;
+      }
+      throw ex;
+    }
+    return (0, _ScheduleRecord.transformScheduleEntry)(this.targetModel, scheduleEntry);
+  }
+  async reschedule(original, input) {
+    const currentDate = new Date();
+    const targetId = original.targetId;
+    const targetEntry = await this.getTargetEntry(targetId);
+
+    /**
+     * There are two cases when we can immediately publish the entry:
+     * 1. If the user requested it.
+     * 2. If the entry is scheduled for a date in the past.
+     */
+    if (input.immediately || input.scheduleOn < currentDate) {
+      await this.cms.publishEntry(this.targetModel, targetEntry.id);
+      /**
+       * We can safely cancel the original schedule entry and the event.
+       *
+       * // TODO determine if we want to ignore the error of the cancelation.
+       */
+      try {
+        await this.cancel(original.id);
+      } catch {
+        //
+      }
+      return {
+        ...original,
+        publishOn: currentDate,
+        unpublishOn: undefined
+        // dateOn: publishedEntry.lastPublishedOn
+        //     ? new Date(publishedEntry.lastPublishedOn)
+        //     : undefined
+      };
+    }
+    await this.cms.updateEntry(this.schedulerModel, original.id, {
+      scheduledBy: this.getIdentity(),
+      scheduledOn: (0, _dates.dateToISOString)(input.scheduleOn)
+    });
+    try {
+      await this.service.update({
+        id: original.id,
+        scheduleOn: input.scheduleOn
+      });
+    } catch (ex) {
+      throw ex;
+    }
+    return {
+      ...original,
+      publishOn: new Date(),
+      unpublishOn: undefined
+    };
+  }
+  async cancel(id) {
+    /**
+     * No need to do anything if the record does not exist.
+     */
+    let scheduleEntry = null;
+    try {
+      scheduleEntry = await this.fetcher.getScheduled(id);
+      if (!scheduleEntry) {
+        return;
+      }
+    } catch {
+      return;
+    }
+    try {
+      await this.cms.deleteEntry(this.schedulerModel, scheduleEntry.id);
+    } catch (ex) {
+      if (ex.code === "NOT_FOUND" || ex instanceof _handlerGraphql.NotFoundError) {
+        return;
+      }
+      console.error(`Error while deleting schedule entry: ${scheduleEntry.id}.`);
+      console.log((0, _utils.convertException)(ex));
+      throw ex;
+    }
+    try {
+      await this.service.delete(scheduleEntry.id);
+    } catch (ex) {
+      console.error(`Error while deleting service event for schedule entry: ${scheduleEntry.id}.`);
+      console.log((0, _utils.convertException)(ex));
+      throw ex;
+    }
+  }
+  async getTargetEntry(id) {
+    return await this.cms.getEntryById(this.targetModel, id);
+  }
+}
+exports.PublishScheduleAction = PublishScheduleAction;
+
+//# sourceMappingURL=PublishScheduleAction.js.map