prisma-ts-select 0.1.2 → 0.1.4

package/dist/extend/dialects/postgresql-v7.js

@@ -4,6 +4,12 @@ function sqlExpr(sql) {
     return sql;
   } };
 }
+var DISTINCT_BRAND = Symbol("sqlDistinct");
+function sqlDistinct(sql) {
+  return { sql, [DISTINCT_BRAND]: true, toString() {
+    return sql;
+  } };
+}
 function resolveArg(arg, quoteFn) {
   if (typeof arg !== "string") return arg.sql;
   return quoteFn(arg);
@@ -11,6 +17,7 @@ function resolveArg(arg, quoteFn) {
 
 // src/dialects/shared.ts
 var esc = (s) => s.replace(/'/g, "''");
+var flattenJsonObjectPairs = (pairs, quoteFn) => pairs.flatMap(([k, v]) => [`'${esc(k)}'`, resolveArg(v, quoteFn)]);
 
 // src/dialects/postgresql.ts
 var PG_CAST_TYPES = /* @__PURE__ */ new Set(["INTEGER", "TEXT", "BIGINT", "BOOLEAN", "REAL", "NUMERIC", "DATE", "TIMESTAMP", "JSON", "JSONB"]);
@@ -18,11 +25,12 @@ var postgresqlContextFns = (quoteFn) => ({
   avg: (col) => sqlExpr(`AVG(${resolveArg(col, quoteFn)})`),
   sum: (col) => sqlExpr(`SUM(${resolveArg(col, quoteFn)})`),
   countAll: () => sqlExpr("COUNT(*)"),
-  count: (col) => sqlExpr(col === "*" ? "COUNT(*)" : `COUNT(${quoteFn(col)})`),
+  count: (col) => sqlExpr(col === "*" ? "COUNT(*)" : `COUNT(${resolveArg(col, quoteFn)})`),
   countDistinct: (col) => sqlExpr(`COUNT(DISTINCT ${quoteFn(col)})`),
+  distinct: (col) => sqlDistinct(`DISTINCT ${quoteFn(col)}`),
   length: (col) => sqlExpr(`LENGTH(${resolveArg(col, quoteFn)})`),
-  stringAgg: (col, sep) => sqlExpr(`STRING_AGG(${quoteFn(col)}, '${esc(sep)}')`),
-  arrayAgg: (col) => sqlExpr(`ARRAY_AGG(${quoteFn(col)})`),
+  stringAgg: (col, sep) => sqlExpr(`STRING_AGG(${resolveArg(col, quoteFn)}, '${esc(sep)}')`),
+  arrayAgg: (col) => sqlExpr(`ARRAY_AGG(${resolveArg(col, quoteFn)})`),
   stddevPop: (col) => sqlExpr(`STDDEV_POP(${quoteFn(col)})`),
   stddevSamp: (col) => sqlExpr(`STDDEV_SAMP(${quoteFn(col)})`),
   varPop: (col) => sqlExpr(`VAR_POP(${quoteFn(col)})`),
@@ -95,6 +103,16 @@ var postgresqlContextFns = (quoteFn) => ({
   trunc: (x, n) => sqlExpr(n !== void 0 ? `TRUNC(${resolveArg(x, quoteFn)}, ${n})` : `TRUNC(${resolveArg(x, quoteFn)})`),
   div: (x, y) => sqlExpr(`DIV(${resolveArg(x, quoteFn)}, ${y})`),
   random: () => sqlExpr("RANDOM()"),
+  // ── JSON scalar fns ───────────────────────────────────────────────────────
+  /**
+   * Uses jsonb_path_query_first — requires PG 12+ (Prisma 5+ minimum).
+   * @note PG uses JSONPath syntax (e.g. `$.tags[0]`, `$.name`).
+   * MySQL/SQLite use SQL/JSON path syntax — paths are NOT cross-dialect compatible.
+   * Mismatched paths silently return NULL.
+   */
+  jsonExtract: (col, path) => sqlExpr(`jsonb_path_query_first(${resolveArg(col, quoteFn)}, '${esc(path)}')`),
+  jsonArray: (...args) => sqlExpr(`jsonb_build_array(${args.map((a) => resolveArg(a, quoteFn)).join(", ")})`),
+  jsonObject: (pairs) => sqlExpr(`jsonb_build_object(${flattenJsonObjectPairs(pairs, quoteFn).join(", ")})`),
   // ── Type coercion ────────────────────────────────────────────────────────
   cast: (expr, type) => {
     if (!PG_CAST_TYPES.has(type)) throw new Error(`cast: invalid cast type '${String(type)}'`);
@@ -127,7 +145,7 @@ var postgresqlDialect = {
 var postgresqlV7ContextFns = (quoteFn) => ({
   ...postgresqlContextFns(quoteFn),
   countAll: () => sqlExpr("COUNT(*)"),
-  count: (col) => sqlExpr(col === "*" ? "COUNT(*)" : `COUNT(${quoteFn(col)})`),
+  count: (col) => sqlExpr(col === "*" ? "COUNT(*)" : `COUNT(${resolveArg(col, quoteFn)})`),
   countDistinct: (col) => sqlExpr(`COUNT(DISTINCT ${quoteFn(col)})`),
   ceil: (col) => sqlExpr(`CEIL(${resolveArg(col, quoteFn)})`),
   floor: (col) => sqlExpr(`FLOOR(${resolveArg(col, quoteFn)})`)

package/dist/extend/dialects/postgresql.d.ts

@@ -1,7 +1,7 @@
 import { Dialect } from './types.js';
-import { S as SQLExpr } from '../sql-expr-BaKWzJ-r.js';
-import { J as JSONValue } from '../types-D84lxYVc.js';
-import { FilterCols, ColName } from './shared.js';
+import { S as SQLExpr, a as SQLDistinct } from '../sql-expr-BGSEwzCi.js';
+import { J as JSONValue, a as JSONObject } from '../types-B0F8m0ok.js';
+import { FilterCols, ColName, ColTypeOf, FilterJsonCols } from './shared.js';
 import '@prisma/client/runtime/client';
 
 type PgCastTypeMap = {
@@ -22,11 +22,12 @@ declare const postgresqlContextFns: <TColEntries extends [string, unknown] = nev
     avg: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
     sum: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
     countAll: () => SQLExpr<number>;
-    count: (col: ColName<TColEntries> | "*") => SQLExpr<number>;
+    count: (col: ColName<TColEntries> | "*" | SQLExpr<unknown>) => SQLExpr<number>;
     countDistinct: (col: ColName<TColEntries>) => SQLExpr<number>;
+    distinct: <Col extends ColName<TColEntries>>(col: Col) => SQLDistinct<NonNullable<ColTypeOf<TColEntries, Col>>>;
     length: (col: FilterCols<TColEntries, string> | SQLExpr<string>) => SQLExpr<number>;
-    stringAgg: (col: ColName<TColEntries>, sep: string) => SQLExpr<string>;
-    arrayAgg: (col: ColName<TColEntries>) => SQLExpr<unknown[]>;
+    stringAgg: (col: ColName<TColEntries> | SQLExpr<string>, sep: string) => SQLExpr<string>;
+    arrayAgg: (col: ColName<TColEntries> | SQLExpr<unknown>) => SQLExpr<unknown[]>;
     stddevPop: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
     stddevSamp: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
     varPop: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
@@ -80,6 +81,9 @@ declare const postgresqlContextFns: <TColEntries extends [string, unknown] = nev
     trunc: (x: FilterCols<TColEntries, number> | SQLExpr<number>, n?: number) => SQLExpr<number>;
     div: (x: FilterCols<TColEntries, number> | SQLExpr<number>, y: number) => SQLExpr<number>;
     random: () => SQLExpr<number>;
+    jsonExtract: (col: FilterJsonCols<TColEntries> | SQLExpr<JSONValue>, path: string) => SQLExpr<JSONValue>;
+    jsonArray: (args_0: SQLExpr<unknown> | ColName<TColEntries>, ...args: (SQLExpr<unknown> | ColName<TColEntries>)[]) => SQLExpr<JSONValue[]>;
+    jsonObject: (pairs: [string, ColName<TColEntries> | SQLExpr<unknown>][]) => SQLExpr<JSONObject>;
     cast: <T extends keyof PgCastTypeMap>(expr: ColName<TColEntries> | SQLExpr<unknown>, type: T) => SQLExpr<PgCastTypeMap[T]>;
 };
 type DialectFns<TColEntries extends [string, unknown] = never, _TCriteria extends object = object> = ReturnType<typeof postgresqlContextFns<TColEntries>>;

package/dist/extend/dialects/postgresql.js

@@ -4,6 +4,12 @@ function sqlExpr(sql) {
     return sql;
   } };
 }
+var DISTINCT_BRAND = Symbol("sqlDistinct");
+function sqlDistinct(sql) {
+  return { sql, [DISTINCT_BRAND]: true, toString() {
+    return sql;
+  } };
+}
 function resolveArg(arg, quoteFn) {
   if (typeof arg !== "string") return arg.sql;
   return quoteFn(arg);
@@ -11,6 +17,7 @@ function resolveArg(arg, quoteFn) {
 
 // src/dialects/shared.ts
 var esc = (s) => s.replace(/'/g, "''");
+var flattenJsonObjectPairs = (pairs, quoteFn) => pairs.flatMap(([k, v]) => [`'${esc(k)}'`, resolveArg(v, quoteFn)]);
 
 // src/dialects/postgresql.ts
 var PG_CAST_TYPES = /* @__PURE__ */ new Set(["INTEGER", "TEXT", "BIGINT", "BOOLEAN", "REAL", "NUMERIC", "DATE", "TIMESTAMP", "JSON", "JSONB"]);
@@ -18,11 +25,12 @@ var postgresqlContextFns = (quoteFn) => ({
   avg: (col) => sqlExpr(`AVG(${resolveArg(col, quoteFn)})`),
   sum: (col) => sqlExpr(`SUM(${resolveArg(col, quoteFn)})`),
   countAll: () => sqlExpr("COUNT(*)"),
-  count: (col) => sqlExpr(col === "*" ? "COUNT(*)" : `COUNT(${quoteFn(col)})`),
+  count: (col) => sqlExpr(col === "*" ? "COUNT(*)" : `COUNT(${resolveArg(col, quoteFn)})`),
   countDistinct: (col) => sqlExpr(`COUNT(DISTINCT ${quoteFn(col)})`),
+  distinct: (col) => sqlDistinct(`DISTINCT ${quoteFn(col)}`),
   length: (col) => sqlExpr(`LENGTH(${resolveArg(col, quoteFn)})`),
-  stringAgg: (col, sep) => sqlExpr(`STRING_AGG(${quoteFn(col)}, '${esc(sep)}')`),
-  arrayAgg: (col) => sqlExpr(`ARRAY_AGG(${quoteFn(col)})`),
+  stringAgg: (col, sep) => sqlExpr(`STRING_AGG(${resolveArg(col, quoteFn)}, '${esc(sep)}')`),
+  arrayAgg: (col) => sqlExpr(`ARRAY_AGG(${resolveArg(col, quoteFn)})`),
   stddevPop: (col) => sqlExpr(`STDDEV_POP(${quoteFn(col)})`),
   stddevSamp: (col) => sqlExpr(`STDDEV_SAMP(${quoteFn(col)})`),
   varPop: (col) => sqlExpr(`VAR_POP(${quoteFn(col)})`),
@@ -95,6 +103,16 @@ var postgresqlContextFns = (quoteFn) => ({
   trunc: (x, n) => sqlExpr(n !== void 0 ? `TRUNC(${resolveArg(x, quoteFn)}, ${n})` : `TRUNC(${resolveArg(x, quoteFn)})`),
   div: (x, y) => sqlExpr(`DIV(${resolveArg(x, quoteFn)}, ${y})`),
   random: () => sqlExpr("RANDOM()"),
+  // ── JSON scalar fns ───────────────────────────────────────────────────────
+  /**
+   * Uses jsonb_path_query_first — requires PG 12+ (Prisma 5+ minimum).
+   * @note PG uses JSONPath syntax (e.g. `$.tags[0]`, `$.name`).
+   * MySQL/SQLite use SQL/JSON path syntax — paths are NOT cross-dialect compatible.
+   * Mismatched paths silently return NULL.
+   */
+  jsonExtract: (col, path) => sqlExpr(`jsonb_path_query_first(${resolveArg(col, quoteFn)}, '${esc(path)}')`),
+  jsonArray: (...args) => sqlExpr(`jsonb_build_array(${args.map((a) => resolveArg(a, quoteFn)).join(", ")})`),
+  jsonObject: (pairs) => sqlExpr(`jsonb_build_object(${flattenJsonObjectPairs(pairs, quoteFn).join(", ")})`),
   // ── Type coercion ────────────────────────────────────────────────────────
   cast: (expr, type) => {
     if (!PG_CAST_TYPES.has(type)) throw new Error(`cast: invalid cast type '${String(type)}'`);

package/dist/extend/dialects/shared.d.ts

@@ -1,6 +1,11 @@
+import { S as SQLExpr } from '../sql-expr-BGSEwzCi.js';
+
 declare const sharedFunctions: {};
 declare const esc: (s: string) => string;
+declare const flattenJsonObjectPairs: (pairs: [string, string | SQLExpr<unknown>][], quoteFn: (ref: string) => string) => string[];
 type FilterCols<TEntries extends [string, unknown], T> = TEntries extends [infer N extends string, infer V] ? NonNullable<V> extends T ? N : never : never;
 type ColName<TEntries extends [string, unknown]> = TEntries extends [infer N extends string, unknown] ? N : never;
+type ColTypeOf<TEntries extends [string, unknown], Col extends string> = TEntries extends [Col, infer V] ? V : never;
+type FilterJsonCols<TEntries extends [string, unknown]> = TEntries extends [infer N extends string, infer V] ? NonNullable<V> extends (string | number | boolean | Date | bigint | Buffer) ? never : N : never;
 
-export { type ColName, type FilterCols, esc, sharedFunctions };
+export { type ColName, type ColTypeOf, type FilterCols, type FilterJsonCols, esc, flattenJsonObjectPairs, sharedFunctions };

package/dist/extend/dialects/shared.js

@@ -1,5 +1,14 @@
+// src/sql-expr.ts
+function resolveArg(arg, quoteFn) {
+  if (typeof arg !== "string") return arg.sql;
+  return quoteFn(arg);
+}
+
 // src/dialects/shared.ts
-var sharedFunctions = {};
+var sharedFunctions = {
+  // Intentionally empty — placeholder for future cross-dialect functions
+};
 var esc = (s) => s.replace(/'/g, "''");
+var flattenJsonObjectPairs = (pairs, quoteFn) => pairs.flatMap(([k, v]) => [`'${esc(k)}'`, resolveArg(v, quoteFn)]);
 
-export { esc, sharedFunctions };
+export { esc, flattenJsonObjectPairs, sharedFunctions };

package/dist/extend/dialects/sqlite.d.ts

@@ -1,6 +1,8 @@
 import { Dialect } from './types.js';
-import { S as SQLExpr } from '../sql-expr-BaKWzJ-r.js';
-import { FilterCols, ColName } from './shared.js';
+import { S as SQLExpr, a as SQLDistinct, D as DISTINCT_BRAND } from '../sql-expr-BGSEwzCi.js';
+import { J as JSONValue, a as JSONObject } from '../types-B0F8m0ok.js';
+import { FilterCols, ColName, ColTypeOf, FilterJsonCols } from './shared.js';
+import '@prisma/client/runtime/client';
 
 type SqliteMinMaxResult<TColEntries extends [string, unknown], Col extends string> = TColEntries extends [Col, infer V] ? NonNullable<V> extends number ? bigint | null : V | null : never;
 type SqliteCastTypeMap = {
@@ -14,10 +16,13 @@ declare const sqliteContextFns: <TColEntries extends [string, unknown] = never,
     avg: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
     sum: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<bigint | number>;
     countAll: () => SQLExpr<bigint>;
-    count: (col: ColName<TColEntries> | "*") => SQLExpr<bigint>;
+    count: (col: ColName<TColEntries> | "*" | SQLExpr<unknown>) => SQLExpr<bigint>;
     countDistinct: (col: ColName<TColEntries>) => SQLExpr<bigint>;
+    distinct: <Col extends ColName<TColEntries>>(col: Col) => SQLDistinct<NonNullable<ColTypeOf<TColEntries, Col>>>;
     length: (col: FilterCols<TColEntries, string> | SQLExpr<string>) => SQLExpr<bigint>;
-    groupConcat: (col: ColName<TColEntries>, sep?: string) => SQLExpr<string>;
+    groupConcat: (((col: SQLDistinct<string>) => SQLExpr<string>) & ((col: ColName<TColEntries> | (SQLExpr<string> & {
+        readonly [DISTINCT_BRAND]?: never;
+    }), sep?: string) => SQLExpr<string>));
     total: (col: ColName<TColEntries>) => SQLExpr<number>;
     min: <Col extends ColName<TColEntries>>(col: Col) => SQLExpr<SqliteMinMaxResult<TColEntries, Col>>;
     max: <Col extends ColName<TColEntries>>(col: Col) => SQLExpr<SqliteMinMaxResult<TColEntries, Col>>;
@@ -54,6 +59,9 @@ declare const sqliteContextFns: <TColEntries extends [string, unknown] = never,
     log: (x: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
     log2: (x: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
     log10: (x: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
+    jsonExtract: (col: FilterJsonCols<TColEntries> | SQLExpr<JSONValue>, path: string) => SQLExpr<JSONValue>;
+    jsonArray: (args_0: SQLExpr<unknown> | ColName<TColEntries>, ...args: (SQLExpr<unknown> | ColName<TColEntries>)[]) => SQLExpr<JSONValue[]>;
+    jsonObject: (pairs: [string, ColName<TColEntries> | SQLExpr<unknown>][]) => SQLExpr<JSONObject>;
     cast: <T extends keyof SqliteCastTypeMap>(expr: ColName<TColEntries> | SQLExpr<unknown>, type: T) => SQLExpr<SqliteCastTypeMap[T]>;
 };
 type DialectFns<TColEntries extends [string, unknown] = never, TCriteria extends object = object> = ReturnType<typeof sqliteContextFns<TColEntries, TCriteria>>;

package/dist/extend/dialects/sqlite.js

@@ -4,11 +4,24 @@ function sqlExpr(sql) {
     return sql;
   } };
 }
+var DISTINCT_BRAND = Symbol("sqlDistinct");
+function sqlDistinct(sql) {
+  return { sql, [DISTINCT_BRAND]: true, toString() {
+    return sql;
+  } };
+}
+function isDistinct(val) {
+  return typeof val === "object" && val !== null && DISTINCT_BRAND in val;
+}
 function resolveArg(arg, quoteFn) {
   if (typeof arg !== "string") return arg.sql;
   return quoteFn(arg);
 }
 
+// src/dialects/shared.ts
+var esc = (s) => s.replace(/'/g, "''");
+var flattenJsonObjectPairs = (pairs, quoteFn) => pairs.flatMap(([k, v]) => [`'${esc(k)}'`, resolveArg(v, quoteFn)]);
+
 // src/dialects/sqlite.ts
 var SQLITE_CAST_TYPES = /* @__PURE__ */ new Set(["INTEGER", "TEXT", "REAL", "NUMERIC", "BLOB"]);
 var dateArg = (col, quoteFn) => {
@@ -22,11 +35,18 @@ var sqliteContextFns = (quoteFn, condFn) => ({
   sum: (col) => sqlExpr(`SUM(${resolveArg(col, quoteFn)})`),
   // Aggregate integer-result fns — SQLite returns INTEGER → bigint
   countAll: () => sqlExpr("COUNT(*)"),
-  count: (col) => sqlExpr(col === "*" ? "COUNT(*)" : `COUNT(${quoteFn(col)})`),
+  count: (col) => sqlExpr(col === "*" ? "COUNT(*)" : `COUNT(${resolveArg(col, quoteFn)})`),
   countDistinct: (col) => sqlExpr(`COUNT(DISTINCT ${quoteFn(col)})`),
+  distinct: (col) => sqlDistinct(`DISTINCT ${quoteFn(col)}`),
   // LENGTH returns INTEGER → bigint in SQLite
   length: (col) => sqlExpr(`LENGTH(${resolveArg(col, quoteFn)})`),
-  groupConcat: (col, sep) => sqlExpr(`GROUP_CONCAT(${quoteFn(col)}${sep !== void 0 ? `, '${sep.replace(/'/g, "''")}'` : ""})`),
+  groupConcat: (col, sep) => {
+    const inner = resolveArg(col, quoteFn);
+    if (isDistinct(col) && sep !== void 0) {
+      throw new Error("SQLite does not support GROUP_CONCAT(DISTINCT col, sep) \u2014 omit the separator.");
+    }
+    return sqlExpr(`GROUP_CONCAT(${inner}${sep !== void 0 ? `, '${sep.replace(/'/g, "''")}'` : ""})`);
+  },
   total: (col) => sqlExpr(`TOTAL(${quoteFn(col)})`),
   // SQLite MIN/MAX return bigint for integer columns — override base (number) return types
   min: (col) => sqlExpr(`MIN(${quoteFn(col)})`),
@@ -86,6 +106,10 @@ var sqliteContextFns = (quoteFn, condFn) => ({
   log: (x) => sqlExpr(`LOG(${resolveArg(x, quoteFn)})`),
   log2: (x) => sqlExpr(`LOG2(${resolveArg(x, quoteFn)})`),
   log10: (x) => sqlExpr(`LOG10(${resolveArg(x, quoteFn)})`),
+  // ── JSON scalar fns ───────────────────────────────────────────────────────
+  jsonExtract: (col, path) => sqlExpr(`json_extract(${resolveArg(col, quoteFn)}, '${esc(path)}')`),
+  jsonArray: (...args) => sqlExpr(`json_array(${args.map((a) => resolveArg(a, quoteFn)).join(", ")})`),
+  jsonObject: (pairs) => sqlExpr(`json_object(${flattenJsonObjectPairs(pairs, quoteFn).join(", ")})`),
   // ── Type coercion ────────────────────────────────────────────────────────
   cast: (expr, type) => {
     if (!SQLITE_CAST_TYPES.has(type)) throw new Error(`cast: invalid cast type '${String(type)}'`);

package/dist/extend/dialects/types.d.ts

@@ -8,5 +8,6 @@ type Dialect = {
 };
 declare const SUPPORTED_PROVIDERS: readonly ["sqlite", "mysql", "postgresql"];
 type SupportedProvider = typeof SUPPORTED_PROVIDERS[keyof typeof SUPPORTED_PROVIDERS];
+type FunctionRegistry = Record<string, (...args: unknown[]) => unknown>;
 
-export { type Dialect, SUPPORTED_PROVIDERS, type SupportedProvider };
+export { type Dialect, type FunctionRegistry, SUPPORTED_PROVIDERS, type SupportedProvider };

package/dist/extend/extend.d.ts

@@ -1,5 +1,5 @@
 import { Decimal } from '@prisma/client/runtime/client';
-import { S as SQLExpr, L as LitToType } from './sql-expr-BaKWzJ-r.js';
+import { S as SQLExpr, L as LitToType } from './sql-expr-BGSEwzCi.js';
 
 type PrismaClient = any;
 
@@ -21,7 +21,7 @@ type DATABASE = {
 type JSONPrimitive = string | number | boolean | null;
 type JSONValue = JSONPrimitive | JSONObject | JSONArray;
 type JSONObject = {
-    [member: string]: JSONValue;
+    [member: string]: JSONValue | undefined;
 };
 type JSONArray = Array<JSONValue>;
 type StrTypeToTSType<str> = str extends string ? (GetTSType<RemoveNullChar<str>> | IsNullable<str>) : never;
@@ -61,6 +61,7 @@ type Values = {
     withs?: Array<{
         name: string;
         sql: string;
+        columns?: string[];
     }>;
     limit?: number;
     offset?: number;
@@ -98,7 +99,7 @@ type FindColumnInFields<Column extends string, TFields extends TFieldsType, Tabl
 type IterateTables<Tables extends Array<TTableSources>, TFields extends TFieldsType, IncTName extends boolean, acc extends Record<string, any> = {}> = Tables extends [infer T extends TTableSources, ...infer Rest extends Array<TTableSources>] ? [IncTName] extends [false] ? IterateTables<Rest, TFields, IncTName, acc & TFields[T extends string ? T : T[1]]> : IterateTables<Rest, TFields, IncTName, acc & IterateTablesFromFields<T, TFields[T extends string ? T : T[1]], IncTName>> : acc;
 type GenName<T extends string, F extends unknown, IncName extends boolean> = F extends string ? [IncName] extends [false] ? F : `${T}.${F}` : never;
 type IterateTablesFromFields<Table extends TTableSources, TFields extends Record<string, string>, IncTName extends boolean> = {
-    [f in keyof TFields as GenName<Table extends string ? Table : `Come back to 6`, f, IncTName>]: TFields[f];
+    [f in keyof TFields as GenName<Table extends string ? Table : Table extends readonly [any, infer Name extends string] ? Name : never, f, IncTName>]: TFields[f];
 };
 type TablesArray2Name<TSources extends Array<TTableSources>, acc extends Array<string> = []> = TSources extends [infer T extends TTableSources, ...infer Rest extends Array<TTableSources>] ? TablesArray2Name<Rest, [...acc, GetAliasTableNames<T>]> : acc;
 type GetColumnNamesFromTable<TDBBase extends TTableSources> = TDBBase extends TVirtualTableSource ? never : keyof GetFieldsFromTable<GetRealTableNames<TDBBase>>;
@@ -109,10 +110,10 @@ type GetOtherColumns<Tables extends TArrSources> = Exclude<GetColumnsFromTables<
 declare class _fSelect<TSources extends TArrSources, TFields extends TFieldsType, TSelectRT extends Record<string, any> = {}> extends _fOrderBy<TSources, TFields, TSelectRT> {
     select<T>(fn: (ctx: SelectFnContext<TSources, TFields>) => SQLExpr<T>): _fSelect<TSources, TFields, Prettify<TSelectRT & Record<string, T>>>;
     select<T, A extends string>(fn: (ctx: SelectFnContext<TSources, TFields>) => SQLExpr<T>, alias: A): _fSelect<TSources, TFields, Prettify<TSelectRT & Record<A, T>>>;
-    select<const TSelect extends ValidSelect<TSources, TFields>>(select: TSelect): _fSelect<TSources, TFields, Prettify<TSelectRT & MergeItems<TSelect, TSources, TFields>>>;
+    select<const TSelect extends ValidSelect<TSources, TFields>>(select: TSelect): _fSelect<TSources, TFields, Prettify<TSelectRT & MergeItems<TSelect, TSources, TFields, CountKeys<TSources> extends 1 ? false : true>>>;
     select<const TSelect extends ValidSelect<TSources, TFields>, TAlias extends string>(select: TSelect, alias: TAlias): _fSelect<TSources, TFields, Prettify<TSelectRT & Record<TAlias, ExtractColumnType<TSelect, TSources, TFields>>>>;
 }
-type CountKeys<T extends Array<TTableSources>, acc extends Array<true> = []> = T extends [string, ...infer R extends Array<string>] ? CountKeys<R, [...acc, true]> : acc["length"];
+type CountKeys<T extends Array<TTableSources>, acc extends Array<true> = []> = T extends [TTableSources, ...infer R extends Array<TTableSources>] ? CountKeys<R, [...acc, true]> : acc["length"];
 type StripTablePrefix<S extends string> = S extends `${string}.${infer Col}` ? Col : S;
 declare class _fSelectDistinct<TSources extends TArrSources, TFields extends TFieldsType, TSelectRT extends Record<string, any> = {}> extends _fSelect<TSources, TFields, TSelectRT> {
     selectDistinct(): _fSelect<TSources, TFields, TSelectRT>;
@@ -264,6 +265,7 @@ type Relations<Table extends TTableSources> = Extract<DATABASE, {
 type AvailableJoins<Tables extends Array<TTableSources>, acc extends TTableSources = never> = Tables extends [infer T extends TTableSources, ...infer Rest extends Array<TTableSources>] ? AvailableJoins<Rest, acc | keyof Relations<T>> : acc;
 type GetRealTableNames<Tables extends TTableSources> = Tables extends any ? Tables extends string ? Tables : Tables[0] : never;
 type GetAliasTableNames<Tables extends TTableSources> = Tables extends any ? Tables extends string ? Tables : Tables[1] : never;
+type IsTargetCTE<TJTable> = TJTable extends TVirtualTableSource ? string : never;
 type SafeJoins<TNewJoin extends TTables, TJoins extends TArrSources, TRelations = Relations<TNewJoin>> = {
     [k in keyof TRelations as Filter<k, GetRealTableNames<TJoins[number]>>]: TRelations[k];
 };
@@ -360,7 +362,7 @@ declare class _fJoin<TSources extends TArrSources, TFields extends TFieldsType,
         where?: JoinWhereCriteria<Table, TAlias>;
         joinType?: JoinType;
     }): _fJoinReturn<[...TSources, [TAlias] extends [undefined] ? Table : [Table, TAlias]], Prettify<TFields & Record<[TAlias] extends [undefined] ? Table : TAlias, GetFieldsFromTable<Table>>>, TCTEs>;
-    join<const TableInput extends `${AvailableJoins<TSources>}` | `${AvailableJoins<TSources>} ${string}`, Table extends AvailableJoins<TSources> = ExtractTableName<TableInput> & AvailableJoins<TSources>, TAlias extends string | never = ExtractAlias<TableInput>, TJoinCols extends [string, string] = ValidStringTuple<GetUnionOfRelations<MapJoinsToKnownTables<SafeJoins<Table, TSources>, TSources>>>, TCol1 extends TJoinCols[0] = never>(table: TableInput, field: TCol1, reference: find<TJoinCols, TCol1>, options?: {
+    join<const TableInput extends `${AvailableJoins<TSources>}` | `${AvailableJoins<TSources>} ${string}`, Table extends AvailableJoins<TSources> = ExtractTableName<TableInput> & AvailableJoins<TSources>, TAlias extends string | never = ExtractAlias<TableInput>, TJoinCols extends [string, string] = ValidStringTuple<GetUnionOfRelations<MapJoinsToKnownTables<SafeJoins<Table, TSources>, TSources>>>, TJTable = Table extends keyof TCTEs ? TVirtualTableSource : [Extract<TSources[number], string>] extends [never] ? TVirtualTableSource : never, TCol1 extends (TJoinCols[0] | IsTargetCTE<TJTable>) = never>(table: TableInput, field: TCol1, reference: find<TJoinCols, TCol1> | IsTargetCTE<TJTable>, options?: {
         where?: JoinWhereCriteria<Table, TAlias>;
         joinType?: JoinType;
     }): _fJoinReturn<[...TSources, [TAlias] extends [never] ? Table : [Table, TAlias]], Prettify<TFields & Record<[TAlias] extends [never] ? Table : TAlias, GetFieldsFromTable<Table>>>, TCTEs>;
@@ -491,6 +493,7 @@ declare class DbWith<TCTEs extends Record<string, Record<string, any>>> {
     constructor(db: PrismaClient, _withs: Array<{
         name: string;
         sql: string;
+        columns?: string[];
     }>);
     with<const TName extends string, TQuery extends _fRun<any, any, any>>(name: TName, query: TQuery): DbWith<TCTEs & Record<TName, InferCTEShape<TQuery>>>;
     from<const TName extends keyof TCTEs & string>(cteName: TName): _fJoinReturn<[readonly ["__cte__", TName]], Record<TName, TCTEs[TName]>, TCTEs>;

package/dist/extend/extend.js

@@ -262,9 +262,6 @@ var I = class _I {
   }
 };
 
-// src/dialects/shared.ts
-var esc = (s2) => s2.replace(/'/g, "''");
-
 // src/sql-expr.ts
 function sqlExpr(sql) {
   return { sql, toString() {
@@ -282,6 +279,9 @@ function resolveArg(arg, quoteFn) {
   return quoteFn(arg);
 }
 
+// src/dialects/shared.ts
+var esc = (s2) => s2.replace(/'/g, "''");
+
 // src/extend.ts
 var DB = {};
 var DbSelect = class {
@@ -575,12 +575,21 @@ var _fSelect = class __fSelect extends _fOrderBy {
       }
     }
     if (alias !== void 0) {
+      if (select === "*" && this.values.tables.length > 1) {
+        throw new Error(`select("*", alias) is not supported on multi-table queries \u2014 use explicit column names or select("*") without alias`);
+      }
       const quotedSelect2 = select === "*" ? "*" : select.includes(".") ? dialect.quoteQualifiedColumn(select) : dialect.quote(select, false);
       return new __fSelect(this.db, {
         ...this.values,
         selects: [...this.values.selects, `${quotedSelect2} AS ${dialect.quote(alias, true)}`]
       });
     }
+    if (select === "*" && this.values.tables.length > 1) {
+      const expandedSelects = this.values.tables.flatMap(
+        (tableObj) => expandToQualifiedSelects(tableObj, this.values.withs)
+      );
+      return new __fSelect(this.db, { ...this.values, selects: [...this.values.selects, ...expandedSelects] });
+    }
     const quotedSelect = select === "*" ? "*" : select.includes(".") ? dialect.quoteQualifiedColumn(select) : dialect.quote(select, false);
     return new __fSelect(this.db, {
       ...this.values,
@@ -596,13 +605,7 @@ var _fSelectDistinct = class extends _fSelect {
     const selects = function(values) {
       if (values.tables && values.tables.length > 1) {
         return values.tables.reduce((acc, tableObj) => {
-          const tableIdentifier = tableObj.alias || tableObj.table;
-          const actualTable = tableObj.table;
-          if (!DB[actualTable]) return acc;
-          return acc.concat(Object.keys(DB[actualTable].fields).map((field) => {
-            const qualifiedCol = `${tableIdentifier}.${field}`;
-            return `${dialect.quoteQualifiedColumn(qualifiedCol)} AS ${dialect.quote(`${tableIdentifier}.${field}`, true)}`;
-          }));
+          return acc.concat(expandToQualifiedSelects(tableObj, values.withs));
         }, []);
       }
       const t2 = values.tables[0];
@@ -706,6 +709,9 @@ var _fWhere = class __fWhere extends _fGroupBy {
       where: [...this.values.where || [], criteriaOrFn]
     });
   }
+  /**
+   * @security NEVER pass user-supplied input. Inserts SQL verbatim into $queryRawUnsafe without parameterization.
+   */
   whereRaw(where) {
     return new _fGroupBy(this.db, {
       ...this.values,
@@ -889,15 +895,42 @@ var _fJoin = class __fJoin extends _fWhere {
     return this._joinImpl("CROSS", table);
   }
 };
+function expandToQualifiedSelects(tableObj, withs) {
+  const tId = tableObj.alias || tableObj.table;
+  if (DB[tableObj.table]) {
+    return Object.keys(DB[tableObj.table].fields).map((field) => {
+      const q = `${tId}.${field}`;
+      return `${dialect.quoteQualifiedColumn(q)} AS ${dialect.quote(q, true)}`;
+    });
+  }
+  const cte = withs?.find((w2) => w2.name === tableObj.table);
+  if (!cte?.columns?.length) throw new Error(`Cannot expand * for CTE "${tableObj.table}" \u2014 select columns explicitly`);
+  return cte.columns.map((col) => {
+    const q = `${tId}.${col}`;
+    return `${dialect.quoteQualifiedColumn(q)} AS ${dialect.quote(q, true)}`;
+  });
+}
+function extractSelectAlias(expr) {
+  const aliased = / AS ["'`](.+?)["'`]\s*$/i.exec(expr);
+  if (aliased) return aliased[1];
+  const quoted = /^["'`](.+?)["'`]$/.exec(expr);
+  if (quoted) return quoted[1];
+  if (/^\w+$/.test(expr)) return expr;
+  return null;
+}
+function extractCTEColumns(query) {
+  return query.values.selects.map(extractSelectAlias).filter((c2) => c2 !== null);
+}
 var DbWith = class _DbWith {
   constructor(db, _withs) {
     this.db = db;
     this._withs = _withs;
   }
   with(name, query) {
+    const columns = extractCTEColumns(query);
     return new _DbWith(this.db, [
       ...this._withs,
-      { name, sql: query.getSQL().replace(/;$/, "") }
+      { name, sql: query.getSQL().replace(/;$/, ""), columns }
     ]);
   }
   from(baseTableOrCTE, alias) {
@@ -916,9 +949,11 @@ var extendedPrismaClient = {
       const [base, ...aliases] = table.split(" ");
       return new DbSelect(client).from(base.trim(), aliases.join().trim() || void 0);
     },
+    /** @note `query` must be produced by the same prisma-ts-select builder instance. */
     $with(name, query) {
       const client = Prisma.getExtensionContext(this);
-      return new DbWith(client, [{ name, sql: query.getSQL().replace(/;$/, "") }]);
+      const columns = extractCTEColumns(query);
+      return new DbWith(client, [{ name, sql: query.getSQL().replace(/;$/, ""), columns }]);
     }
   }
 };

package/dist/extend/{sql-expr-BaKWzJ-r.d.ts → sql-expr-BGSEwzCi.d.ts}

@@ -4,7 +4,11 @@ type SQLExpr<T> = {
     readonly [_type]?: T;
     toString(): string;
 };
+declare const DISTINCT_BRAND: unique symbol;
+type SQLDistinct<T> = SQLExpr<T> & {
+    readonly [DISTINCT_BRAND]: true;
+};
 type LitValue = string | number | boolean | null;
 type LitToType<T extends LitValue> = T extends string ? string : T extends number ? number : T extends boolean ? number : null;
 
-export type { LitToType as L, SQLExpr as S };
+export { DISTINCT_BRAND as D, type LitToType as L, type SQLExpr as S, type SQLDistinct as a };

package/dist/extend/types-B0F8m0ok.d.ts

@@ -0,0 +1,8 @@
+import { JsonValue } from '@prisma/client/runtime/client';
+
+type JSONValue = JsonValue;
+type JSONObject = {
+    [member: string]: JSONValue | undefined;
+};
+
+export type { JSONValue as J, JSONObject as a };

package/dist/generator.cjs

@@ -1,4 +1,4 @@
 'use strict';
 
-require('./chunk-54D2J5AR.cjs');
+require('./chunk-GSIFF2TF.cjs');
 

package/dist/generator.js

@@ -1 +1 @@
-import './chunk-47KZVQLD.js';
+import './chunk-NFKUA5XM.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-ts-select",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "type": "module",
   "bin": {
     "prisma-ts-select": "dist/bin.cjs"
@@ -28,6 +28,30 @@
       }
     }
   },
+  "scripts": {
+    "bp": "pnpm build && pnpm version patch && pnpm pack",
+    "build": "pnpm exec rimraf dist && tsup",
+    "reset": "rm -rf prisma/migrations/ && prisma migrate dev --name init  && prisma generate",
+    "start": "tsx src/index.ts",
+    "prisma-upgrade": "pnpm i --save-dev prisma@latest && pnpm i @prisma/client@latest",
+    "lint:ts": "tsc --noEmit -p tsconfig.json",
+    "lint:tsw": "pnpm tsc -w",
+    "lint": "tsc --noEmit ; eslint \"scripts/**/*.{j,t}s{,x}\" --cache --max-warnings=0",
+    "lint:s": "eslint --config .eslintrc.style.json \"scripts/**/*.{j,t}s{,x}\" --cache --max-warnings=0",
+    "lint:fix": "eslint --config .eslintrc.style.json \"scripts/**/*.{j,t}s{,x}\" --cache --max-warnings=0 --fix",
+    "p:gen": "pnpm exec prisma generate",
+    "p:dbp": "pnpm exec prisma db push",
+    "p:migrate": "pnpm exec prisma migrate dev",
+    "p:update": "pnpm add -D prisma@latest && pnpm add @prisma/client@latest",
+    "test": "node --test tests/**/*.spec.ts",
+    "test:jest": "jest",
+    "2postinstall": "node src/scripts/postinstall.js",
+    "doc": "pnpm exec markdown-toc -i README.md",
+    "mdcode-ts": "pnpm exec mdcode",
+    "readme:extract": "pnpm mdcode extract README.md",
+    "readme:update": "pnpm mdcode update --transform ./transforms/readme-sql-clean.ts README.md",
+    "readme:test": "pnpm --filter usage-sqlite-v7 test -- tests/readme"
+  },
   "dependencies": {
     "@prisma/generator-helper": "^6.0.0",
     "@prisma/internals": "^6.0.0",
@@ -76,7 +100,7 @@
     "knip": "^5.9.4",
     "log-with-statusbar": "^1.2.0",
     "markdown-toc": "^1.2.0",
-    "mdcode-ts": "0.0.3-9",
+    "mdcode-ts": "^0.0.4",
     "prisma": "6.19.2",
     "prisma-dbml-generator": "^0.10.0",
     "prisma-docs-generator": "^0.8.0",
@@ -151,31 +175,5 @@
   "publishConfig": {
     "access": "public",
     "name": "prisma-ts-select"
-  },
-  "scripts": {
-    "bp": "pnpm build && pnpm version patch && pnpm pack",
-    "build": "pnpm exec rimraf dist && tsup",
-    "reset": "rm -rf prisma/migrations/ && prisma migrate dev --name init  && prisma generate",
-    "start": "tsx src/index.ts",
-    "prisma-upgrade": "pnpm i --save-dev prisma@latest && pnpm i @prisma/client@latest",
-    "lint:ts": "tsc --noEmit -p tsconfig.json",
-    "lint:tsw": "pnpm tsc -w",
-    "lint": "tsc --noEmit ; eslint \"scripts/**/*.{j,t}s{,x}\" --cache --max-warnings=0",
-    "lint:s": "eslint --config .eslintrc.style.json \"scripts/**/*.{j,t}s{,x}\" --cache --max-warnings=0",
-    "lint:fix": "eslint --config .eslintrc.style.json \"scripts/**/*.{j,t}s{,x}\" --cache --max-warnings=0 --fix",
-    "p:gen": "pnpm exec prisma generate",
-    "p:dbp": "pnpm exec prisma db push",
-    "p:migrate": "pnpm exec prisma migrate dev",
-    "p:update": "pnpm add -D prisma@latest && pnpm add @prisma/client@latest",
-    "test": "node --test tests/**/*.spec.ts",
-    "test:jest": "jest",
-    "2postinstall": "node src/scripts/postinstall.js",
-    "doc": "pnpm exec markdown-toc -i README.md",
-    "mdcode": "go run github.com/szkiba/mdcode@latest ",
-    "mdcode-ts": "pnpm exec mdcode-ts",
-    "readme:extract": "pnpm mdcode-ts extract README.md",
-    "readme:update:old": "pnpm mdcode update README.md",
-    "readme:update": "pnpm mdcode-ts update README.md",
-    "readme:test": "pnpm --filter usage-sqlite-v7 test -- tests/readme"
   }
-}
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 Adrian Elton-Browning
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/dist/extend/types-D84lxYVc.d.ts

@@ -1,5 +0,0 @@
-import { JsonValue } from '@prisma/client/runtime/client';
-
-type JSONValue = JsonValue;
-
-export type { JSONValue as J };