@martel/calyx 1.11.0 → 1.13.0

package/src/core/index.ts

@@ -3,3 +3,5 @@ export * from './decorators.ts';
 export * from './module-ref.ts';
 export * from './container.ts';
 export * from './reflector.ts';
+export * from './lazy-module-loader.ts';
+export * from './testing-module.ts';

package/src/core/lazy-module-loader.ts

@@ -0,0 +1,29 @@
+import { Injectable } from './decorators.ts';
+import { CalyxContainer } from './container.ts';
+import { ModuleRef } from './module-ref.ts';
+
+@Injectable()
+export class LazyModuleLoader {
+  constructor(private readonly moduleRef: ModuleRef) {}
+
+  async load(loader: () => Promise<any> | any): Promise<ModuleRef> {
+    let moduleClass = await loader();
+    if (moduleClass && typeof moduleClass === 'object' && 'default' in moduleClass) {
+      moduleClass = moduleClass.default;
+    }
+    
+    const container: CalyxContainer = (this.moduleRef as any).container;
+    if (!container) {
+      throw new Error('LazyModuleLoader: Container reference not found on moduleRef');
+    }
+    
+    await container.bootstrap(moduleClass);
+    
+    const record = container.getModuleRecord(moduleClass);
+    if (!record) {
+      throw new Error(`LazyModuleLoader: Module record not found for ${moduleClass.name}`);
+    }
+    
+    return record.instances.get(ModuleRef);
+  }
+}

package/src/core/metadata.ts

@@ -44,7 +44,12 @@ export interface FactoryProvider {
   scope?: Scope;
 }
 
-export type Provider = Type<any> | ValueProvider | ClassProvider | FactoryProvider;
+export interface ExistingProvider {
+  provide: InjectionToken;
+  useExisting: InjectionToken;
+}
+
+export type Provider = Type<any> | ValueProvider | ClassProvider | FactoryProvider | ExistingProvider;
 
 export interface ModuleMetadata {
   imports?: any[];

package/src/core/testing-module.ts

@@ -0,0 +1,123 @@
+import { CalyxContainer } from './container.ts';
+import { ModuleMetadata, Type, InjectionToken } from './metadata.ts';
+import { Module } from './decorators.ts';
+import { ModuleRef } from './module-ref.ts';
+import { CalyxApplication } from '../http/application.ts';
+
+export class TestingModule extends ModuleRef {
+  constructor(public readonly container: CalyxContainer, private readonly rootModuleClass: any) {
+    super();
+  }
+
+  createCalyxApplication(): CalyxApplication {
+    const app = new CalyxApplication(this.rootModuleClass);
+    (app as any).container = this.container;
+    return app;
+  }
+
+  createNestApplication(options?: any): CalyxApplication {
+    return this.createCalyxApplication();
+  }
+
+  get<T>(token: InjectionToken, options?: { strict: boolean }): T {
+    const strict = options?.strict ?? false;
+    if (strict) {
+      return this.container.resolveTokenInModuleContext(this.rootModuleClass, token);
+    } else {
+      return this.container.getGlobalOrAnyInstance(token);
+    }
+  }
+
+  async resolve<T>(token: InjectionToken, contextId?: any, options?: { strict: boolean }): Promise<T> {
+    const requestContext = contextId instanceof Map ? contextId : new Map<any, any>();
+    const strict = options?.strict ?? false;
+    if (strict) {
+      return await this.container.resolveTokenInModuleContextAsync(this.rootModuleClass, token, requestContext);
+    } else {
+      return await this.container.resolveTokenGloballyAsync(token, requestContext);
+    }
+  }
+
+  async create<T>(type: Type<T>): Promise<T> {
+    return await this.container.instantiateClassAsync(type, this.rootModuleClass);
+  }
+
+  async close() {
+    const instances = this.container.getProviderAndControllerInstances();
+    for (const inst of instances) {
+      if (inst && typeof inst.onModuleDestroy === 'function') {
+        await inst.onModuleDestroy();
+      }
+      if (inst && typeof inst.onApplicationShutdown === 'function') {
+        await inst.onApplicationShutdown();
+      }
+    }
+  }
+}
+
+export class TestingModuleBuilder {
+  private overrides = new Map<InjectionToken, { useValue?: any; useClass?: any; useFactory?: any; inject?: any[] }>();
+
+  constructor(private readonly metadata: ModuleMetadata) {}
+
+  overrideProvider(token: InjectionToken) {
+    const builder = {
+      useValue: (value: any) => {
+        this.overrides.set(token, { useValue: value });
+        return this;
+      },
+      useClass: (clazz: any) => {
+        this.overrides.set(token, { useClass: clazz });
+        return this;
+      },
+      useFactory: (options: { factory: (...args: any[]) => any; inject?: any[] }) => {
+        this.overrides.set(token, { useFactory: options.factory, inject: options.inject });
+        return this;
+      },
+    };
+    return builder;
+  }
+
+  overrideGuard(token: any) { return this.overrideProvider(token); }
+  overrideInterceptor(token: any) { return this.overrideProvider(token); }
+  overridePipe(token: any) { return this.overrideProvider(token); }
+  overrideFilter(token: any) { return this.overrideProvider(token); }
+
+  async compile(): Promise<TestingModule> {
+    @Module({
+      imports: this.metadata.imports || [],
+      controllers: this.metadata.controllers || [],
+      providers: this.metadata.providers || [],
+      exports: this.metadata.exports || [],
+    })
+    class RootTestModule {}
+
+    const container = new CalyxContainer();
+    container.addModule(RootTestModule);
+
+    // Apply overrides to module records
+    for (const [token, override] of this.overrides.entries()) {
+      for (const record of (container as any).modules.values()) {
+        if (record.providers.has(token)) {
+          if ('useValue' in override) {
+            record.providers.set(token, { provide: token, useValue: override.useValue });
+          } else if ('useClass' in override) {
+            record.providers.set(token, { provide: token, useClass: override.useClass });
+          } else if ('useFactory' in override) {
+            record.providers.set(token, { provide: token, useFactory: override.useFactory, inject: override.inject });
+          }
+        }
+      }
+    }
+
+    await container.bootstrap(RootTestModule);
+
+    return new TestingModule(container, RootTestModule);
+  }
+}
+
+export class Test {
+  static createTestingModule(metadata: ModuleMetadata): TestingModuleBuilder {
+    return new TestingModuleBuilder(metadata);
+  }
+}

package/src/cqrs/cqrs.ts

@@ -0,0 +1,264 @@
+import { Module, Injectable } from '../core/decorators.ts';
+import { Type } from '../core/metadata.ts';
+import { ModuleRef } from '../core/module-ref.ts';
+import { Subject, Observable } from 'rxjs';
+
+export interface ICommand {}
+export interface ICommandHandler<TCommand extends ICommand = any, TResult = any> {
+  execute(command: TCommand): Promise<TResult>;
+}
+
+export interface IQuery {}
+export interface IQueryHandler<TQuery extends IQuery = any, TResult = any> {
+  execute(query: TQuery): Promise<TResult>;
+}
+
+export interface IEvent {}
+export interface IEventHandler<TEvent extends IEvent = any> {
+  handle(event: TEvent): any;
+}
+
+import { METADATA_KEYS } from '../core/metadata.ts';
+
+export const COMMAND_HANDLER_METADATA = 'cqrs:command_handler';
+export const QUERY_HANDLER_METADATA = 'cqrs:query_handler';
+export const EVENT_HANDLER_METADATA = 'cqrs:event_handler';
+export const SAGA_METADATA = 'cqrs:saga';
+
+export const CommandHandler = (command: Type<ICommand>): ClassDecorator => {
+  return (target) => {
+    Reflect.defineMetadata(COMMAND_HANDLER_METADATA, command, target);
+    Reflect.defineMetadata(METADATA_KEYS.INJECTABLE, true, target);
+  };
+};
+
+export const QueryHandler = (query: Type<IQuery>): ClassDecorator => {
+  return (target) => {
+    Reflect.defineMetadata(QUERY_HANDLER_METADATA, query, target);
+    Reflect.defineMetadata(METADATA_KEYS.INJECTABLE, true, target);
+  };
+};
+
+export const EventsHandler = (...events: Type<IEvent>[]): ClassDecorator => {
+  return (target) => {
+    Reflect.defineMetadata(EVENT_HANDLER_METADATA, events, target);
+    Reflect.defineMetadata(METADATA_KEYS.INJECTABLE, true, target);
+  };
+};
+
+export function Saga(): PropertyDecorator {
+  return (target: any, propertyKey: string | symbol) => {
+    const constructor = target.constructor;
+    const existing = Reflect.getOwnMetadata(SAGA_METADATA, constructor) || [];
+    existing.push(propertyKey);
+    Reflect.defineMetadata(SAGA_METADATA, existing, constructor);
+  };
+}
+
+@Injectable()
+export class UnhandledExceptionBus extends Subject<any> {}
+
+@Injectable()
+export class CommandBus {
+  private handlers = new Map<any, ICommandHandler>();
+
+  constructor(private readonly exceptionBus: UnhandledExceptionBus) {}
+
+  register(command: any, handler: ICommandHandler) {
+    this.handlers.set(command, handler);
+  }
+
+  async execute<T extends ICommand, R = any>(command: T): Promise<R> {
+    const commandClass = command.constructor;
+    const handler = this.handlers.get(commandClass);
+    if (!handler) {
+      throw new Error(`CommandHandler not found for command: ${commandClass.name}`);
+    }
+    try {
+      return (await handler.execute(command)) as R;
+    } catch (err) {
+      this.exceptionBus.next({ error: err, command });
+      throw err;
+    }
+  }
+}
+
+@Injectable()
+export class QueryBus {
+  private handlers = new Map<any, IQueryHandler>();
+
+  constructor(private readonly exceptionBus: UnhandledExceptionBus) {}
+
+  register(query: any, handler: IQueryHandler) {
+    this.handlers.set(query, handler);
+  }
+
+  async execute<T extends IQuery, R = any>(query: T): Promise<R> {
+    const queryClass = query.constructor;
+    const handler = this.handlers.get(queryClass);
+    if (!handler) {
+      throw new Error(`QueryHandler not found for query: ${queryClass.name}`);
+    }
+    try {
+      return (await handler.execute(query)) as R;
+    } catch (err) {
+      this.exceptionBus.next({ error: err, query });
+      throw err;
+    }
+  }
+}
+
+@Injectable()
+export class EventBus {
+  public readonly subject$ = new Subject<any>();
+  private handlers = new Map<any, IEventHandler[]>();
+
+  register(event: any, handler: IEventHandler) {
+    const existing = this.handlers.get(event) || [];
+    existing.push(handler);
+    this.handlers.set(event, existing);
+  }
+
+  publish<T extends IEvent>(event: T) {
+    const eventClass = event.constructor;
+    const eventHandlers = this.handlers.get(eventClass) || [];
+    for (const handler of eventHandlers) {
+      try {
+        handler.handle(event);
+      } catch (err) {
+        console.error(`Error in event handler:`, err);
+      }
+    }
+    this.subject$.next(event);
+  }
+}
+
+@Injectable()
+export class EventPublisher {
+  constructor(private readonly eventBus: EventBus) {}
+
+  mergeClassContext<T extends Type<any>>(metatype: T): T {
+    const eventBus = this.eventBus;
+    return class extends metatype {
+      publish(event: IEvent) {
+        eventBus.publish(event);
+      }
+      publishAll(events: IEvent[]) {
+        for (const event of events) {
+          eventBus.publish(event);
+        }
+      }
+    };
+  }
+
+  mergeObjectContext<T extends Object>(object: T): T {
+    const eventBus = this.eventBus;
+    return Object.assign(object, {
+      publish: (event: IEvent) => eventBus.publish(event),
+      publishAll: (events: IEvent[]) => {
+        for (const event of events) {
+          eventBus.publish(event);
+        }
+      },
+    });
+  }
+}
+
+export class AggregateRoot<EventBase extends IEvent = IEvent> {
+  private readonly _events: EventBase[] = [];
+  autoCommit = false;
+
+  publish(event: EventBase) {}
+  publishAll(events: EventBase[]) {}
+
+  commit() {
+    this.publishAll(this._events);
+    this._events.length = 0;
+  }
+
+  uncommit() {
+    this._events.length = 0;
+  }
+
+  getUncommittedEvents(): EventBase[] {
+    return this._events;
+  }
+
+  loadFromHistory(history: EventBase[]) {
+    history.forEach((event) => this.apply(event, true));
+  }
+
+  apply(event: EventBase, isFromHistory = false) {
+    if (!isFromHistory) {
+      this._events.push(event);
+    }
+    const handlerName = `on${event.constructor.name}`;
+    if ((this as any)[handlerName]) {
+      (this as any)[handlerName](event);
+    }
+    if (this.autoCommit) {
+      this.commit();
+    }
+  }
+}
+
+@Module({
+  providers: [CommandBus, QueryBus, EventBus, EventPublisher, UnhandledExceptionBus],
+  exports: [CommandBus, QueryBus, EventBus, EventPublisher, UnhandledExceptionBus],
+})
+export class CqrsModule {
+  constructor(
+    private readonly moduleRef: ModuleRef,
+    private readonly commandBus: CommandBus,
+    private readonly queryBus: QueryBus,
+    private readonly eventBus: EventBus
+  ) {}
+
+  onModuleInit() {
+    const container = (this.moduleRef as any).container;
+    if (!container) return;
+
+    const instances = container.getProviderAndControllerInstances();
+    for (const inst of instances) {
+      if (!inst || !inst.constructor) continue;
+
+      const command = Reflect.getMetadata(COMMAND_HANDLER_METADATA, inst.constructor);
+      if (command) {
+        this.commandBus.register(command, inst);
+      }
+
+      const query = Reflect.getMetadata(QUERY_HANDLER_METADATA, inst.constructor);
+      if (query) {
+        this.queryBus.register(query, inst);
+      }
+
+      const events = Reflect.getMetadata(EVENT_HANDLER_METADATA, inst.constructor);
+      if (events && Array.isArray(events)) {
+        for (const event of events) {
+          this.eventBus.register(event, inst);
+        }
+      }
+
+      // Check Sagas
+      const sagas: (string | symbol)[] = Reflect.getMetadata(SAGA_METADATA, inst.constructor) || [];
+      for (const sagaKey of sagas) {
+        const sagaFn = inst[sagaKey];
+        if (typeof sagaFn === 'function') {
+          const commands$ = sagaFn(this.eventBus.subject$);
+          if (commands$ && typeof commands$.subscribe === 'function') {
+            commands$.subscribe({
+              next: (cmd: any) => {
+                this.commandBus.execute(cmd).catch((err) => {
+                  console.error(`Saga error executing command:`, err);
+                });
+              },
+              error: (err: any) => {
+                console.error(`Saga stream error:`, err);
+              }
+            });
+          }
+        }
+      }
+    }
+  }
+}

package/src/database/sequelize.module.ts

@@ -0,0 +1,239 @@
+import { Database } from 'bun:sqlite';
+import { Module, DynamicModule, Inject } from '../core/decorators.ts';
+import { ConnectionManager } from './typeorm.module.ts';
+
+let isSequelizeAvailable = false;
+try {
+  require.resolve('sequelize');
+  isSequelizeAvailable = true;
+} catch {
+  // ignore
+}
+
+export class Model<T extends Record<string, any> = any> {
+  static tableName: string;
+  static db: Database;
+  static isNative = true;
+  static realModel: any = null;
+
+  constructor(values?: Partial<T>) {
+    if (values) {
+      Object.assign(this, values);
+    }
+  }
+
+  static async findAll(options?: any): Promise<any[]> {
+    if (!this.isNative && this.realModel) {
+      const results = await this.realModel.findAll(options);
+      return results.map((r: any) => {
+        const inst = new this();
+        Object.assign(inst, r.toJSON ? r.toJSON() : r);
+        return inst;
+      });
+    }
+    const tableName = this.tableName || this.name.toLowerCase();
+    const db = this.db || ConnectionManager.getOrCreate();
+    const rows = db.query(`SELECT id, data FROM ${tableName}`).all() as any[];
+    return rows.map((row) => {
+      const dataObj = JSON.parse(row.data);
+      dataObj.id = row.id;
+      const inst = new this();
+      Object.assign(inst, dataObj);
+      return inst;
+    });
+  }
+
+  static async findOne(options?: any): Promise<any | null> {
+    const list = await this.findAll(options);
+    return list.length > 0 ? list[0] : null;
+  }
+
+  static async findByPk(id: number | string): Promise<any | null> {
+    if (!this.isNative && this.realModel) {
+      const r = await this.realModel.findByPk(id);
+      if (!r) return null;
+      const inst = new this();
+      Object.assign(inst, r.toJSON ? r.toJSON() : r);
+      return inst;
+    }
+    const tableName = this.tableName || this.name.toLowerCase();
+    const db = this.db || ConnectionManager.getOrCreate();
+    const row = db.query(`SELECT id, data FROM ${tableName} WHERE id = $id`).get({ $id: Number(id) }) as any;
+    if (!row) return null;
+    const dataObj = JSON.parse(row.data);
+    dataObj.id = row.id;
+    const inst = new this();
+    Object.assign(inst, dataObj);
+    return inst;
+  }
+
+  static async create(values: any): Promise<any> {
+    if (!this.isNative && this.realModel) {
+      const r = await this.realModel.create(values);
+      const inst = new this();
+      Object.assign(inst, r.toJSON ? r.toJSON() : r);
+      return inst;
+    }
+    const tableName = this.tableName || this.name.toLowerCase();
+    const db = this.db || ConnectionManager.getOrCreate();
+    db.run(`
+      CREATE TABLE IF NOT EXISTS ${tableName} (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        data TEXT
+      )
+    `);
+    const dataCopy = { ...values };
+    delete dataCopy.id;
+    const result = db.query(`INSERT INTO ${tableName} (data) VALUES ($data) RETURNING id`).get({
+      $data: JSON.stringify(dataCopy)
+    }) as any;
+    const inst = new this();
+    Object.assign(inst, values, { id: result.id });
+    return inst;
+  }
+
+  async save(): Promise<this> {
+    const modelClass = this.constructor as any;
+    if (!modelClass.isNative && modelClass.realModel) {
+      const realInst = await modelClass.realModel.build(this);
+      await realInst.save();
+      Object.assign(this, realInst.toJSON());
+      return this;
+    }
+    const tableName = modelClass.tableName || modelClass.name.toLowerCase();
+    const db = modelClass.db || ConnectionManager.getOrCreate();
+    const self = this as any;
+    const dataCopy = { ...this };
+    const id = self.id;
+    delete (dataCopy as any).id;
+
+    if (id !== undefined && id !== null) {
+      db.query(`UPDATE ${tableName} SET data = $data WHERE id = $id`).run({
+        $data: JSON.stringify(dataCopy),
+        $id: id
+      });
+    } else {
+      const result = db.query(`INSERT INTO ${tableName} (data) VALUES ($data) RETURNING id`).get({
+        $data: JSON.stringify(dataCopy)
+      }) as any;
+      self.id = result.id;
+    }
+    return this;
+  }
+
+  async update(values: any): Promise<this> {
+    Object.assign(this, values);
+    return await this.save();
+  }
+
+  async destroy(): Promise<void> {
+    const modelClass = this.constructor as any;
+    if (!modelClass.isNative && modelClass.realModel) {
+      const realInst = await modelClass.realModel.findByPk((this as any).id);
+      if (realInst) await realInst.destroy();
+      return;
+    }
+    const tableName = modelClass.tableName || modelClass.name.toLowerCase();
+    const db = modelClass.db || ConnectionManager.getOrCreate();
+    const id = (this as any).id;
+    if (id !== undefined && id !== null) {
+      db.query(`DELETE FROM ${tableName} WHERE id = $id`).run({ $id: id });
+    }
+  }
+}
+
+export function InjectModel(model: any): ParameterDecorator & PropertyDecorator {
+  return Inject(`Sequelize_Model_${model.name}`);
+}
+
+export interface SequelizeModuleOptions {
+  dialect?: string;
+  storage?: string;
+  host?: string;
+  port?: number;
+  username?: string;
+  password?: string;
+  database?: string;
+  models?: any[];
+  autoLoadModels?: boolean;
+  synchronize?: boolean;
+  [key: string]: any;
+}
+
+@Module({})
+export class SequelizeModule {
+  static forRoot(options: SequelizeModuleOptions = {}): DynamicModule {
+    const isUsingSequelize = isSequelizeAvailable && options.dialect !== 'sqlite-native';
+
+    let seqPromise: Promise<any>;
+    if (isUsingSequelize) {
+      seqPromise = (async () => {
+        const { Sequelize } = await import('sequelize');
+        const sequelize = new Sequelize(options as any);
+        if (options.models) {
+          sequelize.addModels(options.models);
+        }
+        await sequelize.authenticate();
+        if (options.synchronize !== false) {
+          await sequelize.sync();
+        }
+        return sequelize;
+      })();
+    } else {
+      seqPromise = Promise.resolve(ConnectionManager.getOrCreate(options.storage));
+    }
+
+    return {
+      module: SequelizeModule,
+      providers: [
+        {
+          provide: 'Calyx_Sequelize_Instance',
+          useValue: seqPromise,
+        },
+        {
+          provide: 'Calyx_Sequelize_IsNative',
+          useValue: !isUsingSequelize,
+        },
+      ],
+      exports: ['Calyx_Sequelize_Instance', 'Calyx_Sequelize_IsNative'],
+      global: true,
+    };
+  }
+
+  static forFeature(models: any[] = []): DynamicModule {
+    const providers = models.map((model) => {
+      return {
+        provide: `Sequelize_Model_${model.name}`,
+        useFactory: (seqInstancePromise: Promise<any>, isNative: boolean) => {
+          if (isNative) {
+            const db = ConnectionManager.getOrCreate();
+            model.db = db;
+            model.tableName = model.name.toLowerCase();
+            model.isNative = true;
+            db.run(`
+              CREATE TABLE IF NOT EXISTS ${model.tableName} (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                data TEXT
+              )
+            `);
+            return model;
+          } else {
+            return seqInstancePromise.then((seq) => {
+              const realModel = seq.models[model.name];
+              model.realModel = realModel;
+              model.isNative = false;
+              return model;
+            });
+          }
+        },
+        inject: ['Calyx_Sequelize_Instance', 'Calyx_Sequelize_IsNative'],
+      };
+    });
+
+    return {
+      module: SequelizeModule,
+      providers,
+      exports: models.map((model) => `Sequelize_Model_${model.name}`),
+    };
+  }
+}

package/src/event-emitter/decorators.ts

@@ -1,10 +1,10 @@
 import 'reflect-metadata';
 
-export function OnEvent(event: string): MethodDecorator {
+export function OnEvent(event: string, options?: any): MethodDecorator {
   return (target, propertyKey) => {
     const constructor = target.constructor;
     const existing = Reflect.getOwnMetadata('calyx:on_event', constructor) || [];
-    existing.push({ event, propertyKey });
+    existing.push({ event, propertyKey, options });
     Reflect.defineMetadata('calyx:on_event', existing, constructor);
   };
 }

package/src/event-emitter/event-emitter.ts

@@ -59,3 +59,6 @@ export class EventEmitter {
     return Promise.all(promises);
   }
 }
+
+export const EventEmitter2 = EventEmitter;
+