@wearesage/schema/__tests__/adapters/interface.test.ts

A flexible schema definition and validation system for TypeScript with multi-database support

import "reflect-metadata";
import { 
  DatabaseAdapter, 
  DatabaseAdapterRegistry, 
  DatabaseAdapter as DatabaseAdapterDecorator
} from "../../adapters/interface";
import { Entity } from "../../core/decorators";

describe("DatabaseAdapterRegistry", () => {
  test("should register and retrieve adapter entities", () => {
    // Create a registry instance
    const registry = new DatabaseAdapterRegistry();
    
    // Define base and adapter entities
    @Entity()
    class BaseEntity {}
    
    @DatabaseAdapterDecorator("MongoDB")
    class MongoDBEntity extends BaseEntity {}
    
    // Register adapter entity manually
    registry.registerAdapterEntity("MongoDB", BaseEntity, MongoDBEntity);
    
    // Retrieve adapter entity
    const retrievedEntity = registry.getAdapterEntity("MongoDB", BaseEntity);
    expect(retrievedEntity).toBe(MongoDBEntity);
  });

  test("should get all adapter entities for a database type", () => {
    // Create a registry instance
    const registry = new DatabaseAdapterRegistry();
    
    // Define multiple base and adapter entities
    @Entity()
    class BaseEntity1 {}
    
    @Entity()
    class BaseEntity2 {}
    
    @DatabaseAdapterDecorator("Neo4j")
    class Neo4jEntity1 extends BaseEntity1 {}
    
    @DatabaseAdapterDecorator("Neo4j")
    class Neo4jEntity2 extends BaseEntity2 {}
    
    // Register adapter entities manually
    registry.registerAdapterEntity("Neo4j", BaseEntity1, Neo4jEntity1);
    registry.registerAdapterEntity("Neo4j", BaseEntity2, Neo4jEntity2);
    
    // Get all Neo4j adapter entities
    const allNeo4jEntities = registry.getAllAdapterEntities("Neo4j");
    expect(allNeo4jEntities).toBeDefined();
    expect(allNeo4jEntities?.get(BaseEntity1)).toBe(Neo4jEntity1);
    expect(allNeo4jEntities?.get(BaseEntity2)).toBe(Neo4jEntity2);
    expect(allNeo4jEntities?.size).toBe(2);
  });

  test("should handle non-existent database type", () => {
    // Create a registry instance
    const registry = new DatabaseAdapterRegistry();
    
    // Attempt to get adapter entity for non-existent database type
    const entity = registry.getAdapterEntity("NonExistentDB", class {});
    expect(entity).toBeUndefined();
    
    // Attempt to get all adapter entities for non-existent database type
    const allEntities = registry.getAllAdapterEntities("NonExistentDB");
    expect(allEntities).toBeUndefined();
  });

  test("should use the shared instance for decorator registration", () => {
    // Reset the registry to avoid interference from other tests
    // (in a real application, we'd use dependency injection instead)
    const sharedRegistry = DatabaseAdapterRegistry.getInstance();
    
    // Define base and adapter entities using the decorator
    @Entity()
    class MyEntity {}
    
    @DatabaseAdapterDecorator("PostgreSQL")
    class PostgreSQLEntity extends MyEntity {}
    
    // The decorator should have registered with the shared instance
    const retrievedEntity = sharedRegistry.getAdapterEntity("PostgreSQL", MyEntity);
    expect(retrievedEntity).toBe(PostgreSQLEntity);
  });

  test("DatabaseAdapter decorator should set dbType property", () => {
    // Define entity with decorator
    @Entity()
    class BaseEntity {}
    
    @DatabaseAdapterDecorator("MongoDB")
    class MongoDBEntity extends BaseEntity {}
    
    // Check if dbType property was set
    expect((MongoDBEntity as any).dbType).toBe("MongoDB");
  });
});