metal-orm 1.1.2 → 1.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "type": "module",
   "types": "./dist/index.d.ts",
   "engines": {
@@ -44,7 +44,8 @@
     "pg": "^8.0.0",
     "sqlite3": "^5.1.6",
     "tedious": "^19.0.0",
-    "keyv": "^5.6.0"
+    "keyv": "^5.6.0",
+    "ioredis": "^5.0.0"
   },
   "peerDependenciesMeta": {
     "mysql2": {
@@ -61,6 +62,9 @@
     },
     "keyv": {
       "optional": true
+    },
+    "ioredis": {
+      "optional": true
     }
   },
   "devDependencies": {
@@ -70,6 +74,8 @@
     "@vitest/ui": "^4.0.18",
     "eslint": "^9.39.2",
     "express": "^5.2.1",
+    "ioredis": "^5.6.1",
+    "ioredis-mock": "^8.9.0",
     "keyv": "^5.6.0",
     "mysql-memory-server": "^1.14.0",
     "mysql2": "^3.16.2",

package/scripts/naming-strategy.mjs

@@ -95,10 +95,25 @@ export class BaseNamingStrategy {
 
   belongsToProperty(foreignKeyName, targetTable) {
     const trimmed = foreignKeyName.replace(/_?id$/i, '');
-    const base = trimmed && trimmed !== foreignKeyName ? trimmed : this.singularize(targetTable);
+    const targetBase = this.singularize(this.normalizeTableName(targetTable));
+    // If FK name ends with _id, use the trimmed version
+    // If FK name doesn't end with _id but is different from target table name, use the FK name (e.g., "criador", "responsavel_judicial")
+    // Otherwise fallback to target table name
+    const base = trimmed && trimmed !== foreignKeyName
+      ? trimmed
+      : trimmed && this.toCamelCase(trimmed) !== this.toCamelCase(targetBase)
+        ? trimmed
+        : targetBase;
     return this.toCamelCase(base);
   }
 
+  normalizeTableName(tableName) {
+    // Strip schema prefix if present (e.g., "dbo.usuario" -> "usuario")
+    return typeof tableName === 'string' && tableName.includes('.')
+      ? tableName.split('.').pop()
+      : tableName;
+  }
+
   hasManyProperty(targetTable) {
     const base = this.singularize(targetTable);
     const plural = this.inflector.pluralizeRelationProperty

package/src/cache/adapters/keyv-cache-adapter.ts

@@ -19,6 +19,11 @@ interface KeyvInstance {
  */
 export class KeyvCacheAdapter implements CacheProvider {
   readonly name = 'keyv';
+  readonly capabilities = {
+    tags: false,
+    prefix: true,
+    ttl: true,
+  };
 
   constructor(private keyv: KeyvInstance) {}
 

package/src/cache/adapters/memory-cache-adapter.ts

@@ -11,6 +11,11 @@ interface CacheEntry<T> {
  */
 export class MemoryCacheAdapter implements CacheProvider {
   readonly name = 'memory';
+  readonly capabilities = {
+    tags: true,
+    prefix: true,
+    ttl: true,
+  };
   private storage: Map<string, CacheEntry<unknown>> = new Map();
   private tagIndex: Map<string, Set<string>> = new Map();
 

package/src/cache/adapters/redis-cache-adapter.ts

@@ -0,0 +1,233 @@
+import type { CacheProvider } from '../cache-interfaces.js';
+
+// Tipos mínimos para ioredis (para evitar dependência obrigatória)
+interface RedisLike {
+  get(key: string): Promise<string | null>;
+  set(key: string, value: string, ...args: (string | number)[]): Promise<string | null>;
+  del(...keys: string[]): Promise<number>;
+  sadd(key: string, ...members: string[]): Promise<number>;
+  smembers(key: string): Promise<string[]>;
+  srem(key: string, ...members: string[]): Promise<number>;
+  scan(cursor: string | number, ...args: (string | number)[]): Promise<[string, string[]]>;
+  quit(): Promise<string>;
+  disconnect(): void;
+  isReady?: boolean;
+  status?: string;
+}
+
+interface RedisOptions {
+  host?: string;
+  port?: number;
+  password?: string;
+  db?: number;
+  keyPrefix?: string;
+  lazyConnect?: boolean;
+  [key: string]: unknown;
+}
+
+/**
+ * Adapter para Redis usando ioredis
+ * 
+ * Suporta:
+ * - Tags via Redis Sets (SADD, SMEMBERS, SREM)
+ * - Prefix invalidation via SCAN
+ * - TTL nativo do Redis
+ * 
+ * Instalação:
+ * npm install ioredis
+ * 
+ * Para testes (dev):
+ * npm install --save-dev ioredis-mock
+ */
+export class RedisCacheAdapter implements CacheProvider {
+  readonly name = 'redis';
+  readonly capabilities = {
+    tags: true,
+    prefix: true,
+    ttl: true,
+  };
+
+  private redis: RedisLike;
+  private ownsConnection: boolean;
+  private tagPrefix: string;
+
+  /**
+   * Cria um adapter Redis
+   * 
+   * @param redis - Instância do ioredis OU opções de conexão
+   * @param options - Opções adicionais
+   * @param options.tagPrefix - Prefixo para chaves de tag (default: 'tag:')
+   * 
+   * Exemplos:
+   * 
+   * // Com instância existente (recomendado para connection pooling):
+   * const redis = new Redis({ host: 'localhost', port: 6379 });
+   * const adapter = new RedisCacheAdapter(redis);
+   * 
+   * // Com opções (adapter gerencia conexão):
+   * const adapter = new RedisCacheAdapter({ host: 'localhost', port: 6379 });
+   * 
+   * // Para testes com ioredis-mock:
+   * import Redis from 'ioredis-mock';
+   * const adapter = new RedisCacheAdapter(new Redis());
+   */
+  constructor(
+    redis: RedisLike | RedisOptions,
+    options?: { tagPrefix?: string }
+  ) {
+    this.tagPrefix = options?.tagPrefix ?? 'tag:';
+    
+    if (this.isRedisInstance(redis)) {
+      // Recebeu uma instância existente
+      this.redis = redis;
+      this.ownsConnection = false;
+    } else {
+      // Recebeu opções, precisa criar a conexão
+      this.redis = this.createRedis(redis);
+      this.ownsConnection = true;
+    }
+  }
+
+  private isRedisInstance(obj: unknown): obj is RedisLike {
+    return (
+      typeof obj === 'object' &&
+      obj !== null &&
+      'get' in obj &&
+      'set' in obj &&
+      'del' in obj &&
+      typeof (obj as RedisLike).get === 'function'
+    );
+  }
+
+  private createRedis(options: RedisOptions): RedisLike {
+    // Dynamic import para evitar dependência obrigatória
+    try {
+      const Redis = require('ioredis');
+      return new Redis(options) as RedisLike;
+    } catch {
+      throw new Error(
+        'ioredis is required for RedisCacheAdapter. ' +
+        'Install it with: npm install ioredis'
+      );
+    }
+  }
+
+  async get<T>(key: string): Promise<T | undefined> {
+    const value = await this.redis.get(key);
+    if (value === null) {
+      return undefined;
+    }
+    try {
+      return JSON.parse(value) as T;
+    } catch {
+      return undefined;
+    }
+  }
+
+  async has(key: string): Promise<boolean> {
+    const value = await this.redis.get(key);
+    return value !== null;
+  }
+
+  async set<T>(
+    key: string,
+    value: T,
+    ttlMs?: number,
+    tags?: string[]
+  ): Promise<void> {
+    const serialized = JSON.stringify(value);
+    
+    if (ttlMs) {
+      // EX = seconds, PX = milliseconds
+      await this.redis.set(key, serialized, 'PX', ttlMs);
+    } else {
+      await this.redis.set(key, serialized);
+    }
+
+    // Registra tags se fornecidas
+    if (tags && tags.length > 0) {
+      await this.registerTags(key, tags);
+    }
+  }
+
+  async delete(key: string): Promise<void> {
+    await this.redis.del(key);
+  }
+
+  async invalidate(key: string): Promise<void> {
+    await this.delete(key);
+  }
+
+  async invalidateTags(tags: string[]): Promise<void> {
+    const keysToDelete = new Set<string>();
+
+    for (const tag of tags) {
+      const tagKey = `${this.tagPrefix}${tag}`;
+      const keys = await this.redis.smembers(tagKey);
+      
+      for (const key of keys) {
+        keysToDelete.add(key);
+      }
+      
+      // Deleta o set da tag
+      await this.redis.del(tagKey);
+    }
+
+    // Deleta todas as chaves associadas
+    if (keysToDelete.size > 0) {
+      await this.redis.del(...Array.from(keysToDelete));
+    }
+  }
+
+  async invalidatePrefix(prefix: string): Promise<void> {
+    const keysToDelete: string[] = [];
+    let cursor = '0';
+
+    do {
+      const [nextCursor, keys] = await this.redis.scan(
+        cursor,
+        'MATCH',
+        `${prefix}*`,
+        'COUNT',
+        100
+      );
+      cursor = nextCursor;
+      keysToDelete.push(...keys);
+    } while (cursor !== '0');
+
+    if (keysToDelete.length > 0) {
+      // Deleta em batches de 1000 para evitar bloqueio
+      const batchSize = 1000;
+      for (let i = 0; i < keysToDelete.length; i += batchSize) {
+        const batch = keysToDelete.slice(i, i + batchSize);
+        await this.redis.del(...batch);
+      }
+    }
+  }
+
+  private async registerTags(key: string, tags: string[]): Promise<void> {
+    for (const tag of tags) {
+      const tagKey = `${this.tagPrefix}${tag}`;
+      await this.redis.sadd(tagKey, key);
+    }
+  }
+
+  async dispose(): Promise<void> {
+    if (this.ownsConnection) {
+      try {
+        await this.redis.quit();
+      } catch {
+        // Se quit falhar, tenta disconnect
+        this.redis.disconnect?.();
+      }
+    }
+  }
+
+  /**
+   * Retorna a instância Redis subjacente
+   * Útil para operações avançadas ou health checks
+   */
+  getRedis(): RedisLike {
+    return this.redis;
+  }
+}

package/src/cache/cache-interfaces.ts

@@ -27,11 +27,22 @@ export interface CacheInvalidator {
   invalidatePrefix(prefix: string): Promise<void>;
 }
 
+/**
+ * Capabilities de um cache provider
+ * Permite detectar funcionalidades suportadas em runtime
+ */
+export interface CacheCapabilities {
+  tags: boolean;
+  prefix: boolean;
+  ttl: boolean;
+}
+
 /**
  * Interface completa para implementações full-featured
  */
 export interface CacheProvider extends CacheReader, CacheWriter, CacheInvalidator {
   readonly name: string;
+  readonly capabilities: CacheCapabilities;
   dispose?(): Promise<void>;
 }
 

package/src/cache/index.ts

@@ -4,6 +4,7 @@ export type {
   CacheWriter,
   CacheInvalidator,
   CacheProvider,
+  CacheCapabilities,
   Duration,
   CacheOptions,
   InvalidationStrategy,
@@ -20,6 +21,7 @@ export { DefaultCacheStrategy } from './strategies/default-cache-strategy.js';
 // Adapters
 export { MemoryCacheAdapter } from './adapters/memory-cache-adapter.js';
 export { KeyvCacheAdapter } from './adapters/keyv-cache-adapter.js';
+export { RedisCacheAdapter } from './adapters/redis-cache-adapter.js';
 
 // Manager
 export { QueryCacheManager } from './query-cache-manager.js';

package/src/core/ast/procedure.ts

@@ -0,0 +1,21 @@
+import type { OperandNode } from './expression.js';
+
+export type ProcedureDirection = 'in' | 'out' | 'inout';
+
+export interface ProcedureRefNode {
+  name: string;
+  schema?: string;
+}
+
+export interface ProcedureParamNode {
+  name: string;
+  direction: ProcedureDirection;
+  value?: OperandNode;
+  dbType?: string;
+}
+
+export interface ProcedureCallNode {
+  type: 'ProcedureCall';
+  ref: ProcedureRefNode;
+  params: ProcedureParamNode[];
+}

package/src/core/ast/query.ts

@@ -161,25 +161,53 @@ export interface InsertValuesSourceNode {
   rows: OperandNode[][];
 }
 
-export interface InsertSelectSourceNode {
-  type: 'InsertSelect';
-  /** SELECT query providing rows */
-  query: SelectQueryNode;
-}
-
-export type InsertSourceNode = InsertValuesSourceNode | InsertSelectSourceNode;
-
-export interface InsertQueryNode {
-  type: 'InsertQuery';
-  /** Target table */
-  into: TableNode;
-  /** Column order for inserted values */
-  columns: ColumnNode[];
-  /** Source of inserted rows (either literal values or a SELECT query) */
-  source: InsertSourceNode;
-  /** Optional RETURNING clause */
-  returning?: ColumnNode[];
-}
+export interface InsertSelectSourceNode {
+  type: 'InsertSelect';
+  /** SELECT query providing rows */
+  query: SelectQueryNode;
+}
+
+export type InsertSourceNode = InsertValuesSourceNode | InsertSelectSourceNode;
+
+export interface UpsertConflictTarget {
+  /** Conflict columns (primary key or unique columns) */
+  columns: ColumnNode[];
+  /** Named constraint (PostgreSQL only) */
+  constraint?: string;
+}
+
+export interface UpsertUpdateAction {
+  type: 'DoUpdate';
+  /** Assignments to apply on conflict */
+  set: UpdateAssignmentNode[];
+  /** Optional condition for the update branch */
+  where?: ExpressionNode;
+}
+
+export interface UpsertDoNothingAction {
+  type: 'DoNothing';
+}
+
+export type UpsertAction = UpsertUpdateAction | UpsertDoNothingAction;
+
+export interface UpsertClause {
+  target: UpsertConflictTarget;
+  action: UpsertAction;
+}
+
+export interface InsertQueryNode {
+  type: 'InsertQuery';
+  /** Target table */
+  into: TableNode;
+  /** Column order for inserted values */
+  columns: ColumnNode[];
+  /** Source of inserted rows (either literal values or a SELECT query) */
+  source: InsertSourceNode;
+  /** Optional dialect-specific UPSERT clause */
+  onConflict?: UpsertClause;
+  /** Optional RETURNING clause */
+  returning?: ColumnNode[];
+}
 
 export interface UpdateAssignmentNode {
   /** Column to update */

package/src/core/ddl/introspect/utils.ts

@@ -1,56 +1,56 @@
-import { DbExecutor, QueryResult } from '../../execution/db-executor.js';
-import { IntrospectOptions } from './types.js';
-
-/**
- * Converts a query result to an array of row objects.
- * @param result - The query result.
- * @returns The array of rows.
- */
-export const toRows = (result: QueryResult | undefined): Record<string, unknown>[] => {
-  if (!result) return [];
-  return result.values.map(row =>
-    result.columns.reduce<Record<string, unknown>>((acc, col, idx) => {
-      acc[col] = row[idx];
-      return acc;
-    }, {})
-  );
-};
-
-/**
- * Executes a SQL query and returns the rows.
- * @param executor - The database executor.
- * @param sql - The SQL query.
- * @param params - The query parameters.
- * @returns The array of rows.
- */
-export const queryRows = async (
-  executor: DbExecutor,
-  sql: string,
-  params: unknown[] = []
-): Promise<Record<string, unknown>[]> => {
-  const [first] = await executor.executeSql(sql, params);
-  return toRows(first);
-};
-
-/**
- * Checks if a table should be included in introspection based on options.
- * @param name - The table name.
- * @param options - The introspection options.
- * @returns True if the table should be included.
- */
-export const shouldIncludeTable = (name: string, options: IntrospectOptions): boolean => {
-  if (options.includeTables && !options.includeTables.includes(name)) return false;
-  if (options.excludeTables && options.excludeTables.includes(name)) return false;
-  return true;
-};
-
-/**
- * Checks if a view should be included in introspection based on options.
- * @param name - The view name.
- * @param options - The introspection options.
- * @returns True if the view should be included.
- */
-export const shouldIncludeView = (name: string, options: IntrospectOptions): boolean => {
-  if (options.excludeViews && options.excludeViews.includes(name)) return false;
-  return true;
-};
+import { DbExecutor, QueryResult } from '../../execution/db-executor.js';
+import { IntrospectOptions } from './types.js';
+
+/**
+ * Converts a query result to an array of row objects.
+ * @param result - The query result.
+ * @returns The array of rows.
+ */
+export const toRows = (result: QueryResult | undefined): Record<string, unknown>[] => {
+  if (!result) return [];
+  return result.values.map(row =>
+    result.columns.reduce<Record<string, unknown>>((acc, col, idx) => {
+      acc[col] = row[idx];
+      return acc;
+    }, {})
+  );
+};
+
+/**
+ * Executes a SQL query and returns the rows.
+ * @param executor - The database executor.
+ * @param sql - The SQL query.
+ * @param params - The query parameters.
+ * @returns The array of rows.
+ */
+export const queryRows = async (
+  executor: DbExecutor,
+  sql: string,
+  params: unknown[] = []
+): Promise<Record<string, unknown>[]> => {
+  const [first] = await executor.executeSql(sql, params);
+  return toRows(first);
+};
+
+/**
+ * Checks if a table should be included in introspection based on options.
+ * @param name - The table name.
+ * @param options - The introspection options.
+ * @returns True if the table should be included.
+ */
+export const shouldIncludeTable = (name: string, options: IntrospectOptions): boolean => {
+  if (options.includeTables && !options.includeTables.includes(name)) return false;
+  if (options.excludeTables && options.excludeTables.includes(name)) return false;
+  return true;
+};
+
+/**
+ * Checks if a view should be included in introspection based on options.
+ * @param name - The view name.
+ * @param options - The introspection options.
+ * @returns True if the view should be included.
+ */
+export const shouldIncludeView = (name: string, options: IntrospectOptions): boolean => {
+  if (options.excludeViews && options.excludeViews.includes(name)) return false;
+  return true;
+};