FilesExpand file tree

main

/

release-notes.mjs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

140 lines (136 loc) · 4.55 KB

main

/

release-notes.mjs

Copy path

Top

File metadata and controls

• Code
• Blame

140 lines (136 loc) · 4.55 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

#!/usr/bin/env node

import { execFile } from "node:child_process";

import { readFile, writeFile } from "node:fs/promises";

import { parseArgs, promisify } from "node:util";

import { collectGitHubCredits } from "./lib/release-notes-github.mjs";

import { verifyNotesPublication } from "./lib/release-notes-publication.mjs";

import {

contributionRecord,

contributionSummary,

readReleaseHistory,

releaseInventorySchema,

selectedReleaseNotes,

verifyInventoryHistory,

verifyReleaseNotes,

} from "./lib/release-notes.mjs";

const execFileAsync = promisify(execFile);

async function run(command, args, input) {

const pending = execFileAsync(command, args, {

encoding: "utf8",

maxBuffer: 64 * 1024 * 1024,

});

pending.child.stdin.end(input);

return (await pending).stdout;

}

async function createInventory(values) {

if (!values.repository || !values.base || !values.target || !values.version)

throw new Error(

"inventory requires --repository, --base, --target and --version",

);

// Parse caller-selected boundaries before making network requests.

const history = await readReleaseHistory(run, values.base, values.target);

releaseInventorySchema.omit({ commits: true, pullRequests: true }).parse({

schemaVersion: 1,

repository: values.repository,

version: values.version,

base: history.base,

target: history.target,

});

const credits = await collectGitHubCredits(

run,

values.repository,

history.commits,

);

const inventory = releaseInventorySchema.parse({

schemaVersion: 1,

repository: values.repository,

version: values.version,

base: history.base,

target: history.target,

...credits,

});

await verifyInventoryHistory(run, inventory);

await writeFile(values.manifest, `${JSON.stringify(inventory, null, 2)}\n`, {

flag: "wx",

});

process.stdout.write(

`Inventoried ${inventory.commits.length} commits and ${inventory.pullRequests.length} merged PRs. Saved ${values.manifest}\n`,

);

}

async function main() {

const { values, positionals } = parseArgs({

allowPositionals: true,

options: {

repository: { type: "string" },

pr: { type: "string" },

base: { type: "string" },

target: { type: "string" },

version: { type: "string" },

manifest: { type: "string" },

notes: { type: "string", default: "CHANGELOG.md" },

"pr-body": { type: "string" },

source: { type: "string" },

output: { type: "string" },

summary: { type: "boolean", default: false },

},

});

const [command] = positionals;

if (command === "publication" && positionals.length === 1) {

if (!values.repository || !values.source)

throw new Error(

"publication requires --repository and --source; --pr selects the merged release PR",

);

process.stdout.write(

`${JSON.stringify(await verifyNotesPublication(run, values), null, 2)}\n`,

);

return;

}

if (

positionals.length !== 1 ||

!["inventory", "record", "check", "render"].includes(command) ||

!values.manifest

)

throw new Error(

"Usage: release-notes inventory|record|check|render --manifest FILE [--repository OWNER/REPO --base TAG --target SHA --version VERSION] [--notes FILE --pr-body FILE --source SHA --output FILE] [--summary for record]",

);

if (command === "inventory") {

await createInventory(values);

return;

}

const inventory = releaseInventorySchema.parse(

JSON.parse(await readFile(values.manifest, "utf8")),

);

await verifyInventoryHistory(run, inventory, values.source);

if (command === "record") {

const record = values.summary

? contributionSummary(inventory)

: contributionRecord(inventory);

if (values.output)

await writeFile(values.output, record, {

flag: "wx",

});

else process.stdout.write(record);

return;

}

const notes = await readFile(values.notes, "utf8");

const body = values["pr-body"]

? await readFile(values["pr-body"], "utf8")

: undefined;

const report = verifyReleaseNotes(inventory, notes, body);

if (command === "check") {

process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);

return;

}

if (!values.output)

throw new Error(

"render requires --output (an existing file is never overwritten)",

);

const rendered = selectedReleaseNotes(notes, inventory.version);

await writeFile(values.output, `${rendered}\n`, { flag: "wx" });

}

await main().catch((error) => {

process.stderr.write(

`Release notes failed: ${error instanceof Error ? error.message : String(error)}\n`,

);

process.exitCode = 1;

});