@geek-fun/serverlessinsight 0.4.0 → 0.5.0

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

@@ -0,0 +1,511 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteResource = exports.updateResource = exports.readResource = exports.createResource = void 0;
+const aliyunClient_1 = require("../../common/aliyunClient");
+const common_1 = require("../../common");
+const fc3Types_1 = require("./fc3Types");
+const logger_1 = require("../../common/logger");
+const lang_1 = require("../../lang");
+const buildFc3InstanceFromProvider = (info, arn) => {
+    return {
+        type: 'ALIYUN_FC3_FUNCTION',
+        arn,
+        id: info.functionName ?? '',
+        functionName: info.functionName ?? null,
+        functionId: info.functionId ?? null,
+        runtime: info.runtime ?? null,
+        handler: info.handler ?? null,
+        memorySize: info.memorySize ?? null,
+        timeout: info.timeout ?? null,
+        diskSize: info.diskSize ?? null,
+        cpu: info.cpu ?? null,
+        environment: info.environmentVariables ?? {},
+        vpcConfig: info.vpcConfig
+            ? {
+                vpcId: info.vpcConfig.vpcId ?? null,
+                vSwitchIds: info.vpcConfig.vSwitchIds ?? [],
+                securityGroupId: info.vpcConfig.securityGroupId ?? null,
+            }
+            : {},
+        gpuConfig: info.gpuConfig
+            ? {
+                gpuMemorySize: info.gpuConfig.gpuMemorySize ?? null,
+                gpuType: info.gpuConfig.gpuType ?? null,
+            }
+            : {},
+        nasConfig: info.nasConfig
+            ? {
+                userId: info.nasConfig.userId ?? null,
+                groupId: info.nasConfig.groupId ?? null,
+                mountPoints: info.nasConfig.mountPoints?.map((mp) => ({
+                    serverAddr: mp.serverAddr ?? null,
+                    mountDir: mp.mountDir ?? null,
+                    enableTls: mp.enableTls ?? null,
+                })) ?? [],
+            }
+            : {},
+        logConfig: info.logConfig
+            ? {
+                project: info.logConfig.project ?? null,
+                logstore: info.logConfig.logstore ?? null,
+                enableRequestMetrics: info.logConfig.enableRequestMetrics ?? null,
+                enableInstanceMetrics: info.logConfig.enableInstanceMetrics ?? null,
+                logBeginRule: info.logConfig.logBeginRule ?? null,
+            }
+            : {},
+        customContainerConfig: info.customContainerConfig
+            ? {
+                image: info.customContainerConfig.image ?? null,
+                entrypoint: info.customContainerConfig.entrypoint ?? [],
+                command: info.customContainerConfig.command ?? [],
+                port: info.customContainerConfig.port ?? null,
+                accelerationType: info.customContainerConfig.accelerationType ?? null,
+            }
+            : {},
+        description: info.description ?? null,
+        internetAccess: info.internetAccess ?? null,
+        role: info.role ?? null,
+        codeChecksum: info.codeChecksum ?? null,
+        codeSize: info.codeSize ?? null,
+        createdTime: info.createdTime ?? null,
+        lastModifiedTime: info.lastModifiedTime ?? null,
+        state: info.state ?? null,
+        stateReason: info.stateReason ?? null,
+        stateReasonCode: info.stateReasonCode ?? null,
+        lastUpdateStatus: info.lastUpdateStatus ?? null,
+        lastUpdateStatusReason: info.lastUpdateStatusReason ?? null,
+        lastUpdateStatusReasonCode: info.lastUpdateStatusReasonCode ?? null,
+    };
+};
+// Helper function to create dependent resources directly using the client
+const createDependentResources = async (context, fn, serviceName) => {
+    const client = (0, aliyunClient_1.createAliyunClient)(context);
+    const instances = [];
+    let logConfig;
+    let securityGroup;
+    let nasConfig;
+    // Create SLS resources if logging is enabled
+    if (fn.log) {
+        const projectName = `${serviceName}-sls`;
+        const logstoreName = `${serviceName}-sls-logstore`;
+        logger_1.logger.info(`Creating SLS project: ${projectName}`);
+        const project = await client.sls.createProject(projectName);
+        instances.push({
+            type: 'ALIYUN_SLS_PROJECT',
+            id: projectName,
+            attributes: { ...project },
+        });
+        logger_1.logger.info(`Creating SLS logstore: ${logstoreName}`);
+        const logstore = await client.sls.createLogstore(projectName, logstoreName);
+        instances.push({
+            type: 'ALIYUN_SLS_LOGSTORE',
+            id: `${projectName}/${logstoreName}`,
+            attributes: { ...logstore },
+        });
+        logger_1.logger.info(`Creating SLS index for: ${logstoreName}`);
+        const index = await client.sls.createIndex(projectName, logstoreName);
+        instances.push({
+            type: 'ALIYUN_SLS_INDEX',
+            id: `${projectName}/${logstoreName}/index`,
+            attributes: { ...index },
+        });
+        logger_1.logger.info(`Waiting for SLS project and logstore to be ready: ${projectName}/${logstoreName}`);
+        await client.sls.waitForProject(projectName);
+        await client.sls.waitForLogstore(projectName, logstoreName);
+        logConfig = { project: projectName, logstore: logstoreName };
+    }
+    // Create RAM role
+    const roleName = `${serviceName}-fc-role`;
+    logger_1.logger.info(`Creating RAM role: ${roleName}`);
+    const ramRole = await client.ram.createRole(roleName);
+    instances.push({
+        type: 'ALIYUN_RAM_ROLE',
+        id: roleName,
+        arn: ramRole.arn,
+        attributes: { ...ramRole },
+    });
+    const role = { roleName, arn: ramRole.arn ?? `acs:ram::${context.accountId}:role/${roleName}` };
+    // Create security group if network is configured
+    if (fn.network) {
+        const sgName = fn.network.security_group.name;
+        logger_1.logger.info(`Creating security group: ${sgName}`);
+        const sg = await client.ecs.createSecurityGroup(sgName, fn.network.vpc_id, fn.network.security_group.ingress, fn.network.security_group.egress);
+        instances.push({
+            type: 'ALIYUN_ECS_SECURITY_GROUP',
+            id: sg.securityGroupId,
+            attributes: { ...sg },
+        });
+        securityGroup = { securityGroupId: sg.securityGroupId };
+    }
+    // Create NAS resources if configured
+    if (fn.storage?.nas && fn.storage.nas.length > 0 && fn.network) {
+        const mountPoints = [];
+        for (const nasItem of fn.storage.nas) {
+            const mountPath = nasItem.mount_path.replace(/\//g, '-').replace(/^-/, '');
+            const accessGroupName = `${fn.name}-nas-access-${mountPath}`;
+            logger_1.logger.info(`Creating NAS access group: ${accessGroupName}`);
+            const accessGroup = await client.nas.createAccessGroup(accessGroupName);
+            instances.push({
+                type: 'ALIYUN_NAS_ACCESS_GROUP',
+                id: accessGroupName,
+                attributes: { ...accessGroup },
+            });
+            logger_1.logger.info(`Creating NAS access rule for: ${accessGroupName}`);
+            await client.nas.createAccessRule(accessGroupName, '10.0.0.0/8');
+            logger_1.logger.info(`Creating NAS file system for: ${fn.name}`);
+            const fileSystem = await client.nas.createFileSystem(nasItem.storage_class, fn.name);
+            instances.push({
+                type: 'ALIYUN_NAS_FILE_SYSTEM',
+                id: fileSystem.fileSystemId,
+                attributes: { ...fileSystem },
+            });
+            logger_1.logger.info(`Creating NAS mount target for: ${fileSystem.fileSystemId}`);
+            const mountTarget = await client.nas.createMountTarget(fileSystem.fileSystemId, accessGroupName, fn.network.vpc_id, fn.network.subnet_ids[0]);
+            instances.push({
+                type: 'ALIYUN_NAS_MOUNT_TARGET',
+                id: `${fileSystem.fileSystemId}/${mountTarget.mountTargetDomain}`,
+                attributes: { ...mountTarget },
+            });
+            mountPoints.push({
+                serverAddr: `${mountTarget.mountTargetDomain}:/`,
+                mountDir: nasItem.mount_path,
+                fileSystemId: fileSystem.fileSystemId,
+                mountTargetDomain: mountTarget.mountTargetDomain,
+                accessGroupName,
+            });
+        }
+        nasConfig = { mountPoints };
+    }
+    return {
+        logConfig,
+        role,
+        securityGroup,
+        nasConfig,
+        instances,
+    };
+};
+// Helper function to delete dependent resources directly using the client
+const deleteDependentResources = async (context, instances) => {
+    const client = (0, aliyunClient_1.createAliyunClient)(context);
+    // Delete in reverse order of creation
+    for (const instance of [...instances].reverse()) {
+        try {
+            switch (instance.type) {
+                case 'ALIYUN_NAS_MOUNT_TARGET': {
+                    const [fileSystemId, mountTargetDomain] = instance.id.split('/');
+                    logger_1.logger.info(`Deleting NAS mount target: ${instance.id}`);
+                    await client.nas.deleteMountTarget(fileSystemId, mountTargetDomain);
+                    break;
+                }
+                case 'ALIYUN_NAS_FILE_SYSTEM':
+                    logger_1.logger.info(`Deleting NAS file system: ${instance.id}`);
+                    await client.nas.deleteFileSystem(instance.id);
+                    break;
+                case 'ALIYUN_NAS_ACCESS_GROUP':
+                    logger_1.logger.info(`Deleting NAS access group: ${instance.id}`);
+                    await client.nas.deleteAccessGroup(instance.id);
+                    break;
+                case 'ALIYUN_ECS_SECURITY_GROUP':
+                    logger_1.logger.info(`Deleting security group: ${instance.id}`);
+                    await client.ecs.deleteSecurityGroup(instance.id);
+                    break;
+                case 'ALIYUN_RAM_ROLE':
+                    logger_1.logger.info(`Deleting RAM role: ${instance.id}`);
+                    await client.ram.deleteRole(instance.id);
+                    break;
+                case 'ALIYUN_SLS_INDEX': {
+                    const [projectName, logstoreName] = instance.id.split('/');
+                    logger_1.logger.info(`Deleting SLS index: ${instance.id}`);
+                    await client.sls.deleteIndex(projectName, logstoreName);
+                    break;
+                }
+                case 'ALIYUN_SLS_LOGSTORE': {
+                    const [projectName, logstoreName] = instance.id.split('/');
+                    logger_1.logger.info(`Deleting SLS logstore: ${instance.id}`);
+                    await client.sls.deleteLogstore(projectName, logstoreName);
+                    break;
+                }
+                case 'ALIYUN_SLS_PROJECT':
+                    logger_1.logger.info(`Deleting SLS project: ${instance.id}`);
+                    await client.sls.deleteProject(instance.id);
+                    break;
+                default:
+                    logger_1.logger.warn(`Unknown resource type: ${instance.type}`);
+            }
+        }
+        catch (err) {
+            logger_1.logger.error(`Failed to delete resource ${instance.type}:${instance.id}: ${err}`);
+        }
+    }
+};
+const createResource = async (context, fn, state) => {
+    const ctx = (0, common_1.getContext)();
+    const serviceName = ctx.stackName ?? fn.name;
+    // Create dependent resources (SLS, RAM, ECS SecurityGroup, NAS)
+    const dependentResources = await createDependentResources(context, fn, serviceName);
+    // Build FC3 config with dependent resources
+    let config = (0, fc3Types_1.functionToFc3Config)(fn);
+    // Update config with dependent resources
+    if (dependentResources.logConfig) {
+        config = {
+            ...config,
+            logConfig: {
+                project: dependentResources.logConfig.project,
+                logstore: dependentResources.logConfig.logstore,
+                enableRequestMetrics: true,
+            },
+        };
+    }
+    if (dependentResources.role) {
+        config = {
+            ...config,
+            role: dependentResources.role.arn,
+        };
+    }
+    if (dependentResources.securityGroup && fn.network) {
+        config = {
+            ...config,
+            vpcConfig: {
+                vpcId: fn.network.vpc_id,
+                vSwitchIds: fn.network.subnet_ids,
+                securityGroupId: dependentResources.securityGroup.securityGroupId,
+            },
+        };
+    }
+    if (dependentResources.nasConfig) {
+        config = {
+            ...config,
+            nasConfig: {
+                userId: -1,
+                groupId: -1,
+                mountPoints: dependentResources.nasConfig.mountPoints.map((mp) => ({
+                    serverAddr: mp.serverAddr,
+                    mountDir: mp.mountDir,
+                })),
+            },
+        };
+    }
+    const codePath = fn.code.path;
+    const codeHash = (0, common_1.computeFileHash)(codePath);
+    const definition = (0, fc3Types_1.extractFc3Definition)(config, codeHash);
+    const logicalId = `functions.${fn.key}`;
+    // Save state with dependent resources BEFORE attempting function creation
+    const dependentInstances = dependentResources.instances.map((dep) => ({
+        arn: dep.arn ??
+            `arn:acs:${dep.type.toLowerCase()}:${context.region}:${context.accountId}:${dep.id}`,
+        id: dep.id,
+        type: dep.type,
+        ...dep.attributes,
+    }));
+    // Create partial state with just dependent resources
+    const partialResourceState = {
+        mode: 'managed',
+        region: context.region,
+        definition,
+        instances: dependentInstances,
+        lastUpdated: new Date().toISOString(),
+    };
+    state = (0, common_1.setResource)(state, logicalId, partialResourceState);
+    // Now attempt to create the function
+    const client = (0, aliyunClient_1.createAliyunClient)(context);
+    try {
+        await client.fc3.createFunction(config, codePath);
+    }
+    catch (error) {
+        logger_1.logger.error(`Failed to create function, but dependent resources were created and saved to state: ${error}`);
+        logger_1.logger.info(lang_1.lang.__('FC3_DEPENDENT_RESOURCES_TRACKED'));
+        logger_1.logger.info(lang_1.lang.__('FC3_CAN_RETRY_DEPLOYMENT'));
+        return state;
+    }
+    // Refresh state from provider to get all attributes
+    const functionInfo = await client.fc3.getFunction(fn.name);
+    if (!functionInfo) {
+        throw new Error(`Failed to refresh state for function: ${fn.name}`);
+    }
+    const arn = functionInfo.functionArn ??
+        `arn:acs:fc:${context.region}:${context.accountId}:function/${fn.name}`;
+    // Build instances array with FC function as first item, followed by dependent resources
+    const fcInstance = buildFc3InstanceFromProvider(functionInfo, arn);
+    const resourceState = {
+        mode: 'managed',
+        region: context.region,
+        definition,
+        instances: [fcInstance, ...dependentInstances],
+        lastUpdated: new Date().toISOString(),
+    };
+    return (0, common_1.setResource)(state, logicalId, resourceState);
+};
+exports.createResource = createResource;
+const readResource = async (context, functionName) => {
+    const client = (0, aliyunClient_1.createAliyunClient)(context);
+    return await client.fc3.getFunction(functionName);
+};
+exports.readResource = readResource;
+const updateResource = async (context, fn, state) => {
+    const ctx = (0, common_1.getContext)();
+    const serviceName = ctx.stackName ?? fn.name;
+    const logicalId = `functions.${fn.key}`;
+    // Get existing resource state to check if dependent resources exist
+    const existingState = (0, common_1.getResource)(state, logicalId);
+    const existingInstances = (existingState?.instances ?? []);
+    // Check if we need to create new dependent resources
+    const hasSlsResources = existingInstances.some((i) => i.type === 'ALIYUN_SLS_PROJECT');
+    const hasRamRole = existingInstances.some((i) => i.type === 'ALIYUN_RAM_ROLE');
+    const hasSecurityGroup = existingInstances.some((i) => i.type === 'ALIYUN_ECS_SECURITY_GROUP');
+    const hasNasResources = existingInstances.some((i) => i.type === 'ALIYUN_NAS_FILE_SYSTEM');
+    const newDependentInstances = [];
+    let logConfig;
+    let role;
+    let securityGroup;
+    let nasConfig;
+    // Create new dependent resources if they don't exist
+    if (fn.log && !hasSlsResources) {
+        const deps = await createDependentResources(context, { ...fn, network: undefined, storage: { ...fn.storage, nas: undefined } }, serviceName);
+        logConfig = deps.logConfig;
+        newDependentInstances.push(...deps.instances.filter((i) => i.type.startsWith('ALIYUN_SLS_')));
+    }
+    else if (hasSlsResources) {
+        const slsProjectInstance = existingInstances.find((i) => i.type === 'ALIYUN_SLS_PROJECT');
+        const slsLogstoreInstance = existingInstances.find((i) => i.type === 'ALIYUN_SLS_LOGSTORE');
+        if (slsProjectInstance && slsLogstoreInstance) {
+            const [projectName, logstoreName] = slsLogstoreInstance.id.split('/');
+            logConfig = { project: projectName, logstore: logstoreName };
+        }
+    }
+    if (!hasRamRole) {
+        const deps = await createDependentResources(context, { ...fn, log: false, network: undefined, storage: { ...fn.storage, nas: undefined } }, serviceName);
+        role = deps.role;
+        newDependentInstances.push(...deps.instances.filter((i) => i.type === 'ALIYUN_RAM_ROLE'));
+    }
+    else {
+        const ramRoleInstance = existingInstances.find((i) => i.type === 'ALIYUN_RAM_ROLE');
+        if (ramRoleInstance) {
+            role = {
+                roleName: ramRoleInstance.id,
+                arn: ramRoleInstance.arn ?? `acs:ram::${context.accountId}:role/${ramRoleInstance.id}`,
+            };
+        }
+    }
+    if (fn.network && !hasSecurityGroup) {
+        const deps = await createDependentResources(context, { ...fn, log: false, storage: { ...fn.storage, nas: undefined } }, serviceName);
+        securityGroup = deps.securityGroup;
+        newDependentInstances.push(...deps.instances.filter((i) => i.type === 'ALIYUN_ECS_SECURITY_GROUP'));
+    }
+    else if (hasSecurityGroup) {
+        const sgInstance = existingInstances.find((i) => i.type === 'ALIYUN_ECS_SECURITY_GROUP');
+        if (sgInstance) {
+            securityGroup = { securityGroupId: sgInstance.id };
+        }
+    }
+    if (fn.storage?.nas && fn.storage.nas.length > 0 && fn.network && !hasNasResources) {
+        const deps = await createDependentResources(context, { ...fn, log: false }, serviceName);
+        nasConfig = deps.nasConfig;
+        newDependentInstances.push(...deps.instances.filter((i) => i.type.startsWith('ALIYUN_NAS_')));
+    }
+    else if (hasNasResources) {
+        const mountTargetInstances = existingInstances.filter((i) => i.type === 'ALIYUN_NAS_MOUNT_TARGET');
+        const nasStorageItems = fn.storage?.nas ?? [];
+        if (mountTargetInstances.length > 0 && nasStorageItems.length > 0) {
+            nasConfig = {
+                mountPoints: mountTargetInstances.map((mt, idx) => ({
+                    serverAddr: `${mt.id.split('/')[1]}:/`,
+                    mountDir: nasStorageItems[idx]?.mount_path ?? '/mnt/nas',
+                })),
+            };
+        }
+    }
+    // Build FC3 config with dependent resources
+    let config = (0, fc3Types_1.functionToFc3Config)(fn);
+    if (logConfig) {
+        config = {
+            ...config,
+            logConfig: {
+                project: logConfig.project,
+                logstore: logConfig.logstore,
+                enableRequestMetrics: true,
+            },
+        };
+    }
+    if (role) {
+        config = {
+            ...config,
+            role: role.arn,
+        };
+    }
+    if (securityGroup && fn.network) {
+        config = {
+            ...config,
+            vpcConfig: {
+                vpcId: fn.network.vpc_id,
+                vSwitchIds: fn.network.subnet_ids,
+                securityGroupId: securityGroup.securityGroupId,
+            },
+        };
+    }
+    if (nasConfig) {
+        config = {
+            ...config,
+            nasConfig: {
+                userId: -1,
+                groupId: -1,
+                mountPoints: nasConfig.mountPoints,
+            },
+        };
+    }
+    const codePath = fn.code.path;
+    const client = (0, aliyunClient_1.createAliyunClient)(context);
+    await client.fc3.updateFunctionConfiguration(config);
+    await client.fc3.updateFunctionCode(fn.name, codePath);
+    const functionInfo = await client.fc3.getFunction(fn.name);
+    if (!functionInfo) {
+        throw new Error(`Failed to refresh state for function: ${fn.name}`);
+    }
+    const codeHash = (0, common_1.computeFileHash)(codePath);
+    const definition = (0, fc3Types_1.extractFc3Definition)(config, codeHash);
+    const arn = functionInfo.functionArn ??
+        `arn:acs:fc:${context.region}:${context.accountId}:function/${fn.name}`;
+    // Build instances array: FC function + existing dependent resources + new dependent resources
+    const fcInstance = buildFc3InstanceFromProvider(functionInfo, arn);
+    const existingDependentInstances = existingInstances
+        .filter((i) => i.type !== 'ALIYUN_FC3_FUNCTION')
+        .map((i) => {
+        const { arn: existingArn, id: existingId, ...rest } = i;
+        return {
+            arn: existingArn ??
+                `arn:acs:${i.type?.toString().toLowerCase()}:${context.region}:${context.accountId}:${existingId}`,
+            id: existingId?.toString() ?? '',
+            ...rest,
+        };
+    });
+    const newDependentInstancesMapped = newDependentInstances.map((dep) => ({
+        arn: dep.arn ??
+            `arn:acs:${dep.type.toLowerCase()}:${context.region}:${context.accountId}:${dep.id}`,
+        id: dep.id,
+        type: dep.type,
+        ...dep.attributes,
+    }));
+    const resourceState = {
+        mode: 'managed',
+        region: context.region,
+        definition,
+        instances: [fcInstance, ...existingDependentInstances, ...newDependentInstancesMapped],
+        lastUpdated: new Date().toISOString(),
+    };
+    return (0, common_1.setResource)(state, logicalId, resourceState);
+};
+exports.updateResource = updateResource;
+const deleteResource = async (context, functionName, logicalId, state) => {
+    // Get existing resource state to find dependent resources
+    const existingState = (0, common_1.getResource)(state, logicalId);
+    const existingInstances = (existingState?.instances ?? []);
+    // Delete FC function first
+    const client = (0, aliyunClient_1.createAliyunClient)(context);
+    await client.fc3.deleteFunction(functionName);
+    // Delete dependent resources
+    const dependentInstances = existingInstances.filter((i) => i.type !== 'ALIYUN_FC3_FUNCTION' && !i.type.includes('undefined'));
+    if (dependentInstances.length > 0) {
+        await deleteDependentResources(context, dependentInstances);
+    }
+    return (0, common_1.removeResource)(state, logicalId);
+};
+exports.deleteResource = deleteResource;

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractFunctionDomainDefinition = exports.extractFc3Definition = exports.functionToFc3Config = void 0;
+const types_1 = require("../../types");
+const common_1 = require("../../common");
+const gpuConfigMap = {
+    [types_1.FunctionGpuEnum.TESLA_8]: { gpuMemorySize: 8192, gpuType: 'fc.gpu.tesla.1' },
+    [types_1.FunctionGpuEnum.TESLA_12]: { gpuMemorySize: 12288, gpuType: 'fc.gpu.tesla.1' },
+    [types_1.FunctionGpuEnum.TESLA_16]: { gpuMemorySize: 16384, gpuType: 'fc.gpu.tesla.1' },
+    [types_1.FunctionGpuEnum.AMPERE_8]: { gpuMemorySize: 8192, gpuType: 'fc.gpu.ampere.1' },
+    [types_1.FunctionGpuEnum.AMPERE_12]: { gpuMemorySize: 12288, gpuType: 'fc.gpu.ampere.1' },
+    [types_1.FunctionGpuEnum.AMPERE_16]: { gpuMemorySize: 16384, gpuType: 'fc.gpu.ampere.1' },
+    [types_1.FunctionGpuEnum.AMPERE_24]: { gpuMemorySize: 24576, gpuType: 'fc.gpu.ampere.1' },
+    [types_1.FunctionGpuEnum.ADA_48]: { gpuMemorySize: 49152, gpuType: 'fc.gpu.ada.1' },
+};
+const transformGpuConfig = (gpu) => {
+    if (!gpu) {
+        return undefined;
+    }
+    return gpuConfigMap[gpu];
+};
+const functionToFc3Config = (fn) => {
+    const config = {
+        functionName: fn.name,
+        runtime: fn.container ? 'custom-container' : (0, common_1.mapRuntime)(fn.code.runtime, common_1.ProviderEnum.ALIYUN),
+        handler: fn.container ? 'index.handler' : fn.code.handler,
+        memorySize: fn.memory ?? 128,
+        timeout: fn.timeout ?? 60,
+    };
+    if (fn.storage?.disk) {
+        config.diskSize = fn.storage.disk;
+    }
+    if (fn.environment && Object.keys(fn.environment).length > 0) {
+        config.environmentVariables = fn.environment;
+    }
+    if (fn.gpu) {
+        config.gpuConfig = transformGpuConfig(fn.gpu);
+    }
+    if (fn.container) {
+        config.customContainerConfig = {
+            image: fn.container.image,
+            port: fn.container.port,
+            ...(fn.container.cmd && { command: fn.container.cmd.split(' ') }),
+        };
+    }
+    if (fn.network) {
+        config.vpcConfig = {
+            vpcId: fn.network.vpc_id,
+            vSwitchIds: fn.network.subnet_ids,
+            securityGroupId: fn.network.security_group.name,
+        };
+    }
+    return config;
+};
+exports.functionToFc3Config = functionToFc3Config;
+const extractFc3Definition = (config, codeHash) => {
+    return {
+        functionName: config.functionName,
+        runtime: config.runtime,
+        handler: config.handler,
+        memorySize: config.memorySize,
+        timeout: config.timeout,
+        diskSize: config.diskSize ?? null,
+        environment: config.environmentVariables ?? {},
+        vpcConfig: config.vpcConfig ?? null,
+        gpuConfig: config.gpuConfig ?? null,
+        customContainerConfig: config.customContainerConfig ?? null,
+        codeHash,
+    };
+};
+exports.extractFc3Definition = extractFc3Definition;
+const extractFunctionDomainDefinition = (fn, codeHash) => {
+    const config = (0, exports.functionToFc3Config)(fn);
+    return (0, exports.extractFc3Definition)(config, codeHash);
+};
+exports.extractFunctionDomainDefinition = extractFunctionDomainDefinition;

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

@@ -0,0 +1,40 @@
+"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("./fc3Types"), exports);
+__exportStar(require("./fc3Resource"), exports);
+__exportStar(require("./fc3Planner"), exports);
+__exportStar(require("./fc3Executor"), exports);
+__exportStar(require("./apigwTypes"), exports);
+__exportStar(require("./apigwResource"), exports);
+__exportStar(require("./apigwPlanner"), exports);
+__exportStar(require("./apigwExecutor"), exports);
+__exportStar(require("./ossTypes"), exports);
+__exportStar(require("./ossResource"), exports);
+__exportStar(require("./ossPlanner"), exports);
+__exportStar(require("./ossExecutor"), exports);
+__exportStar(require("./rdsTypes"), exports);
+__exportStar(require("./esServerlessTypes"), exports);
+__exportStar(require("./databaseResource"), exports);
+__exportStar(require("./databasePlanner"), exports);
+__exportStar(require("./databaseExecutor"), exports);
+__exportStar(require("./tablestoreTypes"), exports);
+__exportStar(require("./tablestoreResource"), exports);
+__exportStar(require("./tablestorePlanner"), exports);
+__exportStar(require("./tablestoreExecutor"), exports);
+__exportStar(require("./deployer"), exports);
+__exportStar(require("./destroyer"), exports);
+__exportStar(require("./planner"), exports);