@geek-fun/serverlessinsight 0.4.0 → 0.5.0

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

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeBucketPlan = void 0;
+const ossResource_1 = require("./ossResource");
+const common_1 = require("../../common");
+const stateManager_1 = require("../../common/stateManager");
+const lang_1 = require("../../lang");
+const executeCreateAction = async (context, bucket, currentState) => {
+    common_1.logger.info(`Creating bucket: ${bucket.name}`);
+    const newState = await (0, ossResource_1.createBucketResource)(context, bucket, currentState);
+    common_1.logger.info(`Successfully created bucket: ${bucket.name}`);
+    return newState;
+};
+const executeUpdateAction = async (context, bucket, currentState) => {
+    common_1.logger.info(`Updating bucket: ${bucket.name}`);
+    const newState = await (0, ossResource_1.updateBucketResource)(context, bucket, currentState);
+    common_1.logger.info(`Successfully updated bucket: ${bucket.name}`);
+    return newState;
+};
+const executeDeleteAction = async (context, bucketName, logicalId, currentState) => {
+    common_1.logger.info(`Deleting bucket: ${bucketName}`);
+    const newState = await (0, ossResource_1.deleteBucketResource)(context, bucketName, logicalId, currentState);
+    common_1.logger.info(`Successfully deleted bucket: ${bucketName}`);
+    return newState;
+};
+const executeSingleItem = async (context, item, bucketsMap, currentState) => {
+    switch (item.action) {
+        case 'noop':
+            common_1.logger.info(`No changes for ${item.logicalId}`);
+            return null;
+        case 'create': {
+            const bucket = bucketsMap.get(item.logicalId);
+            if (!bucket) {
+                throw new Error(`Bucket not found for logical ID: ${item.logicalId}`);
+            }
+            return executeCreateAction(context, bucket, currentState);
+        }
+        case 'update': {
+            const bucket = bucketsMap.get(item.logicalId);
+            if (!bucket) {
+                throw new Error(`Bucket not found for logical ID: ${item.logicalId}`);
+            }
+            return executeUpdateAction(context, bucket, 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 bucketName = state.definition.bucketName;
+            return executeDeleteAction(context, bucketName, item.logicalId, currentState);
+        }
+        default:
+            common_1.logger.warn(`Unknown action: ${item.action} for ${item.logicalId}`);
+            return null;
+    }
+};
+const executeBucketPlan = async (context, plan, buckets, initialState, onStateChange) => {
+    const bucketsMap = new Map(buckets?.map((bucket) => [`buckets.${bucket.key}`, bucket]) ?? []);
+    const successfulItems = [];
+    let currentState = initialState;
+    for (const item of plan.items) {
+        try {
+            const newState = await executeSingleItem(context, item, bucketsMap, 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.executeBucketPlan = executeBucketPlan;

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateBucketPlan = void 0;
+const aliyunClient_1 = require("../../common/aliyunClient");
+const ossTypes_1 = require("./ossTypes");
+const stateManager_1 = require("../../common/stateManager");
+const hashUtils_1 = require("../../common/hashUtils");
+const planBucketDeletion = (logicalId, definition) => ({
+    logicalId,
+    action: 'delete',
+    resourceType: 'ALIYUN_OSS_BUCKET',
+    changes: { before: definition },
+});
+const generateBucketPlan = async (context, state, buckets) => {
+    if (!buckets || buckets.length === 0) {
+        const allStates = (0, stateManager_1.getAllResources)(state);
+        const items = Object.entries(allStates)
+            .filter(([logicalId]) => logicalId.startsWith('buckets.'))
+            .map(([logicalId, resourceState]) => planBucketDeletion(logicalId, resourceState.definition));
+        return { items };
+    }
+    const desiredLogicalIds = new Set(buckets.map((bucket) => `buckets.${bucket.key}`));
+    const bucketItems = await Promise.all(buckets.map(async (bucket) => {
+        const logicalId = `buckets.${bucket.key}`;
+        const currentState = (0, stateManager_1.getResource)(state, logicalId);
+        const config = (0, ossTypes_1.bucketToOssBucketConfig)(bucket);
+        const desiredDefinition = (0, ossTypes_1.extractOssBucketDefinition)(config);
+        if (!currentState) {
+            return {
+                logicalId,
+                action: 'create',
+                resourceType: 'ALIYUN_OSS_BUCKET',
+                changes: { after: desiredDefinition },
+            };
+        }
+        try {
+            const client = (0, aliyunClient_1.createAliyunClient)(context);
+            const remoteBucket = await client.oss.getBucket(bucket.name);
+            if (!remoteBucket) {
+                return {
+                    logicalId,
+                    action: 'create',
+                    resourceType: 'ALIYUN_OSS_BUCKET',
+                    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: 'ALIYUN_OSS_BUCKET',
+                    changes: { before: currentDefinition, after: desiredDefinition },
+                    drifted: true,
+                };
+            }
+            return { logicalId, action: 'noop', resourceType: 'ALIYUN_OSS_BUCKET' };
+        }
+        catch {
+            return {
+                logicalId,
+                action: 'create',
+                resourceType: 'ALIYUN_OSS_BUCKET',
+                changes: { before: currentState.definition, after: desiredDefinition },
+            };
+        }
+    }));
+    const allStates = (0, stateManager_1.getAllResources)(state);
+    const deletionItems = Object.entries(allStates)
+        .filter(([logicalId]) => logicalId.startsWith('buckets.') && !desiredLogicalIds.has(logicalId))
+        .map(([logicalId, resourceState]) => planBucketDeletion(logicalId, resourceState.definition));
+    return { items: [...bucketItems, ...deletionItems] };
+};
+exports.generateBucketPlan = generateBucketPlan;

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

@@ -0,0 +1,196 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteBucketResource = exports.updateBucketResource = exports.readBucketResource = exports.createBucketResource = void 0;
+const aliyunClient_1 = require("../../common/aliyunClient");
+const common_1 = require("../../common");
+const ossTypes_1 = require("./ossTypes");
+const logger_1 = require("../../common/logger");
+const lang_1 = require("../../lang");
+const node_path_1 = __importDefault(require("node:path"));
+const buildOssInstanceFromProvider = (info, arn) => {
+    return {
+        type: 'ALIYUN_OSS_BUCKET',
+        arn,
+        id: info.name,
+        bucketName: info.name,
+        location: info.location ?? null,
+        creationDate: info.creationDate ?? null,
+        storageClass: info.storageClass ?? null,
+        dataRedundancyType: info.dataRedundancyType ?? null,
+        resourceGroupId: info.resourceGroupId ?? null,
+        comment: info.comment ?? null,
+        owner: info.owner
+            ? {
+                id: info.owner.id ?? null,
+                displayName: info.owner.displayName ?? null,
+            }
+            : undefined,
+        blockPublicAccess: info.blockPublicAccess ?? null,
+        accessMonitorStatus: info.accessMonitorStatus ?? null,
+        acl: info.acl ?? null,
+        websiteConfig: info.websiteConfig
+            ? {
+                indexDocument: info.websiteConfig.indexDocument ?? null,
+                errorDocument: info.websiteConfig.errorDocument ?? null,
+            }
+            : undefined,
+        loggingConfig: info.loggingConfig
+            ? {
+                targetBucket: info.loggingConfig.targetBucket ?? null,
+                targetPrefix: info.loggingConfig.targetPrefix ?? null,
+            }
+            : undefined,
+        corsRules: info.corsRules?.map((rule) => ({
+            id: rule.id ?? null,
+            allowedOrigins: rule.allowedOrigins ?? [],
+            allowedMethods: rule.allowedMethods ?? [],
+            allowedHeaders: rule.allowedHeaders ?? [],
+            exposeHeaders: rule.exposeHeaders ?? [],
+            maxAgeSeconds: rule.maxAgeSeconds ?? null,
+        })),
+        lifecycleRules: info.lifecycleRules?.map((rule) => ({
+            id: rule.id ?? null,
+            status: rule.status ?? null,
+            prefix: rule.prefix ?? null,
+            expiration: rule.expiration
+                ? {
+                    days: rule.expiration.days ?? null,
+                    date: rule.expiration.date ?? null,
+                    expiredObjectDeleteMarker: rule.expiration.expiredObjectDeleteMarker ?? null,
+                }
+                : undefined,
+            transition: rule.transition
+                ? {
+                    days: rule.transition.days ?? null,
+                    date: rule.transition.date ?? null,
+                    storageClass: rule.transition.storageClass ?? null,
+                }
+                : undefined,
+        })),
+        versioningStatus: info.versioningConfig?.status ?? null,
+        encryptionConfig: info.encryptionConfig
+            ? {
+                sseAlgorithm: info.encryptionConfig.sseAlgorithm ?? null,
+                kmsMasterKeyId: info.encryptionConfig.kmsMasterKeyId ?? null,
+                kmsDataEncryption: info.encryptionConfig.kmsDataEncryption ?? null,
+            }
+            : undefined,
+        transferAccelerationStatus: info.transferAccelerationStatus ?? null,
+        replicationRules: info.replicationRules?.map((rule) => ({
+            id: rule.id ?? null,
+            status: rule.status ?? null,
+            prefix: rule.prefix ?? null,
+            destination: rule.destination
+                ? {
+                    bucket: rule.destination.bucket ?? null,
+                    storageClass: rule.destination.storageClass ?? null,
+                }
+                : undefined,
+        })),
+        tags: info.tags?.map((tag) => ({
+            key: tag.key ?? null,
+            value: tag.value ?? null,
+        })),
+    };
+};
+const createBucketResource = async (context, bucket, state) => {
+    const config = (0, ossTypes_1.bucketToOssBucketConfig)(bucket);
+    const client = (0, aliyunClient_1.createAliyunClient)(context);
+    await client.oss.createBucket({
+        bucketName: config.bucketName,
+        acl: config.acl,
+        websiteConfig: config.websiteConfig,
+        storageClass: config.storageClass,
+    });
+    // Refresh state from provider to get bucket info
+    let bucketInfo = await client.oss.getBucket(config.bucketName);
+    if (!bucketInfo) {
+        throw new Error(`Failed to refresh state for bucket: ${config.bucketName}`);
+    }
+    const definition = (0, ossTypes_1.extractOssBucketDefinition)(config);
+    const arn = `arn:acs:oss:${context.region}:${context.accountId}:${config.bucketName}`;
+    const logicalId = `buckets.${bucket.key}`;
+    // Save state immediately after bucket creation, before file upload
+    const partialResourceState = {
+        mode: 'managed',
+        region: context.region,
+        definition,
+        instances: [buildOssInstanceFromProvider(bucketInfo, arn)],
+        lastUpdated: new Date().toISOString(),
+    };
+    state = (0, common_1.setResource)(state, logicalId, partialResourceState);
+    // Upload static files if code path is specified
+    if (bucket.website?.code) {
+        try {
+            const codePath = node_path_1.default.resolve(process.cwd(), bucket.website.code);
+            await client.oss.uploadFiles(config.bucketName, codePath);
+            // Refresh state after upload to get updated info
+            bucketInfo = await client.oss.getBucket(config.bucketName);
+            if (bucketInfo) {
+                const updatedResourceState = {
+                    mode: 'managed',
+                    region: context.region,
+                    definition,
+                    instances: [buildOssInstanceFromProvider(bucketInfo, arn)],
+                    lastUpdated: new Date().toISOString(),
+                };
+                return (0, common_1.setResource)(state, logicalId, updatedResourceState);
+            }
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to upload files to bucket, but bucket was created and saved to state: ${error}`);
+            logger_1.logger.info(lang_1.lang.__('OSS_BUCKET_TRACKED_CAN_RETRY'));
+            return state;
+        }
+    }
+    return state;
+};
+exports.createBucketResource = createBucketResource;
+const readBucketResource = async (context, bucketName) => {
+    const client = (0, aliyunClient_1.createAliyunClient)(context);
+    return await client.oss.getBucket(bucketName);
+};
+exports.readBucketResource = readBucketResource;
+const updateBucketResource = async (context, bucket, state) => {
+    const config = (0, ossTypes_1.bucketToOssBucketConfig)(bucket);
+    const client = (0, aliyunClient_1.createAliyunClient)(context);
+    // Update ACL if specified
+    if (config.acl) {
+        await client.oss.updateBucketAcl(config.bucketName, config.acl);
+    }
+    // Update website configuration if specified
+    if (config.websiteConfig) {
+        await client.oss.updateBucketWebsite(config.bucketName, config.websiteConfig);
+    }
+    // Upload static files if code path is specified
+    if (bucket.website?.code) {
+        const codePath = node_path_1.default.resolve(process.cwd(), bucket.website.code);
+        await client.oss.uploadFiles(config.bucketName, codePath);
+    }
+    // Refresh state from provider to get all attributes
+    const bucketInfo = await client.oss.getBucket(config.bucketName);
+    if (!bucketInfo) {
+        throw new Error(`Failed to refresh state for bucket: ${config.bucketName}`);
+    }
+    const definition = (0, ossTypes_1.extractOssBucketDefinition)(config);
+    const arn = `arn:acs:oss:${context.region}:${context.accountId}:${config.bucketName}`;
+    const resourceState = {
+        mode: 'managed',
+        region: context.region,
+        definition,
+        instances: [buildOssInstanceFromProvider(bucketInfo, arn)],
+        lastUpdated: new Date().toISOString(),
+    };
+    const logicalId = `buckets.${bucket.key}`;
+    return (0, common_1.setResource)(state, logicalId, resourceState);
+};
+exports.updateBucketResource = updateBucketResource;
+const deleteBucketResource = async (context, bucketName, logicalId, state) => {
+    const client = (0, aliyunClient_1.createAliyunClient)(context);
+    await client.oss.deleteBucket(bucketName);
+    return (0, common_1.removeResource)(state, logicalId);
+};
+exports.deleteBucketResource = deleteBucketResource;

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractOssBucketDefinition = exports.bucketToOssBucketConfig = void 0;
+const types_1 = require("../../types");
+const bucketTypes_1 = require("../bucketTypes");
+// Map from domain enum to provider ACL type
+const aclMap = {
+    [types_1.BucketAccessEnum.PRIVATE]: bucketTypes_1.BucketACL.PRIVATE,
+    [types_1.BucketAccessEnum.PUBLIC_READ]: bucketTypes_1.BucketACL.PUBLIC_READ,
+    [types_1.BucketAccessEnum.PUBLIC_READ_WRITE]: bucketTypes_1.BucketACL.PUBLIC_READ_WRITE,
+};
+const bucketToOssBucketConfig = (bucket) => {
+    const config = {
+        bucketName: bucket.name,
+    };
+    if (bucket.security?.acl) {
+        config.acl = aclMap[bucket.security.acl];
+    }
+    if (bucket.website) {
+        config.websiteConfig = {
+            indexDocument: bucket.website.index,
+        };
+        if (bucket.website.error_page) {
+            config.websiteConfig.errorDocument = bucket.website.error_page;
+        }
+    }
+    if (bucket.storage?.class) {
+        config.storageClass = bucket.storage.class;
+    }
+    if (bucket.website?.domain) {
+        config.domain = bucket.website.domain;
+    }
+    return config;
+};
+exports.bucketToOssBucketConfig = bucketToOssBucketConfig;
+const extractOssBucketDefinition = (config) => {
+    return {
+        bucketName: config.bucketName,
+        acl: config.acl ?? null,
+        websiteConfiguration: config.websiteConfig
+            ? {
+                indexDocument: config.websiteConfig.indexDocument,
+                errorDocument: config.websiteConfig.errorDocument ?? null,
+            }
+            : {},
+        storageClass: config.storageClass ?? null,
+        domain: config.domain ?? null,
+    };
+};
+exports.extractOssBucketDefinition = extractOssBucketDefinition;

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAliyunPlan = void 0;
+const common_1 = require("../../common");
+const lang_1 = require("../../lang");
+const fc3Planner_1 = require("./fc3Planner");
+const ossPlanner_1 = require("./ossPlanner");
+const databasePlanner_1 = require("./databasePlanner");
+const tablestorePlanner_1 = require("./tablestorePlanner");
+const apigwPlanner_1 = require("./apigwPlanner");
+const generateAliyunPlan = async (iac) => {
+    const context = (0, common_1.getContext)();
+    const state = (0, common_1.loadState)(iac.provider.name, process.cwd());
+    const functionPlan = await (0, fc3Planner_1.generateFunctionPlan)(context, state, iac.functions);
+    const bucketPlan = await (0, ossPlanner_1.generateBucketPlan)(context, state, iac.buckets);
+    const databasePlan = await (0, databasePlanner_1.generateDatabasePlan)(context, state, iac.databases);
+    const tablePlan = await (0, tablestorePlanner_1.generateTablePlan)(context, state, iac.tables);
+    const eventPlan = await (0, apigwPlanner_1.generateApigwPlan)(context, state, iac.events, iac.service);
+    const allItems = [
+        ...functionPlan.items,
+        ...bucketPlan.items,
+        ...databasePlan.items,
+        ...tablePlan.items,
+        ...eventPlan.items,
+    ];
+    const dependencyInfo = (0, common_1.getDependencyInfo)(allItems);
+    if (dependencyInfo.cycleError) {
+        throw new Error(`${lang_1.lang.__('CYCLE_DETECTED')}: ${dependencyInfo.cycleError.cycle.join(' -> ')}`);
+    }
+    return {
+        items: dependencyInfo.order,
+        levels: dependencyInfo.levels,
+        graph: dependencyInfo.graph,
+        dotGraph: (0, common_1.toDotFormat)(dependencyInfo.graph),
+    };
+};
+exports.generateAliyunPlan = generateAliyunPlan;

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

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractRdsDefinition = exports.databaseToRdsConfig = void 0;
+// Map database versions to RDS engine versions
+const rdsEngineMap = new Map([
+    [
+        `${"RDS_MYSQL_SERVERLESS" /* DatabaseEnum.RDS_MYSQL_SERVERLESS */}-${"MYSQL_5.7" /* DatabaseVersionEnum['MYSQL_5.7'] */}`,
+        {
+            engine: 'MySQL',
+            version: '5.7',
+            category: 'serverless_basic',
+            dbInstanceClass: 'mysql.n2.serverless.1c',
+            quota: { minCapacity: 0.5, maxCapacity: 32, ha: false },
+            storage: { type: 'general_essd', bursting: true },
+        },
+    ],
+    [
+        `${"RDS_MYSQL_SERVERLESS" /* DatabaseEnum.RDS_MYSQL_SERVERLESS */}-${"MYSQL_8.0" /* DatabaseVersionEnum['MYSQL_8.0'] */}`,
+        {
+            engine: 'MySQL',
+            version: '8.0',
+            category: 'serverless_basic',
+            dbInstanceClass: 'mysql.n2.serverless.1c',
+            quota: { minCapacity: 0.5, maxCapacity: 32, ha: false },
+            storage: { type: 'general_essd', bursting: true },
+        },
+    ],
+    [
+        `${"RDS_MYSQL_SERVERLESS" /* DatabaseEnum.RDS_MYSQL_SERVERLESS */}-${"MYSQL_HA_5.7" /* DatabaseVersionEnum['MYSQL_HA_5.7'] */}`,
+        {
+            engine: 'MySQL',
+            version: '5.7',
+            category: 'serverless_standard',
+            dbInstanceClass: 'mysql.n2.serverless.2c',
+            quota: { minCapacity: 0.5, maxCapacity: 32, ha: true },
+            storage: { type: 'general_essd', bursting: true },
+        },
+    ],
+    [
+        `${"RDS_MYSQL_SERVERLESS" /* DatabaseEnum.RDS_MYSQL_SERVERLESS */}-${"MYSQL_HA_8.0" /* DatabaseVersionEnum['MYSQL_HA_8.0'] */}`,
+        {
+            engine: 'MySQL',
+            version: '8.0',
+            category: 'serverless_standard',
+            dbInstanceClass: 'mysql.n2.serverless.2c',
+            quota: { minCapacity: 0.5, maxCapacity: 32, ha: true },
+            storage: { type: 'general_essd', bursting: true },
+        },
+    ],
+    [
+        `${"RDS_PGSQL_SERVERLESS" /* DatabaseEnum.RDS_PGSQL_SERVERLESS */}-${"PGSQL_14" /* DatabaseVersionEnum.PGSQL_14 */}`,
+        {
+            engine: 'PostgreSQL',
+            version: '14.0',
+            category: 'serverless_basic',
+            dbInstanceClass: 'pg.n2.serverless.1c',
+            quota: { minCapacity: 0.5, maxCapacity: 14, ha: false },
+            storage: { type: 'general_essd', bursting: true },
+        },
+    ],
+    [
+        `${"RDS_PGSQL_SERVERLESS" /* DatabaseEnum.RDS_PGSQL_SERVERLESS */}-${"PGSQL_15" /* DatabaseVersionEnum.PGSQL_15 */}`,
+        {
+            engine: 'PostgreSQL',
+            version: '15.0',
+            category: 'serverless_basic',
+            dbInstanceClass: 'pg.n2.serverless.1c',
+            quota: { minCapacity: 0.5, maxCapacity: 14, ha: false },
+            storage: { type: 'general_essd', bursting: true },
+        },
+    ],
+    [
+        `${"RDS_PGSQL_SERVERLESS" /* DatabaseEnum.RDS_PGSQL_SERVERLESS */}-${"PGSQL_16" /* DatabaseVersionEnum.PGSQL_16 */}`,
+        {
+            engine: 'PostgreSQL',
+            version: '16.0',
+            category: 'serverless_basic',
+            dbInstanceClass: 'pg.n2.serverless.1c',
+            quota: { minCapacity: 0.5, maxCapacity: 14, ha: false },
+            storage: { type: 'general_essd', bursting: true },
+        },
+    ],
+    [
+        `${"RDS_PGSQL_SERVERLESS" /* DatabaseEnum.RDS_PGSQL_SERVERLESS */}-${"PGSQL_HA_14" /* DatabaseVersionEnum.PGSQL_HA_14 */}`,
+        {
+            engine: 'PostgreSQL',
+            version: '14.0',
+            category: 'serverless_standard',
+            dbInstanceClass: 'pg.n2.serverless.2c',
+            quota: { minCapacity: 0.5, maxCapacity: 14, ha: true },
+            storage: { type: 'general_essd', bursting: true },
+        },
+    ],
+    [
+        `${"RDS_PGSQL_SERVERLESS" /* DatabaseEnum.RDS_PGSQL_SERVERLESS */}-${"PGSQL_HA_15" /* DatabaseVersionEnum.PGSQL_HA_15 */}`,
+        {
+            engine: 'PostgreSQL',
+            version: '15.0',
+            category: 'serverless_standard',
+            dbInstanceClass: 'pg.n2.serverless.2c',
+            quota: { minCapacity: 0.5, maxCapacity: 14, ha: true },
+            storage: { type: 'general_essd', bursting: true },
+        },
+    ],
+    [
+        `${"RDS_PGSQL_SERVERLESS" /* DatabaseEnum.RDS_PGSQL_SERVERLESS */}-${"PGSQL_HA_16" /* DatabaseVersionEnum.PGSQL_HA_16 */}`,
+        {
+            engine: 'PostgreSQL',
+            version: '16.0',
+            category: 'serverless_standard',
+            dbInstanceClass: 'pg.n2.serverless.2c',
+            quota: { minCapacity: 0.5, maxCapacity: 14, ha: true },
+            storage: { type: 'general_essd', bursting: true },
+        },
+    ],
+    [
+        `${"RDS_MSSQL_SERVERLESS" /* DatabaseEnum.RDS_MSSQL_SERVERLESS */}-${"MSSQL_HA_2016" /* DatabaseVersionEnum.MSSQL_HA_2016 */}`,
+        {
+            engine: 'SQLServer',
+            version: '2016_std_sl',
+            category: 'serverless_ha',
+            dbInstanceClass: 'mssql.mem2.serverless.s2',
+            quota: { minCapacity: 2, maxCapacity: 8, ha: true },
+            storage: { type: 'cloud_essd', bursting: false },
+        },
+    ],
+    [
+        `${"RDS_MSSQL_SERVERLESS" /* DatabaseEnum.RDS_MSSQL_SERVERLESS */}-${"MSSQL_HA_2017" /* DatabaseVersionEnum.MSSQL_HA_2017 */}`,
+        {
+            engine: 'SQLServer',
+            version: '2017_std_sl',
+            category: 'serverless_ha',
+            dbInstanceClass: 'mssql.mem2.serverless.s2',
+            quota: { minCapacity: 2, maxCapacity: 8, ha: true },
+            storage: { type: 'cloud_essd', bursting: false },
+        },
+    ],
+    [
+        `${"RDS_MSSQL_SERVERLESS" /* DatabaseEnum.RDS_MSSQL_SERVERLESS */}-${"MSSQL_HA_2019" /* DatabaseVersionEnum.MSSQL_HA_2019 */}`,
+        {
+            engine: 'SQLServer',
+            version: '2019_std_sl',
+            category: 'serverless_ha',
+            dbInstanceClass: 'mssql.mem2.serverless.s2',
+            quota: { minCapacity: 2, maxCapacity: 8, ha: true },
+            storage: { type: 'cloud_essd', bursting: false },
+        },
+    ],
+]);
+const databaseToRdsConfig = (database) => {
+    const engineConfig = rdsEngineMap.get(`${database.type}-${database.version}`);
+    if (!engineConfig) {
+        throw new Error(`Unsupported RDS database type/version: ${database.type}-${database.version}`);
+    }
+    const { engine, version, category, dbInstanceClass, quota, storage } = engineConfig;
+    const config = {
+        dbInstanceDescription: database.name,
+        engine: engine,
+        engineVersion: version,
+        dbInstanceClass: dbInstanceClass,
+        dbInstanceStorage: database.storage.min,
+        category: category,
+        dbInstanceStorageType: storage.type,
+        burstingEnabled: storage.bursting,
+        serverlessConfig: {
+            minCapacity: database.cu.min === 0 ? quota.minCapacity : database.cu.min + quota.minCapacity,
+            maxCapacity: database.cu.max + quota.minCapacity <= quota.maxCapacity
+                ? database.cu.max + quota.minCapacity
+                : quota.maxCapacity,
+            autoPause: database.cu.min === 0,
+            switchForce: false,
+        },
+        masterUsername: database.security.basicAuth.username,
+        masterUserPassword: database.security.basicAuth.password,
+        masterUserType: 'Super',
+        multiAZ: quota.ha,
+        securityIPList: database.network.ingressRules.join(','),
+        connectionStringType: database.network.type === 'PRIVATE' ? 'Inner' : 'Public',
+        dbInstanceNetType: database.network.type === 'PRIVATE' ? 'Intranet' : 'Internet',
+    };
+    // Add VPC configuration if provided
+    if (database.network.vpcId) {
+        config.vpcId = database.network.vpcId;
+    }
+    if (database.network.subnetId) {
+        config.vSwitchId = database.network.subnetId;
+    }
+    return config;
+};
+exports.databaseToRdsConfig = databaseToRdsConfig;
+const extractRdsDefinition = (config) => {
+    return {
+        dbInstanceDescription: config.dbInstanceDescription,
+        engine: config.engine,
+        engineVersion: config.engineVersion,
+        dbInstanceClass: config.dbInstanceClass,
+        dbInstanceStorage: config.dbInstanceStorage,
+        category: config.category,
+        dbInstanceStorageType: config.dbInstanceStorageType,
+        burstingEnabled: config.burstingEnabled ?? null,
+        serverlessConfig: config.serverlessConfig
+            ? {
+                minCapacity: config.serverlessConfig.minCapacity,
+                maxCapacity: config.serverlessConfig.maxCapacity,
+                autoPause: config.serverlessConfig.autoPause,
+                switchForce: config.serverlessConfig.switchForce,
+            }
+            : null,
+        multiAZ: config.multiAZ ?? null,
+        securityIPList: config.securityIPList ?? null,
+        connectionStringType: config.connectionStringType ?? null,
+        dbInstanceNetType: config.dbInstanceNetType ?? null,
+        vpcId: config.vpcId ?? null,
+        vSwitchId: config.vSwitchId ?? null,
+    };
+};
+exports.extractRdsDefinition = extractRdsDefinition;