@feltdb/core 0.6.9 → 0.6.11

package/dist/cli/application-lifecycle.js

@@ -0,0 +1,112 @@
+import path from 'path';
+import { spawn } from 'child_process';
+import { applicationIsRunning } from './application.js';
+export function resolveApplicationLifecycle(config) {
+    const lifecycle = config.application?.lifecycle;
+    if (lifecycle === undefined)
+        return 'attached';
+    if (lifecycle !== 'managed' && lifecycle !== 'attached') {
+        throw new Error(`Invalid application.lifecycle "${lifecycle}"; expected managed or attached`);
+    }
+    return lifecycle;
+}
+function commandTokens(source) {
+    const tokens = [];
+    let token = '';
+    let quote = '';
+    for (let index = 0; index < source.length; index += 1) {
+        const character = source[index];
+        if (quote) {
+            if (character === quote)
+                quote = '';
+            else if (character === '\\' && quote === '"' && index + 1 < source.length)
+                token += source[++index];
+            else
+                token += character;
+        }
+        else if (character === '"' || character === "'")
+            quote = character;
+        else if (/\s/.test(character)) {
+            if (token) {
+                tokens.push(token);
+                token = '';
+            }
+        }
+        else
+            token += character;
+    }
+    if (quote)
+        throw new Error(`Cannot run managed application command with an unclosed quote: ${source}`);
+    if (token)
+        tokens.push(token);
+    return tokens;
+}
+export function resolveManagedApplicationCommand(project) {
+    const source = project.devScript?.trim();
+    if (!source)
+        throw new Error('Managed application lifecycle requires package.json.scripts.dev');
+    const tokens = commandTokens(source);
+    const environment = {};
+    while (tokens[0] && /^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[0])) {
+        const assignment = tokens.shift();
+        const separator = assignment.indexOf('=');
+        environment[assignment.slice(0, separator)] = assignment.slice(separator + 1);
+    }
+    const executable = tokens.shift();
+    if (!executable)
+        throw new Error(`Managed application command is empty: ${source}`);
+    if (executable === 'feltdb' || (executable === 'npm' && tokens[0] === 'run')) {
+        throw new Error(`Refusing recursive managed application command: ${source}`);
+    }
+    if (/[|&;<>`]/.test(source)) {
+        throw new Error(`Managed application command must be directly executable without shell operators: ${source}`);
+    }
+    return { source, executable, args: tokens, environment };
+}
+export function startManagedApplication(options) {
+    const command = resolveManagedApplicationCommand(options.project);
+    const localBin = path.join(options.projectDir, 'node_modules', '.bin');
+    const inherited = options.environment ?? process.env;
+    const child = spawn(command.executable, command.args, {
+        cwd: options.projectDir,
+        stdio: 'inherit',
+        shell: false,
+        env: {
+            ...inherited,
+            ...command.environment,
+            PATH: `${localBin}${path.delimiter}${inherited.PATH || ''}`,
+        },
+    });
+    const exited = new Promise((resolve, reject) => {
+        child.once('error', reject);
+        child.once('exit', (code, signal) => resolve({ code, signal }));
+    });
+    return {
+        command: command.source,
+        child,
+        exited,
+        async stop() {
+            if (child.exitCode !== null || child.signalCode !== null)
+                return;
+            child.kill('SIGTERM');
+            await Promise.race([exited.catch(() => undefined), new Promise(resolve => setTimeout(resolve, 2000))]);
+            if (child.exitCode === null && child.signalCode === null)
+                child.kill('SIGKILL');
+        },
+    };
+}
+export async function waitForManagedApplication(options) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < options.timeoutMs) {
+        if (await applicationIsRunning(options.expectedUrl, Math.min(500, options.timeoutMs)))
+            return;
+        const exit = await Promise.race([
+            options.application.exited,
+            new Promise(resolve => setTimeout(() => resolve(null), 100)),
+        ]);
+        if (exit) {
+            throw new Error(`Managed application exited before readiness (command: ${options.application.command}; expected URL: ${options.expectedUrl}; workspace: ${options.workspaceId}; project: ${options.projectDir}; exit: ${exit.code ?? exit.signal})`);
+        }
+    }
+    throw new Error(`Managed application readiness timed out after ${options.timeoutMs}ms (command: ${options.application.command}; expected URL: ${options.expectedUrl}; workspace: ${options.workspaceId}; project: ${options.projectDir})`);
+}

package/dist/cli/application.js

@@ -44,12 +44,22 @@ export function detectApplication(root) {
     const dependencies = { ...manifest.dependencies, ...manifest.devDependencies };
     const framework = FRAMEWORKS.find(candidate => candidate.packages.some(name => name in dependencies) || (script ? candidate.pattern.test(script) : false));
     const feltConfigFile = path.join(root, 'feltdb.config.json');
+    const flowFile = path.join(root, 'feltdb.flow');
     const feltConfig = fs.existsSync(feltConfigFile) ? readJson(feltConfigFile, 'Cannot inspect application: malformed feltdb.config.json') : {};
+    const feltDBSignals = [];
+    if ('@feltdb/core' in dependencies)
+        feltDBSignals.push('dependency');
+    if (fs.existsSync(feltConfigFile))
+        feltDBSignals.push('config');
+    if (fs.existsSync(flowFile))
+        feltDBSignals.push('flow');
     const configuredUrl = typeof feltConfig.appUrl === 'string' ? feltConfig.appUrl
         : typeof feltConfig.applicationUrl === 'string' ? feltConfig.applicationUrl : undefined;
     return {
         packageManager: packageManagerAt(root, typeof manifest.packageManager === 'string' ? manifest.packageManager : undefined),
         framework: framework?.name || (script ? 'Custom' : 'Unknown'),
+        feltDBEnabled: feltDBSignals.length > 0,
+        feltDBSignals,
         devScript: script,
         configuredPort: scriptPort(script),
         configuredUrl,