@webiny/app-scheduler 0.0.0-unstable.7be00a75a9

package/Domain/index.js

@@ -0,0 +1,2 @@
+export * from "./Models/index.js";
+export * from "./Repositories/index.js";

package/Gateways/SchedulerCancelGraphQLGateway.d.ts

@@ -0,0 +1,7 @@
+import type { ApolloClient } from "apollo-client";
+import type { ICancelScheduledActionGateway, ICancelScheduledActionGatewayParams } from "./abstractions/CancelScheduledActionGateway.js";
+export declare class SchedulerCancelGraphQLGateway implements ICancelScheduledActionGateway {
+    private readonly client;
+    constructor(client: ApolloClient<object>);
+    execute(params: ICancelScheduledActionGatewayParams): Promise<void>;
+}

package/Gateways/SchedulerCancelGraphQLGateway.js

@@ -0,0 +1,42 @@
+import graphql_tag from "graphql-tag";
+const createScheduleCancelActionMutation = ()=>graphql_tag`
+        mutation ScheduleCancelAction($namespace: String!, $id: ID!) {
+            scheduler {
+                cancelScheduledAction(namespace: $namespace, id: $id) {
+                    data
+                    error {
+                        message
+                        code
+                        data
+                        stack
+                    }
+                }
+            }
+        }
+    `;
+class SchedulerCancelGraphQLGateway {
+    constructor(client){
+        this.client = client;
+    }
+    async execute(params) {
+        const { data: response, errors } = await this.client.mutate({
+            mutation: createScheduleCancelActionMutation(),
+            variables: {
+                namespace: params.namespace,
+                id: params.id
+            },
+            fetchPolicy: "no-cache"
+        });
+        const result = response?.scheduler?.cancelScheduledAction;
+        if (!result || errors?.length) {
+            console.error({
+                errors
+            });
+            throw new Error("Network error while canceling a scheduled action.");
+        }
+        if (!result.data) throw new Error(result.error?.message || "Could not cancel scheduled action.");
+    }
+}
+export { SchedulerCancelGraphQLGateway };
+
+//# sourceMappingURL=SchedulerCancelGraphQLGateway.js.map

package/Gateways/SchedulerCancelGraphQLGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Gateways/SchedulerCancelGraphQLGateway.js","sources":["../../src/Gateways/SchedulerCancelGraphQLGateway.ts"],"sourcesContent":["import type { ApolloClient } from \"apollo-client\";\nimport gql from \"graphql-tag\";\nimport type { SchedulerErrorResponse } from \"~/types.js\";\nimport type {\n    ICancelScheduledActionGateway,\n    ICancelScheduledActionGatewayParams\n} from \"./abstractions/CancelScheduledActionGateway.js\";\n\nconst createScheduleCancelActionMutation = () => {\n    return gql`\n        mutation ScheduleCancelAction($namespace: String!, $id: ID!) {\n            scheduler {\n                cancelScheduledAction(namespace: $namespace, id: $id) {\n                    data\n                    error {\n                        message\n                        code\n                        data\n                        stack\n                    }\n                }\n            }\n        }\n    `;\n};\n\ninterface SchedulerCancelGraphQLMutationVariables {\n    namespace: string;\n    id: string;\n}\n\ninterface SchedulerCancelGraphQLMutationResponse {\n    scheduler: {\n        cancelScheduledAction: {\n            data: boolean | null;\n            error: SchedulerErrorResponse | null;\n        };\n    };\n}\n\nexport class SchedulerCancelGraphQLGateway implements ICancelScheduledActionGateway {\n    private readonly client: ApolloClient<object>;\n\n    public constructor(client: ApolloClient<object>) {\n        this.client = client;\n    }\n\n    public async execute(params: ICancelScheduledActionGatewayParams) {\n        const { data: response, errors } = await this.client.mutate<\n            SchedulerCancelGraphQLMutationResponse,\n            SchedulerCancelGraphQLMutationVariables\n        >({\n            mutation: createScheduleCancelActionMutation(),\n            variables: {\n                namespace: params.namespace,\n                id: params.id\n            },\n            fetchPolicy: \"no-cache\"\n        });\n\n        const result = response?.scheduler?.cancelScheduledAction;\n        if (!result || errors?.length) {\n            console.error({\n                errors\n            });\n            throw new Error(\"Network error while canceling a scheduled action.\");\n        }\n\n        if (!result.data) {\n            throw new Error(result.error?.message || \"Could not cancel scheduled action.\");\n        }\n    }\n}\n"],"names":["createScheduleCancelActionMutation","gql","SchedulerCancelGraphQLGateway","client","params","response","errors","result","console","Error"],"mappings":";AAQA,MAAMA,qCAAqC,IAChCC,WAAG,CAAC;;;;;;;;;;;;;;IAcX,CAAC;AAiBE,MAAMC;IAGT,YAAmBC,MAA4B,CAAE;QAC7C,IAAI,CAAC,MAAM,GAAGA;IAClB;IAEA,MAAa,QAAQC,MAA2C,EAAE;QAC9D,MAAM,EAAE,MAAMC,QAAQ,EAAEC,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAGzD;YACE,UAAUN;YACV,WAAW;gBACP,WAAWI,OAAO,SAAS;gBAC3B,IAAIA,OAAO,EAAE;YACjB;YACA,aAAa;QACjB;QAEA,MAAMG,SAASF,UAAU,WAAW;QACpC,IAAI,CAACE,UAAUD,QAAQ,QAAQ;YAC3BE,QAAQ,KAAK,CAAC;gBACVF;YACJ;YACA,MAAM,IAAIG,MAAM;QACpB;QAEA,IAAI,CAACF,OAAO,IAAI,EACZ,MAAM,IAAIE,MAAMF,OAAO,KAAK,EAAE,WAAW;IAEjD;AACJ"}

package/Gateways/SchedulerGetGraphQLGateway.d.ts

@@ -0,0 +1,21 @@
+import type { ApolloClient } from "apollo-client";
+import type { IGetScheduledActionGateway, IGetScheduledActionGatewayExecuteParams } from "./abstractions/GetScheduledActionGateway.js";
+export declare const createGetScheduledActionQuery: () => import("graphql").DocumentNode;
+export declare class SchedulerGetGraphQLGateway implements IGetScheduledActionGateway {
+    private readonly client;
+    constructor(client: ApolloClient<any>);
+    execute(params: IGetScheduledActionGatewayExecuteParams): Promise<{
+        id: string;
+        targetId: string;
+        namespace: string;
+        scheduledBy: {
+            id: string;
+            displayName: string;
+            type: string;
+        };
+        publishOn: Date | undefined;
+        unpublishOn: Date | undefined;
+        actionType: import("~/types.js").ScheduleActionType;
+        title: string;
+    } | null>;
+}

package/Gateways/SchedulerGetGraphQLGateway.js

@@ -0,0 +1,68 @@
+import graphql_tag from "graphql-tag";
+import zod from "zod";
+import { createZodError } from "@webiny/utils/createZodError.js";
+import { schedulerEntrySchema } from "./schema/schedulerEntry.js";
+import { createSchedulerEntryFields } from "./graphql/fields.js";
+const createGetScheduledActionQuery = ()=>graphql_tag`
+        query GetTargetScheduledActionQuery($namespace: String!, $id: ID!) {
+            scheduler {
+                getTargetScheduledAction(namespace: $namespace, id: $id) {
+                    data {
+                        ${createSchedulerEntryFields()}
+                    }
+                    error {
+                        message
+                        code
+                        data
+                        stack
+                    }
+                }
+            }
+        }
+    `;
+const schema = zod.object({
+    data: schedulerEntrySchema
+});
+class SchedulerGetGraphQLGateway {
+    constructor(client){
+        this.client = client;
+    }
+    async execute(params) {
+        const { data: response, errors } = await this.client.query({
+            query: createGetScheduledActionQuery(),
+            variables: {
+                namespace: params.namespace,
+                id: params.id
+            },
+            fetchPolicy: "network-only"
+        });
+        const result = response?.scheduler?.getTargetScheduledAction;
+        if (!result || errors?.length) {
+            console.error({
+                errors
+            });
+            throw new Error("Network error while getting scheduled action.");
+        }
+        if (result.error) {
+            console.error({
+                error: result.error
+            });
+            throw new Error(result.error.message || "Could not fetch scheduled action.");
+        }
+        if (!result.data) return null;
+        const validated = await schema.safeParseAsync(result);
+        if (!validated.success) {
+            const err = createZodError(validated.error);
+            console.error(err);
+            console.log(JSON.stringify({
+                err,
+                ex: validated.error
+            }));
+            throw err;
+        }
+        return validated.data.data;
+    }
+}
+export { SchedulerGetGraphQLGateway, createGetScheduledActionQuery };
+
+//# sourceMappingURL=SchedulerGetGraphQLGateway.js.map

package/Gateways/SchedulerGetGraphQLGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Gateways/SchedulerGetGraphQLGateway.js","sources":["../../src/Gateways/SchedulerGetGraphQLGateway.ts"],"sourcesContent":["import type { ApolloClient } from \"apollo-client\";\nimport gql from \"graphql-tag\";\nimport zod from \"zod\";\nimport { createZodError } from \"@webiny/utils/createZodError.js\";\nimport { schedulerEntrySchema } from \"./schema/schedulerEntry.js\";\nimport { createSchedulerEntryFields } from \"./graphql/fields.js\";\nimport type {\n    IGetScheduledActionGateway,\n    IGetScheduledActionGatewayExecuteParams\n} from \"./abstractions/GetScheduledActionGateway.js\";\nimport type { SchedulerEntry, SchedulerErrorResponse } from \"~/types.js\";\n\nexport const createGetScheduledActionQuery = () => {\n    return gql`\n        query GetTargetScheduledActionQuery($namespace: String!, $id: ID!) {\n            scheduler {\n                getTargetScheduledAction(namespace: $namespace, id: $id) {\n                    data {\n                        ${createSchedulerEntryFields()}\n                    }\n                    error {\n                        message\n                        code\n                        data\n                        stack\n                    }\n                }\n            }\n        }\n    `;\n};\n\ninterface SchedulerGetGraphQLQueryResponse {\n    scheduler: {\n        getTargetScheduledAction: {\n            data: SchedulerEntry | null;\n            error: SchedulerErrorResponse | null;\n        };\n    };\n}\n\nconst schema = zod.object({\n    data: schedulerEntrySchema\n});\n\nexport class SchedulerGetGraphQLGateway implements IGetScheduledActionGateway {\n    private readonly client: ApolloClient<any>;\n\n    public constructor(client: ApolloClient<any>) {\n        this.client = client;\n    }\n\n    public async execute(params: IGetScheduledActionGatewayExecuteParams) {\n        const { data: response, errors } = await this.client.query<\n            SchedulerGetGraphQLQueryResponse,\n            IGetScheduledActionGatewayExecuteParams\n        >({\n            query: createGetScheduledActionQuery(),\n            variables: {\n                namespace: params.namespace,\n                id: params.id\n            },\n            fetchPolicy: \"network-only\"\n        });\n\n        const result = response?.scheduler?.getTargetScheduledAction;\n        if (!result || errors?.length) {\n            console.error({\n                errors\n            });\n            throw new Error(\"Network error while getting scheduled action.\");\n        } else if (result.error) {\n            console.error({\n                error: result.error\n            });\n            throw new Error(result.error.message || \"Could not fetch scheduled action.\");\n        } else if (!result.data) {\n            return null;\n        }\n\n        const validated = await schema.safeParseAsync(result);\n        if (!validated.success) {\n            const err = createZodError(validated.error);\n            console.error(err);\n            console.log(\n                JSON.stringify({\n                    err,\n                    ex: validated.error\n                })\n            );\n            throw err;\n        }\n\n        return validated.data.data;\n    }\n}\n"],"names":["createGetScheduledActionQuery","gql","createSchedulerEntryFields","schema","zod","schedulerEntrySchema","SchedulerGetGraphQLGateway","client","params","response","errors","result","console","Error","validated","err","createZodError","JSON"],"mappings":";;;;;AAYO,MAAMA,gCAAgC,IAClCC,WAAG,CAAC;;;;;wBAKS,EAAEC,6BAA6B;;;;;;;;;;;IAWnD,CAAC;AAYL,MAAMC,SAASC,IAAI,MAAM,CAAC;IACtB,MAAMC;AACV;AAEO,MAAMC;IAGT,YAAmBC,MAAyB,CAAE;QAC1C,IAAI,CAAC,MAAM,GAAGA;IAClB;IAEA,MAAa,QAAQC,MAA+C,EAAE;QAClE,MAAM,EAAE,MAAMC,QAAQ,EAAEC,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAGxD;YACE,OAAOV;YACP,WAAW;gBACP,WAAWQ,OAAO,SAAS;gBAC3B,IAAIA,OAAO,EAAE;YACjB;YACA,aAAa;QACjB;QAEA,MAAMG,SAASF,UAAU,WAAW;QACpC,IAAI,CAACE,UAAUD,QAAQ,QAAQ;YAC3BE,QAAQ,KAAK,CAAC;gBACVF;YACJ;YACA,MAAM,IAAIG,MAAM;QACpB;QAAO,IAAIF,OAAO,KAAK,EAAE;YACrBC,QAAQ,KAAK,CAAC;gBACV,OAAOD,OAAO,KAAK;YACvB;YACA,MAAM,IAAIE,MAAMF,OAAO,KAAK,CAAC,OAAO,IAAI;QAC5C;QAAO,IAAI,CAACA,OAAO,IAAI,EACnB,OAAO;QAGX,MAAMG,YAAY,MAAMX,OAAO,cAAc,CAACQ;QAC9C,IAAI,CAACG,UAAU,OAAO,EAAE;YACpB,MAAMC,MAAMC,eAAeF,UAAU,KAAK;YAC1CF,QAAQ,KAAK,CAACG;YACdH,QAAQ,GAAG,CACPK,KAAK,SAAS,CAAC;gBACXF;gBACA,IAAID,UAAU,KAAK;YACvB;YAEJ,MAAMC;QACV;QAEA,OAAOD,UAAU,IAAI,CAAC,IAAI;IAC9B;AACJ"}

package/Gateways/SchedulerListGraphQLGateway.d.ts

@@ -0,0 +1,7 @@
+import type { ApolloClient } from "apollo-client";
+import type { IListScheduledActionsGateway, IListScheduledActionsGatewayExecuteParams, IListScheduledActionsGatewayExecuteResponse } from "./abstractions/ListScheduledActionsGateway.js";
+export declare class SchedulerListGraphQLGateway implements IListScheduledActionsGateway {
+    private readonly client;
+    constructor(client: ApolloClient<any>);
+    execute(params: IListScheduledActionsGatewayExecuteParams): Promise<IListScheduledActionsGatewayExecuteResponse>;
+}

package/Gateways/SchedulerListGraphQLGateway.js

@@ -0,0 +1,86 @@
+import graphql_tag from "graphql-tag";
+import zod from "zod";
+import { createZodError } from "@webiny/utils/createZodError.js";
+import { schedulerEntrySchema } from "./schema/schedulerEntry.js";
+import { createSchedulerEntryFields } from "./graphql/fields.js";
+const createListScheduledActionsQuery = ()=>graphql_tag`
+        query ListScheduledActions(
+            $namespace: String!
+            $where: ListScheduledActionsWhereInput
+            $sort: [ListScheduledActionsSorter!]
+            $limit: Int
+            $after: String
+        ) {
+            scheduler {
+                listScheduledActions(
+                    namespace: $namespace
+                    where: $where
+                    sort: $sort
+                    limit: $limit
+                    after: $after
+                ) {
+                    data {
+                        ${createSchedulerEntryFields()}
+                    }
+                    meta {
+                        totalCount
+                        cursor
+                        hasMoreItems
+                    }
+                    error {
+                        message
+                        code
+                        data
+                        stack
+                    }
+                }
+            }
+        }
+    `;
+const schema = zod.object({
+    data: zod.array(schedulerEntrySchema),
+    meta: zod.object({
+        totalCount: zod.number(),
+        cursor: zod.string().nullable(),
+        hasMoreItems: zod.boolean()
+    })
+});
+class SchedulerListGraphQLGateway {
+    constructor(client){
+        this.client = client;
+    }
+    async execute(params) {
+        const { data: response, errors } = await this.client.query({
+            query: createListScheduledActionsQuery(),
+            variables: {
+                namespace: params.namespace,
+                where: params.where,
+                limit: params.limit,
+                after: params.after,
+                sort: params.sort
+            },
+            fetchPolicy: "network-only"
+        });
+        const result = response?.scheduler?.listScheduledActions;
+        if (!result || errors?.length) {
+            console.error({
+                errors
+            });
+            throw new Error("Network error while listing scheduled actions.");
+        }
+        if (!result.data || !result.meta) throw new Error(result.error?.message || "Could not list schedule actions.");
+        const validated = await schema.safeParseAsync(result);
+        if (!validated.success) {
+            const err = createZodError(validated.error);
+            console.error(err);
+            throw err;
+        }
+        return {
+            items: validated.data.data,
+            meta: validated.data.meta
+        };
+    }
+}
+export { SchedulerListGraphQLGateway };
+
+//# sourceMappingURL=SchedulerListGraphQLGateway.js.map

package/Gateways/SchedulerListGraphQLGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Gateways/SchedulerListGraphQLGateway.js","sources":["../../src/Gateways/SchedulerListGraphQLGateway.ts"],"sourcesContent":["import type { ApolloClient } from \"apollo-client\";\nimport gql from \"graphql-tag\";\nimport zod from \"zod\";\nimport { createZodError } from \"@webiny/utils/createZodError.js\";\nimport { schedulerEntrySchema } from \"./schema/schedulerEntry.js\";\nimport { createSchedulerEntryFields } from \"./graphql/fields.js\";\nimport type {\n    IListScheduledActionsGateway,\n    IListScheduledActionsGatewayExecuteParams,\n    IListScheduledActionsGatewayExecuteResponse\n} from \"./abstractions/ListScheduledActionsGateway.js\";\nimport type { SchedulerEntry, SchedulerErrorResponse, SchedulerMetaResponse } from \"~/types.js\";\n\nconst createListScheduledActionsQuery = () => {\n    return gql`\n        query ListScheduledActions(\n            $namespace: String!\n            $where: ListScheduledActionsWhereInput\n            $sort: [ListScheduledActionsSorter!]\n            $limit: Int\n            $after: String\n        ) {\n            scheduler {\n                listScheduledActions(\n                    namespace: $namespace\n                    where: $where\n                    sort: $sort\n                    limit: $limit\n                    after: $after\n                ) {\n                    data {\n                        ${createSchedulerEntryFields()}\n                    }\n                    meta {\n                        totalCount\n                        cursor\n                        hasMoreItems\n                    }\n                    error {\n                        message\n                        code\n                        data\n                        stack\n                    }\n                }\n            }\n        }\n    `;\n};\n\ninterface SchedulerListGraphQLQueryResponse {\n    scheduler: {\n        listScheduledActions: {\n            data: SchedulerEntry[] | null;\n            meta: SchedulerMetaResponse | null;\n            error: SchedulerErrorResponse | null;\n        };\n    };\n}\n\nconst schema = zod.object({\n    data: zod.array(schedulerEntrySchema),\n    meta: zod.object({\n        totalCount: zod.number(),\n        cursor: zod.string().nullable(),\n        hasMoreItems: zod.boolean()\n    })\n});\n\nexport class SchedulerListGraphQLGateway implements IListScheduledActionsGateway {\n    private readonly client: ApolloClient<any>;\n\n    public constructor(client: ApolloClient<any>) {\n        this.client = client;\n    }\n\n    public async execute(\n        params: IListScheduledActionsGatewayExecuteParams\n    ): Promise<IListScheduledActionsGatewayExecuteResponse> {\n        const { data: response, errors } = await this.client.query<\n            SchedulerListGraphQLQueryResponse,\n            IListScheduledActionsGatewayExecuteParams\n        >({\n            query: createListScheduledActionsQuery(),\n            variables: {\n                namespace: params.namespace,\n                where: params.where,\n                limit: params.limit,\n                after: params.after,\n                sort: params.sort\n            },\n            fetchPolicy: \"network-only\"\n        });\n\n        const result = response?.scheduler?.listScheduledActions;\n        if (!result || errors?.length) {\n            console.error({\n                errors\n            });\n            throw new Error(\"Network error while listing scheduled actions.\");\n        }\n\n        if (!result.data || !result.meta) {\n            throw new Error(result.error?.message || \"Could not list schedule actions.\");\n        }\n\n        const validated = await schema.safeParseAsync(result);\n        if (!validated.success) {\n            const err = createZodError(validated.error);\n            console.error(err);\n            throw err;\n        }\n\n        return {\n            items: validated.data.data,\n            meta: validated.data.meta\n        };\n    }\n}\n"],"names":["createListScheduledActionsQuery","gql","createSchedulerEntryFields","schema","zod","schedulerEntrySchema","SchedulerListGraphQLGateway","client","params","response","errors","result","console","Error","validated","err","createZodError"],"mappings":";;;;;AAaA,MAAMA,kCAAkC,IAC7BC,WAAG,CAAC;;;;;;;;;;;;;;;;;wBAiBS,EAAEC,6BAA6B;;;;;;;;;;;;;;;;IAgBnD,CAAC;AAaL,MAAMC,SAASC,IAAI,MAAM,CAAC;IACtB,MAAMA,IAAI,KAAK,CAACC;IAChB,MAAMD,IAAI,MAAM,CAAC;QACb,YAAYA,IAAI,MAAM;QACtB,QAAQA,IAAI,MAAM,GAAG,QAAQ;QAC7B,cAAcA,IAAI,OAAO;IAC7B;AACJ;AAEO,MAAME;IAGT,YAAmBC,MAAyB,CAAE;QAC1C,IAAI,CAAC,MAAM,GAAGA;IAClB;IAEA,MAAa,QACTC,MAAiD,EACG;QACpD,MAAM,EAAE,MAAMC,QAAQ,EAAEC,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAGxD;YACE,OAAOV;YACP,WAAW;gBACP,WAAWQ,OAAO,SAAS;gBAC3B,OAAOA,OAAO,KAAK;gBACnB,OAAOA,OAAO,KAAK;gBACnB,OAAOA,OAAO,KAAK;gBACnB,MAAMA,OAAO,IAAI;YACrB;YACA,aAAa;QACjB;QAEA,MAAMG,SAASF,UAAU,WAAW;QACpC,IAAI,CAACE,UAAUD,QAAQ,QAAQ;YAC3BE,QAAQ,KAAK,CAAC;gBACVF;YACJ;YACA,MAAM,IAAIG,MAAM;QACpB;QAEA,IAAI,CAACF,OAAO,IAAI,IAAI,CAACA,OAAO,IAAI,EAC5B,MAAM,IAAIE,MAAMF,OAAO,KAAK,EAAE,WAAW;QAG7C,MAAMG,YAAY,MAAMX,OAAO,cAAc,CAACQ;QAC9C,IAAI,CAACG,UAAU,OAAO,EAAE;YACpB,MAAMC,MAAMC,eAAeF,UAAU,KAAK;YAC1CF,QAAQ,KAAK,CAACG;YACd,MAAMA;QACV;QAEA,OAAO;YACH,OAAOD,UAAU,IAAI,CAAC,IAAI;YAC1B,MAAMA,UAAU,IAAI,CAAC,IAAI;QAC7B;IACJ;AACJ"}

package/Gateways/SchedulerPublishGraphQLGateway.d.ts

@@ -0,0 +1,7 @@
+import type { ApolloClient } from "apollo-client";
+import type { ISchedulePublishActionGateway, ISchedulePublishActionGatewayExecuteParams, ISchedulePublishActionGatewayExecuteResponse } from "./abstractions/SchedulePublishActionGateway.js";
+export declare class SchedulerPublishGraphQLGateway implements ISchedulePublishActionGateway {
+    private readonly client;
+    constructor(client: ApolloClient<any>);
+    execute(params: ISchedulePublishActionGatewayExecuteParams): Promise<ISchedulePublishActionGatewayExecuteResponse>;
+}

package/Gateways/SchedulerPublishGraphQLGateway.js

@@ -0,0 +1,59 @@
+import zod from "zod";
+import { schedulerEntrySchema } from "./schema/schedulerEntry.js";
+import { createZodError } from "@webiny/utils/createZodError.js";
+import graphql_tag from "graphql-tag";
+import { createSchedulerEntryFields } from "./graphql/fields.js";
+import { ScheduleActionType } from "../types.js";
+const createSchedulePublishActionMutation = ()=>graphql_tag`
+        mutation CreateSchedulePublishAction($namespace: String!, $targetId: ID!, $scheduleFor: DateTime, $actionType: ScheduleRecordType!) {
+            scheduler {
+                scheduleAction(namespace: $namespace, targetId: $targetId, scheduleFor: $scheduleFor, actionType: $actionType) {
+                    data {
+                        ${createSchedulerEntryFields()}
+                    }
+                    error {
+                        message
+                        code
+                        data
+                        stack
+                    }
+                }
+            }
+        }
+    `;
+const schema = zod.object({
+    data: schedulerEntrySchema
+});
+class SchedulerPublishGraphQLGateway {
+    constructor(client){
+        this.client = client;
+    }
+    async execute(params) {
+        const { data: response, errors } = await this.client.mutate({
+            mutation: createSchedulePublishActionMutation(),
+            variables: {
+                namespace: params.namespace,
+                targetId: params.targetId,
+                scheduleFor: params.scheduleOn,
+                actionType: ScheduleActionType.publish
+            },
+            fetchPolicy: "no-cache"
+        });
+        const result = response?.scheduler?.scheduleAction;
+        if (!result || errors?.length) {
+            console.error({
+                errors
+            });
+            throw new Error("Network error while scheduling an action.");
+        }
+        if (!result.data) throw new Error(result.error?.message || "Could execute schedule publish action.");
+        const validated = await schema.safeParseAsync(result);
+        if (!validated.success) throw createZodError(validated.error);
+        return {
+            item: validated.data.data
+        };
+    }
+}
+export { SchedulerPublishGraphQLGateway };
+
+//# sourceMappingURL=SchedulerPublishGraphQLGateway.js.map

package/Gateways/SchedulerPublishGraphQLGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Gateways/SchedulerPublishGraphQLGateway.js","sources":["../../src/Gateways/SchedulerPublishGraphQLGateway.ts"],"sourcesContent":["import type { ApolloClient } from \"apollo-client\";\nimport zod from \"zod\";\nimport { schedulerEntrySchema } from \"./schema/schedulerEntry.js\";\nimport { createZodError } from \"@webiny/utils/createZodError.js\";\nimport gql from \"graphql-tag\";\nimport { createSchedulerEntryFields } from \"./graphql/fields.js\";\nimport { type SchedulerEntry, type SchedulerErrorResponse, ScheduleActionType } from \"~/types.js\";\nimport type {\n    ISchedulePublishActionGateway,\n    ISchedulePublishActionGatewayExecuteParams,\n    ISchedulePublishActionGatewayExecuteResponse\n} from \"./abstractions/SchedulePublishActionGateway.js\";\n\nconst createSchedulePublishActionMutation = () => {\n    return gql`\n        mutation CreateSchedulePublishAction($namespace: String!, $targetId: ID!, $scheduleFor: DateTime, $actionType: ScheduleRecordType!) {\n            scheduler {\n                scheduleAction(namespace: $namespace, targetId: $targetId, scheduleFor: $scheduleFor, actionType: $actionType) {\n                    data {\n                        ${createSchedulerEntryFields()}\n                    }\n                    error {\n                        message\n                        code\n                        data\n                        stack\n                    }\n                }\n            }\n        }\n    `;\n};\n\ninterface SchedulerPublishGraphQLMutationVariables {\n    namespace: string;\n    targetId: string;\n    scheduleFor: Date;\n    actionType: ScheduleActionType.publish;\n}\n\ninterface SchedulerPublishGraphQLMutationResponse {\n    scheduler: {\n        scheduleAction: {\n            data: SchedulerEntry | null;\n            error: SchedulerErrorResponse | null;\n        };\n    };\n}\n\nconst schema = zod.object({\n    data: schedulerEntrySchema\n});\n\nexport class SchedulerPublishGraphQLGateway implements ISchedulePublishActionGateway {\n    private readonly client: ApolloClient<any>;\n\n    public constructor(client: ApolloClient<any>) {\n        this.client = client;\n    }\n\n    public async execute(\n        params: ISchedulePublishActionGatewayExecuteParams\n    ): Promise<ISchedulePublishActionGatewayExecuteResponse> {\n        const { data: response, errors } = await this.client.mutate<\n            SchedulerPublishGraphQLMutationResponse,\n            SchedulerPublishGraphQLMutationVariables\n        >({\n            mutation: createSchedulePublishActionMutation(),\n            variables: {\n                namespace: params.namespace,\n                targetId: params.targetId,\n                scheduleFor: params.scheduleOn,\n                actionType: ScheduleActionType.publish\n            },\n            fetchPolicy: \"no-cache\"\n        });\n\n        const result = response?.scheduler?.scheduleAction;\n        if (!result || errors?.length) {\n            console.error({\n                errors\n            });\n            throw new Error(\"Network error while scheduling an action.\");\n        }\n\n        if (!result.data) {\n            throw new Error(result.error?.message || \"Could execute schedule publish action.\");\n        }\n\n        const validated = await schema.safeParseAsync(result);\n        if (!validated.success) {\n            throw createZodError(validated.error);\n        }\n        return {\n            item: validated.data.data\n        };\n    }\n}\n"],"names":["createSchedulePublishActionMutation","gql","createSchedulerEntryFields","schema","zod","schedulerEntrySchema","SchedulerPublishGraphQLGateway","client","params","response","errors","ScheduleActionType","result","console","Error","validated","createZodError"],"mappings":";;;;;;AAaA,MAAMA,sCAAsC,IACjCC,WAAG,CAAC;;;;;wBAKS,EAAEC,6BAA6B;;;;;;;;;;;IAWnD,CAAC;AAmBL,MAAMC,SAASC,IAAI,MAAM,CAAC;IACtB,MAAMC;AACV;AAEO,MAAMC;IAGT,YAAmBC,MAAyB,CAAE;QAC1C,IAAI,CAAC,MAAM,GAAGA;IAClB;IAEA,MAAa,QACTC,MAAkD,EACG;QACrD,MAAM,EAAE,MAAMC,QAAQ,EAAEC,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAGzD;YACE,UAAUV;YACV,WAAW;gBACP,WAAWQ,OAAO,SAAS;gBAC3B,UAAUA,OAAO,QAAQ;gBACzB,aAAaA,OAAO,UAAU;gBAC9B,YAAYG,mBAAmB,OAAO;YAC1C;YACA,aAAa;QACjB;QAEA,MAAMC,SAASH,UAAU,WAAW;QACpC,IAAI,CAACG,UAAUF,QAAQ,QAAQ;YAC3BG,QAAQ,KAAK,CAAC;gBACVH;YACJ;YACA,MAAM,IAAII,MAAM;QACpB;QAEA,IAAI,CAACF,OAAO,IAAI,EACZ,MAAM,IAAIE,MAAMF,OAAO,KAAK,EAAE,WAAW;QAG7C,MAAMG,YAAY,MAAMZ,OAAO,cAAc,CAACS;QAC9C,IAAI,CAACG,UAAU,OAAO,EAClB,MAAMC,eAAeD,UAAU,KAAK;QAExC,OAAO;YACH,MAAMA,UAAU,IAAI,CAAC,IAAI;QAC7B;IACJ;AACJ"}

package/Gateways/SchedulerUnpublishGraphQLGateway.d.ts

@@ -0,0 +1,23 @@
+import type { ApolloClient } from "apollo-client";
+import { ScheduleActionType } from "../types.js";
+import type { IScheduleUnpublishActionGateway, IScheduleUnpublishActionGatewayExecuteParams } from "./abstractions/ScheduleUnpublishActionGateway.js";
+export declare class SchedulerUnpublishGraphQLGateway implements IScheduleUnpublishActionGateway {
+    private readonly client;
+    constructor(client: ApolloClient<any>);
+    execute(params: IScheduleUnpublishActionGatewayExecuteParams): Promise<{
+        item: {
+            id: string;
+            targetId: string;
+            namespace: string;
+            scheduledBy: {
+                id: string;
+                displayName: string;
+                type: string;
+            };
+            publishOn: Date | undefined;
+            unpublishOn: Date | undefined;
+            actionType: ScheduleActionType;
+            title: string;
+        };
+    }>;
+}

package/Gateways/SchedulerUnpublishGraphQLGateway.js

@@ -0,0 +1,63 @@
+import zod from "zod";
+import { schedulerEntrySchema } from "./schema/schedulerEntry.js";
+import { createZodError } from "@webiny/utils/createZodError.js";
+import graphql_tag from "graphql-tag";
+import { createSchedulerEntryFields } from "./graphql/fields.js";
+import { ScheduleActionType } from "../types.js";
+const createScheduleUnpublishActionMutation = ()=>graphql_tag`
+        mutation ScheduleUnpublishAction($namespace: String!, $targetId: ID!, $scheduleFor: DateTime, $actionType: ScheduleRecordType!) {
+            scheduler {
+                scheduleAction(namespace: $namespace, targetId: $targetId, scheduleFor: $scheduleFor, actionType: $actionType) {
+                    data {
+                        ${createSchedulerEntryFields()}
+                    }
+                    error {
+                        message
+                        code
+                        data
+                        stack
+                    }
+                }
+            }
+        }
+    `;
+const schema = zod.object({
+    data: schedulerEntrySchema
+});
+class SchedulerUnpublishGraphQLGateway {
+    constructor(client){
+        this.client = client;
+    }
+    async execute(params) {
+        const { data: response, errors } = await this.client.mutate({
+            mutation: createScheduleUnpublishActionMutation(),
+            variables: {
+                namespace: params.namespace,
+                targetId: params.targetId,
+                scheduleFor: params.scheduleOn,
+                actionType: ScheduleActionType.unpublish
+            },
+            fetchPolicy: "no-cache"
+        });
+        const result = response?.scheduler?.scheduleAction;
+        if (!result || errors?.length) {
+            console.error({
+                errors
+            });
+            throw new Error("Network error while creating a schedule.");
+        }
+        if (!result.data) throw new Error(result.error?.message || "Could execute schedule unpublish action.");
+        const validated = await schema.safeParseAsync(result);
+        if (!validated.success) {
+            const err = createZodError(validated.error);
+            console.error(err);
+            throw err;
+        }
+        return {
+            item: validated.data.data
+        };
+    }
+}
+export { SchedulerUnpublishGraphQLGateway };
+
+//# sourceMappingURL=SchedulerUnpublishGraphQLGateway.js.map

package/Gateways/SchedulerUnpublishGraphQLGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Gateways/SchedulerUnpublishGraphQLGateway.js","sources":["../../src/Gateways/SchedulerUnpublishGraphQLGateway.ts"],"sourcesContent":["import type { ApolloClient } from \"apollo-client\";\nimport zod from \"zod\";\nimport { schedulerEntrySchema } from \"./schema/schedulerEntry.js\";\nimport { createZodError } from \"@webiny/utils/createZodError.js\";\nimport gql from \"graphql-tag\";\nimport { createSchedulerEntryFields } from \"./graphql/fields.js\";\nimport { type SchedulerEntry, type SchedulerErrorResponse, ScheduleActionType } from \"~/types.js\";\nimport type {\n    IScheduleUnpublishActionGateway,\n    IScheduleUnpublishActionGatewayExecuteParams\n} from \"./abstractions/ScheduleUnpublishActionGateway.js\";\n\nconst createScheduleUnpublishActionMutation = () => {\n    return gql`\n        mutation ScheduleUnpublishAction($namespace: String!, $targetId: ID!, $scheduleFor: DateTime, $actionType: ScheduleRecordType!) {\n            scheduler {\n                scheduleAction(namespace: $namespace, targetId: $targetId, scheduleFor: $scheduleFor, actionType: $actionType) {\n                    data {\n                        ${createSchedulerEntryFields()}\n                    }\n                    error {\n                        message\n                        code\n                        data\n                        stack\n                    }\n                }\n            }\n        }\n    `;\n};\n\ninterface SchedulerUnpublishGraphQLMutationVariables {\n    namespace: string;\n    targetId: string;\n    scheduleFor: Date;\n    actionType: ScheduleActionType.unpublish;\n}\n\ninterface SchedulerUnpublishGraphQLMutationResponse {\n    scheduler: {\n        scheduleAction: {\n            data: SchedulerEntry | null;\n            error: SchedulerErrorResponse | null;\n        };\n    };\n}\n\nconst schema = zod.object({\n    data: schedulerEntrySchema\n});\n\nexport class SchedulerUnpublishGraphQLGateway implements IScheduleUnpublishActionGateway {\n    private readonly client: ApolloClient<any>;\n\n    public constructor(client: ApolloClient<any>) {\n        this.client = client;\n    }\n\n    public async execute(params: IScheduleUnpublishActionGatewayExecuteParams) {\n        const { data: response, errors } = await this.client.mutate<\n            SchedulerUnpublishGraphQLMutationResponse,\n            SchedulerUnpublishGraphQLMutationVariables\n        >({\n            mutation: createScheduleUnpublishActionMutation(),\n            variables: {\n                namespace: params.namespace,\n                targetId: params.targetId,\n                scheduleFor: params.scheduleOn,\n                actionType: ScheduleActionType.unpublish\n            },\n            fetchPolicy: \"no-cache\"\n        });\n\n        const result = response?.scheduler?.scheduleAction;\n        if (!result || errors?.length) {\n            console.error({\n                errors\n            });\n            throw new Error(\"Network error while creating a schedule.\");\n        }\n\n        if (!result.data) {\n            throw new Error(result.error?.message || \"Could execute schedule unpublish action.\");\n        }\n\n        const validated = await schema.safeParseAsync(result);\n        if (!validated.success) {\n            const err = createZodError(validated.error);\n            console.error(err);\n            throw err;\n        }\n        return {\n            item: validated.data.data\n        };\n    }\n}\n"],"names":["createScheduleUnpublishActionMutation","gql","createSchedulerEntryFields","schema","zod","schedulerEntrySchema","SchedulerUnpublishGraphQLGateway","client","params","response","errors","ScheduleActionType","result","console","Error","validated","err","createZodError"],"mappings":";;;;;;AAYA,MAAMA,wCAAwC,IACnCC,WAAG,CAAC;;;;;wBAKS,EAAEC,6BAA6B;;;;;;;;;;;IAWnD,CAAC;AAmBL,MAAMC,SAASC,IAAI,MAAM,CAAC;IACtB,MAAMC;AACV;AAEO,MAAMC;IAGT,YAAmBC,MAAyB,CAAE;QAC1C,IAAI,CAAC,MAAM,GAAGA;IAClB;IAEA,MAAa,QAAQC,MAAoD,EAAE;QACvE,MAAM,EAAE,MAAMC,QAAQ,EAAEC,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAGzD;YACE,UAAUV;YACV,WAAW;gBACP,WAAWQ,OAAO,SAAS;gBAC3B,UAAUA,OAAO,QAAQ;gBACzB,aAAaA,OAAO,UAAU;gBAC9B,YAAYG,mBAAmB,SAAS;YAC5C;YACA,aAAa;QACjB;QAEA,MAAMC,SAASH,UAAU,WAAW;QACpC,IAAI,CAACG,UAAUF,QAAQ,QAAQ;YAC3BG,QAAQ,KAAK,CAAC;gBACVH;YACJ;YACA,MAAM,IAAII,MAAM;QACpB;QAEA,IAAI,CAACF,OAAO,IAAI,EACZ,MAAM,IAAIE,MAAMF,OAAO,KAAK,EAAE,WAAW;QAG7C,MAAMG,YAAY,MAAMZ,OAAO,cAAc,CAACS;QAC9C,IAAI,CAACG,UAAU,OAAO,EAAE;YACpB,MAAMC,MAAMC,eAAeF,UAAU,KAAK;YAC1CF,QAAQ,KAAK,CAACG;YACd,MAAMA;QACV;QACA,OAAO;YACH,MAAMD,UAAU,IAAI,CAAC,IAAI;QAC7B;IACJ;AACJ"}

package/Gateways/abstractions/CancelScheduledActionGateway.d.ts

@@ -0,0 +1,7 @@
+export interface ICancelScheduledActionGatewayParams {
+    namespace: string;
+    id: string;
+}
+export interface ICancelScheduledActionGateway {
+    execute(params: ICancelScheduledActionGatewayParams): Promise<void>;
+}

package/Gateways/abstractions/GetScheduledActionGateway.d.ts

@@ -0,0 +1,9 @@
+import type { SchedulerEntry } from "../../types.js";
+export interface IGetScheduledActionGatewayExecuteParams {
+    namespace: string;
+    id: string;
+}
+export type IGetScheduledActionGatewayResponse = SchedulerEntry | null;
+export interface IGetScheduledActionGateway {
+    execute(params: IGetScheduledActionGatewayExecuteParams): Promise<IGetScheduledActionGatewayResponse>;
+}

package/Gateways/abstractions/ListScheduledActionsGateway.d.ts

@@ -0,0 +1,27 @@
+import type { SchedulerEntry, SchedulerMetaResponse } from "../../types.js";
+import type { ScheduleActionType } from "../../types.js";
+export interface IListScheduledActionsExecuteParamsWhere {
+    targetId?: string;
+    title_contains?: string;
+    title_not_contains?: string;
+    type?: ScheduleActionType;
+    scheduledBy?: string;
+    scheduledFor?: Date;
+    scheduledFor_gte?: Date;
+    scheduledFor_lte?: Date;
+}
+export type IListScheduledActionsExecuteParamsSort = "scheduledFor_ASC" | "scheduledFor_DESC";
+export interface IListScheduledActionsGatewayExecuteParams {
+    namespace: string;
+    where?: IListScheduledActionsExecuteParamsWhere;
+    sort?: IListScheduledActionsExecuteParamsSort[];
+    limit?: number;
+    after?: string;
+}
+export interface IListScheduledActionsGatewayExecuteResponse {
+    items: SchedulerEntry[];
+    meta: SchedulerMetaResponse;
+}
+export interface IListScheduledActionsGateway {
+    execute(params: IListScheduledActionsGatewayExecuteParams): Promise<IListScheduledActionsGatewayExecuteResponse>;
+}

package/Gateways/abstractions/SchedulePublishActionGateway.d.ts

@@ -0,0 +1,12 @@
+import type { SchedulerEntry } from "../../types.js";
+export interface ISchedulePublishActionGatewayExecuteParams {
+    namespace: string;
+    targetId: string;
+    scheduleOn: Date;
+}
+export interface ISchedulePublishActionGatewayExecuteResponse {
+    item: SchedulerEntry;
+}
+export interface ISchedulePublishActionGateway {
+    execute(params: ISchedulePublishActionGatewayExecuteParams): Promise<ISchedulePublishActionGatewayExecuteResponse>;
+}

package/Gateways/abstractions/ScheduleUnpublishActionGateway.d.ts

@@ -0,0 +1,12 @@
+import type { SchedulerEntry } from "../../types.js";
+export interface IScheduleUnpublishActionGatewayExecuteParams {
+    namespace: string;
+    targetId: string;
+    scheduleOn: Date;
+}
+export interface IScheduleUnpublishActionGatewayExecuteResponse {
+    item: SchedulerEntry;
+}
+export interface IScheduleUnpublishActionGateway {
+    execute(params: IScheduleUnpublishActionGatewayExecuteParams): Promise<IScheduleUnpublishActionGatewayExecuteResponse>;
+}

package/Gateways/graphql/fields.d.ts

@@ -0,0 +1 @@
+export declare const createSchedulerEntryFields: () => string;

package/Gateways/graphql/fields.js

@@ -0,0 +1,17 @@
+const createSchedulerEntryFields = ()=>`
+        id
+        targetId
+        namespace
+        scheduledBy {
+            id
+            displayName
+            type
+        }
+        publishOn
+        unpublishOn
+        actionType
+        title
+    `;
+export { createSchedulerEntryFields };
+
+//# sourceMappingURL=fields.js.map

package/Gateways/graphql/fields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Gateways/graphql/fields.js","sources":["../../../src/Gateways/graphql/fields.ts"],"sourcesContent":["export const createSchedulerEntryFields = (): string => {\n    return `\n        id\n        targetId\n        namespace\n        scheduledBy {\n            id\n            displayName\n            type\n        }\n        publishOn\n        unpublishOn\n        actionType\n        title\n    `;\n};\n"],"names":["createSchedulerEntryFields"],"mappings":"AAAO,MAAMA,6BAA6B,IAC/B,CAAC;;;;;;;;;;;;;IAaR,CAAC"}

package/Gateways/index.d.ts

@@ -0,0 +1,5 @@
+export type { ICancelScheduledActionGatewayParams, ICancelScheduledActionGateway } from "./abstractions/CancelScheduledActionGateway.js";
+export type { IGetScheduledActionGatewayExecuteParams, IGetScheduledActionGateway, IGetScheduledActionGatewayResponse } from "./abstractions/GetScheduledActionGateway.js";
+export type { IListScheduledActionsGatewayExecuteParams, IListScheduledActionsExecuteParamsSort, IListScheduledActionsExecuteParamsWhere, IListScheduledActionsGateway, IListScheduledActionsGatewayExecuteResponse } from "./abstractions/ListScheduledActionsGateway.js";
+export type { ISchedulePublishActionGatewayExecuteParams, ISchedulePublishActionGateway, ISchedulePublishActionGatewayExecuteResponse } from "./abstractions/SchedulePublishActionGateway.js";
+export type { IScheduleUnpublishActionGatewayExecuteParams, IScheduleUnpublishActionGateway, IScheduleUnpublishActionGatewayExecuteResponse } from "./abstractions/ScheduleUnpublishActionGateway.js";

package/Gateways/schema/schedulerEntry.d.ts

@@ -0,0 +1,16 @@
+import zod from "zod";
+import { ScheduleActionType } from "../../types.js";
+export declare const schedulerEntrySchema: zod.ZodObject<{
+    id: zod.ZodString;
+    targetId: zod.ZodString;
+    namespace: zod.ZodString;
+    scheduledBy: zod.ZodObject<{
+        id: zod.ZodString;
+        displayName: zod.ZodString;
+        type: zod.ZodString;
+    }, zod.core.$strip>;
+    publishOn: zod.ZodPipe<zod.ZodOptional<zod.ZodNullable<zod.ZodString>>, zod.ZodTransform<Date | undefined, string | null | undefined>>;
+    unpublishOn: zod.ZodPipe<zod.ZodOptional<zod.ZodNullable<zod.ZodString>>, zod.ZodTransform<Date | undefined, string | null | undefined>>;
+    actionType: zod.ZodEnum<typeof ScheduleActionType>;
+    title: zod.ZodString;
+}, zod.core.$strip>;

package/Gateways/schema/schedulerEntry.js

@@ -0,0 +1,19 @@
+import zod from "zod";
+import { ScheduleActionType } from "../../types.js";
+const schedulerEntrySchema = zod.object({
+    id: zod.string(),
+    targetId: zod.string(),
+    namespace: zod.string(),
+    scheduledBy: zod.object({
+        id: zod.string(),
+        displayName: zod.string(),
+        type: zod.string()
+    }),
+    publishOn: zod.string().nullable().optional().transform((value)=>value ? new Date(value) : void 0),
+    unpublishOn: zod.string().nullable().optional().transform((value)=>value ? new Date(value) : void 0),
+    actionType: zod["enum"](ScheduleActionType),
+    title: zod.string()
+});
+export { schedulerEntrySchema };
+
+//# sourceMappingURL=schedulerEntry.js.map

package/Gateways/schema/schedulerEntry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Gateways/schema/schedulerEntry.js","sources":["../../../src/Gateways/schema/schedulerEntry.ts"],"sourcesContent":["import zod from \"zod\";\nimport { ScheduleActionType } from \"~/types.js\";\n\nexport const schedulerEntrySchema = zod.object({\n    id: zod.string(),\n    targetId: zod.string(),\n    namespace: zod.string(),\n    scheduledBy: zod.object({\n        id: zod.string(),\n        displayName: zod.string(),\n        type: zod.string()\n    }),\n    publishOn: zod\n        .string()\n        .nullable()\n        .optional()\n        .transform(value => {\n            return !!value ? new Date(value) : undefined;\n        }),\n    unpublishOn: zod\n        .string()\n        .nullable()\n        .optional()\n        .transform(value => {\n            return !!value ? new Date(value) : undefined;\n        }),\n    actionType: zod.enum(ScheduleActionType),\n    title: zod.string()\n});\n"],"names":["schedulerEntrySchema","zod","value","Date","undefined","ScheduleActionType"],"mappings":";;AAGO,MAAMA,uBAAuBC,IAAI,MAAM,CAAC;IAC3C,IAAIA,IAAI,MAAM;IACd,UAAUA,IAAI,MAAM;IACpB,WAAWA,IAAI,MAAM;IACrB,aAAaA,IAAI,MAAM,CAAC;QACpB,IAAIA,IAAI,MAAM;QACd,aAAaA,IAAI,MAAM;QACvB,MAAMA,IAAI,MAAM;IACpB;IACA,WAAWA,IAAAA,MACA,GACN,QAAQ,GACR,QAAQ,GACR,SAAS,CAACC,CAAAA,QACA,AAAEA,QAAQ,IAAIC,KAAKD,SAASE;IAE3C,aAAaH,IAAAA,MACF,GACN,QAAQ,GACR,QAAQ,GACR,SAAS,CAACC,CAAAA,QACA,AAAEA,QAAQ,IAAIC,KAAKD,SAASE;IAE3C,YAAYH,GAAG,CAAHA,OAAQ,CAACI;IACrB,OAAOJ,IAAI,MAAM;AACrB"}