@cluerise/tools 3.0.0

package/README.md

@@ -0,0 +1,52 @@
+# Cluerise Tools
+
+_Tools for maintaining TypeScript projects_
+
+## Tools
+
+### Init
+
+```
+npx @cluerise/tools init [all|name]
+```
+
+Before you run the `init` command, make sure your `package.json` contains
+
+- the `"type"` field set to `"module"`,
+- the `"repository"` field set to a valid value (e.g. `"github:org/repo"`).
+
+### Lint
+
+```
+cluerise-tools lint [all|code|staged|commit]
+```
+
+### Release
+
+```
+cluerise-tools release [create|extract-changelog]
+```
+
+### Update Node.js versions
+
+```
+cluerise-tools update-node-versions
+```
+
+### Create Commit Message
+
+```
+cluerise-tools create-commit-message
+```
+
+### Format Commit Message
+
+```
+cluerise-tools format-commit-message
+```
+
+### Check Heroku Node.js Version
+
+```
+cluerise-tools check-heroku-node-version
+```

package/dist/bin/cluenar-tools.sh

@@ -0,0 +1,10 @@
+#!/bin/sh
+
+fileArg="$0"
+scriptArg="$1"
+shift
+
+filePath=$(readlink -f "$fileArg")
+fileDir=$(dirname "$filePath")
+
+node "$fileDir/../scripts/$scriptArg/main.js" "$@"

package/dist/configs/.editorconfig

@@ -0,0 +1,10 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+max_line_length = 120

package/dist/configs/.eslintignore

@@ -0,0 +1,47 @@
+# All hidden files and directories
+.*
+
+# Enable hidden files with extensions
+!.*.*
+
+# Enable all hidden directories
+!.*/
+
+# Archives
+*.zip
+*.gz
+*.tgz
+
+# Build
+build/
+dist/
+
+# Dependencies
+node_modules/
+
+# Git
+.git/
+
+# Git hooks
+hooks/*
+!hooks/*.js
+!hooks/*.ts
+
+# Lock files
+package-lock.json
+yarn.lock
+
+# Misc
+etc/
+
+# Sample of .env and .envrc files
+.env.example
+.env.sample
+.envrc.example
+.envrc.sample
+
+# Shell scripts
+*.sh
+
+# Tests coverage
+coverage/

package/dist/configs/.eslintrc.cjs

@@ -0,0 +1,114 @@
+const importRestrictions = {
+  srcDirectory: {
+    group: ['src/*'],
+    message: '\n  Error: Do not import from the src directory'
+  },
+  nestedDirectories: {
+    group: ['./*/*'],
+    message: '\n  Error: Do not import from nested directories'
+  },
+  nestedModules: {
+    group: Array.from({ length: 10 }, (_, i) => `:/modules${'/*'.repeat(i + 2)}`),
+    message: '\n  Error: Do not import from nested modules'
+  },
+  nestedDirectoriesInParentModules: {
+    group: Array.from({ length: 10 }, (_, i) => [`${`../`.repeat(i + 1)}*/**`, `!${`../`.repeat(i + 1)}../*`]).flat(),
+    message: '\n  Error: Do not import from nested directories in parent modules'
+  },
+  appDirectoryInModules: {
+    group: [':/app', ':/app/**'],
+    message: '\n  Error: Do not import from the app directory in the modules'
+  }
+};
+
+const commonImportRestrictions = [
+  importRestrictions.srcDirectory,
+  importRestrictions.nestedDirectories,
+  importRestrictions.nestedModules,
+  importRestrictions.nestedDirectoriesInParentModules
+];
+
+module.exports = {
+  env: {
+    es6: true,
+    node: true
+  },
+  extends: [
+    'eslint:recommended',
+    'plugin:@typescript-eslint/recommended',
+    'plugin:prettier/recommended',
+    'plugin:json/recommended-with-comments',
+    'plugin:markdown/recommended-legacy',
+    'plugin:yml/standard'
+  ],
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    ecmaVersion: 2018,
+    sourceType: 'module'
+  },
+  plugins: ['import', 'simple-import-sort', '@html-eslint'],
+  rules: {
+    '@typescript-eslint/ban-ts-comment': 'off',
+    '@typescript-eslint/explicit-module-boundary-types': 'off',
+    '@typescript-eslint/no-unused-vars': 'off',
+
+    'import/first': 'error',
+    'import/newline-after-import': 'error',
+    'import/no-amd': 'error',
+    'import/no-commonjs': 'error',
+    'import/no-default-export': 'error',
+    'import/no-duplicates': 'error',
+    'import/no-mutable-exports': 'error',
+    'import/no-unassigned-import': 'error',
+    'import/order': 'off',
+
+    'no-restricted-imports': ['error', { patterns: commonImportRestrictions }],
+    'no-undef-init': 'error',
+    'object-shorthand': 'error',
+
+    'simple-import-sort/exports': 'error',
+    'simple-import-sort/imports': 'error',
+
+    'sort-imports': 'off',
+
+    'yml/no-empty-mapping-value': 'off',
+    'yml/quotes': ['error', { prefer: 'single' }]
+  },
+  overrides: [
+    {
+      files: ['*.cjs', '*.cts'],
+      rules: {
+        'import/no-commonjs': 'off',
+        '@typescript-eslint/no-var-requires': 'off'
+      }
+    },
+    {
+      files: ['*.config.js', '*.config.ts'],
+      rules: {
+        'import/no-default-export': 'off'
+      }
+    },
+    {
+      files: ['src/modules/**'],
+      rules: {
+        'no-restricted-imports': [
+          'error',
+          { patterns: [importRestrictions.appDirectoryInModules, ...commonImportRestrictions] }
+        ]
+      }
+    },
+    {
+      files: ['*.yaml', '*.yml'],
+      parser: 'yaml-eslint-parser'
+    },
+    {
+      files: ['*.html'],
+      parser: '@html-eslint/parser',
+      extends: ['plugin:@html-eslint/recommended'],
+      rules: {
+        '@html-eslint/require-title': 'off',
+        '@html-eslint/indent': ['error', 2]
+      }
+    }
+  ]
+};

package/dist/configs/.nvmrc

@@ -0,0 +1 @@
+v22.1.0

package/dist/configs/.prettierignore

@@ -0,0 +1,37 @@
+# All hidden files and directories
+.*
+
+# Enable hidden files with extensions
+!.*.*
+
+# Enable all hidden directories
+!.*/
+
+# Build
+build/
+dist/
+
+# Dependencies
+node_modules/
+
+# Git
+.git/
+
+# Git hooks
+hooks/*
+!hooks/*.js
+!hooks/*.ts
+
+# Lock files
+package-lock.json
+yarn.lock
+
+# Misc
+etc/
+
+# Sample of .env file
+.env.example
+.env.sample
+
+# Tests coverage
+coverage/

package/dist/configs/_gitignore

@@ -0,0 +1,23 @@
+# Build
+build/
+dist/
+
+# Dependencies
+node_modules/
+
+# .env, .envrc
+.env
+.envrc
+
+# Lint Staged
+.lint-staged-temp-tsconfig.json
+
+# Misc
+.DS_Store
+etc/
+
+# Stryker
+.stryker-tmp/
+
+# Tests coverage
+coverage/

package/dist/configs/_npmrc

@@ -0,0 +1 @@
+engine-strict = true

package/dist/configs/commitlint.config.ts

@@ -0,0 +1,31 @@
+import { RuleConfigSeverity, UserConfig } from '@commitlint/types';
+
+const commitlintConfig: UserConfig = {
+  parserPreset: 'conventional-changelog-conventionalcommits',
+  rules: {
+    'body-full-stop': [RuleConfigSeverity.Error, 'always', '.'],
+    'body-leading-blank': [RuleConfigSeverity.Error, 'always'],
+    'body-case': [RuleConfigSeverity.Error, 'always', 'sentence-case'],
+
+    'footer-leading-blank': [RuleConfigSeverity.Error, 'always'],
+
+    'header-full-stop': [RuleConfigSeverity.Error, 'never', '.'],
+    'header-max-length': [RuleConfigSeverity.Error, 'always', 100],
+
+    'scope-case': [RuleConfigSeverity.Error, 'always', 'lower-case'],
+    'scope-enum': [RuleConfigSeverity.Error, 'always', ['actions', 'dev', 'lock', 'prod', 'security']],
+
+    'subject-case': [RuleConfigSeverity.Error, 'always', 'sentence-case'],
+    'subject-empty': [RuleConfigSeverity.Error, 'never'],
+
+    'type-case': [RuleConfigSeverity.Error, 'always', 'lower-case'],
+    'type-enum': [
+      RuleConfigSeverity.Error,
+      'always',
+      ['chore', 'deps', 'docs', 'feat', 'fix', 'perf', 'refactor', 'release', 'revert', 'style', 'test']
+    ],
+    'type-empty': [RuleConfigSeverity.Error, 'never']
+  }
+};
+
+export default commitlintConfig;

package/dist/configs/hooks/commit-msg

@@ -0,0 +1 @@
+npm run __git-hook:commit-msg --if-present "$@"

package/dist/configs/hooks/post-commit

@@ -0,0 +1 @@
+npm run __git-hook:post-commit --if-present "$@"

package/dist/configs/hooks/pre-commit

@@ -0,0 +1 @@
+npm run __git-hook:pre-commit --if-present "$@"

package/dist/configs/hooks/prepare-commit-msg

@@ -0,0 +1 @@
+npm run __git-hook:prepare-commit-msg --if-present "$@"

package/dist/configs/lint-staged.config.js

@@ -0,0 +1,31 @@
+import FileSystem from 'fs';
+import Path from 'path';
+
+const tsconfigPath = '.lint-staged-temp-tsconfig.json';
+
+const toRelative = (filename) => Path.relative('.', filename);
+const mapToRelative = (filenames) => filenames.map(toRelative);
+
+export default {
+  '**': (filenames) => {
+    const relativeFilenames = mapToRelative(filenames).join(' ');
+
+    return [`eslint ${relativeFilenames}`, `prettier --check ${relativeFilenames}`];
+  },
+  '**/*.ts?(x)': (filenames) => {
+    // The lint-staged command runs this function multiple times to prepare
+    // console messages. We want to save the temporary tsconfig.json file only
+    // when this function is run with filenames (that start with a slash)
+    if (filenames.length > 0 && filenames[0].startsWith('/')) {
+      const relativeFilenames = mapToRelative(filenames);
+      const tsconfig = {
+        extends: './tsconfig.json',
+        files: relativeFilenames
+      };
+
+      FileSystem.writeFileSync(tsconfigPath, JSON.stringify(tsconfig));
+    }
+
+    return `tsc -p ${tsconfigPath}`;
+  }
+};

package/dist/configs/prettier.config.js

@@ -0,0 +1,13 @@
+export default {
+  printWidth: 120,
+  singleQuote: true,
+  trailingComma: 'none',
+  overrides: [
+    {
+      files: '*.html',
+      options: {
+        parser: 'html'
+      }
+    }
+  ]
+};

package/dist/configs/release.config.js

@@ -0,0 +1,119 @@
+export const defaultReleaseRules = [
+  { breaking: true, release: 'major' },
+  { type: 'feat', release: 'minor' },
+  { type: 'fix', release: 'patch' },
+  { type: 'perf', release: 'minor' },
+  { type: 'deps', release: false },
+  { type: 'deps', scope: 'prod', release: 'patch' },
+  { type: 'refactor', release: false },
+  { type: 'docs', release: false },
+  { type: 'chore', release: false },
+  { type: 'release', release: false },
+  { type: 'revert', release: false },
+  { type: 'style', release: false },
+  { type: 'test', release: false }
+];
+
+export const defaultChangelogTypes = [
+  { type: 'feat', section: 'Features' },
+  { type: 'fix', section: 'Fixes' },
+  { type: 'perf', section: 'Performance improvements' },
+  { type: 'deps', scope: 'prod', section: 'Dependency updates' }
+];
+
+export const createReleaseConfig = ({
+  host,
+  owner,
+  repository,
+  releaseRules = defaultReleaseRules,
+  changelogTypes = defaultChangelogTypes
+}) => ({
+  branches: ['main'],
+  repositoryUrl: `file://${process.cwd()}`,
+  preset: 'conventionalcommits',
+  dryRun: true,
+
+  plugins: [
+    [
+      '@semantic-release/commit-analyzer',
+      {
+        releaseRules
+      }
+    ],
+    [
+      '@semantic-release/release-notes-generator',
+      {
+        host,
+        presetConfig: {
+          types: changelogTypes
+        },
+        writerOpts: {
+          commitGroupsSort: ({ title: titleA }, { title: titleB }) => {
+            const indexA = changelogTypes.findIndex(({ section }) => section === titleA);
+            const indexB = changelogTypes.findIndex(({ section }) => section === titleB);
+
+            return indexA - indexB;
+          },
+          finalizeContext: (context) => {
+            const commitGroups = context.commitGroups.map((commitGroup) => ({
+              ...commitGroup,
+              commits: commitGroup.commits.map((commit) => ({
+                ...commit,
+                subject: commit.subject.replace(
+                  `${host}/${context.owner}/${context.repository}`,
+                  `${host}/${owner}/${repository}`
+                )
+              })),
+              collapse: commitGroup.title === 'Dependency updates'
+            }));
+
+            return {
+              ...context,
+              owner,
+              repository,
+              commitGroups
+            };
+          },
+          mainTemplate: `{{> header}}
+
+{{#if noteGroups}}
+{{#each noteGroups}}
+
+### ⚠ {{title}} !!
+
+{{#each notes}}
+* {{#if commit.scope}}**{{commit.scope}}:** {{/if}}{{text}}
+{{/each}}
+{{/each}}
+{{/if}}
+{{#each commitGroups}}
+
+{{#if title}}
+### {{title}}
+
+{{/if}}
+{{#if collapse}}
+<details>
+<summary>Show all dependency updates</summary>
+
+{{/if}}
+{{#each commits}}
+{{> commit root=@root}}
+{{/each}}
+{{#if collapse}}
+
+</details>
+{{/if}}
+
+{{/each}}`
+        }
+      }
+    ]
+  ]
+});
+
+export default createReleaseConfig({
+  host: 'https://github.com',
+  owner: 'cluerise',
+  repository: 'tools'
+});

package/dist/configs/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "emitDecoratorMetadata": true,
+    "esModuleInterop": true,
+    "exactOptionalPropertyTypes": true,
+    "experimentalDecorators": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "lib": ["dom", "esnext"],
+    "module": "esnext",
+    "moduleResolution": "node",
+    "noEmit": true,
+    "noUncheckedIndexedAccess": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "baseUrl": "./",
+    "paths": {
+      ":/*": ["./src/*/index"]
+    },
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "target": "esnext",
+    "types": ["node", "vite/client"]
+  },
+  "exclude": ["node_modules"]
+}

package/dist/scripts/check-heroku-node-version/main.js

@@ -0,0 +1,138 @@
+import SemVer from "semver";
+import FileSystem from "fs/promises";
+import { z } from "zod";
+import { parse } from "smol-toml";
+class ParseGitRepositoryError extends Error {
+}
+const gitProviderOrigins = {
+  github: "https://github.com"
+};
+const gitProviderNames = Object.keys(gitProviderOrigins);
+const isGitProviderName = (name) => gitProviderNames.includes(name);
+const parseRepositoryUrl = (urlString) => {
+  const urlValue = urlString.includes(":") ? urlString : `https://${urlString}`;
+  const url = new URL(urlValue);
+  const scheme = url.protocol.slice(0, -1);
+  if (isGitProviderName(scheme)) {
+    const [owner, repositoryName] = url.pathname.split("/");
+    if (!owner || !repositoryName) {
+      throw new ParseGitRepositoryError("Unknown owner or repositoryName");
+    }
+    return {
+      origin: gitProviderOrigins[scheme],
+      owner,
+      repositoryName
+    };
+  }
+  if (scheme === "https") {
+    const [, owner, repositoryName] = url.pathname.split("/");
+    if (!owner || !repositoryName) {
+      throw new ParseGitRepositoryError("Unknown owner or repositoryName");
+    }
+    return {
+      origin: url.origin,
+      owner,
+      repositoryName: repositoryName.endsWith(".git") ? repositoryName.slice(0, -4) : repositoryName
+    };
+  }
+  throw new ParseGitRepositoryError("Unsupported repository URL");
+};
+const parsePackageJsonRepository = (repository) => {
+  if (typeof repository === "string") {
+    return parseRepositoryUrl(repository);
+  }
+  return parseRepositoryUrl(repository.url);
+};
+const enginesSchema = z.object({
+  node: z.string()
+});
+const repositoryObjectSchema = z.object({
+  type: z.string(),
+  url: z.string(),
+  directory: z.ostring()
+});
+const repositorySchema = z.union([z.string(), repositoryObjectSchema]);
+const packageJsonSchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  description: z.string(),
+  engines: enginesSchema.optional(),
+  repository: repositorySchema.optional()
+});
+const readPackageJson = async () => {
+  const packageJsonData = await FileSystem.readFile("package.json", { encoding: "utf8" });
+  const packageJson = JSON.parse(packageJsonData);
+  const parseResult = packageJsonSchema.safeParse(packageJson);
+  if (!parseResult.success) {
+    throw parseResult.error;
+  }
+  return packageJson;
+};
+const CoreCommands = {
+  readPackageJson,
+  parsePackageJsonRepository
+};
+const runMain = (main2) => {
+  main2(process.argv.slice(2)).then((exitCode) => {
+    process.exit(exitCode);
+  }).catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+};
+const herokuNodeReleasesUrl = "https://raw.githubusercontent.com/heroku/heroku-buildpack-nodejs/latest/inventory/node.toml";
+const herokuNodeReleaseSchema = z.object({
+  version: z.string(),
+  channel: z.string(),
+  arch: z.string(),
+  url: z.string(),
+  etag: z.string()
+});
+const herokuNodeReleasesSchema = z.object({
+  name: z.string(),
+  releases: z.array(herokuNodeReleaseSchema)
+});
+const fetchNodeReleases = async () => {
+  const response = await fetch(herokuNodeReleasesUrl);
+  const data = await response.text();
+  const releasesData = parse(data);
+  const { releases } = herokuNodeReleasesSchema.parse(releasesData);
+  return releases;
+};
+const HerokuCommands = {
+  fetchNodeReleases
+};
+const getResultMessage = (nodeVersion, supported) => {
+  const nodeVersionIsRange = SemVer.valid(nodeVersion) === null;
+  const name = `Node.js version ${nodeVersionIsRange ? `range "${nodeVersion}"` : nodeVersion}`;
+  return `${name} is ${supported ? "" : "not "}supported on Heroku`;
+};
+const main = async () => {
+  var _a;
+  try {
+    const packageJson = await CoreCommands.readPackageJson();
+    const nodeVersion = (_a = packageJson.engines) == null ? void 0 : _a.node;
+    if (!nodeVersion) {
+      console.error("Error: Node.js version is not specified in package.json");
+      return 1;
+    }
+    const nodeVersionIsValid = SemVer.validRange(nodeVersion) !== null;
+    if (!nodeVersionIsValid) {
+      console.error(`Error: Node.js version "${nodeVersion}" is not valid semver version or range`);
+      return 1;
+    }
+    const releases = await HerokuCommands.fetchNodeReleases();
+    const nodeVersionIsSupported = releases.some((release) => SemVer.satisfies(release.version, nodeVersion));
+    if (!nodeVersionIsSupported) {
+      console.error(`Error: ${getResultMessage(nodeVersion, false)}`);
+      return 1;
+    }
+    console.log(`Info: ${getResultMessage(nodeVersion, true)}`);
+    return 0;
+  } catch (error) {
+    console.error("Error: Cannot check Node.js version on Heroku");
+    console.error(error);
+    return 1;
+  }
+};
+runMain(main);