semantic-release-minecraft 1.1.2 → 1.2.0

package/src/definitions/plugin-config.ts

@@ -0,0 +1,68 @@
+export type PluginConfig = {
+    release_type?: 'alpha' | 'beta' | 'release';
+    game_versions?: string | string[];
+    mod_loaders?: string | string[];
+    display_name?: string;
+
+    // Global release strategy configuration for multiple publish operations
+    strategies?: Record<string, string>[];
+
+    glob?: string | string[];
+    primary_file_glob: string | string[];
+
+    curseforge?: {
+        project_id: string;
+        game_versions?: string | string[];
+        java_versions?: string | string[];
+        environments?: string | string[];
+        game_versions_for_plugins?: string | string[];
+        game_versions_for_addon?: string | string[];
+        mod_loaders?: string | string[];
+        changelog?: string;
+        changelog_type?: 'text' | 'html' | 'markdown';
+        display_name?: string;
+        is_marked_for_manual_release?: boolean;
+        relations?: {
+            projects?: Array<{
+                slug: string;
+                project_id?: string;
+                type:
+                    | 'embedded_library'
+                    | 'incompatible'
+                    | 'optional_dependency'
+                    | 'required_dependency'
+                    | 'tool';
+            }>;
+        };
+        glob?: string | string[];
+    };
+    modrinth?: {
+        project_id: string;
+        version_number?: string;
+        display_name?: string;
+        game_versions?: string[];
+        mod_loaders?: string[];
+        changelog?: string;
+        dependencies?: Array<{
+            version_id?: string;
+            project_id?: string;
+            file_name?: string;
+            dependency_type:
+                | 'required'
+                | 'optional'
+                | 'incompatible'
+                | 'embedded';
+        }>;
+        featured?: boolean;
+        status?:
+            | 'listed'
+            | 'archived'
+            | 'draft'
+            | 'unlisted'
+            | 'scheduled'
+            | 'unknown';
+        requested_status?: 'listed' | 'archived' | 'draft' | 'unlisted';
+        glob?: string | string[];
+        primary_file_glob?: string | string[];
+    };
+};

package/src/index.ts

@@ -4,69 +4,63 @@ import {
     VerifyConditionsContext,
 } from 'semantic-release';
 import { publishToCurseforge } from './curseforge.js';
-import { Plugin_config } from './definitions/plugin_config.js';
+import { PluginConfig } from './definitions/plugin-config.js';
 import { publishToModrinth } from './modrinth.js';
 import { getCurseForgeGameVersionIds } from './prepare.js';
 
-// 模块级变量存储 CurseForge 版本映射
+// Game version IDs transformed from user's input, used during publishing to CurseForge
 let curseforgeGameVersionsIds: number[] | undefined;
 
 export async function verifyConditions(
-    pluginConfig: Plugin_config,
+    pluginConfig: PluginConfig,
     context: VerifyConditionsContext
 ) {
-    // 验证配置：只检查 project_id，token 通过环境变量验证
-    if (pluginConfig.curseforge && !pluginConfig.curseforge.project_id) {
+    const { env } = context;
+
+    if (env.CURSEFORGE_TOKEN && !pluginConfig.curseforge?.project_id) {
         throw new Error('CurseForge project ID is required');
     }
 
-    if (pluginConfig.modrinth && !pluginConfig.modrinth.project_id) {
+    if (env.MODRINTH_TOKEN && !pluginConfig.modrinth?.project_id) {
         throw new Error('Modrinth project ID is required');
     }
 }
 
 export async function prepare(
-    pluginConfig: Plugin_config,
+    pluginConfig: PluginConfig,
     context: PrepareContext
 ) {
     const { env, logger } = context;
 
     if (env.CURSEFORGE_TOKEN) {
-        const apiKey = env.CURSEFORGE_TOKEN;
-        try {
-            logger.log('Fetching CurseForge game versions and types...');
+        const apiToken = env.CURSEFORGE_TOKEN;
+        logger.log('Fetching CurseForge game versions and types...');
 
-            // 创建版本映射并存储在模块级变量中供后续使用
-            curseforgeGameVersionsIds = await getCurseForgeGameVersionIds(
-                apiKey,
-                pluginConfig.curseforge!,
-                env,
-                context.nextRelease
-            );
+        curseforgeGameVersionsIds = await getCurseForgeGameVersionIds(
+            apiToken,
+            pluginConfig,
+            context
+        );
 
-            logger.log(
-                `Successfully transform ${Object.keys(curseforgeGameVersionsIds).length} CurseForge game versions`
-            );
-        } catch (error) {
-            logger.warn(
-                `Failed to fetch CurseForge game versions: ${error instanceof Error ? error.message : 'Unknown error'}`
-            );
-        }
+        logger.log(
+            `Successfully transform into ${Object.keys(curseforgeGameVersionsIds).length} CurseForge game versions`
+        );
     }
 }
 
 export async function publish(
-    pluginConfig: Plugin_config,
+    pluginConfig: PluginConfig,
     context: PublishContext
 ): Promise<{ url: string }[]> {
     const { env, logger } = context;
     const results: { url: string }[] = [];
 
-    try {
+    for (const strategy of pluginConfig.strategies || [{}]) {
         if (env.CURSEFORGE_TOKEN) {
             const curseforgeId = await publishToCurseforge(
                 pluginConfig,
                 context,
+                strategy,
                 curseforgeGameVersionsIds
             );
             results.push({
@@ -78,9 +72,12 @@ export async function publish(
             );
         }
 
-        // 发布到 Modrinth（如果配置了 Modrinth 且存在环境变量）
         if (env.MODRINTH_TOKEN) {
-            const modrinthId = await publishToModrinth(pluginConfig, context);
+            const modrinthId = await publishToModrinth(
+                pluginConfig,
+                context,
+                strategy
+            );
             results.push({
                 url: `https://modrinth.com/mod/${pluginConfig.modrinth!.project_id}/version/${modrinthId}`,
             });
@@ -89,10 +86,7 @@ export async function publish(
                 'Modrinth publishing is skipped: MODRINTH_TOKEN environment variable not found.'
             );
         }
-
-        return results;
-    } catch (error) {
-        logger.error('Failed to publish:', error);
-        throw error;
     }
+
+    return results;
 }

package/src/modrinth.ts

@@ -1,331 +1,138 @@
 import axios from 'axios';
 import FormData from 'form-data';
 import { readFile } from 'fs/promises';
-import { glob } from 'glob';
-import _ from 'lodash';
-import { resolve } from 'path';
+import { basename } from 'path';
 import { PublishContext } from 'semantic-release';
-import { Plugin_config } from './definitions/plugin_config.js';
+import { PluginConfig } from './definitions/plugin-config';
+import { findFilesAndPrimaryFile } from './utils/platform/utils';
 import {
-    findFiles,
-    renderTemplates,
-    resolveMultipleTemplate,
-    resolveTemplate,
-    toArray,
-} from './utils/utils.js';
+    resolveAndRenderTemplate,
+    resolveAndRenderTemplates,
+} from './utils/template-utils';
 
 /**
- * 发布到 Modrinth
+ * Publishes files to Modrinth.
  */
 export async function publishToModrinth(
-    pluginConfig: Plugin_config,
-    context: PublishContext
+    pluginConfig: PluginConfig,
+    context: PublishContext,
+    strategy: Record<string, string>
 ): Promise<string> {
-    const { env, logger } = context;
+    const { env, logger, nextRelease } = context;
     const { modrinth } = pluginConfig;
     const token = env.MODRINTH_TOKEN!;
     const projectId = modrinth?.project_id!;
-    const nextRelease = context.nextRelease;
-    const nextReleaseVersion = nextRelease.version;
 
-    // 查找文件并确定主要文件
-    const { files, primaryFile } = await findModrinthFiles(
+    const { files, primaryFile } = await findFilesAndPrimaryFile(
         pluginConfig,
-        context
+        context,
+        strategy
     );
     logger.log(
         `Publishing ${files.length} file(s) to Modrinth project ${projectId}...`
     );
 
-    // 使用 multipart/form-data 方式上传文件和版本信息
+    // use multipart/form-data to upload files and version data
     const form = new FormData();
     const filePartNames: string[] = [];
     let primaryFilePartName: string | undefined = undefined;
 
-    // 上传所有文件
     for (let i = 0; i < files.length; i++) {
-        const jarPath = files[i];
-        const jarFile = await readFile(jarPath);
-        const fileName = jarPath.split('\\').pop() || `mod-${i}.jar`;
+        const filePath = files[i];
+        const file = await readFile(filePath);
+        const fileName = basename(filePath);
+
         const filePartName = `file-${i}`;
 
-        form.append(filePartName, jarFile, { filename: fileName });
+        form.append(filePartName, file, { filename: fileName });
         filePartNames.push(filePartName);
 
-        // 标记主要文件
-        if (jarPath === primaryFile) {
+        if (filePath === primaryFile) {
             primaryFilePartName = filePartName;
         }
     }
 
-    // 使用根据 primaryFileGlob 确定的主要文件
-    const finalPrimaryFile: string | undefined = primaryFilePartName;
-
-    // 准备版本信息，只包含必需字段和存在的可选字段
-    // displayName 按照优先级：平台特定配置 > 全局配置 > 平台特定环境变量 > 全局环境变量
-    let displayName: string | undefined;
-    if (modrinth?.display_name) {
-        displayName = _.template(modrinth.display_name)({
-            nextRelease,
-        }) as string;
-    } else if (pluginConfig.display_name) {
-        displayName = _.template(pluginConfig.display_name)({
-            nextRelease,
-        }) as string;
-    } else if (env.MODRINTH_DISPLAY_NAME) {
-        displayName = env.MODRINTH_DISPLAY_NAME;
-    } else if (env.DISPLAY_NAME) {
-        displayName = env.DISPLAY_NAME;
-    }
-
-    // version_number 按照优先级：平台特定配置 > 平台特定环境变量 > 全局环境变量
-    const versionNumber = resolveTemplate(
-        [modrinth?.version_number, env.MODRINTH_VERSION_NUMBER],
-        { nextRelease }
-    );
-
-    // 准备版本信息，只包含必需字段和存在的可选字段
     const versionData: any = {
         project_id: projectId,
-        file_parts: filePartNames, // 必需字段，列出所有文件部分的名称
+        file_parts: filePartNames,
+        changelog: modrinth?.changelog || nextRelease.notes || '',
+        loaders: modrinth?.mod_loaders || [],
+        version_type: pluginConfig.release_type || 'release',
+        dependencies: modrinth?.dependencies || [],
+        featured: modrinth?.featured || false,
+        status: modrinth?.status || 'listed',
+        requested_status: modrinth?.requested_status || 'listed',
+        primary_file: primaryFilePartName,
     };
 
-    // 只有找到值时才添加 name 字段
-    if (displayName) {
-        versionData.name = displayName;
-    } else {
-        // 如果没有找到任何配置，使用默认值
-        versionData.name = context.nextRelease.name;
-    }
-
-    // 只有找到值时才添加 version_number 字段
-    if (versionNumber) {
-        versionData.version_number = versionNumber;
-    } else {
-        // 如果没有找到任何配置，使用默认值
-        versionData.version_number = nextReleaseVersion;
-    }
-
-    // 只添加存在的可选字段
-    if (modrinth?.changelog || context.nextRelease?.notes) {
-        versionData.changelog =
-            modrinth?.changelog || context.nextRelease?.notes || '';
-    }
-
-    if (modrinth?.game_versions && modrinth.game_versions.length > 0) {
-        versionData.game_versions = renderTemplates(modrinth.game_versions, {
-            nextRelease,
-        }) as string[];
-    } else if (
-        pluginConfig.game_versions &&
-        pluginConfig.game_versions.length > 0
-    ) {
-        versionData.game_versions = renderTemplates(
-            toArray(pluginConfig.game_versions),
-            {
-                nextRelease,
-            }
-        ) as string[];
-    }
-
-    // modLoaders 按照优先级：平台特定配置 > 全局配置 > 平台特定环境变量 > 全局环境变量
-    let modLoaders: string[] | undefined;
-    if (modrinth?.mod_loaders && modrinth.mod_loaders.length > 0) {
-        modLoaders = renderTemplates(modrinth.mod_loaders, {
-            nextRelease,
-        }) as string[];
-    } else if (
-        pluginConfig.mod_loaders &&
-        pluginConfig.mod_loaders.length > 0
-    ) {
-        modLoaders = renderTemplates(toArray(pluginConfig.mod_loaders), {
+    const displayName = resolveAndRenderTemplate(
+        [modrinth?.display_name, pluginConfig.display_name],
+        {
             nextRelease,
-        }) as string[];
-    } else if (env.MODRINTH_MOD_LOADERS) {
-        modLoaders = env.MODRINTH_MOD_LOADERS.split(',').map((s) => s.trim());
-    } else if (env.MOD_LOADERS) {
-        modLoaders = env.MOD_LOADERS.split(',').map((s) => s.trim());
-    }
-
-    if (modLoaders) {
-        versionData.loaders = modLoaders;
-    }
-
-    if (pluginConfig.release_type) {
-        versionData.version_type = pluginConfig.release_type;
-    }
-
-    if (modrinth?.dependencies && modrinth.dependencies.length > 0) {
-        versionData.dependencies = modrinth.dependencies;
-    }
-
-    if (modrinth?.featured !== undefined) {
-        versionData.featured = modrinth.featured;
-    }
-
-    if (modrinth?.status) {
-        versionData.status = modrinth.status;
-    }
-
-    if (modrinth?.requested_status) {
-        versionData.requested_status = modrinth.requested_status;
-    }
+            ...strategy,
+        }
+    );
 
-    // 只有当 finalPrimaryFile 存在时才添加 primary_file 字段
-    if (finalPrimaryFile) {
-        versionData.primary_file = finalPrimaryFile;
-    }
+    versionData.name = displayName || nextRelease.name;
 
-    // 添加版本信息作为 JSON
-    form.append('data', JSON.stringify(versionData));
+    const versionNumber = resolveAndRenderTemplate([modrinth?.version_number], {
+        nextRelease,
+        ...strategy,
+    });
 
-    // 发送版本创建请求
-    try {
-        const versionResponse = await axios.post(
-            'https://api.modrinth.com/v2/version',
-            form,
-            {
-                headers: {
-                    ...form.getHeaders(),
-                    Authorization: token,
-                },
-                validateStatus: (status) => status < 500, // 仅拒绝5xx错误
-            }
-        );
+    versionData.version_number = versionNumber || nextRelease.version;
 
-        // 检查响应状态码
-        if (versionResponse.status === 200) {
-            // 成功
-            logger.log(
-                `Successfully published to Modrinth: ${versionResponse.data.name || versionResponse.data.id}`
-            );
-            return versionResponse.data.id;
-        } else if (
-            versionResponse.status === 400 ||
-            versionResponse.status === 401
-        ) {
-            // 处理客户端错误
-            const data = versionResponse.data;
-            if (data && data.error && data.description) {
-                logger.error(
-                    `Modrinth API Error (${versionResponse.status}): ${data.error} - ${data.description}`
-                );
-                throw new Error(
-                    `Modrinth发布失败: ${data.error} - ${data.description}`
-                );
-            } else {
-                logger.error(
-                    `Modrinth API Error (${versionResponse.status}): ${JSON.stringify(data)}`
-                );
-                throw new Error(
-                    `Modrinth发布失败 (状态码: ${versionResponse.status}): ${JSON.stringify(data)}`
-                );
-            }
-        } else {
-            // 其他错误状态码
-            const data = versionResponse.data;
-            logger.error(
-                `Modrinth API Error (${versionResponse.status}): ${JSON.stringify(data)}`
-            );
-            throw new Error(
-                `Modrinth发布失败 (状态码: ${versionResponse.status}): ${JSON.stringify(data)}`
-            );
-        }
-    } catch (error: any) {
-        if (error.response) {
-            // 已经在上面处理过
-            throw error;
-        } else if (error.request) {
-            // 请求已发送但未收到响应
-            logger.error('Modrinth API 请求失败，未收到响应');
-            throw new Error('Modrinth发布失败: 未收到服务器响应');
-        } else {
-            // 请求配置出错
-            logger.error('Modrinth API 请求配置错误:', error.message);
-            throw new Error(`Modrinth发布失败: ${error.message}`);
+    const gameVersions = resolveAndRenderTemplates(
+        [modrinth?.game_versions, pluginConfig.game_versions],
+        {
+            nextRelease,
+            ...strategy,
         }
-    }
-}
+    );
 
-/**
- * 为 Modrinth 查找文件并确定主要文件
- */
-async function findModrinthFiles(
-    pluginConfig: Plugin_config,
-    context: PublishContext
-): Promise<{ files: string[]; primaryFile: string | undefined }> {
-    const { env, logger } = context;
+    versionData.game_versions = gameVersions || [];
 
-    // 获取 Modrinth 专用的 glob 配置，如果没有则使用全局配置
-    const modrinthGlob = resolveMultipleTemplate(
-        [
-            pluginConfig.modrinth?.glob,
-            pluginConfig.glob,
-            env.MODRINTH_GLOB,
-            env.GLOB,
-        ],
+    const modLoaders = resolveAndRenderTemplates(
+        [modrinth?.mod_loaders, pluginConfig.mod_loaders],
         {
-            nextRelease: context.nextRelease,
+            nextRelease,
+            ...strategy,
         }
     );
 
-    // 查找所有文件
-    const jarFiles = await findFiles(modrinthGlob, context);
-    logger.log(
-        `Found ${jarFiles.length} JAR file(s) for Modrinth: ${jarFiles.join(', ')}`
-    );
+    versionData.mod_loaders = modLoaders || [];
 
-    // 确定主要文件
-    let primaryFile: string | undefined = undefined;
+    form.append('data', versionData);
 
-    const primaryPatterns = resolveMultipleTemplate(
-        [
-            pluginConfig.modrinth?.primary_file_glob,
-            env.MODRINTH_PRIMARY_FILE_GLOB,
-        ],
+    const versionResponse = await axios.post(
+        'https://api.modrinth.com/v2/version',
+        form,
         {
-            nextRelease: context.nextRelease,
+            headers: {
+                ...form.getHeaders(),
+                Authorization: token,
+            },
+            validateStatus: (status) => status < 500,
         }
     );
 
-    if (primaryPatterns) {
-        let primaryCandidates: string[] = [];
-
-        for (const pattern of primaryPatterns) {
-            logger.log(`Searching for primary file with pattern: ${pattern}`);
-            const matches = await glob(pattern, {
-                cwd: context.cwd,
-                nodir: true,
-            });
-            primaryCandidates.push(
-                ...matches.map((file) => resolve(context.cwd!, file))
-            );
-        }
-
-        // 过滤出 JAR 文件并与找到的文件列表交叉检查
-        primaryCandidates = primaryCandidates
-            .filter((file) => file.endsWith('.jar'))
-            .filter((file) => jarFiles.includes(file));
+    const resData = versionResponse.data;
 
-        if (primaryCandidates.length === 1) {
-            primaryFile = primaryCandidates[0];
-            logger.log(`Selected primary file for Modrinth: ${primaryFile}`);
-        } else if (primaryCandidates.length > 1) {
-            throw new Error(
-                `Multiple files matched primaryFileGlob for Modrinth. Please specify a more specific pattern. Found: ${primaryCandidates.join(', ')}`
-            );
-        } else {
-            throw new Error(
-                `No files matched primaryFileGlob for Modrinth that were also in the main file list.`
-            );
-        }
-    } else if (jarFiles.length > 1) {
-        // 当有多个文件但没有指定 primaryFileGlob 时，需要指定主要文件
+    if (versionResponse.status === 200) {
+        logger.log(
+            `Successfully published to Modrinth: ${resData.project_id} (File ID: ${resData.file_id})`
+        );
+        return versionResponse.data.id;
+    } else if (
+        versionResponse.status === 400 ||
+        versionResponse.status === 401
+    ) {
         throw new Error(
-            `Multiple files found for Modrinth but no primaryFileGlob specified. Please specify which file should be primary.`
+            `Failed to publish to Modrinth (${versionResponse.status}): ${resData}`
+        );
+    } else {
+        throw new Error(
+            `Failed to publish to Modrinth (${versionResponse.status}): ${resData}`
         );
     }
-    // 当只有一个文件时，不设置 primaryFile，让网站做决定
-
-    return { files: jarFiles, primaryFile };
 }