@mbc-cqrs-serverless/cli 0.1.49-beta.0 → 0.1.51-beta.0

package/dist/schematics/lib/module/files/sync/__name@dasherize__.module.ts

@@ -0,0 +1,19 @@
+import { CommandModule } from '@mbc-cqrs-serverless/core'
+import { Module } from '@nestjs/common'
+
+<% if (schema) { %>import { <%= classify(name) %>DataSyncRdsHandler } from './handler/<%= dasherize(name) %>-rds.handler'<% } %>
+import { <%= classify(name) %>Controller } from './<%= dasherize(name) %>.controller'
+import { <%= classify(name) %>Service } from './<%= dasherize(name) %>.service'
+
+@Module({
+  imports: [
+    CommandModule.register({
+      tableName: '<%= dasherize(name) %>',
+      <% if (schema) { %>dataSyncHandlers: [<%= classify(name) %>DataSyncRdsHandler],<% }
+      else { %>dataSyncHandlers: [],<% } %>
+    }),
+  ],
+  controllers: [<%= classify(name) %>Controller],
+  providers: [<%= classify(name) %>Service],
+})
+export class <%= classify(name) %>Module {}

package/dist/schematics/lib/module/files/sync/__name@dasherize__.service.ts

@@ -0,0 +1,164 @@
+import {
+  CommandPartialInputModel,
+  CommandService,
+  DataService,
+  DetailDto,
+  generateId,
+  getUserContext,
+  IInvoke,
+  toISOStringWithTimezone,
+  VERSION_FIRST,
+} from '@mbc-cqrs-serverless/core'
+import { KEY_SEPARATOR } from '@mbc-cqrs-serverless/core'
+import {
+  BadRequestException,
+  Injectable,
+  Logger,
+  NotFoundException,
+} from '@nestjs/common'
+import { Prisma } from '@prisma/client'
+import { getOrderBys, parsePk } from 'src/helpers'
+import { PrismaService } from 'src/prisma'
+import { ulid } from 'ulid'
+
+import { <%= classify(name) %>CommandDto } from './dto/<%= dasherize(name) %>-command.dto'
+import { <%= classify(name) %>CreateDto } from './dto/<%= dasherize(name) %>-create.dto'
+import { <%= classify(name) %>SearchDto } from './dto/<%= dasherize(name) %>-search.dto'
+import { <%= classify(name) %>UpdateDto } from './dto/<%= dasherize(name) %>-update.dto'
+import { <%= classify(name) %>DataEntity } from './entity/<%= dasherize(name) %>-data.entity'
+import { <%= classify(name) %>DataListEntity } from './entity/<%= dasherize(name) %>-data-list.entity'
+
+@Injectable()
+export class <%= classify(name) %>Service {
+  private readonly logger = new Logger(<%= classify(name) %>Service.name)
+
+  constructor(
+    private readonly commandService: CommandService,
+    private readonly dataService: DataService,
+    <% if (schema) { %>private readonly prismaService: PrismaService,<% } %>
+  ) {}
+
+  async create(
+    createDto: <%= classify(name) %>CreateDto,
+    opts: { invokeContext: IInvoke },
+  ): Promise<<%= classify(name) %>DataEntity> {
+    const { tenantCode } = getUserContext(opts.invokeContext)
+    const pk = `<%= name.toUpperCase() %>${KEY_SEPARATOR}${tenantCode}`
+    const sk = ulid()
+    const <%= camelize(name) %> = new <%= classify(name) %>CommandDto({
+      pk,
+      sk,
+      id: generateId(pk, sk),
+      tenantCode,
+      code: sk,
+      type: '<%= name.toUpperCase() %>',
+      version: VERSION_FIRST,
+      name: createDto.name,
+      attributes: createDto.attributes,
+    })
+    const item = await this.commandService.publishSync(<%= camelize(name) %>, opts)
+    return new <%= classify(name) %>DataEntity(item as <%= classify(name) %>DataEntity)
+  }
+
+  async findOne(detailDto: DetailDto): Promise<<%= classify(name) %>DataEntity> {
+    const item = await this.dataService.getItem(detailDto)
+    if (!item) {
+      throw new NotFoundException('<%= classify(name) %> not found!')
+    }
+    this.logger.debug('item:', item)
+    return new <%= classify(name) %>DataEntity(item as <%= classify(name) %>DataEntity)
+  }
+
+  <% if (schema) { %>async findAll(
+    tenantCode: string,
+    searchDto: <%= classify(name) %>SearchDto,
+  ): Promise<<%= classify(name) %>DataListEntity> {
+    const where: Prisma.<%= classify(name) %>WhereInput = {
+      isDeleted: false,
+      tenantCode,
+    }
+
+    const { pageSize = 10, page = 1, orderBys = ['-createdAt'] } = searchDto
+
+    const [total, items] = await Promise.all([
+      this.prismaService.<%= camelize(name) %>.count({ where }),
+      this.prismaService.<%= camelize(name) %>.findMany({
+        where,
+        take: pageSize,
+        skip: pageSize * (page - 1),
+        orderBy: getOrderBys<Prisma.<%= classify(name) %>OrderByWithRelationInput>(orderBys),
+      }),
+    ])
+
+    return new <%= classify(name) %>DataListEntity({
+      total,
+      items: items.map(
+        (item) =>
+          new <%= classify(name) %>DataEntity({
+            ...item,
+            attributes: {
+              value: item.attributes as object,
+            },
+          }),
+      ),
+    })
+  }<% } %>
+
+  async update(
+    detailDto: DetailDto,
+    updateDto: <%= classify(name) %>UpdateDto,
+    opts: { invokeContext: IInvoke },
+  ): Promise<<%= classify(name) %>DataEntity> {
+    const userContext = getUserContext(opts.invokeContext)
+    const { tenantCode } = parsePk(detailDto.pk)
+    if (userContext.tenantCode !== tenantCode) {
+      throw new BadRequestException('Invalid tenant code')
+    }
+    const data = (await this.dataService.getItem(detailDto)) as <%= classify(name) %>DataEntity
+    if (!data) {
+      throw new NotFoundException('<%= classify(name) %> not found!')
+    }
+    const commandDto = new <%= classify(name) %>CommandDto({
+      pk: data.pk,
+      sk: data.sk,
+      version: data.version,
+      name: updateDto.name ?? data.name,
+      isDeleted: updateDto.isDeleted ?? data.isDeleted,
+      attributes: {
+        ...data.attributes,
+        ...updateDto.attributes,
+      },
+    })
+    const item = await this.commandService.publishPartialUpdateSync(
+      commandDto,
+      opts,
+    )
+    return new <%= classify(name) %>DataEntity(item as <%= classify(name) %>DataEntity)
+  }
+
+  async remove(key: DetailDto, opts: { invokeContext: IInvoke }) {
+    const userContext = getUserContext(opts.invokeContext)
+    const { tenantCode } = parsePk(key.pk)
+
+    if (userContext.tenantCode !== tenantCode) {
+      throw new BadRequestException('Invalid tenant code')
+    }
+
+    const data = (await this.dataService.getItem(key)) as <%= classify(name) %>DataEntity
+    if (!data) {
+      throw new NotFoundException()
+    }
+    const commandDto: CommandPartialInputModel = {
+      pk: data.pk,
+      sk: data.sk,
+      version: data.version,
+      isDeleted: true,
+    }
+    const item = await this.commandService.publishPartialUpdateSync(
+      commandDto,
+      opts,
+    )
+
+    return new <%= classify(name) %>DataEntity(item as any)
+  }
+}

package/dist/schematics/lib/module/files/sync/dto/__name@dasherize__-attributes.dto.ts

@@ -0,0 +1,6 @@
+import { IsObject } from 'class-validator'
+
+export class <%= classify(name) %>Attributes {
+  @IsObject()
+  value: object
+}

package/dist/schematics/lib/module/files/sync/dto/__name@dasherize__-command.dto.ts

@@ -0,0 +1,16 @@
+import { CommandDto } from '@mbc-cqrs-serverless/core'
+import { Type } from 'class-transformer'
+import { ValidateNested } from 'class-validator'
+
+import { <%= classify(name) %>Attributes } from './<%= dasherize(name) %>-attributes.dto'
+
+export class <%= classify(name) %>CommandDto extends CommandDto {
+  @Type(() => <%= classify(name) %>Attributes)
+  @ValidateNested()
+  attributes: <%= classify(name) %>Attributes
+
+  constructor(partial: Partial<<%= classify(name) %>CommandDto>) {
+    super()
+    Object.assign(this, partial)
+  }
+}

package/dist/schematics/lib/module/files/sync/dto/__name@dasherize__-create.dto.ts

@@ -0,0 +1,18 @@
+import { Type } from 'class-transformer'
+import { IsOptional, IsString, ValidateNested } from 'class-validator'
+
+import { <%= classify(name) %>Attributes } from './<%= dasherize(name) %>-attributes.dto'
+
+export class <%= classify(name) %>CreateDto {
+  @IsString()
+  name: string
+
+  @Type(() => <%= classify(name) %>Attributes)
+  @ValidateNested()
+  @IsOptional()
+  attributes?: <%= classify(name) %>Attributes
+
+  constructor(partial: Partial<<%= classify(name) %>CreateDto>) {
+    Object.assign(this, partial)
+  }
+}

package/dist/schematics/lib/module/files/sync/dto/__name@dasherize__-search.dto.ts

@@ -0,0 +1,2 @@
+import { SearchDto } from '@mbc-cqrs-serverless/core'
+export class <%= classify(name) %>SearchDto extends SearchDto {}

package/dist/schematics/lib/module/files/sync/dto/__name@dasherize__-update.dto.ts

@@ -0,0 +1,34 @@
+import { PartialType } from '@nestjs/swagger'
+import { Transform, Type } from 'class-transformer'
+import {
+  IsBoolean,
+  IsOptional,
+  IsString,
+  ValidateNested,
+} from 'class-validator'
+
+import { <%= classify(name) %>Attributes } from './<%= dasherize(name) %>-attributes.dto'
+
+export class <%= classify(name) %>UpdateAttributes extends PartialType(<%= classify(name) %>Attributes) {}
+
+export class <%= classify(name) %>UpdateDto {
+  @IsString()
+  @IsOptional()
+  name?: string
+
+  @IsBoolean()
+  @Transform(({ value }) =>
+    value === 'true' ? true : value === 'false' ? false : value,
+  )
+  @IsOptional()
+  isDeleted?: boolean
+
+  @Type(() => <%= classify(name) %>UpdateAttributes)
+  @ValidateNested()
+  @IsOptional()
+  attributes?: <%= classify(name) %>UpdateAttributes
+
+  constructor(partial: Partial<<%= classify(name) %>UpdateDto>) {
+    Object.assign(this, partial)
+  }
+}

package/dist/schematics/lib/module/files/sync/entity/__name@dasherize__-command.entity.ts

@@ -0,0 +1,12 @@
+import { CommandEntity } from '@mbc-cqrs-serverless/core'
+
+import { <%= classify(name) %>Attributes } from '../dto/<%= dasherize(name) %>-attributes.dto'
+
+export class <%= classify(name) %>CommandEntity extends CommandEntity {
+  attributes: <%= classify(name) %>Attributes
+
+  constructor(partial: Partial<<%= classify(name) %>CommandEntity>) {
+    super()
+    Object.assign(this, partial)
+  }
+}

package/dist/schematics/lib/module/files/sync/entity/__name@dasherize__-data-list.entity.ts

@@ -0,0 +1,12 @@
+import { DataListEntity } from '@mbc-cqrs-serverless/core'
+
+import { <%= classify(name) %>DataEntity } from './<%= dasherize(name) %>-data.entity'
+
+export class <%= classify(name) %>DataListEntity extends DataListEntity {
+  items: <%= classify(name) %>DataEntity[]
+
+  constructor(partial: Partial<<%= classify(name) %>DataListEntity>) {
+    super(partial)
+    Object.assign(this, partial)
+  }
+}

package/dist/schematics/lib/module/files/sync/entity/__name@dasherize__-data.entity.ts

@@ -0,0 +1,12 @@
+import { DataEntity } from '@mbc-cqrs-serverless/core'
+
+import { <%= classify(name) %>Attributes } from '../dto/<%= dasherize(name) %>-attributes.dto'
+
+export class <%= classify(name) %>DataEntity extends DataEntity {
+  attributes: <%= classify(name) %>Attributes
+
+  constructor(partial: Partial<<%= classify(name) %>DataEntity>) {
+    super(partial)
+    Object.assign(this, partial)
+  }
+}

package/dist/schematics/lib/module/files/sync/handler/__name@dasherize__-rds.handler.ts

@@ -0,0 +1,62 @@
+import {
+  CommandModel,
+  IDataSyncHandler,
+  removeSortKeyVersion,
+} from '@mbc-cqrs-serverless/core'
+import { Injectable, Logger } from '@nestjs/common'
+import { PrismaService } from 'src/prisma'
+
+import { <%= classify(name) %>Attributes } from '../dto/<%= dasherize(name) %>-attributes.dto'
+
+@Injectable()
+export class <%= classify(name) %>DataSyncRdsHandler implements IDataSyncHandler {
+  private readonly logger = new Logger(<%= classify(name) %>DataSyncRdsHandler.name)
+
+  constructor(private readonly prismaService: PrismaService) {}
+
+  async up(cmd: CommandModel): Promise<any> {
+    this.logger.debug(cmd)
+    const sk = removeSortKeyVersion(cmd.sk)
+    const attrs = cmd.attributes as <%= classify(name) %>Attributes
+    await this.prismaService.<%= camelize(name) %>.upsert({
+      where: {
+        id: cmd.id,
+      },
+      update: {
+        csk: cmd.sk,
+        name: cmd.name,
+        version: cmd.version,
+        seq: cmd.seq,
+        isDeleted: cmd.isDeleted || false,
+        updatedAt: cmd.updatedAt,
+        updatedBy: cmd.updatedBy,
+        updatedIp: cmd.updatedIp,
+        // attributes
+        attributes: attrs.value,
+      },
+      create: {
+        id: cmd.id,
+        cpk: cmd.pk,
+        csk: cmd.sk,
+        pk: cmd.pk,
+        sk,
+        code: sk,
+        name: cmd.name,
+        version: cmd.version,
+        tenantCode: cmd.tenantCode,
+        seq: cmd.seq,
+        createdAt: cmd.createdAt,
+        createdBy: cmd.createdBy,
+        createdIp: cmd.createdIp,
+        updatedAt: cmd.updatedAt,
+        updatedBy: cmd.updatedBy,
+        updatedIp: cmd.updatedIp,
+        // attributes
+        attributes: attrs.value,
+      },
+    })
+  }
+  async down(cmd: CommandModel): Promise<any> {
+    this.logger.debug(cmd)
+  }
+}

package/dist/schematics/lib/module/module.factory.js

@@ -0,0 +1,204 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const core_1 = require("@angular-devkit/core");
+const schematics_1 = require("@angular-devkit/schematics");
+const ts = __importStar(require("typescript"));
+const yaml_1 = require("yaml");
+function main(options) {
+    return (tree, _context) => {
+        const filePath = (0, core_1.normalize)(`/src/${core_1.strings.dasherize(options.name)}/${core_1.strings.dasherize(options.name)}.module.ts`);
+        const isFileExists = tree.exists(filePath);
+        if (isFileExists) {
+            _context.logger.info(`Module file already exists at: ${filePath}`);
+            return;
+        }
+        updateMainModule(tree, options);
+        updateCdkInfraStack(tree, options);
+        updateCqrsTable(tree, options);
+        updateServerlessYaml(tree, options);
+        if (options.schema) {
+            updatePrismaSchema(tree, options);
+        }
+        return (0, schematics_1.chain)([createModule(options), createUnitTest(options)]);
+    };
+}
+// create rule
+function createModule(options) {
+    return (0, schematics_1.mergeWith)((0, schematics_1.apply)((0, schematics_1.url)(`./files/${options.mode}`), [
+        options.schema ? (0, schematics_1.noop)() : (0, schematics_1.filter)((path) => !path.endsWith('.handler.ts')),
+        (0, schematics_1.template)({
+            ...core_1.strings,
+            ...options,
+        }),
+        (0, schematics_1.move)((0, core_1.normalize)(`/src/${core_1.strings.dasherize(options.name)}`)),
+    ]));
+}
+function createUnitTest(options) {
+    return (0, schematics_1.mergeWith)((0, schematics_1.apply)((0, schematics_1.url)('./units'), [
+        (0, schematics_1.template)({
+            ...core_1.strings,
+            ...options,
+            specFileSuffix: 'spec',
+        }),
+        (0, schematics_1.move)((0, core_1.normalize)(`/test/unit/${core_1.strings.dasherize(options.name)}`)),
+    ]));
+}
+// modify main.module.ts
+function updateMainModule(tree, options) {
+    const mainModulePath = 'src/main.module.ts';
+    const isMainModulePathExists = tree.exists(mainModulePath);
+    if (isMainModulePathExists) {
+        const fileBuffer = tree.read(mainModulePath);
+        const content = fileBuffer.toString('utf-8');
+        const lines = content.split('\n');
+        lines.splice(5, 0, `import { ${core_1.strings.classify(options.name)}Module } from './${core_1.strings.dasherize(options.name)}/${core_1.strings.dasherize(options.name)}.module'`);
+        lines.splice(23, 0, `    ${core_1.strings.classify(options.name)}Module,`);
+        const newContent = lines.join('\n');
+        tree.overwrite(mainModulePath, newContent);
+        return tree;
+    }
+}
+// modify infra cdk
+function updateCdkInfraStack(tree, options) {
+    const infraStackPath = 'infra/libs/infra-stack.ts';
+    const isInfraStackExists = tree.exists(infraStackPath);
+    if (isInfraStackExists) {
+        const fileBuffer = tree.read(infraStackPath);
+        const content = fileBuffer.toString('utf-8');
+        const sourceFile = ts.createSourceFile(infraStackPath, content, ts.ScriptTarget.Latest, true);
+        const updatedContent = updateTableNamesArray(sourceFile, [`${core_1.strings.dasherize(options.name)}-command`], content);
+        tree.overwrite(infraStackPath, updatedContent);
+        return tree;
+    }
+}
+function updateTableNamesArray(sourceFile, newTableNames, content) {
+    let updatedContent = content;
+    const visit = (node) => {
+        if (ts.isVariableDeclaration(node) &&
+            node.name.getText() === 'tableNames' &&
+            ts.isArrayLiteralExpression(node.initializer)) {
+            // Extract existing table names
+            const existingElements = node.initializer.elements.map((element) => element.getText().replace(/['"]/g, ''));
+            // Append new table names, ensuring no duplicates
+            const updatedTableNames = Array.from(new Set([...existingElements, ...newTableNames]));
+            // Generate the updated array string
+            const newArray = `[${updatedTableNames.map((name) => `'${name}'`).join(', ')}]`;
+            // Replace the existing array with the new array
+            updatedContent =
+                updatedContent.slice(0, node.initializer.getStart()) +
+                    newArray +
+                    updatedContent.slice(node.initializer.getEnd());
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return updatedContent;
+}
+// modify cqrs.json
+function updateCqrsTable(tree, options) {
+    const cqrsTablePath = 'prisma/dynamodbs/cqrs.json';
+    const isCqrsTableExists = tree.exists(cqrsTablePath);
+    if (isCqrsTableExists) {
+        const fileContent = tree.read(cqrsTablePath)?.toString();
+        const jsonContent = JSON.parse(fileContent.toString());
+        jsonContent.push(core_1.strings.dasherize(options.name));
+        tree.overwrite(cqrsTablePath, JSON.stringify(jsonContent, null, 2));
+        return tree;
+    }
+}
+// modify prisma.schema
+function updatePrismaSchema(tree, options) {
+    const schemaPath = 'prisma/schema.prisma';
+    const isSchemaExists = tree.exists(schemaPath);
+    if (isSchemaExists) {
+        const fileContent = tree.read(schemaPath)?.toString('utf-8');
+        const stringToAppend = generateModelTemplate(options.name);
+        const updatedContent = fileContent + stringToAppend;
+        tree.overwrite(schemaPath, updatedContent);
+        return tree;
+    }
+}
+// modify serverless.yaml
+function updateServerlessYaml(tree, options) {
+    const serverlessPath = 'infra-local/serverless.yml';
+    const isServerlessExists = tree.exists(serverlessPath);
+    if (isServerlessExists) {
+        const fileContent = tree.read(serverlessPath)?.toString('utf-8');
+        const newStreamEvent = {
+            type: 'dynamodb',
+            maximumRetryAttempts: 10,
+            arn: '${env:LOCAL_DDB_%%TABLE_NAME%%_STREAM}'.replace('%%TABLE_NAME%%', options.name.toUpperCase()),
+            filterPatterns: [{ eventName: ['INSERT'] }],
+        };
+        const doc = (0, yaml_1.parseDocument)(fileContent);
+        const mainFunction = doc.getIn(['functions', 'main']);
+        const events = mainFunction.get('events');
+        events.items.push({ stream: newStreamEvent });
+        const updatedYamlContent = (0, yaml_1.stringify)(doc);
+        tree.overwrite(serverlessPath, updatedYamlContent);
+        return tree;
+    }
+}
+const generateModelTemplate = (name) => `
+model ${core_1.strings.classify(name)} {
+  id             String   @id
+  cpk            String // コマンド用PK
+  csk            String // コマンド用SK
+  pk             String // データ用PK, ${name.toUpperCase()}#tenantCode (テナントコード)
+  sk             String // データ用SK, マスタ種別コード#マスタコード
+  tenantCode     String   @map("tenant_code") // テナントコード, 【テナントコードマスタ】
+  seq            Int      @default(0) // 並び順, 採番機能を使用する
+  code           String // レコードのコード, マスタ種別コード#マスタコード
+  name           String // レコード名, 名前
+  version        Int // バージョン
+  isDeleted      Boolean  @default(false) @map("is_deleted") // 削除フラグ
+  createdBy      String   @default("") @map("created_by") // 作成者
+  createdIp      String   @default("") @map("created_ip") // 作成IP, IPv6も考慮する
+  createdAt      DateTime @default(now()) @map("created_at") @db.Timestamp(0) // 作成日時
+  updatedBy      String   @default("") @map("updated_by") // 更新者
+  updatedIp      String   @default("") @map("updated_ip") // 更新IP, IPv6も考慮する
+  updatedAt      DateTime @updatedAt @map("updated_at") @db.Timestamp(0) // 更新日時
+
+  attributes Json? @map("attributes")
+
+  @@unique([cpk, csk])
+  @@unique([pk, sk])
+  @@unique([tenantCode, code])
+  @@index([tenantCode, name])
+  @@map("${core_1.strings.underscore(name)}s")
+}
+`;