metal-orm 1.0.91 → 1.0.92

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.0.91",
+  "version": "1.0.92",
   "type": "module",
   "types": "./dist/index.d.ts",
   "engines": {

package/scripts/generate-entities/render.mjs

@@ -4,6 +4,14 @@ import { buildSchemaMetadata } from './schema.mjs';
 
 const escapeJsString = value => value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
 
+const sanitizePropertyName = columnName => {
+  if (!columnName) return '';
+  return columnName
+    .replace(/\s+/g, '_')
+    .replace(/[^a-zA-Z0-9_$]/g, '_')
+    .replace(/^[0-9]/, '_$&');
+};
+
 const formatJsDoc = comment => {
   if (!comment) return null;
   const normalized = comment.replace(/\r\n?/g, '\n').trim();
@@ -159,7 +167,7 @@ const buildColumnDoc = column => {
   return entries.join('\n');
 };
 
-const renderColumnExpression = (column, tablePk, tableSchema, defaultSchema) => {
+const renderColumnExpression = (column, tablePk, tableSchema, defaultSchema, propertyName) => {
   const base = parseColumnType(column.type);
   let expr = base.factory;
 
@@ -198,6 +206,10 @@ const renderColumnExpression = (column, tablePk, tableSchema, defaultSchema) =>
   const tsType = base.ts || 'any';
   const optional = !column.notNull;
 
+  if (column.name !== propertyName) {
+    expr = `{ ...${expr}, name: '${escapeJsString(column.name)}' }`;
+  }
+
   return {
     decorator,
     expr,
@@ -236,10 +248,11 @@ const renderEntityClassLines = ({ table, className, naming, relations, resolveCl
   lines.push(`export class ${className} {`);
 
   for (const col of table.columns) {
-    const rendered = renderColumnExpression(col, table.primaryKey, table.schema, defaultSchema);
+    const propertyName = sanitizePropertyName(col.name);
+    const rendered = renderColumnExpression(col, table.primaryKey, table.schema, defaultSchema, propertyName);
     appendJsDoc(lines, rendered.comment, '  ');
     lines.push(`  @${rendered.decorator}(${rendered.expr})`);
-    lines.push(`  ${col.name}${rendered.optional ? '?:' : '!:'} ${rendered.tsType};`);
+    lines.push(`  ${propertyName}${rendered.optional ? '?:' : '!:'} ${rendered.tsType};`);
     lines.push('');
   }
 

package/src/decorators/column-decorator.ts

@@ -12,6 +12,7 @@ export interface ColumnOptions {
   notNull?: boolean;
   primary?: boolean;
   tsType?: ColumnDef['tsType'];
+  name?: string;
 }
 
 /**
@@ -35,7 +36,8 @@ const normalizeColumnInput = (input: ColumnInput): ColumnDefLike => {
     generated: asDefinition.generated,
     check: asDefinition.check,
     references: asDefinition.references,
-    comment: asDefinition.comment
+    comment: asDefinition.comment,
+    name: asOptions.name ?? asDefinition.name
   };
 
   if (!column.type) {

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

@@ -1,23 +1,26 @@
 import type { ColumnDef } from '../../../schema/column-types.js';
-import type { OpenApiSchema } from '../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): OpenApiSchema {
+export function columnToOpenApiSchema(
+  col: ColumnDef,
+  dialect: OpenApiDialect = 'openapi-3.1'
+): OpenApiSchema {
   const schema: OpenApiSchema = {
     type: columnTypeToOpenApiType(col),
     format: columnTypeToOpenApiFormat(col),
   };
 
-  if (!col.notNull) {
-    schema.nullable = true;
-  }
+  const nullable = isNullableColumn(col);
+  const result = applyNullability(schema, nullable, dialect);
 
   if (col.comment) {
-    schema.description = col.comment;
+    result.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[];
+    result.enum = col.args as string[];
   }
 
   const args = col.args;
@@ -25,10 +28,10 @@ export function columnToOpenApiSchema(col: ColumnDef): OpenApiSchema {
     if (col.type.toUpperCase() === 'VARCHAR' || col.type.toUpperCase() === 'CHAR') {
       const length = args[0] as number;
       if (length) {
-        schema.example = 'a'.repeat(length);
+        result.example = 'a'.repeat(length);
       }
     }
   }
 
-  return schema;
+  return result;
 }

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

@@ -1,13 +1,14 @@
 import type { TableDef } from '../../../schema/table.js';
 import type { EntityConstructor } from '../../../orm/entity-metadata.js';
-import type { OpenApiSchema } from '../types.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[]
+  exclude?: TExclude[],
+  dialect: OpenApiDialect = 'openapi-3.1'
 ): OpenApiSchema {
   const columns = getColumnMap(target);
   const properties: Record<string, OpenApiSchema> = {};
@@ -18,7 +19,7 @@ export function dtoToOpenApiSchema<T extends TableDef | EntityConstructor, TExcl
       continue;
     }
 
-    properties[key] = columnToOpenApiSchema(col);
+    properties[key] = columnToOpenApiSchema(col, dialect);
 
     if (col.notNull || col.primary) {
       required.push(key);
@@ -35,7 +36,8 @@ export function dtoToOpenApiSchema<T extends TableDef | EntityConstructor, TExcl
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function createDtoToOpenApiSchema<T extends TableDef | EntityConstructor, TExclude extends keyof any>(
   target: T,
-  exclude?: TExclude[]
+  exclude?: TExclude[],
+  dialect: OpenApiDialect = 'openapi-3.1'
 ): OpenApiSchema {
   const columns = getColumnMap(target);
   const properties: Record<string, OpenApiSchema> = {};
@@ -50,7 +52,7 @@ export function createDtoToOpenApiSchema<T extends TableDef | EntityConstructor,
       continue;
     }
 
-    properties[key] = columnToOpenApiSchema(col);
+    properties[key] = columnToOpenApiSchema(col, dialect);
 
     if (col.notNull && !col.default) {
       required.push(key);
@@ -67,7 +69,8 @@ export function createDtoToOpenApiSchema<T extends TableDef | EntityConstructor,
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function updateDtoToOpenApiSchema<T extends TableDef | EntityConstructor, TExclude extends keyof any>(
   target: T,
-  exclude?: TExclude[]
+  exclude?: TExclude[],
+  dialect: OpenApiDialect = 'openapi-3.1'
 ): OpenApiSchema {
   const columns = getColumnMap(target);
   const properties: Record<string, OpenApiSchema> = {};
@@ -81,10 +84,7 @@ export function updateDtoToOpenApiSchema<T extends TableDef | EntityConstructor,
       continue;
     }
 
-    properties[key] = {
-      ...columnToOpenApiSchema(col),
-      ...(!col.notNull ? { nullable: true } : {}),
-    };
+    properties[key] = columnToOpenApiSchema(col, dialect);
   }
 
   return {

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

@@ -1,54 +1,45 @@
 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 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 normalizedType = col.type.toUpperCase();
-  columnTypeToOpenApiType(col);
-  
-  let filterProperties: Record<string, OpenApiSchema> = {};
+  const openApiType = columnTypeToOpenApiType(col);
+  const openApiFormat = columnTypeToOpenApiFormat(col);
 
-  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'] },
-    };
+  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 {
@@ -57,14 +48,24 @@ function filterFieldToOpenApiSchema(col: ColumnDef): OpenApiSchema {
   };
 }
 
+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
+  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] = filterFieldToOpenApiSchema(col);
+    properties[key] = columnToFilterSchema(col, dialect);
   }
 
   return {

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

@@ -7,8 +7,9 @@ import type {
     HasOneRelation,
     BelongsToManyRelation
 } from '../../../schema/relation.js';
-import type { OpenApiSchema, OpenApiComponent } from '../types.js';
+import type { OpenApiSchema, OpenApiComponent, OpenApiDialect, OpenApiParameterObject, OpenApiResponseObject } from '../types.js';
 import { columnToOpenApiSchema } from './column.js';
+import { columnToFilterSchema } from './filter.js';
 import { getColumnMap } from './base.js';
 import { RelationKinds } from '../../../schema/relation.js';
 
@@ -125,10 +126,7 @@ export function updateDtoWithRelationsToOpenApiSchema<T extends TableDef | Entit
             continue;
         }
 
-        properties[key] = {
-            ...columnToOpenApiSchema(col),
-            nullable: true,
-        };
+        properties[key] = columnToOpenApiSchema(col);
     }
 
     const tableDef = target as TableDef;
@@ -159,10 +157,7 @@ function updateDtoToOpenApiSchemaForComponent(
             continue;
         }
 
-        properties[key] = {
-            ...columnToOpenApiSchema(col),
-            nullable: true,
-        };
+        properties[key] = columnToOpenApiSchema(col);
     }
 
     return {
@@ -270,7 +265,8 @@ function whereInputWithRelationsToOpenApiSchema(
         relationInclude?: string[];
         maxDepth?: number;
         prefix?: string;
-    }
+    },
+    dialect: OpenApiDialect = 'openapi-3.1'
 ): OpenApiSchema {
     const columns = getColumnMap(target);
     const properties: Record<string, OpenApiSchema> = {};
@@ -285,7 +281,7 @@ function whereInputWithRelationsToOpenApiSchema(
             continue;
         }
 
-        properties[key] = columnToOpenApiSchema(col);
+        properties[key] = columnToFilterSchema(col, dialect);
     }
 
     const tableDef = target as TableDef;
@@ -300,9 +296,9 @@ function whereInputWithRelationsToOpenApiSchema(
             }
 
             properties[relationName] = relationFilterToOpenApiSchema(relation, {
-                exclude: options?.columnExclude,
-                include: options?.columnInclude,
-            });
+                exclude: options.columnExclude,
+                include: options.columnInclude,
+            }, dialect);
         }
     }
 
@@ -317,10 +313,11 @@ function relationFilterToOpenApiSchema(
     options?: {
         exclude?: string[];
         include?: string[];
-    }
+    },
+    dialect: OpenApiDialect = 'openapi-3.1'
 ): 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);
     }
 
     if (relation.type === RelationKinds.HasMany || relation.type === RelationKinds.BelongsToMany) {
@@ -332,7 +329,8 @@ function relationFilterToOpenApiSchema(
 
 function singleRelationFilterToOpenApiSchema(
     target: TableDef | EntityConstructor,
-    options?: { exclude?: string[]; include?: string[] }
+    options?: { exclude?: string[]; include?: string[] },
+    dialect: OpenApiDialect = 'openapi-3.1'
 ): OpenApiSchema {
     const columns = getColumnMap(target);
     const properties: Record<string, OpenApiSchema> = {};
@@ -346,7 +344,7 @@ function singleRelationFilterToOpenApiSchema(
             continue;
         }
 
-        properties[key] = columnToOpenApiSchema(col);
+        properties[key] = columnToFilterSchema(col, dialect);
     }
 
     return {
@@ -395,7 +393,7 @@ function generateNestedProperties(
     const properties: Record<string, OpenApiSchema> = {};
 
     for (const [key, col] of Object.entries(columns)) {
-        properties[key] = columnToOpenApiSchema(col);
+        properties[key] = columnToFilterSchema(col);
     }
 
     return properties;
@@ -403,8 +401,8 @@ function generateNestedProperties(
 
 export function createApiComponentsSection(
     schemas: Record<string, OpenApiSchema>,
-    parameters?: Record<string, OpenApiSchema>,
-    responses?: Record<string, OpenApiSchema>
+    parameters?: Record<string, OpenApiParameterObject>,
+    responses?: Record<string, OpenApiResponseObject>
 ): OpenApiComponent {
     const component: OpenApiComponent = {};
 
@@ -439,6 +437,94 @@ export function responseToRef(responseName: string): ComponentReference {
     return createRef(`responses/${responseName}`);
 }
 
+export function canonicalizeSchema(schema: OpenApiSchema): OpenApiSchema {
+    if (typeof schema !== 'object' || schema === null) {
+        return schema;
+    }
+
+    if (Array.isArray(schema)) {
+        return schema.map(canonicalizeSchema) as unknown as OpenApiSchema;
+    }
+
+    const canonical: OpenApiSchema = {};
+
+    const keys = Object.keys(schema).sort();
+
+    for (const key of keys) {
+        if (key === 'description' || key === 'example') {
+            continue;
+        }
+
+        const value = schema[key as keyof OpenApiSchema];
+
+        if (typeof value === 'object' && value !== null) {
+            (canonical as Record<string, unknown>)[key] = canonicalizeSchema(value as OpenApiSchema);
+        } else {
+            (canonical as Record<string, unknown>)[key] = value;
+        }
+    }
+
+    return canonical;
+}
+
+export function computeSchemaHash(schema: OpenApiSchema): string {
+    const canonical = canonicalizeSchema(schema);
+    const json = JSON.stringify(canonical);
+    let hash = 0;
+
+    for (let i = 0; i < json.length; i++) {
+        const char = json.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash;
+    }
+
+    const hex = Math.abs(hash).toString(16);
+    return hex.padStart(8, '0').slice(0, 6);
+}
+
+interface DeterministicNamingState {
+    contentHashToName: Map<string, string>;
+    nameToContentHash: Map<string, string>;
+}
+
+export function createDeterministicNamingState(): DeterministicNamingState {
+    return {
+        contentHashToName: new Map(),
+        nameToContentHash: new Map(),
+    };
+}
+
+export function getDeterministicComponentName(
+    baseName: string,
+    schema: OpenApiSchema,
+    state: DeterministicNamingState
+): string {
+    const hash = computeSchemaHash(schema);
+    const normalizedBase = baseName.replace(/[^A-Za-z0-9_]/g, '');
+
+    const existingName = state.contentHashToName.get(hash);
+    if (existingName) {
+        return existingName;
+    }
+
+    if (!state.nameToContentHash.has(normalizedBase)) {
+        state.contentHashToName.set(hash, normalizedBase);
+        state.nameToContentHash.set(normalizedBase, hash);
+        return normalizedBase;
+    }
+
+    const existingHash = state.nameToContentHash.get(normalizedBase)!;
+    if (existingHash === hash) {
+        return normalizedBase;
+    }
+
+    const uniqueName = `${normalizedBase}_${hash}`;
+    state.contentHashToName.set(hash, uniqueName);
+    state.nameToContentHash.set(uniqueName, hash);
+
+    return uniqueName;
+}
+
 export function replaceWithRefs(
     schema: OpenApiSchema,
     schemaMap: Record<string, OpenApiSchema>,