metal-orm 1.0.16 → 1.0.17

package/dist/index.js

@@ -237,10 +237,13 @@ var isExpressionSelectionNode = (node) => isFunctionNode(node) || isCaseExpressi
 
 // src/core/ast/expression-builders.ts
 var valueToOperand = (value) => {
-  if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return { type: "Literal", value: value === void 0 ? null : value };
+  if (isOperandNode(value)) {
+    return value;
   }
-  return value;
+  return {
+    type: "Literal",
+    value
+  };
 };
 var toNode = (col2) => {
   if (isOperandNode(col2)) return col2;
@@ -251,10 +254,11 @@ var toLiteralNode = (value) => ({
   type: "Literal",
   value
 });
+var isLiteralValue = (value) => value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+var isValueOperandInput = (value) => isOperandNode(value) || isLiteralValue(value);
 var toOperand = (val) => {
-  if (val === null) return { type: "Literal", value: null };
-  if (typeof val === "string" || typeof val === "number" || typeof val === "boolean") {
-    return { type: "Literal", value: val };
+  if (isLiteralValue(val)) {
+    return valueToOperand(val);
   }
   return toNode(val);
 };
@@ -400,6 +404,62 @@ var windowFunction = (name, args = [], partitionBy, orderBy) => {
   return buildWindowFunction(name, nodeArgs, partitionNodes, orderNodes);
 };
 
+// src/core/sql/sql.ts
+var SQL_OPERATORS = {
+  /** Equality operator */
+  EQUALS: "=",
+  /** Not equals operator */
+  NOT_EQUALS: "!=",
+  /** Greater than operator */
+  GREATER_THAN: ">",
+  /** Greater than or equal operator */
+  GREATER_OR_EQUAL: ">=",
+  /** Less than operator */
+  LESS_THAN: "<",
+  /** Less than or equal operator */
+  LESS_OR_EQUAL: "<=",
+  /** LIKE pattern matching operator */
+  LIKE: "LIKE",
+  /** NOT LIKE pattern matching operator */
+  NOT_LIKE: "NOT LIKE",
+  /** IN membership operator */
+  IN: "IN",
+  /** NOT IN membership operator */
+  NOT_IN: "NOT IN",
+  /** BETWEEN range operator */
+  BETWEEN: "BETWEEN",
+  /** NOT BETWEEN range operator */
+  NOT_BETWEEN: "NOT BETWEEN",
+  /** IS NULL null check operator */
+  IS_NULL: "IS NULL",
+  /** IS NOT NULL null check operator */
+  IS_NOT_NULL: "IS NOT NULL",
+  /** Logical AND operator */
+  AND: "AND",
+  /** Logical OR operator */
+  OR: "OR",
+  /** EXISTS operator */
+  EXISTS: "EXISTS",
+  /** NOT EXISTS operator */
+  NOT_EXISTS: "NOT EXISTS"
+};
+var JOIN_KINDS = {
+  /** INNER JOIN type */
+  INNER: "INNER",
+  /** LEFT JOIN type */
+  LEFT: "LEFT",
+  /** RIGHT JOIN type */
+  RIGHT: "RIGHT",
+  /** CROSS JOIN type */
+  CROSS: "CROSS"
+};
+var ORDER_DIRECTIONS = {
+  /** Ascending order */
+  ASC: "ASC",
+  /** Descending order */
+  DESC: "DESC"
+};
+
 // src/core/ast/aggregate-functions.ts
 var buildAggregate = (name) => (col2) => ({
   type: "Function",
@@ -409,6 +469,20 @@ var buildAggregate = (name) => (col2) => ({
 var count = buildAggregate("COUNT");
 var sum = buildAggregate("SUM");
 var avg = buildAggregate("AVG");
+var min = buildAggregate("MIN");
+var max = buildAggregate("MAX");
+var toOrderByNode = (order) => ({
+  type: "OrderBy",
+  column: columnOperand(order.column),
+  direction: order.direction ?? ORDER_DIRECTIONS.ASC
+});
+var groupConcat = (col2, options) => ({
+  type: "Function",
+  name: "GROUP_CONCAT",
+  args: [columnOperand(col2)],
+  orderBy: options?.orderBy?.map(toOrderByNode),
+  separator: options?.separator !== void 0 ? valueToOperand(options.separator) : void 0
+});
 
 // src/core/ast/expression-visitor.ts
 var expressionDispatchers = /* @__PURE__ */ new Map();
@@ -500,12 +574,17 @@ var toTableRef = (table) => ({
 });
 
 // src/core/functions/standard-strategy.ts
-var StandardFunctionStrategy = class {
+var StandardFunctionStrategy = class _StandardFunctionStrategy {
   constructor() {
     this.renderers = /* @__PURE__ */ new Map();
     this.registerStandard();
   }
   registerStandard() {
+    this.add("COUNT", ({ compiledArgs }) => `COUNT(${compiledArgs.join(", ")})`);
+    this.add("SUM", ({ compiledArgs }) => `SUM(${compiledArgs[0]})`);
+    this.add("AVG", ({ compiledArgs }) => `AVG(${compiledArgs[0]})`);
+    this.add("MIN", ({ compiledArgs }) => `MIN(${compiledArgs[0]})`);
+    this.add("MAX", ({ compiledArgs }) => `MAX(${compiledArgs[0]})`);
     this.add("ABS", ({ compiledArgs }) => `ABS(${compiledArgs[0]})`);
     this.add("UPPER", ({ compiledArgs }) => `UPPER(${compiledArgs[0]})`);
     this.add("LOWER", ({ compiledArgs }) => `LOWER(${compiledArgs[0]})`);
@@ -532,6 +611,7 @@ var StandardFunctionStrategy = class {
     this.add("DAY_OF_WEEK", ({ compiledArgs }) => `DAYOFWEEK(${compiledArgs[0]})`);
     this.add("WEEK_OF_YEAR", ({ compiledArgs }) => `WEEKOFYEAR(${compiledArgs[0]})`);
     this.add("DATE_TRUNC", ({ compiledArgs }) => `DATE_TRUNC(${compiledArgs[0]}, ${compiledArgs[1]})`);
+    this.add("GROUP_CONCAT", (ctx) => this.renderGroupConcat(ctx));
   }
   add(name, renderer) {
     this.renderers.set(name, renderer);
@@ -539,6 +619,36 @@ var StandardFunctionStrategy = class {
   getRenderer(name) {
     return this.renderers.get(name);
   }
+  renderGroupConcat(ctx) {
+    const arg = ctx.compiledArgs[0];
+    const orderClause = this.buildOrderByExpression(ctx);
+    const orderSegment = orderClause ? ` ${orderClause}` : "";
+    const separatorClause = this.formatGroupConcatSeparator(ctx);
+    return `GROUP_CONCAT(${arg}${orderSegment}${separatorClause})`;
+  }
+  buildOrderByExpression(ctx) {
+    const orderBy = ctx.node.orderBy;
+    if (!orderBy || orderBy.length === 0) {
+      return "";
+    }
+    const parts = orderBy.map((order) => `${ctx.compileOperand(order.column)} ${order.direction}`);
+    return `ORDER BY ${parts.join(", ")}`;
+  }
+  formatGroupConcatSeparator(ctx) {
+    if (!ctx.node.separator) {
+      return "";
+    }
+    return ` SEPARATOR ${ctx.compileOperand(ctx.node.separator)}`;
+  }
+  getGroupConcatSeparatorOperand(ctx) {
+    return ctx.node.separator ?? _StandardFunctionStrategy.DEFAULT_GROUP_CONCAT_SEPARATOR;
+  }
+  static {
+    this.DEFAULT_GROUP_CONCAT_SEPARATOR = {
+      type: "Literal",
+      value: ","
+    };
+  }
 };
 
 // src/core/dialect/abstract.ts
@@ -885,7 +995,11 @@ var Dialect = class _Dialect {
     const compiledArgs = fnNode.args.map((arg) => this.compileOperand(arg, ctx));
     const renderer = this.functionStrategy.getRenderer(fnNode.name);
     if (renderer) {
-      return renderer({ node: fnNode, compiledArgs });
+      return renderer({
+        node: fnNode,
+        compiledArgs,
+        compileOperand: (operand) => this.compileOperand(operand, ctx)
+      });
     }
     return `${fnNode.name}(${compiledArgs.join(", ")})`;
   }
@@ -1308,6 +1422,14 @@ var PostgresFunctionStrategy = class extends StandardFunctionStrategy {
       const partClean = String(partArg.value).replace(/['"]/g, "").toLowerCase();
       return `DATE_TRUNC('${partClean}', ${date})`;
     });
+    this.add("GROUP_CONCAT", (ctx) => {
+      const arg = ctx.compiledArgs[0];
+      const orderClause = this.buildOrderByExpression(ctx);
+      const orderSegment = orderClause ? ` ${orderClause}` : "";
+      const separatorOperand = this.getGroupConcatSeparatorOperand(ctx);
+      const separator = ctx.compileOperand(separatorOperand);
+      return `STRING_AGG(${arg}, ${separator}${orderSegment})`;
+    });
   }
 };
 
@@ -1552,6 +1674,12 @@ var SqliteFunctionStrategy = class extends StandardFunctionStrategy {
       }
       return `date(${date}, 'start of ${partClean}')`;
     });
+    this.add("GROUP_CONCAT", (ctx) => {
+      const arg = ctx.compiledArgs[0];
+      const separatorOperand = this.getGroupConcatSeparatorOperand(ctx);
+      const separator = ctx.compileOperand(separatorOperand);
+      return `GROUP_CONCAT(${arg}, ${separator})`;
+    });
   }
 };
 
@@ -1668,6 +1796,14 @@ var MssqlFunctionStrategy = class extends StandardFunctionStrategy {
       const partClean = String(partArg.value).replace(/['"]/g, "").toLowerCase();
       return `DATETRUNC(${partClean}, ${date})`;
     });
+    this.add("GROUP_CONCAT", (ctx) => {
+      const arg = ctx.compiledArgs[0];
+      const separatorOperand = this.getGroupConcatSeparatorOperand(ctx);
+      const separator = ctx.compileOperand(separatorOperand);
+      const orderClause = this.buildOrderByExpression(ctx);
+      const withinGroup = orderClause ? ` WITHIN GROUP (${orderClause})` : "";
+      return `STRING_AGG(${arg}, ${separator})${withinGroup}`;
+    });
   }
 };
 
@@ -2037,62 +2173,6 @@ var createJoinNode = (kind, tableName, condition, relationName) => ({
   meta: relationName ? { relationName } : void 0
 });
 
-// src/core/sql/sql.ts
-var SQL_OPERATORS = {
-  /** Equality operator */
-  EQUALS: "=",
-  /** Not equals operator */
-  NOT_EQUALS: "!=",
-  /** Greater than operator */
-  GREATER_THAN: ">",
-  /** Greater than or equal operator */
-  GREATER_OR_EQUAL: ">=",
-  /** Less than operator */
-  LESS_THAN: "<",
-  /** Less than or equal operator */
-  LESS_OR_EQUAL: "<=",
-  /** LIKE pattern matching operator */
-  LIKE: "LIKE",
-  /** NOT LIKE pattern matching operator */
-  NOT_LIKE: "NOT LIKE",
-  /** IN membership operator */
-  IN: "IN",
-  /** NOT IN membership operator */
-  NOT_IN: "NOT IN",
-  /** BETWEEN range operator */
-  BETWEEN: "BETWEEN",
-  /** NOT BETWEEN range operator */
-  NOT_BETWEEN: "NOT BETWEEN",
-  /** IS NULL null check operator */
-  IS_NULL: "IS NULL",
-  /** IS NOT NULL null check operator */
-  IS_NOT_NULL: "IS NOT NULL",
-  /** Logical AND operator */
-  AND: "AND",
-  /** Logical OR operator */
-  OR: "OR",
-  /** EXISTS operator */
-  EXISTS: "EXISTS",
-  /** NOT EXISTS operator */
-  NOT_EXISTS: "NOT EXISTS"
-};
-var JOIN_KINDS = {
-  /** INNER JOIN type */
-  INNER: "INNER",
-  /** LEFT JOIN type */
-  LEFT: "LEFT",
-  /** RIGHT JOIN type */
-  RIGHT: "RIGHT",
-  /** CROSS JOIN type */
-  CROSS: "CROSS"
-};
-var ORDER_DIRECTIONS = {
-  /** Ascending order */
-  ASC: "ASC",
-  /** Descending order */
-  DESC: "DESC"
-};
-
 // src/query-builder/hydration-manager.ts
 var HydrationManager = class _HydrationManager {
   /**
@@ -4220,6 +4300,21 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
   select(columns) {
     return this.clone(this.columnSelector.select(this.context, columns));
   }
+  /**
+   * Selects columns from the root table by name (typed).
+   * @param cols - Column names on the root table
+   */
+  selectColumns(...cols) {
+    const selection = {};
+    for (const key of cols) {
+      const col2 = this.env.table.columns[key];
+      if (!col2) {
+        throw new Error(`Column '${key}' not found on table '${this.env.table.name}'`);
+      }
+      selection[key] = col2;
+    }
+    return this.select(selection);
+  }
   /**
   
      * Selects raw column expressions
@@ -4380,6 +4475,47 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
     nextLazy.add(relationName);
     return this.clone(this.context, nextLazy);
   }
+  /**
+   * Selects columns for a related table in a single hop.
+   */
+  selectRelationColumns(relationName, ...cols) {
+    const relation = this.env.table.relations[relationName];
+    if (!relation) {
+      throw new Error(`Relation '${relationName}' not found on table '${this.env.table.name}'`);
+    }
+    const target = relation.target;
+    for (const col2 of cols) {
+      if (!target.columns[col2]) {
+        throw new Error(
+          `Column '${col2}' not found on related table '${target.name}' for relation '${relationName}'`
+        );
+      }
+    }
+    return this.include(relationName, { columns: cols });
+  }
+  /**
+   * Convenience alias for selecting specific columns from a relation.
+   */
+  includePick(relationName, cols) {
+    return this.selectRelationColumns(relationName, ...cols);
+  }
+  /**
+   * Selects columns for the root table and relations from a single config object.
+   */
+  selectColumnsDeep(config) {
+    let qb = this;
+    if (config.root?.length) {
+      qb = qb.selectColumns(...config.root);
+    }
+    for (const key of Object.keys(config)) {
+      if (key === "root") continue;
+      const relName = key;
+      const cols = config[relName];
+      if (!cols || !cols.length) continue;
+      qb = qb.selectRelationColumns(relName, ...cols);
+    }
+    return qb;
+  }
   getLazyRelations() {
     return Array.from(this.lazyRelations);
   }
@@ -4655,6 +4791,54 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
 var createColumn = (table, name) => ({ type: "Column", table, name });
 var createLiteral = (val) => ({ type: "Literal", value: val });
 
+// src/orm/entity-metadata.ts
+var metadataMap = /* @__PURE__ */ new Map();
+var getEntityMetadata = (target) => {
+  return metadataMap.get(target);
+};
+
+// src/decorators/bootstrap.ts
+var getTableDefFromEntity = (ctor) => {
+  const meta = getEntityMetadata(ctor);
+  if (!meta) return void 0;
+  return meta.table;
+};
+var selectFromEntity = (ctor) => {
+  const table = getTableDefFromEntity(ctor);
+  if (!table) {
+    throw new Error("Entity metadata has not been bootstrapped");
+  }
+  return new SelectQueryBuilder(table);
+};
+
+// src/query-builder/select-helpers.ts
+function sel(table, ...cols) {
+  const selection = {};
+  for (const col2 of cols) {
+    const def = table.columns[col2];
+    if (!def) {
+      throw new Error(`Column '${col2}' not found on table '${table.name}'`);
+    }
+    selection[col2] = def;
+  }
+  return selection;
+}
+function esel(entity, ...props) {
+  const table = getTableDefFromEntity(entity);
+  if (!table) {
+    throw new Error(`No table definition registered for entity '${entity.name}'`);
+  }
+  const selection = {};
+  for (const prop of props) {
+    const col2 = table.columns[prop];
+    if (!col2) {
+      throw new Error(`No column '${prop}' found for entity '${entity.name}'`);
+    }
+    selection[prop] = col2;
+  }
+  return selection;
+}
+
 // src/query-builder/insert-query-state.ts
 var InsertQueryState = class _InsertQueryState {
   constructor(table, ast) {
@@ -4673,7 +4857,15 @@ var InsertQueryState = class _InsertQueryState {
     if (!rows.length) return this;
     const definedColumns = this.ast.columns.length ? this.ast.columns : buildColumnNodes(this.table, Object.keys(rows[0]));
     const newRows = rows.map(
-      (row) => definedColumns.map((column) => valueToOperand(row[column.name]))
+      (row, rowIndex) => definedColumns.map((column) => {
+        const rawValue = row[column.name];
+        if (!isValueOperandInput(rawValue)) {
+          throw new Error(
+            `Invalid insert value for column "${column.name}" in row ${rowIndex}: only primitives, null, or OperandNodes are allowed`
+          );
+        }
+        return valueToOperand(rawValue);
+      })
     );
     return this.clone({
       ...this.ast,
@@ -4724,6 +4916,17 @@ var InsertQueryBuilder = class _InsertQueryBuilder {
 };
 
 // src/query-builder/update-query-state.ts
+var isUpdateValue = (value) => {
+  if (value === null) return true;
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean":
+      return true;
+    default:
+      return isOperandNode(value);
+  }
+};
 var UpdateQueryState = class _UpdateQueryState {
   constructor(table, ast) {
     this.table = table;
@@ -4737,14 +4940,21 @@ var UpdateQueryState = class _UpdateQueryState {
     return new _UpdateQueryState(this.table, nextAst);
   }
   withSet(values) {
-    const assignments = Object.entries(values).map(([column, value]) => ({
-      column: {
-        type: "Column",
-        table: this.table.name,
-        name: column
-      },
-      value: valueToOperand(value)
-    }));
+    const assignments = Object.entries(values).map(([column, rawValue]) => {
+      if (!isUpdateValue(rawValue)) {
+        throw new Error(
+          `Invalid update value for column "${column}": only primitives, null, or OperandNodes are allowed`
+        );
+      }
+      return {
+        column: {
+          type: "Column",
+          table: this.table.name,
+          name: column
+        },
+        value: valueToOperand(rawValue)
+      };
+    });
     return this.clone({
       ...this.ast,
       set: assignments
@@ -6012,8 +6222,8 @@ var TypeScriptGenerator = class {
       return `${key}: ${this.printOperand(operand)}`;
     });
     lines.push(`db.select({`);
-    selections.forEach((sel, index) => {
-      lines.push(`  ${sel}${index < selections.length - 1 ? "," : ""}`);
+    selections.forEach((sel2, index) => {
+      lines.push(`  ${sel2}${index < selections.length - 1 ? "," : ""}`);
     });
     lines.push(`})`);
     lines.push(`.from(${this.namingStrategy.tableToSymbol(ast.from)})`);
@@ -6296,26 +6506,6 @@ var TypeScriptGenerator = class {
   }
 };
 
-// src/orm/entity-metadata.ts
-var metadataMap = /* @__PURE__ */ new Map();
-var getEntityMetadata = (target) => {
-  return metadataMap.get(target);
-};
-
-// src/decorators/bootstrap.ts
-var getTableDefFromEntity = (ctor) => {
-  const meta = getEntityMetadata(ctor);
-  if (!meta) return void 0;
-  return meta.table;
-};
-var selectFromEntity = (ctor) => {
-  const table = getTableDefFromEntity(ctor);
-  if (!table) {
-    throw new Error("Entity metadata has not been bootstrapped");
-  }
-  return new SelectQueryBuilder(table);
-};
-
 // src/orm/identity-map.ts
 var IdentityMap = class {
   constructor() {
@@ -6528,6 +6718,7 @@ var UnitOfWork = class {
   extractColumns(table, entity) {
     const payload = {};
     for (const column of Object.keys(table.columns)) {
+      if (entity[column] === void 0) continue;
       payload[column] = entity[column];
     }
     return payload;
@@ -6582,24 +6773,30 @@ var UnitOfWork = class {
 var DomainEventBus = class {
   constructor(initialHandlers) {
     this.handlers = /* @__PURE__ */ new Map();
-    const handlers = initialHandlers ?? {};
-    Object.entries(handlers).forEach(([name, list]) => {
-      this.handlers.set(name, [...list]);
-    });
+    if (initialHandlers) {
+      for (const key in initialHandlers) {
+        const type = key;
+        const list = initialHandlers[type] ?? [];
+        this.handlers.set(type, [...list]);
+      }
+    }
   }
-  register(name, handler) {
-    const existing = this.handlers.get(name) ?? [];
+  on(type, handler) {
+    const key = type;
+    const existing = this.handlers.get(key) ?? [];
     existing.push(handler);
-    this.handlers.set(name, existing);
+    this.handlers.set(key, existing);
+  }
+  register(type, handler) {
+    this.on(type, handler);
   }
   async dispatch(trackedEntities, ctx) {
     for (const tracked of trackedEntities) {
       const entity = tracked.entity;
-      if (!entity.domainEvents || !entity.domainEvents.length) continue;
+      if (!entity.domainEvents?.length) continue;
       for (const event of entity.domainEvents) {
-        const eventName = this.getEventName(event);
-        const handlers = this.handlers.get(eventName);
-        if (!handlers) continue;
+        const handlers = this.handlers.get(event.type);
+        if (!handlers?.length) continue;
         for (const handler of handlers) {
           await handler(event, ctx);
         }
@@ -6607,11 +6804,6 @@ var DomainEventBus = class {
       entity.domainEvents = [];
     }
   }
-  getEventName(event) {
-    if (!event) return "Unknown";
-    if (typeof event === "string") return event;
-    return event.constructor?.name ?? "Unknown";
-  }
 };
 var addDomainEvent = (entity, event) => {
   if (!entity.domainEvents) {
@@ -6853,8 +7045,8 @@ var OrmSession = class {
   registerInterceptor(interceptor) {
     this.interceptors.push(interceptor);
   }
-  registerDomainEventHandler(name, handler) {
-    this.domainEvents.register(name, handler);
+  registerDomainEventHandler(type, handler) {
+    this.domainEvents.on(type, handler);
   }
   async find(entityClass, id) {
     const table = getTableDefFromEntity(entityClass);
@@ -6866,7 +7058,11 @@ var OrmSession = class {
     if (!column) {
       throw new Error("Entity table does not expose a primary key");
     }
-    const qb = selectFromEntity(entityClass).where(eq(column, id)).limit(1);
+    const columnSelections = Object.values(table.columns).reduce((acc, col2) => {
+      acc[col2.name] = col2;
+      return acc;
+    }, {});
+    const qb = selectFromEntity(entityClass).select(columnSelections).where(eq(column, id)).limit(1);
     const rows = await executeHydrated(this, qb);
     return rows[0] ?? null;
   }
@@ -6978,7 +7174,6 @@ var Orm = class {
     const executor = this.executorFactory.createExecutor(options?.tx);
     return new OrmSession({ orm: this, executor });
   }
-  // Nice convenience:
   async transaction(fn4) {
     const executor = this.executorFactory.createTransactionalExecutor();
     const session = new OrmSession({ orm: this, executor });
@@ -7169,6 +7364,7 @@ export {
   diffSchema,
   endOfMonth,
   eq,
+  esel,
   executeHydrated,
   executeHydratedWithContexts,
   exists,
@@ -7180,6 +7376,7 @@ export {
   generateCreateTableSql,
   generateSchemaSql,
   getSchemaIntrospector,
+  groupConcat,
   gt,
   gte,
   hasMany,
@@ -7194,6 +7391,7 @@ export {
   isNotNull,
   isNull,
   isOperandNode,
+  isValueOperandInput,
   isWindowFunctionNode,
   jsonPath,
   lag,
@@ -7216,6 +7414,8 @@ export {
   lt,
   lte,
   ltrim,
+  max,
+  min,
   mod,
   month,
   neq,
@@ -7246,6 +7446,7 @@ export {
   rowsToQueryResult,
   rpad,
   rtrim,
+  sel,
   sign,
   sin,
   space,