@tokenoftrust/storefront-runner 2.4.28 → 2.4.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tokenoftrust/storefront-runner",
-  "version": "2.4.28",
+  "version": "2.4.29",
   "license": "SEE LICENSE IN LICENSE",
   "description": "World-shareable storefront runner: multi-tenant renderer on Astro/Cloudflare. No control plane.",
   "packageManager": "pnpm@11.9.0",

package/packages/cli/src/publication-spaces.mjs

@@ -305,3 +305,75 @@ export function describeOwner(topology, urlPath) {
     dir: spaceDir(space) || ".",
   };
 }
+
+/**
+ * Route changed workspace files to the repository that ships them. Paths are relative to the
+ * root checkout (a space's files as `spaces/<id>/...`). Each file lands in its owning space's
+ * group; a root file whose URL a mounted space owns is ALSO named as misrouted (it ships with the
+ * root and still never reaches a visitor); a file under `spaces/` naming no declared space is
+ * unowned. Pure.
+ * @param {Topology} topology
+ * @param {string[]} files
+ * @returns {{ groups: Array<{ space: TopologySpace, files: string[] }>,
+ *   misrouted: Array<{ file: string, owner: TopologySpace }>, unowned: string[] }}
+ */
+export function routeWorkspaceChanges(topology, files) {
+  const root = rootSpace(topology);
+  /** @type {Map<string, string[]>} */
+  const byId = new Map(topology.spaces.map((space) => [space.id, []]));
+  const misrouted = [];
+  const unowned = [];
+  for (const file of files) {
+    const owner = spaceForWorkspaceFile(topology, file);
+    if (!owner) { unowned.push(file); continue; }
+    /** @type {string[]} */ (byId.get(owner.space.id)).push(file);
+    if (owner.space.mount === "/") {
+      const urlPath = rootFileUrlPath(root, file);
+      const served = urlPath ? owningSpace(topology, urlPath) : null;
+      if (served?.space && served.space.mount !== "/") misrouted.push({ file, owner: served.space });
+    }
+  }
+  return {
+    groups: topology.spaces.map((space) => ({ space, files: /** @type {string[]} */ (byId.get(space.id)) })),
+    misrouted,
+    unowned,
+  };
+}
+
+/**
+ * Parse `git status --porcelain=v1 -z` into changed paths (a rename yields its new path). Pure.
+ * @param {string} out
+ * @returns {string[]}
+ */
+export function parsePorcelainZ(out) {
+  const parts = String(out).split("\0");
+  const paths = [];
+  for (let i = 0; i < parts.length; i++) {
+    const entry = parts[i];
+    if (!entry || entry.length < 4) continue;
+    const status = entry.slice(0, 2);
+    paths.push(entry.slice(3));
+    if (status[0] === "R" || status[0] === "C") i++; // the next field is the rename's source
+  }
+  return paths;
+}
+
+/**
+ * Every changed file in a workspace, relative to the root checkout: the root repository's own
+ * changes plus each cloned space's (`spaces/<id>/...`). `git(dir, args)` runs git in `dir`.
+ * @param {string} workspace
+ * @param {Topology} topology
+ * @param {(dir: string, args: string[]) => string} git
+ * @returns {string[]}
+ */
+export function workspaceChangedFiles(workspace, topology, git) {
+  const files = parsePorcelainZ(git(workspace, ["status", "--porcelain=v1", "-z", "--untracked-files=all"]));
+  for (const space of mountedSpaces(topology)) {
+    const dir = join(workspace, spaceDir(space));
+    if (!existsSync(join(dir, ".git"))) continue;
+    for (const file of parsePorcelainZ(git(dir, ["status", "--porcelain=v1", "-z", "--untracked-files=all"]))) {
+      files.push(`${spaceDir(space)}/${file}`);
+    }
+  }
+  return files;
+}