@alzulejos/laranja-decorators 0.2.4

package/README.md

@@ -0,0 +1,33 @@
+# @alzulejos/laranja-decorators
+
+Decorators and markers for [laranja](https://laranja.io) — mark your HTTP app, scheduled jobs, and queue consumers in your Node.js app. laranja scans these statically and provisions the matching AWS infrastructure.
+
+```bash
+npm install @alzulejos/laranja-decorators
+```
+
+```ts
+import { http, Cron, Queue, rate, every } from "@alzulejos/laranja-decorators";
+
+export default http(app);   // mark your Express/NestJS app
+
+export class Jobs {
+  @Cron(rate(5, "minutes"))
+  async refreshCache() {}
+
+  @Cron(every("day"))
+  async nightlyCleanup() {}
+
+  @Cron({ schedule: "cron(0 12 * * ? *)", id: "daily-report" })
+  async dailyReport() {}
+
+  @Queue({ name: "emails", batchSize: 10 })
+  async sendEmails(body: unknown) {}
+}
+```
+
+- **`http(app)`** → one Lambda behind a Function URL serving all your routes. The sole way to declare your HTTP app; exactly one per project.
+- **`@Cron(schedule)`** → EventBridge rule + Lambda. `schedule` is an AWS expression; use `rate(n, unit)` / `every(unit)` or a raw `"cron(...)"`/`"rate(...)"` string. Pass `{ schedule, id }` to set a name.
+- **`@Queue({ name, batchSize?, fifo? })`** → SQS queue + consumer Lambda, called once per message with the JSON-parsed body.
+
+📖 **Full docs:** https://laranja.io/docs

package/dist/index.d.ts

@@ -0,0 +1,151 @@
+/**
+ * The decorators the user applies to their job classes.
+ *
+ * These are intentionally near-no-ops at runtime: the *scanner* discovers them
+ * statically (via ts-morph) and bakes class + method names into generated Lambda
+ * entry shims. The runtime metadata registry below exists only so that future
+ * runtime-reflection paths (and tooling/tests) can enumerate handlers too.
+ */
+export { rate, every, CronExpression } from "@alzulejos/laranja-core";
+export type { RateUnit, Schedule, ScheduleInput } from "@alzulejos/laranja-core";
+export type { LaranjaConfig, ComputeConfig, ResourceConfig, } from "@alzulejos/laranja-core";
+export { getQueue } from "./producer.js";
+export type { LaranjaQueue, SendOptions } from "./producer.js";
+import type { ScheduleInput } from "@alzulejos/laranja-core";
+/** Options object `@nestjs/schedule`'s `@Cron` accepts as its SECOND argument. */
+export interface NestCronOptions {
+    /** Stable name for the job — laranja uses it as the resource id. */
+    name?: string;
+    /** IANA timezone the schedule is evaluated in. */
+    timeZone?: string;
+    /** Present for signature compatibility; ignored by laranja's static scan. */
+    utcOffset?: number | string;
+    disabled?: boolean;
+}
+export interface CronOptions {
+    /** A `rate(...)`/`every(...)` builder result, or a raw provider string. */
+    schedule: ScheduleInput;
+    /** Stable logical id. Defaults to "<Class>-<method>". */
+    id?: string;
+}
+export interface QueueOptions {
+    /** Queue name. A ".fifo" suffix (or `fifo: true`) marks a FIFO queue. */
+    name: string;
+    batchSize?: number;
+    fifo?: boolean;
+}
+export type HandlerKind = "cron" | "queue";
+export interface RegisteredHandler {
+    kind: HandlerKind;
+    className: string;
+    method: string;
+    options: CronOptions | QueueOptions;
+}
+/** Module-level registry, populated when decorated classes are imported. */
+export declare const handlerRegistry: RegisteredHandler[];
+/** The shape of a standalone handler passed to `cron()` / `queue()`. */
+export type JobHandler = (...args: any[]) => unknown | Promise<unknown>;
+/**
+ * Schedules a method on an EventBridge rule. Each `@Cron` becomes its own Lambda.
+ *
+ * @example
+ *   @Cron("rate(5 minutes)")
+ *   async refreshCache() {}
+ *
+ *   @Cron({ schedule: "cron(0 12 * * ? *)", id: "daily-report" })
+ *   async dailyReport() {}
+ */
+export declare function Cron(schedule: ScheduleInput): MethodDecorator;
+export declare function Cron(options: CronOptions): MethodDecorator;
+/** `@nestjs/schedule`-compatible form: a cron string/expression + optional options. */
+export declare function Cron(expression: string, options?: NestCronOptions): MethodDecorator;
+/**
+ * `@nestjs/schedule`-compatible `@Interval`. Runs a method every N milliseconds;
+ * laranja lowers it to an EventBridge `rate(...)`, so the interval must be a whole
+ * number of minutes (EventBridge's floor). Discovered statically by the scanner.
+ *
+ * @example
+ *   @Interval(300000)          // every 5 minutes
+ *   @Interval("poll", 300000)  // named
+ */
+export declare function Interval(milliseconds: number): MethodDecorator;
+export declare function Interval(name: string, milliseconds: number): MethodDecorator;
+/**
+ * `@nestjs/schedule`-compatible `@Timeout`. Present so swapped imports compile,
+ * but a one-shot timer relative to process start has no serverless equivalent —
+ * the scanner rejects it at build time with a clear message.
+ */
+export declare function Timeout(milliseconds: number): MethodDecorator;
+export declare function Timeout(name: string, milliseconds: number): MethodDecorator;
+/**
+ * Consumes messages from an SQS queue. Each `@Queue` becomes its own Lambda.
+ *
+ * @example
+ *   @Queue({ name: "emails", batchSize: 10 })
+ *   async sendEmails(event: unknown) {}
+ */
+export declare function Queue(options: QueueOptions): MethodDecorator;
+/**
+ * Function-style counterpart to `@Cron` — for codebases that don't use classes.
+ * Register a standalone exported function on a schedule. The function's name
+ * becomes the resource id (unless you pass an explicit `id`). Like the
+ * decorators, this is a near-no-op at runtime: the scanner reads it statically.
+ *
+ * @example
+ *   export async function refreshCache() {}
+ *   cron(rate(5, "minutes"), refreshCache);
+ */
+export declare function cron(schedule: ScheduleInput, handler: JobHandler): void;
+export declare function cron(options: CronOptions, handler: JobHandler): void;
+/**
+ * Function-style counterpart to `@Queue`. Register a standalone exported function
+ * as an SQS consumer.
+ *
+ * @example
+ *   export async function sendEmails(body: unknown) {}
+ *   queue({ name: "emails", batchSize: 10 }, sendEmails);
+ */
+export declare function queue(options: QueueOptions, handler: JobHandler): void;
+/**
+ * Marks the HTTP app (the proxy target) for laranja, code-first. Export the
+ * result so the scanner (and the generated shim) can find it:
+ *
+ *   export default http(app);          // or
+ *   export const api = http(app);
+ *
+ * Identity at runtime: it returns the app untouched. The scanner reads it
+ * statically; omit it entirely for a workers-only deployment.
+ */
+export declare function http<T>(app: T): T;
+/**
+ * Declare the Nest module laranja resolves background workers (@Cron / @Queue)
+ * against — code-first, the DI counterpart to `http()`. Export the result so the
+ * scanner (and the generated worker shims) can find it:
+ *
+ *   export default workers(AppModule);        // or
+ *   export const jobs = workers(AppModule);
+ *
+ * At runtime laranja builds a standalone Nest context from this module
+ * (`NestFactory.createApplicationContext`) so each worker Lambda resolves its
+ * provider — and that provider's injected dependencies — through real DI instead
+ * of a bare `new`. Pass `AppModule` for the whole graph, or a leaner module you
+ * compose if you want a smaller cold start. Identity at runtime: returns the
+ * module untouched; only Nest projects with crons/queues need it.
+ */
+export declare function workers<T>(module: T): T;
+/**
+ * Declare an environment variable your code needs at runtime — code-first.
+ *
+ * At runtime this is nothing more than a read of `process.env[name]`. Its value
+ * to laranja is *static discovery*: the scanner finds every `env("NAME")` call
+ * (NAME must be a string literal) and records the name in the IR. The deploy
+ * step then resolves each name from your shell / CI `process.env` and populates
+ * the Lambda's environment for you — no more filling vars in the console.
+ *
+ * Only the NAME crosses the wire to the server; the VALUE is resolved on your
+ * machine at deploy time and never leaves it.
+ *
+ * @example
+ *   const dbUrl = env("DATABASE_URL");
+ */
+export declare function env(name: string): string | undefined;

package/dist/index.js

@@ -0,0 +1,131 @@
+/**
+ * The decorators the user applies to their job classes.
+ *
+ * These are intentionally near-no-ops at runtime: the *scanner* discovers them
+ * statically (via ts-morph) and bakes class + method names into generated Lambda
+ * entry shims. The runtime metadata registry below exists only so that future
+ * runtime-reflection paths (and tooling/tests) can enumerate handlers too.
+ */
+// Re-export the schedule builders + types so users import them alongside @Cron.
+// `CronExpression` is the `@nestjs/schedule` enum, mirrored so a Nest user can
+// repoint their import at laranja and keep their existing @Cron(CronExpression.X).
+export { rate, every, CronExpression } from "@alzulejos/laranja-core";
+// The queue PRODUCER (`getQueue(name).send(...)`) — the counterpart to the
+// @Queue / queue() consumers below. Unlike the markers this one does real work at
+// runtime (an SQS SendMessage), but it lives here so users have a single import
+// surface for everything queue-related.
+export { getQueue } from "./producer.js";
+/** Module-level registry, populated when decorated classes are imported. */
+export const handlerRegistry = [];
+function register(kind, target, method, options) {
+    handlerRegistry.push({
+        kind,
+        className: target.constructor.name,
+        method: String(method),
+        options,
+    });
+}
+function registerFunction(kind, handler, options) {
+    const name = handler.name || "(anonymous)";
+    handlerRegistry.push({ kind, className: name, method: name, options });
+}
+export function Cron(arg, _nestOptions) {
+    // The second (Nest) argument is read statically by the scanner (name -> id,
+    // timeZone -> timezone); at runtime this decorator is a near-no-op registry write.
+    const options = toCronOptions(arg);
+    return (target, propertyKey) => {
+        register("cron", target, propertyKey, options);
+    };
+}
+export function Interval(_a, _b) {
+    return (target, propertyKey) => {
+        register("cron", target, propertyKey, { schedule: "" });
+    };
+}
+export function Timeout(_a, _b) {
+    return () => { };
+}
+/** Normalize the `Cron`/`cron` first argument (raw string, Schedule, or full options) into CronOptions. */
+function toCronOptions(arg) {
+    if (typeof arg === "string")
+        return { schedule: arg };
+    if ("kind" in arg)
+        return { schedule: arg }; // a Schedule object
+    return arg; // already CronOptions
+}
+/**
+ * Consumes messages from an SQS queue. Each `@Queue` becomes its own Lambda.
+ *
+ * @example
+ *   @Queue({ name: "emails", batchSize: 10 })
+ *   async sendEmails(event: unknown) {}
+ */
+export function Queue(options) {
+    return (target, propertyKey) => {
+        register("queue", target, propertyKey, options);
+    };
+}
+export function cron(arg, handler) {
+    registerFunction("cron", handler, toCronOptions(arg));
+}
+/**
+ * Function-style counterpart to `@Queue`. Register a standalone exported function
+ * as an SQS consumer.
+ *
+ * @example
+ *   export async function sendEmails(body: unknown) {}
+ *   queue({ name: "emails", batchSize: 10 }, sendEmails);
+ */
+export function queue(options, handler) {
+    registerFunction("queue", handler, options);
+}
+/**
+ * Marks the HTTP app (the proxy target) for laranja, code-first. Export the
+ * result so the scanner (and the generated shim) can find it:
+ *
+ *   export default http(app);          // or
+ *   export const api = http(app);
+ *
+ * Identity at runtime: it returns the app untouched. The scanner reads it
+ * statically; omit it entirely for a workers-only deployment.
+ */
+export function http(app) {
+    return app;
+}
+/**
+ * Declare the Nest module laranja resolves background workers (@Cron / @Queue)
+ * against — code-first, the DI counterpart to `http()`. Export the result so the
+ * scanner (and the generated worker shims) can find it:
+ *
+ *   export default workers(AppModule);        // or
+ *   export const jobs = workers(AppModule);
+ *
+ * At runtime laranja builds a standalone Nest context from this module
+ * (`NestFactory.createApplicationContext`) so each worker Lambda resolves its
+ * provider — and that provider's injected dependencies — through real DI instead
+ * of a bare `new`. Pass `AppModule` for the whole graph, or a leaner module you
+ * compose if you want a smaller cold start. Identity at runtime: returns the
+ * module untouched; only Nest projects with crons/queues need it.
+ */
+export function workers(module) {
+    return module;
+}
+/**
+ * Declare an environment variable your code needs at runtime — code-first.
+ *
+ * At runtime this is nothing more than a read of `process.env[name]`. Its value
+ * to laranja is *static discovery*: the scanner finds every `env("NAME")` call
+ * (NAME must be a string literal) and records the name in the IR. The deploy
+ * step then resolves each name from your shell / CI `process.env` and populates
+ * the Lambda's environment for you — no more filling vars in the console.
+ *
+ * Only the NAME crosses the wire to the server; the VALUE is resolved on your
+ * machine at deploy time and never leaves it.
+ *
+ * @example
+ *   const dbUrl = env("DATABASE_URL");
+ */
+export function env(name) {
+    return process.env[name];
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/producer.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Per-message options for `getQueue(name).send()`. FIFO queues REQUIRE `groupId`
+ * (SQS rejects a FIFO send without a MessageGroupId); `dedupId` is only needed
+ * when the queue doesn't use content-based deduplication. `delaySeconds` is
+ * ignored by FIFO queues (SQS limitation), so it's a standard-queue knob.
+ */
+export interface SendOptions {
+    /** MessageGroupId — required for FIFO queues, ignored for standard. */
+    groupId?: string;
+    /** MessageDeduplicationId — FIFO only, when content-based dedup is off. */
+    dedupId?: string;
+    /** Delay before the message becomes visible (0–900s). Standard queues only. */
+    delaySeconds?: number;
+}
+/** A minimal producer handle for one declared queue. Returned by `getQueue()`. */
+export interface LaranjaQueue {
+    /** The resolved SQS URL this handle sends to. */
+    readonly url: string;
+    /** Enqueue a message. Objects are JSON-serialized; strings are sent as-is. */
+    send(payload: unknown, options?: SendOptions): Promise<{
+        messageId?: string;
+    }>;
+}
+/**
+ * Producer counterpart to the `@Queue` / `queue()` consumer: get a handle to a
+ * declared queue and `.send()` messages to it. laranja provisions the wire — the
+ * SQS URL is injected into every function's env at deploy and `sqs:SendMessage`
+ * is granted — so this is pure infra glue, not a job framework: it resolves the
+ * URL and makes one `SendMessage` call, nothing more.
+ *
+ * @param name The queue's declared `name` (as in `queue({ name })`).
+ * @example
+ *   await getQueue("emails").send({ to, subject });
+ *   await getQueue("orders.fifo").send(order, { groupId: order.customerId });
+ */
+export declare function getQueue(name: string): LaranjaQueue;

package/dist/producer.js

@@ -0,0 +1,46 @@
+import { SQSClient, SendMessageCommand } from "@aws-sdk/client-sqs";
+import { queueUrlEnvName } from "@alzulejos/laranja-core";
+// One SQS client for the whole Lambda invocation environment — created lazily so
+// importing this module has no cost for functions that never produce, and reused
+// across warm invocations. Region comes from the Lambda's AWS_REGION env.
+let client;
+function sqs() {
+    return (client ??= new SQSClient({}));
+}
+/**
+ * Producer counterpart to the `@Queue` / `queue()` consumer: get a handle to a
+ * declared queue and `.send()` messages to it. laranja provisions the wire — the
+ * SQS URL is injected into every function's env at deploy and `sqs:SendMessage`
+ * is granted — so this is pure infra glue, not a job framework: it resolves the
+ * URL and makes one `SendMessage` call, nothing more.
+ *
+ * @param name The queue's declared `name` (as in `queue({ name })`).
+ * @example
+ *   await getQueue("emails").send({ to, subject });
+ *   await getQueue("orders.fifo").send(order, { groupId: order.customerId });
+ */
+export function getQueue(name) {
+    const url = process.env[queueUrlEnvName(name)];
+    if (!url) {
+        throw new Error(`getQueue("${name}"): no queue URL in env. Is "${name}" a declared queue in this project?`);
+    }
+    const isFifo = url.endsWith(".fifo");
+    return {
+        url,
+        async send(payload, options = {}) {
+            if (isFifo && !options.groupId) {
+                throw new Error(`getQueue("${name}").send: FIFO queue requires a groupId.`);
+            }
+            const body = typeof payload === "string" ? payload : JSON.stringify(payload);
+            const out = await sqs().send(new SendMessageCommand({
+                QueueUrl: url,
+                MessageBody: body,
+                MessageGroupId: isFifo ? options.groupId : undefined,
+                MessageDeduplicationId: isFifo ? options.dedupId : undefined,
+                DelaySeconds: !isFifo ? options.delaySeconds : undefined,
+            }));
+            return { messageId: out.MessageId };
+        },
+    };
+}
+//# sourceMappingURL=producer.js.map

package/dist/producer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"producer.js","sourceRoot":"","sources":["../src/producer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAyB1D,iFAAiF;AACjF,iFAAiF;AACjF,0EAA0E;AAC1E,IAAI,MAA6B,CAAC;AAClC,SAAS,GAAG;IACV,OAAO,CAAC,MAAM,KAAK,IAAI,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC;AACxC,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,QAAQ,CAAC,IAAY;IACnC,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC;IAC/C,IAAI,CAAC,GAAG,EAAE,CAAC;QACT,MAAM,IAAI,KAAK,CACb,aAAa,IAAI,gCAAgC,IAAI,qCAAqC,CAC3F,CAAC;IACJ,CAAC;IACD,MAAM,MAAM,GAAG,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IAErC,OAAO;QACL,GAAG;QACH,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,EAAE;YAC9B,IAAI,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;gBAC/B,MAAM,IAAI,KAAK,CAAC,aAAa,IAAI,yCAAyC,CAAC,CAAC;YAC9E,CAAC;YACD,MAAM,IAAI,GAAG,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;YAC7E,MAAM,GAAG,GAAG,MAAM,GAAG,EAAE,CAAC,IAAI,CAC1B,IAAI,kBAAkB,CAAC;gBACrB,QAAQ,EAAE,GAAG;gBACb,WAAW,EAAE,IAAI;gBACjB,cAAc,EAAE,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS;gBACpD,sBAAsB,EAAE,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS;gBAC5D,YAAY,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,SAAS;aACzD,CAAC,CACH,CAAC;YACF,OAAO,EAAE,SAAS,EAAE,GAAG,CAAC,SAAS,EAAE,CAAC;QACtC,CAAC;KACF,CAAC;AACJ,CAAC"}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@alzulejos/laranja-decorators",
+  "version": "0.2.4",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@aws-sdk/client-sqs": "^3.658.0",
+    "@alzulejos/laranja-core": "0.2.4"
+  }
+}