@geek-fun/serverlessinsight 0.4.0 → 0.5.0

package/dist/src/common/aliyunClient/slsOperations.js

@@ -0,0 +1,218 @@
+"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.createSlsOperations = void 0;
+const sls = __importStar(require("@alicloud/sls20201230"));
+const waitForSlsProject = async (getProject, projectName) => {
+    let retries = 0;
+    while (retries < 30) {
+        try {
+            const project = await getProject(projectName);
+            if (project && project.status === 'Normal') {
+                return project;
+            }
+        }
+        catch {
+            // Project not ready yet
+        }
+        await new Promise((resolve) => setTimeout(resolve, 3000));
+        retries++;
+    }
+    return { projectName };
+};
+const waitForSlsLogstore = async (getLogstore, projectName, logstoreName, ttl) => {
+    let retries = 0;
+    while (retries < 30) {
+        try {
+            const logstore = await getLogstore(projectName, logstoreName);
+            if (logstore) {
+                return logstore;
+            }
+        }
+        catch {
+            // Logstore not ready yet
+        }
+        await new Promise((resolve) => setTimeout(resolve, 3000));
+        retries++;
+    }
+    return { logstoreName, projectName, ttl };
+};
+const createSlsOperations = (slsClient) => {
+    const operations = {
+        createProject: async (projectName, description) => {
+            const request = new sls.CreateProjectRequest({
+                projectName,
+                description: description ?? `ServerlessInsight log project for ${projectName}`,
+            });
+            await slsClient.createProject(request);
+            // Wait for project to be ready
+            return await waitForSlsProject(operations.getProject, projectName);
+        },
+        getProject: async (projectName) => {
+            try {
+                const response = await slsClient.getProject(projectName);
+                if (!response || !response.body) {
+                    return null;
+                }
+                return {
+                    projectName: response.body.name ?? projectName,
+                    description: response.body.description,
+                    status: response.body.status,
+                    createTime: response.body.createTime,
+                    lastModifyTime: response.body.lastModifyTime,
+                };
+            }
+            catch (error) {
+                if (error &&
+                    typeof error === 'object' &&
+                    'code' in error &&
+                    error.code === 'ProjectNotExist') {
+                    return null;
+                }
+                throw error;
+            }
+        },
+        deleteProject: async (projectName) => {
+            const request = new sls.DeleteProjectRequest({});
+            await slsClient.deleteProject(projectName, request);
+        },
+        createLogstore: async (projectName, logstoreName, ttl = 7) => {
+            const request = new sls.CreateLogStoreRequest({
+                logstoreName,
+                ttl,
+                shardCount: 2,
+            });
+            await slsClient.createLogStore(projectName, request);
+            // Wait for logstore to be ready
+            return await waitForSlsLogstore(operations.getLogstore, projectName, logstoreName, ttl);
+        },
+        getLogstore: async (projectName, logstoreName) => {
+            try {
+                const response = await slsClient.getLogStore(projectName, logstoreName);
+                if (!response || !response.body) {
+                    return null;
+                }
+                return {
+                    logstoreName: response.body.logstoreName ?? logstoreName,
+                    projectName,
+                    ttl: response.body.ttl,
+                    shardCount: response.body.shardCount,
+                    createTime: response.body.createTime,
+                    lastModifyTime: response.body.lastModifyTime,
+                };
+            }
+            catch (error) {
+                if (error &&
+                    typeof error === 'object' &&
+                    'code' in error &&
+                    error.code === 'LogStoreNotExist') {
+                    return null;
+                }
+                throw error;
+            }
+        },
+        deleteLogstore: async (projectName, logstoreName) => {
+            await slsClient.deleteLogStore(projectName, logstoreName);
+        },
+        createIndex: async (projectName, logstoreName) => {
+            const request = new sls.CreateIndexRequest({
+                body: new sls.Index({
+                    line: new sls.IndexLine({
+                        token: [
+                            ',',
+                            ' ',
+                            "'",
+                            '"',
+                            ';',
+                            '=',
+                            '(',
+                            ')',
+                            '[',
+                            ']',
+                            '{',
+                            '}',
+                            '?',
+                            '@',
+                            '&',
+                            '<',
+                            '>',
+                            '/',
+                            ':',
+                            '\n',
+                            '\t',
+                            '\r',
+                        ],
+                    }),
+                }),
+            });
+            await slsClient.createIndex(projectName, logstoreName, request);
+            return { projectName, logstoreName };
+        },
+        getIndex: async (projectName, logstoreName) => {
+            try {
+                const response = await slsClient.getIndex(projectName, logstoreName);
+                if (!response || !response.body) {
+                    return null;
+                }
+                return {
+                    projectName,
+                    logstoreName,
+                    indexMode: response.body.indexMode,
+                    lastModifyTime: response.body.lastModifyTime,
+                };
+            }
+            catch (error) {
+                if (error &&
+                    typeof error === 'object' &&
+                    'code' in error &&
+                    error.code === 'IndexConfigNotExist') {
+                    return null;
+                }
+                throw error;
+            }
+        },
+        deleteIndex: async (projectName, logstoreName) => {
+            await slsClient.deleteIndex(projectName, logstoreName);
+        },
+        waitForProject: async (projectName) => {
+            return waitForSlsProject(operations.getProject, projectName);
+        },
+        waitForLogstore: async (projectName, logstoreName, ttl = 7) => {
+            return waitForSlsLogstore(operations.getLogstore, projectName, logstoreName, ttl);
+        },
+    };
+    return operations;
+};
+exports.createSlsOperations = createSlsOperations;

package/dist/src/common/aliyunClient/tablestoreOperations.js

@@ -0,0 +1,199 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTablestoreOperations = exports.TableStoreInstanceStatus = void 0;
+const tablestore_1 = __importDefault(require("tablestore"));
+const logger_1 = require("../logger");
+var TableStoreInstanceStatus;
+(function (TableStoreInstanceStatus) {
+    TableStoreInstanceStatus["RUNNING"] = "RUNNING";
+    TableStoreInstanceStatus["CREATING"] = "CREATING";
+    TableStoreInstanceStatus["DELETED"] = "DELETED";
+    TableStoreInstanceStatus["DISABLED"] = "DISABLED";
+})(TableStoreInstanceStatus || (exports.TableStoreInstanceStatus = TableStoreInstanceStatus = {}));
+const waitForTableReady = async (describeTable, tableName) => {
+    const maxAttempts = 60;
+    let attempts = 0;
+    while (attempts < maxAttempts) {
+        try {
+            const table = await describeTable(tableName);
+            if (table) {
+                logger_1.logger.info(`Table ${tableName} is ready`);
+                return;
+            }
+        }
+        catch (error) {
+            // Table might not exist yet during creation
+            if (attempts < maxAttempts - 1) {
+                logger_1.logger.info(`Waiting for table ${tableName} to be ready... (attempt ${attempts + 1}/${maxAttempts})`);
+                await new Promise((resolve) => setTimeout(resolve, 5000));
+                attempts++;
+                continue;
+            }
+            throw error;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 5000));
+        attempts++;
+    }
+    throw new Error(`Timeout waiting for table ${tableName} to be ready`);
+};
+const createTablestoreOperations = (endpoint, instanceName, context) => {
+    const client = new tablestore_1.default.Client({
+        accessKeyId: context.accessKeyId,
+        secretAccessKey: context.accessKeySecret,
+        stsToken: context.securityToken,
+        endpoint,
+        instancename: instanceName,
+    });
+    return {
+        createTable: async (config) => {
+            const params = {
+                tableMeta: {
+                    tableName: config.tableName,
+                    primaryKey: config.primaryKey.map((pk) => ({
+                        name: pk.name,
+                        type: pk.type,
+                    })),
+                },
+                reservedThroughput: config.reservedThroughput || {
+                    capacityUnit: {
+                        read: 0,
+                        write: 0,
+                    },
+                },
+                tableOptions: config.tableOptions || {
+                    timeToLive: -1,
+                    maxVersions: 1,
+                },
+            };
+            return new Promise((resolve, reject) => {
+                client.createTable(params, (err) => {
+                    if (err) {
+                        logger_1.logger.error(`Failed to create table ${config.tableName}: ${err.message}`);
+                        reject(err);
+                    }
+                    else {
+                        logger_1.logger.info(`Successfully created table ${config.tableName}`);
+                        resolve();
+                    }
+                });
+            });
+        },
+        getTable: async (tableName) => {
+            const params = {
+                tableName,
+            };
+            return new Promise((resolve, reject) => {
+                client.describeTable(params, (err, data) => {
+                    if (err) {
+                        const errorMessage = err.message || String(err);
+                        if (errorMessage.includes('OTSObjectNotExist') ||
+                            errorMessage.includes('does not exist')) {
+                            resolve(null);
+                        }
+                        else {
+                            logger_1.logger.error(`Failed to describe table ${tableName}: ${errorMessage}`);
+                            reject(err);
+                        }
+                    }
+                    else {
+                        const result = data;
+                        if (!result.tableMeta) {
+                            resolve(null);
+                        }
+                        else {
+                            resolve({
+                                tableName: result.tableMeta.tableName || tableName,
+                                primaryKey: result.tableMeta.primaryKey,
+                                reservedThroughputDetails: result.reservedThroughputDetails,
+                                tableOptions: result.tableOptions,
+                                streamDetails: result.streamDetails,
+                            });
+                        }
+                    }
+                });
+            });
+        },
+        updateTable: async (config) => {
+            const params = {
+                tableName: config.tableName,
+                reservedThroughput: config.reservedThroughput || {
+                    capacityUnit: {
+                        read: 0,
+                        write: 0,
+                    },
+                },
+                tableOptions: config.tableOptions,
+            };
+            return new Promise((resolve, reject) => {
+                client.updateTable(params, (err) => {
+                    if (err) {
+                        logger_1.logger.error(`Failed to update table ${config.tableName}: ${err.message}`);
+                        reject(err);
+                    }
+                    else {
+                        logger_1.logger.info(`Successfully updated table ${config.tableName}`);
+                        resolve();
+                    }
+                });
+            });
+        },
+        deleteTable: async (tableName) => {
+            const params = {
+                tableName,
+            };
+            return new Promise((resolve, reject) => {
+                client.deleteTable(params, (err) => {
+                    if (err) {
+                        const errorMessage = err.message || String(err);
+                        // If table doesn't exist, consider deletion successful
+                        if (errorMessage.includes('OTSObjectNotExist') ||
+                            errorMessage.includes('does not exist')) {
+                            logger_1.logger.info(`Table ${tableName} already deleted or does not exist`);
+                            resolve();
+                        }
+                        else {
+                            logger_1.logger.error(`Failed to delete table ${tableName}: ${errorMessage}`);
+                            reject(err);
+                        }
+                    }
+                    else {
+                        logger_1.logger.info(`Successfully deleted table ${tableName}`);
+                        resolve();
+                    }
+                });
+            });
+        },
+        waitForTableReady: async (tableName) => {
+            return waitForTableReady(async (name) => {
+                try {
+                    return await new Promise((resolve, reject) => {
+                        client.describeTable({ tableName: name }, (err, data) => {
+                            if (err) {
+                                reject(err);
+                            }
+                            else {
+                                const result = data;
+                                if (!result.tableMeta) {
+                                    resolve(null);
+                                }
+                                else {
+                                    resolve({
+                                        tableName: result.tableMeta.tableName || name,
+                                        primaryKey: result.tableMeta.primaryKey,
+                                    });
+                                }
+                            }
+                        });
+                    });
+                }
+                catch {
+                    return null;
+                }
+            }, tableName);
+        },
+    };
+};
+exports.createTablestoreOperations = createTablestoreOperations;

package/dist/src/common/aliyunClient/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/common/constants.js

@@ -1,8 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SI_LOCALSTACK_SERVER_PORT = exports.SI_BOOTSTRAP_BUCKET_PREFIX = exports.SI_BOOTSTRAP_FC_PREFIX = exports.OSS_DEPLOYMENT_TIMEOUT = exports.CODE_ZIP_SIZE_LIMIT = void 0;
+exports.STALE_LOCK_THRESHOLD = exports.DEFAULT_LOCK_RETRY_DELAY = exports.DEFAULT_LOCK_TIMEOUT = exports.LOCK_FILE_SUFFIX = exports.SI_LOCALSTACK_SERVER_PORT = exports.SI_BOOTSTRAP_BUCKET_PREFIX = exports.SI_BOOTSTRAP_FC_PREFIX = exports.ROS_STACK_OPERATION_TIMEOUT = exports.OSS_DEPLOYMENT_TIMEOUT = exports.CODE_ZIP_SIZE_LIMIT = void 0;
 exports.CODE_ZIP_SIZE_LIMIT = 300 * 1000; // 300 KB ROS TemplateBody size limit 512 KB
 exports.OSS_DEPLOYMENT_TIMEOUT = 3000; // in seconds
+exports.ROS_STACK_OPERATION_TIMEOUT = 3600; // in seconds
 exports.SI_BOOTSTRAP_FC_PREFIX = 'si-bootstrap-api';
 exports.SI_BOOTSTRAP_BUCKET_PREFIX = 'si-bootstrap-artifacts';
 exports.SI_LOCALSTACK_SERVER_PORT = 4567;
+// Lock manager constants
+exports.LOCK_FILE_SUFFIX = '.si-lock';
+exports.DEFAULT_LOCK_TIMEOUT = 10 * 60 * 1000; // 10 minutes
+exports.DEFAULT_LOCK_RETRY_DELAY = 2000; // 2 seconds
+exports.STALE_LOCK_THRESHOLD = 60 * 60 * 1000; // 1 hour

package/dist/src/common/context.js

@@ -3,13 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getContext = exports.setContext = exports.getIacLocation = void 0;
-const node_path_1 = __importDefault(require("node:path"));
+exports.clearContext = exports.setIac = exports.getContext = exports.setContext = exports.getIacLocation = void 0;
 const node_fs_1 = __importDefault(require("node:fs"));
-const providerEnum_1 = require("./providerEnum");
-const node_async_hooks_1 = require("node:async_hooks");
+const node_path_1 = __importDefault(require("node:path"));
+const credentials_1 = require("./credentials");
 const imsClient_1 = require("./imsClient");
-const asyncLocalStorage = new node_async_hooks_1.AsyncLocalStorage();
+const providerEnum_1 = require("./providerEnum");
+let context;
 const DEFAULT_IAC_FILES = [
     'serverlessinsight.yml',
     'serverlessInsight.yml',
@@ -58,14 +58,22 @@ const setContext = async (config, reaValToken = false) => {
         process.env.ROS_REGION_ID ??
         process.env.ALIYUN_REGION ??
         'cn-hangzhou';
-    const context = {
+    const provider = (config.provider ??
+        config.iacProvider?.name ??
+        providerEnum_1.ProviderEnum.ALIYUN);
+    const credentials = (0, credentials_1.getCredentials)({
+        accessKeyId: config.accessKeyId,
+        accessKeySecret: config.accessKeySecret,
+        securityToken: config.securityToken,
+    }, provider);
+    const newContext = {
         stage: config.stage ?? 'default',
         stackName: config.stackName ?? '',
-        provider: (config.provider ?? config.iacProvider?.name ?? providerEnum_1.ProviderEnum.ALIYUN),
+        provider,
         region,
-        accessKeyId: config.accessKeyId ?? process.env.ALIYUN_ACCESS_KEY_ID,
-        accessKeySecret: config.accessKeySecret ?? process.env.ALIYUN_ACCESS_KEY_SECRET,
-        securityToken: config.securityToken ?? process.env.ALIYUN_SECURITY_TOKEN,
+        accessKeyId: credentials.accessKeyId,
+        accessKeySecret: credentials.accessKeySecret,
+        securityToken: credentials.securityToken,
         iacLocation: (0, exports.getIacLocation)(config.location),
         parameters: Object.entries(config.parameters ?? {}).map(([key, value]) => ({ key, value })),
         stages: Object.entries(config.stages ?? {}).reduce((acc, [stage, parameters]) => ({
@@ -74,17 +82,27 @@ const setContext = async (config, reaValToken = false) => {
         }), {}),
     };
     if (reaValToken) {
-        const iamInfo = await (0, imsClient_1.getIamInfo)(context);
-        context.accountId = iamInfo?.accountId;
+        const iamInfo = await (0, imsClient_1.getIamInfo)(newContext);
+        newContext.accountId = iamInfo?.accountId;
     }
-    asyncLocalStorage.enterWith(context);
+    context = newContext;
 };
 exports.setContext = setContext;
 const getContext = () => {
-    const context = asyncLocalStorage.getStore();
     if (!context) {
         throw new Error('No context found');
     }
     return context;
 };
 exports.getContext = getContext;
+const setIac = (iac) => {
+    if (!context) {
+        throw new Error('Context must be set before setting IAC');
+    }
+    context.iac = iac;
+};
+exports.setIac = setIac;
+const clearContext = () => {
+    context = undefined;
+};
+exports.clearContext = clearContext;

package/dist/src/common/credentials.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasCredentials = exports.getCredentials = void 0;
+const providerEnum_1 = require("./providerEnum");
+const getCredentials = (config, provider) => {
+    if (config?.accessKeyId && config?.accessKeySecret) {
+        return {
+            accessKeyId: config.accessKeyId,
+            accessKeySecret: config.accessKeySecret,
+            securityToken: config.securityToken,
+        };
+    }
+    switch (provider) {
+        case providerEnum_1.ProviderEnum.TENCENT:
+            return {
+                accessKeyId: config?.accessKeyId ?? process.env.TENCENTCLOUD_SECRET_ID,
+                accessKeySecret: config?.accessKeySecret ?? process.env.TENCENTCLOUD_SECRET_KEY,
+                securityToken: config?.securityToken ?? process.env.TENCENTCLOUD_SECURITY_TOKEN,
+            };
+        case providerEnum_1.ProviderEnum.HUAWEI:
+            return {
+                accessKeyId: config?.accessKeyId ?? process.env.HUAWEICLOUD_ACCESS_KEY,
+                accessKeySecret: config?.accessKeySecret ?? process.env.HUAWEICLOUD_SECRET_KEY,
+                securityToken: config?.securityToken,
+            };
+        case providerEnum_1.ProviderEnum.ALIYUN:
+        default:
+            return {
+                accessKeyId: config?.accessKeyId ?? process.env.ALIYUN_ACCESS_KEY_ID,
+                accessKeySecret: config?.accessKeySecret ?? process.env.ALIYUN_ACCESS_KEY_SECRET,
+                securityToken: config?.securityToken ?? process.env.ALIYUN_SECURITY_TOKEN,
+            };
+    }
+};
+exports.getCredentials = getCredentials;
+const hasCredentials = (credentials) => {
+    return !!credentials.accessKeyId && !!credentials.accessKeySecret;
+};
+exports.hasCredentials = hasCredentials;