@geek-fun/serverlessinsight 0.4.1 → 0.5.0

package/dist/src/common/dependencyGraph/graph.js

@@ -0,0 +1,280 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toDotFormat = exports.getDependencyInfo = exports.getParallelExecutionPlan = exports.getExecutionOrder = exports.topologicalSort = exports.validateGraph = exports.detectCycle = exports.buildDependencyGraph = void 0;
+const RESOURCE_TYPE_PREFIX_MAP = {
+    // Aliyun resource types (as emitted by planners)
+    ALIYUN_FC3: 'functions',
+    ALIYUN_OSS_BUCKET: 'buckets',
+    ALIYUN_APIGW: 'events',
+    ALIYUN_APIGW_GROUP: 'events',
+    ALIYUN_APIGW_API: 'events',
+    ALIYUN_APIGW_DEPLOYMENT: 'events',
+    ALIYUN_RDS_SERVERLESS: 'databases',
+    ALIYUN_ES_SERVERLESS: 'databases',
+    ALIYUN_TABLESTORE_TABLE: 'tables',
+    // Tencent resource types (as emitted by planners)
+    SCF: 'functions',
+    COS_BUCKET: 'buckets',
+    TDSQL_C_SERVERLESS: 'databases',
+};
+const RESOURCE_DEPENDENCY_ORDER = {
+    databases: 0,
+    buckets: 1,
+    functions: 2,
+    tables: 3,
+    events: 4,
+};
+const getResourcePrefix = (logicalId) => logicalId.split('.')[0];
+const getResourceTypeOrder = (resourceType) => {
+    const prefix = RESOURCE_TYPE_PREFIX_MAP[resourceType] || 'unknown';
+    return RESOURCE_DEPENDENCY_ORDER[prefix] ?? 99;
+};
+const getPrefixOrder = (prefix) => RESOURCE_DEPENDENCY_ORDER[prefix] ?? 99;
+const extractReferencedResources = (changes) => {
+    if (!changes)
+        return [];
+    const isValidResourceReference = (ref) => {
+        const validPrefixes = ['functions', 'events', 'databases', 'buckets', 'tables'];
+        const prefix = ref.split('.')[0];
+        return validPrefixes.includes(prefix);
+    };
+    const findReferences = (obj) => {
+        if (typeof obj === 'string') {
+            const matches = obj.match(/\$\{([^}]+)\}/g) || [];
+            return matches.map((m) => m.replace(/\$\{|\}/g, '')).filter(isValidResourceReference);
+        }
+        if (Array.isArray(obj)) {
+            return obj.flatMap(findReferences);
+        }
+        if (typeof obj === 'object' && obj !== null) {
+            return Object.values(obj).flatMap(findReferences);
+        }
+        return [];
+    };
+    const afterRefs = findReferences(changes.after);
+    return [...new Set(afterRefs)];
+};
+const inferDependenciesFromType = (item, allItems) => {
+    const sourcePrefix = getResourcePrefix(item.logicalId);
+    const sourceOrder = getPrefixOrder(sourcePrefix);
+    return allItems
+        .filter((other) => {
+        if (other.logicalId === item.logicalId)
+            return false;
+        const targetPrefix = getResourcePrefix(other.logicalId);
+        const targetOrder = getPrefixOrder(targetPrefix);
+        return targetOrder < sourceOrder && other.action !== 'delete' && other.action !== 'noop';
+    })
+        .map((dep) => dep.logicalId);
+};
+const findDependencies = (item, allItems) => {
+    const itemsByLogicalId = new Map(allItems.map((i) => [i.logicalId, i]));
+    const explicitRefs = extractReferencedResources(item.changes);
+    const explicitDeps = explicitRefs
+        .filter((ref) => itemsByLogicalId.has(ref))
+        .filter((ref) => {
+        const depItem = itemsByLogicalId.get(ref);
+        return depItem && depItem.action !== 'delete' && depItem.action !== 'noop';
+    });
+    const implicitDeps = item.action !== 'delete' ? inferDependenciesFromType(item, allItems) : [];
+    return [...new Set([...explicitDeps, ...implicitDeps])];
+};
+const findDestroyDependencies = (item, allItems) => {
+    const sourcePrefix = getResourcePrefix(item.logicalId);
+    const sourceOrder = getPrefixOrder(sourcePrefix);
+    return allItems
+        .filter((other) => {
+        if (other.logicalId === item.logicalId)
+            return false;
+        if (other.action !== 'delete')
+            return false;
+        const targetPrefix = getResourcePrefix(other.logicalId);
+        const targetOrder = getPrefixOrder(targetPrefix);
+        return targetOrder > sourceOrder;
+    })
+        .map((dep) => dep.logicalId);
+};
+const buildDependencyGraph = (items) => {
+    const nodes = new Map();
+    const edges = [];
+    items.forEach((item) => {
+        nodes.set(item.logicalId, {
+            id: item.logicalId,
+            planItem: item,
+            dependencies: [],
+            dependents: [],
+        });
+    });
+    items.forEach((item) => {
+        const deps = item.action === 'delete'
+            ? findDestroyDependencies(item, items)
+            : findDependencies(item, items);
+        deps.forEach((depId) => {
+            const node = nodes.get(item.logicalId);
+            const depNode = nodes.get(depId);
+            if (node && depNode) {
+                node.dependencies.push(depId);
+                depNode.dependents.push(item.logicalId);
+                edges.push({ from: depId, to: item.logicalId });
+            }
+        });
+    });
+    return { nodes, edges };
+};
+exports.buildDependencyGraph = buildDependencyGraph;
+const detectCycle = (graph) => {
+    const visited = new Set();
+    const recursionStack = new Set();
+    const path = [];
+    const dfs = (nodeId) => {
+        visited.add(nodeId);
+        recursionStack.add(nodeId);
+        path.push(nodeId);
+        const node = graph.nodes.get(nodeId);
+        if (node) {
+            for (const depId of node.dependents) {
+                if (!visited.has(depId)) {
+                    const cycle = dfs(depId);
+                    if (cycle)
+                        return cycle;
+                }
+                else if (recursionStack.has(depId)) {
+                    const cycleStart = path.indexOf(depId);
+                    return [...path.slice(cycleStart), depId];
+                }
+            }
+        }
+        path.pop();
+        recursionStack.delete(nodeId);
+        return null;
+    };
+    for (const nodeId of graph.nodes.keys()) {
+        if (!visited.has(nodeId)) {
+            const cycle = dfs(nodeId);
+            if (cycle)
+                return cycle;
+        }
+    }
+    return null;
+};
+exports.detectCycle = detectCycle;
+const validateGraph = (graph) => {
+    const cycle = (0, exports.detectCycle)(graph);
+    if (cycle) {
+        return {
+            message: `Circular dependency detected: ${cycle.join(' -> ')}`,
+            cycle,
+        };
+    }
+    return null;
+};
+exports.validateGraph = validateGraph;
+const topologicalSort = (graph) => {
+    const inDegree = new Map();
+    const remaining = new Set();
+    graph.nodes.forEach((node, id) => {
+        inDegree.set(id, node.dependencies.length);
+        remaining.add(id);
+    });
+    const levels = [];
+    let level = 0;
+    while (remaining.size > 0) {
+        const currentLevel = [];
+        remaining.forEach((id) => {
+            if (inDegree.get(id) === 0) {
+                const node = graph.nodes.get(id);
+                if (node) {
+                    currentLevel.push(node.planItem);
+                }
+            }
+        });
+        if (currentLevel.length === 0) {
+            break;
+        }
+        currentLevel.sort((a, b) => getResourceTypeOrder(a.resourceType) - getResourceTypeOrder(b.resourceType));
+        levels.push({ level, items: currentLevel });
+        currentLevel.forEach((item) => {
+            remaining.delete(item.logicalId);
+            const node = graph.nodes.get(item.logicalId);
+            if (node) {
+                node.dependents.forEach((depId) => {
+                    const deg = inDegree.get(depId) ?? 0;
+                    inDegree.set(depId, deg - 1);
+                });
+            }
+        });
+        level++;
+    }
+    return levels;
+};
+exports.topologicalSort = topologicalSort;
+const getExecutionOrder = (items) => {
+    if (items.length === 0)
+        return [];
+    const graph = (0, exports.buildDependencyGraph)(items);
+    const cycleError = (0, exports.validateGraph)(graph);
+    if (cycleError) {
+        throw new Error(cycleError.message);
+    }
+    const levels = (0, exports.topologicalSort)(graph);
+    return levels.flatMap((level) => level.items);
+};
+exports.getExecutionOrder = getExecutionOrder;
+const getParallelExecutionPlan = (items) => {
+    if (items.length === 0)
+        return [];
+    const graph = (0, exports.buildDependencyGraph)(items);
+    const cycleError = (0, exports.validateGraph)(graph);
+    if (cycleError) {
+        throw new Error(cycleError.message);
+    }
+    return (0, exports.topologicalSort)(graph);
+};
+exports.getParallelExecutionPlan = getParallelExecutionPlan;
+const getDependencyInfo = (items) => {
+    const graph = (0, exports.buildDependencyGraph)(items);
+    const cycleError = (0, exports.validateGraph)(graph);
+    if (cycleError) {
+        return {
+            graph,
+            order: [],
+            levels: [],
+            cycleError,
+        };
+    }
+    const levels = (0, exports.topologicalSort)(graph);
+    const order = levels.flatMap((level) => level.items);
+    return {
+        graph,
+        order,
+        levels,
+        cycleError: null,
+    };
+};
+exports.getDependencyInfo = getDependencyInfo;
+const escapeDotString = (str) => str.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n');
+const toDotFormat = (graph) => {
+    const lines = ['digraph DependencyGraph {', '  rankdir=TB;', '  node [shape=box];', ''];
+    graph.nodes.forEach((node) => {
+        const escapedId = escapeDotString(node.id);
+        const escapedLogicalId = escapeDotString(node.planItem.logicalId);
+        const label = `${escapedLogicalId}\\n[${node.planItem.action}]`;
+        const color = node.planItem.action === 'create'
+            ? 'green'
+            : node.planItem.action === 'delete'
+                ? 'red'
+                : node.planItem.action === 'update'
+                    ? 'orange'
+                    : 'gray';
+        lines.push(`  "${escapedId}" [label="${label}", color="${color}"];`);
+    });
+    lines.push('');
+    graph.edges.forEach((edge) => {
+        const escapedFrom = escapeDotString(edge.from);
+        const escapedTo = escapeDotString(edge.to);
+        lines.push(`  "${escapedFrom}" -> "${escapedTo}";`);
+    });
+    lines.push('}');
+    return lines.join('\n');
+};
+exports.toDotFormat = toDotFormat;

package/dist/src/common/dependencyGraph/index.js

@@ -0,0 +1,18 @@
+"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 __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 });
+__exportStar(require("./types"), exports);
+__exportStar(require("./graph"), exports);

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

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

package/dist/src/common/fileUtils.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFile = exports.readFileAsBase64 = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const readFileAsBase64 = (filePath) => {
+    const buffer = node_fs_1.default.readFileSync(filePath);
+    return buffer.toString('base64');
+};
+exports.readFileAsBase64 = readFileAsBase64;
+const readFile = (filePath) => {
+    return node_fs_1.default.readFileSync(filePath);
+};
+exports.readFile = readFile;

package/dist/src/common/hashUtils.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffAttributes = exports.attributesEqual = exports.computeFileHash = void 0;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+/**
+ * Compute SHA-256 hash of a file.
+ * Used for tracking external artifacts like function code zip files.
+ * @param filePath - Path to the file to hash
+ * @returns Hex-encoded SHA-256 hash of the file contents
+ */
+const computeFileHash = (filePath) => {
+    const fileBuffer = node_fs_1.default.readFileSync(filePath);
+    return node_crypto_1.default.createHash('sha256').update(fileBuffer).digest('hex');
+};
+exports.computeFileHash = computeFileHash;
+/**
+ * Deep equality comparison for two values.
+ * Handles primitives, objects, arrays, null, and undefined.
+ * @param a - First value
+ * @param b - Second value
+ * @returns True if values are deeply equal, false otherwise
+ */
+const deepEqual = (a, b) => {
+    // Handle primitives and null/undefined
+    if (a === b) {
+        return true;
+    }
+    // Handle type mismatches
+    if (typeof a !== typeof b) {
+        return false;
+    }
+    // Handle null (typeof null === 'object')
+    if (a === null || b === null) {
+        return false; // One is null, other is not (would have matched above if both null)
+    }
+    // Handle non-objects (primitives that didn't match above)
+    if (typeof a !== 'object') {
+        return false;
+    }
+    // Both are objects/arrays at this point
+    const objA = a;
+    const objB = b;
+    // Handle arrays
+    if (Array.isArray(objA) && Array.isArray(objB)) {
+        if (objA.length !== objB.length) {
+            return false;
+        }
+        for (let i = 0; i < objA.length; i++) {
+            if (!deepEqual(objA[i], objB[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // If one is array and other is not, they're not equal
+    if (Array.isArray(objA) || Array.isArray(objB)) {
+        return false;
+    }
+    // Compare object keys
+    const keysA = Object.keys(objA);
+    const keysB = Object.keys(objB);
+    if (keysA.length !== keysB.length) {
+        return false;
+    }
+    // Check all keys exist in both and have equal values
+    for (const key of keysA) {
+        if (!Object.prototype.hasOwnProperty.call(objB, key)) {
+            return false;
+        }
+        if (!deepEqual(objA[key], objB[key])) {
+            return false;
+        }
+    }
+    return true;
+};
+/**
+ * Compare two ResourceAttributes objects for equality.
+ * Returns true if all keys and values match.
+ * @param a - First attributes object
+ * @param b - Second attributes object
+ * @returns True if objects are equal, false otherwise
+ */
+const attributesEqual = (a, b) => {
+    return deepEqual(a, b);
+};
+exports.attributesEqual = attributesEqual;
+/**
+ * Find differences between two ResourceAttributes objects.
+ * Returns an object with changed keys and their before/after values.
+ * @param before - Previous attributes
+ * @param after - New attributes
+ * @returns Object with changed, added, and removed keys
+ */
+const diffAttributes = (before, after) => {
+    const changed = {};
+    const added = {};
+    const removed = {};
+    const allKeys = new Set([...Object.keys(before), ...Object.keys(after)]);
+    for (const key of allKeys) {
+        const beforeVal = before[key];
+        const afterVal = after[key];
+        if (!(key in before)) {
+            added[key] = afterVal;
+        }
+        else if (!(key in after)) {
+            removed[key] = beforeVal;
+        }
+        else {
+            // Both exist - check if they're different using deep equality
+            if (!deepEqual(beforeVal, afterVal)) {
+                changed[key] = { before: beforeVal, after: afterVal };
+            }
+        }
+    }
+    return { changed, added, removed };
+};
+exports.diffAttributes = diffAttributes;

package/dist/src/common/iacHelper.js

@@ -1,50 +1,15 @@
 "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.splitDomain = exports.formatRosId = exports.getIacDefinition = exports.calcValue = exports.calcRefs = exports.getFileSource = exports.readCodeSize = exports.resolveCode = void 0;
+exports.splitDomain = exports.getIacDefinition = exports.calcValue = 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 lang_1 = require("../lang");
 const resolveCode = (location) => {
     const filePath = node_path_1.default.resolve(process.cwd(), location);
     const fileContent = node_fs_1.default.readFileSync(filePath);
@@ -57,59 +22,33 @@ const readCodeSize = (location) => {
     return stats.size;
 };
 exports.readCodeSize = readCodeSize;
-const getFileSource = (fcName, location) => {
-    const filePath = node_path_1.default.resolve(process.cwd(), location);
-    if (node_fs_1.default.lstatSync(filePath).isDirectory()) {
-        throw new Error('The provided path is a directory, not a file.');
-    }
-    const hash = node_crypto_1.default.createHash('md5').update(node_fs_1.default.readFileSync(filePath)).digest('hex');
-    const objectKey = `${fcName}/${hash}-${filePath.split('/').pop()}`;
-    const source = ossDeployment.Source.asset(filePath, { deployTime: true }, `${fcName}/${hash}-`);
-    return { source, objectKey };
+const getParam = (key, records) => {
+    return records?.find((param) => param.key === key)?.value;
 };
-exports.getFileSource = getFileSource;
-const calcRefs = (rawValue, ctx) => {
-    if (typeof rawValue === 'string') {
-        const containsStage = rawValue.match(/\$\{ctx.\w+}/);
-        const matchVar = rawValue.match(/^\$\{vars\.(\w+)}$/);
-        const containsVar = rawValue.match(/\$\{vars\.(\w+)}/);
-        const matchMap = rawValue.match(/^\$\{stages\.(\w+)}$/);
-        const containsMap = rawValue.match(/\$\{stages\.(\w+)}/);
-        const matchFn = rawValue.match(/^\$\{functions\.(\w+(\.\w+)?)}$/);
-        let value = rawValue;
-        if (containsStage) {
-            value = value.replace(/\$\{ctx.stage}/g, ctx.stage);
-        }
-        if (matchVar?.length) {
-            return ros.Fn.ref(matchVar[1]);
-        }
-        if (matchMap?.length) {
-            return ros.Fn.findInMap('stages', ctx.stage, matchMap[1]);
-        }
-        if (matchFn?.length) {
-            return ros.Fn.getAtt(matchFn[1], 'FunctionName');
-        }
-        if (containsMap?.length || containsVar?.length) {
-            value = ros.Fn.sub(rawValue.replace(/\$\{stages\.(\w+)}/g, '${$1}').replace(/\$\{vars\.(\w+)}/g, '${$1}'));
-        }
+// Attempt to infer the type of the value if it was a template reference
+const inferType = (value, wasTemplateRef) => {
+    if (!wasTemplateRef) {
         return value;
     }
-    if (Array.isArray(rawValue)) {
-        return rawValue.map((item) => (0, exports.calcRefs)(item, ctx));
+    // Try to parse as number
+    if (/^-?\d+(\.\d+)?$/.test(value)) {
+        return Number(value);
     }
-    if (typeof rawValue === 'object' && rawValue !== null) {
-        return Object.fromEntries(Object.entries(rawValue).map(([key, val]) => [key, (0, exports.calcRefs)(val, ctx)]));
+    // Try to parse as boolean
+    if (value === 'true') {
+        return true;
     }
-    return rawValue;
-};
-exports.calcRefs = calcRefs;
-const getParam = (key, records) => {
-    return records?.find((param) => param.key === key)?.value;
+    if (value === 'false') {
+        return false;
+    }
+    return value;
 };
 const calcValue = (rawValue, ctx, iacVars) => {
     const containsStage = rawValue.match(/\$\{ctx.stage}/);
     const containsVar = rawValue.match(/\$\{vars.\w+}/);
     const containsMap = rawValue.match(/\$\{stages\.(\w+)}/);
+    // Check if the entire value is a single template reference (for type inference)
+    const isExactTemplateRef = /^\$\{(vars|stages|ctx)\.[^}]+\}$/.test(rawValue);
     let value = rawValue;
     if (containsStage?.length) {
         value = rawValue.replace(/\$\{ctx.stage}/g, ctx.stage);
@@ -124,7 +63,7 @@ const calcValue = (rawValue, ctx, iacVars) => {
         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`);
+                logger_1.logger.warn(lang_1.lang.__('VARIABLE_NOT_FOUND', { key }));
             }
             return paramValue || '';
         });
@@ -133,12 +72,15 @@ const calcValue = (rawValue, ctx, iacVars) => {
         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`);
+                logger_1.logger.warn(lang_1.lang.__('STAGE_VARIABLE_NOT_FOUND', {
+                    key,
+                    stage: ctx.stage,
+                }));
             }
             return stageValue || '';
         });
     }
-    return value;
+    return inferType(value, isExactTemplateRef);
 };
 exports.calcValue = calcValue;
 const getIacDefinition = (iac, rawValue) => {
@@ -149,20 +91,6 @@ const getIacDefinition = (iac, rawValue) => {
     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');
-    // Convert to lowercase
-    result = result.toLowerCase();
-    // Replace special characters with underscores
-    result = result.replace(/[/*,/#,-]/g, '_');
-    // Remove any number of underscores to single one
-    result = result.replace(/_+/g, '_');
-    // Remove leading underscores
-    result = result.replace(/^_/, '');
-    return result;
-};
-exports.formatRosId = formatRosId;
 const splitDomain = (domain) => {
     const parts = domain.split('.');
     const rr = parts.length > 2 ? parts[0] : '@';

package/dist/src/common/imsClient.js

@@ -36,7 +36,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getIamInfo = void 0;
 const ims20190815_1 = __importStar(require("@alicloud/ims20190815")), ims20190815 = ims20190815_1;
 const openApi = __importStar(require("@alicloud/openapi-client"));
+const providerEnum_1 = require("./providerEnum");
 const getIamInfo = async (context) => {
+    if (context.provider !== providerEnum_1.ProviderEnum.ALIYUN) {
+        return undefined;
+    }
     const imsClient = new ims20190815_1.default(new openApi.Config({
         accessKeyId: context.accessKeyId,
         accessKeySecret: context.accessKeySecret,

package/dist/src/common/index.js

@@ -17,12 +17,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./providerEnum"), exports);
 __exportStar(require("./logger"), exports);
 __exportStar(require("./getVersion"), exports);
-__exportStar(require("./rosClient"), exports);
 __exportStar(require("./context"), exports);
 __exportStar(require("./iacHelper"), exports);
 __exportStar(require("./constants"), exports);
 __exportStar(require("./imsClient"), exports);
 __exportStar(require("./base64"), exports);
-__exportStar(require("./rosAssets"), exports);
 __exportStar(require("./requestHelper"), exports);
 __exportStar(require("./credentials"), exports);
+__exportStar(require("./stateManager"), exports);
+__exportStar(require("./lockManager"), exports);
+__exportStar(require("./scfClient"), exports);
+__exportStar(require("./runtimeMapper"), exports);
+__exportStar(require("./hashUtils"), exports);
+__exportStar(require("./dependencyGraph"), exports);