arcway 0.1.22 → 0.1.24

package/server/pages/vite-dev.js

@@ -0,0 +1,246 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import reactPlugin from '@vitejs/plugin-react';
+import tailwindcss from '@tailwindcss/vite';
+import { createServer as createViteServer } from 'vite';
+import { patternToFileName } from './build-server.js';
+
+function toPosixPath(value) {
+  return value.replace(/\\/g, '/');
+}
+
+function toViteModuleUrl(rootDir, filePath) {
+  if (!filePath) return null;
+  const abs = path.resolve(filePath);
+  const rel = path.relative(rootDir, abs);
+  if (!rel.startsWith('..') && !path.isAbsolute(rel)) {
+    return `/${toPosixPath(rel)}`;
+  }
+  return `/@fs/${toPosixPath(abs)}`;
+}
+
+function getViteEntryPath(outDir, pattern) {
+  return path.join(outDir, '.vite-entries', `${patternToFileName(pattern)}.tsx`);
+}
+
+function buildViteHydrationEntry({
+  componentPath,
+  layouts = [],
+  loadings = [],
+  pattern = '/',
+  globalStylesPath,
+}) {
+  const imports = [
+    `import { hydrateRoot } from 'react-dom/client';`,
+    `import { ApiProvider, Router } from 'arcway/lib/client';`,
+  ];
+
+  if (globalStylesPath) {
+    imports.push(`import '${toPosixPath(path.resolve(globalStylesPath))}';`);
+  }
+
+  imports.push(`import Component from '${toPosixPath(path.resolve(componentPath))}';`);
+
+  const layoutNames = [];
+  for (let i = 0; i < layouts.length; i++) {
+    imports.push(`import Layout${i} from '${toPosixPath(path.resolve(layouts[i]))}';`);
+    layoutNames.push(`Layout${i}`);
+  }
+
+  const loadingNames = [];
+  for (let i = 0; i < loadings.length; i++) {
+    imports.push(`import Loading${i} from '${toPosixPath(path.resolve(loadings[i]))}';`);
+    loadingNames.push(`Loading${i}`);
+  }
+
+  const layoutsArray = layoutNames.length > 0 ? `[${layoutNames.join(', ')}]` : '[]';
+  const loadingsArray = loadingNames.length > 0 ? `[${loadingNames.join(', ')}]` : '[]';
+
+  return `${imports.join('\n')}
+
+const container = document.getElementById('__app');
+const propsEl = document.getElementById('__app_props');
+const props = propsEl ? JSON.parse(propsEl.textContent || '{}') : {};
+const ROOT_KEY = '__arcway_root__';
+const rootOwner = window;
+const element = <ApiProvider><Router initialPath={window.location.pathname} initialParams={props} initialPattern={${JSON.stringify(pattern)}} initialComponent={Component} initialLayouts={${layoutsArray}} initialLoadings={${loadingsArray}} /></ApiProvider>;
+
+if (!container) {
+  throw new Error('Arcway Vite hydrate entry could not find #__app');
+}
+
+if (!rootOwner[ROOT_KEY]) {
+  rootOwner[ROOT_KEY] = hydrateRoot(container, element);
+} else {
+  rootOwner[ROOT_KEY].render(element);
+}
+`;
+}
+
+async function syncViteHydrationEntries({ manifest, outDir }) {
+  const viteDir = path.join(outDir, '.vite-entries');
+  await fs.mkdir(viteDir, { recursive: true });
+
+  const expected = new Set();
+
+  for (const entry of manifest.entries) {
+    const entryPath = getViteEntryPath(outDir, entry.pattern);
+    const content = buildViteHydrationEntry({
+      componentPath: entry.srcPath,
+      layouts: entry.layoutDirs
+        .map((dirPath) => manifest.layouts.get(dirPath)?.srcPath)
+        .filter((value) => value !== undefined),
+      loadings: entry.loadingDirs
+        .map((dirPath) => manifest.loadings.get(dirPath)?.srcPath)
+        .filter((value) => value !== undefined),
+      pattern: entry.pattern,
+      globalStylesPath: manifest.stylesPath,
+    });
+    await fs.mkdir(path.dirname(entryPath), { recursive: true });
+    await fs.writeFile(entryPath, content);
+    expected.add(toPosixPath(path.relative(viteDir, entryPath)));
+  }
+
+  const existing = await listFiles(viteDir);
+  await Promise.all(
+    existing
+      .filter((name) => !expected.has(name))
+      .map((name) => fs.rm(path.join(viteDir, name), { force: true })),
+  );
+}
+
+async function listFiles(rootDir, currentDir = rootDir) {
+  const entries = await fs.readdir(currentDir, { withFileTypes: true }).catch(() => []);
+  const files = [];
+  for (const entry of entries) {
+    const abs = path.join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await listFiles(rootDir, abs);
+      files.push(...nested);
+      continue;
+    }
+    files.push(toPosixPath(path.relative(rootDir, abs)));
+  }
+  return files;
+}
+
+function buildViteClientManifestJson(manifest, rootDir) {
+  const clientManifest = {
+    cssBundle: null,
+    routes: manifest.entries.map((entry) => {
+      const route = {
+        pattern: entry.pattern,
+        paramNames: entry.paramNames,
+        clientBundle: toViteModuleUrl(rootDir, entry.srcPath),
+        layoutBundles: entry.layoutDirs
+          .map((dirPath) => manifest.layouts.get(dirPath)?.srcPath)
+          .filter(Boolean)
+          .map((filePath) => toViteModuleUrl(rootDir, filePath)),
+        loadingBundles: entry.loadingDirs
+          .map((dirPath) => manifest.loadings.get(dirPath)?.srcPath)
+          .filter(Boolean)
+          .map((filePath) => toViteModuleUrl(rootDir, filePath)),
+        cssBundles: [],
+      };
+      if (entry.catchAllParam) route.catchAllParam = entry.catchAllParam;
+      return route;
+    }),
+  };
+  return JSON.stringify(clientManifest).replace(/</g, '\\u003c');
+}
+
+function buildViteRoute(route, { rootDir, outDir }) {
+  return {
+    ...route,
+    clientBundle: toViteModuleUrl(rootDir, getViteEntryPath(outDir, route.pattern)),
+    sharedChunks: ['/@vite/client'],
+    sharedCssChunks: [],
+  };
+}
+
+function resolveAppAliases(rootDir) {
+  const appRequire = createRequire(path.join(rootDir, 'package.json'));
+  const aliases = [];
+
+  try {
+    const reactRoot = path.dirname(appRequire.resolve('react/package.json'));
+    aliases.push({ find: /^react$/, replacement: toPosixPath(path.join(reactRoot, 'index.js')) });
+    aliases.push({ find: /^react\/jsx-runtime$/, replacement: toPosixPath(path.join(reactRoot, 'jsx-runtime.js')) });
+    aliases.push({ find: /^react\/jsx-dev-runtime$/, replacement: toPosixPath(path.join(reactRoot, 'jsx-dev-runtime.js')) });
+  } catch {}
+
+  try {
+    const reactDomRoot = path.dirname(appRequire.resolve('react-dom/package.json'));
+    aliases.push({ find: /^react-dom$/, replacement: toPosixPath(path.join(reactDomRoot, 'index.js')) });
+    aliases.push({ find: /^react-dom\/client$/, replacement: toPosixPath(path.join(reactDomRoot, 'client.js')) });
+  } catch {}
+
+  try {
+    aliases.push({ find: /^swr$/, replacement: toPosixPath(appRequire.resolve('swr')) });
+  } catch {}
+
+  return aliases;
+}
+
+async function createViteDevRouter({ rootDir, log, config }) {
+  const appAliases = resolveAppAliases(rootDir);
+  const vite = await createViteServer({
+    root: rootDir,
+    appType: 'custom',
+    server: {
+      middlewareMode: true,
+    },
+    resolve: {
+      alias: appAliases,
+      dedupe: ['react', 'react-dom', 'swr'],
+    },
+    optimizeDeps: {
+      include: ['react', 'react-dom', 'react/jsx-runtime', 'react/jsx-dev-runtime', 'swr'],
+    },
+    plugins: [reactPlugin(), tailwindcss()],
+    clearScreen: false,
+  });
+
+  const internalPrefixes = ['/@vite/', '/@id/', '/@react-refresh', '/@fs/', '/node_modules/.vite/'];
+  const sourceExt = /\.(?:[cm]?[jt]sx?|css|pcss|postcss|json|svg)$/i;
+
+  async function handle(req, res) {
+    const url = req.url ?? '/';
+    const pathname = url.split('?')[0];
+    const shouldDelegate =
+      internalPrefixes.some((prefix) => pathname.startsWith(prefix)) ||
+      sourceExt.test(pathname) ||
+      pathname.startsWith('/.build/pages/.vite-entries/');
+
+    if (!shouldDelegate) return false;
+
+    return new Promise((resolve, reject) => {
+      vite.middlewares(req, res, (err) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve(res.writableEnded || res.headersSent);
+      });
+    });
+  }
+
+  return {
+    vite,
+    handle,
+    async close() {
+      await vite.close();
+      log?.info?.('Vite dev server closed');
+    },
+  };
+}
+
+export {
+  buildViteClientManifestJson,
+  buildViteRoute,
+  createViteDevRouter,
+  getViteEntryPath,
+  syncViteHydrationEntries,
+  toViteModuleUrl,
+};

package/server/pages/watcher.js

@@ -36,7 +36,9 @@ function createPagesWatcher(options) {
       }
       for (const e of events) {
         if (e.event !== 'change') continue;
-        const result = lazyContext.invalidate(e.path);
+        const result = lazyContext.handleSourceChange
+          ? await lazyContext.handleSourceChange(e.path)
+          : lazyContext.invalidate(e.path);
         if (result.touched) {
           log.info(`Pages: invalidated ${e.relativePath} (${formatAffected(result.affected)})`);
         }

package/server/watcher.js

@@ -1,8 +1,17 @@
 import { watch } from 'chokidar';
 import path from 'node:path';
 function startWatcher(options) {
-  const dirs = options.dirs ?? ['api', 'lib', 'listeners', 'jobs'];
-  const extensions = new Set(options.extensions ?? ['.js']);
+  const dirs = options.dirs ?? [
+    'api',
+    'lib',
+    'listeners',
+    'jobs',
+    'server',
+    'templates',
+    'migrations',
+    'seeds',
+  ];
+  const extensions = new Set(options.extensions ?? ['.js', '.jsx', '.ts', '.tsx', '.css']);
   const debounceMs = options.debounceMs ?? 300;
   const watchPaths = dirs.map((dir) => path.join(options.rootDir, dir));
   let debounceTimer = null;