@thebattlearena/corner 0.9.1-beta.70 → 0.10.0

package/ring/scripts/format-worker.mjs

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+// The batch behind `format-gate.mjs check`: which of many files the repo's format would change, in
+// one process instead of two per file. Reads JSON on stdin { root, tsconfig, sort, prettier, files:
+// [{ file, text }] } (absolute paths; `text` is the content to judge, e.g. as committed) and prints
+// { changed: [file], failed: [file] }.
+//
+// sort-imports runs ONCE over copies of every TypeScript file, outside the repo. prettier runs
+// through its own API, loaded from the repo's node_modules (the same package its binary is; ring
+// adds no dependency), with each file's own path, so its config, overrides and .prettierignore
+// apply; a file prettier ignores or cannot infer a parser for is judged by sort-imports alone.
+import { execFileSync } from 'node:child_process';
+import {
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { createRequire } from 'node:module';
+import { tmpdir } from 'node:os';
+import { basename, extname, join } from 'node:path';
+
+const SORTABLE = ['.ts', '.tsx'];
+
+/** The sorted text of every TypeScript file, by one sort-imports call over copies. */
+function sorted({ root, tsconfig, sort, files }) {
+  const out = new Map(files.map(({ file, text }) => [file, text]));
+  const ts = files.filter(({ file }) =>
+    SORTABLE.includes(extname(file).toLowerCase()),
+  );
+  if (!sort || !ts.length) return out;
+  const dir = mkdtempSync(join(tmpdir(), 'ring-format-batch-'));
+  try {
+    const copies = ts.map(({ file, text }, index) => {
+      const copy = join(dir, String(index), basename(file));
+      mkdirSync(join(dir, String(index)));
+      writeFileSync(copy, text);
+      return { file, copy };
+    });
+    execFileSync(
+      sort,
+      [
+        ...(tsconfig ? ['--tsconfig', tsconfig] : []),
+        '--write',
+        ...copies.map(({ copy }) => copy),
+      ],
+      { cwd: root, stdio: 'pipe', maxBuffer: 64 * 1024 * 1024 },
+    );
+    copies.forEach(({ file, copy }) =>
+      out.set(file, readFileSync(copy, 'utf8')),
+    );
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+  return out;
+}
+
+/** The repo's prettier module, from the package its binary belongs to, or null. */
+function prettierApi(bin) {
+  try {
+    return createRequire(realpathSync(bin))('prettier');
+  } catch {
+    return null;
+  }
+}
+
+/** prettier through the CLI, one file at a time: the fallback when the API does not load. */
+const viaCli = (root, bin, file, text) =>
+  execFileSync(bin, ['--stdin-filepath', file], {
+    cwd: root,
+    input: text,
+    encoding: 'utf8',
+    stdio: ['pipe', 'pipe', 'pipe'],
+    maxBuffer: 64 * 1024 * 1024,
+  });
+
+async function main() {
+  const input = JSON.parse(readFileSync(0, 'utf8'));
+  const { root, prettier: bin, files } = input;
+  const changed = [];
+  const failed = [];
+  let afterSort;
+  try {
+    afterSort = sorted(input);
+  } catch {
+    // sort-imports could not run on the batch: every TypeScript file is unjudged, so failed.
+    afterSort = new Map(files.map(({ file, text }) => [file, text]));
+    files
+      .filter(({ file }) => SORTABLE.includes(extname(file).toLowerCase()))
+      .forEach(({ file }) => failed.push(file));
+  }
+  const api = bin ? prettierApi(bin) : null;
+  const ignorePath = join(root, '.prettierignore');
+  for (const { file, text } of files) {
+    if (failed.includes(file)) continue;
+    let out = afterSort.get(file);
+    try {
+      if (api) {
+        const info = await api.getFileInfo(file, {
+          ignorePath,
+          resolveConfig: true,
+        });
+        if (!info.ignored && info.inferredParser) {
+          const config = (await api.resolveConfig(file)) ?? {};
+          out = await api.format(out, { ...config, filepath: file });
+        }
+      } else if (bin) out = viaCli(root, bin, file, out);
+      if (out !== text) changed.push(file);
+    } catch {
+      failed.push(file);
+    }
+  }
+  process.stdout.write(JSON.stringify({ changed, failed }));
+}
+
+main().catch((error) => {
+  process.stderr.write(String(error?.message ?? error));
+  process.exit(1);
+});

package/ring/scripts/front-routes.mjs

@@ -0,0 +1,345 @@
+// «Rutas del frontend» for the weigh-in of a frontend bout: every Next.js route the deliverable
+// adds, changes or removes against the stack base (pages router `pages/**`, app router
+// `app/**/page|layout|route`), as its URL, with the query params it reads, the changed files it
+// reaches through its imports (components, hooks, services), the back-end calls those files make
+// when they can be read (`/v1/…` literals, `sdk.<resource>.<method>(`), its files and lines, and the
+// fingerprint the judge's verdict is tied to. `_app`, `_document` and the root layout change every
+// route: they come as `global`. The navigation entries (sidebar, menu) whose links change come
+// apart. Read from git and the worktree only, text-based: nothing is parsed or run. Zero-dependency.
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { posix } from 'node:path';
+
+import { readState } from './config.mjs';
+import { scriptJson } from './contract-endpoints.mjs';
+
+const ROUTE_FILE = /\.(tsx|ts|jsx|js|mdx)$/;
+const PAGES = /^(?:src\/)?pages\/(.+)$/;
+const APP =
+  /^(?:src\/)?app\/(?:(.+)\/)?(page|layout|route)\.(?:tsx|ts|jsx|js)$/;
+const GLOBAL_PAGES = /^_(app|document|error)$/;
+const NAVIGATION = /(sidebar|navigation|nav[-_.]|menu|navbar)/i;
+const MAX_REACH = 80;
+
+/**
+ * The route a changed file is, or null: `{ kind: page|api|global, url }`. Pages router:
+ * `pages/a/[id]/index.tsx` → `/a/[id]`, `pages/api/x.ts` → API route `/api/x`, `_app`/`_document`
+ * → global. App router: `app/(group)/a/page.tsx` → `/a`, `route.ts` → API route, the root layout →
+ * global, a nested layout → `/a (layout)`. PURE.
+ */
+export function routeOf(path) {
+  if (!ROUTE_FILE.test(path)) return null;
+  const pages = PAGES.exec(path);
+  if (pages) {
+    const bare = pages[1].replace(ROUTE_FILE, '');
+    if (GLOBAL_PAGES.test(bare))
+      return { kind: 'global', url: `pages/${bare}` };
+    const url = `/${bare}`.replace(/\/index$/, '') || '/';
+    return {
+      kind: url.startsWith('/api/') || url === '/api' ? 'api' : 'page',
+      url,
+    };
+  }
+  const app = APP.exec(path);
+  if (!app) return null;
+  const segments = (app[1] ?? '')
+    .split('/')
+    .filter((part) => part && !/^\(.*\)$/.test(part) && !part.startsWith('@'));
+  const url = `/${segments.join('/')}`;
+  if (app[2] === 'route') return { kind: 'api', url };
+  if (app[2] === 'layout' && segments.length === 0)
+    return { kind: 'global', url: 'app/layout' };
+  if (app[2] === 'layout') return { kind: 'page', url: `${url} (layout)` };
+  return { kind: 'page', url };
+}
+
+/** Names after `query.` that are not URL params: react-query results and string or array methods. */
+const NOT_PARAMS = new Set(
+  'data isLoading isError error refetch isFetching isFetchingNextPage status isSuccess isPending mutate mutateAsync fetchNextPage hasNextPage length replace find trim split includes toLowerCase toUpperCase startsWith endsWith slice map filter some every indexOf match test push join'.split(
+    ' ',
+  ),
+);
+
+/**
+ * The query params a file reads from the URL: `router.query.x`, `query.x` or `{ x } = query` in a
+ * file that uses the router, and `searchParams.get('x')`. PURE.
+ */
+export function queryParams(text) {
+  const source = String(text);
+  const found = new Set();
+  const add = (name) =>
+    name && /^\w+$/.test(name) && !NOT_PARAMS.has(name) && found.add(name);
+  for (const [, name] of source.matchAll(
+    /searchParams\??\.get\(\s*['"`](\w+)['"`]/g,
+  ))
+    add(name);
+  if (!/\buseRouter\b|\brouter\.query\b/.test(source)) return [...found].sort();
+  for (const [, name] of source.matchAll(/\bquery\.(\w+)/g)) add(name);
+  for (const [, names] of source.matchAll(
+    /\{([^}]+)\}\s*=\s*(?:\w+\.)?query\b/g,
+  ))
+    names.split(',').forEach((part) =>
+      add(
+        part
+          .split(':')[0]
+          .trim()
+          .replace(/^\.\.\./, ''),
+      ),
+    );
+  return [...found].sort();
+}
+
+/** The back-end calls a file makes, when they can be read: `/v1/…` literals and `sdk.x.y(` calls. PURE. */
+export function backendCalls(text) {
+  const found = new Set();
+  for (const [literal] of String(text).matchAll(
+    /\/v\d+\/[A-Za-z0-9_\-/{}$.:]*/g,
+  ))
+    found.add(literal.replace(/[.:]+$/, ''));
+  for (const [, resource, method] of String(text).matchAll(
+    /\b(?:sdk|sdkClient|client|apiClient)\(?\)?\.(\w+)\.(\w+)\(/g,
+  ))
+    found.add(`sdk.${resource}.${method}()`);
+  return [...found].sort();
+}
+
+/** The import specifiers of a file (static, dynamic and re-exports). PURE. */
+export function importsOf(text) {
+  return [
+    ...String(text).matchAll(
+      /(?:import|export)\s[^'"]*?from\s*['"]([^'"]+)['"]|import\(\s*['"]([^'"]+)['"]\s*\)/g,
+    ),
+  ].map((match) => match[1] ?? match[2]);
+}
+
+/** The repo file an import resolves to among `exists`, with `@/` and `src/` as `src/`. PURE. */
+export function resolveImport(from, specifier, exists) {
+  const base = specifier.startsWith('.')
+    ? posix.normalize(posix.join(posix.dirname(from), specifier))
+    : /^(@|src)\//.test(specifier)
+      ? `src/${specifier.replace(/^(@|src)\//, '')}`
+      : null;
+  if (!base) return null;
+  const candidates = [
+    base,
+    ...['.tsx', '.ts', '.jsx', '.js'].map((ext) => `${base}${ext}`),
+    ...['tsx', 'ts', 'jsx', 'js'].map((ext) => `${base}/index.${ext}`),
+  ];
+  return candidates.find(exists) ?? null;
+}
+
+/** The links (`href`, `path`, `url`) a navigation file's diff adds and removes. PURE. */
+export function navigationChanges(diff) {
+  const links = (sign) => [
+    ...new Set(
+      String(diff)
+        .split('\n')
+        .filter(
+          (line) =>
+            line.startsWith(sign) && !line.startsWith(`${sign}${sign}${sign}`),
+        )
+        .flatMap((line) =>
+          [
+            ...line.matchAll(
+              /\b(?:href|path|url|to)\s*[:=]\s*['"`](\/[^'"`]*)['"`]/g,
+            ),
+          ].map((match) => match[1]),
+        ),
+    ),
+  ];
+  const added = links('+');
+  const removed = links('-');
+  return {
+    added: added.filter((link) => !removed.includes(link)),
+    removed: removed.filter((link) => !added.includes(link)),
+    moved: added.filter((link) => removed.includes(link)),
+  };
+}
+
+const git = (worktree, args) =>
+  execFileSync('git', ['-C', worktree, ...args], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    maxBuffer: 64 * 1024 * 1024,
+  });
+const tryGit = (worktree, args) => {
+  try {
+    return git(worktree, args);
+  } catch {
+    return null;
+  }
+};
+const sha = (text) => createHash('sha256').update(text).digest('hex');
+
+/** The routes a frontend bout's worktree changes against its stack base. */
+export function collectFrontRoutes(boutDir) {
+  const state = readState(boutDir);
+  const { worktree } = state;
+  if (!worktree || !existsSync(worktree))
+    throw new Error(`the worktree of #${state.pr} is gone (${worktree})`);
+  const ref = tryGit(worktree, [
+    'rev-parse',
+    '--verify',
+    '-q',
+    `origin/${state.base}`,
+  ])
+    ? `origin/${state.base}`
+    : state.base;
+  const changed = new Map();
+  for (const line of git(worktree, [
+    'diff',
+    '--name-status',
+    '--no-renames',
+    ref,
+  ])
+    .split('\n')
+    .filter(Boolean)) {
+    const [code, path] = line.split('\t');
+    changed.set(path, { status: code[0] });
+  }
+  for (const line of git(worktree, ['diff', '--numstat', '--no-renames', ref])
+    .split('\n')
+    .filter(Boolean)) {
+    const [added, deleted, path] = line.split('\t');
+    if (changed.has(path))
+      Object.assign(changed.get(path), {
+        added: Number(added) || 0,
+        deleted: Number(deleted) || 0,
+      });
+  }
+  for (const path of git(worktree, [
+    'ls-files',
+    '--others',
+    '--exclude-standard',
+  ])
+    .split('\n')
+    .filter(Boolean)) {
+    if (changed.has(path) || !ROUTE_FILE.test(path)) continue;
+    const text = readFileSync(posix.join(worktree, path), 'utf8');
+    changed.set(path, {
+      status: 'A',
+      added: text.split('\n').length,
+      deleted: 0,
+    });
+  }
+  const head = (path) =>
+    existsSync(posix.join(worktree, path))
+      ? readFileSync(posix.join(worktree, path), 'utf8')
+      : null;
+  const atBase = (path) => tryGit(worktree, ['show', `${ref}:${path}`]);
+  const textOf = (path) =>
+    (changed.get(path)?.status === 'D' ? atBase(path) : head(path)) ?? '';
+  const exists = (path) => {
+    if (changed.has(path)) return true;
+    try {
+      return statSync(posix.join(worktree, path)).isFile();
+    } catch {
+      return false;
+    }
+  };
+
+  /** The changed files a route reaches through its imports (itself first). */
+  const reach = (file) => {
+    const seen = [file];
+    const queue = [file];
+    while (queue.length && seen.length < MAX_REACH) {
+      const current = queue.shift();
+      for (const specifier of importsOf(textOf(current))) {
+        const target = resolveImport(current, specifier, exists);
+        if (!target || seen.includes(target) || !changed.has(target)) continue;
+        seen.push(target);
+        queue.push(target);
+      }
+    }
+    return seen;
+  };
+  const STATUS = { A: 'added', M: 'changed', D: 'removed' };
+  const routes = [...changed.entries()]
+    .map(([file, change]) => ({ file, change, route: routeOf(file) }))
+    .filter(({ route, change }) => route && STATUS[change.status])
+    .map(({ file, change, route }) => {
+      const files = reach(file);
+      const texts = files.map((path) => textOf(path));
+      const kindOf = (path) =>
+        /\/(services|api|lib|sdk)\//.test(path)
+          ? 'services'
+          : /\/hooks?\//.test(path) || /\/use[A-Z]\w*\.tsx?$/.test(path)
+            ? 'hooks'
+            : 'components';
+      const group = (kind) =>
+        files.slice(1).filter((path) => kindOf(path) === kind);
+      return {
+        key: `pr${state.pr}-ROUTE-${route.url.replace(/[^A-Za-z0-9]+/g, '_').replace(/^_+|_+$/g, '') || 'root'}`,
+        kind: route.kind,
+        url: route.url,
+        file,
+        status: STATUS[change.status],
+        sparringOnly: /sparring/i.test(file),
+        dynamic: [...route.url.matchAll(/\[\.{0,3}(\w+)\]/g)].map(
+          (match) => match[1],
+        ),
+        params: [...new Set(texts.flatMap(queryParams))].sort(),
+        components: group('components'),
+        hooks: group('hooks'),
+        services: group('services'),
+        calls: [...new Set(texts.flatMap(backendCalls))].sort(),
+        files: files.map((path) => ({
+          path,
+          status: changed.get(path).status,
+          added: changed.get(path).added ?? 0,
+          deleted: changed.get(path).deleted ?? 0,
+        })),
+        hash: sha(
+          files
+            .map((path, index) => `${path}\n${texts[index]}`)
+            .join('\n\u0000\n'),
+        ).slice(0, 16),
+      };
+    })
+    .sort(
+      (a, b) =>
+        (a.kind === 'global') - (b.kind === 'global') ||
+        a.url.localeCompare(b.url),
+    );
+  const navigation = [...changed.keys()]
+    .filter(
+      (path) =>
+        NAVIGATION.test(path) && ROUTE_FILE.test(path) && !routeOf(path),
+    )
+    .map((path) => ({
+      path,
+      ...navigationChanges(git(worktree, ['diff', ref, '--', path])),
+    }))
+    .filter(
+      (entry) =>
+        entry.added.length || entry.removed.length || entry.moved.length,
+    );
+  return {
+    pr: state.pr,
+    base: ref,
+    previewUrl: state.previewUrl ?? null,
+    routes,
+    navigation,
+  };
+}
+
+/** The fingerprint of the routes a page embeds for this bout, or null when they cannot be read. */
+export function routesSourcesHash(boutDir) {
+  try {
+    return sha(scriptJson(collectFrontRoutes(boutDir)));
+  } catch {
+    return null;
+  }
+}
+
+/** The block after `<!-- ring:front-routes #<pr> -->`: the container and the routes as JSON. PURE. */
+export function routesBlock(routes) {
+  const fallback = routes.routes.length
+    ? `Las rutas del frontend se dibujan al abrir la página (${routes.routes.length} contra ${routes.base}).`
+    : `Ninguna ruta cambia contra ${routes.base}.`;
+  return [
+    `<div class="endpoints routes" data-ring-routes="${routes.pr}"><p class="endpoints-wait">${fallback}</p></div>`,
+    `<script type="application/json" id="ring-routes-${routes.pr}">${scriptJson(routes)}</script>`,
+  ].join('\n');
+}