arcway 0.1.26 → 0.1.27

package/server/db/index.js

@@ -43,7 +43,9 @@ async function createDB(config, { log } = {}) {
     ...hooks,
     client,
     connection,
-    ...(isSqlite ? { useNullAsDefault: true } : {}),
+    ...(isSqlite
+      ? { useNullAsDefault: config.sqlite?.useNullAsDefault ?? config.useNullAsDefault ?? true }
+      : {}),
   });
 
   try {
@@ -55,6 +57,9 @@ async function createDB(config, { log } = {}) {
   }
 
   if (isSqlite) {
+    if (config.sqlite?.foreignKeys) {
+      await db.raw('PRAGMA foreign_keys = ON');
+    }
     await db.raw('PRAGMA journal_mode = WAL');
     await db.raw('PRAGMA busy_timeout = 5000');
     await db.raw('PRAGMA synchronous = NORMAL');

package/server/events/drivers/memory.js

@@ -1,22 +1,40 @@
+import { randomUUID } from 'node:crypto';
 import { patternToRegex } from '../pattern.js';
 class MemoryTransport {
   subscriptions = [];
   /** Subscribe to events matching a pattern. */
-  subscribe(pattern, handler) {
+  subscribe(pattern, handler, options = {}) {
     const regex = patternToRegex(pattern);
-    this.subscriptions.push({ pattern, regex, handler });
+    const subscription = { pattern, regex, handler, consumerGroup: options.consumerGroup };
+    this.subscriptions.push(subscription);
+    return () => {
+      const index = this.subscriptions.indexOf(subscription);
+      if (index !== -1) this.subscriptions.splice(index, 1);
+    };
   }
   /** Emit an event. Handlers run asynchronously — fire-and-forget. */
   async emit(eventName, payload) {
     const matching = this.subscriptions.filter((sub) => sub.regex.test(eventName));
     if (matching.length === 0) return;
+    const meta = { id: randomUUID() };
+    const grouped = [];
+    const seenGroups = new Set();
+    for (const sub of matching) {
+      if (!sub.consumerGroup) {
+        grouped.push(sub);
+        continue;
+      }
+      if (seenGroups.has(sub.consumerGroup)) continue;
+      seenGroups.add(sub.consumerGroup);
+      grouped.push(sub);
+    }
     Promise.allSettled(
-      matching.map((sub) => sub.handler(eventName, payload)),
+      grouped.map((sub) => sub.handler(payload, eventName, meta)),
     ).then((results) => {
       for (let i = 0; i < results.length; i++) {
         if (results[i].status === 'rejected') {
           console.error(
-            `Event listener error [${matching[i].pattern}] for event "${eventName}":`,
+            `Event listener error [${grouped[i].pattern}] for event "${eventName}":`,
             results[i].reason,
           );
         }

package/server/events/drivers/redis.js

@@ -1,3 +1,4 @@
+import { randomUUID } from 'node:crypto';
 import { patternToRegex } from '../pattern.js';
 class RedisTransport {
   pub;
@@ -10,17 +11,22 @@ class RedisTransport {
     this.sub = sub;
     this.prefix = `${keyPrefix}events:`;
   }
-  subscribe(pattern, handler) {
+  subscribe(pattern, handler, options = {}) {
     const regex = patternToRegex(pattern);
-    this.subscriptions.push({ pattern, regex, handler });
+    const subscription = { pattern, regex, handler, consumerGroup: options.consumerGroup };
+    this.subscriptions.push(subscription);
     if (!this.listening) {
       this.listening = true;
       this.startListening();
     }
+    return () => {
+      const index = this.subscriptions.indexOf(subscription);
+      if (index !== -1) this.subscriptions.splice(index, 1);
+    };
   }
   async emit(eventName, payload) {
     const channel = `${this.prefix}${eventName}`;
-    const message = JSON.stringify({ event: eventName, payload });
+    const message = JSON.stringify({ id: randomUUID(), event: eventName, payload });
     await this.pub.publish(channel, message);
   }
   startListening() {
@@ -36,10 +42,19 @@ class RedisTransport {
         console.warn('[RedisTransport] Malformed event message, skipping');
         return;
       }
-      const { event: eventName, payload } = parsed;
+      const { id, event: eventName, payload } = parsed;
       const matching = this.subscriptions.filter((sub) => sub.regex.test(eventName));
       if (matching.length === 0) return;
-      Promise.allSettled(matching.map((sub) => sub.handler(eventName, payload))).then((results) => {
+      Promise.allSettled(
+        matching.map(async (sub) => {
+          if (sub.consumerGroup) {
+            const claimKey = `${this.prefix}consumer-groups:${sub.consumerGroup}:${id}`;
+            const claimed = await this.pub.set(claimKey, '1', 'PX', 60 * 60 * 1000, 'NX');
+            if (claimed !== 'OK') return;
+          }
+          await sub.handler(payload, eventName, { id });
+        }),
+      ).then((results) => {
         for (let i = 0; i < results.length; i++) {
           if (results[i].status === 'rejected') {
             console.error(

package/server/events/handler.js

@@ -11,8 +11,10 @@ function listenerPathToEvent(relativePath) {
 
 function validateHandler(item, filePath, index) {
   const label = index !== undefined ? `[${index}]` : '';
-  if (typeof item === 'function') return item;
-  if (typeof item === 'object' && item !== null && typeof item.handler === 'function') return item.handler;
+  if (typeof item === 'function') return { handler: item };
+  if (typeof item === 'object' && item !== null && typeof item.handler === 'function') {
+    return { handler: item.handler, consumerGroup: item.consumerGroup };
+  }
   throw new Error(
     `Listener at ${filePath}${label} must be a function or an object with a "handler" function`,
   );
@@ -54,11 +56,23 @@ class EventHandler {
 
       const items = Array.isArray(exported) ? exported : [exported];
       for (let i = 0; i < items.length; i++) {
-        const handler = validateHandler(items[i], filePath, items.length > 1 ? i : undefined);
-        this._events.subscribe(event, (_eventName, payload) => {
-          const ctx = buildContext(this._appContext, { event: { name: _eventName, payload } });
-          handler(ctx);
-        });
+        const { handler, consumerGroup } = validateHandler(
+          items[i],
+          filePath,
+          items.length > 1 ? i : undefined,
+        );
+        const groupName =
+          consumerGroup === false
+            ? undefined
+            : consumerGroup ?? `listener:${relativePath}:${items.length > 1 ? i : 0}`;
+        this._events.subscribe(
+          event,
+          (payload, _eventName) => {
+            const ctx = buildContext(this._appContext, { event: { name: _eventName, payload } });
+            return handler(ctx);
+          },
+          { consumerGroup: groupName },
+        );
         this._listeners.push({ event, fileName: relativePath });
       }
       this._log?.info(`  ${relativePath} → ${event}${items.length > 1 ? ` (${items.length} listeners)` : ''}`);

package/server/events/index.js

@@ -18,8 +18,8 @@ class Events {
     }
   }
 
-  subscribe(pattern, handler) {
-    this._transport.subscribe(pattern, handler);
+  subscribe(pattern, handler, options) {
+    return this._transport.subscribe(pattern, handler, options);
   }
 
   async emit(eventName, payload) {

package/server/index.js

@@ -1,6 +1,5 @@
 export { type } from 'arktype';
 export { buildContext } from './context.js';
-export * as vault from './lib/vault/index.js';
 export { default as boot } from './boot.js';
 export {
   Arcway,

package/server/jobs/runner.js

@@ -45,7 +45,7 @@ class JobRunner {
   _stopped = false;
   _lastEnqueuedMinute = new Map();
 
-  constructor(config, { db, queue, cache, files, mail, events, log, workerPool } = {}) {
+  constructor(config, { db, queue, cache, files, mail, events, log, meta, workerPool } = {}) {
     this._config = config;
     this._log = log;
     this._dispatcher = new JobDispatcher({
@@ -53,7 +53,7 @@ class JobRunner {
       staleTimeoutMs: config?.staleTimeoutMs,
       workerPool,
     });
-    this._appContext = { db, queue, cache, files, mail, events, log };
+    this._appContext = { db, queue, cache, files, mail, events, log, meta };
   }
 
   get dispatcher() {
@@ -96,6 +96,7 @@ class JobRunner {
       cache: this._appContext.cache?.withNamespace(SYSTEM_JOB_DOMAIN),
       files: this._appContext.files?.withNamespace(SYSTEM_JOB_DOMAIN),
       mail: this._appContext.mail,
+      meta: this._appContext.meta,
       log: this._log.extend({ logger: SYSTEM_JOB_DOMAIN }),
     };
     const systemJobs = registerSystemJobs(this._config, this._dispatcher, systemContext);

package/server/jobs/worker-config.js

@@ -0,0 +1,58 @@
+import { makeConfig } from '../config/loader.js';
+
+function isPlainObject(value) {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    !Array.isArray(value) &&
+    Object.getPrototypeOf(value) === Object.prototype
+  );
+}
+
+function stripFunctions(value) {
+  if (typeof value === 'function') return undefined;
+  if (Array.isArray(value)) return value.map(stripFunctions);
+  if (!isPlainObject(value)) return value;
+
+  const result = {};
+  for (const [key, child] of Object.entries(value)) {
+    const stripped = stripFunctions(child);
+    if (stripped !== undefined) result[key] = stripped;
+  }
+  return result;
+}
+
+function mergeConfig(base, override) {
+  if (!isPlainObject(base) || !isPlainObject(override)) {
+    return override === undefined ? base : override;
+  }
+
+  const result = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    result[key] = mergeConfig(result[key], value);
+  }
+  return result;
+}
+
+function createWorkerData({ config, rootDir, mode, meta } = {}) {
+  return {
+    config: stripFunctions(config),
+    configRootDir: rootDir,
+    mode,
+    meta: stripFunctions(meta),
+  };
+}
+
+async function resolveWorkerConfig(workerData) {
+  if (!workerData?.configRootDir) {
+    if (!workerData?.config) {
+      throw new Error('Worker started without workerData.config — cannot build job context');
+    }
+    return workerData.config;
+  }
+
+  const appConfig = await makeConfig(workerData.configRootDir, { mode: workerData.mode });
+  return mergeConfig(appConfig, workerData.config);
+}
+
+export { createWorkerData, mergeConfig, resolveWorkerConfig, stripFunctions };

package/server/jobs/worker-entry.js

@@ -1,6 +1,7 @@
 import { parentPort, workerData } from 'node:worker_threads';
 import { pathToFileURL } from 'node:url';
 import { serializeError } from './worker-pool.js';
+import { resolveWorkerConfig } from './worker-config.js';
 import { buildContext } from '../context.js';
 import { createInfrastructure, destroyInfrastructure } from '../boot/infrastructure.js';
 
@@ -21,16 +22,12 @@ let shuttingDown = false;
 async function ensureInfrastructure() {
   if (infrastructure) return infrastructure;
   if (!infrastructurePromise) {
-    const config = workerData?.config;
-    if (!config) {
-      throw new Error('Worker started without workerData.config — cannot build job context');
-    }
-    infrastructurePromise = createInfrastructure(config, { runMigrations: false }).then(
-      (services) => {
+    infrastructurePromise = resolveWorkerConfig(workerData)
+      .then((config) => createInfrastructure(config, { runMigrations: false }))
+      .then((services) => {
         infrastructure = services;
         return services;
-      },
-    );
+      });
   }
   return infrastructurePromise;
 }
@@ -55,9 +52,7 @@ async function loadHandler(handlerPath, handlerExport) {
         ? exported.handler
         : null;
   if (!fn) {
-    throw new Error(
-      `Worker handler export "${exportName}" in ${handlerPath} is not a function`,
-    );
+    throw new Error(`Worker handler export "${exportName}" in ${handlerPath} is not a function`);
   }
   return fn;
 }
@@ -71,7 +66,7 @@ async function runTask(task) {
   // and any future cpu-only caller) gets the raw payload — no DB spin-up.
   if (withContext) {
     const services = await ensureInfrastructure();
-    const ctx = buildContext(services, { payload });
+    const ctx = buildContext({ ...services, meta: workerData?.meta }, { payload });
     return fn(ctx);
   }
   return fn(payload);

package/server/meta.js

@@ -0,0 +1,106 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+
+function runGit(rootDir, args) {
+  try {
+    return execFileSync('git', args, {
+      cwd: rootDir,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function normalizeMeta(meta = {}) {
+  const sha = meta.sha ?? null;
+  const shortSha = meta.shortSha ?? (sha ? sha.slice(0, 7) : null);
+  const packageVersion = meta.packageVersion ?? null;
+
+  return {
+    builtAt: meta.builtAt ?? null,
+    version: meta.version ?? shortSha ?? packageVersion,
+    buildNumber: meta.buildNumber ?? null,
+    branch: meta.branch ?? null,
+    tag: meta.tag ?? null,
+    dirty: meta.dirty ?? null,
+    environment: meta.environment ?? process.env.NODE_ENV ?? 'development',
+    nodeVersion: meta.nodeVersion ?? process.version,
+    shortSha,
+    sha,
+    packageVersion,
+  };
+}
+
+function resolveEnvSha() {
+  return (
+    process.env.GIT_COMMIT ||
+    process.env.GITHUB_SHA ||
+    process.env.VERCEL_GIT_COMMIT_SHA ||
+    process.env.CI_COMMIT_SHA ||
+    null
+  );
+}
+
+function resolveGitSha(rootDir) {
+  const envSha = resolveEnvSha();
+  if (envSha) return envSha.trim();
+  return runGit(rootDir, ['rev-parse', 'HEAD']);
+}
+
+function resolveBuildNumber(rootDir) {
+  const count = runGit(rootDir, ['rev-list', '--count', 'HEAD']);
+  if (!count) return null;
+
+  const parsed = Number(count);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function resolveGitBranch(rootDir) {
+  return runGit(rootDir, ['rev-parse', '--abbrev-ref', 'HEAD']);
+}
+
+function resolveGitTag(rootDir) {
+  const tag = runGit(rootDir, ['describe', '--tags', '--abbrev=0']);
+  return tag || null;
+}
+
+function resolveDirty(rootDir) {
+  const status = runGit(rootDir, ['status', '--porcelain']);
+  if (status === null) return null;
+  return status.length > 0;
+}
+
+async function resolvePackageVersion(rootDir) {
+  try {
+    const pkg = JSON.parse(await fs.readFile(path.join(rootDir, 'package.json'), 'utf8'));
+    return pkg.version ?? null;
+  } catch {
+    return null;
+  }
+}
+
+async function collectRuntimeMeta(rootDir, { builtAt = new Date().toISOString() } = {}) {
+  const sha = resolveGitSha(rootDir);
+  const buildNumber = resolveBuildNumber(rootDir);
+  const branch = resolveGitBranch(rootDir);
+  const tag = resolveGitTag(rootDir);
+  const dirty = resolveDirty(rootDir);
+  const packageVersion = await resolvePackageVersion(rootDir);
+
+  return normalizeMeta({
+    builtAt,
+    buildNumber,
+    branch,
+    tag,
+    dirty,
+    environment: process.env.NODE_ENV ?? 'development',
+    nodeVersion: process.version,
+    sha,
+    packageVersion,
+  });
+}
+
+export { collectRuntimeMeta, normalizeMeta };

package/server/pages/build-plugins.js

@@ -57,7 +57,8 @@ function clientIsolationPlugin() {
           args.path === 'arcway/lib/client' ||
           args.path.startsWith('arcway/lib/client/') ||
           args.path === 'arcway/ui' ||
-          args.path.startsWith('arcway/ui/')
+          args.path.startsWith('arcway/ui/') ||
+          args.path === 'arcway/dynamic'
         ) {
           return void 0;
         }

package/server/pages/handler.js

@@ -16,10 +16,21 @@ import {
 import { MIME_TYPES } from './static.js';
 import { createArcwayDevEndpoint } from './arcway-endpoint.js';
 import { buildViteClientManifestJson, buildViteRoute } from './vite-dev.js';
+
+function getHtmlHeaders() {
+  return {
+    'Content-Type': 'text/html; charset=utf-8',
+    'Cache-Control': 'no-store',
+  };
+}
 function createPagesHandler(options) {
   const rootDir = options.rootDir;
-  const outDir = path.resolve(rootDir, options.outDir ?? '.build/pages');
-  const manifestPath = path.join(outDir, 'pages-manifest.json');
+  const resolveOutDir =
+    typeof options.resolveOutDir === 'function'
+      ? () => path.resolve(options.resolveOutDir())
+      : () => path.resolve(rootDir, options.outDir ?? '.build/pages');
+  let outDir = resolveOutDir();
+  let manifestPath = path.join(outDir, 'pages-manifest.json');
   const sessionConfig = options.session;
   const appContext = options.appContext ?? null;
   const mode = options.mode ?? 'production';
@@ -87,6 +98,11 @@ function createPagesHandler(options) {
       refreshFromLazy();
       return;
     }
+    const nextOutDir = resolveOutDir();
+    if (nextOutDir !== outDir) {
+      outDir = nextOutDir;
+      manifestPath = path.join(outDir, 'pages-manifest.json');
+    }
     if (!fs.existsSync(manifestPath)) return;
     manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
     routes = compileRoutes(manifest, { rootDir, outDir, viteDev });
@@ -132,6 +148,7 @@ function createPagesHandler(options) {
     }
     // Pick up any invalidations or completed builds that landed since the
     // last request before we resolve the route.
+    if (!lazyContext) reload();
     refreshFromLazy();
     const matched = matchPageRoute(routes, pathname);
     if (!matched) {
@@ -198,7 +215,7 @@ function createPagesHandler(options) {
         }
         const status = middlewareResult.status ?? 403;
         const headers = {
-          'Content-Type': 'text/html; charset=utf-8',
+          ...getHtmlHeaders(),
           ...middlewareResult.headers,
         };
         res.writeHead(status, headers);
@@ -240,7 +257,7 @@ function createPagesHandler(options) {
           projectReact,
         );
       } else if (!res.headersSent) {
-        res.writeHead(500, { 'Content-Type': 'text/html' });
+        res.writeHead(500, getHtmlHeaders());
         res.end('<h1>500 - Internal Server Error</h1>');
       }
     }
@@ -290,7 +307,7 @@ async function renderDevBuildError(
       .replace(/&/g, '&amp;')
       .replace(/</g, '&lt;')
       .replace(/>/g, '&gt;');
-    res.writeHead(500, { 'Content-Type': 'text/html; charset=utf-8' });
+    res.writeHead(500, getHtmlHeaders());
     res.end(`<h1>500 - Build Error</h1><pre>${escaped}</pre>`);
   }
 }
@@ -353,6 +370,7 @@ async function runPageMiddleware(
         queue: appContext.queue,
         files: appContext.files,
         mail: appContext.mail,
+        meta: appContext.meta,
       }
     : { page };
   for (const bundlePath of route.middlewareServerBundles) {

package/server/pages/out-dir.js

@@ -1,6 +1,9 @@
 import path from 'node:path';
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import crypto from 'node:crypto';
 
-function resolvePagesOutDir(config, rootDir, mode = 'production') {
+function resolvePagesBaseOutDir(config, rootDir, mode = 'production') {
   const pages = config?.pages ?? {};
   const isDev = mode === 'development';
   const prodOutDir = pages.outDir ?? path.resolve(rootDir, '.build/pages');
@@ -8,4 +11,102 @@ function resolvePagesOutDir(config, rootDir, mode = 'production') {
   return isDev ? devOutDir : prodOutDir;
 }
 
-export { resolvePagesOutDir };
+function getPagesBuildPaths(baseOutDir) {
+  const parentDir = path.dirname(baseOutDir);
+  return {
+    baseOutDir,
+    buildsDir: parentDir,
+    metaPath: path.join(parentDir, 'meta.json'),
+  };
+}
+
+function readActivePagesBuildHash(baseOutDir) {
+  const { metaPath } = getPagesBuildPaths(baseOutDir);
+  try {
+    const meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+    return typeof meta?.pagesBuildHash === 'string' && meta.pagesBuildHash.length > 0
+      ? meta.pagesBuildHash
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function resolveActivePagesOutDir(baseOutDir) {
+  const { buildsDir } = getPagesBuildPaths(baseOutDir);
+  const buildHash = readActivePagesBuildHash(baseOutDir);
+  if (buildHash) {
+    const candidate = path.join(buildsDir, buildHash);
+    if (fs.existsSync(path.join(candidate, 'pages-manifest.json'))) return candidate;
+  }
+  return baseOutDir;
+}
+
+function resolvePagesOutDir(config, rootDir, mode = 'production') {
+  const baseOutDir = resolvePagesBaseOutDir(config, rootDir, mode);
+  return mode === 'development' ? baseOutDir : resolveActivePagesOutDir(baseOutDir);
+}
+
+function createPagesBuildHash(now = new Date()) {
+  const iso = now
+    .toISOString()
+    .replace(/[-:]/g, '')
+    .replace(/\.\d{3}Z$/, 'Z');
+  return `${iso}-${crypto.randomBytes(4).toString('hex')}`;
+}
+
+async function createPagesVersionedBuildTarget(baseOutDir, buildHash = createPagesBuildHash()) {
+  const { buildsDir } = getPagesBuildPaths(baseOutDir);
+  await fsp.mkdir(buildsDir, { recursive: true });
+  return {
+    buildHash,
+    outDir: path.join(buildsDir, buildHash),
+  };
+}
+
+async function pruneOldPagesBuilds(baseOutDir, keepCount = 5) {
+  if (!Number.isInteger(keepCount) || keepCount < 1) return;
+  const { buildsDir } = getPagesBuildPaths(baseOutDir);
+  const activeHash = readActivePagesBuildHash(baseOutDir);
+  let entries = [];
+  try {
+    entries = await fsp.readdir(buildsDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  const builds = await Promise.all(
+    entries
+      .filter((entry) => entry.isDirectory())
+      .map(async (entry) => {
+        const fullPath = path.join(buildsDir, entry.name);
+        const manifestPath = path.join(fullPath, 'pages-manifest.json');
+        try {
+          const stat = await fsp.stat(manifestPath);
+          return { buildHash: entry.name, fullPath, mtimeMs: stat.mtimeMs };
+        } catch {
+          return null;
+        }
+      }),
+  );
+  const sorted = builds
+    .filter(Boolean)
+    .sort((a, b) => b.mtimeMs - a.mtimeMs || b.buildHash.localeCompare(a.buildHash));
+  const retained = new Set(sorted.slice(0, keepCount).map((entry) => entry.buildHash));
+  if (activeHash) retained.add(activeHash);
+  await Promise.all(
+    sorted
+      .filter((entry) => !retained.has(entry.buildHash))
+      .map((entry) => fsp.rm(entry.fullPath, { recursive: true, force: true })),
+  );
+}
+
+export {
+  createPagesBuildHash,
+  createPagesVersionedBuildTarget,
+  getPagesBuildPaths,
+  pruneOldPagesBuilds,
+  readActivePagesBuildHash,
+  resolveActivePagesOutDir,
+  resolvePagesBaseOutDir,
+  resolvePagesOutDir,
+};

package/server/pages/pages-router.js

@@ -26,7 +26,8 @@ class PagesRouter {
     const { config, rootDir, log, mode, fileWatcher } = this;
     const isDev = mode === 'development';
     const viteDev = isDev && config.pages?.vite?.enabled === true;
-    const outDir = resolvePagesOutDir(config, rootDir, mode);
+    const resolveOutDir = () => resolvePagesOutDir(config, rootDir, mode);
+    const outDir = resolveOutDir();
 
     if (isDev) {
       // Dev mode: `createLazyPagesContext()` builds only the shared bits
@@ -51,7 +52,7 @@ class PagesRouter {
 
     this.handler = createPagesHandler({
       rootDir,
-      outDir,
+      ...(isDev ? { outDir } : { resolveOutDir }),
       session: config.session,
       appContext: this.appContext,
       mode,