@takumi-stack/core 1.0.1 → 1.0.3

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

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

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

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

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

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

@@ -1,117 +0,0 @@
-/* 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

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

@@ -1,29 +0,0 @@
-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/index.ts

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

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

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