fix: improve validation error messages using zod

- replace `microstruct` with `zod`

- downgrade `aggregate-error` for `semantic-release` v19 or earlier

Author: iorate

package.json

@@ -8,15 +8,16 @@
   },
   "dependencies": {
     "@semantic-release/error": "^3.0.0",
-    "aggregate-error": "^4.0.1",
+    "aggregate-error": "^3.1.0",
     "axios": "^1.2.2",
     "execa": "^6.1.0",
     "form-data": "^4.0.0",
     "jsonwebtoken": "^9.0.0",
     "lodash.template": "^4.5.0",
     "marked": "^4.2.5",
-    "microstruct": "^2.0.4",
-    "zip-dir": "^2.0.0"
+    "zip-dir": "^2.0.0",
+    "zod": "^3.20.2",
+    "zod-validation-error": "^0.3.0"
   },
   "devDependencies": {
     "@types/jsonwebtoken": "^9.0.1",

src/common.ts

@@ -1,25 +1,25 @@
 import SemanticReleaseError from '@semantic-release/error';
 import template from 'lodash.template';
-import * as S from 'microstruct';
 import type { Context } from 'semantic-release';
+import { z } from 'zod';
 
-export function createError(message: string): SemanticReleaseError {
-  return new SemanticReleaseError(message, '\u{1f98a}');
+export function createError(message: string, details?: string): SemanticReleaseError {
+  return new SemanticReleaseError(message, '\u{1f98a}', details);
 }
 
-export const pluginConfigStruct = S.type({
-  addonId: S.string(),
-  addonDirPath: S.string(),
-  addonZipPath: S.optional(S.string()),
-  channel: S.optional(S.enums(['unlisted', 'listed'] as const)),
-  approvalNotes: S.optional(S.nullable(S.string())),
-  compatibility: S.optional(S.array(S.enums(['android', 'firefox'] as const))),
-  submitReleaseNotes: S.optional(S.boolean()),
-  submitSource: S.optional(S.boolean()),
-  sourceZipPath: S.optional(S.string()),
+export const pluginConfigSchema = z.object({
+  addonId: z.string(),
+  addonDirPath: z.string(),
+  addonZipPath: z.string().optional(),
+  channel: z.enum(['unlisted', 'listed']).optional(),
+  approvalNotes: z.string().min(1).nullable().optional(),
+  compatibility: z.enum(['android', 'firefox']).array().min(1).optional(),
+  submitReleaseNotes: z.boolean().optional(),
+  submitSource: z.boolean().optional(),
+  sourceZipPath: z.string().optional(),
 });
 
-export type PluginConfig = S.Infer<typeof pluginConfigStruct>;
+export type PluginConfig = NoUndefined<z.infer<typeof pluginConfigSchema>>;
 
 export function applyDefaults(pluginConfig: Readonly<PluginConfig>): Required<PluginConfig> {
   return {
@@ -34,12 +34,23 @@ export function applyDefaults(pluginConfig: Readonly<PluginConfig>): Required<Pl
   };
 }
 
-// For `prepare` and `publish` steps
-export type FullContext = { [K in keyof Context]-?: Exclude<Context[K], undefined> };
+export const envSchema = z.object({
+  AMO_API_KEY: z.string(),
+  AMO_API_SECRET: z.string(),
+  AMO_BASE_URL: z.string().url().optional(),
+});
+
+export type Env = NoUndefined<z.infer<typeof envSchema>>;
+
+// For the `prepare` and `publish` steps
+export type FullContext = Required<NoUndefined<Context>> & { env: Env };
 
 export function applyContext(
   temp: string,
   { branch, lastRelease, nextRelease, commits }: Readonly<FullContext>,
 ): string {
   return template(temp)({ branch, lastRelease, nextRelease, commits });
 }
+
+// "exactOptionalPropertyTypes": true
+type NoUndefined<T> = { [K in keyof T]: Exclude<T[K], undefined> };

src/external.d.ts

@@ -1,6 +1,6 @@
 declare module '@semantic-release/error' {
   class SemanticReleaseError extends Error {
-    constructor(message?: string, code?: string);
+    constructor(message?: string, code?: string, details?: string);
   }
   export = SemanticReleaseError;
 }

src/prepare.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import * as S from 'microstruct';
 import zipDir from 'zip-dir';
+import { z } from 'zod';
 import { FullContext, PluginConfig, applyContext, applyDefaults, createError } from './common';
 
 export async function prepare(
@@ -20,9 +20,11 @@ export async function prepare(
 
   logger.log('Updating manifest.json...');
   const manifestJsonPath = path.join(addonDirPath, 'manifest.json');
-  const mainfestJson = await fs.readFile(manifestJsonPath, 'utf8');
-  const manifest = S.parse(mainfestJson, S.type({ version: S.optional(S.string()) }));
-  if (!manifest) {
+  const manifestJson = await fs.readFile(manifestJsonPath, 'utf8');
+  let manifest;
+  try {
+    manifest = z.record(z.string(), z.unknown()).parse(JSON.parse(manifestJson));
+  } catch {
     throw createError(`Invalid manifest.json: ${manifestJsonPath}`);
   }
   manifest.version = nextRelease.version;

src/publish.ts

@@ -30,19 +30,14 @@ export async function publish(
   const { env, logger, nextRelease } = context;
   const baseURL = env.AMO_BASE_URL ?? 'https://addons.mozilla.org/';
 
-  if (approvalNotes === '') {
-    logger.warn('Approval notes are empty. Skipping submission of approval notes.');
-  }
   if (submitReleaseNotes && !nextRelease.notes) {
     logger.warn('Release notes are empty. Skipping submission of release notes.');
   }
 
   try {
     await updateAddon({
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      apiKey: env.AMO_API_KEY!,
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      apiSecret: env.AMO_API_SECRET!,
+      apiKey: env.AMO_API_KEY,
+      apiSecret: env.AMO_API_SECRET,
       baseURL,
       addonId,
       addonZipPath,

src/update-addon.ts

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import axios, { AxiosResponse } from 'axios';
 import FormData from 'form-data';
 import jwt from 'jsonwebtoken';
-import * as S from 'microstruct';
+import { z } from 'zod';
 
 export class UpdateAddonError extends Error {
   constructor(message: string) {
@@ -89,12 +89,12 @@ function throwBadResponse(path: string, response: AxiosResponse): never {
 
 type APIParams = Pick<UpdateAddonParams, 'apiKey' | 'apiSecret' | 'baseURL'>;
 
-async function apiFetch<T>(
+async function apiFetch<T, Schema extends z.ZodType<T>>(
   { apiKey, apiSecret, baseURL }: Readonly<APIParams>,
   method: string,
   path: string,
   body: Readonly<Record<string, unknown>> | FormData | null,
-  validator: S.Struct<T>,
+  schema: Schema,
 ): Promise<T> {
   try {
     const response = await axios({
@@ -105,10 +105,11 @@ async function apiFetch<T>(
       },
       data: body,
     });
-    if (!S.is(response.data, validator)) {
+    const result = schema.safeParse(response.data);
+    if (!result.success) {
       throwBadResponse(path, response);
     }
-    return response.data;
+    return result.data;
   } catch (error: unknown) {
     if (axios.isAxiosError(error) && error.response) {
       throwBadResponse(path, error.response);
@@ -118,14 +119,14 @@ async function apiFetch<T>(
   }
 }
 
-const uploadStruct = S.type({
-  uuid: S.string(),
-  processed: S.boolean(),
-  valid: S.boolean(),
-  validation: S.nullable(S.record(S.string(), S.unknown())),
+const uploadSchema = z.object({
+  uuid: z.string(),
+  processed: z.boolean(),
+  valid: z.boolean(),
+  validation: z.record(z.string(), z.unknown()).nullable(),
 });
 
-type Upload = S.Infer<typeof uploadStruct>;
+type Upload = z.infer<typeof uploadSchema>;
 
 function createUpload(
   apiParams: Readonly<APIParams>,
@@ -134,16 +135,16 @@ function createUpload(
   const formData = new FormData();
   formData.append('upload', upload);
   formData.append('channel', channel);
-  return apiFetch(apiParams, 'POST', 'upload/', formData, uploadStruct);
+  return apiFetch(apiParams, 'POST', 'upload/', formData, uploadSchema);
 }
 
 function getUpload(apiParams: Readonly<APIParams>, uuid: string): Promise<Upload> {
-  return apiFetch(apiParams, 'GET', `upload/${uuid}/`, null, uploadStruct);
+  return apiFetch(apiParams, 'GET', `upload/${uuid}/`, null, uploadSchema);
 }
 
-const versionStruct = S.type({ id: S.number() });
+const versionSchema = z.object({ id: z.number() });
 
-type Version = S.Infer<typeof versionStruct>;
+type Version = z.infer<typeof versionSchema>;
 
 function createVersion(
   apiParams: Readonly<APIParams>,
@@ -155,7 +156,7 @@ function createVersion(
     release_notes?: Readonly<Record<string, string>>;
   }>,
 ): Promise<Version> {
-  return apiFetch(apiParams, 'POST', `addon/${addonId}/versions/`, body, versionStruct);
+  return apiFetch(apiParams, 'POST', `addon/${addonId}/versions/`, body, versionSchema);
 }
 
 function patchVersion(
@@ -166,7 +167,7 @@ function patchVersion(
 ): Promise<Version> {
   const formData = new FormData();
   formData.append('source', source);
-  return apiFetch(apiParams, 'PATCH', `addon/${addonId}/versions/${id}/`, formData, versionStruct);
+  return apiFetch(apiParams, 'PATCH', `addon/${addonId}/versions/${id}/`, formData, versionSchema);
 }
 
 function waitForValidation(apiParams: Readonly<APIParams>, uuid: string): Promise<void> {
@@ -176,7 +177,7 @@ function waitForValidation(apiParams: Readonly<APIParams>, uuid: string): Promis
       if (intervalId) {
         clearTimeout(intervalId);
       }
-      reject(new UpdateAddonError('Validation Timeout'));
+      reject(new UpdateAddonError('Validation timeout'));
     }, 300000); // 5 minutes
     const poll = () =>
       void getUpload(apiParams, uuid)
@@ -186,7 +187,7 @@ function waitForValidation(apiParams: Readonly<APIParams>, uuid: string): Promis
             if (valid) {
               resolve();
             } else {
-              reject(new UpdateAddonError(`Validation Error: ${JSON.stringify(validation)}`));
+              reject(new UpdateAddonError(`Validation error: ${JSON.stringify(validation)}`));
             }
           } else {
             intervalId = setTimeout(poll, 1000); // 1 second

src/verify-conditions.ts

@@ -1,8 +1,8 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import * as S from 'microstruct';
 import type { Context } from 'semantic-release';
-import { createError, pluginConfigStruct } from './common';
+import { fromZodError } from 'zod-validation-error';
+import { createError, envSchema, pluginConfigSchema } from './common';
 
 async function exists(path: string): Promise<boolean> {
   try {
@@ -25,22 +25,28 @@ export async function verifyConditions(
 
   const errors = [];
 
-  if (!S.is(pluginConfig, pluginConfigStruct)) {
-    errors.push(createError(`Invalid plugin config: ${JSON.stringify(pluginConfig)}`));
-  } else if (!(await exists(pluginConfig.addonDirPath))) {
-    errors.push(createError(`Missing add-on directory: ${pluginConfig.addonDirPath}`));
+  const pluginConfigResult = pluginConfigSchema.safeParse(pluginConfig);
+  if (!pluginConfigResult.success) {
+    errors.push(
+      createError('Invalid plugin config', fromZodError(pluginConfigResult.error).message),
+    );
   } else {
-    const mainfestJsonPath = path.join(pluginConfig.addonDirPath, 'manifest.json');
-    if (!(await exists(mainfestJsonPath))) {
-      errors.push(createError(`Missing manifest.json: ${mainfestJsonPath}`));
+    const { addonDirPath } = pluginConfigResult.data;
+    if (!(await exists(addonDirPath))) {
+      errors.push(createError(`Missing add-on directory: ${addonDirPath}`));
+    } else {
+      const manifestJsonPath = path.join(addonDirPath, 'manifest.json');
+      if (!(await exists(manifestJsonPath))) {
+        errors.push(createError(`Missing manifest.json: ${manifestJsonPath}`));
+      }
     }
   }
 
-  if (env.AMO_API_KEY == null) {
-    errors.push(createError('Missing environment variable: AMO_API_KEY'));
-  }
-  if (env.AMO_API_SECRET == null) {
-    errors.push(createError('Missing environment variable: AMO_API_SECRET'));
+  const envResult = envSchema.safeParse(env);
+  if (!envResult.success) {
+    errors.push(
+      createError('Invalid environment variables', fromZodError(envResult.error).message),
+    );
   }
 
   if (errors.length) {