metal-orm 1.0.93 → 1.0.95

package/src/decorators/validators/country-validators.ts

@@ -0,0 +1,105 @@
+/**
+ * Base interface for country-specific identifier validators
+ */
+export interface CountryValidator<T = string> {
+  /** ISO 3166-1 alpha-2 country code (e.g., 'BR', 'US') */
+  readonly countryCode: string;
+  
+  /** Identifier type (e.g., 'cpf', 'cnpj', 'ssn', 'zip') */
+  readonly identifierType: string;
+  
+  /** Unique validator name (e.g., 'br-cpf', 'us-ssn') */
+  readonly name: string;
+  
+  /**
+   * Validates an identifier value
+   * @param value - The identifier value to validate
+   * @param options - Validation options
+   * @returns Validation result with success status and optional error message
+   */
+  validate(value: T, options?: ValidationOptions): ValidationResult;
+  
+  /**
+   * Normalizes an identifier value (removes formatting, standardizes)
+   * @param value - The identifier value to normalize
+   * @returns Normalized value (digits only, uppercase, etc.)
+   */
+  normalize(value: T): string;
+  
+  /**
+   * Formats an identifier value according to country standards
+   * @param value - The identifier value to format (can be normalized or formatted)
+   * @returns Formatted value (e.g., '123.456.789-01' for CPF)
+   */
+  format(value: T): string;
+  
+  /**
+   * Attempts to auto-correct an invalid value
+   * @param value - The invalid value to correct
+   * @returns Auto-correction result or undefined if not possible
+   */
+  autoCorrect?(value: T): AutoCorrectionResult<T>;
+}
+
+/**
+ * Validation options for country identifiers
+ */
+export interface ValidationOptions {
+  /** Whether to allow formatted input (e.g., '123.456.789-01') */
+  allowFormatted?: boolean;
+  
+  /** Whether to allow normalized input (e.g., '12345678901') */
+  allowNormalized?: boolean;
+  
+  /** Whether to perform strict validation (e.g., check for known invalid numbers) */
+  strict?: boolean;
+  
+  /** Custom error message */
+  errorMessage?: string;
+}
+
+/**
+ * Validation result
+ */
+export interface ValidationResult {
+  /** Whether validation passed */
+  isValid: boolean;
+  
+  /** Error message if validation failed */
+  error?: string;
+  
+  /** Normalized value (if validation passed) */
+  normalizedValue?: string;
+  
+  /** Formatted value (if validation passed) */
+  formattedValue?: string;
+}
+
+/**
+ * Auto-correction result
+ */
+export interface AutoCorrectionResult<T = string> {
+  /** Whether auto-correction was successful */
+  success: boolean;
+  
+  /** Corrected value */
+  correctedValue?: T;
+  
+  /** Description of what was corrected */
+  message?: string;
+}
+
+// Country Validator Factory
+export type CountryValidatorFactory<T = string> = (options?: ValidatorFactoryOptions) => CountryValidator<T>;
+
+// Options for creating a validator instance
+export interface ValidatorFactoryOptions {
+  /** Custom validation rules */
+  customRules?: Record<string, unknown>;
+  
+  /** Whether to enable strict mode by default */
+  strict?: boolean;
+  
+  /** Custom error messages */
+  errorMessages?: Record<string, string>;
+}

package/src/decorators/validators/validator-metadata.ts

@@ -0,0 +1,59 @@
+/**
+ * Validation options for country identifiers
+ */
+export interface ValidationOptions {
+  /** Whether to allow formatted input (e.g., '123.456.789-01') */
+  allowFormatted?: boolean;
+  
+  /** Whether to allow normalized input (e.g., '12345678901') */
+  allowNormalized?: boolean;
+  
+  /** Whether to perform strict validation (e.g., check for known invalid numbers) */
+  strict?: boolean;
+  
+  /** Custom error message */
+  errorMessage?: string;
+}
+
+/**
+ * Validation result
+ */
+export interface ValidationResult {
+  /** Whether validation passed */
+  isValid: boolean;
+  
+  /** Error message if validation failed */
+  error?: string;
+  
+  /** Normalized value (if validation passed) */
+  normalizedValue?: string;
+  
+  /** Formatted value (if validation passed) */
+  formattedValue?: string;
+}
+
+/**
+ * Auto-correction result
+ */
+export interface AutoCorrectionResult<T = string> {
+  /** Whether auto-correction was successful */
+  success: boolean;
+  
+  /** Corrected value */
+  correctedValue?: T;
+  
+  /** Description of what was corrected */
+  message?: string;
+}
+
+// Options for creating a validator instance
+export interface ValidatorFactoryOptions {
+  /** Custom validation rules */
+  customRules?: Record<string, unknown>;
+  
+  /** Whether to enable strict mode by default */
+  strict?: boolean;
+  
+  /** Custom error messages */
+  errorMessages?: Record<string, string>;
+}

package/src/dto/openapi/utilities.ts

@@ -26,6 +26,7 @@ export function applyNullability(
   dialect: OpenApiDialect
 ): OpenApiSchema {
   if (!isNullable) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const { nullable: _, ...clean } = schema;
     return clean;
   }
@@ -37,17 +38,21 @@ export function applyNullability(
   const type = schema.type;
   if (Array.isArray(type)) {
     if (!type.includes('null')) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
       const { nullable: _, ...clean } = schema;
       return { ...clean, type: [...type, 'null'] as OpenApiType[] };
     }
   } else if (type) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const { nullable: _, ...clean } = schema;
     return { ...clean, type: [type, 'null'] as OpenApiType[] };
   } else {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const { nullable: _, ...clean } = schema;
     return { ...clean, type: ['null'] as OpenApiType[] };
   }
 
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   const { nullable: _, ...clean } = schema;
   return clean;
 }

package/src/index.ts

@@ -33,9 +33,10 @@ export * from './core/functions/array.js';
 export * from './orm/als.js';
 export * from './orm/hydration.js';
 export * from './codegen/typescript.js';
-export * from './orm/orm-session.js';
-export * from './orm/orm.js';
-export * from './orm/entity.js';
+export * from './orm/orm-session.js';
+export * from './orm/orm.js';
+export * from './orm/column-introspection.js';
+export * from './orm/entity.js';
 export * from './orm/lazy-batch.js';
 export * from './orm/relations/has-many.js';
 export * from './orm/relations/belongs-to.js';

package/src/orm/column-introspection.ts

@@ -0,0 +1,43 @@
+import { normalizeColumnType } from '../schema/column-types.js';
+import type { ColumnType } from '../schema/column-types.js';
+import type { TableDef } from '../schema/table.js';
+import type { ColumnDefLike, EntityConstructor } from './entity-metadata.js';
+import { getEntityMetadata } from './entity-metadata.js';
+
+type ColumnTarget = TableDef | EntityConstructor;
+
+const getColumnDefFromTarget = (
+  target: ColumnTarget,
+  column: string
+): ColumnDefLike | undefined => {
+  if (typeof target === 'function') {
+    const meta = getEntityMetadata(target);
+    if (!meta?.columns) return undefined;
+    return meta.columns[column];
+  }
+
+  const table = target as TableDef;
+  return table.columns[column];
+};
+
+export const getColumnType = (
+  target: ColumnTarget,
+  column: string
+): ColumnType | undefined => {
+  const col = getColumnDefFromTarget(target, column);
+  if (!col?.type) return undefined;
+  return normalizeColumnType(col.type);
+};
+
+export const getDateKind = (
+  target: ColumnTarget,
+  column: string
+): 'date' | 'date-time' | undefined => {
+  const type = getColumnType(target, column);
+  if (!type) return undefined;
+  if (type === 'date') return 'date';
+  if (type === 'datetime' || type === 'timestamp' || type === 'timestamptz') {
+    return 'date-time';
+  }
+  return undefined;
+};

package/src/orm/entity-metadata.ts

@@ -1,6 +1,7 @@
 import { ColumnDef } from '../schema/column-types.js';
 import { defineTable, TableDef, TableHooks } from '../schema/table.js';
 import { CascadeMode, RelationKinds } from '../schema/relation.js';
+import type { TransformerMetadata } from '../decorators/transformers/transformer-metadata.js';
 
 /**
  * Constructor type for entities.
@@ -21,11 +22,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, '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.
@@ -53,26 +54,26 @@ interface BaseRelationMetadata {
 /**
  * Metadata for has many relations.
  */
-export interface HasManyRelationMetadata extends BaseRelationMetadata {
-  /** The relation kind */
-  kind: typeof RelationKinds.HasMany;
-  /** The foreign key */
-  foreignKey?: string;
-  /** Optional local key */
-  localKey?: string;
-}
+export interface HasManyRelationMetadata extends BaseRelationMetadata {
+  /** The relation kind */
+  kind: typeof RelationKinds.HasMany;
+  /** The foreign key */
+  foreignKey?: string;
+  /** Optional local key */
+  localKey?: string;
+}
 
 /**
  * Metadata for has one relations.
  */
-export interface HasOneRelationMetadata extends BaseRelationMetadata {
-  /** The relation kind */
-  kind: typeof RelationKinds.HasOne;
-  /** The foreign key */
-  foreignKey?: string;
-  /** Optional local key */
-  localKey?: string;
-}
+export interface HasOneRelationMetadata extends BaseRelationMetadata {
+  /** The relation kind */
+  kind: typeof RelationKinds.HasOne;
+  /** The foreign key */
+  foreignKey?: string;
+  /** Optional local key */
+  localKey?: string;
+}
 
 /**
  * Metadata for belongs to relations.
@@ -89,20 +90,20 @@ export interface BelongsToRelationMetadata extends BaseRelationMetadata {
 /**
  * Metadata for belongs to many relations.
  */
-export interface BelongsToManyRelationMetadata extends BaseRelationMetadata {
-  /** The relation kind */
-  kind: typeof RelationKinds.BelongsToMany;
-  /** The pivot table */
-  pivotTable: EntityOrTableTargetResolver;
-  /** The pivot foreign key to root */
-  pivotForeignKeyToRoot?: string;
-  /** The pivot foreign key to target */
-  pivotForeignKeyToTarget?: string;
-  /** Optional local key */
-  localKey?: string;
-  /** Optional target key */
-  targetKey?: string;
-  /** Optional pivot primary key */
+export interface BelongsToManyRelationMetadata extends BaseRelationMetadata {
+  /** The relation kind */
+  kind: typeof RelationKinds.BelongsToMany;
+  /** The pivot table */
+  pivotTable: EntityOrTableTargetResolver;
+  /** The pivot foreign key to root */
+  pivotForeignKeyToRoot?: string;
+  /** The pivot foreign key to target */
+  pivotForeignKeyToTarget?: string;
+  /** Optional local key */
+  localKey?: string;
+  /** Optional target key */
+  targetKey?: string;
+  /** Optional pivot primary key */
   pivotPrimaryKey?: string;
   /** Optional default pivot columns */
   defaultPivotColumns?: string[];
@@ -130,6 +131,8 @@ export interface EntityMetadata<TColumns extends Record<string, ColumnDefLike> =
   columns: TColumns;
   /** The relations */
   relations: Record<string, RelationMetadata>;
+  /** The transformers */
+  transformers: Record<string, TransformerMetadata>;
   /** Optional hooks */
   hooks?: TableHooks;
   /** Optional table definition */
@@ -158,7 +161,8 @@ export const ensureEntityMetadata = (target: EntityConstructor): EntityMetadata
       target,
       tableName: target.name || 'unknown',
       columns: {},
-      relations: {}
+      relations: {},
+      transformers: {}
     };
     metadataMap.set(target, meta);
   }
@@ -219,6 +223,21 @@ export const addRelationMetadata = (
   meta.relations[propertyKey] = relation;
 };
 
+/**
+ * Adds transformer metadata to an entity.
+ * @param target - The entity constructor
+ * @param propertyKey - The property key
+ * @param transformer - The transformer metadata
+ */
+export const addTransformerMetadata = (
+  target: EntityConstructor,
+  propertyKey: string,
+  transformer: TransformerMetadata
+): void => {
+  const meta = ensureEntityMetadata(target);
+  meta.transformers[propertyKey] = transformer;
+};
+
 /**
  * Sets the table name and hooks for an entity.
  * @param target - The entity constructor
@@ -250,15 +269,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: 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;