metal-orm 1.0.88 → 1.0.90

package/src/core/ast/query-visitor.ts

@@ -1,273 +0,0 @@
-import type {
-  CommonTableExpressionNode,
-  DerivedTableNode,
-  FunctionTableNode,
-  OrderByNode,
-  OrderingTerm,
-  SelectQueryNode,
-  SetOperationNode,
-  TableSourceNode
-} from './query.js';
-import type { JoinNode } from './join.js';
-import type {
-  ExpressionNode,
-  OperandNode,
-  ParamNode
-} from './expression-nodes.js';
-import { isOperandNode } from './expression-nodes.js';
-import {
-  hasOperandDispatcher,
-  type ExpressionVisitor,
-  type OperandVisitor,
-  visitExpression,
-  visitOperand
-} from './expression-visitor.js';
-
-export interface SelectQueryVisitor {
-  visitSelectQuery?(node: SelectQueryNode): void;
-  visitTableSource?(node: TableSourceNode): void;
-  visitDerivedTable?(node: DerivedTableNode): void;
-  visitFunctionTable?(node: FunctionTableNode): void;
-  visitJoin?(node: JoinNode): void;
-  visitCte?(node: CommonTableExpressionNode): void;
-  visitSetOperation?(node: SetOperationNode): void;
-  visitOrderBy?(node: OrderByNode): void;
-  visitExpression?(node: ExpressionNode): void;
-  visitOperand?(node: OperandNode): void;
-  visitParam?(node: ParamNode): void;
-}
-
-const getNodeType = (value: unknown): string | undefined => {
-  if (typeof value !== 'object' || value === null) return undefined;
-  const descriptor = Object.getOwnPropertyDescriptor(value, 'type');
-  if (descriptor && typeof descriptor.value === 'string') {
-    return descriptor.value;
-  }
-  if ('type' in value) {
-    const type = (value as { type?: unknown }).type;
-    return typeof type === 'string' ? type : undefined;
-  }
-  return undefined;
-};
-
-export const visitSelectQuery = (ast: SelectQueryNode, visitor: SelectQueryVisitor): void => {
-  const visitExpressionNode = (node: ExpressionNode): void => {
-    visitExpression(node, expressionVisitor);
-  };
-
-  const visitOperandNode = (node: OperandNode): void => {
-    visitOperand(node, operandVisitor);
-  };
-
-  const visitOrderingTerm = (term: OrderingTerm): void => {
-    if (!term || typeof term !== 'object') return;
-    if (isOperandNode(term)) {
-      visitOperandNode(term);
-      return;
-    }
-    const type = getNodeType(term);
-    if (type && hasOperandDispatcher(type)) {
-      visitOperandNode(term as unknown as OperandNode);
-      return;
-    }
-    if (type) {
-      visitExpressionNode(term as ExpressionNode);
-    }
-  };
-
-  const visitOrderByNode = (node: OrderByNode): void => {
-    visitor.visitOrderBy?.(node);
-    visitOrderingTerm(node.term);
-  };
-
-  const visitTableSource = (source: TableSourceNode): void => {
-    visitor.visitTableSource?.(source);
-    if (source.type === 'DerivedTable') {
-      visitor.visitDerivedTable?.(source);
-      visitSelectQuery(source.query, visitor);
-      return;
-    }
-    if (source.type === 'FunctionTable') {
-      visitor.visitFunctionTable?.(source);
-      source.args?.forEach(arg => visitOperandNode(arg));
-    }
-  };
-
-  const expressionVisitor: ExpressionVisitor<void> = {
-    visitBinaryExpression: (node) => {
-      visitor.visitExpression?.(node);
-      visitOperandNode(node.left);
-      visitOperandNode(node.right);
-      if (node.escape) {
-        visitOperandNode(node.escape);
-      }
-    },
-    visitLogicalExpression: (node) => {
-      visitor.visitExpression?.(node);
-      node.operands.forEach(operand => visitExpressionNode(operand));
-    },
-    visitNullExpression: (node) => {
-      visitor.visitExpression?.(node);
-      visitOperandNode(node.left);
-    },
-    visitInExpression: (node) => {
-      visitor.visitExpression?.(node);
-      visitOperandNode(node.left);
-      if (Array.isArray(node.right)) {
-        node.right.forEach(operand => visitOperandNode(operand));
-      } else {
-        visitOperandNode(node.right);
-      }
-    },
-    visitExistsExpression: (node) => {
-      visitor.visitExpression?.(node);
-      visitSelectQuery(node.subquery, visitor);
-    },
-    visitBetweenExpression: (node) => {
-      visitor.visitExpression?.(node);
-      visitOperandNode(node.left);
-      visitOperandNode(node.lower);
-      visitOperandNode(node.upper);
-    },
-    visitArithmeticExpression: (node) => {
-      visitor.visitExpression?.(node);
-      visitOperandNode(node.left);
-      visitOperandNode(node.right);
-    },
-    visitBitwiseExpression: (node) => {
-      visitor.visitExpression?.(node);
-      visitOperandNode(node.left);
-      visitOperandNode(node.right);
-    },
-    visitOperand: (node) => {
-      visitOperandNode(node);
-    },
-    visitSelectQuery: (node) => {
-      visitSelectQuery(node, visitor);
-    },
-    otherwise: (node) => {
-      visitor.visitExpression?.(node);
-    }
-  };
-
-  const operandVisitor: OperandVisitor<void> = {
-    visitColumn: (node) => {
-      visitor.visitOperand?.(node);
-    },
-    visitLiteral: (node) => {
-      visitor.visitOperand?.(node);
-    },
-    visitParam: (node) => {
-      visitor.visitOperand?.(node);
-      visitor.visitParam?.(node);
-    },
-    visitFunction: (node) => {
-      visitor.visitOperand?.(node);
-      node.args?.forEach(arg => visitOperandNode(arg));
-      node.orderBy?.forEach(order => visitOrderByNode(order));
-      if (node.separator) {
-        visitOperandNode(node.separator);
-      }
-    },
-    visitJsonPath: (node) => {
-      visitor.visitOperand?.(node);
-      visitOperandNode(node.column);
-    },
-    visitScalarSubquery: (node) => {
-      visitor.visitOperand?.(node);
-      visitSelectQuery(node.query, visitor);
-    },
-    visitCaseExpression: (node) => {
-      visitor.visitOperand?.(node);
-      node.conditions.forEach(cond => {
-        visitExpressionNode(cond.when);
-        visitOperandNode(cond.then);
-      });
-      if (node.else) {
-        visitOperandNode(node.else);
-      }
-    },
-    visitCast: (node) => {
-      visitor.visitOperand?.(node);
-      visitOperandNode(node.expression);
-    },
-    visitWindowFunction: (node) => {
-      visitor.visitOperand?.(node);
-      node.args?.forEach(arg => visitOperandNode(arg));
-      node.partitionBy?.forEach(term => visitOperandNode(term));
-      node.orderBy?.forEach(order => visitOrderByNode(order));
-    },
-    visitArithmeticExpression: (node) => {
-      visitor.visitOperand?.(node);
-      visitOperandNode(node.left);
-      visitOperandNode(node.right);
-    },
-    visitBitwiseExpression: (node) => {
-      visitor.visitOperand?.(node);
-      visitOperandNode(node.left);
-      visitOperandNode(node.right);
-    },
-    visitExpression: (node) => {
-      visitExpressionNode(node);
-    },
-    visitSelectQuery: (node) => {
-      visitSelectQuery(node, visitor);
-    },
-    visitCollate: (node) => {
-      visitor.visitOperand?.(node);
-      visitOperandNode(node.expression);
-    },
-    visitAliasRef: (node) => {
-      visitor.visitOperand?.(node);
-    },
-    otherwise: (node) => {
-      visitor.visitOperand?.(node);
-    }
-  };
-
-  visitor.visitSelectQuery?.(ast);
-
-  if (ast.ctes) {
-    for (const cte of ast.ctes) {
-      visitor.visitCte?.(cte);
-      visitSelectQuery(cte.query, visitor);
-    }
-  }
-
-  visitTableSource(ast.from);
-
-  ast.columns?.forEach(col => {
-    visitOperandNode(col as OperandNode);
-  });
-
-  ast.joins?.forEach(join => {
-    visitor.visitJoin?.(join);
-    visitTableSource(join.table);
-    visitExpressionNode(join.condition);
-  });
-
-  if (ast.where) {
-    visitExpressionNode(ast.where);
-  }
-
-  ast.groupBy?.forEach(term => {
-    visitOrderingTerm(term);
-  });
-
-  if (ast.having) {
-    visitExpressionNode(ast.having);
-  }
-
-  ast.orderBy?.forEach(order => {
-    visitOrderByNode(order);
-  });
-
-  ast.distinct?.forEach(col => {
-    visitOperandNode(col);
-  });
-
-  ast.setOps?.forEach(op => {
-    visitor.visitSetOperation?.(op);
-    visitSelectQuery(op.query, visitor);
-  });
-};

package/src/openapi/index.ts

@@ -1,4 +0,0 @@
-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

@@ -1,207 +0,0 @@
-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':
-      case 'Param':
-        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
-  }];
-};

package/src/openapi/schema-extractor-input.ts

@@ -1,139 +0,0 @@
-import type { TableDef } from '../schema/table.js';
-import type { RelationDef } from '../schema/relation.js';
-import { findPrimaryKey } from '../query-builder/hydration-planner.js';
-
-import type {
-  OpenApiSchema,
-  SchemaExtractionContext,
-  InputSchemaOptions,
-  JsonSchemaProperty,
-  JsonSchemaType
-} from './schema-types.js';
-import { mapColumnType, mapRelationType } from './type-mappers.js';
-import { buildCircularReferenceSchema } from './schema-extractor-utils.js';
-
-/**
- * Input schema extraction (write payloads)
- */
-export const extractInputSchema = (
-  table: TableDef,
-  context: SchemaExtractionContext,
-  options: InputSchemaOptions
-): OpenApiSchema => {
-  const cacheKey = `${table.name}:${options.mode ?? 'create'}`;
-
-  if (context.schemaCache.has(cacheKey)) {
-    return context.schemaCache.get(cacheKey)!;
-  }
-
-  if (context.visitedTables.has(cacheKey) && context.depth > 0) {
-    return buildCircularReferenceSchema(table.name, 'input');
-  }
-
-  context.visitedTables.add(cacheKey);
-
-  const properties: Record<string, JsonSchemaProperty> = {};
-  const required: string[] = [];
-  const primaryKey = findPrimaryKey(table);
-
-  for (const [columnName, column] of Object.entries(table.columns)) {
-    const isPrimary = columnName === primaryKey || column.primary;
-    if (options.excludePrimaryKey && isPrimary) continue;
-    if (options.omitReadOnly && isReadOnlyColumn(column)) continue;
-
-    properties[columnName] = mapColumnType(column, options);
-
-    if (options.mode === 'create' && isRequiredForCreate(column)) {
-      required.push(columnName);
-    }
-
-    if (options.mode === 'update' && options.requirePrimaryKey && isPrimary) {
-      required.push(columnName);
-    }
-  }
-
-  if (options.includeRelations && context.depth < context.maxDepth) {
-    for (const [relationName, relation] of Object.entries(table.relations)) {
-      properties[relationName] = extractInputRelationSchema(
-        relation,
-        { ...context, depth: context.depth + 1 },
-        options
-      );
-    }
-  }
-
-  const schema: OpenApiSchema = {
-    type: 'object',
-    properties,
-    required
-  };
-
-  context.schemaCache.set(cacheKey, schema);
-  return schema;
-};
-
-const isReadOnlyColumn = (column: { autoIncrement?: boolean; generated?: string }): boolean =>
-  Boolean(column.autoIncrement || column.generated === 'always');
-
-const isRequiredForCreate = (column: { notNull?: boolean; primary?: boolean; default?: unknown; autoIncrement?: boolean; generated?: string }): boolean => {
-  if (isReadOnlyColumn(column)) return false;
-  if (column.default !== undefined) return false;
-  return Boolean(column.notNull || column.primary);
-};
-
-const buildPrimaryKeySchema = (
-  table: TableDef,
-  options: InputSchemaOptions
-): JsonSchemaProperty => {
-  const primaryKey = findPrimaryKey(table);
-  const column = table.columns[primaryKey];
-  if (!column) {
-    return {
-      anyOf: [
-        { type: 'string' as JsonSchemaType },
-        { type: 'number' as JsonSchemaType },
-        { type: 'integer' as JsonSchemaType }
-      ]
-    };
-  }
-
-  return mapColumnType(column, options);
-};
-
-const extractInputRelationSchema = (
-  relation: RelationDef,
-  context: SchemaExtractionContext,
-  options: InputSchemaOptions
-): JsonSchemaProperty => {
-  const { type: relationType, isNullable } = mapRelationType(relation.type);
-  const relationMode = options.relationMode ?? 'mixed';
-  const allowIds = relationMode !== 'objects';
-  const allowObjects = relationMode !== 'ids';
-
-  const variants: JsonSchemaProperty[] = [];
-
-  if (allowIds) {
-    variants.push(buildPrimaryKeySchema(relation.target, options));
-  }
-
-  if (allowObjects) {
-    const targetSchema = extractInputSchema(relation.target, context, options);
-    variants.push(targetSchema as JsonSchemaProperty);
-  }
-
-  const itemSchema: JsonSchemaProperty =
-    variants.length === 1 ? variants[0] : { anyOf: variants };
-
-  if (relationType === 'array') {
-    return {
-      type: 'array',
-      items: itemSchema,
-      nullable: isNullable
-    };
-  }
-
-  return {
-    ...itemSchema,
-    nullable: isNullable
-  };
-};