@sentzunhat/zacatl 0.0.20 → 0.0.21

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.21",
   "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,14 @@
     "test": "NODE_ENV=test ENV=test vitest run",
     "test:watch": "NODE_ENV=test ENV=test vitest",
     "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",
     "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 +135,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 +172,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,52 @@
+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 function loadMongooseAdapter<D, I, O>(
+  config: MongooseRepositoryConfig<D>,
+): 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");
+    return new adapters.MongooseAdapter<D, I, O>(config);
+  } catch (error: any) {
+    if (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 function loadSequelizeAdapter<D extends Model, I, O>(
+  config: SequelizeRepositoryConfig<D>,
+): 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");
+    return new adapters.SequelizeAdapter<D, I, O>(config);
+  } catch (error: any) {
+    if (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,22 +36,27 @@ 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.
  */
 export abstract class BaseRepository<D, I, O> implements Repository<D, I, O> {
   private adapter: ORMAdapter<D, I, O>;
+  private readonly ormType: ORMType;
 
   constructor(config: BaseRepositoryConfig<D>) {
+    this.ormType = config.type;
+
     if (isMongooseConfig<D>(config)) {
-      // TypeScript knows config is MongooseRepositoryConfig<D>
-      this.adapter = new MongooseAdapter<D, I, O>(config);
+      this.adapter = loadMongooseAdapter<D, I, O>(config);
     } else if (isSequelizeConfig(config)) {
-      // TypeScript knows config is SequelizeRepositoryConfig
-      this.adapter = new SequelizeAdapter<Model, I, O>(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
+      >;
     } else {
-      // Exhaustiveness check - should never reach here with proper types
       const exhaustive: never = config;
       throw new Error(
         `Invalid repository configuration. Received: ${JSON.stringify(exhaustive)}`,
@@ -62,11 +69,11 @@ export abstract class BaseRepository<D, I, O> implements Repository<D, I, O> {
   }
 
   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> {