zync-nest-data-module 1.0.0

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

@@ -0,0 +1,358 @@
+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 { ApUniqueIdGenerator, UniqueKeyTypes } from "./database.uniqueId";
+import { DbUtils } from "./database.utils";
+import { Inject } from '@nestjs/common';
+
+export interface IRefInput<T> {
+  prefix?: string;
+  key?: UniqueKeyTypes;
+  filter?: FilterQuery<T>;
+}
+
+export abstract class AbstractBaseRepository<
+  T extends Omit<Document<any, any, any>, "delete">
+> {
+  private _session: TransactionSession = null;
+
+  @Inject(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;
+  }
+
+  public get session(): TransactionSession {
+    return this._session;
+  }
+
+  private get hasSession(): boolean {
+    return !!this._session && !this._session.hasEnded;
+  }
+
+  protected mapIds(query: Partial<T>): any {
+    return DbUtils.mapToObjectIds<T>(query);
+  }
+
+  public async create(data: Partial<T> | T): Promise<T> {
+    return await this._create(data);
+  }
+
+  public async findById(id: string): Promise<T> {
+    return await this._findById(id);
+  }
+
+  public async findOne(query: FilterQuery<T>): Promise<T> {
+    return await this._findOne(query);
+  }
+
+  public async find(query: FilterQuery<T>): Promise<T[]> {
+    return await this._find(query);
+  }
+
+  public async update(id: string, data: Partial<T>): Promise<T> {
+    return this._update(id, data);
+  }
+
+  public async updateMany(query: Partial<T>, model: Partial<T>): Promise<void> {
+    await this._updateMany(query, model);
+  }
+
+  public async delete(id: string): Promise<void> {
+    await this._delete(id);
+  }
+
+  public async deleteMany(query: Partial<T>): Promise<void> {
+    await this._deleteMany(query);
+  }
+
+  public async aggregate(pipeline?: PipelineStage[]): Promise<T[]> {
+    if (!this.hasSession)
+      return await this.dbModel.aggregate(pipeline).session(this.session);
+
+    return await this.dbModel.aggregate(pipeline).session(this.session);
+  }
+
+  public async page(page: IPageParams): Promise<IPageResult<T>> {
+    return await this._page(page);
+  }
+
+  public async findLast(query: FilterQuery<T>): Promise<T> {
+    return await this._findLast(query);
+  }
+
+  public async count(query?: FilterQuery<T>): Promise<number> {
+    return this._count(query);
+  }
+
+  protected async _count(query: FilterQuery<T>): Promise<number> {
+    query = this.mapIds(query) as FilterQuery<T>;
+
+    return this.dbModel.countDocuments(query as FilterQuery<T>);
+  }
+
+  protected async _create(data: Partial<T> | T): Promise<T> {
+    const payload = await this.mapData(data, true);
+
+    payload._id = payload._id
+      ? new Types.ObjectId(payload._id?.toString())
+      : this.getObjectId();
+
+    const created = new this.dbModel(payload);
+
+    if (!this.hasSession) {
+      const saved = await created.save();
+
+      return await this.findById(saved._id);
+    }
+
+    const saved = await created.save({ session: this.session });
+
+    return await this.findById(saved._id);
+  }
+
+  protected async _findById(id: string): Promise<T> {
+    const findQuery = this.dbModel.findById(new Types.ObjectId(id?.toString()));
+
+    if (this.hasSession) {
+      findQuery.session(this.session);
+    }
+
+    return findQuery.exec().then((res) => (res as any)?._doc || res);
+  }
+
+  protected async _findOne(query: FilterQuery<T>): Promise<T> {
+    query = this.mapIds(query) as FilterQuery<T>;
+
+    const findQuery = this.dbModel.findOne(query as FilterQuery<T>);
+
+    if (this.hasSession) {
+      findQuery.session(this.session);
+    }
+
+    return findQuery.exec().then((res) => (res as any)?._doc || res);
+  }
+
+  protected async _find(query: FilterQuery<T>): Promise<T[]> {
+    if (query._id) {
+      query._id = new Types.ObjectId(query._id);
+    }
+
+    query = this.mapIds(query) as FilterQuery<T>;
+
+    const findQuery = this.dbModel
+      .find(query as FilterQuery<T>)
+      .sort({ createdAt: -1 });
+
+    if (this.hasSession) {
+      findQuery.session(this.session);
+    }
+
+    return findQuery.exec().then((res) => (res as any)?._doc || res);
+  }
+
+  protected async _update(id: string, data: Partial<T>): Promise<T> {
+    delete data._id;
+
+    const payload = await this.mapData(data, false);
+
+    await this.dbModel
+      .updateOne(
+        { _id: new Types.ObjectId(id) },
+        { $set: payload },
+        {
+          ...(this.hasSession && { session: this.session }),
+        }
+      )
+      .exec();
+
+    return await this.findById(id);
+  }
+
+  protected async _updateMany(
+    query: Partial<T>,
+    model: Partial<T>
+  ): Promise<void> {
+    delete model._id;
+
+    query = this.mapIds(query) as FilterQuery<T>;
+
+    model = this.mapIds(model);
+
+    await this.dbModel
+      .updateMany(
+        query as FilterQuery<T>,
+        {
+          ...model,
+          updatedAt: Date.now(),
+        },
+        this.hasSession ? { new: true, session: this.session } : {}
+      )
+      .exec();
+  }
+
+  protected async _delete(id: string): Promise<void> {
+    const deleteQuery = this.dbModel.findByIdAndDelete(new Types.ObjectId(id));
+
+    if (this.hasSession) {
+      deleteQuery.session(this.session);
+    }
+
+    await deleteQuery.exec();
+  }
+
+  protected async _deleteMany(query: Partial<T>): Promise<void> {
+    query = this.mapIds(query) as FilterQuery<T>;
+
+    const deleteQuery = this.dbModel.deleteMany(query as FilterQuery<T>);
+
+    if (this.hasSession) {
+      deleteQuery.session(this.session);
+    }
+
+    await deleteQuery.exec();
+  }
+
+  protected async _findLast(query: FilterQuery<T>): Promise<T> {
+    query = this.mapIds(query) as FilterQuery<T>;
+
+    const findQuery = this.dbModel
+      .find(query as FilterQuery<T>)
+      .limit(1)
+      .sort({ createdAt: -1 });
+
+    if (this.hasSession) {
+      findQuery.session(this.session);
+    }
+
+    const result = await findQuery.exec();
+
+    return result.length === 0 ? null : result[0];
+  }
+
+  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) },
+    ]).then(handlePageResult<T>);
+  }
+
+  public schemaKeysQuery(
+    schema: Schema,
+    options: {
+      query: Partial<
+        T & {
+          fromDate?: number;
+          toDate?: number;
+          ref?: string;
+          keyword?: string;
+        }
+      >;
+      searchKeys?: string[];
+      ignoreKeys?: string[];
+    },
+    addMatchCondition: (condition: any) => void
+  ) {
+    const { query, ignoreKeys } = options;
+
+    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],
+        });
+      }
+    });
+
+    if (query?.keyword && options.searchKeys?.length) {
+      const keywordValue = query?.keyword;
+      const globalSearchConditions = options.searchKeys?.map((field) => ({
+        [field]: { $regex: keywordValue, $options: "i" },
+      }));
+
+      if (globalSearchConditions.length > 0) {
+        addMatchCondition({ $or: globalSearchConditions });
+      }
+    }
+
+    if (query?.fromDate && query?.toDate) {
+      addMatchCondition({
+        createdAt: {
+          $gte: moment(query.fromDate).startOf("day").valueOf(),
+          $lte: moment(query.toDate).endOf("day").valueOf(),
+        },
+      });
+    }
+
+    if (query?.ref) {
+      addMatchCondition({
+        ref: { $regex: query.ref?.toUpperCase(), $options: "i" },
+      });
+    }
+  }
+
+  public cleanupQuery(andConditions: any[]) {
+    // If no conditions, match all
+    if (andConditions.length === 0) {
+      return { $match: {} };
+    }
+
+    // If only one condition, avoid unnecessary $and
+    if (andConditions.length === 1) {
+      return { $match: andConditions[0] };
+    }
+
+    // Otherwise, use $and
+    return { $match: { $and: andConditions } };
+  }
+
+  public getObjectId(): string {
+    return this.uniqueIdGenerator.getObjectId();
+  }
+
+  public toObjectId(value: string | any): Types.ObjectId {
+    return new Types.ObjectId(value?.toString());
+  }
+
+  public async generateUniqueId(key: UniqueKeyTypes): Promise<number> {
+    return await this.uniqueIdGenerator.getNextUniqueId(key);
+  }
+
+  public async generateRef(ref?: IRefInput<T>): Promise<string> {
+    const key = ref?.key || "uniqueId";
+    const prefix = ref?.prefix;
+    try {
+      const newRefNumber = await this.uniqueIdGenerator.getNextUniqueId(key);
+      return prefix ? `${prefix}-${newRefNumber}` : `${newRefNumber}`;
+    } catch (error) {
+      console.error("Error generating reference:", error);
+      throw new Error("Failed to generate reference");
+    }
+  }
+}

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

@@ -0,0 +1,128 @@
+import { Prop } from "@nestjs/mongoose";
+import moment from "moment";
+import mongoose, { Types } from "mongoose";
+
+export class BaseSchema {
+  @Prop({ set: (val) => BaseSchema.toObjectId(val) })
+  _id: Types.ObjectId;
+  @Prop({ required: true, unique: true })
+  ref: string;
+  @Prop({ set: (val) => BaseSchema.toObjectId(val) })
+  branchId: Types.ObjectId;
+  @Prop({ set: (val) => moment(val).valueOf() })
+  createdAt: number;
+  @Prop({ set: (val) => new Types.ObjectId(val) })
+  createdBy: Types.ObjectId;
+  @Prop({ set: (val) => moment(val).valueOf() })
+  updatedAt: number;
+  @Prop({ set: (val) => new Types.ObjectId(val) })
+  updatedBy: Types.ObjectId;
+  @Prop({ set: (val) => moment(val).valueOf() })
+  deletedAt: number;
+  @Prop({ set: (val) => new Types.ObjectId(val) })
+  deletedBy: Types.ObjectId;
+  @Prop({ set: (val) => moment(val).valueOf() })
+  deleted: boolean;
+
+  @Prop({ set: (val) => moment(val).valueOf() })
+  documentDate: number;
+
+  @Prop({
+    validate: {
+      validator: function (v) {
+        // If empty, skip unique validation (allow multiple empty)
+        return (
+          v === undefined ||
+          v === null ||
+          v === "" ||
+          this.model(this.constructor.modelName)
+            .countDocuments({
+              documentNumber: v,
+              _id: { $ne: BaseSchema.toObjectId(this._id) },
+            })
+            .then((count) => count === 0)
+        );
+      },
+      message: "documentNumber must be unique if not empty",
+    },
+  })
+  documentNumber: string;
+
+  @Prop({ default: false })
+  canDelete: boolean;
+
+  @Prop({ default: false })
+  canUpdate: boolean;
+
+  @Prop({ set: (val) => (val === "" ? undefined : new Types.ObjectId(val)) })
+  storeId: Types.ObjectId;
+
+  @Prop({ set: (val) => new Types.ObjectId(val) })
+  companyId: Types.ObjectId;
+
+  @Prop({ set: (val) => new Types.ObjectId(val) })
+  employeeId: Types.ObjectId;
+
+  static toObjectId(value: string) {
+    try {
+      if (Array.isArray(value)) {
+        return value.map((v) =>
+          mongoose.Types.ObjectId.isValid(v)
+            ? new mongoose.Types.ObjectId(v)
+            : v
+        );
+      } else if (mongoose.Types.ObjectId.isValid(value)) {
+        return new mongoose.Types.ObjectId(value);
+      } else if (typeof value === "string") {
+        return new mongoose.Types.ObjectId(value);
+      }
+    } catch (error) {
+      return value;
+    }
+  }
+
+  static toUnixTimestamp(value: number | string) {
+    if (!value) {
+      return moment().valueOf();
+    }
+
+    if (typeof value === "number" && !Number.isNaN(value)) {
+      return value;
+    }
+
+    const momentDate = moment(value);
+    if (momentDate.isValid()) {
+      return momentDate.valueOf();
+    }
+
+    return moment().valueOf();
+  }
+}
+
+export interface IPageParams extends BaseSchema {
+  skip: number;
+  take: number;
+}
+
+export interface IPageResult<T> {
+  totalRecords: number;
+  data: Array<T>;
+}
+
+export const handlePageFacet = (page: any) => {
+  return {
+    $facet: {
+      data: [{ $skip: Number(page.skip) }, { $limit: Number(page.take) }],
+      totalRecords: [{ $count: "count" }],
+    },
+  };
+};
+
+export const handlePageResult = <T>(res: any): IPageResult<T> => {
+  let rs = res[0] as any;
+  if (rs.totalRecords.length)
+    rs = { ...rs, totalRecords: rs.totalRecords[0].count };
+  else rs = { ...rs, totalRecords: 0 };
+
+  return rs;
+};

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

@@ -0,0 +1,36 @@
+import { Injectable } from "@nestjs/common";
+import { Connection, createConnection } from "mongoose";
+
+@Injectable({})
+export class DatabaseService {
+  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;
+
+    // Check if the connection already exists
+    if (this.connections.has(companyId)) {
+      return this.connections.get(companyId);
+    }
+
+    // Create new connection
+    const connection = createConnection(
+      process.env.mongodb_url?.replace("{{db_name}}", companyId)
+    );
+
+    this.connections.set(companyId, connection);
+
+    return connection;
+  }
+
+  public getConnection(): Connection {
+    // Check if the connection already exists
+    if (this.connections.has(this._connectionId)) {
+      return this.connections.get(this._connectionId);
+    }
+    return this.setConnection(this._connectionId);
+  }
+}

package/libs/src/database/database.sync.ts

@@ -0,0 +1,61 @@
+import { config } from "dotenv";
+import { MongoClient, ChangeStreamDocument, Document, WithId } from "mongodb";
+config();
+
+interface RealtimeSyncOptions {
+  sourceUri: string;
+  targetUri: string;
+  collection: string;
+  sourceClient: MongoClient;
+  targetClient: MongoClient;
+}
+
+export async function realtimeSync(options: RealtimeSyncOptions): Promise<void> {
+  const { sourceUri, targetUri, collection, sourceClient, targetClient } = options;
+  // const sourceClient = new MongoClient(sourceUri);
+  // const targetClient = new MongoClient(targetUri);
+
+  await sourceClient.connect();
+  await targetClient.connect();
+
+  // Extract DB name from connection string
+  const getDbName = (uri: string) => {
+    const match = uri.match(/\/(\w+)(\?|$)/);
+    return match ? match[1] : undefined;
+  };
+  const sourceDB = getDbName(sourceUri);
+  const targetDB = getDbName(targetUri);
+
+  console.log(`🔗 Connected to source DB: ${sourceDB}`);
+  console.log(`🔗 Connected to target DB: ${targetDB}`);
+
+  if (!sourceDB || !targetDB) {
+    throw new Error("Database name must be specified in both connection strings.");
+  }
+
+  const source = sourceClient.db(sourceDB).collection(collection);
+  const target = targetClient.db(targetDB).collection(collection);
+
+  const changeStream = source.watch([], { fullDocument: "updateLookup" });
+
+  console.log(`📡 Watching changes on ${sourceDB}.${collection}...`);
+
+  changeStream.on("change", async (change: ChangeStreamDocument<WithId<Document>>) => {
+    const { operationType, fullDocument, documentKey }: any = change;
+
+    try {
+      if (operationType === "insert" && fullDocument) {
+        // Use replaceOne with upsert to handle duplicates gracefully
+        await target.replaceOne({ _id: fullDocument._id }, fullDocument, { upsert: true });
+      } else if ((operationType === "update" || operationType === "replace") && fullDocument) {
+        await target.replaceOne({ _id: documentKey._id }, fullDocument, { upsert: true });
+      } else if (operationType === "delete") {
+        await target.deleteOne({ _id: documentKey._id });
+      }
+
+      console.log(`🔄 Synced ${operationType} for _id=${documentKey._id}`);
+    } catch (error) {
+      console.error(`❌ Error syncing ${operationType} for _id=${documentKey._id}:`, error);
+    }
+  });
+}

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

@@ -0,0 +1,101 @@
+import { Injectable, Scope } 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";
+
+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 async getSession(): Promise<ClientSession> {
+    return await this.dbSvc.getConnection().startSession();
+  }
+
+  public async startTransaction(): Promise<TransactionSession> {
+    this._session = await this.getSession();
+
+    this._session.startTransaction({
+      readConcern: { level: "local" },
+      writeConcern: { w: "majority", j: true },
+      readPreference: "primary",
+    });
+    return this._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 abortTransaction(): Promise<void> {
+    if (this._session && this._session.transaction.isActive) {
+      try {
+        await this._session.abortTransaction();
+        await this._session.endSession();
+      } catch (error) {
+      } finally {
+        await this._session.endSession();
+      }
+    }
+  }
+
+  public async endTransaction(): Promise<void> {
+    if (this._session) {
+      try {
+        await this._session.endSession();
+      } catch (error) { }
+    }
+  }
+
+  public get sessionName(): string {
+    return this._sessionName;
+  }
+
+  public set sessionName(name: string) {
+    this._sessionName = name;
+  }
+}