@sentzunhat/zacatl 0.0.20 → 0.0.22

package/package.json

@@ -4,8 +4,36 @@
   "main": "build/index.js",
   "module": "build/index.js",
   "types": "build/index.d.ts",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "packageManager": "npm@10.9.0",
+  "exports": {
+    ".": {
+      "import": "./build/index.js",
+      "types": "./build/index.d.ts"
+    },
+    "./infrastructure": {
+      "import": "./build/service/architecture/infrastructure/repositories/abstract.js",
+      "types": "./build/service/architecture/infrastructure/repositories/abstract.d.ts"
+    },
+    "./domain": {
+      "import": "./build/service/architecture/domain/index.js",
+      "types": "./build/service/architecture/domain/index.d.ts"
+    },
+    "./application": {
+      "import": "./build/service/architecture/application/index.js",
+      "types": "./build/service/architecture/application/index.d.ts"
+    },
+    "./errors": {
+      "import": "./build/error/index.js",
+      "types": "./build/error/index.d.ts"
+    },
+    "./config": {
+      "import": "./build/configuration/index.js",
+      "types": "./build/configuration/index.d.ts"
+    },
+    "./build/*": "./build/*",
+    "./package.json": "./package.json"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/sentzunhat/zacatl.git"
@@ -70,9 +98,16 @@
     "test": "NODE_ENV=test ENV=test vitest run",
     "test:watch": "NODE_ENV=test ENV=test vitest",
     "test:coverage": "npm run test -- --coverage",
-    "type:check": "tsc -p ./tsconfig.json && tsc -p test/tsconfig.json",
+    "test:bun": "bun test",
+    "test:node": "vitest run",
+    "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 .",
-    "publish:latest": "npm i && npm run test && npm run test:coverage && npm run type:check && npm run lint && npm run build && npm publish --access public --tag latest"
+    "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",
+    "publish:otp": "npm run prepublish && npm publish --access public --tag latest --otp",
+    "publish:dry": "npm run prepublish && npm publish --dry-run"
   },
   "devDependencies": {
     "@eslint/eslintrc": "^3.3.3",
@@ -102,6 +137,21 @@
     "README.md",
     "LICENSE"
   ],
+  "peerDependencies": {
+    "mongoose": "^9.0.0",
+    "sequelize": "^6.0.0"
+  },
+  "peerDependenciesMeta": {
+    "mongoose": {
+      "optional": true
+    },
+    "sequelize": {
+      "optional": true
+    },
+    "better-sqlite3": {
+      "optional": true
+    }
+  },
   "dependencies": {
     "@fastify/http-proxy": "^11.4.1",
     "@fastify/static": "^8.3.0",
@@ -124,11 +174,6 @@
     "uuid": "^13.0.0",
     "zod": "^4.3.6"
   },
-  "peerDependenciesMeta": {
-    "better-sqlite3": {
-      "optional": true
-    }
-  },
   "optionalDependencies": {
     "@types/better-sqlite3": "^7.6.13",
     "better-sqlite3": "^12.6.2"

package/src/index.ts

@@ -30,5 +30,8 @@ export type { DependencyContainer } from "tsyringe";
 export { z } from "zod";
 export type { ZodSchema, ZodType, ZodError } from "zod";
 
+// Re-export ORMs (included as dependencies)
+export * from "./orm-exports";
+
 // Note: TypeScript utility types (Partial, Required, Readonly, etc.)
 // are globally available and don't need re-export

package/src/orm-exports.ts

@@ -0,0 +1,23 @@
+/**
+ * Re-export ORM dependencies for convenience
+ * These are included as dependencies (currently) for backward compatibility
+ * Future versions may move them to pure peer dependencies
+ */
+
+// Mongoose exports - full re-export
+export {
+  default as mongoose,
+  Mongoose,
+  Schema,
+  Model,
+  Document,
+  connect,
+  connection,
+} from "mongoose";
+
+// Sequelize exports - full re-export
+export { Sequelize, Model as SequelizeModel, DataTypes, Op } from "sequelize";
+
+// Type-only exports for convenience
+export type { Model as MongooseModel } from "mongoose";
+export type { ModelStatic, Options as SequelizeOptions } from "sequelize";

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

@@ -0,0 +1,54 @@
+import type { Model } from "sequelize";
+import type {
+  MongooseRepositoryConfig,
+  SequelizeRepositoryConfig,
+  ORMAdapter,
+} from "../repositories/types";
+
+/**
+ * Loads MongooseAdapter dynamically - only when needed
+ * Throws helpful error if mongoose is not installed
+ */
+export async function loadMongooseAdapter<D, I, O>(
+  config: MongooseRepositoryConfig<D>,
+): Promise<ORMAdapter<D, I, O>> {
+  try {
+    // Dynamic import - only loads when Mongoose is actually used
+    const adapters = await import("./adapters/mongoose-adapter");
+    return new adapters.MongooseAdapter<D, I, O>(config);
+  } catch (error: any) {
+    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",
+      );
+    }
+    throw error;
+  }
+}
+
+/**
+ * Loads SequelizeAdapter dynamically - only when needed
+ * Throws helpful error if sequelize is not installed
+ */
+export async function loadSequelizeAdapter<D extends Model, I, O>(
+  config: SequelizeRepositoryConfig<D>,
+): Promise<ORMAdapter<D, I, O>> {
+  try {
+    // Dynamic import - only loads when Sequelize is actually used
+    const adapters = await import("./adapters/sequelize-adapter");
+    return new adapters.SequelizeAdapter<D, I, O>(config);
+  } catch (error: any) {
+    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",
+      );
+    }
+    throw error;
+  }
+}

package/src/service/architecture/infrastructure/orm/adapters/mongoose-adapter.ts

@@ -1,8 +1,5 @@
-import importedMongoose, {
-  connection,
-  Model as MongooseModel,
-  Mongoose,
-} from "mongoose";
+import type { Model as MongooseModel } from "mongoose";
+import { Mongoose } from "mongoose";
 import { v4 as uuidv4 } from "uuid";
 import { container } from "tsyringe";
 import type {
@@ -14,9 +11,11 @@ import type {
 /**
  * MongooseAdapter - Handles Mongoose-specific ORM operations
  *
- * This adapter wraps Mongoose model operations and provides a consistent
- * interface for the repository layer. It handles document transformation,
- * ID normalization, and timestamp management.
+ * Provides consistent interface for repository layer with:
+ * - Document transformation
+ * - ID normalization
+ * - Timestamp management
+ * - Connection instance from DI container
  */
 export class MongooseAdapter<D, I, O> implements ORMAdapter<D, I, O> {
   public readonly model: MongooseModel<D>;
@@ -24,9 +23,9 @@ export class MongooseAdapter<D, I, O> implements ORMAdapter<D, I, O> {
 
   constructor(config: MongooseRepositoryConfig<D>) {
     this.config = config;
-    const mongoose = connection.db?.databaseName
-      ? importedMongoose
-      : container.resolve<Mongoose>(Mongoose);
+    // Get mongoose instance from DI container - allows per-database configuration
+    // Connection strings should be set up before repository instantiation
+    const mongoose = container.resolve<Mongoose>(Mongoose);
 
     const { name, schema } = this.config;
 

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

@@ -1,5 +1,5 @@
-import { Model as MongooseModel } from "mongoose";
-import { Model, ModelStatic } from "sequelize";
+import type { Model as MongooseModel } from "mongoose";
+import type { Model, ModelStatic } from "sequelize";
 import {
   BaseRepositoryConfig,
   Repository,
@@ -8,8 +8,10 @@ import {
   ORMAdapter,
   ORMType,
 } from "./types";
-import { MongooseAdapter } from "../orm/adapters/mongoose-adapter";
-import { SequelizeAdapter } from "../orm/adapters/sequelize-adapter";
+import {
+  loadMongooseAdapter,
+  loadSequelizeAdapter,
+} from "../orm/adapter-loader";
 
 export * from "./types";
 
@@ -34,23 +36,51 @@ const isSequelizeConfig = <D extends Model>(
 /**
  * BaseRepository - Abstract base class for all repositories
  *
- * Uses the adapter pattern to support multiple ORMs (Mongoose, Sequelize, etc.)
- * without circular dependencies. Adapters are imported from separate files in
- * the orm/ folder.
+ * 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>) {
-    if (isMongooseConfig<D>(config)) {
-      // TypeScript knows config is MongooseRepositoryConfig<D>
-      this.adapter = new MongooseAdapter<D, I, O>(config);
-    } else if (isSequelizeConfig(config)) {
-      // TypeScript knows config is SequelizeRepositoryConfig
-      this.adapter = new SequelizeAdapter<Model, I, O>(config);
+    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();
+    }
+
+    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 = (await loadSequelizeAdapter<Model, I, O>(
+        this.config,
+      )) as ORMAdapter<D, I, O>;
     } else {
-      // Exhaustiveness check - should never reach here with proper types
-      const exhaustive: never = config;
+      const exhaustive: never = this.config;
       throw new Error(
         `Invalid repository configuration. Received: ${JSON.stringify(exhaustive)}`,
       );
@@ -58,18 +88,28 @@ 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;
   }
 
   public isMongoose(): boolean {
-    return this.adapter instanceof MongooseAdapter;
+    return this.ormType === ORMType.Mongoose;
   }
 
   public isSequelize(): boolean {
-    return this.adapter instanceof SequelizeAdapter;
+    return this.ormType === ORMType.Sequelize;
   }
 
   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");
     }
@@ -77,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");
     }
@@ -84,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);
   }
 }