@kuindji/typed-sql 0.2.0 → 0.4.0

package/src/validation/dispatch.ts

@@ -6,7 +6,7 @@ import type { CteNames, NonCteTables, SingleCteMatch } from "./cte.js";
 import type { DatabaseSchema } from "../schema.js";
 import type { DerivedAliasName, DerivedFirstWord, DerivedTableMatch } from "./return-derived.js";
 import type { DistinctOnColsValid, JoinUsingColsValid, WindowFilterColsValid } from "./joins.js";
-import type { ExceedsLengthBudget, ExtractBefore, ExtractLastWhere, HasLineBreaks, TokenizeLoose, Trim, ValidationScanView } from "../parsing.js";
+import type { ExceedsLengthBudget, ExtractBefore, ExtractLastWhere, HasLineBreaks, Trim, ValidationScanView } from "../parsing.js";
 import type { RefScanSegment } from "./return-types.js";
 // Core validation / inference
 
@@ -126,16 +126,13 @@ export type WhereColsValidForUpdate<
     TargetKey extends string,
     AliasEntry extends string,
     S extends DatabaseSchema
-> =
-    TokenizeLoose<W> extends infer WT extends string[]
-        ? And<
-            QualifiedColumnRefsValidFor<W, S, TargetKey, AliasEntry, WT>,
-            UnqualifiedColumnRefsValidFor<W, S, TargetKey, AliasEntry, WT, never>,
-            true,
-            true,
-            true
-        >
-        : true;
+> = And<
+        QualifiedColumnRefsValidFor<W, S, TargetKey, AliasEntry, W>,
+        UnqualifiedColumnRefsValidFor<W, S, TargetKey, AliasEntry, W, never>,
+        true,
+        true,
+        true
+    >;
 
 // "Light" validator for high-complexity SELECTs: validate the cheap, bounded
 // parts (every referenced table exists, and the select/returning list resolves)
@@ -217,21 +214,19 @@ export type LightSelectTablesAndList<N extends string, S extends DatabaseSchema>
 export type ValidateSQLNormalizedCore<N extends string, S extends DatabaseSchema> =
     TablesInQuery<N, S> extends infer Tables extends string
         ? AliasesInQuery<N, S> extends infer Aliases extends string
-            ? TokenizeLoose<RefScanSegment<N>> extends infer LooseTokens extends string[]
-                ? AllTablesValidFor<NonCteTables<N, S, Tables>, S> extends true
-                    ? AllColumnsValidFor<N, S, Tables, Aliases, LooseTokens> extends true
-                        ? NoAliasShadowedQualifiers<N, S, Tables, Aliases> extends true
-                          ? OuterScopeUnqualifiedValid<N, S> extends true
-                            ? WindowFilterColsValid<N, S, Tables, Aliases> extends true
-                                ? JoinUsingColsValid<N, S, Tables> extends true
-                                    ? DistinctOnColsValid<N, S, Tables, Aliases> extends true
-                                        ? true
-                                        : false
+            ? AllTablesValidFor<NonCteTables<N, S, Tables>, S> extends true
+                ? AllColumnsValidFor<N, S, Tables, Aliases, RefScanSegment<N>> extends true
+                    ? NoAliasShadowedQualifiers<N, S, Tables, Aliases> extends true
+                      ? OuterScopeUnqualifiedValid<N, S> extends true
+                        ? WindowFilterColsValid<N, S, Tables, Aliases> extends true
+                            ? JoinUsingColsValid<N, S, Tables> extends true
+                                ? DistinctOnColsValid<N, S, Tables, Aliases> extends true
+                                    ? true
                                     : false
                                 : false
                             : false
-                          : false
                         : false
+                      : false
                     : false
                 : false
             : false
@@ -290,41 +285,52 @@ export type HasReturning<N extends string> =
 
 // 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;
+// is exact and skips the 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> =
+    string extends S
+        ? false
+        : S extends `${string}'${string}`
+            ? HasReturningQuoteAwareWalk<S>
+            : S extends `${string}"${string}`
+                ? HasReturningQuoteAwareWalk<S>
+                : S extends `${string} returning ${string}` ? true : false;
 
+// Quote-jump, not per-char (the old walk minted the tail string PER CHARACTER on
+// every quote-bearing DML). Find the leftmost ` returning `; if no quote opens
+// before it, it is top-level — answer found. Otherwise jump the leftmost quote
+// span whole (`'…'` or `"…"`, whichever opens first — a quote of the other kind
+// inside the span is data, mirroring the old InString/InDString suppression) 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 HasReturningQuoteAwareWalk<
     S extends string,
-    InString extends boolean = false,
-    InDString extends boolean = false,
     Steps extends any[] = []
 > = string extends S
     ? false
-    : Steps["length"] extends 1200
+    : Steps["length"] extends 400
         ? S extends `${string} returning ${string}` ? true : false
-        : InString extends true
-            ? S extends `${infer C}${infer Rest}`
-                ? HasReturningQuoteAwareWalk<Rest, C extends "'" ? false : true, InDString, [any, ...Steps]>
+        : S extends `${infer Before} returning ${string}`
+            ? Before extends `${string}'${string}` | `${string}"${string}`
+                ? HrqaQuoteJump<S, Steps>
+                : true
+            : false;
+
+// Leftmost of `'` / `"` (the caller guarantees at least one occurs before the
+// first ` returning `): skip its whole span, resume after the closing quote.
+type HrqaQuoteJump<S extends string, Steps extends any[]> =
+    S extends `${infer P}'${infer R}`
+        ? P extends `${string}"${string}`
+            ? HrqaDQuoteJump<S, Steps>
+            : R extends `${string}'${infer R2}`
+                ? HasReturningQuoteAwareWalk<R2, [any, ...Steps]>
                 : false
-            : InDString extends true
-                ? S extends `${infer C}${infer Rest}`
-                    ? HasReturningQuoteAwareWalk<Rest, InString, C extends `"` ? false : true, [any, ...Steps]>
-                    : false
-                : S extends ` returning ${string}`
-                    ? true
-                    : S extends `${infer C}${infer Rest}`
-                        ? HasReturningQuoteAwareWalk<Rest, C extends "'" ? true : false, C extends `"` ? true : false, [any, ...Steps]>
-                        : false;
+        : HrqaDQuoteJump<S, Steps>;
+
+type HrqaDQuoteJump<S extends string, Steps extends any[]> =
+    S extends `${string}"${infer R}`
+        ? R extends `${string}"${infer R2}`
+            ? HasReturningQuoteAwareWalk<R2, [any, ...Steps]>
+            : false
+        : false;

package/src/validation/joins.ts

@@ -1,6 +1,6 @@
 // JOIN USING / window-filter / DISTINCT ON column validation.
 import type { AllTrue, And, IsUnion } from "../utils.js";
-import type { CleanIdent, ExtractCallParenBodies, SplitCommaSimple, TokenizeLoose, Trim } from "../parsing.js";
+import type { CleanIdent, ExtractCallParenBodies, SplitCommaSimple, Trim } from "../parsing.js";
 import type { ColumnExists, DatabaseSchema } from "../schema.js";
 import type { QualifiedColumnRefsValidFor, UnqualifiedColumnRefsValidFor } from "./validate-columns.js";
 import type { QueryKind } from "./dispatch.js";
@@ -151,15 +151,13 @@ export type WindowFilterColsValid<
     ? `${ExtractCallParenBodies<N, " over (">} ${ExtractCallParenBodies<N, " over(">} ${ExtractCallParenBodies<N, " filter (">} ${ExtractCallParenBodies<N, " filter(">} ${ExtractCallParenBodies<N, " within group (">} ${ExtractCallParenBodies<N, " within group(">}` extends infer Seg extends string
         ? Trim<Seg> extends ""
             ? true
-            : TokenizeLoose<Seg> extends infer Toks extends string[]
-                ? And<
-                    QualifiedColumnRefsValidFor<N, S, Tables, Aliases, Toks>,
-                    UnqualifiedColumnRefsValidFor<N, S, Tables, Aliases, Toks, never>,
-                    true,
-                    true,
-                    true
-                  >
-                : true
+            : And<
+                QualifiedColumnRefsValidFor<N, S, Tables, Aliases, Seg>,
+                UnqualifiedColumnRefsValidFor<N, S, Tables, Aliases, Seg, never>,
+                true,
+                true,
+                true
+              >
         : true
     : true;
 
@@ -183,15 +181,13 @@ export type DistinctOnColsValid<
             ? `${ExtractCallParenBodies<N, " distinct on (">} ${ExtractCallParenBodies<N, " distinct on(">}` extends infer Seg extends string
             ? Trim<Seg> extends ""
                 ? true
-                : TokenizeLoose<Seg> extends infer Toks extends string[]
-                    ? And<
-                        QualifiedColumnRefsValidFor<N, S, Tables, Aliases, Toks>,
-                        UnqualifiedColumnRefsValidFor<N, S, Tables, Aliases, Toks, never>,
-                        true,
-                        true,
-                        true
-                      >
-                    : true
+                : And<
+                    QualifiedColumnRefsValidFor<N, S, Tables, Aliases, Seg>,
+                    UnqualifiedColumnRefsValidFor<N, S, Tables, Aliases, Seg, never>,
+                    true,
+                    true,
+                    true
+                  >
             : true
             : true
         : true;

package/src/validation/return-derived.ts

@@ -1,7 +1,7 @@
 // Derived-table & JOIN LATERAL / joined-derived result inference.
-import type { AliasesInQuery, TablesInQuery } from "../tables.js";
+import type { AliasesInQuery, NullableRelations, TablesInQuery } from "../tables.js";
 import type { ApplyJoinNull, OuterCastTs, RefQualifier } from "../expressions.js";
-import type { CleanIdent, ExtractAliasResult, ExtractFromClause, ExtractSelectList, SplitBalancedParen, SplitCommaSimple, SplitSelectList, Trim, TrimLeft } from "../parsing.js";
+import type { CleanIdent, ExtractAliasResult, ExtractFromClause, ExtractSelectList, SplitBalancedParen, SplitCommaSimple, SplitSelectList, StripSubqueries, Trim, TrimLeft } from "../parsing.js";
 import type { DatabaseSchema } from "../schema.js";
 import type { MergeRow, SelectReturnWith } from "./return-types.js";
 import type { Simplify, UnionToIntersection } from "../utils.js";
@@ -107,7 +107,30 @@ export type DerivedBodyColType<E extends string, BaseRow> =
 export type DerivedTableReturn<N extends string, S extends DatabaseSchema> =
     DerivedTableMatch<N> extends { body: infer Body extends string; alias: infer DAlias extends string; cols: infer Cols extends string[] }
         ? DerivedRenamedRow<Body, Cols, S> extends infer SubRow
-            ? BuildDerivedReturn<SplitSelectList<ExtractSelectList<N>>, DAlias, SubRow>
+            ? Simplify<MergeRow<
+                DerivedJoinedBaseRow<N, S>,
+                BuildDerivedReturn<SplitSelectList<ExtractSelectList<N>>, DAlias, SubRow>
+              >>
+            : {}
+        : {};
+
+// Tables JOINed onto the leading derived source (`FROM (<subquery>) d JOIN base
+// b ...`) are real outer relations, so projected refs to them (`b.col`,
+// `b.col AS x`) must resolve against the schema — not leak as a dotted-literal
+// key (`{"b.col": unknown}`) or an `unknown` type. Excise the subquery body
+// (`StripSubqueries`) to recover just those outer relations, then resolve the
+// outer SELECT list against them with outer-join nullability. Refs to the derived
+// alias (`d.col`) don't resolve here (it isn't a real table); the derived-alias
+// path supplies those and `MergeRow` lets it win on overlap. Gated on an actual
+// JOIN so a plain `FROM (<subquery>) d` pays nothing extra.
+export type DerivedJoinedBaseRow<N extends string, S extends DatabaseSchema> =
+    StripSubqueries<N> extends infer Outer extends string
+        ? Outer extends `${string} join ${string}`
+            ? TablesInQuery<Outer, S> extends infer OT extends string
+                ? AliasesInQuery<Outer, S> extends infer OA extends string
+                    ? SelectReturnWith<ExtractSelectList<N>, OT, OA, S, NullableRelations<N, S>>
+                    : {}
+                : {}
             : {}
         : {};
 
@@ -123,6 +146,37 @@ export type BuildDerivedReturn<
         ? BuildDerivedReturn<Rest, DAlias, SubRow, MergeRow<Acc, DerivedExprToObject<H, DAlias, SubRow>>, [any, ...Steps]>
         : Simplify<Acc>;
 
+// A "bare identifier": a simple unquoted name with no operator/paren/space/dot
+// chars. Lets us tell a *plain* qualified column ref (`ip.entity_id`) apart from
+// an expression that merely contains a dot (`sum(t.x)`, `(array_agg(a.b))[1]`).
+export type IsBareIdent<S extends string> =
+    S extends "" ? false
+        : S extends `${string}${
+            | " " | "(" | ")" | "+" | "-" | "*" | "/" | ":" | "'" | "\"" | "["
+            | "]" | "," | "." | "=" | "<" | ">" | "|" | "%" | "!" | "~" | "@"
+          }${string}`
+            ? false
+            : true;
+
+// The qualifier of a *simple* qualified column ref `Q.col` (both parts bare),
+// else `never` (functions/expressions/quoted refs don't qualify).
+export type SimpleQualRef<E extends string> =
+    CleanIdent<E> extends `${infer Q}.${infer Col}`
+        ? IsBareIdent<Q> extends true
+            ? IsBareIdent<Col> extends true ? Q : never
+            : never
+        : never;
+
+// True when `RawExpr` is a simple qualified column ref pointing at something
+// OTHER than the derived alias — i.e. a JOINed base table (`ip.entity_id`,
+// `t.name`). `DerivedTableReturn` resolves those against the schema separately,
+// so the derived-alias path skips them rather than emitting a bogus dotted key.
+export type IsForeignSimpleRef<RawExpr extends string, DAlias extends string> =
+    SimpleQualRef<RawExpr> extends infer Q extends string
+        ? [Q] extends [never] ? false
+            : Q extends DAlias ? (DAlias extends Q ? false : true) : true
+        : false;
+
 // `Nullable` carries the outer-join nullable-qualifier set. When the derived
 // table is the nullable side of an outer join (`LEFT JOIN LATERAL (...) d`), its
 // exposed columns must gain `| null` (Postgres: the whole derived row is NULL when
@@ -130,7 +184,9 @@ export type BuildDerivedReturn<
 // don't pass it are unaffected.
 export type DerivedExprToObject<E extends string, DAlias extends string, SubRow, Nullable extends string = never> =
     ExtractAliasResult<E> extends { expr: infer RawExpr extends string; alias: infer OutAlias }
-        ? [OutAlias] extends [never]
+        ? IsForeignSimpleRef<RawExpr, DAlias> extends true
+            ? {}
+            : [OutAlias] extends [never]
             ? CleanIdent<RawExpr> extends "*"
                 ? SubRow
                 : CleanIdent<RawExpr> extends `${DAlias}.*`

package/src/validation/return-types.ts

@@ -259,9 +259,15 @@ export type SelectAliases<
     ? Acc
     : Exprs extends [infer H extends string, ...infer Rest extends string[]]
         ? ExtractAlias<H> extends { alias: infer Alias }
-            ? Alias extends string
-                ? SelectAliases<Rest, Acc | Alias, [any, ...Steps]>
-                : SelectAliases<Rest, Acc, [any, ...Steps]>
+            // A non-aliased projection yields `alias: never`. Guard it in tuple
+            // position: a NAKED `never extends string ?` arm collapses the whole
+            // conditional (and with it the entire recursion) to `never`, silently
+            // dropping every alias the list DOES define.
+            ? [Alias] extends [never]
+                ? SelectAliases<Rest, Acc, [any, ...Steps]>
+                : Alias extends string
+                    ? SelectAliases<Rest, Acc | Alias, [any, ...Steps]>
+                    : SelectAliases<Rest, Acc, [any, ...Steps]>
             : SelectAliases<Rest, Acc, [any, ...Steps]>
         : Acc;