@cmflow/cli 3.3.0 → 3.4.0-alpha.1

package/src/semantic/core/{analyze-commits.js → analyze-commits.ts}

@@ -1,17 +1,21 @@
 import * as commitAnalyzerPlugins from "@semantic-release/commit-analyzer";
+import type { ReleaseType } from "semantic-release";
+import type { SemanticContext } from "../../common/types.js";
 
 import { calculateSnapshotVersion } from "../utils/calculate-snapshot-version.js";
 
-export async function analyzeCommits(pluginConfig, context) {
+export async function analyzeCommits(pluginConfig: Record<string, unknown>, context: SemanticContext) {
   if (context.branch && context.branch.type !== "prerelease") {
     return commitAnalyzerPlugins.analyzeCommits(pluginConfig, context);
   }
 
   const analyzedCommits = await commitAnalyzerPlugins.analyzeCommits(pluginConfig, context);
   context.nextRelease = context.nextRelease || {};
-  context.nextRelease.type = analyzedCommits;
+  context.nextRelease.type = (analyzedCommits ?? undefined) as ReleaseType;
   context.nextRelease.version = calculateSnapshotVersion(context);
-  context.lastRelease.version = null;
+  if (context.lastRelease) {
+    (context.lastRelease as { version: string | null }).version = null;
+  }
 
   return "patch";
 }

package/src/semantic/core/{conditional.js → conditional.ts}

@@ -1,26 +1,33 @@
 import { getConfig } from "../../common/index.js";
+import type { SemanticContext } from "../../common/types.js";
 
-export function prepare(pluginConfig, context) {
+interface ConditionalPluginConfig {
+  when?: (context: SemanticContext) => boolean;
+  run?: string | string[];
+  [key: string]: unknown;
+}
+
+export function prepare(pluginConfig: ConditionalPluginConfig, context: SemanticContext) {
   return runAll("prepare", pluginConfig, context, context.branch?.type === "release");
 }
 
-export function success(pluginConfig, context) {
+export function success(pluginConfig: ConditionalPluginConfig, context: SemanticContext) {
   return runAll("success", pluginConfig, context, context.branch?.type === "release");
 }
 
-export function publish(pluginConfig, context) {
+export function publish(pluginConfig: ConditionalPluginConfig, context: SemanticContext) {
   return runAll("publish", pluginConfig, context, context.branch?.type === "release");
 }
 
-export function generateNotes(pluginConfig, context) {
+export function generateNotes(pluginConfig: ConditionalPluginConfig, context: SemanticContext) {
   return runAll("generateNotes", pluginConfig, context, context.branch?.type === "release");
 }
 
-export function fail(pluginConfig, context) {
+export function fail(pluginConfig: ConditionalPluginConfig, context: SemanticContext) {
   return runAll("fail", pluginConfig, context, context.branch?.type === "release");
 }
 
-async function runAll(step, pluginConfig, context, defaultCondition) {
+async function runAll(step: string, pluginConfig: ConditionalPluginConfig, context: SemanticContext, defaultCondition: boolean) {
   context.config = getConfig();
 
   const condition = pluginConfig.when !== undefined ? pluginConfig.when(context) : defaultCondition;
@@ -31,15 +38,15 @@ async function runAll(step, pluginConfig, context, defaultCondition) {
   }
 
   if (pluginConfig.run) {
-    const tasks = [].concat(pluginConfig.run);
+    const tasks: string[] = ([] as string[]).concat(pluginConfig.run as string);
 
     for (const task of tasks) {
       if (typeof task === "string") {
-        const mod = await import(task);
+        const mod = (await import(task)) as Record<string, (config: unknown, ctx: unknown) => Promise<void>>;
         const taskFunction = mod[step];
 
         if (taskFunction) {
-          context.logger.log(`   Start conditional step "${step}" of plugin "${task}"`);
+          context.logger.info(`   Start conditional step "${step}" of plugin "${task}"`);
 
           try {
             await taskFunction(pluginConfig, context);

package/src/semantic/core/{exit.js → exit.ts}

@@ -1,8 +1,9 @@
 import { getConfig } from "../../common/index.js";
+import type { SemanticContext } from "../../common/types.js";
 
-export default async function exit(pluginConfig, context) {
+export default async function exit(pluginConfig: Record<string, unknown>, context: SemanticContext) {
   context.config = getConfig();
-  const condition = pluginConfig.when !== undefined ? pluginConfig.when(context) : true;
+  const condition = pluginConfig.when !== undefined ? (pluginConfig.when as (ctx: SemanticContext) => boolean)(context) : true;
 
   if (condition) {
     // avoid next semantic-release steps when is a prerelease or release branch with SKIP_GITHUB_PUBLISH

package/src/semantic/core/prepare/{bump-version.js → bump-version.ts}

@@ -1,36 +1,39 @@
 import { getConfig, getPackageManager, lerna } from "../../../common/index.js";
 import { bumpPackagesVersion } from "../../utils/bump-packages-version.js";
+import type { SemanticContext } from "../../../common/types.js";
 
-export async function prepare(_, context) {
+export async function prepare(_: unknown, context: SemanticContext) {
   context.config = getConfig();
   const {
     config: { PACKAGE_MANAGER, HAS_LERNA, BUMP_METHOD, WORKSPACES },
     logger
   } = context;
-  const versionPackageManager = PACKAGE_MANAGER === "yarn" ? "npm" : PACKAGE_MANAGER;
+  const versionPackageManager = PACKAGE_MANAGER === "yarn" ? "npm" : (PACKAGE_MANAGER as string);
 
   logger.info(`Start bump version for all packages using method: ${BUMP_METHOD}`);
 
+  const version = context.nextRelease?.version ?? "";
+
   switch (BUMP_METHOD) {
     case "native":
       logger.info("Using package manager");
-      getPackageManager(PACKAGE_MANAGER).newVersion(context.nextRelease.version);
+      getPackageManager(PACKAGE_MANAGER as string).newVersion(version);
       break;
     case "lerna":
       if (HAS_LERNA) {
-        await lerna.newVersion(context.nextRelease.version);
+        await lerna.newVersion(version);
       }
       break;
     case "cmflow":
-      await bumpPackagesVersion(context.nextRelease.version, WORKSPACES);
-      await getPackageManager(PACKAGE_MANAGER).install();
+      await bumpPackagesVersion(version, WORKSPACES as string[]);
+      await getPackageManager(PACKAGE_MANAGER as string).install();
       break;
     case "native:lerna":
     default:
-      getPackageManager(versionPackageManager).newVersion(context.nextRelease.version);
+      getPackageManager(versionPackageManager).newVersion(version);
 
       if (HAS_LERNA) {
-        await lerna.newVersion(context.nextRelease.version);
+        await lerna.newVersion(version);
       }
   }
 

package/src/semantic/core/prepare/{commit.js → commit.ts}

@@ -1,6 +1,7 @@
 import { configureGitWorkspace, getConfig, git } from "../../../common/index.js";
+import type { SemanticContext } from "../../../common/types.js";
 
-export async function prepare(pluginConfig, context) {
+export async function prepare(pluginConfig: Record<string, unknown>, context: SemanticContext) {
   context.config = getConfig();
 
   const {
@@ -18,7 +19,7 @@ export async function prepare(pluginConfig, context) {
   logger.info("Get commit stage status");
   git.status();
 
-  const revisionMessage = `chore: ${CI_NAME} build ${context.branch.name} ${BUILD_NUMBER} ${context.nextRelease.gitTag} [ci skip]`;
+  const revisionMessage = `chore: ${CI_NAME} build ${context.branch.name} ${BUILD_NUMBER} ${context.nextRelease?.gitTag} [ci skip]`;
 
   logger.info("Commit changes with revision message: ");
   logger.info(revisionMessage);

package/src/semantic/core/prepare/release-info.ts

@@ -0,0 +1,6 @@
+import { writeFile } from "node:fs/promises";
+import type { SemanticContext } from "../../../common/types.js";
+
+export function prepare(pluginConfig: { path: string }, context: SemanticContext) {
+  return writeFile(pluginConfig.path, context.branch.name, { encoding: "utf-8" });
+}

package/src/semantic/core/{run.js → run.ts}

@@ -1,18 +1,19 @@
 import { getConfig, getPackageManager } from "../../common/index.js";
+import type { SemanticContext } from "../../common/types.js";
 
 /**
  * @param pluginConfig {{command: string}}
  * @param context
  * @return {Promise<void>}
  */
-export default async function runCommand(pluginConfig, context) {
+export default async function runCommand(pluginConfig: { command: string }, context: SemanticContext) {
   context.config = getConfig();
   const {
     config: { PACKAGE_MANAGER },
     logger
   } = context;
 
-  const pkgManager = getPackageManager(PACKAGE_MANAGER);
+  const pkgManager = getPackageManager(PACKAGE_MANAGER as string);
 
   logger.info(`Start ${pluginConfig.command} task`);
 

package/src/semantic/core/sync-repository.ts

@@ -0,0 +1,55 @@
+import { getConfig, git } from "../../common/index.js";
+import type { SemanticContext } from "../../common/types.js";
+
+export default async function syncRepository(pluginConfig: Record<string, unknown>, context: SemanticContext) {
+  context.config = getConfig();
+
+  const {
+    logger,
+    config: { PRODUCTION_BRANCH, ORIGIN, DEVELOP_BRANCH }
+  } = context;
+
+  logger.info("Prepare release");
+
+  async function asyncCatchError(fn: () => unknown) {
+    try {
+      return await fn();
+    } catch (er) {
+      context.logger.error(String(er), (er as Error).stack);
+    }
+  }
+
+  await asyncCatchError(() => git.fetch());
+
+  const branchesOption = context.options?.branches;
+  const branchesArray = Array.isArray(branchesOption) ? branchesOption : branchesOption ? [branchesOption] : [];
+  const candidateBranches =
+    (pluginConfig.includes as string[] | undefined) ||
+    branchesArray.map((branch: string | { name?: string }) => {
+      return (branch as { name?: string }).name || (branch as string);
+    });
+
+  logger.info(`Candidate branches to sync: ${(candidateBranches as string[]).join(", ")}`);
+
+  if ((candidateBranches as string[]).includes(context.branch.name)) {
+    logger.info(`Push ${context.branch.name}`);
+
+    await asyncCatchError(() => {
+      logger.info(`git push --quiet --set-upstream ${ORIGIN} ${context.branch.name}`);
+
+      return git.push("--quiet", "--set-upstream", ORIGIN as string, context.branch.name);
+    });
+  } else {
+    logger.info(`Skip push for ${context.branch.name}`);
+  }
+
+  if (PRODUCTION_BRANCH !== DEVELOP_BRANCH) {
+    logger.info(`Sync ${DEVELOP_BRANCH} with ${PRODUCTION_BRANCH}`);
+    logger.info(`git push -f ${ORIGIN} ${PRODUCTION_BRANCH}:refs/heads/${DEVELOP_BRANCH}`);
+
+    await asyncCatchError(async () => {
+      await git.push("-f", ORIGIN as string, `${PRODUCTION_BRANCH}:refs/heads/${DEVELOP_BRANCH}`);
+      logger.success(`${ORIGIN}/${DEVELOP_BRANCH} branch correctly updated`);
+    });
+  }
+}

package/src/semantic/core/{verify-conditions.js → verify-conditions.ts}

@@ -1,8 +1,9 @@
 import chalk from "chalk";
 
 import { getConfig, git } from "../../common/index.js";
+import type { SemanticContext } from "../../common/types.js";
 
-export function verifyConditions(pluginConfig, context) {
+export function verifyConditions(pluginConfig: Record<string, unknown>, context: SemanticContext) {
   if (pluginConfig.dryRun) {
     return;
   }
@@ -16,8 +17,8 @@ export function verifyConditions(pluginConfig, context) {
   if (USER && EMAIL) {
     context.logger.info("Configure git with username");
 
-    git.config("--global", "user.name", USER);
-    git.config("--global", "user.email", EMAIL);
+    git.config("--global", "user.name", USER as string);
+    git.config("--global", "user.email", EMAIL as string);
 
     context.logger.info("Configure git branch");
     context.logger.success("Workspace is correctly configured");

package/src/semantic/core/{verify-release.js → verify-release.ts}

@@ -1,8 +1,9 @@
 import { getConfig } from "../../common/index.js";
 import { displayPackageInfo } from "../utils/display-package-info.js";
 import { displayReleaseInfo } from "../utils/display-release-info.js";
+import type { SemanticContext } from "../../common/types.js";
 
-export function verifyRelease(pluginConfig, context) {
+export function verifyRelease(pluginConfig: Record<string, unknown>, context: SemanticContext) {
   context.config = getConfig();
   displayPackageInfo(context);
   displayReleaseInfo(context);

package/src/semantic/docker/publish.ts

@@ -0,0 +1,6 @@
+import { dockerPublish } from "../utils/docker-publish.js";
+import type { SemanticContext } from "../../common/types.js";
+
+export async function publish(pluginConfig: Record<string, unknown>, context: SemanticContext) {
+  await dockerPublish(context);
+}

package/src/semantic/docker/{success.js → success.ts}

@@ -1,6 +1,7 @@
+import type { CmContext } from "../../common/types.js";
 import { dockerCleanTags } from "../utils/docker-clean-tags.js";
 
-export async function success(pluginConfig, context) {
+export async function success(_: Record<string, unknown>, context: CmContext) {
   try {
     await dockerCleanTags(context);
   } catch (er) {

package/src/semantic/utils/{bump-packages-version.test.js → bump-packages-version.test.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import fs from "fs-extra";
 import path from "path";
 import * as url from "url";

package/src/semantic/utils/{bump-packages-version.js → bump-packages-version.ts}

@@ -1,10 +1,10 @@
 import fs from "fs-extra";
-import globby from "globby";
+import { globby } from "globby";
 import { dirname } from "path";
 
 const PACKAGE_JSON_PROPS = ["dependencies", "devDependencies", "peerDependencies"];
 
-export async function bumpPackagesVersion(version, workspaces, cwd = process.cwd()) {
+export async function bumpPackagesVersion(version: string, workspaces: string[], cwd = process.cwd()) {
   const patterns = workspaces.map((path) => `${path}/package.json`).concat("package.json");
 
   const files = await globby(patterns, {
@@ -12,13 +12,13 @@ export async function bumpPackagesVersion(version, workspaces, cwd = process.cwd
     absolute: true
   });
 
-  const names = new Set();
+  const names = new Set<string>();
 
   const packages = await Promise.all(
-    files.map(async (file) => {
-      const pkg = await fs.readJson(file);
+    files.map(async (file: string) => {
+      const pkg = (await fs.readJson(file)) as Record<string, unknown>;
 
-      names.add(pkg.name);
+      names.add(pkg.name as string);
 
       return {
         file,
@@ -28,7 +28,7 @@ export async function bumpPackagesVersion(version, workspaces, cwd = process.cwd
   );
 
   return Promise.all(
-    packages.map(({ pkg, file }) => {
+    packages.map(({ pkg, file }: { pkg: Record<string, unknown>; file: string }) => {
       pkg.version = version;
 
       PACKAGE_JSON_PROPS.forEach((key) => bumpDependencies(pkg, key, version, names));
@@ -39,13 +39,14 @@ export async function bumpPackagesVersion(version, workspaces, cwd = process.cwd
   );
 }
 
-function bumpDependencies(pkg, key, version, names) {
+function bumpDependencies(pkg: Record<string, unknown>, key: string, version: string, names: Set<string>) {
   pkg[key] = pkg[key] || {};
 
-  if (pkg[key]) {
+  const deps = pkg[key] as Record<string, string>;
+  if (deps) {
     names.forEach((name) => {
-      if (pkg[key][name] && !pkg[key][name].startsWith("workspace:")) {
-        pkg[key][name] = version;
+      if (deps[name] && !deps[name].startsWith("workspace:")) {
+        deps[name] = version;
       }
     });
   }

package/src/semantic/utils/{calculate-snapshot-version.test.js → calculate-snapshot-version.test.ts}

@@ -1,3 +1,7 @@
+import { git, getConfig } from "../../common/index.js";
+import type { CmContext } from "../../common/types";
+import { calculateSnapshotVersion } from "./calculate-snapshot-version.js";
+
 vi.mock("../../common/index.js", () => {
   return {
     git: {
@@ -6,19 +10,17 @@ vi.mock("../../common/index.js", () => {
     getConfig: vi.fn()
   };
 });
-const { git, getConfig } = await import("../../common/index.js");
-const { calculateSnapshotVersion } = await import("./calculate-snapshot-version.js");
 
 describe("calculateSnapshotVersion", () => {
   beforeEach(() => {
-    git.getCommitTag.mockReturnValue("13246u");
-    getConfig.mockReturnValue({
+    vi.mocked(git.getCommitTag).mockReturnValue("13246u");
+    vi.mocked(getConfig).mockReturnValue({
       DEPLOY_ON_DOCKER: true,
       PRODUCTION_BRANCH: "production",
       DOCKER_REPOSITORY: "owner",
       DOCKER_HUB_ID: "login",
       DOCKER_HUB_PWD: "password"
-    });
+    } as unknown as CmContext["config"]);
   });
   it("should return the snapshot version", () => {
     const context = {
@@ -26,7 +28,7 @@ describe("calculateSnapshotVersion", () => {
       lastRelease: {
         version: "1.0.0"
       }
-    };
+    } as CmContext;
 
     const version = calculateSnapshotVersion(context);
     expect(git.getCommitTag).toHaveBeenCalledWith(context.config.REF_COMMIT);
@@ -42,7 +44,7 @@ describe("calculateSnapshotVersion", () => {
       config: {
         REF_COMMIT: "REF_COMMIT"
       }
-    };
+    } as CmContext;
 
     const version = calculateSnapshotVersion(context);
     expect(git.getCommitTag).toHaveBeenCalledWith(context.config.REF_COMMIT);
@@ -58,7 +60,7 @@ describe("calculateSnapshotVersion", () => {
       config: {
         REF_COMMIT: "REF_COMMIT"
       }
-    };
+    } as CmContext;
 
     const version = calculateSnapshotVersion(context);
     expect(git.getCommitTag).toHaveBeenCalledWith(context.config.REF_COMMIT);

package/src/semantic/utils/calculate-snapshot-version.ts

@@ -0,0 +1,17 @@
+import semver from "semver";
+
+import { getConfig, git } from "../../common/index.js";
+import type { SemanticContext } from "../../common/types.js";
+
+export function calculateSnapshotVersion(context: SemanticContext) {
+  context.config = getConfig();
+  const {
+    nextRelease,
+    lastRelease,
+    config: { REF_COMMIT }
+  } = context;
+  const parsed = semver.parse(lastRelease?.version ?? "0.0.0");
+  const { major, minor, patch } = parsed ?? { major: 0, minor: 0, patch: 0 };
+
+  return `${semver.inc(`${major}.${minor}.${patch}`, nextRelease?.type ?? "patch") ?? "0.0.0"}-beta${git.getCommitTag(REF_COMMIT as string)}`;
+}

package/src/semantic/utils/display-package-info.ts

@@ -0,0 +1,12 @@
+import { logSection } from "./log-section.js";
+import type { SemanticContext } from "../../common/types.js";
+
+export function displayPackageInfo(context: SemanticContext) {
+  logSection("Package Info", context);
+  context.logger.info("Name       : " + context.config.PROJECT_NAME);
+  context.logger.info("Version    : " + context.lastRelease?.version);
+  context.logger.info("Repository : " + context.config.REPOSITORY_URL);
+  context.logger.info("Branch     : " + context.branch.name);
+  context.logger.info("Tag        : " + context.lastRelease?.gitTag);
+  context.logger.info("GitHead    : " + context.lastRelease?.gitHead);
+}

package/src/semantic/utils/display-release-info.ts

@@ -0,0 +1,13 @@
+import { logSection } from "./log-section.js";
+import type { SemanticContext } from "../../common/types.js";
+
+export function displayReleaseInfo(context: SemanticContext) {
+  logSection("Release Info", context);
+  context.logger.info("Branch   : " + context.branch.name);
+  context.logger.info("Build N° : " + context.config.BUILD_NUMBER);
+  context.logger.info("Version  : " + context.nextRelease?.version);
+  context.logger.info("Tag      : " + context.nextRelease?.gitTag);
+  context.logger.info("GitHead  : " + context.nextRelease?.gitHead);
+  context.logger.info("Type     : " + context.nextRelease?.type);
+  context.logger.info("Channel  : " + context.nextRelease?.channel);
+}

package/src/semantic/utils/{docker-clean-tags.test.js → docker-clean-tags.test.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 vi.mock("../../common", () => {
   return {
     docker: {

package/src/semantic/utils/{docker-clean-tags.js → docker-clean-tags.ts}

@@ -1,7 +1,14 @@
 import { docker } from "../../common/index.js";
+import type { CmContext } from "../../common/types";
 
-function mapTags(tags) {
-  tags = tags
+interface DockerTag {
+  name: string;
+  last_updated: string | Date;
+  date?: number;
+}
+
+function mapTags(tags: DockerTag[]) {
+  const mapped = tags
     .map((tag) => {
       return {
         name: tag.name,
@@ -12,7 +19,7 @@ function mapTags(tags) {
 
   let tagFound = false;
 
-  return tags.reduce((result, tag) => {
+  return mapped.reduce((result: typeof mapped, tag) => {
     if (tag.name.match(/\d+\.\d+\.\d+/)) {
       tagFound = true;
     } else if (tagFound) {
@@ -22,7 +29,7 @@ function mapTags(tags) {
   }, []);
 }
 
-export async function dockerCleanTags(context) {
+export async function dockerCleanTags(context: CmContext) {
   const {
     logger,
     config: { DOCKER_HUB_ID, DOCKER_HUB_PWD, DOCKER_REPOSITORY }

package/src/semantic/utils/{docker-publish.test.js → docker-publish.test.ts}

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { docker } from "../../common/cli/docker.js";
 import { getConfig } from "../../common/get-config.js";
 import { dockerPublish } from "./docker-publish.js";

package/src/semantic/utils/{docker-publish.js → docker-publish.ts}

@@ -1,18 +1,19 @@
 import { docker } from "../../common/cli/docker.js";
 import { getConfig } from "../../common/get-config.js";
+import type { SemanticContext } from "../../common/types.js";
 
-export async function dockerPublish(context) {
+export async function dockerPublish(context: SemanticContext) {
   context.config = getConfig();
   const {
     logger,
     config: { PRODUCTION_BRANCH, DOCKER_REPOSITORY, DOCKER_HUB_ID, DOCKER_HUB_PWD }
   } = context;
 
-  docker.login("-u", DOCKER_HUB_ID, "-p", DOCKER_HUB_PWD);
+  docker.login("-u", DOCKER_HUB_ID as string, "-p", DOCKER_HUB_PWD as string);
 
   const image =
     PRODUCTION_BRANCH === context.branch.name
-      ? `${DOCKER_REPOSITORY}:${context.nextRelease.version}`
+      ? `${DOCKER_REPOSITORY}:${context.nextRelease?.version}`
       : `${DOCKER_REPOSITORY}:${context.branch.name}`;
   logger.info("context.branch.name : ", context.branch.name);
   logger.info("context.nextRelease.version : ", context.nextRelease && context.nextRelease.version);

package/src/semantic/utils/{log-section.js → log-section.ts}

@@ -1,4 +1,8 @@
-export function logSection(title, context) {
+interface LogContext {
+  logger: { info: (...args: unknown[]) => void };
+}
+
+export function logSection(title: string, context: LogContext) {
   context.logger.info("-----------------------------------");
   context.logger.info(`--- ${title}`);
   context.logger.info("-----------------------------------");

package/src/semantic/utils/{transform-writer.js → transform-writer.ts}

@@ -1,24 +1,48 @@
 import { WORKFLOW_CONFIGURATION } from "../../workflow/index.js";
 
-const commitTypeMapping = WORKFLOW_CONFIGURATION.reduce((obj, { type, label }) => {
-  return {
-    ...obj,
-    [type]: label
-  };
-}, {});
-
-const transformCommitType = (commit) => {
+type CommitTypeMapping = Record<string, string>;
+
+const commitTypeMapping: CommitTypeMapping = WORKFLOW_CONFIGURATION.reduce(
+  (obj: CommitTypeMapping, { type, label }: { type: string; label: string }) => {
+    return {
+      ...obj,
+      [type]: label
+    };
+  },
+  {} as CommitTypeMapping
+);
+
+interface Commit {
+  type: string;
+  message?: string;
+  subject?: string;
+  scope?: string;
+  hash?: string;
+  shortHash?: string;
+  notes: Array<{ title: string }>;
+  references: Array<{ issue: string }>;
+  [key: string]: unknown;
+}
+
+interface TransformContext {
+  repository?: string;
+  host?: string;
+  owner?: string;
+  repoUrl?: string;
+}
+
+const transformCommitType = (commit: Commit): string => {
   if (commitTypeMapping[commit.type]) {
     return commitTypeMapping[commit.type];
   }
 
-  return commitTypeMapping.default;
+  return commitTypeMapping["default"] ?? commit.type;
 };
 
-export function transformWriter(commit, context) {
+export function transformWriter(commit: Commit, context: TransformContext) {
   commit = { ...commit };
 
-  const issues = [];
+  const issues: string[] = [];
 
   commit.notes.forEach((note) => {
     note.title = "BREAKING CHANGES";
@@ -47,14 +71,14 @@ export function transformWriter(commit, context) {
     if (url) {
       url = `${url}/issues/`;
       // Issue URLs.
-      commit.subject = commit.subject.replace(/#([0-9]+)/g, (_, issue) => {
+      commit.subject = commit.subject.replace(/#([0-9]+)/g, (_, issue: string) => {
         issues.push(issue);
         return `[#${issue}](${url}${issue})`;
       });
     }
     if (context.host) {
       // User URLs.
-      commit.subject = commit.subject.replace(/\B@([a-z0-9](?:-?[a-z0-9/]){0,38})/g, (_, username) => {
+      commit.subject = commit.subject.replace(/\B@([a-z0-9](?:-?[a-z0-9/]){0,38})/g, (_, username: string) => {
         if (username.includes("/")) {
           return `@${username}`;
         }