@danceroutine/tango-orm 1.11.1 → 1.11.3

package/dist/query/domain/RelationTyping.d.ts

@@ -1,163 +0,0 @@
-import type { z } from 'zod';
-import type { Model, PersistedModelOutput } from '@danceroutine/tango-schema/domain';
-import type { DecoratedFieldKind, InternalDecoratedFieldKind, RelationDecoratedSchema } from '@danceroutine/tango-schema/model';
-import type { ManyToManyRelatedManager } from '../../manager/relations/ManyToManyRelatedManager';
-export declare const InternalRelationHydrationCardinality: {
-    readonly SINGLE: "single";
-    readonly MANY: "many";
-};
-export type RelationHydrationCardinality = (typeof InternalRelationHydrationCardinality)[keyof typeof InternalRelationHydrationCardinality];
-export type SingleRelationHydrationCardinality = typeof InternalRelationHydrationCardinality.SINGLE;
-export type ManyRelationHydrationCardinality = typeof InternalRelationHydrationCardinality.MANY;
-export type HydratedQueryResult<TBase extends Record<string, unknown>, THydrated extends Record<string, unknown>> = [
-    keyof THydrated
-] extends [never] ? TBase : Omit<TBase, keyof THydrated> & THydrated;
-declare global {
-    interface TangoGeneratedRelationRegistry {
-    }
-}
-type AnyModel = Model<z.ZodObject<z.ZodRawShape>, string>;
-type ModelSchema<TModel> = TModel extends Model<infer TSchema extends z.ZodObject<z.ZodRawShape>, string> ? TSchema : never;
-type ModelShape<TModel> = ModelSchema<TModel> extends z.ZodObject<infer TShape> ? TShape : never;
-type ModelRow<TModel> = TModel extends Model<infer TSchema extends z.ZodObject<z.ZodRawShape>, string> ? PersistedModelOutput<TSchema> : never;
-type IsLiteralString<TValue> = TValue extends string ? (string extends TValue ? false : true) : false;
-type HasStrictModelKey<TModel> = TModel extends Model<z.ZodObject<z.ZodRawShape>, infer TKey> ? IsLiteralString<TKey> : false;
-type ModelKey<TModel> = TModel extends Model<z.ZodObject<z.ZodRawShape>, infer TKey extends string> ? TKey : never;
-type UnionToIntersection<TValue> = (TValue extends unknown ? (value: TValue) => void : never) extends (value: infer TIntersection) => void ? TIntersection : never;
-type JoinPathSegments<TSegments extends readonly string[]> = TSegments extends readonly [
-    infer THead extends string,
-    ...infer TRest extends string[]
-] ? TRest['length'] extends 0 ? THead : `${THead}__${JoinPathSegments<TRest>}` : never;
-type SplitPath<TPath extends string> = TPath extends `${infer THead}__${infer TRest}` ? [THead, ...SplitPath<TRest>] : [TPath];
-type TailTuple<TTuple extends readonly unknown[]> = TTuple extends readonly [unknown, ...infer TRest] ? TRest : [];
-type DefaultGeneratedCycleBudget = readonly [1, 1, 1, 1];
-type GeneratedRelationRegistry = TangoGeneratedRelationRegistry;
-type GeneratedRelationKeys<TSourceModel> = Extract<keyof GeneratedRelations<TSourceModel>, string>;
-type GeneratedRelations<TSourceModel> = HasStrictModelKey<TSourceModel> extends true ? ModelKey<TSourceModel> extends keyof GeneratedRelationRegistry ? GeneratedRelationRegistry[ModelKey<TSourceModel>] : {} : {};
-type NextSeenModels<TSeen extends readonly string[], TTargetModel> = ModelKey<TTargetModel> extends string ? [...TSeen, ModelKey<TTargetModel>] : TSeen;
-type CanTraverseGeneratedTarget<TTargetModel, TSeen extends readonly string[], TCycleBudget extends readonly unknown[]> = ModelKey<TTargetModel> extends TSeen[number] ? (TCycleBudget extends [] ? false : true) : true;
-type NextGeneratedCycleBudget<TTargetModel, TSeen extends readonly string[], TCycleBudget extends readonly unknown[]> = ModelKey<TTargetModel> extends TSeen[number] ? TailTuple<TCycleBudget> : TCycleBudget;
-type GeneratedCardinalityIncludesMany<TCardinality extends RelationHydrationCardinality> = TCardinality extends typeof InternalRelationHydrationCardinality.MANY ? true : false;
-/**
- * Generated path keys accepted by `selectRelated(...)`.
- *
- * Walks the ambient relation registry one hop at a time. Each hop contributes:
- *   (a) the bare relation key (e.g. `author`) as a valid path terminus, and
- *   (b) a dunder-joined extension (`author__profile`, ...) that recurses into
- *       the target model.
- *
- * Because `selectRelated` only composes single-valued hops, the mapped type
- * filters relations whose `cardinality` is not `SINGLE`. The `TSeen` tuple
- * tracks which model keys the recursion has visited so cyclic schemas
- * (`manager -> manager`) are allowed a bounded number of revisits before
- * typing falls back to `never`. `TCycleBudget` is that revisit budget; see
- * `CanTraverseGeneratedTarget` / `NextGeneratedCycleBudget` for how it
- * shrinks only when the next hop actually re-enters a seen model.
- */
-export type GeneratedSelectRelatedPathKeys<TSourceModel, TSeen extends readonly string[] = [ModelKey<TSourceModel>], TCycleBudget extends readonly unknown[] = DefaultGeneratedCycleBudget> = {
-    [TKey in GeneratedRelationKeys<TSourceModel>]: GeneratedRelations<TSourceModel>[TKey] extends {
-        target: infer TTarget extends AnyModel;
-        cardinality: typeof InternalRelationHydrationCardinality.SINGLE;
-    } ? TKey | (CanTraverseGeneratedTarget<TTarget, TSeen, TCycleBudget> extends true ? `${TKey}__${GeneratedSelectRelatedPathKeys<TTarget, NextSeenModels<TSeen, TTarget>, NextGeneratedCycleBudget<TTarget, TSeen, TCycleBudget>>}` : never) : never;
-}[GeneratedRelationKeys<TSourceModel>];
-/**
- * Generated path keys accepted by `prefetchRelated(...)`.
- *
- * Similar in shape to {@link GeneratedSelectRelatedPathKeys}, but relaxes two
- * constraints because prefetch can cross and continue past collection edges:
- *   1. Any hop whose cardinality is `MANY` is a valid terminus. The
- *      `THasMany` flag threads through recursion so once a collection edge
- *      has been crossed, every subsequent hop is also a valid terminus
- *      (matches Django's `prefetch_related` semantics).
- *   2. Single-valued hops are still accepted as terminators so paths like
- *      `posts__author` survive the join.
- *
- * Cycle handling reuses the same `TSeen` / `TCycleBudget` machinery described
- * in {@link GeneratedSelectRelatedPathKeys}: cyclic schemas are typed up to
- * the bound, then fall back to weaker typing rather than failing.
- */
-export type GeneratedPrefetchRelatedPathKeys<TSourceModel, THasMany extends boolean = false, TSeen extends readonly string[] = [ModelKey<TSourceModel>], TCycleBudget extends readonly unknown[] = DefaultGeneratedCycleBudget> = {
-    [TKey in GeneratedRelationKeys<TSourceModel>]: GeneratedRelations<TSourceModel>[TKey] extends {
-        target: infer TTarget extends AnyModel;
-        cardinality: infer TCardinality extends RelationHydrationCardinality;
-    } ? (THasMany extends true ? TKey : GeneratedCardinalityIncludesMany<TCardinality> extends true ? TKey : never) | (CanTraverseGeneratedTarget<TTarget, TSeen, TCycleBudget> extends true ? `${TKey}__${GeneratedPrefetchRelatedPathKeys<TTarget, THasMany extends true ? true : GeneratedCardinalityIncludesMany<TCardinality>, NextSeenModels<TSeen, TTarget>, NextGeneratedCycleBudget<TTarget, TSeen, TCycleBudget>>}` : never) : never;
-}[GeneratedRelationKeys<TSourceModel>];
-/**
- * Generated relation-path filter keys accepted by `filter(...)`, `exclude(...)`,
- * and `Q(...)`.
- *
- * This stays intentionally lighter than the eager-loading path typing:
- * applications with generated relation registries get completion for the
- * relation path prefix, while the terminal field and lookup suffix remain a
- * string tail so the compiler does not explode on deep recursive field
- * extraction.
- */
-export type GeneratedRelationFilterKeys<TSourceModel> = `${GeneratedSelectRelatedPathKeys<TSourceModel>}__${string}` | `${GeneratedPrefetchRelatedPathKeys<TSourceModel>}__${string}`;
-type GeneratedHydratedTarget<TDescriptor, TPath extends string | never> = TDescriptor extends {
-    target: infer TTarget extends AnyModel;
-} ? [TPath] extends [never] ? ModelRow<TTarget> : HydratedQueryResult<ModelRow<TTarget>, GeneratedHydratedRelationMap<TTarget, TPath>> : never;
-type GeneratedHydratedValue<TDescriptor, TPath extends string | never> = TDescriptor extends {
-    target: infer TTarget extends AnyModel;
-    kind: 'manyToMany';
-} ? ManyToManyRelatedManager<ModelRow<TTarget>> : TDescriptor extends {
-    cardinality: infer TCardinality extends RelationHydrationCardinality;
-} ? TCardinality extends typeof InternalRelationHydrationCardinality.SINGLE ? GeneratedHydratedTarget<TDescriptor, TPath> | null : GeneratedHydratedTarget<TDescriptor, TPath>[] : never;
-type GeneratedHydrationForPath<TSourceModel, TPath extends string> = SplitPath<TPath> extends [infer THead extends string, ...infer TRest extends string[]] ? THead extends GeneratedRelationKeys<TSourceModel> ? {
-    [TKey in THead]: GeneratedHydratedValue<GeneratedRelations<TSourceModel>[THead], JoinPathSegments<TRest>>;
-} : {} : {};
-export type GeneratedHydratedRelationMap<TSourceModel, TPaths extends string | never> = ([TPaths] extends [never] ? Record<never, never> : UnionToIntersection<TPaths extends string ? GeneratedHydrationForPath<TSourceModel, TPaths> : never>) & Record<never, never>;
-export type HasStrictRelationTyping<TSourceModel> = HasStrictModelKey<TSourceModel>;
-type ModelKeysMatch<TCandidate, TExpected> = TCandidate extends Model<z.ZodObject<z.ZodRawShape>, infer TCandidateKey> ? TExpected extends Model<z.ZodObject<z.ZodRawShape>, infer TExpectedKey> ? IsLiteralString<TCandidateKey> extends true ? IsLiteralString<TExpectedKey> extends true ? [
-    TCandidateKey
-] extends [TExpectedKey] ? true : false : false : false : false : false;
-type FieldNamingHint<TKey extends string> = TKey extends `${infer TBase}Id` ? TBase : TKey extends `${infer TBase}_id` ? TBase : TKey;
-type RelationName<TKey extends string, TName> = TName extends string ? TName : FieldNamingHint<TKey>;
-type RelatedName<TName> = TName extends string ? TName : never;
-type RelationTarget<TField> = TField extends RelationDecoratedSchema<z.ZodTypeAny, DecoratedFieldKind, infer TTarget, string | undefined, string | undefined> ? TTarget : never;
-type RelationConfiguredName<TField> = TField extends RelationDecoratedSchema<z.ZodTypeAny, DecoratedFieldKind, AnyModel, infer TName, string | undefined> ? TName : undefined;
-type RelationConfiguredRelatedName<TField> = TField extends RelationDecoratedSchema<z.ZodTypeAny, DecoratedFieldKind, AnyModel, string | undefined, infer TRelatedName> ? TRelatedName : undefined;
-type RelationKindOf<TField> = TField extends RelationDecoratedSchema<z.ZodTypeAny, infer TKind, AnyModel, string | undefined, string | undefined> ? TKind : never;
-export type ForwardSingleRelations<TSourceModel> = HasStrictModelKey<TSourceModel> extends true ? {
-    [TKey in keyof ModelShape<TSourceModel> as TKey extends string ? [
-        RelationKindOf<ModelShape<TSourceModel>[TKey]>
-    ] extends [never] ? never : RelationKindOf<ModelShape<TSourceModel>[TKey]> extends typeof InternalDecoratedFieldKind.FOREIGN_KEY | typeof InternalDecoratedFieldKind.ONE_TO_ONE ? RelationTarget<ModelShape<TSourceModel>[TKey]> extends AnyModel ? RelationName<TKey, RelationConfiguredName<ModelShape<TSourceModel>[TKey]>> : never : never : never]: {
-        kind: typeof InternalDecoratedFieldKind.FOREIGN_KEY;
-        target: RelationTarget<ModelShape<TSourceModel>[TKey]>;
-    };
-} : Record<string, {
-    kind: typeof InternalDecoratedFieldKind.FOREIGN_KEY;
-    target: AnyModel;
-}>;
-export type ReverseSingleRelations<TSourceModel, TTargetModel> = HasStrictModelKey<TSourceModel> extends true ? HasStrictModelKey<TTargetModel> extends true ? {
-    [TKey in keyof ModelShape<TTargetModel> as [RelationKindOf<ModelShape<TTargetModel>[TKey]>] extends [
-        never
-    ] ? never : RelationKindOf<ModelShape<TTargetModel>[TKey]> extends typeof InternalDecoratedFieldKind.ONE_TO_ONE ? ModelKeysMatch<RelationTarget<ModelShape<TTargetModel>[TKey]>, TSourceModel> extends true ? RelatedName<RelationConfiguredRelatedName<ModelShape<TTargetModel>[TKey]>> : never : never]: {
-        kind: typeof InternalDecoratedFieldKind.ONE_TO_ONE;
-        target: TTargetModel;
-    };
-} : {} : Record<string, {
-    kind: typeof InternalDecoratedFieldKind.ONE_TO_ONE;
-    target: AnyModel;
-}>;
-export type ReverseCollectionRelations<TSourceModel, TTargetModel> = HasStrictModelKey<TSourceModel> extends true ? HasStrictModelKey<TTargetModel> extends true ? {
-    [TKey in keyof ModelShape<TTargetModel> as [RelationKindOf<ModelShape<TTargetModel>[TKey]>] extends [
-        never
-    ] ? never : RelationKindOf<ModelShape<TTargetModel>[TKey]> extends typeof InternalDecoratedFieldKind.FOREIGN_KEY ? ModelKeysMatch<RelationTarget<ModelShape<TTargetModel>[TKey]>, TSourceModel> extends true ? RelatedName<RelationConfiguredRelatedName<ModelShape<TTargetModel>[TKey]>> : never : never]: {
-        kind: typeof InternalDecoratedFieldKind.FOREIGN_KEY;
-        target: TTargetModel;
-    };
-} : {} : Record<string, {
-    kind: typeof InternalDecoratedFieldKind.FOREIGN_KEY;
-    target: AnyModel;
-}>;
-export type SelectRelatedRelations<TSourceModel, TTargetModel> = [TTargetModel] extends [undefined] ? ForwardSingleRelations<TSourceModel> : // Target generic supplied: include reverse hasOne relations discovered on that target model.
-ForwardSingleRelations<TSourceModel> & ReverseSingleRelations<TSourceModel, TTargetModel>;
-export type PrefetchRelatedRelations<TSourceModel, TTargetModel> = ReverseCollectionRelations<TSourceModel, TTargetModel>;
-export type RelationKeys<TRelations> = Extract<keyof TRelations, string>;
-export type HydratedRelationMap<TRelations, TKeys extends string, TCardinality extends RelationHydrationCardinality> = {
-    [TKey in TKeys]: TKey extends keyof TRelations ? TRelations[TKey] extends {
-        target: infer TTarget;
-    } ? TCardinality extends typeof InternalRelationHydrationCardinality.SINGLE ? ModelRow<TTarget> | null : ModelRow<TTarget>[] : never : never;
-};
-export type MaybeHydratedRelationMap<TSourceModel, TRelations, TKeys extends string, TCardinality extends RelationHydrationCardinality> = HasStrictModelKey<TSourceModel> extends true ? HydratedRelationMap<TRelations, TKeys, TCardinality> : Record<never, never>;
-export {};

package/dist/query/domain/TableMeta.d.ts

@@ -1,16 +0,0 @@
-import type { RelationMeta } from './RelationMeta';
-/**
- * SQL-facing model metadata visible to the ORM layer.
- */
-export interface TableMeta {
-    /** Stable model key when the table comes from a registered Tango model. */
-    modelKey?: string;
-    /** Physical table name used in compiled SQL. */
-    table: string;
-    /** Primary key column name. */
-    pk: string;
-    /** Base columns and their storage types. */
-    columns: Record<string, string>;
-    /** Relation metadata keyed by public relation name. */
-    relations?: Record<string, RelationMeta>;
-}

package/dist/query/domain/TableMetaFactory.d.ts

@@ -1,10 +0,0 @@
-import type { Model as SchemaModel } from '@danceroutine/tango-schema/domain';
-import type { TableMeta } from './TableMeta';
-/**
- * Build registry-backed recursive table metadata for query planning and
- * hydration execution.
- */
-export declare class TableMetaFactory {
-    static create(model: SchemaModel): TableMeta;
-    private static createWithCache;
-}

package/dist/query/domain/WhereClause.d.ts

@@ -1,4 +0,0 @@
-export interface WhereClause {
-    sql: string;
-    params: readonly unknown[];
-}

package/dist/query/domain/index.d.ts

@@ -1,21 +0,0 @@
-/**
- * Domain boundary barrel: centralizes this subdomain's public contract.
- */
-export type { CompiledQuery } from './CompiledQuery';
-export type { Dialect } from './Dialect';
-export type { Direction } from './Direction';
-export type { FilterInput } from './FilterInput';
-export type { FilterKey } from './FilterKey';
-export type { FilterValue } from './FilterValue';
-export type { LookupType } from './LookupType';
-export type { OrderSpec } from './OrderSpec';
-export type { OrderToken } from './OrderToken';
-export type { QNode } from './QNode';
-export { QueryResult } from './QueryResult';
-export type { QuerySetState } from './QuerySetState';
-export type { RelationMeta } from './RelationMeta';
-export type { ForwardSingleRelations, GeneratedRelationFilterKeys, GeneratedHydratedRelationMap, GeneratedPrefetchRelatedPathKeys, GeneratedSelectRelatedPathKeys, HydratedQueryResult, HydratedRelationMap, ManyRelationHydrationCardinality, MaybeHydratedRelationMap, PrefetchRelatedRelations, RelationKeys, RelationHydrationCardinality, ReverseCollectionRelations, ReverseSingleRelations, SelectRelatedRelations, SingleRelationHydrationCardinality, } from './RelationTyping';
-export { InternalRelationHydrationCardinality } from './RelationTyping';
-export type { TableMeta } from './TableMeta';
-export { TableMetaFactory } from './TableMetaFactory';
-export type { WhereClause } from './WhereClause';

package/dist/query/domain/internal/InternalDialect.d.ts

@@ -1,4 +0,0 @@
-export declare const InternalDialect: {
-    readonly POSTGRES: "postgres";
-    readonly SQLITE: "sqlite";
-};

package/dist/query/domain/internal/InternalDirection.d.ts

@@ -1,4 +0,0 @@
-export declare const InternalDirection: {
-    readonly ASC: "asc";
-    readonly DESC: "desc";
-};

package/dist/query/domain/internal/InternalLookupType.d.ts

@@ -1,15 +0,0 @@
-export declare const InternalLookupType: {
-    readonly EXACT: "exact";
-    readonly LT: "lt";
-    readonly LTE: "lte";
-    readonly GT: "gt";
-    readonly GTE: "gte";
-    readonly IN: "in";
-    readonly ISNULL: "isnull";
-    readonly CONTAINS: "contains";
-    readonly ICONTAINS: "icontains";
-    readonly STARTSWITH: "startswith";
-    readonly ISTARTSWITH: "istartswith";
-    readonly ENDSWITH: "endswith";
-    readonly IENDSWITH: "iendswith";
-};

package/dist/query/domain/internal/InternalPrefetchQueryKind.d.ts

@@ -1,20 +0,0 @@
-/**
- * Discriminator strings for compiled prefetch hydration: how `QueryCompiler.compilePrefetch`
- * batches related rows for hydration (`CompiledPrefetchQuery`).
- */
-export declare const InternalPrefetchQueryKind: {
-    /**
-     * Single-query prefetch against the related table (`SELECT … FROM target WHERE fk IN (...)`).
-     * Used when each related row is reachable from one physical table via a foreign key or
-     * symmetric join path (belongsTo, hasMany, hasOne, reverse one-to-one).
-     */
-    readonly DIRECT: "direct";
-    /**
-     * Two-phase many-to-many prefetch: first query reads join (through) rows pairing owner ids to
-     * target ids (`throughSql`), then target rows load by primary key (`compileManyToManyTargets`).
-     * Distinct from relation metadata’s `manyToMany` relation *kind* on an endpoint—this marks the
-     * compiled prefetch *strategy*, not the schema edge type.
-     */
-    readonly MANY_TO_MANY: "manyToMany";
-};
-export type PrefetchQueryKind = (typeof InternalPrefetchQueryKind)[keyof typeof InternalPrefetchQueryKind];

package/dist/query/domain/internal/InternalQNodeType.d.ts

@@ -1,6 +0,0 @@
-export declare const InternalQNodeType: {
-    readonly ATOM: "atom";
-    readonly AND: "and";
-    readonly OR: "or";
-    readonly NOT: "not";
-};

package/dist/query/domain/internal/InternalRelationKind.d.ts

@@ -1,6 +0,0 @@
-export declare const InternalRelationKind: {
-    readonly HAS_MANY: "hasMany";
-    readonly BELONGS_TO: "belongsTo";
-    readonly HAS_ONE: "hasOne";
-    readonly MANY_TO_MANY: "manyToMany";
-};

package/dist/query/internal/isQNodeLike.d.ts

@@ -1,3 +0,0 @@
-import type { FilterInput } from '../domain/FilterInput';
-import type { QNode } from '../domain/QNode';
-export declare function isQNodeLike<T>(value: FilterInput<T> | QNode<T>): value is QNode<T>;

package/dist/query/planning/QueryPlanner.d.ts

@@ -1,16 +0,0 @@
-import type { QuerySetState } from '../domain/QuerySetState';
-import type { TableMeta } from '../domain/TableMeta';
-import type { QueryHydrationPlanRoot } from './domain/QueryHydrationPlan';
-/**
- * Parse, validate, normalize, and plan recursive relation hydration paths.
- */
-export declare class QueryPlanner {
-    private readonly meta;
-    static readonly BRAND: "tango.orm.query_planner";
-    readonly __tangoBrand: typeof QueryPlanner.BRAND;
-    constructor(meta: TableMeta);
-    static isQueryPlanner(value: unknown): value is QueryPlanner;
-    plan<T, TSourceModel = unknown>(state: QuerySetState<T, TSourceModel>): QueryHydrationPlanRoot;
-    private addPath;
-    private buildPlannedChildren;
-}

package/dist/query/planning/domain/QueryHydrationPlan.d.ts

@@ -1,20 +0,0 @@
-import type { RelationHydrationLoadMode, RelationMeta } from '../../domain/RelationMeta';
-export type QueryHydrationLoadMode = RelationHydrationLoadMode;
-export interface QueryHydrationPlanRoot {
-    joinNodes: readonly QueryHydrationPlanNode[];
-    prefetchNodes: readonly QueryHydrationPlanNode[];
-    requestedPaths: readonly string[];
-}
-export interface QueryHydrationPlanNode {
-    nodeId: string;
-    relationName: string;
-    relationPath: string;
-    ownerModelKey: string;
-    relationEdge: RelationMeta;
-    targetModelKey: string;
-    loadMode: QueryHydrationLoadMode;
-    cardinality: RelationMeta['cardinality'];
-    provenance: readonly string[];
-    joinChildren: readonly QueryHydrationPlanNode[];
-    prefetchChildren: readonly QueryHydrationPlanNode[];
-}

package/dist/query/planning/index.d.ts

@@ -1,2 +0,0 @@
-export { QueryPlanner } from './QueryPlanner';
-export type { QueryHydrationPlanNode, QueryHydrationPlanRoot, QueryHydrationLoadMode, } from './domain/QueryHydrationPlan';