@takumi-stack/core 1.0.0 → 1.0.1

package/prefab/compute/fargate/cluster.ts

@@ -0,0 +1,24 @@
+import * as awsECS from 'aws-cdk-lib/aws-ecs';
+import { Construct } from 'constructs';
+
+import { VpcPrefab } from '../../..';
+import { ServiceStack, getLogicalName, getResourceName } from '../../../common';
+
+export type FargateClusterPrefabParams = {
+  name: string;
+  vpcPrefab: VpcPrefab;
+};
+
+export class FargateClusterPrefab extends Construct {
+  public readonly cluster: awsECS.Cluster;
+
+  constructor(service: ServiceStack, params: FargateClusterPrefabParams) {
+    super(service, getLogicalName(params.name, FargateClusterPrefab.name));
+
+    this.cluster = new awsECS.Cluster(this, getLogicalName(params.name, 'cluster'), {
+      containerInsights: true,
+      clusterName: getResourceName('cluster', { ...service.props, serviceName: params.name }),
+      vpc: params.vpcPrefab.vpc,
+    });
+  }
+}

package/prefab/compute/fargate/index.ts

@@ -0,0 +1,2 @@
+export * from './cluster';
+export * from './service';

package/prefab/compute/fargate/service.ts

@@ -0,0 +1,130 @@
+import * as awsECS from 'aws-cdk-lib/aws-ecs';
+import * as awsALB from 'aws-cdk-lib/aws-elasticloadbalancingv2';
+import { ICertificate } from 'aws-cdk-lib/aws-certificatemanager';
+import { IRepository, Repository } from 'aws-cdk-lib/aws-ecr';
+import { FargatePlatformVersion, HealthCheck, Secret } from 'aws-cdk-lib/aws-ecs';
+import { Effect, PolicyStatement } from 'aws-cdk-lib/aws-iam';
+import { LogGroup } from 'aws-cdk-lib/aws-logs';
+import { Construct } from 'constructs';
+
+import { ServiceStack, SynthError, getLogicalName, getResourceName } from '../../../common';
+import { PublicAlbPrefab } from '../../gateway';
+import { VpcPrefab } from '../../networking';
+import { FargateClusterPrefab } from './cluster';
+
+export type FargateContainerHealthCheck = HealthCheck;
+
+export type FargatePerformanceTunning = {
+  taskCpu: string;
+  taskMemory: string;
+  containerDesiredCount: number;
+  taskAutoScaleMin: number;
+  taskAutoScaleMax: number;
+  taskAutoScalePercent: number;
+  containerMaxMemory: number;
+};
+
+export type FargateServicePrefabParams = {
+  name: string;
+  fargateClusterPrefab: FargateClusterPrefab;
+  vpcPrefab: VpcPrefab;
+  albPrefab: PublicAlbPrefab;
+  mappingPort: number;
+  basePath: string;
+  fixedPriority?: number;
+  healthCheckPath: string;
+  certificate: ICertificate;
+  containerHealthCheck?: FargateContainerHealthCheck;
+  containerEnv?: Record<string, string>;
+  containerSecrets?: Record<string, Secret>;
+  dockerBuildFolder?: string;
+  externalRepository?: {
+    repositoryName: string;
+    tag?: string;
+  };
+  performanceTunning: FargatePerformanceTunning;
+};
+
+export class FargateServicePrefab extends Construct {
+  public readonly repository!: IRepository;
+  public readonly targetGroup!: awsALB.ApplicationTargetGroup;
+
+  constructor(service: ServiceStack, params: FargateServicePrefabParams) {
+    super(service, getLogicalName(params.name, FargateServicePrefab.name));
+
+    if (!params.dockerBuildFolder && !params.externalRepository) throw new SynthError('dockerBuildFolder or externalRepository should exist');
+
+    if (params.externalRepository) {
+      this.repository = Repository.fromRepositoryName(this, getLogicalName(params.name, 'repo'), params.externalRepository.repositoryName);
+    }
+
+    // CONTAINER TASK DEFINITION
+    const taskDefinition = new awsECS.TaskDefinition(this, getLogicalName(params.name, 'taskDefinition'), {
+      family: getResourceName('task-definition', { ...service.props, serviceName: params.name }),
+      compatibility: awsECS.Compatibility.FARGATE,
+      networkMode: awsECS.NetworkMode.AWS_VPC,
+      cpu: params.performanceTunning.taskCpu || '256',
+      memoryMiB: params.performanceTunning.taskMemory || '512',
+    });
+
+    taskDefinition.addContainer(getLogicalName(params.name, 'container'), {
+      containerName: params.name,
+      image: params.dockerBuildFolder
+        ? awsECS.ContainerImage.fromAsset(params.dockerBuildFolder)
+        : awsECS.ContainerImage.fromEcrRepository(this.repository, params.externalRepository?.tag || 'latest'),
+      // memoryLimitMiB: params.performanceTunning.containerMaxMemory,
+      secrets: params.containerSecrets,
+      healthCheck: params.containerHealthCheck,
+      environment: { BASE_PATH: params.basePath, ...params.containerEnv },
+      logging: awsECS.LogDriver.awsLogs({
+        streamPrefix: params.name,
+        logGroup: new LogGroup(this, getLogicalName(params.name, 'logGroup'), {
+          logGroupName: getResourceName('', service.props),
+        }),
+      }),
+      portMappings: [{ containerPort: params.mappingPort }],
+    });
+
+    taskDefinition.addToTaskRolePolicy(
+      new PolicyStatement({
+        effect: Effect.ALLOW,
+        actions: [
+          'ssmmessages:CreateControlChannel',
+          'ssmmessages:CreateDataChannel',
+          'ssmmessages:OpenControlChannel',
+          'ssmmessages:OpenDataChannel',
+        ],
+        resources: ['*'],
+      })
+    );
+    if (params.externalRepository) this.repository.grantPull(taskDefinition.taskRole);
+
+    // FARGATE SERVICE
+    const fargateService = new awsECS.FargateService(this, getLogicalName(params.name, 'fargateService'), {
+      serviceName: getResourceName('service', { ...service.props, serviceName: params.name }),
+      platformVersion: FargatePlatformVersion.LATEST,
+      cluster: params.fargateClusterPrefab.cluster,
+      desiredCount: params.performanceTunning.containerDesiredCount,
+      taskDefinition,
+      securityGroups: [params.albPrefab.getAlbToClusterSG()],
+      assignPublicIp: true,
+      circuitBreaker: { rollback: true },
+      capacityProviderStrategies: [{ capacityProvider: 'FARGATE' }],
+    });
+
+    // AUTOSCALING
+    const scalableTarget = fargateService.autoScaleTaskCount({
+      minCapacity: params.performanceTunning.taskAutoScaleMin,
+      maxCapacity: params.performanceTunning.taskAutoScaleMax,
+    });
+    scalableTarget.scaleOnMemoryUtilization(getLogicalName(params.name, 'ScaleUpMem'), {
+      targetUtilizationPercent: params.performanceTunning.taskAutoScalePercent,
+    });
+    scalableTarget.scaleOnCpuUtilization(getLogicalName(params.name, 'ScaleUpCPU'), {
+      targetUtilizationPercent: params.performanceTunning.taskAutoScalePercent,
+    });
+
+    // CONNECT TO ALB
+    params.albPrefab.appendTargetGroup({ ...params, fargateService });
+  }
+}

package/prefab/compute/function/api-function/api-aggregate.ts

@@ -0,0 +1,73 @@
+import { UserPool, UserPoolClient } from 'aws-cdk-lib/aws-cognito';
+import { IFunction } from 'aws-cdk-lib/aws-lambda';
+import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';
+import { Construct } from 'constructs';
+
+import { TableStoreBuilder } from '@takumi-stack/sdk';
+
+import { ServiceStack, getLogicalName, SynthError } from '../../../../common';
+import { CdnApiPrefab } from '../../../cdn';
+import { DynamoTablePrefab } from '../../../database';
+import { ApiRestPrefab, ApiHttpPrefab } from '../../../gateway';
+import { BaseAggregateParams } from '../base-function';
+import { ApiHandlerParams, ApiFunction } from './api-function';
+
+export type ApiAuthPoolParams = {
+  userPool?: UserPool;
+  userPoolClient?: UserPoolClient;
+};
+
+export type ApiAggregateParams<HandlerName extends string = string> = BaseAggregateParams & {
+  basePath: string;
+  handlers: Record<HandlerName, ApiHandlerParams>;
+  cdnApiPrefab: CdnApiPrefab | undefined;
+  authPool?: ApiAuthPoolParams;
+  customAuthorizerHandler?: IFunction;
+  useRestApi?: true;
+  tableBuilder?: typeof TableStoreBuilder<any>;
+};
+
+export class ApiAggregate<HandlerName extends string = string> extends Construct {
+  public readonly apiPrefab: ApiRestPrefab | ApiHttpPrefab;
+  public readonly tablePrefab?: DynamoTablePrefab;
+  public readonly handlers: Record<HandlerName, NodejsFunction> = {} as Record<HandlerName, NodejsFunction>;
+
+  constructor(service: ServiceStack, params: ApiAggregateParams) {
+    super(service, getLogicalName('ApiAggregate'));
+
+    if (params.useRestApi) {
+      this.apiPrefab = new ApiRestPrefab(service, {
+        ...params,
+        ...params.authPool,
+        customAuthorizerHandler: params.customAuthorizerHandler,
+      });
+    } else {
+      this.apiPrefab = new ApiHttpPrefab(service, {
+        ...params,
+        ...params.authPool,
+        customAuthorizerHandler: params.customAuthorizerHandler,
+      });
+    }
+
+    if (params.tableBuilder && params.tablePrefab)
+      throw new SynthError('Invalid params: tableBuilder and tablePrefab are mutually exclusive', service.props);
+    if (params.tablePrefab) this.tablePrefab = params.tablePrefab;
+    if (params.tableBuilder) this.tablePrefab = new DynamoTablePrefab(service, params.tableBuilder);
+
+    Object.keys(params.handlers).forEach((handler: string) => {
+      if (params.basePath !== params.handlers[handler]!.basePath)
+        throw new SynthError(`[ApiService] Invalid basePath: '${params.handlers[handler]!.basePath}' in '${handler}' function.`, service.props);
+      this.handlers[handler as HandlerName] = new ApiFunction(service, {
+        ...params,
+        ...params.handlers[handler]!,
+        tablePrefab: this.tablePrefab,
+        apiPrefab: this.apiPrefab,
+        modifiers: [...(params.modifiers || []), ...(params.handlers[handler]!.modifiers || [])],
+        environment: {
+          ...params.environment,
+          ...params.handlers[handler]!.environment,
+        },
+      }).lambdaFunction;
+    });
+  }
+}

package/prefab/compute/function/api-function/api-function.ts

@@ -0,0 +1,63 @@
+import { Duration } from 'aws-cdk-lib';
+import { LambdaIntegration } from 'aws-cdk-lib/aws-apigateway';
+import { HttpLambdaIntegration } from 'aws-cdk-lib/aws-apigatewayv2-integrations';
+import { HttpMethod } from 'aws-cdk-lib/aws-events';
+import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';
+import { Construct } from 'constructs';
+
+import { ApiDefinition, ApiInterface } from '@takumi-stack/sdk';
+
+import { ServiceStack, getLogicalName, SynthError } from '../../../../common';
+import { ApiRestPrefab, ApiHttpPrefab } from '../../../gateway';
+import { BaseAggregateParams } from '../base-function';
+import { BaseFunction, BaseHandlerParams } from '../base-function';
+
+export type ApiHandlerParams = BaseHandlerParams & {
+  basePath: ApiDefinition<ApiInterface>['basePath'];
+  path: ApiDefinition<ApiInterface>['path'];
+  method: ApiDefinition<ApiInterface>['method'];
+  isPublic?: ApiDefinition<ApiInterface>['isPublic'];
+  cacheMaxAge?: number;
+};
+
+export type ApiFunctionParams = BaseAggregateParams & {
+  apiPrefab: ApiRestPrefab | ApiHttpPrefab;
+};
+
+export class ApiFunction extends Construct {
+  public readonly lambdaFunction: NodejsFunction;
+
+  constructor(service: ServiceStack, params: ApiHandlerParams & ApiFunctionParams) {
+    super(service, getLogicalName(ApiFunction.name, params.name));
+
+    const baseFunction = new BaseFunction(service, {
+      ...params,
+      environment: { ...params.environment, CC_FUNCTION_TYPE: 'API' },
+    });
+
+    this.lambdaFunction = baseFunction.lambdaFunction;
+    this.lambdaFunction.addEnvironment('CC_CACHE_MAX_AGE', params.cacheMaxAge?.toString() || '10');
+
+    if (this.lambdaFunction.timeout && this.lambdaFunction.timeout.toSeconds() > Duration.seconds(28).toSeconds()) {
+      throw new SynthError('Lambda timeout must be less than 28 seconds in ApiFunctions', service.props);
+    }
+
+    if (params.apiPrefab instanceof ApiHttpPrefab) {
+      const path = params.path === '/' ? '' : params.path;
+      params.apiPrefab.api.addRoutes({
+        path: `/${params.basePath}${path}`,
+        methods: [params.method as HttpMethod],
+        integration: new HttpLambdaIntegration(ApiFunction.name, baseFunction.aliasFunction),
+        ...(params.isPublic ? {} : { authorizer: params.apiPrefab.authorizer }),
+      });
+    }
+    if (params.apiPrefab instanceof ApiRestPrefab) {
+      params.apiPrefab.api.root
+        .resourceForPath(`${params.basePath}${params.path}`)
+        .addMethod(params.method, new LambdaIntegration(baseFunction.aliasFunction), {
+          operationName: this.lambdaFunction.functionName,
+          ...(params.isPublic ? {} : { authorizer: params.apiPrefab.authorizer }),
+        });
+    }
+  }
+}

package/prefab/compute/function/api-function/index.ts

@@ -0,0 +1,2 @@
+export * from './api-aggregate';
+export * from './api-function';

package/prefab/compute/function/base-function/index.ts

@@ -0,0 +1,102 @@
+import { Duration } from 'aws-cdk-lib';
+import { PolicyStatement, Role, ServicePrincipal } from 'aws-cdk-lib/aws-iam';
+import { Alias, Architecture, Runtime, Tracing, Version } from 'aws-cdk-lib/aws-lambda';
+import { NodejsFunction, NodejsFunctionProps } from 'aws-cdk-lib/aws-lambda-nodejs';
+import { Construct } from 'constructs';
+
+import { ApiDefinition, ApiInterface, TablePermission } from '@takumi-stack/sdk';
+
+import { Modifier, ServiceStack, getFunctionEntry, getLogicalName, getShortResourceName } from '../../../../common';
+import { DynamoTablePrefab } from '../../../database';
+import { EventBusPrefab } from '../../../integration';
+
+export const FUNCTION_DEFAULT_TIMEOUT = 6;
+
+export type BaseHandlerParams = NodejsFunctionProps & {
+  name: ApiDefinition<ApiInterface>['name'];
+  modifiers?: Modifier[];
+  environment?: Record<string, string>;
+  architecture?: Architecture;
+  tablePermission?: TablePermission;
+  provisionedConcurrentExecutions?: number;
+};
+
+export type BaseAggregateParams = {
+  baseFunctionFolder?: string;
+  baseFunctionString?: string;
+  globalConfigs?: NodejsFunctionProps;
+  eventBus?: EventBusPrefab;
+  tablePrefab?: DynamoTablePrefab;
+  modifiers?: Modifier[];
+  environment?: Record<string, string>;
+  compiled?: true;
+  tracingDisabled?: true;
+};
+
+export class BaseFunction extends Construct {
+  public readonly lambdaFunction: NodejsFunction;
+  public readonly aliasFunction: Alias;
+
+  constructor(service: ServiceStack, params: BaseHandlerParams & BaseAggregateParams) {
+    super(service, getLogicalName(BaseFunction.name, params.name));
+
+    const role = new Role(this, getLogicalName('role', params.name), {
+      assumedBy: new ServicePrincipal('lambda.amazonaws.com'),
+      roleName: getShortResourceName(params.name, service.props),
+    });
+    role.addManagedPolicy({ managedPolicyArn: 'arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole' });
+
+    const ccEnv = service.props.ephemeralEnvName ? `${service.props.ephemeralEnvName}-${service.props.envName}` : service.props.envName;
+
+    this.lambdaFunction = new NodejsFunction(this, params.name, {
+      runtime: Runtime.NODEJS_18_X,
+      logRetention: 30,
+      handler: 'handler',
+      role,
+      tracing: params.tracingDisabled ? Tracing.DISABLED : Tracing.ACTIVE,
+      timeout: Duration.seconds(FUNCTION_DEFAULT_TIMEOUT),
+      functionName: getShortResourceName(params.name, service.props),
+      entry: params.baseFunctionString || getFunctionEntry(params.baseFunctionFolder!, params.name, params.compiled),
+      architecture: params.architecture || Architecture.ARM_64,
+      ...params.globalConfigs,
+      ...params,
+      environment: {
+        CC_SERVICE: service.props.serviceName,
+        CC_ENV: ccEnv,
+        CC_LOG_LEVEL: 'error',
+        ...params.environment,
+      },
+    });
+
+    const version = Version.fromVersionArn(this, 'LambdaVersion', this.lambdaFunction.currentVersion.functionArn);
+
+    this.aliasFunction = new Alias(this, 'LambdaAlias', {
+      aliasName: service.props.envName,
+      version,
+      provisionedConcurrentExecutions: params.provisionedConcurrentExecutions || 0,
+    });
+
+    this.lambdaFunction.addEnvironment('CC_FUNCTION_TIMEOUT', this.lambdaFunction.timeout!.toSeconds().toString());
+    if (!params.tracingDisabled) this.lambdaFunction.addEnvironment('CC_TRACING', 'true');
+
+    if (this.lambdaFunction.isBoundToVpc) {
+      role.addToPolicy(
+        new PolicyStatement({
+          actions: [
+            'ec2:DescribeNetworkInterfaces',
+            'ec2:CreateNetworkInterface',
+            'ec2:DeleteNetworkInterface',
+            'ec2:DescribeInstances',
+            'ec2:AttachNetworkInterface',
+          ],
+          resources: ['*'],
+        })
+      );
+    }
+
+    params.modifiers?.map((fn) => fn(this.lambdaFunction));
+
+    DynamoTablePrefab.addTable(this.lambdaFunction, params.tablePrefab, params.tablePermission);
+    EventBusPrefab.addBus(this.lambdaFunction, params.eventBus?.bus);
+  }
+}

package/prefab/compute/function/cognito-function/cognito-aggregate.ts

@@ -0,0 +1,29 @@
+import { UserPool } from 'aws-cdk-lib/aws-cognito';
+import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';
+import { Construct } from 'constructs';
+
+import { ServiceStack, getLogicalName } from '../../../../common';
+import { BaseAggregateParams } from '../base-function';
+import { CognitoFunction, CognitoHandlerParams } from './cognito-function';
+
+export type CognitoAggregateParams<HandlerName extends string = string> = BaseAggregateParams & {
+  handlers: Record<HandlerName, CognitoHandlerParams>;
+  userPool: UserPool;
+};
+
+export class CognitoAggregate<HandlerName extends string = string> extends Construct {
+  public readonly handlers: Record<HandlerName, NodejsFunction> = {} as Record<HandlerName, NodejsFunction>;
+
+  constructor(service: ServiceStack, params: CognitoAggregateParams<HandlerName>) {
+    super(service, getLogicalName(CognitoAggregate.name));
+
+    Object.keys(params.handlers).forEach((handler) => {
+      this.handlers[handler as HandlerName] = new CognitoFunction(service, {
+        ...params,
+        ...params.handlers[handler as HandlerName],
+        modifiers: [...(params.modifiers || []), ...(params.handlers[handler as HandlerName].modifiers || [])],
+        environment: { ...params.environment, ...params.handlers[handler as HandlerName].environment },
+      }).lambdaFunction;
+    });
+  }
+}

package/prefab/compute/function/cognito-function/cognito-function.ts

@@ -0,0 +1,36 @@
+import { Duration } from 'aws-cdk-lib';
+import { UserPool, UserPoolOperation } from 'aws-cdk-lib/aws-cognito';
+import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';
+import { Construct } from 'constructs';
+
+import { ServiceStack, getLogicalName, SynthError } from '../../../../common';
+import { BaseAggregateParams } from '../base-function';
+import { BaseFunction, BaseHandlerParams } from '../base-function';
+
+export type CognitoHandlerParams = BaseHandlerParams & {
+  operation: UserPoolOperation;
+};
+
+export type CognitoFunctionParams = BaseAggregateParams & {
+  userPool: UserPool;
+};
+
+export class CognitoFunction extends Construct {
+  public readonly lambdaFunction: NodejsFunction;
+
+  constructor(service: ServiceStack, params: CognitoFunctionParams & CognitoHandlerParams) {
+    super(service, getLogicalName(CognitoFunction.name, params.name));
+
+    this.lambdaFunction = new BaseFunction(service, {
+      ...params,
+      timeout: Duration.seconds(5),
+      environment: { ...params.environment, CC_FUNCTION_TYPE: 'COGNITO' },
+    }).lambdaFunction;
+
+    if (this.lambdaFunction.timeout && this.lambdaFunction.timeout.toSeconds() > Duration.seconds(5).toSeconds()) {
+      throw new SynthError('Lambda timeout must be less than 5 seconds in CognitoFunction', service.props);
+    }
+
+    params.userPool.addTrigger(params.operation, this.lambdaFunction);
+  }
+}

package/prefab/compute/function/cognito-function/index.ts

@@ -0,0 +1,2 @@
+export * from './cognito-aggregate';
+export * from './cognito-function';

package/prefab/compute/function/cron-function/cron-aggregate.ts

@@ -0,0 +1,28 @@
+import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';
+import { Construct } from 'constructs';
+
+import { ServiceStack, getLogicalName } from '../../../../common';
+import { BaseAggregateParams } from '../base-function';
+import { CronFunction, CronHandlerParams } from './cron-function';
+
+export type CronAggregateParams<HandlerName extends string = string> = BaseAggregateParams & {
+  name?: string;
+  handlers: Record<HandlerName, CronHandlerParams>;
+};
+
+export class CronAggregate<HandlerName extends string = string> extends Construct {
+  public readonly handlers: Record<HandlerName, NodejsFunction> = {} as Record<HandlerName, NodejsFunction>;
+
+  constructor(service: ServiceStack, params: CronAggregateParams<HandlerName>) {
+    super(service, getLogicalName(CronAggregate.name, params.name));
+
+    Object.keys(params.handlers).forEach((handler: string) => {
+      this.handlers[handler as HandlerName] = new CronFunction(service, {
+        ...params,
+        ...params.handlers[handler as HandlerName],
+        modifiers: [...(params.modifiers || []), ...(params.handlers[handler as HandlerName].modifiers || [])],
+        environment: { ...params.environment, ...params.handlers[handler as HandlerName].environment },
+      }).lambdaFunction;
+    });
+  }
+}

package/prefab/compute/function/cron-function/cron-function.ts

@@ -0,0 +1,32 @@
+import { CronOptions, Rule, Schedule } from 'aws-cdk-lib/aws-events';
+import { LambdaFunction } from 'aws-cdk-lib/aws-events-targets';
+import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';
+import { Construct } from 'constructs';
+
+import { ServiceStack, getLogicalName } from '../../../../common';
+import { BaseAggregateParams } from '../base-function';
+import { BaseFunction, BaseHandlerParams } from '../base-function';
+
+export type CronHandlerParams = BaseHandlerParams & {
+  cronOptions: CronOptions;
+};
+
+export type CronFunctionParams = BaseAggregateParams;
+
+export class CronFunction extends Construct {
+  public readonly lambdaFunction: NodejsFunction;
+
+  constructor(service: ServiceStack, params: CronFunctionParams & CronHandlerParams) {
+    super(service, getLogicalName(CronFunction.name, params.name));
+
+    this.lambdaFunction = new BaseFunction(service, {
+      ...params,
+      environment: { ...params.environment, CC_FUNCTION_TYPE: 'CRON' },
+    }).lambdaFunction;
+
+    new Rule(service, getLogicalName('EventProcessorRule', params.name), {
+      schedule: Schedule.cron(params.cronOptions),
+      targets: [new LambdaFunction(this.lambdaFunction)],
+    });
+  }
+}

package/prefab/compute/function/cron-function/index.ts

@@ -0,0 +1,2 @@
+export * from './cron-aggregate';
+export * from './cron-function';

package/prefab/compute/function/event-function/EventAggregateParams.ts

@@ -0,0 +1,9 @@
+import { EventBusPrefab } from '../../../integration';
+import { BaseAggregateParams } from '../base-function';
+import { EventHandlerParams } from './event-function';
+
+export type EventAggregateParams<HandlerName extends string = string> = BaseAggregateParams & {
+  name?: string;
+  handlers: Record<HandlerName, EventHandlerParams>;
+  eventBus: EventBusPrefab;
+};

package/prefab/compute/function/event-function/event-aggregate.ts

@@ -0,0 +1,33 @@
+import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';
+import { Construct } from 'constructs';
+
+import { EventBusPrefab } from '../../../..';
+import { ServiceStack, getLogicalName } from '../../../../common';
+import { BaseAggregateParams } from '../base-function';
+import { EventFunction, EventHandlerParams } from './event-function';
+
+export type EventAggregateParams<HandlerName extends string = string> = BaseAggregateParams & {
+  name?: string;
+  handlers: Record<HandlerName, EventHandlerParams>;
+  eventBus: EventBusPrefab;
+};
+
+export class EventAggregate<HandlerName extends string = string> extends Construct {
+  public readonly handlers: Record<HandlerName, NodejsFunction> = {} as Record<HandlerName, NodejsFunction>;
+
+  constructor(service: ServiceStack, params: EventAggregateParams<HandlerName>) {
+    super(service, getLogicalName(EventAggregate.name, params.name));
+
+    Object.keys(params.handlers).forEach((handler: string) => {
+      this.handlers[handler as HandlerName] = new EventFunction(service, {
+        ...params,
+        ...params.handlers[handler as HandlerName],
+        modifiers: [...(params.modifiers || []), ...(params.handlers[handler as HandlerName].modifiers || [])],
+        environment: {
+          ...params.environment,
+          ...params.handlers[handler as HandlerName].environment,
+        },
+      }).lambdaFunction;
+    });
+  }
+}

package/prefab/compute/function/event-function/event-function.ts

@@ -0,0 +1,42 @@
+import { Rule } from 'aws-cdk-lib/aws-events';
+import { LambdaFunction } from 'aws-cdk-lib/aws-events-targets';
+import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';
+import { Construct } from 'constructs';
+
+import { EventConfig } from '@takumi-stack/sdk';
+
+import { ServiceStack, getLogicalName, getShortResourceName } from '../../../../common';
+import { BaseFunction, BaseAggregateParams, BaseHandlerParams } from '../base-function';
+
+export type EventHandlerParams = BaseHandlerParams & {
+  eventConfig: EventConfig[];
+};
+
+export type EventFunctionParams = BaseAggregateParams;
+export class EventFunction extends Construct {
+  public readonly lambdaFunction: NodejsFunction;
+
+  constructor(service: ServiceStack, params: EventFunctionParams & EventHandlerParams) {
+    super(service, getLogicalName(EventFunction.name, params.name));
+
+    this.lambdaFunction = new BaseFunction(service, {
+      ...params,
+      environment: { ...params.environment, CC_FUNCTION_TYPE: 'EVENT' },
+    }).lambdaFunction;
+
+    const source = params.eventConfig.map((e) => e.source);
+    const detailType = params.eventConfig.map((e) => e.name);
+    const detailRules = params.eventConfig.reduce((memo, e) => ({ ...memo, ...(e.detail || {}) }), {});
+
+    new Rule(service, getLogicalName('EventProcessorRule', params.name), {
+      ruleName: getShortResourceName(params.name, service.props),
+      eventBus: params.eventBus?.bus,
+      eventPattern: {
+        ...(source.filter((e) => !!e).length > 0 ? { source } : {}),
+        ...(detailType.filter((e) => !!e).length > 0 ? { detailType } : {}),
+        ...(Object.keys(detailRules).length > 0 ? { detail: detailRules } : {}),
+      },
+      targets: [new LambdaFunction(this.lambdaFunction)],
+    });
+  }
+}

package/prefab/compute/function/event-function/index.ts

@@ -0,0 +1,2 @@
+export * from './event-aggregate';
+export * from './event-function';

package/prefab/compute/function/index.ts

@@ -0,0 +1,7 @@
+export * from './api-function';
+export * from './base-function';
+export * from './cognito-function';
+export * from './cron-function';
+export * from './event-function';
+export * from './queue-function';
+export * from './topic-function';