metal-orm 1.0.89 → 1.0.91

package/src/query-builder/select.ts

@@ -66,9 +66,7 @@ import { SelectProjectionFacet } from './select/projection-facet.js';
 import { SelectPredicateFacet } from './select/predicate-facet.js';
 import { SelectCTEFacet } from './select/cte-facet.js';
 import { SelectSetOpFacet } from './select/setop-facet.js';
-import { SelectRelationFacet } from './select/relation-facet.js';
-import { buildFilterParameters, extractSchema, SchemaOptions, OpenApiSchemaBundle } from '../openapi/index.js';
-import { findFirstParamOperandName } from '../core/ast/ast-validation.js';
+import { SelectRelationFacet } from './select/relation-facet.js';
 
 type ColumnSelectionValue =
   | ColumnDef
@@ -82,14 +80,10 @@ type SelectionValueType<TValue> =
   TValue extends ColumnDef ? ColumnToTs<TValue> :
   unknown;
 
-type SelectionResult<TSelection extends Record<string, ColumnSelectionValue>> = {
-  [K in keyof TSelection]: SelectionValueType<TSelection[K]>;
-};
-
-type ParamOperandCompileOptions = {
-  allowParamOperands?: boolean;
-};
-
+type SelectionResult<TSelection extends Record<string, ColumnSelectionValue>> = {
+  [K in keyof TSelection]: SelectionValueType<TSelection[K]>;
+};
+
 type SelectionFromKeys<
   TTable extends TableDef,
   K extends keyof TTable['columns'] & string
@@ -718,138 +712,120 @@ export class SelectQueryBuilder<T = EntityInstance<TableDef>, TTable extends Tab
     return this.env.table as TTable;
   }
 
-  /**
-   * Ensures that if no columns are selected, all columns from the table are selected by default.
-   */
-  private ensureDefaultSelection(): SelectQueryBuilder<T, TTable> {
-    const columns = this.context.state.ast.columns;
-    if (!columns || columns.length === 0) {
-      const columnKeys = Object.keys(this.env.table.columns) as (keyof TTable['columns'] & string)[];
-      return this.select(...columnKeys);
-    }
-    return this;
-  }
-
-  /**
-   * Validates that the query does not contain Param operands.
-   * Param proxies are only for schema generation, not execution.
-   */
-  private validateNoParamOperands(): void {
-    const ast = this.context.hydration.applyToAst(this.context.state.ast);
-    const paramName = findFirstParamOperandName(ast);
-    if (paramName) {
-      throw new Error(`Cannot execute query containing Param operand "${paramName}". Param proxies are only for schema generation (getSchema()). If you need real parameters, use literal values.`);
-    }
-  }
-
-  /**
-   * Executes the query and returns hydrated results.
-   * If the builder was created with an entity constructor (e.g. via selectFromEntity),
-   * this will automatically return fully materialized entity instances.
-   *
-   * @param ctx - ORM session context
-   * @returns Promise of entity instances (or objects if generic T is not an entity)
-   * @example
-   * const users = await selectFromEntity(User).execute(session);
-   * // users is User[]
-   * users[0] instanceof User; // true
-   */
-  async execute(ctx: OrmSession): Promise<T[]> {
-    this.validateNoParamOperands();
-    if (this.entityConstructor) {
-      return this.executeAs(this.entityConstructor, ctx) as unknown as T[];
-    }
-    const builder = this.ensureDefaultSelection();
-    return executeHydrated(ctx, builder) as unknown as T[];
-  }
-
-  /**
-   * Executes the query and returns plain row objects (POJOs), ignoring any entity materialization.
-   * Use this if you want raw data even when using selectFromEntity.
-   *
-   * @param ctx - ORM session context
-   * @returns Promise of plain entity instances
-   * @example
-   * const rows = await selectFromEntity(User).executePlain(session);
-   * // rows is EntityInstance<UserTable>[] (plain objects)
-   * rows[0] instanceof User; // false
-   */
-  async executePlain(ctx: OrmSession): Promise<EntityInstance<TTable>[]> {
-    this.validateNoParamOperands();
-    const builder = this.ensureDefaultSelection();
-    const rows = await executeHydratedPlain(ctx, builder);
-    return rows as EntityInstance<TTable>[];
-  }
-
-  /**
-   * Executes the query and returns results as real class instances.
-   * Unlike execute(), this returns actual instances of the decorated entity class
-   * with working methods and proper instanceof checks.
-   * @param entityClass - The entity class constructor
-   * @param ctx - ORM session context
-   * @returns Promise of entity class instances
-   * @example
-   * const users = await selectFromEntity(User)
-   *   .include('posts')
-   *   .executeAs(User, session);
-   * users[0] instanceof User; // true!
-   * users[0].getFullName();   // works!
-   */
-  async executeAs<TEntity extends object>(
-    entityClass: EntityConstructor<TEntity>,
-    ctx: OrmSession
-  ): Promise<TEntity[]> {
-    this.validateNoParamOperands();
-    const builder = this.ensureDefaultSelection();
-    const results = await executeHydrated(ctx, builder);
-    return materializeAs(entityClass, results as unknown as Record<string, unknown>[]);
-  }
-
-  /**
-   * Executes a count query for the current builder without LIMIT/OFFSET clauses.
-   *
-   * @example
-   * const total = await qb.count(session);
-   */
-  async count(session: OrmSession): Promise<number> {
-    this.validateNoParamOperands();
-    return executeCount(this.context, this.env, session);
-  }
-
-  /**
-   * Executes the query and returns both the paged items and the total.
-   *
-   * @example
-   * const { items, totalItems, page, pageSize } = await qb.executePaged(session, { page: 1, pageSize: 20 });
-   */
-  async executePaged(
-    session: OrmSession,
-    options: { page: number; pageSize: number }
-  ): Promise<PaginatedResult<T>> {
-    this.validateNoParamOperands();
-    const builder = this.ensureDefaultSelection();
-    return executePagedQuery(builder, session, options, sess => builder.count(sess));
-  }
-
-  /**
-   * Executes the query with provided execution and hydration contexts
-   * @param execCtx - Execution context
-   * @param hydCtx - Hydration context
-   * @returns Promise of entity instances
-   * @example
-   * const execCtx = new ExecutionContext(session);
-   * const hydCtx = new HydrationContext();
-   * const users = await qb.executeWithContexts(execCtx, hydCtx);
-   */
-  async executeWithContexts(execCtx: ExecutionContext, hydCtx: HydrationContext): Promise<T[]> {
-    this.validateNoParamOperands();
-    const builder = this.ensureDefaultSelection();
-    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[];
-    }
-    return results as unknown as T[];
-  }
+  /**
+   * Ensures that if no columns are selected, all columns from the table are selected by default.
+   */
+  private ensureDefaultSelection(): SelectQueryBuilder<T, TTable> {
+    const columns = this.context.state.ast.columns;
+    if (!columns || columns.length === 0) {
+      const columnKeys = Object.keys(this.env.table.columns) as (keyof TTable['columns'] & string)[];
+      return this.select(...columnKeys);
+    }
+    return this;
+  }
+
+  /**
+   * Executes the query and returns hydrated results.
+   * If the builder was created with an entity constructor (e.g. via selectFromEntity),
+   * this will automatically return fully materialized entity instances.
+   *
+   * @param ctx - ORM session context
+   * @returns Promise of entity instances (or objects if generic T is not an entity)
+   * @example
+   * const users = await selectFromEntity(User).execute(session);
+   * // users is User[]
+   * users[0] instanceof User; // true
+   */
+  async execute(ctx: OrmSession): Promise<T[]> {
+    if (this.entityConstructor) {
+      return this.executeAs(this.entityConstructor, ctx) as unknown as T[];
+    }
+    const builder = this.ensureDefaultSelection();
+    return executeHydrated(ctx, builder) as unknown as T[];
+  }
+
+  /**
+   * Executes the query and returns plain row objects (POJOs), ignoring any entity materialization.
+   * Use this if you want raw data even when using selectFromEntity.
+   *
+   * @param ctx - ORM session context
+   * @returns Promise of plain entity instances
+   * @example
+   * const rows = await selectFromEntity(User).executePlain(session);
+   * // rows is EntityInstance<UserTable>[] (plain objects)
+   * rows[0] instanceof User; // false
+   */
+  async executePlain(ctx: OrmSession): Promise<EntityInstance<TTable>[]> {
+    const builder = this.ensureDefaultSelection();
+    const rows = await executeHydratedPlain(ctx, builder);
+    return rows as EntityInstance<TTable>[];
+  }
+
+  /**
+   * Executes the query and returns results as real class instances.
+   * Unlike execute(), this returns actual instances of the decorated entity class
+   * with working methods and proper instanceof checks.
+   * @param entityClass - The entity class constructor
+   * @param ctx - ORM session context
+   * @returns Promise of entity class instances
+   * @example
+   * const users = await selectFromEntity(User)
+   *   .include('posts')
+   *   .executeAs(User, session);
+   * users[0] instanceof User; // true!
+   * users[0].getFullName();   // works!
+   */
+  async executeAs<TEntity extends object>(
+    entityClass: EntityConstructor<TEntity>,
+    ctx: OrmSession
+  ): Promise<TEntity[]> {
+    const builder = this.ensureDefaultSelection();
+    const results = await executeHydrated(ctx, builder);
+    return materializeAs(entityClass, results as unknown as Record<string, unknown>[]);
+  }
+
+  /**
+   * Executes a count query for the current builder without LIMIT/OFFSET clauses.
+   *
+   * @example
+   * const total = await qb.count(session);
+   */
+  async count(session: OrmSession): Promise<number> {
+    return executeCount(this.context, this.env, session);
+  }
+
+  /**
+   * Executes the query and returns both the paged items and the total.
+   *
+   * @example
+   * const { items, totalItems, page, pageSize } = await qb.executePaged(session, { page: 1, pageSize: 20 });
+   */
+  async executePaged(
+    session: OrmSession,
+    options: { page: number; pageSize: number }
+  ): Promise<PaginatedResult<T>> {
+    const builder = this.ensureDefaultSelection();
+    return executePagedQuery(builder, session, options, sess => builder.count(sess));
+  }
+
+  /**
+   * Executes the query with provided execution and hydration contexts
+   * @param execCtx - Execution context
+   * @param hydCtx - Hydration context
+   * @returns Promise of entity instances
+   * @example
+   * const execCtx = new ExecutionContext(session);
+   * const hydCtx = new HydrationContext();
+   * const users = await qb.executeWithContexts(execCtx, hydCtx);
+   */
+  async executeWithContexts(execCtx: ExecutionContext, hydCtx: HydrationContext): Promise<T[]> {
+    const builder = this.ensureDefaultSelection();
+    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[];
+    }
+    return results as unknown as T[];
+  }
 
   /**
    * Adds a WHERE condition to the query
@@ -1113,18 +1089,10 @@ 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?: ParamOperandCompileOptions): CompiledQuery {
-    const resolved = resolveDialectInput(dialect);
-    const ast = this.getAST();
-    if (!options?.allowParamOperands) {
-      const paramName = findFirstParamOperandName(ast);
-      if (paramName) {
-        throw new Error(`Cannot compile query containing Param operand "${paramName}". Param proxies are only for schema generation (getSchema()). If you need real parameters, use literal values.`);
-      }
-      return resolved.compileSelect(ast);
-    }
-    return resolved.compileSelectWithOptions(ast, { allowParams: true });
-  }
+  compile(dialect: SelectDialectInput): CompiledQuery {
+    const resolved = resolveDialectInput(dialect);
+    return resolved.compileSelect(this.getAST());
+  }
 
   /**
    * Converts the query to SQL string for a specific dialect
@@ -1136,43 +1104,20 @@ 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?: ParamOperandCompileOptions): string {
-    return this.compile(dialect, options).sql;
-  }
-
-  /**
-   * Gets hydration plan for query
-   * @returns Hydration plan or undefined if none exists
-   * @example
-   * const plan = qb.include('posts').getHydrationPlan();
-   * console.log(plan?.relations); // Information about included relations
-   */
-  getHydrationPlan(): HydrationPlan | undefined {
-    return this.context.hydration.getPlan();
-  }
-
-  /**
-   * Gets OpenAPI 3.1 JSON Schemas for query output and optional input payloads
-   * @param options - Schema generation options
-   * @returns OpenAPI 3.1 JSON Schemas for query output and input payloads
-   * @example
-   * const { output } = qb.select('id', 'title', 'author').getSchema();
-   * console.log(JSON.stringify(output, null, 2));
-   */
-  getSchema(options?: SchemaOptions): OpenApiSchemaBundle {
-    const plan = this.context.hydration.getPlan();
-    const bundle = extractSchema(this.env.table, plan, this.context.state.ast.columns, options);
-    const parameters = buildFilterParameters(
-      this.env.table,
-      this.context.state.ast.where,
-      this.context.state.ast.from,
-      options ?? {}
-    );
-    if (parameters.length) {
-      return { ...bundle, parameters };
-    }
-    return bundle;
-  }
+  toSql(dialect: SelectDialectInput): string {
+    return this.compile(dialect).sql;
+  }
+
+  /**
+   * Gets the hydration plan for the query
+   * @returns Hydration plan or undefined if none exists
+   * @example
+   * const plan = qb.include('posts').getHydrationPlan();
+   * console.log(plan?.relations); // Information about included relations
+   */
+  getHydrationPlan(): HydrationPlan | undefined {
+    return this.context.hydration.getPlan();
+  }
 
   /**
    * Gets the Abstract Syntax Tree (AST) representation of the query

package/src/schema/column-types.ts

@@ -64,7 +64,7 @@ export interface RawDefaultValue {
   raw: string;
 }
 
-export type DefaultValue = unknown | RawDefaultValue;
+export type DefaultValue = string | number | boolean | Date | null | RawDefaultValue;
 
 export interface ForeignKeyReference {
   /** Target table name */
@@ -112,7 +112,7 @@ export interface ColumnDef<T extends ColumnType = ColumnType, TRuntime = unknown
   /** Column comment/description */
   comment?: string;
   /** Additional arguments for the column type (e.g., VARCHAR length) */
-  args?: unknown[];
+  args?: (string | number)[];
   /** Table name this column belongs to (filled at runtime by defineTable) */
   table?: string;
 }
@@ -240,7 +240,7 @@ export const col = {
    * Creates a column definition with a custom SQL type.
    * Useful for dialect-specific types without polluting the standard set.
    */
-  custom: (type: string, opts: { dialect?: string; args?: unknown[]; tsType?: unknown } = {}): ColumnDef => ({
+  custom: (type: string, opts: { dialect?: string; args?: (string | number)[]; tsType?: unknown } = {}): ColumnDef => ({
     name: '',
     type,
     args: opts.args,
@@ -274,7 +274,7 @@ export const col = {
   /**
    * Sets a default value for the column
    */
-  default: <T extends ColumnType>(def: ColumnDef<T>, value: unknown): ColumnDef<T> =>
+  default: <T extends ColumnType>(def: ColumnDef<T>, value: DefaultValue): ColumnDef<T> =>
   ({
     ...def,
     default: value

package/src/schema/types.ts

@@ -19,6 +19,10 @@ export type RelationTargetTable<TRel extends RelationDef> =
   TRel extends BelongsToManyRelation<infer TTarget, TableDef> ? TTarget :
   never;
 
+export type JsonValue = string | number | boolean | null | JsonArray | JsonObject;
+export type JsonArray = Array<JsonValue>;
+export interface JsonObject { [key: string]: JsonValue }
+
 type NormalizedColumnType<T extends ColumnDef> = Lowercase<T['type'] & string>;
 
 /**
@@ -30,7 +34,7 @@ export type ColumnToTs<T extends ColumnDef> =
   NormalizedColumnType<T> extends 'bigint' ? number | bigint :
   NormalizedColumnType<T> extends 'decimal' | 'float' | 'double' ? number :
   NormalizedColumnType<T> extends 'boolean' ? boolean :
-  NormalizedColumnType<T> extends 'json' ? unknown :
+  NormalizedColumnType<T> extends 'json' ? JsonValue :
   NormalizedColumnType<T> extends 'blob' | 'binary' | 'varbinary' | 'bytea' ? Buffer :
   NormalizedColumnType<T> extends 'date' | 'datetime' | 'timestamp' | 'timestamptz' ? string :
   string

package/src/core/ast/ast-validation.ts

@@ -1,19 +0,0 @@
-import type { SelectQueryNode } from './query.js';
-import { visitSelectQuery } from './query-visitor.js';
-
-export const findFirstParamOperandName = (ast: SelectQueryNode): string | undefined => {
-  let name: string | undefined;
-
-  visitSelectQuery(ast, {
-    visitParam: (node) => {
-      if (!name) {
-        name = node.name;
-      }
-    }
-  });
-
-  return name;
-};
-
-export const hasParamOperandsInQuery = (ast: SelectQueryNode): boolean =>
-  !!findFirstParamOperandName(ast);

package/src/core/ast/param-proxy.ts

@@ -1,47 +0,0 @@
-import type { ParamNode } from './expression-nodes.js';
-
-export type ParamProxy = ParamNode & {
-  [key: string]: ParamProxy;
-};
-
-export type ParamProxyRoot = {
-  [key: string]: ParamProxy;
-};
-
-const buildParamProxy = (name: string): ParamProxy => {
-  const target: ParamNode = { type: 'Param', name };
-  return new Proxy(target, {
-    get(t, prop, receiver) {
-      if (prop === 'then') return undefined;
-      if (typeof prop === 'symbol') {
-        return Reflect.get(t, prop, receiver);
-      }
-      if (typeof prop === 'string' && prop.startsWith('$')) {
-        const trimmed = prop.slice(1);
-        const nextName = name ? `${name}.${trimmed}` : trimmed;
-        return buildParamProxy(nextName);
-      }
-      if (prop in t && name === '') {
-        return (t as unknown as Record<string, unknown>)[prop];
-      }
-      const nextName = name ? `${name}.${prop}` : prop;
-      return buildParamProxy(nextName);
-    }
-  }) as ParamProxy;
-};
-
-export const createParamProxy = (): ParamProxyRoot => {
-  const target: Record<string, unknown> = {};
-  return new Proxy(target, {
-    get(t, prop, receiver) {
-      if (prop === 'then') return undefined;
-      if (typeof prop === 'symbol') {
-        return Reflect.get(t, prop, receiver);
-      }
-      if (typeof prop === 'string' && prop.startsWith('$')) {
-        return buildParamProxy(prop.slice(1));
-      }
-      return buildParamProxy(String(prop));
-    }
-  }) as ParamProxyRoot;
-};