@geek-fun/serverlessinsight 0.3.4 → 0.4.1

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

@@ -0,0 +1,270 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invokeFunction = exports.runFunction = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importStar(require("node:path"));
+const node_url_1 = require("node:url");
+const node_worker_threads_1 = require("node:worker_threads");
+// ============================================================================
+// Worker Thread Code (runs in worker context)
+// ============================================================================
+const parseHandler = (handler) => {
+    const [handlerFile, handlerMethod] = handler.split('.');
+    return [handlerFile, handlerMethod];
+};
+const resolveHandlerPath = (codeDir, servicePath, handlerFile) => servicePath
+    ? node_path_1.default.resolve(servicePath, codeDir, handlerFile)
+    : node_path_1.default.resolve(codeDir, handlerFile);
+const loadHandlerModule = async (handlerPath) => {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        return require(handlerPath);
+    }
+    catch {
+        const fileUrl = (0, node_url_1.pathToFileURL)(handlerPath + '.js').href;
+        return (await Promise.resolve(`${fileUrl}`).then(s => __importStar(require(s))));
+    }
+};
+const getHandlerFunction = (handlerModule, handlerMethod, handlerPath) => {
+    const handlerFn = handlerModule[handlerMethod];
+    if (typeof handlerFn !== 'function') {
+        throw new Error(`Handler "${handlerMethod}" not found or is not a function in ${handlerPath}`);
+    }
+    return handlerFn;
+};
+const invokeHandler = (handlerFn, event, context) => new Promise((resolve, reject) => {
+    // Callback-style handler (3+ parameters)
+    if (handlerFn.length >= 3) {
+        try {
+            handlerFn(event, context, (error, result) => {
+                return error ? reject(error) : resolve(result);
+            });
+        }
+        catch (error) {
+            reject(error);
+        }
+    }
+    else {
+        return Promise.resolve(handlerFn(event, context)).then(resolve).catch(reject);
+    }
+});
+const createTimeoutHandler = (port, timeoutMs) => {
+    const timeoutId = setTimeout(() => {
+        port.postMessage(new Error(`Function execution timed out after ${timeoutMs}ms`));
+        port.close();
+    }, timeoutMs);
+    return {
+        timeoutId,
+        clearTimer: () => clearTimeout(timeoutId),
+    };
+};
+const executeHandler = async ({ event, context, port }) => {
+    let clearTimer;
+    try {
+        const wd = node_worker_threads_1.workerData;
+        const { codeDir, handler, servicePath, timeout } = wd;
+        const timer = createTimeoutHandler(port, timeout);
+        clearTimer = timer.clearTimer;
+        // Convert Uint8Array back to Buffer if needed (worker thread serialization converts Buffers to Uint8Arrays)
+        let actualEvent = event;
+        if (event instanceof Uint8Array && !Buffer.isBuffer(event)) {
+            actualEvent = Buffer.from(event);
+        }
+        // Reconstruct logger and tracing function for Aliyun FC contexts
+        let actualContext = context;
+        if (context &&
+            typeof context === 'object' &&
+            'requestId' in context &&
+            !('logger' in context) &&
+            'function' in context &&
+            'service' in context) {
+            const requestId = context.requestId;
+            const formatLog = (level, message) => {
+                const timestamp = new Date().toISOString();
+                console.log(`${timestamp} ${requestId} [${level}] ${message}`);
+            };
+            const baseContext = context;
+            actualContext = {
+                ...baseContext,
+                tracing: {
+                    ...baseContext.tracing,
+                    parseOpenTracingBaggages: () => ({}),
+                },
+                logger: {
+                    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 [handlerFile, handlerMethod] = parseHandler(handler);
+        const handlerPath = resolveHandlerPath(codeDir, servicePath, handlerFile);
+        const handlerModule = await loadHandlerModule(handlerPath);
+        const handlerFn = getHandlerFunction(handlerModule, handlerMethod, handlerPath);
+        const result = await invokeHandler(handlerFn, actualEvent, actualContext);
+        clearTimer();
+        port.postMessage(result);
+        port.close();
+    }
+    catch (error) {
+        if (clearTimer)
+            clearTimer();
+        port.postMessage(error instanceof Error ? error : new Error(String(error)));
+        port.close();
+    }
+};
+// Initialize worker thread message handler
+if (!node_worker_threads_1.isMainThread) {
+    node_worker_threads_1.parentPort?.on('message', async (message) => {
+        try {
+            await executeHandler(message);
+        }
+        catch (error) {
+            message.port.postMessage(error instanceof Error ? error : new Error(String(error)));
+            message.port.close();
+        }
+    });
+}
+// ============================================================================
+// Main Thread Code (functional API)
+// ============================================================================
+const resolveWorkerPath = () => {
+    const localPath = (0, node_path_1.join)(__dirname, 'functionRunner.js');
+    if ((0, node_fs_1.existsSync)(localPath)) {
+        return localPath;
+    }
+    // Fallback to dist directory
+    const distPath = __dirname.replace(/src\/stack\/localStack$/, 'dist/src/stack/localStack');
+    return (0, node_path_1.join)(distPath, 'functionRunner.js');
+};
+const createWorker = (funOptions, env) => {
+    const { codeDir, functionKey, handler, servicePath, timeout } = funOptions;
+    const workerPath = resolveWorkerPath();
+    return new node_worker_threads_1.Worker(workerPath, {
+        env,
+        workerData: {
+            codeDir,
+            functionKey,
+            handler,
+            servicePath,
+            timeout,
+        },
+    });
+};
+const createMessageHandler = (port, resolve, reject) => {
+    let resolved = false;
+    const handleMessage = (value) => {
+        if (resolved)
+            return;
+        resolved = true;
+        port.close();
+        return value instanceof Error ? reject(value) : resolve(value);
+    };
+    const handleError = (err) => {
+        if (resolved)
+            return;
+        resolved = true;
+        port.close();
+        reject(err);
+    };
+    const handleClose = () => {
+        if (resolved)
+            return;
+        resolved = true;
+        reject(new Error('Port closed before receiving response'));
+    };
+    port.on('message', handleMessage).on('error', handleError).on('close', handleClose);
+    return () => {
+        port.off('message', handleMessage);
+        port.off('error', handleError);
+        port.off('close', handleClose);
+        port.close();
+    };
+};
+const sendMessage = (worker, event, context, port2) => {
+    worker.postMessage({
+        context,
+        event,
+        port: port2,
+    }, [port2]);
+};
+const runFunction = (funOptions, env) => {
+    const worker = createWorker(funOptions, env);
+    const execute = (event, context) => new Promise((resolve, reject) => {
+        const { port1, port2 } = new node_worker_threads_1.MessageChannel();
+        const cleanup = createMessageHandler(port1, resolve, reject);
+        // Handle worker errors/exit
+        const handleWorkerError = (err) => {
+            cleanup();
+            reject(err);
+        };
+        const handleWorkerExit = (code) => {
+            if (code !== 0) {
+                cleanup();
+                reject(new Error(`Worker stopped with exit code ${code}`));
+            }
+        };
+        worker.once('error', handleWorkerError);
+        worker.once('exit', handleWorkerExit);
+        try {
+            sendMessage(worker, event, context, port2);
+        }
+        catch (error) {
+            worker.off('error', handleWorkerError);
+            worker.off('exit', handleWorkerExit);
+            cleanup();
+            reject(error instanceof Error ? error : new Error(String(error)));
+        }
+    });
+    const terminate = () => worker.terminate();
+    return {
+        execute,
+        terminate,
+    };
+};
+exports.runFunction = runFunction;
+const invokeFunction = async (funOptions, env, event, context) => {
+    const runner = (0, exports.runFunction)(funOptions, env);
+    try {
+        return await runner.execute(event, context);
+    }
+    finally {
+        await runner.terminate();
+    }
+};
+exports.invokeFunction = invokeFunction;

package/dist/src/stack/localStack/index.d.ts

@@ -1,2 +1,5 @@
+import { stopLocal } from './localServer';
+import { ServerlessIac } from '../../types';
 export * from './event';
-export declare const startLocalStack: () => Promise<void>;
+export { stopLocal };
+export declare const startLocalStack: (iac: ServerlessIac) => Promise<void>;

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

@@ -14,10 +14,20 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.startLocalStack = void 0;
+exports.startLocalStack = exports.stopLocal = void 0;
+const localStack_1 = require("../../types/localStack");
+const localServer_1 = require("./localServer");
+Object.defineProperty(exports, "stopLocal", { enumerable: true, get: function () { return localServer_1.stopLocal; } });
+const event_1 = require("./event");
+const function_1 = require("./function");
+const bucket_1 = require("./bucket");
 __exportStar(require("./event"), exports);
-const startLocalStack = async () => {
-    // Placeholder for starting local stack logic
-    console.log('Local stack started');
+const handlers = [
+    { kind: localStack_1.RouteKind.SI_FUNCTIONS, handler: function_1.functionsHandler },
+    { kind: localStack_1.RouteKind.SI_EVENTS, handler: event_1.eventsHandler },
+    { kind: localStack_1.RouteKind.SI_BUCKETS, handler: bucket_1.bucketsHandler },
+];
+const startLocalStack = async (iac) => {
+    await (0, localServer_1.servLocal)(handlers, iac);
 };
 exports.startLocalStack = startLocalStack;

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

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stopLocal = exports.servLocal = void 0;
+const localStack_1 = require("../../types/localStack");
+const common_1 = require("../../common");
+const node_http_1 = __importDefault(require("node:http"));
+let localServer;
+const cleanPathSegments = (pathname) => pathname
+    .split('/')
+    .map((segment) => segment.trim())
+    .filter((segment) => segment.length > 0);
+const respondJson = (res, status, body, headers = {}) => {
+    res.writeHead(status, { 'Content-Type': 'application/json', ...headers });
+    res.end(JSON.stringify(body));
+};
+const respondRaw = (res, status, body, headers = {}) => {
+    res.writeHead(status, headers);
+    res.end(body);
+};
+const parseRequest = (req) => {
+    const url = new URL(req.url ?? '/', 'http://localhost');
+    const [routeSegment, identifierSegment, ...rest] = cleanPathSegments(url.pathname);
+    if (!routeSegment) {
+        return undefined;
+    }
+    const kindKey = routeSegment.toUpperCase();
+    const kind = localStack_1.RouteKind[kindKey];
+    if (!kind) {
+        return undefined;
+    }
+    const subPath = rest.length > 0 ? `/${rest.join('/')}` : '/';
+    return {
+        kind,
+        identifier: identifierSegment,
+        url: subPath,
+        method: req.method ?? 'GET',
+        query: Object.fromEntries(url.searchParams.entries()),
+        rawUrl: url.pathname,
+    };
+};
+const servLocal = async (handlers, iac) => {
+    if (localServer) {
+        common_1.logger.info(`localServer already running on http://localhost:${common_1.SI_LOCALSTACK_SERVER_PORT}`);
+        return;
+    }
+    localServer = node_http_1.default.createServer(async (req, res) => {
+        try {
+            const parsed = parseRequest(req);
+            if (!parsed) {
+                respondJson(res, 404, { error: 'Route not found' });
+                return;
+            }
+            const route = handlers.find((h) => h.kind === parsed.kind);
+            if (!route) {
+                respondJson(res, 404, { error: `Handler for ${parsed.kind} not registered` });
+                return;
+            }
+            const outcome = await route.handler(req, parsed, iac);
+            if (!outcome) {
+                respondJson(res, 204, {});
+                return;
+            }
+            // Raw responses (e.g., from bucket handler) include both Content-Type and Content-Length headers
+            // and the body is already formatted as a string (not a JSON object)
+            const isRawResponse = typeof outcome.body === 'string' &&
+                outcome.headers?.['Content-Type'] &&
+                outcome.headers?.['Content-Length'];
+            if (isRawResponse) {
+                respondRaw(res, outcome.statusCode, outcome.body, outcome.headers);
+            }
+            else {
+                respondJson(res, outcome.statusCode, outcome.body ?? {}, outcome.headers);
+            }
+        }
+        catch (err) {
+            common_1.logger.error({ err }, 'Local gateway error');
+            respondJson(res, 500, { error: 'Local gateway failure' });
+        }
+    });
+    await new Promise((resolve, reject) => {
+        localServer.listen(common_1.SI_LOCALSTACK_SERVER_PORT, '0.0.0.0', () => {
+            common_1.logger.info(`Local Server listening on http://localhost:${common_1.SI_LOCALSTACK_SERVER_PORT}`);
+            resolve();
+        });
+        localServer.once('error', reject);
+    });
+};
+exports.servLocal = servLocal;
+const stopLocal = async () => {
+    if (!localServer) {
+        common_1.logger.info('localServer is not running');
+        return;
+    }
+    await new Promise((resolve, reject) => {
+        localServer.close((err) => {
+            if (err) {
+                common_1.logger.error({ err }, 'Error stopping localServer');
+                reject(err);
+            }
+            else {
+                localServer = undefined;
+                common_1.logger.info('localServer stopped');
+                resolve();
+            }
+        });
+    });
+};
+exports.stopLocal = stopLocal;

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

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractZipFile = void 0;
+const jszip_1 = __importDefault(require("jszip"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+const extractZipFile = async (zipPath) => {
+    const zipData = node_fs_1.default.readFileSync(zipPath);
+    const zip = await jszip_1.default.loadAsync(zipData);
+    const tempDir = node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), 'si-function-'));
+    for (const [relativePath, file] of Object.entries(zip.files)) {
+        if (file.dir) {
+            node_fs_1.default.mkdirSync(node_path_1.default.join(tempDir, relativePath), { recursive: true });
+        }
+        else {
+            const content = await file.async('nodebuffer');
+            const filePath = node_path_1.default.join(tempDir, relativePath);
+            node_fs_1.default.mkdirSync(node_path_1.default.dirname(filePath), { recursive: true });
+            node_fs_1.default.writeFileSync(filePath, content);
+        }
+    }
+    // Check if there's a single root directory in the zip
+    const entries = node_fs_1.default.readdirSync(tempDir);
+    if (entries.length === 1) {
+        const singleEntry = node_path_1.default.join(tempDir, entries[0]);
+        if (node_fs_1.default.statSync(singleEntry).isDirectory()) {
+            return singleEntry;
+        }
+    }
+    return tempDir;
+};
+exports.extractZipFile = extractZipFile;

package/dist/src/stack/rosStack/bootstrap.js

@@ -33,7 +33,7 @@ const getBootstrapTemplate = async (context) => {
                     Description: 'ServerlessInsight Bootstrap API',
                     Handler: 'index.handler',
                     Runtime: 'nodejs20',
-                    Layers: [`acs:fc:${context.region}:1990893136649406:layers/si-bootstrap-sdk/versions/18`],
+                    Layers: [`acs:fc:${context.region}:1990893136649406:layers/si-bootstrap-sdk/versions/26`],
                     Code: {
                         SourceCode: `
 const { bootstrapHandler } = require('@geek-fun/si-bootstrap-sdk');

package/dist/src/types/localStack/index.d.ts

@@ -0,0 +1,81 @@
+import { IncomingMessage } from 'node:http';
+import { ServerlessIac } from '../index';
+export declare enum RouteKind {
+    SI_FUNCTIONS = "SI_FUNCTIONS",
+    SI_BUCKETS = "SI_BUCKETS",
+    SI_WEBSITE_BUCKETS = "SI_WEBSITE_BUCKETS",
+    SI_EVENTS = "SI_EVENTS"
+}
+export type ParsedRequest = {
+    kind: RouteKind;
+    identifier: string;
+    url: string;
+    method: string;
+    query: Record<string, string>;
+    rawUrl: string;
+};
+export type RouteResponse = {
+    statusCode: number;
+    headers?: Record<string, string>;
+    body?: unknown;
+};
+export type RouteHandler = (req: IncomingMessage, parsed: ParsedRequest, iac: ServerlessIac) => Promise<RouteResponse | void> | RouteResponse | void;
+export type FunctionOptions = {
+    codeDir: string;
+    functionKey: string;
+    handler: string;
+    servicePath: string;
+    timeout: number;
+};
+export type AliyunApiGatewayContext = {
+    requestId: string;
+    region: string;
+    accountId: string;
+    credentials: {
+        accessKeyId: string;
+        accessKeySecret: string;
+        securityToken: string;
+    };
+    function: {
+        name: string;
+        handler: string;
+        memory: number;
+        timeout: number;
+        initializer: string;
+    };
+    service: {
+        name: string;
+        logProject: string;
+        logStore: string;
+        qualifier: string;
+        versionId: string;
+    };
+    tracing: {
+        spanContext: string;
+        jaegerEndpoint: string;
+        spanBaggages: Record<string, string>;
+        parseOpenTracingBaggages: () => Record<string, string>;
+    };
+    logger: {
+        debug: (message: string) => void;
+        info: (message: string) => void;
+        warn: (message: string) => void;
+        error: (message: string) => void;
+        log: (message: string) => void;
+    };
+};
+export type AliyunServerlessEvent = {
+    path: string;
+    httpMethod: string;
+    headers: Record<string, string>;
+    queryParameters: Record<string, string>;
+    pathParameters: Record<string, string>;
+    body: string | undefined;
+    isBase64Encoded: boolean;
+};
+export type AliyunFCResponse = {
+    isBase64Encoded: boolean;
+    statusCode: string | number;
+    headers?: Record<string, string>;
+    body: string | unknown;
+};

package/dist/src/types/localStack/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteKind = void 0;
+var RouteKind;
+(function (RouteKind) {
+    RouteKind["SI_FUNCTIONS"] = "SI_FUNCTIONS";
+    RouteKind["SI_BUCKETS"] = "SI_BUCKETS";
+    RouteKind["SI_WEBSITE_BUCKETS"] = "SI_WEBSITE_BUCKETS";
+    RouteKind["SI_EVENTS"] = "SI_EVENTS";
+})(RouteKind || (exports.RouteKind = RouteKind = {}));

package/dist/src/validator/iacSchema.js

@@ -14,14 +14,29 @@ const bucketSchema_1 = require("./bucketSchema");
 const tableschema_1 = require("./tableschema");
 class IacSchemaErrors extends Error {
     constructor(errors) {
-        super(`Invalid yaml`);
-        this.schemaErrors = errors.map((error) => ({
+        const schemaErrors = errors.map((error) => ({
             instancePath: error.instancePath,
             schemaPath: error.schemaPath,
             message: error.message,
             allowedValues: error.params?.allowedValues,
             type: error.keyword,
         }));
+        const formattedMessage = schemaErrors
+            .map((error, index) => {
+            const parts = [
+                `Error ${index + 1}:`,
+                `  Path: ${error.instancePath || '/'}`,
+                `  Type: ${error.type}`,
+                `  Message: ${error.message}`,
+            ];
+            if (error.allowedValues) {
+                parts.push(`  Allowed values: ${error.allowedValues.join(', ')}`);
+            }
+            return parts.join('\n');
+        })
+            .join('\n\n');
+        super(`Invalid yaml:\n\n${formattedMessage}`);
+        this.schemaErrors = schemaErrors;
     }
     get errors() {
         return this.schemaErrors;

package/dist/src/validator/rootSchema.js

@@ -12,6 +12,52 @@ exports.rootSchema = {
                 name: { type: 'string', enum: ['huawei', 'aliyun'] },
                 region: { type: 'string' },
             },
+            required: ['name', 'region'],
+            allOf: [
+                {
+                    if: {
+                        properties: {
+                            name: { const: 'aliyun' },
+                        },
+                        required: ['name'],
+                    },
+                    then: {
+                        properties: {
+                            region: {
+                                type: 'string',
+                                enum: [
+                                    'cn-qingdao',
+                                    'cn-beijing',
+                                    'cn-zhangjiakou',
+                                    'cn-huhehaote',
+                                    'cn-wulanchabu',
+                                    'cn-hangzhou',
+                                    'cn-shanghai',
+                                    'cn-shenzhen',
+                                    'cn-heyuan',
+                                    'cn-guangzhou',
+                                    'cn-chengdu',
+                                    'cn-hongkong',
+                                    'ap-southeast-1',
+                                    'ap-southeast-3',
+                                    'ap-southeast-5',
+                                    'ap-southeast-6',
+                                    'ap-southeast-7',
+                                    'ap-northeast-1',
+                                    'ap-northeast-2',
+                                    'eu-central-1',
+                                    'eu-west-1',
+                                    'us-east-1',
+                                    'us-west-1',
+                                    'na-south-1',
+                                    'me-east-1',
+                                    'me-central-1',
+                                ],
+                            },
+                        },
+                    },
+                },
+            ],
         },
         service: { type: 'string' },
         vars: {

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/index.ts","../src/commands/deploy.ts","../src/commands/destroy.ts","../src/commands/index.ts","../src/commands/local.ts","../src/commands/template.ts","../src/commands/validate.ts","../src/common/base64.ts","../src/common/constants.ts","../src/common/context.ts","../src/common/domainHelper.ts","../src/common/getVersion.ts","../src/common/iacHelper.ts","../src/common/imsClient.ts","../src/common/index.ts","../src/common/logger.ts","../src/common/providerEnum.ts","../src/common/rosAssets.ts","../src/common/rosClient.ts","../src/lang/index.ts","../src/parser/bucketParser.ts","../src/parser/databaseParser.ts","../src/parser/eventParser.ts","../src/parser/functionParser.ts","../src/parser/index.ts","../src/parser/tableParser.ts","../src/parser/tagParser.ts","../src/stack/deploy.ts","../src/stack/index.ts","../src/stack/localStack/event.ts","../src/stack/localStack/index.ts","../src/stack/rfsStack/function.ts","../src/stack/rfsStack/index.ts","../src/stack/rosStack/bootstrap.ts","../src/stack/rosStack/bucket.ts","../src/stack/rosStack/database.ts","../src/stack/rosStack/event.ts","../src/stack/rosStack/function.ts","../src/stack/rosStack/index.ts","../src/stack/rosStack/stage.ts","../src/stack/rosStack/table.ts","../src/stack/rosStack/tag.ts","../src/stack/rosStack/vars.ts","../src/types/assets.ts","../src/types/index.ts","../src/types/domains/bucket.ts","../src/types/domains/context.ts","../src/types/domains/database.ts","../src/types/domains/event.ts","../src/types/domains/function.ts","../src/types/domains/provider.ts","../src/types/domains/table.ts","../src/types/domains/tag.ts","../src/types/domains/vars.ts","../src/validator/bucketSchema.ts","../src/validator/databaseSchema.ts","../src/validator/eventSchema.ts","../src/validator/functionSchema.ts","../src/validator/iacSchema.ts","../src/validator/index.ts","../src/validator/rootSchema.ts","../src/validator/tableschema.ts"],"version":"5.9.2"}
+{"root":["../src/index.ts","../src/commands/deploy.ts","../src/commands/destroy.ts","../src/commands/index.ts","../src/commands/local.ts","../src/commands/template.ts","../src/commands/validate.ts","../src/common/base64.ts","../src/common/constants.ts","../src/common/context.ts","../src/common/credentials.ts","../src/common/getVersion.ts","../src/common/iacHelper.ts","../src/common/imsClient.ts","../src/common/index.ts","../src/common/logger.ts","../src/common/providerEnum.ts","../src/common/requestHelper.ts","../src/common/rosAssets.ts","../src/common/rosClient.ts","../src/lang/index.ts","../src/parser/bucketParser.ts","../src/parser/databaseParser.ts","../src/parser/eventParser.ts","../src/parser/functionParser.ts","../src/parser/index.ts","../src/parser/tableParser.ts","../src/parser/tagParser.ts","../src/stack/deploy.ts","../src/stack/index.ts","../src/stack/localStack/aliyunFc.ts","../src/stack/localStack/bucket.ts","../src/stack/localStack/event.ts","../src/stack/localStack/function.ts","../src/stack/localStack/functionRunner.ts","../src/stack/localStack/index.ts","../src/stack/localStack/localServer.ts","../src/stack/localStack/utils.ts","../src/stack/rfsStack/function.ts","../src/stack/rfsStack/index.ts","../src/stack/rosStack/bootstrap.ts","../src/stack/rosStack/bucket.ts","../src/stack/rosStack/database.ts","../src/stack/rosStack/event.ts","../src/stack/rosStack/function.ts","../src/stack/rosStack/index.ts","../src/stack/rosStack/stage.ts","../src/stack/rosStack/table.ts","../src/stack/rosStack/tag.ts","../src/stack/rosStack/vars.ts","../src/types/assets.ts","../src/types/index.ts","../src/types/domains/bucket.ts","../src/types/domains/context.ts","../src/types/domains/database.ts","../src/types/domains/event.ts","../src/types/domains/function.ts","../src/types/domains/provider.ts","../src/types/domains/table.ts","../src/types/domains/tag.ts","../src/types/domains/vars.ts","../src/types/localStack/index.ts","../src/validator/bucketSchema.ts","../src/validator/databaseSchema.ts","../src/validator/eventSchema.ts","../src/validator/functionSchema.ts","../src/validator/iacSchema.ts","../src/validator/index.ts","../src/validator/rootSchema.ts","../src/validator/tableschema.ts"],"version":"5.9.3"}