@nicia-ai/typegraph 0.24.1 → 0.25.1

package/dist/ast-dgLhLOg0.d.cts

@@ -1,497 +0,0 @@
-import { T as TemporalMode, j as FulltextQueryMode } from './types-Qk2l3IkQ.cjs';
-
-declare const MAX_JSON_POINTER_DEPTH: 5;
-type JsonPointer = string & {
-    readonly __jsonPointer: unique symbol;
-};
-type JsonPointerSegment = string | number;
-type JsonPointerSegments = readonly JsonPointerSegment[];
-type Depth = 0 | 1 | 2 | 3 | 4 | 5;
-interface DepthDecrementMap {
-    0: 0;
-    1: 0;
-    2: 1;
-    3: 2;
-    4: 3;
-    5: 4;
-}
-type Decrement<Current extends Depth> = DepthDecrementMap[Current];
-type NonNegativeIntegerString = Exclude<`${bigint}`, `-${string}`>;
-type ObjectPointerKey<T> = Exclude<Extract<keyof T, string>, NonNegativeIntegerString>;
-type EncodeTilde<S extends string> = S extends `${infer Head}~${infer Tail}` ? `${EncodeTilde<Head>}~0${EncodeTilde<Tail>}` : S;
-type EncodeSlash<S extends string> = S extends `${infer Head}/${infer Tail}` ? `${EncodeSlash<Head>}~1${EncodeSlash<Tail>}` : S;
-type EncodePointerSegment<S extends string> = EncodeSlash<EncodeTilde<S>>;
-type DecodePointerSegment<S extends string> = S extends `${infer Head}~1${infer Tail}` ? `${DecodePointerSegment<Head>}/${DecodePointerSegment<Tail>}` : S extends `${infer Head}~0${infer Tail}` ? `${DecodePointerSegment<Head>}~${DecodePointerSegment<Tail>}` : S;
-type PointerForArray<T, Current extends Depth> = `/${NonNegativeIntegerString}` | (Current extends 1 ? never : `/${NonNegativeIntegerString}${JsonPointerFor<T, Decrement<Current>>}`);
-type PointerForObject<T, Current extends Depth> = {
-    [K in ObjectPointerKey<T>]: `/${EncodePointerSegment<K>}` | (Current extends 1 ? never : `/${EncodePointerSegment<K>}${JsonPointerFor<T[K], Decrement<Current>>}`);
-}[ObjectPointerKey<T>];
-type JsonPointerFor<T, Current extends Depth = 5> = "" | (Current extends 0 ? "" : T extends readonly (infer U)[] ? PointerForArray<U, Current> : never) | (Current extends 0 ? "" : T extends Record<string, unknown> ? PointerForObject<T, Current> : never);
-type PointerSegmentsForArray<T, Current extends Depth> = readonly [number] | (Current extends 1 ? readonly [number] : readonly [number, ...JsonPointerSegmentsFor<T, Decrement<Current>>]);
-type PointerSegmentsForObject<T, Current extends Depth> = {
-    [K in ObjectPointerKey<T>]: readonly [K] | (Current extends 1 ? readonly [K] : readonly [K, ...JsonPointerSegmentsFor<T[K], Decrement<Current>>]);
-}[ObjectPointerKey<T>];
-type JsonPointerSegmentsFor<T, Current extends Depth = 5> = readonly [] | (Current extends 0 ? readonly [] : T extends readonly (infer U)[] ? PointerSegmentsForArray<U, Current> : never) | (Current extends 0 ? readonly [] : T extends Record<string, unknown> ? PointerSegmentsForObject<T, Current> : never);
-type JsonPointerInput<T> = JsonPointerFor<T> | JsonPointerSegmentsFor<T> | JsonPointer;
-type ResolveJsonPointer<T, Pointer extends string> = Pointer extends "" ? T : Pointer extends `/${infer Head}/${infer Tail}` ? ResolveJsonPointer<ResolvePointerSegment<T, DecodePointerSegment<Head>>, `/${Tail}`> : Pointer extends `/${infer Head}` ? ResolvePointerSegment<T, DecodePointerSegment<Head>> : unknown;
-type ResolvePointerSegment<T, Segment extends string> = T extends readonly (infer U)[] ? Segment extends NonNegativeIntegerString ? U : unknown : T extends Record<string, unknown> ? Segment extends keyof T ? Segment extends NonNegativeIntegerString ? unknown : T[Segment] : unknown : unknown;
-type ResolveJsonPointerSegments<T, Segments extends readonly JsonPointerSegment[]> = Segments extends readonly [] ? T : Segments extends readonly [infer Head, ...infer Tail] ? ResolveJsonPointerSegments<ResolvePointerSegment<T, SegmentToString<Head>>, Extract<Tail, readonly JsonPointerSegment[]>> : unknown;
-type SegmentToString<Segment> = Segment extends number ? `${Segment}` : Segment extends string ? Segment : string;
-declare function jsonPointer(segments: JsonPointerSegments): JsonPointer;
-declare function normalizeJsonPointer<T>(input: JsonPointerInput<T>): JsonPointer;
-declare function parseJsonPointer(pointer: JsonPointer): readonly string[];
-declare function joinJsonPointers(base: JsonPointer | undefined, relative: JsonPointer): JsonPointer;
-
-/**
- * Query AST types.
- *
- * Defines the abstract syntax tree for TypeGraph queries.
- * This portable representation can be compiled to SQL (today)
- * or other query languages (Cypher, SPARQL) in the future.
- */
-
-/**
- * A field reference in a predicate.
- */
-type FieldRef = Readonly<{
-    __type: "field_ref";
-    alias: string;
-    path: readonly string[];
-    jsonPointer?: JsonPointer | undefined;
-    valueType?: ValueType | undefined;
-    elementType?: ValueType | undefined;
-}>;
-/**
- * A literal value in a predicate.
- */
-type LiteralValue = Readonly<{
-    __type: "literal";
-    value: string | number | boolean;
-    valueType?: ValueType | undefined;
-}>;
-/**
- * A parameter reference for prepared queries.
- *
- * Used in place of a literal value to create parameterized queries
- * that can be executed multiple times with different bindings.
- */
-type ParameterRef = Readonly<{
-    __type: "parameter";
-    name: string;
-    valueType?: ValueType | undefined;
-}>;
-/**
- * Supported value types for predicates.
- */
-type ValueType = "string" | "number" | "boolean" | "date" | "array" | "object" | "embedding" | "unknown";
-/**
- * Comparison operators.
- */
-type ComparisonOp = "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "notIn";
-/**
- * String operators.
- */
-type StringOp = "contains" | "startsWith" | "endsWith" | "like" | "ilike";
-/**
- * A comparison predicate.
- */
-type ComparisonPredicate = Readonly<{
-    __type: "comparison";
-    op: ComparisonOp;
-    left: FieldRef;
-    right: LiteralValue | LiteralValue[] | ParameterRef;
-}>;
-/**
- * A string predicate.
- */
-type StringPredicate = Readonly<{
-    __type: "string_op";
-    op: StringOp;
-    field: FieldRef;
-    pattern: string | ParameterRef;
-}>;
-/**
- * A null check predicate.
- */
-type NullPredicate = Readonly<{
-    __type: "null_check";
-    op: "isNull" | "isNotNull";
-    field: FieldRef;
-}>;
-/**
- * A between predicate.
- */
-type BetweenPredicate = Readonly<{
-    __type: "between";
-    field: FieldRef;
-    lower: LiteralValue | ParameterRef;
-    upper: LiteralValue | ParameterRef;
-}>;
-/**
- * Array operators.
- */
-type ArrayOp = "contains" | "containsAll" | "containsAny" | "isEmpty" | "isNotEmpty" | "lengthEq" | "lengthGt" | "lengthGte" | "lengthLt" | "lengthLte";
-/**
- * An array predicate.
- */
-type ArrayPredicate = Readonly<{
-    __type: "array_op";
-    op: ArrayOp;
-    field: FieldRef;
-    values?: readonly LiteralValue[];
-    length?: number;
-}>;
-/**
- * Object operators.
- */
-type ObjectOp = "hasKey" | "hasPath" | "pathEquals" | "pathContains" | "pathIsNull" | "pathIsNotNull";
-/**
- * An object/JSON predicate.
- */
-type ObjectPredicate = Readonly<{
-    __type: "object_op";
-    op: ObjectOp;
-    field: FieldRef;
-    pointer: JsonPointer;
-    value?: LiteralValue;
-    valueType?: ValueType;
-    elementType?: ValueType;
-}>;
-/**
- * Logical AND predicate.
- */
-type AndPredicate = Readonly<{
-    __type: "and";
-    predicates: readonly PredicateExpression[];
-}>;
-/**
- * Logical OR predicate.
- */
-type OrPredicate = Readonly<{
-    __type: "or";
-    predicates: readonly PredicateExpression[];
-}>;
-/**
- * Logical NOT predicate.
- */
-type NotPredicate = Readonly<{
-    __type: "not";
-    predicate: PredicateExpression;
-}>;
-/**
- * An aggregate comparison predicate (for HAVING clauses).
- */
-type AggregateComparisonPredicate = Readonly<{
-    __type: "aggregate_comparison";
-    op: ComparisonOp;
-    aggregate: AggregateExpr;
-    value: LiteralValue;
-}>;
-/**
- * An EXISTS subquery predicate.
- * Tests whether the subquery returns any rows.
- */
-type ExistsSubquery = Readonly<{
-    __type: "exists";
-    subquery: QueryAst;
-    negated: boolean;
-}>;
-/**
- * An IN subquery predicate.
- * Tests whether a field value is in the subquery results.
- */
-type InSubquery = Readonly<{
-    __type: "in_subquery";
-    field: FieldRef;
-    subquery: QueryAst;
-    negated: boolean;
-}>;
-/**
- * Vector similarity metric types.
- */
-type VectorMetricType = "cosine" | "l2" | "inner_product";
-/**
- * A vector similarity predicate.
- * Finds nodes with embeddings similar to the query embedding.
- *
- * This predicate affects query execution by:
- * - Joining with the embeddings table
- * - Adding ORDER BY distance (ascending)
- * - Applying LIMIT (top k results)
- * - Optionally filtering by minimum score
- */
-type VectorSimilarityPredicate = Readonly<{
-    __type: "vector_similarity";
-    /** The embedding field reference */
-    field: FieldRef;
-    /** The query embedding to compare against */
-    queryEmbedding: readonly number[];
-    /** Similarity metric to use */
-    metric: VectorMetricType;
-    /** Maximum number of results to return */
-    limit: number;
-    /** Optional minimum similarity score (0-1 for cosine) */
-    minScore?: number;
-}>;
-
-/**
- * A fulltext MATCH predicate.
- *
- * Finds nodes whose combined searchable content matches the query. Affects
- * query execution by joining with the fulltext table, adding an ORDER BY
- * on relevance rank (descending), and applying a LIMIT (top k).
- */
-type FulltextMatchPredicate = Readonly<{
-    __type: "fulltext_match";
-    /**
-     * Reserved for forward compatibility with per-field fulltext dispatch.
-     * Today only `field.alias` is consumed: the MATCH always targets the
-     * combined `content` column, so `field.path` is a synthetic
-     * `["$fulltext"]` marker rather than a real props path. Future
-     * strategies (per-field indexes, `setweight()`-style boosts) can use
-     * the full `FieldRef` without breaking the AST shape.
-     */
-    field: FieldRef;
-    /** The user-supplied query string. */
-    query: string;
-    /** Parse mode for the query string. Default: "websearch". */
-    mode: FulltextQueryMode;
-    /** Language override for query parsing. */
-    language?: string;
-    /** Maximum number of results to return. */
-    limit: number;
-    /** Minimum relevance to include (backend-native units). */
-    minScore?: number;
-}>;
-/**
- * Fusion options for hybrid (vector + fulltext) queries.
- *
- * Shared between:
- * - Query-builder path: `QueryBuilder.fuseWith()` stores this on `QueryAst`.
- * - Store path: `store.search.hybrid(kind, { fusion })` accepts the same shape.
- *
- * Only applied when the query contains both a vector and a fulltext
- * predicate. Defaults (when omitted): RRF with k=60 and equal weights.
- */
-type HybridFusionOptions = Readonly<{
-    /** RRF is the only currently supported fusion method. */
-    method?: "rrf";
-    /** RRF constant. The classic value is 60. */
-    k?: number;
-    /** Per-source weights. Default: { vector: 1, fulltext: 1 }. */
-    weights?: Readonly<{
-        vector?: number;
-        fulltext?: number;
-    }>;
-}>;
-/**
- * All predicate expression types.
- */
-type PredicateExpression = ComparisonPredicate | StringPredicate | NullPredicate | BetweenPredicate | ArrayPredicate | ObjectPredicate | AndPredicate | OrPredicate | NotPredicate | AggregateComparisonPredicate | ExistsSubquery | InSubquery | VectorSimilarityPredicate | FulltextMatchPredicate;
-/**
- * The starting point of a query (the FROM clause).
- */
-type QueryStart = Readonly<{
-    alias: string;
-    kinds: readonly string[];
-    includeSubClasses: boolean;
-}>;
-/**
- * Direction of edge traversal.
- */
-type TraversalDirection = "out" | "in";
-/**
- * Traversal ontology expansion behavior.
- *
- * - `"none"` — follow only the exact edge kind specified
- * - `"implying"` — also follow edge kinds that imply the specified kind (subClassOf)
- * - `"inverse"` — also follow the ontological inverse edge kind (inverseOf)
- * - `"all"` — follow both implying and inverse expansions
- */
-type TraversalExpansion = "none" | "implying" | "inverse" | "all";
-/**
- * Cycle handling policy for recursive traversals.
- */
-type RecursiveCyclePolicy = "prevent" | "allow";
-/**
- * Variable-length traversal specification for recursive graph traversals.
- */
-type VariableLengthSpec = Readonly<{
-    /** Minimum number of hops before including results (default: 1) */
-    minDepth: number;
-    /** Maximum number of hops (-1 = unlimited, default: -1) */
-    maxDepth: number;
-    /**
-     * Cycle handling mode.
-     *
-     * - "prevent": Track visited nodes per path and reject revisits
-     * - "allow": Skip cycle checks (faster, may revisit nodes)
-     */
-    cyclePolicy: RecursiveCyclePolicy;
-    /** Optional column alias for projected traversal path array */
-    pathAlias?: string;
-    /** Optional column alias for projected traversal depth */
-    depthAlias?: string;
-}>;
-/**
- * A traversal step in the query.
- */
-type Traversal = Readonly<{
-    edgeAlias: string;
-    edgeKinds: readonly string[];
-    /**
-     * Edge kinds traversed in the opposite direction.
-     *
-     * Populated when query options request inverse/symmetric expansion.
-     */
-    inverseEdgeKinds?: readonly string[];
-    direction: TraversalDirection;
-    nodeAlias: string;
-    nodeKinds: readonly string[];
-    joinFromAlias: string;
-    joinEdgeField: "from_id" | "to_id";
-    /** If true, use LEFT JOIN instead of INNER JOIN (optional match) */
-    optional: boolean;
-    /** Variable-length traversal configuration (for recursive CTEs) */
-    variableLength?: VariableLengthSpec;
-}>;
-/**
- * Supported aggregate functions.
- */
-type AggregateFunction = "count" | "countDistinct" | "sum" | "avg" | "min" | "max";
-/**
- * An aggregate expression.
- */
-type AggregateExpr = Readonly<{
-    __type: "aggregate";
-    function: AggregateFunction;
-    field: FieldRef;
-}>;
-/**
- * A GROUP BY specification.
- */
-type GroupBySpec = Readonly<{
-    fields: readonly FieldRef[];
-}>;
-/**
- * A projected field in the SELECT clause.
- * Can be either a direct field reference or an aggregate expression.
- */
-type ProjectedField = Readonly<{
-    outputName: string;
-    source: FieldRef | AggregateExpr;
-    /** Override the CTE alias for this field (used for edge fields in node CTEs) */
-    cteAlias?: string;
-}>;
-/**
- * The projection (SELECT) clause.
- */
-type Projection = Readonly<{
-    fields: readonly ProjectedField[];
-}>;
-/**
- * A selectively projected field for optimized queries.
- *
- * Used when the select callback only accesses specific fields,
- * allowing the compiler to generate optimized SQL that fetches
- * only those fields instead of the full props blob.
- */
-type SelectiveField = Readonly<{
-    /** The alias (node or edge) this field belongs to */
-    alias: string;
-    /** The field name (e.g., "email", "name", "id") */
-    field: string;
-    /** The output column name in the result (e.g., "p_email") */
-    outputName: string;
-    /** True if this is a system field (id, kind, etc.), false for props */
-    isSystemField: boolean;
-    /**
-     * Optional value type for props fields.
-     *
-     * When present, the compiler can use type-aware JSON extraction
-     * (e.g. numeric/date casts) to better match predicate compilation
-     * and enable expression index coverage.
-     */
-    valueType?: ValueType | undefined;
-}>;
-/**
- * Null ordering preference.
- */
-type NullOrdering = "first" | "last";
-/**
- * Sort direction.
- */
-type SortDirection = "asc" | "desc";
-/**
- * An ordering specification.
- */
-type OrderSpec = Readonly<{
-    field: FieldRef;
-    direction: SortDirection;
-    nulls?: NullOrdering;
-}>;
-/**
- * A predicate applied to a specific node or edge alias.
- */
-type NodePredicate = Readonly<{
-    targetAlias: string;
-    /** Whether this predicate targets a node or edge. Defaults to "node". */
-    targetType?: "node" | "edge";
-    expression: PredicateExpression;
-}>;
-/**
- * Temporal query options.
- */
-type TemporalOptions = Readonly<{
-    mode: TemporalMode;
-    asOf?: string;
-}>;
-/**
- * The complete query AST.
- */
-type QueryAst = Readonly<{
-    /** The graph ID this query is for (used for subqueries) */
-    graphId?: string;
-    start: QueryStart;
-    traversals: readonly Traversal[];
-    predicates: readonly NodePredicate[];
-    projection: Projection;
-    temporalMode: TemporalOptions;
-    orderBy?: readonly OrderSpec[];
-    limit?: number;
-    offset?: number;
-    /** GROUP BY specification for aggregate queries */
-    groupBy?: GroupBySpec;
-    /** HAVING clause - predicates applied after GROUP BY */
-    having?: PredicateExpression;
-    /**
-     * Selective fields for optimized queries.
-     * When present, the compiler generates SQL that only fetches these specific
-     * fields instead of the full props blob, enabling covered index usage.
-     */
-    selectiveFields?: readonly SelectiveField[];
-    /** Fusion options for hybrid queries. Ignored unless both predicates present. */
-    fusion?: HybridFusionOptions;
-}>;
-/**
- * Set operation types for combining queries.
- */
-type SetOperationType = "union" | "unionAll" | "intersect" | "except";
-/**
- * A set operation combining two queries.
- */
-type SetOperation = Readonly<{
-    __type: "set_operation";
-    operator: SetOperationType;
-    left: ComposableQuery;
-    right: ComposableQuery;
-    orderBy?: readonly OrderSpec[];
-    limit?: number;
-    offset?: number;
-}>;
-/**
- * A composable query - either a base query or a set operation.
- */
-type ComposableQuery = QueryAst | SetOperation;
-
-export { type AggregateExpr as A, type ComparisonOp as C, type FieldRef as F, type GroupBySpec as G, type HybridFusionOptions as H, type JsonPointer as J, MAX_JSON_POINTER_DEPTH as M, type NodePredicate as N, type OrderSpec as O, type ParameterRef as P, type QueryAst as Q, type ResolveJsonPointer as R, type SortDirection as S, type TraversalExpansion as T, type ValueType as V, type AggregateComparisonPredicate as a, type JsonPointerFor as b, type JsonPointerInput as c, type JsonPointerSegment as d, type JsonPointerSegments as e, type JsonPointerSegmentsFor as f, type ResolveJsonPointerSegments as g, jsonPointer as h, type PredicateExpression as i, joinJsonPointers as j, type VectorMetricType as k, type Traversal as l, type ProjectedField as m, normalizeJsonPointer as n, type RecursiveCyclePolicy as o, parseJsonPointer as p, type TraversalDirection as q, type SelectiveField as r, type ComposableQuery as s, type SetOperationType as t, type SetOperation as u };