@prisma-next/framework-components 0.7.0 → 0.8.0-dev.1

package/src/control/contract-serializer.ts

@@ -0,0 +1,37 @@
+import type { JsonObject } from '@prisma-next/utils/json';
+
+/**
+ * Framework SPI for moving a contract between its canonical on-disk JSON
+ * form and its in-memory class-hierarchy form. Both directions live on the
+ * same SPI so the conceptual seam — "the boundary where the contract
+ * crosses between persisted JSON and live class instances" — has a single
+ * named home.
+ *
+ * Both faces are needed by the framework today (round-trip property tests,
+ * drift detection, future canonicalization), not eventually. For most
+ * targets `serializeContract` is identity over JSON-clean class instances;
+ * the method exists because the seam is real, not as a convention placeholder.
+ *
+ * Implementers compose this SPI as a named property on their target
+ * descriptor (`descriptor.contractSerializer`); the descriptor itself
+ * remains the aggregator of all per-target SPIs.
+ */
+export interface ContractSerializer<TContract> {
+  /**
+   * Validate the JSON shape and construct typed class instances. Throws on
+   * structural / domain / storage validation failures. Returns the typed
+   * contract on success.
+   */
+  deserializeContract(json: unknown): TContract;
+
+  /**
+   * Serialize a typed contract to its canonical JSON shape. Returns
+   * `JsonObject` so callers can stringify, hash, or feed the result into
+   * another SPI without re-asserting JSON-cleanness. Targets whose contract
+   * fields are JSON-clean by construction return the contract unchanged
+   * (the symmetric pair to `deserializeContract`); targets that need to
+   * canonicalize on the way out (key ordering, dropping computed-only
+   * fields, normalizing numeric encodings) do that work here.
+   */
+  serializeContract(contract: TContract): JsonObject;
+}

package/src/control/control-descriptors.ts

@@ -1,3 +1,4 @@
+import type { Contract } from '@prisma-next/contract/types';
 import type {
   AdapterDescriptor,
   DriverDescriptor,
@@ -5,6 +6,7 @@ import type {
   FamilyDescriptor,
   TargetDescriptor,
 } from '../shared/framework-components';
+import type { ContractSerializer } from './contract-serializer';
 import type {
   ControlAdapterInstance,
   ControlDriverInstance,
@@ -33,7 +35,15 @@ export interface ControlTargetDescriptor<
     TFamilyId,
     TTargetId
   >,
+  TContract extends Contract = Contract,
 > extends TargetDescriptor<TFamilyId, TTargetId> {
+  /**
+   * JSON ⇄ class boundary for this target's contract. Every target
+   * ships the SPI: framework consumers reach the serializer through
+   * `descriptor.contractSerializer` rather than importing a per-target
+   * `validateContract` helper. The descriptor IS the aggregator.
+   */
+  readonly contractSerializer: ContractSerializer<TContract>;
   create(): TTargetInstance;
 }
 

package/src/control/control-instances.ts

@@ -25,27 +25,19 @@ export interface ControlFamilyInstance<TFamilyId extends string, TSchemaIR>
     readonly configPath?: string;
   }): Promise<VerifyDatabaseResult>;
 
-  schemaVerify(options: {
-    readonly driver: ControlDriverInstance<TFamilyId, string>;
-    readonly contract: unknown;
-    readonly strict: boolean;
-    readonly contractPath: string;
-    readonly configPath?: string;
-    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<TFamilyId, string>>;
-  }): Promise<VerifyDatabaseSchemaResult>;
-
   /**
    * Verify a contract against an already-introspected schema slice.
    *
-   * Difference from {@link schemaVerify}: no `driver`, no introspection
-   * — the caller hands over the schema directly. Used by the aggregate
-   * verifier to invoke the family's verification logic per member,
-   * with the schema **pre-projected** to that member's claimed slice
-   * via {@link import('@prisma-next/migration-tools/aggregate').projectSchemaToSpace}.
+   * Callers that need to verify against the live database compose
+   * {@link introspect} + `verifySchema` directly; the family
+   * interface deliberately exposes the introspection step so callers
+   * can pre-project the schema (e.g. the aggregate verifier projects
+   * each member's claimed slice via
+   * {@link import('@prisma-next/migration-tools/aggregate').projectSchemaToSpace}).
    *
    * Synchronous — no I/O. Idempotent.
    */
-  schemaVerifyAgainstSchema(options: {
+  verifySchema(options: {
     readonly contract: unknown;
     readonly schema: TSchemaIR;
     readonly strict: boolean;

package/src/control/control-schema-view.ts

@@ -8,7 +8,7 @@
  * core view via the `toSchemaView` method on `FamilyInstance`.
  */
 
-export type SchemaNodeKind =
+export type SchemaViewNodeKind =
   | 'root'
   | 'namespace'
   | 'collection'
@@ -22,7 +22,7 @@ export interface SchemaTreeVisitor<R> {
 }
 
 export interface SchemaTreeNodeOptions {
-  readonly kind: SchemaNodeKind;
+  readonly kind: SchemaViewNodeKind;
   readonly id: string;
   readonly label: string;
   readonly meta?: Record<string, unknown>;
@@ -30,7 +30,7 @@ export interface SchemaTreeNodeOptions {
 }
 
 export class SchemaTreeNode {
-  readonly kind: SchemaNodeKind;
+  readonly kind: SchemaViewNodeKind;
   readonly id: string;
   readonly label: string;
   readonly meta?: Record<string, unknown>;

package/src/control/control-stack.ts

@@ -2,11 +2,13 @@ import type { Codec } from '../shared/codec';
 import type { CodecLookup, CodecMeta } from '../shared/codec-types';
 import type {
   AuthoringContributions,
+  AuthoringEntityTypeNamespace,
   AuthoringFieldNamespace,
   AuthoringTypeNamespace,
 } from '../shared/framework-authoring';
 import {
   assertNoCrossRegistryCollisions,
+  isAuthoringEntityTypeDescriptor,
   isAuthoringFieldPresetDescriptor,
   isAuthoringTypeConstructorDescriptor,
   mergeAuthoringNamespaces,
@@ -29,6 +31,7 @@ import type {
 export interface AssembledAuthoringContributions {
   readonly field: AuthoringFieldNamespace;
   readonly type: AuthoringTypeNamespace;
+  readonly entityTypes: AuthoringEntityTypeNamespace;
 }
 
 export interface ControlStack<
@@ -147,6 +150,7 @@ export function assembleAuthoringContributions(
 ): AssembledAuthoringContributions {
   const field = {} as Record<string, unknown>;
   const type = {} as Record<string, unknown>;
+  const entityTypes = {} as Record<string, unknown>;
 
   for (const descriptor of descriptors) {
     if (descriptor.authoring?.field) {
@@ -158,25 +162,35 @@ export function assembleAuthoringContributions(
         'field',
       );
     }
-    if (!descriptor.authoring?.type) {
-      continue;
+    if (descriptor.authoring?.type) {
+      mergeAuthoringNamespaces(
+        type,
+        descriptor.authoring.type,
+        [],
+        isAuthoringTypeConstructorDescriptor,
+        'type',
+      );
+    }
+    if (descriptor.authoring?.entityTypes) {
+      mergeAuthoringNamespaces(
+        entityTypes,
+        descriptor.authoring.entityTypes,
+        [],
+        isAuthoringEntityTypeDescriptor,
+        'entity',
+      );
     }
-    mergeAuthoringNamespaces(
-      type,
-      descriptor.authoring.type,
-      [],
-      isAuthoringTypeConstructorDescriptor,
-      'type',
-    );
   }
 
   const fieldNamespace = field as AuthoringFieldNamespace;
   const typeNamespace = type as AuthoringTypeNamespace;
-  assertNoCrossRegistryCollisions(typeNamespace, fieldNamespace);
+  const entityTypeNamespace = entityTypes as AuthoringEntityTypeNamespace;
+  assertNoCrossRegistryCollisions(typeNamespace, fieldNamespace, entityTypeNamespace);
 
   return {
     field: fieldNamespace,
     type: typeNamespace,
+    entityTypes: entityTypeNamespace,
   };
 }
 

package/src/control/schema-verifier.ts

@@ -0,0 +1,51 @@
+import type { SchemaIssue } from './control-result-types';
+
+/**
+ * Framework SPI for verifying that an introspected schema matches the
+ * contract that authored it. The implementer walks the target's IR
+ * natively — concrete classes, target-only kinds — and reports issues.
+ *
+ * The framework verifier (per FR6) walks the contract-space aggregate,
+ * dispatches to the right target's verifier (`descriptor.schemaVerifier`)
+ * per space, and wraps the per-target results into a unified
+ * `VerifyDatabaseSchemaResult` with timings, summary, and per-node
+ * verification tree.
+ *
+ * Family-level abstract bases (e.g. `SqlSchemaVerifierBase`) carry the
+ * shared SQL/Mongo walk logic and expose protected hooks for target
+ * extensions; concrete target verifiers (`PostgresSchemaVerifier extends
+ * SqlSchemaVerifierBase`) own the dispatch on target-specific kinds.
+ *
+ * Target-specific issue kinds (RLS-policy-mismatch, namespace-mismatch,
+ * future function-shape-mismatch) are widened target-side; the framework
+ * `SchemaIssue` union (in `control-result-types.ts`) is intentionally not
+ * generic over target kinds in this project — see the spec's
+ * "Forward note: SchemaIssue layering" for the layering observation
+ * captured for a future project.
+ */
+export interface SchemaVerifier<TContract, TSchema> {
+  verifySchema(options: SchemaVerifyOptions<TContract, TSchema>): SchemaVerifyResult;
+}
+
+/**
+ * Minimal per-target verifier input. Family abstract bases extend this
+ * shape with family-specific options (`strict`, `frameworkComponents`,
+ * codec hooks, …) — the framework SPI itself stays at the contract +
+ * schema pair every implementer needs.
+ */
+export interface SchemaVerifyOptions<TContract, TSchema> {
+  readonly contract: TContract;
+  readonly schema: TSchema;
+}
+
+/**
+ * Per-target verifier result. The framework verifier wraps these into the
+ * existing `VerifyDatabaseSchemaResult` envelope (with timings, summary,
+ * per-node verification tree); the SPI itself returns just the
+ * core ok/issues pair so the seam between target-walk and
+ * framework-aggregation is explicit.
+ */
+export interface SchemaVerifyResult {
+  readonly ok: boolean;
+  readonly issues: readonly SchemaIssue[];
+}

package/src/execution/runtime-middleware.ts

@@ -58,6 +58,27 @@ export interface RuntimeMiddlewareContext {
    * cancels.
    */
   readonly signal?: AbortSignal;
+  /**
+   * Identifies the queryable scope this execution is running under.
+   *
+   * - `'runtime'` — top-level `runtime.execute(plan)`. The default scope
+   *   used by the standard read/write paths.
+   * - `'connection'` — `connection.execute(plan)` after
+   *   `runtime.connection()` checked out a connection from the pool.
+   * - `'transaction'` — `transaction.execute(plan)` inside an explicit
+   *   transaction, or a query routed through `withTransaction`.
+   *
+   * Middleware that should only act at the top level read this field to
+   * bypass non-runtime scopes. The cache middleware uses it to skip
+   * caching inside transactions (where read-after-write coherence is the
+   * caller's expectation) and dedicated connections (where the user has
+   * explicitly stepped outside the shared cache surface). Observers that
+   * don't care about the scope can ignore the field.
+   *
+   * Family runtimes populate this at context-construction time per
+   * scope. Existing middleware that ignore the field are unaffected.
+   */
+  readonly scope: 'runtime' | 'connection' | 'transaction';
 }
 
 export interface AfterExecuteResult {
@@ -201,6 +222,33 @@ export interface RuntimeMiddleware<
   ): Promise<void>;
 }
 
+/**
+ * Cross-family middleware — one that doesn't constrain `familyId` or
+ * `targetId` and is therefore compatible with any family runtime's
+ * middleware array (`SqlMiddleware[]`, `MongoMiddleware[]`, etc.).
+ *
+ * The intersection `RuntimeMiddleware & { familyId?: undefined; targetId?: undefined }`
+ * pins both optional properties to exactly `undefined` (intersecting
+ * `string | undefined` with `undefined` collapses to `undefined`). Under
+ * `exactOptionalPropertyTypes: true`, the plain `RuntimeMiddleware` shape
+ * — with `familyId?: string` — is *not* assignable to `SqlMiddleware`
+ * (which narrows `familyId?: 'sql'`) because `string` is wider than
+ * `'sql'`. Pinning the property to `undefined` makes the value a subtype
+ * of every narrowed variant: `undefined` extends both `'sql' | undefined`
+ * and `'mongo' | undefined`, so a `CrossFamilyMiddleware` value drops
+ * into a SQL or Mongo middleware slot without a cast.
+ *
+ * Cross-family middleware factories (`createCacheMiddleware`, future
+ * `audit` / OTel middleware) declare this as their return type so the
+ * cross-family typing is named once rather than re-spelled at every call
+ * site.
+ */
+export type CrossFamilyMiddleware<TPlan extends QueryPlan = QueryPlan> =
+  RuntimeMiddleware<TPlan> & {
+    readonly familyId?: undefined;
+    readonly targetId?: undefined;
+  };
+
 /**
  * Optional per-`execute` options accepted by every family runtime.
  *
@@ -212,6 +260,7 @@ export interface RuntimeMiddleware<
  */
 export interface RuntimeExecuteOptions {
   readonly signal?: AbortSignal;
+  readonly scope?: 'runtime' | 'connection' | 'transaction';
 }
 
 /**

package/src/exports/authoring.ts

@@ -3,6 +3,11 @@ export type {
   AuthoringArgumentDescriptor,
   AuthoringColumnDefaultTemplate,
   AuthoringContributions,
+  AuthoringEntityContext,
+  AuthoringEntityTypeDescriptor,
+  AuthoringEntityTypeFactoryOutput,
+  AuthoringEntityTypeNamespace,
+  AuthoringEntityTypeTemplateOutput,
   AuthoringFieldNamespace,
   AuthoringFieldPresetDescriptor,
   AuthoringFieldPresetOutput,
@@ -14,9 +19,11 @@ export type {
 export {
   assertNoCrossRegistryCollisions,
   hasRegisteredFieldNamespace,
+  instantiateAuthoringEntityType,
   instantiateAuthoringFieldPreset,
   instantiateAuthoringTypeConstructor,
   isAuthoringArgRef,
+  isAuthoringEntityTypeDescriptor,
   isAuthoringFieldPresetDescriptor,
   isAuthoringTypeConstructorDescriptor,
   mergeAuthoringNamespaces,

package/src/exports/control.ts

@@ -1,4 +1,5 @@
 export type { ImportRequirement } from '@prisma-next/ts-render';
+export type { ContractSerializer } from '../control/contract-serializer';
 export type {
   MigratableTargetDescriptor,
   OperationPreviewCapable,
@@ -78,9 +79,9 @@ export {
 } from '../control/control-result-types';
 export type {
   CoreSchemaView,
-  SchemaNodeKind,
   SchemaTreeNodeOptions,
   SchemaTreeVisitor,
+  SchemaViewNodeKind,
 } from '../control/control-schema-view';
 export { SchemaTreeNode } from '../control/control-schema-view';
 export type {
@@ -105,6 +106,11 @@ export {
   extractComponentIds,
   extractQueryOperationTypeImports,
 } from '../control/control-stack';
+export type {
+  SchemaVerifier,
+  SchemaVerifyOptions,
+  SchemaVerifyResult,
+} from '../control/schema-verifier';
 export type {
   ControlMutationDefaultEntry,
   ControlMutationDefaultRegistry,

package/src/exports/ir.ts

@@ -0,0 +1,6 @@
+export type { IRNode } from '../ir/ir-node';
+export { freezeNode, IRNodeBase } from '../ir/ir-node';
+export type { Namespace } from '../ir/namespace';
+export { NamespaceBase, UNSPECIFIED_NAMESPACE_ID } from '../ir/namespace';
+export type { Storage } from '../ir/storage';
+export type { StorageType } from '../ir/storage-type';

package/src/exports/runtime.ts

@@ -1,3 +1,11 @@
+export type {
+  AnnotationHandle,
+  AnnotationValue,
+  DefineAnnotationOptions,
+  OperationKind,
+  ValidAnnotations,
+} from '../annotations';
+export { assertAnnotationsApplicable, defineAnnotation } from '../annotations';
 export { AsyncIterableResult } from '../execution/async-iterable-result';
 export { runBeforeExecuteChain } from '../execution/before-execute-chain';
 export type { ExecutionPlan, QueryPlan, ResultType } from '../execution/query-plan';
@@ -14,6 +22,7 @@ export {
 } from '../execution/runtime-error';
 export type {
   AfterExecuteResult,
+  CrossFamilyMiddleware,
   InterceptResult,
   ParamRefMutator,
   RuntimeExecuteOptions,
@@ -23,3 +32,5 @@ export type {
   RuntimeMiddlewareContext,
 } from '../execution/runtime-middleware';
 export { checkMiddlewareCompatibility } from '../execution/runtime-middleware';
+export type { LaneMetaBuilder, MetaBuilder } from '../meta-builder';
+export { createMetaBuilder } from '../meta-builder';

package/src/ir/ir-node.ts

@@ -0,0 +1,62 @@
+/**
+ * Framework-level IR alphabet.
+ *
+ * The framework's contribution to Contract IR / Schema IR is a common
+ * root for the IR class hierarchy and a freeze affordance. Family
+ * abstract bases (e.g. `SqlNode`, `MongoSchemaIRNode`) refine the alphabet
+ * for their family shape; targets ship the concrete classes.
+ *
+ * `kind` is an optional discriminator on the base. Families and leaves
+ * that benefit from discriminated-union dispatch declare their own
+ * literal `kind` at the level that earns it — Mongo leaves carry
+ * per-class literals (`readonly kind = 'mongo-collection' as const`)
+ * because Mongo IR has polymorphic walkers; SQL declares a single
+ * family-level `kind = 'sql'` on `SqlNode` because SQL IR has no
+ * polymorphic dispatch today. No framework consumer dispatches on
+ * `IRNode.kind` at the BASE type — every dispatch site narrows
+ * through a union of leaves where each leaf carries a literal kind, so
+ * requiring `kind` at the base would be unearned. Future leaves that
+ * earn polymorphic dispatch override with a required literal at that
+ * leaf (e.g. `override readonly kind = 'postgres-enum' as const`).
+ *
+ * `IRNodeBase` carries no methods: the freeze-and-assign affordance
+ * lives in the free `freezeNode` helper below. Keeping `freezeNode` out
+ * of the class type means an emitted contract literal type
+ * (`{ readonly kind: 'mongo-collection', ... }` or an unkeyed literal
+ * like `{ nativeType, codecId, nullable }`) is structurally assignable
+ * to its class type — a `protected freeze()` instance method would
+ * otherwise leak into the public type surface and require the literal
+ * to carry it too.
+ *
+ * Subclasses construct fields then call `freezeNode(this)` to seal the
+ * instance. Frozen instances + plain readonly fields keep IR nodes
+ * JSON-clean by construction, so `JSON.stringify(node)` produces canonical
+ * JSON without a `toJSON()` method. The `ContractSerializer` SPI handles
+ * round-trip from canonical JSON back to typed class instances.
+ *
+ * The name (`IRNode` / `IRNodeBase`) reflects the dual-hierarchy reality:
+ * this base is the common root for both Contract IR and Schema IR class
+ * hierarchies, not a Schema-IR-specific alphabet.
+ */
+
+export interface IRNode {
+  readonly kind?: string;
+}
+
+export abstract class IRNodeBase implements IRNode {
+  abstract readonly kind?: string;
+}
+
+/**
+ * Seal an IR class instance after its constructor has assigned all
+ * fields. The free-helper form (rather than a `protected freeze()`
+ * instance method) keeps the class type structurally narrow so emitted
+ * contract literal types remain assignable to their class types.
+ *
+ * The helper name stays `freezeNode` — it operates on IR nodes
+ * regardless of root naming.
+ */
+export function freezeNode<T extends IRNode>(node: T): T {
+  Object.freeze(node);
+  return node;
+}

package/src/ir/namespace.ts

@@ -0,0 +1,40 @@
+import { type IRNode, IRNodeBase } from './ir-node';
+
+/**
+ * Reserved sentinel namespace id meaning
+ * "no namespace bound at authoring time; resolve from connection context".
+ *
+ * Materialised target-side as a singleton subclass of the target's
+ * `NamespaceBase` concretion that overrides the namespace's
+ * qualifier-emission methods to elide the prefix entirely. Call sites
+ * stay polymorphic and never branch on `id === UNSPECIFIED_NAMESPACE_ID`
+ * — the singleton's overrides drop the qualifier so emitted SQL / Mongo
+ * commands look unqualified.
+ *
+ * Encoded as an exported const (rather than scattered string literals)
+ * so the sentinel-id invariant is single-sourced: any production-source
+ * site that constructs an unspecified-namespace singleton imports this
+ * constant.
+ */
+export const UNSPECIFIED_NAMESPACE_ID = '__unspecified__' as const;
+
+/**
+ * Framework-level building block for a "namespace" — the database-level
+ * grouping under which storage objects (tables, collections, enums, …)
+ * reside. Each target's namespace concretion maps the framework concept to
+ * a target-native binding:
+ *
+ * - Postgres: a schema (`CREATE SCHEMA …`); rendered as `"<schema>"`.
+ * - SQLite: the singleton `UNSPECIFIED_NAMESPACE_ID`; emitted SQL has no qualifier.
+ * - Mongo: the connection's `db` field; addressed as a database name.
+ *
+ * See `UNSPECIFIED_NAMESPACE_ID` above for the sentinel id and the
+ * singleton-subclass pattern that materialises it.
+ */
+export interface Namespace extends IRNode {
+  readonly id: string;
+}
+
+export abstract class NamespaceBase extends IRNodeBase implements Namespace {
+  abstract readonly id: string;
+}

package/src/ir/storage-type.ts

@@ -0,0 +1,23 @@
+import type { IRNode } from './ir-node';
+
+/**
+ * Framework-level alphabet for entries in a storage `types` slot.
+ *
+ * The slot is polymorphic at the framework level: a family or target can
+ * persist either a JSON-clean codec-triple object literal (carrying
+ * `kind: 'codec-instance'`) or a class-instance IR node with a narrower
+ * kind discriminator (e.g. `'postgres-enum'`). Hydration walkers,
+ * verifiers, and planners dispatch on the `kind` literal to recover the
+ * precise variant.
+ *
+ * The `kind` field is required at this layer (in contrast with
+ * `IRNode.kind` which is optional) because the slot's downstream
+ * consumers dispatch on it — without a guaranteed discriminator the
+ * polymorphic walk cannot pick the right reader. Concrete variants
+ * narrow `kind` to their literal and add their own field set;
+ * downstream consumers use `kind`-discriminator helpers to recover
+ * the precise shape.
+ */
+export interface StorageType extends IRNode {
+  readonly kind: string;
+}

package/src/ir/storage.ts

@@ -0,0 +1,41 @@
+import type { IRNode } from './ir-node';
+import type { Namespace } from './namespace';
+
+/**
+ * Framework-level promise that every Contract IR / Schema IR carries a
+ * collection of namespaces keyed by namespace id. Family storage
+ * concretions (`SqlStorage`, `MongoStorage`) refine the shape with
+ * family-specific fields (tables, collections, enums, …); target
+ * concretions add target fields where the family vocabulary doesn't
+ * reach.
+ *
+ * Keeping `namespaces` at the framework layer enforces that every storage
+ * object — across any target — is namespace-scoped. The framework can
+ * therefore walk the namespace map without knowing the family alphabet, and
+ * the `(namespace.id, name)` keying that the verifier and planner depend on
+ * is honest at every layer.
+ *
+ * Extends `IRNode` so the framework's IR-walking surfaces (verifiers,
+ * serializers) can dispatch on `Storage`-typed slots through the same
+ * IR-node alphabet as every other node — the structural dual already
+ * holds in code (every concrete storage class extends an IR-node base);
+ * the interface promotion makes the typing honest.
+ *
+ * **Persisted envelope shape is target-owned, not framework-promised.**
+ * Whether the `namespaces` map appears in the on-disk JSON envelope is
+ * a per-target decision made by `ContractSerializer.serializeContract`.
+ * Some targets emit a JSON-clean namespace shape that round-trips
+ * through `JSON.stringify` cleanly (SQL today via the family-layer
+ * identity serializer); others ship runtime-only fields on their
+ * namespace concretions and override `serializeContract` to strip
+ * them (Mongo). Future open (F16): extend the per-target
+ * `ContractSerializer` integration-test surface with an explicit
+ * envelope-shape assertion for each target, so the strip-vs-pass-through
+ * choice is locked at test time rather than implied by the override
+ * presence/absence. Earned by PR2's per-target namespace lift, when
+ * `PostgresSchema` / `SqliteUnspecifiedDatabase` start carrying
+ * target-specific fields.
+ */
+export interface Storage extends IRNode {
+  readonly namespaces: Readonly<Record<string, Namespace>>;
+}