@kuindji/typed-sql 0.1.0 → 0.3.0

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/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;
 

package/src/validation/validate-columns.ts

@@ -4,9 +4,9 @@ import type { AllTrue, And, StartsWith } from "../utils.js";
 import type { CleanIdent, DQuoteSpaceSentinel, ExceedsLengthBudget, ExtractAliasResult, ExtractBefore, ExtractConflictColumns, ExtractConflictUpdateExcludedCols, ExtractConflictUpdateSetColumns, ExtractInsertColumns, ExtractLastWhere, ExtractReturningList, ExtractSelectList, ExtractUpdateSetColumns, ReplaceAll, SplitSelectList, StripSubqueries, TokenizeLoose, Trim } from "../parsing.js";
 import type { ColumnRefValidLooseWith, IsSimpleRefPart, QualifiedColumnRefs, ResolveAlias, TableKeysByName, UnqualifiedColumnRefs, UnqualifiedColumnValid } from "../columns.js";
 import type { ColumnsExistInTable, RefScanBeforeOrderBy, RefScanOrderBy, RefScanSegment, SelectAliasesInQuery, SelectAliasSet } from "./return-types.js";
-import type { CteRow, SingleCteMatch } from "./cte.js";
+import type { CteNames, CteRow, SingleCteMatch } from "./cte.js";
 import type { DatabaseSchema } from "../schema.js";
-import type { DerivedRenamedRow, DerivedTableMatch } from "./return-derived.js";
+import type { AliasHasNoSpace, DerivedRenamedRow, DerivedTableMatch } from "./return-derived.js";
 import type { ExprsValidList } from "../expressions.js";
 import type { HasReturning, QueryKind, ValidateSQLNormalized } from "./dispatch.js";
 
@@ -309,7 +309,7 @@ export type ColumnsValidInSelectOrReturningFor<
     HasReturning<N> extends true
         ? [Tables] extends [never]
             ? true
-            : ExprsValidList<SplitSelectList<ReplaceAll<ExtractReturningList<N>, DQuoteSpaceSentinel, " ">>, Tables, Aliases, S>
+            : ExprsValidList<SplitSelectList<ReplaceAll<ExtractReturningList<N>, DQuoteSpaceSentinel, " ">>, Tables, Aliases, S, [], SelectLocalRels<N>>
         : QueryKind<N> extends "select"
             ? [Tables] extends [never]
                 ? true
@@ -318,9 +318,18 @@ export type ColumnsValidInSelectOrReturningFor<
                 // The alias set restores those spaces, so restore them here too or a
                 // qualifier through a space-bearing quoted alias (`"user alias".id`)
                 // would never match its registered alias (round-12 regression).
-                : ExprsValidList<SplitSelectList<ReplaceAll<ExtractSelectList<N>, DQuoteSpaceSentinel, " ">>, Tables, Aliases, S>
+                : ExprsValidList<SplitSelectList<ReplaceAll<ExtractSelectList<N>, DQuoteSpaceSentinel, " ">>, Tables, Aliases, S, [], SelectLocalRels<N>>
             : true;
 
+// Query-local relation names whose qualified refs the projection-list validator
+// must bless: a `WITH`-query's CTE names. (A CTE that reaches the core validator
+// — e.g. `WITH ... SELECT ... JOIN ...` — is collected into `TablesInQuery` as a
+// bogus base table for the ref-resolution, so `cte.col` in the SELECT list would
+// otherwise resolve `never` and falsely reject.) Gated on the `with ` prefix so
+// CTE-free queries pay nothing.
+type SelectLocalRels<N extends string> =
+    N extends `with ${string}` ? CteNames<N> : never;
+
 // insert
 
 export type ColumnsValidInInsert<N extends string, S extends DatabaseSchema> =
@@ -368,10 +377,66 @@ export type QualifiedColumnRefsValidFor<
     Tables extends string,
     Aliases extends string,
     LooseTokens extends string[]
+> =
+    // Common path: with no CTE and no parenthesised FROM source there is no local
+    // relation that could qualify a ref, so skip the (per-ref) local-relation
+    // blessing entirely — exact prior behavior, zero added cost.
+    HasLocalRelations<N> extends true
+        ? QualifiedRefsValidWithLocal<N, S, Tables, Aliases, LooseTokens, CteNames<N>>
+        : QualifiedColumnRefs<LooseTokens, S, Tables, Aliases> extends infer Cols
+            ? AllTrue<Cols extends string ? ColumnRefValidLooseWith<Cols, Tables, Aliases, S> : true>
+            : true;
+
+// A "local relation" is a query-local name that is NOT a base table: a CTE name, or
+// the alias bound to a derived / VALUES / subquery FROM source (`from (…) [as]
+// x[(cols)]`). Its columns are not modeled in the schema, so a ref qualified by it
+// must be accepted leniently rather than resolved against a (non-existent) base
+// table. Blessing only ever turns a reject into an accept — never the reverse —
+// consistent with the lenient-parser contract.
+type HasLocalRelations<N extends string> =
+    N extends `with ${string}` ? true :
+    N extends `${string} from (${string}` ? true :
+    N extends `${string} join (${string}` ? true :
+    false;
+
+type QualifiedRefsValidWithLocal<
+    N extends string,
+    S extends DatabaseSchema,
+    Tables extends string,
+    Aliases extends string,
+    LooseTokens extends string[],
+    Ctes extends string
 > = QualifiedColumnRefs<LooseTokens, S, Tables, Aliases> extends infer Cols
-    ? AllTrue<Cols extends string ? ColumnRefValidLooseWith<Cols, Tables, Aliases, S> : true>
+    ? AllTrue<
+        Cols extends string
+            ? IsLocalRelation<RefQualifierOf<Cols>, Ctes, N> extends true
+                ? true
+                : ColumnRefValidLooseWith<Cols, Tables, Aliases, S>
+            : true
+      >
     : true;
 
+// The qualifier (text before the first `.`) of a qualified column ref.
+type RefQualifierOf<Col extends string> =
+    Col extends `${infer Q}.${string}` ? CleanIdent<Q> : never;
+
+type IsLocalRelation<Q extends string, Ctes extends string, N extends string> =
+    [Q] extends [never] ? false :
+    Q extends Ctes ? true :
+    IsDerivedSourceAlias<Q, N>;
+
+// Detect `… ) [as] q …` / `… ) [as] q( …` — q is the alias bound to a parenthesised
+// (derived / VALUES / subquery) FROM source. N is already normalized (lowercase
+// outside quotes); q is the cleaned, lowercased qualifier.
+type IsDerivedSourceAlias<Q extends string, N extends string> =
+    N extends `${string}) as ${Q} ${string}` ? true :
+    N extends `${string}) as ${Q}(${string}` ? true :
+    N extends `${string}) as ${Q}` ? true :
+    N extends `${string}) ${Q} ${string}` ? true :
+    N extends `${string}) ${Q}(${string}` ? true :
+    N extends `${string}) ${Q}` ? true :
+    false;
+
 // Once a table is given a range alias (`FROM products p`), PostgreSQL hides the
 // original table name as a correlation name for that query level — `products.id`
 // is then invalid; only `p.id` works. The lenient qualified-ref check accepts
@@ -402,15 +467,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
@@ -483,7 +554,46 @@ export type UnqualifiedColumnRefsValidFor<
         Cols extends string
             ? CleanIdent<Cols> extends SelectAliases
                 ? true
-                : UnqualifiedColumnValid<Cols, Tables, Aliases, S>
+                : UnqualifiedColumnValid<Cols, Tables, Aliases, S> extends true
+                    ? true
+                    // A derived/VALUES source's column-alias list (`... ) as
+                    // src(id, t)`) survives tokenization as bare identifier tokens,
+                    // and `t` is not a schema column anywhere — bless names that
+                    // belong to such a list. Checked ONLY after normal resolution
+                    // fails, so valid queries never pay for the extraction, and
+                    // blessing can only turn a reject into an accept (lenient
+                    // contract).
+                    : CleanIdent<Cols> extends SourceAliasListCols<N>
+                        ? true
+                        : false
             : true
     >
     : true;
+
+// Every column name bound by a derived-source column-alias list — `) as p(a, b)`
+// / `) p(a, b)` — plus CTE column-alias lists (`with c(x, y) as (`). Collected
+// across ALL occurrences in the (normalized, single-line) query. The alias word
+// itself must be space-free, mirroring `DerivedColsAfterAlias`'s guard, so a
+// trailing `WHERE ... IN (...)` paren group is not misread as a column list.
+type SourceAliasListCols<N extends string> =
+    N extends `with ${infer CteHead}(${infer CteCols}) as (${infer Rest}`
+        ? AliasHasNoSpace<Trim<CteHead>> extends true
+            ? ColNamesFromList<CteCols> | DerivedAliasListCols<Rest>
+            : DerivedAliasListCols<N>
+        : DerivedAliasListCols<N>;
+
+type DerivedAliasListCols<N extends string, Steps extends any[] = []> =
+    Steps["length"] extends 15
+        ? never
+        : N extends `${string}) as ${infer Rest}`
+            ? Rest extends `${infer Alias}(${infer Cols})${infer Tail}`
+                ? AliasHasNoSpace<Trim<Alias>> extends true
+                    ? ColNamesFromList<Cols> | DerivedAliasListCols<Tail, [any, ...Steps]>
+                    : DerivedAliasListCols<Tail, [any, ...Steps]>
+                : never
+            : never;
+
+type ColNamesFromList<L extends string> =
+    L extends `${infer A},${infer R}`
+        ? CleanIdent<A> | ColNamesFromList<R>
+        : CleanIdent<L>;