@lafken/main 0.10.1

package/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Aníbal Emilio Jorquera Cornejo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,219 @@
+# @lafken/main
+
+Core entry point for a Lafken serverless application. `@lafken/main` initializes the AWS provider, orchestrates resolvers and modules, and synthesizes the resulting Terraform configuration through CDKTN. It provides `createApp` to bootstrap the application and `createModule` to organize resources into logical groups.
+
+## Installation
+
+```bash
+npm install @lafken/main
+```
+
+## Getting Started
+
+Create an application with resolvers and modules, then let Lafken generate all the infrastructure:
+
+```typescript
+import { createApp, createModule } from '@lafken/main';
+import { ApiResolver } from '@lafken/api/resolver';
+import { QueueResolver } from '@lafken/queue/resolver';
+
+// 1. Define modules that group related resources
+const userModule = createModule({
+  name: 'users',
+  resources: [UserApi, UserQueue],
+});
+
+const billingModule = createModule({
+  name: 'billing',
+  resources: [InvoiceSchedule],
+});
+
+// 2. Create the application
+await createApp({
+  name: 'my-app',
+  modules: [userModule, billingModule],
+  resolvers: [
+    new ApiResolver({ restApi: { name: 'my-api' } }),
+    new QueueResolver(),
+  ],
+});
+```
+
+## Features
+
+### createApp
+
+`createApp` is the main entry point. It initializes the AWS stack, runs all resolver lifecycle hooks (`beforeCreate` → `create` → `afterCreate`), and synthesizes the Terraform output:
+
+```typescript
+await createApp({
+  name: 'my-app',
+  modules: [userModule, billingModule],
+  resolvers: [new ApiResolver(), new QueueResolver()],
+  globalConfig: {
+    lambda: {
+      memory: 512,
+      timeout: 30,
+      runtime: 22,
+      services: ['dynamodb', 's3', 'sqs'],
+    },
+    tags: {
+      environment: 'production',
+      team: 'platform',
+    },
+  },
+  awsProviderConfig: {
+    region: 'us-east-1',
+    profile: 'my-aws-profile',
+  },
+  s3Backend: {
+    bucket: 'my-terraform-state',
+    key: 'app/terraform.tfstate',
+    region: 'us-east-1',
+  },
+  extend: async (scope) => {
+    // Add custom CDKTN constructs after all resolvers finish
+  },
+});
+```
+
+#### Application Options
+
+| Option              | Type                | Required | Description                                               |
+| ------------------- | ------------------- | -------- | --------------------------------------------------------- |
+| `name`              | `string`            | Yes      | Application name, used as the stack identifier             |
+| `modules`           | `StackModule[]`     | Yes      | Modules created with `createModule`                        |
+| `resolvers`         | `ResolverType[]`    | Yes      | Resolvers that process decorated resources                 |
+| `globalConfig`      | `GlobalConfig`      | No       | Shared Lambda and tag settings for all resources           |
+| `awsProviderConfig` | `AwsProviderConfig` | No       | AWS provider settings (region, profile, etc.)              |
+| `s3Backend`         | `S3BackendConfig`   | No       | Remote S3 backend for Terraform state                      |
+| `extend`            | `(scope) => void`   | No       | Callback invoked after all resolvers finish                |
+
+### createModule
+
+`createModule` groups related resources into a logical unit with its own scope, IAM role, and configuration. Each resource inside the module is processed by the matching resolver based on its decorator type:
+
+```typescript
+const orderModule = createModule({
+  name: 'orders',
+  resources: [OrderApi, OrderQueue, OrderSchedule],
+  globalConfig: {
+    lambda: {
+      memory: 256,
+      timeout: 15,
+      services: ['dynamodb', 'sqs'],
+    },
+    tags: {
+      domain: 'orders',
+    },
+  },
+});
+```
+
+#### Module Options
+
+| Option         | Type              | Required | Description                                           |
+| -------------- | ----------------- | -------- | ----------------------------------------------------- |
+| `name`         | `string`          | Yes      | Module name, used as scope and tag identifier          |
+| `resources`    | `ClassResource[]` | Yes      | Decorated classes to be processed by resolvers         |
+| `globalConfig` | `GlobalConfig`    | No       | Lambda and tag settings scoped to this module          |
+
+### Global Configuration
+
+Global configuration applies default settings to all Lambda functions and resources. Values cascade from application to module to individual resource, with more specific settings taking precedence:
+
+```
+App globalConfig → Module globalConfig → Resource-level config
+```
+
+#### Lambda Configuration
+
+| Option        | Type             | Description                                               |
+| ------------- | ---------------- | --------------------------------------------------------- |
+| `memory`      | `number`         | Memory allocation in MB                                   |
+| `timeout`     | `number`         | Execution timeout in seconds                              |
+| `runtime`     | `20 \| 22 \| 24` | Node.js runtime version                                   |
+| `services`    | `Services[]`     | AWS services the Lambda can access (creates IAM role)     |
+| `enableTrace` | `boolean`        | Enable AWS X-Ray tracing                                  |
+| `env`         | `EnvironmentValue` | Environment variables for Lambda functions              |
+
+#### Available Services
+
+Services define which AWS resources the Lambda IAM role can access:
+
+| Service         | Description                      |
+| --------------- | -------------------------------- |
+| `dynamodb`      | Amazon DynamoDB                  |
+| `s3`            | Amazon S3                        |
+| `lambda`        | AWS Lambda                       |
+| `cloudwatch`    | Amazon CloudWatch Logs           |
+| `sqs`           | Amazon SQS                       |
+| `state_machine` | AWS Step Functions               |
+| `kms`           | AWS KMS                          |
+| `ssm`           | AWS Systems Manager Parameter Store |
+| `event`         | Amazon EventBridge               |
+
+For fine-grained control, specify individual permissions:
+
+```typescript
+services: [
+  'cloudwatch',
+  { type: 'dynamodb', permissions: ['Query', 'GetItem'] },
+  { type: 's3', permissions: ['GetObject'], resources: ['arn:aws:s3:::my-bucket/*'] },
+  { type: 'custom', serviceName: 'ses', permissions: ['SendEmail'] },
+]
+```
+
+#### Tags
+
+Tags are applied automatically to all taggable resources. Module-level tags merge with app-level tags, and resource-specific tags take highest precedence:
+
+```typescript
+// App-level tags
+globalConfig: {
+  tags: {
+    environment: 'production',
+    project: 'my-app',
+  },
+}
+
+// Module-level tags (merged with app tags)
+globalConfig: {
+  tags: {
+    domain: 'orders',
+  },
+}
+```
+
+Lafken also adds automatic tags: `lafken:app` with the app name and `lafken:module` with the module name.
+
+### S3 Backend
+
+Store Terraform state remotely in an S3 bucket for team collaboration and state locking:
+
+```typescript
+await createApp({
+  name: 'my-app',
+  s3Backend: {
+    bucket: 'terraform-state-bucket',
+    key: 'apps/my-app/terraform.tfstate',
+    region: 'us-east-1',
+    dynamodbTable: 'terraform-locks',
+  },
+});
+```
+
+### Extending the Application
+
+The `extend` callback runs after all resolvers have finished processing. Use it to add custom infrastructure that is not covered by the standard resolvers:
+
+```typescript
+await createApp({
+  name: 'my-app',
+  modules: [userModule],
+  resolvers: [new ApiResolver()],
+  extend: async (scope) => {
+    // Add any CDKTN construct directly to the stack
+  },
+});
+```

package/lib/app/app.d.ts

@@ -0,0 +1,41 @@
+import { App, TerraformStack } from 'cdktn';
+import type { CreateAppProps } from './app.types';
+export declare class AppStack extends TerraformStack {
+    id: string;
+    private props;
+    constructor(scope: App, id: string, props: CreateAppProps);
+    init(): Promise<void>;
+    private triggerHook;
+    private resolveModuleResources;
+    private createRole;
+    private addAspectProperties;
+}
+/**
+ * Creates and synthesizes a Lafken serverless application.
+ *
+ * Initializes the CDKTN application, sets up the AWS stack with the
+ * provided modules and resolvers, executes the full resolver lifecycle
+ * (beforeCreate → create → afterCreate), and synthesizes the resulting
+ * Terraform configuration.
+ *
+ * @param props - The application configuration including name, modules,
+ * resolvers, global settings, and optional extensions.
+ * @returns The CDKTN `App` instance and the `AppStack` created for the application.
+ *
+ * @example
+ * await createApp({
+ *   name: 'my-app',
+ *   modules: [
+ *     //... ,
+ *   ],
+ *   resolvers: [new ApiResolver({ restApi: { name: 'my-api' } })],
+ *   globalConfig: {
+ *     lambda: { runtime: 22, memory: 512 },
+ *     tags: { environment: 'production' },
+ *   },
+ * });
+ */
+export declare const createApp: (props: CreateAppProps) => Promise<{
+    app: App;
+    appStack: AppStack;
+}>;

package/lib/app/app.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApp = exports.AppStack = void 0;
+const provider_1 = require("@cdktn/provider-aws/lib/provider");
+const common_1 = require("@lafken/common");
+const resolver_1 = require("@lafken/resolver");
+const cdktn_1 = require("cdktn");
+const aspect_1 = require("../aspect/aspect");
+const context_1 = require("../context/context");
+(0, common_1.enableBuildEnvVariable)();
+class AppStack extends cdktn_1.TerraformStack {
+    id;
+    props;
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.id = id;
+        this.props = props;
+        new context_1.AppContext(this, {
+            contextName: resolver_1.ContextName.app,
+            globalConfig: props.globalConfig?.lambda,
+            contextCreator: props.name,
+        });
+        new provider_1.AwsProvider(this, 'AWS', props.awsProviderConfig);
+        if (props.s3Backend) {
+            new cdktn_1.S3Backend(this, props.s3Backend);
+        }
+        this.createRole();
+    }
+    async init() {
+        const { resolvers, extend } = this.props;
+        await this.triggerHook(resolvers, 'beforeCreate');
+        await this.resolveModuleResources();
+        await this.triggerHook(resolvers, 'afterCreate');
+        this.addAspectProperties();
+        await resolver_1.lafkenResource.callDependentCallbacks();
+        await resolver_1.lambdaAssets.createAssets();
+        if (extend) {
+            await extend(this);
+        }
+    }
+    async triggerHook(resolvers, trigger) {
+        for (const resolver of resolvers) {
+            if (resolver[trigger] !== undefined) {
+                await resolver[trigger](this);
+            }
+        }
+    }
+    async resolveModuleResources() {
+        const { modules, resolvers } = this.props;
+        const resolversByType = resolvers.reduce((acc, resolver) => {
+            acc[resolver.type] = resolver;
+            return acc;
+        }, {});
+        await Promise.all(modules.map((module) => module(this, resolversByType)));
+    }
+    createRole() {
+        const roleName = `${this.props.name}-global-role`;
+        const lambdaRole = new resolver_1.Role(this, roleName, {
+            name: roleName,
+            services: this.props.globalConfig?.lambda?.services || [
+                'dynamodb',
+                's3',
+                'lambda',
+                'cloudwatch',
+                'sqs',
+                'state_machine',
+                'kms',
+                'ssm',
+                'event',
+            ],
+        });
+        lambdaRole.isGlobal('app', roleName);
+    }
+    addAspectProperties() {
+        cdktn_1.Aspects.of(this).add(new aspect_1.AppAspect(this, 'app', {
+            tags: {
+                ...(this.props.globalConfig?.tags || {}),
+                'lafken:app': this.id,
+            },
+            environment: this.props.globalConfig?.lambda?.env,
+            vpc: this.props.globalConfig?.lambda?.vpcConfig,
+        }));
+    }
+}
+exports.AppStack = AppStack;
+/**
+ * Creates and synthesizes a Lafken serverless application.
+ *
+ * Initializes the CDKTN application, sets up the AWS stack with the
+ * provided modules and resolvers, executes the full resolver lifecycle
+ * (beforeCreate → create → afterCreate), and synthesizes the resulting
+ * Terraform configuration.
+ *
+ * @param props - The application configuration including name, modules,
+ * resolvers, global settings, and optional extensions.
+ * @returns The CDKTN `App` instance and the `AppStack` created for the application.
+ *
+ * @example
+ * await createApp({
+ *   name: 'my-app',
+ *   modules: [
+ *     //... ,
+ *   ],
+ *   resolvers: [new ApiResolver({ restApi: { name: 'my-api' } })],
+ *   globalConfig: {
+ *     lambda: { runtime: 22, memory: 512 },
+ *     tags: { environment: 'production' },
+ *   },
+ * });
+ */
+const createApp = async (props) => {
+    const app = new cdktn_1.App({
+        skipValidation: true,
+    });
+    const appStack = new AppStack(app, props.name, props);
+    await appStack.init();
+    app.synth();
+    return {
+        app,
+        appStack,
+    };
+};
+exports.createApp = createApp;

package/lib/app/app.types.d.ts

@@ -0,0 +1,135 @@
+import type { AwsProviderConfig } from '@cdktn/provider-aws/lib/provider';
+import type { LambdaGlobalConfig, ResolverType } from '@lafken/resolver';
+import type { S3BackendConfig } from 'cdktn';
+import type { StackModule } from '../module';
+import type { ModuleResolverType } from '../module/module.types';
+import type { AppStack } from './app';
+/**
+ * Global configuration for the application.
+ *
+ * Defines shared settings that apply across all resources and Lambda
+ * functions in the application. Individual resources can override
+ * these values with their own specific configuration.
+ */
+export interface GlobalConfig {
+    /**
+     * Global Lambda configuration.
+     *
+     * Specifies default properties for all Lambda functions in the
+     * application, such as memory, timeout, runtime, and services.
+     * These values can be overridden at the module or resource level.
+     *
+     * @example
+     * lambda: {
+     *   memory: 512,
+     *   timeout: 30,
+     *   runtime: 22,
+     *   services: ['s3', 'dynamodb'],
+     * }
+     */
+    lambda?: LambdaGlobalConfig;
+    /**
+     * Global resource tags.
+     *
+     * Specifies a set of tags that will be applied to all resources
+     * unless a resource explicitly defines its own tags. In that case,
+     * the resource-specific tags will override the global values.
+     */
+    tags?: Record<string, string>;
+}
+export interface CreateAppProps {
+    /**
+     * Application name.
+     *
+     * Specifies the name of the application, which is used within
+     * the AWS stack as an identifier for resources.
+     *
+     * @example
+     * name: "my-awesome-app"
+     */
+    name: string;
+    /**
+     * Application modules.
+     *
+     * Defines the set of modules to be created within the application.
+     * Each module groups related resources and handlers into a logical
+     * unit with shared configuration. Modules are created using
+     * `createModule()` and receive the application stack scope along
+     * with the registered resolvers.
+     *
+     * @example
+     * modules: [
+     *   createModule({
+     *     name: 'users',
+     *     resources: [UserApi, UserQueue],
+     *   }),
+     * ]
+     */
+    modules: ((scope: AppStack, resources: Record<string, ModuleResolverType>) => Promise<StackModule>)[];
+    /**
+     * Resource resolvers.
+     *
+     * Defines the list of resolvers responsible for creating and configuring
+     * resources loaded by the stacks. Each resolver can receive detailed
+     * configuration options depending on the type of resource it manages.
+     *
+     * For example, an `ApiResolver` can include REST API settings,
+     * deployment options, and authorization configurations.
+     */
+    resolvers: ResolverType[];
+    /**
+     * Global configuration for the application.
+     *
+     * Provides settings that are applied across all resources, stacks,
+     * and Lambda functions unless overridden at a lower level.
+     * This includes global Lambda properties, environment configuration,
+     * and resource tags.
+     */
+    globalConfig?: GlobalConfig;
+    /**
+     * AWS provider configuration.
+     *
+     * Specifies the configuration for the AWS provider used by the
+     * application stack. This includes settings such as the AWS region,
+     * profile, and other provider-level options required for
+     * deploying resources.
+     *
+     * @example
+     * awsProviderConfig: {
+     *   region: 'us-east-1',
+     *   profile: 'my-aws-profile',
+     * }
+     */
+    awsProviderConfig?: AwsProviderConfig;
+    /**
+     * S3 backend configuration for Terraform state.
+     *
+     * Configures an S3 bucket as the remote backend for storing the
+     * Terraform state file. This enables team collaboration, state
+     * locking, and centralized state management.
+     *
+     * @example
+     * s3Backend: {
+     *   bucket: 'my-terraform-state',
+     *   key: 'app/terraform.tfstate',
+     *   region: 'us-east-1',
+     * }
+     */
+    s3Backend?: S3BackendConfig;
+    /**
+     * Extension callback.
+     *
+     * An optional async callback that is invoked after all modules and
+     * resolvers have been fully processed. Use this to add custom
+     * infrastructure or perform additional configuration on the
+     * application stack that is not covered by the standard resolvers.
+     *
+     * @param scope - The application stack instance.
+     *
+     * @example
+     * extend: async (scope) => {
+     *   new S3Bucket(scope, 'custom-bucket', { bucket: 'my-bucket' });
+     * }
+     */
+    extend?: (scope: AppStack) => Promise<void>;
+}

package/lib/app/app.types.js

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

package/lib/app/index.d.ts

@@ -0,0 +1,2 @@
+export * from './app';
+export * from './app.types';

package/lib/app/index.js

@@ -0,0 +1,18 @@
+"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("./app"), exports);
+__exportStar(require("./app.types"), exports);

package/lib/aspect/aspect.d.ts

@@ -0,0 +1,17 @@
+import type { IAspect } from 'cdktn';
+import type { Construct, IConstruct } from 'constructs';
+import type { AppAspectProps } from './aspect.types';
+export declare class AppAspect implements IAspect {
+    private scope;
+    private id;
+    private props;
+    private env;
+    private vpcConfig;
+    constructor(scope: Construct, id: string, props: AppAspectProps);
+    visit(node: IConstruct): void;
+    private initializeEnvironment;
+    private initializeVpcConfig;
+    private addEnvironmentValues;
+    private addVpcConfig;
+    private isTaggableResource;
+}

package/lib/aspect/aspect.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppAspect = void 0;
+const lambda_function_1 = require("@cdktn/provider-aws/lib/lambda-function");
+const resolver_1 = require("@lafken/resolver");
+const lambdaValues = {
+    env: {},
+    vpcConfig: {},
+};
+class AppAspect {
+    scope;
+    id;
+    props;
+    env;
+    vpcConfig;
+    constructor(scope, id, props) {
+        this.scope = scope;
+        this.id = id;
+        this.props = props;
+        this.initializeEnvironment();
+        this.initializeVpcConfig();
+    }
+    visit(node) {
+        if (this.props.tags && this.isTaggableResource(node)) {
+            const currentTags = node.tagsInput || {};
+            node.tags = { ...this.props.tags, ...currentTags };
+        }
+        if (node instanceof lambda_function_1.LambdaFunction) {
+            this.addEnvironmentValues(node);
+            this.addVpcConfig(node);
+        }
+    }
+    initializeEnvironment() {
+        if (!this.props.environment) {
+            return;
+        }
+        const values = new resolver_1.Environment(this.scope, `${this.id}-env`, this.props.environment).getValues();
+        if (values === false) {
+            throw new Error(`resources in ${this.id} env not found`);
+        }
+        this.env = values;
+    }
+    initializeVpcConfig() {
+        if (!this.props.vpc) {
+            return;
+        }
+        this.vpcConfig =
+            typeof this.props.vpc === 'function'
+                ? this.props.vpc((0, resolver_1.resolverSSMValues)(this.scope))
+                : this.props.vpc;
+    }
+    addEnvironmentValues(node) {
+        if (!this.env) {
+            return;
+        }
+        const currentVars = node.environmentInput?.variables || {};
+        lambdaValues.env[node.node.addr] ??= currentVars;
+        node.putEnvironment({
+            variables: {
+                ...currentVars,
+                ...this.env,
+                ...lambdaValues.env[node.node.addr],
+            },
+        });
+    }
+    addVpcConfig(node) {
+        if (!this.vpcConfig) {
+            return;
+        }
+        lambdaValues.vpcConfig[node.node.addr] ??= node.vpcConfigInput || {};
+        const hasProperties = Object.keys(lambdaValues.vpcConfig[node.node.addr]).length > 0;
+        node.putVpcConfig(hasProperties ? lambdaValues.vpcConfig[node.node.addr] : this.vpcConfig);
+    }
+    isTaggableResource(resource) {
+        return 'tags' in resource && 'tagsInput' in resource;
+    }
+}
+exports.AppAspect = AppAspect;

package/lib/aspect/aspect.types.d.ts

@@ -0,0 +1,15 @@
+import type { EnvironmentValue, VpcConfigValue } from '@lafken/common';
+import type { Construct } from 'constructs';
+export interface TaggableResource extends Construct {
+    tags?: Record<string, string>;
+    tagsInput?: Record<string, string>;
+}
+export interface AppAspectProps {
+    tags?: Record<string, string>;
+    environment?: EnvironmentValue;
+    vpc?: VpcConfigValue;
+}
+export interface OriginalLambdaValue {
+    env: Record<string, Record<string, string>>;
+    vpcConfig: Record<string, any>;
+}

package/lib/aspect/aspect.types.js

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

package/lib/context/context.d.ts

@@ -0,0 +1,5 @@
+import type { Construct } from 'constructs';
+import type { ContextProps } from './context.types';
+export declare class AppContext {
+    constructor(scope: Construct, props: ContextProps);
+}

package/lib/context/context.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppContext = void 0;
+class AppContext {
+    constructor(scope, props) {
+        const { contextName, globalConfig = {} } = props;
+        const { services: _services, vpcConfig: _vpcConfig, env: _env, ...contextData } = globalConfig || {};
+        scope.node.setContext(contextName, {
+            ...contextData,
+            contextCreator: props.contextCreator,
+        });
+    }
+}
+exports.AppContext = AppContext;

package/lib/context/context.types.d.ts

@@ -0,0 +1,6 @@
+import type { LambdaGlobalConfig } from '@lafken/resolver';
+export interface ContextProps {
+    globalConfig?: LambdaGlobalConfig;
+    contextCreator: string;
+    contextName: string;
+}

package/lib/context/context.types.js

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

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './app';
+export * from './module';

package/lib/index.js

@@ -0,0 +1,18 @@
+"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("./app"), exports);
+__exportStar(require("./module"), exports);

package/lib/module/index.d.ts

@@ -0,0 +1,2 @@
+export * from './module';
+export * from './module.types';

package/lib/module/index.js

@@ -0,0 +1,18 @@
+"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("./module"), exports);
+__exportStar(require("./module.types"), exports);

package/lib/module/module.d.ts

@@ -0,0 +1,35 @@
+import { Construct } from 'constructs';
+import type { CreateModuleProps, ModuleConstruct, ModuleProps, ModuleResolverType } from './module.types';
+export declare class StackModule extends Construct {
+    id: string;
+    private props;
+    constructor(scope: Construct, id: string, props: ModuleProps);
+    generateResources(): Promise<void>;
+    private createRole;
+    private addAspectProperties;
+}
+/**
+ * Creates a module factory for the Lafken application.
+ *
+ * Returns a function that, when invoked by `createApp`, instantiates a
+ * `StackModule` and processes all its declared resources through the
+ * registered resolvers. Each module groups related resources into a
+ * logical unit with its own scope, IAM role, tags, and optional
+ * Lambda configuration.
+ *
+ * @param props - The module configuration including name, resources, and
+ * optional global settings scoped to this module.
+ * @returns A factory function consumed by `createApp` to build the module
+ * within the application stack.
+ *
+ * @example
+ * createModule({
+ *   name: 'users',
+ *   resources: [UserApi, UserQueue],
+ *   globalConfig: {
+ *     lambda: { memory: 256, services: ['dynamodb'] },
+ *     tags: { team: 'backend' },
+ *   },
+ * })
+ */
+export declare const createModule: (props: CreateModuleProps) => (scope: ModuleConstruct, resolvers: Record<string, ModuleResolverType>) => Promise<StackModule>;

package/lib/module/module.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModule = exports.StackModule = void 0;
+const common_1 = require("@lafken/common");
+const resolver_1 = require("@lafken/resolver");
+const cdktn_1 = require("cdktn");
+const constructs_1 = require("constructs");
+const aspect_1 = require("../aspect/aspect");
+const context_1 = require("../context/context");
+class StackModule extends constructs_1.Construct {
+    id;
+    props;
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.id = id;
+        this.props = props;
+        new context_1.AppContext(this, {
+            contextName: resolver_1.ContextName.module,
+            globalConfig: props.globalConfig?.lambda,
+            contextCreator: props.name,
+        });
+        this.createRole();
+    }
+    async generateResources() {
+        const { resources } = this.props;
+        for (const resource of resources) {
+            const metadata = (0, common_1.getResourceMetadata)(resource);
+            const resolver = this.props.resolvers[metadata.type];
+            if (!resolver) {
+                throw new Error(`There is no resolver for the resource ${metadata.type}`);
+            }
+            await resolver.create(this, resource);
+        }
+        this.addAspectProperties();
+    }
+    createRole() {
+        if (!this.props.globalConfig?.lambda?.services?.length) {
+            return;
+        }
+        const roleName = `${this.props.name}-module-role`;
+        const lambdaRole = new resolver_1.Role(this, roleName, {
+            name: roleName,
+            services: this.props.globalConfig?.lambda?.services || [],
+        });
+        lambdaRole.isGlobal('module', roleName);
+    }
+    addAspectProperties() {
+        cdktn_1.Aspects.of(this).add(new aspect_1.AppAspect(this, this.props.name, {
+            tags: {
+                ...(this.props.globalConfig?.tags || {}),
+                'lafken:module': this.props.name,
+            },
+            environment: this.props.globalConfig?.lambda?.env,
+            vpc: this.props.globalConfig?.lambda?.vpcConfig,
+        }));
+    }
+}
+exports.StackModule = StackModule;
+/**
+ * Creates a module factory for the Lafken application.
+ *
+ * Returns a function that, when invoked by `createApp`, instantiates a
+ * `StackModule` and processes all its declared resources through the
+ * registered resolvers. Each module groups related resources into a
+ * logical unit with its own scope, IAM role, tags, and optional
+ * Lambda configuration.
+ *
+ * @param props - The module configuration including name, resources, and
+ * optional global settings scoped to this module.
+ * @returns A factory function consumed by `createApp` to build the module
+ * within the application stack.
+ *
+ * @example
+ * createModule({
+ *   name: 'users',
+ *   resources: [UserApi, UserQueue],
+ *   globalConfig: {
+ *     lambda: { memory: 256, services: ['dynamodb'] },
+ *     tags: { team: 'backend' },
+ *   },
+ * })
+ */
+const createModule = (props) => async (scope, resolvers) => {
+    const module = new StackModule(scope, props.name, {
+        ...props,
+        resolvers,
+    });
+    await module.generateResources();
+    return module;
+};
+exports.createModule = createModule;

package/lib/module/module.types.d.ts

@@ -0,0 +1,42 @@
+import type { ClassResource, ResourceMetadata } from '@lafken/common';
+import type { ResolverType } from '@lafken/resolver';
+import type { Construct } from 'constructs';
+import type { GlobalConfig } from '../app/app.types';
+import type { StackModule } from './module';
+export interface CreateModuleProps {
+    /**
+     * Module name.
+     *
+     * Specifies the name of the module, which will be used as an identifier
+     * for all resources created within this stack.
+     */
+    name: string;
+    /**
+     * Module resources.
+     *
+     * Defines the list of resources to be created within this stack.
+     * Each item represents a resource such as Api, Queue, StateMachine, etc.
+     */
+    resources: ClassResource[];
+    /**
+     * Module-level global configuration.
+     *
+     * Provides settings that are applied to all resources and Lambda functions
+     * within this specific module. This configuration behaves similarly to
+     * the application-wide `GlobalConfig`, but excludes environment settings (`env`),
+     * which are managed at the application level.
+     */
+    globalConfig?: Omit<GlobalConfig, 'env'>;
+}
+export interface ModuleProps extends CreateModuleProps {
+    resolvers: Record<string, ResolverType>;
+}
+export interface ModuleResource {
+    module: StackModule;
+    metadata: ResourceMetadata;
+    Resource: ClassResource;
+}
+export interface ModuleResolverType extends ResolverType {
+}
+export interface ModuleConstruct extends Construct {
+}

package/lib/module/module.types.js

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

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@lafken/main",
+  "version": "0.10.1",
+  "private": false,
+  "description": "Lafken core engine - orchestrate AWS serverless infrastructure using decorators with automatic CDKTN code generation",
+  "keywords": [
+    "aws",
+    "serverless",
+    "lafken",
+    "infrastructure",
+    "infrastructure-as-code",
+    "cdktn",
+    "typescript",
+    "decorators",
+    "terraform"
+  ],
+  "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/main"
+  },
+  "license": "MIT",
+  "author": "Aníbal Jorquera",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib"
+  ],
+  "dependencies": {
+    "reflect-metadata": "^0.2.2",
+    "@lafken/resolver": "0.10.1"
+  },
+  "devDependencies": {
+    "@cdktn/provider-aws": "^23.5.0",
+    "cdktn": "^0.22.1",
+    "cdktn-vitest": "^1.0.0",
+    "constructs": "^10.6.0",
+    "typescript": "6.0.2",
+    "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"
+  }
+}