@takumi-stack/core 1.0.0 → 1.0.1

package/prefab/gateway/alb-public/index.ts

@@ -0,0 +1,124 @@
+import * as awsALB from 'aws-cdk-lib/aws-elasticloadbalancingv2';
+import { Tags } from 'aws-cdk-lib';
+import { ICertificate } from 'aws-cdk-lib/aws-certificatemanager';
+import { ISecurityGroup, IVpc, Peer, Port, SecurityGroup } from 'aws-cdk-lib/aws-ec2';
+import { FargateService } from 'aws-cdk-lib/aws-ecs';
+import { ApplicationListener, ListenerAction, ListenerCondition } from 'aws-cdk-lib/aws-elasticloadbalancingv2';
+import { Construct } from 'constructs';
+
+import { ServiceStack, SynthError, getLogicalName, getResourceName } from '../../../common';
+
+import { CdnApiPrefab } from '../../cdn';
+
+export type PublicAlbPrefabParams = {
+  name: string;
+  vpc: IVpc;
+  certificate: ICertificate;
+  basePath?: string;
+  cdnApiPrefab?: CdnApiPrefab;
+  existingResource?: {
+    albToClusterSG: string;
+    securityGroupId: string;
+    listenerArn: string;
+  };
+};
+
+export class PublicAlbPrefab extends Construct {
+  public readonly alb!: awsALB.ApplicationLoadBalancer;
+  private readonly listener: awsALB.IApplicationListener;
+  private readonly albToClusterSG: ISecurityGroup;
+  private readonly upstreamSG!: ISecurityGroup;
+  private readonly vpc: IVpc;
+  private priorityIndex: number;
+  private service: ServiceStack;
+
+  constructor(service: ServiceStack, params: PublicAlbPrefabParams) {
+    super(service, getLogicalName(PublicAlbPrefab.name));
+
+    this.service = service;
+    this.vpc = params.vpc;
+    this.priorityIndex = 1;
+
+    if (params.existingResource) {
+      this.listener = ApplicationListener.fromApplicationListenerAttributes(this, getLogicalName(params.name, 'listener'), {
+        listenerArn: params.existingResource.listenerArn,
+        securityGroup: SecurityGroup.fromSecurityGroupId(this, 'sg', params.existingResource.securityGroupId),
+      });
+      this.albToClusterSG = SecurityGroup.fromSecurityGroupId(this, 'escSG', params.existingResource.albToClusterSG);
+      return this;
+    }
+
+    // UPSTREAM SECURITY GROUP
+    this.upstreamSG = new SecurityGroup(this, getLogicalName(params.name, 'sg'), {
+      securityGroupName: getResourceName('upstream', service.props),
+      vpc: params.vpc,
+      allowAllOutbound: true,
+    });
+    Tags.of(this.upstreamSG).add('Name', getResourceName('upstream', service.props));
+    this.upstreamSG.addIngressRule(Peer.anyIpv4(), Port.tcp(443), 'Allow https traffic');
+
+    // ALB
+    this.alb = new awsALB.ApplicationLoadBalancer(this, getLogicalName(params.name, 'alb'), {
+      loadBalancerName: getResourceName('', { ...this.service.props, serviceName: params.name }),
+      vpc: params.vpc,
+      vpcSubnets: { subnets: params.vpc.publicSubnets },
+      internetFacing: true,
+      securityGroup: this.upstreamSG,
+    });
+
+    // INBOUND
+    this.listener = this.alb.addListener(getLogicalName(params.name, 'listener'), {
+      open: true,
+      protocol: awsALB.ApplicationProtocol.HTTPS,
+      port: 443,
+      certificates: [params.certificate],
+      defaultAction: ListenerAction.fixedResponse(404, { messageBody: 'MissingPath' }),
+    });
+    // this.alb.addSecurityGroup(this.sg), getResourceName('upstream', service.props);
+
+    this.albToClusterSG = new SecurityGroup(this, getLogicalName(params.name, 'escSG'), {
+      securityGroupName: getResourceName('downstream', service.props),
+      vpc: params.vpc,
+      allowAllOutbound: true,
+    });
+    this.albToClusterSG.connections.allowFrom(this.upstreamSG, Port.allTcp(), 'Outbound traffic from ALB to Cluster');
+    Tags.of(this.albToClusterSG).add('Name', getResourceName('downstream', service.props));
+
+    // ADD PATH TO CDN DISTRIBUTION
+    if (params.cdnApiPrefab) {
+      if (!params.basePath) throw new SynthError('basePath is required when cdnApi is enabled');
+      params.cdnApiPrefab.addAlb(params.basePath, this.alb);
+    }
+  }
+  private getNextPriorityIndex(): number {
+    return this.priorityIndex++;
+  }
+  public getAlbToClusterSG(): ISecurityGroup {
+    return this.albToClusterSG;
+  }
+  public appendTargetGroup({ name, basePath, mappingPort, fargateService, healthCheckPath, fixedPriority }: AppendTargetGroup): void {
+    const targetGroup = new awsALB.ApplicationTargetGroup(this, getLogicalName(name, 'targetGroup'), {
+      targetGroupName: getResourceName('', { ...this.service.props, serviceName: name }),
+      port: mappingPort,
+      vpc: this.vpc,
+      protocol: awsALB.ApplicationProtocol.HTTP,
+      healthCheck: { protocol: awsALB.Protocol.HTTP, path: healthCheckPath },
+      targets: [fargateService.loadBalancerTarget({ containerName: name, containerPort: mappingPort })],
+    });
+
+    this.listener.addTargetGroups(getLogicalName(name, 'listenerTG'), {
+      targetGroups: [targetGroup],
+      conditions: [ListenerCondition.pathPatterns([`${basePath}*`])],
+      priority: fixedPriority || this.getNextPriorityIndex(),
+    });
+  }
+}
+
+export type AppendTargetGroup = {
+  name: string;
+  basePath: string;
+  mappingPort: number;
+  fargateService: FargateService;
+  healthCheckPath: string;
+  fixedPriority?: number;
+};

package/prefab/gateway/api-gateway/api-http.ts

@@ -0,0 +1,71 @@
+import { CfnOutput, Duration, Fn } from 'aws-cdk-lib';
+import { CorsHttpMethod, HttpApi, HttpMethod, IHttpRouteAuthorizer } from 'aws-cdk-lib/aws-apigatewayv2';
+import { HttpUserPoolAuthorizer, HttpLambdaAuthorizer, HttpLambdaResponseType } from 'aws-cdk-lib/aws-apigatewayv2-authorizers';
+import { HttpLambdaIntegration } from 'aws-cdk-lib/aws-apigatewayv2-integrations';
+import { UserPool, UserPoolClient } from 'aws-cdk-lib/aws-cognito';
+import { IFunction } from 'aws-cdk-lib/aws-lambda';
+import { Construct } from 'constructs';
+
+import { ApiDefinition, ApiInterface } from '@takumi-stack/sdk';
+
+import { ServiceStack, getLogicalName, getResourceName } from '../../../common';
+import { CdnApiPrefab } from '../../cdn';
+
+export type ApiHttPrefabParams = {
+  basePath: string;
+  cdnApiPrefab?: CdnApiPrefab;
+  userPool?: UserPool;
+  userPoolClient?: UserPoolClient;
+  customAuthorizerHandler?: IFunction;
+};
+
+export class ApiHttpPrefab extends Construct {
+  public readonly api: HttpApi;
+  public readonly authorizer!: IHttpRouteAuthorizer;
+
+  constructor(service: ServiceStack, params: ApiHttPrefabParams) {
+    super(service, getLogicalName(ApiHttpPrefab.name));
+
+    if (params.userPool && params.userPoolClient)
+      this.authorizer = new HttpUserPoolAuthorizer('Authorizer', params.userPool, {
+        userPoolClients: [params.userPoolClient],
+        identitySource: ['$request.header.Authorization'],
+      });
+
+    if (params.customAuthorizerHandler)
+      this.authorizer = new HttpLambdaAuthorizer('LambdaAuthorizer', params.customAuthorizerHandler, {
+        responseTypes: [HttpLambdaResponseType.SIMPLE],
+      });
+
+    this.api = new HttpApi(this, 'HttpApi', {
+      apiName: getResourceName('', service.props),
+      corsPreflight: {
+        allowOrigins: ['*'],
+        allowMethods: [CorsHttpMethod.ANY],
+        allowHeaders: ['*'],
+        maxAge: Duration.seconds(10),
+      },
+    });
+
+    const apiUrl: string = Fn.join('', [this.api.apiId, '.execute-api.', service.props.regionName, '.amazonaws.com']);
+
+    params.cdnApiPrefab?.addApiGateway(params.basePath, apiUrl);
+
+    new CfnOutput(this, 'ApiUrl', { value: apiUrl });
+  }
+  public addPath(params: {
+    basePath: string;
+    path: string;
+    method: ApiDefinition<ApiInterface>['method'];
+    lambdaFunction: IFunction;
+    isPublic?: true;
+  }): void {
+    const path = params.path === '/' ? '' : params.path;
+    this.api.addRoutes({
+      path: `/${params.basePath}${path}`,
+      methods: [params.method as HttpMethod],
+      integration: new HttpLambdaIntegration(params.lambdaFunction.functionName, params.lambdaFunction),
+      ...(params.isPublic ? {} : { authorizer: this.authorizer }),
+    });
+  }
+}

package/prefab/gateway/api-gateway/api-rest.ts

@@ -0,0 +1,93 @@
+import * as awsApigateway from 'aws-cdk-lib/aws-apigateway';
+import { CfnOutput, Fn } from 'aws-cdk-lib';
+import { UserPool } from 'aws-cdk-lib/aws-cognito';
+import { IFunction } from 'aws-cdk-lib/aws-lambda';
+import { Construct } from 'constructs';
+
+import { ServiceStack, getLogicalName, getResourceName } from '../../../common';
+import { CdnApiPrefab } from '../../cdn';
+
+export type ApiRestPrefabParams = {
+  basePath: string;
+  cdnApiPrefab?: CdnApiPrefab;
+  userPool?: UserPool;
+  customAuthorizerHandler?: IFunction;
+  stageName?: string;
+  stageVariables?: Record<string, string>;
+  httpProxyIntegrationUrl?: string;
+  apiKeyRequired?: boolean;
+};
+
+export class ApiRestPrefab extends Construct {
+  public readonly api: awsApigateway.RestApi;
+  public readonly authorizer!: awsApigateway.IAuthorizer;
+  public readonly basePath: awsApigateway.Resource;
+
+  constructor(service: ServiceStack, params: ApiRestPrefabParams) {
+    super(service, getLogicalName(ApiRestPrefab.name));
+
+    if (params.userPool) {
+      this.authorizer = new awsApigateway.CognitoUserPoolsAuthorizer(this, 'Authorizer', {
+        cognitoUserPools: [params.userPool],
+      });
+    }
+
+    if (params.customAuthorizerHandler) {
+      this.authorizer = new awsApigateway.RequestAuthorizer(this, 'LambdaAuthorizer', {
+        identitySources: ['$request.header.Authorization'],
+        handler: params.customAuthorizerHandler,
+      });
+    }
+
+    this.api = new awsApigateway.RestApi(this, 'RestApi', {
+      restApiName: getResourceName('', service.props),
+      deploy: true,
+      deployOptions: {
+        tracingEnabled: true,
+        stageName: params.stageName || 'default',
+        variables: params.stageVariables,
+      },
+      defaultCorsPreflightOptions: {
+        allowOrigins: awsApigateway.Cors.ALL_ORIGINS,
+      },
+    });
+
+    const apiUrl: string = Fn.join('', [this.api.restApiId, '.execute-api.', service.props.regionName, '.amazonaws.com']);
+
+    this.basePath = this.api.root.resourceForPath(params.basePath);
+
+    if (params.httpProxyIntegrationUrl) {
+      const proxy = this.basePath.addProxy({ anyMethod: false });
+
+      proxy.addMethod(
+        'ANY',
+        new awsApigateway.HttpIntegration(params.httpProxyIntegrationUrl, {
+          httpMethod: 'ANY',
+          proxy: true,
+          options: { requestParameters: { 'integration.request.path.proxy': 'method.request.path.proxy' } },
+        }),
+        { requestParameters: { 'method.request.path.proxy': true }, apiKeyRequired: params.apiKeyRequired }
+      );
+      // I'm sorry for this, but there isn't a better way to do this...
+      this.api.methods
+        .filter((method) => method.httpMethod === 'OPTIONS')
+        .forEach((m) => {
+          proxy.node.tryRemoveChild(m.node.id);
+        });
+
+      proxy.addCorsPreflight({
+        allowOrigins: ['*'],
+        allowHeaders: ['*'],
+        allowMethods: awsApigateway.Cors.ALL_METHODS,
+        statusCode: 204,
+      });
+    }
+
+    if (params.cdnApiPrefab)
+      params.cdnApiPrefab.addApiGateway(params.basePath, apiUrl, {
+        originPath: `/${this.api.deploymentStage.stageName}`,
+      });
+
+    new CfnOutput(this, 'RestApiUrl', { value: apiUrl });
+  }
+}

package/prefab/gateway/api-gateway/index.ts

@@ -0,0 +1,2 @@
+export * from './api-http';
+export * from './api-rest';

package/prefab/gateway/app-sync/index.ts

@@ -0,0 +1,117 @@
+/* eslint-disable @typescript-eslint/ban-types */
+import 'reflect-metadata';
+
+import * as appsync from 'aws-cdk-lib/aws-appsync';
+import { CfnOutput } from 'aws-cdk-lib';
+import { ICertificate } from 'aws-cdk-lib/aws-certificatemanager';
+import { UserPool } from 'aws-cdk-lib/aws-cognito';
+import { RetentionDays } from 'aws-cdk-lib/aws-logs';
+import { CnameRecord, HostedZone } from 'aws-cdk-lib/aws-route53';
+import { Construct } from 'constructs';
+
+import { log } from 'console';
+import path from 'path';
+import { buildSchemaSync, NonEmptyArray } from 'type-graphql';
+
+import { ServiceStack, getLogicalName, SynthError, getDomain, getResourceName } from '../../../common';
+import { CdnApiPrefab } from '../../cdn';
+import { EventBusPrefab } from '../../integration';
+
+export type AppSyncPrefabParams = {
+  name: string;
+  baseFolder: string;
+  schemas: NonEmptyArray<Function>;
+  eventBusPrefab?: EventBusPrefab;
+  userPool?: UserPool;
+  cdnApiPrefab?: CdnApiPrefab;
+  domainConfig?: {
+    certificate: ICertificate;
+    subdomain: string;
+  };
+};
+
+export class AppSyncPrefab extends Construct {
+  public api: appsync.GraphqlApi;
+  public eventBridgeDataSource!: EventBridgeDataSource;
+  public schemas: NonEmptyArray<Function>;
+
+  constructor(service: ServiceStack, params: AppSyncPrefabParams) {
+    super(service, getLogicalName(AppSyncPrefab.name));
+
+    if (params.cdnApiPrefab && params.domainConfig) throw new SynthError('Cannot use cdnApi and custom domain at the same time');
+
+    this.schemas = params.schemas;
+
+    const defaultAuthorization: appsync.AuthorizationMode = params.userPool
+      ? {
+          authorizationType: appsync.AuthorizationType.USER_POOL,
+          userPoolConfig: { userPool: params.userPool },
+        }
+      : { authorizationType: appsync.AuthorizationType.API_KEY };
+
+    const domainConfig: appsync.GraphqlApiProps['domainName'] = params.domainConfig
+      ? {
+          certificate: params.domainConfig.certificate,
+          domainName: getDomain(params.domainConfig.subdomain, service.props),
+        }
+      : undefined;
+
+    log('<< Building GraphQL Schema >>');
+    const schemaPath = path.join(params.baseFolder, 'consolidated.graphql');
+    buildSchemaSync({
+      resolvers: this.schemas as NonEmptyArray<Function>,
+      emitSchemaFile: schemaPath,
+    });
+    log('<< GraphQL Schema Built >>');
+
+    this.api = new appsync.GraphqlApi(this, 'Api', {
+      name: getResourceName('', service.props),
+      schema: appsync.SchemaFile.fromAsset(schemaPath),
+      authorizationConfig: { defaultAuthorization },
+      domainName: domainConfig,
+      logConfig: {
+        fieldLogLevel: appsync.FieldLogLevel.ALL,
+        retention: RetentionDays.ONE_MONTH,
+      },
+    });
+
+    if (params.eventBusPrefab) {
+      this.eventBridgeDataSource = new EventBridgeDataSource(service, 'EventBridgeDataSource', {
+        name: 'EventBridgeDataSource',
+        api: this.api,
+      });
+      appsync.CfnDataSource;
+      const cfDs = this.eventBridgeDataSource.node.defaultChild as appsync.CfnDataSource;
+      cfDs.eventBridgeConfig = { eventBusArn: params.eventBusPrefab.bus.eventBusArn };
+      params.eventBusPrefab.bus.grantPutEventsTo(this.eventBridgeDataSource);
+    }
+
+    if (params.domainConfig) {
+      const hostedZone = HostedZone.fromLookup(this, 'HostedZoneEnvDns', {
+        domainName: getDomain('', service.props),
+      });
+      new CnameRecord(service, 'Record', {
+        zone: hostedZone,
+        recordName: domainConfig?.domainName,
+        domainName: this.api.appSyncDomainName,
+      });
+    }
+    if (params.cdnApiPrefab) {
+      params.cdnApiPrefab.addAppSync(this.api.graphqlUrl);
+    }
+    new CfnOutput(this, 'Domain', { value: domainConfig?.domainName || this.api.graphqlUrl });
+  }
+
+  // addSchema(schema: Function) {
+  //   if (!this.schemas) this.schemas = [];
+  //   this.schemas.push(schema);
+  // }
+}
+
+export class EventBridgeDataSource extends appsync.BackedDataSource {
+  constructor(scope: Construct, id: string, props: appsync.BackedDataSourceProps) {
+    super(scope, id, props, {
+      type: 'AMAZON_EVENTBRIDGE',
+    });
+  }
+}

package/prefab/gateway/app-sync/resolver-aggregate.ts

@@ -0,0 +1,138 @@
+import * as appsync from 'aws-cdk-lib/aws-appsync';
+import { BaseDataSource } from 'aws-cdk-lib/aws-appsync';
+import { Construct } from 'constructs';
+
+import * as esbuild from 'esbuild';
+import { readFileSync, writeFileSync } from 'fs';
+
+import { AppSyncPrefab } from '.';
+import { ServiceStack, getLogicalName, capFirstLetter, toDashCase } from '../../../common';
+import { DynamoTablePrefab } from '../../database';
+import { FunctionResolver } from './types';
+
+type Resolver = {
+  typeName: string;
+  resolversPipeline?: { name: string; dataSource?: BaseDataSource }[];
+  env?: Record<string, string>;
+};
+
+export type AppSyncResolverAggregateParams<T> = {
+  appSyncPrefab: AppSyncPrefab;
+  baseApiFolder: string;
+  tablePrefab: DynamoTablePrefab;
+  resolvers: Record<MethodNames<T>, Resolver>;
+};
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+type MethodNames<T> = { [K in keyof T]: T[K] extends Function ? K : never }[keyof T];
+
+export class AppSyncResolverAggregate<T> extends Construct {
+  public readonly api!: appsync.GraphqlApi;
+  public readonly baseApiFolder!: string;
+
+  constructor(service: ServiceStack, params: AppSyncResolverAggregateParams<T>) {
+    super(service, getLogicalName(AppSyncResolverAggregate.name));
+    const { appSyncPrefab, baseApiFolder, resolvers, tablePrefab } = params;
+
+    const dataSource = new appsync.DynamoDbDataSource(service, getLogicalName('dynamoDataSource', tablePrefab.tableName), {
+      api: appSyncPrefab.api,
+      table: tablePrefab.table,
+      name: `${tablePrefab.tableName}TableDataSource`,
+    });
+
+    Object.keys(resolvers).map((r) => {
+      const fieldName = r;
+      const resolver = resolvers[r as MethodNames<T>];
+      const fnPipeline =
+        resolver.resolversPipeline && resolver.resolversPipeline.length > 1
+          ? resolver.resolversPipeline.map((rp) =>
+              this.functionResolver(service, {
+                api: appSyncPrefab.api,
+                baseApiFolder,
+                dataSource: rp.dataSource || dataSource,
+                fieldName: fieldName,
+                resolverName: rp.name,
+                env: resolver.env,
+              })
+            )
+          : [
+              this.functionResolver(service, {
+                api: appSyncPrefab.api,
+                dataSource,
+                baseApiFolder,
+                fieldName: fieldName,
+                env: resolver.env,
+              }),
+            ];
+
+      // PipelineResolver
+      new appsync.Resolver(service, getLogicalName('pipeline', fieldName), {
+        api: appSyncPrefab.api,
+        typeName: resolver.typeName,
+        fieldName: fieldName,
+        pipelineConfig: fnPipeline,
+        code: appsync.Code.fromInline(`
+          // The before step
+          export function request() {
+            return {};
+          }
+
+          // The after step
+          export function response(ctx) {
+            return ctx.prev.result;
+          }
+        `),
+        runtime: appsync.FunctionRuntime.JS_1_0_0,
+      });
+    });
+  }
+
+  addDynamoTableDataSource = (tablePrefab: DynamoTablePrefab): appsync.DynamoDbDataSource => {
+    return this.api.addDynamoDbDataSource(tablePrefab.tableName, tablePrefab.table, {
+      name: `${tablePrefab.tableName}TableDataSource`,
+    });
+  };
+
+  functionResolver = (service: ServiceStack, params: FunctionResolver): appsync.AppsyncFunction => {
+    return new appsync.AppsyncFunction(
+      service,
+      getLogicalName('function', params.resolverName ? `${params.fieldName}${params.resolverName}` : params.fieldName),
+      {
+        api: params.api,
+        dataSource: params.dataSource,
+        name: params.resolverName ? `${params.fieldName}${capFirstLetter(params.resolverName)}` : params.fieldName,
+        code: bundleAppSyncResolver(params.baseApiFolder, params.fieldName, params.resolverName, params.env),
+        runtime: appsync.FunctionRuntime.JS_1_0_0,
+      }
+    );
+  };
+}
+const bundleAppSyncResolver = (
+  baseApiFolder: string,
+  fieldName: string,
+  resolverName = 'index',
+  env: Record<string, string> | undefined
+): appsync.Code => {
+  const outFile = `cdk.out/resolvers/${toDashCase(fieldName)}/${resolverName}.js`;
+  esbuild.buildSync({
+    entryPoints: [`${baseApiFolder}/resolvers/${toDashCase(fieldName)}/${resolverName}.ts`],
+    external: ['@aws-appsync/utils'],
+    allowOverwrite: true,
+    outfile: outFile,
+    bundle: true,
+    write: true,
+    platform: 'node',
+    target: 'esnext',
+    format: 'esm',
+    sourcesContent: false,
+    // minify: true,
+  });
+  if (Object.keys(env || {}).length > 0) {
+    let mappedFile = readFileSync(outFile, 'utf8');
+    for (const [key, value] of Object.entries(env || {})) {
+      mappedFile = mappedFile.replace(new RegExp(key, 'gi'), value);
+    }
+    writeFileSync(outFile, mappedFile);
+  }
+  return appsync.Code.fromAsset(outFile);
+};

package/prefab/gateway/app-sync/types.ts

@@ -0,0 +1,29 @@
+import { BaseDataSource, GraphqlApi } from 'aws-cdk-lib/aws-appsync';
+
+import { DynamoTablePrefab } from '../../database';
+import { EventBusPrefab } from '../../integration';
+
+export type EventBridgeDataSourceParams = {
+  api: GraphqlApi;
+  eventBusPrefab: EventBusPrefab;
+};
+
+export type ServiceResolver = {
+  api: GraphqlApi;
+  baseApiFolder: string;
+  tablePrefab: DynamoTablePrefab;
+  resolvers: {
+    fieldName: string;
+    typeName: 'Mutation' | 'Query' | 'Subscription';
+    resolversPipeline?: { name: string; dataSource?: BaseDataSource }[];
+  }[];
+};
+
+export type FunctionResolver = {
+  fieldName: string;
+  resolverName?: string;
+  baseApiFolder: string;
+  api: GraphqlApi;
+  dataSource: BaseDataSource;
+  env?: Record<string, string>;
+};

package/prefab/gateway/index.ts

@@ -0,0 +1,3 @@
+export * from './alb-public';
+export * from './api-gateway';
+export * from './app-sync';

package/prefab/index.ts

@@ -0,0 +1,10 @@
+export * from './analytics';
+export * from './auth';
+export * from './cdn';
+export * from './compute';
+export * from './database';
+export * from './gateway';
+export * from './integration';
+export * from './networking';
+export * from './storage';
+export * from './utils';

package/prefab/integration/event-bus/index.ts

@@ -0,0 +1,52 @@
+import { EventBus, IEventBus } from 'aws-cdk-lib/aws-events';
+import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';
+import { Construct } from 'constructs';
+
+import { ServiceStack, getLogicalName, getResourceName, Modifier } from '../../../common';
+
+export type EventBusPrefabParams = {
+  defaultEventBus?: true;
+};
+export class EventBusPrefab extends Construct {
+  public readonly bus: IEventBus;
+
+  constructor(service: ServiceStack, params?: EventBusPrefabParams) {
+    super(service, getLogicalName(EventBusPrefab.name));
+
+    if (params?.defaultEventBus) {
+      this.bus = EventBus.fromEventBusName(service, 'DefaultEventBus', 'default');
+    } else {
+      this.bus = new EventBus(this, 'bus', { eventBusName: getResourceName('', service.props) });
+    }
+  }
+
+  // Mods
+  public useMod(variableName = 'EVENT_BUS', mods: ((bus: IEventBus) => any)[]): Modifier {
+    return (lambda) => {
+      lambda.addEnvironment(variableName, this.bus.eventBusName);
+      mods.map((fn) => fn(this.bus)(lambda));
+    };
+  }
+
+  // Class Mods
+  public static modifier = {
+    writer: (bus: IEventBus): Modifier => {
+      return (lambda) => {
+        bus.grantPutEventsTo(lambda);
+      };
+    },
+  };
+
+  // Instance Mods
+  public useModWriter(variableName = 'EVENT_BUS'): Modifier {
+    return this.useMod(variableName, [EventBusPrefab.modifier.writer]);
+  }
+
+  // addBus is used inside aggregates in order to apply permissions if EventBus is there.
+  public static addBus(lambdaFunction: NodejsFunction, eventBus?: IEventBus): void {
+    if (eventBus instanceof EventBus) {
+      eventBus.grantPutEventsTo(lambdaFunction);
+      lambdaFunction.addEnvironment('EVENT_BUS', eventBus.eventBusName);
+    }
+  }
+}

package/prefab/integration/index.ts

@@ -0,0 +1,3 @@
+export * from './event-bus';
+export * from './queue';
+export * from './topic';