@point-hub/papi 0.1.5 → 0.1.6

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

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

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

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

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

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

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

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