@entrinsik/vite-plugin-informer 2.0.0 → 2.1.0

package/bin/init.js

@@ -232,12 +232,18 @@ async function init() {
         console.log('Added @entrinsik/vite-plugin-informer to devDependencies');
     }
 
-    // 6. Add deploy script if not present
+    // 6. Add scripts if not present
     if (!pkg.scripts) pkg.scripts = {};
     if (!pkg.scripts.deploy) {
         pkg.scripts.deploy = 'npm run build && informer-deploy';
         console.log('Added "deploy" script to package.json');
     }
+    if (!pkg.scripts['workspace:init']) {
+        pkg.scripts['workspace:init'] = 'informer-workspace init';
+        pkg.scripts['workspace:migrate'] = 'informer-workspace migrate';
+        pkg.scripts['workspace:reset'] = 'informer-workspace reset';
+        console.log('Added workspace scripts to package.json');
+    }
 
     await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
     console.log(`Updated package.json with informer.name="${reportName}"`);

package/bin/workspace.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+
+import dotenv from 'dotenv';
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { createClient } from '../src/client.js';
+import { init, migrate, reset } from '../src/workspace.js';
+
+dotenv.config();
+
+const command = process.argv[2];
+
+if (!command || !['init', 'migrate', 'reset'].includes(command)) {
+    console.error('Usage: informer-workspace <init|migrate|reset>');
+    console.error('');
+    console.error('Commands:');
+    console.error('  init      Create a dev workspace datasource and run migrations');
+    console.error('  migrate   Run pending migrations against the dev workspace');
+    console.error('  reset     Drop all tables and re-run all migrations');
+    process.exit(1);
+}
+
+const baseUrl = process.env.INFORMER_URL;
+const apiKey = process.env.INFORMER_API_KEY;
+const user = process.env.INFORMER_USER;
+const pass = process.env.INFORMER_PASS;
+
+if (!baseUrl || (!apiKey && (!user || !pass))) {
+    console.error('Missing required environment variables.');
+    console.error('Set INFORMER_URL and either INFORMER_API_KEY or INFORMER_USER/INFORMER_PASS in .env');
+    process.exit(1);
+}
+
+const api = createClient({ baseUrl, apiKey, user, pass });
+const migrationsDir = resolve('migrations');
+const envPath = resolve('.env');
+
+try {
+    if (command === 'init') {
+        // Check if already initialized
+        if (process.env.INFORMER_DEV_WORKSPACE) {
+            console.error(`Workspace already initialized: ${process.env.INFORMER_DEV_WORKSPACE}`);
+            console.error('Run workspace:reset to start fresh, or remove INFORMER_DEV_WORKSPACE from .env to re-initialize.');
+            process.exit(1);
+        }
+
+        // Read slug from package.json
+        const pkgPath = resolve('package.json');
+        let pkg;
+        try {
+            pkg = JSON.parse(await readFile(pkgPath, 'utf8'));
+        } catch {
+            console.error('Could not read package.json in current directory.');
+            process.exit(1);
+        }
+
+        let slug = pkg.name;
+        if (slug && slug.startsWith('@') && slug.includes('/')) {
+            slug = slug.split('/')[1];
+        }
+        if (!slug) {
+            console.error('package.json must have a "name" field.');
+            process.exit(1);
+        }
+
+        await init({ api, slug, migrationsDir, envPath });
+
+    } else if (command === 'migrate') {
+        const workspaceId = process.env.INFORMER_DEV_WORKSPACE;
+        if (!workspaceId) {
+            console.error('No dev workspace found. Run workspace:init first.');
+            process.exit(1);
+        }
+        await migrate({ api, workspaceId, migrationsDir });
+
+    } else if (command === 'reset') {
+        const workspaceId = process.env.INFORMER_DEV_WORKSPACE;
+        if (!workspaceId) {
+            console.error('No dev workspace found. Run workspace:init first.');
+            process.exit(1);
+        }
+        await reset({ api, workspaceId, migrationsDir });
+    }
+} catch (err) {
+    console.error(`workspace:${command} failed:`, err.message);
+    process.exit(1);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@entrinsik/vite-plugin-informer",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Vite plugin and publish tool for local Magic Report development",
   "repository": {
     "type": "git",
@@ -23,11 +23,13 @@
       "types": "./index.d.ts",
       "default": "./src/index.js"
     },
-    "./deploy": "./src/deploy.js"
+    "./deploy": "./src/deploy.js",
+    "./workspace": "./src/workspace.js"
   },
   "bin": {
     "informer-deploy": "./bin/deploy.js",
     "informer-init": "./bin/init.js",
+    "informer-workspace": "./bin/workspace.js",
     "create-magic-report": "./bin/init.js"
   },
   "files": [

package/src/deploy.js

@@ -11,7 +11,7 @@ const TEXT_EXTENSIONS = new Set([
 const CHUNK_THRESHOLD = 512 * 1024; // 512KB
 
 // Config files to upload from project root (if they exist)
-const ROOT_CONFIG_FILES = ['data-access.yaml'];
+const ROOT_CONFIG_FILES = ['informer.yaml', 'data-access.yaml'];
 
 /**
  * Deploy a built Vite project to Informer as an App (or legacy Magic Report).
@@ -59,7 +59,7 @@ export async function deploy({ baseUrl, apiKey, user, pass, distDir, name, descr
 
         try {
             console.log(`Creating new app "${name}"...`);
-            entity = await api.post('apps', { ...payload, type: 'report' });
+            entity = await api.post('apps', { ...payload, type: 'app' });
             apiPrefix = 'apps';
         } catch (e) {
             // If apps endpoint doesn't exist (404), fall back to legacy reports
@@ -168,8 +168,40 @@ export async function deploy({ baseUrl, apiKey, user, pass, distDir, name, descr
         }
     }
 
-    // 8. Print URL and return UUID for saving
-    const totalFiles = entries.length + configCount;
+    // 8. Upload migrations/ directory from project root (if it exists)
+    const migrationsDir = join(projectRoot, 'migrations');
+    let migrationsCount = 0;
+    try {
+        await access(migrationsDir);
+        const migrationFiles = await walkDir(migrationsDir);
+        for (const filePath of migrationFiles) {
+            const relPath = posix.normalize(relative(projectRoot, filePath).split('\\').join('/'));
+            const content = await readFile(filePath, 'utf8');
+            await api.put(`${entityPath}/contents/${relPath}`, {
+                content,
+                encoding: 'utf8'
+            });
+            console.log(`  ${relPath} (from project root)`);
+            migrationsCount++;
+        }
+    } catch {
+        // No migrations directory, skip
+    }
+
+    // 9. Run migrations (if the server supports it)
+    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(', ')}`);
+            }
+        } catch {
+            // Server may not support _migrate yet — ignore
+        }
+    }
+
+    // 9. Print URL and return UUID for saving
+    const totalFiles = entries.length + configCount + migrationsCount;
     const base = baseUrl.replace(/\/+$/, '');
     const entityUrl = apiPrefix === 'apps'
         ? `${base}/api/apps/${naturalId}/view`

package/src/index.js

@@ -4,6 +4,7 @@ import dotenv from 'dotenv';
  * 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)
  * - Injects window.__INFORMER__ context mock in dev mode
  * - Sets base to './' so built assets use relative paths
  *
@@ -12,6 +13,9 @@ import dotenv from 'dotenv';
  */
 export default function informer(options = {}) {
     let isDev = false;
+    let authHeader = null;
+    let serverOrigin = null;
+    let devWorkspaceId = null;
 
     return {
         name: 'vite-plugin-informer',
@@ -31,8 +35,11 @@ export default function informer(options = {}) {
                 const user = process.env.INFORMER_USER;
                 const pass = process.env.INFORMER_PASS;
 
+                devWorkspaceId = process.env.INFORMER_DEV_WORKSPACE || null;
+
                 if (baseUrl) {
-                    const auth = apiKey
+                    serverOrigin = baseUrl.replace(/\/+$/, '');
+                    authHeader = apiKey
                         ? 'Bearer ' + apiKey
                         : 'Basic ' + Buffer.from(`${user}:${pass}`).toString('base64');
 
@@ -42,7 +49,7 @@ export default function informer(options = {}) {
                                 target: baseUrl,
                                 changeOrigin: true,
                                 headers: {
-                                    Authorization: auth
+                                    Authorization: authHeader
                                 }
                             }
                         }
@@ -53,6 +60,45 @@ export default function informer(options = {}) {
             return cfg;
         },
 
+        configureServer(server) {
+            if (!isDev || !devWorkspaceId || !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();
+
+                // Read request body
+                const chunks = [];
+                for await (const chunk of req) {
+                    chunks.push(chunk);
+                }
+                const body = Buffer.concat(chunks).toString('utf8');
+
+                // 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);
+                } catch (err) {
+                    res.statusCode = 502;
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+        },
+
         transformIndexHtml: {
             order: 'pre',
             handler(html) {
@@ -64,6 +110,7 @@ export default function informer(options = {}) {
                         name: 'Local Development'
                     },
                     theme: 'light',
+                    roles: [],
                     ...options.mock
                 };
 

package/src/workspace.js

@@ -0,0 +1,159 @@
+import { readdir, readFile, writeFile, access } from 'node:fs/promises';
+import { join } from 'node:path';
+
+/**
+ * Execute raw SQL against a workspace datasource via the _sql route.
+ */
+async function execSql(api, workspaceId, sql, params = []) {
+    return api.post(`datasources/${workspaceId}/_sql`, { sql, params });
+}
+
+/**
+ * Ensure the _migrations tracking table exists in the workspace.
+ */
+async function ensureMigrationsTable(api, workspaceId) {
+    await execSql(api, workspaceId, `
+        CREATE TABLE IF NOT EXISTS _migrations (
+            name TEXT PRIMARY KEY,
+            executed_at TIMESTAMPTZ DEFAULT NOW()
+        )
+    `);
+}
+
+/**
+ * Read local migration files sorted alphabetically.
+ * @returns {Promise<string[]>} Sorted filenames (e.g., ['001-create-orders.sql', '002-add-index.sql'])
+ */
+async function readMigrationFiles(migrationsDir) {
+    try {
+        await access(migrationsDir);
+    } catch {
+        return [];
+    }
+
+    const entries = await readdir(migrationsDir);
+    return entries
+        .filter(f => f.endsWith('.sql'))
+        .sort();
+}
+
+/**
+ * Get the set of already-executed migration names.
+ */
+async function getCompletedMigrations(api, workspaceId) {
+    const result = await execSql(api, workspaceId, 'SELECT name FROM _migrations');
+    return new Set(result.rows.map(r => r.name));
+}
+
+/**
+ * Run pending migrations against a workspace.
+ */
+async function runMigrations(api, workspaceId, migrationsDir) {
+    await ensureMigrationsTable(api, workspaceId);
+
+    const files = await readMigrationFiles(migrationsDir);
+    if (files.length === 0) {
+        console.log('No migration files found in migrations/');
+        return { migrated: [], total: 0 };
+    }
+
+    const completed = await getCompletedMigrations(api, workspaceId);
+    const pending = files.filter(f => !completed.has(f));
+
+    if (pending.length === 0) {
+        console.log(`All ${files.length} migration(s) already applied.`);
+        return { migrated: [], total: files.length };
+    }
+
+    const migrated = [];
+    for (const file of pending) {
+        const sql = await readFile(join(migrationsDir, file), 'utf8');
+        console.log(`  Running ${file}...`);
+        await execSql(api, workspaceId, sql);
+        await execSql(api, workspaceId, 'INSERT INTO _migrations (name) VALUES ($1)', [file]);
+        migrated.push(file);
+    }
+
+    console.log(`Applied ${migrated.length} migration(s). Total: ${files.length}`);
+    return { migrated, total: files.length };
+}
+
+/**
+ * Initialize a dev workspace datasource.
+ *
+ * Creates a new workspace datasource named "{slug}-dev", runs all
+ * migrations, and saves the workspace ID to .env.
+ */
+export async function init({ api, slug, migrationsDir, envPath }) {
+    const name = `${slug}-dev`;
+    console.log(`Creating workspace datasource "${name}"...`);
+
+    const datasource = await api.post('datasources', {
+        name,
+        type: 'workspace'
+    });
+
+    if (!datasource || !datasource.naturalId) {
+        throw new Error('Failed to create workspace datasource');
+    }
+
+    const workspaceId = datasource.naturalId;
+    console.log(`Created: ${workspaceId}`);
+
+    // Run all migrations
+    const result = await runMigrations(api, workspaceId, migrationsDir);
+
+    // Save workspace ID to .env
+    let envContent = '';
+    try {
+        envContent = await readFile(envPath, 'utf8');
+    } catch {
+        // .env doesn't exist yet
+    }
+
+    if (envContent.includes('INFORMER_DEV_WORKSPACE=')) {
+        envContent = envContent.replace(
+            /INFORMER_DEV_WORKSPACE=.*/,
+            `INFORMER_DEV_WORKSPACE=${workspaceId}`
+        );
+    } else {
+        const nl = envContent.length > 0 && !envContent.endsWith('\n') ? '\n' : '';
+        envContent += `${nl}\n# Dev workspace (created by workspace:init)\nINFORMER_DEV_WORKSPACE=${workspaceId}\n`;
+    }
+
+    await writeFile(envPath, envContent);
+    console.log(`Saved INFORMER_DEV_WORKSPACE=${workspaceId} to .env`);
+
+    return { workspaceId, ...result };
+}
+
+/**
+ * Run pending migrations against the dev workspace.
+ */
+export async function migrate({ api, workspaceId, migrationsDir }) {
+    console.log(`Migrating workspace ${workspaceId}...`);
+    return runMigrations(api, workspaceId, migrationsDir);
+}
+
+/**
+ * Reset the dev workspace: drop all tables, then re-run all migrations.
+ */
+export async function reset({ api, workspaceId, migrationsDir }) {
+    console.log(`Resetting workspace ${workspaceId}...`);
+
+    // Drop all tables in the workspace schema
+    await execSql(api, workspaceId, `
+        DO $$
+        DECLARE r RECORD;
+        BEGIN
+            FOR r IN SELECT tablename FROM pg_tables WHERE schemaname = current_schema()
+            LOOP
+                EXECUTE 'DROP TABLE IF EXISTS "' || r.tablename || '" CASCADE';
+            END LOOP;
+        END $$
+    `);
+    console.log('Dropped all tables.');
+
+    // Re-run all migrations from scratch
+    return runMigrations(api, workspaceId, migrationsDir);
+}