fix(lint): eliminate 5 bare as casts to satisfy lint:casts ratchet

CI lint:casts reported +5 net new bare casts vs merge-base:
- 3 in relational-core/src/expression.ts (createRawSql factory)
- 1 in sql-builder/src/runtime/joined-tables-impl.ts (#addJoin)
- 1 in sql-builder/src/runtime/query-impl.ts (having())

Refactor each site to remove the cast without weakening typing:
- expression.ts: rewrite createRawSql to use values.forEach (eliminates
  the values[i] cast and preserves the defence-in-depth throw on
  undefined interpolations); move the builder into a RawSqlBuilderImpl
  class so the overloaded returns() signatures live next to the wider
  implementation signature (no per-call casts needed).
- joined-tables-impl.ts: drop the redundant 'fns as Functions<QC>' cast
  (createFunctions<QC>() already returns the exact type) and prune the
  now-unused Functions import.
- query-impl.ts: pass <QC> explicitly to createAggregateFunctions so its
  return type is AggregateFunctions<QC> without needing a cast.

Signed-off-by: Serhii Tatarintsev <tatarintsev@prisma.io>

Author: SevInf

packages/2-sql/4-lanes/relational-core/src/expression.ts

@@ -228,24 +228,33 @@ function resolveInterpolation(
 export function createRawSql(adapter: RawCodecInferer): RawSqlTag {
   return (strings, ...values) => {
     const parts: (string | AstExpression | ParamRef)[] = [];
-    for (let i = 0; i < strings.length; i++) {
-      const fragment = strings[i] ?? '';
-      parts.push(fragment);
-      if (i < values.length) {
-        parts.push(resolveInterpolation(adapter, values[i] as RawSqlInterpolation));
-      }
-    }
-    return {
-      returns(spec: string | { readonly codecId: string; readonly nullable?: boolean }) {
-        const codecId = typeof spec === 'string' ? spec : spec.codecId;
-        const nullable = typeof spec === 'string' ? false : (spec.nullable ?? false);
-        const returns: ParamSpec = { codecId, nullable };
-        const node = new RawExpr({ parts, returns });
-        return {
-          returnType: { codecId, nullable },
-          buildAst: () => node,
-        } as Expression<{ codecId: string; nullable: boolean }>;
-      },
-    } as RawSqlBuilder;
+    parts.push(strings[0] ?? '');
+    values.forEach((value, i) => {
+      parts.push(resolveInterpolation(adapter, value));
+      parts.push(strings[i + 1] ?? '');
+    });
+    return new RawSqlBuilderImpl(parts);
   };
 }
+
+class RawSqlBuilderImpl implements RawSqlBuilder {
+  constructor(private readonly parts: readonly (string | AstExpression | ParamRef)[]) {}
+
+  returns<S extends string>(spec: S): Expression<{ codecId: S; nullable: false }>;
+  returns<S extends string, N extends boolean = false>(spec: {
+    readonly codecId: S;
+    readonly nullable?: N;
+  }): Expression<{ codecId: S; nullable: N }>;
+  returns(
+    spec: string | { readonly codecId: string; readonly nullable?: boolean },
+  ): Expression<{ codecId: string; nullable: boolean }> {
+    const codecId = typeof spec === 'string' ? spec : spec.codecId;
+    const nullable = typeof spec === 'string' ? false : (spec.nullable ?? false);
+    const paramSpec: ParamSpec = { codecId, nullable };
+    const node = new RawExpr({ parts: this.parts, returns: paramSpec });
+    return {
+      returnType: { codecId, nullable },
+      buildAst: () => node,
+    };
+  }
+}

packages/2-sql/4-lanes/sql-builder/src/runtime/joined-tables-impl.ts

@@ -10,7 +10,6 @@ import type {
   ExpressionBuilder,
   ExtractScopeFields,
   FieldProxy,
-  Functions,
   WithField,
   WithFields,
 } from '../expression';
@@ -179,7 +178,7 @@ export class JoinedTablesImpl<QC extends QueryContext, AvailableScope extends Sc
       ),
     ) as FieldProxy<MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>>;
     const fns = createFunctions<QC>(this.ctx.queryOperationTypes, this.ctx.rawCodecInferer);
-    const onResult = onExpr(fieldProxy, fns as Functions<QC>);
+    const onResult = onExpr(fieldProxy, fns);
     const joinAst = new JoinAst(joinType, other.buildAst(), onResult.buildAst());
 
     return new JoinedTablesImpl(

packages/2-sql/4-lanes/sql-builder/src/runtime/query-impl.ts

@@ -269,8 +269,11 @@ export class GroupedQueryImpl<
       this.state.scope as AvailableScope,
       this.state.rowFields as RowType,
     );
-    const fns = createAggregateFunctions(this.ctx.queryOperationTypes, this.ctx.rawCodecInferer);
-    const result = expr(createFieldProxy(combined), fns as AggregateFunctions<QC>);
+    const fns = createAggregateFunctions<QC>(
+      this.ctx.queryOperationTypes,
+      this.ctx.rawCodecInferer,
+    );
+    const result = expr(createFieldProxy(combined), fns);
     return new GroupedQueryImpl(cloneState(this.state, { having: result.buildAst() }), this.ctx);
   }