@lafken/state-machine 0.10.1

package/lib/resolver/state-machine/schema/schema.utils.d.ts

@@ -0,0 +1,15 @@
+import { LambdaHandler } from '@lafken/resolver';
+import type { ExecutionSource, IntegrationMode, StateMachineSource, StateSource, TaskSource } from '../../../main';
+export declare const mapSourceExecution: Record<ExecutionSource, string>;
+export declare const mapSourceStateMachine: Record<StateMachineSource, string>;
+export declare const mapSourceState: Record<StateSource, string>;
+export declare const mapSourceTask: Record<TaskSource, string>;
+export declare const mapIntegrationMode: Record<IntegrationMode, string>;
+export declare class StateNames {
+    private nameCount;
+    createName(name: string): string;
+}
+export declare class LambdaStates {
+    private lambdas;
+    createLambda([scope, id, props]: ConstructorParameters<typeof LambdaHandler>): LambdaHandler;
+}

package/lib/resolver/state-machine/schema/schema.utils.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LambdaStates = exports.StateNames = exports.mapIntegrationMode = exports.mapSourceTask = exports.mapSourceState = exports.mapSourceStateMachine = exports.mapSourceExecution = void 0;
+const resolver_1 = require("@lafken/resolver");
+exports.mapSourceExecution = {
+    id: 'Id',
+    name: 'Name',
+    role_arn: 'RoleArn',
+    redrive_count: 'RedriveCount',
+    redrive_time: 'RedriveTime',
+    start_time: 'StartTime',
+};
+exports.mapSourceStateMachine = {
+    id: 'Id',
+    name: 'Name',
+};
+exports.mapSourceState = {
+    entered_time: 'EnteredTime',
+    retry_count: 'Name',
+    name: 'Name',
+};
+exports.mapSourceTask = {
+    token: 'Token',
+};
+exports.mapIntegrationMode = {
+    token: 'waitForTaskToken',
+    sync: 'sync:2',
+    async: 'async',
+};
+class StateNames {
+    nameCount = {};
+    createName(name) {
+        this.nameCount[name] ??= 0;
+        this.nameCount[name]++;
+        if (this.nameCount[name] === 1) {
+            return name;
+        }
+        return `${name}-${this.nameCount[name]}`;
+    }
+}
+exports.StateNames = StateNames;
+class LambdaStates {
+    lambdas = {};
+    createLambda([scope, id, props]) {
+        if (this.lambdas[id]) {
+            return this.lambdas[id];
+        }
+        const lambda = new resolver_1.LambdaHandler(scope, id, props);
+        this.lambdas[id] = lambda;
+        return lambda;
+    }
+}
+exports.LambdaStates = LambdaStates;

package/lib/resolver/state-machine/state-machine.d.ts

@@ -0,0 +1,19 @@
+import { SfnStateMachine } from '@cdktn/provider-aws/lib/sfn-state-machine';
+import { type AppModule } from '@lafken/resolver';
+import type { StateMachineProps } from './state-machine.types';
+declare const StateMachine_base: (new (...args: any[]) => {
+    isGlobal(module: import("@lafken/common").ModuleGlobalReferenceNames | (string & {}), id: string): void;
+    isDependent(resolveDependency: () => void): void;
+    readonly node: import("constructs").Node;
+    with(...mixins: import("constructs").IMixin[]): import("constructs").IConstruct;
+    toString(): string;
+}) & typeof SfnStateMachine;
+export declare class StateMachine extends StateMachine_base {
+    private props;
+    constructor(scope: AppModule, id: string, props: StateMachineProps);
+    attachDefinition(): Promise<void>;
+    private overrideDefinition;
+    private overrideRole;
+    private addLoggingConfiguration;
+}
+export {};

package/lib/resolver/state-machine/state-machine.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateMachine = void 0;
+const cloudwatch_log_group_1 = require("@cdktn/provider-aws/lib/cloudwatch-log-group");
+const sfn_state_machine_1 = require("@cdktn/provider-aws/lib/sfn-state-machine");
+const resolver_1 = require("@lafken/resolver");
+const schema_1 = require("./schema/schema");
+class StateMachine extends resolver_1.lafkenResource.make(sfn_state_machine_1.SfnStateMachine) {
+    props;
+    constructor(scope, id, props) {
+        const { resourceMetadata } = props;
+        super(scope, `${id}-state-machine`, {
+            name: resourceMetadata.name,
+            roleArn: '',
+            definition: '',
+            tracingConfiguration: resourceMetadata.enableTrace
+                ? {
+                    enabled: true,
+                }
+                : undefined,
+        });
+        this.props = props;
+        this.isGlobal(scope.id, `state-machine::${id}`);
+        this.addLoggingConfiguration(resourceMetadata);
+        new resolver_1.ResourceOutput(this, resourceMetadata.outputs);
+    }
+    async attachDefinition() {
+        const { classResource } = this.props;
+        const schema = new schema_1.Schema(this, classResource);
+        const definition = await schema.getDefinition();
+        this.overrideRole(schema);
+        if (!schema.hasUnresolvedDependency) {
+            this.overrideDefinition(definition);
+        }
+        if (schema.hasUnresolvedDependency) {
+            this.isDependent(async () => {
+                this.overrideDefinition(await schema.resolveArguments(definition));
+            });
+        }
+    }
+    overrideDefinition(definition) {
+        const { resourceMetadata } = this.props;
+        this.addOverride('definition', JSON.stringify({
+            ...definition,
+            QueryLanguage: 'JSONata',
+            ExecutionType: resourceMetadata.executionType
+                ? resourceMetadata.executionType.toUpperCase()
+                : undefined,
+        }));
+    }
+    overrideRole(schema) {
+        const { resourceMetadata, moduleName } = this.props;
+        const permissions = {
+            read: ['GetObject', 'ListBucket'],
+            write: ['GetObject', 'ListBucket', 'PutObject'],
+        };
+        const bucketServices = Object.entries(schema.buckets).map(([bucket, permission]) => {
+            return {
+                type: 's3',
+                permissions: permissions[permission],
+                resources: [`arn:aws:s3:::${bucket}`, `arn:aws:s3:::${bucket}/*`],
+            };
+        });
+        const roleName = `${resourceMetadata.name}-${moduleName}-role`;
+        const role = new resolver_1.Role(this, roleName, {
+            name: roleName,
+            services: ({ getResourceValue, getSSMValue }) => {
+                const basePermissions = ['cloudwatch', 'lambda', ...bucketServices];
+                if (typeof resourceMetadata.services === 'function') {
+                    return [
+                        ...basePermissions,
+                        ...resourceMetadata.services({ getResourceValue, getSSMValue }),
+                    ];
+                }
+                return [...basePermissions, ...(resourceMetadata.services || [])];
+            },
+            principal: 'states.amazonaws.com',
+        });
+        this.addOverride('role_arn', role.arn);
+    }
+    addLoggingConfiguration(resourceMetadata) {
+        if (!resourceMetadata.loggingConfiguration) {
+            return;
+        }
+        const logGroup = new cloudwatch_log_group_1.CloudwatchLogGroup(this, 'sfn-logs', {
+            name: resourceMetadata.loggingConfiguration.logGroupName,
+            retentionInDays: resourceMetadata.loggingConfiguration.retentionInDays,
+        });
+        this.putLoggingConfiguration({
+            includeExecutionData: resourceMetadata.loggingConfiguration.includeExecutionData,
+            level: resourceMetadata.loggingConfiguration.level?.toUpperCase(),
+            logDestination: `${logGroup.arn}:*`,
+        });
+    }
+}
+exports.StateMachine = StateMachine;

package/lib/resolver/state-machine/state-machine.types.d.ts

@@ -0,0 +1,7 @@
+import type { ClassResource } from '@lafken/common';
+import type { StateMachineResourceMetadata } from '../../main';
+export interface StateMachineProps {
+    classResource: ClassResource;
+    resourceMetadata: StateMachineResourceMetadata;
+    moduleName: string;
+}

package/lib/resolver/state-machine/state-machine.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@lafken/state-machine",
+  "version": "0.10.1",
+  "private": false,
+  "description": "Build Step Functions workflows with TypeScript decorators - declarative orchestration with Lafken",
+  "keywords": [
+    "aws",
+    "step functions",
+    "state machine",
+    "workflow",
+    "orchestration",
+    "serverless",
+    "typescript",
+    "decorators",
+    "lafken"
+  ],
+  "homepage": "https://github.com/Hero64/lafken#readme",
+  "bugs": "https://github.com/Hero64/lafken/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Hero64/lafken",
+    "directory": "packages/state-machine"
+  },
+  "license": "MIT",
+  "author": "Aníbal Jorquera",
+  "exports": {
+    "./main": {
+      "import": "./lib/main/index.js",
+      "types": "./lib/main/index.d.ts",
+      "require": "./lib/main/index.js"
+    },
+    "./resolver": {
+      "import": "./lib/resolver/index.js",
+      "types": "./lib/resolver/index.d.ts",
+      "require": "./lib/resolver/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "main": [
+        "./lib/main/index.d.ts"
+      ],
+      "resolver": [
+        "./lib/resolver/index.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "lib"
+  ],
+  "dependencies": {
+    "reflect-metadata": "^0.2.2",
+    "@lafken/resolver": "0.10.1"
+  },
+  "devDependencies": {
+    "@cdktn/provider-aws": "^23.5.0",
+    "@swc/core": "^1.15.21",
+    "@swc/helpers": "^0.5.20",
+    "@vitest/runner": "^4.1.2",
+    "cdktn": "^0.22.1",
+    "cdktn-vitest": "^1.0.0",
+    "constructs": "^10.6.0",
+    "typescript": "6.0.2",
+    "unplugin-swc": "^1.5.9",
+    "vitest": "^4.1.2",
+    "@lafken/common": "0.10.1"
+  },
+  "peerDependencies": {
+    "@cdktn/provider-aws": ">=23.0.0",
+    "cdktn": ">=0.22.0",
+    "constructs": "^10.4.5",
+    "@lafken/common": "0.10.1"
+  },
+  "engines": {
+    "node": ">=20.19"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "pnpm clean && tsc -p ./tsconfig.build.json",
+    "check-types": "tsc --noEmit -p ./tsconfig.build.json",
+    "clean": "rm -rf ./lib",
+    "dev": "tsc -w",
+    "test": "vitest"
+  }
+}