npm - lambder - Versions diffs - 2.0.18 → 3.0.0 - Mend

lambder 2.0.18 → 3.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (67) hide show

package/Readme.md +162 -41
package/dist/Lambder.d.ts +154 -46
package/dist/Lambder.js +312 -166
package/dist/LambderCaller.js +6 -3
package/dist/LambderContext.d.ts +20 -9
package/dist/LambderContext.js +57 -17
package/dist/LambderCors.d.ts +12 -0
package/dist/LambderCors.js +30 -0
package/dist/LambderHtml.d.ts +33 -0
package/dist/LambderHtml.js +62 -0
package/dist/LambderMSW.d.ts +16 -1
package/dist/LambderMSW.js +5 -9
package/dist/LambderPublicFiles.d.ts +47 -0
package/dist/LambderPublicFiles.js +108 -0
package/dist/LambderResolver.d.ts +30 -31
package/dist/LambderResolver.js +29 -43
package/dist/LambderResponse.d.ts +71 -0
package/dist/LambderResponse.js +196 -0
package/dist/LambderResponseBuilder.d.ts +58 -33
package/dist/LambderResponseBuilder.js +114 -167
package/dist/LambderRouting.d.ts +23 -0
package/dist/LambderRouting.js +67 -0
package/dist/LambderSessionController.d.ts +13 -1
package/dist/LambderSessionController.js +33 -10
package/dist/LambderSessionManager.d.ts +3 -1
package/dist/LambderSessionManager.js +15 -6
package/dist/LambderTemplatingEngine.d.ts +87 -0
package/dist/LambderTemplatingEngine.js +156 -0
package/dist/index.d.ts +14 -2
package/dist/index.js +10 -1
package/dist/node-polyfills.d.ts +4 -2
package/dist/node-polyfills.js +28 -0
package/package.json +7 -5
package/.eslintrc.cjs +0 -26
package/.vscode/settings.json +0 -26
package/deploy +0 -22
package/dist/LambderUtils.d.ts +0 -10
package/dist/LambderUtils.js +0 -70
package/docs/DYNAMODB_SETUP.md +0 -96
package/docs/LAMBDER_MSW.md +0 -409
package/docs/TYPE_SAFE_QUICK_START.md +0 -77
package/examples/msw-testing-example.ts +0 -280
package/examples/secure-session-example.ts +0 -207
package/examples/zod-chained-api-example.ts +0 -63
package/src/Lambder.ts +0 -430
package/src/LambderApiContract.ts +0 -20
package/src/LambderCaller.ts +0 -238
package/src/LambderContext.ts +0 -78
package/src/LambderMSW.ts +0 -180
package/src/LambderResolver.ts +0 -101
package/src/LambderResponseBuilder.ts +0 -332
package/src/LambderSessionController.ts +0 -114
package/src/LambderSessionManager.ts +0 -217
package/src/LambderUtils.ts +0 -75
package/src/index.ts +0 -17
package/src/node-polyfills.ts +0 -27
package/tests/error-handling.test.ts +0 -585
package/tests/file-serving.test.ts +0 -194
package/tests/fixtures/public/index.html +0 -1
package/tests/fixtures/public/main.css +0 -1
package/tests/hooks.test.ts +0 -561
package/tests/output-type-runtime.test.ts +0 -381
package/tests/redirect.test.ts +0 -88
package/tests/routes.test.ts +0 -543
package/tests/session.test.ts +0 -1083
package/tests/use-plugin.test.ts +0 -460
package/tsconfig.json +0 -24

package/dist/LambderTemplatingEngine.d.ts ADDED Viewed

@@ -0,0 +1,87 @@
+import { type LambderHtmlValue } from "./LambderHtml.js";
+/**
+ * LambderTemplatingEngine: a comment-only HTML template engine.
+ *
+ * Fully standalone: it has no dependency on Lambder routing or file serving,
+ * and can template any HTML: app shells, emails, error pages. res.templateFile
+ * uses it internally to render HTML files from publicPath per request.
+ *
+ * Every construct is an HTML comment. That is the whole point: templates
+ * survive HTML build pipelines (e.g. Vite) untouched, and are invisible in the
+ * browser during frontend development, where the default content between the
+ * markers renders as-is.
+ *
+ * Syntax:
+ *
+ *   <!--slot:name-->default content<!--/slot:name-->    replaceable region;
+ *                                                       default kept when the
+ *                                                       data omits "name"
+ *   <!--slot:name/-->                                   insert-only point
+ *   <!--if:name--> ... <!--else--> ... <!--/if:name-->  conditional block,
+ *                                                       shown when data.name
+ *                                                       is truthy
+ *   <!--if:!name--> ... <!--/if:!name-->                negated conditional
+ *
+ * Blocks nest freely (ifs in slots, slots in ifs). There are intentionally no
+ * loops or inline expressions: dynamic lists are built server-side with the
+ * html`...` tagged template and passed in as a slot value. Attribute-position
+ * values (e.g. <html lang="...">) are handled with if/else around whole-tag
+ * variants.
+ *
+ * Data is dynamically typed: one Record<string, LambderHtmlValue> shared by
+ * slots and conditions.
+ *   - strings/numbers are HTML-escaped on insertion (XSS-safe by default)
+ *   - html`...` / raw() / jsonScript() values are inserted verbatim
+ *   - arrays are flattened; null/undefined/false render the slot default
+ *   - unknown data keys are ignored, so one data object can serve several
+ *     templates with different slots
+ *
+ * Templates are parsed once (construction throws on unclosed or mismatched
+ * blocks with a descriptive message); render() is a cheap tree walk, safe to
+ * call per request. Discovered names are exposed on `slotNames` and
+ * `conditionNames` for runtime validation.
+ *
+ * @example
+ * ```typescript
+ * import { LambderTemplatingEngine, html } from "lambder";
+ *
+ * const template = new LambderTemplatingEngine(`
+ *     <title><!--slot:title-->My Site<!--/slot:title--></title>
+ *     <!--if:isBeta--><meta name="robots" content="noindex" /><!--/if:isBeta-->
+ *     <!--slot:head/-->
+ * `);
+ *
+ * template.render({
+ *     title: userInput,                                      // escaped
+ *     isBeta: stage === "beta",
+ *     head: html`<link rel="canonical" href="${canonical}" />`, // verbatim
+ * });
+ *
+ * // Or load from disk (compile once, render many times):
+ * const emailTemplate = await LambderTemplatingEngine.fromFile("./templates/welcome.html");
+ * ```
+ */
+export type LambderTemplateData = Record<string, LambderHtmlValue>;
+export type LambderTemplatingEngineOptions = {
+    /**
+     * For full HTML documents without declared markers: expose the <title>
+     * element content as slot "title" and the position before </head> as
+     * insert-only slot "head". Default: false.
+     */
+    htmlVirtualSlots?: boolean;
+};
+export declare class LambderTemplatingEngine {
+    private nodes;
+    /** Slot names discovered at compile time (dynamic typing surface). */
+    readonly slotNames: readonly string[];
+    /** Condition names discovered at compile time. */
+    readonly conditionNames: readonly string[];
+    /** Parse `source`; throws on unclosed or mismatched blocks. */
+    constructor(source: string, options?: LambderTemplatingEngineOptions);
+    /** Read and parse a template file (compile once, render many times). */
+    static fromFile(filePath: string, options?: LambderTemplatingEngineOptions): Promise<LambderTemplatingEngine>;
+    /** True when the template declares `name` as a slot or condition. */
+    has(name: string): boolean;
+    /** Render with escaped-by-default data; unknown keys ignored, omitted slots keep defaults. */
+    render(data?: LambderTemplateData): string;
+}

package/dist/LambderTemplatingEngine.js ADDED Viewed

@@ -0,0 +1,156 @@
+import { getFS } from "./node-polyfills.js";
+import { renderHtmlValue } from "./LambderHtml.js";
+const TOKEN_PATTERN = /<!--\s*(?:(slot:([\w-]+)\s*\/)|(slot:([\w-]+))|(\/slot:([\w-]+))|(if:(!?)([\w-]+))|(else)|(\/if:(!?)([\w-]+)))\s*-->/g;
+/**
+ * Fail loudly on slot positions where HTML escaping cannot protect against
+ * injection: unquoted attribute values (`class=<!--slot:x/-->`) and inside
+ * <script>/<style> elements (HTML escaping is the wrong grammar there; embed
+ * data with jsonScript() into a normal slot instead).
+ */
+const assertSafeSlotPosition = (source, slotIndex, slotName) => {
+    const before = source.slice(0, slotIndex);
+    if (/=\s*$/.test(before)) {
+        throw new Error(`LambderTemplatingEngine: slot "${slotName}" is in an unquoted attribute position. ` +
+            `Escaping cannot prevent injection there; quote the attribute: attr="<!--slot:${slotName}/-->".`);
+    }
+    for (const tag of ["script", "style"]) {
+        const lastOpen = before.toLowerCase().lastIndexOf(`<${tag}`);
+        if (lastOpen !== -1 && before.toLowerCase().indexOf(`</${tag}`, lastOpen) === -1) {
+            throw new Error(`LambderTemplatingEngine: slot "${slotName}" is inside a <${tag}> element where HTML ` +
+                `escaping does not apply. Pass data with the jsonScript() helper in a regular slot instead.`);
+        }
+    }
+};
+const parseTemplate = (source) => {
+    const root = { kind: "root", name: "", negated: false, nodes: [], elseNodes: [], inElse: false };
+    const stack = [root];
+    const top = () => stack[stack.length - 1];
+    const emit = (node) => {
+        const frame = top();
+        (frame.inElse ? frame.elseNodes : frame.nodes).push(node);
+    };
+    TOKEN_PATTERN.lastIndex = 0;
+    let cursor = 0;
+    let match;
+    while ((match = TOKEN_PATTERN.exec(source)) !== null) {
+        if (match.index > cursor) {
+            emit({ type: "text", value: source.slice(cursor, match.index) });
+        }
+        cursor = TOKEN_PATTERN.lastIndex;
+        const [, selfClosingSlot, selfClosingName, openSlot, openSlotName, closeSlot, closeSlotName, openIf, openIfNegation, openIfName, elseTag, closeIf, closeIfNegation, closeIfName] = match;
+        if (selfClosingSlot) {
+            assertSafeSlotPosition(source, match.index, selfClosingName);
+            emit({ type: "slot", name: selfClosingName, defaultNodes: [] });
+        }
+        else if (openSlot) {
+            assertSafeSlotPosition(source, match.index, openSlotName);
+            stack.push({ kind: "slot", name: openSlotName, negated: false, nodes: [], elseNodes: [], inElse: false });
+        }
+        else if (closeSlot) {
+            const frame = stack.pop();
+            if (!frame || frame.kind !== "slot" || frame.name !== closeSlotName) {
+                throw new Error(`LambderTemplatingEngine: unexpected <!--/slot:${closeSlotName}--> (open block: ${frame ? `${frame.kind}:${frame.name}` : "none"}).`);
+            }
+            emit({ type: "slot", name: frame.name, defaultNodes: frame.nodes });
+        }
+        else if (openIf) {
+            stack.push({ kind: "if", name: openIfName, negated: openIfNegation === "!", nodes: [], elseNodes: [], inElse: false });
+        }
+        else if (elseTag) {
+            const frame = top();
+            if (frame.kind !== "if" || frame.inElse) {
+                throw new Error("LambderTemplatingEngine: <!--else--> outside of an <!--if:...--> block.");
+            }
+            frame.inElse = true;
+        }
+        else if (closeIf) {
+            const frame = stack.pop();
+            const negated = closeIfNegation === "!";
+            if (!frame || frame.kind !== "if" || frame.name !== closeIfName || frame.negated !== negated) {
+                throw new Error(`LambderTemplatingEngine: unexpected <!--/if:${closeIfNegation}${closeIfName}--> (open block: ${frame ? `${frame.kind}:${frame.name}` : "none"}).`);
+            }
+            emit({ type: "if", name: frame.name, negated: frame.negated, thenNodes: frame.nodes, elseNodes: frame.elseNodes });
+        }
+    }
+    if (cursor < source.length) {
+        emit({ type: "text", value: source.slice(cursor) });
+    }
+    if (stack.length !== 1) {
+        const frame = top();
+        throw new Error(`LambderTemplatingEngine: unclosed <!--${frame.kind}:${frame.name}--> block.`);
+    }
+    return root.nodes;
+};
+const renderNodes = (nodes, data) => {
+    let out = "";
+    for (const node of nodes) {
+        if (node.type === "text") {
+            out += node.value;
+        }
+        else if (node.type === "slot") {
+            const value = Object.prototype.hasOwnProperty.call(data, node.name) ? data[node.name] : undefined;
+            out += value === undefined ? renderNodes(node.defaultNodes, data) : renderHtmlValue(value);
+        }
+        else {
+            const condition = !!data[node.name] !== node.negated;
+            out += renderNodes(condition ? node.thenNodes : node.elseNodes, data);
+        }
+    }
+    return out;
+};
+const collectNames = (nodes, slots, conditions) => {
+    for (const node of nodes) {
+        if (node.type === "slot") {
+            slots.add(node.name);
+            collectNames(node.defaultNodes, slots, conditions);
+        }
+        else if (node.type === "if") {
+            conditions.add(node.name);
+            collectNames(node.thenNodes, slots, conditions);
+            collectNames(node.elseNodes, slots, conditions);
+        }
+    }
+};
+export class LambderTemplatingEngine {
+    nodes;
+    /** Slot names discovered at compile time (dynamic typing surface). */
+    slotNames;
+    /** Condition names discovered at compile time. */
+    conditionNames;
+    /** Parse `source`; throws on unclosed or mismatched blocks. */
+    constructor(source, options = {}) {
+        this.nodes = parseTemplate(options.htmlVirtualSlots ? applyHtmlVirtualSlots(source) : source);
+        const slots = new Set();
+        const conditions = new Set();
+        collectNames(this.nodes, slots, conditions);
+        this.slotNames = [...slots];
+        this.conditionNames = [...conditions];
+    }
+    /** Read and parse a template file (compile once, render many times). */
+    static async fromFile(filePath, options = {}) {
+        const fs = await getFS();
+        if (!fs)
+            throw new Error("LambderTemplatingEngine.fromFile requires a Node.js environment.");
+        const source = await fs.promises.readFile(filePath, "utf8");
+        return new LambderTemplatingEngine(source, options);
+    }
+    /** True when the template declares `name` as a slot or condition. */
+    has(name) {
+        return this.slotNames.includes(name) || this.conditionNames.includes(name);
+    }
+    /** Render with escaped-by-default data; unknown keys ignored, omitted slots keep defaults. */
+    render(data = {}) {
+        return renderNodes(this.nodes, data);
+    }
+}
+/** Wrap the <title> content and the pre-</head> position in virtual slot markers. */
+const applyHtmlVirtualSlots = (source) => {
+    let out = source;
+    if (!/<!--\s*slot:title\b/.test(out)) {
+        out = out.replace(/(<title[^>]*>)([\s\S]*?)(<\/title>)/i, (_all, open, inner, close) => `${open}<!--slot:title-->${inner}<!--/slot:title-->${close}`);
+    }
+    if (!/<!--\s*slot:head\b/.test(out)) {
+        out = out.replace(/<\/head\s*>/i, (headClose) => `<!--slot:head/-->${headClose}`);
+    }
+    return out;
+};

package/dist/index.d.ts CHANGED Viewed

@@ -4,7 +4,19 @@ export { default as LambderCaller } from "./LambderCaller.js";
 export { default as LambderResponseBuilder } from "./LambderResponseBuilder.js";
 export { default as LambderResolver } from "./LambderResolver.js";
 export { default as LambderSessionManager } from "./LambderSessionManager.js";
+export { default as LambderSessionController } from "./LambderSessionController.js";
 export { default as LambderMSW } from "./LambderMSW.js";
+export type { LambderMswModule } from "./LambderMSW.js";
+export { LambderResponse, finalizeResponse, acceptsEncoding, type HttpStatusCode, type LambderHttpResponse, type LambderHttpEventFormat, type LambderHeadersInput, type LambderFinalizeOptions, } from "./LambderResponse.js";
+export { html, xml, raw, jsonScript, escapeHtml, renderHtmlValue, LambderSafeHtml, type LambderHtmlValue } from "./LambderHtml.js";
+export { LambderTemplatingEngine } from "./LambderTemplatingEngine.js";
+export type { LambderTemplateData, LambderTemplatingEngineOptions } from "./LambderTemplatingEngine.js";
+export type { LambderResponseOptions, LambderApiResponse, LambderApiResponseConfig, LambderRawResponseInit, } from "./LambderResponseBuilder.js";
+export type { LambderRouteMatcher, LambderCorsConfig, LambderConstructorOptions, ConditionFunction, RouteCondition, PathParamsOf, LambderActionTools, LambderHandler, LambderIndexHtmlOptions, } from "./Lambder.js";
+export { LambderPublicFilesHandler } from "./LambderPublicFiles.js";
+export type { LambderPublicFilesOptions } from "./LambderPublicFiles.js";
+export type { LambderSessionCookieOptions } from "./LambderSessionController.js";
+export type { LambderSessionContext } from "./LambderSessionManager.js";
 export { type ApiContractShape, } from "./LambderApiContract.js";
-export type { LambderRenderContext, LambderSessionRenderContext } from "./LambderContext.js";
-export { createContext } from "./LambderContext.js";
+export type { LambderRenderContext, LambderSessionRenderContext, LambderHttpEvent } from "./LambderContext.js";
+export { createContext, isV2HttpEvent } from "./LambderContext.js";

package/dist/index.js CHANGED Viewed

@@ -4,5 +4,14 @@ export { default as LambderCaller } from "./LambderCaller.js";
 export { default as LambderResponseBuilder } from "./LambderResponseBuilder.js";
 export { default as LambderResolver } from "./LambderResolver.js";
 export { default as LambderSessionManager } from "./LambderSessionManager.js";
+export { default as LambderSessionController } from "./LambderSessionController.js";
 export { default as LambderMSW } from "./LambderMSW.js";
-export { createContext } from "./LambderContext.js";
+// Response model
+export { LambderResponse, finalizeResponse, acceptsEncoding, } from "./LambderResponse.js";
+// Type-safe templating (tagged templates with auto-escaping)
+export { html, xml, raw, jsonScript, escapeHtml, renderHtmlValue, LambderSafeHtml } from "./LambderHtml.js";
+// Comment-based HTML templating engine (build-pipeline-safe slots and conditionals, standalone)
+export { LambderTemplatingEngine } from "./LambderTemplatingEngine.js";
+// Public file serving
+export { LambderPublicFilesHandler } from "./LambderPublicFiles.js";
+export { createContext, isV2HttpEvent } from "./LambderContext.js";

package/dist/node-polyfills.d.ts CHANGED Viewed

@@ -1,2 +1,4 @@
-export declare function getFS(): Promise<any>;
-export declare function getPath(): Promise<any>;
+export declare function getFS(): Promise<typeof import('fs') | null>;
+export declare function getPath(): Promise<typeof import('path') | null>;
+export declare function getZlib(): Promise<typeof import('zlib') | null>;
+export declare function getCrypto(): Promise<typeof import('crypto') | null>;

package/dist/node-polyfills.js CHANGED Viewed

@@ -2,6 +2,8 @@
 // This file provides optional Node.js modules that fail gracefully in browser environments
 let fs = null;
 let path = null;
+let zlib = null;
+let crypto = null;
 export async function getFS() {
     try {
         if (fs) {
@@ -28,3 +30,29 @@ export async function getPath() {
         return null;
     }
 }
+export async function getZlib() {
+    try {
+        if (zlib) {
+            return zlib;
+        }
+        zlib = await import('zlib');
+        return zlib;
+    }
+    catch (e) {
+        // Silently fail - we're in a browser environment
+        return null;
+    }
+}
+export async function getCrypto() {
+    try {
+        if (crypto) {
+            return crypto;
+        }
+        crypto = await import('crypto');
+        return crypto;
+    }
+    catch (e) {
+        // Silently fail - we're in a browser environment
+        return null;
+    }
+}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "lambder",
-  "version": "2.0.18",
+  "version": "3.0.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,8 +13,13 @@
   },
   "browser": {
     "fs": false,
-    "path": false
+    "path": false,
+    "zlib": false,
+    "crypto": false
   },
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "test": "vitest run",
     "test:watch": "vitest",
@@ -31,11 +36,9 @@
     "@aws-sdk/client-dynamodb": "^3.574.0",
     "@aws-sdk/lib-dynamodb": "^3.574.0",
     "cookie": "^1.0.2",
-    "ejs": "^3.1.9",
     "js-cookie": "^3.0.5",
     "mime-types": "^2.1.35",
     "path-to-regexp": "^6.2.1",
-    "querystring": "^0.2.1",
     "zod": "^4.1.12"
   },
   "peerDependencies": {
@@ -49,7 +52,6 @@
   "devDependencies": {
     "@types/aws-lambda": "^8.10.136",
     "@types/cookie": "^0.6.0",
-    "@types/ejs": "^3.1.5",
     "@types/js-cookie": "^3.0.6",
     "@types/mime-types": "^2.1.4",
     "@types/node": "^20.19.22",

package/.eslintrc.cjs DELETED Viewed

@@ -1,26 +0,0 @@
-module.exports = {
-    "env": {
-        "browser": true,
-        "es2021": true
-    },
-    "extends": "standard-with-typescript",
-    "overrides": [
-        {
-            "env": {
-                "node": true
-            },
-            "files": [
-                ".eslintrc.{js,cjs}"
-            ],
-            "parserOptions": {
-                "sourceType": "script"
-            }
-        }
-    ],
-    "parserOptions": {
-        "ecmaVersion": "latest",
-        "sourceType": "module"
-    },
-    "rules": {
-    }
-}

package/.vscode/settings.json DELETED Viewed

@@ -1,26 +0,0 @@
-{
-    "editor.codeActionsOnSave": {
-      "source.fixAll.eslint": "explicit"
-    },
-    "eslint.validate": [
-      "javascript",
-      "javascriptreact",
-      "typescript",
-      "typescriptreact"
-    ],
-    "eslint.workingDirectories": [
-      "./src"
-    ],
-		"search.exclude": {
-			"**/node_modules/": true,
-			"**/dist/": true,
-			"**/package-lock.json": true,
-			"**/.git/": true,
-    },
-    "cSpell.words": [
-      "lambder",
-      "LMBDRAUTHID",
-      "LMBDRTOKEN"
-    ],
-  }

package/deploy DELETED Viewed

@@ -1,22 +0,0 @@
-#!/bin/bash
-# Exit immediately if a command exits with a non-zero status.
-set -e
-echo "Running tests..."
-npm run test
-echo "Tests passed! Proceeding with deployment..."
-# Update the version, build the project, and publish
-rm -rf ./dist/*
-npm version patch --no-git-tag-version
-npm run build
-npm publish
-echo "All operations completed successfully"
-# git add .
-# git commit -m ""
-# git push -u origin main

package/dist/LambderUtils.d.ts DELETED Viewed

@@ -1,10 +0,0 @@
-export default class LambderUtils {
-    private ejsPath?;
-    constructor({ ejsPath }?: {
-        ejsPath?: string;
-    });
-    private readEjsFileSync;
-    private checkEjsFileExist;
-    renderEjs(template: string, pageData: Record<string, any>): Promise<string>;
-    renderEjsFile(filePath: string, pageData: Record<string, any>): Promise<string>;
-}

package/dist/LambderUtils.js DELETED Viewed

@@ -1,70 +0,0 @@
-import ejs from "ejs";
-import { getFS, getPath } from "./node-polyfills.js";
-export default class LambderUtils {
-    ejsPath;
-    constructor({ ejsPath } = {}) {
-        this.ejsPath = ejsPath;
-    }
-    ;
-    async readEjsFileSync(filePath) {
-        const fs = await getFS();
-        const path = await getPath();
-        if (!fs || !path) {
-            throw new Error("File system operations are not available in browser environment");
-        }
-        if (!this.ejsPath) {
-            return "EJS PATH NOT SET!";
-        }
-        const ejsPath = path.resolve(this.ejsPath);
-        const normalizedFilePath = filePath.startsWith('/') ? filePath.slice(1) : filePath;
-        const absolutePath = path.resolve(ejsPath, normalizedFilePath);
-        if (!absolutePath.startsWith(ejsPath)) {
-            return "forbidden-ejs-path";
-        }
-        return await fs.promises.readFile(absolutePath, 'utf-8');
-    }
-    ;
-    async checkEjsFileExist(filePath) {
-        const fs = await getFS();
-        const path = await getPath();
-        if (!fs || !path) {
-            return false;
-        }
-        if (!this.ejsPath) {
-            return "EJS PATH NOT SET!";
-        }
-        const ejsPath = path.resolve(this.ejsPath);
-        const normalizedFilePath = filePath.startsWith('/') ? filePath.slice(1) : filePath;
-        const absolutePath = path.resolve(ejsPath, normalizedFilePath);
-        if (!absolutePath.startsWith(ejsPath)) {
-            return false;
-        }
-        try {
-            const stat = await fs.promises.stat(absolutePath);
-            return stat.isFile();
-        }
-        catch {
-            return false;
-        }
-    }
-    ;
-    async renderEjs(template, pageData) {
-        const includeRenderedFile = async (filePath, partialData) => {
-            const template = await this.readEjsFileSync(filePath);
-            return await ejs.render(template, { page: pageData, partial: partialData, include: includeRenderedFile }, { async: true });
-        };
-        const renderedResult = await ejs.render(template, { page: pageData, include: includeRenderedFile }, { async: true });
-        return renderedResult;
-    }
-    ;
-    async renderEjsFile(filePath, pageData) {
-        const doesFileExist = await this.checkEjsFileExist(filePath);
-        if (!doesFileExist) {
-            return "File not found: " + filePath;
-        }
-        const template = await this.readEjsFileSync(filePath);
-        return this.renderEjs(template, pageData);
-    }
-    ;
-}
-;

package/docs/DYNAMODB_SETUP.md DELETED Viewed

@@ -1,96 +0,0 @@
-# DynamoDB Session Table Setup Guide
-This guide helps you set up a DynamoDB table for Lambder session management with all security features enabled.
-## Table Creation
-### Using Terraform
-```hcl
-resource "aws_dynamodb_table" "lambder_sessions" {
-  name           = "lambder-sessions"
-  billing_mode   = "PAY_PER_REQUEST"
-  hash_key       = "pk"
-  range_key      = "sk"
-  attribute {
-    name = "pk"
-    type = "S"
-  }
-  attribute {
-    name = "sk"
-    type = "S"
-  }
-  ttl {
-    enabled        = true
-    attribute_name = "expiresAt"
-  }
-  tags = {
-    Purpose = "Session Management"
-  }
-}
-```
-## Enable Time to Live (TTL)
-TTL automatically removes expired sessions from DynamoDB, saving storage costs.
-### Using AWS Console
-1. Go to DynamoDB Console
-2. Select your table (`lambder-sessions`)
-3. Navigate to **Additional settings** tab
-4. Click **Edit** under **Time to Live (TTL)**
-5. Enable TTL
-6. Set **TTL attribute** to: `expiresAt`
-7. Save changes
-## IAM Permissions
-Your Lambda function needs these permissions:
-```json
-{
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Action": [
-        "dynamodb:GetItem",
-        "dynamodb:PutItem",
-        "dynamodb:DeleteItem",
-        "dynamodb:Query"
-      ],
-      "Resource": [
-        "arn:aws:dynamodb:us-east-1:123456789012:table/lambder-sessions"
-      ]
-    }
-  ]
-}
-```
-## Session Data Structure
-Each session is stored as:
-```json
-{
-  "pk": "hash_of_user_id",
-  "sk": "random_64_char_hex",
-  "sessionToken": "hash_of_user_id:random_64_char_hex",
-  "csrfToken": "random_64_char_hex",
-  "sessionKey": "user_123",
-  "data": {
-    "userId": "user_123",
-    "username": "john_doe",
-    "role": "admin"
-  },
-  "createdAt": 1697712000,
-  "lastAccessedAt": 1697712300,
-  "expiresAt": 1700304000,
-  "ttlInSeconds": 2592000
-}
-```