@kuindji/typed-sql 0.1.0

package/src/builder/write-state.ts

@@ -0,0 +1,43 @@
+// src/builder/write-state.ts
+import type { DriverParamValue } from "./scanner.js";
+
+export interface InsertValueEntry { readonly col: string; readonly text: string; }
+export interface RuntimeInsertState {
+    readonly table: string;
+    readonly values: ReadonlyArray<InsertValueEntry>;
+    // INSERT...SELECT form: explicit column list and a free-text SELECT body that
+    // replaces the VALUES clause. When `fromSelect` is set, the value fragments are
+    // ignored and the SELECT form is emitted instead (see assembleInsertSQL).
+    readonly columns?: string;
+    readonly fromSelect?: string;
+    readonly conflict?: string;
+    readonly returning?: string;
+    readonly namedParams: Record<string, DriverParamValue>;
+}
+export interface RuntimeUpdateState {
+    readonly table: string;
+    // Optional table alias, e.g. `update orders o set ...`. Emitted after the
+    // table name when present so aliased WHERE/SET references resolve.
+    readonly alias?: string;
+    // Optional CTEs prepended as a `with ... ` clause before `update`. The body
+    // text may contain `:params`; because it precedes the UPDATE in the final
+    // SQL, those params get the lowest positional numbers.
+    readonly ctes?: ReadonlyArray<{ name: string; body: string; materialized: boolean }>;
+    readonly sets: ReadonlyArray<string>;
+    readonly froms: ReadonlyArray<string>;
+    readonly wheres: ReadonlyArray<string>;
+    readonly returning?: string;
+    readonly namedParams: Record<string, DriverParamValue>;
+}
+export interface RuntimeDeleteState {
+    readonly table: string;
+    readonly usings: ReadonlyArray<string>;
+    readonly wheres: ReadonlyArray<string>;
+    readonly returning?: string;
+    readonly namedParams: Record<string, DriverParamValue>;
+}
+// `columns: ""` mirrors the type-level EmptyInsertTag default so a `.fromSelect(...)`
+// reached without `.columns(...)` emits an honest `()` rather than `(undefined)`.
+export const EMPTY_INSERT_STATE: RuntimeInsertState = { table: "", values: [], columns: "", namedParams: {} };
+export const EMPTY_UPDATE_STATE: RuntimeUpdateState = { table: "", sets: [], froms: [], wheres: [], namedParams: {} };
+export const EMPTY_DELETE_STATE: RuntimeDeleteState = { table: "", usings: [], wheres: [], namedParams: {} };

package/src/builder/write-tag.ts

@@ -0,0 +1,119 @@
+// src/builder/write-tag.ts
+import type { DatabaseSchema } from "../schema.js";
+import type { ExtractParams, ExtractReturning } from "./extract-params.js";
+
+export type WriteMode = "max" | "req";
+
+export interface ValueFrag { readonly col: string; readonly text: string; readonly cond: boolean; }
+export interface ClauseFrag { readonly text: string; readonly cond: boolean; }
+
+export interface InsertTag {
+    readonly kind: "insert";
+    readonly table: string;
+    readonly values: readonly ValueFrag[];
+    // INSERT...SELECT: explicit column list + free-text SELECT body. Empty string
+    // ("") means "not set" — the VALUES form is rendered instead.
+    readonly columns: string;
+    readonly fromSelect: string;
+    readonly conflict: string | null;
+    readonly wheres: readonly ClauseFrag[];     // unused for insert; kept uniform
+    readonly using: readonly ClauseFrag[];
+    readonly from: readonly ClauseFrag[];
+    readonly returning: string | null;
+}
+export interface CteFrag { readonly name: string; readonly body: string; readonly materialized: boolean; }
+export interface UpdateTag {
+    readonly kind: "update";
+    readonly table: string;
+    readonly alias: string;
+    readonly ctes: readonly CteFrag[];
+    readonly sets: readonly ClauseFrag[];
+    readonly from: readonly ClauseFrag[];
+    readonly wheres: readonly ClauseFrag[];
+    readonly returning: string | null;
+}
+export interface DeleteTag {
+    readonly kind: "delete";
+    readonly table: string;
+    readonly using: readonly ClauseFrag[];
+    readonly wheres: readonly ClauseFrag[];
+    readonly returning: string | null;
+}
+
+// keep only the fragments live for a mode ("req" drops cond=true).
+type ForMode<List extends readonly { cond: boolean }[], Mode extends WriteMode> =
+    Mode extends "max" ? List : DropCond<List>;
+type DropCond<List extends readonly { cond: boolean }[]> =
+    List extends readonly [infer H extends { cond: boolean }, ...infer R extends readonly { cond: boolean }[]]
+        ? H["cond"] extends true ? DropCond<R> : readonly [H, ...DropCond<R>]
+        : readonly [];
+
+type ColList<List extends readonly ValueFrag[], Acc extends string = ""> =
+    List extends readonly [infer H extends ValueFrag, ...infer R extends readonly ValueFrag[]]
+        ? ColList<R, Acc extends "" ? H["col"] : `${Acc}, ${H["col"]}`> : Acc;
+type ValList<List extends readonly ValueFrag[], Acc extends string = ""> =
+    List extends readonly [infer H extends ValueFrag, ...infer R extends readonly ValueFrag[]]
+        ? ValList<R, Acc extends "" ? H["text"] : `${Acc}, ${H["text"]}`> : Acc;
+type JoinText<List extends readonly { text: string }[], Sep extends string, Acc extends string = ""> =
+    List extends readonly [infer H extends { text: string }, ...infer R extends readonly { text: string }[]]
+        ? JoinText<R, Sep, Acc extends "" ? H["text"] : `${Acc}${Sep}${H["text"]}`> : Acc;
+
+type Conflict<C extends string | null> = C extends string ? ` on conflict ${C}` : "";
+type Returning<R extends string | null> = R extends string ? ` returning ${R}` : "";
+type FromClause<L extends readonly ClauseFrag[]> = L extends readonly [] ? "" : ` from ${JoinText<L, ", ">}`;
+type UsingClause<L extends readonly ClauseFrag[]> = L extends readonly [] ? "" : ` using ${JoinText<L, ", ">}`;
+type WhereClause<L extends readonly ClauseFrag[]> = L extends readonly [] ? "" : ` where ${JoinText<L, " and ">}`;
+
+// INSERT...SELECT form: `insert into <table> (<columns>) <fromSelect>[ on conflict
+// <c>][ returning <r>]`. The fromSelect text carries its own `:params`, which
+// ExtractParams scans positionally from the built string.
+export type BuildInsertSelectSQL<T extends InsertTag> =
+    `insert into ${T["table"]} (${T["columns"]}) ${T["fromSelect"]}${Conflict<T["conflict"]>}${Returning<T["returning"]>}`;
+
+export type BuildInsertSQL<T extends InsertTag, Mode extends WriteMode> =
+    // Branch on whether a SELECT body was supplied (non-empty fromSelect).
+    T["fromSelect"] extends "" ? BuildInsertValuesSQL<T, Mode> : BuildInsertSelectSQL<T>;
+
+// Original VALUES rendering, used when no fromSelect is present.
+type BuildInsertValuesSQL<T extends InsertTag, Mode extends WriteMode> =
+    ForMode<T["values"], Mode> extends infer V extends readonly ValueFrag[]
+        ? `insert into ${T["table"]} (${ColList<V>}) values (${ValList<V>})${Conflict<T["conflict"]>}${Returning<T["returning"]>}`
+        : never;
+
+// Head is `table` alone, or `table alias` when an alias was supplied.
+type UpdateHead<T extends UpdateTag> = T["alias"] extends "" ? T["table"] : `${T["table"]} ${T["alias"]}`;
+
+// Render one CTE: `name as [materialized ](body)`.
+type RenderCte<C extends CteFrag> = `${C["name"]} as ${C["materialized"] extends true ? "materialized " : ""}(${C["body"]})`;
+// Join CTEs with ", " (comma-separated), mirroring JoinText but per-CTE rendered.
+type JoinCtes<L extends readonly CteFrag[], Acc extends string = ""> =
+    L extends readonly [infer H extends CteFrag, ...infer R extends readonly CteFrag[]]
+        ? JoinCtes<R, Acc extends "" ? RenderCte<H> : `${Acc}, ${RenderCte<H>}`> : Acc;
+// Leading `with ... ` clause (trailing space) when CTEs exist, else empty. The
+// body text is embedded so ExtractParams picks up its `:params` ahead of the rest.
+type WithClause<L extends readonly CteFrag[]> = L extends readonly [] ? "" : `with ${JoinCtes<L>} `;
+
+export type BuildUpdateSQL<T extends UpdateTag, Mode extends WriteMode> =
+    `${WithClause<T["ctes"]>}update ${UpdateHead<T>} set ${JoinText<ForMode<T["sets"], Mode>, ", ">}${FromClause<ForMode<T["from"], Mode>>}${WhereClause<ForMode<T["wheres"], Mode>>}${Returning<T["returning"]>}`;
+
+export type BuildDeleteSQL<T extends DeleteTag, Mode extends WriteMode> =
+    `delete from ${T["table"]}${UsingClause<ForMode<T["using"], Mode>>}${WhereClause<ForMode<T["wheres"], Mode>>}${Returning<T["returning"]>}`;
+
+type BuildSQL<T, Mode extends WriteMode> =
+    T extends InsertTag ? BuildInsertSQL<T, Mode>
+    : T extends UpdateTag ? BuildUpdateSQL<T, Mode>
+    : T extends DeleteTag ? BuildDeleteSQL<T, Mode>
+    : never;
+
+// Required iff present in the req-mode params; value type taken from max-mode
+// (full §6.2 intersection over all occurrences). Mirrors return-type.ts Partition.
+type Partition<Max, Req> =
+    & { [K in keyof Max as K extends keyof Req ? K : never]: Max[K] }
+    & { [K in keyof Max as K extends keyof Req ? never : K]?: Max[K] };
+
+export type WriteParamsFor<T, S extends DatabaseSchema> =
+    Partition<ExtractParams<BuildSQL<T, "max">, S>, ExtractParams<BuildSQL<T, "req">, S>> extends infer P
+        ? { [K in keyof P]: P[K] } : never;
+
+export type WriteReturnFor<T, S extends DatabaseSchema> =
+    ExtractReturning<BuildSQL<T, "max"> & string, S>;

package/src/columns.ts

@@ -0,0 +1,336 @@
+import type {
+    DatabaseSchema,
+    ColumnExists,
+    ColumnExistsInAnyTable,
+    ResolveColumnName,
+    TableExists
+} from "./schema.js";
+import type { AliasesInQuery, AliasNames, IsAliasName, TableKeyFromToken, TableKeyValid, TablesInQuery } from "./tables.js";
+import type {
+    CanPrecedeColumn,
+    CleanExpr,
+    CleanIdent,
+    HasSpecial,
+    IsParamPlaceholder,
+    IsQualifiedRefCandidate,
+    IsRuntimeStringFragment,
+    IsSqlConstant,
+    OperatorToken,
+    ReplaceAll,
+    SqlReserved,
+    SplitOnDotClean
+} from "./parsing.js";
+import type { IsNever } from "./utils.js";
+
+// Column references
+
+export type ColumnRef<TableKey extends string, Column extends string> = {
+    tableKey: TableKey;
+    column: Column;
+};
+
+export type BuildColumnRef<
+    TableKey extends string,
+    Column extends string,
+    S extends DatabaseSchema
+> =
+    ResolveColumnName<TableKey, Column, S> extends infer Resolved extends string
+        ? ColumnRef<TableKey, Resolved>
+        : never;
+
+export type StripDoubleQuotes<S extends string> = ReplaceAll<S, `"`, "">;
+
+// Parse column references from expressions
+// - supports schema.table.column, table.column, and column
+
+// A qualified ref whose table/alias prefix is a double-quoted identifier
+// containing operator punctuation (`"u-1".id`) breaks the generic path: stripping
+// the quotes yields `u-1`, which `IsSimpleRefPart`/`HasSpecial` reject as an
+// arithmetic-looking token, so the ref collapses to `never` and the projected key
+// is lost. A double-quoted identifier is by definition a single opaque name, so
+// when the prefix carries punctuation we resolve it directly (alias/table lookup)
+// without the special-char gate. The no-punctuation case (`"u1".id`) stays on the
+// proven generic path; the column part must be a plain name (no dot/quote/star).
+export type ParseColumnRef<
+    Expr extends string,
+    Tables extends string,
+    Aliases extends string,
+    S extends DatabaseSchema
+> =
+    CleanExpr<Expr> extends `"${infer P}".${infer Col}`
+        ? IsQuotedPunctPrefix<P, Col> extends true
+            ? ResolveQuotedPrefixRef<CleanIdent<P>, CleanIdent<Col>, Tables, Aliases, S>
+            : ParseColumnRefGeneric<Expr, Tables, Aliases, S>
+        : ParseColumnRefGeneric<Expr, Tables, Aliases, S>;
+
+export type IsQuotedPunctPrefix<P extends string, Col extends string> =
+    Col extends `${string}.${string}` ? false :
+    Col extends `${string}"${string}` ? false :
+    Col extends `${string}*${string}` ? false :
+    HasSpecial<P> extends true ? true :
+    false;
+
+export type ResolveQuotedPrefixRef<
+    P extends string,
+    Col extends string,
+    Tables extends string,
+    Aliases extends string,
+    S extends DatabaseSchema
+> =
+    [ResolveTableKey<P, Tables, Aliases, S>] extends [infer TK extends string]
+        ? [TK] extends [never]
+            ? [ResolveTableKeyForUnqualified<Tables, Aliases, S, Col>] extends [infer TKF extends string]
+                ? [TKF] extends [never]
+                    ? never
+                    : BuildColumnRef<TKF, Col, S>
+                : never
+            : BuildColumnRef<TK, Col, S>
+        : never;
+
+export type ParseColumnRefGeneric<
+    Expr extends string,
+    Tables extends string,
+    Aliases extends string,
+    S extends DatabaseSchema
+> =
+    SplitOnDotClean<StripDoubleQuotes<CleanExpr<Expr>>> extends [infer A extends string, infer B extends string, infer C extends string]
+        ? IsSimpleRefPart<A> extends true
+            ? IsSimpleRefPart<B> extends true
+                ? IsSimpleRefPart<C> extends true
+                    ? BuildColumnRef<`${A}.${B}`, C, S>
+                    : never
+                : never
+            : never
+        : SplitOnDotClean<StripDoubleQuotes<CleanExpr<Expr>>> extends [infer A extends string, infer B extends string]
+            ? IsSimpleRefPart<A> extends true
+                ? IsSimpleRefPart<B> extends true
+                    ? IsRuntimeStringFragment<A> extends true
+                        ? [ResolveTableKeyForUnqualified<Tables, Aliases, S, B>] extends [infer TKRuntime extends string]
+                            ? [TKRuntime] extends [never]
+                                ? never
+                                : BuildColumnRef<TKRuntime, B, S>
+                            : never
+                        : CleanIdent<A> extends "excluded"
+                        ? [ResolveTableKeyForUnqualified<Tables, Aliases, S, B>] extends [infer TKExcluded extends string]
+                            ? [TKExcluded] extends [never]
+                                ? never
+                                : BuildColumnRef<TKExcluded, B, S>
+                            : never
+                        : [ResolveTableKey<A, Tables, Aliases, S>] extends [infer TK extends string]
+                            ? [TK] extends [never]
+                                ? [ResolveTableKeyForUnqualified<Tables, Aliases, S, B>] extends [infer TKFallback extends string]
+                                    ? [TKFallback] extends [never]
+                                        ? never
+                                        : BuildColumnRef<TKFallback, B, S>
+                                    : never
+                                : BuildColumnRef<TK, B, S>
+                            : never
+                    : never
+                : never
+            : SplitOnDotClean<StripDoubleQuotes<CleanExpr<Expr>>> extends [infer A extends string]
+                ? IsSimpleRefPart<A> extends true
+                    ? [ResolveTableKeyForUnqualified<Tables, Aliases, S, A>] extends [infer TK2 extends string]
+                        ? [TK2] extends [never]
+                            ? never
+                            : BuildColumnRef<TK2, A, S>
+                        : never
+                    : never
+                : never;
+
+export type IsSimpleRefPart<S extends string> =
+    S extends "" ? false :
+    HasSpecial<S> extends true ? false :
+    true;
+
+// Validate a column reference string like a.b or a.b.c
+
+export type ColumnRefValid<ColRef extends string, N extends string, S extends DatabaseSchema> =
+    TablesInQuery<N, S> extends infer Tables extends string
+        ? AliasesInQuery<N, S> extends infer Aliases extends string
+            ? ColumnRefValidWith<ColRef, Tables, Aliases, S>
+            : true
+        : true;
+
+export type ColumnRefValidWith<
+    ColRef extends string,
+    Tables extends string,
+    Aliases extends string,
+    S extends DatabaseSchema
+> =
+    ColRef extends `${infer Prefix}.*`
+        ? [ResolveAlias<CleanIdent<Prefix>, Aliases>] extends [infer AliasKey extends string]
+            ? [AliasKey] extends [never]
+                ? TableKeysByName<CleanIdent<Prefix>, Tables> extends infer TableKey extends string
+                    ? [TableKey] extends [never]
+                        ? CleanIdent<Prefix> extends `${infer Schema}.${infer Table}`
+                            ? TableExists<S, Schema, Table> extends true
+                                ? TableKeyValid<`${Schema}.${Table}`, S>
+                                : false
+                            : false
+                        : TableKeyValid<TableKey, S>
+                    : false
+                : TableKeyValid<AliasKey, S>
+            : false
+        : ParseColumnRef<ColRef, Tables, Aliases, S> extends infer Ref
+            ? [Ref] extends [never]
+                ? true
+                : [Ref] extends [ColumnRef<infer TableKey extends string, infer Column extends string>]
+                    ? ColumnExists<TableKey, Column, S>
+                    : true
+            : true;
+
+export type ColumnRefValidLoose<ColRef extends string, N extends string, S extends DatabaseSchema> =
+    TablesInQuery<N, S> extends infer Tables extends string
+        ? AliasesInQuery<N, S> extends infer Aliases extends string
+            ? ColumnRefValidLooseWith<ColRef, Tables, Aliases, S>
+            : ColumnRefValid<ColRef, N, S>
+        : ColumnRefValid<ColRef, N, S>;
+
+export type ColumnRefValidLooseWith<
+    ColRef extends string,
+    Tables extends string,
+    Aliases extends string,
+    S extends DatabaseSchema
+> = IsNever<Tables> extends true
+    ? ColumnRefValidNoTables<ColRef, S>
+    : ColumnRefValidWith<ColRef, Tables, Aliases, S>;
+
+export type ColumnRefValidNoTables<ColRef extends string, S extends DatabaseSchema> =
+    SplitOnDotClean<ColRef> extends [infer A extends string, infer B extends string, infer C extends string]
+        ? TableExists<S, A, B> extends true
+            ? ColumnExists<`${A}.${B}`, C, S>
+            : false
+        : SplitOnDotClean<ColRef> extends [infer A extends string, infer B extends string]
+            ? TableExists<S, S["defaultSchema"], A> extends true
+                ? ColumnExists<`${S["defaultSchema"]}.${A}`, B, S>
+                : ColumnExistsInAnyTable<B, S>
+            : ColumnExistsInAnyTable<CleanIdent<ColRef>, S>;
+
+// Best-effort qualified column references across the query
+
+export type QualifiedColumnRefs<
+    Tokens extends string[],
+    S extends DatabaseSchema,
+    Tables extends string,
+    Aliases extends string,
+    Acc extends string = never,
+    Prev extends string = "",
+    Steps extends any[] = []
+> = Steps["length"] extends 900
+    ? Acc
+    : Tokens extends [infer T extends string, ...infer Rest extends string[]]
+    ? T extends `${string}.${string}`
+        ? Prev extends "from" | "join" | "update" | "into" | "delete"
+            ? QualifiedColumnRefs<Rest, S, Tables, Aliases, Acc, T, [any, ...Steps]>
+            : IsQualifiedRefCandidate<T> extends true
+                ? QualifiedColumnRefs<Rest, S, Tables, Aliases, Acc | T, T, [any, ...Steps]>
+                : QualifiedColumnRefs<Rest, S, Tables, Aliases, Acc, T, [any, ...Steps]>
+        : QualifiedColumnRefs<Rest, S, Tables, Aliases, Acc, T, [any, ...Steps]>
+    : Acc;
+
+// Best-effort unqualified column references across the query
+
+export type UnqualifiedColumnRefs<
+    Tokens extends string[],
+    S extends DatabaseSchema,
+    Tables extends string,
+    Aliases extends string,
+    Acc extends string = never,
+    Prev extends string = "",
+    Steps extends any[] = []
+> = Steps["length"] extends 900
+    ? Acc
+    : Tokens extends [infer T extends string, infer Next extends string, ...infer Rest extends string[]]
+    ? IsUnqualifiedColumnCandidate<T, Prev, Next, Tables, Aliases, S> extends true
+        ? UnqualifiedColumnRefs<[Next, ...Rest], S, Tables, Aliases, Acc | T, T, [any, ...Steps]>
+        : UnqualifiedColumnRefs<[Next, ...Rest], S, Tables, Aliases, Acc, T, [any, ...Steps]>
+    : Tokens extends [infer T extends string]
+        ? IsUnqualifiedColumnCandidate<T, Prev, "", Tables, Aliases, S> extends true
+            ? Acc | T
+            : Acc
+        : Acc;
+
+export type UnqualifiedColumnValid<
+    Col extends string,
+    Tables extends string,
+    Aliases extends string,
+    S extends DatabaseSchema
+> = IsNever<Tables> extends true
+    ? ColumnExistsInAnyTable<CleanIdent<Col>, S>
+    : [ResolveTableKeyForUnqualified<Tables, Aliases, S, CleanIdent<Col>>] extends [never]
+        ? false
+        : true;
+
+export type IsUnqualifiedColumnCandidate<
+    Token extends string,
+    Prev extends string,
+    Next extends string,
+    Tables extends string,
+    Aliases extends string,
+    S extends DatabaseSchema
+> =
+    Token extends "" ? false :
+    IsRuntimeStringFragment<Token> extends true ? false :
+    Token extends OperatorToken ? false :
+    Token extends `${string}.${string}` ? false :
+    Token extends `'${string}'` ? false :
+    Token extends `${string}'${string}` ? false :
+    Token extends `${number}` ? false :
+    IsParamPlaceholder<Token> extends true ? false :
+    IsSqlConstant<Token> extends true ? false :
+    HasSpecial<Token> extends true ? false :
+    CleanIdent<Token> extends SqlReserved ? false :
+    IsAliasName<Token, Aliases> extends true ? false :
+    Prev extends "as" ? false :
+    Prev extends "from" | "join" | "update" | "into" | "delete" ? false :
+    Next extends "(" ? false :
+    // A bareword immediately followed by a string literal is a PostgreSQL typed
+    // string literal's type prefix (`DATE '...'`, `TIMESTAMP '...'`), never a
+    // column — a real column is never directly adjacent to a quote (round-12 L1/L2).
+    Next extends `'${string}` ? false :
+    // A table name following a comma is another FROM source in the comma
+    // cross-join `from a, b` (the `,` plays the role `join` does), not a column.
+    Prev extends "," ? (IsTableName<Token, S> extends true ? false : CanPrecedeColumn<Prev>) :
+    IsNever<Tables> extends true
+        ? IsTableName<Token, S> extends true
+            ? false
+            : CanPrecedeColumn<Prev>
+        : CanPrecedeColumn<Prev>;
+
+export type IsTableName<Token extends string, S extends DatabaseSchema> =
+    TableKeyFromToken<Token, S> extends infer TableKey extends string
+        ? TableKeyValid<TableKey, S>
+        : false;
+
+// Utilities for table/column resolution
+
+export type ResolveTableKey<Name extends string, Tables extends string, Aliases extends string, S extends DatabaseSchema> =
+    ResolveAlias<Name, Aliases> | TableKeysByName<Name, Tables> | `${S["defaultSchema"]}.${Name}`;
+
+export type ResolveTableKeyForUnqualified<
+    Tables extends string,
+    Aliases extends string,
+    S extends DatabaseSchema,
+    Column extends string
+> = TablesWithColumn<Tables, Column, S> extends infer TK extends string ? TK : never;
+
+export type ResolveAlias<Name extends string, Aliases extends string> =
+    Aliases extends `${infer A}=>${infer T}`
+        ? A extends Name
+            ? T
+            : never
+        : never;
+
+export type TableKeysByName<Name extends string, Tables extends string> =
+    Tables extends `${infer Schema}.${infer Table}`
+        ? Table extends Name
+            ? `${Schema}.${Table}`
+            : never
+        : never;
+
+export type TablesWithColumn<Tables extends string, Column extends string, S extends DatabaseSchema> =
+    Tables extends `${infer Schema}.${infer Table}`
+        ? ColumnExists<`${Schema}.${Table}`, Column, S> extends true
+            ? `${Schema}.${Table}`
+            : never
+        : never;