wishforge-ide/tests/helpers/memory-store.ts
eust-w 0b4c09f7eb refactor: declare every entity field instead of an open index signature
Entity carried `[key: string]: unknown`, so a misspelt field compiled and most
records were read as untyped bags. Every stored kind now has an interface in
contracts (workspace, runner task and registration, provider connection,
checkpoint record, resource allocation, integration lease, delivery config) and
the project, run, release and evidence types list all their fields. Entity writes
are generic over the record type, and the project delivery settings no longer
accept a stray target branch.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 16:32:36 +08:00

128 lines
5.7 KiB
TypeScript

import type { Entity, EntityKind, Role, RunEvent } from '@wishforge/contracts';
import type { ListFilter, Meter, OutboxItem, Store, Tenant, Transaction } from '../../apps/api/src/db/store.js';
import { normalizeMeter, OUTBOX_PRIORITY } from '../../apps/api/src/db/store.js';
type State = {
tenant: Tenant;
members: Map<string, Role>;
entities: Map<string, Entity>;
events: RunEvent[];
keys: Map<string, { digest: string; response: unknown }>;
outbox: Array<OutboxItem & { claimedUntil?: number }>;
meters: Meter[];
};
/** Transactional test double. Production never falls back to this store. */
export class MemoryStore implements Store {
readonly state = new Map<string, State>();
private tail: Promise<unknown> = Promise.resolve();
seed(id: string, tokenLimit = 2_000_000) {
this.state.set(id, {
tenant: { id, name: id, region: 'test', maxConcurrentRuns: 2, tokenLimit },
members: new Map([
['owner', 'owner'],
['viewer', 'viewer'],
]),
entities: new Map(),
events: [],
keys: new Map(),
outbox: [],
meters: [],
});
}
transaction<T>(tenantId: string, work: (tx: Transaction) => Promise<T>): Promise<T> {
return this.run(tenantId, work, true);
}
/** Like PostgreSQL's read-only transactions: changes made inside are discarded. */
read<T>(tenantId: string, work: (tx: Transaction) => Promise<T>): Promise<T> {
return this.run(tenantId, work, false);
}
private run<T>(tenantId: string, work: (tx: Transaction) => Promise<T>, commit: boolean): Promise<T> {
const next = this.tail.then(async () => {
const existing = this.state.get(tenantId);
if (!existing) throw new Error('Tenant missing');
const s = structuredClone(existing);
const tx: Transaction = {
tenant: async () => s.tenant,
membership: async id => s.members.get(id),
members: async () => [...s.members.entries()].map(([userId, role]) => ({ userId, role, active: true })),
putMembership: async member => {
if (member.active) s.members.set(member.userId, member.role);
else s.members.delete(member.userId);
},
get: async <E extends Entity>(kind: EntityKind, id: string) =>
structuredClone(s.entities.get(`${kind}:${id}`)) as E | undefined,
// Newest first, as PostgreSQL orders them; equal timestamps keep the later insert first.
list: async <E extends Entity>(kind: EntityKind, filter: ListFilter = {}) => {
const matching = [...s.entities.entries()]
.filter(([k]) => k.startsWith(`${kind}:`))
.map(([, v]) => v)
.reverse()
.sort((a, b) => b.createdAt.localeCompare(a.createdAt))
.filter(v => {
const fields = v as unknown as Record<string, unknown>;
return (
(filter.projectId === undefined || fields.projectId === filter.projectId) &&
(filter.runId === undefined || fields.runId === filter.runId) &&
(filter.status === undefined || fields.status === filter.status) &&
(filter.before === undefined || v.createdAt < filter.before)
);
});
return structuredClone(filter.limit ? matching.slice(0, filter.limit) : matching) as E[];
},
put: async (kind, value) => {
if (value.tenantId !== tenantId) throw new Error('Tenant mismatch');
s.entities.set(`${kind}:${value.id}`, structuredClone(value));
},
remove: async (kind, id) => {
s.entities.delete(`${kind}:${id}`);
},
event: async (runId, type, message, data) => {
const seq = s.events.filter(e => e.runId === runId).length + 1;
const e = { id: `${runId}:${seq}`, seq, runId, type, message, data, time: new Date().toISOString() };
s.events.push(e);
return e;
},
events: async (runId, after = 0) => s.events.filter(e => e.runId === runId && e.seq > after),
idempotency: async k => s.keys.get(k),
remember: async (k, digest, response) => {
s.keys.set(k, { digest, response: structuredClone(response) });
},
enqueue: async (type, payload, id = `${type}:${s.outbox.length}`) => {
if (!s.outbox.some(x => x.id === id)) s.outbox.push({ id, type, payload, attempts: 0 });
},
outbox: async () => s.outbox.map(({ claimedUntil: _, ...item }) => item),
claimOutbox: async (types, seconds) => {
const rank = (type: string) =>
OUTBOX_PRIORITY.includes(type) ? OUTBOX_PRIORITY.indexOf(type) : OUTBOX_PRIORITY.length;
const due = s.outbox
.filter(item => types.includes(item.type) && (item.claimedUntil ?? 0) <= Date.now())
.sort((a, b) => rank(a.type) - rank(b.type))
.slice(0, 50);
for (const item of due) item.claimedUntil = Date.now() + seconds * 1000;
return due.map(({ claimedUntil: _, ...item }) => structuredClone(item));
},
acknowledge: async id => {
s.outbox = s.outbox.filter(x => x.id !== id);
},
defer: async id => {
const item = s.outbox.find(x => x.id === id);
if (item) {
item.attempts++;
item.claimedUntil = undefined;
}
},
prune: async () => {},
meter: async m => {
if (!s.meters.some(x => x.id === m.id)) s.meters.push(normalizeMeter(m));
},
usage: async since => s.meters.filter(m => m.at >= since),
};
const value = await work(tx);
if (commit) this.state.set(tenantId, s);
return value;
});
this.tail = next.catch(() => undefined);
return next;
}
async close() {}
}