@kuindji/typed-sql 0.3.0 → 0.4.0

package/src/columns.ts

@@ -10,11 +10,14 @@ import type {
     CanPrecedeColumn,
     CleanExpr,
     CleanIdent,
+    CleanLooseToken,
+    DQuoteSpaceSentinel,
     HasSpecial,
     IsParamPlaceholder,
     IsQualifiedRefCandidate,
     IsRuntimeStringFragment,
     IsSqlConstant,
+    LooseScanView,
     OperatorToken,
     ReplaceAll,
     SqlReserved,
@@ -206,49 +209,182 @@ export type ColumnRefValidNoTables<ColRef extends string, S extends DatabaseSche
                 : ColumnExistsInAnyTable<B, S>
             : ColumnExistsInAnyTable<CleanIdent<ColRef>, S>;
 
-// Best-effort qualified column references across the query
+// ---- Direct-string column ref-scans ----
+//
+// Best-effort qualified / unqualified column references across a query segment.
+// These walk the padded `LooseScanView` string DIRECTLY, word by word — replacing
+// the old `TokenizeLoose` token ARRAY plus two array-walks (round-9): every array
+// build/destructure step minted a unique-content tuple and its apparent-`Array`
+// types, while a word-jump string walk interns its substrings and `[any, ...Steps]`
+// counter tuples. Token semantics are reproduced verbatim:
+//   - per word, the kept token is `CleanLooseToken<ReplaceAll<H, DQuoteSpaceSentinel, " ">>`
+//     (exactly the old `SrclPush`); a word cleaning to `""` never occupied an array
+//     position, so it updates NO register and consumes NO cap budget;
+//   - `IS [NOT] DISTINCT FROM` (old `DropDistinctFrom` pre-pass, fused in): a `from`
+//     token whose RAW-stream predecessor is `distinct` is operator text, not a
+//     FROM-clause boundary — it is dropped, so the filtered-stream `Prev` the next
+//     token sees stays `distinct` (which `CanPrecedeColumn` blesses) instead of
+//     `from` (which would mark it a table source and skip validation). `PrevRaw`
+//     tracks the UNFILTERED stream (a dropped `from` still sets it to `from`),
+//     mirroring the old pre-pass's own `Prev` chain exactly. The old pass only ran
+//     when the segment contained `distinct ` — per-token it's the same test, and
+//     its 400-token cap (remainder unfiltered) is gone: a >400-token `distinct`
+//     stream now validates its RHS like any other, never rejecting valid SQL.
+//
+// Cap parity: `Steps` caps total WORDS at 2000 (the old split cap — on cap the old
+// pipeline blobbed the remainder into ONE token and the walkers processed it; the
+// `*Last` arms apply the same one-token transform to the remainder). `Kept` caps
+// kept TOKENS at 900 (the old ref-walk cap — return `Acc`, rest unscanned).
 
-export type QualifiedColumnRefs<
-    Tokens extends string[],
-    S extends DatabaseSchema,
-    Tables extends string,
-    Aliases extends string,
+export type QualifiedRefScan<Seg extends string> =
+    LooseScanView<Seg> extends infer V extends string
+        ? QrsWalk<V>
+        : never;
+
+type QrsWalk<
+    V extends string,
     Acc extends string = never,
     Prev extends string = "",
+    PrevRaw extends string = "",
+    Kept extends any[] = [],
     Steps extends any[] = []
-> = Steps["length"] extends 900
-    ? Acc
-    : Tokens extends [infer T extends string, ...infer Rest extends string[]]
-    ? T extends `${string}.${string}`
-        ? Prev extends "from" | "join" | "update" | "into" | "delete"
-            ? QualifiedColumnRefs<Rest, S, Tables, Aliases, Acc, T, [any, ...Steps]>
-            : IsQualifiedRefCandidate<T> extends true
-                ? QualifiedColumnRefs<Rest, S, Tables, Aliases, Acc | T, T, [any, ...Steps]>
-                : QualifiedColumnRefs<Rest, S, Tables, Aliases, Acc, T, [any, ...Steps]>
-        : QualifiedColumnRefs<Rest, S, Tables, Aliases, Acc, T, [any, ...Steps]>
-    : Acc;
+> = Steps["length"] extends 2000
+    ? QrsLast<V, Acc, Prev>
+    : Kept["length"] extends 900
+        ? Acc
+        : V extends `${infer H} ${infer R}`
+            ? CleanLooseToken<ReplaceAll<H, DQuoteSpaceSentinel, " ">> extends infer M extends string
+                ? M extends ""
+                    ? QrsWalk<R, Acc, Prev, PrevRaw, Kept, [any, ...Steps]>
+                    : M extends "from"
+                        ? PrevRaw extends "distinct"
+                            ? QrsWalk<R, Acc, Prev, "from", Kept, [any, ...Steps]>
+                            : QrsWalk<R, Acc, "from", "from", [any, ...Kept], [any, ...Steps]>
+                        : M extends `${string}.${string}`
+                            ? Prev extends "from" | "join" | "update" | "into" | "delete"
+                                ? QrsWalk<R, Acc, M, M, [any, ...Kept], [any, ...Steps]>
+                                : IsQualifiedRefCandidate<M> extends true
+                                    ? QrsWalk<R, Acc | M, M, M, [any, ...Kept], [any, ...Steps]>
+                                    : QrsWalk<R, Acc, M, M, [any, ...Kept], [any, ...Steps]>
+                            : QrsWalk<R, Acc, M, M, [any, ...Kept], [any, ...Steps]>
+                : never
+            : QrsLast<V, Acc, Prev>;
+
+// Final word (or capped remainder) as one token. A trailing `from` is never a ref
+// and there is no subsequent token for its `Prev` effect to matter — `Acc` either way.
+type QrsLast<H extends string, Acc extends string, Prev extends string> =
+    CleanLooseToken<ReplaceAll<H, DQuoteSpaceSentinel, " ">> extends infer M extends string
+        ? M extends `${string}.${string}`
+            ? Prev extends "from" | "join" | "update" | "into" | "delete"
+                ? Acc
+                : IsQualifiedRefCandidate<M> extends true
+                    ? Acc | M
+                    : Acc
+            : Acc
+        : never;
 
-// Best-effort unqualified column references across the query
+export type UnqualifiedRefScan<
+    Seg extends string,
+    S extends DatabaseSchema,
+    Tables extends string,
+    Aliases extends string
+> = LooseScanView<Seg> extends infer V extends string
+    ? UrsWalk<V, S, Tables, Aliases>
+    : never;
 
-export type UnqualifiedColumnRefs<
-    Tokens extends string[],
+// Deferred-decision walk: the old array walker judged token T with (Prev, Next) via
+// one-token lookahead. Here the PENDING token `Pend` is judged only when the NEXT
+// kept token `M` materializes — `IsUnqualifiedColumnCandidate<Pend, PrevPrev, M, …>`
+// — then registers shift (`PrevPrev := Pend`, `Pend := M`). At end of stream `Pend`
+// is judged with `Next = ""`, exactly the old `[T]` tail arm. `Pend = ""` means "no
+// pending yet" — safe sentinel (kept tokens are never empty), and the candidate
+// check is `false` for `""`, so the initial shift needs no special arm.
+type UrsWalk<
+    V extends string,
     S extends DatabaseSchema,
     Tables extends string,
     Aliases extends string,
     Acc extends string = never,
-    Prev extends string = "",
+    PrevPrev extends string = "",
+    Pend extends string = "",
+    PrevRaw extends string = "",
+    Kept extends any[] = [],
     Steps extends any[] = []
-> = Steps["length"] extends 900
-    ? Acc
-    : Tokens extends [infer T extends string, infer Next extends string, ...infer Rest extends string[]]
-    ? IsUnqualifiedColumnCandidate<T, Prev, Next, Tables, Aliases, S> extends true
-        ? UnqualifiedColumnRefs<[Next, ...Rest], S, Tables, Aliases, Acc | T, T, [any, ...Steps]>
-        : UnqualifiedColumnRefs<[Next, ...Rest], S, Tables, Aliases, Acc, T, [any, ...Steps]>
-    : Tokens extends [infer T extends string]
-        ? IsUnqualifiedColumnCandidate<T, Prev, "", Tables, Aliases, S> extends true
-            ? Acc | T
-            : Acc
-        : Acc;
+> = Steps["length"] extends 2000
+    ? UrsLast<V, S, Tables, Aliases, Acc, PrevPrev, Pend, PrevRaw>
+    : Kept["length"] extends 900
+        ? Acc
+        : V extends `${infer H} ${infer R}`
+            ? CleanLooseToken<ReplaceAll<H, DQuoteSpaceSentinel, " ">> extends infer M extends string
+                ? M extends ""
+                    ? UrsWalk<R, S, Tables, Aliases, Acc, PrevPrev, Pend, PrevRaw, Kept, [any, ...Steps]>
+                    : M extends "from"
+                        ? PrevRaw extends "distinct"
+                            ? UrsWalk<R, S, Tables, Aliases, Acc, PrevPrev, Pend, "from", Kept, [any, ...Steps]>
+                            : UrsShift<R, S, Tables, Aliases, Acc, PrevPrev, Pend, M, Kept, Steps>
+                        : UrsShift<R, S, Tables, Aliases, Acc, PrevPrev, Pend, M, Kept, Steps>
+                : never
+            : UrsLast<V, S, Tables, Aliases, Acc, PrevPrev, Pend, PrevRaw>;
+
+type UrsShift<
+    R extends string,
+    S extends DatabaseSchema,
+    Tables extends string,
+    Aliases extends string,
+    Acc extends string,
+    PrevPrev extends string,
+    Pend extends string,
+    M extends string,
+    Kept extends any[],
+    Steps extends any[]
+> = IsUnqualifiedColumnCandidate<Pend, PrevPrev, M, Tables, Aliases, S> extends true
+    ? UrsWalk<R, S, Tables, Aliases, Acc | Pend, Pend, M, M, [any, ...Kept], [any, ...Steps]>
+    : UrsWalk<R, S, Tables, Aliases, Acc, Pend, M, M, [any, ...Kept], [any, ...Steps]>;
+
+// Final word (or capped remainder) as one token: judge `Pend` with the final token
+// as `Next`, then the final token itself with `Next = ""`. A final dropped
+// `distinct`-`from` ends the stream, so only `Pend` (with `Next = ""`) is judged.
+type UrsLast<
+    H extends string,
+    S extends DatabaseSchema,
+    Tables extends string,
+    Aliases extends string,
+    Acc extends string,
+    PrevPrev extends string,
+    Pend extends string,
+    PrevRaw extends string
+> = CleanLooseToken<ReplaceAll<H, DQuoteSpaceSentinel, " ">> extends infer M extends string
+    ? M extends ""
+        ? UrsEnd<S, Tables, Aliases, Acc, PrevPrev, Pend>
+        : M extends "from"
+            ? PrevRaw extends "distinct"
+                ? UrsEnd<S, Tables, Aliases, Acc, PrevPrev, Pend>
+                : UrsLast2<S, Tables, Aliases, Acc, PrevPrev, Pend, M>
+            : UrsLast2<S, Tables, Aliases, Acc, PrevPrev, Pend, M>
+    : never;
+
+type UrsLast2<
+    S extends DatabaseSchema,
+    Tables extends string,
+    Aliases extends string,
+    Acc extends string,
+    PrevPrev extends string,
+    Pend extends string,
+    M extends string
+> = IsUnqualifiedColumnCandidate<Pend, PrevPrev, M, Tables, Aliases, S> extends true
+    ? UrsEnd<S, Tables, Aliases, Acc | Pend, Pend, M>
+    : UrsEnd<S, Tables, Aliases, Acc, Pend, M>;
+
+type UrsEnd<
+    S extends DatabaseSchema,
+    Tables extends string,
+    Aliases extends string,
+    Acc extends string,
+    PrevPrev extends string,
+    Pend extends string
+> = IsUnqualifiedColumnCandidate<Pend, PrevPrev, "", Tables, Aliases, S> extends true
+    ? Acc | Pend
+    : Acc;
 
 export type UnqualifiedColumnValid<
     Col extends string,