@danceroutine/tango-schema 1.11.1 → 1.11.3

package/dist/model/registry/ModelRegistry.d.ts

@@ -1,129 +0,0 @@
-import type { Field, Model } from '../../domain/index';
-import { type ModelRef } from '../decorators/domain/ModelRef';
-import type { FinalizedStorageArtifacts } from '../fields/FinalizedStorageArtifacts';
-import type { ResolvedRelationGraph } from '../relations/ResolvedRelationGraph';
-import type { ResolvedRelationGraphSnapshot } from './ResolvedRelationGraphSnapshot';
-/**
- * Registry that resolves Tango models by stable identity.
- *
- * The default shared registry is convenient for application bootstrapping
- * within one schema package instance, while dedicated instances are useful in
- * tests and tooling. Explicit active-registry binding stays process-shared so
- * tooling can construct models across separate schema package copies without
- * relying on the ambient default registry.
- */
-export declare class ModelRegistry {
-    private static globalRegistry?;
-    private readonly models;
-    private version;
-    private storageCache?;
-    private relationGraphCache?;
-    private lastRelationRegistryDriftCheckVersion?;
-    /**
-     * Return the shared default registry used by `Model(...)` for this schema
-     * package instance.
-     */
-    static global(): ModelRegistry;
-    /**
-     * Return the registry currently bound to model construction work.
-     *
-     * This explicit binding is process-shared so code that imports separate
-     * schema package copies can still participate in one construction flow.
-     */
-    static active(): ModelRegistry;
-    /**
-     * Run work with a specific registry bound as the active construction target.
-     */
-    static runWithRegistry<T>(registry: ModelRegistry, work: () => Promise<T> | T): Promise<T>;
-    /**
-     * Register a model on the shared global registry.
-     */
-    static register(model: Model): void;
-    /**
-     * Register several models on the shared global registry.
-     */
-    static registerMany(models: readonly Model[]): void;
-    /**
-     * Resolve a model from the shared registry by namespace and name.
-     */
-    static get(namespace: string, name: string): Model | undefined;
-    /**
-     * Resolve a model from the shared registry by its `namespace/name` key.
-     */
-    static getByKey(key: string): Model | undefined;
-    /**
-     * Resolve any supported model reference form against the shared registry.
-     */
-    static resolveRef(ref: ModelRef): Model;
-    /**
-     * Clear the shared registry, which is mainly useful in tests.
-     */
-    static clear(): void;
-    /**
-     * Return the owning registry for a model.
-     */
-    static getOwner(model: {
-        metadata: {
-            key?: string;
-        };
-    } & object): ModelRegistry;
-    private static runtimeGlobal;
-    private static activeRegistryStorage;
-    /**
-     * Register a model on this registry instance.
-     */
-    register(model: Model): void;
-    /**
-     * Register several models on this registry instance.
-     */
-    registerMany(models: readonly Model[]): void;
-    /**
-     * Resolve a model from this registry instance by namespace and name.
-     */
-    get(namespace: string, name: string): Model | undefined;
-    /**
-     * Resolve a model from this registry instance by its `namespace/name` key.
-     */
-    getByKey(key: string): Model | undefined;
-    /**
-     * Resolve a string, callback, or direct model reference into a model object.
-     */
-    resolveRef(ref: ModelRef): Model;
-    /**
-     * Finalize storage-only artifacts for all models in this registry.
-     */
-    finalizeStorageArtifacts(): FinalizedStorageArtifacts;
-    /**
-     * Return finalized storage fields for a specific model.
-     */
-    getFinalizedFields(model: Model | string): readonly Field[];
-    /**
-     * Resolve the registry's relation graph from finalized storage artifacts.
-     */
-    getResolvedRelationGraph(): ResolvedRelationGraph;
-    /**
-     * Return a canonical snapshot of the resolved relation graph.
-     */
-    getResolvedRelationGraphSnapshot(): ResolvedRelationGraphSnapshot;
-    /**
-     * Return a deterministic fingerprint for the resolved relation graph.
-     */
-    getResolvedRelationGraphFingerprint(): string;
-    /**
-     * Remove all registered models from this registry instance.
-     */
-    clear(): void;
-    /**
-     * Return all registered models in insertion order.
-     */
-    values(): readonly Model[];
-    private bumpVersion;
-    private stripImplicitManyToManyModels;
-    private freezeFields;
-    private inferPrimaryKeyName;
-    private mergeStorageFields;
-    private warnOnGeneratedRelationRegistryDrift;
-    private shouldCheckGeneratedRelationRegistry;
-    private readGeneratedRelationRegistryArtifact;
-    private isPartialRegistrySnapshot;
-}

package/dist/model/registry/ResolvedRelationGraphArtifactFactory.d.ts

@@ -1,13 +0,0 @@
-import type { ResolvedRelationGraph } from '../relations/ResolvedRelationGraph';
-import type { ResolvedRelationGraphSnapshot } from './ResolvedRelationGraphSnapshot';
-/**
- * Build canonical serialized artifacts from a resolved relation graph.
- *
- * Generation, drift detection, and related tooling all need the same stable
- * snapshot shape and fingerprinting rules, so that work lives behind one class
- * instead of a pair of free functions.
- */
-export declare class ResolvedRelationGraphArtifactFactory {
-    static createSnapshot(graph: ResolvedRelationGraph): ResolvedRelationGraphSnapshot;
-    static createFingerprint(value: ResolvedRelationGraph | ResolvedRelationGraphSnapshot): string;
-}

package/dist/model/registry/ResolvedRelationGraphSnapshot.d.ts

@@ -1,110 +0,0 @@
-import type { RelationCardinality, RelationPublicKind, RelationStorageStrategy } from '../relations/RelationSpec';
-/**
- * Serializable snapshot of a single relation edge from the resolved relation
- * graph. Snapshots are the stable, build-time wire format consumed by codegen
- * and by tooling that compares the graph across runs.
- *
- * A snapshot row captures both the abstract edge identity (who connects to
- * whom, under what public name) and the physical storage details (local
- * fields, join columns, through-model coordinates) needed to translate the
- * edge into SQL later.
- */
-export type ResolvedRelationGraphSnapshotRelation = {
-    /**
-     * Stable identifier for this edge within the graph. Used to cross-reference
-     * an edge with its inverse and to detect drift between snapshots.
-     */
-    edgeId: string;
-    /** Model key of the endpoint that owns this edge in the resolved graph. */
-    sourceModelKey: string;
-    /** Model key of the endpoint this edge points at. */
-    targetModelKey: string;
-    /**
-     * Public relation name exposed to application code and query builders
-     * (for example `author` or `tags`).
-     */
-    name: string;
-    /**
-     * Identifier of the paired edge on the opposite endpoint, when one exists.
-     * Bidirectional relations populate this; one-way edges leave it unset.
-     */
-    inverseEdgeId?: string;
-    /**
-     * Public relation kind (`belongsTo`, `hasMany`, `manyToMany`, ...).
-     */
-    kind: RelationPublicKind;
-    /**
-     * How the edge is physically stored. Distinguishes direct foreign-key
-     * references from reverse references and join-table backed relations.
-     */
-    storageStrategy: RelationStorageStrategy;
-    /** Whether the edge yields one target (`single`) or many (`many`). */
-    cardinality: RelationCardinality;
-    /**
-     * Owner-side column that stores the foreign key, when the edge is backed
-     * by a local reference column.
-     */
-    localFieldName?: string;
-    /**
-     * Target-side column the foreign key resolves against, when applicable.
-     */
-    targetFieldName?: string;
-    /**
-     * Model key of the synthesized or user-provided through model for
-     * many-to-many edges.
-     */
-    throughModelKey?: string;
-    /** Physical join-table name for many-to-many edges. */
-    throughTable?: string;
-    /** Through-model schema field on the source side, if resolved. */
-    throughSourceFieldName?: string;
-    /** Through-model schema field on the target side, if resolved. */
-    throughTargetFieldName?: string;
-    /**
-     * Physical join-table column that stores the owner-side primary key for
-     * many-to-many edges.
-     */
-    throughSourceKey?: string;
-    /**
-     * Physical join-table column that stores the target-side primary key for
-     * many-to-many edges.
-     */
-    throughTargetKey?: string;
-    /**
-     * Alias used when the edge participates in SQL joins. Derived
-     * deterministically so compiled SQL is stable across runs.
-     */
-    alias: string;
-    /**
-     * What this edge is allowed to participate in. The builder uses these
-     * flags to decide whether migrations emit DDL, queries can select over
-     * the edge, and hydration can populate the related attribute.
-     */
-    capabilities: {
-        /** Whether migration tooling should emit DDL for this edge. */
-        migratable: boolean;
-        /** Whether the edge can appear as a hop in a query path. */
-        queryable: boolean;
-        /** Whether hydrators can populate the related attribute on a row. */
-        hydratable: boolean;
-    };
-};
-/**
- * Snapshot of one model's relation edges. Grouping edges by source model
- * lets codegen walk the graph model-by-model without having to re-index.
- */
-export type ResolvedRelationGraphSnapshotModel = {
-    /** Model key these relations source from. */
-    key: string;
-    /** Resolved outgoing relation edges in registration order. */
-    relations: ResolvedRelationGraphSnapshotRelation[];
-};
-/**
- * Top-level serializable snapshot of the resolved relation graph for a
- * registry. Written to disk by codegen and diffed across runs to detect
- * registry drift.
- */
-export type ResolvedRelationGraphSnapshot = {
-    /** Per-model relation snapshots in registration order. */
-    models: ResolvedRelationGraphSnapshotModel[];
-};

package/dist/model/registry/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * Domain boundary barrel: centralizes this subdomain's public contract.
- */
-export { ModelRegistry } from './ModelRegistry';
-export { createSchemaModuleAliases, resolveSchemaModuleEntrypoint } from '../../resolveSchemaModuleEntrypoint';
-export { GENERATED_RELATION_REGISTRY_DIRNAME, GENERATED_RELATION_REGISTRY_METADATA_FILENAME, GENERATED_RELATION_REGISTRY_METADATA_VERSION, GENERATED_RELATION_REGISTRY_TYPES_FILENAME, type GeneratedRelationRegistryArtifact, } from './GeneratedRelationRegistryArtifact';
-export { ResolvedRelationGraphArtifactFactory } from './ResolvedRelationGraphArtifactFactory';
-export { type ResolvedRelationGraphSnapshot, type ResolvedRelationGraphSnapshotModel, type ResolvedRelationGraphSnapshotRelation, } from './ResolvedRelationGraphSnapshot';

package/dist/model/relations/ImplicitManyToManyIdentifier.d.ts

@@ -1,45 +0,0 @@
-/**
- * Single source of truth for identity of Tango-synthesized many-to-many
- * through models. Other parts of the schema package interact with synthesized
- * models exclusively through this class so they do not have to know the
- * namespace or digest scheme those keys encode.
- */
-export declare class ImplicitManyToManyIdentifier {
-    private static readonly NAMESPACE;
-    /**
-     * Stable model key for the synthesized through model connecting
-     * `sourceModelKey` to `targetModelKey` via the schema field
-     * `sourceSchemaFieldKey`.
-     *
-     * The returned key is deterministic across runs so storage and hydration
-     * artifacts stay stable as long as the inputs match.
-     */
-    static getModelKey(sourceModelKey: string, sourceSchemaFieldKey: string, targetModelKey: string): string;
-    /**
-     * Deterministic short digest used to derive the physical join-table name
-     * for a synthesized through model. Shorter than the model-key digest so
-     * table names stay within common SQL identifier limits.
-     */
-    static getTableBaseDigest(sourceModelKey: string, sourceSchemaFieldKey: string, targetModelKey: string): string;
-    /**
-     * True when `modelKey` was produced by {@link getModelKey} and therefore
-     * identifies a synthesized through model. Callers use this instead of
-     * comparing namespace prefixes so the namespace remains an implementation
-     * detail of this class.
-     */
-    static isImplicitManyToManyModel(modelKey: string): boolean;
-    /**
-     * Namespace under which synthesized through models are registered.
-     * Exposed so {@link ImplicitManyToManyThroughFactory} can construct the
-     * model with the correct namespace. External callers that want to ask
-     * "is this an implicit model" should prefer {@link isImplicitManyToManyModel}.
-     */
-    static getNamespace(): string;
-    /**
-     * Extract the `m2m_<digest>` component of a synthesized model key so the
-     * factory can register the through model with a deterministic name while
-     * keeping the namespace owned by this class.
-     */
-    static getModelName(modelKey: string): string;
-    private static digest;
-}

package/dist/model/relations/ImplicitManyToManyThroughFactory.d.ts

@@ -1,14 +0,0 @@
-import type { Model } from '../../domain/index';
-import type { ModelRegistry } from '../registry/ModelRegistry';
-export declare class ImplicitManyToManyThroughFactory {
-    static throughFieldNames(sourceModel: Model, targetModel: Model): {
-        throughSourceFieldName: string;
-        throughTargetFieldName: string;
-    };
-    static buildModels(registry: ModelRegistry): Model[];
-    private static unwrapForForeignKeyField;
-    private static clonePrimaryKeySchemaForForeignKey;
-    private static readSinglePrimaryKey;
-    private static collectImplicitDescriptors;
-    private static allocateTableName;
-}

package/dist/model/relations/NormalizedRelationStorageDescriptor.d.ts

@@ -1,36 +0,0 @@
-import type { DeleteReferentialAction, UpdateReferentialAction } from '../../domain/index';
-import type { ModelRef } from '../decorators/domain/ModelRef';
-export declare const InternalNormalizedRelationOrigin: {
-    readonly FOREIGN_KEY: "foreignKey";
-    readonly ONE_TO_ONE: "oneToOne";
-    readonly MANY_TO_MANY: "manyToMany";
-};
-export type NormalizedRelationOrigin = (typeof InternalNormalizedRelationOrigin)[keyof typeof InternalNormalizedRelationOrigin];
-/**
- * Registry-independent relation descriptor produced immediately after model
- * construction.
- *
- * This is the handoff object between relation authoring and relation
- * resolution. It preserves field-authored relation intent in a normalized form
- * without yet assigning public reverse names or resolved graph edges.
- */
-export interface NormalizedRelationStorageDescriptor {
-    edgeId: string;
-    sourceModelKey: string;
-    sourceSchemaFieldKey: string;
-    targetRef: ModelRef;
-    origin: NormalizedRelationOrigin;
-    localFieldName: string;
-    dbColumnName: string;
-    referencedTargetColumn?: string;
-    onDelete?: DeleteReferentialAction;
-    onUpdate?: UpdateReferentialAction;
-    unique?: boolean;
-    explicitForwardName?: string;
-    explicitReverseName?: string;
-    namingHint: string;
-    throughModelRef?: ModelRef;
-    throughSourceFieldName?: string;
-    throughTargetFieldName?: string;
-    provenance: 'field-decorator';
-}

package/dist/model/relations/RelationBuilder.d.ts

@@ -1,19 +0,0 @@
-import type { RelationDef } from '../../domain/index';
-/**
- * Public authoring DSL for model-level named relations.
- *
- * This is the first stage of the relations subdomain. Application code uses it
- * inside `relations: (r) => ({ ... })` to declare stable relation names and
- * resolve ambiguity that field decorators alone cannot express.
- *
- * Later internal stages normalize these authored definitions and combine them
- * with field-authored relation metadata to build the resolved relation graph.
- */
-export declare class RelationBuilder {
-    /** Declare a one-to-many relation from this model to `target`. */
-    hasMany(target: string, foreignKey: string): RelationDef;
-    /** Declare an owning relation to a parent model. */
-    belongsTo(target: string, foreignKey: string, localKey?: string): RelationDef;
-    /** Declare a one-to-one relation from this model to `target`. */
-    hasOne(target: string, foreignKey: string): RelationDef;
-}

package/dist/model/relations/RelationDescriptorNormalizer.d.ts

@@ -1,30 +0,0 @@
-import { z } from 'zod';
-import type { NormalizedRelationStorageDescriptor } from './NormalizedRelationStorageDescriptor';
-/**
- * Normalizes field-authored relation declarations from a model schema into the
- * shared descriptor shape consumed by storage and relation finalization.
- *
- * This is the normalization stage of the relations subdomain. It sits between
- * authoring and resolution:
- *
- * - authoring: decorators attach relation intent to schema fields
- * - normalization: this class converts that intent into a registry-independent
- *   descriptor shape
- * - resolution: the graph builder combines those descriptors with finalized
- *   storage artifacts and explicit relation names
- */
-export declare class RelationDescriptorNormalizer {
-    private readonly sourceModelKey;
-    private readonly schema;
-    constructor(sourceModelKey: string, schema: z.ZodObject<z.ZodRawShape>);
-    static normalize(sourceModelKey: string, schema: z.ZodObject<z.ZodRawShape>): readonly NormalizedRelationStorageDescriptor[];
-    /**
-     * Run the field-authored relation normalization pipeline for one model
-     * schema and emit descriptors that later relation stages can resolve.
-     */
-    normalize(): readonly NormalizedRelationStorageDescriptor[];
-    private collectRelationCandidates;
-    private normalizeCandidate;
-    private buildEdgeId;
-    private deriveNamingHint;
-}

package/dist/model/relations/RelationSpec.d.ts

@@ -1,48 +0,0 @@
-export declare const InternalRelationPublicKind: {
-    readonly BELONGS_TO: "belongsTo";
-    readonly HAS_ONE: "hasOne";
-    readonly HAS_MANY: "hasMany";
-    readonly MANY_TO_MANY: "manyToMany";
-};
-export declare const InternalRelationStorageStrategy: {
-    readonly REFERENCE: "reference";
-    readonly REVERSE_REFERENCE: "reverse_reference";
-    readonly MANY_TO_MANY: "many_to_many";
-};
-export declare const InternalRelationCardinality: {
-    readonly SINGLE: "single";
-    readonly MANY: "many";
-};
-export declare const InternalRelationProvenance: {
-    readonly FIELD_DECORATOR: "field-decorator";
-    readonly RELATIONS_API: "relations-api";
-    readonly SYNTHESIZED_REVERSE: "synthesized-reverse";
-};
-export type RelationPublicKind = (typeof InternalRelationPublicKind)[keyof typeof InternalRelationPublicKind];
-export type RelationStorageStrategy = (typeof InternalRelationStorageStrategy)[keyof typeof InternalRelationStorageStrategy];
-export type RelationCardinality = (typeof InternalRelationCardinality)[keyof typeof InternalRelationCardinality];
-export type RelationProvenance = (typeof InternalRelationProvenance)[keyof typeof InternalRelationProvenance];
-/**
- * Author-time relation intent after target resolution but before full graph
- * pairing and naming.
- *
- * This type is the conceptual bridge between normalized descriptors and the
- * fully resolved graph. It exists so the relations subdomain has a stable
- * vocabulary for relation kinds, storage strategies, and provenance as the
- * pipeline becomes more sophisticated.
- */
-export interface RelationSpec {
-    edgeId: string;
-    sourceModelKey: string;
-    sourceSchemaFieldKey?: string;
-    targetModelKey: string;
-    kind: RelationPublicKind;
-    storageStrategy: RelationStorageStrategy;
-    localFieldName?: string;
-    targetFieldName?: string;
-    nameHint?: string;
-    throughModelKey?: string;
-    throughSourceFieldName?: string;
-    throughTargetFieldName?: string;
-    provenance: RelationProvenance;
-}

package/dist/model/relations/ResolvedRelationGraph.d.ts

@@ -1,49 +0,0 @@
-import type { RelationCardinality, RelationProvenance, RelationStorageStrategy, RelationPublicKind } from './RelationSpec';
-/**
- * Fully resolved relation edge published by the registry after storage
- * artifacts are finalized.
- *
- * This is the resolution-stage shape consumed by ORM-facing relation metadata.
- * Each descriptor has final naming, cardinality, key mapping, and capability
- * flags that describe whether the edge is currently migratable, queryable, and
- * hydratable.
- */
-export interface ResolvedRelationDescriptor {
-    edgeId: string;
-    sourceModelKey: string;
-    targetModelKey: string;
-    name: string;
-    inverseEdgeId?: string;
-    kind: RelationPublicKind;
-    storageStrategy: RelationStorageStrategy;
-    cardinality: RelationCardinality;
-    localFieldName?: string;
-    targetFieldName?: string;
-    throughModelKey?: string;
-    throughTable?: string;
-    throughSourceFieldName?: string;
-    throughTargetFieldName?: string;
-    throughSourceKey?: string;
-    throughTargetKey?: string;
-    capabilities: {
-        migratable: boolean;
-        queryable: boolean;
-        hydratable: boolean;
-    };
-    provenance: RelationProvenance;
-    alias: string;
-    ambiguity?: string;
-}
-/**
- * Registry-scoped relation graph built from normalized relation descriptors,
- * explicit relation names, and finalized storage artifacts.
- *
- * This is the canonical resolved relation view for query planning and future
- * hydration work. It is versioned because relation resolution is scoped to a
- * specific registry snapshot.
- */
-export interface ResolvedRelationGraph {
-    version: number;
-    byModel: ReadonlyMap<string, ReadonlyMap<string, ResolvedRelationDescriptor>>;
-    byEdgeId: ReadonlyMap<string, ResolvedRelationDescriptor>;
-}

package/dist/model/relations/ResolvedRelationGraphBuilder.d.ts

@@ -1,54 +0,0 @@
-import type { Model } from '../../domain/index';
-import type { FinalizedStorageArtifacts } from '../fields/FinalizedStorageArtifacts';
-import type { ResolvedRelationGraphSnapshot } from '../registry/ResolvedRelationGraphSnapshot';
-import { type NormalizedRelationStorageDescriptor } from './NormalizedRelationStorageDescriptor';
-import type { ResolvedRelationGraph } from './ResolvedRelationGraph';
-type GraphBuilderOptions = {
-    version: number;
-    models: readonly Model[];
-    storage: FinalizedStorageArtifacts;
-    resolveRef: (ref: NormalizedRelationStorageDescriptor['targetRef']) => Model;
-};
-/**
- * Resolution-stage builder that turns normalized relation descriptors into the
- * registry-scoped resolved relation graph.
- *
- * This is the final pipeline stage in the relations subdomain. It combines:
- *
- * - normalized field-authored relation descriptors
- * - explicit model-level relation names from `RelationBuilder`
- * - finalized storage artifacts from the registry
- *
- * The result is the canonical named relation graph used by ORM-facing
- * consumers.
- */
-export declare class ResolvedRelationGraphBuilder {
-    private readonly options;
-    private readonly byModel;
-    private readonly byEdgeId;
-    private readonly matchedOverrides;
-    constructor(options: GraphBuilderOptions);
-    static build(options: GraphBuilderOptions): ResolvedRelationGraph;
-    /**
-     * Serialize a resolved graph into the canonical snapshot shape used by
-     * relation-registry code generation and fingerprinting.
-     */
-    static createSnapshot(graph: ResolvedRelationGraph): ResolvedRelationGraphSnapshot;
-    /**
-     * Resolve every model's normalized relation descriptors into a single
-     * registry-scoped graph and fail when authoring ambiguity remains.
-     */
-    build(): ResolvedRelationGraph;
-    private addModelRelations;
-    private addReferenceRelations;
-    private findForwardOverride;
-    private findReverseOverride;
-    private assertAllOverridesMatched;
-    private addResolvedRelation;
-    private getPrimaryKey;
-    private markOverrideMatched;
-    private buildOverrideMarker;
-    private resolveRelationTargetKey;
-    private deriveReverseName;
-}
-export {};

package/dist/model/relations/SchemaNaming.d.ts

@@ -1,12 +0,0 @@
-/**
- * Shared naming policy for the model and relations subdomains.
- *
- * These helpers are not an authoring or graph stage on their own. They are the
- * cross-cutting policy layer used by both model construction and relation
- * resolution when Tango derives table names, aliases, and synthesized relation
- * names in a Django-style shape.
- */
-export declare function toSnakeCase(value: string): string;
-export declare function pluralize(value: string): string;
-export declare function deriveTableName(name: string): string;
-export declare function decapitalizeModelName(name: string): string;

package/dist/model/relations/index.d.ts

@@ -1,13 +0,0 @@
-/**
- * Domain boundary barrel for relation authoring.
- *
- * The relations subdomain has three internal layers:
- *
- * - authoring: `RelationBuilder`
- * - normalization: field-authored relations become normalized descriptors
- * - resolution: normalized descriptors become the registry-scoped relation graph
- *
- * Only the authoring surface is exported here. The later pipeline stages stay
- * internal until Tango intentionally publishes them as supported contracts.
- */
-export { RelationBuilder } from './RelationBuilder';