@point-hub/papi 0.1.5 → 0.1.6

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@point-hub/papi",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Point API Framework",
   "type": "module",
-  "main": "lib/index.ts",
+  "main": "src/index.ts",
   "types": "lib/index.d.ts",
   "files": [
     "lib/",
-    "stub/"
+    "stub/",
+    "src/"
   ],
   "scripts": {
     "check-types": "tsc -p tsconfig.json",

package/src/app.spec.ts

@@ -0,0 +1,8 @@
+import { expect, it } from 'bun:test'
+
+import { createApp } from './app'
+
+it('express app to be defined', async () => {
+  const app = await createApp()
+  expect(app).toBeDefined()
+})

package/src/app.ts

@@ -0,0 +1,13 @@
+import express, { Express, Request, Response } from 'express'
+
+export async function createApp() {
+  const app: Express = express()
+
+  app.get('/', (req: Request, res: Response) => {
+    res.status(200).json({
+      message: 'Papi',
+    })
+  })
+
+  return app
+}

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

@@ -0,0 +1,52 @@
+import { BaseCommand, Color } from '@point-hub/express-cli'
+import { camelCase, kebabCase, pascalCase } from '@point-hub/express-utils'
+import fs from 'fs'
+import path from 'path'
+
+import { stubDir } from '../../../index'
+
+export default class MakeCommand extends BaseCommand {
+  constructor() {
+    super({
+      name: 'make:command',
+      description: 'Make a new console command',
+      summary: 'Make a new console command',
+      arguments: [
+        {
+          name: 'name',
+          description: 'Name of console command',
+        },
+      ],
+      options: [],
+    })
+  }
+  async handle(): Promise<void> {
+    // Check if command directory is already exists
+    if (fs.existsSync(`${process.cwd()}/src/console/commands/${kebabCase(this.args.name)}`)) {
+      console.error(Color.red('Command directory is exists'))
+      return
+    }
+
+    // Create directory
+    fs.mkdirSync(`${process.cwd()}/src/console/commands/${kebabCase(this.args.name)}`, { recursive: true })
+
+    // Copy command file
+    const stubCommand = fs
+      .readFileSync(path.resolve(stubDir, './command/index.command.ts'))
+      .toString()
+      .replace('[name]', kebabCase(this.args.name))
+      .replace('NewCommand', `${pascalCase(this.args.name)}Command`)
+    fs.writeFileSync(`${process.cwd()}/src/console/commands/${kebabCase(this.args.name)}/index.command.ts`, stubCommand)
+
+    // Copy test file
+    const stubTest = fs
+      .readFileSync(path.resolve(stubDir, './command/index.spec.ts'))
+      .toString()
+      .replace(/NewCommand/g, `${pascalCase(this.args.name)}Command`)
+      .replace(/newCommand/g, `${camelCase(this.args.name)}Command`)
+    fs.writeFileSync(`${process.cwd()}/src/console/commands/${kebabCase(this.args.name)}/index.spec.ts`, stubTest)
+
+    console.info(`src/console/commands/${kebabCase(this.args.name)}/index.command.ts`, 'has been created')
+    console.info(`src/console/commands/${kebabCase(this.args.name)}/index.spec.ts`, 'has been created')
+  }
+}

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

@@ -0,0 +1,58 @@
+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 MakeCommand from './index.command'
+
+const dir = 'src/console/commands'
+
+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:command', () => {
+  beforeAll(() => {
+    spyOn(console, 'error').mockImplementation(() => '')
+    spyOn(console, 'info').mockImplementation(() => '')
+  })
+
+  it('should create new command', async () => {
+    const makeCommand = new MakeCommand()
+    makeCommand.args = {
+      name: generateRandomName(),
+    }
+    const spy = spyOn(makeCommand, 'handle')
+    await makeCommand.handle()
+
+    shell.rm('-rf', `${dir}/${makeCommand.args.name}`)
+
+    expect(spy).toHaveBeenCalled()
+  })
+
+  it("should return error 'command directory exists'", async () => {
+    const makeCommand = new MakeCommand()
+    makeCommand.args = {
+      name: generateRandomName(),
+    }
+    const spy = spyOn(makeCommand, 'handle')
+
+    // first attempt it will create new command
+    await makeCommand.handle()
+    // second attempt it should return error because command directory exists
+    await makeCommand.handle()
+
+    shell.rm('-rf', `${dir}/${makeCommand.args.name}`)
+
+    expect(console.error).toHaveBeenCalled()
+    expect(console.error).toHaveBeenCalledWith(Color.red('Command directory is exists'))
+    expect(spy).toHaveBeenCalled()
+  })
+})

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

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

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

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

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

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