Reorganize repo structure and standards references

This commit is contained in:
david committed 2026-06-29 05:03:42 +02:00
1 parent 3cb93a81be
commit be2054274d
5885 files changed
+2588 -195

No files matched your search

@@ -0,0 +1,198 @@
import { describe, it, expect, vi } from "vitest";
import {
startSequenceRun,
advanceSequenceRun,
type SequenceEngineStore,
type SequenceEngineQueue,
type SequenceRunRow,
} from "./engine.js";
import type { SequenceDefinition } from "./types.js";
function makeStore(initial: SequenceRunRow | null = null): SequenceEngineStore & {
createdDeliveries: Array<{ runId: string; stepIndex: number; scheduledAt: Date }>;
createdRuns: Array<{ sequenceId: string }>;
statusUpdates: Array<{ runId: string; status: string }>;
} {
const createdDeliveries: Array<{ runId: string; stepIndex: number; scheduledAt: Date }> = [];
const createdRuns: Array<{ sequenceId: string }> = [];
const statusUpdates: Array<{ runId: string; status: string }> = [];
return {
createdDeliveries,
createdRuns,
statusUpdates,
createRun: vi.fn(async ({ sequenceId, leadId, tenantId, triggerEventId }) => {
createdRuns.push({ sequenceId });
return {
id: `run_${createdRuns.length}`,
sequenceId,
leadId,
tenantId,
triggerEventId,
status: "running" as const,
startedAt: new Date("2026-05-17T12:00:00Z"),
completedAt: null,
stepStateJson: null,
};
}),
findRunByTrigger: vi.fn(async () => initial),
updateRunStatus: vi.fn(async (runId, status) => {
statusUpdates.push({ runId, status });
}),
createDelivery: vi.fn(async ({ runId, stepIndex, scheduledAt }) => {
createdDeliveries.push({ runId, stepIndex, scheduledAt });
return {
id: `del_${createdDeliveries.length}`,
runId,
stepIndex,
status: "pending" as const,
scheduledAt,
};
}),
};
}
function makeQueue(): SequenceEngineQueue & { scheduled: Array<{ runId: string; stepIndex: number; runAt: Date }> } {
const scheduled: Array<{ runId: string; stepIndex: number; runAt: Date }> = [];
return {
scheduled,
scheduleStep: vi.fn(async (args) => {
scheduled.push(args);
}),
};
}
const BASE_SEQUENCE: SequenceDefinition = {
id: "seq_1",
tenantId: null,
name: "Welcome",
description: null,
triggerEvent: "lead.captured",
isEnabled: true,
steps: [
{ stepIndex: 0, delayHours: 0, template: "welcome", subject: "Welcome" },
{ stepIndex: 1, delayHours: 24, template: "generic-step", subject: "Day 1" },
{ stepIndex: 2, delayHours: 72, template: "generic-step", subject: "Day 3" },
],
};
const TRIGGER = {
triggerEventId: "evt_1",
leadId: "lead_1",
tenantId: null,
email: "alice@example.com",
recipientName: "Alice",
payload: { lead: { status: "new" } },
} as const;
const NOW = () => new Date("2026-05-17T12:00:00Z");
describe("startSequenceRun", () => {
it("creates a run and schedules step 0 immediately when delayHours=0", async () => {
const store = makeStore();
const queue = makeQueue();
const result = await startSequenceRun({ sequence: BASE_SEQUENCE, trigger: TRIGGER }, { store, queue, now: NOW });
expect(result.scheduled).toBe(true);
expect(result.alreadyExisted).toBe(false);
expect(store.createdRuns).toHaveLength(1);
expect(store.createdDeliveries).toHaveLength(1);
expect(store.createdDeliveries[0]?.scheduledAt.toISOString()).toBe("2026-05-17T12:00:00.000Z");
expect(queue.scheduled).toHaveLength(1);
});
it("returns the existing run when (sequence, trigger-event-id) already produced one", async () => {
const existing: SequenceRunRow = {
id: "run_existing",
sequenceId: BASE_SEQUENCE.id,
leadId: "lead_1",
tenantId: null,
triggerEventId: "evt_1",
status: "running",
startedAt: NOW(),
completedAt: null,
stepStateJson: null,
};
const store = makeStore(existing);
const queue = makeQueue();
const result = await startSequenceRun({ sequence: BASE_SEQUENCE, trigger: TRIGGER }, { store, queue, now: NOW });
expect(result.alreadyExisted).toBe(true);
expect(store.createdRuns).toHaveLength(0);
expect(queue.scheduled).toHaveLength(0);
});
it("skips disabled sequences", async () => {
const store = makeStore();
const queue = makeQueue();
const result = await startSequenceRun(
{ sequence: { ...BASE_SEQUENCE, isEnabled: false }, trigger: TRIGGER },
{ store, queue, now: NOW }
);
expect(result.scheduled).toBe(false);
expect(store.createdRuns).toHaveLength(0);
});
it("skips when sequence-level conditions are false", async () => {
const store = makeStore();
const queue = makeQueue();
const result = await startSequenceRun(
{
sequence: {
...BASE_SEQUENCE,
conditions: [{ path: "lead.status", op: "eq", value: "qualified" }],
},
trigger: TRIGGER,
},
{ store, queue, now: NOW }
);
expect(result.scheduled).toBe(false);
expect(store.createdRuns).toHaveLength(0);
});
});
describe("advanceSequenceRun", () => {
it("schedules the next step with its delay-from-now", async () => {
const store = makeStore();
const queue = makeQueue();
const run: SequenceRunRow = {
id: "run_1",
sequenceId: "seq_1",
leadId: "lead_1",
tenantId: null,
triggerEventId: "evt_1",
status: "running",
startedAt: NOW(),
completedAt: null,
stepStateJson: null,
};
const result = await advanceSequenceRun(
{ run, steps: BASE_SEQUENCE.steps, previousStepIndex: 0 },
{ store, queue, now: NOW }
);
expect(result.completed).toBe(false);
expect(result.scheduledAt?.toISOString()).toBe("2026-05-18T12:00:00.000Z");
expect(queue.scheduled).toHaveLength(1);
expect(queue.scheduled[0]?.stepIndex).toBe(1);
});
it("completes the run when no further steps exist", async () => {
const store = makeStore();
const queue = makeQueue();
const run: SequenceRunRow = {
id: "run_1",
sequenceId: "seq_1",
leadId: "lead_1",
tenantId: null,
triggerEventId: "evt_1",
status: "running",
startedAt: NOW(),
completedAt: null,
stepStateJson: null,
};
const result = await advanceSequenceRun(
{ run, steps: BASE_SEQUENCE.steps, previousStepIndex: 2 },
{ store, queue, now: NOW }
);
expect(result.completed).toBe(true);
expect(store.statusUpdates).toEqual([{ runId: "run_1", status: "completed" }]);
expect(queue.scheduled).toHaveLength(0);
});
});