zync-nest-data-module 1.1.38 → 1.1.39

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

@@ -1,355 +0,0 @@
-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 { TransactionManager, TransactionSession } from "./database.transaction";
-import { ApUniqueIdGenerator, UniqueKeyTypes } from "./database.uniqueId";
-import { DbUtils } from "./database.utils";
-
-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;
-
-  protected abstract mapData?(data: any, isCreate: boolean): Promise<T>;
-
-  public get session(): TransactionSession {
-    return TransactionManager.getCurrentSession();
-  }
-
-  private get hasSession(): boolean {
-    const session = this.session;
-    return !!session && !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: any = await this._mapData(data, true);
-
-    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);
-
-    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);
-  }
-
-  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>;
-
-    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[];
-      dateKey?: 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({
-        [options.dateKey || "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

@@ -1,128 +0,0 @@
-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, $lookups?: any[]) => {
-  return {
-    $facet: {
-      data: [{ $skip: Number(page.skip) }, { $limit: Number(page.take) }, ...($lookups || [])],
-      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

@@ -1,75 +0,0 @@
-import { Injectable, Logger } from "@nestjs/common";
-import mongoose, { Connection } from "mongoose";
-
-@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;
-
-  /**
-   * 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;
-
-    // ✅ Reuse existing pending/established connection
-    if (this.connections.has(dbName)) {
-      return this.connections.get(dbName);
-    }
-
-    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;
-
-    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;
-  }
-
-  /**
-   * 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}`);
-    }
-    this.connections.clear();
-  }
-}

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

@@ -1,61 +0,0 @@
-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);
-    }
-  });
-}