metal-orm 1.0.86 → 1.0.88

package/dist/index.js

@@ -6160,9 +6160,9 @@ var flattenResults = (results) => {
   }
   return rows;
 };
-var executeWithContexts = async (execCtx, entityCtx, qb, options) => {
+var executeWithContexts = async (execCtx, entityCtx, qb) => {
   const ast = qb.getAST();
-  const compiled = options?.allowParamOperands ? execCtx.dialect.compileSelectWithOptions(ast, { allowParams: true }) : execCtx.dialect.compileSelect(ast);
+  const compiled = execCtx.dialect.compileSelect(ast);
   const executed = await execCtx.interceptors.run({ sql: compiled.sql, params: compiled.params }, execCtx.executor);
   const rows = flattenResults(executed);
   const lazyRelations = qb.getLazyRelations();
@@ -6180,9 +6180,9 @@ var executeWithContexts = async (execCtx, entityCtx, qb, options) => {
   await preloadRelationIncludes(entities, includeTree);
   return entities;
 };
-var executePlainWithContexts = async (execCtx, qb, options) => {
+var executePlainWithContexts = async (execCtx, qb) => {
   const ast = qb.getAST();
-  const compiled = options?.allowParamOperands ? execCtx.dialect.compileSelectWithOptions(ast, { allowParams: true }) : execCtx.dialect.compileSelect(ast);
+  const compiled = execCtx.dialect.compileSelect(ast);
   const executed = await execCtx.interceptors.run({ sql: compiled.sql, params: compiled.params }, execCtx.executor);
   const rows = flattenResults(executed);
   if (ast.setOps && ast.setOps.length > 0) {
@@ -6190,21 +6190,21 @@ var executePlainWithContexts = async (execCtx, qb, options) => {
   }
   return hydrateRows(rows, qb.getHydrationPlan());
 };
-async function executeHydrated(session, qb, options) {
-  return executeWithContexts(session.getExecutionContext(), session, qb, options);
+async function executeHydrated(session, qb) {
+  return executeWithContexts(session.getExecutionContext(), session, qb);
 }
-async function executeHydratedPlain(session, qb, options) {
-  return executePlainWithContexts(session.getExecutionContext(), qb, options);
+async function executeHydratedPlain(session, qb) {
+  return executePlainWithContexts(session.getExecutionContext(), qb);
 }
-async function executeHydratedWithContexts(execCtx, hydCtx, qb, options) {
+async function executeHydratedWithContexts(execCtx, hydCtx, qb) {
   const entityCtx = hydCtx.entityContext;
   if (!entityCtx) {
     throw new Error("Hydration context is missing an EntityContext");
   }
-  return executeWithContexts(execCtx, entityCtx, qb, options);
+  return executeWithContexts(execCtx, entityCtx, qb);
 }
-async function executeHydratedPlainWithContexts(execCtx, qb, options) {
-  return executePlainWithContexts(execCtx, qb, options);
+async function executeHydratedPlainWithContexts(execCtx, qb) {
+  return executePlainWithContexts(execCtx, qb);
 }
 var loadLazyRelationsForTable = async (ctx, table, lazyRelations, lazyRelationOptions) => {
   if (!lazyRelations.length) return;
@@ -6405,7 +6405,7 @@ function applyOrderBy(context, predicateFacet, term, directionOrOptions) {
   const dir = options.direction ?? ORDER_DIRECTIONS.ASC;
   return predicateFacet.orderBy(context, term, dir, options.nulls, options.collation);
 }
-async function executeCount(context, env, session, options) {
+async function executeCount(context, env, session) {
   const unpagedAst = {
     ...context.state.ast,
     orderBy: void 0,
@@ -6425,7 +6425,7 @@ async function executeCount(context, env, session, options) {
     joins: []
   };
   const execCtx = session.getExecutionContext();
-  const compiled = options?.allowParamOperands ? execCtx.dialect.compileSelectWithOptions(countQuery, { allowParams: true }) : execCtx.dialect.compileSelect(countQuery);
+  const compiled = execCtx.dialect.compileSelect(countQuery);
   const results = await execCtx.interceptors.run({ sql: compiled.sql, params: compiled.params }, execCtx.executor);
   const value = results[0]?.values?.[0]?.[0];
   if (typeof value === "number") return value;
@@ -6433,7 +6433,7 @@ async function executeCount(context, env, session, options) {
   if (typeof value === "string") return Number(value);
   return value === null || value === void 0 ? 0 : Number(value);
 }
-async function executePagedQuery(builder, session, options, countCallback, paramOptions) {
+async function executePagedQuery(builder, session, options, countCallback) {
   const { page, pageSize } = options;
   if (!Number.isInteger(page) || page < 1) {
     throw new Error("executePaged: page must be an integer >= 1");
@@ -6443,7 +6443,7 @@ async function executePagedQuery(builder, session, options, countCallback, param
   }
   const offset = (page - 1) * pageSize;
   const totalItems = await countCallback(session);
-  const items = await builder.limit(pageSize).offset(offset).execute(session, paramOptions);
+  const items = await builder.limit(pageSize).offset(offset).execute(session);
   return { items, totalItems, page, pageSize };
 }
 function buildWhereHasPredicate(env, context, relationFacet, createChildBuilder, relationName, callbackOrOptions, maybeOptions, negate = false) {
@@ -6963,47 +6963,52 @@ var getTemporalFormat = (sqlType) => {
   }
 };
 
-// src/openapi/schema-extractor.ts
-var DEFAULT_MAX_DEPTH = 5;
-var extractSchema = (table, plan, projectionNodes, options = {}) => {
-  const outputOptions = resolveOutputOptions(options);
-  const outputContext = createContext(outputOptions.maxDepth ?? DEFAULT_MAX_DEPTH);
-  const output = extractOutputSchema(table, plan, projectionNodes, outputContext, outputOptions);
-  const inputOptions = resolveInputOptions(options);
-  if (!inputOptions) {
-    return { output };
+// src/openapi/schema-extractor-utils.ts
+var hasComputedProjection = (projectionNodes) => Boolean(projectionNodes && projectionNodes.some((node) => node.type !== "Column"));
+var shouldUseSelectedSchema = (options, plan, projectionNodes) => {
+  if (!plan || options.mode !== "selected") return false;
+  if (hasComputedProjection(projectionNodes)) return false;
+  if (options.refMode === "components" && options.selectedRefMode !== "components") return false;
+  return true;
+};
+var resolveComponentName = (table, options) => options.componentName ? options.componentName(table) : table.name;
+var normalizeColumns = (columns) => Array.from(new Set(columns)).sort((a, b) => a.localeCompare(b));
+var buildSelectionSignature = (plan) => {
+  const relations = plan.relations.map((relation) => ({
+    name: relation.name,
+    columns: normalizeColumns(relation.columns)
+  })).sort((a, b) => a.name.localeCompare(b.name));
+  return JSON.stringify({
+    root: normalizeColumns(plan.rootColumns),
+    relations
+  });
+};
+var hashString = (value) => {
+  let hash = 2166136261;
+  for (let i = 0; i < value.length; i += 1) {
+    hash ^= value.charCodeAt(i);
+    hash = hash * 16777619 >>> 0;
   }
-  const inputContext = createContext(inputOptions.maxDepth ?? DEFAULT_MAX_DEPTH);
-  const input = extractInputSchema(table, inputContext, inputOptions);
-  return { output, input };
+  return hash.toString(16).padStart(8, "0");
 };
-var resolveOutputOptions = (options) => ({
-  mode: options.mode ?? "full",
-  includeDescriptions: options.includeDescriptions,
-  includeEnums: options.includeEnums,
-  includeExamples: options.includeExamples,
-  includeDefaults: options.includeDefaults,
-  includeNullable: options.includeNullable,
-  maxDepth: options.maxDepth ?? DEFAULT_MAX_DEPTH
-});
-var resolveInputOptions = (options) => {
-  if (options.input === false) return void 0;
-  const input = options.input ?? {};
-  const mode = input.mode ?? "create";
-  return {
-    mode,
-    includeRelations: input.includeRelations ?? true,
-    relationMode: input.relationMode ?? "mixed",
-    includeDescriptions: input.includeDescriptions ?? options.includeDescriptions,
-    includeEnums: input.includeEnums ?? options.includeEnums,
-    includeExamples: input.includeExamples ?? options.includeExamples,
-    includeDefaults: input.includeDefaults ?? options.includeDefaults,
-    includeNullable: input.includeNullable ?? options.includeNullable,
-    maxDepth: input.maxDepth ?? options.maxDepth ?? DEFAULT_MAX_DEPTH,
-    omitReadOnly: input.omitReadOnly ?? true,
-    excludePrimaryKey: input.excludePrimaryKey ?? false,
-    requirePrimaryKey: input.requirePrimaryKey ?? mode === "update"
-  };
+var resolveSelectedComponentName = (table, plan, options) => {
+  const base = resolveComponentName(table, options);
+  const signature = buildSelectionSignature(plan);
+  return `${base}__sel_${hashString(signature)}`;
+};
+var ensureComponentRef = (table, componentName, context, schemaFactory) => {
+  if (context.components && !context.components.schemas[componentName]) {
+    if (!context.visitedTables.has(table.name)) {
+      context.components.schemas[componentName] = schemaFactory();
+    }
+  }
+  return { $ref: `#/components/schemas/${componentName}` };
+};
+var registerComponentSchema = (name, schema, context) => {
+  if (!context.components) return;
+  if (!context.components.schemas[name]) {
+    context.components.schemas[name] = schema;
+  }
 };
 var createContext = (maxDepth) => ({
   visitedTables: /* @__PURE__ */ new Set(),
@@ -7011,19 +7016,18 @@ var createContext = (maxDepth) => ({
   depth: 0,
   maxDepth
 });
-var extractOutputSchema = (table, plan, projectionNodes, context, options) => {
-  const mode = options.mode ?? "full";
-  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 buildCircularReferenceSchema = (tableName, kind) => ({
+  type: "object",
+  properties: {
+    _ref: {
+      type: "string",
+      description: `Circular ${kind} reference to ${tableName}`
+    }
+  },
+  required: []
+});
+
+// src/openapi/schema-extractor-input.ts
 var extractInputSchema = (table, context, options) => {
   const cacheKey = `${table.name}:${options.mode ?? "create"}`;
   if (context.schemaCache.has(cacheKey)) {
@@ -7111,6 +7115,18 @@ var extractInputRelationSchema = (relation, context, options) => {
     nullable: isNullable
   };
 };
+
+// src/openapi/schema-extractor-output.ts
+var extractOutputSchema = (table, plan, projectionNodes, context, options) => {
+  const hasComputedFields = hasComputedProjection(projectionNodes);
+  if (hasComputedFields) {
+    return extractFromProjectionNodes(table, projectionNodes, context, options);
+  }
+  if (shouldUseSelectedSchema(options, plan, projectionNodes)) {
+    return extractSelectedSchema(table, plan, context, options);
+  }
+  return extractFullTableSchema(table, context, options);
+};
 var extractFromProjectionNodes = (table, projectionNodes, context, options) => {
   const properties = {};
   const required = [];
@@ -7316,6 +7332,52 @@ var extractFullTableSchema = (table, context, options) => {
 var extractRelationSchema = (relation, relationPlan, selectedColumns, context, options) => {
   const targetTable = relation.target;
   const { type: relationType, isNullable } = mapRelationType(relation.type);
+  if (options.refMode === "components" && context.components) {
+    if (relationPlan && selectedColumns.length > 0 && options.selectedRefMode === "components") {
+      const plan = {
+        rootTable: targetTable.name,
+        rootPrimaryKey: relationPlan.targetPrimaryKey,
+        rootColumns: selectedColumns,
+        relations: []
+      };
+      const componentName2 = resolveSelectedComponentName(targetTable, plan, options);
+      const ref2 = ensureComponentRef(
+        targetTable,
+        componentName2,
+        context,
+        () => extractSelectedSchema(targetTable, plan, context, options)
+      );
+      if (relationType === "array") {
+        return {
+          type: "array",
+          items: ref2,
+          nullable: isNullable
+        };
+      }
+      return {
+        ...ref2,
+        nullable: isNullable
+      };
+    }
+    const componentName = resolveComponentName(targetTable, options);
+    const ref = ensureComponentRef(
+      targetTable,
+      componentName,
+      context,
+      () => extractFullTableSchema(targetTable, context, options)
+    );
+    if (relationType === "array") {
+      return {
+        type: "array",
+        items: ref,
+        nullable: isNullable
+      };
+    }
+    return {
+      ...ref,
+      nullable: isNullable
+    };
+  }
   let targetSchema;
   if (relationPlan && selectedColumns.length > 0) {
     const plan = {
@@ -7343,16 +7405,68 @@ var extractRelationSchema = (relation, relationPlan, selectedColumns, context, o
     description: targetSchema.description
   };
 };
-var buildCircularReferenceSchema = (tableName, kind) => ({
-  type: "object",
-  properties: {
-    _ref: {
-      type: "string",
-      description: `Circular ${kind} reference to ${tableName}`
-    }
-  },
-  required: []
+
+// src/openapi/schema-extractor.ts
+var DEFAULT_MAX_DEPTH = 5;
+var extractSchema = (table, plan, projectionNodes, options = {}) => {
+  const outputOptions = resolveOutputOptions(options);
+  const outputContext = createContext(outputOptions.maxDepth ?? DEFAULT_MAX_DEPTH);
+  if (outputOptions.refMode === "components") {
+    outputContext.components = { schemas: {} };
+  }
+  const output = extractOutputSchema(table, plan, projectionNodes, outputContext, outputOptions);
+  const useSelected = shouldUseSelectedSchema(outputOptions, plan, projectionNodes);
+  const hasComputedFields = hasComputedProjection(projectionNodes);
+  if (outputOptions.refMode === "components" && outputContext.components && !hasComputedFields) {
+    const componentName = useSelected && plan ? resolveSelectedComponentName(table, plan, outputOptions) : resolveComponentName(table, outputOptions);
+    registerComponentSchema(componentName, output, outputContext);
+  }
+  const inputOptions = resolveInputOptions(options);
+  if (!inputOptions) {
+    return {
+      output,
+      components: outputContext.components && Object.keys(outputContext.components.schemas).length ? outputContext.components : void 0
+    };
+  }
+  const inputContext = createContext(inputOptions.maxDepth ?? DEFAULT_MAX_DEPTH);
+  const input = extractInputSchema(table, inputContext, inputOptions);
+  return {
+    output,
+    input,
+    components: outputContext.components && Object.keys(outputContext.components.schemas).length ? outputContext.components : void 0
+  };
+};
+var resolveOutputOptions = (options) => ({
+  mode: options.mode ?? "full",
+  includeDescriptions: options.includeDescriptions,
+  includeEnums: options.includeEnums,
+  includeExamples: options.includeExamples,
+  includeDefaults: options.includeDefaults,
+  includeNullable: options.includeNullable,
+  maxDepth: options.maxDepth ?? DEFAULT_MAX_DEPTH,
+  refMode: options.refMode ?? "inline",
+  selectedRefMode: options.selectedRefMode ?? "inline",
+  componentName: options.componentName
 });
+var resolveInputOptions = (options) => {
+  if (options.input === false) return void 0;
+  const input = options.input ?? {};
+  const mode = input.mode ?? "create";
+  return {
+    mode,
+    includeRelations: input.includeRelations ?? true,
+    relationMode: input.relationMode ?? "mixed",
+    includeDescriptions: input.includeDescriptions ?? options.includeDescriptions,
+    includeEnums: input.includeEnums ?? options.includeEnums,
+    includeExamples: input.includeExamples ?? options.includeExamples,
+    includeDefaults: input.includeDefaults ?? options.includeDefaults,
+    includeNullable: input.includeNullable ?? options.includeNullable,
+    maxDepth: input.maxDepth ?? options.maxDepth ?? DEFAULT_MAX_DEPTH,
+    omitReadOnly: input.omitReadOnly ?? true,
+    excludePrimaryKey: input.excludePrimaryKey ?? false,
+    requirePrimaryKey: input.requirePrimaryKey ?? mode === "update"
+  };
+};
 var schemaToJson = (schema, pretty = false) => {
   return JSON.stringify(schema, null, pretty ? 2 : 0);
 };
@@ -8234,8 +8348,7 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
    * Validates that the query does not contain Param operands.
    * Param proxies are only for schema generation, not execution.
    */
-  validateNoParamOperands(options) {
-    if (options?.allowParamOperands) return;
+  validateNoParamOperands() {
     const ast = this.context.hydration.applyToAst(this.context.state.ast);
     const paramName = findFirstParamOperandName(ast);
     if (paramName) {
@@ -8254,13 +8367,13 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
    * // users is User[]
    * users[0] instanceof User; // true
    */
-  async execute(ctx, options) {
-    this.validateNoParamOperands(options);
+  async execute(ctx) {
+    this.validateNoParamOperands();
     if (this.entityConstructor) {
-      return this.executeAs(this.entityConstructor, ctx, options);
+      return this.executeAs(this.entityConstructor, ctx);
     }
     const builder = this.ensureDefaultSelection();
-    return executeHydrated(ctx, builder, options);
+    return executeHydrated(ctx, builder);
   }
   /**
    * Executes the query and returns plain row objects (POJOs), ignoring any entity materialization.
@@ -8273,10 +8386,10 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
    * // rows is EntityInstance<UserTable>[] (plain objects)
    * rows[0] instanceof User; // false
    */
-  async executePlain(ctx, options) {
-    this.validateNoParamOperands(options);
+  async executePlain(ctx) {
+    this.validateNoParamOperands();
     const builder = this.ensureDefaultSelection();
-    const rows = await executeHydratedPlain(ctx, builder, options);
+    const rows = await executeHydratedPlain(ctx, builder);
     return rows;
   }
   /**
@@ -8293,10 +8406,10 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
    * users[0] instanceof User; // true!
    * users[0].getFullName();   // works!
    */
-  async executeAs(entityClass, ctx, options) {
-    this.validateNoParamOperands(options);
+  async executeAs(entityClass, ctx) {
+    this.validateNoParamOperands();
     const builder = this.ensureDefaultSelection();
-    const results = await executeHydrated(ctx, builder, options);
+    const results = await executeHydrated(ctx, builder);
     return materializeAs(entityClass, results);
   }
   /**
@@ -8305,9 +8418,9 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
    * @example
    * const total = await qb.count(session);
    */
-  async count(session, options) {
-    this.validateNoParamOperands(options);
-    return executeCount(this.context, this.env, session, options);
+  async count(session) {
+    this.validateNoParamOperands();
+    return executeCount(this.context, this.env, session);
   }
   /**
    * Executes the query and returns both the paged items and the total.
@@ -8316,9 +8429,9 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
    * const { items, totalItems, page, pageSize } = await qb.executePaged(session, { page: 1, pageSize: 20 });
    */
   async executePaged(session, options) {
-    this.validateNoParamOperands(options);
+    this.validateNoParamOperands();
     const builder = this.ensureDefaultSelection();
-    return executePagedQuery(builder, session, options, (sess) => builder.count(sess, options), options);
+    return executePagedQuery(builder, session, options, (sess) => builder.count(sess));
   }
   /**
    * Executes the query with provided execution and hydration contexts
@@ -8330,10 +8443,10 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
    * const hydCtx = new HydrationContext();
    * const users = await qb.executeWithContexts(execCtx, hydCtx);
    */
-  async executeWithContexts(execCtx, hydCtx, options) {
-    this.validateNoParamOperands(options);
+  async executeWithContexts(execCtx, hydCtx) {
+    this.validateNoParamOperands();
     const builder = this.ensureDefaultSelection();
-    const results = await executeHydratedWithContexts(execCtx, hydCtx, builder, options);
+    const results = await executeHydratedWithContexts(execCtx, hydCtx, builder);
     if (this.entityConstructor) {
       return materializeAs(this.entityConstructor, results);
     }