@kuindji/typed-sql 0.2.0 → 0.4.0

package/src/parsing/split.ts

@@ -13,6 +13,15 @@ import type { SqlReserved } from "./tokenize.js";
 // `{ __c: [...] }` marker. `SplitTopLevel` (the driver below) re-invokes the
 // worker on the remainder with a fresh step counter, which resets TS's internal
 // tail-recursion count per chunk — so arbitrarily long lists split losslessly.
+// Segment-jump, not per-char (the old walk minted one growing-`Cur` string PER
+// CHARACTER and the tail at every step). Each step advances to the LEFTMOST of
+// the five state chars `,` `'` `"` `(` `)`, copying the whole run before it into
+// `Cur` in a single mint; inside a quote it jumps straight to the closing quote
+// (the other quote kind inside a span is data, preserving the old InQ/InDQ
+// suppression; `''` escapes exit+re-enter across two jumps; an unterminated
+// quote at EOF copies the rest verbatim). The `Steps` cap counts JUMPS and
+// yields `{ __c: [...] }` to the driver as before. Mirrors `MtcStructJump`
+// (tokenize.ts) and `SbpParenJump` (extract.ts).
 type SplitTopLevelWorker<
     S extends string,
     Depth extends any[] = [],
@@ -21,36 +30,89 @@ type SplitTopLevelWorker<
     Steps extends any[] = [],
     InQ extends boolean = false,
     InDQ extends boolean = false
-> = Steps["length"] extends 450
+// CHUNK = 120 JUMPS, not chars: since the round-7 struct-jump rewrite each
+// jump costs ~4 conditional evaluations through the StlStructJump* helper
+// chain, so the old 450-jump chunk could burn >1000 tail counts inside ONE
+// chunk (TS2589) on a 50-projection select list. 120 jumps ≈ 500 tail counts.
+> = Steps["length"] extends 120
     ? { __c: [S, Depth, Acc, Cur, InQ, InDQ] }
     : string extends CleanIdent<S>
         ? [...Acc, `${Cur}string`]
-        : S extends `${infer C}${infer Rest}`
-        ? C extends "'"
-            // A single quote toggles "inside string literal": commas, parens and
-            // path braces inside a '...' literal are kept verbatim, not split.
-            // Suppressed while inside a double-quoted identifier.
-            ? InDQ extends true
-                ? SplitTopLevelWorker<Rest, Depth, Acc, `${Cur}${C}`, [any, ...Steps], InQ, InDQ>
-                : SplitTopLevelWorker<Rest, Depth, Acc, `${Cur}${C}`, [any, ...Steps], InQ extends true ? false : true, InDQ>
-            : InQ extends true
-                ? SplitTopLevelWorker<Rest, Depth, Acc, `${Cur}${C}`, [any, ...Steps], InQ, InDQ>
-            : C extends `"`
-                // A double quote toggles "inside quoted identifier": commas and
-                // parens inside `"..."` are part of the identifier, kept verbatim.
-                ? SplitTopLevelWorker<Rest, Depth, Acc, `${Cur}${C}`, [any, ...Steps], InQ, InDQ extends true ? false : true>
+        : InQ extends true
+            ? S extends `${infer P}'${infer R}`
+                ? SplitTopLevelWorker<R, Depth, Acc, `${Cur}${P}'`, [any, ...Steps], false, InDQ>
+                : [...Acc, `${Cur}${S}`]
             : InDQ extends true
-                ? SplitTopLevelWorker<Rest, Depth, Acc, `${Cur}${C}`, [any, ...Steps], InQ, InDQ>
-            : C extends "("
-                ? SplitTopLevelWorker<Rest, [any, ...Depth], Acc, `${Cur}${C}`, [any, ...Steps], InQ, InDQ>
-                : C extends ")"
-                    ? SplitTopLevelWorker<Rest, Depth extends [any, ...infer D] ? D : [], Acc, `${Cur}${C}`, [any, ...Steps], InQ, InDQ>
-                    : C extends ","
-                        ? Depth["length"] extends 0
-                            ? SplitTopLevelWorker<Rest, Depth, [...Acc, Cur], "", [any, ...Steps], InQ, InDQ>
-                            : SplitTopLevelWorker<Rest, Depth, Acc, `${Cur}${C}`, [any, ...Steps], InQ, InDQ>
-                        : SplitTopLevelWorker<Rest, Depth, Acc, `${Cur}${C}`, [any, ...Steps], InQ, InDQ>
-        : [...Acc, Cur];
+                ? S extends `${infer P}"${infer R}`
+                    ? SplitTopLevelWorker<R, Depth, Acc, `${Cur}${P}"`, [any, ...Steps], InQ, false>
+                    : [...Acc, `${Cur}${S}`]
+                : S extends `${infer P},${infer R}`
+                    // a structural char in the run before the first comma → it is
+                    // leftmost; defer to the struct jump
+                    ? StlHasStruct<P> extends true
+                        ? StlStructJump<S, Depth, Acc, Cur, Steps>
+                        : Depth["length"] extends 0
+                            ? SplitTopLevelWorker<R, Depth, [...Acc, `${Cur}${P}`], "", [any, ...Steps], false, false>
+                            : SplitTopLevelWorker<R, Depth, Acc, `${Cur}${P},`, [any, ...Steps], false, false>
+                    : StlHasStruct<S> extends true
+                        ? StlStructJump<S, Depth, Acc, Cur, Steps>
+                        : [...Acc, `${Cur}${S}`];
+
+type StlHasStruct<S extends string> =
+    S extends `${string}'${string}` ? true
+    : S extends `${string}"${string}` ? true
+    : S extends `${string}(${string}` ? true
+    : S extends `${string})${string}` ? true
+    : false;
+
+// Leftmost of `'` / `"` / `(` / `)` (the caller guarantees at least one occurs
+// before any comma). Pairwise narrowing: split on a candidate; if an
+// earlier-class char appears in its prefix, that one is leftmost instead.
+type StlStructJump<
+    S extends string,
+    Depth extends any[],
+    Acc extends string[],
+    Cur extends string,
+    Steps extends any[]
+> = S extends `${infer P}'${infer R}`
+    ? P extends `${string}"${string}` | `${string}(${string}` | `${string})${string}`
+        ? StlStructJump2<S, Depth, Acc, Cur, Steps>
+        : SplitTopLevelWorker<R, Depth, Acc, `${Cur}${P}'`, [any, ...Steps], true, false>
+    : StlStructJump2<S, Depth, Acc, Cur, Steps>;
+
+type StlStructJump2<
+    S extends string,
+    Depth extends any[],
+    Acc extends string[],
+    Cur extends string,
+    Steps extends any[]
+> = S extends `${infer P}"${infer R}`
+    ? P extends `${string}(${string}` | `${string})${string}`
+        ? StlStructJump3<S, Depth, Acc, Cur, Steps>
+        : SplitTopLevelWorker<R, Depth, Acc, `${Cur}${P}"`, [any, ...Steps], false, true>
+    : StlStructJump3<S, Depth, Acc, Cur, Steps>;
+
+type StlStructJump3<
+    S extends string,
+    Depth extends any[],
+    Acc extends string[],
+    Cur extends string,
+    Steps extends any[]
+> = S extends `${infer P}(${infer R}`
+    ? P extends `${string})${string}`
+        ? StlCloseJump<S, Depth, Acc, Cur, Steps>
+        : SplitTopLevelWorker<R, [any, ...Depth], Acc, `${Cur}${P}(`, [any, ...Steps], false, false>
+    : StlCloseJump<S, Depth, Acc, Cur, Steps>;
+
+type StlCloseJump<
+    S extends string,
+    Depth extends any[],
+    Acc extends string[],
+    Cur extends string,
+    Steps extends any[]
+> = S extends `${infer P})${infer R}`
+    ? SplitTopLevelWorker<R, Depth extends [any, ...infer D] ? D : [], Acc, `${Cur}${P})`, [any, ...Steps], false, false>
+    : [...Acc, `${Cur}${S}`];
 
 // Driver: run the worker chunk-by-chunk until it returns the finished `string[]`.
 // Each `{ __c: state }` yield is fed back with a fresh step counter, so no single
@@ -70,55 +132,157 @@ type SplitTopLevelDrive<R> =
 // Quote-aware on BOTH single quotes (`'...'` string literals) and double quotes
 // (`"..."` quoted identifiers): a ` from ` token sitting inside a double-quoted
 // output alias (`id as "came from import"`) is part of the identifier, not the
-// SELECT/FROM boundary, so it must not split the list. `InString` tracks single
-// quotes; `InDString` tracks double quotes. Parens and the ` from ` boundary are
-// only honoured when outside BOTH kinds of quote.
-export type ExtractBeforeFromTopLevel<
+// SELECT/FROM boundary, so it must not split the list. Parens and the ` from `
+// boundary are only honoured when outside BOTH kinds of quote.
+// Struct-jump, not per-char (the old walk minted a growing `Acc` PER CHARACTER
+// over every subquery select-list). At depth 0 each step advances to the
+// LEFTMOST of `'` `"` `(` `)` ` from ` (pairwise narrowing, multi-char keyword
+// checked last); at depth > 0 the ` from ` candidate is dropped (a nested FROM
+// is not the boundary). Quote spans are jumped quote-to-quote (the other quote
+// kind inside a span is data, preserving the old InString/InDString
+// suppression; an unterminated quote swallows the rest, as the old
+// walk-to-EOF did).
+//
+// CHUNKED worker/driver (mirrors `SplitTopLevel`): each jump costs ~4-5
+// conditional evaluations through the EbftJump* helper chain, so a single
+// recursion chain crosses TS's 1000 tail-count budget at ~200+ jumps — a
+// 50-projection SELECT list of quoted/parenthesised expressions gets there
+// (TS2589). The worker yields its state every 120 jumps and the driver
+// re-invokes it with a fresh step counter, so arbitrarily long select lists
+// complete losslessly. (The pre-chunking version bailed to a lenient
+// `ExtractBefore<S, " from ">` at a 350-jump cap — and blew TS2589 before
+// ever reaching it on exactly the queries the cap was meant to protect.)
+export type ExtractBeforeFromTopLevel<S extends string> =
+    EbftDrive<EbftWorker<S>>;
+
+type EbftDrive<R> =
+    [R] extends [never]
+        ? never
+        : R extends { __c: [infer S extends string, infer Depth extends any[], infer Acc extends string] }
+            ? EbftDrive<EbftWorker<S, Depth, Acc, []>>
+            : R;
+
+type EbftWorker<
     S extends string,
     Depth extends any[] = [],
-    InString extends boolean = false,
     Acc extends string = "",
-    Steps extends any[] = [],
-    InDString extends boolean = false
-> = Steps["length"] extends 350
-    ? `${Acc}${ExtractBefore<S, " from ">}`
-    : InString extends true
-        ? S extends `${infer C}${infer Rest}`
-            ? C extends "'"
-                ? ExtractBeforeFromTopLevel<Rest, Depth, false, `${Acc}${C}`, [any, ...Steps], InDString>
-                : ExtractBeforeFromTopLevel<Rest, Depth, InString, `${Acc}${C}`, [any, ...Steps], InDString>
-            : Acc
-        : InDString extends true
-            ? S extends `${infer C}${infer Rest}`
-                ? C extends `"`
-                    ? ExtractBeforeFromTopLevel<Rest, Depth, InString, `${Acc}${C}`, [any, ...Steps], false>
-                    : ExtractBeforeFromTopLevel<Rest, Depth, InString, `${Acc}${C}`, [any, ...Steps], true>
-                : Acc
-            : Depth["length"] extends 0
-                ? S extends ` from ${string}`
-                    ? Acc
-                    : S extends `${infer C}${infer Rest}`
-                        ? C extends "'"
-                            ? ExtractBeforeFromTopLevel<Rest, Depth, true, `${Acc}${C}`, [any, ...Steps], InDString>
-                            : C extends `"`
-                                ? ExtractBeforeFromTopLevel<Rest, Depth, InString, `${Acc}${C}`, [any, ...Steps], true>
-                                : C extends "("
-                                    ? ExtractBeforeFromTopLevel<Rest, [any, ...Depth], InString, `${Acc}${C}`, [any, ...Steps], InDString>
-                                    : C extends ")"
-                                        ? ExtractBeforeFromTopLevel<Rest, Depth extends [any, ...infer D] ? D : [], InString, `${Acc}${C}`, [any, ...Steps], InDString>
-                                        : ExtractBeforeFromTopLevel<Rest, Depth, InString, `${Acc}${C}`, [any, ...Steps], InDString>
-                        : Acc
-                : S extends `${infer C}${infer Rest}`
-                    ? C extends "'"
-                        ? ExtractBeforeFromTopLevel<Rest, Depth, true, `${Acc}${C}`, [any, ...Steps], InDString>
-                        : C extends `"`
-                            ? ExtractBeforeFromTopLevel<Rest, Depth, InString, `${Acc}${C}`, [any, ...Steps], true>
-                            : C extends "("
-                                ? ExtractBeforeFromTopLevel<Rest, [any, ...Depth], InString, `${Acc}${C}`, [any, ...Steps], InDString>
-                                : C extends ")"
-                                    ? ExtractBeforeFromTopLevel<Rest, Depth extends [any, ...infer D] ? D : [], InString, `${Acc}${C}`, [any, ...Steps], InDString>
-                                    : ExtractBeforeFromTopLevel<Rest, Depth, InString, `${Acc}${C}`, [any, ...Steps], InDString>
-                    : Acc;
+    Steps extends any[] = []
+> = Steps["length"] extends 120
+    ? { __c: [S, Depth, Acc] }
+    : Depth["length"] extends 0
+        ? EbftJumpTop<S, Depth, Acc, Steps>
+        : EbftJumpNested<S, Depth, Acc, Steps>;
+
+// inside `'…'`: resume after the closing quote (any depth; quotes ignore depth)
+type EbftQuoteClose<
+    R extends string,
+    Depth extends any[],
+    Acc extends string,
+    Steps extends any[]
+> = R extends `${infer Span}'${infer R2}`
+    ? EbftWorker<R2, Depth, `${Acc}${Span}'`, [any, ...Steps]>
+    : `${Acc}${R}`;
+
+type EbftDQuoteClose<
+    R extends string,
+    Depth extends any[],
+    Acc extends string,
+    Steps extends any[]
+> = R extends `${infer Span}"${infer R2}`
+    ? EbftWorker<R2, Depth, `${Acc}${Span}"`, [any, ...Steps]>
+    : `${Acc}${R}`;
+
+type EbftJumpTop<
+    S extends string,
+    Depth extends any[],
+    Acc extends string,
+    Steps extends any[]
+> = S extends `${infer P}'${infer R}`
+    ? P extends `${string}"${string}` | `${string}(${string}` | `${string})${string}` | `${string} from ${string}`
+        ? EbftJumpTop2<S, Depth, Acc, Steps>
+        : EbftQuoteClose<R, Depth, `${Acc}${P}'`, Steps>
+    : EbftJumpTop2<S, Depth, Acc, Steps>;
+
+type EbftJumpTop2<
+    S extends string,
+    Depth extends any[],
+    Acc extends string,
+    Steps extends any[]
+> = S extends `${infer P}"${infer R}`
+    ? P extends `${string}(${string}` | `${string})${string}` | `${string} from ${string}`
+        ? EbftJumpTop3<S, Depth, Acc, Steps>
+        : EbftDQuoteClose<R, Depth, `${Acc}${P}"`, Steps>
+    : EbftJumpTop3<S, Depth, Acc, Steps>;
+
+type EbftJumpTop3<
+    S extends string,
+    Depth extends any[],
+    Acc extends string,
+    Steps extends any[]
+> = S extends `${infer P}(${infer R}`
+    ? P extends `${string})${string}` | `${string} from ${string}`
+        ? EbftJumpTop4<S, Depth, Acc, Steps>
+        : EbftWorker<R, [any, ...Depth], `${Acc}${P}(`, [any, ...Steps]>
+    : EbftJumpTop4<S, Depth, Acc, Steps>;
+
+type EbftJumpTop4<
+    S extends string,
+    Depth extends any[],
+    Acc extends string,
+    Steps extends any[]
+> = S extends `${infer P})${infer R}`
+    ? P extends `${string} from ${string}`
+        ? EbftJumpTop5<S, Acc>
+        // an unmatched `)` at depth 0 stays at depth 0 (pop of empty = empty)
+        : EbftWorker<R, [], `${Acc}${P})`, [any, ...Steps]>
+    : EbftJumpTop5<S, Acc>;
+
+type EbftJumpTop5<S extends string, Acc extends string> =
+    S extends `${infer P} from ${string}`
+        ? `${Acc}${P}`
+        : `${Acc}${S}`;
+
+type EbftJumpNested<
+    S extends string,
+    Depth extends any[],
+    Acc extends string,
+    Steps extends any[]
+> = S extends `${infer P}'${infer R}`
+    ? P extends `${string}"${string}` | `${string}(${string}` | `${string})${string}`
+        ? EbftJumpNested2<S, Depth, Acc, Steps>
+        : EbftQuoteClose<R, Depth, `${Acc}${P}'`, Steps>
+    : EbftJumpNested2<S, Depth, Acc, Steps>;
+
+type EbftJumpNested2<
+    S extends string,
+    Depth extends any[],
+    Acc extends string,
+    Steps extends any[]
+> = S extends `${infer P}"${infer R}`
+    ? P extends `${string}(${string}` | `${string})${string}`
+        ? EbftJumpNested3<S, Depth, Acc, Steps>
+        : EbftDQuoteClose<R, Depth, `${Acc}${P}"`, Steps>
+    : EbftJumpNested3<S, Depth, Acc, Steps>;
+
+type EbftJumpNested3<
+    S extends string,
+    Depth extends any[],
+    Acc extends string,
+    Steps extends any[]
+> = S extends `${infer P}(${infer R}`
+    ? P extends `${string})${string}`
+        ? EbftJumpNested4<S, Depth, Acc, Steps>
+        : EbftWorker<R, [any, ...Depth], `${Acc}${P}(`, [any, ...Steps]>
+    : EbftJumpNested4<S, Depth, Acc, Steps>;
+
+type EbftJumpNested4<
+    S extends string,
+    Depth extends any[],
+    Acc extends string,
+    Steps extends any[]
+> = S extends `${infer P})${infer R}`
+    ? EbftWorker<R, Depth extends [any, ...infer D] ? D : [], `${Acc}${P})`, [any, ...Steps]>
+    : `${Acc}${S}`;
 
 // Simple comma split (no paren awareness)
 

package/src/parsing/string-utils.ts

@@ -69,6 +69,7 @@ export type HasSpecial<S extends string> =
     S extends `${string}-${string}` ? true :
     S extends `${string}*${string}` ? true :
     S extends `${string}/${string}` ? true :
+    S extends `${string}%${string}` ? true :
     S extends `${string}=${string}` ? true :
     S extends `${string}<${string}` ? true :
     S extends `${string}>${string}` ? true :
@@ -136,17 +137,21 @@ export type SplitLast<S extends string, Delim extends string> =
             : [Head, Tail]
         : [S, ""];
 
-export type SplitOnDot<S extends string> =
-    S extends `${infer A}.${infer B}` ? [A, ...SplitOnDot<B>] : [S];
-
+// Direct template-match split of a (≤3-part) dotted ref into cleaned segments.
+// Replaces the old recursive `SplitOnDot` array build (its `[S]` base case and
+// `[A, ...rest]` prepend minted tuples per qualified ref, and the 1/2/3-arm
+// dispatch re-matched the built array three times). `${infer A}.${infer R}`
+// binds the LEFTMOST dot, so A is the first segment exactly as before; a 4th
+// segment (a dot remaining after the third split) yields `[]`, matching the old
+// "no arm matches a 4+-tuple" fall-through.
 export type SplitOnDotClean<S extends string> =
-    SplitOnDot<S> extends [infer A extends string, infer B extends string, infer C extends string]
-        ? [CleanIdent<A>, CleanIdent<B>, CleanIdent<C>]
-        : SplitOnDot<S> extends [infer A extends string, infer B extends string]
-            ? [CleanIdent<A>, CleanIdent<B>]
-            : SplitOnDot<S> extends [infer A extends string]
-                ? [CleanIdent<A>]
-                : [];
+    S extends `${infer A}.${infer R}`
+        ? R extends `${infer B}.${infer R2}`
+            ? R2 extends `${string}.${string}`
+                ? []
+                : [CleanIdent<A>, CleanIdent<B>, CleanIdent<R2>]
+            : [CleanIdent<A>, CleanIdent<R>]
+        : [CleanIdent<S>];
 
 export type MapClean<Tokens extends string[], Acc extends string[] = []> =
     Tokens extends [infer H extends string, ...infer R extends string[]]
@@ -154,11 +159,6 @@ export type MapClean<Tokens extends string[], Acc extends string[] = []> =
         : Acc;
 
 
-export type MapCleanLoose<Tokens extends string[], Acc extends string[] = []> =
-    Tokens extends [infer H extends string, ...infer R extends string[]]
-        ? MapCleanLoose<R, [...Acc, CleanLooseToken<H>]>
-        : Acc;
-
 export type CleanLooseToken<S extends string> =
     S extends OperatorToken
         ? S