@kuindji/typed-sql 0.1.0 → 0.2.0

package/src/parsing/tokenize.ts

@@ -1,9 +1,9 @@
 // Tokenization, sentinels, operators, and SQL keyword sets.
-import type { CollapseSpaces, FilterEmpty, MapClean, MapCleanLoose, ReplaceAll, Split } from "./string-utils.js";
+import type { CleanIdent, CleanLooseToken, CollapseSpaces, ReplaceAll, Split, Trim, TrimPunctuation } from "./string-utils.js";
 import type { ExceedsLengthBudget, HasLineBreaks } from "./normalize.js";
 // Tokenization & parsing helpers
 
-export type Tokenize<N extends string> = FilterEmpty<MapClean<Split<N, " ">>>;
+export type Tokenize<N extends string> = CleanFilterTokens<Split<N, " ">>;
 
 // Sentinel token standing in for a TOP-LEVEL comma. It survives `MapClean`
 // (no stripped punctuation, non-empty identifier) whereas a bare `,` does not,
@@ -64,12 +64,12 @@ export type TokenizeTables<N extends string> =
         ? Tokenize<N>
         : ExceedsLengthBudget<N> extends true
             ? Tokenize<N>
-            : FilterEmpty<MapClean<RestoreDQuotedSpaces<Split<MaybeMarkDQuotedSpaces<MarkTopLevelCommas<N>>, " ">>>>;
+            : RestoreCleanFilterTokens<Split<MaybeMarkDQuotedSpaces<MarkTopLevelCommas<N>>, " ">>;
 
 export type TokenizeLoose<N extends string> =
-    FilterEmpty<MapCleanLoose<RestoreDQuotedSpaces<
+    RestoreCleanLooseFilterTokens<
         Split<CollapseSpaces<RestoreWildcards<PadOperators<ProtectWildcards<MaybeMarkDQuotedSpaces<MaybeStripDQuotedPunct<N>>>>>>, " ">
-    >>> extends infer Toks extends string[]
+    > extends infer Toks extends string[]
         ? N extends `${string}distinct ${string}`
             ? DropDistinctFrom<Toks>
             : Toks
@@ -168,12 +168,45 @@ export type MarkDQuotedSpaces<
                     : MarkDQuotedSpaces<Rest, InDQ, `${Acc}${C}`, [any, ...Steps]>
             : Acc;
 
-// Restore the space sentinel to a real space in each token of a token list, so a
-// quoted identifier that survived the space-split as one token (`"Order ID"`,
-// `"user alias".id`) is cleaned to its true value (`order id`, `"user alias".id`).
-export type RestoreDQuotedSpaces<Tokens extends string[], Acc extends string[] = []> =
+// Fused token post-passes: one walk instead of the old
+// `FilterEmpty<MapClean<RestoreDQuotedSpaces<…>>>` three-walk chain. Each pass was
+// an independent element-wise map/filter, so composing them per token yields the
+// identical list (ordering preserved) while building the result spine once.
+//
+// The DQuote-space sentinel restore (`ReplaceAll<H, DQuoteSpaceSentinel, " ">`) lets
+// a quoted identifier that survived the space-split as one token (`"Order ID"`,
+// `"user alias".id`) clean to its true value. `CleanFilterTokens` is the no-restore
+// variant (plain `Tokenize`, which never marks sentinels).
+//
+// MapClean maps each token to `CleanIdent<H> extends "" ? "" : TrimPunctuation<Trim<H>>`
+// and FilterEmpty drops the `""`s. Since `CleanIdent = Lowercase<Unquote<TrimPunctuation<
+// Trim<S>>>>`, a non-empty `CleanIdent<H>` guarantees a non-empty `TrimPunctuation<Trim<H>>`,
+// so the kept value is never empty — the empty-token filter collapses to the single
+// `CleanIdent<H> extends ""` test. (The loose variant keeps an explicit empty filter
+// because `CleanLooseToken` can return `""` for a non-operator empty ident.)
+export type CleanFilterTokens<Tokens extends string[], Acc extends string[] = []> =
     Tokens extends [infer H extends string, ...infer R extends string[]]
-        ? RestoreDQuotedSpaces<R, [...Acc, ReplaceAll<H, DQuoteSpaceSentinel, " ">]>
+        ? CleanIdent<H> extends ""
+            ? CleanFilterTokens<R, Acc>
+            : CleanFilterTokens<R, [...Acc, TrimPunctuation<Trim<H>>]>
+        : Acc;
+
+export type RestoreCleanFilterTokens<Tokens extends string[], Acc extends string[] = []> =
+    Tokens extends [infer H0 extends string, ...infer R extends string[]]
+        ? ReplaceAll<H0, DQuoteSpaceSentinel, " "> extends infer H extends string
+            ? CleanIdent<H> extends ""
+                ? RestoreCleanFilterTokens<R, Acc>
+                : RestoreCleanFilterTokens<R, [...Acc, TrimPunctuation<Trim<H>>]>
+            : never
+        : Acc;
+
+export type RestoreCleanLooseFilterTokens<Tokens extends string[], Acc extends string[] = []> =
+    Tokens extends [infer H0 extends string, ...infer R extends string[]]
+        ? CleanLooseToken<ReplaceAll<H0, DQuoteSpaceSentinel, " ">> extends infer M extends string
+            ? M extends ""
+                ? RestoreCleanLooseFilterTokens<R, Acc>
+                : RestoreCleanLooseFilterTokens<R, [...Acc, M]>
+            : never
         : Acc;
 
 // A validation-only view of a query: blank the CONTENTS of every single-quoted
@@ -198,26 +231,26 @@ export type ValidationScanView<S extends string> =
         ? MaybeMarkDQuotedSpaces<BlankSingleQuotedLiterals<S>>
         : MaybeMarkDQuotedSpaces<S>;
 
+// Pairwise marker-jump: hop to the opening `'`, then to its closing `'`, emitting
+// the verbatim prefix plus a blanked body `''`, and recurse on the tail. The `''`
+// SQL escape pairs LEFTMOST exactly as the old per-char toggle did (`'it''s'` →
+// `''''`); an UNTERMINATED opener (no closing `'`) is closed off with an appended
+// `'`, matching the old EOF-in-string branch (`${Acc}'`), so `…'xyz` → `…''`. Depth
+// is now the NUMBER OF LITERALS (a handful), not the string length (≤600 before).
+// Step cap retained purely as a runaway backstop for a pathological quote storm.
 export type BlankSingleQuotedLiterals<
     S extends string,
-    InString extends boolean = false,
     Acc extends string = "",
     Steps extends any[] = []
 > = string extends S
     ? S
-    : Steps["length"] extends 600
+    : Steps["length"] extends 300
         ? `${Acc}${S}`
-        : InString extends true
-            ? S extends `${infer C}${infer R}`
-                ? C extends "'"
-                    ? BlankSingleQuotedLiterals<R, false, `${Acc}'`, [any, ...Steps]>
-                    : BlankSingleQuotedLiterals<R, true, Acc, [any, ...Steps]>
-                : `${Acc}'`
-            : S extends `${infer C}${infer R}`
-                ? C extends "'"
-                    ? BlankSingleQuotedLiterals<R, true, `${Acc}'`, [any, ...Steps]>
-                    : BlankSingleQuotedLiterals<R, false, `${Acc}${C}`, [any, ...Steps]>
-                : Acc;
+        : S extends `${infer Pre}'${infer Rest}`
+            ? Rest extends `${infer _Lit}'${infer After}`
+                ? BlankSingleQuotedLiterals<After, `${Acc}${Pre}''`, [any, ...Steps]>
+                : `${Acc}${Pre}''`
+            : `${Acc}${S}`;
 
 export type OperatorToken =
     | "(" | ")" | "," | "=" | "<" | ">" | "+" | "-" | "*" | "/" | "|" | "&" | "!" | "?"

package/src/validation/dispatch.ts

@@ -288,25 +288,43 @@ export type HasReturning<N extends string> =
         ? false
         : HasReturningQuoteAware<N>;
 
+// Quote-free fast-path: a query with no `'` and no `"` has no place for a
+// ` returning ` to hide, so every occurrence is top-level — a single pattern test
+// is exact and skips the ~1200-step char-walk (these run on every DML). Only
+// quote-bearing queries pay for the walk below. The fast-path pattern matches the
+// step-cap fallback this walk already uses, so it is consistent with prior behavior.
 export type HasReturningQuoteAware<
     S extends string,
     InString extends boolean = false,
     InDString extends boolean = false,
     Steps extends any[] = []
+> = string extends S
+    ? false
+    : S extends `${string}'${string}`
+        ? HasReturningQuoteAwareWalk<S, InString, InDString, Steps>
+        : S extends `${string}"${string}`
+            ? HasReturningQuoteAwareWalk<S, InString, InDString, Steps>
+            : S extends `${string} returning ${string}` ? true : false;
+
+type HasReturningQuoteAwareWalk<
+    S extends string,
+    InString extends boolean = false,
+    InDString extends boolean = false,
+    Steps extends any[] = []
 > = string extends S
     ? false
     : Steps["length"] extends 1200
         ? S extends `${string} returning ${string}` ? true : false
         : InString extends true
             ? S extends `${infer C}${infer Rest}`
-                ? HasReturningQuoteAware<Rest, C extends "'" ? false : true, InDString, [any, ...Steps]>
+                ? HasReturningQuoteAwareWalk<Rest, C extends "'" ? false : true, InDString, [any, ...Steps]>
                 : false
             : InDString extends true
                 ? S extends `${infer C}${infer Rest}`
-                    ? HasReturningQuoteAware<Rest, InString, C extends `"` ? false : true, [any, ...Steps]>
+                    ? HasReturningQuoteAwareWalk<Rest, InString, C extends `"` ? false : true, [any, ...Steps]>
                     : false
                 : S extends ` returning ${string}`
                     ? true
                     : S extends `${infer C}${infer Rest}`
-                        ? HasReturningQuoteAware<Rest, C extends "'" ? true : false, C extends `"` ? true : false, [any, ...Steps]>
+                        ? HasReturningQuoteAwareWalk<Rest, C extends "'" ? true : false, C extends `"` ? true : false, [any, ...Steps]>
                         : false;

package/src/validation/validate-columns.ts

@@ -402,15 +402,21 @@ export type NoAliasShadowedQualifiers<
 > =
     [AliasedTableKeys<Aliases>] extends [never]
         ? true
-        : AllTrue<
-            QualifiedColumnRefs<TokenizeLoose<N>, S, Tables, Aliases> extends infer R
-                ? R extends `${infer Q}.${string}`
-                    ? QualifierShadowedByAlias<Q, Tables, Aliases, S> extends true
-                        ? false
+        // A shadowable qualifier is a `qualifier.column` token, which requires a
+        // `.`. With no `.` anywhere, `QualifiedColumnRefs` accumulates `never` and
+        // `AllTrue<never>` is `true` — so skip the whole-query `TokenizeLoose<N>`
+        // re-walk (computed nowhere else) on dot-free queries. Exact-equivalent.
+        : N extends `${string}.${string}`
+            ? AllTrue<
+                QualifiedColumnRefs<TokenizeLoose<N>, S, Tables, Aliases> extends infer R
+                    ? R extends `${infer Q}.${string}`
+                        ? QualifierShadowedByAlias<Q, Tables, Aliases, S> extends true
+                            ? false
+                            : true
                         : true
                     : true
-                : true
-        >;
+            >
+            : true;
 
 // A table introduced INSIDE a subquery is in scope only there — it must not
 // satisfy an UNQUALIFIED column reference in the OUTER query. The whole-query