@lafken/state-machine 0.10.6 → 0.11.1

package/lib/resolver/resolver.js

@@ -8,6 +8,7 @@ const state_machine_1 = require("./state-machine/state-machine");
 class StateMachineResolver {
     type = main_1.RESOURCE_TYPE;
     async create(module, resource) {
+        const minify = (0, resolver_1.getContextValueByScope)(module, 'minify');
         const metadata = (0, common_1.getResourceMetadata)(resource);
         const handlers = (0, common_1.getResourceHandlerMetadata)(resource);
         resolver_1.lambdaAssets.initializeMetadata({
@@ -15,9 +16,10 @@ class StateMachineResolver {
             filename: metadata.filename,
             className: metadata.originalName,
             methods: handlers.map((handler) => handler.name),
-            minify: metadata.minify,
+            minify: metadata.minify ?? minify,
         });
         const stateMachine = new state_machine_1.StateMachine(module, metadata.name, {
+            minify,
             classResource: resource,
             resourceMetadata: metadata,
             moduleName: module.id,

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

@@ -1,9 +1,11 @@
 import { type ClassResource } from '@lafken/common';
+import type { TerraformResource } from 'cdktn';
 import type { Construct } from 'constructs';
 import type { BucketPermission, DefinitionSchema, SchemaProps } from './schema.types';
 export declare class Schema {
     private scope;
     private resource;
+    private props;
     private states;
     private resourceMetadata;
     private handlers;
@@ -11,8 +13,10 @@ export declare class Schema {
     private lambdaStates;
     private unresolvedDependency;
     private bucketPermissions;
+    private lambdaResources;
     constructor(scope: Construct, resource: ClassResource, props?: SchemaProps);
-    getDefinition(): DefinitionSchema;
+    get definition(): DefinitionSchema;
+    get resources(): TerraformResource[];
     resolveArguments(definition: DefinitionSchema): Promise<DefinitionSchema>;
     get hasUnresolvedDependency(): boolean;
     get buckets(): BucketPermission;

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

@@ -8,6 +8,7 @@ const schema_utils_1 = require("./schema.utils");
 class Schema {
     scope;
     resource;
+    props;
     states = {};
     resourceMetadata;
     handlers = {};
@@ -15,20 +16,25 @@ class Schema {
     lambdaStates;
     unresolvedDependency = false;
     bucketPermissions = {};
+    lambdaResources = [];
     constructor(scope, resource, props = {}) {
         this.scope = scope;
         this.resource = resource;
+        this.props = props;
         this.stateNames = props.stateNames || new schema_utils_1.StateNames();
         this.lambdaStates = props.lambdas || new schema_utils_1.LambdaStates();
         this.getMetadata(props.initializeAssets ?? false);
     }
-    getDefinition() {
+    get definition() {
         const startName = this.getNextState(this.resourceMetadata.startAt);
         return {
             StartAt: startName,
             States: this.states,
         };
     }
+    get resources() {
+        return this.lambdaResources;
+    }
     async resolveArguments(definition) {
         for (const key in definition.States) {
             const state = definition.States[key];
@@ -52,7 +58,7 @@ class Schema {
     get buckets() {
         return this.bucketPermissions;
     }
-    getMetadata(initializeAssets) {
+    getMetadata(initializeAssets, minify) {
         this.resourceMetadata = (0, common_1.getResourceMetadata)(this.resource);
         const handlers = (0, common_1.getResourceHandlerMetadata)(this.resource);
         this.handlers = handlers.reduce((acc, handler) => {
@@ -65,7 +71,7 @@ class Schema {
                 filename: this.resourceMetadata.filename,
                 className: this.resourceMetadata.originalName,
                 methods: handlers.map((handler) => handler.name),
-                minify: this.resourceMetadata.minify,
+                minify: this.resourceMetadata.minify ?? minify,
             });
         }
     }
@@ -135,8 +141,10 @@ class Schema {
                         initializeAssets: true,
                         lambdas: this.lambdaStates,
                         stateNames: this.stateNames,
+                        minify: this.props.minify,
                     });
-                    branchStates.push(branchSchema.getDefinition());
+                    this.resources.push(...this.resources);
+                    branchStates.push(branchSchema.definition);
                     this.mergeBucketPermissions(branchSchema.buckets);
                     this.setUnresolvedDependency(branchSchema.unresolvedDependency);
                 }
@@ -157,9 +165,11 @@ class Schema {
                     initializeAssets: true,
                     lambdas: this.lambdaStates,
                     stateNames: this.stateNames,
+                    minify: this.props.minify,
                 });
+                this.resources.push(...this.resources);
                 this.mergeBucketPermissions(mapSchema.buckets);
-                const mapState = mapSchema.getDefinition();
+                const mapState = mapSchema.definition;
                 this.setUnresolvedDependency(mapSchema.hasUnresolvedDependency);
                 const itemProcessor = {
                     ...mapState,
@@ -275,6 +285,7 @@ class Schema {
                 suffix: 'states',
             },
         ]);
+        this.resources.push(lambdaHandler);
         return {
             Resource: 'arn:aws:states:::lambda:invoke',
             Arguments: {

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

@@ -137,6 +137,7 @@ export type States = StateTask | ParallelTask | MapTask | ChoiceTask | WaitTask
 export type StatesWithCatchErrors = StateTask | ParallelTask | MapTask;
 export interface SchemaProps {
     initializeAssets?: boolean;
+    minify?: boolean;
     stateNames?: StateNames | undefined;
     lambdas?: LambdaStates | undefined;
 }

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

@@ -15,5 +15,6 @@ export declare class StateMachine extends StateMachine_base {
     private overrideDefinition;
     private overrideRole;
     private addLoggingConfiguration;
+    private addDependency;
 }
 export {};

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

@@ -4,6 +4,7 @@ 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 cdktn_1 = require("cdktn");
 const schema_1 = require("./schema/schema");
 class StateMachine extends resolver_1.lafkenResource.make(sfn_state_machine_1.SfnStateMachine) {
     props;
@@ -26,15 +27,17 @@ class StateMachine extends resolver_1.lafkenResource.make(sfn_state_machine_1.Sf
     }
     async attachDefinition() {
         const { classResource } = this.props;
-        const schema = new schema_1.Schema(this, classResource);
-        const definition = await schema.getDefinition();
+        const schema = new schema_1.Schema(this, classResource, { minify: this.props.minify });
+        const definition = await schema.definition;
         this.overrideRole(schema);
         if (!schema.hasUnresolvedDependency) {
             this.overrideDefinition(definition);
+            this.addDependency(...schema.resources);
         }
-        if (schema.hasUnresolvedDependency) {
+        else {
             this.isDependent(async () => {
                 this.overrideDefinition(await schema.resolveArguments(definition));
+                this.addDependency(...schema.resources);
             });
         }
     }
@@ -76,6 +79,7 @@ class StateMachine extends resolver_1.lafkenResource.make(sfn_state_machine_1.Sf
             },
             principal: 'states.amazonaws.com',
         });
+        this.addDependency(role, role.policy);
         this.addOverride('role_arn', role.arn);
     }
     addLoggingConfiguration(resourceMetadata) {
@@ -91,6 +95,13 @@ class StateMachine extends resolver_1.lafkenResource.make(sfn_state_machine_1.Sf
             level: resourceMetadata.loggingConfiguration.level?.toUpperCase(),
             logDestination: `${logGroup.arn}:*`,
         });
+        this.addDependency(logGroup);
+    }
+    addDependency(...resource) {
+        this.dependsOn = [
+            ...(this.dependsOn || []),
+            ...resource.map((res) => (0, cdktn_1.dependable)(res)),
+        ];
     }
 }
 exports.StateMachine = StateMachine;

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

@@ -4,4 +4,5 @@ export interface StateMachineProps {
     classResource: ClassResource;
     resourceMetadata: StateMachineResourceMetadata;
     moduleName: string;
+    minify?: boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lafken/state-machine",
-  "version": "0.10.6",
+  "version": "0.11.1",
   "private": false,
   "description": "Build Step Functions workflows with TypeScript decorators - declarative orchestration with Lafken",
   "keywords": [
@@ -50,7 +50,7 @@
   ],
   "dependencies": {
     "reflect-metadata": "^0.2.2",
-    "@lafken/resolver": "0.10.6"
+    "@lafken/resolver": "0.11.1"
   },
   "devDependencies": {
     "@cdktn/provider-aws": "^23.5.0",
@@ -63,13 +63,13 @@
     "typescript": "6.0.2",
     "unplugin-swc": "^1.5.9",
     "vitest": "^4.1.2",
-    "@lafken/common": "0.10.6"
+    "@lafken/common": "0.11.1"
   },
   "peerDependencies": {
     "@cdktn/provider-aws": ">=23.0.0",
     "cdktn": ">=0.22.0",
     "constructs": "^10.4.5",
-    "@lafken/common": "0.10.6"
+    "@lafken/common": "0.11.1"
   },
   "engines": {
     "node": ">=20.19"