@geek-fun/serverlessinsight 0.3.3 → 0.4.0

package/dist/src/common/context.js

@@ -10,28 +10,46 @@ const providerEnum_1 = require("./providerEnum");
 const node_async_hooks_1 = require("node:async_hooks");
 const imsClient_1 = require("./imsClient");
 const asyncLocalStorage = new node_async_hooks_1.AsyncLocalStorage();
+const DEFAULT_IAC_FILES = [
+    'serverlessinsight.yml',
+    'serverlessInsight.yml',
+    'ServerlessInsight.yml',
+    'serverless-insight.yml',
+];
 const getIacLocation = (location) => {
     const projectRoot = node_path_1.default.resolve(process.cwd());
-    if (location) {
-        const candidate = node_path_1.default.isAbsolute(location) ? location : node_path_1.default.resolve(projectRoot, location);
-        if (node_fs_1.default.existsSync(candidate)) {
-            return candidate;
+    const searchTargets = location ? [location] : DEFAULT_IAC_FILES;
+    const attempted = new Set();
+    const toAbsolutePath = (target) => node_path_1.default.isAbsolute(target) ? target : node_path_1.default.resolve(projectRoot, target);
+    const tryResolveCandidate = (target) => {
+        const resolved = toAbsolutePath(target);
+        attempted.add(resolved);
+        if (!node_fs_1.default.existsSync(resolved)) {
+            return undefined;
         }
-        throw new Error(`IaC file not found at '${candidate}'`);
-    }
-    const candidates = [
-        'serverlessinsight.yml',
-        'serverlessInsight.yml',
-        'ServerlessInsight.yml',
-        'serverless-insight.yml',
-    ];
-    for (const name of candidates) {
-        const candidate = node_path_1.default.resolve(projectRoot, name);
-        if (node_fs_1.default.existsSync(candidate)) {
-            return candidate;
+        const stats = node_fs_1.default.statSync(resolved);
+        if (stats.isDirectory()) {
+            for (const fileName of DEFAULT_IAC_FILES) {
+                const nested = node_path_1.default.join(resolved, fileName);
+                attempted.add(nested);
+                if (node_fs_1.default.existsSync(nested) && node_fs_1.default.statSync(nested).isFile()) {
+                    return nested;
+                }
+            }
+            return undefined;
+        }
+        return resolved;
+    };
+    for (const candidate of searchTargets) {
+        const match = tryResolveCandidate(candidate);
+        if (match) {
+            return match;
         }
     }
-    throw new Error(`No IaC file found. Tried: ${candidates.map((n) => `'${node_path_1.default.resolve(projectRoot, n)}'`).join(', ')}`);
+    const attemptedList = Array.from(attempted)
+        .map((n) => `'${n}'`)
+        .join(', ');
+    throw new Error(`No IaC file found. Tried: ${attemptedList}`);
 };
 exports.getIacLocation = getIacLocation;
 const setContext = async (config, reaValToken = false) => {

package/dist/src/common/iacHelper.js

@@ -36,13 +36,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatRosId = exports.calcValue = exports.calcRefs = exports.getFileSource = exports.readCodeSize = exports.resolveCode = void 0;
+exports.splitDomain = exports.formatRosId = exports.getIacDefinition = exports.calcValue = exports.calcRefs = exports.getFileSource = exports.readCodeSize = exports.resolveCode = void 0;
 const node_path_1 = __importDefault(require("node:path"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const ros = __importStar(require("@alicloud/ros-cdk-core"));
 const ossDeployment = __importStar(require("@alicloud/ros-cdk-ossdeployment"));
 const node_crypto_1 = __importDefault(require("node:crypto"));
 const lodash_1 = require("lodash");
+const parser_1 = require("../parser");
+const logger_1 = require("./logger");
 const resolveCode = (location) => {
     const filePath = node_path_1.default.resolve(process.cwd(), location);
     const fileContent = node_fs_1.default.readFileSync(filePath);
@@ -104,7 +106,7 @@ exports.calcRefs = calcRefs;
 const getParam = (key, records) => {
     return records?.find((param) => param.key === key)?.value;
 };
-const calcValue = (rawValue, ctx) => {
+const calcValue = (rawValue, ctx, iacVars) => {
     const containsStage = rawValue.match(/\$\{ctx.stage}/);
     const containsVar = rawValue.match(/\$\{vars.\w+}/);
     const containsMap = rawValue.match(/\$\{stages\.(\w+)}/);
@@ -113,14 +115,40 @@ const calcValue = (rawValue, ctx) => {
         value = rawValue.replace(/\$\{ctx.stage}/g, ctx.stage);
     }
     if (containsVar?.length) {
-        value = value.replace(/\$\{vars\.(\w+)}/g, (_, key) => getParam(key, ctx.parameters));
+        // Use provided iacVars or parse from file
+        const vars = iacVars ?? (0, parser_1.parseYaml)(ctx.iacLocation).vars;
+        const mergedParams = Array.from(new Map([
+            ...Object.entries(vars ?? {}).map(([key, value]) => [key, String(value)]),
+            ...(ctx.parameters ?? []).map(({ key, value }) => [key, value]),
+        ].filter(([, v]) => v !== undefined)).entries()).map(([key, value]) => ({ key, value }));
+        value = value.replace(/\$\{vars\.(\w+)}/g, (_, key) => {
+            const paramValue = getParam(key, mergedParams);
+            if (!paramValue) {
+                logger_1.logger.warn(`Variable '${key}' not found in vars or parameters, using empty string`);
+            }
+            return paramValue || '';
+        });
     }
     if (containsMap?.length) {
-        value = value.replace(/\$\{stages\.(\w+)}/g, (_, key) => getParam(key, (0, lodash_1.get)(ctx.stages, `${ctx.stage}`)));
+        value = value.replace(/\$\{stages\.(\w+)}/g, (_, key) => {
+            const stageValue = getParam(key, (0, lodash_1.get)(ctx.stages, `${ctx.stage}`));
+            if (!stageValue) {
+                logger_1.logger.warn(`Stage variable '${key}' not found in stage '${ctx.stage}', using empty string`);
+            }
+            return stageValue || '';
+        });
     }
     return value;
 };
 exports.calcValue = calcValue;
+const getIacDefinition = (iac, rawValue) => {
+    const matchFn = rawValue.match(/^\$\{functions\.(\w+(\.\w+)?)}$/);
+    if (matchFn?.length) {
+        return iac.functions?.find((fc) => fc.key === matchFn[1]);
+    }
+    return iac.functions?.find((fc) => fc.key === rawValue);
+};
+exports.getIacDefinition = getIacDefinition;
 const formatRosId = (id) => {
     // Insert underscore before uppercase letters, but only when they follow a lowercase letter
     let result = id.replace(/([a-z])([A-Z])/g, '$1_$2');
@@ -135,3 +163,10 @@ const formatRosId = (id) => {
     return result;
 };
 exports.formatRosId = formatRosId;
+const splitDomain = (domain) => {
+    const parts = domain.split('.');
+    const rr = parts.length > 2 ? parts[0] : '@';
+    const domainName = parts.length > 2 ? parts.slice(1).join('.') : domain;
+    return { rr, domainName };
+};
+exports.splitDomain = splitDomain;

package/dist/src/common/index.d.ts

@@ -8,4 +8,4 @@ export * from './constants';
 export * from './imsClient';
 export * from './base64';
 export * from './rosAssets';
-export * from './domainHelper';
+export * from './requestHelper';

package/dist/src/common/index.js

@@ -24,4 +24,4 @@ __exportStar(require("./constants"), exports);
 __exportStar(require("./imsClient"), exports);
 __exportStar(require("./base64"), exports);
 __exportStar(require("./rosAssets"), exports);
-__exportStar(require("./domainHelper"), exports);
+__exportStar(require("./requestHelper"), exports);

package/dist/src/common/requestHelper.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readRequestBody = void 0;
+const readRequestBody = (req) => {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        req.on('data', (chunk) => {
+            body += chunk.toString();
+        });
+        req.on('end', () => {
+            resolve(body);
+        });
+        req.on('error', reject);
+    });
+};
+exports.readRequestBody = readRequestBody;

package/dist/src/parser/eventParser.js

@@ -9,7 +9,7 @@ const parseEvent = (events) => {
         key,
         name: event.name,
         type: event.type,
-        triggers: event.triggers,
+        triggers: event.triggers?.map((trigger) => ({ ...trigger, method: trigger.method ?? 'GET' })),
         domain: event.domain,
     }));
 };

package/dist/src/parser/index.d.ts

@@ -1,2 +1,3 @@
-import { ServerlessIac } from '../types';
+import { ServerlessIac, Context } from '../types';
 export declare const parseYaml: (iacLocation: string) => ServerlessIac;
+export declare const revalYaml: (iacLocation: string, ctx: Context) => ServerlessIac;

package/dist/src/parser/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseYaml = void 0;
+exports.revalYaml = exports.parseYaml = void 0;
 const node_fs_1 = require("node:fs");
 const functionParser_1 = require("./functionParser");
 const eventParser_1 = require("./eventParser");
@@ -10,6 +10,7 @@ const yaml_1 = require("yaml");
 const validator_1 = require("../validator");
 const bucketParser_1 = require("./bucketParser");
 const tableParser_1 = require("./tableParser");
+const common_1 = require("../common");
 const validateExistence = (path) => {
     if (!(0, node_fs_1.existsSync)(path)) {
         throw new Error(`File does not exist at path: ${path}`);
@@ -38,3 +39,33 @@ const parseYaml = (iacLocation) => {
     return transformYaml(iacJson);
 };
 exports.parseYaml = parseYaml;
+const evaluateObject = (obj, ctx, iacVars) => {
+    if (typeof obj === 'string') {
+        return (0, common_1.calcValue)(obj, ctx, iacVars);
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item) => evaluateObject(item, ctx, iacVars));
+    }
+    if (typeof obj === 'object' && obj !== null) {
+        return Object.fromEntries(Object.entries(obj).map(([key, val]) => [key, evaluateObject(val, ctx, iacVars)]));
+    }
+    return obj;
+};
+const revalYaml = (iacLocation, ctx) => {
+    validateExistence(iacLocation);
+    const yamlContent = (0, node_fs_1.readFileSync)(iacLocation, 'utf8');
+    const iacJson = (0, yaml_1.parse)(yamlContent);
+    (0, validator_1.validateYaml)(iacJson);
+    const evaluatedIacJson = evaluateObject(iacJson, ctx, iacJson.vars);
+    const iac = transformYaml(evaluatedIacJson);
+    // Set default values for optional fields in functions
+    if (iac.functions) {
+        iac.functions = iac.functions.map((fn) => ({
+            ...fn,
+            memory: fn.memory || 128,
+            timeout: fn.timeout || 3,
+        }));
+    }
+    return iac;
+};
+exports.revalYaml = revalYaml;

package/dist/src/stack/localStack/aliyunFc.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRequestId = exports.logApiGatewayRequest = exports.transformFCResponse = exports.addFCHeaders = exports.createAliyunContext = exports.createAliyunContextSerializable = exports.transformToAliyunEvent = void 0;
+const crypto_1 = require("crypto");
+const common_1 = require("../../common");
+const createFCLogger = (requestId) => {
+    const formatLog = (level, message) => {
+        const timestamp = new Date().toISOString();
+        console.log(`${timestamp} ${requestId} [${level}] ${message}`);
+    };
+    return {
+        debug: (message) => formatLog('DEBUG', message),
+        info: (message) => formatLog('INFO', message),
+        warn: (message) => formatLog('WARNING', message),
+        error: (message) => formatLog('ERROR', message),
+        log: (message) => formatLog('INFO', message),
+    };
+};
+const transformToAliyunEvent = async (req, url, query) => {
+    const rawBody = await (0, common_1.readRequestBody)(req);
+    const pathParameters = {};
+    const event = {
+        path: url,
+        httpMethod: req.method || 'GET',
+        headers: req.headers,
+        queryParameters: query,
+        pathParameters,
+        body: rawBody || undefined,
+        isBase64Encoded: false,
+    };
+    const eventBuffer = Buffer.from(JSON.stringify(event));
+    return { event: eventBuffer, headers: req.headers };
+};
+exports.transformToAliyunEvent = transformToAliyunEvent;
+const createAliyunContextSerializable = (iac, functionName, handler, memory, timeout, requestId) => {
+    return {
+        requestId,
+        region: iac.provider.region || 'cn-hangzhou',
+        accountId: process.env.ALIYUN_ACCOUNT_ID || '000000000000',
+        credentials: {
+            accessKeyId: process.env.ALIYUN_ACCESS_KEY_ID || 'mock-access-key-id',
+            accessKeySecret: process.env.ALIYUN_ACCESS_KEY_SECRET || 'mock-access-key-secret',
+            securityToken: process.env.ALIYUN_SECURITY_TOKEN || '',
+        },
+        function: {
+            name: functionName,
+            handler,
+            memory,
+            timeout,
+            initializer: '',
+        },
+        service: {
+            name: iac.service || 'default-service',
+            logProject: `${iac.service}-log-project`,
+            logStore: `${iac.service}-log-store`,
+            qualifier: 'LATEST',
+            versionId: '1',
+        },
+        tracing: {
+            spanContext: '',
+            jaegerEndpoint: '',
+            spanBaggages: {},
+        },
+    };
+};
+exports.createAliyunContextSerializable = createAliyunContextSerializable;
+const createAliyunContext = (iac, functionName, handler, memory, timeout, requestId) => {
+    const baseContext = (0, exports.createAliyunContextSerializable)(iac, functionName, handler, memory, timeout, requestId);
+    return {
+        ...baseContext,
+        tracing: {
+            ...baseContext.tracing,
+            parseOpenTracingBaggages: () => ({}),
+        },
+        logger: createFCLogger(requestId),
+    };
+};
+exports.createAliyunContext = createAliyunContext;
+const addFCHeaders = (context, headers) => {
+    return {
+        ...headers,
+        'x-fc-request-id': context.requestId,
+        'x-fc-access-key-id': context.credentials.accessKeyId,
+        'x-fc-access-key-secret': context.credentials.accessKeySecret,
+        'x-fc-security-token': context.credentials.securityToken,
+        'x-fc-function-handler': context.function.handler,
+        'x-fc-function-memory': String(context.function.memory),
+        'x-fc-region': context.region,
+        'x-fc-account-id': context.accountId,
+        'x-fc-qualifier': context.service.qualifier,
+        'x-fc-version-id': context.service.versionId,
+        'x-fc-function-name': context.function.name,
+        'x-fc-service-logproject': context.service.logProject,
+        'x-fc-service-logstore': context.service.logStore,
+        'x-fc-control-path': '/http-invoke',
+    };
+};
+exports.addFCHeaders = addFCHeaders;
+const transformFCResponse = (result) => {
+    if (result && typeof result === 'object' && 'statusCode' in result && 'body' in result) {
+        const { statusCode: rawStatus = 200, body: rawBody, isBase64Encoded, headers = {}, } = result;
+        const parsedStatus = typeof rawStatus === 'string' ? parseInt(rawStatus, 10) : rawStatus;
+        const statusCode = isNaN(parsedStatus) ? 200 : parsedStatus;
+        let body = rawBody;
+        if (isBase64Encoded && typeof body === 'string') {
+            body = Buffer.from(body, 'base64').toString('utf-8');
+        }
+        if (typeof body === 'string') {
+            try {
+                body = JSON.parse(body);
+            }
+            catch {
+                // If parsing fails, keep as string
+            }
+        }
+        return { statusCode, headers, body };
+    }
+    return {
+        statusCode: 200,
+        headers: { 'Content-Type': 'application/json' },
+        body: result,
+    };
+};
+exports.transformFCResponse = transformFCResponse;
+const logApiGatewayRequest = (requestId, apiPath, statusCode, startTime, endTime, sourceIp) => {
+    const duration = ((endTime.getTime() - startTime.getTime()) / 1000).toFixed(1);
+    const startTimeStr = formatDateTime(startTime);
+    const endTimeStr = formatDateTime(endTime);
+    const timestamp = formatDateTime(new Date());
+    console.log(`${timestamp} | ${requestId} | ${apiPath} | Sync Call | local-app | Development | local-project | ${statusCode} | ${startTimeStr} | ${endTimeStr} | ${duration}s | - | ${sourceIp}`);
+};
+exports.logApiGatewayRequest = logApiGatewayRequest;
+const formatDateTime = (date) => {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    const hours = String(date.getHours()).padStart(2, '0');
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    const seconds = String(date.getSeconds()).padStart(2, '0');
+    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+};
+const generateRequestId = () => {
+    return (0, crypto_1.randomUUID)().replace(/-/g, '');
+};
+exports.generateRequestId = generateRequestId;

package/dist/src/stack/localStack/bucket.js

@@ -0,0 +1,226 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bucketsHandler = void 0;
+const common_1 = require("../../common");
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const TEXT_MIME_TYPES = new Set([
+    'text/plain',
+    'text/html',
+    'text/css',
+    'text/javascript',
+    'text/markdown',
+    'text/xml',
+    'application/json',
+    'application/javascript',
+    'application/xml',
+]);
+const getMimeType = (filename) => {
+    const ext = node_path_1.default.extname(filename).toLowerCase();
+    const mimeTypes = {
+        '.html': 'text/html',
+        '.htm': 'text/html',
+        '.css': 'text/css',
+        '.js': 'application/javascript',
+        '.json': 'application/json',
+        '.xml': 'application/xml',
+        '.txt': 'text/plain',
+        '.md': 'text/markdown',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.png': 'image/png',
+        '.gif': 'image/gif',
+        '.svg': 'image/svg+xml',
+        '.ico': 'image/x-icon',
+        '.pdf': 'application/pdf',
+        '.zip': 'application/zip',
+        '.tar': 'application/x-tar',
+        '.gz': 'application/gzip',
+    };
+    return mimeTypes[ext] || 'application/octet-stream';
+};
+const listDirectory = (dirPath, bucketPath) => {
+    try {
+        const entries = node_fs_1.default.readdirSync(dirPath, { withFileTypes: true });
+        return entries.map((entry) => {
+            const fullPath = node_path_1.default.join(dirPath, entry.name);
+            const relativePath = node_path_1.default.relative(bucketPath, fullPath);
+            const stats = node_fs_1.default.statSync(fullPath);
+            return {
+                name: entry.name,
+                type: entry.isDirectory() ? 'directory' : 'file',
+                size: entry.isDirectory() ? 0 : stats.size,
+                path: relativePath.replace(/\\/g, '/'), // Normalize path separators
+            };
+        });
+    }
+    catch (error) {
+        common_1.logger.error(`Error listing directory: ${error}`);
+        return [];
+    }
+};
+const getAllFiles = (dirPath, bucketPath, fileList = []) => {
+    try {
+        const entries = node_fs_1.default.readdirSync(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = node_path_1.default.join(dirPath, entry.name);
+            const relativePath = node_path_1.default.relative(bucketPath, fullPath);
+            if (entry.isDirectory()) {
+                // Recursively list files in subdirectories
+                getAllFiles(fullPath, bucketPath, fileList);
+            }
+            else {
+                const stats = node_fs_1.default.statSync(fullPath);
+                fileList.push({
+                    name: entry.name,
+                    type: 'file',
+                    size: stats.size,
+                    path: relativePath.replace(/\\/g, '/'),
+                });
+            }
+        }
+        return fileList;
+    }
+    catch (error) {
+        common_1.logger.error(`Error getting all files: ${error}`);
+        return fileList;
+    }
+};
+const bucketsHandler = async (req, parsed, iac) => {
+    common_1.logger.info(`Bucket request received by local server -> ${req.method} ${parsed.identifier ?? '/'} ${parsed.url}`);
+    // Find the bucket definition
+    const bucketDef = iac.buckets?.find((bucket) => bucket.key === parsed.identifier);
+    if (!bucketDef) {
+        return {
+            statusCode: 404,
+            body: { error: 'Bucket not found', bucketKey: parsed.identifier },
+        };
+    }
+    // Determine the bucket path - use website.code if available, otherwise use bucket name
+    let bucketBasePath;
+    if (bucketDef.website?.code) {
+        bucketBasePath = node_path_1.default.resolve(process.cwd(), bucketDef.website.code);
+    }
+    else {
+        // Fallback: create a directory based on bucket name (for non-website buckets)
+        bucketBasePath = node_path_1.default.resolve(process.cwd(), bucketDef.name);
+    }
+    // Check if bucket path exists
+    if (!node_fs_1.default.existsSync(bucketBasePath)) {
+        return {
+            statusCode: 404,
+            body: {
+                error: 'Bucket directory not found',
+                bucketKey: bucketDef.key,
+                bucketName: bucketDef.name,
+                expectedPath: bucketBasePath,
+            },
+        };
+    }
+    // Root path lists all files in bucket
+    if (parsed.url === '/') {
+        try {
+            const files = getAllFiles(bucketBasePath, bucketBasePath);
+            return {
+                statusCode: 200,
+                headers: { 'Content-Type': 'application/json' },
+                body: {
+                    bucket: bucketDef.name,
+                    bucketKey: bucketDef.key,
+                    files,
+                    count: files.length,
+                },
+            };
+        }
+        catch (error) {
+            common_1.logger.error(`Error listing bucket files: ${error}`);
+            return {
+                statusCode: 500,
+                body: {
+                    error: 'Failed to list bucket files',
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            };
+        }
+    }
+    // Otherwise, serve the requested file
+    const requestedPath = parsed.url.startsWith('/') ? parsed.url.slice(1) : parsed.url;
+    const filePath = node_path_1.default.join(bucketBasePath, requestedPath);
+    // Security check: ensure the requested file is within the bucket directory
+    const normalizedFilePath = node_path_1.default.normalize(filePath);
+    const normalizedBucketPath = node_path_1.default.normalize(bucketBasePath);
+    if (!normalizedFilePath.startsWith(normalizedBucketPath)) {
+        return {
+            statusCode: 403,
+            body: { error: 'Access denied: Path traversal attempt detected' },
+        };
+    }
+    // Check if file exists
+    if (!node_fs_1.default.existsSync(filePath)) {
+        return {
+            statusCode: 404,
+            body: {
+                error: 'File not found',
+                path: requestedPath,
+                bucketKey: bucketDef.key,
+            },
+        };
+    }
+    // If it's a directory, list its contents
+    const stats = node_fs_1.default.statSync(filePath);
+    if (stats.isDirectory()) {
+        try {
+            const files = listDirectory(filePath, bucketBasePath);
+            return {
+                statusCode: 200,
+                headers: { 'Content-Type': 'application/json' },
+                body: {
+                    bucket: bucketDef.name,
+                    bucketKey: bucketDef.key,
+                    directory: requestedPath,
+                    files,
+                    count: files.length,
+                },
+            };
+        }
+        catch (error) {
+            common_1.logger.error(`Error listing directory: ${error}`);
+            return {
+                statusCode: 500,
+                body: {
+                    error: 'Failed to list directory',
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            };
+        }
+    }
+    // Serve the file
+    try {
+        const fileContent = node_fs_1.default.readFileSync(filePath);
+        const mimeType = getMimeType(filePath);
+        // For text files, return as string; for binary files, return as base64
+        const isTextFile = TEXT_MIME_TYPES.has(mimeType);
+        return {
+            statusCode: 200,
+            headers: {
+                'Content-Type': mimeType,
+                'Content-Length': String(fileContent.length),
+            },
+            body: isTextFile ? fileContent.toString('utf-8') : fileContent.toString('base64'),
+        };
+    }
+    catch (error) {
+        common_1.logger.error(`Error reading file: ${error}`);
+        return {
+            statusCode: 500,
+            body: {
+                error: 'Failed to read file',
+                message: error instanceof Error ? error.message : String(error),
+            },
+        };
+    }
+};
+exports.bucketsHandler = bucketsHandler;