@lafken/common 0.6.0

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,66 @@
+# @lafken/common
+
+`@lafken/common` is the core utility package for the Lafken framework. It provides the essential factory functions and utilities used to create the decorators that define infrastructure resources and Lambda handlers throughout the ecosystem.
+
+## Features
+
+### Decorator Factories
+
+The package exports powerful factories to create custom decorators that integrate with the framework's metadata system.
+
+#### `createResourceDecorator`
+
+Use this factory to create class-level decorators that mark a class as a deployable resource (e.g., a State Machine, a Queue, or a custom Event).
+
+It automatically captures:
+- The resource name.
+- The file path and folder name (for bundling).
+- Custom metadata defined in your props.
+
+```typescript
+import { createResourceDecorator } from '@lafken/common';
+
+export const MyCustomResource = createResourceDecorator({
+  type: 'MY_CUSTOM_RESOURCE',
+  callerFileIndex: 5, // Adjusts stack trace to find the caller file
+});
+
+// Usage
+@MyCustomResource({ ... })
+export class MyService { ... }
+```
+
+#### `createLambdaDecorator`
+
+Use this factory to create method-level decorators that mark methods as Lambda function handlers. It handles:
+- Method metadata reflection.
+- Argument injection (Event, Context, Callback).
+
+```typescript
+import { createLambdaDecorator } from '@lafken/common';
+
+export const MyLambdaTrigger = <T>(props: T) =>
+  createLambdaDecorator({
+    getLambdaMetadata: (props, methodName) => ({
+      ...props,
+      name: methodName,
+    }),
+  })(props);
+
+// Usage
+class MyService {
+  @MyLambdaTrigger({ ... })
+  handleRequest(@Event() event: any) { ... }
+}
+```
+
+### Metadata Utilities
+
+`@lafken/common` provides utilities to read the metadata stored by these decorators, which resolvers use to build the actual infrastructure.
+
+- `getResourceMetadata(target)`: Retrieves metadata from a resource class.
+- `getResourceHandlerMetadata(target)`: Retrieves metadata for all lambda handlers in a class.
+
+## Usage
+
+This package is intended for internal use within the Lafken framework or for advanced users extending the framework with custom resource types. It ensures consistent metadata handling across all `@lafken/*` packages.

package/lib/constants/env.constants.d.ts

@@ -0,0 +1,2 @@
+export declare const LAFKEN_CONTEXT = "LAFKEN_CONTEXT";
+export declare const LAFKEN_CONTEXT_VALUE = "BUILD";

package/lib/constants/env.constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LAFKEN_CONTEXT_VALUE = exports.LAFKEN_CONTEXT = void 0;
+exports.LAFKEN_CONTEXT = 'LAFKEN_CONTEXT';
+exports.LAFKEN_CONTEXT_VALUE = 'BUILD';

package/lib/constants/index.d.ts

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

package/lib/constants/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("./env.constants"), exports);

package/lib/decorators/field/field.d.ts

@@ -0,0 +1,9 @@
+import 'reflect-metadata';
+import { type AllowedTypes, type BaseFieldMetadata, type CreateFieldDecoratorProps, FieldProperties, type FieldProps, type PrimitiveTypes } from './field.types';
+export declare const primitiveTypeValues: Set<PrimitiveTypes>;
+export declare const primitiveTypeofValues: Set<string>;
+export declare const mapTypeofValueToPrimitiveType: Record<string, PrimitiveTypes>;
+export declare const getPrimitiveType: (type: AllowedTypes) => PrimitiveTypes | undefined;
+export declare const getEventFields: (prefix: string, target?: AllowedTypes, name?: string) => BaseFieldMetadata | undefined;
+export declare const createFieldDecorator: <T extends FieldProps, M>({ prefix, enableInLambdaInvocation, getMetadata, }: CreateFieldDecoratorProps<T, M>) => (props?: T) => (target: any, destinationName: string) => void;
+export declare const createFieldName: (prefix: string, type: FieldProperties) => string;

package/lib/decorators/field/field.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFieldName = exports.createFieldDecorator = exports.getEventFields = exports.getPrimitiveType = exports.mapTypeofValueToPrimitiveType = exports.primitiveTypeofValues = exports.primitiveTypeValues = void 0;
+require("reflect-metadata");
+const utils_1 = require("../../utils");
+const build_env_utils_1 = require("../../utils/build-env.utils");
+const field_types_1 = require("./field.types");
+exports.primitiveTypeValues = new Set([
+    'Boolean',
+    'Number',
+    'String',
+]);
+exports.primitiveTypeofValues = new Set(['boolean', 'number', 'string']);
+exports.mapTypeofValueToPrimitiveType = {
+    boolean: 'Boolean',
+    number: 'Number',
+    string: 'String',
+};
+const getPrimitiveType = (type) => {
+    if (type === String)
+        return 'String';
+    if (type === Number)
+        return 'Number';
+    if (type === Boolean)
+        return 'Boolean';
+};
+exports.getPrimitiveType = getPrimitiveType;
+const getEventFields = (prefix, target, name = 'event') => {
+    if (!target) {
+        return undefined;
+    }
+    return getFieldMetadata({
+        destinationName: name,
+        type: `${name}_type`,
+        fieldProps: {
+            type: target,
+        },
+        prefix,
+    });
+};
+exports.getEventFields = getEventFields;
+const getObjectMetadata = (metadata, payloadClass, prefix) => {
+    const payloadMetadata = (0, utils_1.getMetadataByKey)(payloadClass, (0, exports.createFieldName)(prefix, field_types_1.FieldProperties.payload)) || {
+        name: payloadClass.name,
+        id: payloadClass.name,
+    };
+    const properties = (0, utils_1.getMetadataPrototypeByKey)(payloadClass, (0, exports.createFieldName)(prefix, field_types_1.FieldProperties.field));
+    if (!properties?.length) {
+        throw new Error(`should include Field properties in ${payloadClass.name} class`);
+    }
+    return {
+        ...metadata,
+        properties,
+        type: 'Object',
+        payload: payloadMetadata,
+    };
+};
+const getFieldMetadata = (props) => {
+    const { fieldProps, destinationName, type, prefix } = props;
+    const metadata = {
+        destinationName,
+        name: fieldProps?.name || destinationName,
+    };
+    const primitiveType = (0, exports.getPrimitiveType)(type);
+    const typeHasValue = exports.mapTypeofValueToPrimitiveType[typeof fieldProps?.type];
+    if (fieldProps?.type !== undefined) {
+        if (typeof fieldProps.type === 'function') {
+            return getObjectMetadata(metadata, fieldProps.type, prefix);
+        }
+        if (Array.isArray(fieldProps.type)) {
+            const arrayPrimitiveType = (0, exports.getPrimitiveType)(fieldProps.type[0]);
+            let items;
+            if (arrayPrimitiveType) {
+                items = {
+                    type: arrayPrimitiveType,
+                    name: arrayPrimitiveType,
+                    destinationName: arrayPrimitiveType,
+                };
+            }
+            else {
+                if (typeof fieldProps.type[0] === 'function') {
+                    items = getObjectMetadata({
+                        name: 'Object',
+                        destinationName: 'Object',
+                    }, fieldProps.type[0], prefix);
+                }
+            }
+            return {
+                ...metadata,
+                type: 'Array',
+                items,
+            };
+        }
+    }
+    if (exports.primitiveTypeValues.has(type) ||
+        exports.primitiveTypeValues.has(primitiveType) ||
+        typeHasValue) {
+        return {
+            type: primitiveType || typeHasValue || type,
+            initialValue: typeHasValue ? fieldProps?.type : undefined,
+            ...metadata,
+        };
+    }
+    throw new Error(`unidentified type ${type} in ${destinationName} field`);
+};
+const createFieldDecorator = ({ prefix, enableInLambdaInvocation, getMetadata, }) => (props) => (target, destinationName) => {
+    if (!(0, build_env_utils_1.isBuildEnvironment)() && !enableInLambdaInvocation) {
+        return;
+    }
+    const filedKey = (0, exports.createFieldName)(prefix, field_types_1.FieldProperties.field);
+    const fields = (0, utils_1.getMetadataByKey)(target, filedKey) || [];
+    const propertyType = Reflect.getMetadata('design:type', target, destinationName).name;
+    const parentMetadata = getMetadata(props);
+    const metadata = [
+        ...fields,
+        {
+            ...parentMetadata,
+            ...getFieldMetadata({
+                destinationName,
+                type: propertyType,
+                fieldProps: props,
+                prefix,
+            }),
+        },
+    ];
+    Reflect.defineMetadata(filedKey, metadata, target);
+};
+exports.createFieldDecorator = createFieldDecorator;
+const createFieldName = (prefix, type) => {
+    return `${prefix}:${type}`;
+};
+exports.createFieldName = createFieldName;

package/lib/decorators/field/field.types.d.ts

@@ -0,0 +1,69 @@
+import type { PayloadMetadata } from '../payload';
+export type BasicTypes = StringConstructor | NumberConstructor | BooleanConstructor;
+export type AllowedTypes = String | Number | Boolean | Function | [String | Number | Boolean | Function];
+export type AllowedTypesWithoutFunction = BasicTypes | [BasicTypes];
+export type EnumValue = (string | number)[];
+export interface FieldProps {
+    /**
+     * Original field name.
+     *
+     * Specifies the original name of the field as it is expected
+     * in the input or payload. This is used to map incoming data
+     * to the corresponding property in the system.
+     */
+    name?: string;
+    /**
+     * Field data type.
+     *
+     * Specifies the type of the field. By default, the type is inferred
+     * from the property that decorates the field. However, it can be
+     * explicitly set to a primitive type such as `String`, `Number`,
+     * `Boolean`, or to another payload type.
+     *
+     * This ensures correct parsing, validation, and serialization of the field's value.
+     */
+    type?: AllowedTypes;
+}
+export interface BaseFieldMetadata {
+    name: string;
+    destinationName: string;
+}
+export interface StringField extends BaseFieldMetadata {
+    type: 'String';
+    initialValue?: string;
+}
+export interface NumberField extends BaseFieldMetadata {
+    type: 'Number';
+    initialValue?: number;
+}
+export interface BooleanField extends BaseFieldMetadata {
+    type: 'Boolean';
+    initialValue?: boolean;
+}
+export interface ObjectField extends BaseFieldMetadata {
+    type: 'Object';
+    properties: FieldMetadata[];
+    payload: PayloadMetadata;
+}
+export interface ArrayField extends BaseFieldMetadata {
+    type: 'Array';
+    items: FieldMetadata;
+}
+export type FieldMetadata = StringField | NumberField | BooleanField | ObjectField | ArrayField;
+export type FieldTypes = FieldMetadata['type'];
+export type PrimitiveTypes = Extract<FieldTypes, 'String' | 'Number' | 'Boolean'>;
+export declare enum FieldProperties {
+    field = "lafken:field",
+    payload = "lafken:payload"
+}
+export interface CreateFieldDecoratorProps<P extends FieldProps, M> {
+    prefix: string;
+    enableInLambdaInvocation?: boolean;
+    getMetadata: (props?: P) => Omit<M, keyof FieldMetadata>;
+}
+export interface GetFieldMetadataProps {
+    type: string;
+    prefix: string;
+    destinationName: string;
+    fieldProps?: FieldProps;
+}

package/lib/decorators/field/field.types.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldProperties = void 0;
+var FieldProperties;
+(function (FieldProperties) {
+    FieldProperties["field"] = "lafken:field";
+    FieldProperties["payload"] = "lafken:payload";
+})(FieldProperties || (exports.FieldProperties = FieldProperties = {}));

package/lib/decorators/field/index.d.ts

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

package/lib/decorators/field/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("./field"), exports);
+__exportStar(require("./field.types"), exports);

package/lib/decorators/index.d.ts

@@ -0,0 +1,4 @@
+export * from './field';
+export * from './lambda';
+export * from './payload';
+export * from './resource';

package/lib/decorators/index.js

@@ -0,0 +1,20 @@
+"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("./field"), exports);
+__exportStar(require("./lambda"), exports);
+__exportStar(require("./payload"), exports);
+__exportStar(require("./resource"), exports);

package/lib/decorators/lambda/index.d.ts

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

package/lib/decorators/lambda/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("./lambda"), exports);
+__exportStar(require("./lambda.types"), exports);

package/lib/decorators/lambda/lambda.d.ts

@@ -0,0 +1,8 @@
+import 'reflect-metadata';
+import { type AllowedTypes } from '../field';
+import { type CreateEventDecoratorProps, type CreateLambdaDecoratorProps, LambdaArgumentTypes } from './lambda.types';
+export declare const reflectArgumentMethod: (target: Function, methodName: string, type: LambdaArgumentTypes) => void;
+export declare const createLambdaDecorator: <T, M>({ getLambdaMetadata, descriptorValue, argumentParser, }: CreateLambdaDecoratorProps<T, M>) => (props?: T) => (target: any, methodName: string, descriptor: PropertyDescriptor) => any;
+export declare const createEventDecorator: ({ enableInLambdaInvocation, prefix }: CreateEventDecoratorProps) => (eventField: AllowedTypes) => (target: any, methodName: string, _number: number) => void;
+export declare const Callback: () => (target: any, methodName: string, _number: number) => void;
+export declare const Context: () => (target: any, methodName: string, _number: number) => void;

package/lib/decorators/lambda/lambda.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = exports.Callback = exports.createEventDecorator = exports.createLambdaDecorator = exports.reflectArgumentMethod = void 0;
+require("reflect-metadata");
+const utils_1 = require("../../utils");
+const field_1 = require("../field");
+const lambda_types_1 = require("./lambda.types");
+const argumentsByType = {
+    [lambda_types_1.LambdaArgumentTypes.event]: ({ event }) => event,
+    [lambda_types_1.LambdaArgumentTypes.callback]: ({ callback }) => callback,
+    [lambda_types_1.LambdaArgumentTypes.context]: ({ context }) => context,
+};
+const reflectArgumentMethod = (target, methodName, type) => {
+    const properties = Reflect.getMetadata(lambda_types_1.LambdaReflectKeys.arguments, target) || {};
+    properties[methodName] = [type, ...(properties[methodName] || [])];
+    Reflect.defineMetadata(lambda_types_1.LambdaReflectKeys.arguments, properties, target);
+};
+exports.reflectArgumentMethod = reflectArgumentMethod;
+const createLambdaDecorator = ({ getLambdaMetadata, descriptorValue, argumentParser, }) => (props) => (target, methodName, descriptor) => {
+    if ((0, utils_1.isBuildEnvironment)()) {
+        const handlersMetadata = Reflect.getMetadata(lambda_types_1.LambdaReflectKeys.handlers, target) || [];
+        Reflect.defineMetadata(lambda_types_1.LambdaReflectKeys.handlers, [...handlersMetadata, getLambdaMetadata(props || {}, methodName)], target);
+    }
+    const lambdaArguments = Reflect.getMetadata(lambda_types_1.LambdaReflectKeys.arguments, target);
+    if (descriptorValue) {
+        return descriptorValue(descriptor);
+    }
+    const { value: originalValue } = descriptor;
+    const mapArgumentMethod = {
+        ...argumentsByType,
+        ...argumentParser,
+    };
+    descriptor.value = async (event, context, callback) => {
+        const methodArguments = (lambdaArguments?.[methodName] || []).map((argumentType) => mapArgumentMethod[argumentType]({ event, context, methodName, target, callback }));
+        const response = await originalValue.apply(this, methodArguments);
+        return response;
+    };
+};
+exports.createLambdaDecorator = createLambdaDecorator;
+const reflectEventMetadata = (target, methodName, key, data) => {
+    const argumentsByMethod = Reflect.getMetadata(key, target) || {};
+    Reflect.defineMetadata(key, {
+        ...argumentsByMethod,
+        ...(data ? { [methodName]: data } : {}),
+    }, target);
+};
+const createEventDecorator = ({ enableInLambdaInvocation = false, prefix }) => (eventField) => (target, methodName, _number) => {
+    (0, exports.reflectArgumentMethod)(target, methodName, lambda_types_1.LambdaArgumentTypes.event);
+    if (!eventField || (!enableInLambdaInvocation && !(0, utils_1.isBuildEnvironment)())) {
+        return;
+    }
+    const field = (0, field_1.getEventFields)(prefix, eventField);
+    reflectEventMetadata(target, methodName, lambda_types_1.LambdaReflectKeys.event_param, field);
+};
+exports.createEventDecorator = createEventDecorator;
+const Callback = () => (target, methodName, _number) => {
+    (0, exports.reflectArgumentMethod)(target, methodName, lambda_types_1.LambdaArgumentTypes.callback);
+};
+exports.Callback = Callback;
+const Context = () => (target, methodName, _number) => {
+    (0, exports.reflectArgumentMethod)(target, methodName, lambda_types_1.LambdaArgumentTypes.context);
+};
+exports.Context = Context;

package/lib/decorators/lambda/lambda.types.d.ts

@@ -0,0 +1,126 @@
+import type { EnvironmentValue } from '../../types';
+import type { ServicesValues } from '../../types/services.types';
+export interface LambdaProps {
+    /**
+     * Lambda execution timeout.
+     *
+     * Specifies the maximum amount of time (in seconds) that the Lambda
+     * function is allowed to run before being terminated. If the execution
+     * exceeds this limit, the function will be stopped and an error will be raised.
+     */
+    timeout?: number;
+    /**
+     * Lambda memory allocation.
+     *
+     * Specifies the amount of memory (in MB) allocated to the Lambda function.
+     * Increasing memory also increases the CPU and network resources proportionally.
+     */
+    memory?: number;
+    /**
+     * Lambda NodeJS runtime
+     *
+     * Defines the Node.js runtime environment that the Lambda will use
+     * during execution. Only supported LTS versions are allowed to ensure
+     * long-term stability and AWS compatibility.
+     *
+     * Supported values:
+     * - `24` → Node.js 24
+     * - `22` → Node.js 22
+     * - `20` → Node.js 20
+     */
+    runtime?: 24 | 22 | 20;
+    /**
+     * Lambda services.
+     *
+     * Defines which AWS services the Lambda function is allowed to access.
+     * Internally, a role is created with the specified service permissions,
+     * granting the Lambda the ability to interact with those resources.
+     */
+    services?: ServicesValues;
+    /**
+     * Lambda environments.
+     *
+     * Defines environment values that will be applied specifically to
+     * this Lambda. These values override any global or stack-level
+     * environment configuration.
+     *
+     * Values can be provided in three formats:
+     * 1. `string` - The value will be taken from the `.env` file if present.
+     * 2. `Record<string, string | number | boolean | EnvFunction>` - Directly provides the value as a string.
+     * 3. `Record<string, EnvFunction>` - Functions can compute dynamic values based on resources
+     *    created in the project, using the `getResourceValue` helper.
+     *
+     * @example
+     * // Load value from .env
+     * ["ENV_VALUE"]
+     *
+     * @example
+     * // Provide static values
+     * [
+     *   { "ENV_VALUE": "static_string" },
+     *   { "ENV_NUMBER": 123 }
+     * ]
+     *
+     * @example
+     * // Provide dynamic values from resources
+     * [
+     *   {
+     *     "ENV_VALUE": {
+     *       name: "any",
+     *       other: ({ getResourceValue }) => getResourceValue("s3_bucket", "arn")
+     *     }
+     *   }
+     * ]
+     */
+    env?: EnvironmentValue;
+    /**
+     * Lambda tags.
+     *
+     * Specifies a set of tags that will be applied to lambda function.
+     */
+    tags?: Record<string, string>;
+    /**
+     * Enables AWS X-Ray tracing for Lambda function.
+     *
+     * When set to `true`, X-Ray tracing is activated, allowing you to
+     * collect detailed information about requests, performance, and
+     * interactions with other AWS services.
+     *
+     * This is useful for debugging, monitoring, and gaining visibility
+     * into the execution flow of your Lambda.
+     */
+    enableTrace?: boolean;
+}
+export interface LambdaMetadata {
+    name: string;
+    lambda?: LambdaProps;
+    description?: string;
+}
+export declare enum LambdaReflectKeys {
+    handlers = "lambda:handlers",
+    arguments = "lambda:arguments",
+    event_param = "lambda:event_params"
+}
+export declare enum LambdaArgumentTypes {
+    event = "event",
+    callback = "callback",
+    context = "context"
+}
+export type CallbackParam = (error: boolean | null, response?: any) => void;
+export type LambdaArguments = Record<string, LambdaArgumentTypes[]>;
+export type LambdaArgumentsType = Record<LambdaArgumentTypes, ({ event, context, callback, }: {
+    event: any;
+    context: any;
+    methodName: string;
+    target: any;
+    callback: CallbackParam;
+}) => any>;
+export interface CreateLambdaDecoratorProps<T, M> {
+    getLambdaMetadata: (params: T, methodName: string) => M;
+    descriptorValue?: (descriptor: PropertyDescriptor) => any;
+    argumentParser?: Partial<LambdaArgumentsType | (string & {})>;
+}
+export interface CreateEventDecoratorProps {
+    prefix: string;
+    enableInLambdaInvocation?: boolean;
+}

package/lib/decorators/lambda/lambda.types.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LambdaArgumentTypes = exports.LambdaReflectKeys = void 0;
+var LambdaReflectKeys;
+(function (LambdaReflectKeys) {
+    LambdaReflectKeys["handlers"] = "lambda:handlers";
+    LambdaReflectKeys["arguments"] = "lambda:arguments";
+    LambdaReflectKeys["event_param"] = "lambda:event_params";
+})(LambdaReflectKeys || (exports.LambdaReflectKeys = LambdaReflectKeys = {}));
+var LambdaArgumentTypes;
+(function (LambdaArgumentTypes) {
+    LambdaArgumentTypes["event"] = "event";
+    LambdaArgumentTypes["callback"] = "callback";
+    LambdaArgumentTypes["context"] = "context";
+})(LambdaArgumentTypes || (exports.LambdaArgumentTypes = LambdaArgumentTypes = {}));

package/lib/decorators/payload/index.d.ts

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

package/lib/decorators/payload/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("./payload"), exports);
+__exportStar(require("./payload.types"), exports);

package/lib/decorators/payload/payload.d.ts

@@ -0,0 +1,2 @@
+import type { CreatePayloadDecoratorProps, PayloadProps } from './payload.types';
+export declare const createPayloadDecorator: <T extends PayloadProps, M>({ prefix, getMetadata, createUniqueId, enableInLambdaInvocation, }: CreatePayloadDecoratorProps<T, M>) => (props?: T) => (target: Function) => void;

package/lib/decorators/payload/payload.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPayloadDecorator = void 0;
+const utils_1 = require("../../utils");
+const field_1 = require("../field");
+const payloadIds = {};
+const createPayloadDecorator = ({ prefix, getMetadata, createUniqueId = false, enableInLambdaInvocation = false, }) => (props) => (target) => {
+    if (!(0, utils_1.isBuildEnvironment)() && !enableInLambdaInvocation) {
+        return;
+    }
+    const { name = target.name } = props || {};
+    let id = name;
+    if (createUniqueId) {
+        payloadIds[name] ??= 0;
+        if (payloadIds[name] > 0) {
+            id = `${name}_${payloadIds[name]}`;
+        }
+        payloadIds[name]++;
+    }
+    let payloadMetadata = {
+        id,
+        name,
+    };
+    if (getMetadata) {
+        payloadMetadata = {
+            ...payloadMetadata,
+            ...getMetadata(props),
+        };
+    }
+    Reflect.defineMetadata(`${prefix}:${field_1.FieldProperties.payload}`, payloadMetadata, target);
+};
+exports.createPayloadDecorator = createPayloadDecorator;

package/lib/decorators/payload/payload.types.d.ts

@@ -0,0 +1,18 @@
+export interface PayloadProps {
+    /**
+     * Payload name.
+     *
+     * Specifies the name of the payload, which is used to identify
+     * it within the application or during data processing.
+     */
+    name?: string;
+}
+export interface PayloadMetadata extends Required<PayloadProps> {
+    id: string;
+}
+export interface CreatePayloadDecoratorProps<P extends PayloadProps, M> {
+    prefix: string;
+    enableInLambdaInvocation?: boolean;
+    createUniqueId?: boolean;
+    getMetadata?: (props?: P) => Omit<M, keyof PayloadMetadata>;
+}

package/lib/decorators/payload/payload.types.js

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

package/lib/decorators/resource/index.d.ts

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

package/lib/decorators/resource/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("./resource"), exports);
+__exportStar(require("./resource.types"), exports);

package/lib/decorators/resource/resource.d.ts

@@ -0,0 +1,2 @@
+import { type ResourceDecoratorProps, type ResourceProps } from './resource.types';
+export declare const createResourceDecorator: <T extends ResourceProps>(decoratorProps: ResourceDecoratorProps<T>) => (props?: T) => (constructor: Function) => void;

package/lib/decorators/resource/resource.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createResourceDecorator = void 0;
+const node_path_1 = require("node:path");
+const utils_1 = require("../../utils");
+const path_utils_1 = require("../../utils/path.utils");
+const resource_types_1 = require("./resource.types");
+const createResourceDecorator = (decoratorProps) => (props) => (constructor) => {
+    if (!(0, utils_1.isBuildEnvironment)()) {
+        return;
+    }
+    const { type, callerFileIndex, getMetadata = () => props } = decoratorProps;
+    const additionalMetadata = getMetadata(props || {});
+    const callerFile = (0, path_utils_1.getCallerFileName)(callerFileIndex);
+    Reflect.defineMetadata(resource_types_1.ResourceReflectKeys.resource, {
+        ...additionalMetadata,
+        type,
+        name: props?.name || constructor.name,
+        foldername: (0, node_path_1.dirname)(callerFile),
+        filename: (0, node_path_1.basename)(callerFile).replace('.js', ''),
+        originalName: constructor.name,
+        minify: props?.minify ?? true,
+    }, constructor);
+};
+exports.createResourceDecorator = createResourceDecorator;

package/lib/decorators/resource/resource.types.d.ts

@@ -0,0 +1,31 @@
+export declare enum ResourceReflectKeys {
+    resource = "resource"
+}
+export interface ResourceProps {
+    /**
+     * Resource name.
+     *
+     * Specifies the name of the resource. This name is used to identify
+     * the resource within the application, stack, or deployment.
+     */
+    name?: string;
+    /**
+     * Resource minify
+     *
+     * Specifies whether the code should be minified when the resource is processed
+     *
+     * @default true
+     */
+    minify?: boolean;
+}
+export interface ResourceMetadata extends Required<ResourceProps> {
+    type: string;
+    filename: string;
+    foldername: string;
+    originalName: string;
+}
+export interface ResourceDecoratorProps<T> {
+    type: string;
+    callerFileIndex?: number;
+    getMetadata?: (props: T) => T;
+}

package/lib/decorators/resource/resource.types.js

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

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from './constants/env.constants';
+export * from './decorators';
+export * from './types';
+export * from './utils';

package/lib/index.js

@@ -0,0 +1,20 @@
+"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("./constants/env.constants"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);

package/lib/types/env.types.d.ts

@@ -0,0 +1,4 @@
+import type { GetResourceProps } from './resource.types';
+type EvnFunction = (props: GetResourceProps) => Record<string, string>;
+export type EnvironmentValue = Record<string, string> | EvnFunction;
+export {};

package/lib/types/env.types.js

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

package/lib/types/index.d.ts

@@ -0,0 +1,7 @@
+export * from './env.types';
+export * from './output.types';
+export * from './override-resources.types';
+export * from './resource.types';
+export * from './services.types';
+export * from './time.types';
+export * from './utilities.types';

package/lib/types/index.js

@@ -0,0 +1,23 @@
+"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("./env.types"), exports);
+__exportStar(require("./output.types"), exports);
+__exportStar(require("./override-resources.types"), exports);
+__exportStar(require("./resource.types"), exports);
+__exportStar(require("./services.types"), exports);
+__exportStar(require("./time.types"), exports);
+__exportStar(require("./utilities.types"), exports);

package/lib/types/output.types.d.ts

@@ -0,0 +1,2 @@
+export type OutputType = 'arn' | 'id';
+export type GetResourceValue<T = string, V = OutputType> = (value: T, type: V) => any;

package/lib/types/output.types.js

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

package/lib/types/override-resources.types.d.ts

@@ -0,0 +1,35 @@
+import type { ResourceIdentifiers, ScopedResourceNames } from './utilities.types';
+export type ModuleGlobalReferenceNames = 'api' | 'auth' | 'bucket' | 'dynamo' | 'event-bus';
+export interface ModulesAvailable {
+}
+export interface AuthAvailable {
+}
+export interface BucketAvailable {
+}
+export interface ApiRestAvailable {
+}
+export interface ApiAuthorizerAvailable {
+}
+export interface EventBusAvailable {
+}
+export interface DynamoTableAvailable {
+}
+type ResourceNames<T> = keyof T | (string & {});
+type StackResourceName<T, S extends ModuleGlobalReferenceNames> = `${S}::${Extract<keyof T, string | number>}` | (string & {});
+export type ModuleNames = ResourceNames<ModulesAvailable>;
+export type AuthNames = ResourceNames<AuthAvailable>;
+export type AuthScopedNames = StackResourceName<AuthAvailable, 'auth'>;
+export type BucketNames = ResourceNames<BucketAvailable>;
+export type BucketScopedNames = StackResourceName<ApiRestAvailable, 'bucket'>;
+export type ApiRestNames = ResourceNames<ApiRestAvailable>;
+export type ApiRestScopedNames = StackResourceName<ApiRestAvailable, 'api'>;
+export type ApiAuthorizerNames = ResourceNames<ApiAuthorizerAvailable>;
+export type EventBusNames = ResourceNames<EventBusAvailable>;
+export type EventBusScopedNames = StackResourceName<ApiRestAvailable, 'event-bus'>;
+export type DynamoTableNames = ResourceNames<DynamoTableAvailable>;
+export type DynamoTableScopedNames = StackResourceName<DynamoTableAvailable, 'dynamo'>;
+export type StateMachineNames = ResourceIdentifiers<ModulesAvailable, 'StateMachine'> | (string & {});
+export type StateMachineScopedNames = ScopedResourceNames<ModulesAvailable, 'StateMachine'> | (string & {});
+export type QueueNames = ResourceIdentifiers<ModulesAvailable, 'Queue'> | (string & {});
+export type QueueScopedNames = ScopedResourceNames<ModulesAvailable, 'Queue'> | (string & {});
+export {};

package/lib/types/override-resources.types.js

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

package/lib/types/resource.types.d.ts

@@ -0,0 +1,8 @@
+import type { GetResourceValue } from './output.types';
+import type { ApiRestScopedNames, AuthScopedNames, BucketScopedNames, DynamoTableScopedNames, EventBusScopedNames, QueueScopedNames, StateMachineScopedNames } from './override-resources.types';
+export interface ClassResource {
+    new (...args: any[]): {};
+}
+export interface GetResourceProps {
+    getResourceValue: GetResourceValue<DynamoTableScopedNames | AuthScopedNames | BucketScopedNames | ApiRestScopedNames | EventBusScopedNames | StateMachineScopedNames | QueueScopedNames>;
+}

package/lib/types/resource.types.js

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

package/lib/types/services.types.d.ts

@@ -0,0 +1,22 @@
+import type { GetResourceProps } from './resource.types';
+export type ServicesName = 'dynamodb' | 's3' | 'lambda' | 'cloudwatch' | 'sqs' | 'state_machine' | 'kms' | 'ssm' | 'event';
+interface PermissionService<T extends ServicesName | 'custom', P extends string> {
+    type: T;
+    permissions?: P[];
+    resources?: string[];
+}
+export type DynamoPermissions = 'Query' | 'Scan' | 'GetItem' | 'BatchGetItem' | 'PutItem' | 'DeleteItem' | 'UpdateItem' | 'ConditionCheckItem' | 'DescribeStream' | 'GetRecords' | 'GetShardIterator' | 'ListStreams';
+export type S3Permissions = 'AbortMultipartUpload' | 'CreateBucket' | 'DeleteBucket' | 'DeleteObject' | 'DeleteObjectTagging' | 'DeleteObjectVersion' | 'DeleteObjectVersionTagging' | 'GetBucketTagging' | 'GetBucketVersioning' | 'GetObject' | 'GetObjectAttributes' | 'GetObjectTagging' | 'GetObjectVersion' | 'GetObjectVersionAttributes' | 'GetObjectVersionTagging' | 'ListAllMyBuckets' | 'ListBucket' | 'ListBucketMultipartUploads' | 'ListBucketVersions' | 'ListMultipartUploadParts' | 'PutObject' | 'PutObjectTagging' | 'PutObjectVersionTagging' | 'ReplicateDelete' | 'ReplicateObject' | 'ReplicateTags' | 'RestoreObject';
+export type LambdaPermissions = 'InvokeFunction';
+export type LogsPermission = 'CreateLogGroup' | 'CreateLogStream' | 'PutLogEvents';
+export type SQSPermissions = 'DeleteMessage' | 'GetQueueUrl' | 'ReceiveMessage' | 'ReceiveMessage' | 'SendMessage' | 'GetQueueAttributes';
+export type StateMachinePermissions = 'InvokeHTTPEndpoint' | 'DescribeExecution' | 'StartExecution' | 'StopExecution' | 'DescribeExecution' | 'GetExecutionHistory';
+export type KMSPermissions = 'Decrypt' | 'DescribeKey' | 'Encrypt' | 'GenerateDataKey' | 'GenerateRandom' | 'GetPublicKey' | 'Sign' | 'Verify';
+export type SSMPermissions = 'DescribeParameters' | 'GetDocument' | 'GetParameter' | 'GetParameters' | 'GetParametersByPath' | 'ListDocuments' | 'PutParameter';
+export type EventPermissions = 'DescribeEventRule' | 'DescribeEventBus' | 'DescribeRule' | 'PutEvents' | 'PutRule';
+export type Services = ServicesName | PermissionService<'dynamodb', DynamoPermissions> | PermissionService<'s3', S3Permissions> | PermissionService<'lambda', LambdaPermissions> | PermissionService<'cloudwatch', LogsPermission> | PermissionService<'sqs', SQSPermissions> | PermissionService<'state_machine', StateMachinePermissions> | PermissionService<'kms', KMSPermissions> | PermissionService<'ssm', SSMPermissions> | PermissionService<'event', EventPermissions> | (PermissionService<'custom', string> & {
+    serviceName: string;
+});
+export type ServiceFunction = (props: GetResourceProps) => Services[];
+export type ServicesValues = Services[] | ServiceFunction;
+export {};

package/lib/types/services.types.js

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

package/lib/types/time.types.d.ts

@@ -0,0 +1,8 @@
+export interface Time {
+    type: 'days' | 'minutes' | 'seconds';
+    duration: number;
+}
+/**
+ * Time in seconds or Time object
+ */
+export type Duration = number | Time;

package/lib/types/time.types.js

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

package/lib/types/utilities.types.d.ts

@@ -0,0 +1,33 @@
+export type KeyOfClass<E extends Function> = keyof E['prototype'];
+export type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export type OnlyNumberString<T> = {
+    [key in keyof T as T[key] extends string | number ? key : never]: T[key];
+};
+export type OnlyNumber<T> = {
+    [key in keyof T as T[key] extends number ? key : never]: T[key];
+};
+export type Join<K, P> = K extends string ? P extends string ? `${K}::${P}` : never : never;
+export type FlattenStacksByResource<TStacks, TResource extends string> = {
+    [StackName in keyof TStacks]: TResource extends keyof TStacks[StackName] ? Join<TResource, Join<StackName & string, keyof TStacks[StackName][TResource] & string>> : never;
+}[keyof TStacks];
+export type ResourceIdentifiers<TStacks, TResource extends string> = {
+    [K in keyof TStacks]: TResource extends keyof TStacks[K] ? keyof TStacks[K][TResource] : never;
+}[keyof TStacks] & string;
+export type ScopedResourceNames<TStacks, TResource extends string> = {
+    [StackName in keyof TStacks]: TResource extends keyof TStacks[StackName] ? Join<StackName & string, keyof TStacks[StackName][TResource] & string> : never;
+}[keyof TStacks];
+export type OnlyOne<T> = {
+    [K in keyof T]: Required<Pick<T, K>> & Partial<Record<Exclude<keyof T, K>, never>>;
+}[keyof T];
+export type OnlyOneKey<T> = {
+    [K in keyof T]: {
+        [P in K]: T[P];
+    } & {
+        [P in Exclude<keyof T, K>]?: never;
+    };
+}[keyof T];
+export type StripReadonly<T> = {
+    -readonly [P in keyof T]: StripReadonly<T[P]>;
+};

package/lib/types/utilities.types.js

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

package/lib/utils/build-env.utils.d.ts

@@ -0,0 +1,2 @@
+export declare const enableBuildEnvVariable: () => void;
+export declare const isBuildEnvironment: () => boolean;

package/lib/utils/build-env.utils.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBuildEnvironment = exports.enableBuildEnvVariable = void 0;
+const env_constants_1 = require("../constants/env.constants");
+const enableBuildEnvVariable = () => {
+    process.env[env_constants_1.LAFKEN_CONTEXT] = env_constants_1.LAFKEN_CONTEXT_VALUE;
+};
+exports.enableBuildEnvVariable = enableBuildEnvVariable;
+const isBuildEnvironment = () => {
+    return process.env[env_constants_1.LAFKEN_CONTEXT] === env_constants_1.LAFKEN_CONTEXT_VALUE;
+};
+exports.isBuildEnvironment = isBuildEnvironment;

package/lib/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './build-env.utils';
+export * from './path.utils';
+export * from './resource.utils';
+export * from './string.utils';

package/lib/utils/index.js

@@ -0,0 +1,20 @@
+"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("./build-env.utils"), exports);
+__exportStar(require("./path.utils"), exports);
+__exportStar(require("./resource.utils"), exports);
+__exportStar(require("./string.utils"), exports);

package/lib/utils/path.utils.d.ts

@@ -0,0 +1 @@
+export declare const getCallerFileName: (fileIndex?: number) => string;

package/lib/utils/path.utils.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCallerFileName = void 0;
+const getStacks = () => {
+    const originalPrepareStackTrace = Error.prepareStackTrace;
+    Error.prepareStackTrace = (_, stack) => stack;
+    const err = new Error();
+    const stacks = err.stack;
+    Error.prepareStackTrace = originalPrepareStackTrace;
+    return stacks;
+};
+const getCallerFileName = (fileIndex = 5) => {
+    const stacks = getStacks();
+    return stacks[fileIndex].getFileName();
+};
+exports.getCallerFileName = getCallerFileName;

package/lib/utils/resource.utils.d.ts

@@ -0,0 +1,6 @@
+import { type LambdaMetadata, type ResourceMetadata } from '../decorators';
+import type { ClassResource } from '../types';
+export declare const getResourceMetadata: <T = ResourceMetadata>(classResource: ClassResource) => T;
+export declare const getResourceHandlerMetadata: <T = LambdaMetadata>(classResource: ClassResource) => T[];
+export declare const getMetadataByKey: <T>(classResource: ClassResource, key: string) => T;
+export declare const getMetadataPrototypeByKey: <T>(classResource: ClassResource, key: string) => T;

package/lib/utils/resource.utils.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMetadataPrototypeByKey = exports.getMetadataByKey = exports.getResourceHandlerMetadata = exports.getResourceMetadata = void 0;
+const decorators_1 = require("../decorators");
+const getResourceMetadata = (classResource) => {
+    return Reflect.getMetadata(decorators_1.ResourceReflectKeys.resource, classResource);
+};
+exports.getResourceMetadata = getResourceMetadata;
+const getResourceHandlerMetadata = (classResource) => {
+    return Reflect.getMetadata(decorators_1.LambdaReflectKeys.handlers, classResource.prototype) || [];
+};
+exports.getResourceHandlerMetadata = getResourceHandlerMetadata;
+const getMetadataByKey = (classResource, key) => {
+    return Reflect.getMetadata(key, classResource);
+};
+exports.getMetadataByKey = getMetadataByKey;
+const getMetadataPrototypeByKey = (classResource, key) => {
+    return Reflect.getMetadata(key, classResource.prototype);
+};
+exports.getMetadataPrototypeByKey = getMetadataPrototypeByKey;

package/lib/utils/string.utils.d.ts

@@ -0,0 +1,4 @@
+export declare const capitalize: (str: string) => string;
+export declare const kebabCase: (str: string) => string;
+export declare const cleanString: (str: string) => string;
+export declare const cleanTemplateString: (str: string) => string;

package/lib/utils/string.utils.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanTemplateString = exports.cleanString = exports.kebabCase = exports.capitalize = void 0;
+const capitalize = (str) => {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+};
+exports.capitalize = capitalize;
+const kebabCase = (str) => {
+    if (str === str.toUpperCase()) {
+        return str.toLocaleLowerCase();
+    }
+    return str
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/[\s_]+/g, '-')
+        .toLowerCase();
+};
+exports.kebabCase = kebabCase;
+const cleanString = (str) => {
+    return str.replace(/[^a-zA-Z0-9]/g, '');
+};
+exports.cleanString = cleanString;
+const cleanTemplateString = (str) => {
+    return str
+        .split('\n')
+        .map((s) => s.trim())
+        .filter(Boolean)
+        .join(' ');
+};
+exports.cleanTemplateString = cleanTemplateString;

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@lafken/common",
+  "version": "0.6.0",
+  "private": false,
+  "license": "MIT",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib"
+  ],
+  "dependencies": {
+    "reflect-metadata": "0.2.2"
+  },
+  "devDependencies": {
+    "@types/jest": "30.0.0",
+    "jest": "30.2.0",
+    "ts-jest": "29.4.6",
+    "ts-node": "10.9.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "pnpm clean && tsc -p ./tsconfig.build.json",
+    "clean": "rm -rf ./lib",
+    "dev": "tsc -w",
+    "test": "jest",
+    "test:coverage": "jest --coverage"
+  }
+}