metal-orm 1.0.86 → 1.0.87

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.0.86",
+  "version": "1.0.87",
   "type": "module",
   "types": "./dist/index.d.ts",
   "engines": {

package/src/orm/execute.ts

@@ -24,10 +24,6 @@ import {
 
 type Row = Record<string, unknown>;
 
-type ParamOperandOptions = {
-  allowParamOperands?: boolean;
-};
-
 const flattenResults = (results: { columns: string[]; values: unknown[][] }[]): Row[] => {
   const rows: Row[] = [];
   for (const result of results) {
@@ -46,13 +42,10 @@ const flattenResults = (results: { columns: string[]; values: unknown[][] }[]):
 const executeWithContexts = async <TTable extends TableDef>(
   execCtx: ExecutionContext,
   entityCtx: EntityContext,
-  qb: SelectQueryBuilder<unknown, TTable>,
-  options?: ParamOperandOptions
+  qb: SelectQueryBuilder<unknown, TTable>
 ): Promise<EntityInstance<TTable>[]> => {
   const ast = qb.getAST();
-  const compiled = options?.allowParamOperands
-    ? execCtx.dialect.compileSelectWithOptions(ast, { allowParams: true })
-    : execCtx.dialect.compileSelect(ast);
+  const compiled = execCtx.dialect.compileSelect(ast);
   const executed = await execCtx.interceptors.run({ sql: compiled.sql, params: compiled.params }, execCtx.executor);
   const rows = flattenResults(executed);
   const lazyRelations = qb.getLazyRelations() as RelationKey<TTable>[];
@@ -75,13 +68,10 @@ const executeWithContexts = async <TTable extends TableDef>(
 
 const executePlainWithContexts = async <TTable extends TableDef>(
   execCtx: ExecutionContext,
-  qb: SelectQueryBuilder<unknown, TTable>,
-  options?: ParamOperandOptions
+  qb: SelectQueryBuilder<unknown, TTable>
 ): Promise<Record<string, unknown>[]> => {
   const ast = qb.getAST();
-  const compiled = options?.allowParamOperands
-    ? execCtx.dialect.compileSelectWithOptions(ast, { allowParams: true })
-    : execCtx.dialect.compileSelect(ast);
+  const compiled = execCtx.dialect.compileSelect(ast);
   const executed = await execCtx.interceptors.run({ sql: compiled.sql, params: compiled.params }, execCtx.executor);
   const rows = flattenResults(executed);
 
@@ -101,10 +91,9 @@ const executePlainWithContexts = async <TTable extends TableDef>(
  */
 export async function executeHydrated<TTable extends TableDef>(
   session: OrmSession,
-  qb: SelectQueryBuilder<unknown, TTable>,
-  options?: ParamOperandOptions
+  qb: SelectQueryBuilder<unknown, TTable>
 ): Promise<EntityInstance<TTable>[]> {
-  return executeWithContexts(session.getExecutionContext(), session, qb, options);
+  return executeWithContexts(session.getExecutionContext(), session, qb);
 }
 
 /**
@@ -116,10 +105,9 @@ export async function executeHydrated<TTable extends TableDef>(
  */
 export async function executeHydratedPlain<TTable extends TableDef>(
   session: OrmSession,
-  qb: SelectQueryBuilder<unknown, TTable>,
-  options?: ParamOperandOptions
+  qb: SelectQueryBuilder<unknown, TTable>
 ): Promise<Record<string, unknown>[]> {
-  return executePlainWithContexts(session.getExecutionContext(), qb, options);
+  return executePlainWithContexts(session.getExecutionContext(), qb);
 }
 
 /**
@@ -133,14 +121,13 @@ export async function executeHydratedPlain<TTable extends TableDef>(
 export async function executeHydratedWithContexts<TTable extends TableDef>(
   execCtx: ExecutionContext,
   hydCtx: HydrationContext,
-  qb: SelectQueryBuilder<unknown, TTable>,
-  options?: ParamOperandOptions
+  qb: SelectQueryBuilder<unknown, TTable>
 ): Promise<EntityInstance<TTable>[]> {
   const entityCtx = hydCtx.entityContext;
   if (!entityCtx) {
     throw new Error('Hydration context is missing an EntityContext');
   }
-  return executeWithContexts(execCtx, entityCtx, qb, options);
+  return executeWithContexts(execCtx, entityCtx, qb);
 }
 
 /**
@@ -152,10 +139,9 @@ export async function executeHydratedWithContexts<TTable extends TableDef>(
  */
 export async function executeHydratedPlainWithContexts<TTable extends TableDef>(
   execCtx: ExecutionContext,
-  qb: SelectQueryBuilder<unknown, TTable>,
-  options?: ParamOperandOptions
+  qb: SelectQueryBuilder<unknown, TTable>
 ): Promise<Record<string, unknown>[]> {
-  return executePlainWithContexts(execCtx, qb, options);
+  return executePlainWithContexts(execCtx, qb);
 }
 
 const loadLazyRelationsForTable = async <TTable extends TableDef>(

package/src/query-builder/select/select-operations.ts

@@ -15,10 +15,6 @@ export type WhereHasOptions = {
   correlate?: ExpressionNode;
 };
 
-type ParamOperandOptions = {
-  allowParamOperands?: boolean;
-};
-
 export type RelationCallback = <TChildTable extends TableDef>(
   qb: SelectQueryBuilder<unknown, TChildTable>
 ) => SelectQueryBuilder<unknown, TChildTable>;
@@ -46,8 +42,7 @@ export function applyOrderBy(
 export async function executeCount(
   context: SelectQueryBuilderContext,
   env: SelectQueryBuilderEnvironment,
-  session: OrmSession,
-  options?: ParamOperandOptions
+  session: OrmSession
 ): Promise<number> {
   const unpagedAst: SelectQueryNode = {
     ...context.state.ast,
@@ -71,9 +66,7 @@ export async function executeCount(
   };
 
   const execCtx = session.getExecutionContext();
-  const compiled = options?.allowParamOperands
-    ? execCtx.dialect.compileSelectWithOptions(countQuery, { allowParams: true })
-    : execCtx.dialect.compileSelect(countQuery);
+  const compiled = execCtx.dialect.compileSelect(countQuery);
   const results = await execCtx.interceptors.run({ sql: compiled.sql, params: compiled.params }, execCtx.executor);
   const value = results[0]?.values?.[0]?.[0];
 
@@ -97,8 +90,7 @@ export async function executePagedQuery<T, TTable extends TableDef>(
   builder: SelectQueryBuilder<T, TTable>,
   session: OrmSession,
   options: { page: number; pageSize: number },
-  countCallback: (session: OrmSession) => Promise<number>,
-  paramOptions?: ParamOperandOptions
+  countCallback: (session: OrmSession) => Promise<number>
 ): Promise<PaginatedResult<T>> {
   const { page, pageSize } = options;
 
@@ -112,7 +104,7 @@ export async function executePagedQuery<T, TTable extends TableDef>(
   const offset = (page - 1) * pageSize;
 
   const totalItems = await countCallback(session);
-  const items = await builder.limit(pageSize).offset(offset).execute(session, paramOptions);
+  const items = await builder.limit(pageSize).offset(offset).execute(session);
 
   return { items, totalItems, page, pageSize };
 }

package/src/query-builder/select.ts

@@ -86,7 +86,7 @@ type SelectionResult<TSelection extends Record<string, ColumnSelectionValue>> =
   [K in keyof TSelection]: SelectionValueType<TSelection[K]>;
 };
 
-type ParamOperandOptions = {
+type ParamOperandCompileOptions = {
   allowParamOperands?: boolean;
 };
 
@@ -734,8 +734,7 @@ export class SelectQueryBuilder<T = EntityInstance<TableDef>, TTable extends Tab
    * Validates that the query does not contain Param operands.
    * Param proxies are only for schema generation, not execution.
    */
-  private validateNoParamOperands(options?: ParamOperandOptions): void {
-    if (options?.allowParamOperands) return;
+  private validateNoParamOperands(): void {
     const ast = this.context.hydration.applyToAst(this.context.state.ast);
     const paramName = findFirstParamOperandName(ast);
     if (paramName) {
@@ -755,13 +754,13 @@ export class SelectQueryBuilder<T = EntityInstance<TableDef>, TTable extends Tab
    * // users is User[]
    * users[0] instanceof User; // true
    */
-  async execute(ctx: OrmSession, options?: ParamOperandOptions): Promise<T[]> {
-    this.validateNoParamOperands(options);
+  async execute(ctx: OrmSession): Promise<T[]> {
+    this.validateNoParamOperands();
     if (this.entityConstructor) {
-      return this.executeAs(this.entityConstructor, ctx, options) as unknown as T[];
+      return this.executeAs(this.entityConstructor, ctx) as unknown as T[];
     }
     const builder = this.ensureDefaultSelection();
-    return executeHydrated(ctx, builder, options) as unknown as T[];
+    return executeHydrated(ctx, builder) as unknown as T[];
   }
 
   /**
@@ -775,10 +774,10 @@ export class SelectQueryBuilder<T = EntityInstance<TableDef>, TTable extends Tab
    * // rows is EntityInstance<UserTable>[] (plain objects)
    * rows[0] instanceof User; // false
    */
-  async executePlain(ctx: OrmSession, options?: ParamOperandOptions): Promise<EntityInstance<TTable>[]> {
-    this.validateNoParamOperands(options);
+  async executePlain(ctx: OrmSession): Promise<EntityInstance<TTable>[]> {
+    this.validateNoParamOperands();
     const builder = this.ensureDefaultSelection();
-    const rows = await executeHydratedPlain(ctx, builder, options);
+    const rows = await executeHydratedPlain(ctx, builder);
     return rows as EntityInstance<TTable>[];
   }
 
@@ -798,12 +797,11 @@ export class SelectQueryBuilder<T = EntityInstance<TableDef>, TTable extends Tab
    */
   async executeAs<TEntity extends object>(
     entityClass: EntityConstructor<TEntity>,
-    ctx: OrmSession,
-    options?: ParamOperandOptions
+    ctx: OrmSession
   ): Promise<TEntity[]> {
-    this.validateNoParamOperands(options);
+    this.validateNoParamOperands();
     const builder = this.ensureDefaultSelection();
-    const results = await executeHydrated(ctx, builder, options);
+    const results = await executeHydrated(ctx, builder);
     return materializeAs(entityClass, results as unknown as Record<string, unknown>[]);
   }
 
@@ -813,9 +811,9 @@ export class SelectQueryBuilder<T = EntityInstance<TableDef>, TTable extends Tab
    * @example
    * const total = await qb.count(session);
    */
-  async count(session: OrmSession, options?: ParamOperandOptions): Promise<number> {
-    this.validateNoParamOperands(options);
-    return executeCount(this.context, this.env, session, options);
+  async count(session: OrmSession): Promise<number> {
+    this.validateNoParamOperands();
+    return executeCount(this.context, this.env, session);
   }
 
   /**
@@ -826,11 +824,11 @@ export class SelectQueryBuilder<T = EntityInstance<TableDef>, TTable extends Tab
    */
   async executePaged(
     session: OrmSession,
-    options: { page: number; pageSize: number } & ParamOperandOptions
+    options: { page: number; pageSize: number }
   ): Promise<PaginatedResult<T>> {
-    this.validateNoParamOperands(options);
+    this.validateNoParamOperands();
     const builder = this.ensureDefaultSelection();
-    return executePagedQuery(builder, session, options, sess => builder.count(sess, options), options);
+    return executePagedQuery(builder, session, options, sess => builder.count(sess));
   }
 
   /**
@@ -843,10 +841,10 @@ export class SelectQueryBuilder<T = EntityInstance<TableDef>, TTable extends Tab
    * const hydCtx = new HydrationContext();
    * const users = await qb.executeWithContexts(execCtx, hydCtx);
    */
-  async executeWithContexts(execCtx: ExecutionContext, hydCtx: HydrationContext, options?: ParamOperandOptions): Promise<T[]> {
-    this.validateNoParamOperands(options);
+  async executeWithContexts(execCtx: ExecutionContext, hydCtx: HydrationContext): Promise<T[]> {
+    this.validateNoParamOperands();
     const builder = this.ensureDefaultSelection();
-    const results = await executeHydratedWithContexts(execCtx, hydCtx, builder, options);
+    const results = await executeHydratedWithContexts(execCtx, hydCtx, builder);
     if (this.entityConstructor) {
       return materializeAs(this.entityConstructor, results as unknown as Record<string, unknown>[]) as unknown as T[];
     }
@@ -1115,7 +1113,7 @@ export class SelectQueryBuilder<T = EntityInstance<TableDef>, TTable extends Tab
    *   .compile('postgres');
    * console.log(compiled.sql); // SELECT "id", "name" FROM "users" WHERE "active" = true
    */
-  compile(dialect: SelectDialectInput, options?: ParamOperandOptions): CompiledQuery {
+  compile(dialect: SelectDialectInput, options?: ParamOperandCompileOptions): CompiledQuery {
     const resolved = resolveDialectInput(dialect);
     const ast = this.getAST();
     if (!options?.allowParamOperands) {
@@ -1138,7 +1136,7 @@ export class SelectQueryBuilder<T = EntityInstance<TableDef>, TTable extends Tab
    *   .toSql('postgres');
    * console.log(sql); // SELECT "id", "name" FROM "users" WHERE "active" = true
    */
-  toSql(dialect: SelectDialectInput, options?: ParamOperandOptions): string {
+  toSql(dialect: SelectDialectInput, options?: ParamOperandCompileOptions): string {
     return this.compile(dialect, options).sql;
   }