@antelopejs/dms-frontend 0.5.5 → 0.6.0

package/dist/layer-watch.js

@@ -14,7 +14,7 @@ const derived_outputs_1 = require("./derived-outputs");
 const output_1 = require("./output");
 const fs_sync_1 = require("./fs-sync");
 const WATCH_DEBOUNCE_MS = 80;
-const DERIVED_REFRESH_DEBOUNCE_MS = 100;
+const DERIVED_REFRESH_GAP_MS = 100;
 function capitalize(text) {
     return `${text.charAt(0).toUpperCase()}${text.slice(1)}`;
 }
@@ -37,126 +37,88 @@ function createSyncFailures(src, reporter) {
         },
     };
 }
-function createLayerSync(src, dest, onFlushed, reporter) {
+function createLayerSync(src, dest, reporter, onStaged) {
     const fileUpserts = new Set();
     const fileDeletes = new Set();
     const dirCreates = new Set();
     const dirDeletes = new Set();
     const failures = createSyncFailures(src, reporter);
-    let timer = null;
     const toRel = (p) => {
         const r = (0, node_path_1.relative)(src, p);
         return r ? r : null;
     };
-    const flush = () => {
-        timer = null;
-        const touched = [
-            ...dirCreates,
-            ...fileUpserts,
-            ...fileDeletes,
-            ...dirDeletes,
-        ];
-        for (const rel of [...dirCreates].sort((a, b) => a.length - b.length)) {
-            try {
-                (0, node_fs_1.mkdirSync)((0, node_path_1.join)(dest, rel), { recursive: true });
-                failures.applied(rel);
+    const take = (staged, select) => {
+        const taken = [...staged].filter(select);
+        for (const rel of taken)
+            staged.delete(rel);
+        return taken;
+    };
+    const upsert = (rel) => {
+        try {
+            const srcPath = (0, node_path_1.join)(src, rel);
+            if (!(0, node_fs_1.existsSync)(srcPath))
+                return;
+            const destPath = (0, node_path_1.join)(dest, rel);
+            if (rel === "package.json") {
+                (0, fs_sync_1.applyContent)((0, fs_sync_1.sanitizedPackageContent)((0, node_fs_1.readFileSync)(srcPath, "utf-8")), destPath);
             }
-            catch (err) {
-                failures.fail(rel, err);
+            else {
+                (0, fs_sync_1.applyFile)(srcPath, destPath);
             }
+            failures.applied(rel);
         }
-        dirCreates.clear();
-        for (const rel of fileUpserts) {
-            try {
-                const srcPath = (0, node_path_1.join)(src, rel);
-                if (!(0, node_fs_1.existsSync)(srcPath))
-                    continue;
-                const destPath = (0, node_path_1.join)(dest, rel);
-                if (rel === "package.json") {
-                    (0, fs_sync_1.applyContent)((0, fs_sync_1.sanitizedPackageContent)((0, node_fs_1.readFileSync)(srcPath, "utf-8")), destPath);
-                }
-                else {
-                    (0, fs_sync_1.applyFile)(srcPath, destPath);
-                }
-                failures.applied(rel);
-            }
-            catch (err) {
-                failures.fail(rel, err);
-            }
+        catch (err) {
+            failures.fail(rel, err);
         }
-        fileUpserts.clear();
-        for (const rel of fileDeletes) {
-            try {
-                if ((0, node_fs_1.existsSync)((0, node_path_1.join)(src, rel)))
-                    continue;
-                const destPath = (0, node_path_1.join)(dest, rel);
-                if ((0, node_fs_1.existsSync)(destPath))
-                    (0, node_fs_1.rmSync)(destPath, { force: true });
-                failures.applied(rel);
-            }
-            catch (err) {
-                failures.fail(rel, err);
-            }
+    };
+    const remove = (rel, recursive) => {
+        try {
+            if ((0, node_fs_1.existsSync)((0, node_path_1.join)(src, rel)))
+                return;
+            const destPath = (0, node_path_1.join)(dest, rel);
+            if ((0, node_fs_1.existsSync)(destPath))
+                (0, node_fs_1.rmSync)(destPath, { recursive, force: true });
+            failures.applied(rel);
         }
-        fileDeletes.clear();
-        for (const rel of [...dirDeletes].sort((a, b) => b.length - a.length)) {
-            try {
-                if ((0, node_fs_1.existsSync)((0, node_path_1.join)(src, rel)))
-                    continue;
-                const destPath = (0, node_path_1.join)(dest, rel);
-                if ((0, node_fs_1.existsSync)(destPath))
-                    (0, node_fs_1.rmSync)(destPath, { recursive: true, force: true });
-                failures.applied(rel);
-            }
-            catch (err) {
-                failures.fail(rel, err);
-            }
+        catch (err) {
+            failures.fail(rel, err);
         }
-        dirDeletes.clear();
-        onFlushed(touched);
     };
-    const arm = () => {
-        if (timer)
-            clearTimeout(timer);
-        timer = setTimeout(flush, WATCH_DEBOUNCE_MS);
+    const stage = (p, add, cancel) => {
+        const r = toRel(p);
+        if (!r)
+            return;
+        cancel.delete(r);
+        add.add(r);
+        onStaged();
     };
     return {
-        upsertFile(p) {
-            const r = toRel(p);
-            if (!r)
-                return;
-            fileDeletes.delete(r);
-            fileUpserts.add(r);
-            arm();
+        src,
+        upsertFile: (p) => stage(p, fileUpserts, fileDeletes),
+        deleteFile: (p) => stage(p, fileDeletes, fileUpserts),
+        createDir: (p) => stage(p, dirCreates, dirDeletes),
+        deleteDir: (p) => stage(p, dirDeletes, dirCreates),
+        pending() {
+            return [...dirCreates, ...fileUpserts, ...fileDeletes, ...dirDeletes];
         },
-        deleteFile(p) {
-            const r = toRel(p);
-            if (!r)
-                return;
-            fileUpserts.delete(r);
-            fileDeletes.add(r);
-            arm();
-        },
-        createDir(p) {
-            const r = toRel(p);
-            if (!r)
-                return;
-            dirDeletes.delete(r);
-            dirCreates.add(r);
-            arm();
-        },
-        deleteDir(p) {
-            const r = toRel(p);
-            if (!r)
-                return;
-            dirCreates.delete(r);
-            dirDeletes.add(r);
-            arm();
+        createDirs() {
+            for (const rel of take(dirCreates, () => true).sort((a, b) => a.length - b.length)) {
+                try {
+                    (0, node_fs_1.mkdirSync)((0, node_path_1.join)(dest, rel), { recursive: true });
+                    failures.applied(rel);
+                }
+                catch (err) {
+                    failures.fail(rel, err);
+                }
+            }
         },
-        flushNow() {
-            if (timer)
-                clearTimeout(timer);
-            flush();
+        apply(select) {
+            for (const rel of take(fileUpserts, select))
+                upsert(rel);
+            for (const rel of take(fileDeletes, select))
+                remove(rel, false);
+            for (const rel of take(dirDeletes, select).sort((a, b) => b.length - a.length))
+                remove(rel, true);
         },
     };
 }
@@ -186,10 +148,8 @@ function describeLayerDirectories(paths, reporter) {
         : `Layer directory ${shown[0]} removed`;
 }
 function createDerivedOutputRefresher(workspaceDir, layers, reporter) {
-    const pending = new Map();
     const failures = new Map();
     let hasRestartNotice = false;
-    let timer = null;
     const fail = (key, failure) => {
         failures.set(key, failure);
         reporter.warn(failure.text, failure.options);
@@ -215,19 +175,18 @@ function createDerivedOutputRefresher(workspaceDir, layers, reporter) {
             recover(output);
             if (isChanged)
                 noticeRestart(output, paths);
+            return isChanged;
         }
         catch (err) {
             fail(output, describeOutputFailure(output, err, reporter));
+            return false;
         }
     };
-    const refresh = () => {
-        timer = null;
-        const outputs = derived_outputs_1.DERIVED_OUTPUTS.filter((output) => pending.has(output)).map((output) => [output, pending.get(output) ?? []]);
-        pending.clear();
-        let registry;
+    const buildRegistry = () => {
         try {
-            registry = (0, derived_outputs_1.createFrontendModuleRegistry)(workspaceDir, layers);
+            const registry = (0, derived_outputs_1.createFrontendModuleRegistry)(workspaceDir, layers);
             recover("registry");
+            return registry;
         }
         catch (err) {
             fail("registry", {
@@ -240,35 +199,69 @@ function createDerivedOutputRefresher(workspaceDir, layers, reporter) {
                 },
                 fixed: "Derived files regenerated",
             });
-            return;
+            return undefined;
         }
-        for (const [output, paths] of outputs)
-            regenerate(output, paths, registry);
     };
     return {
-        schedule(src, paths) {
-            let isAffected = false;
+        plan(touched) {
+            const pending = new Map();
             for (const output of derived_outputs_1.DERIVED_OUTPUTS) {
-                const affected = paths.filter((path) => output.affects(path));
-                if (affected.length === 0)
-                    continue;
-                isAffected = true;
-                pending.set(output, [
-                    ...(pending.get(output) ?? []),
-                    ...affected.map((path) => (0, node_path_1.join)(src, path)),
-                ]);
+                const affected = touched.flatMap(({ src, paths }) => paths
+                    .filter((path) => output.affects(path))
+                    .map((path) => (0, node_path_1.join)(src, path)));
+                if (affected.length > 0)
+                    pending.set(output, affected);
             }
-            if (!isAffected)
-                return;
+            const registry = pending.size > 0 ? buildRegistry() : undefined;
+            return (select) => {
+                let isChanged = false;
+                if (!registry)
+                    return isChanged;
+                for (const [output, paths] of pending) {
+                    if (select(output))
+                        isChanged = regenerate(output, paths, registry) || isChanged;
+                }
+                return isChanged;
+            };
+        },
+    };
+}
+function isReadAsData(relativePath) {
+    return derived_outputs_1.DERIVED_OUTPUTS.some((output) => output.readsSourcesAsData && output.affects(relativePath));
+}
+function runPass(syncs, refresher) {
+    const writeOutputs = refresher.plan(syncs.map((sync) => ({ src: sync.src, paths: sync.pending() })));
+    const isDataOutput = (output) => output.readsSourcesAsData === true;
+    for (const sync of syncs)
+        sync.createDirs();
+    for (const sync of syncs)
+        sync.apply(isReadAsData);
+    const isDataChanged = writeOutputs(isDataOutput);
+    for (const sync of syncs)
+        sync.apply((path) => !isReadAsData(path));
+    const isChanged = writeOutputs((output) => !isDataOutput(output));
+    return isDataChanged || isChanged;
+}
+function createPassScheduler(pass) {
+    let timer = null;
+    let lastRegeneration = Number.NEGATIVE_INFINITY;
+    const flush = () => {
+        timer = null;
+        if (pass())
+            lastRegeneration = Date.now();
+    };
+    return {
+        arm: () => {
             if (timer)
                 clearTimeout(timer);
-            timer = setTimeout(refresh, DERIVED_REFRESH_DEBOUNCE_MS);
+            const gap = lastRegeneration + DERIVED_REFRESH_GAP_MS - Date.now();
+            timer = setTimeout(flush, Math.max(WATCH_DEBOUNCE_MS, gap));
         },
-        flushNow() {
+        flushNow: () => {
             if (!timer)
                 return;
             clearTimeout(timer);
-            refresh();
+            flush();
         },
     };
 }
@@ -289,12 +282,13 @@ function startLayerWatchers(workspaceDir, layers, ui = (0, cli_1.getProcessUi)()
     const watchers = [];
     const syncs = [];
     const refresher = createDerivedOutputRefresher(workspaceDir, layers, reporter);
+    const passes = createPassScheduler(() => runPass(syncs, refresher));
     for (const layer of layers) {
         if (!layer.packageName)
             continue;
         const dest = (0, layers_1.getLayerWorkspacePath)(workspaceDir, layer);
         const src = layer.path;
-        const sync = createLayerSync(src, dest, (paths) => refresher.schedule(src, paths), reporter);
+        const sync = createLayerSync(src, dest, reporter, passes.arm);
         syncs.push(sync);
         const watcher = chokidar_1.default.watch(src, {
             ignoreInitial: true,
@@ -310,8 +304,6 @@ function startLayerWatchers(workspaceDir, layers, ui = (0, cli_1.getProcessUi)()
     }
     return async () => {
         await Promise.all(watchers.map((w) => w.close().catch(() => { })));
-        for (const sync of syncs)
-            sync.flushNow();
-        refresher.flushNow();
+        passes.flushNow();
     };
 }

package/dist/layers.js

@@ -125,8 +125,10 @@ function resolveLayer(layerPath, mod) {
         priority: mod.priority,
         configKey: mod.configKey,
         options: mod.options,
+        privateOptions: mod.privateOptions,
         authEstablishEndpoints: mod.authEstablishEndpoints,
         publicEndpoints: mod.publicEndpoints,
+        backendProxies: mod.backendProxies,
     };
 }
 function buildLayersFromPaths(modules) {

package/dist/manifest-secrets.js

@@ -59,14 +59,14 @@ function resolveManifestSecrets(secrets, env = process.env) {
     for (const name of SECRET_NAMES) {
         const explicit = env[name];
         const published = secrets.published[name];
-        if (explicit) {
-            resolved.env[name] = explicit;
-            resolved.sources[name] = "env";
-        }
-        else if (published) {
+        if (published) {
             resolved.env[name] = published.value;
             resolved.sources[name] = "manifest";
         }
+        else if (explicit) {
+            resolved.env[name] = explicit;
+            resolved.sources[name] = "env";
+        }
         else {
             resolved.sources[name] = "not set";
         }

package/dist/manifest.js

@@ -192,7 +192,13 @@ async function fetchManifest(backendUrl, clientUrl, bootstrapSecret) {
     if (incompatible.length) {
         throw new ManifestRefusedError(`Frontend manifest contains incompatible renderer modules: ${incompatible.map((module) => module.name).join(", ")}`);
     }
-    return { pack: manifest.archive, modules: manifest.modules };
+    const resolved = {
+        pack: manifest.archive,
+        modules: manifest.modules,
+    };
+    if (manifest.settling)
+        resolved.settling = true;
+    return resolved;
 }
 const MANIFEST_CACHE_FILE = ".manifest-cache.json";
 function readCachedManifest(workspaceDir) {

package/dist/materialize.js

@@ -13,6 +13,7 @@ const cli_1 = require("@antelopejs/core/cli");
 const config_1 = require("./config");
 const derived_outputs_1 = require("./derived-outputs");
 const layers_1 = require("./layers");
+const manifest_secrets_1 = require("./manifest-secrets");
 const fs_sync_1 = require("./fs-sync");
 function getPackageRoot() {
     return (0, node_path_1.resolve)(__dirname, "..");
@@ -98,13 +99,32 @@ function writeAuthEstablishEndpoints(workspaceDir, layers) {
 function collectPublicEndpoints(layers) {
     return layers.flatMap((layer) => (Array.isArray(layer.publicEndpoints) ? layer.publicEndpoints : []).filter((endpoint) => typeof endpoint === "object" && endpoint !== null));
 }
+function collectBackendProxies(layers) {
+    return layers.flatMap((layer) => (Array.isArray(layer.backendProxies) ? layer.backendProxies : [])
+        .filter((proxy) => typeof proxy === "object" && proxy !== null)
+        .map((proxy) => ({
+        ...proxy,
+        module: layer.name ?? layer.packageName ?? "unknown",
+    })));
+}
 function writePublicEndpoints(workspaceDir, layers) {
-    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(workspaceDir, config_1.PUBLIC_ENDPOINTS_FILE), `${JSON.stringify({ endpoints: collectPublicEndpoints(layers) }, null, 2)}\n`);
+    const declared = {
+        endpoints: collectPublicEndpoints(layers),
+        proxies: collectBackendProxies(layers),
+    };
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(workspaceDir, config_1.PUBLIC_ENDPOINTS_FILE), `${JSON.stringify(declared, null, 2)}\n`);
+}
+function writeServerOptions(workspaceDir, layers) {
+    const modules = Object.fromEntries(layers.flatMap((layer) => layer.privateOptions
+        ? [[(0, layers_1.getLayerSafeName)(layer), layer.privateOptions]]
+        : []));
+    (0, config_1.writeSecretBearingFile)((0, node_path_1.join)(workspaceDir, config_1.SERVER_OPTIONS_FILE), `${JSON.stringify({ modules, environment: manifest_secrets_1.MANIFEST_SECRET_ENV }, null, 2)}\n`);
 }
 function writeFrontendModuleRegistry(workspaceDir, layers) {
     const registry = (0, derived_outputs_1.createFrontendModuleRegistry)(workspaceDir, layers);
     writeAuthEstablishEndpoints(workspaceDir, layers);
     writePublicEndpoints(workspaceDir, layers);
+    writeServerOptions(workspaceDir, layers);
     for (const output of derived_outputs_1.DERIVED_OUTPUTS)
         output.write(workspaceDir, registry);
 }

package/dist/module-set.d.ts

@@ -0,0 +1,16 @@
+import { type ManifestModule } from "./workspace";
+export declare const MODULE_SET_POLL_INTERVAL_MS = 3000;
+export type ModuleSetMember = Pick<ManifestModule, "name" | "path" | "priority" | "publicEndpoints" | "backendProxies">;
+export type BootstrapSecretSource = () => string | undefined;
+export interface ModuleSetFollowOptions {
+    backendUrl: string;
+    clientUrl?: string;
+    bootstrapSecret?: BootstrapSecretSource;
+    fingerprint: string;
+    onChange: () => void;
+    onUnchanged?: () => void;
+    intervalMs?: number;
+}
+export declare function moduleSetFingerprint(modules: readonly ModuleSetMember[]): string;
+export declare function followModuleSet(options: ModuleSetFollowOptions): () => void;
+export declare function reportFrontendReady(backendUrl: string, moduleNames: readonly string[], bootstrapSecret?: string): Promise<boolean>;

package/dist/module-set.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODULE_SET_POLL_INTERVAL_MS = void 0;
+exports.moduleSetFingerprint = moduleSetFingerprint;
+exports.followModuleSet = followModuleSet;
+exports.reportFrontendReady = reportFrontendReady;
+const manifest_1 = require("./manifest");
+const workspace_1 = require("./workspace");
+exports.MODULE_SET_POLL_INTERVAL_MS = 3000;
+const READY_ENDPOINT = "/dms/frontend/ready";
+const READY_TIMEOUT_MS = 5000;
+const JSON_CONTENT_TYPE = "application/json";
+function moduleSetFingerprint(modules) {
+    return JSON.stringify([...modules]
+        .sort((left, right) => left.name.localeCompare(right.name))
+        .map((module) => [
+        module.name,
+        module.path ?? "",
+        module.priority,
+        module.publicEndpoints ?? [],
+        module.backendProxies ?? [],
+    ]));
+}
+function followModuleSet(options) {
+    let isStopped = false;
+    let timer;
+    let candidate;
+    const inspect = (fingerprint) => {
+        if (fingerprint === options.fingerprint) {
+            candidate = undefined;
+            options.onUnchanged?.();
+            return;
+        }
+        if (fingerprint !== candidate) {
+            candidate = fingerprint;
+            return;
+        }
+        isStopped = true;
+        options.onChange();
+    };
+    const poll = async () => {
+        try {
+            const manifest = await (0, manifest_1.fetchManifest)(options.backendUrl, options.clientUrl, options.bootstrapSecret?.());
+            if (!isStopped && !manifest.settling) {
+                inspect(moduleSetFingerprint(manifest.modules));
+            }
+        }
+        catch {
+        }
+        if (!isStopped)
+            schedule();
+    };
+    const schedule = () => {
+        timer = setTimeout(() => void poll(), options.intervalMs ?? exports.MODULE_SET_POLL_INTERVAL_MS);
+        timer.unref();
+    };
+    schedule();
+    return () => {
+        isStopped = true;
+        if (timer)
+            clearTimeout(timer);
+    };
+}
+async function reportFrontendReady(backendUrl, moduleNames, bootstrapSecret) {
+    try {
+        const response = await fetch((0, manifest_1.backendEndpoint)(backendUrl, READY_ENDPOINT), {
+            method: "POST",
+            headers: {
+                ...(0, workspace_1.bootstrapHeaders)(bootstrapSecret),
+                "content-type": JSON_CONTENT_TYPE,
+            },
+            body: JSON.stringify({ modules: moduleNames }),
+            signal: AbortSignal.timeout(READY_TIMEOUT_MS),
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/server-process.d.ts

@@ -30,6 +30,7 @@ export interface RunServerOptions {
     env: NodeJS.ProcessEnv;
     mapPath?: PathMapper;
     onReady: (address: ServerAddress) => void;
+    stopSignal?: AbortSignal;
 }
 export declare function describeStartError(error: StartError, mapPath?: PathMapper): CliProblem;
 export declare function describeListenError(error: ListenError): CliProblem;

package/dist/server-process.js

@@ -22,6 +22,30 @@ const VIRTUAL_INTERFACE_NAME = /^(docker\d|br-|veth|virbr|cni|flannel|cali|ciliu
 const LINK_LOCAL_IPV4 = /^169\.254\./;
 const MAX_NETWORK_URLS = 3;
 const LINUX_NET_DIR = "/sys/class/net";
+function stopOnAbort(child, signal) {
+    if (!signal)
+        return;
+    const stop = () => {
+        if (child.pid === undefined || child.exitCode !== null)
+            return;
+        try {
+            if (process.platform === "win32") {
+                child.kill();
+            }
+            else {
+                process.kill(-child.pid, "SIGTERM");
+            }
+        }
+        catch {
+        }
+    };
+    if (signal.aborted) {
+        stop();
+        return;
+    }
+    signal.addEventListener("abort", stop, { once: true });
+    child.once("exit", () => signal.removeEventListener("abort", stop));
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null;
 }
@@ -128,8 +152,9 @@ function describeListenError(error) {
         reason: error.message,
     };
 }
+const LOOPBACK_ADDRESSES = new Set(["127.0.0.1", "::1"]);
 function urlHost(address) {
-    if (WILDCARD_ADDRESSES.has(address))
+    if (WILDCARD_ADDRESSES.has(address) || LOOPBACK_ADDRESSES.has(address))
         return LOCAL_HOST;
     return address.includes(":") ? `[${address}]` : address;
 }
@@ -188,7 +213,7 @@ function readyLines(address, settings, interfaces, isGuestInterface) {
     ];
 }
 async function runServer(options) {
-    const { name, script, cwd, env, mapPath, onReady } = options;
+    const { name, script, cwd, env, mapPath, onReady, stopSignal } = options;
     let readyAt;
     let listenError;
     let startError;
@@ -199,6 +224,7 @@ async function runServer(options) {
             shell: false,
             stdio: ["inherit", "inherit", "inherit", "ipc"],
         }, (child) => {
+            stopOnAbort(child, stopSignal);
             child.on("message", (message) => {
                 const ready = readReady(message);
                 if (ready && readyAt === undefined) {

package/dist/verify-source-build.d.ts

@@ -0,0 +1,11 @@
+import { type PathMapper } from "./child-output";
+import { ViteWarnings } from "./vite-output";
+export interface VerificationContext {
+    workspace: string;
+    env: NodeJS.ProcessEnv;
+    mapLine: PathMapper;
+    warnings: ViteWarnings;
+    isVerbose: boolean;
+}
+export declare function prepareTypes(context: VerificationContext): Promise<void>;
+export declare function buildAndTypeCheck(context: VerificationContext): Promise<void>;