feat: loyalty program

examples/loyalty-payments/.gitignore

@@ -0,0 +1,5 @@
+lib
+node_modules
+cdk.out
+.eventual
+*.tsbuildinfo

examples/loyalty-payments/README.md

@@ -0,0 +1,71 @@
+# Welcome to your Eventual Project
+
+## Project Structure
+The following folder structure will be generated. 
+```bash
+├──infra # an AWS CDK application that deploys the repo's infrastructure
+├──packages
+    ├──service # the NPM package containing the my-service business logic
+```
+
+### `infra`
+
+This is where you control what infrastructure is deployed with your Service, for example adding DynamoDB Tables, SQS Queues, or other stateful Resources.
+
+### `packages/service`
+
+This is where you add business logic such as APIs, Event handlers, Workflows and Tasks.
+
+## Deployed Infrastructure
+
+After deploying to AWS, you'll have a single stack named `loyalty-payments` containing your Service. Take a look at the structure using the Resources view in CloudFormation. Here, you can find a list of all the Lambda Functions and other Resources that come with a Service.
+
+See the [Service documentation](https://docs.eventual.ai/reference/service) for more information.
+
+## Scripts
+
+The root `package.json` contains some scripts for your convenience.
+
+### Build
+
+The `build` script compiles all TypeScript (`.ts`) files in each package's `src/` directory and emits the compiled output in the corresponding `lib/` folder.
+
+```
+pnpm build
+```
+
+### Test
+
+The `test` script runs `jest` in all sub-packages. Check out the packages/service package for example tests.
+
+```
+pnpm test
+```
+
+### Watch
+
+The `watch` script run the typescript compiler in the background and re-compiles `.ts` files whenever they are changed.
+```
+pnpm watch
+```
+
+### Synth
+
+The `synth` script synthesizes the CDK application in the `infra/` package. 
+```
+pnpm synth
+```
+
+### Deploy
+
+The `deploy` script synthesizes and deploys the CDK application in the `infra/` package to AWS.
+```
+pnpm run deploy
+```
+
+### Hotswap
+
+The `hotswap` script synthesizes and deploys the CDK application in the `infra/` package to AWS using `cdk deploy --hotswap` which can bypass a slow CloudFormation deployment in cases where only the business logic in a Lambda Function has changed.
+```
+pnpm run deploy
+```

examples/loyalty-payments/eventual.json

@@ -0,0 +1,5 @@
+{
+  "projectType": "aws-cdk",
+  "synth": "pnpm synth",
+  "deploy": "pnpm run deploy --require-approval never"
+}

examples/loyalty-payments/infra/cdk.json

@@ -0,0 +1,3 @@
+{
+  "app": "ts-node ./src/app.ts"
+}

examples/loyalty-payments/infra/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "infra",
+  "version": "0.0.0",
+  "scripts": {
+    "synth": "cdk synth",
+    "deploy": "cdk deploy",
+    "test": "echo no-op"
+  },
+  "dependencies": {
+    "@aws-cdk/aws-apigatewayv2-alpha": "^2.50.0-alpha.0",
+    "@aws-cdk/aws-apigatewayv2-authorizers-alpha": "^2.50.0-alpha.0",
+    "@aws-cdk/aws-apigatewayv2-integrations-alpha": "^2.50.0-alpha.0",
+    "@eventual/aws-cdk": "^0.39.8",
+    "aws-cdk-lib": "^2.50.0",
+    "aws-cdk": "^2.50.0",
+    "constructs": "^10",
+    "esbuild": "^0.16.14",
+    "@loyalty-payments/service": "workspace:^"
+  },
+  "devDependencies": {
+    "@types/node": "^18",
+    "aws-cdk": "^2.50.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.9.4"
+  }
+}

examples/loyalty-payments/infra/src/app.ts

@@ -0,0 +1,12 @@
+import { App, Stack, CfnOutput } from "aws-cdk-lib";
+import { Service } from "@eventual/aws-cdk";
+
+const app = new App();
+const stack = new Stack(app, "loyalty-payments")
+
+import type * as loyaltypayments from "@loyalty-payments/service"
+
+const service = new Service<typeof loyaltypayments>(stack, "Service", {
+  name: "loyalty-payments",
+  entry: require.resolve("@loyalty-payments/service")
+});

examples/loyalty-payments/infra/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../tsconfig.base.json",
+  "include": [
+    "src"
+  ],
+  "compilerOptions": {
+    "outDir": "lib",
+    "rootDir": "src",
+    "module": "CommonJS",
+    "moduleResolution": "Node"
+  },
+  "references": [
+    {
+      "path": "../packages/service"
+    }
+  ]
+}

examples/loyalty-payments/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "loyalty-payments",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "build": "tsc -b",
+    "test": "NODE_OPTIONS=--experimental-vm-modules pnpm -r run test",
+    "watch": "tsc -b -w",
+    "synth": "tsc -b && pnpm --filter infra synth",
+    "deploy": "tsc -b && pnpm --filter infra run deploy",
+    "hotswap": "tsc -b && pnpm --filter infra run deploy --hotswap"
+  },
+  "devDependencies": {
+    "@eventual/cli": "^0.39.8",
+    "@tsconfig/node18": "^1",
+    "@types/jest": "^29",
+    "@types/node": "^18",
+    "esbuild": "^0.16.14",
+    "typescript": "^5"
+  }
+}

examples/loyalty-payments/packages/service/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@loyalty-payments/service",
+  "type": "module",
+  "main": "lib/index.js",
+  "module": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "version": "0.0.0",
+  "scripts": {
+    "test": "jest --passWithNoTests"
+  },
+  "dependencies": {
+    "@eventual/core": "^0.39.8",
+    "zod": "^3.21.4",
+    "jsonwebtoken": "^9.0.0",
+    "uuid": "^9.0.0"
+  },
+  "devDependencies": {
+    "@types/jsonwebtoken": "9.0.2",
+    "@types/uuid": "^9.0.1",
+    "@eventual/testing": "^0.39.8",
+    "esbuild": "^0.16.14",
+    "jest": "^29",
+    "ts-jest": "^29",
+    "typescript": "^4.9.4"
+  },
+  "jest": {
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.js$": "$1"
+    },
+    "transform": {
+      "^.+\\.(t|j)sx?$": [
+        "ts-jest",
+        {
+          "tsconfig": "tsconfig.test.json",
+          "useESM": true
+        }
+      ]
+    }
+  }
+}

examples/loyalty-payments/packages/service/src/auth.ts

@@ -0,0 +1,56 @@
+import {
+  CommandContext,
+  HttpError,
+  MiddlewareInput,
+  api,
+} from "@eventual/core";
+
+import jwt, { JwtPayload } from "jsonwebtoken";
+import { User } from "./data.js";
+
+const mySecret = "my-secret";
+
+export interface AuthorizedContext {
+  user: User;
+}
+
+export const authorized = api.use(authorizeJWT);
+
+export async function authorizeJWT<In extends CommandContext>({
+  request,
+  next,
+  context,
+}: MiddlewareInput<In>) {
+  const auth = request.headers.get("Authorization");
+  if (!auth) {
+    throw new HttpError({
+      code: 401,
+      message: "Expected Authorization header to be preset.",
+    });
+  }
+  const [prefix, token] = auth.split(" ");
+  if (prefix?.toLowerCase() !== "Bearer") {
+    throw new HttpError({
+      code: 400,
+      message: "Token is not valid, must be in the form 'Bearer [token]'.",
+    });
+  }
+
+  const jwtPayload = jwt.verify(token, mySecret) as JwtPayload;
+  const user = await User.get({
+    userId: jwtPayload.iss!,
+  });
+  if (user === undefined) {
+    throw new HttpError({
+      code: 401,
+      message: `Unauthorized`,
+    });
+  }
+
+  return next({
+    ...context,
+    // put the JWT token and user record in the context for commands to access
+    jwt: jwtPayload,
+    user,
+  });
+}

examples/loyalty-payments/packages/service/src/create-award.ts

@@ -0,0 +1,91 @@
+import { time, transaction, workflow } from "@eventual/core";
+import { v4 as uuid } from "uuid";
+import { Award, User } from "./data.js";
+
+export const createAward = transaction(
+  "createAward",
+  async (input: {
+    awardId: string;
+    userId: string;
+    amount: number;
+    expiry?: string;
+    currency: string;
+  }) => {
+    const awardId = uuid();
+    const user = await User.get({
+      userId: input.userId,
+    });
+
+    await Award.set({
+      awardId,
+      userId: input.userId,
+      amount: input.amount,
+      awardTime: new Date().toISOString(),
+      company: "TODO",
+      currency: input.currency,
+      expired: false,
+    });
+
+    await User.set({
+      ...user,
+      credits: {
+        ...user.credits,
+        [input.currency]: (user.credits[input.currency] ?? 0) + input.amount,
+      },
+    });
+  }
+);
+
+// every time an Award is created, start a workflow to track it, e.g. expire it
+export const onAwardCreated = Award.stream(
+  "onAwardCreated",
+  {
+    operations: ["insert"],
+  },
+  async (event) => {
+    if (event.operation === "insert") {
+      await awardPointsWorkflow.startExecution({
+        executionName: event.newValue.awardId,
+        input: event.newValue,
+      });
+    }
+  }
+);
+
+export const awardPointsWorkflow = workflow(
+  "awardPoints",
+  async (input: {
+    awardId: string;
+    userId: string;
+    amount: number;
+    expiry?: string;
+    currency: string;
+  }) => {
+    if (input.expiry) {
+      // wait until the time it expires
+      await time(input.expiry);
+
+      // then expire it
+      await expireAward(input.awardId);
+    }
+  }
+);
+
+/**
+ * Use a Transaction to atomically get/set the Award record to expire it
+ */
+export const expireAward = transaction(
+  "expireAward",
+  async (awardId: string) => {
+    const award = await Award.get({
+      awardId,
+    });
+
+    if (!award.expired) {
+      Award.set({
+        ...award,
+        expired: true,
+      });
+    }
+  }
+);