@geek-fun/serverlessinsight 0.4.0 → 0.5.0

package/dist/src/stack/scfStack/scfResource.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteResource = exports.updateResource = exports.readResource = exports.createResource = void 0;
+const tencentClient_1 = require("../../common/tencentClient");
+const fileUtils_1 = require("../../common/fileUtils");
+const scfTypes_1 = require("./scfTypes");
+const stateManager_1 = require("../../common/stateManager");
+const hashUtils_1 = require("../../common/hashUtils");
+const buildScfInstanceFromProvider = (info, arn) => {
+    const envMap = info.Environment?.Variables?.reduce((acc, v) => ({ ...acc, [v.Key]: v.Value }), {}) ?? {};
+    const triggersArray = info.Triggers?.map((t) => ({
+        modTime: t.ModTime,
+        type: t.Type,
+        triggerDesc: t.TriggerDesc,
+        triggerName: t.TriggerName,
+        addTime: t.AddTime,
+        enable: t.Enable,
+        customArgument: t.CustomArgument ?? null,
+        availableStatus: t.AvailableStatus ?? null,
+        resourceId: t.ResourceId ?? null,
+        bindStatus: t.BindStatus ?? null,
+        triggerAttribute: t.TriggerAttribute ?? null,
+        qualifier: t.Qualifier ?? null,
+        description: t.Description ?? null,
+    }));
+    const tagsArray = info.Tags?.map((t) => ({
+        key: t.Key,
+        value: t.Value,
+    }));
+    const layersArray = info.Layers?.map((l) => ({
+        layerName: l.LayerName ?? null,
+        layerVersion: l.LayerVersion ?? null,
+        compatibleRuntimes: l.CompatibleRuntimes ?? [],
+    }));
+    return {
+        arn,
+        id: info.FunctionName,
+        functionName: info.FunctionName,
+        runtime: info.Runtime,
+        handler: info.Handler,
+        memorySize: info.MemorySize,
+        timeout: info.Timeout,
+        environment: envMap,
+        modTime: info.ModTime ?? null,
+        codeSha256: info.CodeSha256 ?? null,
+        codeInfo: info.CodeInfo ?? null,
+        description: info.Description ?? null,
+        triggers: triggersArray ?? [],
+        codeSize: info.CodeSize ?? null,
+        functionVersion: info.FunctionVersion ?? null,
+        vpcConfig: info.VpcConfig
+            ? {
+                vpcId: info.VpcConfig.VpcId ?? null,
+                subnetId: info.VpcConfig.SubnetId ?? null,
+            }
+            : {},
+        useGpu: info.UseGpu ?? null,
+        codeResult: info.CodeResult ?? null,
+        codeError: info.CodeError ?? null,
+        errNo: info.ErrNo ?? null,
+        namespace: info.Namespace ?? null,
+        role: info.Role ?? null,
+        installDependency: info.InstallDependency ?? null,
+        status: info.Status ?? null,
+        statusDesc: info.StatusDesc ?? null,
+        clsLogsetId: info.ClsLogsetId ?? null,
+        clsTopicId: info.ClsTopicId ?? null,
+        functionId: info.FunctionId ?? null,
+        tags: tagsArray ?? [],
+        eipConfig: info.EipConfig
+            ? {
+                eipFixed: info.EipConfig.EipFixed ?? null,
+                eips: info.EipConfig.Eips ?? [],
+            }
+            : {},
+        accessInfo: info.AccessInfo
+            ? {
+                host: info.AccessInfo.Host ?? null,
+                vip: info.AccessInfo.Vip ?? null,
+            }
+            : {},
+        type: info.Type ?? null,
+        l5Enable: info.L5Enable ?? null,
+        layers: layersArray ?? [],
+        deadLetterConfig: info.DeadLetterConfig
+            ? {
+                type: info.DeadLetterConfig.Type ?? null,
+                name: info.DeadLetterConfig.Name ?? null,
+                filterType: info.DeadLetterConfig.FilterType ?? null,
+            }
+            : {},
+        addTime: info.AddTime ?? null,
+        publicNetConfig: info.PublicNetConfig
+            ? {
+                publicNetStatus: info.PublicNetConfig.PublicNetStatus ?? null,
+                eipConfig: info.PublicNetConfig.EipConfig
+                    ? {
+                        eipStatus: info.PublicNetConfig.EipConfig.EipStatus ?? null,
+                        eipAddress: info.PublicNetConfig.EipConfig.EipAddress ?? [],
+                    }
+                    : {},
+            }
+            : {},
+        onsEnable: info.OnsEnable ?? null,
+        cfsConfig: info.CfsConfig
+            ? {
+                cfsInsList: info.CfsConfig.CfsInsList?.map((c) => ({
+                    userId: c.UserId ?? null,
+                    userGroupId: c.UserGroupId ?? null,
+                    cfsId: c.CfsId ?? null,
+                    mountInsId: c.MountInsId ?? null,
+                    localMountDir: c.LocalMountDir ?? null,
+                    remoteMountDir: c.RemoteMountDir ?? null,
+                    ipAddress: c.IpAddress ?? null,
+                    mountVpcId: c.MountVpcId ?? null,
+                    mountSubnetId: c.MountSubnetId ?? null,
+                })) ?? [],
+            }
+            : {},
+        availableStatus: info.AvailableStatus ?? null,
+        qualifier: info.Qualifier ?? null,
+        initTimeout: info.InitTimeout ?? null,
+        statusReasons: info.StatusReasons?.map((s) => ({
+            errorCode: s.ErrorCode ?? null,
+            errorMessage: s.ErrorMessage ?? null,
+        })) ?? [],
+        asyncRunEnable: info.AsyncRunEnable ?? null,
+        traceEnable: info.TraceEnable ?? null,
+        imageConfig: info.ImageConfig
+            ? {
+                imageType: info.ImageConfig.ImageType ?? null,
+                imageUri: info.ImageConfig.ImageUri ?? null,
+            }
+            : {},
+        protocolType: info.ProtocolType ?? null,
+        protocolParams: info.ProtocolParams
+            ? {
+                wsParams: info.ProtocolParams.WSParams
+                    ? {
+                        idleTimeOut: info.ProtocolParams.WSParams.IdleTimeOut ?? null,
+                    }
+                    : {},
+            }
+            : {},
+        dnsCache: info.DnsCache ?? null,
+        intranetConfig: info.IntranetConfig
+            ? {
+                ipFixed: info.IntranetConfig.IpFixed ?? null,
+            }
+            : {},
+    };
+};
+const createResource = async (context, fn, state) => {
+    const config = (0, scfTypes_1.functionToScfConfig)(fn);
+    const codePath = fn.code.path;
+    const codeBase64 = (0, fileUtils_1.readFileAsBase64)(codePath);
+    const client = (0, tencentClient_1.createTencentClient)(context);
+    await client.scf.createFunction(config, codeBase64);
+    // Refresh state from provider to get all attributes
+    const functionInfo = await client.scf.getFunction(fn.name);
+    if (!functionInfo) {
+        throw new Error(`Failed to refresh state for function: ${fn.name}`);
+    }
+    const codeHash = (0, hashUtils_1.computeFileHash)(codePath);
+    const definition = (0, scfTypes_1.extractScfDefinition)(config, codeHash);
+    const arn = `arn:tencent:scf:${context.region}::function:${fn.name}`;
+    const resourceState = {
+        mode: 'managed',
+        region: context.region,
+        definition,
+        instances: [buildScfInstanceFromProvider(functionInfo, arn)],
+        lastUpdated: new Date().toISOString(),
+    };
+    const logicalId = `functions.${fn.key}`;
+    return (0, stateManager_1.setResource)(state, logicalId, resourceState);
+};
+exports.createResource = createResource;
+const readResource = async (context, functionName) => {
+    const client = (0, tencentClient_1.createTencentClient)(context);
+    return await client.scf.getFunction(functionName);
+};
+exports.readResource = readResource;
+const updateResource = async (context, fn, state) => {
+    const config = (0, scfTypes_1.functionToScfConfig)(fn);
+    const codePath = fn.code.path;
+    const client = (0, tencentClient_1.createTencentClient)(context);
+    // Update configuration
+    await client.scf.updateFunctionConfiguration(config);
+    // Update code
+    const codeBase64 = (0, fileUtils_1.readFileAsBase64)(codePath);
+    await client.scf.updateFunctionCode(fn.name, codeBase64);
+    // Refresh state from provider to get all attributes
+    const functionInfo = await client.scf.getFunction(fn.name);
+    if (!functionInfo) {
+        throw new Error(`Failed to refresh state for function: ${fn.name}`);
+    }
+    const codeHash = (0, hashUtils_1.computeFileHash)(codePath);
+    const definition = (0, scfTypes_1.extractScfDefinition)(config, codeHash);
+    const arn = `arn:tencent:scf:${context.region}::function:${fn.name}`;
+    const resourceState = {
+        mode: 'managed',
+        region: context.region,
+        definition,
+        instances: [buildScfInstanceFromProvider(functionInfo, arn)],
+        lastUpdated: new Date().toISOString(),
+    };
+    const logicalId = `functions.${fn.key}`;
+    return (0, stateManager_1.setResource)(state, logicalId, resourceState);
+};
+exports.updateResource = updateResource;
+const deleteResource = async (context, functionName, logicalId, state) => {
+    const client = (0, tencentClient_1.createTencentClient)(context);
+    await client.scf.deleteFunction(functionName);
+    return (0, stateManager_1.removeResource)(state, logicalId);
+};
+exports.deleteResource = deleteResource;

package/dist/src/stack/scfStack/scfTypes.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractFunctionDomainDefinition = exports.extractScfDefinition = exports.functionToScfConfig = void 0;
+const common_1 = require("../../common");
+const functionToScfConfig = (fn) => {
+    const config = {
+        FunctionName: fn.name,
+        Runtime: (0, common_1.mapRuntime)(fn.code.runtime, common_1.ProviderEnum.TENCENT),
+        Handler: fn.code.handler,
+        MemorySize: fn.memory ?? 128,
+        Timeout: fn.timeout ?? 3,
+    };
+    if (fn.environment && Object.keys(fn.environment).length > 0) {
+        config.Environment = {
+            Variables: Object.entries(fn.environment).map(([key, value]) => ({
+                Key: key,
+                Value: value,
+            })),
+        };
+    }
+    return config;
+};
+exports.functionToScfConfig = functionToScfConfig;
+const extractScfDefinition = (config, codeHash) => {
+    const envMap = config.Environment?.Variables?.reduce((acc, v) => ({ ...acc, [v.Key]: v.Value }), {}) ?? {};
+    return {
+        functionName: config.FunctionName,
+        runtime: config.Runtime,
+        handler: config.Handler,
+        memorySize: config.MemorySize,
+        timeout: config.Timeout,
+        environment: envMap,
+        codeHash,
+    };
+};
+exports.extractScfDefinition = extractScfDefinition;
+const extractFunctionDomainDefinition = (fn, codeHash) => {
+    const config = (0, exports.functionToScfConfig)(fn);
+    return (0, exports.extractScfDefinition)(config, codeHash);
+};
+exports.extractFunctionDomainDefinition = extractFunctionDomainDefinition;

package/dist/src/stack/scfStack/tdsqlcExecutor.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeDatabasePlan = void 0;
+const tdsqlcResource_1 = require("./tdsqlcResource");
+const common_1 = require("../../common");
+const stateManager_1 = require("../../common/stateManager");
+const lang_1 = require("../../lang");
+const executeCreateAction = async (context, database, currentState) => {
+    common_1.logger.info(`Creating TDSQL-C database: ${database.name}`);
+    const newState = await (0, tdsqlcResource_1.createDatabaseResource)(context, database, currentState);
+    common_1.logger.info(`Successfully created TDSQL-C database: ${database.name}`);
+    return newState;
+};
+const executeUpdateAction = async (context, database, clusterId, currentState) => {
+    common_1.logger.info(`Updating TDSQL-C database: ${database.name}`);
+    const newState = await (0, tdsqlcResource_1.updateDatabaseResource)(context, database, clusterId, currentState);
+    common_1.logger.info(`Successfully updated TDSQL-C database: ${database.name}`);
+    return newState;
+};
+const executeDeleteAction = async (context, clusterId, logicalId, currentState) => {
+    common_1.logger.info(`Deleting TDSQL-C database: ${clusterId}`);
+    const newState = await (0, tdsqlcResource_1.deleteDatabaseResource)(context, clusterId, logicalId, currentState);
+    common_1.logger.info(`Successfully deleted TDSQL-C database: ${clusterId}`);
+    return newState;
+};
+const executeSingleItem = async (context, item, databasesMap, currentState) => {
+    if (item.resourceType !== 'TDSQL_C_SERVERLESS') {
+        return null;
+    }
+    switch (item.action) {
+        case 'noop':
+            common_1.logger.info(`No changes for ${item.logicalId}`);
+            return null;
+        case 'create': {
+            const database = databasesMap.get(item.logicalId);
+            if (!database) {
+                throw new Error(`Database not found for logical ID: ${item.logicalId}`);
+            }
+            return executeCreateAction(context, database, currentState);
+        }
+        case 'update': {
+            const database = databasesMap.get(item.logicalId);
+            if (!database) {
+                throw new Error(`Database not found for logical ID: ${item.logicalId}`);
+            }
+            const state = (0, stateManager_1.getResource)(currentState, item.logicalId);
+            if (!state) {
+                throw new Error(`State not found for ${item.logicalId}`);
+            }
+            const clusterId = state.metadata?.clusterId || state.instances?.[0]?.id;
+            if (!clusterId) {
+                throw new Error(`Cluster ID not found in state for ${item.logicalId}`);
+            }
+            return executeUpdateAction(context, database, clusterId, 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 clusterId = state.metadata?.clusterId || state.instances?.[0]?.id;
+            if (!clusterId) {
+                throw new Error(`Cluster ID not found in state for ${item.logicalId}`);
+            }
+            return executeDeleteAction(context, clusterId, item.logicalId, currentState);
+        }
+        default:
+            common_1.logger.warn(`Unknown action: ${item.action} for ${item.logicalId}`);
+            return null;
+    }
+};
+const executeDatabasePlan = async (context, plan, databases, initialState, onStateChange) => {
+    const databasesMap = new Map(databases?.map((database) => [`databases.${database.key}`, database]) ?? []);
+    const successfulItems = [];
+    let currentState = initialState;
+    for (const item of plan.items) {
+        try {
+            const newState = await executeSingleItem(context, item, databasesMap, 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.executeDatabasePlan = executeDatabasePlan;

package/dist/src/stack/scfStack/tdsqlcPlanner.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDatabasePlan = void 0;
+const tencentClient_1 = require("../../common/tencentClient");
+const tdsqlcTypes_1 = require("./tdsqlcTypes");
+const stateManager_1 = require("../../common/stateManager");
+const hashUtils_1 = require("../../common/hashUtils");
+const planDatabaseDeletion = (logicalId, definition) => ({
+    logicalId,
+    action: 'delete',
+    resourceType: 'TDSQL_C_SERVERLESS',
+    changes: { before: definition },
+});
+const generateDatabasePlan = async (context, state, databases) => {
+    const tdsqlcDatabases = databases?.filter((db) => db.type === "TDSQL_C_SERVERLESS" /* DatabaseEnum.TDSQL_C_SERVERLESS */);
+    if (!tdsqlcDatabases || tdsqlcDatabases.length === 0) {
+        const allStates = (0, stateManager_1.getAllResources)(state);
+        const items = Object.entries(allStates)
+            .filter(([logicalId, resourceState]) => {
+            if (!logicalId.startsWith('databases.'))
+                return false;
+            const resourceType = resourceState.metadata?.resourceType;
+            // Only plan deletion for TDSQL-C resources (or legacy resources without resourceType
+            // that have clusterId metadata, indicating they are TDSQL-C)
+            return !resourceType || resourceType === 'TDSQL_C_SERVERLESS';
+        })
+            .map(([logicalId, resourceState]) => planDatabaseDeletion(logicalId, resourceState.definition));
+        return { items };
+    }
+    const desiredLogicalIds = new Set(tdsqlcDatabases.map((db) => `databases.${db.key}`));
+    const databaseItems = await Promise.all(tdsqlcDatabases.map(async (database) => {
+        const logicalId = `databases.${database.key}`;
+        const currentState = (0, stateManager_1.getResource)(state, logicalId);
+        const config = (0, tdsqlcTypes_1.databaseToTdsqlcConfig)(database);
+        const desiredDefinition = (0, tdsqlcTypes_1.extractTdsqlcDefinition)(config);
+        if (!currentState) {
+            return {
+                logicalId,
+                action: 'create',
+                resourceType: 'TDSQL_C_SERVERLESS',
+                changes: { after: desiredDefinition },
+            };
+        }
+        const clusterId = currentState.metadata?.clusterId || currentState.instances?.[0]?.id;
+        try {
+            const client = (0, tencentClient_1.createTencentClient)(context);
+            const remoteCluster = clusterId ? await client.tdsqlc.getCluster(clusterId) : null;
+            if (!remoteCluster) {
+                return {
+                    logicalId,
+                    action: 'create',
+                    resourceType: 'TDSQL_C_SERVERLESS',
+                    changes: { before: currentState.definition, after: desiredDefinition },
+                    drifted: true,
+                };
+            }
+            const currentDefinition = currentState.definition || {};
+            const definitionChanged = !(0, hashUtils_1.attributesEqual)(currentDefinition, desiredDefinition);
+            if (definitionChanged) {
+                return {
+                    logicalId,
+                    action: 'update',
+                    resourceType: 'TDSQL_C_SERVERLESS',
+                    changes: { before: currentDefinition, after: desiredDefinition },
+                    drifted: true,
+                };
+            }
+            return { logicalId, action: 'noop', resourceType: 'TDSQL_C_SERVERLESS' };
+        }
+        catch {
+            return {
+                logicalId,
+                action: 'create',
+                resourceType: 'TDSQL_C_SERVERLESS',
+                changes: { before: currentState.definition, after: desiredDefinition },
+            };
+        }
+    }));
+    const allStates = (0, stateManager_1.getAllResources)(state);
+    const deletionItems = Object.entries(allStates)
+        .filter(([logicalId, resourceState]) => {
+        if (!logicalId.startsWith('databases.') || desiredLogicalIds.has(logicalId))
+            return false;
+        const resourceType = resourceState.metadata?.resourceType;
+        return !resourceType || resourceType === 'TDSQL_C_SERVERLESS';
+    })
+        .map(([logicalId, resourceState]) => planDatabaseDeletion(logicalId, resourceState.definition));
+    return { items: [...databaseItems, ...deletionItems] };
+};
+exports.generateDatabasePlan = generateDatabasePlan;

package/dist/src/stack/scfStack/tdsqlcResource.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteDatabaseResource = exports.updateDatabaseResource = exports.readDatabaseResource = exports.createDatabaseResource = void 0;
+const tencentClient_1 = require("../../common/tencentClient");
+const tdsqlcTypes_1 = require("./tdsqlcTypes");
+const stateManager_1 = require("../../common/stateManager");
+const buildTdsqlcInstanceFromProvider = (info, arn) => {
+    return {
+        arn,
+        id: info.ClusterId,
+        clusterId: info.ClusterId,
+        clusterName: info.ClusterName,
+        region: info.Region,
+        zone: info.Zone ?? null,
+        physicalZone: info.PhysicalZone ?? null,
+        dbType: info.DbType,
+        dbVersion: info.DbVersion,
+        dbMode: info.DbMode ?? null,
+        status: info.Status,
+        statusDesc: info.StatusDesc ?? null,
+        serverlessStatus: info.ServerlessStatus ?? null,
+        vpcId: info.VpcId ?? null,
+        vpcName: info.VpcName ?? null,
+        subnetId: info.SubnetId ?? null,
+        subnetName: info.SubnetName ?? null,
+        charset: info.Charset ?? null,
+        vip: info.Vip ?? null,
+        vport: info.Vport ?? null,
+        wanDomain: info.WanDomain ?? null,
+        wanIP: info.WanIP ?? null,
+        wanPort: info.WanPort ?? null,
+        wanStatus: info.WanStatus ?? null,
+        minCpu: info.MinCpu ?? null,
+        maxCpu: info.MaxCpu ?? null,
+        minStorageSize: info.MinStorageSize ?? null,
+        maxStorageSize: info.MaxStorageSize ?? null,
+        storageId: info.StorageId ?? null,
+        storage: info.Storage ?? null,
+        storageLimit: info.StorageLimit ?? null,
+        storagePayMode: info.StoragePayMode ?? null,
+        autoPause: info.AutoPause ?? null,
+        autoPauseDelay: info.AutoPauseDelay ?? null,
+        createTime: info.CreateTime ?? null,
+        updateTime: info.UpdateTime ?? null,
+        projectId: info.ProjectId ?? null,
+        payMode: info.PayMode ?? null,
+        periodEndTime: info.PeriodEndTime ?? null,
+        autoRenewFlag: info.AutoRenewFlag ?? null,
+        instanceCount: info.InstanceCount ?? null,
+        processingTask: info.ProcessingTask ?? null,
+        supportedFeatures: info.SupportedFeatures ?? [],
+        rollbackSupport: info.RollbackSupport ?? null,
+        networkType: info.NetworkType ?? null,
+        resourcePackageId: info.ResourcePackageId ?? null,
+        resourcePackageType: info.ResourcePackageType ?? null,
+        resourcePackageState: info.ResourcePackageState ?? null,
+        physicalRegion: info.PhysicalRegion ?? null,
+        proxyStatus: info.ProxyStatus ?? null,
+        rwGroupId: info.RwGroupId ?? null,
+        masterZone: info.MasterZone ?? null,
+        slaveZones: info.SlaveZones ?? [],
+        businessType: info.BusinessType ?? null,
+        isFreeze: info.IsFreeze ?? null,
+        orderSource: info.OrderSource ?? null,
+        ability: info.Ability
+            ? {
+                isSupportSlaveZone: info.Ability.IsSupportSlaveZone ?? null,
+                nonsupportSlaveZoneReason: info.Ability.NonsupportSlaveZoneReason ?? null,
+                isSupportRo: info.Ability.IsSupportRo ?? null,
+                nonsupportRoReason: info.Ability.NonsupportRoReason ?? null,
+            }
+            : {},
+        resourceTags: info.ResourceTags?.map((t) => ({
+            tagKey: t.TagKey ?? null,
+            tagValue: t.TagValue ?? null,
+        })) ?? [],
+        cynosVersion: info.CynosVersion ?? null,
+        cynosVersionStatus: info.CynosVersionStatus ?? null,
+        isLatestVersion: info.IsLatestVersion ?? null,
+    };
+};
+const createDatabaseResource = async (context, database, state) => {
+    const config = (0, tdsqlcTypes_1.databaseToTdsqlcConfig)(database);
+    const client = (0, tencentClient_1.createTencentClient)(context);
+    const clusterId = await client.tdsqlc.createCluster(config);
+    // Refresh state from provider to get all attributes
+    const clusterInfo = await client.tdsqlc.getCluster(clusterId);
+    if (!clusterInfo) {
+        throw new Error(`Failed to refresh state for cluster: ${clusterId}`);
+    }
+    const definition = (0, tdsqlcTypes_1.extractTdsqlcDefinition)(config);
+    const arn = `arn:tencent:cynosdb:${context.region}::cluster:${clusterId}`;
+    const resourceState = {
+        mode: 'managed',
+        region: context.region,
+        definition,
+        instances: [buildTdsqlcInstanceFromProvider(clusterInfo, arn)],
+        lastUpdated: new Date().toISOString(),
+        metadata: {
+            clusterName: database.name,
+            clusterId,
+            resourceType: 'TDSQL_C_SERVERLESS',
+        },
+    };
+    const logicalId = `databases.${database.key}`;
+    return (0, stateManager_1.setResource)(state, logicalId, resourceState);
+};
+exports.createDatabaseResource = createDatabaseResource;
+const readDatabaseResource = async (context, clusterId) => {
+    const client = (0, tencentClient_1.createTencentClient)(context);
+    return await client.tdsqlc.getCluster(clusterId);
+};
+exports.readDatabaseResource = readDatabaseResource;
+const updateDatabaseResource = async (context, database, clusterId, state) => {
+    const config = (0, tdsqlcTypes_1.databaseToTdsqlcConfig)(database);
+    const client = (0, tencentClient_1.createTencentClient)(context);
+    await client.tdsqlc.updateCluster(clusterId, config);
+    // Refresh state from provider to get all attributes
+    const clusterInfo = await client.tdsqlc.getCluster(clusterId);
+    if (!clusterInfo) {
+        throw new Error(`Failed to refresh state for cluster: ${clusterId}`);
+    }
+    const definition = (0, tdsqlcTypes_1.extractTdsqlcDefinition)(config);
+    const arn = `arn:tencent:cynosdb:${context.region}::cluster:${clusterId}`;
+    const resourceState = {
+        mode: 'managed',
+        region: context.region,
+        definition,
+        instances: [buildTdsqlcInstanceFromProvider(clusterInfo, arn)],
+        lastUpdated: new Date().toISOString(),
+        metadata: {
+            clusterName: database.name,
+            clusterId,
+            resourceType: 'TDSQL_C_SERVERLESS',
+        },
+    };
+    const logicalId = `databases.${database.key}`;
+    return (0, stateManager_1.setResource)(state, logicalId, resourceState);
+};
+exports.updateDatabaseResource = updateDatabaseResource;
+const deleteDatabaseResource = async (context, clusterId, logicalId, state) => {
+    const client = (0, tencentClient_1.createTencentClient)(context);
+    await client.tdsqlc.deleteCluster(clusterId);
+    return (0, stateManager_1.removeResource)(state, logicalId);
+};
+exports.deleteDatabaseResource = deleteDatabaseResource;

package/dist/src/stack/scfStack/tdsqlcTypes.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTdsqlcDefinition = exports.databaseToTdsqlcConfig = void 0;
+const databaseToTdsqlcConfig = (database) => {
+    // Map version from enum to Tencent Cloud version format
+    const versionMap = {
+        'MYSQL_5.7': '5.7',
+        'MYSQL_8.0': '8.0',
+    };
+    const dbVersion = versionMap[database.version] || '8.0';
+    const config = {
+        ClusterName: database.name,
+        DbType: 'MYSQL',
+        DbVersion: dbVersion,
+        DbMode: 'SERVERLESS',
+        MinCpu: database.cu.min,
+        MaxCpu: database.cu.max,
+        AutoPause: database.cu.min === 0,
+        AutoPauseDelay: 600, // Default 10 minutes
+        StoragePayMode: 0, // Pay-per-use
+        AdminPassword: database.security.basicAuth.password,
+    };
+    // Add VPC configuration if provided
+    if (database.network.vpcId) {
+        config.VpcId = database.network.vpcId;
+    }
+    if (database.network.subnetId) {
+        config.SubnetId = database.network.subnetId;
+    }
+    // Add storage configuration if provided
+    if (database.storage.min !== undefined) {
+        config.MinStorageSize = database.storage.min;
+    }
+    if (database.storage.max !== undefined) {
+        config.MaxStorageSize = database.storage.max;
+    }
+    return config;
+};
+exports.databaseToTdsqlcConfig = databaseToTdsqlcConfig;
+const extractTdsqlcDefinition = (config) => {
+    return {
+        clusterName: config.ClusterName,
+        dbType: config.DbType,
+        dbVersion: config.DbVersion,
+        dbMode: config.DbMode,
+        minCpu: config.MinCpu,
+        maxCpu: config.MaxCpu,
+        autoPause: config.AutoPause ?? null,
+        autoPauseDelay: config.AutoPauseDelay ?? null,
+        storagePayMode: config.StoragePayMode ?? null,
+        vpcId: config.VpcId ?? null,
+        subnetId: config.SubnetId ?? null,
+        port: config.Port ?? null,
+        projectId: config.ProjectId ?? null,
+        minStorageSize: config.MinStorageSize ?? null,
+        maxStorageSize: config.MaxStorageSize ?? null,
+    };
+};
+exports.extractTdsqlcDefinition = extractTdsqlcDefinition;

package/dist/src/types/domains/lock.js

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

package/dist/src/types/domains/resolvable.js

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