@vistagenic/vista 0.2.2 → 0.2.4

package/dist/server/rsc-upstream.js

@@ -77,6 +77,25 @@ function resolveFromWorkspace(specifier, cwd) {
 function normalizeModulePath(filePath) {
     return filePath.replace(/\\/g, '/').toLowerCase();
 }
+function shouldInvalidateDevModule(modulePath, cwd) {
+    const normalized = normalizeModulePath(modulePath);
+    const rootPrefix = normalizeModulePath(`${cwd}${path_1.default.sep}`);
+    if (!normalized.startsWith(rootPrefix))
+        return false;
+    if (normalized.includes('/node_modules/'))
+        return false;
+    if (normalized.includes(`/${constants_1.BUILD_DIR.toLowerCase()}/`))
+        return false;
+    return /\.(?:[cm]?[jt]sx?|json)$/i.test(normalized);
+}
+function clearProjectRequireCache(cwd) {
+    for (const key of Object.keys(require.cache)) {
+        if (!shouldInvalidateDevModule(key, cwd))
+            continue;
+        delete require.cache[key];
+        clientDirectiveCache.delete(key);
+    }
+}
 function setupTypeScriptRuntime(cwd) {
     try {
         const swcPath = require.resolve('@swc-node/register', { paths: [cwd] });
@@ -174,18 +193,10 @@ function installSingleReactResolution() {
 function installClientLoadHook(cwd, createClientModuleProxy) {
     if (installedClientLoadHook)
         return;
-    const appDir = path_1.default.join(cwd, 'app');
-    const componentsDir = path_1.default.join(cwd, 'components');
-    const normalizedAppDir = normalizeModulePath(appDir);
-    const normalizedComponentsDir = normalizeModulePath(componentsDir);
     originalCompile = CjsModule.prototype._compile;
     CjsModule.prototype._compile = function (content, filename) {
-        const normalized = normalizeModulePath(filename);
-        const isInAppTree = normalized.startsWith(normalizedAppDir);
-        const isInComponentsTree = normalized.startsWith(normalizedComponentsDir);
-        if ((isInAppTree || isInComponentsTree) &&
-            /\.[jt]sx?$/.test(filename) &&
-            isClientBoundaryFile(filename, content)) {
+        const isJavaScriptModule = /\.[jt]sx?$/.test(filename);
+        if (isJavaScriptModule && isClientBoundaryFile(filename, content)) {
             const moduleId = (0, url_1.pathToFileURL)(filename).href;
             this.exports = createClientModuleProxy(moduleId);
             return;
@@ -254,16 +265,10 @@ function extractParams(pathname, route) {
     }
     return params;
 }
-async function createRouteElement(route, context, isDev) {
+async function createRouteElement(route, context, isDev, cwd) {
     const { params, searchParams, req } = context;
     if (isDev) {
-        for (const key of Object.keys(require.cache)) {
-            if (key.includes(`${path_1.default.sep}app${path_1.default.sep}`) ||
-                key.includes(`${path_1.default.sep}components${path_1.default.sep}`)) {
-                delete require.cache[key];
-                clientDirectiveCache.delete(key);
-            }
-        }
+        clearProjectRequireCache(cwd);
     }
     const PageModule = require(route.pagePath);
     const PageComponent = PageModule.default;
@@ -429,7 +434,7 @@ function startUpstream() {
             }
             const params = extractParams(pathname, route);
             const searchParams = Object.fromEntries(new URLSearchParams(req.query).entries());
-            const element = await createRouteElement(route, { params, searchParams, req }, isDev);
+            const element = await createRouteElement(route, { params, searchParams, req }, isDev, cwd);
             res.setHeader('Content-Type', 'text/x-component');
             res.setHeader('Vary', 'Accept');
             const stream = flightServer.renderToPipeableStream(element, flightManifest, {

package/dist/server/static-generator.js

@@ -17,6 +17,102 @@ exports.revalidatePath = revalidatePath;
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const static_cache_1 = require("./static-cache");
+const CjsModule = require('module');
+let staticRuntimeReady = false;
+let reactResolutionInstalled = false;
+let originalResolveFilename = null;
+function installSingleReactResolution(cwd) {
+    if (reactResolutionInstalled)
+        return;
+    let reactPath;
+    let reactDomPath;
+    try {
+        reactPath = require.resolve('react', { paths: [cwd] });
+        reactDomPath = require.resolve('react-dom', { paths: [cwd] });
+    }
+    catch {
+        try {
+            reactPath = require.resolve('react');
+            reactDomPath = require.resolve('react-dom');
+        }
+        catch {
+            return;
+        }
+    }
+    originalResolveFilename = CjsModule._resolveFilename;
+    CjsModule._resolveFilename = function (request, parent, isMain, options) {
+        if (request === 'react')
+            return reactPath;
+        if (request === 'react-dom')
+            return reactDomPath;
+        if (request.startsWith('react/')) {
+            const subPath = request.slice('react/'.length);
+            try {
+                return require.resolve(`react/${subPath}`, { paths: [path_1.default.dirname(reactPath)] });
+            }
+            catch {
+                // fall through
+            }
+        }
+        if (request.startsWith('react-dom/')) {
+            const subPath = request.slice('react-dom/'.length);
+            try {
+                return require.resolve(`react-dom/${subPath}`, { paths: [path_1.default.dirname(reactDomPath)] });
+            }
+            catch {
+                // fall through
+            }
+        }
+        return originalResolveFilename.call(this, request, parent, isMain, options);
+    };
+    reactResolutionInstalled = true;
+}
+function setupTypeScriptRuntime(cwd) {
+    try {
+        const swcPath = require.resolve('@swc-node/register', { paths: [cwd] });
+        require(swcPath);
+        return;
+    }
+    catch {
+        // fallback
+    }
+    try {
+        const tsNodePath = require.resolve('ts-node', { paths: [cwd] });
+        require(tsNodePath).register({
+            transpileOnly: true,
+            compilerOptions: {
+                module: 'commonjs',
+                jsx: 'react-jsx',
+                moduleResolution: 'node16',
+                esModuleInterop: true,
+            },
+        });
+        return;
+    }
+    catch {
+        // fallback
+    }
+    try {
+        require.resolve('tsx', { paths: [cwd] });
+        require('tsx/cjs');
+    }
+    catch {
+        // no transpiler available
+    }
+}
+function setupStaticGenerationRuntime(cwd) {
+    if (staticRuntimeReady)
+        return;
+    // Ignore CSS imports while requiring app modules for prerender.
+    require.extensions['.css'] = (m, filename) => {
+        if (filename.endsWith('.module.css')) {
+            m.exports = {};
+        }
+    };
+    installSingleReactResolution(cwd);
+    setupTypeScriptRuntime(cwd);
+    staticRuntimeReady = true;
+}
 // ---------------------------------------------------------------------------
 // Static param expansion
 // ---------------------------------------------------------------------------
@@ -25,6 +121,7 @@ const static_cache_1 = require("./static-cache");
  * and return the list of param sets.
  */
 async function resolveStaticParams(route, cwd) {
+    setupStaticGenerationRuntime(cwd);
     if (!route.hasGenerateStaticParams) {
         return [];
     }
@@ -80,6 +177,7 @@ function expandPattern(pattern, params) {
  * handled by the upstream process.
  */
 async function prerenderPage(urlPath, route, params, cwd) {
+    setupStaticGenerationRuntime(cwd);
     try {
         const React = require('react');
         const { renderToString } = require('react-dom/server');

package/dist/server/structure-validator.js

@@ -20,7 +20,7 @@ const path_1 = __importDefault(require("path"));
 // ============================================================================
 const FILE_EXTENSIONS = ['.tsx', '.ts', '.jsx', '.js'];
 const RESERVED_INTERNAL_SEGMENTS = new Set(['[not-found]']);
-const VALID_SEGMENT_PATTERN = /^[a-zA-Z0-9_\-]+$|^\[\[\.\.\.[\w\-]+\]\]$|^\[[\w\-]+\]$|^\[\.\.\.[\ w\-]+\]$|^\([\w\-]+\)$/;
+const VALID_SEGMENT_PATTERN = /^[a-zA-Z0-9_\-]+$|^\[\[\.\.\.[\w\-]+\]\]$|^\[[\w\-]+\]$|^\[\.\.\.[\w\-]+\]$|^\([\w\-]+\)$/;
 const CONVENTION_FILES = new Set([
     'page',
     'layout',

package/dist/server/typed-api-runtime.d.ts

@@ -0,0 +1,16 @@
+import type express from 'express';
+import type { ResolvedTypedApiConfig } from '../config';
+export declare function resolveLegacyApiRoutePath(cwd: string, requestPath: string): string | null;
+export declare function runLegacyApiRoute(options: {
+    req: express.Request;
+    res: express.Response;
+    apiPath: string;
+    isDev: boolean;
+}): Promise<void>;
+export declare function runTypedApiRoute(options: {
+    req: express.Request;
+    res: express.Response;
+    cwd: string;
+    isDev: boolean;
+    config: ResolvedTypedApiConfig;
+}): Promise<boolean>;

package/dist/server/typed-api-runtime.js

@@ -0,0 +1,336 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveLegacyApiRoutePath = resolveLegacyApiRoutePath;
+exports.runLegacyApiRoute = runLegacyApiRoute;
+exports.runTypedApiRoute = runTypedApiRoute;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const server_1 = require("../stack/server");
+const TYPED_API_ENTRYPOINTS = [
+    path_1.default.join('app', 'api', 'typed.ts'),
+    path_1.default.join('app', 'api', 'typed.tsx'),
+    path_1.default.join('app', 'api', 'typed.js'),
+    path_1.default.join('app', 'api', 'typed.jsx'),
+    path_1.default.join('app', 'typed-api.ts'),
+    path_1.default.join('app', 'typed-api.tsx'),
+    path_1.default.join('app', 'typed-api.js'),
+    path_1.default.join('app', 'typed-api.jsx'),
+];
+class BodyLimitError extends Error {
+    status = 413;
+    constructor(limitBytes) {
+        super(`Typed API body exceeds configured limit (${limitBytes} bytes)`);
+        this.name = 'BodyLimitError';
+    }
+}
+class BodyParseError extends Error {
+    status = 400;
+    constructor(message) {
+        super(message);
+        this.name = 'BodyParseError';
+    }
+}
+function isStackRouterLike(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const candidate = value;
+    return (!!candidate.procedures &&
+        !!candidate.routes &&
+        !!candidate.metadata &&
+        typeof candidate.resolve === 'function');
+}
+function resolveTypedRouterFromModule(mod) {
+    const candidates = [
+        mod?.default,
+        mod?.router,
+        mod?.typedRouter,
+        mod?.api,
+        typeof mod?.createRouter === 'function' ? mod.createRouter() : null,
+        typeof mod?.createTypedRouter === 'function' ? mod.createTypedRouter() : null,
+    ];
+    for (const candidate of candidates) {
+        if (isStackRouterLike(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function normalizeApiPath(pathname) {
+    if (!pathname.startsWith('/api')) {
+        return pathname || '/';
+    }
+    const stripped = pathname.slice('/api'.length);
+    return stripped ? stripped : '/';
+}
+function buildPathCandidates(pathname) {
+    const normalized = pathname || '/';
+    const apiNormalized = normalizeApiPath(normalized);
+    const dedup = new Set([normalized, apiNormalized]);
+    return Array.from(dedup);
+}
+function hasMethodMatch(router, pathname, method) {
+    const normalized = method.toLowerCase();
+    return router.resolve(pathname, normalized) !== null;
+}
+function hasRouteForAnyMethod(router, pathname) {
+    return hasMethodMatch(router, pathname, 'get') || hasMethodMatch(router, pathname, 'post');
+}
+async function parseRequestBody(req, bodySizeLimitBytes) {
+    if (req.method === 'GET' || req.method === 'HEAD') {
+        return undefined;
+    }
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.length;
+        if (size > bodySizeLimitBytes) {
+            throw new BodyLimitError(bodySizeLimitBytes);
+        }
+        chunks.push(buffer);
+    }
+    if (chunks.length === 0) {
+        return undefined;
+    }
+    const raw = Buffer.concat(chunks);
+    const contentType = String(req.headers['content-type'] || '')
+        .split(';')[0]
+        .trim()
+        .toLowerCase();
+    if (!contentType || contentType === 'application/json' || contentType.endsWith('+json')) {
+        try {
+            return JSON.parse(raw.toString('utf-8'));
+        }
+        catch {
+            throw new BodyParseError('Invalid JSON body for typed API request.');
+        }
+    }
+    if (contentType === 'application/x-www-form-urlencoded') {
+        return Object.fromEntries(new URLSearchParams(raw.toString('utf-8')).entries());
+    }
+    if (contentType.startsWith('text/')) {
+        return raw.toString('utf-8');
+    }
+    return raw;
+}
+async function sendFetchResponse(res, response) {
+    response.headers.forEach((value, key) => {
+        res.setHeader(key, value);
+    });
+    const arrayBuffer = await response.arrayBuffer();
+    const body = Buffer.from(arrayBuffer);
+    res.status(response.status).send(body);
+}
+function getTypedApiEntrypoint(cwd) {
+    for (const relativePath of TYPED_API_ENTRYPOINTS) {
+        const absolutePath = path_1.default.resolve(cwd, relativePath);
+        if (fs_1.default.existsSync(absolutePath)) {
+            return absolutePath;
+        }
+    }
+    return null;
+}
+async function executeTypedRoute(router, options) {
+    const pathCandidates = buildPathCandidates(options.req.path);
+    const method = options.method.toLowerCase();
+    let selectedPath = null;
+    let routeExistsForDifferentMethod = false;
+    for (const candidate of pathCandidates) {
+        if (hasMethodMatch(router, candidate, method)) {
+            selectedPath = candidate;
+            break;
+        }
+        if (hasRouteForAnyMethod(router, candidate)) {
+            routeExistsForDifferentMethod = true;
+        }
+    }
+    if (!selectedPath) {
+        if (routeExistsForDifferentMethod) {
+            return {
+                kind: 'method-not-allowed',
+                status: 405,
+                error: `Method ${method.toUpperCase()} not allowed`,
+            };
+        }
+        return { kind: 'not-found' };
+    }
+    const result = await (0, server_1.executeRoute)(router, {
+        path: selectedPath,
+        method,
+        req: {
+            method,
+            path: selectedPath,
+            query: options.query,
+            body: options.body,
+            headers: options.req.headers,
+            originalUrl: options.req.originalUrl,
+            url: options.req.url,
+        },
+        ctx: options.context,
+        env: options.env,
+        serialization: options.serialization,
+    });
+    return {
+        kind: 'handled',
+        status: 200,
+        payload: result.serializedData,
+    };
+}
+function resolveLegacyApiRoutePath(cwd, requestPath) {
+    if (!requestPath.startsWith('/api/')) {
+        return null;
+    }
+    const apiRoute = requestPath.substring('/api/'.length);
+    const routeCandidates = [
+        path_1.default.resolve(cwd, 'app', 'api', apiRoute, 'route.ts'),
+        path_1.default.resolve(cwd, 'app', 'api', apiRoute, 'route.tsx'),
+        path_1.default.resolve(cwd, 'app', 'api', apiRoute, 'route.js'),
+        path_1.default.resolve(cwd, 'app', 'api', apiRoute, 'route.jsx'),
+        path_1.default.resolve(cwd, 'app', 'api', `${apiRoute}.ts`),
+        path_1.default.resolve(cwd, 'app', 'api', `${apiRoute}.tsx`),
+        path_1.default.resolve(cwd, 'app', 'api', `${apiRoute}.js`),
+        path_1.default.resolve(cwd, 'app', 'api', `${apiRoute}.jsx`),
+    ];
+    for (const routePath of routeCandidates) {
+        if (fs_1.default.existsSync(routePath)) {
+            return routePath;
+        }
+    }
+    return null;
+}
+async function runLegacyApiRoute(options) {
+    const { req, res, apiPath, isDev } = options;
+    if (isDev) {
+        delete require.cache[require.resolve(apiPath)];
+    }
+    const apiModule = require(apiPath);
+    const method = req.method?.toUpperCase() || 'GET';
+    const methodHandler = apiModule[method];
+    if (typeof methodHandler === 'function') {
+        const request = {
+            url: req.protocol + '://' + req.get('host') + req.originalUrl,
+            method: req.method,
+            headers: new Map(Object.entries(req.headers)),
+            json: async () => req.body,
+            text: async () => JSON.stringify(req.body),
+            nextUrl: {
+                pathname: req.path,
+                searchParams: new URLSearchParams(req.query),
+            },
+        };
+        const result = await methodHandler(request, { params: {} });
+        if (result && typeof result.json === 'function') {
+            const json = await result.json();
+            res.status(result.status || 200).json(json);
+            return;
+        }
+        if (result !== undefined) {
+            res.status(200).json(result);
+            return;
+        }
+        res.status(204).end();
+        return;
+    }
+    if (typeof apiModule.default === 'function') {
+        apiModule.default(req, res);
+        return;
+    }
+    res.status(405).json({ error: `Method ${method} not allowed` });
+}
+async function runTypedApiRoute(options) {
+    const { req, res, cwd, isDev, config } = options;
+    if (!config.enabled) {
+        return false;
+    }
+    const entrypoint = getTypedApiEntrypoint(cwd);
+    if (!entrypoint) {
+        return false;
+    }
+    try {
+        if (isDev) {
+            delete require.cache[require.resolve(entrypoint)];
+        }
+        const typedModule = require(entrypoint);
+        const router = resolveTypedRouterFromModule(typedModule);
+        if (!router) {
+            res.status(500).json({
+                error: `Typed API entrypoint "${path_1.default.relative(cwd, entrypoint)}" does not export a valid stack router.`,
+            });
+            return true;
+        }
+        const method = (req.method || 'GET').toUpperCase();
+        const body = await parseRequestBody(req, config.bodySizeLimitBytes);
+        const query = (req.query ?? {});
+        const contextFactory = typeof typedModule.createContext === 'function' ? typedModule.createContext : null;
+        const envFactory = typeof typedModule.createEnv === 'function' ? typedModule.createEnv : null;
+        const context = contextFactory ? await contextFactory({ req, res }) : {};
+        const env = envFactory ? await envFactory({ req, res }) : {};
+        const routeResult = await executeTypedRoute(router, {
+            req,
+            method,
+            query,
+            body,
+            serialization: config.serialization,
+            context: context ?? {},
+            env,
+        });
+        if (routeResult.kind === 'not-found') {
+            return false;
+        }
+        if (routeResult.kind === 'method-not-allowed') {
+            res.status(routeResult.status).json({ error: routeResult.error });
+            return true;
+        }
+        res.status(routeResult.status).json(routeResult.payload);
+        return true;
+    }
+    catch (error) {
+        const typedError = error;
+        if (typedError instanceof BodyLimitError || typedError instanceof BodyParseError) {
+            res.status(typedError.status).json({ error: typedError.message });
+            return true;
+        }
+        if (typedError instanceof server_1.StackValidationError ||
+            typedError instanceof server_1.StackMethodNotAllowedError) {
+            const status = typeof typedError.status === 'number' ? typedError.status : 400;
+            res.status(status).json({ error: typedError.message });
+            return true;
+        }
+        if (typedError instanceof server_1.StackRouteNotFoundError) {
+            return false;
+        }
+        // Router-level error handler gets first chance.
+        try {
+            const entrypoint = getTypedApiEntrypoint(cwd);
+            if (entrypoint) {
+                if (isDev) {
+                    delete require.cache[require.resolve(entrypoint)];
+                }
+                const typedModule = require(entrypoint);
+                const router = resolveTypedRouterFromModule(typedModule);
+                const errorHandler = router?.metadata?.errorHandler;
+                if (typeof errorHandler === 'function') {
+                    const response = errorHandler(error, {
+                        method: req.method,
+                        path: req.path,
+                        query: (req.query ?? {}),
+                        headers: req.headers,
+                    });
+                    if (response instanceof Response) {
+                        await sendFetchResponse(res, response);
+                        return true;
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore fallback handler errors and use generic 500 response below.
+        }
+        res.status(500).json({ error: 'Internal Server Error in Typed API' });
+        return true;
+    }
+}

package/dist/stack/client/create-client.d.ts

@@ -0,0 +1,2 @@
+import type { AppRouterLike, ClientRoutes, CreateVistaClientOptions, VistaClient } from './types';
+export declare function createVistaClient<TAppRouter extends AppRouterLike, TRoutes = ClientRoutes<TAppRouter>>(options?: CreateVistaClientOptions): VistaClient<TRoutes>;