@incident-io/pulumi 0.1.0-alpha.1

package/scheduleRotation.d.ts

@@ -0,0 +1,287 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as inputs from "./types/input";
+import * as outputs from "./types/output";
+/**
+ * Manage a rotation on an on-call schedule.
+ *
+ * A rotation is a group of people who take turns being on call, and the cadence they
+ * hand over on. A schedule can hold several, and each is managed independently — so
+ * changing one never rewrites the others.
+ *
+ * Editing a rotation takes effect straight away, unless `rollout` says otherwise.
+ *
+ * ## Changing when shifts hand over
+ *
+ * `firstIntervalStartsAt` is the point intervals are counted from. With
+ * `handovers` it fixes the time of day and day of week that shifts change hands —
+ * the dashboard calls it the handover time.
+ *
+ * It can't change in the same apply as `rollout`. Whenever `rollout` is set the
+ * rotation keeps the interval start it already runs: an immediate rollout copies that
+ * across so the cadence doesn't move, and a phased one works backwards from the next
+ * handover so the new line-up slots into the rhythm people are already working. Either
+ * way a new `firstIntervalStartsAt` is discarded, so the provider stops the apply
+ * rather than storing a value that won't be kept.
+ *
+ * To change both, take it in two applies:
+ *
+ * 1. Change `firstIntervalStartsAt` on its own, with `rollout` unset. The new
+ *    cadence takes effect straight away.
+ * 2. Then make the line-up change, with `rollout` set.
+ *
+ * ## Choosing a scheduling mode
+ *
+ * `schedulingMode` decides who takes the next shift.
+ *
+ * `fair` shares time on call out evenly, tracking how much each person has already
+ * done and giving the next shift to whoever is behind. Someone newly added has done
+ * none, so `fair` tends to bring them on call sooner rather than adding them to
+ * the back of the queue.
+ *
+ * `sequential` goes around the list in order, so the next person on call is always
+ * the one after the last.
+ *
+ * For an even rotation — everyone on for the same length of time, no working hours,
+ * nobody joining or leaving — the two behave identically. They only diverge once
+ * shifts differ in length, `workingIntervals` is set, or the list of users
+ * changes. Reach for `sequential` when it matters that the running order is
+ * obvious to the people in it.
+ *
+ * ## Upgrading from v6
+ *
+ * Before v7, a rotation was declared inline on `incident.Schedule`, in its
+ * `rotations` attribute. It is now its own resource. See `incident.Schedule`
+ * for what that changes and how to import the rotations you already have.
+ *
+ * ## Example Usage
+ *
+ * ```typescript
+ * import * as pulumi from "@pulumi/pulumi";
+ * import * as incident from "@incident-io/pulumi";
+ *
+ * // A rotation is a group of people who take turns being on call. Each one is managed
+ * // on its own, so editing this rotation doesn't touch the others on the schedule.
+ * const primary = new incident.ScheduleRotation("primary", {
+ *     scheduleId: platform.id,
+ *     name: "Primary",
+ *     users: [
+ *         alice.id,
+ *         bob.id,
+ *     ],
+ *     firstIntervalStartsAt: "2024-01-08T09:00:00Z",
+ *     handovers: [{
+ *         interval: 1,
+ *         intervalType: "weekly",
+ *     }],
+ * });
+ * // A rotation that only covers weekday working hours, with two people on call at
+ * // once and a place in the schedule's running order.
+ * const businessHours = new incident.ScheduleRotation("business_hours", {
+ *     scheduleId: platform.id,
+ *     name: "Business hours",
+ *     rank: 2,
+ *     users: [
+ *         alice.id,
+ *         bob.id,
+ *         carol.id,
+ *     ],
+ *     firstIntervalStartsAt: "2024-01-08T09:00:00Z",
+ *     handovers: [{
+ *         interval: 1,
+ *         intervalType: "daily",
+ *     }],
+ *     concurrentShifts: 2,
+ *     workingIntervals: [
+ *         {
+ *             weekday: "monday",
+ *             startTime: "09:00",
+ *             endTime: "17:00",
+ *         },
+ *         {
+ *             weekday: "tuesday",
+ *             startTime: "09:00",
+ *             endTime: "17:00",
+ *         },
+ *         {
+ *             weekday: "wednesday",
+ *             startTime: "09:00",
+ *             endTime: "17:00",
+ *         },
+ *         {
+ *             weekday: "thursday",
+ *             startTime: "09:00",
+ *             endTime: "17:00",
+ *         },
+ *         {
+ *             weekday: "friday",
+ *             startTime: "09:00",
+ *             endTime: "17:00",
+ *         },
+ *     ],
+ * });
+ * ```
+ */
+export declare class ScheduleRotation extends pulumi.CustomResource {
+    /**
+     * Get an existing ScheduleRotation resource's state with the given name, ID, and optional extra
+     * properties used to qualify the lookup.
+     *
+     * @param name The _unique_ name of the resulting resource.
+     * @param id The _unique_ provider ID of the resource to lookup.
+     * @param state Any extra arguments used during the lookup.
+     * @param opts Optional settings to control the behavior of the CustomResource.
+     */
+    static get(name: string, id: pulumi.Input<pulumi.ID>, state?: ScheduleRotationState, opts?: pulumi.CustomResourceOptions): ScheduleRotation;
+    /**
+     * Returns true if the given object is an instance of ScheduleRotation.  This is designed to work even
+     * when multiple copies of the Pulumi SDK have been loaded into the same process.
+     */
+    static isInstance(obj: any): obj is ScheduleRotation;
+    /**
+     * How many shifts run at the same time, which is how many people are on call at once. Defaults to 1, one person on call at a time. Reducing this stops scheduling the last of them, and stops any overrides on those shifts from applying.
+     */
+    readonly concurrentShifts: pulumi.Output<number>;
+    /**
+     * When this shape of the rotation took over. Unset when the rotation has only ever had one.
+     */
+    readonly effectiveFrom: pulumi.Output<string>;
+    /**
+     * When the first handover interval starts being counted from, which fixes the time of day and day of week shifts change hands. The dashboard calls this the handover time.. Can't be changed in the same apply as `rollout` — see the resource description for why, and what to do instead.
+     */
+    readonly firstIntervalStartsAt: pulumi.Output<string>;
+    /**
+     * The cadence shifts hand over on, applied in turn
+     */
+    readonly handovers: pulumi.Output<outputs.ScheduleRotationHandover[]>;
+    /**
+     * Human readable name for the rotation, unique within the schedule
+     */
+    readonly name: pulumi.Output<string>;
+    /**
+     * Where this rotation sits in the schedule's running order, lowest first. Unset when it has never been ordered.
+     */
+    readonly rank: pulumi.Output<number | undefined>;
+    /**
+     * How a change to this rotation is introduced: `immediate` replaces the line-up now and can change who is on call this minute, `afterCurrentShift` lets the shift on call finish first, and `afterFullRotation` waits for everyone to have taken a turn. Leave it out to replace the line-up straight away. Creating a rotation ignores it, as there's no shift to protect yet.
+     */
+    readonly rollout: pulumi.Output<string | undefined>;
+    /**
+     * ID of the schedule this rotation belongs to. Changing this replaces the rotation, as a rotation can't move between schedules.
+     */
+    readonly scheduleId: pulumi.Output<string>;
+    /**
+     * How users are allocated across shifts of differing length. Possible values are: `fair`, `sequential`. Omit it to leave us to pick. For an even rotation the two behave identically — see the resource description for when they diverge.
+     */
+    readonly schedulingMode: pulumi.Output<string | undefined>;
+    /**
+     * IDs of the people in the rotation, in the order they take shifts. Use the special ID `NOBODY` for a slot with nobody in it, which schedules the shift without putting anyone on call until an override covers it.
+     */
+    readonly users: pulumi.Output<string[]>;
+    /**
+     * If set, restricts on-call to these weekday intervals. Omit it to keep the rotation on call around the clock. An empty list is not valid, and is rejected at plan time — it would leave a rotation nobody is ever on call for.
+     */
+    readonly workingIntervals: pulumi.Output<outputs.ScheduleRotationWorkingInterval[] | undefined>;
+    /**
+     * Create a ScheduleRotation resource with the given unique name, arguments, and options.
+     *
+     * @param name The _unique_ name of the resource.
+     * @param args The arguments to use to populate this resource's properties.
+     * @param opts A bag of options that control this resource's behavior.
+     */
+    constructor(name: string, args: ScheduleRotationArgs, opts?: pulumi.CustomResourceOptions);
+}
+/**
+ * Input properties used for looking up and filtering ScheduleRotation resources.
+ */
+export interface ScheduleRotationState {
+    /**
+     * How many shifts run at the same time, which is how many people are on call at once. Defaults to 1, one person on call at a time. Reducing this stops scheduling the last of them, and stops any overrides on those shifts from applying.
+     */
+    concurrentShifts?: pulumi.Input<number | undefined>;
+    /**
+     * When this shape of the rotation took over. Unset when the rotation has only ever had one.
+     */
+    effectiveFrom?: pulumi.Input<string | undefined>;
+    /**
+     * When the first handover interval starts being counted from, which fixes the time of day and day of week shifts change hands. The dashboard calls this the handover time.. Can't be changed in the same apply as `rollout` — see the resource description for why, and what to do instead.
+     */
+    firstIntervalStartsAt?: pulumi.Input<string | undefined>;
+    /**
+     * The cadence shifts hand over on, applied in turn
+     */
+    handovers?: pulumi.Input<pulumi.Input<inputs.ScheduleRotationHandover>[] | undefined>;
+    /**
+     * Human readable name for the rotation, unique within the schedule
+     */
+    name?: pulumi.Input<string | undefined>;
+    /**
+     * Where this rotation sits in the schedule's running order, lowest first. Unset when it has never been ordered.
+     */
+    rank?: pulumi.Input<number | undefined>;
+    /**
+     * How a change to this rotation is introduced: `immediate` replaces the line-up now and can change who is on call this minute, `afterCurrentShift` lets the shift on call finish first, and `afterFullRotation` waits for everyone to have taken a turn. Leave it out to replace the line-up straight away. Creating a rotation ignores it, as there's no shift to protect yet.
+     */
+    rollout?: pulumi.Input<string | undefined>;
+    /**
+     * ID of the schedule this rotation belongs to. Changing this replaces the rotation, as a rotation can't move between schedules.
+     */
+    scheduleId?: pulumi.Input<string | undefined>;
+    /**
+     * How users are allocated across shifts of differing length. Possible values are: `fair`, `sequential`. Omit it to leave us to pick. For an even rotation the two behave identically — see the resource description for when they diverge.
+     */
+    schedulingMode?: pulumi.Input<string | undefined>;
+    /**
+     * IDs of the people in the rotation, in the order they take shifts. Use the special ID `NOBODY` for a slot with nobody in it, which schedules the shift without putting anyone on call until an override covers it.
+     */
+    users?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+    /**
+     * If set, restricts on-call to these weekday intervals. Omit it to keep the rotation on call around the clock. An empty list is not valid, and is rejected at plan time — it would leave a rotation nobody is ever on call for.
+     */
+    workingIntervals?: pulumi.Input<pulumi.Input<inputs.ScheduleRotationWorkingInterval>[] | undefined>;
+}
+/**
+ * The set of arguments for constructing a ScheduleRotation resource.
+ */
+export interface ScheduleRotationArgs {
+    /**
+     * How many shifts run at the same time, which is how many people are on call at once. Defaults to 1, one person on call at a time. Reducing this stops scheduling the last of them, and stops any overrides on those shifts from applying.
+     */
+    concurrentShifts?: pulumi.Input<number | undefined>;
+    /**
+     * When the first handover interval starts being counted from, which fixes the time of day and day of week shifts change hands. The dashboard calls this the handover time.. Can't be changed in the same apply as `rollout` — see the resource description for why, and what to do instead.
+     */
+    firstIntervalStartsAt: pulumi.Input<string>;
+    /**
+     * The cadence shifts hand over on, applied in turn
+     */
+    handovers: pulumi.Input<pulumi.Input<inputs.ScheduleRotationHandover>[]>;
+    /**
+     * Human readable name for the rotation, unique within the schedule
+     */
+    name?: pulumi.Input<string | undefined>;
+    /**
+     * Where this rotation sits in the schedule's running order, lowest first. Unset when it has never been ordered.
+     */
+    rank?: pulumi.Input<number | undefined>;
+    /**
+     * How a change to this rotation is introduced: `immediate` replaces the line-up now and can change who is on call this minute, `afterCurrentShift` lets the shift on call finish first, and `afterFullRotation` waits for everyone to have taken a turn. Leave it out to replace the line-up straight away. Creating a rotation ignores it, as there's no shift to protect yet.
+     */
+    rollout?: pulumi.Input<string | undefined>;
+    /**
+     * ID of the schedule this rotation belongs to. Changing this replaces the rotation, as a rotation can't move between schedules.
+     */
+    scheduleId: pulumi.Input<string>;
+    /**
+     * How users are allocated across shifts of differing length. Possible values are: `fair`, `sequential`. Omit it to leave us to pick. For an even rotation the two behave identically — see the resource description for when they diverge.
+     */
+    schedulingMode?: pulumi.Input<string | undefined>;
+    /**
+     * IDs of the people in the rotation, in the order they take shifts. Use the special ID `NOBODY` for a slot with nobody in it, which schedules the shift without putting anyone on call until an override covers it.
+     */
+    users: pulumi.Input<pulumi.Input<string>[]>;
+    /**
+     * If set, restricts on-call to these weekday intervals. Omit it to keep the rotation on call around the clock. An empty list is not valid, and is rejected at plan time — it would leave a rotation nobody is ever on call for.
+     */
+    workingIntervals?: pulumi.Input<pulumi.Input<inputs.ScheduleRotationWorkingInterval>[] | undefined>;
+}
+//# sourceMappingURL=scheduleRotation.d.ts.map

package/scheduleRotation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduleRotation.d.ts","sourceRoot":"","sources":["../scheduleRotation.ts"],"names":[],"mappings":"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"}

package/scheduleRotation.js

@@ -0,0 +1,224 @@
+"use strict";
+// *** WARNING: this file was generated by pulumi-language-nodejs. ***
+// *** Do not edit by hand unless you're certain you know what you are doing! ***
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScheduleRotation = void 0;
+const pulumi = __importStar(require("@pulumi/pulumi"));
+const utilities = __importStar(require("./utilities"));
+/**
+ * Manage a rotation on an on-call schedule.
+ *
+ * A rotation is a group of people who take turns being on call, and the cadence they
+ * hand over on. A schedule can hold several, and each is managed independently — so
+ * changing one never rewrites the others.
+ *
+ * Editing a rotation takes effect straight away, unless `rollout` says otherwise.
+ *
+ * ## Changing when shifts hand over
+ *
+ * `firstIntervalStartsAt` is the point intervals are counted from. With
+ * `handovers` it fixes the time of day and day of week that shifts change hands —
+ * the dashboard calls it the handover time.
+ *
+ * It can't change in the same apply as `rollout`. Whenever `rollout` is set the
+ * rotation keeps the interval start it already runs: an immediate rollout copies that
+ * across so the cadence doesn't move, and a phased one works backwards from the next
+ * handover so the new line-up slots into the rhythm people are already working. Either
+ * way a new `firstIntervalStartsAt` is discarded, so the provider stops the apply
+ * rather than storing a value that won't be kept.
+ *
+ * To change both, take it in two applies:
+ *
+ * 1. Change `firstIntervalStartsAt` on its own, with `rollout` unset. The new
+ *    cadence takes effect straight away.
+ * 2. Then make the line-up change, with `rollout` set.
+ *
+ * ## Choosing a scheduling mode
+ *
+ * `schedulingMode` decides who takes the next shift.
+ *
+ * `fair` shares time on call out evenly, tracking how much each person has already
+ * done and giving the next shift to whoever is behind. Someone newly added has done
+ * none, so `fair` tends to bring them on call sooner rather than adding them to
+ * the back of the queue.
+ *
+ * `sequential` goes around the list in order, so the next person on call is always
+ * the one after the last.
+ *
+ * For an even rotation — everyone on for the same length of time, no working hours,
+ * nobody joining or leaving — the two behave identically. They only diverge once
+ * shifts differ in length, `workingIntervals` is set, or the list of users
+ * changes. Reach for `sequential` when it matters that the running order is
+ * obvious to the people in it.
+ *
+ * ## Upgrading from v6
+ *
+ * Before v7, a rotation was declared inline on `incident.Schedule`, in its
+ * `rotations` attribute. It is now its own resource. See `incident.Schedule`
+ * for what that changes and how to import the rotations you already have.
+ *
+ * ## Example Usage
+ *
+ * ```typescript
+ * import * as pulumi from "@pulumi/pulumi";
+ * import * as incident from "@incident-io/pulumi";
+ *
+ * // A rotation is a group of people who take turns being on call. Each one is managed
+ * // on its own, so editing this rotation doesn't touch the others on the schedule.
+ * const primary = new incident.ScheduleRotation("primary", {
+ *     scheduleId: platform.id,
+ *     name: "Primary",
+ *     users: [
+ *         alice.id,
+ *         bob.id,
+ *     ],
+ *     firstIntervalStartsAt: "2024-01-08T09:00:00Z",
+ *     handovers: [{
+ *         interval: 1,
+ *         intervalType: "weekly",
+ *     }],
+ * });
+ * // A rotation that only covers weekday working hours, with two people on call at
+ * // once and a place in the schedule's running order.
+ * const businessHours = new incident.ScheduleRotation("business_hours", {
+ *     scheduleId: platform.id,
+ *     name: "Business hours",
+ *     rank: 2,
+ *     users: [
+ *         alice.id,
+ *         bob.id,
+ *         carol.id,
+ *     ],
+ *     firstIntervalStartsAt: "2024-01-08T09:00:00Z",
+ *     handovers: [{
+ *         interval: 1,
+ *         intervalType: "daily",
+ *     }],
+ *     concurrentShifts: 2,
+ *     workingIntervals: [
+ *         {
+ *             weekday: "monday",
+ *             startTime: "09:00",
+ *             endTime: "17:00",
+ *         },
+ *         {
+ *             weekday: "tuesday",
+ *             startTime: "09:00",
+ *             endTime: "17:00",
+ *         },
+ *         {
+ *             weekday: "wednesday",
+ *             startTime: "09:00",
+ *             endTime: "17:00",
+ *         },
+ *         {
+ *             weekday: "thursday",
+ *             startTime: "09:00",
+ *             endTime: "17:00",
+ *         },
+ *         {
+ *             weekday: "friday",
+ *             startTime: "09:00",
+ *             endTime: "17:00",
+ *         },
+ *     ],
+ * });
+ * ```
+ */
+class ScheduleRotation extends pulumi.CustomResource {
+    /**
+     * Get an existing ScheduleRotation resource's state with the given name, ID, and optional extra
+     * properties used to qualify the lookup.
+     *
+     * @param name The _unique_ name of the resulting resource.
+     * @param id The _unique_ provider ID of the resource to lookup.
+     * @param state Any extra arguments used during the lookup.
+     * @param opts Optional settings to control the behavior of the CustomResource.
+     */
+    static get(name, id, state, opts) {
+        return new ScheduleRotation(name, state, { ...opts, id: id });
+    }
+    /** @internal */
+    static __pulumiType = 'incident:index/scheduleRotation:ScheduleRotation';
+    /**
+     * Returns true if the given object is an instance of ScheduleRotation.  This is designed to work even
+     * when multiple copies of the Pulumi SDK have been loaded into the same process.
+     */
+    static isInstance(obj) {
+        if (obj === undefined || obj === null) {
+            return false;
+        }
+        return obj['__pulumiType'] === ScheduleRotation.__pulumiType;
+    }
+    constructor(name, argsOrState, opts) {
+        let resourceInputs = {};
+        opts = opts || {};
+        if (opts.id) {
+            const state = argsOrState;
+            resourceInputs["concurrentShifts"] = state?.concurrentShifts;
+            resourceInputs["effectiveFrom"] = state?.effectiveFrom;
+            resourceInputs["firstIntervalStartsAt"] = state?.firstIntervalStartsAt;
+            resourceInputs["handovers"] = state?.handovers;
+            resourceInputs["name"] = state?.name;
+            resourceInputs["rank"] = state?.rank;
+            resourceInputs["rollout"] = state?.rollout;
+            resourceInputs["scheduleId"] = state?.scheduleId;
+            resourceInputs["schedulingMode"] = state?.schedulingMode;
+            resourceInputs["users"] = state?.users;
+            resourceInputs["workingIntervals"] = state?.workingIntervals;
+        }
+        else {
+            const args = argsOrState;
+            if (args?.firstIntervalStartsAt === undefined && !opts.urn) {
+                throw new Error("Missing required property 'firstIntervalStartsAt'");
+            }
+            if (args?.handovers === undefined && !opts.urn) {
+                throw new Error("Missing required property 'handovers'");
+            }
+            if (args?.scheduleId === undefined && !opts.urn) {
+                throw new Error("Missing required property 'scheduleId'");
+            }
+            if (args?.users === undefined && !opts.urn) {
+                throw new Error("Missing required property 'users'");
+            }
+            resourceInputs["concurrentShifts"] = args?.concurrentShifts;
+            resourceInputs["firstIntervalStartsAt"] = args?.firstIntervalStartsAt;
+            resourceInputs["handovers"] = args?.handovers;
+            resourceInputs["name"] = args?.name;
+            resourceInputs["rank"] = args?.rank;
+            resourceInputs["rollout"] = args?.rollout;
+            resourceInputs["scheduleId"] = args?.scheduleId;
+            resourceInputs["schedulingMode"] = args?.schedulingMode;
+            resourceInputs["users"] = args?.users;
+            resourceInputs["workingIntervals"] = args?.workingIntervals;
+            resourceInputs["effectiveFrom"] = undefined /*out*/;
+        }
+        opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts);
+        super(ScheduleRotation.__pulumiType, name, resourceInputs, opts);
+    }
+}
+exports.ScheduleRotation = ScheduleRotation;
+//# sourceMappingURL=scheduleRotation.js.map

package/scheduleRotation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduleRotation.js","sourceRoot":"","sources":["../scheduleRotation.ts"],"names":[],"mappings":"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"}