@entrinsik/vite-plugin-informer 1.0.5 → 2.1.0

package/bin/deploy.js

@@ -72,12 +72,12 @@ try {
         id: savedId
     });
 
-    // Save the report ID back to package.json for future deploys
+    // Save the app ID back to package.json for future deploys
     if (result.id && result.id !== savedId) {
         if (!pkg.informer) pkg.informer = {};
         pkg.informer.id = result.id;
         await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
-        console.log(`Saved report ID "${result.id}" to package.json`);
+        console.log(`Saved app ID "${result.id}" to package.json`);
     }
 } catch (err) {
     console.error('Deploy failed:', err.message);

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,20 +1,35 @@
 {
   "name": "@entrinsik/vite-plugin-informer",
-  "version": "1.0.5",
+  "version": "2.1.0",
   "description": "Vite plugin and publish tool for local Magic Report development",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/entrinsik-org/i5.git",
+    "directory": "packages/vite-plugin-informer"
+  },
+  "publishConfig": {
+    "registry": "https://docker.entrinsik.com/repository/entNPM/"
+  },
+  "author": "Entrinsik Inc.",
+  "license": "UNLICENSED",
   "type": "module",
   "types": "index.d.ts",
   "main": "./src/index.js",
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "exports": {
     ".": {
       "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": [
@@ -26,10 +41,6 @@
     "vite": ">=5.0.0"
   },
   "dependencies": {
-    "dotenv": "^16.4.0"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "license": "UNLICENSED"
+    "dotenv": "16.6.1"
+  }
 }

package/src/client.js

@@ -60,10 +60,11 @@ export function createClient({ baseUrl, apiKey, user, pass }) {
     }
 
     /**
-     * Upload a file using chunked Flow.js protocol, then assemble into a report's library.
-     * @param {{ reportId: string, path: string, buffer: Buffer, filename: string }} opts
+     * Upload a file using chunked Flow.js protocol, then assemble into an entity's library.
+     * @param {{ entityPath?: string, reportId?: string, path: string, buffer: Buffer, filename: string }} opts
      */
-    async function uploadChunked({ reportId, path, buffer, filename }) {
+    async function uploadChunked({ entityPath, reportId, path, buffer, filename }) {
+        const basePath = entityPath || `reports/${reportId}`;
         const totalChunks = Math.ceil(buffer.length / CHUNK_SIZE);
         const uploadId = `publish-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
 
@@ -97,8 +98,8 @@ export function createClient({ baseUrl, apiKey, user, pass }) {
             }
         }
 
-        // Assemble chunks into a file in the report's library at the specified path
-        await request('POST', `reports/${reportId}/_upload`, {
+        // Assemble chunks into a file in the entity's library at the specified path
+        await request('POST', `${basePath}/_upload`, {
             uploadId,
             path
         });

package/src/deploy.js

@@ -11,91 +11,115 @@ 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 a Magic Report.
+ * Deploy a built Vite project to Informer as an App (or legacy Magic Report).
+ *
+ * Tries the new /api/apps endpoint first. If the server doesn't support it,
+ * falls back to the legacy /api/reports endpoint transparently.
  *
  * @param {{ baseUrl: string, apiKey?: string, user?: string, pass?: string, distDir: string, name: string, description?: string, icon?: string, id?: string }} opts
- * @returns {Promise<{ id: string, url: string }>} The report's natural ID and URL
+ * @returns {Promise<{ id: string, url: string }>} The entity's stable UUID and URL
  */
 export async function deploy({ baseUrl, apiKey, user, pass, distDir, name, description, icon, id }) {
     const api = createClient({ baseUrl, apiKey, user, pass });
 
-    let report = null;
+    let entity = null;
     let naturalId = null;
+    let apiPrefix = 'apps';
 
-    // 1. If we have a saved ID, try to look it up
+    // 1. Try to find existing entity — apps API first, then legacy reports
     if (id) {
-        console.log(`Looking up report "${id}"...`);
-        report = await api.get(`reports/${id}`);
-        if (report) {
-            naturalId = report.naturalId || id;
-            console.log(`Found existing report: ${naturalId}`);
+        console.log(`Looking up "${id}"...`);
+        entity = await api.get(`apps/${id}`);
+        if (entity) {
+            apiPrefix = 'apps';
+            naturalId = entity.naturalId || id;
+            console.log(`Found existing app: ${naturalId}`);
         } else {
-            console.log(`Report "${id}" not found, will create new...`);
+            entity = await api.get(`reports/${id}`);
+            if (entity) {
+                apiPrefix = 'reports';
+                naturalId = entity.naturalId || id;
+                console.log(`Found existing report: ${naturalId} (legacy API)`);
+            } else {
+                console.log(`"${id}" not found, will create new...`);
+            }
         }
     }
 
-    // 2. Create if not found (or no ID was provided)
-    if (!report) {
-        console.log(`Creating new report "${name}"...`);
+    // 2. Create if not found — try apps API, fall back to reports
+    if (!entity) {
         const payload = {
-            type: 'magicReport',
             name: name,
             description: description || ''
         };
-        // If we have a saved ID (UUID), use it for the new report
-        if (id) {
-            payload.id = id;
+        if (id) payload.id = id;
+
+        try {
+            console.log(`Creating new app "${name}"...`);
+            entity = await api.post('apps', { ...payload, type: 'app' });
+            apiPrefix = 'apps';
+        } catch (e) {
+            // If apps endpoint doesn't exist (404), fall back to legacy reports
+            if (e.status === 404) {
+                console.log('Apps API not available, using legacy reports API...');
+                entity = await api.post('reports', { ...payload, type: 'magicReport' });
+                apiPrefix = 'reports';
+            } else {
+                throw e;
+            }
         }
-        report = await api.post('reports', payload);
-        if (!report || !report.id) {
-            throw new Error(`Failed to create report "${name}"`);
+
+        if (!entity || !entity.id) {
+            throw new Error(`Failed to create "${name}"`);
         }
-        naturalId = report.naturalId || `${report.ownerId}:${report.slug}`;
-        console.log(`Created report: ${naturalId}`);
+        naturalId = entity.naturalId || `${entity.ownerId}:${entity.slug}`;
+        console.log(`Created: ${naturalId}`);
     }
 
-    // 3. Update name/description/icon if provided (for existing reports)
+    const entityPath = `${apiPrefix}/${naturalId}`;
+
+    // 3. Update name/description/icon if provided (for existing entities)
     const updates = {};
-    if (name && report.name !== name) updates.name = name;
-    if (description !== undefined && report.description !== description) updates.description = description;
+    if (name && entity.name !== name) updates.name = name;
+    if (description !== undefined && entity.description !== description) updates.description = description;
     if (icon) {
-        const currentDefn = report.defn || {};
+        const currentDefn = entity.defn || {};
         if (currentDefn.icon !== icon) {
             updates.defn = { ...currentDefn, icon };
         }
     }
     if (Object.keys(updates).length > 0) {
-        await api.put(`reports/${naturalId}`, updates);
+        await api.put(entityPath, updates);
     }
 
-    // 5. Snapshot via report route
+    // 4. Snapshot
     console.log('Creating snapshot...');
-    await api.post(`reports/${naturalId}/snapshots`, {
+    await api.post(`${entityPath}/snapshots`, {
         trigger: 'refresh',
         limit: 10
     });
 
-    // 6. Clear existing files via report route
+    // 5. Clear existing files
     console.log('Clearing existing files...');
-    const files = await api.get(`reports/${naturalId}/files?start=0&end=10000`);
+    const files = await api.get(`${entityPath}/files?start=0&end=10000`);
     if (files && Array.isArray(files)) {
         // Delete non-directories first
         const nonDirs = files.filter(f => !f.directory);
-        await Promise.all(nonDirs.map(f => api.del(`reports/${naturalId}/files/${f.id}`)));
+        await Promise.all(nonDirs.map(f => api.del(`${entityPath}/files/${f.id}`)));
 
         // Then delete directories in reverse order (deepest first by path length)
         const dirs = files
             .filter(f => f.directory)
             .sort((a, b) => (b.path || '').length - (a.path || '').length);
         for (const d of dirs) {
-            await api.del(`reports/${naturalId}/files/${d.id}`);
+            await api.del(`${entityPath}/files/${d.id}`);
         }
     }
 
-    // 7. Upload dist/ contents via report routes
+    // 6. Upload dist/ contents
     console.log(`Uploading files from ${distDir}...`);
     const entries = await walkDir(distDir);
 
@@ -106,7 +130,7 @@ export async function deploy({ baseUrl, apiKey, user, pass, distDir, name, descr
         if (content.length > CHUNK_THRESHOLD) {
             // Large file: chunked upload via Flow.js protocol
             await api.uploadChunked({
-                reportId: naturalId,
+                entityPath,
                 path: relPath,
                 buffer: content,
                 filename: basename(filePath)
@@ -120,12 +144,12 @@ export async function deploy({ baseUrl, apiKey, user, pass, distDir, name, descr
                 ? { content: content.toString('utf8'), encoding: 'utf8' }
                 : { content: content.toString('base64'), encoding: 'base64' };
 
-            await api.put(`reports/${naturalId}/contents/${relPath}`, payload);
+            await api.put(`${entityPath}/contents/${relPath}`, payload);
             console.log(`  ${relPath}`);
         }
     }
 
-    // 8. Upload config files from project root (e.g., data-access.yaml)
+    // 7. Upload config files from project root (e.g., data-access.yaml)
     const projectRoot = dirname(distDir);
     let configCount = 0;
     for (const configFile of ROOT_CONFIG_FILES) {
@@ -133,7 +157,7 @@ export async function deploy({ baseUrl, apiKey, user, pass, distDir, name, descr
         try {
             await access(configPath);
             const content = await readFile(configPath, 'utf8');
-            await api.put(`reports/${naturalId}/contents/${configFile}`, {
+            await api.put(`${entityPath}/contents/${configFile}`, {
                 content,
                 encoding: 'utf8'
             });
@@ -144,13 +168,47 @@ export async function deploy({ baseUrl, apiKey, user, pass, distDir, name, descr
         }
     }
 
-    // 9. Print report URL and return UUID for saving
-    const totalFiles = entries.length + configCount;
-    const reportUrl = `${baseUrl.replace(/\/+$/, '')}/reports/r/${naturalId}`;
-    console.log(`\nPublished ${totalFiles} files to: ${reportUrl}`);
+    // 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`
+        : `${base}/reports/r/${naturalId}`;
+    console.log(`\nPublished ${totalFiles} files to: ${entityUrl}`);
 
-    // Return the stable UUID (not natural ID) for package.json storage
-    return { id: report.id, url: reportUrl };
+    return { id: entity.id, url: entityUrl };
 }
 
 /**

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);
+}