zync-nest-data-module 1.1.38 → 1.1.39

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

@@ -1,99 +0,0 @@
-import { Injectable, Scope, Logger } from "@nestjs/common";
-import { InjectConnection } from "@nestjs/mongoose";
-import mongodb, { ClientSession, Connection } from "mongoose";
-import { AsyncLocalStorage } from "async_hooks";
-
-export type TransactionSession = mongodb.ClientSession;
-
-@Injectable({ scope: Scope.DEFAULT })
-export class TransactionManager {
-  private readonly logger = new Logger(TransactionManager.name);
-  private static readonly storage = new AsyncLocalStorage<{ session: ClientSession; sessionName?: string }>();
-
-  constructor(@InjectConnection() private readonly connection: Connection) { }
-
-  public run<T>(callback: () => Promise<T>): Promise<T> {
-    return TransactionManager.storage.run({ session: null }, callback);
-  }
-
-  public static getCurrentSession(): ClientSession | null {
-    const store = TransactionManager.storage.getStore();
-    return store?.session || null;
-  }
-
-  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 store.session as TransactionSession;
-  }
-
-  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> {
-    const store = TransactionManager.storage.getStore();
-    if (store?.session && store.session.transaction.isActive) {
-      try {
-        await store.session.abortTransaction();
-      } catch (error) {
-      } finally {
-        await this.endTransaction();
-      }
-    }
-  }
-
-  public async endTransaction(): Promise<void> {
-    const store = TransactionManager.storage.getStore();
-    if (store?.session) {
-      try {
-        await store.session.endSession();
-      } catch (error) { }
-      store.session = null;
-    }
-  }
-
-  public get sessionName(): string {
-    return TransactionManager.storage.getStore()?.sessionName;
-  }
-
-  public set sessionName(name: string) {
-    const store = TransactionManager.storage.getStore();
-    if (store) {
-      store.sessionName = name;
-    }
-  }
-}

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

@@ -1,90 +0,0 @@
-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 {
-  _id: string;
-  @Prop({ unique: true })
-  key: string;
-  @Prop()
-  sequence_value: number;
-}
-export type UniqueIdDocument = UniqueId & Document;
-
-export const UniqueIdSchema = SchemaFactory.createForClass(UniqueId);
-
-export type UniqueKeyTypes = "users" | "uniqueId";
-
-@Injectable({})
-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 } },
-      { returnDocument: "after", upsert: true }
-    );
-
-    if (!result) {
-      throw new Error("Failed to generate unique ID");
-    }
-
-    return result.sequence_value;
-  }
-
-  public getObjectId(): string {
-    return new Types.ObjectId().toString();
-  }
-
-  public async seed(): Promise<void> {
-    this.ensureModelInitialized();
-
-    const keys = [{ key: "uniqueId", sequence_value: 1001 }];
-
-    for await (const key of keys) {
-      const exist = await this.model.findOne({ key: key.key });
-
-      if (exist) {
-        continue;
-      }
-      await this.model.create(key);
-    }
-  }
-}

package/libs/src/database/database.utils.ts

@@ -1,99 +0,0 @@
-import moment from "moment";
-import { ObjectId } from "mongodb";
-import * as mongoose from "mongoose";
-import { Connection, Schema } from "mongoose";
-
-const mapToObjectIds = <T>(query: Partial<T>): T => {
-  try {
-    const mapVal = (val: any): any => {
-      if (Array.isArray(val)) {
-        return val.map(mapVal); // Recursively map each array element
-      } else if (val && typeof val === "object" && !ObjectId.isValid(val)) {
-        return mapToObjectIds(val); // Recursively process nested objects
-      } else if (
-        val &&
-        ObjectId.isValid(val?.toString()) &&
-        new ObjectId(val?.toString())?.toString() === val
-      ) {
-        return new ObjectId(val?.toString()); // Convert valid ObjectId strings
-      }
-      return val; // Return as-is if no conversion needed
-    };
-
-    const mappedQuery: any = { ...query };
-    Object.keys(mappedQuery).forEach((key) => {
-      mappedQuery[key] = mapVal(mappedQuery[key]); // Apply transformation
-    });
-
-    return mappedQuery;
-  } catch (error) {
-    console.error("mapToObjectIds Error:", error);
-    // return query; // Return original query in case of error
-  }
-};
-
-export const DbUtils = {
-  mapToObjectIds,
-  getOrCreateDiscriminatorModel(
-    connection: Connection = mongoose.connection,
-    baseModelName: string,
-    baseSchema: Schema,
-    discriminatorName: string,
-    discriminatorSchema: Schema
-  ) {
-    const getBaseModel = (conn: Connection | typeof mongoose) =>
-      conn.models[baseModelName] || conn.model(baseModelName, baseSchema);
-
-    const BaseModel = connection
-      ? getBaseModel(connection)
-      : getBaseModel(mongoose);
-
-    if (
-      !BaseModel.discriminators ||
-      !BaseModel.discriminators[discriminatorName]
-    ) {
-      return BaseModel.discriminator(discriminatorName, discriminatorSchema);
-    }
-
-    return connection
-      ? connection.models[discriminatorName] ||
-          connection.model(discriminatorName)
-      : mongoose.models[discriminatorName] || mongoose.model(discriminatorName);
-  },
-};
-
-export const SchemeUtil = {
-  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;
-    }
-  },
-  toCurrentDate: (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();
-  },
-};

package/libs/src/database/index.ts

@@ -1,8 +0,0 @@
-export * from './database.scheme';
-export * from './database.repository';
-export * from './database.transaction';
-export * from './database.module';
-export * from './database.uniqueId';
-export * from './database.service';
-export * from './database.utils';
-export * from './database.sync';

package/libs/src/index.ts

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

package/libs/src/main.ts

@@ -1,52 +0,0 @@
-import { NestFactory } from "@nestjs/core";
-import { DocumentBuilder, SwaggerModule } from "@nestjs/swagger";
-import { ZyncNestDataModule } from "./app.module";
-
-async function bootstrap() {
-  const app = await NestFactory.create(ZyncNestDataModule);
-
-  // Enable CORS
-  app.enableCors({
-    origin: true,
-    credentials: true,
-  });
-
-  // Swagger configuration
-  const config = new DocumentBuilder()
-    .setTitle("Zync Nest Data Module API")
-    .setDescription("API documentation for Zync Nest Data Module")
-    .setVersion("1.0.23")
-    .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 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",
-      "https://cdnjs.cloudflare.com/ajax/libs/swagger-ui/4.15.5/swagger-ui-standalone-preset.js",
-    ],
-    customCssUrl: [
-      "https://cdnjs.cloudflare.com/ajax/libs/swagger-ui/4.15.5/swagger-ui.min.css",
-    ],
-  });
-
-  const port = process.env.app_port || 3000;
-  await app.listen(port);
-
-  console.log(
-    `🚀 Zync Nest Data Module server is running on: http://localhost:${port}`
-  );
-  console.log(
-    `📚 Swagger documentation available at: http://localhost:${port}/api`
-  );
-  console.log(
-    `🔍 Health check available at: http://localhost:${port}/test/health`
-  );
-}
-
-bootstrap().catch((error) => {
-  console.error("Failed to start the application:", error);
-  process.exit(1);
-});

package/libs/src/redis/index.ts

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

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

@@ -1,34 +0,0 @@
-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
-}

package/libs/src/redis/redis.module.ts

@@ -1,30 +0,0 @@
-// src/redis/redis.module.ts
-import { Global, Module } from "@nestjs/common";
-import Redis from "ioredis";
-import { ConfigModule } from "@nestjs/config";
-import { RedisService } from "./redis.service";
-
-@Global()
-@Module({
-  imports: [ConfigModule],
-  providers: [
-    {
-      provide: "REDIS_CLIENT",
-      useFactory: async () => {
-        const client = new Redis({
-          host: process.env.redis_host || "127.0.0.1",
-          port: Number(process.env.redis_port) || 6379,
-          password: process.env.redis_password || undefined,
-          db: Number(process.env.redis_database) || 0
-        });
-
-        client.on("connect", () => console.log("✅ Redis connected"));
-        client.on("error", (err) => console.error("❌ Redis error:", err));
-
-        return client;
-      }
-    },
-  ],
-  exports: ["REDIS_CLIENT", RedisService]
-})
-export class RedisModule { }

package/libs/src/redis/redis.service.ts

@@ -1,137 +0,0 @@
-import { Injectable, Logger } from "@nestjs/common";
-import { RedisPubSub } from "graphql-redis-subscriptions";
-import { EntityData, Client as RedisOmClient, Repository, Schema, SchemaDefinition, Search } from "redis-om";
-import { IPageParams } from "../database/database.scheme";
-
-@Injectable()
-export abstract class RedisService<T extends EntityData> extends RedisPubSub {
-  private readonly logger = new Logger(RedisService.name);
-  public readonly baseKey = `${process.env.redis_prefix || "zync_redis_data"}:`;
-  private redisOmClient: RedisOmClient | null = null;
-
-  constructor() {
-    super({
-      connection: {
-        host: process.env.redis_host || "localhost",
-        port: Number(process.env.redis_port) || 6379,
-        username: process.env.redis_username || undefined,
-        password: process.env.redis_password || undefined,
-        db: Number(process.env.redis_database) || 0
-      }
-    });
-  }
-
-  public abstract cacheKey: string;
-
-  protected abstract buildQuery(search: Search, query: any): Search;
-
-  protected abstract mapSchema(): Record<string, any>;
-
-  protected async repository(): Promise<Repository<T>> {
-    const schema = this.createSchema(this.cacheKey, this.mapSchema());
-    const repository = await this.getRepository(schema);
-    try {
-      await repository.createIndex();
-    } catch (error) {
-      this.logger.error(`Error creating index for ${this.cacheKey}: ${error}`);
-    }
-    return repository;
-  }
-
-  private createSchema<M extends EntityData>(name: string, fields: Record<string, any>): Schema<M> {
-    return new Schema<M>(`${this.baseKey}${name}`, fields as SchemaDefinition<M>, {
-      dataStructure: "JSON",
-      indexName: `${this.baseKey}${name}:idx`
-    });
-  }
-
-  private async getRedisOmClient(): Promise<RedisOmClient> {
-    if (this.redisOmClient) return this.redisOmClient;
-
-    const host = process.env.redis_host || "127.0.0.1";
-    const port = Number(process.env.redis_port) || 6379;
-    const password = process.env.redis_password;
-    const db = Number(process.env.redis_database) || 0;
-
-    const authSegment = password ? `:${password}@` : "";
-    const url = `redis://${authSegment}${host}:${port}/${db}`;
-
-    const client = new RedisOmClient();
-    await client.open(url);
-    this.redisOmClient = client;
-    return client;
-  }
-
-  public async getRepository(schema: Schema<any>): Promise<Repository<any>> {
-    return (await this.getRedisOmClient()).fetchRepository(schema);
-  }
-
-
-  public async create(data: Partial<T> | T): Promise<T> {
-    const repository = await this.repository();
-    const _id = (data as any)._id as string;
-    const existing = _id ? await this.findById(_id) : null;
-    if (existing) {
-      return await this.update(_id, data);
-    }
-    return await repository.save(JSON.parse(JSON.stringify(data)));
-  }
-
-  public async update(_id: string, data: Partial<T> | T): Promise<T> {
-    const repository = await this.repository();
-    const entityId = await this.getEntityId(_id);
-
-    // Fetch the entity with its internal metadata (including entityId)
-    const entity = await repository.fetch(entityId);
-
-    // Update the entity properties
-    Object.assign(entity, JSON.parse(JSON.stringify(data)));
-
-    return await repository.save(entity);
-  }
-
-  public async delete(id: string): Promise<boolean> {
-    const repository = await this.repository();
-    await repository.remove(await this.getEntityId(id));
-    return true;
-  }
-
-  public async findById(_id: string): Promise<T> {
-    const repository = await this.repository();
-    return await repository
-      .search()
-      .where("_id" as any)
-      .eq(_id)
-      .return.first();
-  }
-
-
-  public async getEntityId(_id: string): Promise<string> {
-    const repository = await this.repository();
-    return await repository
-      .search()
-      .where("_id" as any)
-      .eq(_id)
-      .return.firstId();
-  }
-
-  public async findOne(query: Partial<T>): Promise<T> {
-    const repository = await this.repository();
-    const search = this.buildQuery(repository.search(), query);
-    return (await search.return.first()) as T;
-  }
-
-  public async find(query: Partial<T>): Promise<T[]> {
-    const repository = await this.repository();
-    const search = this.buildQuery(repository.search(), query);
-    return (await search.return.all()) as T[];
-  }
-
-  public async page(query: Partial<T> & IPageParams): Promise<{ totalRecords: number; data: Array<Partial<T>> }> {
-    const repository = await this.repository();
-    const search = this.buildQuery(repository.search(), query);
-    const totalRecords = await search.return.count();
-    const data = (await search.return.page(query.skip, query.take)) as T[];
-    return { totalRecords, data };
-  }
-}

package/libs/src/service/index.ts

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