arcway 0.1.14 → 0.1.16

package/client/page-loader.js

@@ -1,3 +1,5 @@
+import { compileRoutePattern, extractRouteParams } from './route-pattern.js';
+
 const moduleCache = new Map();
 const patternCache = new Map();
 
@@ -34,43 +36,11 @@ function readClientManifest() {
   }
 }
 
-function compilePattern(pattern) {
-  const paramNames = [];
-  let catchAllParam;
-
-  const regexStr = pattern.replace(
-    /\/:([^/]+)|\/\*(\w+)\?|\/\*(\w+)/g,
-    (match, singleParam, optCatchAll, reqCatchAll) => {
-      if (singleParam) {
-        paramNames.push(singleParam);
-        return '/([^/]+)';
-      }
-      if (optCatchAll) {
-        paramNames.push(optCatchAll);
-        catchAllParam = optCatchAll;
-        return '(?:/(.+))?';
-      }
-      if (reqCatchAll) {
-        paramNames.push(reqCatchAll);
-        catchAllParam = reqCatchAll;
-        return '/(.+)';
-      }
-      return match;
-    },
-  );
-
-  return {
-    regex: new RegExp(`^${regexStr}\\/?$`),
-    paramNames,
-    catchAllParam,
-  };
-}
-
 function matchClientRoute(manifest, pathname) {
   for (const route of manifest.routes) {
     let compiled = patternCache.get(route.pattern);
     if (!compiled) {
-      compiled = compilePattern(route.pattern);
+      compiled = compileRoutePattern(route.pattern);
       patternCache.set(route.pattern, compiled);
     }
     const { regex, paramNames, catchAllParam } = compiled;
@@ -78,20 +48,8 @@ function matchClientRoute(manifest, pathname) {
     const match = regex.exec(pathname);
     if (!match) continue;
 
-    const params = {};
-    try {
-      for (let i = 0; i < paramNames.length; i++) {
-        const name = paramNames[i];
-        const raw = match[i + 1];
-        if (name === catchAll) {
-          params[name] = raw ? raw.split('/').map(decodeURIComponent) : [];
-        } else {
-          params[name] = decodeURIComponent(raw);
-        }
-      }
-    } catch {
-      continue;
-    }
+    const params = extractRouteParams(match, paramNames, catchAll);
+    if (!params) continue;
 
     return { route, params };
   }
@@ -146,7 +104,6 @@ async function loadPage(manifest, pathname) {
 }
 
 export {
-  compilePattern,
   loadLoadingComponents,
   loadPage,
   matchClientRoute,

package/client/route-pattern.js

@@ -0,0 +1,48 @@
+function compileRoutePattern(pattern) {
+  const paramNames = [];
+  let catchAllParam;
+  let isOptionalCatchAll = false;
+  const regexStr = pattern.replace(
+    /\/:([^/]+)|\/\*(\w+)\?|\/\*(\w+)/g,
+    (match, singleParam, optCatchAll, reqCatchAll) => {
+      if (singleParam) {
+        paramNames.push(singleParam);
+        return '/([^/]+)';
+      }
+      if (optCatchAll) {
+        paramNames.push(optCatchAll);
+        catchAllParam = optCatchAll;
+        isOptionalCatchAll = true;
+        return '(?:/(.+))?';
+      }
+      if (reqCatchAll) {
+        paramNames.push(reqCatchAll);
+        catchAllParam = reqCatchAll;
+        return '/(.+)';
+      }
+      return match;
+    },
+  );
+  const regex = new RegExp(`^${regexStr}/?$`);
+  return { regex, paramNames, catchAllParam, isOptionalCatchAll };
+}
+
+function extractRouteParams(match, paramNames, catchAllParam) {
+  const params = {};
+  try {
+    for (let i = 0; i < paramNames.length; i++) {
+      const name = paramNames[i];
+      const raw = match[i + 1];
+      if (name === catchAllParam) {
+        params[name] = raw ? raw.split('/').map(decodeURIComponent) : [];
+      } else {
+        params[name] = decodeURIComponent(raw);
+      }
+    }
+  } catch {
+    return null;
+  }
+  return params;
+}
+
+export { compileRoutePattern, extractRouteParams };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arcway",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "A convention-based framework for building modular monoliths with strict domain boundaries.",
   "license": "MIT",
   "type": "module",
@@ -96,7 +96,6 @@
     "swr": "^2.3.3",
     "tailwind-merge": "^3.4.1",
     "tailwindcss": "^4.1.18",
-    "tailwindcss-animate": "^1.0.7",
     "vaul": "^1.1.2",
     "ws": "^8.19.0",
     "zod": "^3.24.0"
@@ -114,10 +113,8 @@
     }
   },
   "devDependencies": {
-    "@chromatic-com/storybook": "^5.0.1",
     "@storybook/addon-a11y": "^10.2.8",
     "@storybook/addon-docs": "^10.2.8",
-    "@storybook/addon-onboarding": "^10.2.8",
     "@storybook/addon-vitest": "^10.2.8",
     "@storybook/react-vite": "^10.2.8",
     "@tailwindcss/vite": "^4.1.18",

package/server/boot/index.js

@@ -59,8 +59,8 @@ async function boot(options) {
   });
   await jobRunner.init();
 
-  const fileWatcher = new FileWatcher(rootDir, { log });
-  await fileWatcher.start();
+  const fileWatcher = mode === 'development' ? new FileWatcher(rootDir, { log }) : null;
+  if (fileWatcher) await fileWatcher.start();
 
   const appContext = { db, redis, events, queue, cache, files, mail, log, fileWatcher };
 
@@ -68,13 +68,14 @@ async function boot(options) {
 
   const apiRouter = new ApiRouter(config.api, {
     log,
+    mode,
     fileWatcher,
     appContext,
     sessionConfig: config.session,
   });
   await apiRouter.init();
 
-  const pagesRouter = new PagesRouter(config, { rootDir, log, fileWatcher, appContext });
+  const pagesRouter = new PagesRouter(config, { rootDir, log, mode, fileWatcher, appContext });
   await pagesRouter.init();
 
   const healthDeps = {
@@ -117,7 +118,7 @@ async function boot(options) {
     await pagesRouter.close();
     await apiRouter.close();
     await webServer.close();
-    await fileWatcher.close();
+    if (fileWatcher) await fileWatcher.close();
     await destroyInfrastructure(infrastructure);
     await mcpRouter.cleanup(rootDir);
   };

package/server/docs/openapi.js

@@ -50,6 +50,89 @@ function buildQueryParameters(route) {
     return [];
   }
 }
+function buildOperationId(method, openApiPath) {
+  const path = openApiPath.replace(/[{}\/]/g, '_').replace(/_+/g, '_').replace(/^_|_$/g, '');
+  return `${method}_${path}`;
+}
+
+function tryConvertSchema(schema) {
+  if (!schema) return undefined;
+  try {
+    return typeToOpenAPISchema(schema);
+  } catch {
+    return undefined;
+  }
+}
+
+function resolveTags(route) {
+  const tags = route.config.meta?.tags;
+  if (tags && tags.length > 0) return tags;
+  return [route.pattern.split('/')[1] || 'default'];
+}
+
+function buildRequestBody(bodySchema) {
+  const converted = tryConvertSchema(bodySchema);
+  if (!converted) return undefined;
+  return {
+    required: true,
+    content: { 'application/json': { schema: converted } },
+  };
+}
+
+const VALIDATION_ERROR_RESPONSE = {
+  description: 'Validation error',
+  content: {
+    'application/json': {
+      schema: {
+        type: 'object',
+        properties: {
+          error: {
+            type: 'object',
+            properties: {
+              code: { type: 'string' },
+              message: { type: 'string' },
+              details: {},
+            },
+          },
+        },
+      },
+    },
+  },
+};
+
+const DEFAULT_SUCCESS_SCHEMA = { type: 'object', properties: { data: {} } };
+
+function buildResponses(routeSchema) {
+  const successSchema = tryConvertSchema(routeSchema?.response) ?? DEFAULT_SUCCESS_SCHEMA;
+  const responses = {
+    200: {
+      description: 'Successful response',
+      content: { 'application/json': { schema: successSchema } },
+    },
+  };
+  if (routeSchema?.body || routeSchema?.query) {
+    responses[400] = VALIDATION_ERROR_RESPONSE;
+  }
+  return responses;
+}
+
+function buildOperation(route, method, openApiPath) {
+  const operation = { operationId: buildOperationId(method, openApiPath) };
+  const meta = route.config.meta;
+  if (meta?.summary) operation.summary = meta.summary;
+  if (meta?.description) operation.description = meta.description;
+  operation.tags = resolveTags(route);
+
+  const parameters = [...buildPathParameters(route), ...buildQueryParameters(route)];
+  if (parameters.length > 0) operation.parameters = parameters;
+
+  const requestBody = buildRequestBody(route.config.schema?.body);
+  if (requestBody) operation.requestBody = requestBody;
+
+  operation.responses = buildResponses(route.config.schema);
+  return operation;
+}
+
 function generateOpenAPISpec(routes, info) {
   const spec = {
     openapi: '3.0.3',
@@ -63,90 +146,8 @@ function generateOpenAPISpec(routes, info) {
   for (const route of routes) {
     const openApiPath = toOpenAPIPath(route.pattern);
     const method = route.method.toLowerCase();
-    if (!spec.paths[openApiPath]) {
-      spec.paths[openApiPath] = {};
-    }
-    const operation = {
-      operationId: `${method}_${openApiPath
-        .replace(/[{}\/]/g, '_')
-        .replace(/_+/g, '_')
-        .replace(/^_|_$/g, '')}`,
-    };
-    const meta = route.config.meta;
-    if (meta?.summary) operation.summary = meta.summary;
-    if (meta?.description) operation.description = meta.description;
-    if (meta?.tags && meta.tags.length > 0) {
-      operation.tags = meta.tags;
-    } else {
-      const firstSegment = route.pattern.split('/')[1] || 'default';
-      operation.tags = [firstSegment];
-    }
-    const parameters = [...buildPathParameters(route), ...buildQueryParameters(route)];
-    if (parameters.length > 0) {
-      operation.parameters = parameters;
-    }
-    if (route.config.schema?.body) {
-      try {
-        const bodySchema = typeToOpenAPISchema(route.config.schema.body);
-        operation.requestBody = {
-          required: true,
-          content: {
-            'application/json': {
-              schema: bodySchema,
-            },
-          },
-        };
-      } catch {}
-    }
-    const responseSchema = route.config.schema?.response
-      ? (() => {
-          try {
-            return typeToOpenAPISchema(route.config.schema.response);
-          } catch {
-            return void 0;
-          }
-        })()
-      : void 0;
-    operation.responses = {
-      200: {
-        description: 'Successful response',
-        content: {
-          'application/json': {
-            schema: responseSchema ?? {
-              type: 'object',
-              properties: {
-                data: {},
-              },
-            },
-          },
-        },
-      },
-      ...(route.config.schema?.body || route.config.schema?.query
-        ? {
-            400: {
-              description: 'Validation error',
-              content: {
-                'application/json': {
-                  schema: {
-                    type: 'object',
-                    properties: {
-                      error: {
-                        type: 'object',
-                        properties: {
-                          code: { type: 'string' },
-                          message: { type: 'string' },
-                          details: {},
-                        },
-                      },
-                    },
-                  },
-                },
-              },
-            },
-          }
-        : {}),
-    };
-    spec.paths[openApiPath][method] = operation;
+    if (!spec.paths[openApiPath]) spec.paths[openApiPath] = {};
+    spec.paths[openApiPath][method] = buildOperation(route, method, openApiPath);
   }
   return spec;
 }

package/server/logger/index.js

@@ -22,6 +22,23 @@ function wrapPino(p) {
   };
 }
 
+const QUERY_FILTERS = {
+  level: (v) => (e) => e.level === v,
+  logger: (v) => (e) => e.logger === v,
+  requestId: (v) => (e) => e.data?.requestId === v,
+  message: (v) => (e) => e.message === v,
+  method: (v) => (e) => e.data?.method === v.toUpperCase(),
+  path: (v) => (e) => e.data?.path?.includes(v),
+  status: (v) => (e) => e.data?.status === v,
+  minDurationMs: (v) => (e) => e.data?.durationMs >= v,
+  eventName: (v) => (e) =>
+    e.data?.eventName === v || e.data?.eventName?.includes(v),
+  since: (v) => {
+    const sinceTs = new Date(v).getTime();
+    return (e) => new Date(e.timestamp).getTime() >= sinceTs;
+  },
+};
+
 class Logger {
   _base;
   _ring;
@@ -89,22 +106,13 @@ class Logger {
   query(filters) {
     if (!this._ring) return [];
     let entries = this._ring.toArray();
-    if (filters?.level) entries = entries.filter((e) => e.level === filters.level);
-    if (filters?.logger) entries = entries.filter((e) => e.logger === filters.logger);
-    if (filters?.requestId) entries = entries.filter((e) => e.data?.requestId === filters.requestId);
-    if (filters?.message) entries = entries.filter((e) => e.message === filters.message);
-    if (filters?.method) entries = entries.filter((e) => e.data?.method === filters.method.toUpperCase());
-    if (filters?.path) entries = entries.filter((e) => e.data?.path?.includes(filters.path));
-    if (filters?.status) entries = entries.filter((e) => e.data?.status === filters.status);
-    if (filters?.minDurationMs) entries = entries.filter((e) => e.data?.durationMs >= filters.minDurationMs);
-    if (filters?.eventName) {
-      entries = entries.filter((e) => e.data?.eventName === filters.eventName || e.data?.eventName?.includes(filters.eventName));
-    }
-    if (filters?.since) {
-      const sinceTs = new Date(filters.since).getTime();
-      entries = entries.filter((e) => new Date(e.timestamp).getTime() >= sinceTs);
+    if (!filters) return entries;
+    for (const [key, makePredicate] of Object.entries(QUERY_FILTERS)) {
+      const value = filters[key];
+      if (value === undefined || value === null || value === '' || value === false) continue;
+      entries = entries.filter(makePredicate(value));
     }
-    if (filters?.limit && filters.limit > 0) entries = entries.slice(-filters.limit);
+    if (filters.limit && filters.limit > 0) entries = entries.slice(-filters.limit);
     return entries;
   }
 

package/server/pages/build-cache.js

@@ -194,10 +194,128 @@ async function buildWithCache({
   return { cacheHit: false, metafile: result.metafile };
 }
 
+// Multi-file cache for bundles with several output files (client build with
+// code-splitting). Each cache entry lives under <bucket>/<coarseKey>/ and the
+// index is a sidecar <bucket>/<coarseKey>.meta.json.
+async function lookupMultiFileCache({ rootDir, kind, coarseKey }) {
+  const bucket = bucketDir(rootDir, kind);
+  const metaPath = path.join(bucket, `${coarseKey}.meta.json`);
+  const cacheDir = path.join(bucket, coarseKey);
+  const meta = await readJson(metaPath);
+  if (!meta) return { hit: false, bucket, cacheDir, metaPath };
+  const currentHash = await hashInputs(meta.inputs);
+  if (currentHash === null || currentHash !== meta.inputsHash) {
+    return { hit: false, bucket, cacheDir, metaPath };
+  }
+  // Sanity-check every recorded output file still exists in the cache dir.
+  for (const rel of meta.outputs) {
+    try {
+      await fs.access(path.join(cacheDir, rel));
+    } catch {
+      return { hit: false, bucket, cacheDir, metaPath };
+    }
+  }
+  return { hit: true, bucket, cacheDir, metaPath, meta };
+}
+
+async function restoreMultiFileCache({ cacheDir, outputs, destDir }) {
+  await fs.mkdir(destDir, { recursive: true });
+  await Promise.all(
+    outputs.map(async (rel) => {
+      const src = path.join(cacheDir, rel);
+      const dst = path.join(destDir, rel);
+      await fs.mkdir(path.dirname(dst), { recursive: true });
+      await fs.cp(src, dst);
+    }),
+  );
+}
+
+async function storeMultiFileCache({
+  bucket,
+  coarseKey,
+  destDir,
+  outputs,
+  inputs,
+  metadata,
+}) {
+  const cacheDir = path.join(bucket, coarseKey);
+  await fs.rm(cacheDir, { recursive: true, force: true });
+  await fs.mkdir(cacheDir, { recursive: true });
+  await Promise.all(
+    outputs.map(async (rel) => {
+      const src = path.join(destDir, rel);
+      const dst = path.join(cacheDir, rel);
+      await fs.mkdir(path.dirname(dst), { recursive: true });
+      await cpAtomic(src, dst);
+    }),
+  );
+  const inputsHash = await hashInputs(inputs);
+  const metaPath = path.join(bucket, `${coarseKey}.meta.json`);
+  await writeJsonAtomic(metaPath, {
+    inputs,
+    inputsHash,
+    outputs,
+    metadata,
+    mtime: Date.now(),
+  });
+}
+
+// Walk every cache entry in <rootDir>/node_modules/.cache/arcway-pages/<kind>
+// and drop any whose recorded inputs no longer hash to the stored value (or
+// whose inputs are gone). Used by tests that intentionally mutate fixture
+// sources to keep cross-fork cache state consistent. Best-effort: missing
+// bucket → returns {removed: 0, kept: 0}; individual unlink failures are
+// swallowed since a concurrent worker may already be removing the same entry.
+async function pruneStaleCache({ rootDir, kind }) {
+  const bucket = bucketDir(rootDir, kind);
+  let entries;
+  try {
+    entries = await fs.readdir(bucket);
+  } catch (err) {
+    if (err.code === 'ENOENT') return { removed: 0, kept: 0 };
+    throw err;
+  }
+
+  const metaFiles = entries.filter((f) => f.endsWith('.meta.json'));
+  let removed = 0;
+  let kept = 0;
+
+  for (const metaFile of metaFiles) {
+    const metaPath = path.join(bucket, metaFile);
+    const meta = await readJson(metaPath);
+    const stale =
+      !meta ||
+      !Array.isArray(meta.inputs) ||
+      (await hashInputs(meta.inputs)) !== meta.inputsHash;
+
+    if (!stale) {
+      kept += 1;
+      continue;
+    }
+
+    const baseKey = metaFile.slice(0, -'.meta.json'.length);
+    await Promise.allSettled([
+      fs.rm(metaPath, { force: true }),
+      fs.rm(path.join(bucket, `${baseKey}.js`), { force: true }),
+      fs.rm(path.join(bucket, `${baseKey}.js.map`), { force: true }),
+      fs.rm(path.join(bucket, baseKey), { recursive: true, force: true }),
+    ]);
+    removed += 1;
+  }
+
+  return { removed, kept };
+}
+
 export {
   buildWithCache,
   computeConfigHash,
   cacheRoot,
   entryKey,
   ESBUILD_VERSION,
+  sha256,
+  hashInputs,
+  lookupMultiFileCache,
+  pruneStaleCache,
+  restoreMultiFileCache,
+  storeMultiFileCache,
 };