@oneuptime/common 11.7.3 → 12.0.0

package/Server/Services/{RunbookAgentOwnerTeamService.ts → AutoRemediationRuleService.ts}

@@ -1,5 +1,5 @@
 import DatabaseService from "./DatabaseService";
-import Model from "../../Models/DatabaseModels/RunbookAgentOwnerTeam";
+import Model from "../../Models/DatabaseModels/AutoRemediationRule";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {

package/Server/Services/AutoRemediationSuggestionService.ts

@@ -0,0 +1,183 @@
+import AutoRemediationSuggestionStatus from "../../Types/AutoRemediation/AutoRemediationSuggestionStatus";
+import AutoRemediationVerificationStatus from "../../Types/AutoRemediation/AutoRemediationVerificationStatus";
+import { JSONObject } from "../../Types/JSON";
+import ObjectID from "../../Types/ObjectID";
+import PositiveNumber from "../../Types/PositiveNumber";
+import CountBy from "../Types/Database/CountBy";
+import DeleteBy from "../Types/Database/DeleteBy";
+import FindBy from "../Types/Database/FindBy";
+import { OnDelete, OnFind, OnUpdate } from "../Types/Database/Hooks";
+import UpdateBy from "../Types/Database/UpdateBy";
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/AutoRemediationSuggestion";
+import { applyOptionalAlertRelatedRecordPrivacyFilter } from "../Utils/Alert/AlertPrivacyFilter";
+import { applyOptionalIncidentRelatedRecordPrivacyFilter } from "../Utils/Incident/IncidentPrivacyFilter";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import { UpdateQueryBuilder, UpdateResult } from "typeorm";
+import { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
+
+/*
+ * The fields a status transition may set. Primitives only — the query-builder
+ * update below bypasses column transformers, so ObjectID-backed columns must
+ * be passed as their pre-transformed string form (ObjectID.toString()).
+ */
+export interface SuggestionTransitionSet {
+  status: AutoRemediationSuggestionStatus;
+  runbookId?: string | undefined;
+  runbookNameSnapshot?: string | undefined;
+  rationaleMarkdown?: string | undefined;
+  runbookExecutionId?: string | undefined;
+  approvedByUserId?: string | undefined;
+  approvedAt?: Date | undefined;
+  dismissedByUserId?: string | undefined;
+  dismissedAt?: Date | undefined;
+  verificationStatus?: AutoRemediationVerificationStatus | undefined;
+  verificationDeadlineAt?: Date | undefined;
+  /*
+   * The frozen AI-composed command plan (AiRemediationCommandPlan as plain
+   * JSON) for CommandPlan suggestions. jsonb column — no transformer, so
+   * the query-builder update stores it as-is.
+   */
+  commandPlan?: JSONObject | undefined;
+}
+
+// What the outcome verifier may set when a verification concludes.
+export interface VerificationTransitionSet {
+  verificationStatus: AutoRemediationVerificationStatus;
+  verificationCompletedAt?: Date | undefined;
+  verificationNote?: string | undefined;
+}
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  /*
+   * Suggestions are incident/alert child records whose rationale can quote
+   * the AI's analysis of the subject — reads must respect the subject's
+   * privacy exactly like feed items and internal notes do. Both link
+   * columns are nullable (a row links an incident OR an alert), so the
+   * null-tolerant filter variants apply: a NULL link passes its own clause
+   * and the sibling column's filter does the gating.
+   */
+  @CaptureSpan()
+  protected override async onBeforeFind(
+    findBy: FindBy<Model>,
+  ): Promise<OnFind<Model>> {
+    findBy.query = applyOptionalIncidentRelatedRecordPrivacyFilter(
+      findBy.query,
+      findBy.props,
+    );
+    findBy.query = applyOptionalAlertRelatedRecordPrivacyFilter(
+      findBy.query,
+      findBy.props,
+    );
+    return { findBy, carryForward: null };
+  }
+
+  @CaptureSpan()
+  public override async countBy(
+    countBy: CountBy<Model>,
+  ): Promise<PositiveNumber> {
+    countBy.query = applyOptionalIncidentRelatedRecordPrivacyFilter(
+      countBy.query,
+      countBy.props,
+    );
+    countBy.query = applyOptionalAlertRelatedRecordPrivacyFilter(
+      countBy.query,
+      countBy.props,
+    );
+    return super.countBy(countBy);
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    updateBy.query = applyOptionalIncidentRelatedRecordPrivacyFilter(
+      updateBy.query,
+      updateBy.props,
+    );
+    updateBy.query = applyOptionalAlertRelatedRecordPrivacyFilter(
+      updateBy.query,
+      updateBy.props,
+    );
+    return { updateBy, carryForward: null };
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    deleteBy.query = applyOptionalIncidentRelatedRecordPrivacyFilter(
+      deleteBy.query,
+      deleteBy.props,
+    );
+    deleteBy.query = applyOptionalAlertRelatedRecordPrivacyFilter(
+      deleteBy.query,
+      deleteBy.props,
+    );
+    return { deleteBy, carryForward: null };
+  }
+
+  /*
+   * A genuinely atomic status transition: one conditional UPDATE whose WHERE
+   * carries the expected current status. Returns the number of rows changed —
+   * 0 means another actor won the race. This is what makes double-approving
+   * (and therefore double-starting a runbook) impossible; updateOneBy is
+   * SELECT-then-save and cannot implement a claim.
+   */
+  @CaptureSpan()
+  public async attemptStatusTransition(data: {
+    suggestionId: ObjectID;
+    fromStatus: AutoRemediationSuggestionStatus;
+    set: SuggestionTransitionSet;
+  }): Promise<number> {
+    /*
+     * The double cast stops TS from structurally exploring JSONObject
+     * (commandPlan) against the entity type — a recursive type that trips
+     * TS2589. The set is intentionally a raw column map.
+     */
+    const queryBuilder: UpdateQueryBuilder<Model> = this.getRepository()
+      .createQueryBuilder()
+      .update(Model)
+      .set(data.set as unknown as QueryDeepPartialEntity<Model>)
+      .where('"_id" = :id', { id: data.suggestionId.toString() })
+      .andWhere('"status" = :fromStatus', { fromStatus: data.fromStatus })
+      .andWhere('"deletedAt" IS NULL');
+
+    const result: UpdateResult = await queryBuilder.execute();
+
+    return result.affected || 0;
+  }
+
+  /*
+   * The verification twin of attemptStatusTransition: one conditional
+   * UPDATE guarded on the expected current verificationStatus, so
+   * concurrent verifier sweeps (multiple Workers replicas) settle each
+   * verification exactly once.
+   */
+  @CaptureSpan()
+  public async attemptVerificationTransition(data: {
+    suggestionId: ObjectID;
+    fromVerificationStatus: AutoRemediationVerificationStatus;
+    set: VerificationTransitionSet;
+  }): Promise<number> {
+    const queryBuilder: UpdateQueryBuilder<Model> = this.getRepository()
+      .createQueryBuilder()
+      .update(Model)
+      .set(data.set as QueryDeepPartialEntity<Model>)
+      .where('"_id" = :id', { id: data.suggestionId.toString() })
+      .andWhere('"verificationStatus" = :fromVerificationStatus', {
+        fromVerificationStatus: data.fromVerificationStatus,
+      })
+      .andWhere('"deletedAt" IS NULL');
+
+    const result: UpdateResult = await queryBuilder.execute();
+
+    return result.affected || 0;
+  }
+}
+
+export default new Service();

package/Server/Services/BillingService.ts

@@ -37,6 +37,13 @@ export interface PaymentMethod {
   isDefault: boolean;
 }
 
+/*
+ * Stripe rejects a trial_end more than two years past the billing cycle
+ * anchor. Enforce the same ceiling here so an admin gets a readable error
+ * instead of a raw payment-provider failure.
+ */
+export const MAX_TRIAL_LENGTH_IN_DAYS: number = 730;
+
 export interface Invoice {
   id: string;
   amount: number;
@@ -254,12 +261,23 @@ export class BillingService extends BaseService {
     meteredSubscriptionId: string;
     trialEndsAt: Date | null;
   }> {
+    /*
+     * Only plans with a Stripe price can become subscription items. A plan
+     * without one yet would make getPriceId throw and abort project
+     * creation, so we skip them here - their usage still stages
+     * into TelemetryUsageBilling and is pushed once the price ids exist.
+     */
+    const priceableMeteredPlans: Array<ServerMeteredPlan> =
+      data.serverMeteredPlans.filter((plan: ServerMeteredPlan) => {
+        return plan.hasPriceId();
+      });
+
     const meteredPlanSubscriptionParams: Stripe.SubscriptionCreateParams = {
       customer: data.customerId,
 
       proration_behavior: "always_invoice",
 
-      items: data.serverMeteredPlans.map((item: ServerMeteredPlan) => {
+      items: priceableMeteredPlans.map((item: ServerMeteredPlan) => {
         return {
           price: item.getPriceId(),
         };
@@ -449,6 +467,16 @@ export class BillingService extends BaseService {
       throw new BadDataException(Errors.BillingService.BILLING_NOT_ENABLED);
     }
 
+    /*
+     * A plan without a Stripe price yet cannot be pushed
+     * to a subscription - getPriceId would throw. Usage has already been staged
+     * into TelemetryUsageBilling by the caller, so skipping here loses nothing;
+     * the push happens once the price ids are created.
+     */
+    if (!serverMeteredPlan.hasPriceId()) {
+      return;
+    }
+
     // get subscription.
     const subscription: Stripe.Subscription = await this.getSubscription(
       subscriptionId.toString(),
@@ -870,6 +898,97 @@ export class BillingService extends BaseService {
     }
   }
 
+  /*
+   * Moves the trial end of a project's subscriptions to a new date.
+   *
+   * Both the flat-fee subscription and the metered subscription have to move
+   * together: they were created with the same trial_end (see subscribeToPlan),
+   * and leaving the metered one behind would start billing usage while the
+   * customer still believes they are on trial.
+   */
+  @CaptureSpan()
+  public async extendTrial(data: {
+    subscriptionId: string;
+    meteredSubscriptionId?: string | undefined;
+    trialEndsAt: Date;
+  }): Promise<void> {
+    if (!this.isBillingEnabled()) {
+      throw new BadDataException(Errors.BillingService.BILLING_NOT_ENABLED);
+    }
+
+    if (!OneUptimeDate.isInTheFuture(data.trialEndsAt)) {
+      throw new BadDataException(Errors.BillingService.TRIAL_END_DATE_IN_PAST);
+    }
+
+    if (
+      OneUptimeDate.isAfter(
+        data.trialEndsAt,
+        OneUptimeDate.getSomeDaysAfter(MAX_TRIAL_LENGTH_IN_DAYS),
+      )
+    ) {
+      throw new BadDataException(
+        Errors.BillingService.TRIAL_END_DATE_TOO_FAR_IN_FUTURE,
+      );
+    }
+
+    const subscriptionIds: Array<string> = [data.subscriptionId];
+
+    if (data.meteredSubscriptionId) {
+      subscriptionIds.push(data.meteredSubscriptionId);
+    }
+
+    /*
+     * Validate every subscription before touching any of them. Updating the
+     * flat-fee subscription and then discovering the metered one is cancelled
+     * would leave the project's two subscriptions on different trial dates.
+     */
+    for (const subscriptionId of subscriptionIds) {
+      const subscription: Stripe.Subscription =
+        await this.getSubscription(subscriptionId);
+
+      if (!subscription) {
+        throw new BadDataException(
+          Errors.BillingService.SUBSCRIPTION_NOT_FOUND,
+        );
+      }
+
+      if (
+        subscription.status === "canceled" ||
+        subscription.status === "incomplete_expired"
+      ) {
+        throw new BadDataException(
+          Errors.BillingService.CANNOT_EXTEND_TRIAL_ON_CANCELLED_SUBSCRIPTION,
+        );
+      }
+    }
+
+    for (const subscriptionId of subscriptionIds) {
+      await this.stripe.subscriptions.update(subscriptionId, {
+        trial_end: OneUptimeDate.toUnixTimestamp(data.trialEndsAt),
+
+        /*
+         * Setting trial_end also moves the billing cycle anchor to that date.
+         * With the default proration behaviour Stripe raises proration line
+         * items for the shifted period, which is exactly the surprise invoice
+         * extending a trial is meant to prevent - so prorations are disabled.
+         *
+         * Caveat: this only silences the flat-fee subscription. Usage-based
+         * billing is not subject to proration, so closing the metered
+         * subscription's period early still invoices the usage recorded in it.
+         * For a project that is still trialing that is nothing (trial usage is
+         * not billable), but extending the trial of an already-active project
+         * bills its accrued usage immediately - the admin page warns about
+         * this before the extension is submitted.
+         */
+        proration_behavior: "none",
+      });
+
+      logger.debug(
+        `Extended trial for subscription ${subscriptionId} to ${data.trialEndsAt.toISOString()}`,
+      );
+    }
+  }
+
   @CaptureSpan()
   public async getSubscriptionStatus(
     subscriptionId: string,
@@ -1398,11 +1517,39 @@ export class BillingService extends BaseService {
       return "price_1TGwTDANuQdJ93r7s0jKRxaT";
     }
 
+    if (productType === ProductType.SessionReplay) {
+      if (this.isTestEnvironment()) {
+        return "price_1U0icaANuQdJ93r7yE4a6icc";
+      }
+
+      return "price_1U0iWJANuQdJ93r7iVAXwhdP";
+    }
+
     throw new BadDataException(
       "Plan with productType " + productType + " not found",
     );
   }
 
+  /*
+   * Whether a Stripe metered price exists for this product type yet.
+   *
+   * getMeteredPlanPriceId throws for product types whose Stripe prices have
+   * not been created and for unknown types. Every product type is priced
+   * today, so this only guards the next one added ahead of its Stripe price.
+   * Callers that build Stripe subscription items must skip those plans instead of
+   * letting the throw abort the whole operation - a metered plan without a
+   * price still stages usage into TelemetryUsageBilling, only the push to
+   * Stripe waits on the price ids. This is the single, side-effect-free way to
+   * ask, so we keep getMeteredPlanPriceId as the single source of truth.
+   */
+  public hasMeteredPlanPriceId(productType: ProductType): boolean {
+    try {
+      return Boolean(this.getMeteredPlanPriceId(productType));
+    } catch {
+      return false;
+    }
+  }
+
   @CaptureSpan()
   public verifyWebhookSignature(
     payload: string | Buffer,