@geek-fun/serverlessinsight 0.4.0 → 0.5.0

package/dist/src/stack/aliyunStack/tablestoreExecutor.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeTablePlan = void 0;
+const tablestoreResource_1 = require("./tablestoreResource");
+const common_1 = require("../../common");
+const stateManager_1 = require("../../common/stateManager");
+const lang_1 = require("../../lang");
+const executeCreateAction = async (context, table, currentState) => {
+    common_1.logger.info(`Creating table: ${table.collection}/${table.name}`);
+    const newState = await (0, tablestoreResource_1.createTableResource)(context, table, currentState);
+    common_1.logger.info(`Successfully created table: ${table.collection}/${table.name}`);
+    return newState;
+};
+const executeUpdateAction = async (context, table, currentState) => {
+    common_1.logger.info(`Updating table: ${table.collection}/${table.name}`);
+    const newState = await (0, tablestoreResource_1.updateTableResource)(context, table, currentState);
+    common_1.logger.info(`Successfully updated table: ${table.collection}/${table.name}`);
+    return newState;
+};
+const executeDeleteAction = async (context, instanceName, tableName, logicalId, currentState) => {
+    common_1.logger.info(`Deleting table: ${instanceName}/${tableName}`);
+    const newState = await (0, tablestoreResource_1.deleteTableResource)(context, instanceName, tableName, logicalId, currentState);
+    common_1.logger.info(`Successfully deleted table: ${instanceName}/${tableName}`);
+    return newState;
+};
+const executeSingleItem = async (context, item, tablesMap, currentState) => {
+    switch (item.action) {
+        case 'noop':
+            common_1.logger.info(`No changes for ${item.logicalId}`);
+            return null;
+        case 'create': {
+            const table = tablesMap.get(item.logicalId);
+            if (!table) {
+                throw new Error(`Table not found for logical ID: ${item.logicalId}`);
+            }
+            return executeCreateAction(context, table, currentState);
+        }
+        case 'update': {
+            const table = tablesMap.get(item.logicalId);
+            if (!table) {
+                throw new Error(`Table not found for logical ID: ${item.logicalId}`);
+            }
+            return executeUpdateAction(context, table, currentState);
+        }
+        case 'delete': {
+            const state = (0, stateManager_1.getResource)(currentState, item.logicalId);
+            if (!state) {
+                common_1.logger.warn(`State not found for ${item.logicalId}, skipping deletion`);
+                return null;
+            }
+            const instanceName = state.definition.instanceName;
+            const tableName = state.definition.tableName;
+            return executeDeleteAction(context, instanceName, tableName, item.logicalId, currentState);
+        }
+        default:
+            common_1.logger.warn(`Unknown action: ${item.action} for ${item.logicalId}`);
+            return null;
+    }
+};
+const executeTablePlan = async (context, plan, tables, initialState, onStateChange) => {
+    const tablesMap = new Map(tables?.map((table) => [`tables.${table.key}`, table]) ?? []);
+    const successfulItems = [];
+    let currentState = initialState;
+    for (const item of plan.items) {
+        try {
+            const newState = await executeSingleItem(context, item, tablesMap, currentState);
+            if (newState !== null) {
+                currentState = newState;
+                successfulItems.push(item);
+                if (onStateChange) {
+                    onStateChange(currentState);
+                    common_1.logger.debug(lang_1.lang.__('STATE_PERSISTED_AFTER_OPERATION', {
+                        action: item.action,
+                        resourceId: item.logicalId,
+                    }));
+                }
+            }
+        }
+        catch (error) {
+            return {
+                state: currentState,
+                partialFailure: {
+                    failedItem: item,
+                    error: error instanceof Error ? error : new Error(String(error)),
+                    successfulItems,
+                },
+            };
+        }
+    }
+    return { state: currentState };
+};
+exports.executeTablePlan = executeTablePlan;

package/dist/src/stack/aliyunStack/tablestorePlanner.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTablePlan = void 0;
+const aliyunClient_1 = require("../../common/aliyunClient");
+const tablestoreTypes_1 = require("./tablestoreTypes");
+const stateManager_1 = require("../../common/stateManager");
+const hashUtils_1 = require("../../common/hashUtils");
+const planTableDeletion = (logicalId, definition) => ({
+    logicalId,
+    action: 'delete',
+    resourceType: 'ALIYUN_TABLESTORE_TABLE',
+    changes: { before: definition },
+});
+const generateTablePlan = async (context, state, tables) => {
+    if (!tables || tables.length === 0) {
+        const allStates = (0, stateManager_1.getAllResources)(state);
+        const items = Object.entries(allStates)
+            .filter(([logicalId]) => logicalId.startsWith('tables.'))
+            .map(([logicalId, resourceState]) => planTableDeletion(logicalId, resourceState.definition));
+        return { items };
+    }
+    const desiredLogicalIds = new Set(tables.map((table) => `tables.${table.key}`));
+    const tableItems = await Promise.all(tables.map(async (table) => {
+        const logicalId = `tables.${table.key}`;
+        const currentState = (0, stateManager_1.getResource)(state, logicalId);
+        const config = (0, tablestoreTypes_1.tableToTableStoreConfig)(table);
+        const desiredDefinition = (0, tablestoreTypes_1.extractTableStoreDefinition)(config);
+        if (!currentState) {
+            return {
+                logicalId,
+                action: 'create',
+                resourceType: 'ALIYUN_TABLESTORE_TABLE',
+                changes: { after: desiredDefinition },
+            };
+        }
+        try {
+            const client = (0, aliyunClient_1.createAliyunClient)(context);
+            const tablestoreClient = client.tablestore(config.instanceName);
+            const remoteTable = await tablestoreClient.getTable(config.tableName);
+            if (!remoteTable) {
+                return {
+                    logicalId,
+                    action: 'create',
+                    resourceType: 'ALIYUN_TABLESTORE_TABLE',
+                    changes: { before: currentState.definition, after: desiredDefinition },
+                    drifted: true,
+                };
+            }
+            const currentDefinition = currentState.definition || {};
+            const definitionChanged = !(0, hashUtils_1.attributesEqual)(currentDefinition, desiredDefinition);
+            if (definitionChanged) {
+                // Check if primary keys changed (not updatable in TableStore)
+                const currentPrimaryKey = JSON.stringify(currentDefinition.primaryKey || []);
+                const desiredPrimaryKey = JSON.stringify(desiredDefinition.primaryKey || []);
+                if (currentPrimaryKey !== desiredPrimaryKey) {
+                    // Primary key changes require table recreation (delete + create)
+                    // For now, we plan it as an update action with drift detection
+                    // The user should manually recreate the table if primary keys need to change
+                    return {
+                        logicalId,
+                        action: 'update',
+                        resourceType: 'ALIYUN_TABLESTORE_TABLE',
+                        changes: { before: currentDefinition, after: desiredDefinition },
+                        drifted: true,
+                    };
+                }
+                // Only throughput and table options changes can be applied via update
+                return {
+                    logicalId,
+                    action: 'update',
+                    resourceType: 'ALIYUN_TABLESTORE_TABLE',
+                    changes: { before: currentDefinition, after: desiredDefinition },
+                    drifted: true,
+                };
+            }
+            return { logicalId, action: 'noop', resourceType: 'ALIYUN_TABLESTORE_TABLE' };
+        }
+        catch {
+            // If we can't check remote state, assume we need to create
+            return {
+                logicalId,
+                action: 'create',
+                resourceType: 'ALIYUN_TABLESTORE_TABLE',
+                changes: { before: currentState.definition, after: desiredDefinition },
+            };
+        }
+    }));
+    const allStates = (0, stateManager_1.getAllResources)(state);
+    const deletionItems = Object.entries(allStates)
+        .filter(([logicalId]) => logicalId.startsWith('tables.') && !desiredLogicalIds.has(logicalId))
+        .map(([logicalId, resourceState]) => planTableDeletion(logicalId, resourceState.definition));
+    return { items: [...tableItems, ...deletionItems] };
+};
+exports.generateTablePlan = generateTablePlan;

package/dist/src/stack/aliyunStack/tablestoreResource.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteTableResource = exports.updateTableResource = exports.readTableResource = exports.createTableResource = void 0;
+const aliyunClient_1 = require("../../common/aliyunClient");
+const common_1 = require("../../common");
+const tablestoreTypes_1 = require("./tablestoreTypes");
+const buildTableStoreInstanceFromProvider = (info, arn, instanceName, clusterType) => {
+    return {
+        type: 'ALIYUN_TABLESTORE_TABLE',
+        arn,
+        id: `${instanceName}/${info.tableName}`,
+        instanceName,
+        tableName: info.tableName,
+        clusterType,
+        primaryKey: info.primaryKey || [],
+        reservedThroughput: info.reservedThroughputDetails
+            ? {
+                capacityUnit: info.reservedThroughputDetails.capacityUnit,
+                lastIncreaseTime: info.reservedThroughputDetails.lastIncreaseTime ?? null,
+                lastDecreaseTime: info.reservedThroughputDetails.lastDecreaseTime ?? null,
+            }
+            : undefined,
+        tableOptions: info.tableOptions
+            ? {
+                timeToLive: info.tableOptions.timeToLive ?? null,
+                maxVersions: info.tableOptions.maxVersions ?? null,
+                maxTimeDeviation: info.tableOptions.maxTimeDeviation ?? null,
+                allowUpdate: info.tableOptions.allowUpdate ?? null,
+            }
+            : undefined,
+        streamDetails: info.streamDetails
+            ? {
+                enableStream: info.streamDetails.enableStream ?? null,
+                streamId: info.streamDetails.streamId ?? null,
+                expirationTime: info.streamDetails.expirationTime ?? null,
+                lastEnableTime: info.streamDetails.lastEnableTime ?? null,
+            }
+            : undefined,
+    };
+};
+const createTableResource = async (context, table, state) => {
+    const config = (0, tablestoreTypes_1.tableToTableStoreConfig)(table);
+    const client = (0, aliyunClient_1.createAliyunClient)(context);
+    const tablestoreClient = client.tablestore(config.instanceName);
+    // Create table
+    await tablestoreClient.createTable({
+        tableName: config.tableName,
+        primaryKey: config.primaryKey,
+        reservedThroughput: config.reservedThroughput,
+        tableOptions: config.tableOptions,
+    });
+    // Wait for table to be ready
+    await tablestoreClient.waitForTableReady(config.tableName);
+    // Refresh state from provider to get all attributes
+    const tableInfo = await tablestoreClient.getTable(config.tableName);
+    if (!tableInfo) {
+        throw new Error(`Failed to refresh state for table: ${config.tableName}`);
+    }
+    const definition = (0, tablestoreTypes_1.extractTableStoreDefinition)(config);
+    const arn = `arn:acs:ots:${context.region}:${context.accountId}:instance/${config.instanceName}/table/${config.tableName}`;
+    const resourceState = {
+        mode: 'managed',
+        region: context.region,
+        definition,
+        instances: [
+            buildTableStoreInstanceFromProvider(tableInfo, arn, config.instanceName, config.clusterType),
+        ],
+        lastUpdated: new Date().toISOString(),
+    };
+    const logicalId = `tables.${table.key}`;
+    return (0, common_1.setResource)(state, logicalId, resourceState);
+};
+exports.createTableResource = createTableResource;
+const readTableResource = async (context, instanceName, tableName) => {
+    const client = (0, aliyunClient_1.createAliyunClient)(context);
+    const tablestoreClient = client.tablestore(instanceName);
+    return await tablestoreClient.getTable(tableName);
+};
+exports.readTableResource = readTableResource;
+const updateTableResource = async (context, table, state) => {
+    const config = (0, tablestoreTypes_1.tableToTableStoreConfig)(table);
+    const client = (0, aliyunClient_1.createAliyunClient)(context);
+    const tablestoreClient = client.tablestore(config.instanceName);
+    // Update table (only reserved throughput and table options can be updated)
+    // Note: Primary keys cannot be changed in TableStore
+    await tablestoreClient.updateTable({
+        tableName: config.tableName,
+        primaryKey: config.primaryKey, // Required by SDK but not used for updates
+        reservedThroughput: config.reservedThroughput,
+        tableOptions: config.tableOptions,
+    });
+    // Wait for table to be ready
+    await tablestoreClient.waitForTableReady(config.tableName);
+    // Refresh state from provider to get all attributes
+    const tableInfo = await tablestoreClient.getTable(config.tableName);
+    if (!tableInfo) {
+        throw new Error(`Failed to refresh state for table: ${config.tableName}`);
+    }
+    const definition = (0, tablestoreTypes_1.extractTableStoreDefinition)(config);
+    const arn = `arn:acs:ots:${context.region}:${context.accountId}:instance/${config.instanceName}/table/${config.tableName}`;
+    const resourceState = {
+        mode: 'managed',
+        region: context.region,
+        definition,
+        instances: [
+            buildTableStoreInstanceFromProvider(tableInfo, arn, config.instanceName, config.clusterType),
+        ],
+        lastUpdated: new Date().toISOString(),
+    };
+    const logicalId = `tables.${table.key}`;
+    return (0, common_1.setResource)(state, logicalId, resourceState);
+};
+exports.updateTableResource = updateTableResource;
+const deleteTableResource = async (context, instanceName, tableName, logicalId, state) => {
+    const client = (0, aliyunClient_1.createAliyunClient)(context);
+    const tablestoreClient = client.tablestore(instanceName);
+    await tablestoreClient.deleteTable(tableName);
+    return (0, common_1.removeResource)(state, logicalId);
+};
+exports.deleteTableResource = deleteTableResource;

package/dist/src/stack/aliyunStack/tablestoreTypes.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTableStoreDefinition = exports.tableToTableStoreConfig = void 0;
+const types_1 = require("../../types");
+// Map from TableStore cluster type to TableEnum
+const clusterTypeMap = new Map([
+    ["TABLE_STORE_C" /* TableEnum.TABLE_STORE_C */, 'HYBRID'],
+    ["TABLE_STORE_H" /* TableEnum.TABLE_STORE_H */, 'SSD'],
+]);
+// Map from domain attribute type to TableStore primary key type
+const attributeTypeToTableStoreType = (type) => {
+    switch (type) {
+        case types_1.AttributeTypeEnum.INTEGER:
+            return 'INTEGER';
+        case types_1.AttributeTypeEnum.STRING:
+            return 'STRING';
+        case types_1.AttributeTypeEnum.BINARY:
+            return 'BINARY';
+        // For types not directly supported as primary keys, default to STRING
+        case types_1.AttributeTypeEnum.DOUBLE:
+        case types_1.AttributeTypeEnum.BOOLEAN:
+        default:
+            return 'STRING';
+    }
+};
+const tableToTableStoreConfig = (table) => {
+    const clusterType = clusterTypeMap.get(table.type);
+    if (!clusterType) {
+        throw new Error(`Unsupported table type: ${table.type}`);
+    }
+    // Extract primary keys from keySchema
+    const primaryKey = table.keySchema.map((key) => {
+        const attribute = table.attributes.find((attr) => attr.name === key.name);
+        if (!attribute) {
+            throw new Error(`Attribute not found for key: ${key.name}`);
+        }
+        return {
+            name: key.name,
+            type: attributeTypeToTableStoreType(attribute.type),
+        };
+    });
+    const config = {
+        instanceName: table.collection,
+        tableName: table.name,
+        clusterType,
+        primaryKey,
+        network: table.network,
+    };
+    // Add reserved throughput if specified
+    if (table.throughput?.reserved) {
+        config.reservedThroughput = {
+            capacityUnit: {
+                read: table.throughput.reserved.read,
+                write: table.throughput.reserved.write,
+            },
+        };
+    }
+    // Default table options
+    config.tableOptions = {
+        timeToLive: -1, // -1 means never expire
+        maxVersions: 1, // Keep only the latest version
+    };
+    return config;
+};
+exports.tableToTableStoreConfig = tableToTableStoreConfig;
+const extractTableStoreDefinition = (config) => {
+    return {
+        instanceName: config.instanceName,
+        tableName: config.tableName,
+        clusterType: config.clusterType,
+        primaryKey: config.primaryKey,
+        reservedThroughput: config.reservedThroughput ?? null,
+        tableOptions: config.tableOptions ?? null,
+        network: config.network ?? null,
+    };
+};
+exports.extractTableStoreDefinition = extractTableStoreDefinition;

package/dist/src/stack/bucketTypes.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Shared bucket types for OSS and COS providers.
+ * Both Aliyun OSS and Tencent COS share similar bucket concepts.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BucketACL = void 0;
+/**
+ * Bucket ACL (Access Control List) values.
+ * Common across cloud providers.
+ */
+var BucketACL;
+(function (BucketACL) {
+    BucketACL["PRIVATE"] = "private";
+    BucketACL["PUBLIC_READ"] = "public-read";
+    BucketACL["PUBLIC_READ_WRITE"] = "public-read-write";
+})(BucketACL || (exports.BucketACL = BucketACL = {}));

package/dist/src/stack/deploy.js

@@ -1,63 +1,11 @@
 "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;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateStackTemplate = exports.deployStack = exports.generateRfsStackTemplate = exports.generateRosStackTemplate = void 0;
-const ros = __importStar(require("@alicloud/ros-cdk-core"));
-const node_fs_1 = __importDefault(require("node:fs"));
+exports.generateStackTemplate = exports.deployStack = exports.generateRfsStackTemplate = void 0;
 const common_1 = require("../common");
-const rosStack_1 = require("./rosStack");
 const rfsStack_1 = require("./rfsStack");
-const lodash_1 = require("lodash");
-const generateRosStackTemplate = (stackName, iac) => {
-    const context = (0, common_1.getContext)();
-    const app = new ros.App();
-    new rosStack_1.RosStack(app, iac, context);
-    const assembly = app.synth();
-    const { template } = assembly.getStackByName(stackName);
-    const assetFolderPath = (0, lodash_1.get)(assembly.tryGetArtifact(`${stackName}.assets`), 'file', '');
-    const assetsFileBody = node_fs_1.default.readFileSync(assetFolderPath);
-    const assets = {
-        rootPath: assembly.directory,
-        ...JSON.parse(assetsFileBody.toString('utf-8').trim()),
-    };
-    return { template, assets };
-};
-exports.generateRosStackTemplate = generateRosStackTemplate;
+const scfStack_1 = require("./scfStack");
+const aliyunStack_1 = require("./aliyunStack");
+const lang_1 = require("../lang");
 const generateRfsStackTemplate = (stackName, iac) => {
     const stack = new rfsStack_1.RfsStack(iac);
     const hcl = stack.toHclTerraform();
@@ -65,39 +13,38 @@ const generateRfsStackTemplate = (stackName, iac) => {
     return { template: hcl };
 };
 exports.generateRfsStackTemplate = generateRfsStackTemplate;
+const deployHuawei = async (stackName, iac) => {
+    // For now, Huawei uses the same approach as Aliyun but with different stack
+    const { template } = (0, exports.generateRfsStackTemplate)(stackName, iac);
+    common_1.logger.info(lang_1.lang.__('DEPLOYING_STACK_PUBLISHING_ASSETS'));
+    // TODO: Implement Huawei-specific deployment logic
+    console.log('HCL:', template);
+    common_1.logger.info(lang_1.lang.__('STACK_DEPLOYED'));
+};
 const deployStack = async (stackName, iac) => {
-    const { template, assets } = (0, exports.generateRosStackTemplate)(stackName, iac);
-    await (0, rosStack_1.prepareBootstrapStack)();
-    common_1.logger.info(`Deploying stack, publishing assets...`);
-    const constructedAssets = await (0, common_1.constructAssets)(assets);
-    try {
-        await (0, common_1.publishAssets)(constructedAssets);
-        common_1.logger.info(`Assets published! 🎉`);
-        await (0, common_1.rosStackDeploy)(stackName, template);
+    if (iac.provider.name === common_1.ProviderEnum.TENCENT) {
+        await (0, scfStack_1.deployTencentStack)(iac);
     }
-    catch (e) {
-        common_1.logger.error(`Failed to deploy stack: ${e}`);
-        throw e;
+    else if (iac.provider.name === common_1.ProviderEnum.ALIYUN) {
+        await (0, aliyunStack_1.deployAliyunStack)(iac);
     }
-    finally {
-        try {
-            common_1.logger.info(`Cleaning up temporary Assets...`);
-            await (0, common_1.cleanupAssets)(constructedAssets);
-            common_1.logger.info(`Assets cleaned up!♻️`);
-        }
-        catch (e) {
-            common_1.logger.error(`Failed to cleanup assets, it wont affect the deployment result, but to avoid potential cost, you can delete the temporary bucket : ${constructedAssets?.[0].bucketName}, error details:${e}`);
-        }
+    else if (iac.provider.name === common_1.ProviderEnum.HUAWEI) {
+        await deployHuawei(stackName, iac);
     }
 };
 exports.deployStack = deployStack;
 const generateStackTemplate = (stackName, iac) => {
     if (iac.provider.name === common_1.ProviderEnum.ALIYUN) {
-        return (0, exports.generateRosStackTemplate)(stackName, iac);
+        // Aliyun now uses state-based deployment, no template generation needed
+        return { template: {} };
     }
     else if (iac.provider.name === common_1.ProviderEnum.HUAWEI) {
         return (0, exports.generateRfsStackTemplate)(stackName, iac);
     }
+    else if (iac.provider.name === common_1.ProviderEnum.TENCENT) {
+        // Tencent uses state-based deployment, no template generation needed
+        return { template: {} };
+    }
     return { template: '' };
 };
 exports.generateStackTemplate = generateStackTemplate;

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

@@ -7,6 +7,7 @@ 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 lang_1 = require("../../lang");
 const TEXT_MIME_TYPES = new Set([
     'text/plain',
     'text/html',
@@ -58,7 +59,7 @@ const listDirectory = (dirPath, bucketPath) => {
         });
     }
     catch (error) {
-        common_1.logger.error(`Error listing directory: ${error}`);
+        common_1.logger.error(lang_1.lang.__('ERROR_LISTING_DIRECTORY', { error: String(error) }));
         return [];
     }
 };
@@ -85,12 +86,16 @@ const getAllFiles = (dirPath, bucketPath, fileList = []) => {
         return fileList;
     }
     catch (error) {
-        common_1.logger.error(`Error getting all files: ${error}`);
+        common_1.logger.error(lang_1.lang.__('ERROR_GETTING_ALL_FILES', { error: String(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}`);
+    common_1.logger.info(lang_1.lang.__('BUCKET_REQUEST_RECEIVED', {
+        method: req.method || '',
+        identifier: parsed.identifier ?? '/',
+        url: parsed.url || '',
+    }));
     // Find the bucket definition
     const bucketDef = iac.buckets?.find((bucket) => bucket.key === parsed.identifier);
     if (!bucketDef) {
@@ -136,7 +141,7 @@ const bucketsHandler = async (req, parsed, iac) => {
             };
         }
         catch (error) {
-            common_1.logger.error(`Error listing bucket files: ${error}`);
+            common_1.logger.error(lang_1.lang.__('ERROR_LISTING_BUCKET_FILES', { error: String(error) }));
             return {
                 statusCode: 500,
                 body: {
@@ -187,7 +192,7 @@ const bucketsHandler = async (req, parsed, iac) => {
             };
         }
         catch (error) {
-            common_1.logger.error(`Error listing directory: ${error}`);
+            common_1.logger.error(lang_1.lang.__('ERROR_LISTING_DIRECTORY', { error: String(error) }));
             return {
                 statusCode: 500,
                 body: {
@@ -213,7 +218,7 @@ const bucketsHandler = async (req, parsed, iac) => {
         };
     }
     catch (error) {
-        common_1.logger.error(`Error reading file: ${error}`);
+        common_1.logger.error(lang_1.lang.__('ERROR_READING_FILE', { error: String(error) }));
         return {
             statusCode: 500,
             body: {

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

@@ -13,6 +13,7 @@ const functionRunner_1 = require("./functionRunner");
 const node_path_1 = __importDefault(require("node:path"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const utils_1 = require("./utils");
+const lang_1 = require("../../lang");
 const matchTrigger = (req, trigger) => {
     if (req.method !== 'ANY' && req.method !== trigger.method) {
         return false;
@@ -47,7 +48,11 @@ const servEvent = async (req, parsed, iac) => {
             body: { error: 'API Gateway event not found', event: parsed.identifier },
         };
     }
-    common_1.logger.info(`Event trigger ${JSON.stringify(event.triggers)}, req method: ${req.method}, req url${req.url}`);
+    common_1.logger.info(lang_1.lang.__('EVENT_TRIGGER', {
+        triggers: JSON.stringify(event.triggers),
+        method: req.method || '',
+        url: req.url || '',
+    }));
     const matchedTrigger = event.triggers.find((trigger) => matchTrigger({ method: parsed.method, path: parsed.url }, trigger));
     if (!matchedTrigger) {
         const endTime = new Date();
@@ -90,13 +95,13 @@ const servEvent = async (req, parsed, iac) => {
                     functionKey: backendDef.key,
                     handler: backendDef.code.handler,
                     servicePath: '',
-                    timeout: backendDef.timeout * 1000,
+                    timeout: (backendDef.timeout ?? 3) * 1000,
                 };
-                const aliyunContext = (0, aliyunFc_1.createAliyunContextSerializable)(iac, backendDef.name, backendDef.code.handler, backendDef.memory, backendDef.timeout, requestId);
+                const aliyunContext = (0, aliyunFc_1.createAliyunContextSerializable)(iac, backendDef.name, backendDef.code.handler, backendDef.memory ?? 128, backendDef.timeout ?? 3, requestId);
                 const env = {
                     ...backendDef.environment,
                 };
-                common_1.logger.debug(`Invoking FC function with Aliyun event format`);
+                common_1.logger.debug(lang_1.lang.__('INVOKING_FC_FUNCTION_WITH_ALIYUN_EVENT'));
                 const result = await (0, functionRunner_1.invokeFunction)(funOptions, env, aliyunEvent, aliyunContext);
                 const endTime = new Date();
                 const transformed = (0, aliyunFc_1.transformFCResponse)(result);
@@ -111,7 +116,7 @@ const servEvent = async (req, parsed, iac) => {
             catch (error) {
                 const endTime = new Date();
                 (0, aliyunFc_1.logApiGatewayRequest)(requestId, parsed.url, 500, startTime, endTime, sourceIp);
-                common_1.logger.error(`Function execution error: ${error}`);
+                common_1.logger.error(lang_1.lang.__('FUNCTION_EXECUTION_ERROR', { error: String(error) }));
                 return {
                     statusCode: 500,
                     body: {