@endora-commerce/test-kit 0.100.0

package/dist/database/run-isolation.d.ts

@@ -0,0 +1,356 @@
+/**
+ * Per-invocation test isolation (issue #189).
+ *
+ * ## The defect
+ *
+ * Isolation in this suite is **per database and per Redis instance**, not per
+ * invocation. `helpers/test-server.ts` truncates `SEEDED_TABLES`, composes a
+ * server and seeds fixtures on every booting file, so a second `vitest run`
+ * against the same `b2b_test` lands its truncate in the middle of the first
+ * one's setup. Three agents hit that in one day and every one of them read it
+ * as a real failure first: `Hook timed out in 30000ms` in `beforeAll`, then
+ * `Cannot read properties of undefined (reading 'app')` in the teardown that
+ * never got a handle; a shifting subset of one directory failing with 403s and
+ * missing fixtures, a different subset each run; and a role created through the
+ * API reading back `null` because another invocation had truncated
+ * `admin_roles` between the write and the read.
+ *
+ * The cost is not the flakes. It is that a false failure is indistinguishable
+ * from a true one, so the failure is either chased for an hour or — worse —
+ * dismissed as "probably the shared database" when it is real.
+ *
+ * ## The answer
+ *
+ * A run gets its **own** database and its **own** Redis logical database,
+ * automatically. The escape hatch already existed and was manual — every agent
+ * that got clean results set `TEST_DATABASE_URL=…/b2b_<something>_test` by hand
+ * — so this makes the thing that already worked the default rather than a thing
+ * you have to know. (156 hand-named test databases were standing on the
+ * developer machine that reported this, 4.1 GB of them, which is the other half
+ * of what "manual" costs.)
+ *
+ * **Per invocation, not per file.** The harness's per-file cost already
+ * dominates the suite (issue #72: a truncate is 1149 ms per composition), so a
+ * fresh database per *file* would be unaffordable. Per invocation is the
+ * granularity the defect actually has.
+ *
+ * **Cloned, not migrated.** `<base>_tpl` is the migrated template — created and
+ * brought up to date once, under an advisory lock so concurrent invocations
+ * cannot race on it — and each run is `create database … template <base>_tpl`,
+ * which is a file copy: 0.2 s warm against the 39 MB this schema occupies.
+ * Nothing about the migration coverage changes: the template is still migrated
+ * from scratch on a fresh cluster, which is what the CI job's comment about
+ * exercising the whole chain is protecting.
+ *
+ * **And it is the template of this run's migration set, not the machine's.**
+ * `<base>_tpl_<digest>` (issue #289): the digest covers the ordered migration
+ * class names *and* the content of every file that writes into a template, so
+ * two branches that differ anywhere a template can see get two templates, and
+ * two trees that agree share one and migrate once between them. Before that
+ * there was one `<base>_tpl` and a check comparing applied migration *names*
+ * against the configured order — which catches a branch that added a migration
+ * and cannot catch one that changed what a migration of the same name does.
+ * See `templateDigest`. What the name claims is checked against the template's
+ * own provenance comment and against `mikro_orm_migrations` before anything is
+ * cloned; a template that cannot account for itself is rebuilt, never used.
+ *
+ * **Names satisfy the existing guard.** `runDatabaseName` refuses to produce a
+ * name `TEST_DATABASE_NAME_PATTERN` would not accept, so the harness's refusal
+ * to truncate a non-test database is untouched — not loosened, not bypassed.
+ * That predicate lives here now and every caller imports it, so there is
+ * one spelling of it rather than three.
+ *
+ * **Redis by logical database index, not by key prefix.** Every Redis client in
+ * this tree — 8 in `src/`, 40-odd in `test/` — is built as
+ * `new Redis(process.env['REDIS_URL'] ?? 'redis://localhost:6379')`, and
+ * ioredis reads the index off the DSN path. Pointing `REDIS_URL` at
+ * `…/<index>` therefore isolates all of them, including BullMQ, with no call
+ * site changed. A key prefix would have to be threaded through every one of
+ * those constructions, and `keys(pattern)` — which `dropStaleCaches` uses — is
+ * not a key-taking command as far as ioredis is concerned, so a prefixed client
+ * would still scan and delete another run's keys.
+ *
+ * ## Cleanup
+ *
+ * The run database is dropped by the lease's own release. A **crashed**
+ * run cannot run its teardown, so every invocation also sweeps: run databases
+ * carry their creation instant in their name, and one older than
+ * `STALE_RUN_DATABASE_MS` with no connection to it is dropped, at most
+ * `SWEEP_LIMIT` per invocation. Only names this module generated are ever
+ * considered — the 156 hand-named databases and anything else on the cluster
+ * are outside the pattern by construction, and `strandedRunDatabases` is
+ * unit-tested on exactly that. Redis leases expire on their own TTL.
+ *
+ * **Templates are collected too**, and have to be: one per migration set means
+ * one left behind whenever a branch gains a migration or is rebased.
+ * `staleTemplates` is the other half of the bargain keying them made — same
+ * three conditions, with the age read from the template's provenance rather
+ * than from its name, because what matters about a template is when it was last
+ * *used*.
+ */
+/**
+ * A database name that says "this database exists to be wiped".
+ *
+ * The one spelling of the judgement. `assertTestDatabaseUrl` applies it before
+ * a run touches anything, `runDatabaseName` refuses to emit a name that fails
+ * it, and the application's own dev-seed guard keeps its copy pinned to this one
+ * by a test of its own — `backend/src/seeds/dev-seed-guard.ts` is `src/`, so it
+ * cannot import a test's module and has to re-spell the regex.
+ */
+export declare const TEST_DATABASE_NAME_PATTERN: RegExp;
+/** How many hex characters of the digest a template name carries. */
+export declare const TEMPLATE_DIGEST_LENGTH = 12;
+/** How old a run database must be before a sweep may take it for stranded. */
+export declare const STALE_RUN_DATABASE_MS: number;
+/**
+ * How long a template survives with nothing using it.
+ *
+ * Templates are keyed by the migration set, so a branch that adds a migration
+ * leaves the previous set's template behind the moment it is rebased or merged.
+ * A day of nobody asking for a set is the point at which keeping its 19 MB
+ * costs more than the one migration pass rebuilding it would.
+ */
+export declare const STALE_TEMPLATE_MS: number;
+/** How many stranded databases one invocation drops, so a sweep cannot become the run's cost. */
+export declare const SWEEP_LIMIT = 25;
+/** The environment variable that turns per-invocation isolation off. */
+export declare const ISOLATION_ENV = "BACKEND_TEST_ISOLATION";
+/** Set this to keep the run database after the run, for a post-mortem. */
+export declare const KEEP_DATABASE_ENV = "BACKEND_TEST_KEEP_DATABASE";
+/**
+ * The base DSN, exported to the workers by the lease on the isolated
+ * path only.
+ *
+ * Its **presence is the statement** "this invocation has a migrated template,
+ * and a file that needs a database of its own may clone it" — which is what
+ * `setupMigratorTestDb` asks. Nothing derives it from the run database's name:
+ * a run database is `<base>_r_<stamp>_<token>` and taking the base back out of
+ * one would be a second, weaker spelling of `runDatabaseName`.
+ */
+export declare const BASE_DATABASE_URL_ENV = "BACKEND_TEST_BASE_URL";
+/**
+ * The template this run was cloned from, exported to the workers alongside it.
+ *
+ * A name and not a derivation, because since #289 there is more than one
+ * template on the cluster and which one is this run's is a fact about the run,
+ * not about the base: another invocation may build a template of its own while
+ * this one is still going, and a file that re-derived "the template" mid-run
+ * would clone whichever set happened to be newest.
+ */
+export declare const TEMPLATE_DATABASE_ENV = "BACKEND_TEST_TEMPLATE";
+export type IsolationMode = 'per-invocation' | 'shared';
+export declare function isolationMode(env?: NodeJS.ProcessEnv): IsolationMode;
+/**
+ * Why this run is sharing the base database rather than taking one of its own,
+ * or `undefined` when it is not.
+ */
+export declare function sharedDatabaseReason(env: NodeJS.ProcessEnv, baseName: string): 'explicit' | 'name-override' | undefined;
+/** Whether this run keeps its database for a post-mortem instead of dropping it. */
+export declare function keepRunDatabase(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * The migrated source every run of *this migration set* is cloned from.
+ *
+ * The digest is in the name because that is what makes two different migration
+ * sets two different databases: a template is shared exactly by the runs whose
+ * platform it actually is, and never by the runs that merely share a cluster
+ * with it. See `templateDigest` for what "the same set" means, and issue #289
+ * for what one shared `<base>_tpl` cost.
+ */
+export declare function templateDatabaseName(base: string, digest: string): string;
+/**
+ * The lock every invocation of this base takes before it touches a template.
+ *
+ * One key for the whole family rather than one per digest: a sweep walks the
+ * templates of *other* digests, so it has to exclude an invocation that is
+ * half-way through building one. It is also, deliberately, the exact string the
+ * pre-#289 code derived its key from, so an invocation running that code still
+ * serializes against this one while the two versions coexist on a machine.
+ */
+export declare function templateFamilyName(base: string): string;
+/** The digest a template name carries, or `undefined` for a name this module did not make. */
+export declare function parseTemplateDatabaseName(base: string, name: string): {
+    readonly digest: string;
+} | undefined;
+/** What a template is built from: this run's migration order and the sources behind it. */
+export interface TemplateInputs {
+    /** The migration class names this run applies, in the order it applies them. */
+    readonly migrations: readonly string[];
+    /** Every file whose content decides what the migrated template holds. */
+    readonly sources: readonly TemplateSource[];
+}
+export interface TemplateSource {
+    /** Repository-relative, so two worktrees of the same commit agree. */
+    readonly path: string;
+    readonly sha256: string;
+}
+/**
+ * What makes two runs' templates the same template.
+ *
+ * Issue #189 keyed the template on the base database alone and compared the
+ * *names* of the applied migrations against this run's order before cloning it.
+ * That catches a template another branch added a migration to. It does not
+ * catch — and cannot — a branch that changed what a migration of the same name
+ * *does*, which is the ordinary shape of two agents iterating on the same
+ * feature, and it is how a run whose tree contained no such string failed
+ * against a payment method row called `paypal_checkout` seeded from a branch it
+ * had never seen (issue #289).
+ *
+ * So the identity is the whole input: the ordered class names — order included,
+ * because a manifest `dependencies` edit reorders migrations without touching
+ * one of them — and the content of every file that writes into the template,
+ * which is every migration source plus the handful of files that seed the
+ * platform invariants. Two trees that agree on all of it share a template and
+ * pay one migration pass between them; two that do not cannot collide, because
+ * they are not looking at the same database at all.
+ *
+ * It **throws on an empty input** rather than digesting nothing: every empty
+ * input hashes to the same value, so a caller that read no migrations would
+ * quietly name the same template as a caller that read all of them — a template
+ * of unknown provenance, which is the defect and not a fix for it.
+ */
+export declare function templateDigest(inputs: TemplateInputs): string;
+/** What a template says about itself, in the comment PostgreSQL keeps on the database. */
+export interface TemplateProvenance {
+    readonly digest: string;
+    /** How many migrations were applied when it was built — a second, cheaper thing to disagree about. */
+    readonly migrations: number;
+    readonly lastUsedAt: Date;
+}
+export declare function formatTemplateProvenance(provenance: TemplateProvenance): string;
+/**
+ * What the template says it is, or `undefined` when it says nothing this
+ * version understands.
+ *
+ * Every "undefined" is a template a run must rebuild rather than clone: an
+ * older version's template, a hand-made database that happens to fit the name,
+ * one whose build died before it could sign itself. "I cannot tell what this
+ * holds" and "this holds the wrong thing" get the same answer on purpose.
+ */
+export declare function parseTemplateProvenance(comment: string | null | undefined): TemplateProvenance | undefined;
+export interface StaleTemplateSelection {
+    readonly base: string;
+    /** Every database name on the cluster. */
+    readonly names: readonly string[];
+    readonly busy: ReadonlySet<string>;
+    /** This invocation's own template, which is never stale. */
+    readonly keep: string;
+    /** When each template was last used, from its own provenance comment. */
+    readonly lastUsed: ReadonlyMap<string, Date>;
+    readonly now: Date;
+    readonly maxAgeMs: number;
+    readonly limit: number;
+}
+/**
+ * The templates a sweep may drop.
+ *
+ * Keying templates by their migration set is what stops two branches sharing
+ * one; the cost of it is that a branch leaves its set's template behind when it
+ * merges, so something has to collect them. Same three conditions as the run
+ * database sweep — a name this module generated, nothing connected, nobody
+ * using it lately — with the age read from the template's own provenance
+ * comment rather than from its name, because a template's useful age is when it
+ * was last *used* and not when it was built.
+ *
+ * A template with no readable provenance is stale immediately. It is a database
+ * no run would clone anyway (provisioning rebuilds one it cannot identify), so
+ * leaving it costs disk and buys nothing. The pre-#289 `<base>_tpl` is not in
+ * the population at all — `parseTemplateDatabaseName` refuses it — because an
+ * invocation running older code clones that one *during* its run, and dropping
+ * it under such a run would fail it for a reason in nobody's diff.
+ */
+export declare function staleTemplates(input: StaleTemplateSelection): string[];
+export declare function randomRunToken(): string;
+/**
+ * `<base>_r_<epoch-seconds base36>_<6 hex>`.
+ *
+ * The instant is in the name because `pg_database` has no creation timestamp
+ * and the sweep needs an age. The random tail is what makes two invocations
+ * starting in the same second distinct.
+ */
+export declare function runDatabaseName(base: string, createdAt?: Date, token?: string): string;
+export declare function parseRunDatabaseName(base: string, name: string): {
+    readonly createdAt: Date;
+} | undefined;
+export interface StrandedSelection {
+    readonly base: string;
+    /** Every database name on the cluster. */
+    readonly names: readonly string[];
+    /** Names with at least one session connected, from `pg_stat_activity`. */
+    readonly busy: ReadonlySet<string>;
+    /** This invocation's own database, which is never stranded. */
+    readonly keep: string;
+    readonly now: Date;
+    readonly maxAgeMs: number;
+    readonly limit: number;
+}
+/**
+ * The stranded run databases a sweep may drop.
+ *
+ * Three conditions, and each one is load-bearing: the name is one this module
+ * generated (so no foreign database is ever a candidate), it is older than the
+ * threshold (so a live run is not taken for a corpse — the complete suite takes
+ * the better part of an hour), and nothing is connected to it right now (a
+ * booting file closes the ORM between files, so idleness alone would not be
+ * enough, which is why it is `and` rather than `or`).
+ */
+export declare function strandedRunDatabases(input: StrandedSelection): string[];
+/** The same DSN, pointed at another database on the same server. */
+export declare function withDatabase(url: string, database: string): string;
+export declare function databaseNameOf(url: string): string;
+/** The same Redis DSN, pointed at a logical database index. */
+export declare function redisUrlWithDatabase(url: string, index: number): string;
+/** Whether a Redis DSN already names a logical database — an explicit choice this module leaves alone. */
+export declare function redisUrlNamesDatabase(url: string): boolean;
+/** Identifies this invocation in a Redis lease and in the log lines. */
+export declare function runIdentity(): string;
+/**
+ * A 32-bit key for `pg_advisory_lock`, derived from the template name so two
+ * bases do not serialize against each other. FNV-1a, folded into a signed int.
+ */
+export declare function advisoryLockKey(name: string): number;
+/**
+ * Why the migration template cannot be brought forward to this run's migration
+ * set by `migrator.up()`, and must be rebuilt from empty instead.
+ */
+export interface TemplateDrift {
+    /**
+     * `unknown-migration` — a name applied to the template that this run's
+     * registry does not contain at all. `out-of-order` — one of this run's own
+     * migrations, applied in a position the configured order does not put it in.
+     */
+    readonly kind: 'unknown-migration' | 'out-of-order';
+    /** The applied migration the judgement is about. */
+    readonly name: string;
+    /** The migration this run's order has in that position, when there is one. */
+    readonly expected?: string;
+    /** The whole finding as one line, for the log or for a throw. */
+    readonly message: string;
+}
+/**
+ * Whether the template is a database this run's migrations could have produced.
+ *
+ * The template is **long-lived and shared by every branch on the machine**, and
+ * it is only ever moved forward by `migrator.up()`, which appends. That is
+ * enough exactly when what is already applied is a **prefix** of the order this
+ * run configures: then the pending ones land after it, and the result is the
+ * order a database migrated from scratch today would have. Anything else —
+ * another branch's migration, or one of ours applied somewhere the order does
+ * not put it — is a database no `up()` can repair, so it is rebuilt.
+ *
+ * Both shapes are ordinary here, not exotic. Five agents share one cluster, so
+ * a template routinely carries a migration the branch running has never heard
+ * of; and `orderMigrations` places a migration by its module's position in the
+ * dependency graph, so a migration added anywhere but the last module lands at
+ * the **end** of an incrementally-migrated template and in the **middle** of a
+ * fresh one.
+ *
+ * That is not cosmetic. It broke
+ * `test/integration/catalog/attributes-migration-parity.test.ts`, which drives
+ * the real migrator: umzug reverts the last migration in *configured* order,
+ * while the test reads the last one in *applied* (`id`) order, and the two stop
+ * agreeing the moment the template stops being a prefix. The test then walked
+ * `down()` past its own target, never reached its termination condition, timed
+ * out, and left the run database with most of its schema reverted.
+ */
+export declare function templateDrift(applied: readonly string[], expected: readonly string[], templateName?: string): TemplateDrift | undefined;
+//# sourceMappingURL=run-isolation.d.ts.map

package/dist/database/run-isolation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-isolation.d.ts","sourceRoot":"","sources":["../../src/database/run-isolation.ts"],"names":[],"mappings":"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"}