zync-nest-data-module 1.0.0

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

@@ -0,0 +1,59 @@
+import { Injectable } from "@nestjs/common";
+import { InjectModel, Prop, Schema, SchemaFactory } from "@nestjs/mongoose";
+import { Document, Types } from "mongoose";
+import { SoftDeleteModel } from "mongoose-delete";
+
+@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 {
+  constructor(
+    @InjectModel(UniqueId.name)
+    private model: SoftDeleteModel<UniqueIdDocument>
+  ) {
+    this.seed();
+  }
+
+  public async getNextUniqueId(key: string = "uniqueId"): Promise<number> {
+    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> {
+    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

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

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

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

package/libs/src/main.ts

@@ -0,0 +1,62 @@
+import { NestFactory } from "@nestjs/core";
+import { SwaggerModule, DocumentBuilder } from "@nestjs/swagger";
+import { ValidationPipe } from "@nestjs/common";
+import { ApDbModule } from "./app.module";
+
+async function bootstrap() {
+  const app = await NestFactory.create(ApDbModule);
+
+  // Enable CORS
+  app.enableCors({
+    origin: true,
+    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")
+    .setVersion("1.0.23")
+    .addTag("Database", "Database endpoints for Zync Nest Database")
+    .build();
+
+  const document = SwaggerModule.createDocument(app, config);
+  SwaggerModule.setup("api", app, document, {
+    customSiteTitle: "Zync Nest Database 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 Database 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/service/index.ts

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

package/libs/src/service/service.ts

@@ -0,0 +1,201 @@
+import { forwardRef, Inject } from "@nestjs/common";
+import { AbstractBaseRepository, IPageParams, TransactionManager, TransactionSession } from "../database";
+
+class BaseService<T> {
+  constructor(
+    @Inject(forwardRef(() => AbstractBaseRepository))
+    protected readonly repository: AbstractBaseRepository<any>
+  ) {}
+
+  public async create(data: Partial<T> | T): Promise<T> {
+    return await this.repository.create(data);
+  }
+
+  public async update(_id: string, data: Partial<T> | T): Promise<T> {
+    return await this.repository.update(_id, data);
+  }
+
+  public async updateMany(query: Partial<T>, model: Partial<T>): Promise<void> {
+    return await this.repository.updateMany(query, model);
+  }
+
+  public async findById(_id: string): Promise<T> {
+    return await this.repository.findById(_id);
+  }
+
+  public async findOne(query: Partial<T>): Promise<T> {
+    return await this.repository.findOne(query);
+  }
+
+  public async find(query: Partial<T>): Promise<T[]> {
+    return await this.repository.find(query);
+  }
+
+  public async findLast(query?: Partial<T>): Promise<T> {
+    return await this.repository.findLast(query);
+  }
+
+  public async delete(_id: string): Promise<Boolean> {
+    await this.repository.delete(_id);
+    return true;
+  }
+
+  public async deleteMany(query: Partial<T>): Promise<Boolean> {
+    await this.repository.deleteMany(query);
+    return true;
+  }
+
+  public async page(
+    query: Partial<T> & IPageParams
+  ): Promise<{ totalRecords: number; data: Array<T> }> {
+    return await this.repository.page(query);
+  }
+
+  public async count(query: Partial<T>): Promise<number> {
+    return this.repository.count(query);
+  }
+}
+
+export abstract class AbstractBaseService<T> extends BaseService<T> {
+  private _session: TransactionSession;
+  constructor(
+    @Inject(forwardRef(() => AbstractBaseRepository))
+    protected readonly repository: AbstractBaseRepository<any>,
+    @Inject(forwardRef(() => TransactionManager))
+    public readonly transactionManager: TransactionManager
+  ) {
+    super(repository);
+  }
+
+  protected abstract setSession(session: any): void;
+
+  public get session(): TransactionSession {
+    return this._session;
+  }
+
+  public set session(v: TransactionSession) {
+    this._session = v;
+    this.repository.session = this._session;
+  }
+
+  public get sessionName(): string {
+    return this.transactionManager.sessionName;
+  }
+
+  public async withRetryTransaction(
+    sessionName: string,
+    operations: () => Promise<T>,
+    retries: number = 3
+  ): Promise<T> {
+    if (!process.env.mongodb_transaction_enabled) {
+      return await operations();
+    }
+
+    try {
+      await this.startSession(sessionName);
+
+      let attempt = 0;
+      while (attempt < retries) {
+        try {
+          const op = await operations();
+          await this.commitSession(sessionName);
+          return op;
+        } catch (error) {
+          if (this.isRetryableError(error)) {
+            console.log(`[TransactionManager] Retrying transaction...`);
+            await this.delay(1000 * (attempt + 1)); // Exponential backoff
+            await this.transactionManager.abortTransaction();
+            await this.startSession(sessionName, true);
+          } else {
+            await this.abortSession();
+            throw error;
+          }
+        }
+        attempt++;
+      }
+    } catch (error) {
+      console.log(`[TransactionManager] Error in transaction`, error);
+      await this.abortSession();
+      throw error;
+    } finally {
+      console.log(`[TransactionManager] Finally block`);
+      if (this.transactionManager.sessionName == sessionName) {
+        await this.endSession();
+      }
+    }
+  }
+
+  private isRetryableError(error: any): boolean {
+    return (
+      error.code === 112 // WriteConflict
+    );
+  }
+
+  private delay(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  protected async startSession(sessionName: string, force: boolean = false) {
+    if (this.transactionManager.sessionName && !force) {
+      this.session = this._session;
+      this.repository.session = this._session;
+      console.log(
+        `[TransactionManager] startSession ${this.transactionManager.sessionName} - ${sessionName} is already active`
+      );
+      return;
+    }
+
+    console.log(`[TransactionManager] startSession  ${sessionName} is started`);
+
+    this._session = await this.transactionManager.startTransaction();
+    this.repository.session = this._session;
+    this.transactionManager.sessionName = sessionName;
+    this.setSession(this._session);
+  }
+
+  protected async commitSession(sessionName: string) {
+    if (this.transactionManager.sessionName !== sessionName) {
+      console.log(
+        `[TransactionManager] Session ${this.transactionManager.sessionName} - ${sessionName} is not active`
+      );
+      return;
+    }
+
+    await this.transactionManager.commitTransaction();
+    this._session = null;
+    this.repository.session = null;
+    this.transactionManager.sessionName = undefined;
+    this.setSession(null);
+  }
+
+  public async abortSession() {
+    await this.transactionManager.abortTransaction();
+    this._session = null;
+    this.repository.session = null;
+    this.transactionManager.sessionName = undefined;
+    this.setSession(null);
+  }
+
+  public async endSession() {
+    await this.transactionManager.endTransaction();
+    this._session = null;
+    this.repository.session = null;
+    this.transactionManager.sessionName = undefined;
+    this.setSession(null);
+  }
+
+  protected getObjectId(): string | any {
+    return this.repository.getObjectId();
+  }
+
+  protected toObjectId(value: string | any): any {
+    return this.repository.toObjectId(value);
+  }
+
+  public async checkExist(id: any): Promise<void> {
+    const exist = await this.repository.findOne(id);
+    if (!exist) {
+      throw new Error("Record does not exist");
+    }
+  }
+}

package/libs/src/test/test.dto.ts

@@ -0,0 +1,41 @@
+import { Field, InputType, ObjectType, PartialType } from "@nestjs/graphql";
+
+@ObjectType()
+export class Test {
+  @Field({ nullable: true })
+  name: string;
+}
+
+@InputType()
+export class TestCommonInput {
+  @Field({ nullable: true })
+  name: string;
+}
+
+@InputType()
+export class CreateTestInput extends TestCommonInput {}
+
+@InputType()
+export class UpdateTestInput extends PartialType(TestCommonInput) {}
+
+@InputType()
+export class TestQueryInput {
+  @Field({ nullable: true })
+  keyword: string;
+}
+
+@ObjectType()
+export class TestPageResult {
+  @Field({})
+  totalRecords: number;
+  @Field((type) => [Test])
+  data: Array<Test>;
+}
+
+@InputType()
+export class TestPageInput extends TestQueryInput {
+  @Field({})
+  skip: number;
+  @Field({})
+  take: number;
+}

package/libs/src/test/test.module.ts

@@ -0,0 +1,20 @@
+import { forwardRef, Module } from "@nestjs/common";
+import { MongooseModule } from "@nestjs/mongoose";
+import { TestRepository } from "./test.repository";
+import { TestResolver } from "./test.resolver";
+import { Test, TestSchema } from "./test.schema";
+import { TestService } from "./test.service";
+
+const TestMongooseModule = MongooseModule.forFeature([
+  {
+    name: Test.name,
+    schema: TestSchema,
+  },
+]);
+
+@Module({
+  imports: [TestMongooseModule],
+  providers: [TestRepository, TestService, TestResolver],
+  exports: [TestService],
+})
+export class TestModule {}

package/libs/src/test/test.repository.ts

@@ -0,0 +1,44 @@
+import { Injectable } from "@nestjs/common";
+import { InjectModel } from "@nestjs/mongoose";
+import moment from "moment";
+import { SoftDeleteModel } from "mongoose-delete";
+import { AbstractBaseRepository } from "../database/database.repository";
+import { Test, TestDocument, TestSchema } from "./test.schema";
+
+@Injectable()
+export class TestRepository extends AbstractBaseRepository<TestDocument> {
+  constructor(
+    @InjectModel(Test.name)
+    public dbModel: SoftDeleteModel<TestDocument>
+  ) {
+    super(dbModel);
+  }
+
+  public async mapData(data: any, isCreate: boolean): Promise<TestDocument> {
+    const payload: any = data;
+
+    if (isCreate) {
+      payload.ref = payload.ref || (await this.generateRef());
+      payload.createdBy = payload.createdBy;
+      payload.createdAt = payload.createdAt
+        ? moment(payload.createdAt).valueOf()
+        : moment().valueOf();
+    } else {
+      payload.updatedBy = payload.updatedBy;
+      payload.updatedAt = payload.updatedAt
+        ? moment(payload.updatedAt).valueOf()
+        : moment().valueOf();
+    }
+    return this.mapIds(payload);
+  }
+
+  protected buildQuery(query: Partial<TestDocument>) {
+    const andConditions: any[] = [];
+
+    this.schemaKeysQuery(TestSchema, { query }, (condition: any) => {
+      andConditions.push(condition);
+    });
+
+    return this.cleanupQuery(andConditions);
+  }
+}

package/libs/src/test/test.resolver.ts

@@ -0,0 +1,44 @@
+import { Args, Mutation, Query, Resolver } from "@nestjs/graphql";
+import {
+  CreateTestInput,
+  Test,
+  TestPageInput,
+  TestPageResult,
+  TestQueryInput,
+  UpdateTestInput,
+} from "./test.dto";
+import { TestService } from "./test.service";
+
+@Resolver(() => Test)
+export class TestResolver {
+  constructor(private readonly testSvc: TestService) {}
+
+  @Mutation((returns) => Test, { name: "createTest" })
+  public async create(@Args("test") testSvc: CreateTestInput) {
+    return this.testSvc.create(testSvc as any);
+  }
+
+  @Mutation((returns) => Test, { name: "updateTest" })
+  public async update(
+    @Args("_id") id: string,
+    @Args("test") test: UpdateTestInput
+  ) {
+    return this.testSvc.update(id, { ...test } as any);
+  }
+
+  @Mutation((returns) => Boolean, { name: "deleteTest" })
+  public async delete(@Args("_id") id: string) {
+    await this.testSvc.delete(id);
+    return true;
+  }
+
+  @Query((returns) => Test, { name: "findOneTest" })
+  public async findOne(@Args("test") test: TestQueryInput) {
+    return this.testSvc.findOne(test as any);
+  }
+
+  @Query((returns) => TestPageResult, { name: "testPage" })
+  public async page(@Args("page") page: TestPageInput) {
+    return this.testSvc.page({ ...page } as any);
+  }
+}

package/libs/src/test/test.schema.ts

@@ -0,0 +1,21 @@
+import { Prop, Schema, SchemaFactory } from "@nestjs/mongoose";
+import { Document } from "mongoose";
+import { BaseSchema, IPageParams } from "../database/database.scheme";
+export type TestDocument = Test & Document;
+
+@Schema({ collection: "tests" })
+export class Test extends BaseSchema {
+  @Prop({ required: true })
+  name: string;
+}
+
+export const TestSchema = SchemaFactory.createForClass(Test);
+
+export class TestQuery extends Test {
+  keyword?: string;
+}
+
+export class PageParams extends TestQuery implements IPageParams {
+  skip: number;
+  take: number;
+}

package/libs/src/test/test.service.ts

@@ -0,0 +1,19 @@
+import { forwardRef, Inject, Injectable } from "@nestjs/common";
+import { TestRepository } from "./test.repository";
+import { Test } from "./test.schema";
+import { TransactionManager } from "../database";
+import { AbstractBaseService } from "../service/service";
+
+@Injectable()
+export class TestService extends AbstractBaseService<Test> {
+  constructor(
+    @Inject(forwardRef(() => TestRepository))
+    private readonly testRepo: TestRepository,
+    @Inject(forwardRef(() => TransactionManager))
+    transactionManager: TransactionManager
+  ) {
+    super(testRepo, transactionManager);
+  }
+
+  protected setSession(session: any): void {}
+}

package/libs/tsconfig.lib.json

@@ -0,0 +1,19 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "declaration": true,
+    "outDir": "../dist"
+  },
+  "include": [
+    "src/database/**/*",
+    "src/backup/**/*",
+    "src/service/**/*",
+    "src/index.ts",
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "test",
+    "**/*spec.ts",
+  ]
+}

package/nest-cli.json

@@ -0,0 +1,16 @@
+{
+  "projects": {
+    ".": {
+      "type": "library",
+      "root": "libs",
+      "entryFile": "index",
+      "sourceRoot": "libs/src",
+      "compilerOptions": {
+        "tsConfigPath": "libs/tsconfig.lib.json"
+      }
+    }
+  },
+  "compilerOptions": {
+    "webpack": true
+  }
+}