orchid-orm 1.78.4 → 1.78.5

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { Adapter, AfterCommitStandaloneHook, AfterHook, BrandColumnsShape, Column, ColumnSchemaConfig, ColumnsShape, ComputedOptionsConfig, ComputedOptionsFactory, CreateData, CreateManyMethodsNames, CreateMethodsNames, CreateSelf, DbSharedOptions, DbSqlMethod, DbTableOptionScopes, DefaultColumnTypes, DefaultSchemaConfig, DeleteMethodsNames, EmptyObject, FromArg, FromResult, Grant, IsQuery, IsolationLevel, MaybeArray, MergeQuery, PickQuerySelectableRelations, QueryAfterHook, QueryBeforeActionHook, QueryBeforeHook, QueryData, QueryHasWhere, QueryOrExpression, QueryReturnType, QuerySchema, QueryScopes, QueryTake, RawSqlBase, RecordUnknown, RelationConfigBase, Rls, RlsPolicy, SelectAsFnReturnType, SelectResultObj, SelectableFromShape, StorageOptions, TableData, TableDataFn, TableDataItem, TransactionOptions, UpdateData, WhereArg } from "pqb/internal";
-import { Db, Query } from "pqb";
+import { Adapter, AfterCommitStandaloneHook, AfterHook, BrandColumnsShape, Column, ColumnSchemaConfig, ColumnsShape, ComputedOptionsConfig, ComputedOptionsFactory, CreateData, CreateManyMethodsNames, CreateMethodsNames, CreateSelf, DbSharedOptions, DbSqlMethod, DbTableOptionScopes, DefaultColumnTypes, DefaultSchemaConfig, DeleteMethodsNames, EmptyObject, FromArg, FromResult, Grant, IsQuery, IsolationLevel, MaybeArray, MergeQuery, PickQuerySelectableRelations, QueryAfterHook, QueryBeforeActionHook, QueryBeforeHook, QueryCatch, QueryData, QueryHasWhere, QueryOrExpression, QueryReturnType, QuerySchema, QueryScopes, QueryThen, QueryThenShallowSimplify, RawSqlBase, RecordUnknown, RelationConfigBase, Rls, RlsPolicy, SelectAsFnReturnType, SelectResultObj, SelectableFromShape, StorageOptions, TableData, TableDataFn, TableDataItem, TransactionOptions, UpdateData, WhereArg } from "pqb/internal";
+import { Db, Expression, Query } from "pqb";
 export * from "pqb";
 interface BelongsToDataForCreate<Name extends string, FK extends string, Required, Q extends Query> {
   columns: FK;
@@ -943,10 +943,35 @@ declare function isInTransaction(this: {
 declare function afterCommit(this: {
   $qb: Db;
 }, hook: AfterCommitStandaloneHook): void;
+type OrmSelectArg = Record<string, () => SelectAsFnReturnType>;
+interface OrmSelectMethods {
+  /**
+   * Use `$select` to select independent query and expression results in a single SQL query.
+   * Each value is a callback returning a query or SQL expression. The helper returns a
+   * single-result query, so it can be awaited directly or further composed.
+   */
+  $select<Obj extends OrmSelectArg>(selection: Obj): {
+    then: QueryThenShallowSimplify<ColumnsShape.Output<SelectResultObj<Db, Obj>['result']>>;
+    catch: QueryCatch;
+  };
+}
+type RequiredPreparedParams<Params extends object> = { [K in keyof Params]-?: Exclude<Params[K], undefined>; };
+type PreparedQueryParams<Params extends object> = { [K in keyof Params]: Expression<Column.Pick.QueryColumnOfType<Params[K]>>; };
+type PreparedQueryResult<Q extends Query> = Q['then'] extends QueryThen<infer Result> ? Promise<Result> : never;
+type PreparedQueryExecutor<Params extends object, Q extends Query> = keyof Params extends never ? () => PreparedQueryResult<Q> : (params: Params) => PreparedQueryResult<Q>;
+interface OrmPrepareMethods {
+  /**
+   * Creates a query executor that builds SQL once on its first execution and
+   * reuses it as a driver prepared statement afterwards.
+   *
+   * Values closed over by `callback` are static: they are captured when the
+   * prepared query is defined. Use `Params` for values that change per call.
+   */
+  $prepare<Params extends object = {}, Q extends Query = Query>(callback: (params: PreparedQueryParams<Params>) => Q, ...invalidParams: Params extends RequiredPreparedParams<Params> ? [] : [message: 'Prepared statement parameters must be required and cannot include undefined']): PreparedQueryExecutor<Params, Q>;
+}
 interface FromQuery extends Query {
   returnType: 'all';
 }
-type OrmSelectArg = Record<string, () => SelectAsFnReturnType>;
 interface OrchidORMQueryHelper<Q extends Query, Args extends unknown[], Result> {
   <T extends Query>(q: T & {
     table: Q['table'];
@@ -1031,7 +1056,7 @@ declare const defineRls: <T extends Rls.TableConfig>(rls: T) => T;
  * Identity helper for table-local grant configuration.
  */
 declare const setGrants: <const T extends readonly Grant.TableClassGrant[]>(grants: T) => T;
-interface OrchidORMMethods {
+interface OrchidORMMethods extends OrmPrepareMethods, OrmSelectMethods {
   /**
    * @see import('pqb').QueryTransaction.prototype.transaction
    */
@@ -1116,21 +1141,6 @@ interface OrchidORMMethods {
    * @param args - SQL template literal, or an object { raw: string, values?: unknown[] }
    */
   $queryArrays: Db['queryArrays'];
-  /**
-   * Use `$select` to select independent query and expression results in a single SQL query.
-   * Each value is a callback returning a query or SQL expression. The helper returns a
-   * single-result query, so it can be awaited directly or further composed.
-   *
-   * ```ts
-   * const result = await db.$select({
-   *   userCount: () => db.user.count(),
-   *   one: () => sql<number>`1::int`,
-   * });
-   *
-   * // { userCount: number; one: number }
-   * ```
-   */
-  $select<Obj extends OrmSelectArg>(selection: Obj): QueryTake<SelectResultObj<Db, Obj>>;
   /**
    * See {@link FromMethods.from}
    */

package/dist/index.js

@@ -2616,6 +2616,81 @@ function isInTransaction() {
 function afterCommit(hook) {
 	this.$qb.afterCommit(hook);
 }
+const ormSelect = (qb) => (async (selection) => {
+	const q = qb.select(selection);
+	const [{ selectAs }] = q.q.select;
+	const values = Object.entries(selectAs);
+	if (values.every(([, val]) => val instanceof pqb_internal.ValExpression)) return Object.fromEntries(values.map(([key, expr]) => [key, expr.value]));
+	const valExpressions = {};
+	for (const [key, value] of values) if (value instanceof pqb_internal.ValExpression) {
+		valExpressions[key] = value.value;
+		delete selectAs[key];
+	}
+	const result = await q.take();
+	return Object.assign(result, valExpressions);
+});
+var PreparedParamExpression = class extends pqb.Expression {
+	constructor(key) {
+		super();
+		this.key = key;
+		this.result = { value: pqb_internal.emptyObject };
+		this.q = { expr: this };
+	}
+	makeSQL(ctx) {
+		ctx.values.push(this);
+		return `$${ctx.values.length}`;
+	}
+};
+const prepareSqlItem = (sql, params) => {
+	const values = sql.values?.map((value) => {
+		return value instanceof PreparedParamExpression ? params[value.key] : value;
+	});
+	return {
+		...sql,
+		values,
+		prepare: true
+	};
+};
+const prepareSql = (sql, params) => {
+	if ("text" in sql) return prepareSqlItem(sql, params);
+	return {
+		...sql,
+		batch: sql.batch.map((item) => prepareSqlItem(item, params))
+	};
+};
+const createPreparedParams = () => {
+	return new Proxy(Object.create(null), { get(expressions, key) {
+		if (typeof key !== "string") return;
+		let expression = expressions[key];
+		if (!expression) {
+			expression = new PreparedParamExpression(key);
+			expressions[key] = expression;
+		}
+		return expression;
+	} });
+};
+const ormPrepare = () => {
+	return ((callback) => {
+		const query = callback(createPreparedParams());
+		const emptyParams = {};
+		let prepared;
+		return (params) => {
+			let cached;
+			if (prepared) cached = prepared;
+			else {
+				const sql = query.toSQL(true);
+				cached = {
+					query: Object.create(query),
+					sql
+				};
+				prepared = cached;
+			}
+			const executionQuery = Object.create(cached.query);
+			Object.defineProperty(executionQuery, "toSQL", { value: () => prepareSql(cached.sql, params ?? emptyParams) });
+			return executionQuery.then();
+		};
+	});
+};
 /**
 * Identity helper for table row-level security configuration.
 */
@@ -2765,7 +2840,8 @@ const privateOrchidORMWithAdapter = ({ log, logger, autoPreparedStatements, noPr
 		$withRecursive: qb.withRecursive.bind(qb),
 		$withSql: qb.withSql.bind(qb),
 		$from: qb.from.bind(qb),
-		$select: ((selection) => qb.select(selection).take()),
+		$select: ormSelect(qb),
+		$prepare: ormPrepare(),
 		$close: adapter.close.bind(adapter),
 		$withOptions: qb.withOptions.bind(qb)
 	};