@antelopejs/dms-frontend 0.7.1 → 0.8.0

package/dist/layers.js

@@ -1,57 +1,17 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertLayerPathsServed = assertLayerPathsServed;
-exports.assertCachedArchivesExist = assertCachedArchivesExist;
 exports.readLayerPackage = readLayerPackage;
 exports.buildLayersFromPaths = buildLayersFromPaths;
-exports.downloadAndExtractLayers = downloadAndExtractLayers;
-exports.buildLayersFromCache = buildLayersFromCache;
 exports.getLayerSafeName = getLayerSafeName;
 exports.getLayerWorkspacePath = getLayerWorkspacePath;
 const node_fs_1 = require("node:fs");
-const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
-const node_stream_1 = require("node:stream");
-const consumers_1 = require("node:stream/consumers");
 const cli_1 = require("@antelopejs/core/cli");
 const manifest_1 = require("./manifest");
-const fs_sync_1 = require("./fs-sync");
 const config_1 = require("./config");
 const output_1 = require("./output");
-const BUILD_FIX = "A remote or production backend never sends them: use `ajs dms build` against it";
+const BUILD_FIX = "A remote or production backend never sends them: build the frontend from the project instead, with `ajs dms build`";
 function assertLayerPathsServed(modules, backendUrl, { bootstrapSecret, cache } = {}) {
     const pathless = modules.filter((mod) => !mod.path);
     if (pathless.length === 0)
@@ -87,17 +47,6 @@ function assertLayerPathsServed(modules, backendUrl, { bootstrapSecret, cache }
         fixes: [fix, BUILD_FIX],
     });
 }
-function assertCachedArchivesExist(modules, cacheDir, fetchedAt) {
-    const present = new Set((0, node_fs_1.readdirSync)(cacheDir));
-    const missing = modules.filter((mod) => !present.has(mod.archiveName));
-    if (missing.length === 0)
-        return;
-    throw new cli_1.CliError({
-        title: `The cached layers archive is missing entries listed in the manifest${fetchedAt ? ` (fetched ${(0, output_1.formatAge)(fetchedAt)})` : ""}`,
-        fixes: ["Run once with the backend reachable to download the layers again"],
-        details: missing.map((mod) => `${mod.name}: ${mod.archiveName}`),
-    });
-}
 function sortModulesByPriority(modules) {
     return [...modules].sort((a, b) => b.priority - a.priority);
 }
@@ -134,49 +83,6 @@ function resolveLayer(layerPath, mod) {
 function buildLayersFromPaths(modules) {
     return sortModulesByPriority(modules).map((mod) => resolveLayer(mod.path, mod));
 }
-async function downloadAndExtractLayers(backendUrl, packUrl, cacheDir, force, bootstrapSecret) {
-    const url = (0, manifest_1.backendEndpoint)(backendUrl, packUrl);
-    const response = await (0, manifest_1.fetchFromBackend)(backendUrl, url, bootstrapSecret);
-    if (!response.ok) {
-        throw new manifest_1.BackendResponseError("the layers archive", url, response);
-    }
-    if (!response.body) {
-        throw new Error(`The layers archive from ${(0, manifest_1.displayUrl)(url)} came without a body`);
-    }
-    const modulesBlob = await (0, consumers_1.buffer)(node_stream_1.Readable.fromWeb(response.body));
-    const { Open } = await Promise.resolve().then(() => __importStar(require("unzipper")));
-    const cacheExists = (0, node_fs_1.existsSync)(cacheDir);
-    if (force || !cacheExists) {
-        if (cacheExists) {
-            (0, node_fs_1.rmSync)(cacheDir, { recursive: true, force: true });
-        }
-        await (await Open.buffer(modulesBlob)).extract({ path: cacheDir });
-        return;
-    }
-    const tempDir = `${cacheDir}_temp`;
-    if ((0, node_fs_1.existsSync)(tempDir)) {
-        (0, node_fs_1.rmSync)(tempDir, { recursive: true, force: true });
-    }
-    await (await Open.buffer(modulesBlob)).extract({ path: tempDir });
-    const tempEntries = (0, node_fs_1.readdirSync)(tempDir);
-    for (const entry of tempEntries) {
-        (0, fs_sync_1.syncDirectories)((0, node_path_1.join)(tempDir, entry), (0, node_path_1.join)(cacheDir, entry));
-    }
-    (0, node_fs_1.rmSync)(tempDir, { recursive: true, force: true });
-}
-async function buildLayersFromCache(modules, cacheDir) {
-    if (!(0, node_fs_1.existsSync)(cacheDir))
-        return [];
-    const layerFiles = await (0, promises_1.readdir)(cacheDir);
-    const layers = [];
-    for (const mod of sortModulesByPriority(modules)) {
-        if (!layerFiles.includes(mod.archiveName))
-            continue;
-        const layerPath = (0, node_path_1.join)(cacheDir, mod.archiveName);
-        layers.push(resolveLayer(layerPath, mod));
-    }
-    return layers;
-}
 function getLayerSafeName(layer) {
     if (layer.packageName) {
         return layer.packageName.replace(/^@/, "").replace(/\//g, "__");

package/dist/manifest.d.ts

@@ -18,6 +18,7 @@ export declare class ManifestRefusedError extends CliError {
 }
 export declare function describeManifestVersion(version: unknown): CliProblem;
 export declare class BackendResponseError extends CliError {
+    readonly status: number;
     constructor(subject: string, url: string | URL, response: Pick<Response, "status" | "statusText">);
 }
 export declare class NoCachedManifestError extends CliError {
@@ -29,19 +30,18 @@ export interface ManifestCacheEntry {
     fetchedAt: string;
 }
 export declare function readCachedManifest(workspaceDir: string): ManifestCacheEntry | undefined;
-export declare function writeCachedManifest(workspaceDir: string, manifest: Manifest, privateValues: PrivateValues, fetchedAt?: string): void;
-export type PrivateValues = "keep" | "drop";
-export type ManifestCacheUse = "fallback" | "offline" | "never";
+export declare function writeCachedManifest(workspaceDir: string, manifest: Manifest, fetchedAt?: string): void;
+export type ManifestCacheUse = "fallback" | "offline";
+export interface ManifestRequest {
+    clientUrl?: string;
+    bootstrapSecret?: string;
+}
 export interface ResolvedManifest {
     manifest: Manifest;
     fromCache: boolean;
     fetchedAt?: string;
 }
-export declare function resolveManifest(workspaceDir: string, backendUrl: string, cacheUse: ManifestCacheUse, { clientUrl, bootstrapSecret, privateValues, }?: {
-    clientUrl?: string;
-    bootstrapSecret?: string;
-    privateValues?: PrivateValues;
-}): Promise<ResolvedManifest>;
+export declare function resolveManifest(workspaceDir: string, backendUrl: string, cacheUse: ManifestCacheUse, { clientUrl, bootstrapSecret }?: ManifestRequest): Promise<ResolvedManifest>;
 export declare function assertCachedLayerPathsExist(modules: ServedWithPath[], fetchedAt?: string): void;
 export type ServedWithPath = ManifestModule & {
     path: string;

package/dist/manifest.js

@@ -14,7 +14,6 @@ const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const cli_1 = require("@antelopejs/core/cli");
 const config_1 = require("./config");
-const private_values_1 = require("./private-values");
 const output_1 = require("./output");
 const workspace_1 = require("./workspace");
 class ManifestUnauthorizedError extends cli_1.CliError {
@@ -162,6 +161,7 @@ class BackendResponseError extends cli_1.CliError {
             };
         super(problem);
         this.name = "BackendResponseError";
+        this.status = status;
     }
 }
 exports.BackendResponseError = BackendResponseError;
@@ -194,10 +194,7 @@ async function fetchManifest(backendUrl, clientUrl, bootstrapSecret) {
     if (incompatible.length) {
         throw new ManifestRefusedError(`Frontend manifest contains incompatible renderer modules: ${incompatible.map((module) => module.name).join(", ")}`);
     }
-    const resolved = {
-        pack: manifest.archive,
-        modules: manifest.modules,
-    };
+    const resolved = { modules: manifest.modules };
     if (manifest.settling)
         resolved.settling = true;
     return resolved;
@@ -217,19 +214,15 @@ function readCachedManifest(workspaceDir) {
         return undefined;
     }
 }
-function writeCachedManifest(workspaceDir, manifest, privateValues, fetchedAt = new Date().toISOString()) {
+function writeCachedManifest(workspaceDir, manifest, fetchedAt = new Date().toISOString()) {
     const entry = { manifest, fetchedAt };
-    const write = privateValues === "keep" ? config_1.writeSecretBearingFile : config_1.writeShareableFile;
-    write((0, node_path_1.join)(workspaceDir, MANIFEST_CACHE_FILE), `${JSON.stringify(entry, null, 2)}\n`);
+    (0, config_1.writeSecretBearingFile)((0, node_path_1.join)(workspaceDir, MANIFEST_CACHE_FILE), `${JSON.stringify(entry, null, 2)}\n`);
 }
-async function resolveManifest(workspaceDir, backendUrl, cacheUse, { clientUrl, bootstrapSecret, privateValues = "keep", } = {}) {
+async function resolveManifest(workspaceDir, backendUrl, cacheUse, { clientUrl, bootstrapSecret } = {}) {
     if (cacheUse !== "offline") {
         try {
-            const served = await fetchManifest(backendUrl, clientUrl, bootstrapSecret);
-            const manifest = privateValues === "keep"
-                ? served
-                : { ...served, modules: (0, private_values_1.withoutPrivateValues)(served.modules) };
-            writeCachedManifest(workspaceDir, manifest, privateValues);
+            const manifest = await fetchManifest(backendUrl, clientUrl, bootstrapSecret);
+            writeCachedManifest(workspaceDir, manifest);
             return { manifest, fromCache: false };
         }
         catch (err) {
@@ -240,37 +233,20 @@ async function resolveManifest(workspaceDir, backendUrl, cacheUse, { clientUrl,
             const cached = readCachedManifest(workspaceDir);
             if (!cached)
                 throw err;
-            if (cacheUse === "never")
-                throw cacheNotUsed(err, backendUrl, cached);
-            return fromCachedEntry(workspaceDir, cached, privateValues);
+            return fromCachedEntry(cached);
         }
     }
     const cached = readCachedManifest(workspaceDir);
     if (!cached)
         throw new NoCachedManifestError();
-    return fromCachedEntry(workspaceDir, cached, privateValues);
-}
-function cacheNotUsed(failure, backendUrl, cached) {
-    const problem = failure instanceof cli_1.CliError
-        ? failure.problem
-        : { title: errorMessage(failure) };
-    const cache = `A manifest${(0, output_1.cachedAge)(cached.fetchedAt)} exists; a build uses it only with --offline.`;
-    return new cli_1.CliError({
-        ...problem,
-        reason: problem.reason ? `${problem.reason} ${cache}` : cache,
-        fixes: [
-            ...(problem.fixes ?? []),
-            `Or build from the cache on purpose: ajs dms build -b ${displayUrl(backendUrl)} --offline`,
-        ],
-    }, { cause: failure });
+    return fromCachedEntry(cached);
 }
-function fromCachedEntry(workspaceDir, cached, privateValues) {
-    let { manifest } = cached;
-    if (privateValues === "drop") {
-        manifest = { ...manifest, modules: (0, private_values_1.withoutPrivateValues)(manifest.modules) };
-        writeCachedManifest(workspaceDir, manifest, "drop", cached.fetchedAt);
-    }
-    return { manifest, fromCache: true, fetchedAt: cached.fetchedAt };
+function fromCachedEntry(cached) {
+    return {
+        manifest: cached.manifest,
+        fromCache: true,
+        fetchedAt: cached.fetchedAt,
+    };
 }
 function assertCachedLayerPathsExist(modules, fetchedAt) {
     const missing = modules.filter((mod) => !(0, node_fs_1.existsSync)(mod.path));

package/dist/materialize.js

@@ -70,6 +70,12 @@ function copyLayerSource(src, dest) {
         filter: (srcPath) => !(0, fs_sync_1.isBlocklistedCopyPath)(src, srcPath),
     });
     sanitizeLayerPackage((0, node_path_1.join)(dest, "package.json"));
+    sanitizeBuildDeclaration((0, node_path_1.join)(dest, config_1.FRONTEND_BUILD_ENTRY));
+}
+function sanitizeBuildDeclaration(file) {
+    if (!(0, node_fs_1.existsSync)(file))
+        return;
+    (0, fs_sync_1.applyContent)((0, fs_sync_1.sanitizedBuildDeclaration)((0, node_fs_1.readFileSync)(file, "utf-8")), file);
 }
 function sanitizeLayerPackage(pkgPath) {
     if (!(0, node_fs_1.existsSync)(pkgPath))

package/dist/module-set.d.ts

@@ -1,5 +1,8 @@
 import { type ManifestModule } from "./workspace";
 export declare const MODULE_SET_POLL_INTERVAL_MS = 3000;
+export declare const OWN_RELEASE: {
+    version: string;
+};
 export type ModuleSetMember = Pick<ManifestModule, "name" | "path" | "priority" | "publicEndpoints" | "backendProxies">;
 export type BootstrapSecretSource = () => string | undefined;
 export interface ModuleSetFollowOptions {
@@ -13,15 +16,14 @@ export interface ModuleSetFollowOptions {
 }
 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>;
-export type BuildDrift = {
-    status: "matches";
-    served: string;
-} | {
-    status: "drifted";
-    served: string;
-} | {
-    status: "unknown";
-    reason: string;
-};
-export declare function compareWithBackend(backendUrl: string, builtDigest: string, digestOf: (modules: readonly ManifestModule[]) => string, bootstrapSecret?: string): Promise<BuildDrift>;
+export interface ServedModule {
+    name: string;
+    version?: string;
+}
+export interface ReadyRetry {
+    firstDelayMs: number;
+    maxDelayMs: number;
+    timeoutMs: number;
+}
+export declare function reportFrontendReady(backendUrl: string, modules: readonly ServedModule[], bootstrapSecret?: string): Promise<boolean>;
+export declare function reportFrontendReadyOnceAnswered(backendUrl: string, modules: readonly ServedModule[], bootstrapSecret?: string, retry?: ReadyRetry): Promise<boolean>;

package/dist/module-set.js

@@ -1,17 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MODULE_SET_POLL_INTERVAL_MS = void 0;
+exports.OWN_RELEASE = exports.MODULE_SET_POLL_INTERVAL_MS = void 0;
 exports.moduleSetFingerprint = moduleSetFingerprint;
 exports.followModuleSet = followModuleSet;
 exports.reportFrontendReady = reportFrontendReady;
-exports.compareWithBackend = compareWithBackend;
+exports.reportFrontendReadyOnceAnswered = reportFrontendReadyOnceAnswered;
+const promises_1 = require("node:timers/promises");
 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";
-const OWN_RELEASE = require("../package.json");
+exports.OWN_RELEASE = require("../package.json");
 function moduleSetFingerprint(modules) {
     return JSON.stringify([...modules]
         .sort((left, right) => left.name.localeCompare(right.name))
@@ -63,40 +64,47 @@ function followModuleSet(options) {
             clearTimeout(timer);
     };
 }
-async function reportFrontendReady(backendUrl, moduleNames, bootstrapSecret) {
+const READY_WAKE_TIMEOUT_MS = 90_000;
+const READY_FIRST_RETRY_MS = 2_000;
+const READY_MAX_RETRY_MS = 60_000;
+const SERVER_ERROR = 500;
+const DEFAULT_READY_RETRY = {
+    firstDelayMs: READY_FIRST_RETRY_MS,
+    maxDelayMs: READY_MAX_RETRY_MS,
+    timeoutMs: READY_WAKE_TIMEOUT_MS,
+};
+async function postReadyReport(backendUrl, modules, bootstrapSecret, timeoutMs) {
+    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, version: exports.OWN_RELEASE.version }),
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    await response.body?.cancel();
+    return response;
+}
+async function reportFrontendReady(backendUrl, modules, 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,
-                version: OWN_RELEASE.version,
-            }),
-            signal: AbortSignal.timeout(READY_TIMEOUT_MS),
-        });
+        const response = await postReadyReport(backendUrl, modules, bootstrapSecret, READY_TIMEOUT_MS);
         return response.ok;
     }
     catch {
         return false;
     }
 }
-const DRIFT_CHECK_TIMEOUT_MS = 10_000;
-async function compareWithBackend(backendUrl, builtDigest, digestOf, bootstrapSecret) {
-    try {
-        const manifest = await Promise.race([
-            (0, manifest_1.fetchManifest)(backendUrl, undefined, bootstrapSecret),
-            new Promise((_resolve, reject) => setTimeout(() => reject(new Error("the backend did not answer in time")), DRIFT_CHECK_TIMEOUT_MS).unref()),
-        ]);
-        const served = digestOf(manifest.modules);
-        return { status: served === builtDigest ? "matches" : "drifted", served };
-    }
-    catch (error) {
-        return {
-            status: "unknown",
-            reason: error instanceof Error ? error.message : String(error),
-        };
+async function reportFrontendReadyOnceAnswered(backendUrl, modules, bootstrapSecret, retry = DEFAULT_READY_RETRY) {
+    for (let delayMs = retry.firstDelayMs;;) {
+        try {
+            const response = await postReadyReport(backendUrl, modules, bootstrapSecret, retry.timeoutMs);
+            if (response.status < SERVER_ERROR)
+                return response.ok;
+        }
+        catch {
+        }
+        await (0, promises_1.setTimeout)(delayMs, undefined, { ref: false });
+        delayMs = Math.min(retry.maxDelayMs, delayMs * 2);
     }
 }

package/dist/private-values.d.ts

@@ -1,5 +1,5 @@
-import type { FrontendModuleOptions, ManifestModule } from "./workspace";
-export declare function withoutPrivateValues(modules: readonly ManifestModule[]): ManifestModule[];
+import type { FrontendModuleOptions } from "./workspace";
+export declare function emptiedOptions(options: FrontendModuleOptions): FrontendModuleOptions;
 export declare const PRIVATE_OPTIONS_VARIABLE = "DMS_PRIVATE_OPTIONS";
 export interface UnfilledPrivateValue {
     module: string;

package/dist/private-values.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PRIVATE_OPTIONS_VARIABLE = void 0;
-exports.withoutPrivateValues = withoutPrivateValues;
+exports.emptiedOptions = emptiedOptions;
 exports.parsePrivateOptions = parsePrivateOptions;
 exports.unfilledPrivateValues = unfilledPrivateValues;
 const config_1 = require("./config");
@@ -17,11 +17,6 @@ function emptied(value) {
 function emptiedOptions(options) {
     return Object.fromEntries(Object.entries(options).map(([key, value]) => [key, emptied(value)]));
 }
-function withoutPrivateValues(modules) {
-    return modules.map((module) => module.privateOptions
-        ? { ...module, privateOptions: emptiedOptions(module.privateOptions) }
-        : { ...module });
-}
 exports.PRIVATE_OPTIONS_VARIABLE = "DMS_PRIVATE_OPTIONS";
 function isOptions(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);

package/dist/project-modules.d.ts

@@ -0,0 +1,46 @@
+import type { BackendProxyDeclaration, FrontendModuleOptions, PublicEndpointDeclaration, ResolvedLayer } from "./workspace";
+export declare const FRONTEND_DECLARATION_FIELD = "dmsFrontend";
+export interface FrontendRegistration {
+    name: string;
+    sourcePath: string;
+    renderer: {
+        name: string;
+        version: string;
+    };
+    priority?: number;
+    configKey?: string;
+    options?: FrontendModuleOptions;
+    privateOptions?: FrontendModuleOptions;
+    authEstablishEndpoints?: string[];
+    publicEndpoints?: PublicEndpointDeclaration[];
+    backendProxies?: BackendProxyDeclaration[];
+}
+export interface FrontendModuleContext {
+    dev: boolean;
+}
+interface ModuleSource {
+    type: string;
+    path?: string;
+    package?: string;
+}
+interface ProjectModule {
+    source: ModuleSource;
+    config: unknown;
+}
+interface ProjectConfig {
+    cacheFolder: string;
+    modules: Record<string, ProjectModule>;
+}
+export interface ProjectFrontendModule {
+    layer: ResolvedLayer;
+    version?: string;
+}
+export interface ProjectModulesOptions {
+    projectDir: string;
+    environment: string;
+    dev?: boolean;
+}
+export declare function loadProjectConfig(projectDir: string, environment: string): Promise<ProjectConfig>;
+export declare function readShippingVersion(sourcePath: string): string | undefined;
+export declare function readProjectFrontendModules(options: ProjectModulesOptions): Promise<ProjectFrontendModule[]>;
+export {};