@feltdb/core 0.6.4 → 0.6.6

package/dist/cli/commands.js

@@ -7,7 +7,7 @@ import http from 'http';
 import net from 'net';
 import { createRequire } from 'module';
 import { spawn, spawnSync } from 'child_process';
-import { createFeltDB, diffFlowSpec, formatFlowSpec, parseFlowSpec, planFlowSpecMigration, validateFlowSpec } from '@feltdb/core';
+import { createFeltDB, diffFlowSpec, formatFlowSpec, parseFlowSpec, planFlowSpecMigration, startLocalDevelopmentAuthority, validateFlowSpec } from '@feltdb/core';
 import { discoverWorkspace, generatePairingToken, persistPairingToken, displayWorkspaceStatus, initializeWorkspace, startPairingDiscoveryServer } from './workspace-integration.js';
 function loadProjectEnvironment(file = path.resolve('.env.local')) {
     if (!fs.existsSync(file))
@@ -429,6 +429,10 @@ function runLocalVite(args, waitForExit) {
 }
 async function handleDev(args) {
     var _a, _b, _c;
+    if (args.includes('--help')) {
+        console.log('Usage: feltdb dev [--port 5173] [--studio-port 7701] [--authority-port 7700] [--discovery-port 7799] [--no-open]');
+        return;
+    }
     loadProjectEnvironment();
     console.log('🚀 Starting FeltDB development server...\n');
     const projectDir = process.cwd();
@@ -498,6 +502,7 @@ async function handleDev(args) {
     process.env.APP_PORT = appPort;
     process.env.STUDIO_PORT = studioPort;
     let selfHostedStarted = false;
+    let localAuthority = null;
     const stopSelfHosted = () => {
         if (selfHostedStarted) {
             spawnSync('docker', ['compose', 'stop', 'feltdb'], { cwd: process.cwd(), stdio: 'ignore' });
@@ -519,6 +524,14 @@ async function handleDev(args) {
         selfHostedStarted = true;
         (_c = process.env).VITE_FELTDB_URL || (_c.VITE_FELTDB_URL = 'http://127.0.0.1:7700');
     }
+    if (!process.env.VITE_FELTDB_URL) {
+        const authorityPort = Number(args.includes('--authority-port') ? args[args.indexOf('--authority-port') + 1] || '7700' : '7700');
+        localAuthority = await startLocalDevelopmentAuthority({
+            dataDir: path.join(projectDir, '.feltdb', 'authority'),
+            port: authorityPort,
+        });
+        process.env.VITE_FELTDB_URL = localAuthority.endpoint;
+    }
     // Generate pairing token for the workspace
     // This enables browsers and IDEs to discover and connect to the workspace
     let pairingToken = null;
@@ -538,6 +551,7 @@ async function handleDev(args) {
         pairingToken = token.token;
     }
     console.log('FeltDB Dev Server');
+    console.log(`  Authority: ${process.env.VITE_FELTDB_URL}`);
     console.log(`  Namespace: ${config.namespace}`);
     console.log(`  Runtime: ${config.runtime}`);
     console.log(`  Storage: ${config.storage}`);
@@ -547,7 +561,7 @@ async function handleDev(args) {
         console.log(`🔗 Development Workspace`);
         if (pairingToken) {
             console.log(`  Pairing Code: ${pairingToken}`);
-            console.log(`  Discovery: http://127.0.0.1:${(pairingDiscoveryServer?.address()).port}`);
+            console.log(`  Pairing discovery: http://127.0.0.1:${(pairingDiscoveryServer?.address()).port}`);
             console.log(`  Clients can use this code to auto-discover the workspace`);
         }
     }
@@ -560,7 +574,7 @@ async function handleDev(args) {
     let shuttingDown = false;
     const stopVite = () => { if (!vite.killed)
         vite.kill('SIGTERM'); };
-    const stopAll = () => { shuttingDown = true; stopVite(); pairingDiscoveryServer?.close(); stopSelfHosted(); };
+    const stopAll = () => { shuttingDown = true; stopVite(); pairingDiscoveryServer?.close(); void localAuthority?.close(); stopSelfHosted(); };
     // In an inherited terminal Ctrl-C can reach Vite before this parent process.
     // Never leave Studio (or its port) running after the application exits.
     vite.once('exit', code => {

package/dist/cli/index.js

@@ -23,7 +23,7 @@ import * as path from 'path';
 import * as readline from 'readline';
 import { getClient } from './api-client.js';
 import { loadFeltDBConfig, createDefaultConfig, validateModel, } from './config.js';
-const VERSION = '0.6.4';
+const VERSION = '0.6.6';
 function prompt(question) {
     const rl = readline.createInterface({
         input: process.stdin,

package/dist/create/package-versions.js

@@ -1,4 +1,4 @@
 // One release train keeps generated applications installable. The repository
 // validation script checks these values against every workspace manifest.
-export const FELTDB_PACKAGE_VERSION = '0.6.4';
+export const FELTDB_PACKAGE_VERSION = '0.6.6';
 export const feltdbPackageRange = `^${FELTDB_PACKAGE_VERSION}`;

package/dist/workspace/index.d.ts

@@ -17,4 +17,6 @@ export { connectDevelopmentWorkspace, discoverDevelopmentWorkspace, resolvePairi
 export { createWorkspaceId, isValidWorkspaceId, createDevelopmentWorkspace, updateWorkspaceTimestamp, discoverWorkspace, persistWorkspaceDiscovery, } from './workspace-identity.js';
 export { DevelopmentNode, getDevelopmentNode, shutdownDevelopmentNode, } from './development-node.js';
 export type { DevelopmentNodeConfig } from './development-node.js';
+export { startLocalDevelopmentAuthority } from './local-development-authority.js';
+export type { LocalDevelopmentAuthority, LocalDevelopmentAuthorityOptions } from './local-development-authority.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/workspace/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/workspace/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,YAAY,EACV,oBAAoB,EACpB,UAAU,EACV,qBAAqB,EACrB,eAAe,EACf,UAAU,EACV,kBAAkB,EAClB,cAAc,EACd,eAAe,EACf,kBAAkB,GACnB,MAAM,sBAAsB,CAAC;AAE9B,YAAY,EACV,0BAA0B,EAC1B,iBAAiB,EACjB,gBAAgB,EAChB,wBAAwB,EACxB,uBAAuB,EACvB,UAAU,GACX,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EACL,2BAA2B,EAC3B,4BAA4B,EAC5B,kBAAkB,EAClB,8BAA8B,GAC/B,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,0BAA0B,EAC1B,wBAAwB,EACxB,iBAAiB,EACjB,yBAAyB,GAC1B,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,uBAAuB,GACxB,MAAM,uBAAuB,CAAC;AAE/B,YAAY,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/workspace/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,YAAY,EACV,oBAAoB,EACpB,UAAU,EACV,qBAAqB,EACrB,eAAe,EACf,UAAU,EACV,kBAAkB,EAClB,cAAc,EACd,eAAe,EACf,kBAAkB,GACnB,MAAM,sBAAsB,CAAC;AAE9B,YAAY,EACV,0BAA0B,EAC1B,iBAAiB,EACjB,gBAAgB,EAChB,wBAAwB,EACxB,uBAAuB,EACvB,UAAU,GACX,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EACL,2BAA2B,EAC3B,4BAA4B,EAC5B,kBAAkB,EAClB,8BAA8B,GAC/B,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,0BAA0B,EAC1B,wBAAwB,EACxB,iBAAiB,EACjB,yBAAyB,GAC1B,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,uBAAuB,GACxB,MAAM,uBAAuB,CAAC;AAE/B,YAAY,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAEnE,OAAO,EAAE,8BAA8B,EAAE,MAAM,kCAAkC,CAAC;AAClF,YAAY,EAAE,yBAAyB,EAAE,gCAAgC,EAAE,MAAM,kCAAkC,CAAC"}

package/dist/workspace/index.js

@@ -14,3 +14,4 @@
 export { connectDevelopmentWorkspace, discoverDevelopmentWorkspace, resolvePairingCode, DevelopmentWorkspaceConnection, } from './workspace-connection.js';
 export { createWorkspaceId, isValidWorkspaceId, createDevelopmentWorkspace, updateWorkspaceTimestamp, discoverWorkspace, persistWorkspaceDiscovery, } from './workspace-identity.js';
 export { DevelopmentNode, getDevelopmentNode, shutdownDevelopmentNode, } from './development-node.js';
+export { startLocalDevelopmentAuthority } from './local-development-authority.js';

package/dist/workspace/local-development-authority.d.ts

@@ -0,0 +1,12 @@
+export interface LocalDevelopmentAuthority {
+    endpoint: string;
+    close(): Promise<void>;
+}
+export interface LocalDevelopmentAuthorityOptions {
+    dataDir: string;
+    host?: string;
+    port?: number;
+}
+/** Start the durable, unauthenticated loopback authority used by `feltdb dev`. */
+export declare function startLocalDevelopmentAuthority(options: LocalDevelopmentAuthorityOptions): Promise<LocalDevelopmentAuthority>;
+//# sourceMappingURL=local-development-authority.d.ts.map

package/dist/workspace/local-development-authority.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-development-authority.d.ts","sourceRoot":"","sources":["../../src/workspace/local-development-authority.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,MAAM,WAAW,gCAAgC;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,kFAAkF;AAClF,wBAAsB,8BAA8B,CAClD,OAAO,EAAE,gCAAgC,GACxC,OAAO,CAAC,yBAAyB,CAAC,CAyFpC"}

package/dist/workspace/local-development-authority.js

@@ -0,0 +1,137 @@
+import http from 'node:http';
+import path from 'node:path';
+import { FileJsDb } from '../file-db.js';
+/** Start the durable, unauthenticated loopback authority used by `feltdb dev`. */
+export async function startLocalDevelopmentAuthority(options) {
+    const host = options.host || '127.0.0.1';
+    const port = options.port ?? 7700;
+    if (host !== '127.0.0.1' && host !== 'localhost' && host !== '::1') {
+        throw new Error('The development authority may only bind to a loopback address');
+    }
+    const db = new FileJsDb(path.resolve(options.dataDir));
+    const streams = new Set();
+    const server = http.createServer(async (request, response) => {
+        try {
+            response.setHeader('Access-Control-Allow-Origin', '*');
+            response.setHeader('Access-Control-Allow-Methods', 'GET, POST, PATCH, DELETE, OPTIONS');
+            response.setHeader('Access-Control-Allow-Headers', 'Authorization, Content-Type, FeltDB-Protocol');
+            response.setHeader('Cache-Control', 'no-store');
+            if (request.method === 'OPTIONS') {
+                response.statusCode = 204;
+                response.end();
+                return;
+            }
+            const pathname = new URL(request.url || '/', `http://${host}`).pathname;
+            if (request.method === 'GET' && (pathname === '/health' || pathname === '/ready')) {
+                json(response, 200, { status: 'ready', storage: 'writable', authority: 'local-development' });
+                return;
+            }
+            if (request.method === 'GET' && pathname === '/events') {
+                response.writeHead(200, {
+                    'Content-Type': 'text/event-stream',
+                    Connection: 'keep-alive',
+                    'Cache-Control': 'no-cache',
+                    'Access-Control-Allow-Origin': '*',
+                });
+                response.write(': connected\n\n');
+                streams.add(response);
+                request.once('close', () => streams.delete(response));
+                return;
+            }
+            const match = pathname.match(/^\/collections\/([^/]+)(?:\/([^/]+))?$/);
+            if (!match) {
+                json(response, 404, { error: 'NOT_FOUND' });
+                return;
+            }
+            const collection = decodeURIComponent(match[1]);
+            const id = match[2] ? decodeURIComponent(match[2]) : undefined;
+            const body = await readBody(request);
+            let result;
+            if (request.method === 'GET' && !id) {
+                result = db.query(collection);
+                json(response, result.success ? 200 : 500, result.success
+                    ? JSON.parse(result.data || '[]').map(value => ({ value }))
+                    : { error: result.error });
+                return;
+            }
+            if (request.method === 'GET' && id) {
+                result = db.get(`${collection}:${id}`);
+                if (!result.success) {
+                    json(response, 500, { error: result.error });
+                    return;
+                }
+                if (!result.data) {
+                    json(response, 404, { error: 'NOT_FOUND' });
+                    return;
+                }
+                json(response, 200, { value: JSON.parse(result.data) });
+                return;
+            }
+            if (request.method === 'POST' && !id) {
+                const value = parseObject(body);
+                const recordId = typeof value.id === 'string' ? value.id : '';
+                if (!recordId) {
+                    json(response, 400, { error: 'Record must have an id' });
+                    return;
+                }
+                result = db.insert(`${collection}:${recordId}`, JSON.stringify(value));
+            }
+            else if (request.method === 'PATCH' && id) {
+                result = db.update(`${collection}:${id}`, JSON.stringify(parseObject(body)));
+            }
+            else if (request.method === 'DELETE' && id) {
+                result = db.delete(`${collection}:${id}`);
+            }
+            else {
+                json(response, 404, { error: 'NOT_FOUND' });
+                return;
+            }
+            if (!result.success) {
+                json(response, 400, { error: result.error });
+                return;
+            }
+            json(response, request.method === 'POST' ? 201 : 200, { ok: true });
+            const frame = `data: ${JSON.stringify({ change: { capability: collection } })}\n\n`;
+            for (const stream of streams)
+                stream.write(frame);
+        }
+        catch (error) {
+            if (!response.headersSent)
+                json(response, 400, { error: error instanceof Error ? error.message : String(error) });
+            else
+                response.end();
+        }
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(port, host, resolve);
+    });
+    return {
+        endpoint: `http://${host}:${port}`,
+        close: () => new Promise((resolve, reject) => {
+            for (const stream of streams)
+                stream.end();
+            server.close(error => error ? reject(error) : resolve());
+        }),
+    };
+}
+function json(response, status, value) {
+    response.statusCode = status;
+    response.setHeader('Content-Type', 'application/json; charset=utf-8');
+    response.end(JSON.stringify(value));
+}
+function readBody(request) {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        request.setEncoding('utf8');
+        request.on('data', chunk => { body += chunk; });
+        request.once('end', () => resolve(body));
+        request.once('error', reject);
+    });
+}
+function parseObject(body) {
+    const value = JSON.parse(body || '{}');
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Request body must be an object');
+    return value;
+}

package/dist/workspace/workspace-connection.js

@@ -407,13 +407,38 @@ class HttpWorkspaceTransport {
     }
     subscribe(workspaceId, handler) {
         let stopped = false;
+        let delivering = false;
+        let deliveryPending = false;
         const subscribedAt = Date.now();
+        const deliver = async () => {
+            if (stopped)
+                return;
+            if (delivering) {
+                deliveryPending = true;
+                return;
+            }
+            delivering = true;
+            try {
+                await this.deliverEvents(workspaceId, subscribedAt, handler);
+            }
+            finally {
+                delivering = false;
+                if (deliveryPending) {
+                    deliveryPending = false;
+                    void deliver();
+                }
+            }
+        };
         const unsubscribe = this.db.subscribe_changes(collection => {
             if (collection !== EVENT_COLLECTION || stopped)
                 return;
-            void this.deliverEvents(workspaceId, subscribedAt, handler);
+            void deliver();
         });
-        return () => { stopped = true; unsubscribe(); };
+        // The event log is authoritative. Reconcile immediately and periodically so
+        // an event cannot be stranded in the small window before SSE is established.
+        void deliver();
+        const reconciliation = setInterval(() => void deliver(), 250);
+        return () => { stopped = true; clearInterval(reconciliation); unsubscribe(); };
     }
     async appendEvent(input, type, value) {
         const event = { id: generateEventId(), ...input, type, value, timestamp: Date.now() };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feltdb/core",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "description": "FeltDB Core - Application-facing database with Browser, Local, and Server runtimes. Durable state, reactive APIs.",
   "license": "MIT",
   "type": "module",