@sentzunhat/zacatl 0.0.21 → 0.0.22

package/package.json

@@ -4,7 +4,7 @@
   "main": "build/index.js",
   "module": "build/index.js",
   "types": "build/index.d.ts",
-  "version": "0.0.21",
+  "version": "0.0.22",
   "packageManager": "npm@10.9.0",
   "exports": {
     ".": {
@@ -100,7 +100,9 @@
     "test:coverage": "npm run test -- --coverage",
     "test:bun": "bun test",
     "test:node": "vitest run",
-    "type:check": "tsc -p ./tsconfig.json && tsc -p test/tsconfig.json",
+    "type:check": "npm run type:check:src && npm run type:check:test",
+    "type:check:src": "tsc --noEmit -p ./tsconfig.json",
+    "type:check:test": "tsc --noEmit -p ./test/tsconfig.json",
     "lint": "DEBUG=eslint:cli-engine bun eslint .",
     "prepublish": "npm run test:coverage && npm run type:check && npm run lint && npm run build",
     "publish:latest": "npm run prepublish && npm publish --access public --tag latest",

package/src/service/architecture/infrastructure/orm/adapter-loader.ts

@@ -9,17 +9,18 @@ import type {
  * Loads MongooseAdapter dynamically - only when needed
  * Throws helpful error if mongoose is not installed
  */
-export function loadMongooseAdapter<D, I, O>(
+export async function loadMongooseAdapter<D, I, O>(
   config: MongooseRepositoryConfig<D>,
-): ORMAdapter<D, I, O> {
+): Promise<ORMAdapter<D, I, O>> {
   try {
     // Dynamic import - only loads when Mongoose is actually used
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const adapters =
-      require("./adapters/mongoose-adapter") as typeof import("./adapters/mongoose-adapter");
+    const adapters = await import("./adapters/mongoose-adapter");
     return new adapters.MongooseAdapter<D, I, O>(config);
   } catch (error: any) {
-    if (error.code === "MODULE_NOT_FOUND") {
+    if (
+      error.code === "ERR_MODULE_NOT_FOUND" ||
+      error.code === "MODULE_NOT_FOUND"
+    ) {
       throw new Error(
         "Mongoose is not installed. Install it with: npm install mongoose",
       );
@@ -32,17 +33,18 @@ export function loadMongooseAdapter<D, I, O>(
  * Loads SequelizeAdapter dynamically - only when needed
  * Throws helpful error if sequelize is not installed
  */
-export function loadSequelizeAdapter<D extends Model, I, O>(
+export async function loadSequelizeAdapter<D extends Model, I, O>(
   config: SequelizeRepositoryConfig<D>,
-): ORMAdapter<D, I, O> {
+): Promise<ORMAdapter<D, I, O>> {
   try {
     // Dynamic import - only loads when Sequelize is actually used
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const adapters =
-      require("./adapters/sequelize-adapter") as typeof import("./adapters/sequelize-adapter");
+    const adapters = await import("./adapters/sequelize-adapter");
     return new adapters.SequelizeAdapter<D, I, O>(config);
   } catch (error: any) {
-    if (error.code === "MODULE_NOT_FOUND") {
+    if (
+      error.code === "ERR_MODULE_NOT_FOUND" ||
+      error.code === "MODULE_NOT_FOUND"
+    ) {
       throw new Error(
         "Sequelize is not installed. Install it with: npm install sequelize",
       );

package/src/service/architecture/infrastructure/repositories/abstract.ts

@@ -39,25 +39,48 @@ const isSequelizeConfig = <D extends Model>(
  * Supports multiple ORMs (Mongoose, Sequelize) through adapter pattern.
  * Adapters are lazy-loaded - only the ORM you use gets imported.
  * This allows projects to install only one ORM without unused dependencies.
+ *
+ * Uses lazy initialization to support ESM dynamic imports while maintaining
+ * backward compatibility with synchronous constructors.
  */
 export abstract class BaseRepository<D, I, O> implements Repository<D, I, O> {
-  private adapter: ORMAdapter<D, I, O>;
+  private adapter?: ORMAdapter<D, I, O>;
   private readonly ormType: ORMType;
+  private readonly config: BaseRepositoryConfig<D>;
+  private initPromise?: Promise<void>;
 
   constructor(config: BaseRepositoryConfig<D>) {
     this.ormType = config.type;
+    this.config = config;
+  }
+
+  /**
+   * Ensures the adapter is initialized before any operation
+   * Uses a promise to prevent multiple concurrent initializations
+   */
+  private async ensureInitialized(): Promise<void> {
+    if (this.adapter) return;
+
+    if (!this.initPromise) {
+      this.initPromise = this.loadAdapter();
+    }
 
-    if (isMongooseConfig<D>(config)) {
-      this.adapter = loadMongooseAdapter<D, I, O>(config);
-    } else if (isSequelizeConfig(config)) {
+    await this.initPromise;
+  }
+
+  /**
+   * Loads the appropriate ORM adapter based on configuration
+   */
+  private async loadAdapter(): Promise<void> {
+    if (isMongooseConfig<D>(this.config)) {
+      this.adapter = await loadMongooseAdapter<D, I, O>(this.config);
+    } else if (isSequelizeConfig(this.config)) {
       // Type assertion needed here because D could be either Mongoose or Sequelize model
-      this.adapter = loadSequelizeAdapter<Model, I, O>(config) as ORMAdapter<
-        D,
-        I,
-        O
-      >;
+      this.adapter = (await loadSequelizeAdapter<Model, I, O>(
+        this.config,
+      )) as ORMAdapter<D, I, O>;
     } else {
-      const exhaustive: never = config;
+      const exhaustive: never = this.config;
       throw new Error(
         `Invalid repository configuration. Received: ${JSON.stringify(exhaustive)}`,
       );
@@ -65,6 +88,11 @@ export abstract class BaseRepository<D, I, O> implements Repository<D, I, O> {
   }
 
   get model(): MongooseModel<D> | ModelStatic<any> {
+    if (!this.adapter) {
+      throw new Error(
+        "Repository not initialized. Call an async method first or await repository.ensureInitialized()",
+      );
+    }
     return this.adapter.model;
   }
 
@@ -77,6 +105,11 @@ export abstract class BaseRepository<D, I, O> implements Repository<D, I, O> {
   }
 
   public getMongooseModel(): MongooseModel<D> {
+    if (!this.adapter) {
+      throw new Error(
+        "Repository not initialized. Call an async method first or await repository.ensureInitialized()",
+      );
+    }
     if (!this.isMongoose()) {
       throw new Error("Repository is not using Mongoose");
     }
@@ -84,6 +117,11 @@ export abstract class BaseRepository<D, I, O> implements Repository<D, I, O> {
   }
 
   public getSequelizeModel(): ModelStatic<any> {
+    if (!this.adapter) {
+      throw new Error(
+        "Repository not initialized. Call an async method first or await repository.ensureInitialized()",
+      );
+    }
     if (!this.isSequelize()) {
       throw new Error("Repository is not using Sequelize");
     }
@@ -91,22 +129,31 @@ export abstract class BaseRepository<D, I, O> implements Repository<D, I, O> {
   }
 
   public toLean(input: unknown): O | null {
+    if (!this.adapter) {
+      throw new Error(
+        "Repository not initialized. Call an async method first or await repository.ensureInitialized()",
+      );
+    }
     return this.adapter.toLean(input);
   }
 
   async findById(id: string): Promise<O | null> {
-    return this.adapter.findById(id);
+    await this.ensureInitialized();
+    return this.adapter!.findById(id);
   }
 
   async create(entity: I): Promise<O> {
-    return this.adapter.create(entity);
+    await this.ensureInitialized();
+    return this.adapter!.create(entity);
   }
 
   async update(id: string, update: Partial<I>): Promise<O | null> {
-    return this.adapter.update(id, update);
+    await this.ensureInitialized();
+    return this.adapter!.update(id, update);
   }
 
   async delete(id: string): Promise<O | null> {
-    return this.adapter.delete(id);
+    await this.ensureInitialized();
+    return this.adapter!.delete(id);
   }
 }