lambder 3.3.0 → 3.3.3

package/dist/Lambder.d.ts

@@ -130,7 +130,7 @@ export default class Lambder<TSessionData = any, _TContract extends Record<strin
         enableSlidingExpiration?: boolean;
         /** Min seconds between sliding-expiration writes. Default: max(60, 5% of TTL). */
         slidingWriteIntervalSeconds?: number;
-        /** Session cookie attributes, e.g. { domain: ".example.com" } for cross-subdomain sessions. */
+        /** Session cookie attributes, e.g. { domain: ".example.com" } for cross-subdomain sessions. `domain` may be a (hostname) => string function for multi-domain deployments. */
         cookie?: LambderSessionCookieOptions;
         partitionKey?: string;
         sortKey?: string;

package/dist/LambderCaller.d.ts

@@ -41,7 +41,8 @@ export default class LambderCaller<TContract extends ApiContractShape = any> {
     private fetchEndedHandler?;
     private sessionTokenCookieKey;
     private sessionCsrfCookieKey;
-    constructor({ apiPath, apiVersion, isCorsEnabled, versionExpiredHandler, sessionExpiredHandler, messageHandler, errorMessageHandler, notAuthorizedHandler, errorHandler, fetchStartedHandler, fetchEndedHandler, apiInputValidationErrorHandler, }: {
+    private sessionCookieDomain?;
+    constructor({ apiPath, apiVersion, isCorsEnabled, versionExpiredHandler, sessionExpiredHandler, messageHandler, errorMessageHandler, notAuthorizedHandler, errorHandler, fetchStartedHandler, fetchEndedHandler, apiInputValidationErrorHandler, sessionCookieDomain, }: {
         apiPath: string;
         apiVersion?: string;
         isCorsEnabled: boolean;
@@ -54,8 +55,11 @@ export default class LambderCaller<TContract extends ApiContractShape = any> {
         fetchStartedHandler?: FetchStartEventHandler;
         fetchEndedHandler?: FetchEndEventHandler;
         apiInputValidationErrorHandler?: ValidationErrorHandler;
+        /** Must mirror the server's session cookie Domain, otherwise expired cookies cannot be cleared. */
+        sessionCookieDomain?: string | ((hostname: string) => string | undefined | null);
     });
     setSessionCookieKey(sessionTokenCookieKey: string, sessionCsrfCookieKey: string): void;
+    private clearSessionCookies;
     apiRaw<TApiName extends keyof TContract & string = string, TOutput = TApiName extends keyof TContract ? TContract[TApiName]['output'] : any>(apiName: TApiName, payload?: TApiName extends keyof TContract ? TContract[TApiName]['input'] : any, options?: {
         headers?: Record<string, any>;
         versionExpiredHandler?: VoidFunction;

package/dist/LambderCaller.js

@@ -16,10 +16,12 @@ export default class LambderCaller {
     fetchEndedHandler;
     sessionTokenCookieKey = "LMDRSESSIONTKID";
     sessionCsrfCookieKey = "LMDRSESSIONCSTK";
-    constructor({ apiPath, apiVersion, isCorsEnabled = false, versionExpiredHandler, sessionExpiredHandler, messageHandler, errorMessageHandler, notAuthorizedHandler, errorHandler, fetchStartedHandler, fetchEndedHandler, apiInputValidationErrorHandler, }) {
+    sessionCookieDomain;
+    constructor({ apiPath, apiVersion, isCorsEnabled = false, versionExpiredHandler, sessionExpiredHandler, messageHandler, errorMessageHandler, notAuthorizedHandler, errorHandler, fetchStartedHandler, fetchEndedHandler, apiInputValidationErrorHandler, sessionCookieDomain, }) {
         this.apiPath = apiPath ?? "/api";
         this.apiVersion = apiVersion;
         this.isCorsEnabled = isCorsEnabled;
+        this.sessionCookieDomain = sessionCookieDomain;
         this.versionExpiredHandler = versionExpiredHandler;
         this.sessionExpiredHandler = sessionExpiredHandler;
         this.messageHandler = messageHandler;
@@ -35,6 +37,17 @@ export default class LambderCaller {
         this.sessionTokenCookieKey = sessionTokenCookieKey;
         this.sessionCsrfCookieKey = sessionCsrfCookieKey;
     }
+    clearSessionCookies() {
+        const domainOption = this.sessionCookieDomain;
+        const hostname = typeof window !== "undefined" ? window.location.hostname : "";
+        const resolvedDomain = typeof domainOption === "function" ? domainOption(hostname) : domainOption;
+        for (const key of [this.sessionTokenCookieKey, this.sessionCsrfCookieKey]) {
+            // Host-only and domain-scoped cookies are distinct entries; clear both.
+            Cookies.remove(key);
+            if (resolvedDomain)
+                Cookies.remove(key, { domain: resolvedDomain, path: "/" });
+        }
+    }
     async apiRaw(apiName, payload, options) {
         const headers = options?.headers;
         const fetchTracker = { apiName, done: false, fetchEndCalled: false };
@@ -102,8 +115,7 @@ export default class LambderCaller {
                 return null;
             }
             if (data && data.sessionExpired) {
-                Cookies.set(this.sessionTokenCookieKey, '', { expires: -1 });
-                Cookies.set(this.sessionCsrfCookieKey, '', { expires: -1 });
+                this.clearSessionCookies();
                 if (this.sessionExpiredHandler) {
                     await this.sessionExpiredHandler();
                 }

package/dist/LambderDdbRateLimiter.d.ts

@@ -0,0 +1,50 @@
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+export interface LambderRateLimitPolicy {
+    perMin?: number;
+    per10Min?: number;
+    perHour?: number;
+    perDay?: number;
+    perWeek?: number;
+    perMonth?: number;
+}
+export type LambderRateLimitExceededMap = Partial<Record<keyof LambderRateLimitPolicy, number>>;
+/** `false` when allowed, otherwise the window(s) whose limit was hit. */
+export type LambderRateLimitResult = false | LambderRateLimitExceededMap;
+export interface LambderDdbRateLimiterOptions {
+    tableName: string;
+    region?: string;
+    /** Partition key prefix, keeps counters separated from other items. */
+    keyPrefix?: string;
+    /** Multiplier applied to the window length when setting the item TTL. */
+    ttlWindowMultiplier?: number;
+    /** Allow the request when DynamoDB itself errors. Defaults to false. */
+    failOpen?: boolean;
+    client?: DynamoDBClient;
+}
+/**
+ * Fixed-window rate limiter backed by DynamoDB.
+ *
+ * Each window is a single item counted with a conditional `ADD`, so the
+ * increment and the limit check happen atomically in one request. Windows are
+ * evaluated from smallest to largest and evaluation stops at the first
+ * exceeded window, which keeps blocked requests cheap and avoids inflating the
+ * larger counters. Items carry an `expiresAt` attribute for DynamoDB TTL.
+ *
+ * Table shape: string hash key `pk`, string range key `sk`, TTL on `expiresAt`.
+ */
+export declare class LambderDdbRateLimiter {
+    readonly tableName: string;
+    readonly keyPrefix: string;
+    private readonly client;
+    private readonly ttlWindowMultiplier;
+    private readonly failOpen;
+    constructor(options: LambderDdbRateLimiterOptions);
+    /**
+     * Increment every configured window for `trackerKey` (IP, session, user id, ...)
+     * and report whether any of them is over its limit.
+     */
+    isRateLimited(trackerKey: string, policy: LambderRateLimitPolicy): Promise<LambderRateLimitResult>;
+    /** Increments one window counter. Returns true when the limit was already reached. */
+    private incrementWindow;
+}
+export default LambderDdbRateLimiter;

package/dist/LambderDdbRateLimiter.js

@@ -0,0 +1,87 @@
+import { DynamoDBClient, UpdateItemCommand, } from "@aws-sdk/client-dynamodb";
+const WINDOW_CONFIG = [
+    { key: "perMin", seconds: 60 },
+    { key: "per10Min", seconds: 10 * 60 },
+    { key: "perHour", seconds: 60 * 60 },
+    { key: "perDay", seconds: 24 * 60 * 60 },
+    { key: "perWeek", seconds: 7 * 24 * 60 * 60 },
+    { key: "perMonth", seconds: 30 * 24 * 60 * 60 },
+];
+/**
+ * Fixed-window rate limiter backed by DynamoDB.
+ *
+ * Each window is a single item counted with a conditional `ADD`, so the
+ * increment and the limit check happen atomically in one request. Windows are
+ * evaluated from smallest to largest and evaluation stops at the first
+ * exceeded window, which keeps blocked requests cheap and avoids inflating the
+ * larger counters. Items carry an `expiresAt` attribute for DynamoDB TTL.
+ *
+ * Table shape: string hash key `pk`, string range key `sk`, TTL on `expiresAt`.
+ */
+export class LambderDdbRateLimiter {
+    tableName;
+    keyPrefix;
+    client;
+    ttlWindowMultiplier;
+    failOpen;
+    constructor(options) {
+        if (!options.tableName.trim())
+            throw new Error("tableName is required");
+        this.tableName = options.tableName;
+        this.keyPrefix = options.keyPrefix ?? "RL";
+        this.ttlWindowMultiplier = options.ttlWindowMultiplier ?? 2;
+        if (!Number.isFinite(this.ttlWindowMultiplier) || this.ttlWindowMultiplier < 1) {
+            throw new Error("ttlWindowMultiplier must be a number greater than or equal to 1");
+        }
+        this.failOpen = options.failOpen ?? false;
+        this.client = options.client ?? new DynamoDBClient(options.region ? { region: options.region } : {});
+    }
+    /**
+     * Increment every configured window for `trackerKey` (IP, session, user id, ...)
+     * and report whether any of them is over its limit.
+     */
+    async isRateLimited(trackerKey, policy) {
+        for (const { key, seconds } of WINDOW_CONFIG) {
+            const limit = policy[key];
+            if (!limit)
+                continue;
+            const exceeded = await this.incrementWindow(trackerKey, key, seconds, limit);
+            if (exceeded)
+                return { [key]: limit };
+        }
+        return false;
+    }
+    /** Increments one window counter. Returns true when the limit was already reached. */
+    async incrementWindow(trackerKey, sortKeyPrefix, windowSeconds, limit) {
+        const nowSeconds = Math.floor(Date.now() / 1000);
+        const windowStart = Math.floor(nowSeconds / windowSeconds) * windowSeconds;
+        const expiresAt = nowSeconds + Math.ceil(windowSeconds * this.ttlWindowMultiplier);
+        const input = {
+            TableName: this.tableName,
+            Key: {
+                pk: { S: `${this.keyPrefix}#${trackerKey}` },
+                sk: { S: `${sortKeyPrefix}#${windowStart}` },
+            },
+            UpdateExpression: "ADD #count :one SET #expiresAt = if_not_exists(#expiresAt, :expiresAt)",
+            ConditionExpression: "attribute_not_exists(#count) OR #count < :limit",
+            ExpressionAttributeNames: { "#count": "count", "#expiresAt": "expiresAt" },
+            ExpressionAttributeValues: {
+                ":one": { N: "1" },
+                ":expiresAt": { N: String(expiresAt) },
+                ":limit": { N: String(limit) },
+            },
+        };
+        try {
+            await this.client.send(new UpdateItemCommand(input));
+            return false;
+        }
+        catch (error) {
+            if (error.name === "ConditionalCheckFailedException")
+                return true;
+            if (this.failOpen)
+                return false;
+            throw error;
+        }
+    }
+}
+export default LambderDdbRateLimiter;

package/dist/LambderSessionController.d.ts

@@ -2,8 +2,12 @@ import { LambderRenderContext, LambderSessionRenderContext } from "./LambderCont
 import type LambderSessionManager from "./LambderSessionManager.js";
 import type { LambderSessionContext } from "./LambderSessionManager.js";
 export type LambderSessionCookieOptions = {
-    /** e.g. ".example.com" to share sessions across subdomains. */
-    domain?: string;
+    /**
+     * e.g. ".example.com" to share sessions across subdomains. Pass a function to
+     * derive it from the request hostname when one deployment serves several
+     * apex domains; return undefined for a host-only cookie.
+     */
+    domain?: string | ((hostname: string) => string | undefined | null);
     path?: string;
     sameSite?: "Strict" | "Lax" | "None";
     secure?: boolean;

package/dist/LambderSessionController.js

@@ -14,11 +14,14 @@ export default class LambderSessionController {
     ;
     buildCookie(key, value, expiresAtMs, httpOnly) {
         const { domain, path = "/", sameSite = "Lax", secure = true } = this.cookieOptions;
+        // Host header can carry a port; browsers match the Domain attribute on hostname only.
+        const hostname = (this.ctx.host || "").split(":")[0];
+        const resolvedDomain = typeof domain === "function" ? domain(hostname) : domain;
         const parts = [
             `${key}=${value}`,
             `Expires=${new Date(expiresAtMs).toUTCString()}`,
             `Path=${path}`,
-            ...(domain ? [`Domain=${domain}`] : []),
+            ...(resolvedDomain ? [`Domain=${resolvedDomain}`] : []),
             ...(httpOnly ? ["HttpOnly"] : []),
             `SameSite=${sameSite}`,
             ...(secure ? ["Secure"] : []),

package/dist/index.d.ts

@@ -19,6 +19,8 @@ export type { LambderSessionCookieOptions } from "./LambderSessionController.js"
 export type { LambderSessionContext } from "./LambderSessionManager.js";
 export { LambderDdbCache } from "./LambderDdbCache.js";
 export type { LambderDdbCacheOptions, LambderDdbCacheSetOptions, LambderDdbCacheGetOrSetOptions, } from "./LambderDdbCache.js";
+export { LambderDdbRateLimiter } from "./LambderDdbRateLimiter.js";
+export type { LambderDdbRateLimiterOptions, LambderRateLimitPolicy, LambderRateLimitExceededMap, LambderRateLimitResult, } from "./LambderDdbRateLimiter.js";
 export { createLambderI18n } from "./LambderI18n.js";
 export type { LambderLanguageMeta, LambderI18nConfig, LambderI18nInstance, LambderI18nTranslator, LambderI18nExtractParams, LambderI18nCodes, LambderI18nKeys, LambderI18nTranslatorFor, } from "./LambderI18n.js";
 export { type ApiContractShape, } from "./LambderApiContract.js";

package/dist/index.js

@@ -16,6 +16,8 @@ export { LambderTemplatingEngine } from "./LambderTemplatingEngine.js";
 export { LambderPublicFilesHandler } from "./LambderPublicFiles.js";
 // DynamoDB-backed compressed cache (standalone, server-only)
 export { LambderDdbCache } from "./LambderDdbCache.js";
+// DynamoDB-backed fixed-window rate limiter (standalone, server-only)
+export { LambderDdbRateLimiter } from "./LambderDdbRateLimiter.js";
 // Typed translations (standalone, isomorphic)
 export { createLambderI18n } from "./LambderI18n.js";
 export { createContext, isV2HttpEvent } from "./LambderContext.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lambder",
-  "version": "3.3.0",
+  "version": "3.3.3",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",