@point-hub/papi 0.1.6 → 0.1.8

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

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

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

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

@@ -1,143 +0,0 @@
-import { SortDirection } from 'mongodb'
-
-interface IFieldsObject {
-  [key: string]: number
-}
-
-interface ISortObject {
-  [key: string]: SortDirection
-}
-
-/**
- * Parse query string to number
- *
- * @example
- * page("10") // => 10
- * page(10) // => 10
- */
-export function page(page: string | number = 1): number {
-  if (typeof page === 'string') {
-    return parseInt(page)
-  }
-
-  return page
-}
-
-/**
- * Parse query string to number
- *
- * @example
- * limit("10") // => 10
- * limit(10) // => 10
- */
-export function limit(pageSize: string | number = 10): number {
-  if (typeof pageSize === 'string') {
-    return parseInt(pageSize)
-  }
-
-  return pageSize
-}
-
-/**
- * Skip number of data from page
- *
- * @example
- * skip(1, 10) // => 0
- * skip(2, 10) // => 10
- * skip(3, 10) // => 20
- */
-export function skip(currentPage: string | number, pageSize: string | number): number {
-  return (page(currentPage) - 1) * limit(pageSize)
-}
-
-export function filter(filter: never) {
-  return filter
-}
-
-/**
- * Convert string param to mongodb field object
- *
- * @example
- * fields("name, address") // => { name: 1, address: 1 }
- */
-export function fields(fields = '', excludeFields: string[] = []): IFieldsObject {
-  const obj: IFieldsObject = convertArrayToObject(convertStringToArray(fields))
-
-  return filterExludeFields(obj, excludeFields)
-}
-
-/**
- * Convert string to array
- *
- * @example
- * convertStringToArray("name, address") // => ["name", "address"]
- */
-export function convertStringToArray(fields: string): string[] {
-  return fields
-    .split(' ')
-    .join()
-    .split(',')
-    .filter((el) => el)
-}
-
-/**
- * Convert array to mongodb field object
- *
- * @example
- * convertArrayToObject(["name", "address"]) // => { name: 1, address: 1 }
- * convertArrayToObject(["name", "address"], -1) // => { name: -1, address: -1 }
- */
-export function convertArrayToObject(array: string[], value = 1): IFieldsObject {
-  const obj: IFieldsObject = {}
-  for (let i = 0; i < array.length; i++) {
-    obj[`${array[i].trim()}`] = value
-  }
-  return obj
-}
-
-/**
- * Remove excluded fields
- *
- * @example
- * ex: { password: 0 }
- */
-export function filterExludeFields(obj: IFieldsObject, excludeFields: string[]): IFieldsObject {
-  for (let i = 0; i < excludeFields.length; i++) {
-    obj[`${excludeFields[i]}`] = 0
-  }
-  return obj
-}
-
-/**
- * Convert string param to mongodb sort object
- *
- * @example
- * sort("name, -createdAt") // => { name: 1, createdAt: -1 }
- */
-export function sort(fields: string): ISortObject {
-  const obj: ISortObject = {}
-
-  if (fields) {
-    fields.split(',').forEach(function (field) {
-      if (field.charAt(0) === '-') {
-        field = field.substring(1)
-        obj[field.trim()] = -1
-      } else {
-        obj[field.trim()] = 1
-      }
-    })
-  }
-  return obj
-}
-
-export default {
-  page,
-  limit,
-  skip,
-  sort,
-  fields,
-  filter,
-  filterExludeFields,
-  convertStringToArray,
-  convertArrayToObject,
-}

package/src/index.ts

@@ -1,42 +0,0 @@
-import { BaseCommand } from '@point-hub/express-cli'
-import {
-  ApiError,
-  BaseError,
-  errorHandlerMiddleware,
-  find,
-  invalidPathMiddleware,
-  isTrustedError,
-} from '@point-hub/express-error-handler'
-import { MongoServerError } from 'mongodb'
-
-import { ConsoleKernel } from './console'
-import { DatabaseConnection } from './database/connection'
-import { MongoDBConnection } from './database/mongodb/connection'
-import { MongoErrorHandler } from './database/mongodb/mongodb-error-handler'
-import { MongoDBHelper } from './database/mongodb/mongodb-helper'
-import Querystring from './database/mongodb/mongodb-querystring'
-
-export const stubDir = import.meta.path.replace('/index.ts', '/../stub').replace('/index.js', '/../stub')
-
-// Console
-export { ExpressCli as BaseConsoleCli } from '@point-hub/express-cli'
-export const BaseConsoleCommand = BaseCommand
-export const BaseConsoleKernel = ConsoleKernel
-// Database
-export const BaseDatabaseConnection = DatabaseConnection
-export const BaseMongoDBConnection = MongoDBConnection
-export const BaseMongoDBHelper = MongoDBHelper
-export const BaseMongoDBQuerystring = Querystring
-export const BaseMongoServerError = MongoServerError
-export const BaseMongoErrorHandler = MongoErrorHandler
-// Error Handler
-export const BaseErrorHandler = {
-  ApiError,
-  BaseError,
-  isTrustedError,
-  getHttpError: find,
-  errorHandlerMiddleware,
-  invalidPathMiddleware,
-}
-// Server
-export { Server as BaseServer } from './server'

package/src/server.spec.ts

@@ -1,68 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-
-import { createApp } from './app'
-import { BaseServer as Server } from './index'
-
-const port = 3001
-
-describe('server', () => {
-  it('server should start on http://localhost:port', async () => {
-    const server = new Server(await createApp())
-
-    await server.start(port)
-
-    expect(server.host).toEqual('localhost')
-    expect(server.port).toEqual(port)
-    expect(server.url).toEqual(`http://localhost:${port}`)
-
-    server.stop()
-  })
-
-  it('get.url should not print out port if port = 80', async () => {
-    const server = new Server(await createApp())
-
-    await server.start(80)
-
-    expect(server.url).toEqual(`http://localhost`)
-
-    server.stop()
-  })
-
-  it('get.host return original ip', async () => {
-    const server = new Server(await createApp())
-    await server.start(port, '127.0.0.1')
-    expect(server.host).toEqual('127.0.0.1')
-    server.stop()
-  })
-
-  it('get.host return localhost', async () => {
-    const server = new Server(await createApp())
-    await server.start(port)
-    expect(server.host).toEqual('localhost')
-    server.stop()
-  })
-
-  it('not listening server should return undefined', async () => {
-    const server = new Server(await createApp())
-    server.stop()
-    expect(server.host).toBeUndefined()
-    expect(server.port).toBeUndefined()
-    expect(server.url).toEqual('http://undefined:undefined')
-  })
-
-  it('using port that already in use return error', async () => {
-    const server1 = new Server(await createApp())
-    const server2 = new Server(await createApp())
-
-    try {
-      await server1.start(port)
-
-      // start another server using same port to invoke error
-      await server2.start(port)
-    } catch (error) {
-      expect(error).toBeDefined()
-      server1.stop()
-      server2.stop()
-    }
-  })
-})

package/src/server.ts

@@ -1,49 +0,0 @@
-import { Express } from 'express'
-import { Server as HttpServer } from 'http'
-import { AddressInfo } from 'net'
-
-export class Server {
-  app: Express
-  server: HttpServer | null = null
-
-  constructor(app: Express) {
-    this.app = app
-  }
-
-  listen(port: number, hostname?: string) {
-    return new Promise((resolve, reject) => {
-      if (hostname) {
-        this.server = this.app.listen(port, hostname).once('listening', resolve).once('error', reject)
-      } else {
-        this.server = this.app.listen(port).once('listening', resolve).once('error', reject)
-      }
-    })
-  }
-
-  async start(port: number, hostname?: string) {
-    await this.listen(port, hostname)
-  }
-
-  stop() {
-    this.server?.close()
-    this.server = null
-  }
-
-  get host() {
-    const address = this.server?.address() as AddressInfo
-    if (address?.address === '0.0.0.0' || address?.address === '::') {
-      return 'localhost'
-    } else {
-      return address?.address
-    }
-  }
-
-  get port() {
-    const address = this.server?.address() as AddressInfo
-    return address?.port
-  }
-
-  get url() {
-    return `http://${this.host}${this.port !== 80 ? `:${this.port}` : ''}`
-  }
-}

package/src/types/controller.d.ts

@@ -1,18 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-interface IHttpRequest {
-  [key: string]: any
-}
-
-interface IControllerInput {
-  httpRequest: IHttpRequest
-  dbConnection: IDatabase
-}
-
-interface IController {
-  (input: IControllerInput): Promise<IControllerOutput>
-}
-
-interface IControllerOutput {
-  status: number
-  json?: any
-}

package/src/types/database.d.ts

@@ -1,104 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-interface IDocument {
-  [key: string]: any
-}
-
-interface IQuery {
-  fields?: string
-  excludeFields?: string[]
-  filter?: { [key: string]: unknown }
-  page?: number
-  pageSize?: number
-  sort?: string
-}
-
-interface IPipeline {
-  [key: string]: any
-}
-
-interface ICreateOutput {
-  insertedId: string
-}
-
-interface ICreateManyOutput {
-  insertedCount: number
-  insertedIds: string[]
-}
-
-interface IRetrieveOutput {
-  _id: string
-  [key: string]: unknown
-}
-
-interface IRetrieveAllOutput {
-  data: IRetrieveOutput[]
-  pagination: {
-    page: number
-    pageCount: number
-    pageSize: number
-    totalDocument: number
-  }
-}
-
-interface IUpdateOutput {
-  matchedCount: number
-  modifiedCount: number
-}
-
-interface IUpdateManyOutput {
-  matchedCount: number
-  modifiedCount: number
-}
-
-interface IDeleteOutput {
-  deletedCount: number
-}
-
-interface IDeleteManyOutput {
-  deletedCount: number
-}
-
-interface IAggregateOutput {
-  data: IRetrieveOutput[]
-  pagination: {
-    page: number
-    pageCount: number
-    pageSize: number
-    totalDocument: number
-  }
-}
-
-interface IClientSession {
-  startTransaction(options?: unknown): void
-  commitTransaction(): Promise<void>
-  abortTransaction(): Promise<void>
-  endSession(): Promise<void>
-}
-
-interface IDatabase {
-  session: unknown
-  open(): Promise<void>
-  close(): Promise<void>
-  database(name: string, options?: unknown): this
-  collection(name: string, options?: unknown): this
-  listCollections(): Promise<{ name: string }[]>
-  startSession(): IClientSession
-  endSession(): Promise<void>
-  startTransaction(): void
-  commitTransaction(): Promise<void>
-  abortTransaction(): Promise<void>
-  createIndex(name: string, spec: unknown, options?: unknown): Promise<void>
-  createCollection(name: string, options?: unknown): Promise<void>
-  dropCollection(name: string, options?: unknown): Promise<void>
-  updateSchema(name: string, schema: unknown): Promise<void>
-  create(document: IDocument, options?: unknown): Promise<ICreateOutput>
-  createMany(documents: IDocument[], options?: unknown): Promise<ICreateManyOutput>
-  retrieveAll(query: IQuery, options?: unknown): Promise<IRetrieveAllOutput>
-  retrieve(_id: string, options?: unknown): Promise<IRetrieveOutput>
-  update(_id: string, document: IDocument, options?: unknown): Promise<IUpdateOutput>
-  updateMany(filter: IDocument, document: IDocument, options?: unknown): Promise<IUpdateManyOutput>
-  delete(_id: string, options?: unknown): Promise<IDeleteOutput>
-  deleteMany(_ids: string[], options?: unknown): Promise<IDeleteManyOutput>
-  deleteAll(options?: unknown): Promise<IDeleteManyOutput>
-  aggregate(pipeline: IPipeline, query: IQuery, options?: unknown): Promise<IAggregateOutput>
-}

package/src/types/use-case.d.ts

@@ -1,3 +0,0 @@
-interface IUseCase<TInput, TDeps, TOptions, TOutput> {
-  handle(input: TInput, deps: TDeps, options?: TOptions): Promise<TOutput>
-}