metal-orm 1.0.90 → 1.0.92

package/src/dto/openapi/generators/column.ts

@@ -1,34 +1,37 @@
-import type { ColumnDef } from '../../../schema/column-types.js';
-import type { OpenApiSchema } from '../types.js';
-import { columnTypeToOpenApiType, columnTypeToOpenApiFormat } from '../type-mappings.js';
-
-export function columnToOpenApiSchema(col: ColumnDef): OpenApiSchema {
-  const schema: OpenApiSchema = {
-    type: columnTypeToOpenApiType(col),
-    format: columnTypeToOpenApiFormat(col),
-  };
-
-  if (!col.notNull) {
-    schema.nullable = true;
-  }
-
-  if (col.comment) {
-    schema.description = col.comment;
-  }
-
-  if (col.type.toUpperCase() === 'ENUM' && col.args && Array.isArray(col.args) && col.args.every(v => typeof v === 'string')) {
-    schema.enum = col.args as string[];
-  }
-
-  const args = col.args;
-  if (args && args.length > 0) {
-    if (col.type.toUpperCase() === 'VARCHAR' || col.type.toUpperCase() === 'CHAR') {
-      const length = args[0] as number;
-      if (length) {
-        schema.example = 'a'.repeat(length);
-      }
-    }
-  }
-
-  return schema;
-}
+import type { ColumnDef } from '../../../schema/column-types.js';
+import type { OpenApiSchema, OpenApiDialect } from '../types.js';
+import { columnTypeToOpenApiType, columnTypeToOpenApiFormat } from '../type-mappings.js';
+import { applyNullability, isNullableColumn } from '../utilities.js';
+
+export function columnToOpenApiSchema(
+  col: ColumnDef,
+  dialect: OpenApiDialect = 'openapi-3.1'
+): OpenApiSchema {
+  const schema: OpenApiSchema = {
+    type: columnTypeToOpenApiType(col),
+    format: columnTypeToOpenApiFormat(col),
+  };
+
+  const nullable = isNullableColumn(col);
+  const result = applyNullability(schema, nullable, dialect);
+
+  if (col.comment) {
+    result.description = col.comment;
+  }
+
+  if (col.type.toUpperCase() === 'ENUM' && col.args && Array.isArray(col.args) && col.args.every(v => typeof v === 'string')) {
+    result.enum = col.args as string[];
+  }
+
+  const args = col.args;
+  if (args && args.length > 0) {
+    if (col.type.toUpperCase() === 'VARCHAR' || col.type.toUpperCase() === 'CHAR') {
+      const length = args[0] as number;
+      if (length) {
+        result.example = 'a'.repeat(length);
+      }
+    }
+  }
+
+  return result;
+}

package/src/dto/openapi/generators/dto.ts

@@ -1,94 +1,94 @@
-import type { TableDef } from '../../../schema/table.js';
-import type { EntityConstructor } from '../../../orm/entity-metadata.js';
-import type { OpenApiSchema } from '../types.js';
-import { columnToOpenApiSchema } from './column.js';
-import { getColumnMap } from './base.js';
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function dtoToOpenApiSchema<T extends TableDef | EntityConstructor, TExclude extends keyof any>(
-  target: T,
-  exclude?: TExclude[]
-): OpenApiSchema {
-  const columns = getColumnMap(target);
-  const properties: Record<string, OpenApiSchema> = {};
-  const required: string[] = [];
-
-  for (const [key, col] of Object.entries(columns)) {
-    if (exclude?.includes(key as TExclude)) {
-      continue;
-    }
-
-    properties[key] = columnToOpenApiSchema(col);
-
-    if (col.notNull || col.primary) {
-      required.push(key);
-    }
-  }
-
-  return {
-    type: 'object',
-    properties,
-    ...(required.length > 0 && { required }),
-  };
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function createDtoToOpenApiSchema<T extends TableDef | EntityConstructor, TExclude extends keyof any>(
-  target: T,
-  exclude?: TExclude[]
-): OpenApiSchema {
-  const columns = getColumnMap(target);
-  const properties: Record<string, OpenApiSchema> = {};
-  const required: string[] = [];
-
-  for (const [key, col] of Object.entries(columns)) {
-    if (exclude?.includes(key as TExclude)) {
-      continue;
-    }
-
-    if (col.autoIncrement || col.generated) {
-      continue;
-    }
-
-    properties[key] = columnToOpenApiSchema(col);
-
-    if (col.notNull && !col.default) {
-      required.push(key);
-    }
-  }
-
-  return {
-    type: 'object',
-    properties,
-    ...(required.length > 0 && { required }),
-  };
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function updateDtoToOpenApiSchema<T extends TableDef | EntityConstructor, TExclude extends keyof any>(
-  target: T,
-  exclude?: TExclude[]
-): OpenApiSchema {
-  const columns = getColumnMap(target);
-  const properties: Record<string, OpenApiSchema> = {};
-
-  for (const [key, col] of Object.entries(columns)) {
-    if (exclude?.includes(key as TExclude)) {
-      continue;
-    }
-
-    if (col.autoIncrement || col.generated) {
-      continue;
-    }
-
-    properties[key] = {
-      ...columnToOpenApiSchema(col),
-      ...(!col.notNull ? { nullable: true } : {}),
-    };
-  }
-
-  return {
-    type: 'object',
-    properties,
-  };
-}
+import type { TableDef } from '../../../schema/table.js';
+import type { EntityConstructor } from '../../../orm/entity-metadata.js';
+import type { OpenApiSchema, OpenApiDialect } from '../types.js';
+import { columnToOpenApiSchema } from './column.js';
+import { getColumnMap } from './base.js';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function dtoToOpenApiSchema<T extends TableDef | EntityConstructor, TExclude extends keyof any>(
+  target: T,
+  exclude?: TExclude[],
+  dialect: OpenApiDialect = 'openapi-3.1'
+): OpenApiSchema {
+  const columns = getColumnMap(target);
+  const properties: Record<string, OpenApiSchema> = {};
+  const required: string[] = [];
+
+  for (const [key, col] of Object.entries(columns)) {
+    if (exclude?.includes(key as TExclude)) {
+      continue;
+    }
+
+    properties[key] = columnToOpenApiSchema(col, dialect);
+
+    if (col.notNull || col.primary) {
+      required.push(key);
+    }
+  }
+
+  return {
+    type: 'object',
+    properties,
+    ...(required.length > 0 && { required }),
+  };
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function createDtoToOpenApiSchema<T extends TableDef | EntityConstructor, TExclude extends keyof any>(
+  target: T,
+  exclude?: TExclude[],
+  dialect: OpenApiDialect = 'openapi-3.1'
+): OpenApiSchema {
+  const columns = getColumnMap(target);
+  const properties: Record<string, OpenApiSchema> = {};
+  const required: string[] = [];
+
+  for (const [key, col] of Object.entries(columns)) {
+    if (exclude?.includes(key as TExclude)) {
+      continue;
+    }
+
+    if (col.autoIncrement || col.generated) {
+      continue;
+    }
+
+    properties[key] = columnToOpenApiSchema(col, dialect);
+
+    if (col.notNull && !col.default) {
+      required.push(key);
+    }
+  }
+
+  return {
+    type: 'object',
+    properties,
+    ...(required.length > 0 && { required }),
+  };
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function updateDtoToOpenApiSchema<T extends TableDef | EntityConstructor, TExclude extends keyof any>(
+  target: T,
+  exclude?: TExclude[],
+  dialect: OpenApiDialect = 'openapi-3.1'
+): OpenApiSchema {
+  const columns = getColumnMap(target);
+  const properties: Record<string, OpenApiSchema> = {};
+
+  for (const [key, col] of Object.entries(columns)) {
+    if (exclude?.includes(key as TExclude)) {
+      continue;
+    }
+
+    if (col.autoIncrement || col.generated) {
+      continue;
+    }
+
+    properties[key] = columnToOpenApiSchema(col, dialect);
+  }
+
+  return {
+    type: 'object',
+    properties,
+  };
+}

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

@@ -1,74 +1,75 @@
-import type { TableDef } from '../../../schema/table.js';
-import type { ColumnDef } from '../../../schema/column-types.js';
-import type { EntityConstructor } from '../../../orm/entity-metadata.js';
-import type { OpenApiSchema } from '../types.js';
-import { columnTypeToOpenApiType } from '../type-mappings.js';
-import { getColumnMap } from './base.js';
-
-function filterFieldToOpenApiSchema(col: ColumnDef): OpenApiSchema {
-  const normalizedType = col.type.toUpperCase();
-  columnTypeToOpenApiType(col);
-  
-  let filterProperties: Record<string, OpenApiSchema> = {};
-
-  if (['INT', 'INTEGER', 'BIGINT', 'DECIMAL', 'FLOAT', 'DOUBLE'].includes(normalizedType)) {
-    filterProperties = {
-      equals: { type: 'number' },
-      not: { type: 'number' },
-      in: { type: 'array', items: { type: 'number' } },
-      notIn: { type: 'array', items: { type: 'number' } },
-      lt: { type: 'number' },
-      lte: { type: 'number' },
-      gt: { type: 'number' },
-      gte: { type: 'number' },
-    };
-  } else if (['BOOLEAN'].includes(normalizedType)) {
-    filterProperties = {
-      equals: { type: 'boolean' },
-      not: { type: 'boolean' },
-    };
-  } else if (['DATE', 'DATETIME', 'TIMESTAMP', 'TIMESTAMPTZ'].includes(normalizedType)) {
-    filterProperties = {
-      equals: { type: 'string', format: 'date-time' },
-      not: { type: 'string', format: 'date-time' },
-      in: { type: 'array', items: { type: 'string', format: 'date-time' } },
-      notIn: { type: 'array', items: { type: 'string', format: 'date-time' } },
-      lt: { type: 'string', format: 'date-time' },
-      lte: { type: 'string', format: 'date-time' },
-      gt: { type: 'string', format: 'date-time' },
-      gte: { type: 'string', format: 'date-time' },
-    };
-  } else {
-    filterProperties = {
-      equals: { type: 'string' },
-      not: { type: 'string' },
-      in: { type: 'array', items: { type: 'string' } },
-      notIn: { type: 'array', items: { type: 'string' } },
-      contains: { type: 'string' },
-      startsWith: { type: 'string' },
-      endsWith: { type: 'string' },
-      mode: { type: 'string', enum: ['default', 'insensitive'] },
-    };
-  }
-
-  return {
-    type: 'object',
-    properties: filterProperties,
-  };
-}
-
-export function whereInputToOpenApiSchema<T extends TableDef | EntityConstructor>(
-  target: T
-): OpenApiSchema {
-  const columns = getColumnMap(target);
-  const properties: Record<string, OpenApiSchema> = {};
-
-  for (const [key, col] of Object.entries(columns)) {
-    properties[key] = filterFieldToOpenApiSchema(col);
-  }
-
-  return {
-    type: 'object',
-    properties,
-  };
-}
+import type { TableDef } from '../../../schema/table.js';
+import type { ColumnDef } from '../../../schema/column-types.js';
+import type { EntityConstructor } from '../../../orm/entity-metadata.js';
+import type { OpenApiSchema, OpenApiDialect } from '../types.js';
+import { columnTypeToOpenApiType, columnTypeToOpenApiFormat } from '../type-mappings.js';
+import { getColumnMap } from './base.js';
+import { applyNullability, isNullableColumn } from '../utilities.js';
+
+function filterFieldToOpenApiSchema(col: ColumnDef): OpenApiSchema {
+  const openApiType = columnTypeToOpenApiType(col);
+  const openApiFormat = columnTypeToOpenApiFormat(col);
+
+  const filterProperties: Record<string, OpenApiSchema> = {};
+
+  filterProperties.equals = { type: openApiType, format: openApiFormat };
+  filterProperties.not = { type: openApiType, format: openApiFormat };
+  filterProperties.in = { type: 'array', items: { type: openApiType, format: openApiFormat } };
+  filterProperties.notIn = { type: 'array', items: { type: openApiType, format: openApiFormat } };
+
+  const isNumeric = openApiType === 'integer' || openApiType === 'number';
+  const isDateOrTime = openApiType === 'string' && (openApiFormat === 'date' || openApiFormat === 'date-time');
+  const isString = openApiType === 'string' && !isDateOrTime;
+
+  if (isNumeric) {
+    filterProperties.lt = { type: openApiType, format: openApiFormat };
+    filterProperties.lte = { type: openApiType, format: openApiFormat };
+    filterProperties.gt = { type: openApiType, format: openApiFormat };
+    filterProperties.gte = { type: openApiType, format: openApiFormat };
+  }
+
+  if (isDateOrTime) {
+    filterProperties.lt = { type: openApiType, format: openApiFormat };
+    filterProperties.lte = { type: openApiType, format: openApiFormat };
+    filterProperties.gt = { type: openApiType, format: openApiFormat };
+    filterProperties.gte = { type: openApiType, format: openApiFormat };
+  }
+
+  if (isString) {
+    filterProperties.contains = { type: 'string' };
+    filterProperties.startsWith = { type: 'string' };
+    filterProperties.endsWith = { type: 'string' };
+    filterProperties.mode = { type: 'string', enum: ['default', 'insensitive'] };
+  }
+
+  return {
+    type: 'object',
+    properties: filterProperties,
+  };
+}
+
+export function columnToFilterSchema(
+  col: ColumnDef,
+  dialect: OpenApiDialect = 'openapi-3.1'
+): OpenApiSchema {
+  const filterSchema = filterFieldToOpenApiSchema(col);
+  const nullable = isNullableColumn(col);
+  return applyNullability(filterSchema, nullable, dialect);
+}
+
+export function whereInputToOpenApiSchema<T extends TableDef | EntityConstructor>(
+  target: T,
+  dialect: OpenApiDialect = 'openapi-3.1'
+): OpenApiSchema {
+  const columns = getColumnMap(target);
+  const properties: Record<string, OpenApiSchema> = {};
+
+  for (const [key, col] of Object.entries(columns)) {
+    properties[key] = columnToFilterSchema(col, dialect);
+  }
+
+  return {
+    type: 'object',
+    properties,
+  };
+}