DEV Community: Kazi Abdur Rakib

Linux keyboard shortcuts for shutting down (or rebooting) system immediately

Kazi Abdur Rakib — Fri, 22 Dec 2023 11:34:33 +0000

Alt + PrtSc + O == Shutdown the system immediately

Custom QueryBuilder in Typescript ( MERN Stack)

Kazi Abdur Rakib — Tue, 19 Dec 2023 15:00:54 +0000

Unlocking the Power of QueryBuilder:

//=> src/app/modules/student/student.service.ts
const getAllDataFromDB = async (query: Record<string, any>) => {
  const studentQuery = new QueryBuilder(
    Student.find()
      .populate('admissionSemester')
      .populate({
        path: 'academicDepartment',
        populate: {
          path: 'academicFaculty',
        },
      }),
    query,
  )
    .search(studentSearchableFields)
    .filter()
    .sort()
    .paginate()
    .fields();

  const result = await studentQuery.modelQuery;
  return result;
}

//==>src/app/builder/QueryBuilder.ts
import { FilterQuery, Query } from 'mongoose';

class QueryBuilder<T> {
  public modelQuery: Query<T[], T>;
  public query: Record<string, unknown>;

  constructor(modelQuery: Query<T[], T>, query: Record<string, unknown>) {
    this.modelQuery = modelQuery;
    this.query = query;
  }

  search(searchableFields: string[]) {
    const searchTerm = this?.query?.searchTerm;
    if (searchTerm) {
      this.modelQuery = this.modelQuery.find({
        $or: searchableFields.map(
          (field) =>
            ({
              [field]: { $regex: searchTerm, $options: 'i' },
            }) as FilterQuery<T>,
        ),
      });
    }

    return this;
  }

  filter() {
    const queryObj = { ...this.query }; // copy

    // Filtering
    const excludeFields = ['searchTerm', 'sort', 'limit', 'page', 'fields'];

    excludeFields.forEach((el) => delete queryObj[el]);

    this.modelQuery = this.modelQuery.find(queryObj as FilterQuery<T>);

    return this;
  }

  sort() {
    const sort =
      (this?.query?.sort as string)?.split(',')?.join(' ') || '-createdAt';
    this.modelQuery = this.modelQuery.sort(sort as string);

    return this;
  }

  paginate() {
    const page = Number(this?.query?.page) || 1;
    const limit = Number(this?.query?.limit) || 10;
    const skip = (page - 1) * limit;

    this.modelQuery = this.modelQuery.skip(skip).limit(limit);

    return this;
  }

  fields() {
    const fields =
      (this?.query?.fields as string)?.split(',')?.join(' ') || '-__v';

    this.modelQuery = this.modelQuery.select(fields);
    return this;
  }
}

export default QueryBuilder;

Raw Searching: Efficient MongoDB Search in Node.js: Using Dynamic Queries

Kazi Abdur Rakib — Mon, 18 Dec 2023 20:24:26 +0000

// query = req.body
let searchTerm = '';
  if (query?.searchTerm) {
    searchTerm = query?.searchTerm;
  }

  const result = await Student.find({
    $or: ['email', 'name.firstName', 'presentAddress'].map((field) => ({
      [field]: { $regex: searchTerm, $options: 'i' },
    })),
  })

AppError UnhandledRejection _ UncaughtException

Kazi Abdur Rakib — Mon, 18 Dec 2023 19:21:59 +0000

///src/app.ts
const test = async (req: Request, res: Response) => {
  Promise.reject();
  // res.send('Hello PH UNIVERSTIY');
};

//src/server.ts
process.on('unhandledRejection', () => {
  console.log(`😈 unahandledRejection is detected , shutting down ...`);
  if (server) {
    server.close(() => {
      process.exit(1);
    });
  }
  process.exit(1);
});

process.on('uncaughtException', () => {
  console.log(`😈 uncaughtException is detected , shutting down ...`);
  process.exit(1);
});

handleZodError create

Kazi Abdur Rakib — Mon, 18 Dec 2023 15:20:12 +0000

//=> src/app/errors/handleZodError.ts
import { ZodError, ZodIssue } from 'zod';
import { TErrorSources } from '../interface/error';

const handleZodError = (err: ZodError) => {
  const errorSources: TErrorSources = err.issues.map((issue: ZodIssue) => {
    return {
      path: issue?.path[issue.path.length - 1],
      message: issue.message,
    };
  });

  const statusCode = 400;

  return {
    statusCode,
    message: 'Validation Error',
    errorSources,
  };
};

export default handleZodError;

//=> src/app/middlewares/globalErrorhandeler.ts
export const globalErrorHandeler: ErrorRequestHandler = (
  err,
  req,
  res,
  next,
) => {
  let statusCode = err.statusCode || 500;
  let message = err.message || 'Something went wrong';

  let errorSources: TErrorSources = [
    {
      path: '',
      message: 'something went wrong',
    },
  ];

  if (err instanceof ZodError) {
    const simpliedError = handleZodError(err);
    statusCode = simpliedError?.statusCode;
    message = simpliedError?.message;
    errorSources = simpliedError?.errorSources;
  }

  return res.status(statusCode).json({
    success: false,
    message,
    errorSources,
    stack: config.NODE_ENV === 'development' ? err?.stack : null,
  });
};

import mongoose from 'mongoose';
import { TErrorSources } from '../interface/error';

const handleValidationError = (err: mongoose.Error.ValidationError) => {
  const errorSources: TErrorSources = Object.values(err.errors).map(
    (val: mongoose.Error.ValidatorError | mongoose.Error.CastError) => {
      return {
        path: val?.path,
        message: val?.message,
      };
    },
  );

  const statusCode = 400;

  return {
    statusCode,
    message: 'Validation Error',
    errorSources,
  };
};
export default handleValidationError;

AppError middleware function create

Kazi Abdur Rakib — Sat, 16 Dec 2023 19:40:02 +0000


//==> src/app/errors/AppError.ts
class AppError extends Error {
  public statusCode: number;

  constructor(statusCode: number, message: string, stack = '') {
    super(message);
    this.statusCode = statusCode;

    if (stack) {
      this.stack = stack;
    } else {
      Error.captureStackTrace(this, this.constructor);
    }
  }
}

export default AppError;

//=> src/app/modules/academicDepartment/academicDepartment.model.ts

  if (!isDepartmentExist) {
    throw new AppError(
      httpStatus.NOT_FOUND,
      'This department does not exist! ',
    );
  }

Implement transaction & rollback

Kazi Abdur Rakib — Sat, 16 Dec 2023 19:33:21 +0000

const session = await mongoose.startSession();
try {
  session.startTransaction();
  const newUser = await User.create([userData], { session }); // array
  await session.commitTransaction();
  await session.endSession();
} catch (err: any) {
  await session.abortTransaction();
  await session.endSession();
  throw new AppError(httpStatus.NOT_FOUND, err);
}

pull the changes up to a specific commit and delete all commits made after it

Kazi Abdur Rakib — Sat, 16 Dec 2023 12:56:32 +0000

To pull the changes up to a specific commit and delete all commits made after it, you can follow these steps:

Identify the commit hash:
- Use git log to find the commit hash of the commit you want to revert to.
- Let's assume the commit hash is CODE OF SHA.
Reset your local branch:
- Use the following commands to reset your local branch to the specified commit:
```
 git reset --hard (CODE OF SHA)
```
Force-push to the remote repository:
- If you've already pushed the commits you want to delete, you'll need to force-push the changes to the remote repository:
```
 git push origin main --force
```
Be cautious with --force as it overwrites the remote branch with your local branch.

After completing these steps, your local and remote repositories should be rolled back to the state of the specified commit (30c87bb1797c6ac8f4afde9e0004d723f21fe8d5), and all commits made after that will be deleted.

Keep in mind that force-pushing can cause issues if others are collaborating on the same branch. Use it with caution, especially on shared branches. If others are working on the same branch, communicate with them about the force-push to avoid conflicts.

If you face any issues or have further questions, feel free to ask!

populate referencing fields

Kazi Abdur Rakib — Sat, 16 Dec 2023 06:33:12 +0000

//=> student.service.ts
const getAllStudentsFromBD = async () => {
  const result = await Student.find()
    .populate('admissionSemester')
    .populate({
      path: 'academicDepartment',
      populate: {
        path: 'academicFaculty',
      },
    });
  return result;
};

here i got the admissionSemester id then I input semester id inside populate, then I get full details of this admissionSemester id.

//=>src/app/modules/academicDepartment/academicDepartment.model.ts
const academicDepartmentSchema = new Schema<TAcademicDepartment>(
  {
    name: {
      type: String,
      required: true,
      unique: true,
    },
    academicFaculty: {
      type: Schema.Types.ObjectId,
      ref: 'AcademicFaculty',
    },
  },
  {
    timestamps: true,
  },
);

ref: 'AcademicFaculty',
.populate('modelname')

AppError=> Develop an AppError class in TypeScript for a MERN application utilizing Mongoose for MongoDB integration.

Kazi Abdur Rakib — Sat, 16 Dec 2023 06:19:06 +0000

//src/app/errors/AppError.ts

class AppError extends Error {
  public statusCode: number;

  constructor(statusCode: number, message: string, stack = '') {
    super(message);
    this.statusCode = statusCode;

    if (stack) {
      this.stack = stack;
    } else {
      Error.captureStackTrace(this, this.constructor);
    }
  }
}

export default AppError;

where i am using this AppError function

//src/app/modules/academicDepartment/academicDepartment.model.ts

academicDepartmentSchema.pre('save', async function (next) {
  const isDepartmentExist = await AcademicDepartment.findOne({
    name: this.name,
  });

  if (isDepartmentExist) {
    throw new AppError(
      httpStatus.NOT_FOUND,
      'This department is already exist!',
    );
  }

  next();
});

academicDepartmentSchema.pre('findOneAndUpdate', async function (next) {
  const query = this.getQuery();
  const isDepartmentExist = await AcademicDepartment.findOne(query);

  if (!isDepartmentExist) {
    throw new AppError(
      httpStatus.NOT_FOUND,
      'This department does not exist! ',
    );
  }

  next();
});

sendResponse dynamic function create

Kazi Abdur Rakib — Wed, 13 Dec 2023 04:50:40 +0000

//==>src/app/utils/sendResponse.ts

import { Response } from 'express';

type TResponse<T> = {
  statusCode: number;
  success: boolean;
  message?: string;
  data: T;
};

const sendResponse = <T>(res: Response, data: TResponse<T>) => {
  res.status(data?.statusCode).json({
    success: data.success,
    message: data.message,
    data: data.data,
  });
};

export default sendResponse;

catchAsync dynamic function create

Kazi Abdur Rakib — Wed, 13 Dec 2023 04:49:49 +0000

// catchAsync

//==>src/app/utils/catchAsync.ts

import { NextFunction, Request, RequestHandler, Response } from 'express';

const catchAsync = (asyncFn: RequestHandler) => {
  return (req: Request, res: Response, next: NextFunction) => {
    Promise.resolve(asyncFn(req, res, next)).catch((err) => next(err));
  };
};

export default catchAsync;