lambder 2.0.18 → 3.0.0

package/src/LambderContext.ts

@@ -1,78 +0,0 @@
-import cookieParser from "cookie";
-import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, Context } from "aws-lambda";
-import type { LambderSessionContext } from "./LambderSessionManager.js";
-
-export type LambderRenderContext<TApiPayload = any> = {
-    host: string;
-    path: string;
-    pathParams: Record<string, any> | null;
-    method: string;
-    get: Record<string, any>;
-    post: Record<string, any>;
-    cookie: Record<string, any>;
-    session: null;
-    apiName: string;
-    apiPayload: TApiPayload;
-    headers: APIGatewayProxyEventHeaders;
-    event: APIGatewayProxyEvent;
-    lambdaContext: Context;
-    _otherInternal: { 
-        isApiCall: boolean,
-        requestVersion: string|null;
-        setHeaderFnAccumulator: { key:string, value:string|string[] }[];
-        addHeaderFnAccumulator: { key:string, value:string }[];
-        logToApiResponseAccumulator: any[];
-    };
-};
-
-export type LambderSessionRenderContext<
-    TApiPayload = any, SessionData = any
-> = Omit<LambderRenderContext<TApiPayload>, 'session'> & { session: LambderSessionContext<SessionData> };
-
-export const createContext = (
-    event: APIGatewayProxyEvent, 
-    lambdaContext: Context,
-    apiPath: string,
-):LambderRenderContext<any> => {
-    const host = event.headers.Host || event.headers.host || "";
-    const path = event.path;
-    const pathParams = null;
-    const get: Record<string, any> = event.queryStringParameters || {};
-    const method = event.httpMethod;
-    const cookie = cookieParser.parse(event.headers.Cookie || event.headers.cookie || "");
-    const headers = event.headers;
-    
-    // Decode body for the post
-    let post: Record<string, any> = {};
-    try {
-        const decodedBody = event.isBase64Encoded ? ( event.body ? Buffer.from(event.body,"base64").toString() : "{}" ) : ( event.body || "{}" );
-        try { post = JSON.parse(decodedBody) || {}; }
-        catch(e){ 
-            const params = new URLSearchParams(decodedBody);
-            post = {};
-            for(const [key, value] of params.entries()){
-                post[key] = value;
-            }
-        }
-    }catch(e){}
-    // Parse api variables
-
-    const isApiCall = method === "POST" && apiPath && path === apiPath && post.apiName;
-    const apiName:string = isApiCall ? post.apiName : null;
-    const apiPayload:string = isApiCall ? post.payload : null;
-    const requestVersion:string = isApiCall ? post.version : null;
-
-    return { 
-        host, path, pathParams, method, 
-        get, post, cookie, event,
-        session: null,
-        apiName, apiPayload, 
-        headers, lambdaContext, 
-        _otherInternal: { 
-            isApiCall, requestVersion,
-            setHeaderFnAccumulator: [], 
-            addHeaderFnAccumulator: [], 
-            logToApiResponseAccumulator: [], 
-        } 
-    };
-}

package/src/LambderMSW.ts

@@ -1,180 +0,0 @@
-import type { ApiContractShape } from './LambderApiContract';
-import type { LambderApiResponse } from './LambderResponseBuilder';
-
-// MSW types - these will be resolved at runtime when msw is installed
-type RequestHandler = any;
-
-type MockApiOptions = {
-    versionExpired?: boolean;
-    sessionExpired?: boolean;
-    notAuthorized?: boolean;
-    message?: any;
-    errorMessage?: any;
-    logList?: any[];
-    delay?: number; // Add artificial delay to simulate network latency
-};
-
-// Extended response type that includes apiVersion
-type MockApiResponse<T> = {
-    apiVersion?: string;
-} & LambderApiResponse<T>;
-
-export default class LambderMSW<TContract extends ApiContractShape = any> {
-    private apiPath: string;
-    private apiVersion?: string;
-    private http: any;
-    private HttpResponse: any;
-
-    constructor({
-        apiPath,
-        apiVersion,
-    }: {
-        apiPath: string;
-        apiVersion?: string;
-    }) {
-        this.apiPath = apiPath;
-        this.apiVersion = apiVersion;
-        
-        // Dynamically import MSW - it needs to be installed by the user
-        try {
-            const msw = require('msw');
-            this.http = msw.http;
-            this.HttpResponse = msw.HttpResponse;
-        } catch (err) {
-            throw new Error('MSW (Mock Service Worker) is required. Install it with: npm install msw --save-dev');
-        }
-    }
-
-    /**
-     * Mock an API endpoint with MSW
-     * @param apiName - The name of the API to mock
-     * @param handler - Function that returns the mock payload
-     * @param options - Additional response options (session expired, version expired, etc.)
-     * 
-     * Note: TypeScript will check that the return type is assignable to the output type,
-     * but due to structural typing, extra properties are allowed. Enable strict checks
-     * in your tsconfig.json with "noUncheckedIndexedAccess" and "exactOptionalPropertyTypes"
-     * for better type safety.
-     */
-    mockApi<TApiName extends keyof TContract>(
-        apiName: TApiName,
-        handler: (payload?: TContract[TApiName]['input']) => Promise<TContract[TApiName]['output']> | TContract[TApiName]['output'],
-        options?: MockApiOptions
-    ): RequestHandler {
-        return this.http.post(this.apiPath, async ({ request }: any) => {
-            let body: any;
-            
-            try {
-                const clonedRequest = request.clone();
-                body = await clonedRequest.json();
-            } catch (parseErr) {
-                // If JSON parsing fails, return undefined to let other handlers try
-                console.warn("LambderMSW: Failed to parse request body as JSON");
-                return;
-            }
-            
-            // Check if body is valid and has apiName
-            if (!body || typeof body.apiName !== 'string') { return; }
-            if (body.apiName !== apiName) { return; }
-            
-            try {
-                // Add artificial delay if specified
-                if (options?.delay) {
-                    await new Promise(resolve => setTimeout(resolve, options.delay));
-                }
-
-                // Call the handler with the payload from the request
-                const payload = await handler(body.payload as TContract[TApiName]['input']);
-                
-                const response: MockApiResponse<TContract[TApiName]['output']> = {
-                    apiVersion: this.apiVersion,
-                    payload,
-                    ...(options?.versionExpired ? { versionExpired: options.versionExpired } : {}),
-                    ...(options?.sessionExpired ? { sessionExpired: options.sessionExpired } : {}),
-                    ...(options?.notAuthorized ? { notAuthorized: options.notAuthorized } : {}),
-                    ...(options?.message ? { message: options.message } : {}),
-                    ...(options?.errorMessage ? { errorMessage: options.errorMessage } : {}),
-                    ...(options?.logList?.length ? { logList: options.logList } : {}),
-                };
-
-                return this.HttpResponse.json(response);
-            } catch (err: any) {
-                // Only handle errors that occur during handler execution for matched APIs
-                console.error("Error in LambderMSW handler for", apiName, ":", err);
-                
-                const errorResponse: MockApiResponse<null> = {
-                    apiVersion: this.apiVersion,
-                    payload: null,
-                    errorMessage: err.message || "Unknown error",
-                };
-
-                return this.HttpResponse.json(errorResponse, { status: 500 });
-            }
-        });
-    }
-
-    /**
-     * Mock an API endpoint that returns a session expired error
-     */
-    mockSessionExpired<TApiName extends keyof TContract>(
-        apiName: TApiName
-    ): RequestHandler {
-        return this.mockApi(
-            apiName,
-            async () => null as any,
-            { sessionExpired: true }
-        );
-    }
-
-    /**
-     * Mock an API endpoint that returns a version expired error
-     */
-    mockVersionExpired<TApiName extends keyof TContract>(
-        apiName: TApiName
-    ): RequestHandler {
-        return this.mockApi(
-            apiName,
-            async () => null as any,
-            { versionExpired: true }
-        );
-    }
-
-    /**
-     * Mock an API endpoint that returns a not authorized error
-     */
-    mockNotAuthorized<TApiName extends keyof TContract>(
-        apiName: TApiName
-    ): RequestHandler {
-        return this.mockApi(
-            apiName,
-            async () => null as any,
-            { notAuthorized: true }
-        );
-    }
-
-    /**
-     * Mock an API endpoint that returns an error message
-     */
-    mockError<TApiName extends keyof TContract>(
-        apiName: TApiName,
-        errorMessage: string
-    ): RequestHandler {
-        return this.mockApi(
-            apiName,
-            async () => null as any,
-            { errorMessage }
-        );
-    }
-
-    /**
-     * Mock an API endpoint with a custom message
-     */
-    mockWithMessage<TApiName extends keyof TContract>(
-        apiName: TApiName,
-        handler: (payload?: TContract[TApiName]['input']) => Promise<TContract[TApiName]['output']> | TContract[TApiName]['output'],
-        message: any
-    ): RequestHandler {
-        return this.mockApi(apiName, handler, { message });
-    }
-}
-

package/src/LambderResolver.ts

@@ -1,101 +0,0 @@
-import type { LambderRenderContext } from "./LambderContext.js";
-import LambderResponseBuilder, { LambderResolverResponse } from "./LambderResponseBuilder.js";
-import LambderUtils from "./LambderUtils.js";
-
-type MethodType<T, M extends keyof T> = T[M] extends (...args: any[]) => any ? T[M] : never;
-
-interface DieResolverMethods<TOutput> {
-    raw: MethodType<LambderResponseBuilder, 'raw'>;
-    json: MethodType<LambderResponseBuilder, 'json'>;
-    xml: MethodType<LambderResponseBuilder, 'xml'>;
-    html: MethodType<LambderResponseBuilder, 'html'>;
-    redirect: MethodType<LambderResponseBuilder, 'redirect'>;
-    status404: MethodType<LambderResponseBuilder, 'status404'>;
-    cors: MethodType<LambderResponseBuilder, 'cors'>;
-    fileBase64: MethodType<LambderResponseBuilder, 'fileBase64'>;
-    file: MethodType<LambderResponseBuilder, 'file'>;
-    ejsFile: MethodType<LambderResponseBuilder, 'ejsFile'>;
-    ejsTemplate: MethodType<LambderResponseBuilder, 'ejsTemplate'>;
-    api: (
-        payload: TOutput | null,
-        config?: Parameters<LambderResponseBuilder['api']>[1],
-        headers?: Parameters<LambderResponseBuilder['api']>[2]
-    ) => LambderResolverResponse;
-}
-
-export default class LambderResolver<TOutput = any> extends LambderResponseBuilder<TOutput> {
-    public resolve: (response: LambderResolverResponse) => void;
-    public reject: (err: Error) => void;
-    public die: DieResolverMethods<TOutput>;
-
-    constructor(
-        { isCorsEnabled, publicPath, apiVersion, lambderUtils, ctx, resolve, reject }: 
-        { 
-            isCorsEnabled: boolean, 
-            publicPath: string,
-            apiVersion?: string|null,
-            lambderUtils: LambderUtils,
-            ctx: LambderRenderContext<any>,
-            resolve: (response: LambderResolverResponse) => void,
-            reject: (err: Error) => void,
-        }
-    ){
-        super({ isCorsEnabled, publicPath, apiVersion, lambderUtils, ctx, });
-        this.resolve = resolve;
-        this.reject = reject;
-
-        this.die = {
-            raw: this.autoResolve(this.raw),
-            json: this.autoResolve(this.json),
-            xml: this.autoResolve(this.xml),
-            html: this.autoResolve(this.html),
-            redirect: this.autoResolve(this.redirect),
-            status404: this.autoResolve(this.status404),
-            cors: this.autoResolve(this.cors),
-            fileBase64: this.autoResolve(this.fileBase64),
-            file: this.autoResolvePromise(this.file),
-            ejsFile: this.autoResolvePromise(this.ejsFile),
-            ejsTemplate: this.autoResolvePromise(this.ejsTemplate),
-            api: this.autoResolve(this.api),
-        };
-    }
-
-    // Override api method with proper typing
-    api(
-        payload: TOutput | null,
-        config?: Parameters<LambderResponseBuilder['api']>[1],
-        headers?: Parameters<LambderResponseBuilder['api']>[2]
-    ): LambderResolverResponse {
-        return super.api(payload, config, headers);
-    }
-
-
-    private autoResolve<
-        T extends (...args: any[]) => LambderResolverResponse
-    >(method: T): (...funcArgs: Parameters<T>) => LambderResolverResponse {
-        return (...args: Parameters<T>): LambderResolverResponse => {
-            const result: LambderResolverResponse = method.apply(this, args);
-            this.resolve(result);
-            return result;
-        };
-    }
-
-    private autoResolvePromise<
-        T extends (...args: any[]) => Promise<LambderResolverResponse>
-    >(method: T): (...funcArgs: Parameters<T>) => Promise<LambderResolverResponse> {
-        return (...args: Parameters<T>): Promise<LambderResolverResponse> => {
-            return new Promise<LambderResolverResponse>((resolve, reject) => {
-                method.apply(this, args)
-                    .then(result => {
-                        this.resolve(result);
-                        resolve(result);
-                    })
-                    .catch(err => {
-                        this.reject(err);
-                        reject(err);
-                    });
-            });
-        };
-    }
-
-};

package/src/LambderResponseBuilder.ts

@@ -1,332 +0,0 @@
-import mimeTypeResolver from "mime-types";
-import LambderUtils from "./LambderUtils.js";
-import { LambderRenderContext } from "./LambderContext.js";
-import { getFS, getPath } from "./node-polyfills.js";
-
-const convertToMultiHeader = (
-    headers: Record<string, string|string[]> | undefined
-):Record<string, string[]>  =>
-    Object.fromEntries(Object.entries(headers||{}).map(([k,v])=>[ k, Array.isArray(v) ? v : [v] ]));
-
-const CORS_HEADERS = convertToMultiHeader({
-    "Access-Control-Allow-Credentials": "true",
-    "Access-Control-Allow-Headers" : "Origin, X-Requested-With, Content-Type, Accept",
-    "Access-Control-Allow-Origin": "*",
-    "Access-Control-Allow-Methods": "OPTIONS,POST",
-});
-
-export type HttpStatusCode = 
-    | 200 | 201 | 202 | 204
-    | 300 | 301 | 302 | 303 | 304 | 307 | 308
-    | 400 | 401 | 403 | 404 | 405 | 409 | 410 | 413 | 415 | 422 | 429
-    | 500 | 501 | 502 | 503 | 504;
-
-export type LambderResolverResponse = { 
-    statusCode: HttpStatusCode, 
-    multiValueHeaders?: Record<string, string[]>, 
-    body: string | null,
-    isBase64Encoded?: boolean,
-};
-
-export type LambderApiResponseConfig = {
-    versionExpired?: boolean; 
-    sessionExpired?: boolean; 
-    notAuthorized?: boolean; 
-    message?: any; 
-    errorMessage?: any;
-    logList?: any[];
-}
-
-
-export type LambderApiResponse<T> = LambderApiResponseConfig & {
-    payload?: T | null; 
-}
-
-export default class LambderResponseBuilder<TResponse = any> {
-    private isCorsEnabled: boolean;
-    private publicPath: string;
-    private apiVersion: string|null;
-    private lambderUtils: LambderUtils;
-    private ctx?: LambderRenderContext<any>;
-
-    constructor(
-        { isCorsEnabled, publicPath, apiVersion, lambderUtils, ctx }: 
-        { 
-            isCorsEnabled: boolean, 
-            publicPath: string,
-            apiVersion?: string|null,
-            lambderUtils: LambderUtils,
-            ctx?: LambderRenderContext<any>,
-        }
-    ){
-        this.isCorsEnabled = isCorsEnabled;
-        this.publicPath = publicPath;
-        this.apiVersion = apiVersion ?? null;
-        this.lambderUtils = lambderUtils;
-        this.ctx = ctx;
-    };
-
-    private async readPublicFileSync(filePath: string){
-        const fs = await getFS();
-        const path = await getPath();
-        
-        if (!fs || !path) {
-            throw new Error("File system operations are not available in browser environment");
-        }
-        
-        const publicPath = path.resolve(this.publicPath);
-        const normalizedFilePath = filePath.startsWith('/') ? filePath.slice(1) : filePath;
-        const absolutePath = path.resolve(publicPath, normalizedFilePath);
-        if(!absolutePath.startsWith(publicPath)){ return "forbidden-public-path"; }
-        return await fs.promises.readFile(absolutePath);
-    };
-
-    private async checkPublicFileExist(filePath: string){
-        const fs = await getFS();
-        const path = await getPath();
-        
-        if (!fs || !path) { return false; }
-        
-        const publicPath = path.resolve(this.publicPath);
-        const normalizedFilePath = filePath.startsWith('/') ? filePath.slice(1) : filePath;
-        const absolutePath = path.resolve(publicPath, normalizedFilePath);
-        if(!absolutePath.startsWith(publicPath)){ return false; }
-        try {
-            const stat = await fs.promises.stat(absolutePath);
-            return stat.isFile();
-        } catch {
-            return false;
-        }
-    };
-
-    addHeader(key: string, value: string){
-        if(!this.ctx) throw new Error(".addHeader function is not available within this hook"); 
-        else{
-            this.ctx._otherInternal.addHeaderFnAccumulator.push({ key, value });
-        }
-    };
-
-    setHeader(key: string, value: string|string[]){
-        if(!this.ctx) throw new Error(".setHeader function is not available within this hook"); 
-        else{
-            this.ctx._otherInternal.addHeaderFnAccumulator = this.ctx._otherInternal.addHeaderFnAccumulator
-                .filter((header: { key: string, value: string }) => header.key !== key);
-            this.ctx._otherInternal.setHeaderFnAccumulator.push({ key, value });
-        }
-    };
-    
-    logToApiResponse(input:any){
-        if(!this.ctx) throw new Error(".logToResponse function is not available within this hook"); 
-        else{
-            this.ctx._otherInternal.logToApiResponseAccumulator.push(input);
-        }
-    };
-
-
-    raw(param: LambderResolverResponse){
-        return param;
-    };
-
-	json(
-        data: Record<string, any>, 
-        headers?: Record<string, string|string[]>
-    ):LambderResolverResponse{
-        return this.raw({
-            statusCode: 200,
-            multiValueHeaders: { 
-                "Content-Type": ["application/json; charset=utf-8"],
-                 ...(this.isCorsEnabled ? CORS_HEADERS : {}), 
-                 ...convertToMultiHeader(headers)
-            },
-            body: JSON.stringify(data),
-        });
-    }
-
-	xml(data: string):LambderResolverResponse{
-        return this.raw({
-            statusCode: 200,
-            isBase64Encoded: true,
-            multiValueHeaders: { "Content-Type": ["application/xml; charset=utf-8"]}, 
-            body: Buffer.from(data).toString("base64"),
-        });
-    };
-
-	html(
-        data: string, 
-        headers?: Record<string, string|string[]>,
-    ):LambderResolverResponse{
-        return this.raw({
-            statusCode: 200,
-            isBase64Encoded: true,
-            multiValueHeaders: {"Content-Type": ["text/html; charset=utf-8"], ...convertToMultiHeader(headers)},
-            body: Buffer.from(data).toString("base64"),
-        });
-    };
-
-    redirect(
-        url: string, 
-        statusCode: HttpStatusCode = 302,
-        headers?: Record<string, string|string[]>,
-    ):LambderResolverResponse{
-        return this.raw({
-            statusCode: statusCode, 
-            multiValueHeaders: { "Location" : [url], ...convertToMultiHeader(headers) },
-            body:null
-        });
-    };
-
-	status404(
-        data: string,
-        headers?: Record<string, string|string[]>,
-    ):LambderResolverResponse{
-        return this.raw({
-            statusCode: 404,
-            isBase64Encoded: true,
-            multiValueHeaders: {"Content-Type": ["text/html; charset=utf-8"], ...convertToMultiHeader(headers)},
-            body: Buffer.from(data).toString("base64"),
-        });
-    };
-
-	versionExpired(
-        headers?: Record<string, string|string[]>,
-    ):LambderResolverResponse{
-        return this.api(null, { versionExpired: true }, headers);
-    };
-
-	cors():LambderResolverResponse{
-        return this.raw({ 
-            statusCode: 200,
-            multiValueHeaders: this.isCorsEnabled ? CORS_HEADERS: {},
-            body: JSON.stringify(""),
-        });
-    };
-
-	fileBase64 (
-        fileBase64: string, 
-        mimeType: string, 
-        headers?: Record<string, string|string[]>,
-    ):LambderResolverResponse{
-        return this.raw({ 
-            statusCode: 200, 
-            isBase64Encoded: true, 
-            multiValueHeaders: { "Content-Type": [mimeType || "application/octet-stream"], ...convertToMultiHeader(headers) }, 
-            body: fileBase64, 
-        });
-    };
-
-	async file(
-        filePath: string, 
-        headers?: Record<string, string|string[]>,
-        fallbackFilePath?: string,
-    ):Promise<LambderResolverResponse>{
-        const doesFileExist = await this.checkPublicFileExist(filePath);
-        if(!doesFileExist){
-            if(fallbackFilePath){
-                const doesFallbackExist = await this.checkPublicFileExist(fallbackFilePath);
-                if(doesFallbackExist){
-                    return await this.file(fallbackFilePath, headers);
-                }
-            }
-            return this.json({ error: "File not found: " + filePath })
-        }
-        const mimeType = mimeTypeResolver.lookup(filePath);
-        const body = await this.readPublicFileSync(filePath);
-        if (body === "forbidden-public-path") {
-            throw new Error("Forbidden public path: " + filePath);
-        }
-        const bodyBuffer: Buffer =  Buffer.isBuffer(body) ? body : Buffer.from(body);
-        const bodyBase64 = bodyBuffer.toString("base64");
-        console.log("bodyBase64.length",bodyBase64.length);
-        return this.fileBase64(bodyBase64, mimeType || "application/octet-stream", headers);
-    };
-
-	async ejsTemplate(
-        template: string, 
-        pageData: Record<string, any>,
-        headers?: Record<string, string|string[]>,
-    ):Promise<LambderResolverResponse>{
-        const renderedResult = await this.lambderUtils.renderEjs(template, pageData);
-
-        return this.raw({
-            statusCode: 200,
-            isBase64Encoded: true,
-            multiValueHeaders: {"Content-Type": ["text/html; charset=utf-8"], ...convertToMultiHeader(headers)},
-            body: Buffer.from(renderedResult).toString("base64"),
-        });
-    };
-
-	async ejsFile(
-        filePath: string, 
-        pageData: Record<string, any>,
-        headers?: Record<string, string|string[]>,
-    ):Promise<LambderResolverResponse>{
-        const renderedResult = await this.lambderUtils.renderEjsFile(filePath, pageData);
-
-        return this.raw({
-            statusCode: 200,
-            isBase64Encoded: true,
-            multiValueHeaders: {"Content-Type": ["text/html; charset=utf-8"], ...convertToMultiHeader(headers)},
-            body: Buffer.from(renderedResult).toString("base64"),
-        });
-    };
-
-    api(
-        payload: TResponse | null, 
-        {
-            versionExpired, sessionExpired, notAuthorized, 
-            message, errorMessage, logList,
-        }: LambderApiResponseConfig = {
-            versionExpired: undefined, sessionExpired: undefined, notAuthorized: undefined, 
-            message: null, errorMessage: null, logList: undefined
-        }, 
-        headers?: Record<string, string|string[]>,
-    ): LambderResolverResponse {
-        const finalLogList = logList || this.ctx?._otherInternal?.logToApiResponseAccumulator;
-        return this.json({ 
-            apiVersion: this.apiVersion,
-            payload,
-            ...(versionExpired ? {versionExpired} : {}),
-            ...(sessionExpired ? {sessionExpired} : {}),
-            ...(notAuthorized ? {notAuthorized} : {}),
-            ...(message ? {message} : {}),
-            ...(errorMessage ? {errorMessage} : {}),
-            ...(finalLogList?.length ? {logList: finalLogList} : {}),
-        }, headers);
-    };
-
-    apiBinary<T=any>(
-        payload: T | null, 
-        {
-            versionExpired, sessionExpired, notAuthorized, 
-            message, errorMessage, logList,
-        }: LambderApiResponseConfig = {
-            versionExpired: undefined, sessionExpired: undefined, notAuthorized: undefined, 
-            message: null, errorMessage: null, logList: undefined
-        }, 
-        headers?: Record<string, string|string[]>,
-    ): LambderResolverResponse {
-        const finalLogList = logList || this.ctx?._otherInternal?.logToApiResponseAccumulator;
-        const result = { 
-            apiVersion: this.apiVersion,
-            payload,
-            ...(versionExpired ? {versionExpired} : {}),
-            ...(sessionExpired ? {sessionExpired} : {}),
-            ...(notAuthorized ? {notAuthorized} : {}),
-            ...(message ? {message} : {}),
-            ...(errorMessage ? {errorMessage} : {}),
-            ...(finalLogList?.length ? {logList: finalLogList} : {}),
-        };
-
-        return this.raw({ 
-            statusCode: 200, 
-            isBase64Encoded: true, 
-            multiValueHeaders: { 
-                "Content-Type": ["application/lambder-json-stream"],
-                "Content-Encoding": ["gzip"],
-                ...convertToMultiHeader(headers) 
-            }, 
-            body: Buffer.from(JSON.stringify(result)).toString("base64"), 
-        });
-    };
-
-};