@lafken/schedule 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,151 @@
+# @lafken/schedule
+
+Define Amazon EventBridge scheduled rules using TypeScript decorators. `@lafken/schedule` lets you declare cron-based tasks directly on class methods — each one becomes a Lambda function invoked automatically by EventBridge at the specified times.
+
+## Installation
+
+```bash
+npm install @lafken/schedule
+```
+
+## Getting Started
+
+Define a schedule class with `@Schedule`, add `@Cron` methods, and register it through `ScheduleResolver`:
+
+```typescript
+import { createApp, createModule } from '@lafken/main';
+import { ScheduleResolver } from '@lafken/schedule/resolver';
+import { Schedule, Cron } from '@lafken/schedule/main';
+
+// 1. Define scheduled tasks
+@Schedule()
+export class MaintenanceJobs {
+  @Cron({ schedule: 'cron(0 3 * * ? *)' })
+  cleanupExpiredSessions() {
+    // Runs every day at 3:00 AM UTC
+  }
+
+  @Cron({ schedule: { hour: 0, minute: 0, weekDay: 'SUN' } })
+  generateWeeklyReport() {
+    // Runs every Sunday at midnight UTC
+  }
+}
+
+// 2. Register in a module
+const maintenanceModule = createModule({
+  name: 'maintenance',
+  resources: [MaintenanceJobs],
+});
+
+// 3. Add the resolver to the app
+createApp({
+  name: 'my-app',
+  resolvers: [new ScheduleResolver()],
+  modules: [maintenanceModule],
+});
+```
+
+Each `@Cron` method becomes an independent Lambda function with its own EventBridge rule.
+
+## Features
+
+### Schedule Class
+
+Use the `@Schedule` decorator to group related cron tasks in a single class. The class itself holds no schedule logic — it acts as a container for `@Cron` handlers:
+
+```typescript
+import { Schedule, Cron } from '@lafken/schedule/main';
+
+@Schedule()
+export class DataPipeline {
+  @Cron({ schedule: 'cron(0 6 * * ? *)' })
+  ingestData() { }
+
+  @Cron({ schedule: 'cron(30 6 * * ? *)' })
+  transformData() { }
+}
+```
+
+### Cron Expression (String)
+
+Pass a standard AWS cron expression as a string. The format follows:
+
+```
+cron(Minutes Hours Day-of-month Month Day-of-week Year)
+```
+
+```typescript
+@Cron({ schedule: 'cron(0 12 * * ? *)' })
+sendDailyDigest() {
+  // Every day at 12:00 PM UTC
+}
+
+@Cron({ schedule: 'cron(0 9 1 * ? *)' })
+generateMonthlyInvoice() {
+  // First day of every month at 9:00 AM UTC
+}
+```
+
+> [!NOTE]
+> AWS cron expressions require either the day-of-month or day-of-week field to be `?`. You cannot specify both simultaneously. When using a cron string, include the full `cron(...)` wrapper.
+
+### Cron Expression (Object)
+
+For a more readable alternative, use the `ScheduleTime` object format. Each field defaults to `'*'` when omitted:
+
+```typescript
+@Cron({
+  schedule: {
+    minute: 0,
+    hour: 8,
+    weekDay: 'MON-FRI',
+  },
+})
+startBusinessHours() {
+  // Every weekday at 8:00 AM UTC
+}
+
+@Cron({
+  schedule: {
+    minute: 30,
+    hour: 22,
+    day: 15,
+  },
+})
+midMonthAudit() {
+  // 15th of every month at 10:30 PM UTC
+}
+```
+
+#### ScheduleTime Fields
+
+| Field     | Type                        | Default | Description          |
+| --------- | --------------------------- | ------- | -------------------- |
+| `minute`  | `number \| '*' \| '?'`     | `'*'`   | Minute (0–59)        |
+| `hour`    | `number \| '*' \| '?'`     | `'*'`   | Hour (0–23)          |
+| `day`     | `number \| '*' \| '?'`     | `'*'`   | Day of month (1–31)  |
+| `month`   | `number \| '*' \| '?'`     | `'*'`   | Month (1–12)         |
+| `weekDay` | `number \| string \| '?'`  | `'*'`   | Day of week (SUN–SAT or 1–7) |
+| `year`    | `number \| '*' \| '?'`     | `'*'`   | Year                 |
+
+When `day` is set to a specific value, `weekDay` is automatically set to `'?'` and vice versa, following the AWS cron constraint.
+
+### Retry Policy
+
+Configure how EventBridge handles failed deliveries using `retryAttempts` and `maxEventAge`:
+
+```typescript
+@Cron({
+  schedule: 'cron(0 0 * * ? *)',
+  retryAttempts: 3,
+  maxEventAge: 3600,
+})
+criticalNightlyJob() {
+  // Retries up to 3 times, discards events older than 1 hour
+}
+```
+
+| Option          | Type     | Description                                                |
+| --------------- | -------- | ---------------------------------------------------------- |
+| `retryAttempts` | `number` | Maximum retry attempts if the target invocation fails      |
+| `maxEventAge`   | `number` | Maximum event age in seconds before the event is discarded |

package/lib/index.d.ts

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

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("./main"), exports);
+__exportStar(require("./resolver"), exports);

package/lib/main/index.d.ts

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

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

package/lib/main/schedule/index.d.ts

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

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

package/lib/main/schedule/schedule.d.ts

@@ -0,0 +1,43 @@
+import type { EventCronProps } from './schedule.types';
+export declare const RESOURCE_TYPE: "CRON";
+/**
+ * Class decorator that registers a class as a scheduled event resource.
+ *
+ * The decorated class groups one or more `@Cron` handler methods that
+ * are invoked on a time-based schedule via Amazon EventBridge.
+ *
+ * @param props - Optional resource configuration (e.g. a custom `name`).
+ *
+ * @example
+ * ```ts
+ * @Schedule()
+ * export class MaintenanceJobs {
+ *   @Cron({ schedule: { hour: 3, minute: 0 } })
+ *   cleanup() { }
+ * }
+ * ```
+ */
+export declare const Schedule: (props?: import("@lafken/common").ResourceProps | undefined) => (constructor: Function) => void;
+/**
+ * Method decorator that registers a handler to run on a cron schedule.
+ *
+ * The decorated method becomes a Lambda function invoked automatically
+ * by EventBridge at the times defined by the `schedule` option. The
+ * schedule can be a standard AWS cron string or a structured
+ * `ScheduleTime` object.
+ *
+ * @param props - Schedule configuration (schedule expression, maxEventAge,
+ *                retryAttempts).
+ *
+ * @example
+ * ```ts
+ * // Using a cron string (every day at midnight UTC)
+ * @Cron({ schedule: 'cron(0 0 * * ? *)' })
+ * dailyReport() { }
+ *
+ * // Using a ScheduleTime object (every Monday at 8:30 AM)
+ * @Cron({ schedule: { weekDay: 'MON', hour: 8, minute: 30 } })
+ * weeklyDigest() { }
+ * ```
+ */
+export declare const Cron: (props: EventCronProps) => (target: any, methodName: string, descriptor: PropertyDescriptor) => any;

package/lib/main/schedule/schedule.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cron = exports.Schedule = exports.RESOURCE_TYPE = void 0;
+const common_1 = require("@lafken/common");
+exports.RESOURCE_TYPE = 'CRON';
+/**
+ * Class decorator that registers a class as a scheduled event resource.
+ *
+ * The decorated class groups one or more `@Cron` handler methods that
+ * are invoked on a time-based schedule via Amazon EventBridge.
+ *
+ * @param props - Optional resource configuration (e.g. a custom `name`).
+ *
+ * @example
+ * ```ts
+ * @Schedule()
+ * export class MaintenanceJobs {
+ *   @Cron({ schedule: { hour: 3, minute: 0 } })
+ *   cleanup() { }
+ * }
+ * ```
+ */
+exports.Schedule = (0, common_1.createResourceDecorator)({
+    type: exports.RESOURCE_TYPE,
+    callerFileIndex: 5,
+});
+/**
+ * Method decorator that registers a handler to run on a cron schedule.
+ *
+ * The decorated method becomes a Lambda function invoked automatically
+ * by EventBridge at the times defined by the `schedule` option. The
+ * schedule can be a standard AWS cron string or a structured
+ * `ScheduleTime` object.
+ *
+ * @param props - Schedule configuration (schedule expression, maxEventAge,
+ *                retryAttempts).
+ *
+ * @example
+ * ```ts
+ * // Using a cron string (every day at midnight UTC)
+ * @Cron({ schedule: 'cron(0 0 * * ? *)' })
+ * dailyReport() { }
+ *
+ * // Using a ScheduleTime object (every Monday at 8:30 AM)
+ * @Cron({ schedule: { weekDay: 'MON', hour: 8, minute: 30 } })
+ * weeklyDigest() { }
+ * ```
+ */
+const Cron = (props) => (0, common_1.createLambdaDecorator)({
+    getLambdaMetadata: (props, methodName) => ({
+        ...props,
+        name: methodName,
+    }),
+})(props);
+exports.Cron = Cron;

package/lib/main/schedule/schedule.types.d.ts

@@ -0,0 +1,70 @@
+import type { LambdaMetadata, ResourceOutputType } from '@lafken/common';
+type ScheduleExpressions = number | '*' | '?' | (string & {});
+/**
+ * Attributes that can be exported from an EventBridge schedule rule resource.
+ *
+ * Based on Terraform `aws_cloudwatch_event_rule` attribute reference:
+ * - `arn`: The Amazon Resource Name (ARN) of the rule.
+ * - `id`: The name of the rule.
+ */
+export type ScheduleOutputAttributes = 'arn' | 'id';
+export interface ScheduleTime {
+    day?: ScheduleExpressions;
+    hour?: ScheduleExpressions;
+    minute?: ScheduleExpressions;
+    month?: ScheduleExpressions;
+    weekDay?: ScheduleExpressions;
+    year?: ScheduleExpressions;
+}
+export interface EventCronProps {
+    /**
+     * Maximum event age.
+     *
+     * Specifies the maximum age of an event that can be sent to the rule's targets.
+     * Events older than this duration will be discarded.
+     */
+    maxEventAge?: number;
+    /**
+     * Retry attempts for failed events.
+     *
+     * Specifies the maximum number of times EventBridge will retry sending
+     * an event to the target if the initial attempt fails.
+     */
+    retryAttempts?: number;
+    /**
+     * Schedule for the EventBridge rule.
+     *
+     * Defines when the rule should trigger, either using a cron expression
+     * or a structured schedule object. This allows for time-based Lambda invocation
+     *
+     * You can provide:
+     * - A cron string in the standard AWS format: `cron(* * * * * *)`
+     * - A `ScheduleTime` object to specify individual fields:
+     *   - `minute`, `hour`, `day`, `month`, `weekDay`, `year`
+     *   - Each field can be a number, '*', '?', a range `${number}-${number}`
+     */
+    schedule: string | ScheduleTime;
+    /**
+     * Defines which EventBridge schedule rule attributes should be exported.
+     *
+     * Supported attributes are based on Terraform `aws_cloudwatch_event_rule`
+     * attribute reference:
+     * - `arn`: The Amazon Resource Name (ARN) of the rule.
+     * - `id`: The name of the rule.
+     *
+     * Each selected attribute can be exported through SSM Parameter Store (`type: 'ssm'`)
+     * or Terraform outputs (`type: 'output'`).
+     *
+     * @example
+     * {
+     *   outputs: [
+     *     { type: 'ssm', name: '/my-app/schedule-arn', value: 'arn' },
+     *     { type: 'output', name: 'schedule_id', value: 'id' }
+     *   ]
+     * }
+     */
+    outputs?: ResourceOutputType<ScheduleOutputAttributes>;
+}
+export interface EventCronMetadata extends LambdaMetadata, EventCronProps {
+}
+export {};

package/lib/main/schedule/schedule.types.js

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

package/lib/resolver/cron/cron.d.ts

@@ -0,0 +1,17 @@
+import { CloudwatchEventRule } from '@cdktn/provider-aws/lib/cloudwatch-event-rule';
+import { type AppModule } from '@lafken/resolver';
+import type { CronProps } from './cron.types';
+declare const Cron_base: (new (...args: any[]) => {
+    isGlobal(module: import("@lafken/common").ModuleGlobalReferenceNames | (string & {}), id: string): void;
+    isDependent(resolveDependency: () => void): void;
+    readonly node: import("constructs").Node;
+    with(...mixins: import("constructs").IMixin[]): import("constructs").IConstruct;
+    toString(): string;
+}) & typeof CloudwatchEventRule;
+export declare class Cron extends Cron_base {
+    private props;
+    constructor(scope: AppModule, id: string, props: CronProps);
+    addEventTarget(id: string): void;
+    private static buildScheduleExpression;
+}
+export {};

package/lib/resolver/cron/cron.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cron = void 0;
+const cloudwatch_event_rule_1 = require("@cdktn/provider-aws/lib/cloudwatch-event-rule");
+const cloudwatch_event_target_1 = require("@cdktn/provider-aws/lib/cloudwatch-event-target");
+const resolver_1 = require("@lafken/resolver");
+class Cron extends resolver_1.lafkenResource.make(cloudwatch_event_rule_1.CloudwatchEventRule) {
+    props;
+    constructor(scope, id, props) {
+        const { handler } = props;
+        super(scope, `${handler.name}-cron`, {
+            name: handler.name,
+            scheduleExpression: Cron.buildScheduleExpression(handler.schedule),
+        });
+        this.props = props;
+        this.isGlobal(scope.id, id);
+        this.addEventTarget(id);
+        new resolver_1.ResourceOutput(this, handler.outputs);
+    }
+    addEventTarget(id) {
+        const { handler, resourceMetadata } = this.props;
+        const lambdaHandler = new resolver_1.LambdaHandler(this, `${handler.name}-${resourceMetadata.name}`, {
+            ...handler,
+            originalName: resourceMetadata.originalName,
+            filename: resourceMetadata.filename,
+            foldername: resourceMetadata.foldername,
+            suffix: 'event',
+            principal: 'events.amazonaws.com',
+            sourceArn: this.arn,
+        });
+        new cloudwatch_event_target_1.CloudwatchEventTarget(this, `${id}-event-target`, {
+            rule: this.name,
+            arn: lambdaHandler.arn,
+            retryPolicy: {
+                maximumRetryAttempts: handler.retryAttempts,
+                maximumEventAgeInSeconds: handler.maxEventAge,
+            },
+        });
+    }
+    static buildScheduleExpression(schedule) {
+        if (typeof schedule === 'string') {
+            return `cron(${schedule})`;
+        }
+        const { minute = '*', hour = '*', day = '*', month = '*', year = '*', weekDay = '*', } = schedule;
+        let dayValue;
+        let weekDayValue;
+        if (day && day !== '*' && day !== '?') {
+            dayValue = day.toString();
+            weekDayValue = '?';
+        }
+        else if (weekDay && weekDay !== '*' && weekDay !== '?') {
+            dayValue = '?';
+            weekDayValue = weekDay.toString();
+        }
+        else {
+            dayValue = day?.toString() ?? '*';
+            weekDayValue = '?';
+        }
+        return `cron(${minute} ${hour} ${dayValue} ${month} ${weekDayValue} ${year})`;
+    }
+}
+exports.Cron = Cron;

package/lib/resolver/cron/cron.types.d.ts

@@ -0,0 +1,6 @@
+import type { ResourceMetadata } from '@lafken/common';
+import type { EventCronMetadata } from '../../main';
+export interface CronProps {
+    resourceMetadata: ResourceMetadata;
+    handler: EventCronMetadata;
+}

package/lib/resolver/cron/cron.types.js

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

package/lib/resolver/index.d.ts

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

package/lib/resolver/index.js

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

package/lib/resolver/resolver.d.ts

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

package/lib/resolver/resolver.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScheduleResolver = void 0;
+const common_1 = require("@lafken/common");
+const resolver_1 = require("@lafken/resolver");
+const main_1 = require("../main");
+const cron_1 = require("./cron/cron");
+class ScheduleResolver {
+    type = main_1.RESOURCE_TYPE;
+    create(module, resource) {
+        const metadata = (0, common_1.getResourceMetadata)(resource);
+        const handlers = (0, common_1.getResourceHandlerMetadata)(resource);
+        resolver_1.lambdaAssets.initializeMetadata({
+            foldername: metadata.foldername,
+            filename: metadata.filename,
+            minify: metadata.minify,
+            className: metadata.originalName,
+            methods: handlers.map((handler) => handler.name),
+        });
+        for (const handler of handlers) {
+            const id = `${handler.name}-${metadata.name}`;
+            new cron_1.Cron(module, id, {
+                handler,
+                resourceMetadata: metadata,
+            });
+        }
+    }
+}
+exports.ScheduleResolver = ScheduleResolver;

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@lafken/schedule",
+  "version": "0.10.1",
+  "private": false,
+  "description": "Define EventBridge scheduled rules and cron jobs using TypeScript decorators with Lafken",
+  "keywords": [
+    "aws",
+    "eventbridge",
+    "schedule",
+    "cron",
+    "scheduling",
+    "serverless",
+    "typescript",
+    "decorators",
+    "lafken"
+  ],
+  "homepage": "https://github.com/Hero64/lafken#readme",
+  "bugs": "https://github.com/Hero64/lafken/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Hero64/lafken",
+    "directory": "packages/schedule"
+  },
+  "license": "MIT",
+  "author": "Aníbal Jorquera",
+  "exports": {
+    "./main": {
+      "import": "./lib/main/index.js",
+      "types": "./lib/main/index.d.ts",
+      "require": "./lib/main/index.js"
+    },
+    "./resolver": {
+      "import": "./lib/resolver/index.js",
+      "types": "./lib/resolver/index.d.ts",
+      "require": "./lib/resolver/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "main": [
+        "./lib/main/index.d.ts"
+      ],
+      "resolver": [
+        "./lib/resolver/index.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "lib"
+  ],
+  "dependencies": {
+    "reflect-metadata": "^0.2.2",
+    "@lafken/resolver": "0.10.1"
+  },
+  "devDependencies": {
+    "@cdktn/provider-aws": "^23.5.0",
+    "@swc/core": "^1.15.21",
+    "@swc/helpers": "^0.5.20",
+    "@vitest/runner": "^4.1.2",
+    "cdktn": "^0.22.1",
+    "cdktn-vitest": "^1.0.0",
+    "constructs": "^10.6.0",
+    "typescript": "6.0.2",
+    "unplugin-swc": "^1.5.9",
+    "vitest": "^4.1.2",
+    "@lafken/common": "0.10.1"
+  },
+  "peerDependencies": {
+    "@cdktn/provider-aws": ">=23.0.0",
+    "@lafken/common": "0.7.0",
+    "cdktn": ">=0.22.0",
+    "constructs": "^10.4.5"
+  },
+  "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"
+  }
+}