metal-orm 1.0.91 → 1.0.93

package/src/dto/openapi/generators/relation-filter.ts

@@ -8,8 +8,8 @@ import {
     BelongsToManyRelation,
     RelationKinds
 } from '../../../schema/relation.js';
-import type { OpenApiSchema } from '../types.js';
-import { columnToOpenApiSchema } from './column.js';
+import type { OpenApiSchema, OpenApiDialect } from '../types.js';
+import { columnToFilterSchema } from './filter.js';
 import { getColumnMap } from './base.js';
 
 export function relationFilterToOpenApiSchema(
@@ -17,14 +17,26 @@ export function relationFilterToOpenApiSchema(
     options?: {
         exclude?: string[];
         include?: string[];
-    }
+    },
+    dialect: OpenApiDialect = 'openapi-3.1',
+    depth: number = 0
 ): OpenApiSchema {
     if (relation.type === RelationKinds.BelongsTo || relation.type === RelationKinds.HasOne) {
-        return singleRelationFilterToOpenApiSchema((relation as BelongsToRelation | HasOneRelation).target, options);
+        return singleRelationFilterToOpenApiSchema(
+            (relation as BelongsToRelation | HasOneRelation).target,
+            options,
+            dialect,
+            depth
+        );
     }
 
     if (relation.type === RelationKinds.HasMany || relation.type === RelationKinds.BelongsToMany) {
-        return manyRelationFilterToOpenApiSchema((relation as HasManyRelation | BelongsToManyRelation).target, options);
+        return manyRelationFilterToOpenApiSchema(
+            (relation as HasManyRelation | BelongsToManyRelation).target,
+            options,
+            dialect,
+            depth
+        );
     }
 
     return { type: 'object', properties: {} };
@@ -32,7 +44,9 @@ export function relationFilterToOpenApiSchema(
 
 function singleRelationFilterToOpenApiSchema(
     target: TableDef | EntityConstructor,
-    options?: { exclude?: string[]; include?: string[] }
+    options?: { exclude?: string[]; include?: string[] },
+    dialect: OpenApiDialect = 'openapi-3.1',
+    depth: number = 0
 ): OpenApiSchema {
     const columns = getColumnMap(target);
     const properties: Record<string, OpenApiSchema> = {};
@@ -47,13 +61,22 @@ function singleRelationFilterToOpenApiSchema(
             continue;
         }
 
-        properties[key] = columnToOpenApiSchema(col);
+        properties[key] = columnToFilterSchema(col, dialect);
 
         if (col.notNull || col.primary) {
             required.push(key);
         }
     }
 
+    if (depth > 0) {
+        const tableDef = target as TableDef;
+        if (tableDef.relations) {
+            for (const [relationName, relation] of Object.entries(tableDef.relations)) {
+                properties[relationName] = relationFilterToOpenApiSchema(relation, undefined, dialect, depth - 1);
+            }
+        }
+    }
+
     return {
         type: 'object',
         properties,
@@ -63,25 +86,31 @@ function singleRelationFilterToOpenApiSchema(
 
 function manyRelationFilterToOpenApiSchema(
     target: TableDef | EntityConstructor,
-    options?: { exclude?: string[]; include?: string[] }
+    options?: { exclude?: string[]; include?: string[] },
+    dialect: OpenApiDialect = 'openapi-3.1',
+    depth: number = 0
 ): OpenApiSchema {
+    const nestedSchema: OpenApiSchema = depth > 0
+        ? nestedWhereInputToOpenApiSchema(target, depth, dialect)
+        : {
+            type: 'object',
+            properties: generateNestedProperties(target, options, dialect),
+        };
+
     return {
         type: 'object',
         properties: {
             some: {
-                type: 'object',
+                ...nestedSchema,
                 description: 'Filter related records that match all conditions',
-                properties: generateNestedProperties(target, options),
             },
             every: {
-                type: 'object',
+                ...nestedSchema,
                 description: 'Filter related records where all match conditions',
-                properties: generateNestedProperties(target, options),
             },
             none: {
-                type: 'object',
+                ...nestedSchema,
                 description: 'Filter where no related records match',
-                properties: generateNestedProperties(target, options),
             },
             isEmpty: {
                 type: 'boolean',
@@ -97,7 +126,8 @@ function manyRelationFilterToOpenApiSchema(
 
 function generateNestedProperties(
     target: TableDef | EntityConstructor,
-    options?: { exclude?: string[]; include?: string[] }
+    options?: { exclude?: string[]; include?: string[] },
+    dialect: OpenApiDialect = 'openapi-3.1'
 ): Record<string, OpenApiSchema> {
     const columns = getColumnMap(target);
     const properties: Record<string, OpenApiSchema> = {};
@@ -111,7 +141,7 @@ function generateNestedProperties(
             continue;
         }
 
-        properties[key] = columnToOpenApiSchema(col);
+        properties[key] = columnToFilterSchema(col, dialect);
     }
 
     return properties;
@@ -125,7 +155,8 @@ export function whereInputWithRelationsToOpenApiSchema<T extends TableDef | Enti
         relationExclude?: string[];
         relationInclude?: string[];
         maxDepth?: number;
-    }
+    },
+    dialect: OpenApiDialect = 'openapi-3.1'
 ): OpenApiSchema {
     const columns = getColumnMap(target);
     const properties: Record<string, OpenApiSchema> = {};
@@ -140,7 +171,7 @@ export function whereInputWithRelationsToOpenApiSchema<T extends TableDef | Enti
             continue;
         }
 
-        properties[key] = columnToOpenApiSchema(col);
+        properties[key] = columnToFilterSchema(col, dialect);
     }
 
     const tableDef = target as TableDef;
@@ -157,7 +188,7 @@ export function whereInputWithRelationsToOpenApiSchema<T extends TableDef | Enti
             properties[relationName] = relationFilterToOpenApiSchema(relation, {
                 exclude: options?.columnExclude,
                 include: options?.columnInclude,
-            });
+            }, dialect);
         }
     }
 
@@ -169,7 +200,8 @@ export function whereInputWithRelationsToOpenApiSchema<T extends TableDef | Enti
 
 export function nestedWhereInputToOpenApiSchema<T extends TableDef | EntityConstructor>(
     target: T,
-    depth: number = 2
+    depth: number = 2,
+    dialect: OpenApiDialect = 'openapi-3.1'
 ): OpenApiSchema {
     if (depth <= 0) {
         return { type: 'object', properties: {} };
@@ -179,27 +211,13 @@ export function nestedWhereInputToOpenApiSchema<T extends TableDef | EntityConst
     const properties: Record<string, OpenApiSchema> = {};
 
     for (const [key, col] of Object.entries(columns)) {
-        properties[key] = columnToOpenApiSchema(col);
+        properties[key] = columnToFilterSchema(col, dialect);
     }
 
     const tableDef = target as TableDef;
     if (tableDef.relations) {
         for (const [relationName, relation] of Object.entries(tableDef.relations)) {
-            properties[relationName] = relationFilterToOpenApiSchema(relation);
-
-            if (depth > 1) {
-                if (relation.type === RelationKinds.BelongsTo || relation.type === RelationKinds.HasOne) {
-                    properties[relationName] = singleRelationFilterToOpenApiSchema((relation as BelongsToRelation | HasOneRelation).target);
-                } else if (relation.type === RelationKinds.HasMany || relation.type === RelationKinds.BelongsToMany) {
-                    properties[relationName] = {
-                        type: 'object',
-                        properties: {
-                            some: nestedWhereInputToOpenApiSchema((relation as HasManyRelation | BelongsToManyRelation).target, depth - 1),
-                            every: nestedWhereInputToOpenApiSchema((relation as HasManyRelation | BelongsToManyRelation).target, depth - 1),
-                        },
-                    };
-                }
-            }
+            properties[relationName] = relationFilterToOpenApiSchema(relation, undefined, dialect, depth - 1);
         }
     }
 

package/src/dto/openapi/types.ts

@@ -25,7 +25,7 @@ export interface OpenApiSchema {
   oneOf?: OpenApiSchema[];
 }
 
-export interface OpenApiParameter {
+export interface OpenApiParameterObject {
   name: string;
   in: 'query' | 'path' | 'header' | 'cookie';
   required?: boolean;
@@ -33,10 +33,19 @@ export interface OpenApiParameter {
   description?: string;
 }
 
+export interface OpenApiResponseObject {
+  description: string;
+  content?: {
+    'application/json': {
+      schema: OpenApiSchema;
+    };
+  };
+}
+
 export interface OpenApiOperation {
   summary?: string;
   description?: string;
-  parameters?: OpenApiParameter[];
+  parameters?: OpenApiParameterObject[];
   requestBody?: {
     description?: string;
     required?: boolean;
@@ -46,14 +55,7 @@ export interface OpenApiOperation {
       };
     };
   };
-  responses?: Record<string, {
-    description: string;
-    content?: {
-      'application/json': {
-        schema: OpenApiSchema;
-      };
-    };
-  }>;
+  responses?: Record<string, OpenApiResponseObject>;
 }
 
 export interface OpenApiDocumentInfo {
@@ -77,8 +79,8 @@ export interface PaginationParams {
 
 export interface OpenApiComponent {
   schemas?: Record<string, OpenApiSchema>;
-  parameters?: Record<string, OpenApiSchema>;
-  responses?: Record<string, OpenApiSchema>;
+  parameters?: Record<string, OpenApiParameterObject>;
+  responses?: Record<string, OpenApiResponseObject>;
   securitySchemes?: Record<string, unknown>;
 }
 
@@ -88,3 +90,12 @@ export interface OpenApiDocument {
   paths: Record<string, Record<string, OpenApiOperation>>;
   components?: OpenApiComponent;
 }
+
+export type OpenApiDialect = 'openapi-3.0' | 'openapi-3.1';
+
+export interface OpenApiDocumentOptions {
+  dialect?: OpenApiDialect;
+  allowScalarEquals?: boolean;
+}
+
+export type OpenApiParameter = OpenApiParameterObject;

package/src/dto/openapi/utilities.ts

@@ -1,4 +1,4 @@
-import type { OpenApiSchema, OpenApiOperation, OpenApiDocumentInfo, ApiRouteDefinition, OpenApiDocument } from './types.js';
+import type { OpenApiSchema, OpenApiOperation, OpenApiDocumentInfo, ApiRouteDefinition, OpenApiDocument, OpenApiDialect, OpenApiType } from './types.js';
 
 export function schemaToJson(schema: OpenApiSchema): string {
   return JSON.stringify(schema, null, 2);
@@ -20,10 +20,55 @@ export function mergeSchemas(base: OpenApiSchema, override: Partial<OpenApiSchem
   };
 }
 
+export function applyNullability(
+  schema: OpenApiSchema,
+  isNullable: boolean,
+  dialect: OpenApiDialect
+): OpenApiSchema {
+  if (!isNullable) {
+    const { nullable: _, ...clean } = schema;
+    return clean;
+  }
+
+  if (dialect === 'openapi-3.0') {
+    return { ...schema, nullable: true };
+  }
+
+  const type = schema.type;
+  if (Array.isArray(type)) {
+    if (!type.includes('null')) {
+      const { nullable: _, ...clean } = schema;
+      return { ...clean, type: [...type, 'null'] as OpenApiType[] };
+    }
+  } else if (type) {
+    const { nullable: _, ...clean } = schema;
+    return { ...clean, type: [type, 'null'] as OpenApiType[] };
+  } else {
+    const { nullable: _, ...clean } = schema;
+    return { ...clean, type: ['null'] as OpenApiType[] };
+  }
+
+  const { nullable: _, ...clean } = schema;
+  return clean;
+}
+
+export function isNullableColumn(col: { notNull?: boolean }): boolean {
+  return !col.notNull;
+}
+
+export function getOpenApiVersionForDialect(dialect: OpenApiDialect): string {
+  return dialect === 'openapi-3.0' ? '3.0.3' : '3.1.0';
+}
+
 export function generateOpenApiDocument(
   info: OpenApiDocumentInfo,
-  routes: ApiRouteDefinition[]
+  routes: ApiRouteDefinition[],
+  options?: {
+    dialect?: OpenApiDialect;
+    allowScalarEquals?: boolean;
+  }
 ): OpenApiDocument {
+  const dialect: OpenApiDialect = options?.dialect ?? 'openapi-3.1';
   const paths: Record<string, Record<string, OpenApiOperation>> = {};
 
   for (const route of routes) {
@@ -34,7 +79,7 @@ export function generateOpenApiDocument(
   }
 
   return {
-    openapi: '3.1.0',
+    openapi: getOpenApiVersionForDialect(dialect),
     info: {
       title: info.title,
       version: info.version,

package/src/orm/entity-metadata.ts

@@ -21,11 +21,11 @@ export type EntityOrTableTarget = EntityConstructor | TableDef;
 export type EntityOrTableTargetResolver<T extends EntityOrTableTarget = EntityOrTableTarget> =
   T | (() => T);
 
-/**
- * Simplified column definition structure used during metadata registration.
- * @template T - Concrete column definition type being extended
- */
-export type ColumnDefLike<T extends ColumnDef = ColumnDef> = Omit<T, 'name' | 'table'>;
+/**
+ * Simplified column definition structure used during metadata registration.
+ * @template T - Concrete column definition type being extended
+ */
+export type ColumnDefLike<T extends ColumnDef = ColumnDef> = Omit<T, 'table'>;
 
 /**
  * Transforms simplified column metadata into full ColumnDef objects during table building.
@@ -250,15 +250,15 @@ export const buildTableDef = <TColumns extends Record<string, ColumnDefLike>>(me
     return meta.table;
   }
 
-  // Build columns using a simpler approach that avoids type assertion
-  const columns: Record<string, ColumnDef> = {};
-  for (const [key, def] of Object.entries(meta.columns)) {
-    columns[key] = {
-      ...def,
-      name: key,
-      table: meta.tableName
-    } as ColumnDef;
-  }
+  // Build columns using a simpler approach that avoids type assertion
+  const columns: Record<string, ColumnDef> = {};
+  for (const [key, def] of Object.entries(meta.columns)) {
+    columns[key] = {
+      ...def,
+      name: def.name ?? key,
+      table: meta.tableName
+    } as ColumnDef;
+  }
 
   const table = defineTable(meta.tableName, columns as MaterializeColumns<TColumns>, {}, meta.hooks);
   meta.table = table;