@sentzunhat/zacatl 0.0.21 → 0.0.23

package/package.json

@@ -4,13 +4,21 @@
   "main": "build/index.js",
   "module": "build/index.js",
   "types": "build/index.d.ts",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "packageManager": "npm@10.9.0",
   "exports": {
     ".": {
       "import": "./build/index.js",
       "types": "./build/index.d.ts"
     },
+    "./orm/mongoose": {
+      "import": "./build/orm/mongoose.js",
+      "types": "./build/orm/mongoose.d.ts"
+    },
+    "./orm/sequelize": {
+      "import": "./build/orm/sequelize.js",
+      "types": "./build/orm/sequelize.d.ts"
+    },
     "./infrastructure": {
       "import": "./build/service/architecture/infrastructure/repositories/abstract.js",
       "types": "./build/service/architecture/infrastructure/repositories/abstract.d.ts"
@@ -100,7 +108,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",
@@ -122,6 +132,7 @@
     "@vitest/coverage-istanbul": "^4.0.15",
     "eslint": "^9.39.1",
     "knip": "^5.71.0",
+    "mongodb-memory-server": "^10.4.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.48.1",
@@ -162,7 +173,6 @@
     "i18n": "^0.15.3",
     "i18next": "^25.8.0",
     "js-yaml": "^4.1.1",
-    "mongodb-memory-server": "^10.4.1",
     "mongoose": "^9.0.1",
     "pino": "^10.3.0",
     "pino-pretty": "^13.1.3",

package/src/index.ts

@@ -10,10 +10,8 @@ export * from "./logs";
 export * from "./runtime";
 export * from "./localization";
 
-// Re-export infrastructure with ORM types
 export * from "./service/architecture/infrastructure";
 
-// Re-export server types for convenience
 export {
   ServerType,
   ServerVendor,
@@ -22,16 +20,12 @@ export {
 } from "./service/architecture/platform/server/server";
 export type { ConfigServer } from "./service/architecture/platform/server/server";
 
-// Re-export commonly used third-party packages
-export { container } from "tsyringe";
+// Third-party integrations
+export { container, singleton, inject } from "tsyringe";
 export type { DependencyContainer } from "tsyringe";
-
-// Re-export Zod for validation
 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
+// Optional ORM exports for convenience (also available via subpath imports)
+export * from "./orm/mongoose.js";
+export * from "./orm/sequelize.js";

package/src/orm/mongoose.ts

@@ -0,0 +1,22 @@
+/**
+ * Mongoose ORM exports
+ *
+ * @example Minimal bundle (tree-shakeable)
+ * import { mongoose, Schema } from "@sentzunhat/zacatl/orm/mongoose";
+ *
+ * @example Convenience (from main package)
+ * import { mongoose, Schema } from "@sentzunhat/zacatl";
+ */
+
+export {
+  default as mongoose,
+  Mongoose,
+  Schema,
+  Model,
+  Document,
+  connect,
+  connection,
+} from "mongoose";
+
+// Type-only exports
+export type { Model as MongooseModel } from "mongoose";

package/src/orm/sequelize.ts

@@ -0,0 +1,14 @@
+/**
+ * Sequelize ORM exports
+ *
+ * @example Minimal bundle (tree-shakeable)
+ * import { Sequelize, DataTypes } from "@sentzunhat/zacatl/orm/sequelize";
+ *
+ * @example Convenience (from main package)
+ * import { Sequelize, DataTypes } from "@sentzunhat/zacatl";
+ */
+
+export { Sequelize, Model as SequelizeModel, DataTypes, Op } from "sequelize";
+
+// Type-only exports
+export type { ModelStatic, Options as SequelizeOptions } from "sequelize";

package/src/service/architecture/application/application.ts

@@ -18,6 +18,7 @@ export type ApplicationEntryPoints = {
 
 export type ConfigApplication = {
   entryPoints: ApplicationEntryPoints;
+  autoRegister?: boolean; // Auto-register on construction (default: false)
 };
 
 export class Application extends AbstractArchitecture {
@@ -36,6 +37,11 @@ export class Application extends AbstractArchitecture {
     });
 
     this.config = config;
+
+    // Auto-register if enabled (useful without Service)
+    if (config.autoRegister) {
+      this.registerRest();
+    }
   }
 
   /**
@@ -44,16 +50,19 @@ export class Application extends AbstractArchitecture {
   private registerRest(): void {
     this.registerAndStoreDependencies(
       this.config.entryPoints.rest.hookHandlers,
-      this.hookHandlers
+      this.hookHandlers,
     );
 
     this.registerAndStoreDependencies(
       this.config.entryPoints.rest.routeHandlers,
-      this.routeHandlers
+      this.routeHandlers,
     );
   }
 
   public start(): void {
-    this.registerRest();
+    // Register if not already done
+    if (!this.config.autoRegister) {
+      this.registerRest();
+    }
   }
 }

package/src/service/architecture/application/index.ts

@@ -1,2 +1,3 @@
 export * from "./entry-points";
 export * from "./application";
+export * from "../../../dependency-injection";

package/src/service/architecture/domain/domain.ts

@@ -4,6 +4,7 @@ import { container } from "tsyringe";
 
 export type ConfigDomain = {
   providers: Array<Constructor>;
+  autoRegister?: boolean; // Auto-register on construction (default: false)
 };
 
 export class Domain extends AbstractArchitecture {
@@ -14,10 +15,18 @@ export class Domain extends AbstractArchitecture {
     super();
 
     this.config = config;
+
+    // Auto-register if enabled (useful without Service)
+    if (config.autoRegister) {
+      this.registerDependencies(this.config.providers);
+    }
   }
 
   public async start(): Promise<void> {
-    this.registerDependencies(this.config.providers);
+    // Register if not already done
+    if (!this.config.autoRegister) {
+      this.registerDependencies(this.config.providers);
+    }
 
     // Auto-start providers that implement the start method
     for (const ProviderClass of this.config.providers) {

package/src/service/architecture/infrastructure/index.ts

@@ -1,48 +1,2 @@
 export * from "./repositories";
 export * from "./infrastructure";
-
-// Re-export Mongoose for user convenience
-// Users can import directly from @sentzunhat/zacatl instead of installing mongoose
-export {
-  Schema,
-  Model,
-  Types,
-  connect,
-  connection,
-  createConnection,
-} from "mongoose";
-
-export type {
-  Document,
-  SchemaDefinition,
-  SchemaOptions,
-  SchemaTypeOptions,
-  Connection,
-  Mongoose,
-  ObjectId,
-  UpdateQuery,
-  QueryOptions,
-  PopulateOptions,
-  HydratedDocument,
-  InferSchemaType,
-} from "mongoose";
-
-// Re-export Sequelize for user convenience
-// Users can import directly from @sentzunhat/zacatl instead of installing sequelize
-export { DataTypes, Sequelize, Model as SequelizeModelClass } from "sequelize";
-
-export type {
-  ModelStatic,
-  QueryInterface,
-  Transaction,
-  Options as SequelizeOptions,
-  ModelAttributes,
-  ModelOptions,
-  FindOptions,
-  CreateOptions,
-  UpdateOptions,
-  DestroyOptions,
-  WhereOptions,
-  Order,
-  Includeable,
-} from "sequelize";

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

@@ -2,6 +2,7 @@ import { AbstractArchitecture, Constructor } from "../architecture";
 
 export type ConfigInfrastructure = {
   repositories: Array<Constructor>;
+  autoRegister?: boolean; // Auto-register on construction (default: false)
 };
 
 export class Infrastructure extends AbstractArchitecture {
@@ -11,9 +12,17 @@ export class Infrastructure extends AbstractArchitecture {
     super();
 
     this.config = config;
+
+    // Auto-register if enabled (useful without Service)
+    if (config.autoRegister) {
+      this.registerDependencies(this.config.repositories);
+    }
   }
 
   public start(): void {
-    this.registerDependencies(this.config.repositories);
+    // Register if not already done
+    if (!this.config.autoRegister) {
+      this.registerDependencies(this.config.repositories);
+    }
   }
 }

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

@@ -5,21 +5,18 @@ import type {
   ORMAdapter,
 } from "../repositories/types";
 
-/**
- * Loads MongooseAdapter dynamically - only when needed
- * Throws helpful error if mongoose is not installed
- */
-export function loadMongooseAdapter<D, I, O>(
+/** Lazy-loads MongooseAdapter when needed */
+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",
       );
@@ -28,21 +25,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>(
+/** Lazy-loads SequelizeAdapter when needed */
+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

@@ -1,3 +1,4 @@
+// Type-only imports prevent eager loading in ESM
 import type { Model as MongooseModel } from "mongoose";
 import type { Model, ModelStatic } from "sequelize";
 import {
@@ -15,18 +16,12 @@ import {
 
 export * from "./types";
 
-/**
- * Type guard to check if config is for Mongoose
- */
 const isMongooseConfig = <D>(
   config: BaseRepositoryConfig<D>,
 ): config is MongooseRepositoryConfig<D> => {
   return config.type === ORMType.Mongoose;
 };
 
-/**
- * Type guard to check if config is for Sequelize
- */
 const isSequelizeConfig = <D extends Model>(
   config: BaseRepositoryConfig<D>,
 ): config is SequelizeRepositoryConfig<D> => {
@@ -34,30 +29,47 @@ const isSequelizeConfig = <D extends Model>(
 };
 
 /**
- * BaseRepository - Abstract base class for all repositories
- *
- * 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.
+ * Abstract base repository supporting multiple ORMs via adapter pattern.
+ * Adapters are lazy-loaded for optimal bundle size.
  */
 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 (isMongooseConfig<D>(config)) {
-      this.adapter = loadMongooseAdapter<D, I, O>(config);
-    } else if (isSequelizeConfig(config)) {
+    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 = 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 +77,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 +94,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 +106,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 +118,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);
   }
 }

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

@@ -1,4 +1,4 @@
-import {
+import type {
   Document,
   Model as MongooseModel,
   Schema,
@@ -7,11 +7,8 @@ import {
   ObjectId,
   IfAny,
 } from "mongoose";
-import { Model as SequelizeModel, ModelStatic, Model } from "sequelize";
+import type { Model as SequelizeModel, ModelStatic, Model } from "sequelize";
 
-/**
- * Enum for supported ORM types
- */
 export enum ORMType {
   Mongoose = "mongoose",
   Sequelize = "sequelize",
@@ -51,29 +48,17 @@ export type ToLeanInput<D, T> =
   | null
   | undefined;
 
-/**
- * Configuration for Mongoose-based repository
- * @template D - Database document type
- */
 export type MongooseRepositoryConfig<D = unknown> = {
   readonly type: ORMType.Mongoose;
   readonly name?: string;
   readonly schema: Schema<D>;
 };
 
-/**
- * Configuration for Sequelize-based repository
- * @template D - Sequelize Model type (must extend Model)
- */
 export type SequelizeRepositoryConfig<D extends Model = Model> = {
   readonly type: ORMType.Sequelize;
   readonly model: ModelStatic<D>;
 };
 
-/**
- * Discriminated union of all repository configuration types
- * @template D - Database/Model type
- */
 export type BaseRepositoryConfig<D = unknown> =
   | MongooseRepositoryConfig<D>
   | SequelizeRepositoryConfig<Model>;
@@ -88,38 +73,12 @@ export type Repository<D, I, O> = {
   delete(id: string): Promise<O | null>;
 };
 
-/**
- * ORM Adapter Interface - Defines the contract for ORM-specific implementations
- * This enables pluggable ORM support without circular dependencies
- */
+/** ORM adapter interface for pluggable ORM implementations */
 export interface ORMAdapter<D, I, O> {
-  /**
-   * Get the underlying ORM model
-   */
   readonly model: MongooseModel<D> | ModelStatic<any>;
-
-  /**
-   * Transform database entity to plain lean object
-   */
   toLean(input: unknown): O | null;
-
-  /**
-   * Find entity by ID
-   */
   findById(id: string): Promise<O | null>;
-
-  /**
-   * Create new entity
-   */
   create(entity: I): Promise<O>;
-
-  /**
-   * Update existing entity
-   */
   update(id: string, update: Partial<I>): Promise<O | null>;
-
-  /**
-   * Delete entity by ID
-   */
   delete(id: string): Promise<O | null>;
 }