feat(pos): merchants services (#3528)

* merchant service

* jest setup

* tests

Author: lengyel-arpad85

packages/point-of-sale/jest.setup.ts

@@ -0,0 +1,74 @@
+import { knex } from 'knex'
+import { GenericContainer, Wait } from 'testcontainers'
+require('./jest.env') // set environment variables
+
+const POSTGRES_PORT = 5432
+
+const setup = async (globalConfig): Promise<void> => {
+  const workers = globalConfig.maxWorkers
+
+  const setupDatabase = async () => {
+    if (!process.env.DATABASE_URL) {
+      const postgresContainer = await new GenericContainer('postgres:15')
+        .withExposedPorts(POSTGRES_PORT)
+        .withBindMounts([
+          {
+            source: __dirname + '/scripts/init.sh',
+            target: '/docker-entrypoint-initdb.d/init.sh'
+          }
+        ])
+        .withEnvironment({
+          POSTGRES_PASSWORD: 'password'
+        })
+        .withHealthCheck({
+          test: ['CMD-SHELL', 'pg_isready -d testing'],
+          interval: 10000,
+          timeout: 5000,
+          retries: 5
+        })
+        .withWaitStrategy(Wait.forHealthCheck())
+        .start()
+
+      process.env.DATABASE_URL = `postgresql://postgres:password@localhost:${postgresContainer.getMappedPort(
+        POSTGRES_PORT
+      )}/testing`
+
+      global.__POS_POSTGRES__ = postgresContainer
+    }
+
+    const db = knex({
+      client: 'postgresql',
+      connection: process.env.DATABASE_URL,
+      pool: {
+        min: 2,
+        max: 10
+      },
+      migrations: {
+        tableName: 'pos_knex_migrations'
+      }
+    })
+
+    // node pg defaults to returning bigint as string. This ensures it parses to bigint
+    db.client.driver.types.setTypeParser(
+      db.client.driver.types.builtins.INT8,
+      'text',
+      BigInt
+    )
+    await db.migrate.latest({
+      directory: __dirname + '/migrations'
+    })
+
+    for (let i = 1; i <= workers; i++) {
+      const workerDatabaseName = `testing_${i}`
+
+      await db.raw(`DROP DATABASE IF EXISTS ${workerDatabaseName}`)
+      await db.raw(`CREATE DATABASE ${workerDatabaseName} TEMPLATE testing`)
+    }
+
+    global.__POS_KNEX__ = db
+  }
+
+  await Promise.all([setupDatabase()])
+}
+
+export default setup

packages/point-of-sale/jest.teardown.js

@@ -0,0 +1,10 @@
+module.exports = async () => {
+  await global.__POS_KNEX__.migrate.rollback(
+    { directory: __dirname + '/migrations' },
+    true
+  )
+  await global.__POS_KNEX__.destroy()
+  if (global.__POS_POSTGRES__) {
+    await global.__POS_POSTGRES__.stop()
+  }
+}

packages/point-of-sale/scripts/init.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+set -e
+
+psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" <<-EOSQL
+    DROP DATABASE IF EXISTS TESTING;
+    CREATE DATABASE testing;
+    CREATE DATABASE development;
+EOSQL

packages/point-of-sale/src/merchant/service.test.ts

@@ -0,0 +1,65 @@
+import { IocContract } from '@adonisjs/fold'
+
+import { Merchant } from './model'
+import { MerchantService } from './service'
+
+import { createTestApp, TestContainer } from '../tests/app'
+import { truncateTables } from '../tests/tableManager'
+import { Config } from '../config/app'
+
+import { initIocContainer } from '../'
+import { AppServices } from '../app'
+
+describe('Merchant Service', (): void => {
+  let deps: IocContract<AppServices>
+  let appContainer: TestContainer
+  let merchantService: MerchantService
+
+  beforeAll(async (): Promise<void> => {
+    deps = initIocContainer({
+      ...Config
+    })
+
+    appContainer = await createTestApp(deps)
+    merchantService = await deps.use('merchantService')
+  })
+
+  afterEach(async (): Promise<void> => {
+    jest.useRealTimers()
+    await truncateTables(deps)
+  })
+
+  afterAll(async (): Promise<void> => {
+    await appContainer.shutdown()
+  })
+
+  describe('create', (): void => {
+    test('creates a merchant', async (): Promise<void> => {
+      const merchant = await merchantService.create('Test merchant')
+      expect(merchant).toEqual({ id: merchant.id, name: 'Test merchant' })
+    })
+  })
+
+  describe('delete', (): void => {
+    test('soft deletes an existing merchant', async (): Promise<void> => {
+      const created = await merchantService.create('Test merchant')
+
+      const result = await merchantService.delete(created.id)
+      expect(result).toBe(true)
+
+      const deletedMerchant = await Merchant.query()
+        .findById(created.id)
+        .whereNotNull('deletedAt')
+      expect(deletedMerchant).toBeDefined()
+      expect(deletedMerchant?.deletedAt).toBeDefined()
+    })
+
+    test('returns false for already deleted merchant', async (): Promise<void> => {
+      const created = await merchantService.create('Test merchant')
+
+      await merchantService.delete(created.id)
+      const secondDelete = await merchantService.delete(created.id)
+      expect(secondDelete).toBe(false)
+    })
+  })
+})

packages/point-of-sale/src/merchant/service.ts

@@ -0,0 +1,48 @@
+import { BaseService } from '../shared/baseService'
+import { TransactionOrKnex } from 'objection'
+import { Merchant } from './model'
+
+export interface MerchantService {
+  create(name: string): Promise<Merchant>
+  delete(id: string): Promise<boolean>
+}
+
+interface ServiceDependencies extends BaseService {
+  knex: TransactionOrKnex
+}
+
+export async function createMerchantService({
+  logger,
+  knex
+}: ServiceDependencies): Promise<MerchantService> {
+  const log = logger.child({
+    service: 'MerchantService'
+  })
+  const deps: ServiceDependencies = {
+    logger: log,
+    knex
+  }
+
+  return {
+    create: (input: string) => createMerchant(deps, input),
+    delete: (id: string) => deleteMerchant(deps, id)
+  }
+}
+
+async function createMerchant(
+  deps: ServiceDependencies,
+  name: string
+): Promise<Merchant> {
+  return await Merchant.query(deps.knex).insert({ name })
+}
+
+async function deleteMerchant(
+  deps: ServiceDependencies,
+  id: string
+): Promise<boolean> {
+  const deleted = await Merchant.query(deps.knex)
+    .patch({ deletedAt: new Date() })
+    .whereNull('deletedAt')
+    .where('id', id)
+  return deleted > 0
+}

packages/point-of-sale/src/tests/tableManager.ts

@@ -0,0 +1,45 @@
+import { IocContract } from '@adonisjs/fold'
+import { Knex } from 'knex'
+import { AppServices } from '../app'
+
+export async function truncateTable(
+  knex: Knex,
+  tableName: string
+): Promise<void> {
+  const RAW = `TRUNCATE TABLE "${tableName}" RESTART IDENTITY`
+  await knex.raw(RAW)
+}
+
+export async function truncateTables(
+  deps: IocContract<AppServices>
+): Promise<void> {
+  const knex = await deps.use('knex')
+  const config = await deps.use('config')
+  const dbSchema = config.dbSchema ?? 'public'
+
+  const ignoreTables = [
+    'knex_migrations',
+    'knex_migrations_lock',
+    'pos_knex_migrations',
+    'pos_knex_migrations_lock'
+  ]
+  const tables = await getTables(knex, dbSchema, ignoreTables)
+  const RAW = `TRUNCATE TABLE "${tables}" RESTART IDENTITY`
+  await knex.raw(RAW)
+}
+
+async function getTables(
+  knex: Knex,
+  dbSchema: string = 'public',
+  ignoredTables: string[]
+): Promise<string> {
+  const result = await knex.raw(
+    `SELECT tablename FROM pg_catalog.pg_tables WHERE schemaname='${dbSchema}'`
+  )
+  return result.rows
+    .map((val: { tablename: string }) => {
+      if (!ignoredTables.includes(val.tablename)) return val.tablename
+    })
+    .filter(Boolean)
+    .join('","')
+}