leegilmorecode

import * as cdk from 'aws-cdk-lib';

import { Construct } from 'constructs';
import { EnvironmentConfig } from '../pipeline-types/pipeline-types';
import { StatefulStack } from '../../app/stateful/stateful-stack';
import { StatelessStack } from '../../app/stateless/stateless-stack';

// this is our stage made up of multiple stacks which will be deployed to various environments
// based on config i.e. feature-dev, staging, prod, which also includes our application config
export class PipelineStage extends cdk.Stage {

leegilmorecode

import { AppSyncResolverEvent, AppSyncResolverHandler } from "aws-lambda";
import { Customer } from "../../types";
import { HttpRequest } from "@aws-sdk/protocol-http";
import { URL } from "url";
import fetch from "node-fetch";
import { signRequest } from "../../helpers/request-signer";
import { config } from "../../config";

import { v4 as uuid } from "uuid";

leegilmorecode

// create the orders connection for the api destination
    const externalOrdersConnection: events.Connection = new events.Connection(
      this,
      'ExternalOrdersApiDestinationsConnection',
      {
        authorization: events.Authorization.apiKey(
          'x-api-key',
          SecretValue.unsafePlainText('SuperSecretKey!12345') // this is for the demo only
        ),
        description: 'External Orders API Destination Connection',

leegilmorecode

import * as AWS from 'aws-sdk';

import { APIGatewayProxyHandler, APIGatewayProxyResult } from 'aws-lambda';

import axios from 'axios';
import { v4 as uuid } from 'uuid';

const dynamoDb = new AWS.DynamoDB.DocumentClient();

export const handler: APIGatewayProxyHandler = async ({

leegilmorecode

// .. creation of the eventbus above

const sharedEdaApi: apigw.RestApi = new apigw.RestApi(
  this,
  'SharedEdaApi',
  {
    description: 'shared eda api',
    restApiName: 'shared-eda-api',
    deploy: true,
    deployOptions: {

leegilmorecode

import * as AWS from 'aws-sdk';

import { PutEventsRequestEntry } from 'aws-sdk/clients/eventbridge';
import { config } from '@config/config';
import { logger } from '@packages/logger';

class NoEventBodyError extends Error {
  constructor(message: string) {
    super(message);
    this.name = 'NoEventBodyError';

leegilmorecode

import { DomainEvent } from '@entity/domain-event';
import { publishEvent } from '@adapters/secondary/event-adapter';

// this is the repository which the domain calls to utilise the adapter
// only working with domain entities, and translating dto's from the secondary adapters
// domain --> (repository) --> adapter
export async function publishDomainEvents(
  events: DomainEvent[]
): Promise<void> {
  const eventsToPublish: Promise<void>[] = events.map((item) =>

leegilmorecode

import {
  CustomerAccountDto,
  NewCustomerAccountDto,
} from '@dto/customer-account';

import { CustomerAccount } from '@domain/customer-account';
import { createCustomerAccount } from '@repositories/create-customer-account-repository';
import { logger } from '@packages/logger';
import { publishDomainEvents } from '@repositories/publish-event-recipient';

leegilmorecode

import { CustomerAddressDto } from '@dto/customer-address';
import { CustomerAddressProps } from '@models/customer-address-types';
import { ValueObject } from '@entity/value-object';
import { schema } from '@schemas/customer-address';

export class CustomerAddressInvalidError extends Error {
  constructor(message: string) {
    super(message);
    this.name = 'CustomerAddressInvalidError';
  }

leegilmorecode

import { schemaValidator } from '@packages/schema-validator';
interface ValueObjectProps {
  [index: string]: any;
}

export abstract class ValueObject<T extends ValueObjectProps> {
  protected props: T;

  constructor(props: T) {
    this.props = Object.freeze(props);