@mbc-cqrs-serverless/cli 0.1.4-beta.0

package/templates/src/master/master.controller.ts

@@ -0,0 +1,83 @@
+import {
+  CommandService,
+  DataService,
+  DetailDto,
+  IInvoke,
+  INVOKE_CONTEXT,
+  SearchDto,
+} from '@mbc-cqrs-sererless/core'
+import {
+  Body,
+  Controller,
+  Get,
+  Logger,
+  NotFoundException,
+  Param,
+  Post,
+  Query,
+} from '@nestjs/common'
+import { ApiTags } from '@nestjs/swagger'
+
+import { MasterCommandDto } from './dto/master-command.dto'
+import { MasterCommandEntity } from './entity/master-command.entity'
+import { MasterDataEntity } from './entity/master-data.entity'
+import { MasterDataListEntity } from './entity/master-data-list.entity'
+import { MasterService } from './master.service'
+
+@Controller('api/master')
+@ApiTags('master')
+export class MasterController {
+  private readonly logger = new Logger(MasterController.name)
+
+  constructor(
+    private readonly commandService: CommandService,
+    private readonly dataService: DataService,
+    private readonly masterService: MasterService,
+  ) {}
+
+  @Post('/')
+  async publishCommand(
+    @INVOKE_CONTEXT() invokeContext: IInvoke,
+    @Body() masterDto: MasterCommandDto,
+  ): Promise<MasterDataEntity> {
+    this.logger.debug('cmd:', masterDto)
+    this.logger.debug('commandService:' + this.commandService.tableName)
+    const item = await this.commandService.publish(masterDto, { invokeContext })
+    return new MasterDataEntity(item as MasterDataEntity)
+  }
+
+  @Get('command/:pk/:sk')
+  async getCommand(
+    @Param() detailDto: DetailDto,
+  ): Promise<MasterCommandEntity> {
+    this.logger.debug('commandService:' + this.commandService.tableName)
+    const item = await this.commandService.getItem(detailDto)
+    if (!item) {
+      throw new NotFoundException()
+    }
+    this.logger.debug('item:', item)
+    return new MasterCommandEntity(item as MasterCommandEntity)
+  }
+
+  @Get('data/:pk/:sk')
+  async getData(@Param() detailDto: DetailDto): Promise<MasterDataEntity> {
+    this.logger.debug('dataService:' + this.dataService.tableName)
+    const item = await this.dataService.getItem(detailDto)
+    if (!item) {
+      throw new NotFoundException()
+    }
+    this.logger.debug('item:', item)
+    return new MasterDataEntity(item as MasterDataEntity)
+  }
+
+  @Get('data/:pk')
+  async listDataByPk(@Param('pk') pk: string): Promise<MasterDataListEntity> {
+    const res = await this.dataService.listItemsByPk(pk)
+    return new MasterDataListEntity(res as MasterDataListEntity)
+  }
+
+  @Get('data')
+  async searchData(@Query() searchDto: SearchDto) {
+    return await this.masterService.searchData(searchDto)
+  }
+}

package/templates/src/master/master.module.ts

@@ -0,0 +1,19 @@
+import { CommandModule } from '@mbc-cqrs-sererless/core'
+import { Module } from '@nestjs/common'
+
+import { MasterDataSyncRdsHandler } from './handler/master-rds.handler'
+import { MasterController } from './master.controller'
+import { MasterService } from './master.service'
+
+@Module({
+  imports: [
+    CommandModule.register({
+      tableName: 'master',
+      dataSyncHandlers: [MasterDataSyncRdsHandler],
+    }),
+  ],
+  controllers: [MasterController],
+  providers: [MasterService],
+  exports: [MasterService],
+})
+export class MasterModule {}

package/templates/src/master/master.service.ts

@@ -0,0 +1,58 @@
+import { SearchDto } from '@mbc-cqrs-sererless/core'
+import { Injectable, Logger } from '@nestjs/common'
+import { Prisma } from '@prisma/client'
+import { getOrderBys } from 'src/helpers'
+import { PrismaService } from 'src/prisma'
+
+import { MasterDataEntity } from './entity/master-data.entity'
+import { MasterDataListEntity } from './entity/master-data-list.entity'
+
+@Injectable()
+export class MasterService {
+  private readonly logger = new Logger(MasterService.name)
+
+  constructor(private readonly prismaService: PrismaService) {}
+
+  async searchData(searchDto: SearchDto): Promise<MasterDataListEntity> {
+    const where: Prisma.MasterWhereInput = {
+      isDeleted: false,
+    }
+    if (searchDto.keyword?.trim()) {
+      where.name = { contains: searchDto.keyword.trim() }
+    }
+    if (searchDto.id) {
+      where.id = searchDto.id
+    }
+    if (searchDto.pk) {
+      where.pk = searchDto.pk
+    }
+    if (searchDto.sk) {
+      where.sk = searchDto.sk
+    }
+
+    const { pageSize = 10, page = 1, orderBys = ['-createdAt'] } = searchDto
+
+    const [total, items] = await Promise.all([
+      this.prismaService.master.count({ where }),
+      this.prismaService.master.findMany({
+        where,
+        take: pageSize,
+        skip: pageSize * (page - 1),
+        orderBy: getOrderBys<Prisma.MasterOrderByWithRelationInput>(orderBys),
+      }),
+    ])
+
+    return new MasterDataListEntity({
+      total,
+      items: items.map(
+        (item) =>
+          new MasterDataEntity({
+            ...item,
+            attributes: {
+              master: item.atttributesMaster as object,
+            },
+          }),
+      ),
+    })
+  }
+}

package/templates/src/prisma/index.ts

@@ -0,0 +1,5 @@
+export * from './interfaces'
+export * from './prisma.constants'
+export * from './prisma.logging.middleware'
+export * from './prisma.module'
+export * from './prisma.service'

package/templates/src/prisma/interfaces/index.ts

@@ -0,0 +1 @@
+export * from './prisma-module-options.interface'

package/templates/src/prisma/interfaces/prisma-module-options.interface.ts

@@ -0,0 +1,50 @@
+import { ModuleMetadata, Type } from '@nestjs/common'
+import { Prisma } from '@prisma/client'
+
+export interface PrismaModuleOptions {
+  /**
+   * If "true", registers `PrismaModule` as a global module.
+   * See: https://docs.nestjs.com/modules#global-modules
+   */
+  isGlobal?: boolean
+
+  prismaServiceOptions?: PrismaServiceOptions
+}
+
+export interface PrismaServiceOptions {
+  /**
+   * Pass options directly to the `PrismaClient`.
+   * See: https://www.prisma.io/docs/reference/api-reference/prisma-client-reference/#prismaclient
+   */
+  prismaOptions?: Prisma.PrismaClientOptions
+
+  /**
+   * If "true", `PrismaClient` explicitly creates a connection pool and your first query will respond instantly.
+   *
+   * For most use cases the lazy connect behavior of `PrismaClient` will do. The first query of `PrismaClient` creates the connection pool.
+   * See: https://www.prisma.io/docs/concepts/components/prisma-client/working-with-prismaclient/connection-management
+   */
+  explicitConnect?: boolean
+
+  /**
+   * Apply Prisma middlewares to perform actions before or after db queries.
+   *
+   * See: https://www.prisma.io/docs/concepts/components/prisma-client/middleware
+   */
+  middlewares?: Array<Prisma.Middleware>
+}
+
+export interface PrismaOptionsFactory {
+  createPrismaOptions(): Promise<PrismaServiceOptions> | PrismaServiceOptions
+}
+
+export interface PrismaModuleAsyncOptions
+  extends Pick<ModuleMetadata, 'imports'> {
+  isGlobal?: boolean
+  useExisting?: Type<PrismaOptionsFactory>
+  useClass?: Type<PrismaOptionsFactory>
+  useFactory?: (
+    ...args: any[]
+  ) => Promise<PrismaServiceOptions> | PrismaServiceOptions
+  inject?: any[]
+}

package/templates/src/prisma/prisma.constants.ts

@@ -0,0 +1,2 @@
+export const PRISMA_SERVICE_OPTIONS = 'PRISMA_SERVICE_OPTIONS'
+export const PRISMA_EXPLICIT_CONNECT = 'PRISMA_EXPLICIT_CONNECT'

package/templates/src/prisma/prisma.logging.middleware.ts

@@ -0,0 +1,20 @@
+import { Logger } from '@nestjs/common'
+import { Prisma } from '@prisma/client'
+
+const logger = new Logger('Prisma')
+
+export function prismaLoggingMiddleware(): Prisma.Middleware {
+  return async (params, next) => {
+    const before = Date.now()
+
+    const result = await next(params)
+
+    const after = Date.now()
+
+    logger.debug(
+      `Query ${params.model}.${params.action} took ${after - before}ms`,
+    )
+
+    return result
+  }
+}

package/templates/src/prisma/prisma.module.ts

@@ -0,0 +1,75 @@
+import { DynamicModule, Module, Provider } from '@nestjs/common'
+
+import {
+  PrismaModuleAsyncOptions,
+  PrismaModuleOptions,
+  PrismaOptionsFactory,
+} from './interfaces'
+import { PRISMA_SERVICE_OPTIONS } from './prisma.constants'
+import { PrismaService } from './prisma.service'
+
+@Module({
+  providers: [PrismaService],
+  exports: [PrismaService],
+})
+export class PrismaModule {
+  static forRoot(options: PrismaModuleOptions = {}): DynamicModule {
+    return {
+      global: options.isGlobal,
+      module: PrismaModule,
+      providers: [
+        {
+          provide: PRISMA_SERVICE_OPTIONS,
+          useValue: options.prismaServiceOptions,
+        },
+      ],
+    }
+  }
+
+  static forRootAsync(options: PrismaModuleAsyncOptions): DynamicModule {
+    return {
+      global: options.isGlobal,
+      module: PrismaModule,
+      imports: options.imports || [],
+      providers: this.createAsyncProviders(options),
+    }
+  }
+
+  private static createAsyncProviders(
+    options: PrismaModuleAsyncOptions,
+  ): Provider[] {
+    if (options.useExisting || options.useFactory) {
+      return this.createAsyncOptionsProvider(options)
+    }
+
+    return [
+      ...this.createAsyncOptionsProvider(options),
+      {
+        provide: options.useClass,
+        useClass: options.useClass,
+      },
+    ]
+  }
+
+  private static createAsyncOptionsProvider(
+    options: PrismaModuleAsyncOptions,
+  ): Provider[] {
+    if (options.useFactory) {
+      return [
+        {
+          provide: PRISMA_SERVICE_OPTIONS,
+          useFactory: options.useFactory,
+          inject: options.inject || [],
+        },
+      ]
+    }
+    return [
+      {
+        provide: PRISMA_SERVICE_OPTIONS,
+        useFactory: async (optionsFactory: PrismaOptionsFactory) =>
+          await optionsFactory.createPrismaOptions(),
+        inject: [options.useExisting || options.useClass],
+      },
+    ]
+  }
+}

package/templates/src/prisma/prisma.service.ts

@@ -0,0 +1,45 @@
+import {
+  Inject,
+  Injectable,
+  Logger,
+  OnModuleInit,
+  Optional,
+} from '@nestjs/common'
+import { Prisma, PrismaClient } from '@prisma/client'
+
+import { PrismaServiceOptions } from './interfaces'
+import { PRISMA_SERVICE_OPTIONS } from './prisma.constants'
+
+@Injectable()
+export class PrismaService
+  extends PrismaClient<Prisma.PrismaClientOptions, 'query' | 'error'>
+  implements OnModuleInit
+{
+  private readonly logger = new Logger(PrismaService.name)
+
+  constructor(
+    @Optional()
+    @Inject(PRISMA_SERVICE_OPTIONS)
+    private readonly prismaServiceOptions: PrismaServiceOptions = {},
+  ) {
+    super(prismaServiceOptions.prismaOptions)
+
+    if (this.prismaServiceOptions.middlewares) {
+      this.prismaServiceOptions.middlewares.forEach((middleware) =>
+        this.$use(middleware),
+      )
+    }
+
+    this.$on('query', (e) => {
+      this.logger.debug('Query: ' + e.query)
+      this.logger.debug('Params: ' + e.params)
+      this.logger.debug('Duration: ' + e.duration + 'ms')
+    })
+  }
+
+  async onModuleInit() {
+    if (this.prismaServiceOptions.explicitConnect) {
+      await this.$connect()
+    }
+  }
+}

package/templates/src/repl.ts

@@ -0,0 +1,21 @@
+/* eslint-disable no-console */
+import { repl } from '@nestjs/core'
+import { AppModule } from '@mbc-cqrs-sererless/core'
+
+import { MainModule } from './main.module'
+
+async function bootstrap() {
+  const replServer = await repl(
+    AppModule.forRoot({
+      rootModule: MainModule,
+    }),
+  )
+  replServer.setupHistory('.nestjs_repl_history', (err) => {
+    if (err) {
+      console.error(err)
+    }
+  })
+}
+bootstrap()
+
+// npm run start -- --watch --entryFile repl

package/templates/test/api.http

@@ -0,0 +1,42 @@
+@endpoint = http://localhost:3000
+@cognitoEndpoint = http://localhost:9229
+@clientId = dnk8y7ii3wled35p3lw0l2cd7
+# account's username 
+@username = admin2
+# account's password
+@password = admin1234
+# account's email
+@email = admin2@example.com
+
+@apiBaseUrl = {{endpoint}}/api
+@eventBaseUrl = {{endpoint}}/event
+
+###
+GET {{endpoint}} HTTP/1.1
+
+###
+# login
+# @name login_cognito
+POST {{cognitoEndpoint}}
+Accept: application/json
+Content-Type: application/x-amz-json-1.1
+X-Amz-Target: AWSCognitoIdentityProviderService.InitiateAuth
+
+{
+  "AuthFlow": "USER_PASSWORD_AUTH",
+  "ClientId": "{{clientId}}",
+  "AuthParameters": {
+    "USERNAME": "{{username}}",
+    "PASSWORD": "{{password}}"
+  },
+  "ClientMetadata": {}
+}
+
+###
+@token = {{login_cognito.response.body.AuthenticationResult.IdToken}}
+###
+
+# Health
+GET {{endpoint}}
+Accept: application/json
+Authorization: {{token}}

package/templates/test/jest-e2e.json

@@ -0,0 +1,9 @@
+{
+  "moduleFileExtensions": ["js", "json", "ts"],
+  "rootDir": ".",
+  "testEnvironment": "node",
+  "testRegex": ".e2e-spec.ts$",
+  "transform": {
+    "^.+\\.(t|j)s$": "ts-jest"
+  }
+}

package/templates/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
+}

package/templates/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": false,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "ES2021",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strictNullChecks": false,
+    "noImplicitAny": false,
+    "strictBindCallApply": false,
+    "forceConsistentCasingInFileNames": false,
+    "noFallthroughCasesInSwitch": false,
+    "esModuleInterop": true,
+    "noLib": false,
+    "noUnusedLocals": false
+  },
+  "include": ["src/*", "src/**/*"]
+}