FilesExpand file tree

master

/

ci-dependency-cache.mjs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

83 lines (80 loc) · 3.98 KB

master

/

ci-dependency-cache.mjs

Copy path

Top

File metadata and controls

• Code
• Blame

83 lines (80 loc) · 3.98 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

import { execFileSync } from "node:child_process";

import { createHash } from "node:crypto";

import { appendFileSync, existsSync, readFileSync, realpathSync } from "node:fs";

import path from "node:path";

import { fileURLToPath } from "node:url";

import { readPluginsUnder } from "./link-plugin-dev-sdk.mjs";

const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");

export function cachePlan({ files, read, scope, packageDirs }) {

const dependencyInputs = files.filter((file) =>

/(^|\/)package\.json$/.test(file)

|| ["pnpm-lock.yaml", "pnpm-workspace.yaml", ".npmrc", ".pnpmfile.cjs", "pnpmfile.cjs"].includes(file)

|| file.startsWith("scripts/")

|| file.startsWith("patches/"));

const digest = (inputs, salt) => {

const hash = createHash("sha256").update(JSON.stringify(salt));

for (const file of [...inputs].sort()) {

const bytes = read(file);

hash.update(JSON.stringify([file, bytes === null ? null : bytes.length]));

if (bytes !== null) hash.update(bytes);

}

return hash.digest("hex");

};

const dependencyKey = `ci-dependencies-v1-${digest(dependencyInputs, scope)}`;

const cacheable = packageDirs.every((directory) => {

const manifest = read(path.posix.join(directory, 'package.json'));

if (manifest === null) return false;

const scripts = JSON.parse(manifest).scripts ?? {};

return ['preinstall', 'install', 'postinstall', 'prepare'].every((hook) =>

scripts[hook] === undefined || (directory === '.' && hook === 'postinstall'

&& scripts[hook] === 'node scripts/link-plugin-dev-sdk.mjs'));

});

const buildInputs = files.filter((file) =>

file.startsWith("packages/shared/") || file.startsWith("packages/plugins/sdk/")

|| /^tsconfig[^/]*\.json$/.test(file)

|| file === "scripts/ensure-plugin-build-deps.mjs");

return {

cacheable,

dependencyKey,

buildKey: `ci-build-dependencies-v1-${digest(buildInputs, dependencyKey)}`,

dependencyPaths: [...new Set(packageDirs.map((directory) => {

if (path.isAbsolute(directory) || directory.split('/').includes('..')) throw new Error('Package directory escapes the checkout');

return path.posix.join(directory, 'node_modules');

}))].sort(),

};

}

if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {

const files = execFileSync("git", ["ls-files", "-z"], { cwd: root }).toString().split("\0").filter(Boolean);

const command = (args) => execFileSync("pnpm", args, { cwd: root, encoding: "utf8" }).trim();

const workspaces = JSON.parse(command(['-r', 'list', '--depth=-1', '--json']));

const packageDirs = ['.',

...workspaces.map((workspace) => path.relative(root, workspace.path).split(path.sep).join('/') || '.'),

...readPluginsUnder(path.join(root, 'packages/plugins/sandbox-providers')).map((directory) => path.relative(root, directory).split(path.sep).join('/')),

'packages/plugins/examples/plugin-orchestration-smoke-example',

];

const plan = cachePlan({

files,

read: (file) => existsSync(path.join(root, file)) ? readFileSync(path.join(root, file)) : null,

packageDirs,

scope: {

root: realpathSync(root), node: process.version, abi: process.versions.modules,

platform: process.platform, arch: process.arch,

libc: process.report.getReport().header.glibcVersionRuntime ?? null,

pnpm: command(["--version"]), store: command(["store", "path", "--silent"]),

},

});

const output = [

`cacheable=${plan.cacheable}`,

`dependency-key=${plan.dependencyKey}`,

`build-key=${plan.buildKey}`,

"dependency-paths<<PAPERCLIP_CACHE_PATHS",

...plan.dependencyPaths.map((file) => path.join(root, file)),

"PAPERCLIP_CACHE_PATHS",

"build-paths<<PAPERCLIP_BUILD_PATHS",

path.join(root, "packages/shared/dist"),

path.join(root, "packages/plugins/sdk/dist"),

"PAPERCLIP_BUILD_PATHS",

].join("\n") + "\n";

if (process.env.GITHUB_OUTPUT) appendFileSync(process.env.GITHUB_OUTPUT, output);

else console.log(JSON.stringify(plan, null, 2));

}