metal-orm 1.0.80 → 1.0.81

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.0.80",
+  "version": "1.0.81",
   "type": "module",
   "types": "./dist/index.d.ts",
   "engines": {
@@ -59,11 +59,13 @@
   },
   "devDependencies": {
     "@electric-sql/pglite": "^0.3.14",
+    "@types/express": "^5.0.6",
     "@typescript-eslint/eslint-plugin": "^8.20.0",
     "@typescript-eslint/parser": "^8.20.0",
     "@vitest/ui": "^4.0.14",
     "eslint": "^8.57.0",
     "eslint-plugin-deprecation": "^3.0.0",
+    "express": "^5.2.1",
     "mysql-memory-server": "^1.13.0",
     "mysql2": "^3.15.3",
     "pg": "^8.16.3",

package/src/core/execution/db-executor.ts

@@ -1,10 +1,11 @@
 // src/core/execution/db-executor.ts
 
 // low-level canonical shape
-export type QueryResult = {
-  columns: string[];
-  values: unknown[][];
-};
+export type QueryResult = {
+  columns: string[];
+  values: unknown[][];
+  insertId?: number;
+};
 
 export interface DbExecutor {
   /** Capability flags so the runtime can make correct decisions without relying on optional methods. */

package/src/core/execution/executors/mysql-executor.ts

@@ -31,13 +31,15 @@ export function createMysqlExecutor(
     capabilities: {
       transactions: supportsTransactions,
     },
-    async executeSql(sql, params) {
-      const [rows] = await client.query(sql, params);
-
-      if (!Array.isArray(rows)) {
-        // e.g. insert/update returning only headers, treat as no rows
-        return [{ columns: [], values: [] }];
-      }
+    async executeSql(sql, params) {
+      const [rows] = await client.query(sql, params);
+
+      if (!Array.isArray(rows)) {
+        const insertId = (rows as { insertId?: number } | null)?.insertId;
+        const normalized = typeof insertId === 'number' && insertId > 0 ? insertId : undefined;
+        // e.g. insert/update returning only headers, treat as no rows
+        return [{ columns: [], values: [], insertId: normalized }];
+      }
 
       const result = rowsToQueryResult(
         rows as Array<Record<string, unknown>>

package/src/openapi/index.ts

@@ -1,3 +1,4 @@
 export * from './schema-types.js';
 export * from './type-mappers.js';
 export * from './schema-extractor.js';
+export * from './query-parameters.js';

package/src/openapi/query-parameters.ts

@@ -0,0 +1,206 @@
+import type { TableDef } from '../schema/table.js';
+import {
+  isOperandNode,
+  type ExpressionNode,
+  type OperandNode,
+  type ColumnNode,
+  type FunctionNode,
+  type JsonPathNode,
+  type CaseExpressionNode,
+  type CastExpressionNode,
+  type WindowFunctionNode,
+  type ArithmeticExpressionNode,
+  type BitwiseExpressionNode,
+  type CollateExpressionNode
+} from '../core/ast/expression.js';
+import type { TableSourceNode, OrderByNode, OrderingTerm } from '../core/ast/query.js';
+import type { ColumnSchemaOptions, JsonSchemaProperty, OpenApiParameter } from './schema-types.js';
+import { mapColumnType } from './type-mappers.js';
+
+const FILTER_PARAM_NAME = 'filter';
+
+const buildRootTableNames = (table: TableDef, from?: TableSourceNode): Set<string> => {
+  const names = new Set<string>([table.name]);
+  if (from?.type === 'Table') {
+    names.add(from.name);
+    if (from.alias) names.add(from.alias);
+  }
+  return names;
+};
+
+const collectFilterColumns = (
+  expr: ExpressionNode,
+  table: TableDef,
+  rootTables: Set<string>
+): Set<string> => {
+  const columns = new Set<string>();
+
+  const recordColumn = (node: ColumnNode): void => {
+    if (!rootTables.has(node.table)) return;
+    if (node.name in table.columns) {
+      columns.add(node.name);
+    }
+  };
+
+  const visitOrderingTerm = (term: OrderingTerm): void => {
+    if (!term || typeof term !== 'object') return;
+    if (isOperandNode(term)) {
+      visitOperand(term as OperandNode);
+      return;
+    }
+    if ('type' in term) {
+      visitExpression(term as ExpressionNode);
+    }
+  };
+
+  const visitOrderBy = (orderBy: OrderByNode[] | undefined): void => {
+    if (!orderBy) return;
+    orderBy.forEach(node => visitOrderingTerm(node.term));
+  };
+
+  const visitOperand = (node: OperandNode): void => {
+    switch (node.type) {
+      case 'Column':
+        recordColumn(node as ColumnNode);
+        return;
+      case 'Function': {
+        const fn = node as FunctionNode;
+        fn.args?.forEach(visitOperand);
+        visitOrderBy(fn.orderBy);
+        if (fn.separator) visitOperand(fn.separator);
+        return;
+      }
+      case 'JsonPath': {
+        const jp = node as JsonPathNode;
+        recordColumn(jp.column);
+        return;
+      }
+      case 'ScalarSubquery':
+        return;
+      case 'CaseExpression': {
+        const cs = node as CaseExpressionNode;
+        cs.conditions.forEach(condition => {
+          visitExpression(condition.when);
+          visitOperand(condition.then);
+        });
+        if (cs.else) visitOperand(cs.else);
+        return;
+      }
+      case 'Cast': {
+        const cast = node as CastExpressionNode;
+        visitOperand(cast.expression);
+        return;
+      }
+      case 'WindowFunction': {
+        const windowFn = node as WindowFunctionNode;
+        windowFn.args?.forEach(visitOperand);
+        windowFn.partitionBy?.forEach(recordColumn);
+        visitOrderBy(windowFn.orderBy);
+        return;
+      }
+      case 'ArithmeticExpression': {
+        const arith = node as ArithmeticExpressionNode;
+        visitOperand(arith.left);
+        visitOperand(arith.right);
+        return;
+      }
+      case 'BitwiseExpression': {
+        const bitwise = node as BitwiseExpressionNode;
+        visitOperand(bitwise.left);
+        visitOperand(bitwise.right);
+        return;
+      }
+      case 'Collate': {
+        const collate = node as CollateExpressionNode;
+        visitOperand(collate.expression);
+        return;
+      }
+      case 'AliasRef':
+      case 'Literal':
+        return;
+      default:
+        return;
+    }
+  };
+
+  const visitExpression = (node: ExpressionNode): void => {
+    switch (node.type) {
+      case 'BinaryExpression':
+        visitOperand(node.left);
+        visitOperand(node.right);
+        if (node.escape) visitOperand(node.escape);
+        return;
+      case 'LogicalExpression':
+        node.operands.forEach(visitExpression);
+        return;
+      case 'NullExpression':
+        visitOperand(node.left);
+        return;
+      case 'InExpression':
+        visitOperand(node.left);
+        if (Array.isArray(node.right)) {
+          node.right.forEach(visitOperand);
+        }
+        return;
+      case 'ExistsExpression':
+        return;
+      case 'BetweenExpression':
+        visitOperand(node.left);
+        visitOperand(node.lower);
+        visitOperand(node.upper);
+        return;
+      case 'ArithmeticExpression':
+        visitOperand(node.left);
+        visitOperand(node.right);
+        return;
+      case 'BitwiseExpression':
+        visitOperand(node.left);
+        visitOperand(node.right);
+        return;
+      default:
+        return;
+    }
+  };
+
+  visitExpression(expr);
+  return columns;
+};
+
+export const buildFilterParameters = (
+  table: TableDef,
+  where: ExpressionNode | undefined,
+  from: TableSourceNode | undefined,
+  options: ColumnSchemaOptions = {}
+): OpenApiParameter[] => {
+  if (!where) return [];
+
+  const rootTables = buildRootTableNames(table, from);
+  const columnNames = collectFilterColumns(where, table, rootTables);
+
+  let schema: JsonSchemaProperty;
+  if (columnNames.size) {
+    const properties: Record<string, JsonSchemaProperty> = {};
+    for (const name of columnNames) {
+      const column = table.columns[name];
+      if (!column) continue;
+      properties[name] = mapColumnType(column, options);
+    }
+    schema = {
+      type: 'object',
+      properties
+    };
+  } else {
+    schema = {
+      type: 'object',
+      additionalProperties: true
+    };
+  }
+
+  return [{
+    name: FILTER_PARAM_NAME,
+    in: 'query',
+    style: 'deepObject',
+    explode: true,
+    schema
+  }];
+};