@prisma-next/migration-tools 0.5.0-dev.62 → 0.5.0-dev.63

package/dist/exports/spaces.d.mts

@@ -0,0 +1,447 @@
+import { APP_SPACE_ID } from "@prisma-next/framework-components/control";
+
+//#region src/concatenate-space-apply-inputs.d.ts
+
+/**
+ * Per-space input the runner consumes when applying a migration.
+ *
+ * The shape is target-agnostic: callers (today the SQL family; later
+ * any other family) bind `TOp` to their own per-target operation type
+ * (e.g. `SqlMigrationPlanOperation<TTargetDetails>` for the SQL family)
+ * and the helper preserves it through the concatenation.
+ *
+ * - `migrationDirectory` is the on-disk migration directory for the
+ *   space — `<projectRoot>/migrations` for `'app'` and
+ *   `<projectRoot>/migrations/<space-id>` for an extension space.
+ * - `currentMarkerHash` and `currentMarkerInvariants` are the values
+ *   read from the `prisma_contract.marker` row keyed by `space = <space-id>`
+ *   (T1.1). `null` hash = no marker row yet.
+ * - `path` is the per-space operation list resolved from
+ *   `findPathWithDecision(currentMarker, ref.hash, effectiveRequired)`
+ *   per ADR 208, materialised against the on-disk migration packages.
+ *
+ * @see specs/framework-mechanism.spec.md § 4 — Runner.
+ */
+interface SpaceApplyInput<TOp> {
+  readonly spaceId: string;
+  readonly migrationDirectory: string;
+  readonly currentMarkerHash: string | null;
+  readonly currentMarkerInvariants: readonly string[];
+  readonly path: readonly TOp[];
+}
+/**
+ * Order a set of per-space apply inputs into the canonical cross-space
+ * sequence the runner applies under a single transaction.
+ *
+ * Cross-space ordering convention (sub-spec § 4):
+ *
+ * 1. **Extension spaces first**, alphabetically by `spaceId`.
+ * 2. **App space last** — only one `'app'` entry expected, at most.
+ *
+ * Rationale: extensions install their own structural objects (types,
+ * functions, helper tables) before the app's structural ops reference
+ * them. Putting app-space last lets app-space ops freely depend on any
+ * extension-space declaration in the same transaction.
+ *
+ * Determinism (NFR6): the output order is independent of the input
+ * order, so two callers with the same set of `extensionPacks` produce
+ * identical apply sequences.
+ *
+ * Atomicity: rejects duplicate `spaceId`s with
+ * `MIGRATION.DUPLICATE_SPACE_ID` before producing any output. This
+ * mirrors {@link import('./plan-all-spaces').planAllSpaces} so the
+ * planner-side and runner-side helpers reject malformed inputs the same
+ * way (callers don't need a separate dedup pass).
+ *
+ * Synchronous, pure, no I/O: callers resolve marker rows and `path`
+ * before invoking this helper. The actual DB application — driving the
+ * transaction, committing marker writes, recording the per-space marker
+ * rows — happens at the SQL-family consumption site (per the
+ * helper-location convention from R3).
+ */
+declare function concatenateSpaceApplyInputs<TOp>(inputs: readonly SpaceApplyInput<TOp>[]): readonly SpaceApplyInput<TOp>[];
+//#endregion
+//#region src/detect-space-contract-drift.d.ts
+/**
+ * Inputs for {@link detectSpaceContractDrift}.
+ *
+ * Both hashes are produced by the caller (the SQL-family wiring at the
+ * consumption site) using the canonical contract hashing pipeline.
+ * Keeping the helper pure lets `migration-tools` stay framework-neutral
+ * — the SQL family already speaks `Contract<SqlStorage>`, the Mongo
+ * family speaks its own contract type, and both reduce to a hash string
+ * before drift detection runs.
+ *
+ * `pinnedHash` is `null` when no pinned `contract.json` exists yet for
+ * the space (the descriptor declares an extension that has never been
+ * emitted into the user's repo). That's the "first emit" case — no
+ * drift to surface; the migrate emit will create the pinned files.
+ *
+ * @see specs/framework-mechanism.spec.md § 3 — Drift detection (T1.9).
+ */
+interface DetectSpaceContractDriftInputs {
+  readonly descriptorHash: string;
+  readonly pinnedHash: string | null;
+}
+/**
+ * Result discriminant for {@link detectSpaceContractDrift}.
+ *
+ * - `noDrift`: descriptor hash and pinned hash agree byte-for-byte.
+ *   The migrate emit can proceed with no warning.
+ * - `firstEmit`: no pinned `contract.json` on disk yet. The extension
+ *   was just added to `extensionPacks`; this run will create the
+ *   pinned files. No warning either — the user's intent is to install
+ *   the extension, not to "drift" from a state they haven't pinned.
+ * - `drift`: descriptor hash differs from pinned hash. The caller
+ *   surfaces a non-fatal warning naming the extension and the
+ *   diff direction (descriptor → pinned). The migrate emit proceeds
+ *   normally so the bump is materialised this run; the warning just
+ *   confirms the bump is being captured.
+ *
+ * `spaceId`, `descriptorHash`, and `pinnedHash` are threaded through
+ * verbatim so the caller (logger / TerminalUI / strict-mode envelope)
+ * has everything it needs to format the warning message without
+ * re-reading the descriptor or the pinned file.
+ */
+type SpaceContractDriftResult = {
+  readonly kind: 'noDrift' | 'firstEmit' | 'drift';
+  readonly spaceId: string;
+  readonly descriptorHash: string;
+  readonly pinnedHash: string | null;
+};
+/**
+ * Pure drift-detection primitive for a single contract space.
+ *
+ * Runs once per loaded extension space, just before computing the
+ * `priorContract` that feeds {@link import('./plan-all-spaces').planAllSpaces}.
+ * Hash equality is byte-for-byte (no normalisation) — both sides are
+ * already canonical hashes produced by the same pipeline, so any
+ * difference is meaningful drift.
+ *
+ * Synchronous, pure, no I/O. The caller (SQL family in M2 R1) reads
+ * the pinned `contract.json` and computes its hash, then invokes this
+ * helper alongside the descriptor's `headRef.hash`. Composes naturally
+ * with {@link import('./read-pinned-contract-hash').readPinnedContractHash}
+ * which provides the read-side primitive.
+ *
+ * @see specs/framework-mechanism.spec.md § 3 — Drift detection (T1.9).
+ * @see specs/framework-mechanism.spec.md AM7 — drift warning surfaces
+ *   the extension name and the diff direction.
+ */
+declare function detectSpaceContractDrift(spaceId: string, inputs: DetectSpaceContractDriftInputs): SpaceContractDriftResult;
+//#endregion
+//#region src/emit-pinned-space-artefacts.d.ts
+/**
+ * Pinned head reference for a contract space — `(hash, invariants)`.
+ * Mirrors {@link import('./refs').RefEntry} but is redeclared locally so
+ * callers can construct the input without depending on the refs module.
+ */
+interface PinnedSpaceHeadRef {
+  readonly hash: string;
+  readonly invariants: readonly string[];
+}
+/**
+ * Inputs for {@link emitPinnedSpaceArtefacts}.
+ *
+ * - `contract` is the canonical contract value the framework just emitted
+ *   for the space; it is serialised through {@link canonicalizeJson}, so
+ *   it must be a JSON-compatible value (objects / arrays / primitives).
+ *   Typed as `unknown` rather than the SQL-family `Contract<SqlStorage>`
+ *   to keep `migration-tools` framework-neutral; SQL-family callers pass
+ *   their typed value through unchanged.
+ *
+ * - `contractDts` is the pre-rendered `.d.ts` text. Rendering happens in
+ *   the SQL family (which owns the codec / typemap input the renderer
+ *   needs), so this helper accepts the text verbatim and writes it out
+ *   without further transformation.
+ *
+ * - `headRef` is the pinned head reference for the space.
+ *   `invariants` are sorted alphabetically before serialisation so two
+ *   callers passing the same set in different orders produce
+ *   byte-identical `refs/head.json`.
+ */
+interface PinnedSpaceArtefactInputs {
+  readonly contract: unknown;
+  readonly contractDts: string;
+  readonly headRef: PinnedSpaceHeadRef;
+}
+/**
+ * Emit the pinned per-space artefacts (`contract.json`, `contract.d.ts`,
+ * `refs/head.json`) under `<projectMigrationsDir>/<spaceId>/`.
+ *
+ * Always-overwrite: the framework owns these files; running `migrate`
+ * twice with the same inputs is a no-op observably (idempotent), but the
+ * helper does not check pre-existing contents — re-emit always wins.
+ *
+ * Path layout matches the convention in
+ * [`spaceMigrationDirectory`](./space-layout.ts), with two restrictions
+ * specific to pinned artefacts:
+ *
+ * - Rejects the app space (`spaceId === APP_SPACE_ID`): the app space's
+ *   canonical `contract.json` lives at the project root, not under
+ *   `migrations/`. Callers that want to emit it use the app-space
+ *   contract emit pipeline.
+ * - Validates `spaceId` against `[a-z][a-z0-9_-]{0,63}` via
+ *   {@link assertValidSpaceId} for the same filesystem-safety reasons.
+ *
+ * The migrations directory and space subdirectory are created if they
+ * do not yet exist (`mkdir { recursive: true }`).
+ *
+ * @see specs/framework-mechanism.spec.md § 3 — Pinned artefact emission (T1.8).
+ */
+declare function emitPinnedSpaceArtefacts(projectMigrationsDir: string, spaceId: string, inputs: PinnedSpaceArtefactInputs): Promise<void>;
+//#endregion
+//#region src/plan-all-spaces.d.ts
+/**
+ * Per-space input for {@link planAllSpaces}. One entry per loaded
+ * contract space (the application's `'app'` plus each extension that
+ * exposes a `contractSpace`).
+ *
+ * - `priorContract` is `null` for a space that has never been emitted
+ *   (no `migrations/<space-id>/contract.json` on disk yet); otherwise it
+ *   is the canonical contract value pinned for that space.
+ * - `newContract` is the canonical contract value the planner is about
+ *   to emit for that space — for app-space, the just-emitted root
+ *   `contract.json`; for an extension space, the descriptor's
+ *   `contractSpace.contractJson`.
+ *
+ * @see specs/framework-mechanism.spec.md § 3.
+ */
+interface SpacePlanInput<TContract> {
+  readonly spaceId: string;
+  readonly priorContract: TContract | null;
+  readonly newContract: TContract;
+}
+interface SpacePlanOutput<TPackage> {
+  readonly spaceId: string;
+  readonly migrationPackages: readonly TPackage[];
+}
+/**
+ * Iterate the per-space planner across a set of loaded contract spaces
+ * and return a deterministic shape regardless of declaration order.
+ *
+ * Behaviour:
+ *
+ * - The output is sorted alphabetically by `spaceId` (AM3). Two callers
+ *   passing the same set of inputs in different orders observe
+ *   byte-identical outputs.
+ * - The per-space planner (`planSpace`) is called exactly once per
+ *   input, in alphabetical-by-spaceId order. Its return value is
+ *   attached to the corresponding output entry verbatim.
+ * - Duplicate `spaceId`s in the input array throw
+ *   `MIGRATION.DUPLICATE_SPACE_ID` before any `planSpace` call runs,
+ *   keeping the planner pure when the input is malformed.
+ *
+ * The signature is generic over `TContract` and `TPackage` because the
+ * shape is framework-neutral (SQL family today, Mongo family
+ * eventually). Callers wire in whatever contract value and migration
+ * package shape their family already speaks.
+ *
+ * Synchronous: the underlying per-space planner (target's
+ * `MigrationPlanner.plan(...)`) is synchronous; callers that need to
+ * resolve async I/O (e.g. reading pinned `contract.json` from disk)
+ * resolve it before calling `planAllSpaces` and pass the materialised
+ * inputs through.
+ *
+ * @see specs/framework-mechanism.spec.md § 3 — Per-space planner (T1.3).
+ */
+declare function planAllSpaces<TContract, TPackage>(inputs: readonly SpacePlanInput<TContract>[], planSpace: (input: SpacePlanInput<TContract>) => readonly TPackage[]): readonly SpacePlanOutput<TPackage>[];
+//#endregion
+//#region src/read-pinned-contract-hash.d.ts
+/**
+ * Read the pinned head hash for an extension space.
+ *
+ * Returns the `hash` field of `<projectMigrationsDir>/<spaceId>/refs/head.json`
+ * — i.e. the canonical contract hash the framework wrote on the last
+ * `migrate` for this space. Returns `null` when the file does not exist
+ * (or the migrations directory is missing entirely), which is the
+ * "first emit" signal {@link import('./detect-space-contract-drift').detectSpaceContractDrift}
+ * uses to distinguish a brand-new extension from drift.
+ *
+ * Pure I/O (read + parse). The "comparison hash" is stored on disk by
+ * {@link import('./emit-pinned-space-artefacts').emitPinnedSpaceArtefacts}
+ * via the descriptor's `headRef.hash`, so reading it back here matches
+ * the descriptor's hashing pipeline by construction — neither side
+ * recomputes anything.
+ *
+ * Validation:
+ *
+ * - Rejects the app space — pinned head refs are an extension-space
+ *   concept; the app space's contract-of-record lives at the project
+ *   root, not under `migrations/`.
+ * - Validates the space id against the same `[a-z][a-z0-9_-]{0,63}`
+ *   pattern as the rest of the per-space helpers.
+ * - Surfaces `MIGRATION.INVALID_JSON` / `MIGRATION.INVALID_REF_FILE`
+ *   on a corrupt `refs/head.json` so callers can distinguish "no
+ *   pinned file" (returns `null`) from "pinned file but unreadable"
+ *   (throws).
+ *
+ * @see specs/framework-mechanism.spec.md § 3 — Drift detection (T1.9).
+ */
+declare function readPinnedContractHash(projectMigrationsDir: string, spaceId: string): Promise<string | null>;
+//#endregion
+//#region src/space-layout.d.ts
+/**
+ * Branded string carrying a compile-time guarantee that the value has
+ * been validated by {@link assertValidSpaceId}. Downstream filesystem
+ * helpers (e.g. {@link spaceMigrationDirectory}) accept this type to
+ * make "validated" tracking visible at the type level rather than
+ * relying purely on a runtime check.
+ */
+type ValidSpaceId = string & {
+  readonly __brand: 'ValidSpaceId';
+};
+declare function isValidSpaceId(spaceId: string): spaceId is ValidSpaceId;
+declare function assertValidSpaceId(spaceId: string): asserts spaceId is ValidSpaceId;
+/**
+ * Resolve the migrations subdirectory for a given contract space.
+ *
+ * - **App space** (`spaceId === APP_SPACE_ID`) keeps today's layout: the
+ *   project's `migrations/` directory is the migrations directory, no
+ *   subdirectory.
+ * - **Extension space** lands under `<projectMigrationsDir>/<spaceId>/`.
+ *   The space id is validated against {@link SPACE_ID_PATTERN} because
+ *   it becomes a filesystem directory name verbatim.
+ *
+ * `projectMigrationsDir` is the project's top-level `migrations/`
+ * directory; the helper does not assume anything about its absolute /
+ * relative shape and is symmetric with `pathe.join`.
+ */
+declare function spaceMigrationDirectory(projectMigrationsDir: string, spaceId: string): string;
+//#endregion
+//#region src/verify-contract-spaces.d.ts
+/**
+ * List the per-space pinned subdirectories under
+ * `<projectRoot>/migrations/`. Returns space-id directory names (sorted
+ * alphabetically) — i.e. any non-dot-prefixed subdirectory whose root
+ * does **not** contain a `migration.json` manifest. The manifest is the
+ * structural marker of a user-authored migration directory (see
+ * `readMigrationsDir` in `./io`); directory names themselves belong to
+ * the user and are not part of the contract.
+ *
+ * Returns `[]` if the migrations directory does not exist (greenfield
+ * project).
+ *
+ * Reads only the user's repo. **No descriptor import.** The caller
+ * (verifier) feeds the result into {@link verifyContractSpaces} alongside
+ * the loaded-space set and the marker rows.
+ *
+ * @see specs/framework-mechanism.spec.md § 4 — Verifier (steps 5–6).
+ */
+declare function listPinnedSpaceDirectories(projectMigrationsDir: string): Promise<readonly string[]>;
+/**
+ * Pinned head value (`(hash, invariants)`) for one contract space.
+ * The verifier compares this against the marker row for the same space
+ * to detect drift between the user-emitted artefacts and the live DB
+ * marker.
+ */
+interface SpacePinnedHashRecord {
+  readonly hash: string;
+  readonly invariants: readonly string[];
+}
+/**
+ * Marker row read from `prisma_contract.marker` (one per `space`).
+ * Caller resolves these via the family runtime's marker reader (T1.1)
+ * before invoking {@link verifyContractSpaces}.
+ */
+interface SpaceMarkerRecord {
+  readonly hash: string;
+  readonly invariants: readonly string[];
+}
+interface VerifyContractSpacesInputs {
+  /**
+   * Set of contract spaces the project declares: `'app'` plus each
+   * extension space in `extensionPacks`. The caller's discovery path
+   * never reads the extension descriptor module — it walks the
+   * `extensionPacks` configuration in `prisma-next.config.ts` for the
+   * space ids.
+   */
+  readonly loadedSpaces: ReadonlySet<string>;
+  /**
+   * Pinned per-space subdirectories observed under
+   * `<projectRoot>/migrations/`. Resolved via
+   * {@link listPinnedSpaceDirectories}.
+   */
+  readonly pinnedDirsOnDisk: readonly string[];
+  /**
+   * Pinned head ref per space, keyed by space id. Caller reads
+   * `<projectRoot>/migrations/<space-id>/contract.json` and
+   * `refs/head.json` (or, for app-space if its pinned shape ever moves
+   * under `migrations/`, the equivalent files) to construct this map.
+   * Spaces with no pinned dir on disk simply omit a map entry.
+   */
+  readonly pinnedHashesBySpace: ReadonlyMap<string, SpacePinnedHashRecord>;
+  /**
+   * Marker rows keyed by `space`. Caller reads them from the
+   * `prisma_contract.marker` table.
+   */
+  readonly markerRowsBySpace: ReadonlyMap<string, SpaceMarkerRecord>;
+}
+type SpaceVerifierViolation = {
+  readonly kind: 'declaredButUnmigrated';
+  readonly spaceId: string;
+  readonly remediation: string;
+} | {
+  readonly kind: 'orphanMarker';
+  readonly spaceId: string;
+  readonly remediation: string;
+} | {
+  readonly kind: 'orphanPinnedDir';
+  readonly spaceId: string;
+  readonly remediation: string;
+} | {
+  readonly kind: 'hashMismatch';
+  readonly spaceId: string;
+  readonly pinnedHash: string;
+  readonly markerHash: string;
+  readonly remediation: string;
+} | {
+  readonly kind: 'invariantsMismatch';
+  readonly spaceId: string;
+  readonly pinnedInvariants: readonly string[];
+  readonly markerInvariants: readonly string[];
+  readonly remediation: string;
+};
+type VerifyContractSpacesResult = {
+  readonly ok: true;
+} | {
+  readonly ok: false;
+  readonly violations: readonly SpaceVerifierViolation[];
+};
+/**
+ * Pure structural verifier for the per-space mechanism. Aggregates the
+ * three orphan / missing checks (FR6 cases a–c) plus per-space hash and
+ * invariant comparison.
+ *
+ * Algorithm (sub-spec § 4):
+ *
+ * - For every extension space declared in `loadedSpaces` (`'app'`
+ *   excluded — its pinned `contract.json` lives at the project root):
+ *   - If no pinned dir on disk → `declaredButUnmigrated`.
+ *   - Else if `markerRowsBySpace` lacks an entry → no violation here;
+ *     the live-DB compare in step 8 (out of scope of this helper) is
+ *     where the absence shows up.
+ *   - Else compare marker hash / invariants vs. pinned hash /
+ *     invariants → `hashMismatch` / `invariantsMismatch` on drift.
+ * - For every pinned dir on disk that is not in `loadedSpaces` →
+ *   `orphanPinnedDir`.
+ * - For every marker row whose `space` is not in `loadedSpaces` →
+ *   `orphanMarker`. The app-space marker is always loaded (`'app'` is
+ *   in `loadedSpaces` by definition).
+ *
+ * Output is deterministic (NFR6): violations are sorted first by `kind`
+ * (`declaredButUnmigrated` → `orphanMarker` → `orphanPinnedDir` →
+ * `hashMismatch` → `invariantsMismatch`) then by `spaceId`. Two callers
+ * passing equivalent inputs see byte-identical violation lists.
+ *
+ * Synchronous, pure, no I/O. **Does not import the extension descriptor**
+ * (the inputs are pre-resolved by the caller). This is the property
+ * AC-15 / AC-26 ("verifier reads only the user repo, not
+ * `node_modules`") locks in.
+ *
+ * @see specs/framework-mechanism.spec.md § 4 — Verifier (T1.5).
+ */
+declare function verifyContractSpaces(inputs: VerifyContractSpacesInputs): VerifyContractSpacesResult;
+//#endregion
+export { APP_SPACE_ID, type DetectSpaceContractDriftInputs, type PinnedSpaceArtefactInputs, type PinnedSpaceHeadRef, type SpaceApplyInput, type SpaceContractDriftResult, type SpaceMarkerRecord, type SpacePinnedHashRecord, type SpacePlanInput, type SpacePlanOutput, type SpaceVerifierViolation, type ValidSpaceId, type VerifyContractSpacesInputs, type VerifyContractSpacesResult, assertValidSpaceId, concatenateSpaceApplyInputs, detectSpaceContractDrift, emitPinnedSpaceArtefacts, isValidSpaceId, listPinnedSpaceDirectories, planAllSpaces, readPinnedContractHash, spaceMigrationDirectory, verifyContractSpaces };
+//# sourceMappingURL=spaces.d.mts.map

package/dist/exports/spaces.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spaces.d.mts","names":[],"sources":["../../src/concatenate-space-apply-inputs.ts","../../src/detect-space-contract-drift.ts","../../src/emit-pinned-space-artefacts.ts","../../src/plan-all-spaces.ts","../../src/read-pinned-contract-hash.ts","../../src/space-layout.ts","../../src/verify-contract-spaces.ts"],"sourcesContent":[],"mappings":"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"}