@oneuptime/common 11.5.13 → 11.6.1

package/Server/API/GlobalConfigAPI.ts

@@ -17,8 +17,14 @@ import API from "../../Utils/API";
 import HTTPErrorResponse from "../../Types/API/HTTPErrorResponse";
 import HTTPResponse from "../../Types/API/HTTPResponse";
 import PartialEntity from "../../Types/Database/PartialEntity";
-import { EnterpriseLicenseValidationUrl, Host } from "../EnvironmentConfig";
+import {
+  AppVersion,
+  DisableUpdateCheck,
+  EnterpriseLicenseValidationUrl,
+  Host,
+} from "../EnvironmentConfig";
 import EnterpriseLicenseInstanceSummary from "../../Types/EnterpriseLicense/EnterpriseLicenseInstanceSummary";
+import VersionUtil from "../../Utils/VersionUtil";
 import UserMiddleware from "../Middleware/UserAuthorization";
 
 export default class GlobalConfigAPI extends BaseAPI<
@@ -67,11 +73,15 @@ export default class GlobalConfigAPI extends BaseAPI<
                 enterpriseLicenseExpiresAt: true,
                 enterpriseLicenseKey: true,
                 enterpriseLicenseToken: true,
+                enterpriseLicenseIsEvaluation: true,
                 enterpriseLicenseUserLimit: true,
                 enterpriseLicenseCurrentUserCount: true,
                 enterpriseLicenseUserCountUpdatedAt: true,
                 enterpriseLicenseInstances: true,
                 instanceId: true,
+                latestReleaseVersion: true,
+                latestReleasePublishedAt: true,
+                latestReleaseCheckedAt: true,
               },
               props: {
                 isRoot: true,
@@ -106,6 +116,12 @@ export default class GlobalConfigAPI extends BaseAPI<
               ? config?.enterpriseLicenseToken || null
               : null,
             licenseValid: licenseValid,
+            /*
+             * Whether this is an evaluation/testing license. Benign like the
+             * company name and expiry, so it is not gated behind sign-in — the
+             * edition modal shows the evaluation notice to anyone who opens it.
+             */
+            isEvaluationLicense: Boolean(config?.enterpriseLicenseIsEvaluation),
             userLimit:
               typeof config?.enterpriseLicenseUserLimit === "number"
                 ? config.enterpriseLicenseUserLimit
@@ -126,6 +142,38 @@ export default class GlobalConfigAPI extends BaseAPI<
               isAuthenticatedUser && config?.instanceId
                 ? config.instanceId.toString()
                 : null,
+            /*
+             * Which build this installation runs, and whether a newer one has
+             * been released, are gated the same way as the instance topology:
+             * telling an anonymous visitor on the login page that this server
+             * is behind on patches advertises an unpatched target.
+             */
+            currentVersion: isAuthenticatedUser ? AppVersion : null,
+            latestVersion: isAuthenticatedUser
+              ? config?.latestReleaseVersion || null
+              : null,
+            latestVersionPublishedAt:
+              isAuthenticatedUser && config?.latestReleasePublishedAt
+                ? config.latestReleasePublishedAt.toISOString()
+                : null,
+            latestVersionCheckedAt:
+              isAuthenticatedUser && config?.latestReleaseCheckedAt
+                ? config.latestReleaseCheckedAt.toISOString()
+                : null,
+            isUpdateAvailable: isAuthenticatedUser
+              ? VersionUtil.isUpdateAvailable({
+                  currentVersion: AppVersion,
+                  latestVersion: config?.latestReleaseVersion,
+                })
+              : false,
+            /*
+             * Lets the modal say "update checks are off" instead of "has not
+             * checked yet", which would be a promise the installation is never
+             * going to keep.
+             */
+            isUpdateCheckDisabled: isAuthenticatedUser
+              ? DisableUpdateCheck
+              : false,
           };
 
           return Response.sendJsonObjectResponse(req, res, responseBody);
@@ -179,6 +227,12 @@ export default class GlobalConfigAPI extends BaseAPI<
               licenseKey,
               instanceId: instanceId.toString(),
               host: Host,
+              /*
+               * Sent here as well as from the daily report job so the version
+               * lands on the license server the moment the key is validated,
+               * rather than up to 24 hours later.
+               */
+              version: AppVersion,
             },
           });
 
@@ -239,6 +293,9 @@ export default class GlobalConfigAPI extends BaseAPI<
             }
           }
 
+          const isEvaluationLicense: boolean =
+            payload["isEvaluationLicense"] === true;
+
           const instances: Array<EnterpriseLicenseInstanceSummary> =
             Array.isArray(payload["instances"])
               ? (payload[
@@ -251,6 +308,7 @@ export default class GlobalConfigAPI extends BaseAPI<
             enterpriseLicenseKey: licenseKeyRaw || null,
             enterpriseLicenseExpiresAt: licenseExpiry || null,
             enterpriseLicenseToken: licenseToken || null,
+            enterpriseLicenseIsEvaluation: isEvaluationLicense,
             enterpriseLicenseUserLimit: userLimit,
             enterpriseLicenseCurrentUserCount: currentUserCount,
             enterpriseLicenseUserCountUpdatedAt: userCountUpdatedAt,
@@ -287,6 +345,8 @@ export default class GlobalConfigAPI extends BaseAPI<
               newConfig.enterpriseLicenseToken = licenseToken;
             }
 
+            newConfig.enterpriseLicenseIsEvaluation = isEvaluationLicense;
+
             if (licenseExpiry) {
               newConfig.enterpriseLicenseExpiresAt = licenseExpiry;
             }
@@ -321,6 +381,7 @@ export default class GlobalConfigAPI extends BaseAPI<
             expiresAt: licenseExpiry ? licenseExpiry.toISOString() : null,
             licenseKey: licenseKeyRaw || null,
             token: licenseToken || null,
+            isEvaluationLicense: isEvaluationLicense,
             userLimit: userLimit,
             currentUserCount: currentUserCount,
             userCountUpdatedAt: userCountUpdatedAt

package/Server/EnvironmentConfig.ts

@@ -665,6 +665,14 @@ export const IpWhitelist: string = process.env["IP_WHITELIST"] || "";
 export const DisableTelemetry: boolean =
   process.env["DISABLE_TELEMETRY"] === "true";
 
+/*
+ * Opt out of the daily "is a newer OneUptime released?" check against the
+ * GitHub API. Deliberately separate from DISABLE_TELEMETRY, which turns off
+ * the OpenTelemetry SDK and says nothing about outbound calls.
+ */
+export const DisableUpdateCheck: boolean =
+  process.env["DISABLE_UPDATE_CHECK"] === "true";
+
 export const EnableProfiling: boolean =
   process.env["ENABLE_PROFILING"] === "true";
 
@@ -782,6 +790,20 @@ export const EnterpriseLicenseUserCountReportUrl: URL = URL.fromString(
   "https://oneuptime.com/api/enterprise-license/report-user-count",
 );
 
+/*
+ * GitHub's "latest release" endpoint. It already excludes drafts and
+ * prereleases, so whatever it returns is a version an administrator can
+ * safely be told to upgrade to.
+ *
+ * Overridable so an installation with no route to github.com can point the
+ * check at an internal mirror instead of turning it off entirely. The mirror
+ * must answer with GitHub's release shape (tag_name, html_url, published_at).
+ */
+export const LatestReleaseCheckUrl: URL = URL.fromString(
+  process.env["LATEST_RELEASE_CHECK_URL"] ||
+    "https://api.github.com/repos/OneUptime/oneuptime/releases/latest",
+);
+
 // Inbound Email Configuration for Incoming Email Monitor
 export enum InboundEmailProviderType {
   SendGrid = "SendGrid",

package/Server/Infrastructure/Postgres/SchemaMigrations/1784659816363-AddInstanceVersionAndLatestReleaseColumns.ts

@@ -0,0 +1,38 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddInstanceVersionAndLatestReleaseColumns1784659816363
+  implements MigrationInterface
+{
+  public name: string =
+    "AddInstanceVersionAndLatestReleaseColumns1784659816363";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "EnterpriseLicenseInstance" ADD "oneuptimeVersion" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" ADD "latestReleaseVersion" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" ADD "latestReleasePublishedAt" TIMESTAMP WITH TIME ZONE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" ADD "latestReleaseCheckedAt" TIMESTAMP WITH TIME ZONE`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" DROP COLUMN "latestReleaseCheckedAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" DROP COLUMN "latestReleasePublishedAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" DROP COLUMN "latestReleaseVersion"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "EnterpriseLicenseInstance" DROP COLUMN "oneuptimeVersion"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1784705487674-AddEnterpriseLicenseEvaluationColumns.ts

@@ -0,0 +1,25 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddEnterpriseLicenseEvaluationColumns1784705487674
+  implements MigrationInterface
+{
+  public name: string = "AddEnterpriseLicenseEvaluationColumns1784705487674";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "EnterpriseLicense" ADD "isEvaluationLicense" boolean NOT NULL DEFAULT false`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" ADD "enterpriseLicenseIsEvaluation" boolean DEFAULT false`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" DROP COLUMN "enterpriseLicenseIsEvaluation"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "EnterpriseLicense" DROP COLUMN "isEvaluationLicense"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -462,6 +462,8 @@ import { AddEnterpriseLicenseNotificationColumns1784218257664 } from "./17842182
 import { AddAttributionColumnsToUserAndProject1784293516000 } from "./1784293516000-AddAttributionColumnsToUserAndProject";
 import { AddMarketingConversionTable1784298000000 } from "./1784298000000-AddMarketingConversionTable";
 import { AddExceptionTriageAndPrivacyColumns1784640000000 } from "./1784640000000-AddExceptionTriageAndPrivacyColumns";
+import { AddInstanceVersionAndLatestReleaseColumns1784659816363 } from "./1784659816363-AddInstanceVersionAndLatestReleaseColumns";
+import { AddEnterpriseLicenseEvaluationColumns1784705487674 } from "./1784705487674-AddEnterpriseLicenseEvaluationColumns";
 
 export default [
   InitialMigration,
@@ -928,4 +930,6 @@ export default [
   AddAttributionColumnsToUserAndProject1784293516000,
   AddMarketingConversionTable1784298000000,
   AddExceptionTriageAndPrivacyColumns1784640000000,
+  AddInstanceVersionAndLatestReleaseColumns1784659816363,
+  AddEnterpriseLicenseEvaluationColumns1784705487674,
 ];

package/Server/Services/AnalyticsDatabaseService.ts

@@ -47,7 +47,7 @@ import {
   ResponseJSON,
   ResultSet,
 } from "@clickhouse/client";
-import { AsyncLocalStorage } from "node:async_hooks";
+import { nextInsertDedupToken } from "../Utils/AnalyticsDatabase/InsertDedupContext";
 import AnalyticsBaseModel from "../../Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
 import { WorkflowRoute } from "../../ServiceRoute";
 import Protocol from "../../Types/API/Protocol";
@@ -140,40 +140,42 @@ export const MigrationExecuteOptions: ClickhouseExecuteOptions = {
   },
 };
 
-/**
- * Ambient context that makes ClickHouse inserts idempotent across queue
- * retries. The telemetry queue worker wraps each job in
- * `runWithInsertDedup(jobId, ...)`; every insertJsonRows call inside the
- * job then stamps `insert_deduplication_token =
- * "<tokenBase>:<table>:<chunkIndex>"` plus async_insert_deduplicate=1 /
- * wait_for_async_insert=1, so a stalled-job retry that re-processes the
- * same payload re-issues byte-identical tokens and ClickHouse drops the
- * duplicate blocks (on replicated tables; on plain MergeTree the token is
- * ignored unless non_replicated_deduplication_window is set — no harm
- * either way). The chunk counter is per table because one job inserts
- * into several tables (e.g. Span + ExceptionInstance) in a deterministic
- * order.
+/*
+ * The insert-dedup ambient context lives in
+ * Utils/AnalyticsDatabase/InsertDedupContext so that both this service and
+ * TelemetryFanInWriter can consume deterministic tokens without an import
+ * cycle. Re-exported here for existing callers.
  *
- * HTTP-path inserts run outside the context and keep the fire-and-forget
- * async insert (wait_for_async_insert=0) — dedup waiting is only
- * affordable off the request thread.
+ * HTTP-path inserts run outside the context and are always fire-and-forget
+ * (wait_for_async_insert=0) — flush waiting, when opted into via
+ * TELEMETRY_WAIT_FOR_ASYNC_INSERT, is only affordable off the request
+ * thread and therefore only applies to tokened (queue-job) inserts.
  */
-export interface InsertDedupContextStore {
-  tokenBase: string;
-  chunkIndexByTable: Map<string, number>;
-}
+export {
+  runWithInsertDedup,
+  nextInsertDedupToken,
+  type InsertDedupContextStore,
+} from "../Utils/AnalyticsDatabase/InsertDedupContext";
 
-const insertDedupContext: AsyncLocalStorage<InsertDedupContextStore> =
-  new AsyncLocalStorage<InsertDedupContextStore>();
-
-export function runWithInsertDedup<T>(
-  tokenBase: string,
-  fn: () => Promise<T>,
-): Promise<T> {
-  return insertDedupContext.run(
-    { tokenBase, chunkIndexByTable: new Map<string, number>() },
-    fn,
-  );
+/*
+ * Ack mode for telemetry ClickHouse inserts.
+ *
+ * Default (false): wait_for_async_insert=0 — fire-and-forget. ClickHouse
+ * acks as soon as the batch is accepted into its async-insert buffer and
+ * owns flushing from there; inserts release their query slot almost
+ * immediately. The trade: flush-time errors surface only in server logs
+ * (system.asynchronous_inserts / part log), and a ClickHouse crash between
+ * buffer-accept and flush loses that buffer even though callers were acked.
+ *
+ * Set TELEMETRY_WAIT_FOR_ASYNC_INSERT=true to make every tokened insert
+ * wait for the durable flush before acking (ack-after-flush end to end
+ * through the fan-in writer and writer tier) — at the cost of each waiting
+ * insert holding a ClickHouse query slot until its buffer flushes.
+ */
+export function shouldWaitForAsyncInsert(): boolean {
+  const raw: string | undefined =
+    process.env["TELEMETRY_WAIT_FOR_ASYNC_INSERT"];
+  return raw === "true" || raw === "1";
 }
 
 export default class AnalyticsDatabaseService<
@@ -259,30 +261,31 @@ export default class AnalyticsDatabaseService<
     let dedupToken: string | undefined = options?.dedupToken;
 
     if (!dedupToken) {
-      const dedupStore: InsertDedupContextStore | undefined =
-        insertDedupContext.getStore();
-      if (dedupStore) {
-        const chunkIndex: number =
-          dedupStore.chunkIndexByTable.get(tableName) ?? 0;
-        dedupStore.chunkIndexByTable.set(tableName, chunkIndex + 1);
-        dedupToken = `${dedupStore.tokenBase}:${tableName}:${chunkIndex}`;
-      }
+      dedupToken = nextInsertDedupToken(tableName);
     }
 
+    const waitForAsyncInsert: 0 | 1 = shouldWaitForAsyncInsert() ? 1 : 0;
+
     let clickhouseSettings: ClickHouseSettings = {
       async_insert: 1,
-      wait_for_async_insert: 0,
+      wait_for_async_insert: waitForAsyncInsert,
     };
 
     if (dedupToken) {
       /*
-       * wait_for_async_insert=1 so the worker only acks the job after
-       * the block actually landed (or was deduplicated) — otherwise a
-       * crash between buffer-write and flush loses data with no retry.
+       * Dedup settings ride along in both ack modes. For async inserts
+       * ClickHouse dedups by content hash of the insert body when
+       * async_insert_deduplicate=1 (the explicit token is not yet honored
+       * for async inserts — ClickHouse #52018), so byte-identical queue
+       * retries are still dropped. The ack mode is a separate, deliberate
+       * trade (see shouldWaitForAsyncInsert): by default ClickHouse owns
+       * flushing and an ack means "accepted into the async-insert buffer";
+       * with TELEMETRY_WAIT_FOR_ASYNC_INSERT=true the ack waits for the
+       * durable flush instead.
        */
       clickhouseSettings = {
         async_insert: 1,
-        wait_for_async_insert: 1,
+        wait_for_async_insert: waitForAsyncInsert,
         async_insert_deduplicate: 1,
         insert_deduplication_token: dedupToken,
       };
@@ -980,7 +983,19 @@ export default class AnalyticsDatabaseService<
         onBeforeFind.select = {} as any;
       }
 
-      if (!(onBeforeFind.select as any)["_id"]) {
+      /*
+       * Derived aggregate targets deliberately omit AnalyticsBaseModel's
+       * synthetic `_id`: the aggregation key is the row identity. Only force
+       * `_id` into generic reads when the model actually declares it.
+       */
+      if (
+        this.model.tableColumns.some(
+          (column: AnalyticsTableColumn): boolean => {
+            return column.key === "_id";
+          },
+        ) &&
+        !(onBeforeFind.select as any)["_id"]
+      ) {
         (onBeforeFind.select as any)["_id"] = true;
       }
 

package/Server/Services/DatabaseService.ts

@@ -1743,10 +1743,67 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
     });
   }
 
+  /*
+   * Update `data` may arrive as a full model instance rather than a plain
+   * partial — the QueryDeepPartialEntity type structurally admits both, and
+   * callers do construct `new Model()` payloads. A model instance carries
+   * non-column own properties from DatabaseBaseModel (every column
+   * initializer plus `isPermissionIf = {}`), and _updateBy turns every data
+   * key into a select column for its internal find, so the extra keys made
+   * that find throw `TableColumnMetadata not found for isPermissionIf
+   * column` and fail the whole update. Strip a model instance down to its
+   * set table columns; plain objects pass through untouched so a typo'd
+   * column name in a literal still fails loudly instead of being silently
+   * dropped.
+   *
+   * `_id`, `createdAt`, `updatedAt` and `version` are dropped for model
+   * instances the same way BaseAPI drops them from client payloads: the row
+   * is located by the update query (spreading a foreign `_id` into the save
+   * payload would redirect the write), timestamps are database-managed, and
+   * `version` is TypeORM's optimistic-concurrency counter.
+   */
+  public sanitizeUpdateData(
+    data: UpdateBy<TBaseModel>["data"],
+  ): UpdateBy<TBaseModel>["data"] {
+    if (!(data instanceof BaseModel)) {
+      return data;
+    }
+
+    const plainData: JSONObject = {};
+
+    for (const key of Object.keys(data)) {
+      if (!this.model.isTableColumn(key)) {
+        continue;
+      }
+
+      if (
+        key === "_id" ||
+        key === "createdAt" ||
+        key === "updatedAt" ||
+        key === "version"
+      ) {
+        continue;
+      }
+
+      const value: JSONValue = (data as any)[key];
+
+      // Unset columns must not become writes (or select columns).
+      if (value === undefined) {
+        continue;
+      }
+
+      plainData[key] = value;
+    }
+
+    return plainData as UpdateBy<TBaseModel>["data"];
+  }
+
   private async _updateBy(updateBy: UpdateBy<TBaseModel>): Promise<number> {
     try {
       this.setTelemetryContextFromProps(updateBy.props);
 
+      updateBy.data = this.sanitizeUpdateData(updateBy.data);
+
       const onUpdate: OnUpdate<TBaseModel> = updateBy.props.ignoreHooks
         ? { updateBy, carryForward: [] }
         : await this.onBeforeUpdate(updateBy);
@@ -1830,9 +1887,17 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
       });
 
       for (const item of items) {
+        /*
+         * _id must be set AFTER the spread: update data can carry an
+         * explicit `_id: undefined` (sanitizeUpdateData strips it from model
+         * instances, but a plain object can still hold it), and spreading it
+         * after _id would clobber the located row's id — save() then sees no
+         * primary key, INSERTs instead of updating, and dies on the first
+         * NOT NULL column.
+         */
         const updatedItem: any = {
-          _id: item._id!,
           ...data,
+          _id: item._id!,
         } as any;
 
         logger.debug("Updated Item", {

package/Server/Services/WorkflowService.ts

@@ -49,6 +49,40 @@ export class Service extends DatabaseService<Model> {
       createdItem.webhookSecretKey = secretKey;
     }
 
+    /*
+     * A workflow that arrives with its graph already in place - imported from
+     * a JSON export, or duplicated from another workflow - never passes
+     * through onUpdateSuccess, so nothing has denormalized its trigger onto
+     * the row. The runner looks workflows up by triggerId, so without this the
+     * workflow is saved and looks correct in the builder but silently never
+     * fires.
+     */
+    if (createdItem.id && createdItem.graph) {
+      await this.saveTriggerFromGraph({
+        workflowId: createdItem.id,
+        graph: createdItem.graph,
+      });
+
+      /*
+       * Registers schedule triggers with the runner. Best effort: the row and
+       * its trigger are already persisted, so a workflow service outage must
+       * not fail the create. The trigger is already on the row, so the next
+       * save - or the runner's own startup scan in Schedule.init, which
+       * queries by triggerId - picks the workflow up.
+       */
+      try {
+        await this.notifyWorkflowService(createdItem.id);
+      } catch (error) {
+        logger.error(
+          `Error notifying workflow service of created workflow: ${error}`,
+          {
+            projectId: createdItem.projectId?.toString(),
+            workflowId: createdItem.id?.toString(),
+          } as LogAttributes,
+        );
+      }
+    }
+
     if (createdItem.projectId && createdItem.id) {
       /*
        * Run label rule first so rule-added labels are persisted before
@@ -87,39 +121,13 @@ export class Service extends DatabaseService<Model> {
   ): Promise<OnUpdate<Model>> {
     /// save trigger and trigger args.
 
-    if (
-      onUpdate.updateBy.data &&
-      (onUpdate.updateBy.data as any).graph &&
-      (((onUpdate.updateBy.data as any).graph as any)[
-        "nodes"
-      ] as Array<JSONObject>)
-    ) {
-      let trigger: NodeDataProp | null = null;
-
-      // check if it has a trigger node.
-      for (const node of ((onUpdate.updateBy.data as any).graph as any)[
-        "nodes"
-      ] as Array<JSONObject>) {
-        const nodeData: NodeDataProp = node["data"] as any;
-        if (
-          nodeData.componentType === ComponentType.Trigger &&
-          nodeData.nodeType === NodeType.Node
-        ) {
-          // found the trigger;
-          trigger = nodeData;
-        }
-      }
+    const updatedGraph: JSONObject | undefined = (onUpdate.updateBy.data as any)
+      ?.graph as JSONObject | undefined;
 
-      await this.updateOneById({
-        id: new ObjectID(onUpdate.updateBy.query._id! as any),
-        data: {
-          triggerId: trigger?.metadataId || null,
-          triggerArguments: trigger?.arguments || {},
-        } as any,
-        props: {
-          isRoot: true,
-          ignoreHooks: true,
-        },
+    if (updatedGraph) {
+      await this.saveTriggerFromGraph({
+        workflowId: new ObjectID(onUpdate.updateBy.query._id! as any),
+        graph: updatedGraph,
       });
     }
 
@@ -127,23 +135,76 @@ export class Service extends DatabaseService<Model> {
       workflowId: onUpdate.updateBy.query._id?.toString(),
     } as LogAttributes);
 
+    await this.notifyWorkflowService(
+      new ObjectID(onUpdate.updateBy.query._id! as any),
+    );
+
+    logger.debug("Updated workflow on the workflow service", {
+      workflowId: onUpdate.updateBy.query._id?.toString(),
+    } as LogAttributes);
+
+    return onUpdate;
+  }
+
+  /*
+   * The trigger node is denormalized out of the graph onto triggerId /
+   * triggerArguments because the runner queries workflows by trigger and
+   * cannot parse every graph to do it. A graph with no trigger node clears
+   * both columns, which is how a workflow stops firing when its trigger is
+   * removed in the builder.
+   */
+  private async saveTriggerFromGraph(data: {
+    workflowId: ObjectID;
+    graph: JSONObject;
+  }): Promise<void> {
+    const nodes: Array<JSONObject> | undefined = data.graph["nodes"] as
+      | Array<JSONObject>
+      | undefined;
+
+    if (!nodes || !Array.isArray(nodes)) {
+      return;
+    }
+
+    let trigger: NodeDataProp | null = null;
+
+    // check if it has a trigger node.
+    for (const node of nodes) {
+      const nodeData: NodeDataProp = node["data"] as any;
+
+      if (
+        nodeData?.componentType === ComponentType.Trigger &&
+        nodeData?.nodeType === NodeType.Node
+      ) {
+        // found the trigger;
+        trigger = nodeData;
+      }
+    }
+
+    await this.updateOneById({
+      id: data.workflowId,
+      data: {
+        triggerId: trigger?.metadataId || null,
+        triggerArguments: trigger?.arguments || {},
+      } as any,
+      props: {
+        isRoot: true,
+        ignoreHooks: true,
+      },
+    });
+  }
+
+  private async notifyWorkflowService(workflowId: ObjectID): Promise<void> {
     await API.post<EmptyResponseData>({
       url: new URL(
         Protocol.HTTP,
         WorkflowHostname,
-        new Route("/workflow/update/" + onUpdate.updateBy.query._id!),
+        new Route("/workflow/update/" + workflowId.toString()),
       ),
       data: {},
       headers: {
         ...ClusterKeyAuthorization.getClusterKeyHeaders(),
       },
     });
-
-    logger.debug("Updated workflow on the workflow service", {
-      workflowId: onUpdate.updateBy.query._id?.toString(),
-    } as LogAttributes);
-
-    return onUpdate;
   }
 }
 export default new Service();