@cms0/cms0 0.2.19 → 0.2.21

package/dist/cjs/libs/cli/browser-sidecar.cjs

@@ -6,9 +6,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.startBrowserDescriptorSidecar = startBrowserDescriptorSidecar;
 const node_http_1 = __importDefault(require("node:http"));
 const descriptor_sidecar_js_1 = require("../../descriptor-sidecar.cjs");
+function writeSchemaVersionEvent(response, version) {
+    response.write(`event: schema-version\ndata: ${JSON.stringify({ version })}\n\n`);
+}
 function startBrowserDescriptorSidecar(resolved, initialDescriptor) {
     const port = (0, descriptor_sidecar_js_1.getCms0DescriptorSidecarPort)(resolved.apiBaseUrl, resolved.apiKey);
     let currentDescriptor = initialDescriptor;
+    let currentVersion = 1;
+    const eventClients = new Set();
     const server = node_http_1.default.createServer((request, response) => {
         const requestUrl = new URL(request.url ?? "/", `http://127.0.0.1:${port}`);
         response.setHeader("Access-Control-Allow-Origin", "*");
@@ -19,6 +24,19 @@ function startBrowserDescriptorSidecar(resolved, initialDescriptor) {
             response.end();
             return;
         }
+        if (request.method === "GET" && requestUrl.pathname === "/schema-events") {
+            response.writeHead(200, {
+                "content-type": "text/event-stream; charset=utf-8",
+                "cache-control": "no-store",
+                connection: "keep-alive",
+            });
+            response.write(": cms0 browser schema sidecar\n\n");
+            eventClients.add(response);
+            request.on("close", () => {
+                eventClients.delete(response);
+            });
+            return;
+        }
         if (request.method !== "GET" || requestUrl.pathname !== "/schema-descriptor") {
             response.writeHead(404, { "content-type": "application/json; charset=utf-8" });
             response.end(JSON.stringify({ error: "Not found" }));
@@ -38,9 +56,21 @@ function startBrowserDescriptorSidecar(resolved, initialDescriptor) {
             resolve({
                 updateDescriptor(descriptor) {
                     currentDescriptor = descriptor;
+                    currentVersion += 1;
+                    for (const client of [...eventClients]) {
+                        if (client.destroyed || client.writableEnded) {
+                            eventClients.delete(client);
+                            continue;
+                        }
+                        writeSchemaVersionEvent(client, currentVersion);
+                    }
                 },
                 close() {
                     return new Promise((closeResolve, closeReject) => {
+                        for (const client of eventClients) {
+                            client.end();
+                        }
+                        eventClients.clear();
                         server.close((error) => {
                             if (error) {
                                 closeReject(error);

package/dist/cjs/libs/cli/config-loader.cjs

@@ -46,6 +46,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const url_1 = require("url");
 const crypto_1 = __importDefault(require("crypto"));
+const module_1 = require("module");
 const DEFAULT_CONFIG_BASENAMES = [
     "cms0.config.ts",
     "cms0.config.js",
@@ -145,9 +146,7 @@ function resolvePaths(cfgPath, config) {
     }
     const baseDir = path_1.default.dirname(cfgPath);
     const packageJsonPath = findNearestPackageJson(cfgPath);
-    const projectRoot = packageJsonPath
-        ? path_1.default.dirname(packageJsonPath)
-        : baseDir;
+    const projectRoot = packageJsonPath ? path_1.default.dirname(packageJsonPath) : baseDir;
     const entryFile = path_1.default.resolve(baseDir, config.entry);
     const tsconfigPath = config.tsconfig
         ? path_1.default.resolve(baseDir, config.tsconfig)
@@ -178,7 +177,7 @@ function findTsConfig(entryFile) {
     return undefined;
 }
 async function transpileTsModuleToTemp(tsPath, format) {
-    const ts = await Promise.resolve().then(() => __importStar(require("typescript")));
+    const ts = await loadTypescriptCompiler(tsPath);
     const source = fs_1.default.readFileSync(tsPath, "utf8");
     const transpiled = ts.transpileModule(source, {
         compilerOptions: {
@@ -204,3 +203,45 @@ function cleanupTempModule(tempPath) {
         // ignore cleanup failures
     }
 }
+async function loadTypescriptCompiler(tsPath) {
+    const attemptedErrors = [];
+    const manifestCandidates = [
+        findNearestPackageJson(tsPath),
+        path_1.default.join(process.cwd(), "package.json"),
+    ].filter((candidate) => Boolean(candidate && fs_1.default.existsSync(candidate)));
+    for (const manifest of manifestCandidates) {
+        try {
+            const resolver = (0, module_1.createRequire)(manifest);
+            const mod = resolver("typescript");
+            return normalizeTypescriptModule(mod);
+        }
+        catch (error) {
+            attemptedErrors.push(error);
+        }
+    }
+    try {
+        const mod = (0, module_1.createRequire)(path_1.default.resolve("package.json"))("typescript");
+        return normalizeTypescriptModule(mod);
+    }
+    catch (error) {
+        attemptedErrors.push(error);
+    }
+    try {
+        const mod = await Promise.resolve().then(() => __importStar(require("typescript")));
+        return normalizeTypescriptModule(mod);
+    }
+    catch (error) {
+        attemptedErrors.push(error);
+    }
+    throw new AggregateError(attemptedErrors, 'cms0: Unable to resolve the "typescript" package required to load cms0.config.* files. Ensure it is installed in your project.');
+}
+function normalizeTypescriptModule(mod) {
+    if (mod && typeof mod.transpileModule === "function") {
+        return mod;
+    }
+    const candidate = mod?.default;
+    if (candidate && typeof candidate.transpileModule === "function") {
+        return candidate;
+    }
+    throw new Error("cms0: resolved 'typescript' module does not provide transpileModule");
+}

package/dist/cjs/libs/cli/publisher.cjs

@@ -20,6 +20,17 @@ function shouldRetryPublishError(error) {
     }
     return true;
 }
+function trimTrailingSlashes(value) {
+    return value.replace(/\/+$/, "");
+}
+function buildSchemaPublishUrl(baseUrl) {
+    const normalized = trimTrailingSlashes(baseUrl);
+    return `${normalized}/schema`;
+}
+function buildHealthUrls(baseUrl) {
+    const normalized = trimTrailingSlashes(baseUrl);
+    return [`${normalized}/health`];
+}
 const startSpinner = (label) => {
     if (!process.stdout.isTTY) {
         console.log(`${label}...`);
@@ -47,7 +58,7 @@ const startSpinner = (label) => {
     };
 };
 async function waitForAdminReady(baseUrl, headers) {
-    const healthUrl = `${baseUrl.replace(/\/$/, "")}/ok`;
+    const healthUrls = buildHealthUrls(baseUrl);
     const maxWaitMs = 30_000;
     const startedAt = Date.now();
     const spinner = startSpinner("cms0: waiting for admin to reload");
@@ -55,15 +66,17 @@ async function waitForAdminReady(baseUrl, headers) {
     let attempt = 0;
     while (Date.now() - startedAt < maxWaitMs) {
         attempt += 1;
-        try {
-            const res = await fetch(healthUrl, { headers });
-            if (res.ok) {
-                spinner.stop("cms0: admin ready");
-                return true;
+        for (const healthUrl of healthUrls) {
+            try {
+                const res = await fetch(healthUrl, { headers });
+                if (res.ok) {
+                    spinner.stop("cms0: admin ready");
+                    return true;
+                }
+            }
+            catch {
+                // ignore transient errors during restart
             }
-        }
-        catch {
-            // ignore transient errors during restart
         }
         await sleep(Math.min(500 + attempt * 250, 2000));
     }
@@ -84,7 +97,7 @@ async function publishDescriptor(resolved, descriptor) {
         if (resolved.apiKey) {
             headers["Authorization"] = `Bearer ${resolved.apiKey}`;
         }
-        const target = `${resolved.apiBaseUrl.replace(/\/$/, "")}/schema`;
+        const target = buildSchemaPublishUrl(resolved.apiBaseUrl);
         const maxAttempts = 5;
         for (let attempt = 1; attempt <= maxAttempts; attempt++) {
             try {
@@ -96,7 +109,7 @@ async function publishDescriptor(resolved, descriptor) {
                 if (!res.ok) {
                     throw new PublishHttpError(res.status);
                 }
-                const ready = await waitForAdminReady(resolved.apiBaseUrl.replace(/\/$/, ""), headers);
+                const ready = await waitForAdminReady(trimTrailingSlashes(resolved.apiBaseUrl), headers);
                 if (!ready) {
                     console.warn("cms0: publish succeeded, but admin did not become healthy in time.");
                 }

package/dist/cjs/schema-descriptors.cjs

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.schemaDescriptor = void 0;
 exports.readLocalSchemaDescriptor = readLocalSchemaDescriptor;
+exports.invalidateBrowserSchemaDescriptorCache = invalidateBrowserSchemaDescriptorCache;
+exports.ensureBrowserSchemaDescriptorDevSubscription = ensureBrowserSchemaDescriptorDevSubscription;
 exports.resolveBrowserSchemaDescriptor = resolveBrowserSchemaDescriptor;
 exports.getActiveSchemaDescriptor = getActiveSchemaDescriptor;
 exports.syncActiveSchemaDescriptorGlobals = syncActiveSchemaDescriptorGlobals;
@@ -14,6 +16,7 @@ const LOCAL_DESCRIPTOR_RELATIVE_SEGMENTS = [
 ];
 let cachedLocalDescriptor = null;
 const browserDescriptorPromiseCache = new Map();
+const browserDescriptorSubscriptionCache = new Map();
 exports.schemaDescriptor = schema_descriptor_1.schemaDescriptor;
 function setSchemaDescriptorGlobals(descriptor) {
     const globals = globalThis;
@@ -205,6 +208,52 @@ function createBrowserDescriptorFetchError(sidecarUrl, reason) {
     const details = reason ? ` ${reason}` : "";
     return new Error(`cms0: failed to load the browser schema descriptor from ${sidecarUrl}.${details} Start the cms0 sidecar before calling cms0() in the browser.`);
 }
+function clearBrowserSchemaDescriptorGlobals() {
+    const globals = globalThis;
+    delete globals.__CMS0_SCHEMA_DESCRIPTOR__;
+    delete globals.__CMS0_CANVAS_SCHEMA_DESCRIPTOR__;
+}
+function invalidateBrowserSchemaDescriptorCache(baseUrl, apiKey) {
+    clearBrowserSchemaDescriptorGlobals();
+    browserDescriptorPromiseCache.delete((0, descriptor_sidecar_js_1.getCms0DescriptorSidecarUrl)(baseUrl, apiKey));
+}
+function ensureBrowserSchemaDescriptorDevSubscription(baseUrl, apiKey, onInvalidate) {
+    if (typeof window === "undefined")
+        return;
+    if (readBundledBrowserDescriptor())
+        return;
+    if (typeof globalThis.EventSource !== "function")
+        return;
+    const eventsUrl = (0, descriptor_sidecar_js_1.getCms0DescriptorSidecarEventsUrl)(baseUrl, apiKey);
+    let subscription = browserDescriptorSubscriptionCache.get(eventsUrl);
+    if (!subscription) {
+        const listeners = new Set();
+        const source = new globalThis.EventSource(eventsUrl);
+        const handleSchemaVersion = () => {
+            invalidateBrowserSchemaDescriptorCache(baseUrl, apiKey);
+            for (const listener of listeners) {
+                listener();
+            }
+        };
+        const handleError = () => {
+            const activeSubscription = browserDescriptorSubscriptionCache.get(eventsUrl);
+            if (activeSubscription?.source === source) {
+                browserDescriptorSubscriptionCache.delete(eventsUrl);
+            }
+            source.close();
+        };
+        source.addEventListener("schema-version", handleSchemaVersion);
+        source.onerror = handleError;
+        subscription = {
+            listeners,
+            source,
+        };
+        browserDescriptorSubscriptionCache.set(eventsUrl, subscription);
+    }
+    if (onInvalidate) {
+        subscription.listeners.add(onInvalidate);
+    }
+}
 async function resolveBrowserSchemaDescriptor(baseUrl, apiKey) {
     const injectedDescriptor = readGlobalSchemaDescriptor();
     if (injectedDescriptor) {

package/dist/esm/custom-types/registry.js

@@ -8,6 +8,12 @@ const primitive = (type) => ({
 const fileFieldDescriptors = {
     name: primitive("string"),
     filename: primitive("string"),
+    storageKey: {
+        kind: "primitive",
+        type: "string",
+        optional: true,
+        nullable: false,
+    },
     extension: primitive("string"),
     mimeType: primitive("string"),
     size: primitive("number"),

package/dist/esm/descriptor-sidecar.js

@@ -13,4 +13,8 @@ function getCms0DescriptorSidecarUrl(baseUrl, apiKey) {
     const port = getCms0DescriptorSidecarPort(baseUrl, apiKey);
     return `http://127.0.0.1:${port}/schema-descriptor`;
 }
-export { getCms0DescriptorSidecarPort, getCms0DescriptorSidecarUrl, hashCms0SidecarSeed, };
+function getCms0DescriptorSidecarEventsUrl(baseUrl, apiKey) {
+    const port = getCms0DescriptorSidecarPort(baseUrl, apiKey);
+    return `http://127.0.0.1:${port}/schema-events`;
+}
+export { getCms0DescriptorSidecarPort, getCms0DescriptorSidecarUrl, getCms0DescriptorSidecarEventsUrl, hashCms0SidecarSeed, };