@sentzunhat/zacatl 0.0.22 → 0.0.24

package/package.json

@@ -4,13 +4,21 @@
   "main": "build/index.js",
   "module": "build/index.js",
   "types": "build/index.d.ts",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "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"
@@ -124,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",
@@ -164,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,13 @@ 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
+// ⚠️ ORM exports REMOVED from main package to prevent eager loading
+// Use dedicated subpath imports instead:
+//   import { mongoose, Schema } from "@sentzunhat/zacatl/orm/mongoose"
+//   import { Sequelize, DataTypes } from "@sentzunhat/zacatl/orm/sequelize"

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

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,14 +29,8 @@ 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.
- *
- * Uses lazy initialization to support ESM dynamic imports while maintaining
- * backward compatibility with synchronous constructors.
+ * 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>;

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>;
 }