@entrinsik/vite-plugin-informer 2.1.0 → 2.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@entrinsik/vite-plugin-informer",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Vite plugin and publish tool for local Magic Report development",
   "repository": {
     "type": "git",

package/src/deploy.js

@@ -188,20 +188,52 @@ export async function deploy({ baseUrl, apiKey, user, pass, distDir, name, descr
         // No migrations directory, skip
     }
 
-    // 9. Run migrations (if the server supports it)
+    // 9. Upload server/ directory from project root (if it exists)
+    const serverDir = join(projectRoot, 'server');
+    let serverCount = 0;
+    try {
+        await access(serverDir);
+        const serverFiles = await walkDir(serverDir);
+        for (const filePath of serverFiles) {
+            const relPath = posix.normalize(relative(projectRoot, filePath).split('\\').join('/'));
+            const content = await readFile(filePath);
+            const ext = '.' + relPath.split('.').pop();
+            const isText = TEXT_EXTENSIONS.has(ext.toLowerCase());
+            const payload = isText
+                ? { content: content.toString('utf8'), encoding: 'utf8' }
+                : { content: content.toString('base64'), encoding: 'base64' };
+
+            await api.put(`${entityPath}/contents/${relPath}`, payload);
+            console.log(`  ${relPath} (from project root)`);
+            serverCount++;
+        }
+    } catch {
+        // No server directory, skip
+    }
+
+    // 10. Deploy: run migrations + scan/bundle server routes
     if (apiPrefix === 'apps') {
         try {
-            const result = await api.post(`${entityPath}/_migrate`);
-            if (result && result.migrated && result.migrated.length > 0) {
-                console.log(`Ran ${result.migrated.length} migration(s): ${result.migrated.join(', ')}`);
+            console.log('Deploying...');
+            const result = await api.post(`${entityPath}/_deploy`);
+            if (result) {
+                if (result.migrated && result.migrated.length > 0) {
+                    console.log(`  Ran ${result.migrated.length} migration(s): ${result.migrated.join(', ')}`);
+                }
+                if (result.routes && result.routes.length > 0) {
+                    console.log(`  Registered ${result.routes.length} server route(s):`);
+                    for (const r of result.routes) {
+                        console.log(`    ${r}`);
+                    }
+                }
             }
         } catch {
-            // Server may not support _migrate yet — ignore
+            // Server may not support _deploy yet — ignore
         }
     }
 
-    // 9. Print URL and return UUID for saving
-    const totalFiles = entries.length + configCount + migrationsCount;
+    // 11. Print URL and return UUID for saving
+    const totalFiles = entries.length + configCount + migrationsCount + serverCount;
     const base = baseUrl.replace(/\/+$/, '');
     const entityUrl = apiPrefix === 'apps'
         ? `${base}/api/apps/${naturalId}/view`

package/src/index.js

@@ -1,10 +1,16 @@
 import dotenv from 'dotenv';
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { createClient } from './client.js';
+import { createMiddleware as createServerRoutes } from './server-routes.js';
+import { init, migrate } from './workspace.js';
 
 /**
  * Vite plugin for local Magic Report development.
  *
  * - Proxies /api requests to the Informer server with Basic auth
- * - Rewrites /api/_query to the dev workspace's _sql route (if configured)
+ * - Runs server/ route handlers locally via ssrLoadModule (if server/ dir exists)
  * - Injects window.__INFORMER__ context mock in dev mode
  * - Sets base to './' so built assets use relative paths
  *
@@ -60,43 +66,69 @@ export default function informer(options = {}) {
             return cfg;
         },
 
-        configureServer(server) {
-            if (!isDev || !devWorkspaceId || !serverOrigin) return;
+        async configureServer(server) {
+            if (!isDev || !serverOrigin) return;
 
-            // Intercept POST /api/_query and proxy to the dev workspace's _sql route.
-            // This middleware runs before the generic /api proxy, so the rewrite takes effect.
-            server.middlewares.use('/api/_query', async (req, res, next) => {
-                if (req.method !== 'POST') return next();
+            const projectRoot = process.cwd();
+            const migrationsDir = resolve(projectRoot, 'migrations');
 
-                // Read request body
-                const chunks = [];
-                for await (const chunk of req) {
-                    chunks.push(chunk);
-                }
-                const body = Buffer.concat(chunks).toString('utf8');
+            // Auto-provision workspace if migrations/ exists
+            if (existsSync(migrationsDir)) {
+                const api = createClient({
+                    baseUrl: serverOrigin,
+                    apiKey: process.env.INFORMER_API_KEY,
+                    user: process.env.INFORMER_USER,
+                    pass: process.env.INFORMER_PASS
+                });
 
-                // Forward to workspace _sql endpoint
-                const url = `${serverOrigin}/api/datasources/${devWorkspaceId}/_sql`;
                 try {
-                    const upstream = await fetch(url, {
-                        method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json',
-                            Authorization: authHeader
-                        },
-                        body
-                    });
-
-                    res.statusCode = upstream.status;
-                    res.setHeader('Content-Type', 'application/json');
-                    const text = await upstream.text();
-                    res.end(text);
+                    // Verify existing workspace or create a new one
+                    let needsInit = !devWorkspaceId;
+                    if (devWorkspaceId) {
+                        const ds = await api.get(`datasources/${devWorkspaceId}`);
+                        if (ds) {
+                            await migrate({ api, workspaceId: devWorkspaceId, migrationsDir });
+                        } else {
+                            console.warn(`[informer] Workspace ${devWorkspaceId} not found on server. Re-creating...`);
+                            needsInit = true;
+                        }
+                    }
+
+                    if (needsInit) {
+                        const pkg = JSON.parse(await readFile(resolve(projectRoot, 'package.json'), 'utf8'));
+                        let slug = pkg.name;
+                        if (slug && slug.startsWith('@') && slug.includes('/')) {
+                            slug = slug.split('/')[1];
+                        }
+
+                        const result = await init({
+                            api,
+                            slug,
+                            migrationsDir,
+                            envPath: resolve(projectRoot, '.env')
+                        });
+                        devWorkspaceId = result.workspaceId;
+                    }
                 } catch (err) {
-                    res.statusCode = 502;
-                    res.setHeader('Content-Type', 'application/json');
-                    res.end(JSON.stringify({ error: err.message }));
+                    console.warn(`[informer] Workspace setup failed: ${err.message}`);
+                    console.warn('[informer] query() will not work. Run: npx informer-workspace init');
                 }
-            });
+            }
+
+            // Mount server-side route handlers if a server/ directory exists
+            const serverDir = resolve(projectRoot, 'server');
+
+            if (existsSync(serverDir)) {
+                const serverRoutes = createServerRoutes(server, {
+                    serverOrigin,
+                    authHeader,
+                    devWorkspaceId,
+                    projectRoot,
+                    roles: (options.mock && options.mock.roles) || []
+                });
+                server.middlewares.use('/api/_server', serverRoutes);
+            }
+
         },
 
         transformIndexHtml: {

package/src/server-routes.js

@@ -0,0 +1,284 @@
+import { readdir, stat } from 'node:fs/promises';
+import { join, relative, posix } from 'node:path';
+import { parse as parseUrl } from 'node:url';
+
+const VALID_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'];
+
+/**
+ * Convert a file path under server/ to a route path.
+ *
+ * Examples:
+ *   server/orders/index.js     -> /orders
+ *   server/orders/[id].js      -> /orders/:id
+ *   server/orders/[id]/approve.js -> /orders/:id/approve
+ *   server/index.js            -> /
+ */
+function filePathToRoute(filePath) {
+    let route = filePath
+        .replace(/^server\//, '')
+        .replace(/\.js$/, '');
+
+    route = route.replace(/\[([^\]]+)\]/g, ':$1');
+
+    route = route.replace(/\/index$/, '');
+
+    if (route === 'index' || route === '') {
+        return '/';
+    }
+
+    if (!route.startsWith('/')) {
+        route = '/' + route;
+    }
+
+    if (route.length > 1 && route.endsWith('/')) {
+        route = route.slice(0, -1);
+    }
+
+    return route;
+}
+
+/**
+ * Match an incoming request against a route table.
+ *
+ * @param {Array<{ method: string, path: string }>} routes
+ * @param {string} method - HTTP method
+ * @param {string} requestPath - e.g. "/orders/123"
+ * @returns {{ route: Object, params: Object }|null}
+ */
+function matchRoute(routes, method, requestPath) {
+    const upperMethod = method.toUpperCase();
+    const candidates = routes.filter(r => r.method === upperMethod);
+
+    const normalizedPath = requestPath.length > 1 && requestPath.endsWith('/')
+        ? requestPath.slice(0, -1)
+        : requestPath;
+
+    const requestSegments = normalizedPath.split('/').filter(Boolean);
+
+    let bestMatch = null;
+    let bestScore = -1;
+
+    for (const route of candidates) {
+        const routeSegments = route.path.split('/').filter(Boolean);
+
+        if (routeSegments.length !== requestSegments.length) continue;
+
+        const params = {};
+        let score = 0;
+        let matched = true;
+
+        for (let i = 0; i < routeSegments.length; i++) {
+            const routeSeg = routeSegments[i];
+            const reqSeg = requestSegments[i];
+
+            if (routeSeg.startsWith(':')) {
+                params[routeSeg.slice(1)] = decodeURIComponent(reqSeg);
+            } else if (routeSeg === reqSeg) {
+                score++;
+            } else {
+                matched = false;
+                break;
+            }
+        }
+
+        if (matched && score > bestScore) {
+            bestMatch = { route, params };
+            bestScore = score;
+        }
+    }
+
+    if (requestSegments.length === 0) {
+        const rootRoute = candidates.find(r => r.path === '/');
+        if (rootRoute) {
+            return { route: rootRoute, params: {} };
+        }
+    }
+
+    return bestMatch;
+}
+
+/**
+ * Recursively scan the server/ directory for .js handler files.
+ *
+ * @param {string} serverDir - Absolute path to server/ directory
+ * @returns {Promise<Array<{ path: string, filePath: string }>>}
+ */
+async function scanRoutes(serverDir) {
+    const files = await walkJsFiles(serverDir, 'server');
+    return files.map(({ relPath, absPath }) => ({
+        path: filePathToRoute(relPath),
+        filePath: absPath
+    }));
+}
+
+async function walkJsFiles(dir, basePath) {
+    const results = [];
+    let items;
+    try {
+        items = await readdir(dir);
+    } catch {
+        return results;
+    }
+
+    for (const item of items) {
+        const full = join(dir, item);
+        const childPath = `${basePath}/${item}`;
+        const s = await stat(full);
+
+        if (s.isDirectory()) {
+            results.push(...await walkJsFiles(full, childPath));
+        } else if (item.endsWith('.js')) {
+            results.push({ relPath: childPath, absPath: full });
+        }
+    }
+
+    return results;
+}
+
+/**
+ * Create Connect middleware for dev-mode server route execution.
+ *
+ * @param {Object} viteServer - Vite dev server instance
+ * @param {{ serverOrigin: string, authHeader: string, devWorkspaceId: string|null, projectRoot: string }} opts
+ * @returns {Function} Connect middleware
+ */
+export function createMiddleware(viteServer, { serverOrigin, authHeader, devWorkspaceId, projectRoot, roles }) {
+    const serverDir = join(projectRoot, 'server');
+
+    // query() implementation — proxies to the workspace _sql endpoint
+    async function query(sql, params) {
+        if (!devWorkspaceId) {
+            throw new Error('query() requires INFORMER_DEV_WORKSPACE. Run: npx informer-workspace init');
+        }
+
+        const resp = await globalThis.fetch(`${serverOrigin}/api/datasources/${devWorkspaceId}/_sql`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', Authorization: authHeader },
+            body: JSON.stringify({ sql, params: params || [] })
+        });
+
+        if (!resp.ok) {
+            const err = await resp.json().catch(() => ({}));
+            const detail = err.message || resp.statusText;
+            throw new Error(`query() failed: ${resp.status} ${detail} (${serverOrigin}/api/datasources/${devWorkspaceId}/_sql)`);
+        }
+
+        const data = await resp.json();
+        return data.rows;
+    }
+
+    // fetch() implementation — proxies API calls to the Informer server
+    async function apiFetch(path, opts = {}) {
+        const method = (opts.method || 'GET').toUpperCase();
+        const url = `${serverOrigin}/api/${path.replace(/^\/?(?:api\/)?/, '')}`;
+        const fetchOpts = {
+            method,
+            headers: { Authorization: authHeader, 'Content-Type': 'application/json' }
+        };
+
+        if (opts.body && ['POST', 'PUT', 'PATCH'].includes(method)) {
+            fetchOpts.body = JSON.stringify(opts.body);
+        }
+
+        const resp = await globalThis.fetch(url, fetchOpts);
+        let body;
+        try { body = await resp.json(); } catch { body = await resp.text(); }
+        return { status: resp.status, body };
+    }
+
+    return async function serverRoutesMiddleware(req, res, next) {
+        try {
+            // The URL has already had /api/_server stripped by Vite's middleware.use()
+            const parsed = parseUrl(req.url, true);
+            const routePath = parsed.pathname || '/';
+
+            // Scan server/ directory for handler files
+            const scannedRoutes = await scanRoutes(serverDir);
+
+            // Build route table with all valid methods per file
+            const routeTable = [];
+            for (const scanned of scannedRoutes) {
+                for (const method of VALID_METHODS) {
+                    routeTable.push({ method, path: scanned.path, filePath: scanned.filePath });
+                }
+            }
+
+            // Match request against route table
+            const match = matchRoute(routeTable, req.method, routePath);
+            if (!match) return next();
+
+            // Load handler via Vite's ssrLoadModule (ESM + HMR)
+            const mod = await viteServer.ssrLoadModule(match.route.filePath);
+            const handler = mod[req.method.toUpperCase()];
+
+            if (typeof handler !== 'function') {
+                res.statusCode = 404;
+                res.setHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify({ error: 'Method not found' }));
+                return;
+            }
+
+            // Read request body
+            const chunks = [];
+            for await (const chunk of req) {
+                chunks.push(chunk);
+            }
+            const rawBody = Buffer.concat(chunks).toString('utf8');
+            let body = null;
+            if (rawBody) {
+                try { body = JSON.parse(rawBody); } catch { body = rawBody; }
+            }
+
+            // Build request context
+            const request = {
+                method: req.method.toUpperCase(),
+                path: routePath,
+                params: match.params,
+                query: parsed.query || {},
+                body,
+                headers: req.headers,
+                roles: roles || []
+            };
+
+            // Call handler
+            const result = await handler({ query, fetch: apiFetch, env: {}, request });
+
+            // Normalize response (mirrors app-sandbox.js buildInvokeScript logic)
+            let status, responseBody, responseHeaders;
+
+            if (result === undefined || result === null) {
+                status = 204;
+                responseBody = null;
+                responseHeaders = {};
+            } else if (typeof result === 'object' && typeof result.status === 'number') {
+                status = result.status || 200;
+                responseBody = result.body !== undefined ? result.body : null;
+                responseHeaders = result.headers || {};
+            } else {
+                status = 200;
+                responseBody = result;
+                responseHeaders = { 'content-type': 'application/json' };
+            }
+
+            res.statusCode = status;
+            for (const [key, value] of Object.entries(responseHeaders)) {
+                res.setHeader(key, value);
+            }
+
+            if (responseBody === null) {
+                res.end();
+            } else {
+                if (!res.getHeader('content-type')) {
+                    res.setHeader('Content-Type', 'application/json');
+                }
+                res.end(JSON.stringify(responseBody));
+            }
+        } catch (err) {
+            viteServer.ssrFixStacktrace(err);
+            console.error('[server-routes]', err);
+            res.statusCode = 500;
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify({ error: err.message }));
+        }
+    };
+}