metal-orm 1.0.87 → 1.0.89

package/dist/index.cjs

@@ -7249,47 +7249,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(),
@@ -7297,19 +7302,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)) {
@@ -7337,6 +7341,7 @@ var extractInputSchema = (table, context, options) => {
   if (options.includeRelations && context.depth < context.maxDepth) {
     for (const [relationName, relation] of Object.entries(table.relations)) {
       properties[relationName] = extractInputRelationSchema(
+        relationName,
         relation,
         { ...context, depth: context.depth + 1 },
         options
@@ -7371,7 +7376,7 @@ var buildPrimaryKeySchema = (table, options) => {
   }
   return mapColumnType(column, options);
 };
-var extractInputRelationSchema = (relation, context, options) => {
+var extractInputRelationSchema = (relationName, relation, context, options) => {
   const { type: relationType, isNullable } = mapRelationType(relation.type);
   const relationMode = options.relationMode ?? "mixed";
   const allowIds = relationMode !== "objects";
@@ -7381,7 +7386,11 @@ var extractInputRelationSchema = (relation, context, options) => {
     variants.push(buildPrimaryKeySchema(relation.target, options));
   }
   if (allowObjects) {
-    const targetSchema = extractInputSchema(relation.target, context, options);
+    let targetSchema = extractInputSchema(relation.target, context, options);
+    targetSchema = applyRelationSelection(targetSchema, options.relationSelections?.[relationName]);
+    if (options.excludeRelationForeignKeys && isRelationForeignKeyToParent(relation)) {
+      targetSchema = removeForeignKey(targetSchema, relation.foreignKey);
+    }
     variants.push(targetSchema);
   }
   const itemSchema = variants.length === 1 ? variants[0] : { anyOf: variants };
@@ -7397,6 +7406,55 @@ var extractInputRelationSchema = (relation, context, options) => {
     nullable: isNullable
   };
 };
+var applyRelationSelection = (schema, selection) => {
+  if (!selection || selection.pick === void 0 && selection.omit === void 0) {
+    return schema;
+  }
+  const hasPick = selection.pick !== void 0;
+  const pick = hasPick ? new Set(selection.pick ?? []) : void 0;
+  const omit = selection.omit !== void 0 ? new Set(selection.omit ?? []) : void 0;
+  const properties = Object.entries(schema.properties).reduce(
+    (acc, [key, value]) => {
+      if (pick && !pick.has(key)) return acc;
+      if (omit && omit.has(key)) return acc;
+      acc[key] = value;
+      return acc;
+    },
+    {}
+  );
+  const required = schema.required.filter((name) => properties[name] !== void 0);
+  return {
+    ...schema,
+    properties,
+    required
+  };
+};
+var removeForeignKey = (schema, foreignKey) => {
+  if (!foreignKey || !schema.properties[foreignKey]) return schema;
+  const properties = { ...schema.properties };
+  delete properties[foreignKey];
+  const required = schema.required.filter((name) => name !== foreignKey);
+  return {
+    ...schema,
+    properties,
+    required
+  };
+};
+var isRelationForeignKeyToParent = (relation) => {
+  return relation.type === RelationKinds.HasMany || relation.type === RelationKinds.HasOne;
+};
+
+// 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 = [];
@@ -7602,6 +7660,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 = {
@@ -7629,16 +7733,76 @@ 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}`
+
+// 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 outputSchema = extractOutputSchema(table, plan, projectionNodes, outputContext, outputOptions);
+  let output = outputSchema;
+  const useSelected = shouldUseSelectedSchema(outputOptions, plan, projectionNodes);
+  const hasComputedFields = hasComputedProjection(projectionNodes);
+  const canUseComponents = outputOptions.refMode === "components" && outputContext.components && !hasComputedFields;
+  if (canUseComponents) {
+    const componentName = useSelected && plan ? resolveSelectedComponentName(table, plan, outputOptions) : resolveComponentName(table, outputOptions);
+    registerComponentSchema(componentName, outputSchema, outputContext);
+    if (outputOptions.outputAsRef) {
+      output = { $ref: `#/components/schemas/${componentName}` };
     }
-  },
-  required: []
+  }
+  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,
+  outputAsRef: options.outputAsRef ?? false
 });
+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",
+    excludeRelationForeignKeys: input.excludeRelationForeignKeys ?? false,
+    relationSelections: input.relationSelections
+  };
+};
 var schemaToJson = (schema, pretty = false) => {
   return JSON.stringify(schema, null, pretty ? 2 : 0);
 };