metal-orm 1.0.79 → 1.0.80

package/dist/index.js

@@ -2269,6 +2269,9 @@ var PostgresDialect = class extends SqlDialectBase {
   quoteIdentifier(id) {
     return `"${id}"`;
   }
+  formatPlaceholder(index) {
+    return `$${index}`;
+  }
   /**
    * Compiles JSON path expression using PostgreSQL syntax
    * @param node - JSON path node
@@ -6664,6 +6667,438 @@ var SelectRelationFacet = class {
   }
 };
 
+// src/openapi/type-mappers.ts
+var mapColumnType = (column) => {
+  const sqlType = normalizeType(column.type);
+  const baseSchema = mapSqlTypeToBaseSchema(sqlType, column);
+  const schema = {
+    ...baseSchema,
+    description: column.comment,
+    nullable: !column.notNull && !column.primary
+  };
+  if (column.args && sqlType === "varchar" || sqlType === "char") {
+    schema.maxLength = column.args[0];
+  }
+  if (column.args && sqlType === "decimal" || sqlType === "float") {
+    if (column.args.length >= 1) {
+      schema.minimum = -(10 ** column.args[0]);
+    }
+  }
+  if (sqlType === "enum" && column.args && column.args.length > 0) {
+    schema.enum = column.args;
+  }
+  if (column.default !== void 0) {
+    schema.default = column.default;
+  }
+  return schema;
+};
+var normalizeType = (type) => {
+  return type.toLowerCase();
+};
+var mapSqlTypeToBaseSchema = (sqlType, column) => {
+  const type = normalizeType(sqlType);
+  const hasCustomTsType = column.tsType !== void 0;
+  switch (type) {
+    case "int":
+    case "integer":
+    case "bigint":
+      return {
+        type: hasCustomTsType ? inferTypeFromTsType(column.tsType) : "integer",
+        format: type === "bigint" ? "int64" : "int32",
+        minimum: column.autoIncrement ? 1 : void 0
+      };
+    case "decimal":
+    case "float":
+    case "double":
+      return {
+        type: hasCustomTsType ? inferTypeFromTsType(column.tsType) : "number"
+      };
+    case "varchar":
+      return {
+        type: "string",
+        minLength: column.notNull ? 1 : void 0,
+        maxLength: column.args?.[0]
+      };
+    case "text":
+      return {
+        type: "string",
+        minLength: column.notNull ? 1 : void 0
+      };
+    case "char":
+      return {
+        type: "string",
+        minLength: column.notNull ? column.args?.[0] || 1 : void 0,
+        maxLength: column.args?.[0]
+      };
+    case "boolean":
+      return {
+        type: "boolean"
+      };
+    case "json":
+      return {
+        anyOf: [
+          { type: "object" },
+          { type: "array" }
+        ]
+      };
+    case "blob":
+    case "binary":
+    case "varbinary":
+      return {
+        type: "string",
+        format: "base64"
+      };
+    case "date":
+      return {
+        type: "string",
+        format: "date"
+      };
+    case "datetime":
+    case "timestamp":
+      return {
+        type: "string",
+        format: "date-time"
+      };
+    case "timestamptz":
+      return {
+        type: "string",
+        format: "date-time"
+      };
+    case "uuid":
+      return {
+        type: "string",
+        format: "uuid",
+        pattern: "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"
+      };
+    case "enum":
+      return {
+        type: "string",
+        enum: column.args || []
+      };
+    default:
+      if (column.dialectTypes?.postgres && column.dialectTypes.postgres === "bytea") {
+        return {
+          type: "string",
+          format: "base64"
+        };
+      }
+      return {
+        type: "string"
+      };
+  }
+};
+var inferTypeFromTsType = (tsType) => {
+  if (typeof tsType === "string") {
+    if (tsType === "number") return "number";
+    if (tsType === "string") return "string";
+    if (tsType === "boolean") return "boolean";
+  }
+  if (typeof tsType === "function") {
+    const typeStr = tsType.name?.toLowerCase();
+    if (typeStr === "number") return "number";
+    if (typeStr === "string") return "string";
+    if (typeStr === "boolean") return "boolean";
+    if (typeStr === "array") return "array";
+    if (typeStr === "object") return "object";
+  }
+  return "string";
+};
+var mapRelationType = (relationType) => {
+  switch (relationType) {
+    case "HAS_MANY":
+    case "BELONGS_TO_MANY":
+      return { type: "array", isNullable: false };
+    case "HAS_ONE":
+    case "BELONGS_TO":
+      return { type: "object", isNullable: true };
+    default:
+      return { type: "object", isNullable: true };
+  }
+};
+var getTemporalFormat = (sqlType) => {
+  const type = normalizeType(sqlType);
+  switch (type) {
+    case "date":
+      return "date";
+    case "datetime":
+    case "timestamp":
+    case "timestamptz":
+      return "date-time";
+    default:
+      return void 0;
+  }
+};
+
+// src/openapi/schema-extractor.ts
+var extractSchema = (table, plan, projectionNodes, options = {}) => {
+  const mode = options.mode ?? "full";
+  const context = {
+    visitedTables: /* @__PURE__ */ new Set(),
+    schemaCache: /* @__PURE__ */ new Map(),
+    depth: 0,
+    maxDepth: options.maxDepth ?? 5
+  };
+  const hasComputedFields = projectionNodes && projectionNodes.some(
+    (node) => node.type !== "Column"
+  );
+  if (hasComputedFields) {
+    return extractFromProjectionNodes(table, projectionNodes, context, options);
+  }
+  if (mode === "selected" && plan) {
+    return extractSelectedSchema(table, plan, context, options);
+  }
+  return extractFullTableSchema(table, context, options);
+};
+var extractFromProjectionNodes = (table, projectionNodes, context, options) => {
+  const properties = {};
+  const required = [];
+  for (const node of projectionNodes) {
+    if (!node || typeof node !== "object") continue;
+    const projection = node;
+    const propertyName = projection.alias ?? "";
+    if (!propertyName) continue;
+    if (projection.type === "Column") {
+      const columnNode4 = node;
+      const column = table.columns[columnNode4.name];
+      if (!column) continue;
+      const property = mapColumnType(column);
+      if (!property.description && options.includeDescriptions && column.comment) {
+        property.description = column.comment;
+      }
+      properties[propertyName] = property;
+      if (column.notNull || column.primary) {
+        required.push(propertyName);
+      }
+    } else if (projection.type === "Function" || projection.type === "WindowFunction") {
+      const fnNode = node;
+      const functionName = fnNode.fn?.toUpperCase() ?? fnNode.name?.toUpperCase() ?? "";
+      const propertySchema = projection.type === "Function" ? mapFunctionNodeToSchema(functionName) : mapWindowFunctionToSchema(functionName);
+      properties[propertyName] = propertySchema;
+      const isCountFunction = functionName === "COUNT";
+      const isWindowRankFunction = functionName === "ROW_NUMBER" || functionName === "RANK";
+      if (isCountFunction || isWindowRankFunction) {
+        required.push(propertyName);
+      }
+    } else if (projection.type === "CaseExpression") {
+      const propertySchema = {
+        type: "string",
+        description: "Computed CASE expression",
+        nullable: true
+      };
+      properties[propertyName] = propertySchema;
+    } else if (projection.type === "ScalarSubquery") {
+      const propertySchema = {
+        type: "object",
+        description: "Subquery result",
+        nullable: true
+      };
+      properties[propertyName] = propertySchema;
+    } else if (projection.type === "CastExpression") {
+      const propertySchema = {
+        type: "string",
+        description: "CAST expression result",
+        nullable: true
+      };
+      properties[propertyName] = propertySchema;
+    }
+  }
+  return {
+    type: "object",
+    properties,
+    required
+  };
+};
+var mapFunctionNodeToSchema = (functionName) => {
+  const upperName = functionName.toUpperCase();
+  switch (upperName) {
+    case "COUNT":
+    case "SUM":
+    case "AVG":
+    case "MIN":
+    case "MAX":
+      return {
+        type: "number",
+        description: `${upperName} aggregate function result`,
+        nullable: false
+      };
+    case "GROUP_CONCAT":
+    case "STRING_AGG":
+    case "ARRAY_AGG":
+      return {
+        type: "string",
+        description: `${upperName} aggregate function result`,
+        nullable: true
+      };
+    case "JSON_ARRAYAGG":
+    case "JSON_OBJECTAGG":
+      return {
+        type: "object",
+        description: `${upperName} aggregate function result`,
+        nullable: true
+      };
+    default:
+      return {
+        type: "string",
+        description: `Unknown function: ${functionName}`,
+        nullable: true
+      };
+  }
+};
+var mapWindowFunctionToSchema = (functionName) => {
+  const upperName = functionName.toUpperCase();
+  switch (upperName) {
+    case "ROW_NUMBER":
+    case "RANK":
+    case "DENSE_RANK":
+    case "NTILE":
+      return {
+        type: "integer",
+        description: `${upperName} window function result`,
+        nullable: false
+      };
+    case "LAG":
+    case "LEAD":
+    case "FIRST_VALUE":
+    case "LAST_VALUE":
+      return {
+        type: "string",
+        description: `${upperName} window function result`,
+        nullable: true
+      };
+    default:
+      return {
+        type: "string",
+        description: `Unknown window function: ${functionName}`,
+        nullable: true
+      };
+  }
+};
+var extractSelectedSchema = (table, plan, context, options) => {
+  const properties = {};
+  const required = [];
+  plan.rootColumns.forEach((columnName) => {
+    const column = table.columns[columnName];
+    if (!column) return;
+    const property = mapColumnType(column);
+    if (!property.description && options.includeDescriptions && column.comment) {
+      property.description = column.comment;
+    }
+    properties[columnName] = property;
+    if (column.notNull || column.primary) {
+      required.push(columnName);
+    }
+  });
+  plan.relations.forEach((relationPlan) => {
+    const relation = table.relations[relationPlan.name];
+    if (!relation) return;
+    const relationSchema = extractRelationSchema(
+      relation,
+      relationPlan,
+      relationPlan.columns,
+      context,
+      options
+    );
+    properties[relationPlan.name] = relationSchema;
+    const { isNullable } = mapRelationType(relation.type);
+    if (!isNullable && relationPlan.name) {
+      required.push(relationPlan.name);
+    }
+  });
+  return {
+    type: "object",
+    properties,
+    required
+  };
+};
+var extractFullTableSchema = (table, context, options) => {
+  const cacheKey = table.name;
+  if (context.schemaCache.has(cacheKey)) {
+    return context.schemaCache.get(cacheKey);
+  }
+  if (context.visitedTables.has(cacheKey) && context.depth > 0) {
+    return {
+      type: "object",
+      properties: {
+        _ref: {
+          type: "string",
+          description: `Circular reference to ${table.name}`
+        }
+      },
+      required: []
+    };
+  }
+  context.visitedTables.add(cacheKey);
+  const properties = {};
+  const required = [];
+  Object.entries(table.columns).forEach(([columnName, column]) => {
+    const property = mapColumnType(column);
+    if (!property.description && options.includeDescriptions && column.comment) {
+      property.description = column.comment;
+    }
+    properties[columnName] = property;
+    if (column.notNull || column.primary) {
+      required.push(columnName);
+    }
+  });
+  Object.entries(table.relations).forEach(([relationName, relation]) => {
+    if (context.depth >= context.maxDepth) {
+      return;
+    }
+    const relationSchema = extractRelationSchema(
+      relation,
+      void 0,
+      [],
+      { ...context, depth: context.depth + 1 },
+      options
+    );
+    properties[relationName] = relationSchema;
+    const { isNullable } = mapRelationType(relation.type);
+    if (!isNullable) {
+      required.push(relationName);
+    }
+  });
+  const schema = {
+    type: "object",
+    properties,
+    required
+  };
+  context.schemaCache.set(cacheKey, schema);
+  return schema;
+};
+var extractRelationSchema = (relation, relationPlan, selectedColumns, context, options) => {
+  const targetTable = relation.target;
+  const { type: relationType, isNullable } = mapRelationType(relation.type);
+  let targetSchema;
+  if (relationPlan && selectedColumns.length > 0) {
+    const plan = {
+      rootTable: targetTable.name,
+      rootPrimaryKey: relationPlan.targetPrimaryKey,
+      rootColumns: selectedColumns,
+      relations: []
+    };
+    targetSchema = extractSelectedSchema(targetTable, plan, context, options);
+  } else {
+    targetSchema = extractFullTableSchema(targetTable, context, options);
+  }
+  if (relationType === "array") {
+    return {
+      type: "array",
+      items: targetSchema,
+      nullable: isNullable
+    };
+  }
+  return {
+    type: "object",
+    properties: targetSchema.properties,
+    required: targetSchema.required,
+    nullable: isNullable,
+    description: targetSchema.description
+  };
+};
+var schemaToJson = (schema, pretty = false) => {
+  return JSON.stringify(schema, null, pretty ? 2 : 0);
+};
+
 // src/query-builder/select.ts
 var SelectQueryBuilder = class _SelectQueryBuilder {
   env;
@@ -7473,7 +7908,7 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
     return this.compile(dialect).sql;
   }
   /**
-   * Gets the hydration plan for the query
+   * Gets hydration plan for query
    * @returns Hydration plan or undefined if none exists
    * @example
    * const plan = qb.include('posts').getHydrationPlan();
@@ -7482,6 +7917,18 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
   getHydrationPlan() {
     return this.context.hydration.getPlan();
   }
+  /**
+   * Gets OpenAPI 3.1 JSON Schema for query result
+   * @param options - Schema generation options
+   * @returns OpenAPI 3.1 JSON Schema for query result
+   * @example
+   * const schema = qb.select('id', 'title', 'author').getSchema();
+   * console.log(JSON.stringify(schema, null, 2));
+   */
+  getSchema(options) {
+    const plan = this.context.hydration.getPlan();
+    return extractSchema(this.env.table, plan, this.context.state.ast.columns, options);
+  }
   /**
    * Gets the Abstract Syntax Tree (AST) representation of the query
    * @returns Query AST with hydration applied
@@ -8511,14 +8958,14 @@ var buildAddColumnSql = (table, colName, dialect) => {
   const rendered = renderColumnDefinition(table, column, dialect);
   return `ALTER TABLE ${dialect.formatTableName(table)} ADD ${rendered.sql};`;
 };
-var normalizeType = (value) => (value || "").toLowerCase().replace(/\s+/g, " ").trim();
+var normalizeType2 = (value) => (value || "").toLowerCase().replace(/\s+/g, " ").trim();
 var normalizeDefault = (value) => {
   if (value === void 0 || value === null) return void 0;
   return String(value).trim();
 };
 var diffColumn = (expected, actual, dialect) => {
-  const expectedType = normalizeType(dialect.renderColumnType(expected));
-  const actualType = normalizeType(actual.type);
+  const expectedType = normalizeType2(dialect.renderColumnType(expected));
+  const actualType = normalizeType2(actual.type);
   const expectedDefault = expected.default !== void 0 ? normalizeDefault(dialect.renderDefault(expected.default, expected)) : void 0;
   const actualDefault = normalizeDefault(actual.default);
   return {
@@ -12999,6 +13446,7 @@ export {
   HasMany,
   HasOne,
   InsertQueryBuilder,
+  InterceptorPipeline,
   MySqlDialect,
   Orm,
   OrmSession,
@@ -13096,6 +13544,7 @@ export {
   exists,
   exp,
   extract,
+  extractSchema,
   firstValue,
   floor,
   fromUnixTime,
@@ -13106,6 +13555,7 @@ export {
   getDecoratorMetadata,
   getSchemaIntrospector,
   getTableDefFromEntity,
+  getTemporalFormat,
   greatest,
   groupConcat,
   gt,
@@ -13161,6 +13611,8 @@ export {
   lt,
   lte,
   ltrim,
+  mapColumnType,
+  mapRelationType,
   materializeAs,
   max,
   md5,
@@ -13206,6 +13658,7 @@ export {
   rowsToQueryResult,
   rpad,
   rtrim,
+  schemaToJson,
   second,
   sel,
   selectFrom,