@sentzunhat/zacatl 0.0.12 → 0.0.14

package/package.json

@@ -2,7 +2,7 @@
   "name": "@sentzunhat/zacatl",
   "main": "src/index.ts",
   "module": "src/index.ts",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "repository": {
     "type": "git",
     "url": "https://github.com/sentzunhat/zacatl.git"
@@ -65,6 +65,7 @@
     "@types/config": "^3.3.5",
     "@types/i18n": "^0.13.12",
     "@types/node": "^22.7.4",
+    "@types/sequelize": "^4.28.20",
     "@types/uuid": "^10.0.0",
     "@typescript-eslint/parser": "^8.29.0",
     "@vitest/coverage-istanbul": "^3.1.1",
@@ -84,6 +85,7 @@
     "i18n": "^0.15.1",
     "mongodb-memory-server": "^10.1.4",
     "mongoose": "^8.15.0",
+    "sequelize": "^6.37.5",
     "pino": "^9.7.0",
     "pino-pretty": "^13.0.0",
     "reflect-metadata": "^0.2.2",

package/src/index.ts

@@ -3,4 +3,5 @@ export * from "./configuration";
 export * from "./utils";
 export * from "./error";
 export * from "./micro-service";
+export { MicroService } from "./micro-service";
 export * from "./logs";

package/src/logs.ts

@@ -31,50 +31,44 @@ const defaultLogger: pino.BaseLogger = pino({
 
 export type LoggerInput =
   | {
-      logData?: unknown;
-      metadata?: unknown;
+      data?: unknown;
+      details?: unknown;
     }
   | undefined;
 
 const logger = {
   log: (message: string, input?: LoggerInput): void => {
     console.log(message, {
-      logData: input?.logData,
-      metadata: input?.metadata,
+      data: input?.data,
+      details: input?.details,
     });
   },
 
   info: (message: string, input?: LoggerInput): void => {
-    defaultLogger.info(
-      { logData: input?.logData, metadata: input?.metadata },
-      message
-    );
+    defaultLogger.info({ data: input?.data, details: input?.details }, message);
   },
 
   trace: (message: string, input?: LoggerInput): void => {
     defaultLogger.trace(
-      { logData: input?.logData, metadata: input?.metadata },
+      { data: input?.data, details: input?.details },
       message
     );
   },
 
   warn: (message: string, input?: LoggerInput): void => {
-    defaultLogger.warn(
-      { logData: input?.logData, metadata: input?.metadata },
-      message
-    );
+    defaultLogger.warn({ data: input?.data, details: input?.details }, message);
   },
 
   error: (message: string, input?: LoggerInput): void => {
     defaultLogger.error(
-      { logData: input?.logData, metadata: input?.metadata },
+      { data: input?.data, details: input?.details },
       message
     );
   },
 
   fatal: (message: string, input?: LoggerInput): void => {
     defaultLogger.fatal(
-      { logData: input?.logData, metadata: input?.metadata },
+      { data: input?.data, details: input?.details },
       message
     );
   },

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

@@ -1,11 +1,11 @@
 import i18n from "i18n";
 import path from "path";
 
-import { AbstractArchitecture } from "../architecture";
+import { AbstractArchitecture, Constructor } from "../architecture";
 import { HookHandler, RouteHandler } from "./entry-points/rest";
 
-export type ApplicationHookHandlers = Array<new () => HookHandler>;
-export type ApplicationRouteHandlers = Array<new () => RouteHandler>;
+export type ApplicationHookHandlers = Array<Constructor<HookHandler>>;
+export type ApplicationRouteHandlers = Array<Constructor<RouteHandler>>;
 
 export type ApplicationEntryPoints = {
   rest: {

package/src/micro-service/architecture/application/entry-points/rest/common/handler.ts

@@ -6,8 +6,9 @@ export type Handler<
   TBody = void,
   TQuerystring = void,
   TParams = void,
-  THeaders = void
+  THeaders = void,
+  TReply = unknown
 > = (
   request: Request<TBody, TQuerystring, TParams, THeaders>,
   reply: FastifyReply
-) => Promise<void>;
+) => Promise<TReply>;

package/src/micro-service/architecture/application/entry-points/rest/route-handlers/route-handler.ts

@@ -6,10 +6,11 @@ export type RouteHandler<
   TBody = void,
   TQuerystring = void,
   TParams = void,
-  THeaders = void
+  THeaders = void,
+  TReply = unknown
 > = {
   url: string;
   method: HTTPMethods;
   schema: FastifySchema;
-  execute: Handler<TBody, TQuerystring, TParams, THeaders>;
+  execute: Handler<TBody, TQuerystring, TParams, THeaders, TReply>;
 };

package/src/micro-service/architecture/architecture.ts

@@ -1,5 +1,7 @@
 import { container } from "tsyringe";
 
+export type Constructor<T = unknown> = new (...args: unknown[]) => T;
+
 type Architecture = {
   start: () => void;
 };
@@ -9,7 +11,7 @@ export abstract class AbstractArchitecture implements Architecture {
    * A generic helper method to register an array of handler classes.
    * @param handlers - An array of class constructors that implement the handler functionality.
    */
-  protected registerDependencies<T>(dependencies: Array<new () => T>): void {
+  protected registerDependencies<T>(dependencies: Array<Constructor<T>>): void {
     for (const dependency of dependencies) {
       const instance = new dependency();
 

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

@@ -1,7 +1,7 @@
-import { AbstractArchitecture } from "../architecture";
+import { AbstractArchitecture, Constructor } from "../architecture";
 
 export type ConfigDomain = {
-  providers: Array<new () => unknown>;
+  providers: Array<Constructor>;
 };
 
 export class Domain extends AbstractArchitecture {

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

@@ -1,7 +1,7 @@
-import { AbstractArchitecture } from "../architecture";
+import { AbstractArchitecture, Constructor } from "../architecture";
 
 export type ConfigInfrastructure = {
-  repositories: Array<new () => unknown>;
+  repositories: Array<Constructor>;
 };
 
 export class Infrastructure extends AbstractArchitecture {

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

@@ -1,176 +1,90 @@
-import importedMongoose, {
-  connection,
-  IfAny,
-  Model,
-  Mongoose,
-  Document,
-  Schema,
-  Default__v,
-  Require_id,
-  ObjectId,
-} from "mongoose";
-import { v4 as uuidv4 } from "uuid";
-import { container } from "tsyringe";
-
-export type BaseRepositoryConfig<D> = {
-  name?: string;
-  schema: Schema<D>;
-};
-
-export type WithMongooseMeta<T> = Default__v<Require_id<T>>;
-
-export type MongooseDocument<Db> = Document<
-  ObjectId,
-  {},
-  Db,
-  Record<string, string>
-> &
-  WithMongooseMeta<Db>;
-
-export type LeanWithMeta<T> = WithMongooseMeta<T> & {
-  id: string;
-  createdAt: Date;
-  updatedAt: Date;
-};
-
-export type LeanDocument<T> = T & {
-  id: string;
-  createdAt: Date;
-  updatedAt: Date;
-};
-
-export type MongooseDoc<Db> = IfAny<
-  MongooseDocument<Db>,
-  MongooseDocument<Db>,
-  MongooseDocument<Db>
->;
-
-export type ToLeanInput<D, T> =
-  | MongooseDoc<D>
-  | LeanDocument<T>
-  | null
-  | undefined;
-
-// D - Document, meant for Database representation
-// T - Type, meant for TypeScript representation
-export type Repository<D, T> = {
-  model: Model<D>;
-
-  toLean(input: ToLeanInput<D, T>): LeanDocument<T> | null;
-  findById(id: string): Promise<LeanDocument<T> | null>;
-  create(entity: D): Promise<LeanDocument<T>>;
-  update(id: string, update: Partial<D>): Promise<LeanDocument<T> | null>;
-  delete(id: string): Promise<LeanDocument<T> | null>;
-};
+import { Model as MongooseModel } from "mongoose";
+import { ModelCtor } from "sequelize";
+import {
+  BaseRepositoryConfig,
+  Repository,
+  LeanDocument,
+  ToLeanInput,
+  MongooseRepositoryConfig,
+} from "./types";
+import { MongooseRepository } from "./mongoose";
+import { SequelizeRepository } from "./sequelize";
+
+export * from "./types";
 
 export abstract class BaseRepository<D, T> implements Repository<D, T> {
-  public readonly model: Model<D>;
-  private readonly config: BaseRepositoryConfig<D>;
+  private implementation: Repository<D, T>;
 
   constructor(config: BaseRepositoryConfig<D>) {
-    this.config = config;
-    const mongoose = connection.db?.databaseName
-      ? importedMongoose
-      : container.resolve<Mongoose>(Mongoose);
-
-    const { name, schema } = this.config;
-
-    if (name) {
-      this.model = mongoose.model<D>(name, schema);
+    if (config.type === "mongoose") {
+      this.implementation = new MongooseRepository(config);
+    } else if (config.type === "sequelize") {
+      this.implementation = new SequelizeRepository(
+        config as any
+      ) as unknown as Repository<D, T>;
     } else {
-      this.model = mongoose.model<D>(uuidv4(), schema);
+      // Backward compatibility: if type is missing but schema is present, assume Mongoose
+      if ((config as any).schema) {
+        const mongooseConfig: MongooseRepositoryConfig<D> = {
+          type: "mongoose",
+          name: (config as any).name,
+          schema: (config as any).schema,
+        };
+        this.implementation = new MongooseRepository(mongooseConfig);
+      } else {
+        throw new Error(
+          "Invalid repository configuration: 'type' must be 'mongoose' or 'sequelize'"
+        );
+      }
     }
+  }
 
-    this.model.createCollection();
-    this.model.createIndexes();
-    this.model.init();
+  get model(): MongooseModel<D> | ModelCtor<any> {
+    return this.implementation.model;
   }
 
-  /**
-   * Ensures the returned document has the correct id, createdAt, and updatedAt fields.
-   * Accepts a Mongoose document, a plain object, or a result from .lean().
-   */
-  public toLean(input: ToLeanInput<D, T>): LeanDocument<T> | null {
-    if (!input) {
-      return null;
-    }
+  public isMongoose(): boolean {
+    return this.implementation instanceof MongooseRepository;
+  }
 
-    let base: LeanWithMeta<T>;
+  public isSequelize(): boolean {
+    return this.implementation instanceof SequelizeRepository;
+  }
 
-    if (typeof (input as MongooseDoc<D>).toObject === "function") {
-      base = (input as MongooseDoc<D>).toObject<LeanDocument<T>>({
-        virtuals: true,
-      });
-    } else {
-      base = input as LeanWithMeta<T>;
+  public getMongooseModel(): MongooseModel<D> {
+    if (!this.isMongoose()) {
+      throw new Error("Repository is not using Mongoose");
     }
+    return this.implementation.model as MongooseModel<D>;
+  }
 
-    const result: LeanDocument<T> = {
-      ...(base as T), // trust only known keys from T
-      id:
-        typeof base.id === "string"
-          ? base.id
-          : typeof base._id === "string"
-          ? base._id
-          : base._id !== undefined
-          ? String(base._id)
-          : "",
-      createdAt:
-        base.createdAt instanceof Date
-          ? base.createdAt
-          : base.createdAt
-          ? new Date(base.createdAt as string | number)
-          : new Date(),
-      updatedAt:
-        base.updatedAt instanceof Date
-          ? base.updatedAt
-          : base.updatedAt
-          ? new Date(base.updatedAt as string | number)
-          : new Date(),
-    };
+  public getSequelizeModel(): ModelCtor<any> {
+    if (!this.isSequelize()) {
+      throw new Error("Repository is not using Sequelize");
+    }
+    return this.implementation.model as ModelCtor<any>;
+  }
 
-    return result;
+  public toLean(input: ToLeanInput<D, T>): LeanDocument<T> | null {
+    return this.implementation.toLean(input);
   }
 
   async findById(id: string): Promise<LeanDocument<T> | null> {
-    const entity = await this.model
-      .findById(id)
-      .lean<LeanDocument<T>>({ virtuals: true })
-      .exec();
-
-    return this.toLean(entity);
+    return this.implementation.findById(id);
   }
 
   async create(entity: D): Promise<LeanDocument<T>> {
-    const document = await this.model.create<D>(entity);
-
-    const leanDocument = this.toLean(document as MongooseDoc<D>);
-
-    if (!leanDocument) {
-      throw new Error("failed to create document");
-    }
-
-    return leanDocument;
+    return this.implementation.create(entity);
   }
 
   async update(
     id: string,
     update: Partial<D>
   ): Promise<LeanDocument<T> | null> {
-    const entity = await this.model
-      .findByIdAndUpdate(id, update, { new: true })
-      .lean<LeanDocument<T>>({ virtuals: true })
-      .exec();
-
-    return this.toLean(entity);
+    return this.implementation.update(id, update);
   }
 
   async delete(id: string): Promise<LeanDocument<T> | null> {
-    const entity = await this.model
-      .findByIdAndDelete(id)
-      .lean<LeanDocument<T>>({ virtuals: true })
-      .exec();
-
-    return this.toLean(entity);
+    return this.implementation.delete(id);
   }
 }

package/src/micro-service/architecture/infrastructure/repositories/mongoose.ts

@@ -0,0 +1,124 @@
+import importedMongoose, { connection, Model, Mongoose } from "mongoose";
+import { v4 as uuidv4 } from "uuid";
+import { container } from "tsyringe";
+import {
+  Repository,
+  MongooseRepositoryConfig,
+  LeanDocument,
+  ToLeanInput,
+  LeanWithMeta,
+  MongooseDoc,
+} from "./types";
+
+export class MongooseRepository<D, T> implements Repository<D, T> {
+  public readonly model: Model<D>;
+  private readonly config: MongooseRepositoryConfig<D>;
+
+  constructor(config: MongooseRepositoryConfig<D>) {
+    this.config = config;
+    const mongoose = connection.db?.databaseName
+      ? importedMongoose
+      : container.resolve<Mongoose>(Mongoose);
+
+    const { name, schema } = this.config;
+
+    if (name) {
+      this.model = mongoose.model<D>(name, schema);
+    } else {
+      this.model = mongoose.model<D>(uuidv4(), schema);
+    }
+
+    this.model.createCollection();
+    this.model.createIndexes();
+    this.model.init();
+  }
+
+  public toLean(input: ToLeanInput<D, T>): LeanDocument<T> | null {
+    if (!input) {
+      return null;
+    }
+
+    let base: LeanWithMeta<T>;
+
+    if (
+      input &&
+      typeof input === "object" &&
+      "toObject" in input &&
+      typeof (input as any).toObject === "function"
+    ) {
+      base = (input as any).toObject({
+        virtuals: true,
+      }) as LeanWithMeta<T>;
+    } else {
+      base = input as LeanWithMeta<T>;
+    }
+
+    const result: LeanDocument<T> = {
+      ...(base as T),
+      id:
+        typeof base.id === "string"
+          ? base.id
+          : typeof base._id === "string"
+          ? base._id
+          : base._id !== undefined
+          ? String(base._id)
+          : "",
+      createdAt:
+        base.createdAt instanceof Date
+          ? base.createdAt
+          : base.createdAt
+          ? new Date(base.createdAt as string | number)
+          : new Date(),
+      updatedAt:
+        base.updatedAt instanceof Date
+          ? base.updatedAt
+          : base.updatedAt
+          ? new Date(base.updatedAt as string | number)
+          : new Date(),
+    };
+
+    return result;
+  }
+
+  async findById(id: string): Promise<LeanDocument<T> | null> {
+    const entity = await this.model
+      .findById(id)
+      .lean<LeanDocument<T>>({ virtuals: true })
+      .exec();
+
+    return this.toLean(entity);
+  }
+
+  async create(entity: D): Promise<LeanDocument<T>> {
+    const document = await this.model.create<D>(entity);
+
+    const leanDocument = this.toLean(document as MongooseDoc<D>);
+
+    if (!leanDocument) {
+      throw new Error("failed to create document");
+    }
+
+    return leanDocument;
+  }
+
+  async update(
+    id: string,
+    update: Partial<D>
+  ): Promise<LeanDocument<T> | null> {
+    const entity = await this.model
+      .findByIdAndUpdate(id, update, { new: true })
+      .lean<LeanDocument<T>>({ virtuals: true })
+      .exec();
+
+    return this.toLean(entity);
+  }
+
+  async delete(id: string): Promise<LeanDocument<T> | null> {
+    const entity = await this.model
+      .findByIdAndDelete(id)
+      .lean<LeanDocument<T>>({ virtuals: true })
+      .exec();
+
+    return this.toLean(entity);
+  }
+}

package/src/micro-service/architecture/infrastructure/repositories/sequelize.ts

@@ -0,0 +1,70 @@
+import { Model, ModelCtor } from "sequelize";
+import { Repository, SequelizeRepositoryConfig, LeanDocument } from "./types";
+
+export class SequelizeRepository<D extends Model, T>
+  implements Repository<D, T>
+{
+  public readonly model: ModelCtor<D>;
+
+  constructor(config: SequelizeRepositoryConfig<D>) {
+    this.model = config.model;
+  }
+
+  public toLean(input: any): LeanDocument<T> | null {
+    if (!input) return null;
+    const plain = input instanceof Model ? input.get({ plain: true }) : input;
+
+    // Ensure id, createdAt, updatedAt exist and are correct types
+    // This assumes the model has these fields.
+    return {
+      ...(plain as T),
+      id: String(plain.id || plain._id || ""),
+      createdAt: plain.createdAt ? new Date(plain.createdAt) : new Date(),
+      updatedAt: plain.updatedAt ? new Date(plain.updatedAt) : new Date(),
+    } as LeanDocument<T>;
+  }
+
+  async findById(id: string): Promise<LeanDocument<T> | null> {
+    const entity = await this.model.findByPk(id);
+    return this.toLean(entity);
+  }
+
+  async create(entity: D): Promise<LeanDocument<T>> {
+    const document = await this.model.create(entity as any);
+    return this.toLean(document) as LeanDocument<T>;
+  }
+
+  async update(
+    id: string,
+    update: Partial<D>
+  ): Promise<LeanDocument<T> | null> {
+    const [affectedCount] = await this.model.update(update as any, {
+      where: { id } as any,
+    });
+
+    if (affectedCount === 0) {
+      return null;
+    }
+
+    return this.findById(id);
+  }
+
+  async delete(id: string): Promise<LeanDocument<T> | null> {
+    const entity = await this.findById(id);
+    if (!entity) return null;
+
+    await this.model.destroy({
+      where: { id } as any,
+    });
+
+    return entity;
+  }
+}
+[
+  {
+    type: "image",
+    payload: {
+      attachment_id: "{{ $json.propertyName }}",
+    },
+  },
+];

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

@@ -0,0 +1,69 @@
+import {
+  Document,
+  Model as MongooseModel,
+  Schema,
+  Default__v,
+  Require_id,
+  ObjectId,
+  IfAny,
+} from "mongoose";
+import { Model as SequelizeModel, ModelCtor, Model } from "sequelize";
+
+export type WithMongooseMeta<T> = Default__v<Require_id<T>>;
+
+export type MongooseDocument<Db> = Document<
+  ObjectId,
+  {},
+  Db,
+  Record<string, string>
+> &
+  WithMongooseMeta<Db>;
+
+export type LeanWithMeta<T> = WithMongooseMeta<T> & {
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+};
+
+export type LeanDocument<T> = T & {
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+};
+
+export type MongooseDoc<Db> = IfAny<
+  MongooseDocument<Db>,
+  MongooseDocument<Db>,
+  MongooseDocument<Db>
+>;
+
+export type ToLeanInput<D, T> =
+  | MongooseDoc<D>
+  | LeanDocument<T>
+  | null
+  | undefined;
+
+export type MongooseRepositoryConfig<D> = {
+  type: "mongoose";
+  name?: string;
+  schema: Schema<D>;
+};
+
+export type SequelizeRepositoryConfig<D extends Model> = {
+  type: "sequelize";
+  model: ModelCtor<D>;
+};
+
+export type BaseRepositoryConfig<D> =
+  | MongooseRepositoryConfig<D>
+  | SequelizeRepositoryConfig<D extends Model ? D : never>;
+
+export type Repository<D, T> = {
+  model: MongooseModel<D> | ModelCtor<SequelizeModel<any, any>>;
+
+  toLean(input: any): LeanDocument<T> | null;
+  findById(id: string): Promise<LeanDocument<T> | null>;
+  create(entity: D): Promise<LeanDocument<T>>;
+  update(id: string, update: Partial<D>): Promise<LeanDocument<T> | null>;
+  delete(id: string): Promise<LeanDocument<T> | null>;
+};

package/src/micro-service/architecture/platform/service/service.ts

@@ -3,6 +3,7 @@ import { FastifyInstance } from "fastify";
 import { ZodTypeProvider } from "fastify-type-provider-zod";
 import { container } from "tsyringe";
 import { Mongoose } from "mongoose";
+import { Sequelize } from "sequelize";
 
 import { HookHandler, RouteHandler } from "../../application";
 import { CustomError } from "../../../../error";
@@ -37,9 +38,10 @@ type ServiceServer = {
 
 export enum DatabaseVendor {
   MONGOOSE = "MONGOOSE",
+  SEQUELIZE = "SEQUELIZE",
 }
 
-type DatabaseInstance = Mongoose;
+type DatabaseInstance = Mongoose | Sequelize;
 
 type OnDatabaseConnectedFunction = Optional<
   (dbInstance: DatabaseInstance) => Promise<void> | void
@@ -126,7 +128,9 @@ export const strategiesForDatabaseVendor = {
     const { serviceName, database, connectionString, onDatabaseConnected } =
       input;
 
-    if (!database || !database.connect) {
+    const mongoose = database as Mongoose;
+
+    if (!mongoose || !mongoose.connect) {
       throw new CustomError({
         message: "database instance is not provided",
         code: 500,
@@ -134,18 +138,45 @@ export const strategiesForDatabaseVendor = {
       });
     }
 
-    await database.connect(connectionString, {
+    await mongoose.connect(connectionString, {
       dbName: serviceName,
       autoIndex: true,
       autoCreate: true,
     });
 
+    if (onDatabaseConnected) {
+      await onDatabaseConnected(mongoose);
+    }
+
+    container.register<Mongoose>(mongoose.constructor.name, {
+      useValue: mongoose,
+    });
+  },
+  [DatabaseVendor.SEQUELIZE]: async (input: {
+    serviceName: string;
+    database: DatabaseInstance;
+    connectionString: string;
+    onDatabaseConnected?: OnDatabaseConnectedFunction;
+  }) => {
+    const { database, onDatabaseConnected } = input;
+    const sequelize = database as Sequelize;
+
+    if (!sequelize || !sequelize.authenticate) {
+      throw new CustomError({
+        message: "database instance is not provided or invalid",
+        code: 500,
+        reason: "database instance not provided",
+      });
+    }
+
+    await sequelize.authenticate();
+
     if (onDatabaseConnected) {
       await onDatabaseConnected(database);
     }
 
-    container.register<typeof database>(database.constructor.name, {
-      useValue: database,
+    container.register<Sequelize>("Sequelize", {
+      useValue: sequelize,
     });
   },
 };

package/test/unit/micro-service/architecture/infrastructure/repositories/abstract.test.ts

@@ -15,7 +15,7 @@ const schemaUserTest = new Schema<UserTest>({
 @singleton()
 class UserRepository extends BaseRepository<UserTest, UserTest> {
   constructor() {
-    super({ name: "User", schema: schemaUserTest });
+    super({ type: "mongoose", name: "User", schema: schemaUserTest });
   }
 }
 
@@ -29,14 +29,14 @@ describe("BaseRepository", () => {
   });
 
   it("should create a model using the provided name and schema", async () => {
-    expect(repository.model.modelName).toBe("User");
-    expect(repository.model.schema).toBe(schemaUserTest);
+    expect(repository.getMongooseModel().modelName).toBe("User");
+    expect(repository.getMongooseModel().schema).toBe(schemaUserTest);
   });
 
   it("should call create() and return the created user document", async () => {
     const user = { name: "Alice" };
 
-    const spyFunction = vi.spyOn(repository.model, "create");
+    const spyFunction = vi.spyOn(repository.getMongooseModel(), "create");
 
     const result = await repository.create(user);
 
@@ -46,7 +46,7 @@ describe("BaseRepository", () => {
 
   it("should call findById() and return the user document", async () => {
     const user = await repository.create({ name: "Alice" });
-    const spyFunction = vi.spyOn(repository.model, "findById");
+    const spyFunction = vi.spyOn(repository.getMongooseModel(), "findById");
     const result = await repository.findById(user.id);
     expect(spyFunction).toHaveBeenNthCalledWith(1, user.id);
     expect(result).toMatchObject({ name: user.name });
@@ -58,7 +58,10 @@ describe("BaseRepository", () => {
 
     const update = { name: "Alice Updated" };
 
-    const spyFunction = vi.spyOn(repository.model, "findByIdAndUpdate");
+    const spyFunction = vi.spyOn(
+      repository.getMongooseModel(),
+      "findByIdAndUpdate"
+    );
 
     const result = await repository.update(user.id, update);
 
@@ -70,7 +73,10 @@ describe("BaseRepository", () => {
 
   it("should call delete() and return the deleted user document", async () => {
     const user = await repository.create({ name: "Alice" });
-    const spyFunction = vi.spyOn(repository.model, "findByIdAndDelete");
+    const spyFunction = vi.spyOn(
+      repository.getMongooseModel(),
+      "findByIdAndDelete"
+    );
     const result = await repository.delete(user.id);
     expect(spyFunction).toHaveBeenNthCalledWith(1, user.id);
     // Patch: allow for id only (ignore _id)