Transition to Yarn Workspaces

.github/actions/build.js

@@ -0,0 +1,17 @@
+// @ts-check
+import getBuildCommand from '@sourceacademy/modules-repotools/builder';
+
+const buildCommand = getBuildCommand({
+  bundle: true,
+  entryPoints: [
+    { in: './src/info/index.ts', out: 'info' },
+    { in: './src/load-artifacts/index.ts', out: 'load' }
+  ],
+  format: 'esm',
+  outdir: 'dist',
+  packages: 'external',
+  platform: 'node',
+  target: 'node20',
+});
+
+await buildCommand.parseAsync();

.github/actions/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@sourceacademy/modules-github-actions",
+  "description": "Github Actions for the modules repository",
+  "private": true,
+  "type": "module",
+  "devDependencies": {
+    "@sourceacademy/modules-repotools": "workspace:^",
+    "@types/node": "^22.15.30",
+    "typescript": "^5.8.2",
+    "vitest": "^3.2.3"
+  },
+  "dependencies": {
+    "@actions/artifact": "^2.3.2",
+    "@actions/core": "^1.11.1",
+    "@actions/exec": "^1.1.1",
+    "lodash": "^4.17.21"
+  },
+  "scripts": {
+    "build": "node ./build.js",
+    "postinstall": "yarn build",
+    "test": "vitest",
+    "tsc": "tsc --project ./tsconfig.json"
+  }
+}

.github/actions/src/__tests__/git.test.ts

@@ -0,0 +1,30 @@
+import * as exec from '@actions/exec';
+import { describe, expect, it, vi } from 'vitest';
+import * as git from '../commons.js';
+
+vi.mock(import('lodash/memoize.js'), () => ({
+  default: (x: any) => x
+}) as any);
+
+const mockedExecOutput = vi.spyOn(exec, 'getExecOutput');
+
+describe(git.checkForChanges, () => {
+  function mockChanges(value: boolean) {
+    mockedExecOutput.mockResolvedValueOnce({
+      exitCode: value ? 1 : 0, stdout: '', stderr: ''
+    });
+  }
+
+  it('should return true if git diff exits with non zero code', async () => {
+    mockChanges(true);
+    await expect(git.checkForChanges('/')).resolves.toEqual(true);
+    expect(mockedExecOutput).toHaveBeenCalledOnce();
+  });
+
+  it('should return false if git diff exits with 0', async () => {
+    mockChanges(false);
+
+    await expect(git.checkForChanges('/')).resolves.toEqual(false);
+    expect(mockedExecOutput).toHaveBeenCalledOnce();
+  });
+});

.github/actions/src/commons.ts

@@ -0,0 +1,87 @@
+import { getExecOutput } from '@actions/exec';
+import memoize from 'lodash/memoize.js';
+
+export interface RawPackageRecord {
+  directory: string;
+  hasChanges: boolean;
+  package: {
+    name: string;
+    devDependencies: Record<string, string>;
+    dependencies: Record<string, string>;
+  };
+}
+
+interface BasePackageRecord {
+  /**
+   * Directory within which the `package.json` file was found
+   */
+  directory: string;
+
+  /**
+   * Full scoped package name
+   */
+  name: string;
+  /**
+   * `true` if git detected changes from within the package's subdirectories,
+   * `false` otherwise
+   */
+  changes: boolean;
+  /**
+   * `true` if playwright is present under devDependencies. This means that the package
+   * might need playwright for its tests
+   */
+  needsPlaywright: boolean;
+}
+
+export interface BundlePackageRecord extends BasePackageRecord {
+  bundleName: string;
+}
+
+export interface TabPackageRecord extends BasePackageRecord {
+  tabName: string;
+}
+
+export type PackageRecord = BundlePackageRecord | TabPackageRecord | BasePackageRecord;
+
+export function isPackageRecord(obj: unknown): obj is PackageRecord {
+  if (typeof obj !== 'object' || obj === null) return false;
+
+  if (!('directory' in obj) || typeof obj.directory !== 'string') return false;
+  if (!('name' in obj) || typeof obj.name !== 'string') return false;
+  if (!('changes' in obj) || typeof obj.changes !== 'boolean') return false;
+  if (!('needsPlaywright' in obj) || typeof obj.needsPlaywright !== 'boolean') return false;
+
+  if ('bundleName' in obj && typeof obj.bundleName !== 'string') return false;
+  if ('tabName' in obj && typeof obj.tabName !== 'string') return false;
+
+  return true;
+}
+
+export function isPackageRecordArray(obj: unknown): obj is PackageRecord[] {
+  return Array.isArray(obj) && !obj.some(each => !isPackageRecord(each));
+}
+
+// Not using the repotools version since this uses @action/exec instead of
+// calling execFile from child_process
+
+export async function getGitRoot() {
+  const { stdout } = await getExecOutput('git rev-parse --show-toplevel');
+  return stdout.trim();
+}
+
+/**
+ * Returns `true` if there are changes present in the given directory relative to
+ * the master branch\
+ * Used to determine, particularly for libraries if running tests and tsc are necessary
+ */
+export const checkForChanges = memoize(async (directory: string) => {
+  const { exitCode } = await getExecOutput(
+    'git',
+    ['--no-pager', 'diff', '--quiet', 'origin/master', '--', directory],
+    {
+      failOnStdErr: false,
+      ignoreReturnCode: true
+    }
+  );
+  return exitCode !== 0;
+});

.github/actions/src/info/__tests__/index.test.ts

@@ -0,0 +1,204 @@
+import type { Dirent } from 'fs';
+import fs from 'fs/promises';
+import pathlib from 'path';
+import { describe, expect, test, vi } from 'vitest';
+import * as git from '../../commons.js';
+import { getAllPackages, getRawPackages } from '../index.js';
+
+const mockedCheckChanges = vi.spyOn(git, 'checkForChanges');
+
+class NodeError extends Error {
+  constructor(public readonly code: string) {
+    super();
+  }
+}
+
+const mockDirectory: Record<string, string | Record<string, unknown>> = {
+  'package.json': JSON.stringify({
+    name: '@sourceacademy/modules'
+  }),
+  lib: {
+    'modules-lib': {
+      'package.json': JSON.stringify({
+        name: '@sourceacademy/modules-lib'
+      }),
+    }
+  },
+  src: {
+    bundles: {
+      bundle0: {
+        'package.json': JSON.stringify({
+          name: '@sourceacademy/bundle-bundle0',
+          devDependencies: {
+            '@sourceacademy/modules-lib': 'workspace:^'
+          }
+        })
+      },
+    },
+    tabs: {
+      tab0: {
+        'package.json': JSON.stringify({
+          name: '@sourceacademy/tab-Tab0',
+          dependencies: {
+            '@sourceacademy/bundle-bundle0': 'workspace:^'
+          },
+          devDependencies: {
+            playwright: '^1.54.0'
+          }
+        })
+      }
+    }
+  }
+};
+
+function mockReaddir(path: string) {
+  function recurser(segments: string[], obj: string | Record<string, unknown>): Promise<Dirent[]> {
+    if (segments.length === 0) {
+      if (typeof obj === 'string') throw new NodeError('ENOTDIR');
+
+      const dirents = Object.entries(obj)
+        .map(([name, each]): Dirent => {
+          if (typeof each === 'string') {
+            return {
+              isFile: () => true,
+              isDirectory: () => false,
+              name,
+            } as Dirent;
+          }
+
+          return {
+            isFile: () => false,
+            isDirectory: () => true,
+            name
+          } as Dirent;
+        });
+
+      return Promise.resolve(dirents);
+    }
+
+    if (typeof obj === 'string') throw new NodeError('ENOENT');
+
+    const [seg0, ...remainingSegments] = segments;
+    return recurser(remainingSegments, obj[seg0] as string | Record<string, unknown>);
+  }
+
+  const segments = path.split(pathlib.sep);
+  return recurser(segments, { root: mockDirectory });
+}
+
+function mockReadFile(path: string) {
+  function recurser(segments: string[], obj: string | Record<string, unknown>): Promise<string> {
+    if (segments.length === 0) {
+      if (typeof obj !== 'string') throw new NodeError('EISDIR');
+      return Promise.resolve(obj);
+    }
+
+    if (typeof obj === 'string') throw new NodeError('ENOENT');
+
+    const [seg0, ...remainingSegments] = segments;
+    return recurser(remainingSegments, obj[seg0] as string | Record<string, unknown>);
+  }
+
+  const segments = path.split(pathlib.sep);
+  return recurser(segments, { root: mockDirectory });
+}
+
+vi.spyOn(fs, 'readdir').mockImplementation(mockReaddir as any);
+vi.spyOn(fs, 'readFile').mockImplementation(mockReadFile as any);
+
+describe(getRawPackages, () => {
+  test('maxDepth = 1', async () => {
+    mockedCheckChanges.mockResolvedValueOnce(true);
+    const results = Object.entries(await getRawPackages('root', 1));
+    expect(fs.readdir).toHaveBeenCalledTimes(3);
+    expect(results.length).toEqual(1);
+
+    const [[name, packageData]] = results;
+    expect(name).toEqual('@sourceacademy/modules');
+    expect(packageData.hasChanges).toEqual(true);
+    expect(git.checkForChanges).toHaveBeenCalledOnce();
+  });
+
+  test('maxDepth = 3', async () => {
+    mockedCheckChanges.mockResolvedValue(true);
+    const results = await getRawPackages('root', 3);
+    expect(Object.values(results).length).toEqual(4);
+    expect(fs.readdir).toHaveBeenCalledTimes(8);
+
+    expect(results).toHaveProperty('@sourceacademy/bundle-bundle0');
+    const bundleResult = results['@sourceacademy/bundle-bundle0'];
+    expect(bundleResult.hasChanges).toEqual(true);
+
+    expect(results).toHaveProperty('@sourceacademy/tab-Tab0');
+    const tabResult = results['@sourceacademy/tab-Tab0'];
+    expect(tabResult.hasChanges).toEqual(true);
+
+    expect(results).toHaveProperty('@sourceacademy/modules-lib');
+    const libResult = results['@sourceacademy/modules-lib'];
+    expect(libResult.hasChanges).toEqual(true);
+  });
+
+  test('hasChanges fields accurately reflects value returned from checkChanges', async () => {
+    mockedCheckChanges.mockImplementation(p => {
+      switch (p) {
+        case 'root/src/bundles/bundle0':
+          return Promise.resolve(false);
+        case 'root/src/tabs/tab0':
+          return Promise.resolve(false);
+        case 'root':
+          return Promise.resolve(true);
+      }
+
+      return Promise.resolve(false);
+    });
+
+    const results = await getRawPackages('root');
+    expect(Object.keys(results).length).toEqual(4);
+
+    expect(results).toHaveProperty('@sourceacademy/modules');
+    expect(results['@sourceacademy/modules'].hasChanges).toEqual(true);
+
+    expect(results).toHaveProperty('@sourceacademy/bundle-bundle0');
+    expect(results['@sourceacademy/bundle-bundle0'].hasChanges).toEqual(false);
+
+    expect(results).toHaveProperty('@sourceacademy/tab-Tab0');
+    expect(results['@sourceacademy/tab-Tab0'].hasChanges).toEqual(false);
+
+    expect(results).toHaveProperty('@sourceacademy/modules-lib');
+    expect(results['@sourceacademy/modules-lib'].hasChanges).toEqual(false);
+  });
+});
+
+describe(getAllPackages, () => {
+  test('Transitive change dependencies', async () => {
+    mockedCheckChanges.mockImplementation(p => {
+      switch (p) {
+        case 'root/lib/modules-lib':
+          return Promise.resolve(true);
+        case 'root/src/bundles/bundle0':
+          return Promise.resolve(false);
+        case 'root/src/tabs/tab0':
+          return Promise.resolve(false);
+        case 'root':
+          return Promise.resolve(false);
+      }
+
+      return Promise.resolve(false);
+    });
+
+    const { packages: results } = await getAllPackages('root');
+    expect(Object.keys(results).length).toEqual(4);
+
+    expect(results).toHaveProperty('@sourceacademy/modules');
+    expect(results['@sourceacademy/modules'].changes).toEqual(false);
+
+    expect(results).toHaveProperty('@sourceacademy/bundle-bundle0');
+    expect(results['@sourceacademy/bundle-bundle0'].changes).toEqual(true);
+
+    expect(results).toHaveProperty('@sourceacademy/tab-Tab0');
+    expect(results['@sourceacademy/tab-Tab0'].changes).toEqual(true);
+
+    expect(results).toHaveProperty('@sourceacademy/modules-lib');
+    expect(results['@sourceacademy/modules-lib'].changes).toEqual(true);
+  });
+});