@takumi-stack/core 1.0.1 → 1.0.2

package/prefab/compute/fargate/cluster.ts

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

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

package/prefab/compute/fargate/service.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/prefab/compute/function/index.ts

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