test(trigger-record-change): end-to-end regression coverage for record-change flows (#1491)

#1491 reported record-change flows never firing on data writes (7.4.1–7.7.0).
It no longer reproduces on current main — the triggers-first-class-dir +
flow-engine-alignment refactor fixed the wiring. The gap that let it regress
silently: the existing tests only used a FAKE data engine, never the real
dispatch path.

Adds a full-kernel integration test (ObjectQL + automation + record-change
trigger + in-memory driver) that boots the real stack, inserts a row, and
asserts a `record-after-create` flow fires and its `update_record` writes back
— in BOTH registration orderings:
  1. flow registered after the trigger (engine.registerFlow), and
  2. flow pulled from the registry at automation.start(), bound when the
     trigger registers on kernel:ready (the production sequence).

Adds @objectstack/driver-memory as a devDependency for the test. Test-only;
empty changeset (no shipped-code change).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: os-zhuang

.changeset/record-change-trigger-e2e-1491.md

@@ -0,0 +1,14 @@
+---
+---
+
+test(trigger-record-change): add end-to-end regression coverage for record-change flows (#1491)
+
+Test-only — no shipped-code change, so no version bump. #1491 reported that
+record-change flows never fired on data writes (7.4.1–7.7.0); it no longer
+reproduces on current `main` (fixed by the triggers-first-class-dir + flow-engine
+alignment refactor). The existing tests only used a fake data engine, so the real
+path was uncovered. Adds a full-kernel integration test (ObjectQL + automation +
+record-change trigger + in-memory driver) asserting a `record-after-create` flow
+fires and its `update_record` writes back — in both registration orderings
+(direct `registerFlow`, and registry-pull at `automation.start()` with the
+trigger binding on `kernel:ready`).

packages/triggers/trigger-record-change/package.json

@@ -21,6 +21,9 @@
     "@objectstack/spec": "workspace:*"
   },
   "devDependencies": {
+    "@objectstack/driver-memory": "workspace:*",
+    "@objectstack/objectql": "workspace:*",
+    "@objectstack/service-automation": "workspace:*",
     "@types/node": "^25.9.2",
     "typescript": "^6.0.3",
     "vitest": "^4.1.8"

packages/triggers/trigger-record-change/src/record-change-integration.test.ts

@@ -0,0 +1,127 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * End-to-end integration test for the record-change trigger (#1491).
+ *
+ * #1491 reported that record-change flows never fired on data writes (observed
+ * 7.4.1–7.7.0). The existing unit tests only exercised a *fake* data engine, so
+ * they never covered the real path: a flow pulled into the automation engine,
+ * the trigger binding to an ObjectQL lifecycle hook on `kernel:ready`, an actual
+ * insert firing that hook, and the flow's `update_record` writing back through
+ * the live data engine. This test boots a real kernel (ObjectQL + automation +
+ * record-change trigger + in-memory driver) and asserts the full chain — in BOTH
+ * registration orderings, since the engine relies on re-activating already-pulled
+ * flows when the trigger registers later.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { ObjectKernel } from '@objectstack/core';
+import { ObjectQLPlugin } from '@objectstack/objectql';
+import { AutomationServicePlugin, type AutomationEngine } from '@objectstack/service-automation';
+import { InMemoryDriver } from '@objectstack/driver-memory';
+import { RecordChangeTriggerPlugin } from './plugin.js';
+
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+/** A flow that stamps `stamp: 'done'` on the just-created record of `object`. */
+function stampFlow(name: string, object: string) {
+  return {
+    name,
+    label: name,
+    type: 'autolaunched',
+    nodes: [
+      { id: 'start', type: 'start', label: 'Start', config: { objectName: object, triggerType: 'record-after-create' } },
+      { id: 'stamp', type: 'update_record', label: 'Stamp', config: { objectName: object, filter: { id: '{record.id}' }, fields: { stamp: 'done' } } },
+      { id: 'end', type: 'end', label: 'End' },
+    ],
+    edges: [
+      { id: 'e1', source: 'start', target: 'stamp' },
+      { id: 'e2', source: 'stamp', target: 'end' },
+    ],
+  };
+}
+
+const objectDef = (name: string) => ({
+  name,
+  label: name,
+  fields: {
+    status: { name: 'status', label: 'S', type: 'text' },
+    stamp: { name: 'stamp', label: 'St', type: 'text' },
+  },
+});
+
+describe('record-change trigger — end-to-end (#1491)', () => {
+  it('fires a record-after-create flow registered AFTER the trigger (engine.registerFlow path)', async () => {
+    const kernel = new ObjectKernel({ logLevel: 'silent' });
+    await kernel.use(new ObjectQLPlugin());
+    await kernel.use(new AutomationServicePlugin());
+    await kernel.use(new RecordChangeTriggerPlugin());
+    await kernel.bootstrap();
+
+    const objectql = kernel.getService('objectql') as any;
+    const data = kernel.getService('data') as any;
+    const automation = kernel.getService<AutomationEngine>('automation');
+
+    objectql.registerDriver(new InMemoryDriver(), true);
+    objectql.registry.registerObject(objectDef('wid'), 'test', 'test');
+    automation.registerFlow('stamp_flow', stampFlow('stamp_flow', 'wid') as any);
+
+    // The flow bound to the trigger…
+    expect((automation as any).getActiveTriggerBindings()).toContainEqual({
+      flowName: 'stamp_flow',
+      triggerType: 'record_change',
+    });
+
+    const created = await data.insert('wid', { status: 'new' });
+    const id = Array.isArray(created) ? created[0]?.id : created?.id ?? created;
+    await sleep(200);
+
+    const row = await data.findOne('wid', { where: { id } });
+    expect(row?.stamp).toBe('done');
+  }, 15000);
+
+  it('fires a flow PULLED FROM THE REGISTRY at automation.start(), bound when the trigger registers on kernel:ready (production ordering)', async () => {
+    const flowDef = stampFlow('stamp_flow2', 'wid2');
+
+    // Seeds the driver + object + flow into the registry in start(), which runs
+    // before AutomationServicePlugin.start() pulls flows — the production
+    // sequence (metadata seeds → automation pulls → trigger binds on
+    // kernel:ready via re-activation of the already-registered flow).
+    const seeder = {
+      name: 'test.seeder',
+      type: 'standard',
+      version: '1.0.0',
+      dependencies: ['com.objectstack.engine.objectql'],
+      async init() {},
+      async start(ctx: any) {
+        const ql = ctx.getService('objectql');
+        ql.registerDriver(new InMemoryDriver(), true);
+        ql.registry.registerObject(objectDef('wid2'), 'test', 'test');
+        ql.registry.registerItem('flow', flowDef, 'name', 'test');
+      },
+    };
+
+    const kernel = new ObjectKernel({ logLevel: 'silent' });
+    await kernel.use(new ObjectQLPlugin());
+    await kernel.use(seeder as any);
+    await kernel.use(new AutomationServicePlugin());
+    await kernel.use(new RecordChangeTriggerPlugin());
+    await kernel.bootstrap();
+
+    const data = kernel.getService('data') as any;
+    const automation = kernel.getService<AutomationEngine>('automation');
+
+    // The registry-pulled flow bound to the trigger after kernel:ready.
+    expect((automation as any).getActiveTriggerBindings()).toContainEqual({
+      flowName: 'stamp_flow2',
+      triggerType: 'record_change',
+    });
+
+    const created = await data.insert('wid2', { status: 'new' });
+    const id = Array.isArray(created) ? created[0]?.id : created?.id ?? created;
+    await sleep(200);
+
+    const row = await data.findOne('wid2', { where: { id } });
+    expect(row?.stamp).toBe('done');
+  }, 15000);
+});