metal-orm 1.0.90 → 1.0.91

package/src/dto/openapi/type-mappings.ts

@@ -1,191 +1,191 @@
-import type { ColumnDef } from '../../schema/column-types.js';
-import type { OpenApiType } from './types.js';
-
-export interface TypeMappingStrategy {
-  supports(columnType: string): boolean;
-  getOpenApiType(): OpenApiType;
-  getFormat(columnType: string): string | undefined;
-}
-
-export class IntegerTypeStrategy implements TypeMappingStrategy {
-  private readonly types = ['INT', 'INTEGER'];
-
-  supports(type: string): boolean {
-    return this.types.includes(type.toUpperCase());
-  }
-
-  getOpenApiType(): OpenApiType {
-    return 'integer';
-  }
-
-  getFormat(): string | undefined {
-    return 'int32';
-  }
-}
-
-export class BigIntTypeStrategy implements TypeMappingStrategy {
-  private readonly types = ['BIGINT'];
-
-  supports(type: string): boolean {
-    return this.types.includes(type.toUpperCase());
-  }
-
-  getOpenApiType(): OpenApiType {
-    return 'integer';
-  }
-
-  getFormat(): string | undefined {
-    return 'int64';
-  }
-}
-
-export class DecimalTypeStrategy implements TypeMappingStrategy {
-  private readonly types = ['DECIMAL', 'FLOAT', 'DOUBLE'];
-
-  supports(type: string): boolean {
-    return this.types.includes(type.toUpperCase());
-  }
-
-  getOpenApiType(): OpenApiType {
-    return 'number';
-  }
-
-  getFormat(): string | undefined {
-    return 'double';
-  }
-}
-
-export class BooleanTypeStrategy implements TypeMappingStrategy {
-  private readonly types = ['BOOLEAN'];
-
-  supports(type: string): boolean {
-    return this.types.includes(type.toUpperCase());
-  }
-
-  getOpenApiType(): OpenApiType {
-    return 'boolean';
-  }
-
-  getFormat(): undefined {
-    return undefined;
-  }
-}
-
-export class UuidTypeStrategy implements TypeMappingStrategy {
-  private readonly types = ['UUID'];
-
-  supports(type: string): boolean {
-    return this.types.includes(type.toUpperCase());
-  }
-
-  getOpenApiType(): OpenApiType {
-    return 'string';
-  }
-
-  getFormat(): string {
-    return 'uuid';
-  }
-}
-
-export class DateTimeTypeStrategy implements TypeMappingStrategy {
-  private readonly types = ['DATE', 'DATETIME', 'TIMESTAMP', 'TIMESTAMPTZ'];
-
-  supports(type: string): boolean {
-    return this.types.includes(type.toUpperCase());
-  }
-
-  getOpenApiType(): OpenApiType {
-    return 'string';
-  }
-
-  getFormat(columnType: string = 'DATETIME'): string {
-    return columnType.toUpperCase() === 'DATE' ? 'date' : 'date-time';
-  }
-}
-
-export class StringTypeStrategy implements TypeMappingStrategy {
-  private readonly types = [
-    'JSON', 'TEXT', 'VARCHAR', 'CHAR', 'BINARY',
-    'VARBINARY', 'BLOB', 'ENUM'
-  ];
-
-  supports(type: string): boolean {
-    return this.types.includes(type.toUpperCase());
-  }
-
-  getOpenApiType(): OpenApiType {
-    return 'string';
-  }
-
-  getFormat(): undefined {
-    return undefined;
-  }
-}
-
-export class DefaultTypeStrategy implements TypeMappingStrategy {
-  supports(): boolean {
-    return true;
-  }
-
-  getOpenApiType(): OpenApiType {
-    return 'string';
-  }
-
-  getFormat(): undefined {
-    return undefined;
-  }
-}
-
-export class TypeMappingService {
-  private readonly strategies: TypeMappingStrategy[];
-
-  constructor() {
-    this.strategies = [
-      new IntegerTypeStrategy(),
-      new BigIntTypeStrategy(),
-      new DecimalTypeStrategy(),
-      new BooleanTypeStrategy(),
-      new DateTimeTypeStrategy(),
-      new UuidTypeStrategy(),
-      new StringTypeStrategy(),
-      new DefaultTypeStrategy(),
-    ];
-  }
-
-  getOpenApiType(column: ColumnDef): OpenApiType {
-    const strategy = this.findStrategy(column.type);
-    return strategy.getOpenApiType();
-  }
-
-  getFormat(column: ColumnDef): string | undefined {
-    const strategy = this.findStrategy(column.type);
-    return strategy.getFormat(column.type);
-  }
-
-  private findStrategy(columnType: string): TypeMappingStrategy {
-    for (const strategy of this.strategies) {
-      if (strategy.supports(columnType)) {
-        return strategy;
-      }
-    }
-    return this.strategies[this.strategies.length - 1];
-  }
-
-  registerStrategy(strategy: TypeMappingStrategy, index?: number): void {
-    if (index !== undefined) {
-      this.strategies.splice(index, 0, strategy);
-    } else {
-      this.strategies.push(strategy);
-    }
-  }
-}
-
-export const typeMappingService = new TypeMappingService();
-
-export function columnTypeToOpenApiType(col: ColumnDef): OpenApiType {
-  return typeMappingService.getOpenApiType(col);
-}
-
-export function columnTypeToOpenApiFormat(col: ColumnDef): string | undefined {
-  return typeMappingService.getFormat(col);
-}
+import type { ColumnDef } from '../../schema/column-types.js';
+import type { OpenApiType } from './types.js';
+
+export interface TypeMappingStrategy {
+  supports(columnType: string): boolean;
+  getOpenApiType(): OpenApiType;
+  getFormat(columnType: string): string | undefined;
+}
+
+export class IntegerTypeStrategy implements TypeMappingStrategy {
+  private readonly types = ['INT', 'INTEGER'];
+
+  supports(type: string): boolean {
+    return this.types.includes(type.toUpperCase());
+  }
+
+  getOpenApiType(): OpenApiType {
+    return 'integer';
+  }
+
+  getFormat(): string | undefined {
+    return 'int32';
+  }
+}
+
+export class BigIntTypeStrategy implements TypeMappingStrategy {
+  private readonly types = ['BIGINT'];
+
+  supports(type: string): boolean {
+    return this.types.includes(type.toUpperCase());
+  }
+
+  getOpenApiType(): OpenApiType {
+    return 'integer';
+  }
+
+  getFormat(): string | undefined {
+    return 'int64';
+  }
+}
+
+export class DecimalTypeStrategy implements TypeMappingStrategy {
+  private readonly types = ['DECIMAL', 'FLOAT', 'DOUBLE'];
+
+  supports(type: string): boolean {
+    return this.types.includes(type.toUpperCase());
+  }
+
+  getOpenApiType(): OpenApiType {
+    return 'number';
+  }
+
+  getFormat(): string | undefined {
+    return 'double';
+  }
+}
+
+export class BooleanTypeStrategy implements TypeMappingStrategy {
+  private readonly types = ['BOOLEAN'];
+
+  supports(type: string): boolean {
+    return this.types.includes(type.toUpperCase());
+  }
+
+  getOpenApiType(): OpenApiType {
+    return 'boolean';
+  }
+
+  getFormat(): undefined {
+    return undefined;
+  }
+}
+
+export class UuidTypeStrategy implements TypeMappingStrategy {
+  private readonly types = ['UUID'];
+
+  supports(type: string): boolean {
+    return this.types.includes(type.toUpperCase());
+  }
+
+  getOpenApiType(): OpenApiType {
+    return 'string';
+  }
+
+  getFormat(): string {
+    return 'uuid';
+  }
+}
+
+export class DateTimeTypeStrategy implements TypeMappingStrategy {
+  private readonly types = ['DATE', 'DATETIME', 'TIMESTAMP', 'TIMESTAMPTZ'];
+
+  supports(type: string): boolean {
+    return this.types.includes(type.toUpperCase());
+  }
+
+  getOpenApiType(): OpenApiType {
+    return 'string';
+  }
+
+  getFormat(columnType: string = 'DATETIME'): string {
+    return columnType.toUpperCase() === 'DATE' ? 'date' : 'date-time';
+  }
+}
+
+export class StringTypeStrategy implements TypeMappingStrategy {
+  private readonly types = [
+    'JSON', 'TEXT', 'VARCHAR', 'CHAR', 'BINARY',
+    'VARBINARY', 'BLOB', 'ENUM'
+  ];
+
+  supports(type: string): boolean {
+    return this.types.includes(type.toUpperCase());
+  }
+
+  getOpenApiType(): OpenApiType {
+    return 'string';
+  }
+
+  getFormat(): undefined {
+    return undefined;
+  }
+}
+
+export class DefaultTypeStrategy implements TypeMappingStrategy {
+  supports(): boolean {
+    return true;
+  }
+
+  getOpenApiType(): OpenApiType {
+    return 'string';
+  }
+
+  getFormat(): undefined {
+    return undefined;
+  }
+}
+
+export class TypeMappingService {
+  private readonly strategies: TypeMappingStrategy[];
+
+  constructor() {
+    this.strategies = [
+      new IntegerTypeStrategy(),
+      new BigIntTypeStrategy(),
+      new DecimalTypeStrategy(),
+      new BooleanTypeStrategy(),
+      new DateTimeTypeStrategy(),
+      new UuidTypeStrategy(),
+      new StringTypeStrategy(),
+      new DefaultTypeStrategy(),
+    ];
+  }
+
+  getOpenApiType(column: ColumnDef): OpenApiType {
+    const strategy = this.findStrategy(column.type);
+    return strategy.getOpenApiType();
+  }
+
+  getFormat(column: ColumnDef): string | undefined {
+    const strategy = this.findStrategy(column.type);
+    return strategy.getFormat(column.type);
+  }
+
+  private findStrategy(columnType: string): TypeMappingStrategy {
+    for (const strategy of this.strategies) {
+      if (strategy.supports(columnType)) {
+        return strategy;
+      }
+    }
+    return this.strategies[this.strategies.length - 1];
+  }
+
+  registerStrategy(strategy: TypeMappingStrategy, index?: number): void {
+    if (index !== undefined) {
+      this.strategies.splice(index, 0, strategy);
+    } else {
+      this.strategies.push(strategy);
+    }
+  }
+}
+
+export const typeMappingService = new TypeMappingService();
+
+export function columnTypeToOpenApiType(col: ColumnDef): OpenApiType {
+  return typeMappingService.getOpenApiType(col);
+}
+
+export function columnTypeToOpenApiFormat(col: ColumnDef): string | undefined {
+  return typeMappingService.getFormat(col);
+}

package/src/dto/openapi/types.ts

@@ -1,83 +1,90 @@
-export type OpenApiType =
-  | 'string'
-  | 'number'
-  | 'integer'
-  | 'boolean'
-  | 'array'
-  | 'object'
-  | 'null';
-
-export interface OpenApiSchema {
-  type?: OpenApiType | OpenApiType[];
-  properties?: Record<string, OpenApiSchema>;
-  items?: OpenApiSchema;
-  required?: string[];
-  enum?: unknown[];
-  format?: string;
-  description?: string;
-  example?: unknown;
-  nullable?: boolean;
-  minimum?: number;
-  maximum?: number;
-  default?: unknown;
-  $ref?: string;
-  allOf?: OpenApiSchema[];
-  oneOf?: OpenApiSchema[];
-}
-
-export interface OpenApiParameter {
-  name: string;
-  in: 'query' | 'path' | 'header' | 'cookie';
-  required?: boolean;
-  schema?: OpenApiSchema;
-  description?: string;
-}
-
-export interface OpenApiOperation {
-  summary?: string;
-  description?: string;
-  parameters?: OpenApiParameter[];
-  requestBody?: {
-    description?: string;
-    required?: boolean;
-    content: {
-      'application/json': {
-        schema: OpenApiSchema;
-      };
-    };
-  };
-  responses?: Record<string, {
-    description: string;
-    content?: {
-      'application/json': {
-        schema: OpenApiSchema;
-      };
-    };
-  }>;
-}
-
-export interface OpenApiDocumentInfo {
-  title: string;
-  version: string;
-  description?: string;
-}
-
-export interface ApiRouteDefinition {
-  path: string;
-  method: 'get' | 'post' | 'put' | 'patch' | 'delete';
-  operation: OpenApiOperation;
-}
-
-export interface PaginationParams {
-  page?: number;
-  pageSize?: number;
-  sortBy?: string;
-  sortOrder?: 'asc' | 'desc';
-}
-
-export interface OpenApiComponent {
-  schemas?: Record<string, OpenApiSchema>;
-  parameters?: Record<string, OpenApiSchema>;
-  responses?: Record<string, OpenApiSchema>;
-  securitySchemes?: Record<string, unknown>;
-}
+export type OpenApiType =
+  | 'string'
+  | 'number'
+  | 'integer'
+  | 'boolean'
+  | 'array'
+  | 'object'
+  | 'null';
+
+export interface OpenApiSchema {
+  type?: OpenApiType | OpenApiType[];
+  properties?: Record<string, OpenApiSchema>;
+  items?: OpenApiSchema;
+  required?: string[];
+  enum?: unknown[];
+  format?: string;
+  description?: string;
+  example?: unknown;
+  nullable?: boolean;
+  minimum?: number;
+  maximum?: number;
+  default?: unknown;
+  $ref?: string;
+  allOf?: OpenApiSchema[];
+  oneOf?: OpenApiSchema[];
+}
+
+export interface OpenApiParameter {
+  name: string;
+  in: 'query' | 'path' | 'header' | 'cookie';
+  required?: boolean;
+  schema?: OpenApiSchema;
+  description?: string;
+}
+
+export interface OpenApiOperation {
+  summary?: string;
+  description?: string;
+  parameters?: OpenApiParameter[];
+  requestBody?: {
+    description?: string;
+    required?: boolean;
+    content: {
+      'application/json': {
+        schema: OpenApiSchema;
+      };
+    };
+  };
+  responses?: Record<string, {
+    description: string;
+    content?: {
+      'application/json': {
+        schema: OpenApiSchema;
+      };
+    };
+  }>;
+}
+
+export interface OpenApiDocumentInfo {
+  title: string;
+  version: string;
+  description?: string;
+}
+
+export interface ApiRouteDefinition {
+  path: string;
+  method: 'get' | 'post' | 'put' | 'patch' | 'delete';
+  operation: OpenApiOperation;
+}
+
+export interface PaginationParams {
+  page?: number;
+  pageSize?: number;
+  sortBy?: string;
+  sortOrder?: 'asc' | 'desc';
+}
+
+export interface OpenApiComponent {
+  schemas?: Record<string, OpenApiSchema>;
+  parameters?: Record<string, OpenApiSchema>;
+  responses?: Record<string, OpenApiSchema>;
+  securitySchemes?: Record<string, unknown>;
+}
+
+export interface OpenApiDocument {
+  openapi: string;
+  info: OpenApiDocumentInfo;
+  paths: Record<string, Record<string, OpenApiOperation>>;
+  components?: OpenApiComponent;
+}

package/src/dto/openapi/utilities.ts

@@ -1,45 +1,45 @@
-import type { OpenApiSchema, OpenApiOperation, OpenApiDocumentInfo, ApiRouteDefinition } from './types.js';
-
-export function schemaToJson(schema: OpenApiSchema): string {
-  return JSON.stringify(schema, null, 2);
-}
-
-export function deepCloneSchema(schema: OpenApiSchema): OpenApiSchema {
-  return JSON.parse(JSON.stringify(schema));
-}
-
-export function mergeSchemas(base: OpenApiSchema, override: Partial<OpenApiSchema>): OpenApiSchema {
-  return {
-    ...base,
-    ...override,
-    properties: {
-      ...base.properties,
-      ...(override.properties || {}),
-    },
-    required: override.required ?? base.required,
-  };
-}
-
-export function generateOpenApiDocument(
-  info: OpenApiDocumentInfo,
-  routes: ApiRouteDefinition[]
-): Record<string, unknown> {
-  const paths: Record<string, Record<string, OpenApiOperation>> = {};
-
-  for (const route of routes) {
-    if (!paths[route.path]) {
-      paths[route.path] = {};
-    }
-    paths[route.path][route.method] = route.operation;
-  }
-
-  return {
-    openapi: '3.1.0',
-    info: {
-      title: info.title,
-      version: info.version,
-      description: info.description,
-    },
-    paths,
-  };
-}
+import type { OpenApiSchema, OpenApiOperation, OpenApiDocumentInfo, ApiRouteDefinition, OpenApiDocument } from './types.js';
+
+export function schemaToJson(schema: OpenApiSchema): string {
+  return JSON.stringify(schema, null, 2);
+}
+
+export function deepCloneSchema(schema: OpenApiSchema): OpenApiSchema {
+  return JSON.parse(JSON.stringify(schema));
+}
+
+export function mergeSchemas(base: OpenApiSchema, override: Partial<OpenApiSchema>): OpenApiSchema {
+  return {
+    ...base,
+    ...override,
+    properties: {
+      ...base.properties,
+      ...(override.properties || {}),
+    },
+    required: override.required ?? base.required,
+  };
+}
+
+export function generateOpenApiDocument(
+  info: OpenApiDocumentInfo,
+  routes: ApiRouteDefinition[]
+): OpenApiDocument {
+  const paths: Record<string, Record<string, OpenApiOperation>> = {};
+
+  for (const route of routes) {
+    if (!paths[route.path]) {
+      paths[route.path] = {};
+    }
+    paths[route.path][route.method] = route.operation;
+  }
+
+  return {
+    openapi: '3.1.0',
+    info: {
+      title: info.title,
+      version: info.version,
+      description: info.description,
+    },
+    paths,
+  };
+}