github-settings-as-code 3.2.0 → 4.0.1

package/src/github/pages/backup.mts

@@ -2,35 +2,44 @@
 import 'dotenv/config';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import {
-  formatUncommittedFiles,
-  isDirectlyExecuted,
-  makeEmptyDir,
-} from 'ts-repo-utils';
+import { formatUncommittedFiles, isDirectlyExecuted } from 'ts-repo-utils';
+import { clearJsonFilesIn } from '../clear-json-files.mjs';
 import { pagesSettingsDir, settingsJsonName } from '../constants.mjs';
 import { getPagesSettings } from './api/index.mjs';
 
-const backupDir = path.resolve(pagesSettingsDir, './bk');
-
-/** Settings > Pages の現在値を `bk/` に保存する。 */
+/**
+ * Settings > Pages の現在値を宣言ファイルへ撮り直す。
+ *
+ * **Pages が無効なら宣言も消える。** 他のターゲットと同じ規則にしてある — 撮り
+ * 直したあとに在るものが live から取れたものそのもの、という性質を、ここだけ
+ * 崩さない。無効になったことが `git status` に削除として出る。
+ *
+ * 無効化と読み取り失敗を区別できないという弱点は残るが、`getPagesSettings` が
+ * `undefined` を返すのは 404 のときだけで、それ以外の失敗は例外になる。消えた
+ * 宣言はコミットしなければ失われない。
+ */
 export const backupPagesSettings = async (
   fmt: boolean = true,
 ): Promise<void> => {
-  await makeEmptyDir(backupDir);
-
   const settings = await getPagesSettings();
 
+  await clearJsonFilesIn(pagesSettingsDir);
+
   if (settings === undefined) {
     console.warn(
-      'GitHub Pages is not enabled for this repository; skipping backup.',
+      'GitHub Pages is not enabled for this repository; the declaration was removed.',
     );
 
+    if (fmt) {
+      await formatUncommittedFiles();
+    }
+
     return;
   }
 
   // eslint-disable-next-line security/detect-non-literal-fs-filename
   await fs.writeFile(
-    path.resolve(backupDir, settingsJsonName),
+    path.resolve(pagesSettingsDir, settingsJsonName),
     JSON.stringify(settings, undefined, 2),
   );
 

package/src/github/repository/apply.mts

@@ -13,7 +13,6 @@ import {
 import { type StrictPick } from 'ts-type-forge';
 import { repositorySettingsDir, settingsJsonName } from '../constants.mjs';
 import { getRepositorySettings, updateRepository } from './api/index.mjs';
-import { backupRepositorySettings } from './backup.mjs';
 import {
   type RepositoryKeysToPick,
   repositoryKeysToPick,
@@ -21,8 +20,6 @@ import {
 } from './constants.mjs';
 
 export const applyRepositorySettings = async (): Promise<void> => {
-  await backupRepositorySettings(false);
-
   const settings = await readSettings();
 
   await updateRepository({
@@ -72,12 +69,6 @@ export const applyRepositorySettings = async (): Promise<void> => {
       str,
     );
 
-    // eslint-disable-next-line security/detect-non-literal-fs-filename
-    await fs.writeFile(
-      path.resolve(repositorySettingsDir, 'bk', settingsJsonName),
-      str,
-    );
-
     await formatUncommittedFiles();
   }
 };

package/src/github/repository/backup.mts

@@ -3,27 +3,22 @@ import 'dotenv/config';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { Obj } from 'ts-data-forge';
-import {
-  formatUncommittedFiles,
-  isDirectlyExecuted,
-  makeEmptyDir,
-} from 'ts-repo-utils';
+import { formatUncommittedFiles, isDirectlyExecuted } from 'ts-repo-utils';
+import { clearJsonFilesIn } from '../clear-json-files.mjs';
 import { repositorySettingsDir, settingsJsonName } from '../constants.mjs';
 import { getRepositorySettings } from './api/index.mjs';
 import { repositoryKeysToPick } from './constants.mjs';
 
-const backupDir = path.resolve(repositorySettingsDir, './bk');
-
 export const backupRepositorySettings = async (
   fmt: boolean = true,
 ): Promise<void> => {
-  await makeEmptyDir(backupDir);
-
   const repositorySettings = await getRepositorySettings();
 
+  await clearJsonFilesIn(repositorySettingsDir);
+
   // eslint-disable-next-line security/detect-non-literal-fs-filename
   await fs.writeFile(
-    path.resolve(backupDir, settingsJsonName),
+    path.resolve(repositorySettingsDir, settingsJsonName),
     JSON.stringify(
       Obj.pick(repositorySettings, repositoryKeysToPick),
       undefined,

package/src/github/ruleset/apply.mts

@@ -1,35 +1,32 @@
 #!/usr/bin/env node
 import 'dotenv/config';
 import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
 import { Obj } from 'ts-data-forge';
 import { formatUncommittedFiles, isDirectlyExecuted } from 'ts-repo-utils';
 import { rulesetsDir } from '../constants.mjs';
+import { settingsFilePath } from '../settings-file-path.mjs';
 import {
   createRuleset,
   getAllRulesets,
   getRuleset,
   updateRuleset,
 } from './api/index.mjs';
-import { backupRulesets } from './backup.mjs';
 import { rulesetKeysToPick } from './constants.mjs';
-import {
-  readRulesetBackupFiles,
-  readRulesetFiles,
-} from './read-rule-set-contents.mjs';
+import { readRulesetFiles } from './read-rule-set-contents.mjs';
 
 export const applyRulesets = async (): Promise<void> => {
-  await backupRulesets(false);
-
   const rulesets = await readRulesetFiles();
 
-  const backupIds: ReadonlySet<number> = await readRulesetBackupFiles().then(
+  // 既にあるかどうかは live に訊く。以前はこの直前に走らせた backup の出力を
+  // 読んでいたが、それは live の写しでしかなく、写した時点と送る時点のあいだに
+  // 消えた ruleset を「更新できる」と誤らせる余地があった。
+  const existingIds: ReadonlySet<number> = await getAllRulesets().then(
     (rs) => new Set(rs.map((r) => r.id)),
   );
 
-  const rulesetsToUpdate = rulesets.filter((r) => backupIds.has(r.id));
+  const rulesetsToUpdate = rulesets.filter((r) => existingIds.has(r.id));
 
-  const rulesetsToCreate = rulesets.filter((r) => !backupIds.has(r.id));
+  const rulesetsToCreate = rulesets.filter((r) => !existingIds.has(r.id));
 
   for (const ruleset of rulesetsToUpdate) {
     await updateRuleset({
@@ -71,14 +68,9 @@ export const applyRulesets = async (): Promise<void> => {
         2,
       );
 
+      // `settingsFilePath` が `rulesetsDir` の直下であることを確かめている。
       // eslint-disable-next-line security/detect-non-literal-fs-filename
-      await fs.writeFile(path.resolve(rulesetsDir, `${rule.name}.json`), str);
-
-      // eslint-disable-next-line security/detect-non-literal-fs-filename
-      await fs.writeFile(
-        path.resolve(rulesetsDir, `./bk/${rule.name}.json`),
-        str,
-      );
+      await fs.writeFile(settingsFilePath(rulesetsDir, rule.name), str);
     }
 
     await formatUncommittedFiles();

package/src/github/ruleset/backup.mts

@@ -1,30 +1,40 @@
 #!/usr/bin/env node
 import 'dotenv/config';
 import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
 import { Obj } from 'ts-data-forge';
-import {
-  formatUncommittedFiles,
-  isDirectlyExecuted,
-  makeEmptyDir,
-} from 'ts-repo-utils';
+import { formatUncommittedFiles, isDirectlyExecuted } from 'ts-repo-utils';
+import { clearJsonFilesIn } from '../clear-json-files.mjs';
 import { rulesetsDir } from '../constants.mjs';
+import { settingsFilePath } from '../settings-file-path.mjs';
 import { getAllRulesets, getRuleset } from './api/index.mjs';
 import { rulesetKeysToPick } from './constants.mjs';
 
-const backupDir = path.resolve(rulesetsDir, './bk');
-
+/**
+ * ruleset の現在値を宣言ファイルへ撮り直す。
+ *
+ * 先に直下の `*.json` を消してから書くので、撮り直したあとにそこに在るものが
+ * live から取れたものそのものになる。取れなかった ruleset は `git status` に
+ * 削除として現れる。理由は {@link clearJsonFilesIn} を参照。
+ */
 export const backupRulesets = async (fmt: boolean = true): Promise<void> => {
-  await makeEmptyDir(backupDir);
-
   const rulesetsResult = await getAllRulesets();
 
-  for (const rule of rulesetsResult) {
-    const content = await getRuleset(rule.id);
+  // 取得がすべて終わってから消す。途中で失敗したときに、宣言だけ消えて何も
+  // 書かれていない状態にしないため。
+  const contents = await Promise.all(
+    rulesetsResult.map(async (rule) => ({
+      name: rule.name,
+      content: await getRuleset(rule.id),
+    })),
+  );
+
+  await clearJsonFilesIn(rulesetsDir);
 
+  for (const { name, content } of contents) {
+    // `settingsFilePath` が `rulesetsDir` の直下であることを確かめている。
     // eslint-disable-next-line security/detect-non-literal-fs-filename
     await fs.writeFile(
-      path.resolve(backupDir, `${rule.name}.json`),
+      settingsFilePath(rulesetsDir, name),
       JSON.stringify(Obj.pick(content, rulesetKeysToPick), undefined, 2),
     );
   }

package/src/github/ruleset/read-rule-set-contents.mts

@@ -9,10 +9,6 @@ import { RulesetPicked } from './constants.mjs';
 export const readRulesetFiles = async (): Promise<readonly RulesetPicked[]> =>
   readFilesIn(rulesetsDir);
 
-export const readRulesetBackupFiles = async (): Promise<
-  readonly RulesetPicked[]
-> => readFilesIn(path.resolve(rulesetsDir, './bk'));
-
 const readFilesIn = async (dir: string): Promise<readonly RulesetPicked[]> => {
   // eslint-disable-next-line security/detect-non-literal-fs-filename
   const files: readonly Dirent<string>[] = await fs.readdir(dir, {

package/src/github/ruleset/schema.test.mts

@@ -77,19 +77,6 @@ describe('the ruleset schema', () => {
     }
   });
 
-  test('accepts every backed-up ruleset', async () => {
-    const files = await readJsonFilesIn(path.resolve(rulesetsDir, './bk'));
-
-    assert.isTrue(Arr.isNonEmpty(files));
-
-    for (const [name, content] of files) {
-      assert.deepStrictEqual(
-        outcomeOf(name, RulesetPicked.validate(content)),
-        name,
-      );
-    }
-  });
-
   test('accepts the fields GitHub adds to what apply sends back', async () => {
     const files = await readJsonFilesIn(rulesetsDir);
 
@@ -99,18 +86,20 @@ describe('the ruleset schema', () => {
 
     assert.deepStrictEqual(outcomeOf(files[0][0], declared), files[0][0]);
 
-    if (Result.isOk(declared)) {
-      // `getRuleset` hands the whole API response to this type, and a response
-      // carries more than the seven fields that go back out again.
-      const result = RulesetPicked.validate({
-        ...declared.value,
-        source: 'noshiro-pf/mono',
-        source_type: 'Repository',
-        node_id: 'RRS_lACqUmVwb3NpdG9yeQ',
-      });
-
-      assert.isTrue(Result.isOk(result));
+    if (Result.isErr(declared)) {
+      return;
     }
+
+    // `getRuleset` hands the whole API response to this type, and a response
+    // carries more than the seven fields that go back out again.
+    const result = RulesetPicked.validate({
+      ...declared.value,
+      source: 'noshiro-pf/mono',
+      source_type: 'Repository',
+      node_id: 'RRS_lACqUmVwb3NpdG9yeQ',
+    });
+
+    assert.isTrue(Result.isOk(result));
   });
 
   test('accepts a ruleset built from values GitHub does use', () => {

package/src/github/settings-file-path.mts

@@ -0,0 +1,51 @@
+import * as path from 'node:path';
+
+/**
+ * `dir` の直下の `<name>.json` を指すパスを返す。ファイル名にできない名前は
+ * 拒否する。
+ *
+ * environment 名と ruleset 名は GitHub API が返す素の文字列で、パス片として
+ * 使えることは何も保証していない。区切りを含む名前をそのまま結合すると、
+ * 書き込み先が `dir` の外 — GitHub の現在値と突き合わせる宣言ファイルが
+ * 置いてある場所 — へ出てしまう。
+ *
+ * 正規化ではなく拒否にしてあるのは、そういう名前が来たこと自体が異常の証拠だ
+ * からで、黙って書き換えると何が起きていたのかが分からなくなる。
+ */
+export const settingsFilePath = (dir: string, name: string): string => {
+  if (!isUsableAsFileName(name)) {
+    throw new Error(
+      [
+        `ファイル名にできない名前です: ${JSON.stringify(name)}。`,
+        `${dir} の外へ書き込もうとしている可能性があります。`,
+      ].join('\n'),
+    );
+  }
+
+  const resolvedDir = path.resolve(dir);
+
+  const resolved = path.resolve(resolvedDir, `${name}.json`);
+
+  // 二重の歯止め。上の判定が漏れても、`dir` の外には出さない。
+  if (!resolved.startsWith(resolvedDir + path.sep)) {
+    throw new Error(
+      `書き込み先が ${resolvedDir} の外を指しています: ${resolved}`,
+    );
+  }
+
+  return resolved;
+};
+
+/**
+ * パス片ひとつとして読める名前か。
+ *
+ * `path.sep` ではなく両方の区切りを見るのは、Windows で書かれた名前が POSIX
+ * 上で素通りしないようにするため。
+ */
+const isUsableAsFileName = (name: string): boolean =>
+  name !== '' &&
+  name !== '.' &&
+  name !== '..' &&
+  !name.includes('/') &&
+  !name.includes('\\') &&
+  !name.includes('\u{0}');

package/src/github/settings-file-path.test.mts

@@ -0,0 +1,70 @@
+import * as path from 'node:path';
+import { Result } from 'ts-data-forge';
+import { settingsFilePath } from './settings-file-path.mjs';
+
+const dir = path.resolve('/tmp/repo-settings/environments');
+
+/** `'rejected'` when the name was refused, the resolved path when it was not. */
+const outcomeOf = (name: string): string => {
+  const result = Result.fromThrowable(() => settingsFilePath(dir, name));
+
+  return Result.isErr(result) ? 'rejected' : result.value;
+};
+
+describe(settingsFilePath, () => {
+  test('names a file directly under the directory it was given', () => {
+    assert.deepStrictEqual(
+      settingsFilePath(dir, 'release'),
+      path.join(dir, 'release.json'),
+    );
+  });
+
+  test('keeps the characters a name is allowed to carry', () => {
+    assert.deepStrictEqual(
+      settingsFilePath(dir, 'main-no-bypass'),
+      path.join(dir, 'main-no-bypass.json'),
+    );
+
+    assert.deepStrictEqual(
+      settingsFilePath(dir, 'Production (US East)'),
+      path.join(dir, 'Production (US East).json'),
+    );
+  });
+
+  test('rejects a name that would resolve above the directory', () => {
+    assert.deepStrictEqual(outcomeOf('../release'), 'rejected');
+
+    assert.deepStrictEqual(outcomeOf('../../../../tmp/elsewhere'), 'rejected');
+  });
+
+  test('rejects a name carrying a separator, rather than nesting it', () => {
+    assert.deepStrictEqual(outcomeOf('production/us-east'), 'rejected');
+
+    assert.deepStrictEqual(
+      outcomeOf(String.raw`production\us-east`),
+      'rejected',
+    );
+  });
+
+  test('rejects the names that are not file names at all', () => {
+    assert.deepStrictEqual(outcomeOf(''), 'rejected');
+
+    assert.deepStrictEqual(outcomeOf('.'), 'rejected');
+
+    assert.deepStrictEqual(outcomeOf('..'), 'rejected');
+
+    assert.deepStrictEqual(outcomeOf('release\u{0}'), 'rejected');
+  });
+
+  test('says which name it refused', () => {
+    const result = Result.fromThrowable(() =>
+      settingsFilePath(dir, '../release'),
+    );
+
+    assert.isTrue(Result.isErr(result));
+
+    if (Result.isErr(result)) {
+      assert.isTrue(result.value.message.includes('../release'));
+    }
+  });
+});

package/src/github/variables/api/list-repo-variables.mts

@@ -23,5 +23,7 @@ export const listRepoVariables = async (): Promise<
     },
   );
 
-  return result.data.variables;
+  // `getAllEnvironments` と同じく名前順に整えて返す。宣言ファイルの中身が API
+  // の返す順に左右されると、値が変わっていない日にも diff が出る。
+  return result.data.variables.toSorted((a, b) => a.name.localeCompare(b.name));
 };

package/src/github/variables/apply.mts

@@ -1,43 +1,70 @@
 #!/usr/bin/env node
-
-// cspell:ignore lilpi
 import 'dotenv/config';
-import { isDirectlyExecuted } from 'ts-repo-utils';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as t from 'ts-fortress';
+import { isDirectlyExecuted, Result } from 'ts-repo-utils';
+import { settingsJsonName, variablesDir } from '../constants.mjs';
 import {
   createRepoVariable,
   listRepoVariables,
   updateRepoVariable,
 } from './api/index.mjs';
+import {
+  assertVariableNamesAreValid,
+  RepositoryVariables,
+} from './constants.mjs';
 
+/**
+ * `repo-settings/variables/settings.json` を Settings > Secrets and variables >
+ * Actions > Variables に反映する。
+ *
+ * ruleset や environment と同じく、**宣言に無い変数は消さない。** 消したい
+ * ときは宣言から外したうえで GitHub 側でも消す。 apply が片付けてしまうと、
+ * 誰かが GUI で足したものが「いつの間にか無くなる」ことになり、drift 検査が
+ * 報せるという見え方が働かなくなる。
+ */
 export const applyVariables = async (): Promise<void> => {
-  const variables = [
-    {
-      // noshiro-repo-settings-bot (App ID: 4476573)
-      // Administration を含む強い権限を持つ。設定の backup / apply 専用。
-      name: 'REPO_SETTINGS_BOT_CLIENT_ID',
-      value: 'Iv23ctr4Lq9H3wOYRQrD',
-    },
-    {
-      // noshiro-repo-automation-bot (App ID: 4478721)
-      // Contents / Pull requests / Issues 権限。PR を作る自動化（ pnpm-update ）と
-      // release で共用する。実際に使う権限は各ワークフローの permission-* 入力で
-      // 絞る。
-      name: 'REPO_AUTOMATION_BOT_CLIENT_ID',
-      value: 'Iv23lilpiDh0twq2PErv',
-    },
-  ] as const;
-
-  const variableListSaved = await listRepoVariables();
-
-  const variablesSaved: ReadonlySet<string> = new Set(
-    variableListSaved.map((v) => v.name),
+  const variables = await readSettings();
+
+  // 1 本目を送る前に、全部の名前を見る。
+  assertVariableNamesAreValid(variables);
+
+  const existing: ReadonlySet<string> = await listRepoVariables().then(
+    (vs) => new Set(vs.map((v) => v.name)),
+  );
+
+  for (const [name, value] of Object.entries(variables)) {
+    await (existing.has(name)
+      ? updateRepoVariable({ name, value })
+      : createRepoVariable({ name, value }));
+  }
+
+  // ここで live を読み直して書き戻すことはしない。 backup は live をそのまま
+  // 宣言に写す操作で、 live は宣言の上位集合になりうる — apply の締めに呼ぶと、
+  // 宣言していない変数まで黙って宣言に入る。送った値は宣言そのものなので、
+  // 書き戻して得られるものも無い。現在値を取り込みたいときは backup を明示的に
+  // 実行する。
+};
+
+const readSettings = async (): Promise<RepositoryVariables> => {
+  // eslint-disable-next-line security/detect-non-literal-fs-filename
+  const settingsText = await fs.readFile(
+    path.resolve(variablesDir, settingsJsonName),
+    { encoding: 'utf8' },
   );
 
-  for (const variable of variables) {
-    const found = variablesSaved.has(variable.name);
+  const validationResult = RepositoryVariables.validate(
+    JSON.parse(settingsText),
+  );
 
-    await (found ? updateRepoVariable(variable) : createRepoVariable(variable));
+  if (Result.isErr(validationResult)) {
+    throw new Error(
+      t.validationErrorsToMessages(validationResult.value).join('\n'),
+    );
   }
+
+  return validationResult.value;
 };
 
 if (isDirectlyExecuted(import.meta.url)) {

package/src/github/variables/backup.mts

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { formatUncommittedFiles, isDirectlyExecuted } from 'ts-repo-utils';
+import { clearJsonFilesIn } from '../clear-json-files.mjs';
+import { settingsJsonName, variablesDir } from '../constants.mjs';
+import { listRepoVariables } from './api/index.mjs';
+import { type RepositoryVariables } from './constants.mjs';
+
+/**
+ * repository variable の現在値を宣言ファイルへ撮り直す。
+ *
+ * 宣言していないものも含めて live にあるものを全部書く。 backup は「いま何が
+ * あるか」を写す操作なので、 GUI で足された変数もここで宣言に入る。要らない
+ * ものは撮り直したあとに宣言から外し、 GitHub 側でも消す。
+ */
+export const backupVariables = async (fmt: boolean = true): Promise<void> => {
+  const variables = await listRepoVariables();
+
+  await clearJsonFilesIn(variablesDir);
+
+  // eslint-disable-next-line security/detect-non-literal-fs-filename
+  await fs.writeFile(
+    path.resolve(variablesDir, settingsJsonName),
+    JSON.stringify(toDeclaration(variables), undefined, 2),
+  );
+
+  if (fmt) {
+    await formatUncommittedFiles();
+  }
+};
+
+/**
+ * API の配列を `settings.json` と同じ record に畳む。
+ *
+ * `created_at` / `updated_at` はここで落ちる。値が変わっていなくても動くので、
+ * 残すと宣言ファイルが毎日変わり、ドリフト検査が本当の変更を報せなくなる。
+ */
+export const toDeclaration = (
+  variables: Awaited<ReturnType<typeof listRepoVariables>>,
+): RepositoryVariables =>
+  Object.fromEntries(variables.map(({ name, value }) => [name, value]));
+
+if (isDirectlyExecuted(import.meta.url)) {
+  await backupVariables();
+}

package/src/github/variables/constants.mts

@@ -0,0 +1,61 @@
+import { Arr } from 'ts-data-forge';
+import * as t from 'ts-fortress';
+
+/**
+ * `repo-settings/variables/settings.json` の型。
+ *
+ * Settings > Secrets and variables > Actions > Variables に対応する
+ * (`GET|POST /repos/{owner}/{repo}/actions/variables`,
+ * `PATCH /repos/{owner}/{repo}/actions/variables/{name}`)。
+ *
+ * 変数名をキー、値を値にした素の record にしてある。 API が返す配列
+ * (`{ name, value, created_at, updated_at }[]`) をそのまま写さないのは、
+ * `created_at` / `updated_at` が値の変化なしに動くためで、宣言に入れると
+ * 毎日ドリフトとして出てしまう。ここで持つのは宣言できるものだけ。
+ *
+ * **ここに秘密を書かないこと。** repository variable は API でも Actions の
+ * ログでも平文で読める。秘密は secret 側で、そちらはこのツールの管理外にある。
+ */
+export const RepositoryVariables = t.keyValueRecord(t.string(), t.string(), {
+  typeName: 'RepositoryVariables',
+});
+
+export type RepositoryVariables = t.TypeOf<typeof RepositoryVariables>;
+
+/**
+ * GitHub が受け付けない変数名を、送る前にすべて挙げて落とす。
+ *
+ * 名前は `PATCH .../actions/variables/{name}` のパスに入る。 octokit が URL
+ * エンコードするので注入にはならないが、弾かれる名前は 422 になり、それが
+ * 起きるのは**何本か書き込んだ後**である。 environments の `assertConsistent`
+ * と同じ理由でここに置いてある — 1 本目を送る前に全部の名前を見ておけば、
+ * この種の間違いで中途半端に適用された状態にはならない。
+ *
+ * 規則は GitHub の documentation のとおり: 英数字と `_` のみ、先頭に数字は
+ * 不可、`GITHUB_` 始まりは予約。名前の大文字小文字は区別されないので、
+ * 予約接頭辞の判定も区別しない。
+ */
+export const assertVariableNamesAreValid = (
+  variables: RepositoryVariables,
+): void => {
+  const offenders = Object.keys(variables).filter(
+    (name) => !isValidVariableName(name),
+  );
+
+  if (Arr.isNonEmpty(offenders)) {
+    throw new Error(
+      [
+        `repository variable の名前として使えないものがあります: ${offenders
+          .map((name) => JSON.stringify(name))
+          .join(', ')}。`,
+        '英数字と "_" のみが使え、先頭に数字は置けず、"GITHUB_" 始まりは予約されています。',
+      ].join('\n'),
+    );
+  }
+};
+
+/** 先頭は英字か `_`、以降は英数字か `_`。入れ子の量化子は無いので線形。 */
+const variableNamePattern = /^[A-Za-z_][A-Za-z0-9_]*$/u;
+
+const isValidVariableName = (name: string): boolean =>
+  variableNamePattern.test(name) && !name.toUpperCase().startsWith('GITHUB_');