zync-nest-data-module 1.0.0 → 1.1.38

package/libs/src/database/database.repository.ts

@@ -1,17 +1,12 @@
+import { Inject } from "@nestjs/common";
 import { InjectModel } from "@nestjs/mongoose";
 import moment from "moment";
 import { Document, FilterQuery, PipelineStage, Schema, Types } from "mongoose";
 import { SoftDeleteModel } from "mongoose-delete";
-import {
-  handlePageFacet,
-  handlePageResult,
-  IPageParams,
-  IPageResult,
-} from "./database.scheme";
-import { TransactionSession } from "./database.transaction";
+import { handlePageFacet, handlePageResult, IPageParams, IPageResult } from "./database.scheme";
+import { TransactionManager, TransactionSession } from "./database.transaction";
 import { ApUniqueIdGenerator, UniqueKeyTypes } from "./database.uniqueId";
 import { DbUtils } from "./database.utils";
-import { Inject } from '@nestjs/common';
 
 export interface IRefInput<T> {
   prefix?: string;
@@ -19,33 +14,28 @@ export interface IRefInput<T> {
   filter?: FilterQuery<T>;
 }
 
-export abstract class AbstractBaseRepository<
-  T extends Omit<Document<any, any, any>, "delete">
-> {
+export abstract class AbstractBaseRepository<T extends Omit<Document<any, any, any>, "delete">> {
   private _session: TransactionSession = null;
 
   @Inject(ApUniqueIdGenerator)
-  private uniqueIdGenerator: ApUniqueIdGenerator  ;
+  private uniqueIdGenerator: ApUniqueIdGenerator;
 
   constructor(
     @InjectModel("MODEL_NAME")
     protected dbModel: SoftDeleteModel<T>
-  ) {}
+  ) { }
 
   protected abstract buildQuery(query: Partial<T>): any;
 
-  public abstract mapData(data: any, isCreate: boolean): Promise<T>;
-
-  public set session(v: TransactionSession) {
-    this._session = v;
-  }
+  protected abstract mapData?(data: any, isCreate: boolean): Promise<T>;
 
   public get session(): TransactionSession {
-    return this._session;
+    return TransactionManager.getCurrentSession();
   }
 
   private get hasSession(): boolean {
-    return !!this._session && !this._session.hasEnded;
+    const session = this.session;
+    return !!session && !session.hasEnded;
   }
 
   protected mapIds(query: Partial<T>): any {
@@ -85,8 +75,7 @@ export abstract class AbstractBaseRepository<
   }
 
   public async aggregate(pipeline?: PipelineStage[]): Promise<T[]> {
-    if (!this.hasSession)
-      return await this.dbModel.aggregate(pipeline).session(this.session);
+    if (!this.hasSession) return await this.dbModel.aggregate(pipeline).session(this.session);
 
     return await this.dbModel.aggregate(pipeline).session(this.session);
   }
@@ -110,11 +99,11 @@ export abstract class AbstractBaseRepository<
   }
 
   protected async _create(data: Partial<T> | T): Promise<T> {
-    const payload = await this.mapData(data, true);
+    const payload: any = await this._mapData(data, true);
 
-    payload._id = payload._id
-      ? new Types.ObjectId(payload._id?.toString())
-      : this.getObjectId();
+    payload.ref = payload.ref || (await this.generateRef());
+
+    payload._id = payload._id ? new Types.ObjectId(payload._id?.toString()) : this.getObjectId();
 
     const created = new this.dbModel(payload);
 
@@ -158,9 +147,7 @@ export abstract class AbstractBaseRepository<
 
     query = this.mapIds(query) as FilterQuery<T>;
 
-    const findQuery = this.dbModel
-      .find(query as FilterQuery<T>)
-      .sort({ createdAt: -1 });
+    const findQuery = this.dbModel.find(query as FilterQuery<T>).sort({ createdAt: -1 });
 
     if (this.hasSession) {
       findQuery.session(this.session);
@@ -172,14 +159,14 @@ export abstract class AbstractBaseRepository<
   protected async _update(id: string, data: Partial<T>): Promise<T> {
     delete data._id;
 
-    const payload = await this.mapData(data, false);
+    const payload = await this._mapData(data, false);
 
     await this.dbModel
       .updateOne(
         { _id: new Types.ObjectId(id) },
         { $set: payload },
         {
-          ...(this.hasSession && { session: this.session }),
+          ...(this.hasSession && { session: this.session })
         }
       )
       .exec();
@@ -187,10 +174,25 @@ export abstract class AbstractBaseRepository<
     return await this.findById(id);
   }
 
-  protected async _updateMany(
-    query: Partial<T>,
-    model: Partial<T>
-  ): Promise<void> {
+  private async _mapData(data: Partial<T>, isNew: boolean): Promise<Partial<T>> {
+    const payload: any = await this.mapData(data, isNew);
+
+    payload.documentNo = payload.documentNo || (await this.generateRef());
+    payload.documentDate = payload.documentDate ? moment(payload.documentDate).valueOf() : moment().valueOf();
+
+    if (isNew) {
+      // payload.createdBy = payload.createdBy || this.contextUser?._id;
+      payload.ref = payload.ref || (await this.generateRef());
+      payload.createdAt = payload.createdAt ? moment(payload.createdAt).valueOf() : moment().valueOf();
+    } else {
+      // payload.updatedBy = payload.updatedBy || this.contextUser?._id;
+      payload.updatedAt = payload.updatedAt ? moment(payload.updatedAt).valueOf() : moment().valueOf();
+    }
+
+    return this.mapIds(payload);
+  }
+
+  protected async _updateMany(query: Partial<T>, model: Partial<T>): Promise<void> {
     delete model._id;
 
     query = this.mapIds(query) as FilterQuery<T>;
@@ -202,7 +204,7 @@ export abstract class AbstractBaseRepository<
         query as FilterQuery<T>,
         {
           ...model,
-          updatedAt: Date.now(),
+          updatedAt: Date.now()
         },
         this.hasSession ? { new: true, session: this.session } : {}
       )
@@ -248,16 +250,13 @@ export abstract class AbstractBaseRepository<
     return result.length === 0 ? null : result[0];
   }
 
-  protected async _page(
-    page: IPageParams,
-    $lookups?: any[]
-  ): Promise<IPageResult<T>> {
+  protected async _page(page: IPageParams, $lookups?: any[]): Promise<IPageResult<T>> {
     const query = this.buildQuery(page as any);
     return this.aggregate([
       ...(!!$lookups?.length ? $lookups : []),
       ...(Array.isArray(query) ? query : [query]),
       { $sort: { createdAt: -1 } },
-      { ...handlePageFacet(page) },
+      { ...handlePageFacet(page) }
     ]).then(handlePageResult<T>);
   }
 
@@ -274,6 +273,7 @@ export abstract class AbstractBaseRepository<
       >;
       searchKeys?: string[];
       ignoreKeys?: string[];
+      dateKey?: string;
     },
     addMatchCondition: (condition: any) => void
   ) {
@@ -282,10 +282,7 @@ export abstract class AbstractBaseRepository<
     Object.keys(schema.obj).forEach((key) => {
       if (query[key] && !ignoreKeys?.includes(key)) {
         addMatchCondition({
-          [key]:
-            schema.path(key).instance === "Mixed"
-              ? this.toObjectId(query[key])
-              : query[key],
+          [key]: schema.path(key).instance === "Mixed" ? this.toObjectId(query[key]) : query[key]
         });
       }
     });
@@ -293,7 +290,7 @@ export abstract class AbstractBaseRepository<
     if (query?.keyword && options.searchKeys?.length) {
       const keywordValue = query?.keyword;
       const globalSearchConditions = options.searchKeys?.map((field) => ({
-        [field]: { $regex: keywordValue, $options: "i" },
+        [field]: { $regex: keywordValue, $options: "i" }
       }));
 
       if (globalSearchConditions.length > 0) {
@@ -303,16 +300,16 @@ export abstract class AbstractBaseRepository<
 
     if (query?.fromDate && query?.toDate) {
       addMatchCondition({
-        createdAt: {
+        [options.dateKey || "createdAt"]: {
           $gte: moment(query.fromDate).startOf("day").valueOf(),
-          $lte: moment(query.toDate).endOf("day").valueOf(),
-        },
+          $lte: moment(query.toDate).endOf("day").valueOf()
+        }
       });
     }
 
     if (query?.ref) {
       addMatchCondition({
-        ref: { $regex: query.ref?.toUpperCase(), $options: "i" },
+        ref: { $regex: query.ref?.toUpperCase(), $options: "i" }
       });
     }
   }

package/libs/src/database/database.scheme.ts

@@ -109,10 +109,10 @@ export interface IPageResult<T> {
   data: Array<T>;
 }
 
-export const handlePageFacet = (page: any) => {
+export const handlePageFacet = (page: any, $lookups?: any[]) => {
   return {
     $facet: {
-      data: [{ $skip: Number(page.skip) }, { $limit: Number(page.take) }],
+      data: [{ $skip: Number(page.skip) }, { $limit: Number(page.take) }, ...($lookups || [])],
       totalRecords: [{ $count: "count" }],
     },
   };

package/libs/src/database/database.service.ts

@@ -1,36 +1,75 @@
-import { Injectable } from "@nestjs/common";
-import { Connection, createConnection } from "mongoose";
+import { Injectable, Logger } from "@nestjs/common";
+import mongoose, { Connection } from "mongoose";
 
-@Injectable({})
+@Injectable()
 export class DatabaseService {
+  private readonly logger = new Logger(DatabaseService.name);
+  private readonly connections: Map<string, Promise<Connection>> = new Map();
   private _connectionId: string = process.env.mongodb_default_db_name;
-  private connections: Map<string, Connection> = new Map();
 
-  public setConnection(companyId: string): Connection {
-    this._connectionId = companyId
-      ? companyId
-      : process.env.mongodb_default_db_name;
+  /**
+   * Create or retrieve a connection for a given DB name (company/module)
+   */
+  public async setConnection(companyId?: string): Promise<Connection> {
+    const dbName = companyId || process.env.mongodb_default_db_name;
 
-    // Check if the connection already exists
-    if (this.connections.has(companyId)) {
-      return this.connections.get(companyId);
+    // ✅ Reuse existing pending/established connection
+    if (this.connections.has(dbName)) {
+      return this.connections.get(dbName);
     }
 
-    // Create new connection
-    const connection = createConnection(
-      process.env.mongodb_url?.replace("{{db_name}}", companyId)
-    );
+    const mongoUri = process.env.mongodb_url?.replace("{{db_name}}", dbName);
+    if (!mongoUri) {
+      throw new Error("mongodb_url not defined in environment variables");
+    }
+
+    this.logger.log(`Connecting to MongoDB: ${dbName}`);
+
+    // ✅ Store promise immediately to prevent race conditions
+    const connectionPromise = mongoose.createConnection(mongoUri).asPromise();
+
+    this.connections.set(dbName, connectionPromise);
+
+    // ✅ Wait until fully connected
+    const connection = await connectionPromise;
 
-    this.connections.set(companyId, connection);
+    connection.on("connected", () =>
+      this.logger.log(`✅ MongoDB connected: ${dbName}`)
+    );
+    connection.on("disconnected", () => {
+      this.logger.warn(`⚠️ MongoDB disconnected: ${dbName}`);
+      this.connections.delete(dbName);
+    });
+    connection.on("error", (err) => {
+      this.logger.error(`❌ MongoDB error on ${dbName}: ${err.message}`);
+      this.connections.delete(dbName);
+    });
 
     return connection;
   }
 
-  public getConnection(): Connection {
-    // Check if the connection already exists
-    if (this.connections.has(this._connectionId)) {
-      return this.connections.get(this._connectionId);
+  /**
+   * Retrieve an existing connection, or create one if missing
+   */
+  public async getConnection(companyId?: string): Promise<Connection> {
+    const dbName = companyId || this._connectionId;
+
+    if (this.connections.has(dbName)) {
+      return this.connections.get(dbName);
+    }
+
+    return this.setConnection(dbName);
+  }
+
+  /**
+   * Gracefully close all open connections
+   */
+  public async closeAll(): Promise<void> {
+    for (const [dbName, connPromise] of this.connections.entries()) {
+      const conn = await connPromise;
+      await conn.close();
+      this.logger.log(`Closed MongoDB connection: ${dbName}`);
     }
-    return this.setConnection(this._connectionId);
+    this.connections.clear();
   }
-}
+}

package/libs/src/database/database.transaction.ts

@@ -1,101 +1,99 @@
-import { Injectable, Scope } from "@nestjs/common";
+import { Injectable, Scope, Logger } from "@nestjs/common";
 import { InjectConnection } from "@nestjs/mongoose";
-import { MongoServerError } from "mongodb"; // Import MongoServerError if using native MongoDB driver
 import mongodb, { ClientSession, Connection } from "mongoose";
-import { DatabaseService } from "./database.service";
+import { AsyncLocalStorage } from "async_hooks";
 
 export type TransactionSession = mongodb.ClientSession;
 
 @Injectable({ scope: Scope.DEFAULT })
 export class TransactionManager {
-  private _session: ClientSession;
-  private _sessionName: string;
-  constructor(
-    @InjectConnection() private readonly connection: Connection,
-    private dbSvc: DatabaseService
-  ) { }
+  private readonly logger = new Logger(TransactionManager.name);
+  private static readonly storage = new AsyncLocalStorage<{ session: ClientSession; sessionName?: string }>();
 
-  private async getSession(): Promise<ClientSession> {
-    return await this.dbSvc.getConnection().startSession();
+  constructor(@InjectConnection() private readonly connection: Connection) { }
+
+  public run<T>(callback: () => Promise<T>): Promise<T> {
+    return TransactionManager.storage.run({ session: null }, callback);
   }
 
-  public async startTransaction(): Promise<TransactionSession> {
-    this._session = await this.getSession();
+  public static getCurrentSession(): ClientSession | null {
+    const store = TransactionManager.storage.getStore();
+    return store?.session || null;
+  }
 
-    this._session.startTransaction({
-      readConcern: { level: "local" },
-      writeConcern: { w: "majority", j: true },
-      readPreference: "primary",
+  private async getSession(): Promise<ClientSession> {
+    const store = TransactionManager.storage.getStore();
+    if (!store) {
+      throw new Error("[TransactionManager] Context not initialized. Use run() method.");
+    }
+
+    if (store.session) return store.session;
+
+    store.session = await this.connection.startSession();
+    store.session.startTransaction({
+      readConcern: { level: "snapshot" },
+      writeConcern: { w: "majority" },
     });
-    return this._session as TransactionSession;
+    return store.session as TransactionSession;
   }
 
-  public async commitTransaction(retries: number = 3): Promise<void> {
-    // if (this._session && this._session.transaction.isActive) {
-    //   try {
-    //     await this._session.commitTransaction();
-    //   } catch (error) {
-    //     console.error("Transaction commit failed:", error);
-    //     await this.abortTransaction();
-    //   } finally {
-    //     await this._session.endSession();
-    //   }
-    // }
-    if (this._session && this._session.transaction.isActive) {
-      let attempt = 0;
-      while (attempt < retries) {
-        try {
-          await this._session.commitTransaction();
-          return;
-        } catch (error) {
-          if (
-            error instanceof MongoServerError &&
-            error.message.includes("Write conflict during plan execution")
-          ) {
-            attempt++;
-            if (attempt >= retries) {
-              throw error;
-            }
-            console.warn(
-              `Write conflict detected. Retrying commit (${attempt}/${retries})...`
-            );
-            await new Promise((resolve) => setTimeout(resolve, 1000)); // Wait for 1 second before retrying
-          } else {
-            throw error;
-          }
-        } finally {
-          await this._session.endSession();
-          // await this.dbSvc.getConnection().close();
-        }
-      }
+  public async startTransaction(): Promise<TransactionSession> {
+    return await this.getSession();
+  }
+
+  public async commitTransaction(): Promise<void> {
+    const store = TransactionManager.storage.getStore();
+    if (!store?.session) {
+      throw new Error("[TransactionManager] No session available");
+    }
+
+    if (!store.session.transaction.isActive) {
+      this.logger.warn("[TransactionManager] No active transaction to commit"); // Changed to warn
+      return;
+    }
+
+    try {
+      await store.session.commitTransaction();
+      this.logger.log("[TransactionManager] Transaction committed successfully.");
+    } catch (error) {
+      await this.abortTransaction();
+      throw error;
+    } finally {
+      this.logger.log("[TransactionManager] Ending transaction...");
+      await this.endTransaction();
     }
   }
 
   public async abortTransaction(): Promise<void> {
-    if (this._session && this._session.transaction.isActive) {
+    const store = TransactionManager.storage.getStore();
+    if (store?.session && store.session.transaction.isActive) {
       try {
-        await this._session.abortTransaction();
-        await this._session.endSession();
+        await store.session.abortTransaction();
       } catch (error) {
       } finally {
-        await this._session.endSession();
+        await this.endTransaction();
       }
     }
   }
 
   public async endTransaction(): Promise<void> {
-    if (this._session) {
+    const store = TransactionManager.storage.getStore();
+    if (store?.session) {
       try {
-        await this._session.endSession();
+        await store.session.endSession();
       } catch (error) { }
+      store.session = null;
     }
   }
 
   public get sessionName(): string {
-    return this._sessionName;
+    return TransactionManager.storage.getStore()?.sessionName;
   }
 
   public set sessionName(name: string) {
-    this._sessionName = name;
+    const store = TransactionManager.storage.getStore();
+    if (store) {
+      store.sessionName = name;
+    }
   }
 }

package/libs/src/database/database.uniqueId.ts

@@ -1,7 +1,9 @@
-import { Injectable } from "@nestjs/common";
-import { InjectModel, Prop, Schema, SchemaFactory } from "@nestjs/mongoose";
+import { Inject, Injectable, OnModuleInit } from "@nestjs/common";
+import { getModelToken, InjectModel, Prop, Schema, SchemaFactory } from "@nestjs/mongoose";
 import { Document, Types } from "mongoose";
 import { SoftDeleteModel } from "mongoose-delete";
+import { CONNECTION_NAME } from "./database.module";
+import { ModuleRef } from "@nestjs/core";
 
 @Schema({ collection: "unique_ids" })
 export class UniqueId {
@@ -18,15 +20,42 @@ export const UniqueIdSchema = SchemaFactory.createForClass(UniqueId);
 export type UniqueKeyTypes = "users" | "uniqueId";
 
 @Injectable({})
-export class ApUniqueIdGenerator {
-  constructor(
-    @InjectModel(UniqueId.name)
-    private model: SoftDeleteModel<UniqueIdDocument>
-  ) {
-    this.seed();
+export class ApUniqueIdGenerator implements OnModuleInit {
+  private model: SoftDeleteModel<UniqueId>;
+
+  constructor(@Inject(CONNECTION_NAME) private readonly connName: string, private readonly moduleRef: ModuleRef) {}
+  // constructor(
+  //   @InjectModel(UniqueId.name)
+  //   private model: SoftDeleteModel<UniqueIdDocument>
+  // ) {}
+  onModuleInit() {
+    this.ensureModelInitialized();
+  }
+
+  private ensureModelInitialized(): void {
+    if (!this.model) {
+      // Lazy initialization as fallback
+      this.model = this.connName
+        ? this.moduleRef.get<SoftDeleteModel<UniqueId>>(getModelToken(UniqueId.name, this.connName), {
+            strict: false
+          })
+        : this.moduleRef.get<SoftDeleteModel<UniqueId>>(getModelToken(UniqueId.name), {
+            strict: false
+          });
+
+      if (!this.model) {
+        throw new Error(
+          `UniqueId model is not initialized. Please ensure MongooseModule.forFeature includes UniqueId schema with connection name: ${
+            this.connName || "default"
+          }`
+        );
+      }
+    }
   }
 
   public async getNextUniqueId(key: string = "uniqueId"): Promise<number> {
+    this.ensureModelInitialized();
+
     const result = await this.model.findOneAndUpdate(
       { key },
       { $inc: { sequence_value: 1 } },
@@ -45,6 +74,8 @@ export class ApUniqueIdGenerator {
   }
 
   public async seed(): Promise<void> {
+    this.ensureModelInitialized();
+
     const keys = [{ key: "uniqueId", sequence_value: 1001 }];
 
     for await (const key of keys) {

package/libs/src/index.ts

@@ -1,3 +1,5 @@
 export * from "./backup";
 export * from "./database";
-export * from "./service";
+export * from "./service";
+export * from "./base";
+export * from "./redis";

package/libs/src/main.ts

@@ -1,10 +1,9 @@
 import { NestFactory } from "@nestjs/core";
-import { SwaggerModule, DocumentBuilder } from "@nestjs/swagger";
-import { ValidationPipe } from "@nestjs/common";
-import { ApDbModule } from "./app.module";
+import { DocumentBuilder, SwaggerModule } from "@nestjs/swagger";
+import { ZyncNestDataModule } from "./app.module";
 
 async function bootstrap() {
-  const app = await NestFactory.create(ApDbModule);
+  const app = await NestFactory.create(ZyncNestDataModule);
 
   // Enable CORS
   app.enableCors({
@@ -12,26 +11,17 @@ async function bootstrap() {
     credentials: true,
   });
 
-  // // Global validation pipe
-  // app.useGlobalPipes(
-  //   new ValidationPipe({
-  //     transform: true,
-  //     whitelist: true,
-  //     forbidNonWhitelisted: true,
-  //   })
-  // );
-
   // Swagger configuration
   const config = new DocumentBuilder()
-    .setTitle("Zync Nest Database API")
-    .setDescription("API documentation for Zync Nest Database")
+    .setTitle("Zync Nest Data Module API")
+    .setDescription("API documentation for Zync Nest Data Module")
     .setVersion("1.0.23")
-    .addTag("Database", "Database endpoints for Zync Nest Database")
+    .addTag("Data Module", "Data Module endpoints for Zync Nest Data Module")
     .build();
 
   const document = SwaggerModule.createDocument(app, config);
   SwaggerModule.setup("api", app, document, {
-    customSiteTitle: "Zync Nest Database API",
+    customSiteTitle: "Zync Nest Data Module API",
     customfavIcon: "https://nestjs.com/img/logo-small.svg",
     customJs: [
       "https://cdnjs.cloudflare.com/ajax/libs/swagger-ui/4.15.5/swagger-ui-bundle.js",
@@ -46,7 +36,7 @@ async function bootstrap() {
   await app.listen(port);
 
   console.log(
-    `🚀 Zync Nest Database server is running on: http://localhost:${port}`
+    `🚀 Zync Nest Data Module server is running on: http://localhost:${port}`
   );
   console.log(
     `📚 Swagger documentation available at: http://localhost:${port}/api`

package/libs/src/redis/index.ts

@@ -0,0 +1,2 @@
+export * from "./redis.service";
+export * from "./redis.module";

package/libs/src/redis/redis.interface.ts

@@ -0,0 +1,34 @@
+export interface IRedisSearchParams {
+  query?: string;
+  minScore?: number;
+  maxScore?: number;
+  keyPrefix?: string;
+  sortBy: {
+    field: string;
+    order?: "asc" | "desc";
+  };
+}
+
+export interface IRedisPageParams extends IRedisSearchParams {
+  page: number; // 1-based page
+  pageSize: number;
+}
+
+export interface IRedisSearchResult<T> {
+  data: T[];
+  totalRecords: number;
+  page?: number;
+  totalPages?: number;
+}
+
+export interface IRedisZSetItem {
+  key: string;
+  score: number;
+}
+
+export interface IRedisSchemaField {
+  name: string;
+  type: "TEXT" | "NUMERIC" | "TAG"; // supported Redisearch types
+  sortable?: boolean; // if field can be used in SORTBY
+  noIndex?: boolean; // optional, skip indexing
+}