@point-hub/papi 0.1.6 → 0.1.8

package/src/console/commands/make-middleware/index.command.ts

@@ -1,86 +0,0 @@
-import { BaseCommand, Color } from '@point-hub/express-cli'
-import { kebabCase, pascalCase } from '@point-hub/express-utils'
-import fs from 'fs'
-import path from 'path'
-
-import { stubDir } from '../../../index'
-
-export default class MakeMiddleware extends BaseCommand {
-  constructor() {
-    super({
-      name: 'make:middleware',
-      description: 'Make a new middleware',
-      summary: 'Make a new middleware',
-      arguments: [
-        {
-          name: 'name',
-          description: 'Name of middleware',
-        },
-      ],
-      options: [
-        {
-          type: 'boolean',
-          flag: '--configurable',
-          shorthand: '-c',
-          description: 'Export a function which accepts an options',
-        },
-      ],
-    })
-  }
-
-  async handle(): Promise<void> {
-    // Check if middleware directory is already exists
-    if (fs.existsSync(`${process.cwd()}/src/middleware/${kebabCase(this.args.name)}`)) {
-      console.error(Color.red('Middleware directory is exists'))
-      return
-    }
-
-    // Create middleware directory
-    fs.mkdirSync(`${process.cwd()}/src/middleware/${kebabCase(this.args.name)}`, { recursive: true })
-
-    // Copy middleware
-    if (this.opts['--configurable']) {
-      this.copyConfigureableMiddleware()
-    } else {
-      this.copyMiddleware()
-    }
-  }
-
-  private copyMiddleware() {
-    // Copy middleware file
-    const stubMiddleware = fs
-      .readFileSync(path.resolve(stubDir, './middleware/new.middleware.ts'))
-      .toString()
-      .replace('NewMiddleware', `${pascalCase(this.args.name)}Middleware`)
-    fs.writeFileSync(`${process.cwd()}/src/middleware/${kebabCase(this.args.name)}/index.middleware.ts`, stubMiddleware)
-
-    // Copy test file
-    const stubTest = fs
-      .readFileSync(path.resolve(stubDir, './middleware/new.spec.ts'))
-      .toString()
-      .replace('new.middleware.ts', `index.middleware.ts`)
-    fs.writeFileSync(`${process.cwd()}/src/middleware/${kebabCase(this.args.name)}/index.spec.ts`, stubTest)
-
-    console.info(`src/middleware/${kebabCase(this.args.name)}/index.middleware.ts`, 'has been created')
-    console.info(`src/middleware/${kebabCase(this.args.name)}/index.spec.ts`, 'has been created')
-  }
-
-  private copyConfigureableMiddleware() {
-    // Copy middleware file
-    const stubMiddleware = fs
-      .readFileSync(path.resolve(stubDir, './middleware/configurable.middleware.ts'))
-      .toString()
-      .replace('NewMiddleware', `${pascalCase(this.args.name)}Middleware`)
-    fs.writeFileSync(`${process.cwd()}/src/middleware/${kebabCase(this.args.name)}/index.middleware.ts`, stubMiddleware)
-
-    // Copy test file
-    const stubTest = fs
-      .readFileSync(path.resolve(stubDir, './middleware/configurable.spec.ts'))
-      .toString()
-      .replace('configurable.middleware.ts', `index.middleware.ts`)
-    fs.writeFileSync(`${process.cwd()}/src/middleware/${kebabCase(this.args.name)}/index.spec.ts`, stubTest)
-
-    console.info(`src/middleware/${kebabCase(this.args.name)}/index.middleware.ts`, 'has been created')
-    console.info(`src/middleware/${kebabCase(this.args.name)}/index.spec.ts`, 'has been created')
-  }
-}

package/src/console/commands/make-middleware/index.spec.ts

@@ -1,73 +0,0 @@
-import { Color } from '@point-hub/express-cli'
-import { beforeAll, describe, expect, it, spyOn } from 'bun:test'
-import crypto from 'crypto'
-import fs from 'fs'
-import shell from 'shelljs'
-
-import MakeMiddlewareCommand from './index.command'
-
-const dir = 'src/middleware'
-
-function generateRandomName() {
-  let exists = true
-  let name = 'test'
-  while (exists) {
-    name = `test-${crypto.randomBytes(4).toString('hex')}`
-    exists = fs.existsSync(`${dir}/${name}`)
-  }
-  return name
-}
-
-describe('make:middleware', () => {
-  beforeAll(() => {
-    spyOn(console, 'error').mockImplementation(() => '')
-    spyOn(console, 'info').mockImplementation(() => '')
-  })
-  it('should create new middleware', async () => {
-    const makeMiddlewareCommand = new MakeMiddlewareCommand()
-    makeMiddlewareCommand.args = {
-      name: generateRandomName(),
-    }
-    const spy = spyOn(makeMiddlewareCommand, 'handle')
-    await makeMiddlewareCommand.handle()
-
-    shell.rm('-rf', `${dir}/${makeMiddlewareCommand.args.name}`)
-
-    expect(spy).toHaveBeenCalled()
-  })
-
-  it('should create new configureable middleware', async () => {
-    const makeMiddlewareCommand = new MakeMiddlewareCommand()
-    makeMiddlewareCommand.args = {
-      name: generateRandomName(),
-    }
-    makeMiddlewareCommand.opts = {
-      '--configurable': true,
-    }
-    const spy = spyOn(makeMiddlewareCommand, 'handle')
-    await makeMiddlewareCommand.handle()
-
-    shell.rm('-rf', `${dir}/${makeMiddlewareCommand.args.name}`)
-
-    expect(spy).toHaveBeenCalled()
-  })
-
-  it("should return error 'middleware directory exists'", async () => {
-    const makeMiddlewareCommand = new MakeMiddlewareCommand()
-    makeMiddlewareCommand.args = {
-      name: generateRandomName(),
-    }
-    const spy = spyOn(makeMiddlewareCommand, 'handle')
-
-    // first attempt it will create new middleware
-    await makeMiddlewareCommand.handle()
-    // second attempt it should return error because middleware directory exists
-    await makeMiddlewareCommand.handle()
-
-    shell.rm('-rf', `${dir}/${makeMiddlewareCommand.args.name}`)
-
-    expect(console.error).toHaveBeenCalled()
-    expect(console.error).toHaveBeenCalledWith(Color.red('Middleware directory is exists'))
-    expect(spy).toHaveBeenCalled()
-  })
-})

package/src/console/index.spec.ts

@@ -1,14 +0,0 @@
-import { ExpressCli } from '@point-hub/express-cli'
-import { expect, it } from 'bun:test'
-
-import { ConsoleKernel } from './index'
-
-it('express cli to be defined', async () => {
-  const cli = new ExpressCli('cli', '1.0.0')
-
-  const kernel = new ConsoleKernel(cli)
-  await kernel.register()
-
-  expect(cli).toBeDefined()
-  expect(cli).toBeInstanceOf(ExpressCli)
-})

package/src/console/index.ts

@@ -1,23 +0,0 @@
-import { ExpressCli } from '@point-hub/express-cli'
-
-import MakeCommand from './commands/make-command/index.command'
-import MakeMiddleware from './commands/make-middleware/index.command'
-
-export class ConsoleKernel {
-  private command: ExpressCli
-
-  constructor(command: ExpressCli) {
-    this.command = command
-  }
-
-  /**
-   * Register the commands for the application.
-   *
-   * @example
-   * this.command.register(new ExampleCommand());
-   */
-  async register() {
-    this.command.register(new MakeCommand())
-    this.command.register(new MakeMiddleware())
-  }
-}

package/src/database/connection.ts

@@ -1,78 +0,0 @@
-export class DatabaseConnection implements IDatabase {
-  session: unknown
-  constructor(public adapter: IDatabase) {}
-  public async open(): Promise<void> {
-    await this.adapter.open()
-  }
-  public async close(): Promise<void> {
-    await this.adapter.close()
-  }
-  public database(name: string): this {
-    this.adapter.database(name)
-    return this
-  }
-  public collection(name: string): this {
-    this.adapter.collection(name)
-    return this
-  }
-  public async listCollections(): Promise<{ name: string }[]> {
-    return this.adapter.listCollections()
-  }
-  public startSession() {
-    return this.adapter.startSession()
-  }
-  public async endSession() {
-    await this.adapter.endSession()
-  }
-  public startTransaction() {
-    this.adapter.startTransaction()
-  }
-  public async commitTransaction() {
-    await this.adapter.commitTransaction()
-  }
-  public async abortTransaction() {
-    await this.adapter.abortTransaction()
-  }
-  public async createIndex(name: string, spec: unknown, options?: unknown) {
-    await this.adapter.createIndex(name, spec, options)
-  }
-  public async createCollection(name: string, options?: unknown) {
-    await this.adapter.createCollection(name, options)
-  }
-  public async dropCollection(name: string, options?: unknown) {
-    await this.adapter.dropCollection(name, options)
-  }
-  public async updateSchema(name: string, schema: unknown) {
-    await this.adapter.updateSchema(name, schema)
-  }
-  public async create(document: IDocument, options?: unknown): Promise<ICreateOutput> {
-    return await this.adapter.create(document, options)
-  }
-  public async createMany(documents: IDocument[], options?: unknown): Promise<ICreateManyOutput> {
-    return await this.adapter.createMany(documents, options)
-  }
-  public async retrieveAll(query: IQuery, options?: unknown): Promise<IRetrieveAllOutput> {
-    return await this.adapter.retrieveAll(query, options)
-  }
-  public async retrieve(_id: string, options?: unknown): Promise<IRetrieveOutput> {
-    return await this.adapter.retrieve(_id, options)
-  }
-  public async update(_id: string, document: IDocument, options?: unknown): Promise<IUpdateOutput> {
-    return await this.adapter.update(_id, document, options)
-  }
-  public async updateMany(filter: IDocument, document: IDocument, options?: unknown): Promise<IUpdateManyOutput> {
-    return await this.adapter.updateMany(filter, document, options)
-  }
-  public async delete(_id: string, options?: unknown): Promise<IDeleteOutput> {
-    return await this.adapter.delete(_id, options)
-  }
-  public async deleteMany(_ids: string[], options?: unknown): Promise<IDeleteManyOutput> {
-    return await this.adapter.deleteMany(_ids, options)
-  }
-  public async deleteAll(options?: unknown): Promise<IDeleteManyOutput> {
-    return await this.adapter.deleteAll(options)
-  }
-  public async aggregate(pipeline: IPipeline[], query: IQuery, options?: unknown): Promise<IAggregateOutput> {
-    return await this.adapter.aggregate(pipeline, query, options)
-  }
-}

package/src/database/mongodb/connection.ts

@@ -1,339 +0,0 @@
-/* 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

@@ -1,63 +0,0 @@
-/* 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'
-  }
-}