@point-hub/papi 0.1.5 → 0.1.6

package/src/database/mongodb/connection.ts

@@ -0,0 +1,339 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type {
+  AggregateOptions,
+  BulkWriteOptions,
+  ClientSession,
+  Collection,
+  CollectionOptions,
+  CreateIndexesOptions,
+  Db,
+  DbOptions,
+  DeleteOptions,
+  FindOptions,
+  IndexSpecification,
+  InsertOneOptions,
+  MongoClientOptions,
+  UpdateOptions,
+} from 'mongodb'
+import { MongoClient, ObjectId } from 'mongodb'
+
+import { MongoDBHelper } from './mongodb-helper'
+import Querystring from './mongodb-querystring'
+
+export class MongoDBConnection implements IDatabase {
+  public client: MongoClient
+  public _database: Db | undefined
+  public _collection: Collection | undefined
+  public session: ClientSession | undefined
+
+  constructor(
+    connectionString: string,
+    public databaseName: string,
+  ) {
+    const options: MongoClientOptions = {}
+
+    this.client = new MongoClient(connectionString, options)
+    this.database(databaseName)
+  }
+
+  public async open() {
+    await this.client.connect()
+  }
+
+  public async close() {
+    await this.client.close()
+  }
+
+  public database(name: string, options?: DbOptions) {
+    this._database = this.client.db(name, options)
+    return this
+  }
+
+  public collection(name: string, options?: CollectionOptions) {
+    if (!this._database) {
+      throw new Error('Database not found')
+    }
+
+    this._collection = this._database.collection(name, options)
+    return this
+  }
+
+  public async listCollections(): Promise<{ name: string }[]> {
+    if (!this._database) {
+      throw new Error('Database not found')
+    }
+
+    return await this._database.listCollections().toArray()
+  }
+
+  public async createIndex(name: string, spec: IndexSpecification, options: CreateIndexesOptions): Promise<void> {
+    if (!this._database) {
+      throw new Error('Database not found')
+    }
+
+    await this._database.createIndex(name, spec, options)
+  }
+
+  public async updateSchema(name: string, schema: unknown): Promise<void> {
+    if (!this._database) {
+      throw new Error('Database not found')
+    }
+
+    await this._database.command({
+      collMod: name,
+      validator: {
+        $jsonSchema: schema,
+      },
+    })
+  }
+
+  public async createCollection(name: string, options: any): Promise<void> {
+    if (!this._database) {
+      throw new Error('Database not found')
+    }
+
+    await this._database.createCollection(name, options)
+  }
+
+  public async dropCollection(name: string, options: any): Promise<void> {
+    if (!this._database) {
+      throw new Error('Database not found')
+    }
+
+    await this._database.dropCollection(name, options)
+  }
+
+  public startSession() {
+    this.session = this.client.startSession()
+    return this.session
+  }
+
+  public async endSession() {
+    await this.session?.endSession()
+  }
+
+  public startTransaction() {
+    this.session?.startTransaction()
+  }
+
+  public async commitTransaction() {
+    await this.session?.commitTransaction()
+  }
+
+  public async abortTransaction() {
+    await this.session?.abortTransaction()
+  }
+
+  public async create(document: IDocument, options?: unknown): Promise<ICreateOutput> {
+    if (!this._collection) {
+      throw new Error('Collection not found')
+    }
+
+    const createOptions = options as InsertOneOptions
+
+    const response = await this._collection.insertOne(document, createOptions)
+
+    return {
+      insertedId: response.insertedId.toString(),
+    }
+  }
+
+  public async createMany(documents: IDocument[], options?: unknown): Promise<ICreateManyOutput> {
+    if (!this._collection) {
+      throw new Error('Collection not found')
+    }
+
+    const createManyOptions = options as BulkWriteOptions
+
+    const response = await this._collection.insertMany(documents, createManyOptions)
+
+    // convert array of object to array of string
+    const insertedIds: string[] = []
+    Object.values(response.insertedIds).forEach((val) => {
+      insertedIds.push(val.toString())
+    })
+
+    return {
+      insertedIds: insertedIds,
+      insertedCount: response.insertedCount,
+    }
+  }
+
+  public async retrieveAll(query: IQuery, options?: any): Promise<IRetrieveAllOutput> {
+    if (!this._collection) {
+      throw new Error('Collection not found')
+    }
+
+    const retrieveOptions = options as FindOptions
+
+    const cursor = this._collection
+      .find(MongoDBHelper.stringToObjectId(query.filter ?? {}), retrieveOptions)
+      .limit(Querystring.limit(query.pageSize))
+      .skip(Querystring.skip(Querystring.page(query.page), Querystring.limit(query.pageSize)))
+
+    if (query.sort && Querystring.sort(query.sort)) {
+      cursor.sort(Querystring.sort(query.sort))
+    }
+
+    if (Querystring.fields(query.fields, query.excludeFields)) {
+      cursor.project(Querystring.fields(query.fields, query.excludeFields))
+    }
+    const result = await cursor.toArray()
+
+    const totalDocument = await this._collection.countDocuments(query.filter ?? {}, retrieveOptions)
+
+    return {
+      data: MongoDBHelper.objectIdToString(result) as unknown[] as IRetrieveOutput[],
+      pagination: {
+        page: Querystring.page(query.page),
+        pageCount: Math.ceil(totalDocument / Querystring.limit(query.pageSize)),
+        pageSize: Querystring.limit(query.pageSize),
+        totalDocument,
+      },
+    }
+  }
+
+  public async retrieve(_id: string, options?: any): Promise<IRetrieveOutput> {
+    if (!this._collection) {
+      throw new Error('Collection not found')
+    }
+
+    const retrieveOptions = options as FindOptions
+
+    const result = await this._collection.findOne(
+      {
+        _id: new ObjectId(_id),
+      },
+      retrieveOptions,
+    )
+
+    return MongoDBHelper.objectIdToString(result)
+  }
+
+  public async update(_id: string, document: IDocument, options?: any): Promise<IUpdateOutput> {
+    if (!this._collection) {
+      throw new Error('Collection not found')
+    }
+
+    const updateOptions = options as UpdateOptions
+
+    const result = await this._collection.updateOne(
+      { _id: new ObjectId(_id) },
+      { $set: MongoDBHelper.stringToObjectId(document) },
+      updateOptions,
+    )
+
+    return {
+      modifiedCount: result.modifiedCount,
+      matchedCount: result.matchedCount,
+    }
+  }
+
+  public async updateMany(filter: IDocument[], document: IDocument[], options?: any): Promise<IUpdateManyOutput> {
+    if (!this._collection) {
+      throw new Error('Collection not found')
+    }
+
+    const updateManyOptions = options as UpdateOptions
+
+    const result = await this._collection.updateMany(
+      filter,
+      { $set: MongoDBHelper.stringToObjectId(document) },
+      updateManyOptions,
+    )
+
+    return {
+      matchedCount: result.matchedCount,
+      modifiedCount: result.modifiedCount,
+    }
+  }
+
+  public async delete(_id: string, options?: any): Promise<IDeleteOutput> {
+    if (!this._collection) {
+      throw new Error('Collection not found')
+    }
+
+    const deleteOptions = options as DeleteOptions
+
+    const result = await this._collection.deleteOne(
+      {
+        _id: new ObjectId(_id),
+      },
+      deleteOptions,
+    )
+
+    return { deletedCount: result.deletedCount }
+  }
+
+  public async deleteMany(_ids: string[], options?: any): Promise<IDeleteManyOutput> {
+    if (!this._collection) {
+      throw new Error('Collection not found')
+    }
+
+    const deleteOptions = options as DeleteOptions
+
+    const result = await this._collection.deleteMany(
+      {
+        _id: {
+          $in: MongoDBHelper.stringToObjectId(_ids),
+        },
+      },
+      deleteOptions,
+    )
+
+    return { deletedCount: result.deletedCount }
+  }
+
+  public async deleteAll(options?: any): Promise<IDeleteManyOutput> {
+    if (!this._collection) {
+      throw new Error('Collection not found')
+    }
+
+    const deleteOptions = options as DeleteOptions
+
+    const result = await this._collection.deleteMany({}, deleteOptions)
+
+    return { deletedCount: result.deletedCount }
+  }
+
+  public async aggregate(pipeline: IPipeline[], query: IQuery, options?: any): Promise<IAggregateOutput> {
+    if (!this._collection) {
+      throw new Error('Collection not found')
+    }
+
+    const aggregateOptions = options as AggregateOptions
+
+    const cursor = this._collection.aggregate(
+      [
+        ...pipeline,
+        { $skip: (Querystring.page(query.page) - 1) * Querystring.limit(query.pageSize) },
+        { $limit: Querystring.limit(query.pageSize) },
+      ],
+      aggregateOptions,
+    )
+
+    if (query.sort && Querystring.sort(query.sort)) {
+      cursor.sort(Querystring.sort(query.sort))
+    }
+
+    if (Querystring.fields(query.fields, query.excludeFields)) {
+      cursor.project(Querystring.fields(query.fields, query.excludeFields))
+    }
+
+    const result = await cursor.toArray()
+
+    const cursorPagination = this._collection.aggregate([...pipeline, { $count: 'totalDocument' }], aggregateOptions)
+    const resultPagination = await cursorPagination.toArray()
+
+    const totalDocument = resultPagination.length ? resultPagination[0].totalDocument : 0
+    return {
+      data: MongoDBHelper.objectIdToString(result) as IRetrieveOutput[],
+      pagination: {
+        page: Querystring.page(query.page),
+        pageCount: Math.ceil(totalDocument / Querystring.limit(query.pageSize)),
+        pageSize: Querystring.limit(query.pageSize),
+        totalDocument,
+      },
+    }
+  }
+}

package/src/database/mongodb/mongodb-error-handler.ts

@@ -0,0 +1,63 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { BaseError, find, type IError, type IHttpStatus } from '@point-hub/express-error-handler'
+import { MongoServerError } from 'mongodb'
+
+export function handleSchemaValidation(err: MongoServerError, error: IError) {
+  // handle schema validation error
+  error.errors = {} as any
+  const errorMessage = err.errInfo?.details.schemaRulesNotSatisfied[0].propertiesNotSatisfied
+  errorMessage.forEach((element: any) => {
+    const obj: any = {}
+    obj[element.propertyName] = [element.details[0].reason]
+    error.errors = obj
+  })
+}
+
+export function handleUniqueValidation(err: MongoServerError, error: IError) {
+  // handle unique validation
+  if (Object.keys(err.keyPattern).length === 1) {
+    error.errors = {
+      [Object.keys(err.keyPattern)[0]]: [`The ${Object.keys(err.keyPattern)[0]} is exists.`],
+    }
+  } else {
+    // get keys
+    const keys = Object.keys(err.keyPattern).reduce((keys: string, key, index) => {
+      if (index === 0) {
+        keys += `'`
+      }
+      keys += `${key.toString()}`
+      if (index === Object.keys(err.keyPattern).length - 1) {
+        keys += `'`
+      } else {
+        keys += `, `
+      }
+      return keys
+    }, '')
+
+    // generate error object
+    const obj = Object.keys(err.keyPattern).reduce((obj: any, key) => {
+      obj[key] = [`The combination of ${keys.toString()} is exists.`]
+      return obj
+    }, {})
+    error.errors = obj
+  }
+}
+
+export class MongoErrorHandler extends BaseError {
+  constructor(err: MongoServerError) {
+    const error: IError = find(400) as IHttpStatus
+    if (err.code === 121) {
+      handleSchemaValidation(err, error)
+    } else if (err.code === 11000) {
+      handleUniqueValidation(err, error)
+    }
+    super(error)
+    Object.setPrototypeOf(this, new.target.prototype)
+  }
+  get isOperational() {
+    return true
+  }
+  override get name() {
+    return 'MongoErrorHandler'
+  }
+}

package/src/database/mongodb/mongodb-helper.ts

@@ -0,0 +1,109 @@
+import { isValid } from 'date-fns'
+import { ObjectId } from 'mongodb'
+
+/**
+ * https://www.mongodb.com/docs/drivers/node/current/fundamentals/indexes/
+ * https://www.mongodb.com/docs/manual/reference/collation/
+ * https://www.mongodb.com/docs/manual/core/index-sparse/
+ * https://www.mongodb.com/docs/manual/core/index-partial/
+ */
+export class MongoDBHelper {
+  private db
+
+  constructor(db: IDatabase) {
+    this.db = db
+  }
+
+  /**
+   * Create unique column
+   *
+   * @example
+   * create unique attribute "name"
+   * createUnique(collection, {
+   *   name: -1,
+   * })
+   *
+   * @example
+   * create unique attribute for multiple column "first_name" and "last_name"
+   * createUnique(collection, {
+   *   firstName: -1,
+   *   lastName: -1,
+   * })
+   */
+  public async createUnique(collection: string, properties: object) {
+    await this.db.createIndex(collection, properties, {
+      unique: true,
+      collation: {
+        locale: 'en',
+        strength: 2,
+      },
+    })
+  }
+
+  /**
+   * Create unique if column is exists
+   */
+  public async createUniqueIfNotNull(collection: string, properties: object) {
+    await this.db.createIndex(collection, properties, {
+      unique: true,
+      sparse: true,
+      collation: {
+        locale: 'en',
+        strength: 2,
+      },
+    })
+  }
+
+  public async isExists(name: string) {
+    const collections = (await this.db.listCollections()) as []
+    return collections.some(function (collection: { name: string }) {
+      return collection.name === name
+    })
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  public static stringToObjectId(val: any): any {
+    if (val == null) return null
+    if (Array.isArray(val)) {
+      return val.map((item) => {
+        return MongoDBHelper.stringToObjectId(item)
+      })
+    } else if (typeof val === 'object' && !isValid(val)) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      return Object.keys(val).reduce((obj: any, key) => {
+        const propVal = MongoDBHelper.stringToObjectId(val[key])
+        obj[key] = propVal
+        return obj
+      }, {})
+    } else if (typeof val === 'string' && ObjectId.isValid(val) && val === new ObjectId(val).toString()) {
+      return new ObjectId(val)
+    }
+
+    return val
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  public static objectIdToString(val: any): any {
+    if (val == null) return null
+    if (Array.isArray(val)) {
+      return val.map((item) => {
+        return MongoDBHelper.objectIdToString(item)
+      })
+    } else if (typeof val === 'object' && ObjectId.isValid(val)) {
+      return val.toString()
+    } else if (typeof val === 'object' && !isValid(val)) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      return Object.keys(val).reduce((obj: any, key) => {
+        if (ObjectId.isValid(val) || isValid(val)) {
+          return val.toString()
+        } else {
+          const propVal = MongoDBHelper.objectIdToString(val[key])
+          obj[key] = propVal
+          return obj
+        }
+      }, {})
+    }
+
+    return val
+  }
+}

package/src/database/mongodb/mongodb-querystring.spec.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it } from 'bun:test'
+
+import {
+  convertArrayToObject,
+  convertStringToArray,
+  fields,
+  filterExludeFields,
+  limit,
+  page,
+  skip,
+  sort,
+} from './mongodb-querystring'
+
+describe('field', () => {
+  it('convert string to array', async () => {
+    expect(convertStringToArray('name, password')).toStrictEqual(['name', 'password'])
+  })
+
+  it('convert array to mongodb field object', async () => {
+    expect(convertArrayToObject(['name', 'password'])).toStrictEqual({
+      name: 1,
+      password: 1,
+    })
+  })
+
+  it('add excluded fields to the object', async () => {
+    const obj = { name: 1, password: 1 }
+    const excluded = ['password']
+    const result = {
+      ...obj,
+      ...filterExludeFields(obj, excluded),
+    }
+    expect(result).toStrictEqual({
+      name: 1,
+      password: 0,
+    })
+  })
+
+  it('filter fields', async () => {
+    const result = fields('', ['password'])
+    expect(result).toStrictEqual({
+      password: 0,
+    })
+  })
+})
+
+describe('page', () => {
+  it('convert page string to number', async () => {
+    expect(page('1')).toStrictEqual(1)
+  })
+  it('default page should be 1', async () => {
+    expect(page()).toStrictEqual(1)
+  })
+})
+
+describe('limit', () => {
+  it('convert limit string to number', async () => {
+    expect(limit('1')).toStrictEqual(1)
+  })
+  it('default limit should be 10', async () => {
+    expect(limit()).toStrictEqual(10)
+  })
+})
+
+describe('skip', () => {
+  it('should skip number of data from page', async () => {
+    expect(skip(1, 10)).toStrictEqual(0)
+    expect(skip(2, 10)).toStrictEqual(10)
+    expect(skip(2, 50)).toStrictEqual(50)
+  })
+})
+
+describe('sort', () => {
+  it('convert string to mongodb sort object', async () => {
+    expect(sort('name,-address')).toStrictEqual({
+      name: 1,
+      address: -1,
+    })
+  })
+})