@kuindji/typed-sql 0.2.0 → 0.4.0

package/src/parsing/extract.ts

@@ -36,28 +36,40 @@ export type FirstTopLevelReturningTail<S extends string> =
                 ? FirstTopLevelReturningTailWalk<S>
                 : S extends `${string} returning ${infer After}` ? After : "";
 
+// Quote-jump twin of `HasReturningQuoteAwareWalk` (validation/dispatch.ts):
+// find the leftmost ` returning `; if no quote opens before it, its tail is the
+// answer. Otherwise jump the leftmost quote span whole (`'…'` or `"…"`,
+// whichever opens first — the other quote kind inside the span is data) and
+// re-test the remainder. O(quote spans) instead of O(chars); an unterminated
+// quote swallows the rest, exactly like the old walk-to-EOF inside a literal.
 type FirstTopLevelReturningTailWalk<
     S extends string,
-    InString extends boolean = false,
-    InDString extends boolean = false,
     Steps extends any[] = []
 > = string extends S
     ? ""
-    : Steps["length"] extends 1200
+    : Steps["length"] extends 400
         ? S extends `${string} returning ${infer After}` ? After : ""
-        : InString extends true
-            ? S extends `${infer C}${infer Rest}`
-                ? FirstTopLevelReturningTailWalk<Rest, C extends "'" ? false : true, InDString, [any, ...Steps]>
+        : S extends `${infer Before} returning ${infer After}`
+            ? Before extends `${string}'${string}` | `${string}"${string}`
+                ? FtrtQuoteJump<S, Steps>
+                : After
+            : "";
+
+type FtrtQuoteJump<S extends string, Steps extends any[]> =
+    S extends `${infer P}'${infer R}`
+        ? P extends `${string}"${string}`
+            ? FtrtDQuoteJump<S, Steps>
+            : R extends `${string}'${infer R2}`
+                ? FirstTopLevelReturningTailWalk<R2, [any, ...Steps]>
                 : ""
-            : InDString extends true
-                ? S extends `${infer C}${infer Rest}`
-                    ? FirstTopLevelReturningTailWalk<Rest, InString, C extends `"` ? false : true, [any, ...Steps]>
-                    : ""
-                : S extends ` returning ${infer After}`
-                    ? After
-                    : S extends `${infer C}${infer Rest}`
-                        ? FirstTopLevelReturningTailWalk<Rest, C extends "'" ? true : false, C extends `"` ? true : false, [any, ...Steps]>
-                        : "";
+        : FtrtDQuoteJump<S, Steps>;
+
+type FtrtDQuoteJump<S extends string, Steps extends any[]> =
+    S extends `${string}"${infer R}`
+        ? R extends `${string}"${infer R2}`
+            ? FirstTopLevelReturningTailWalk<R2, [any, ...Steps]>
+            : ""
+        : "";
 
 // Given a string whose first non-skipped char is `(`, consume the first
 // balanced parenthesised group (quote-aware) and return its inner content plus
@@ -72,6 +84,15 @@ type FirstTopLevelReturningTailWalk<
 // every CHUNK steps and a driver that re-invokes it with a fresh step counter —
 // resetting TS's per-chain tail-recursion count, so arbitrarily long groups split
 // losslessly. Mirrors the `SplitTopLevel` worker/driver above.
+//
+// Struct-jump, not per-char (the old walk minted one growing-`Acc` string PER
+// CHARACTER across entire CTE/subquery bodies). Each step advances to the
+// LEFTMOST of the three state chars `'` `(` `)` (double quotes were never
+// tracked here — preserved), copying the whole run before it in a single mint;
+// inside a `'…'` literal it jumps straight to the closing quote (`''` 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, so arbitrarily paren-dense inputs still complete losslessly.
 type SplitBalancedParenWorker<
     S extends string,
     Depth extends any[] = [],
@@ -80,23 +101,42 @@ type SplitBalancedParenWorker<
     Steps extends any[] = []
 > = Steps["length"] extends 350
     ? { __c: [S, Depth, Acc, InString] }
-    : S extends `${infer C}${infer Rest}`
-        ? C extends "'"
-            ? SplitBalancedParenWorker<Rest, Depth, `${Acc}${C}`, InString extends true ? false : true, [any, ...Steps]>
-            : InString extends true
-                ? SplitBalancedParenWorker<Rest, Depth, `${Acc}${C}`, InString, [any, ...Steps]>
-                : C extends "("
-                    ? Depth["length"] extends 0
-                        ? SplitBalancedParenWorker<Rest, [any], Acc, InString, [any, ...Steps]>
-                        : SplitBalancedParenWorker<Rest, [any, ...Depth], `${Acc}${C}`, InString, [any, ...Steps]>
-                    : C extends ")"
-                        ? Depth extends [any, ...infer D extends any[]]
-                            ? D["length"] extends 0
-                                ? { inner: Acc; rest: Rest }
-                                : SplitBalancedParenWorker<Rest, D, `${Acc}${C}`, InString, [any, ...Steps]>
-                            : { inner: Acc; rest: Rest }
-                        : SplitBalancedParenWorker<Rest, Depth, `${Acc}${C}`, InString, [any, ...Steps]>
-        : { inner: Acc; rest: "" };
+    : InString extends true
+        ? S extends `${infer P}'${infer R}`
+            ? SplitBalancedParenWorker<R, Depth, `${Acc}${P}'`, false, [any, ...Steps]>
+            : { inner: `${Acc}${S}`; rest: "" }
+        : S extends `${infer P}'${infer R}`
+            ? P extends `${string}(${string}` | `${string})${string}`
+                ? SbpParenJump<S, Depth, Acc, Steps>
+                : SplitBalancedParenWorker<R, Depth, `${Acc}${P}'`, true, [any, ...Steps]>
+            : SbpParenJump<S, Depth, Acc, Steps>;
+
+// Leftmost of `(` / `)` (the caller guarantees no `'` occurs before either).
+type SbpParenJump<
+    S extends string,
+    Depth extends any[],
+    Acc extends string,
+    Steps extends any[]
+> = S extends `${infer P}(${infer R}`
+    ? P extends `${string})${string}`
+        ? SbpCloseJump<S, Depth, Acc, Steps>
+        : Depth["length"] extends 0
+            // the group-opening `(` itself is consumed, not copied into `inner`
+            ? SplitBalancedParenWorker<R, [any], `${Acc}${P}`, false, [any, ...Steps]>
+            : SplitBalancedParenWorker<R, [any, ...Depth], `${Acc}${P}(`, false, [any, ...Steps]>
+    : SbpCloseJump<S, Depth, Acc, Steps>;
+
+type SbpCloseJump<
+    S extends string,
+    Depth extends any[],
+    Acc extends string,
+    Steps extends any[]
+> = S extends `${infer P})${infer R}`
+    ? Depth extends [any, any, ...infer D extends any[]]
+        ? SplitBalancedParenWorker<R, [any, ...D], `${Acc}${P})`, false, [any, ...Steps]>
+        // depth ≤ 1: this `)` closes the group (or is an unmatched top-level `)`)
+        : { inner: `${Acc}${P}`; rest: R }
+    : { inner: `${Acc}${S}`; rest: "" };
 
 export type SplitBalancedParen<S extends string> =
     SplitBalancedParenDrive<SplitBalancedParenWorker<S>>;

package/src/parsing/normalize.ts

@@ -24,7 +24,65 @@ import type { NeutralizePgLiterals, RewriteExtractCall, StripComments } from "./
 // length, so the "collapse first to fit the lowercaser under its cap" rationale no
 // longer requires a second collapse afterwards.
 export type NormalizeQuery<S extends string> =
-    RewriteExtractCall<Trim<RemoveTrailingSemicolon<LowercaseOutsideQuotes<CollapseSpaces<ReplaceWhitespace<StripComments<NeutralizePgLiterals<S>>>>>>>>;
+    RewriteExtractCall<Trim<RemoveTrailingSemicolon<CollapseDotSpaces<LowercaseOutsideQuotes<CollapseSpaces<ReplaceWhitespace<StripComments<NeutralizePgLiterals<S>>>>>>>>>;
+
+// Collapse whitespace around the `.` qualifier separator: `X .Y` / `X. Y` /
+// `X . Y` -> `X.Y`. PostgreSQL allows whitespace around the qualifier dot
+// (`tbl . col` === `tbl.col`); the normalizer's ReplaceWhitespace+CollapseSpaces
+// turns a multi-line qualified ref (`tbl\n  .col`) into `tbl .col`, which would
+// otherwise tokenize as the orphan `.col` plus a bare `tbl` that the
+// unqualified-column check then rejects as a (non-existent) column. Rejoining the
+// dot lets `tbl.col` resolve normally.
+//
+// CHEAP PRE-GATE: the overwhelmingly common query has no spaced dot, so a single
+// `" ."` / `". "` membership test short-circuits to identity in ~1 instantiation.
+export type CollapseDotSpaces<S extends string> =
+    S extends `${string} .${string}`
+        ? MaybeCollapseDotSpaces<S>
+        : S extends `${string}. ${string}`
+            ? MaybeCollapseDotSpaces<S>
+            : S;
+
+// Single-quoted literals are already blanked to '' by NeutralizePgLiterals, so
+// only a double-quoted identifier could host a spaced dot (`"a . b"`). With no
+// `"` present the quote-unaware ladder is provably safe; otherwise defer to a
+// quote-aware walk that collapses dots only OUTSIDE double-quoted spans.
+type MaybeCollapseDotSpaces<S extends string> =
+    S extends `${string}"${string}`
+        ? CollapseDotSpacesQuoteAware<S, false, "", []>
+        : CollapseDotSpacesWalk<S>;
+
+// O(spaced dots), not O(chars): `${infer A}` jumps a whole non-matching run per
+// step, so a string with no further spaced dot exits in one instantiation. Step
+// cap is a runaway backstop, far under TS's recursion ceiling.
+type CollapseDotSpacesWalk<S extends string, Steps extends any[] = []> =
+    Steps["length"] extends 400
+        ? S
+        : S extends `${infer A} . ${infer B}`
+            ? CollapseDotSpacesWalk<`${A}.${B}`, [any, ...Steps]>
+            : S extends `${infer A} .${infer B}`
+                ? CollapseDotSpacesWalk<`${A}.${B}`, [any, ...Steps]>
+                : S extends `${infer A}. ${infer B}`
+                    ? CollapseDotSpacesWalk<`${A}.${B}`, [any, ...Steps]>
+                    : S;
+
+// Quote-aware tier: copy `"..."` identifier spans verbatim, collapse spaced dots
+// only in the runs OUTSIDE them, so a column literally named `"a . b"` is never
+// corrupted. Depth is O(double-quote boundaries).
+type CollapseDotSpacesQuoteAware<
+    S extends string,
+    InDQ extends boolean,
+    Acc extends string,
+    Steps extends any[]
+> = Steps["length"] extends 400
+    ? `${Acc}${S}`
+    : InDQ extends true
+        ? S extends `${infer P}"${infer R}`
+            ? CollapseDotSpacesQuoteAware<R, false, `${Acc}${P}"`, [any, ...Steps]>
+            : `${Acc}${S}`
+        : S extends `${infer P}"${infer R}`
+            ? CollapseDotSpacesQuoteAware<R, true, `${Acc}${CollapseDotSpacesWalk<P>}"`, [any, ...Steps]>
+            : `${Acc}${CollapseDotSpacesWalk<S>}`;
 
 // Quote-aware lowercasing: SQL keywords/identifiers are case-insensitive, but
 // single-quoted string literals and double-quoted identifiers keep their exact
@@ -221,7 +279,7 @@ type LcKeepQuoteJump<
 // NormalizeQuery variant that preserves `:name` param case — used by the
 // write/raw builder param extraction (ExtractParams) only.
 export type NormalizeQueryKeepParams<S extends string> =
-    RewriteExtractCall<Trim<RemoveTrailingSemicolon<LowercaseOutsideQuotesKeepParams<CollapseSpaces<ReplaceWhitespace<StripComments<NeutralizePgLiterals<S>>>>>>>>;
+    RewriteExtractCall<Trim<RemoveTrailingSemicolon<CollapseDotSpaces<LowercaseOutsideQuotesKeepParams<CollapseSpaces<ReplaceWhitespace<StripComments<NeutralizePgLiterals<S>>>>>>>>>;
 
 // Convert every `\n` / `\t` / `\r` to a space. OCCURRENCE-based (like
 // `CollapseSpaces`): each step splits at the FIRST remaining line break, so the
@@ -237,18 +295,64 @@ export type ReplaceWhitespace<S extends string> =
         ? ReplaceWhitespaceRuns<S>
         : S;
 
-type ReplaceWhitespaceRuns<S extends string, Steps extends any[] = []> =
+// Acc-carrying worker: the finished prefix moves into `Acc` and is NEVER
+// rescanned or reminted (the old form rebuilt the FULL string once per line
+// break and re-matched it from the start). Because consumed segments leave the
+// scan, the worker must take the LEFTMOST of `\n`/`\t`/`\r` each step — the
+// old rebuild-and-rescan form got that for free by always re-matching `\n`
+// first over the whole string. Same pairwise-narrowing cascade as
+// `MtcStructJump`. The step cap counts whitespace RUNS (each consumed whole by
+// `ConsumeWsRun`), so it covers at least as much input as the old
+// per-occurrence cap; on cap the remainder is left as-is, as before.
+type ReplaceWhitespaceRuns<S extends string, Acc extends string = "", Steps extends any[] = []> =
     string extends S
         ? S
         : Steps["length"] extends 1500
-            ? S
+            ? `${Acc}${S}`
             : S extends `${infer A}\n${infer B}`
-                ? ReplaceWhitespaceRuns<`${A} ${B}`, [any, ...Steps]>
-                : S extends `${infer A}\t${infer B}`
-                    ? ReplaceWhitespaceRuns<`${A} ${B}`, [any, ...Steps]>
-                    : S extends `${infer A}\r${infer B}`
-                        ? ReplaceWhitespaceRuns<`${A} ${B}`, [any, ...Steps]>
-                        : S;
+                ? A extends `${string}\t${string}` | `${string}\r${string}`
+                    ? RwrTabCr<S, Acc, Steps>
+                    : ReplaceWhitespaceRuns<ConsumeWsRun<B>, `${Acc}${A} `, [any, ...Steps]>
+                : RwrTabCr<S, Acc, Steps>;
+
+// Leftmost of `\t` / `\r` (caller ruled out an earlier `\n`).
+type RwrTabCr<S extends string, Acc extends string, Steps extends any[]> =
+    S extends `${infer A}\t${infer B}`
+        ? A extends `${string}\r${string}`
+            ? S extends `${infer A2}\r${infer B2}`
+                ? ReplaceWhitespaceRuns<ConsumeWsRun<B2>, `${Acc}${A2} `, [any, ...Steps]>
+                : `${Acc}${S}`
+            : ReplaceWhitespaceRuns<ConsumeWsRun<B>, `${Acc}${A} `, [any, ...Steps]>
+        : S extends `${infer A2}\r${infer B2}`
+            ? ReplaceWhitespaceRuns<ConsumeWsRun<B2>, `${Acc}${A2} `, [any, ...Steps]>
+            : `${Acc}${S}`;
+
+// Eat the whole whitespace run FOLLOWING a consumed line break before the full
+// string is rebuilt. A formatted query's `\n␣␣␣␣` indentation otherwise survives
+// as a multi-space run that costs `ReplaceWhitespaceRuns` extra full-string
+// remints (one per `\n` of a blank line) plus one more full remint per run in
+// `CollapseSpaces`. Peeling here works on the TAIL only — far cheaper mints —
+// and leaves `CollapseSpaces` a no-op for these runs. Equivalence: both forms
+// reduce every whitespace run that touches a line break to a single space, and
+// runs NOT touching a line break are still collapsed by the unchanged
+// `CollapseSpaces` pass. A capped-out leftover (`\t`/`\n`/`\r` beyond the
+// budget) is still caught by the outer loop's own branches.
+type ConsumeWsRun<S extends string, Steps extends any[] = []> =
+    Steps["length"] extends 64
+        ? S
+        : S extends `                ${infer R}`   // 16 spaces
+            ? ConsumeWsRun<R, [any, ...Steps]>
+            : S extends `    ${infer R}`           // 4 spaces
+                ? ConsumeWsRun<R, [any, ...Steps]>
+                : S extends ` ${infer R}`
+                    ? ConsumeWsRun<R, [any, ...Steps]>
+                    : S extends `\t${infer R}`
+                        ? ConsumeWsRun<R, [any, ...Steps]>
+                        : S extends `\n${infer R}`
+                            ? ConsumeWsRun<R, [any, ...Steps]>
+                            : S extends `\r${infer R}`
+                                ? ConsumeWsRun<R, [any, ...Steps]>
+                                : S;
 
 // Cheap "is this string longer than ~500 chars" check: drop 10 chars per step
 // for up to 50 steps. If content survives all 50 drops the string exceeds the

package/src/parsing/pg-literals.ts

@@ -170,16 +170,38 @@ export type RewriteExtractCall<S extends string> =
             : RewriteExtractWalk<S>
         : S;
 
-export type RewriteExtractWalk<S extends string, Steps extends any[] = []> =
-    Steps["length"] extends 24
-        ? S
-        : S extends `${infer Pre} extract(${infer AfterOpen}`
-            ? SplitBalancedParen<`(${AfterOpen}`> extends { inner: infer Inner extends string; rest: infer Rest extends string }
-                ? Inner extends `${infer _Field} from ${infer Source}`
-                    ? `${RewriteExtractWalk<Pre, [any, ...Steps]>} extract(${Trim<Source>})${RewriteExtractWalk<Rest, [any, ...Steps]>}`
-                    : `${RewriteExtractWalk<Pre, [any, ...Steps]>} extract(${Inner})${RewriteExtractWalk<Rest, [any, ...Steps]>}`
-                : S
-            : S;
+// Tail-recursive accumulator walk + chunked driver. Template matching is
+// LEFTMOST, so `Pre` can never contain another ` extract(` — it is appended to
+// `Acc` verbatim and only `Rest` is recursed. (The previous version recursed
+// into BOTH `Pre` and `Rest` building a nested template, so its step cap had to
+// stay tiny — 24 — and a 50-projection report query with 25+ EXTRACTs bailed
+// half-rewritten: the surviving inner ` from ` tokens then fed the tables
+// collector bogus sources like `min(ua.col`, flipping ValidateSQL to a false
+// rejection.) The driver re-invokes the worker with a fresh step counter every
+// 64 rewrites, so any realistic number of EXTRACTs completes losslessly.
+export type RewriteExtractWalk<S extends string> =
+    RewExDrive<RewExWorker<S>>;
+
+type RewExDrive<R> =
+    [R] extends [never]
+        ? never
+        : R extends { __c: [infer S extends string, infer Acc extends string] }
+            ? RewExDrive<RewExWorker<S, Acc, []>>
+            : R;
+
+type RewExWorker<
+    S extends string,
+    Acc extends string = "",
+    Steps extends any[] = []
+> = Steps["length"] extends 64
+    ? { __c: [S, Acc] }
+    : S extends `${infer Pre} extract(${infer AfterOpen}`
+        ? SplitBalancedParen<`(${AfterOpen}`> extends { inner: infer Inner extends string; rest: infer Rest extends string }
+            ? Inner extends `${infer _Field} from ${infer Source}`
+                ? RewExWorker<Rest, `${Acc}${Pre} extract(${Trim<Source>})`, [any, ...Steps]>
+                : RewExWorker<Rest, `${Acc}${Pre} extract(${Inner})`, [any, ...Steps]>
+            : `${Acc}${S}`
+        : `${Acc}${S}`;
 
 // As `RewriteExtractWalk`, but an ` extract(` whose prefix has an odd number of
 // single quotes sits INSIDE a string literal and is left verbatim (the literal's