@lafken/state-machine 0.10.1

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateMachineReflectKeys = void 0;
+var StateMachineReflectKeys;
+(function (StateMachineReflectKeys) {
+    StateMachineReflectKeys["nested"] = "state_machine:nested";
+})(StateMachineReflectKeys || (exports.StateMachineReflectKeys = StateMachineReflectKeys = {}));

package/lib/resolver/index.d.ts

@@ -0,0 +1 @@
+export * from './resolver';

package/lib/resolver/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./resolver"), exports);

package/lib/resolver/resolver.d.ts

@@ -0,0 +1,6 @@
+import { type ClassResource } from '@lafken/common';
+import { type AppModule, type ResolverType } from '@lafken/resolver';
+export declare class StateMachineResolver implements ResolverType {
+    type: "STATE_MACHINE";
+    create(module: AppModule, resource: ClassResource): Promise<void>;
+}

package/lib/resolver/resolver.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateMachineResolver = void 0;
+const common_1 = require("@lafken/common");
+const resolver_1 = require("@lafken/resolver");
+const main_1 = require("../main");
+const state_machine_1 = require("./state-machine/state-machine");
+class StateMachineResolver {
+    type = main_1.RESOURCE_TYPE;
+    async create(module, resource) {
+        const metadata = (0, common_1.getResourceMetadata)(resource);
+        const handlers = (0, common_1.getResourceHandlerMetadata)(resource);
+        resolver_1.lambdaAssets.initializeMetadata({
+            foldername: metadata.foldername,
+            filename: metadata.filename,
+            className: metadata.originalName,
+            methods: handlers.map((handler) => handler.name),
+            minify: metadata.minify,
+        });
+        const stateMachine = new state_machine_1.StateMachine(module, metadata.name, {
+            classResource: resource,
+            resourceMetadata: metadata,
+            moduleName: module.id,
+        });
+        await stateMachine.attachDefinition();
+    }
+}
+exports.StateMachineResolver = StateMachineResolver;

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

@@ -0,0 +1,34 @@
+import { type ClassResource } from '@lafken/common';
+import type { Construct } from 'constructs';
+import type { BucketPermission, DefinitionSchema, SchemaProps } from './schema.types';
+export declare class Schema {
+    private scope;
+    private resource;
+    private states;
+    private resourceMetadata;
+    private handlers;
+    private stateNames;
+    private lambdaStates;
+    private unresolvedDependency;
+    private bucketPermissions;
+    constructor(scope: Construct, resource: ClassResource, props?: SchemaProps);
+    getDefinition(): DefinitionSchema;
+    resolveArguments(definition: DefinitionSchema): Promise<DefinitionSchema>;
+    get hasUnresolvedDependency(): boolean;
+    get buckets(): BucketPermission;
+    private getMetadata;
+    private getNextState;
+    private getStateName;
+    private getIntegrationTask;
+    private getLambdaTask;
+    private addTaskState;
+    private getLambdaPayload;
+    private parseArgumentParam;
+    private getParallelArguments;
+    private addRetry;
+    private addCatch;
+    private addRetryAndCatch;
+    private setUnresolvedDependency;
+    private mergeBucketPermissions;
+    private addBucketPermission;
+}

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

@@ -0,0 +1,431 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Schema = void 0;
+const common_1 = require("@lafken/common");
+const resolver_1 = require("@lafken/resolver");
+const main_1 = require("../../../main");
+const schema_utils_1 = require("./schema.utils");
+class Schema {
+    scope;
+    resource;
+    states = {};
+    resourceMetadata;
+    handlers = {};
+    stateNames;
+    lambdaStates;
+    unresolvedDependency = false;
+    bucketPermissions = {};
+    constructor(scope, resource, props = {}) {
+        this.scope = scope;
+        this.resource = resource;
+        this.stateNames = props.stateNames || new schema_utils_1.StateNames();
+        this.lambdaStates = props.lambdas || new schema_utils_1.LambdaStates();
+        this.getMetadata(props.initializeAssets ?? false);
+    }
+    getDefinition() {
+        const startName = this.getNextState(this.resourceMetadata.startAt);
+        return {
+            StartAt: startName,
+            States: this.states,
+        };
+    }
+    async resolveArguments(definition) {
+        for (const key in definition.States) {
+            const state = definition.States[key];
+            if (state.Type === 'Task' && typeof state.Arguments === 'function') {
+                state.Arguments = await state.Arguments();
+            }
+            if (state.Type === 'Map') {
+                await this.resolveArguments(state.ItemProcessor);
+            }
+            if (state.Type === 'Parallel') {
+                for (const branch of state.Branches) {
+                    await this.resolveArguments(branch);
+                }
+            }
+        }
+        return definition;
+    }
+    get hasUnresolvedDependency() {
+        return this.unresolvedDependency;
+    }
+    get buckets() {
+        return this.bucketPermissions;
+    }
+    getMetadata(initializeAssets) {
+        this.resourceMetadata = (0, common_1.getResourceMetadata)(this.resource);
+        const handlers = (0, common_1.getResourceHandlerMetadata)(this.resource);
+        this.handlers = handlers.reduce((acc, handler) => {
+            acc[handler.name] = handler;
+            return acc;
+        }, {});
+        if (initializeAssets) {
+            resolver_1.lambdaAssets.initializeMetadata({
+                foldername: this.resourceMetadata.foldername,
+                filename: this.resourceMetadata.filename,
+                className: this.resourceMetadata.originalName,
+                methods: handlers.map((handler) => handler.name),
+                minify: this.resourceMetadata.minify,
+            });
+        }
+    }
+    getNextState(currentState, end = false) {
+        if (!currentState || end) {
+            return;
+        }
+        if (typeof currentState === 'string') {
+            return this.addTaskState(this.handlers[currentState]);
+        }
+        const stateName = this.getStateName(currentState);
+        switch (currentState.type) {
+            case 'wait': {
+                this.states[stateName] = {
+                    Type: 'Wait',
+                    Seconds: currentState.seconds,
+                    Timestamp: currentState.timestamp,
+                    Next: this.getNextState(currentState.next),
+                };
+                break;
+            }
+            case 'choice': {
+                const choices = [];
+                for (const choice of currentState.choices) {
+                    choices.push({
+                        Condition: choice.condition,
+                        Next: this.getNextState(choice.next),
+                    });
+                }
+                this.states[stateName] = {
+                    Type: 'Choice',
+                    Choices: choices,
+                    Default: this.getNextState(currentState.default),
+                };
+                break;
+            }
+            case 'fail': {
+                this.states[stateName] = {
+                    Type: 'Fail',
+                    Cause: currentState.cause,
+                    Error: currentState.error,
+                };
+                break;
+            }
+            case 'succeed': {
+                this.states[stateName] = {
+                    Type: 'Succeed',
+                    Output: currentState.output,
+                };
+                break;
+            }
+            case 'pass': {
+                this.states[stateName] = {
+                    Type: 'Pass',
+                    Assign: currentState.assign,
+                    Output: currentState.output,
+                    End: currentState.end,
+                    Next: this.getNextState(currentState.next, currentState.end),
+                };
+                break;
+            }
+            case 'parallel': {
+                const branchStates = [];
+                for (let i = 0; i < currentState.branches.length; i++) {
+                    const branch = currentState.branches[i];
+                    const branchSchema = new Schema(this.scope, branch, {
+                        initializeAssets: true,
+                        lambdas: this.lambdaStates,
+                        stateNames: this.stateNames,
+                    });
+                    branchStates.push(branchSchema.getDefinition());
+                    this.mergeBucketPermissions(branchSchema.buckets);
+                    this.setUnresolvedDependency(branchSchema.unresolvedDependency);
+                }
+                this.states[stateName] = {
+                    Type: 'Parallel',
+                    Arguments: this.getParallelArguments(currentState.arguments),
+                    Output: currentState.output,
+                    Assign: currentState.assign,
+                    End: currentState.end ?? currentState.next === undefined,
+                    Next: this.getNextState(currentState.next, currentState.end),
+                    Branches: branchStates,
+                };
+                this.addRetryAndCatch(currentState, stateName);
+                break;
+            }
+            case 'map': {
+                const mapSchema = new Schema(this.scope, currentState.states, {
+                    initializeAssets: true,
+                    lambdas: this.lambdaStates,
+                    stateNames: this.stateNames,
+                });
+                this.mergeBucketPermissions(mapSchema.buckets);
+                const mapState = mapSchema.getDefinition();
+                this.setUnresolvedDependency(mapSchema.hasUnresolvedDependency);
+                const itemProcessor = {
+                    ...mapState,
+                    ProcessorConfig: {
+                        Mode: 'INLINE',
+                    },
+                };
+                const mapTask = {
+                    Type: 'Map',
+                    Items: currentState.items,
+                    ItemProcessor: itemProcessor,
+                    End: currentState.end ?? currentState.next === undefined,
+                    Next: this.getNextState(currentState.next, currentState.end),
+                    Output: currentState.output,
+                    Assign: currentState.assign,
+                };
+                if (currentState.mode === 'distributed') {
+                    itemProcessor.ProcessorConfig = {
+                        Mode: 'DISTRIBUTED',
+                        ExecutionType: (currentState.executionType || 'STANDARD').toUpperCase(),
+                    };
+                    mapTask.ItemProcessor = itemProcessor;
+                    if (currentState.itemReader) {
+                        this.addBucketPermission(currentState.itemReader.bucket, 'read');
+                        const readerConfig = {
+                            Resource: 'arn:aws:states:::s3:getObject',
+                            Arguments: {
+                                Bucket: currentState.itemReader.bucket,
+                                Key: currentState.itemReader.key,
+                            },
+                            ReaderConfig: {
+                                InputType: currentState.itemReader.source.toUpperCase(),
+                            },
+                        };
+                        if (currentState.itemReader.source === 'csv') {
+                            readerConfig.ReaderConfig.CSVDelimiter = currentState.itemReader.delimiter;
+                            readerConfig.ReaderConfig.CSVHeaderLocation =
+                                currentState.itemReader.headers?.location;
+                            readerConfig.ReaderConfig.CSVHeaders =
+                                currentState.itemReader.headers?.titles;
+                            readerConfig.ReaderConfig.MaxItems = currentState.itemReader.maxItems;
+                        }
+                        mapTask.ItemReader = readerConfig;
+                    }
+                    if (currentState.resultWriter) {
+                        this.addBucketPermission(currentState.resultWriter.bucket, 'write');
+                        mapTask.ResultWriter = {
+                            Resource: 'arn:aws:states:::s3:putObject',
+                            Arguments: {
+                                Bucket: currentState.resultWriter.bucket,
+                                Prefix: currentState.resultWriter.prefix,
+                            },
+                            WriterConfig: currentState.resultWriter.config
+                                ? {
+                                    OutputType: currentState.resultWriter.config.outputType,
+                                    Transformation: currentState.resultWriter.config?.transformation,
+                                }
+                                : undefined,
+                        };
+                    }
+                    if (currentState.maxItemsPerBatch) {
+                        mapTask.ItemBatcher = {
+                            MaxItemsPerBatch: currentState.maxItemsPerBatch,
+                        };
+                    }
+                    if (currentState.toleratedFailureCount) {
+                        mapTask.ToleratedFailureCount = currentState.toleratedFailureCount;
+                    }
+                    if (currentState.toleratedFailurePercentage) {
+                        mapTask.ToleratedFailurePercentage =
+                            currentState.toleratedFailurePercentage.toString();
+                    }
+                }
+                this.states[stateName] = mapTask;
+                this.addRetryAndCatch(currentState, stateName);
+                break;
+            }
+        }
+        return stateName;
+    }
+    getStateName(currentState) {
+        if (typeof currentState === 'string') {
+            return '';
+        }
+        return this.stateNames.createName(currentState.type);
+    }
+    getIntegrationTask(handler) {
+        const task = {
+            Resource: handler.integrationResource,
+            Output: handler.output,
+        };
+        const resource = new this.resource();
+        this.unresolvedDependency = true;
+        task.Arguments = async () => {
+            const argumentValues = await (0, resolver_1.resolveCallbackResource)(this.scope, (props) => resource[handler.name]({}, props));
+            if (!argumentValues) {
+                throw new Error('The schema has a unresolved dependency');
+            }
+            return argumentValues;
+        };
+        return task;
+    }
+    getLambdaTask(handler) {
+        const id = `${handler.name}-${this.resourceMetadata.name}`;
+        const lambdaHandler = this.lambdaStates.createLambda([
+            this.scope,
+            id,
+            {
+                ...handler,
+                originalName: this.resourceMetadata.originalName,
+                filename: this.resourceMetadata.filename,
+                foldername: this.resourceMetadata.foldername,
+                suffix: 'states',
+            },
+        ]);
+        return {
+            Resource: 'arn:aws:states:::lambda:invoke',
+            Arguments: {
+                Payload: this.getLambdaPayload(handler.name),
+                FunctionName: lambdaHandler.functionName,
+            },
+            Output: handler.output ||
+                '{% $exists($states.result.Payload) ? $states.result.Payload : {} %}',
+        };
+    }
+    addTaskState(handler) {
+        const stateName = this.stateNames.createName(handler.name);
+        if (this.states[stateName]) {
+            return handler.name;
+        }
+        const task = {
+            Type: 'Task',
+            Resource: '',
+            Arguments: {},
+            Next: this.getNextState(handler.next, handler.end),
+            End: handler.end,
+            Assign: handler.assign,
+            ...(handler.integrationResource !== undefined
+                ? this.getIntegrationTask(handler)
+                : this.getLambdaTask(handler)),
+        };
+        this.states[stateName] = task;
+        this.addRetryAndCatch(handler, stateName);
+        return stateName;
+    }
+    getLambdaPayload(stateName) {
+        const params = (0, common_1.getMetadataPrototypeByKey)(this.resource, common_1.LambdaReflectKeys.event_param) || {};
+        const paramsByMethod = params[stateName];
+        if (!paramsByMethod) {
+            return {};
+        }
+        if (paramsByMethod.type === 'String') {
+            return paramsByMethod.initialValue || '';
+        }
+        const stateParameters = {};
+        for (const param of paramsByMethod.properties) {
+            stateParameters[param.name] = this.parseArgumentParam(param);
+        }
+        return stateParameters;
+    }
+    parseArgumentParam = (field) => {
+        const { context } = field;
+        switch (context) {
+            case 'custom': {
+                if (field.type !== 'Object') {
+                    return field.value;
+                }
+                const params = {};
+                if (field.type === 'Object') {
+                    for (const property of field.properties) {
+                        params[property.destinationName] = this.parseArgumentParam(property);
+                    }
+                }
+                return params;
+            }
+            case 'input': {
+                return `{% $states.input.${field.source} %}`;
+            }
+            case 'execution': {
+                const source = schema_utils_1.mapSourceExecution[field.source];
+                return `{% $states.context.Execution.${field.source.startsWith('input.') ? field.source.replace('input.', 'Input.') : source} %}`;
+            }
+            case 'state_machine': {
+                const source = schema_utils_1.mapSourceStateMachine[field.source];
+                return `{% $states.context.StateMachine.${source} %}`;
+            }
+            case 'state': {
+                const source = schema_utils_1.mapSourceState[field.source];
+                return `{% $states.context.State.${source} %}`;
+            }
+            case 'task': {
+                const source = schema_utils_1.mapSourceTask[field.source];
+                return `{% $states.context.Task.${source} %}`;
+            }
+            case 'jsonata': {
+                return field.value;
+            }
+        }
+    };
+    getParallelArguments(args) {
+        if (!args || typeof args === 'object') {
+            return args;
+        }
+        const params = (0, common_1.getMetadataPrototypeByKey)(args, main_1.stateMachineFieldKey);
+        const parallelArguments = {};
+        for (const param of params) {
+            parallelArguments[param.destinationName] = this.parseArgumentParam(param);
+        }
+        return parallelArguments;
+    }
+    addRetry(state, stateName) {
+        if (!state.retry || state.retry.length === 0) {
+            return;
+        }
+        const retries = [];
+        for (const retry of state.retry || []) {
+            retries.push({
+                ErrorEquals: retry.errorEquals,
+                BackoffRate: retry.backoffRate,
+                IntervalSeconds: retry.intervalSeconds,
+                MaxAttempts: retry.maxAttempt,
+                MaxDelaySeconds: retry.maxDelaySeconds,
+            });
+        }
+        const currentState = this.states[stateName];
+        currentState.Retry = retries;
+        this.states[stateName] = currentState;
+    }
+    addCatch(state, stateName) {
+        if (!state.catch || state.catch.length === 0) {
+            return;
+        }
+        const catches = [];
+        for (const catchValue of state.catch || []) {
+            catches.push({
+                ErrorEquals: catchValue.errorEquals,
+                Next: this.getNextState(catchValue.next),
+            });
+        }
+        const currentState = this.states[stateName];
+        currentState.Catch = catches;
+        this.states[stateName] = currentState;
+    }
+    addRetryAndCatch(state, stateName) {
+        this.addCatch(state, stateName);
+        this.addRetry(state, stateName);
+    }
+    setUnresolvedDependency(unresolved) {
+        if (!this.unresolvedDependency || !unresolved) {
+            return;
+        }
+        this.unresolvedDependency = true;
+    }
+    mergeBucketPermissions(bucketPermissions) {
+        for (const bucket in bucketPermissions) {
+            this.addBucketPermission(bucket, bucketPermissions[bucket]);
+        }
+    }
+    addBucketPermission(bucketName, permission) {
+        if (!this.bucketPermissions[bucketName]) {
+            this.bucketPermissions[bucketName] = permission;
+            return;
+        }
+        if (this.bucketPermissions[bucketName] === 'read' && permission === 'write') {
+            this.bucketPermissions[bucketName] = permission;
+        }
+    }
+}
+exports.Schema = Schema;

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

@@ -0,0 +1,149 @@
+import type { CsvDelimiter, HeaderLocation, ResultOutputType, ResultTransformation } from '../../../main';
+import type { LambdaStates, StateNames } from './schema.utils';
+export interface Retry {
+    ErrorEquals: string[];
+    IntervalSeconds?: number;
+    MaxAttempts?: number;
+    BackoffRate?: number;
+    MaxDelaySeconds?: number;
+}
+export interface Catch {
+    ErrorEquals: string[];
+    Next: string;
+}
+export interface StateTask {
+    Type: 'Task';
+    Resource: string;
+    Arguments: any;
+    Output?: string | Record<string, any>;
+    Assign?: Record<string, any>;
+    Next?: string;
+    End?: boolean;
+    Retry?: Retry[];
+    Catch?: Catch[];
+}
+export interface ParallelBranch {
+    StartAt: string;
+    States: Record<string, States>;
+}
+export interface ParallelTask {
+    Type: 'Parallel';
+    Branches: ParallelBranch[];
+    Arguments?: Record<string, any>;
+    Output?: string | Record<string, any>;
+    Assign?: Record<string, any>;
+    Next?: string;
+    End?: boolean;
+    Retry?: Retry[];
+    Catch?: Catch[];
+}
+export type ExecutionType = 'EXPRESS' | 'STANDARD';
+export interface DistributedProcessorConfig {
+    Mode: 'DISTRIBUTED';
+    ExecutionType: ExecutionType;
+}
+export interface InlineProcessorConfig {
+    Mode: 'INLINE';
+}
+export interface ItemProcessor extends ParallelBranch {
+    ProcessorConfig: DistributedProcessorConfig | InlineProcessorConfig;
+}
+export type ItemReaderTypes = 'CSV' | 'JSON' | 'JSONL' | 'PARQUET' | 'MANIFEST';
+export interface ItemReader {
+    Resource: 'arn:aws:states:::s3:getObject';
+    ReaderConfig: {
+        InputType: ItemReaderTypes;
+        CSVHeaderLocation?: HeaderLocation;
+        CSVHeaders?: string[];
+        Transformation?: 'NONE' | 'LOAD_AND_FLATTEN';
+        ManifestType?: 'ATHENA_DATA' | 'S3_INVENTORY';
+        CSVDelimiter?: CsvDelimiter;
+        MaxItems?: number;
+    };
+    Arguments: {
+        Bucket: string;
+        Key: string;
+        VersionId?: string;
+    };
+}
+interface ResultWriter {
+    Resource: 'arn:aws:states:::s3:putObject';
+    WriterConfig?: {
+        Transformation?: ResultTransformation;
+        OutputType?: ResultOutputType;
+    };
+    Arguments: {
+        Bucket: string;
+        Prefix?: string;
+    };
+}
+interface ItemBatcher {
+    MaxItemsPerBatch?: number | string;
+}
+export interface MapTask {
+    Type: 'Map';
+    ItemProcessor: ItemProcessor;
+    ItemReader?: ItemReader;
+    ResultWriter?: ResultWriter;
+    ItemBatcher?: ItemBatcher;
+    Items?: any[] | string;
+    MaxConcurrency?: number;
+    ToleratedFailurePercentage?: string;
+    ToleratedFailureCount?: number;
+    Output?: string | Record<string, any>;
+    Assign?: Record<string, any>;
+    Next?: string;
+    End?: boolean;
+    Retry?: Retry[];
+    Catch?: Catch[];
+}
+export interface PassTask {
+    Type: 'Pass';
+    Output?: string | Record<string, any>;
+    Assign?: Record<string, any>;
+    Next?: string;
+    End?: boolean;
+}
+export interface WaitTask {
+    Type: 'Wait';
+    Seconds?: string | number;
+    Timestamp?: string;
+    Output?: string | Record<string, any>;
+    Assign?: Record<string, any>;
+    Next?: string;
+    End?: boolean;
+}
+export interface ChoiceCondition {
+    Condition: string;
+    Next: string;
+}
+export interface ChoiceTask {
+    Type: 'Choice';
+    Choices: ChoiceCondition[];
+    Default?: string;
+    Output?: string | Record<string, any>;
+    Assign?: Record<string, any>;
+}
+export interface SucceedTask {
+    Type: 'Succeed';
+    Output?: string | Record<string, any>;
+}
+export interface FailTask {
+    Type: 'Fail';
+    Error?: string;
+    Cause?: string;
+}
+export type States = StateTask | ParallelTask | MapTask | ChoiceTask | WaitTask | PassTask | SucceedTask | FailTask;
+export type StatesWithCatchErrors = StateTask | ParallelTask | MapTask;
+export interface SchemaProps {
+    initializeAssets?: boolean;
+    stateNames?: StateNames | undefined;
+    lambdas?: LambdaStates | undefined;
+}
+export interface DefinitionSchema {
+    StartAt: string;
+    States: Record<string, States>;
+}
+export type PermissionType = 'read' | 'write';
+export type BucketPermission = Record<string, PermissionType>;
+export {};

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

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