@vibes.diy/vibe-runtime 12.1.1 → 12.1.2

package/parse-backend-config.js

@@ -1,13 +1,13 @@
 export const MIN_INTERVAL_MS = 5_000;
 export const MAX_INTERVAL_MS = 3_600_000;
 const HANDLER_NAMES = ["fetch", "scheduled", "onChange"];
-function exportsName(source, name) {
+function exportsName(code, name) {
     const decl = new RegExp(`export\\s+(?:async\\s+)?(?:function\\s+${name}\\b|(?:const|let|var)\\s+${name}\\b)`);
-    if (decl.test(source))
+    if (decl.test(code))
         return true;
     const listPattern = /export\s*\{([^}]*)\}/g;
     let m;
-    while ((m = listPattern.exec(source)) !== null) {
+    while ((m = listPattern.exec(code)) !== null) {
         const inner = m[1];
         const bareOrAliased = new RegExp(`(?:\\bas\\s+${name}\\b|(?:^|,)\\s*${name}\\s*(?:,|$))`);
         if (bareOrAliased.test(inner))
@@ -25,6 +25,10 @@ function parseDurationMs(raw) {
     const mult = m[2] === "s" ? 1_000 : m[2] === "m" ? 60_000 : 3_600_000;
     return n * mult;
 }
+const sliceAligned = (a, from, to) => ({
+    code: a.code.slice(from, to),
+    text: a.text.slice(from, to),
+});
 function skipQuoted(src, start, quote) {
     let i = start + 1;
     while (i < src.length) {
@@ -124,23 +128,6 @@ const REGEX_PRECEDING_KEYWORDS = new Set([
     "await",
     "throw",
 ]);
-function regexAllowedAt(chars, idx) {
-    let i = idx - 1;
-    while (i >= 0 && /\s/.test(chars[i]))
-        i--;
-    if (i < 0)
-        return true;
-    const ch = chars[i];
-    if (ch === ")" || ch === "]")
-        return false;
-    if (/[A-Za-z0-9_$]/.test(ch)) {
-        let j = i;
-        while (j >= 0 && /[A-Za-z0-9_$]/.test(chars[j]))
-            j--;
-        return REGEX_PRECEDING_KEYWORDS.has(chars.slice(j + 1, i + 1).join(""));
-    }
-    return true;
-}
 function maskNonCode(source) {
     const chars = source.split("");
     const blank = (from, to) => {
@@ -149,6 +136,8 @@ function maskNonCode(source) {
                 chars[k] = " ";
         }
     };
+    let prevIsValue = false;
+    let prevIsDot = false;
     let i = 0;
     while (i < source.length) {
         const ch = source[i];
@@ -171,82 +160,149 @@ function maskNonCode(source) {
         }
         if (ch === '"' || ch === "'") {
             i = skipQuoted(source, i, ch);
+            prevIsValue = true;
+            prevIsDot = false;
             continue;
         }
         if (ch === "`") {
             const end = skipTemplate(source, i);
             blank(i, end);
             i = end;
+            prevIsValue = true;
+            prevIsDot = false;
             continue;
         }
-        if (ch === "/" && regexAllowedAt(chars, i)) {
-            const end = skipRegex(source, i);
-            if (end !== undefined) {
-                blank(i, end);
-                i = end;
-                continue;
+        if (ch === "/") {
+            if (!prevIsValue) {
+                const end = skipRegex(source, i);
+                if (end !== undefined) {
+                    blank(i, end);
+                    i = end;
+                    prevIsValue = true;
+                    prevIsDot = false;
+                    continue;
+                }
             }
+            i++;
+            prevIsValue = false;
+            prevIsDot = false;
+            continue;
+        }
+        if (/[A-Za-z0-9_$]/.test(ch)) {
+            let j = i;
+            while (j < source.length && /[A-Za-z0-9_$]/.test(source[j]))
+                j++;
+            prevIsValue = prevIsDot || !REGEX_PRECEDING_KEYWORDS.has(source.slice(i, j));
+            prevIsDot = false;
+            i = j;
+            continue;
         }
+        if (ch === ")" || ch === "]") {
+            prevIsValue = true;
+            prevIsDot = false;
+            i++;
+            continue;
+        }
+        if ((ch === "+" && source[i + 1] === "+") || (ch === "-" && source[i + 1] === "-")) {
+            prevIsValue = true;
+            prevIsDot = false;
+            i += 2;
+            continue;
+        }
+        if (/\s/.test(ch)) {
+            i++;
+            continue;
+        }
+        prevIsValue = false;
+        prevIsDot = ch === ".";
         i++;
     }
     return chars.join("");
 }
-function hasLiveKey(masked, key) {
-    const at = new RegExp(`\\b${key}\\s*:`, "y");
-    for (let i = 0; i < masked.length; i++) {
+function blankStrings(masked) {
+    const chars = masked.split("");
+    let i = 0;
+    while (i < masked.length) {
         const ch = masked[i];
         if (ch === '"' || ch === "'") {
-            i = skipQuoted(masked, i, ch) - 1;
+            const end = skipQuoted(masked, i, ch);
+            const interiorEnd = masked[end - 1] === ch ? end - 1 : end;
+            for (let k = i + 1; k < interiorEnd && k < chars.length; k++) {
+                if (chars[k] !== "\n")
+                    chars[k] = " ";
+            }
+            i = end;
             continue;
         }
-        at.lastIndex = i;
-        if (at.exec(masked) !== null)
+        i++;
+    }
+    return chars.join("");
+}
+function viewsOf(source) {
+    const text = maskNonCode(source);
+    return { text, code: blankStrings(text) };
+}
+function skipSpace(code, from) {
+    let i = from;
+    while (i < code.length && /\s/.test(code[i]))
+        i++;
+    return i;
+}
+function quotedSpan(code, start) {
+    const quote = code[start];
+    let i = start + 1;
+    while (i < code.length && code[i] !== quote) {
+        if (code[i] === "\n")
+            return undefined;
+        i++;
+    }
+    return i < code.length ? { end: i + 1 } : undefined;
+}
+function mentionsKey(view, key) {
+    if (new RegExp(`\\b${key}\\s*:`).test(view.code))
+        return true;
+    const code = view.code;
+    for (let i = 0; i < code.length; i++) {
+        if (code[i] !== '"' && code[i] !== "'")
+            continue;
+        const span = quotedSpan(code, i);
+        if (span === undefined)
+            continue;
+        if (view.text.slice(i + 1, span.end - 1) === key && code[skipSpace(code, span.end)] === ":")
             return true;
+        i = span.end - 1;
     }
     return false;
 }
-function sliceBalancedObject(source, openIdx) {
+function balancedObjectEnd(code, openIdx) {
     let depth = 0;
-    let quote = null;
-    for (let i = openIdx; i < source.length; i++) {
-        const ch = source[i];
-        if (quote !== null) {
-            if (ch === "\\") {
-                i++;
-                continue;
-            }
-            if (ch === quote)
-                quote = null;
-            continue;
-        }
-        if (ch === '"' || ch === "'" || ch === "`") {
-            quote = ch;
-        }
-        else if (ch === "{") {
+    for (let i = openIdx; i < code.length; i++) {
+        const ch = code[i];
+        if (ch === "{")
             depth++;
-        }
         else if (ch === "}") {
             depth--;
             if (depth === 0)
-                return source.slice(openIdx, i + 1);
+                return i + 1;
         }
     }
     return undefined;
 }
-function extractConfigObject(masked) {
-    const decl = /(?:export\s+)?(?:const|let|var)\s+config\s*=\s*\{/.exec(masked);
+function extractConfigObject(src) {
+    const decl = /(?:export\s+)?(?:const|let|var)\s+config\s*=\s*\{/.exec(src.code);
     if (decl === null)
         return undefined;
     const openIdx = decl.index + decl[0].length - 1;
-    return sliceBalancedObject(masked, openIdx);
+    const end = balancedObjectEnd(src.code, openIdx);
+    return end === undefined ? undefined : sliceAligned(src, openIdx, end);
 }
-function exportedConfigLocalNames(masked) {
+function exportedConfigLocalNames(code) {
     const names = new Set();
-    if (/export\s+(?:const|let|var)\s+config\s*=/.test(masked))
+    if (/export\s+(?:const|let|var)\s+config\s*=/.test(code))
         names.add("config");
     const listPattern = /export\s*\{([^}]*)\}/g;
     let m;
-    while ((m = listPattern.exec(masked)) !== null) {
+    while ((m = listPattern.exec(code)) !== null) {
         for (const entry of m[1].split(",")) {
             const aliased = /^\s*([A-Za-z_$][\w$]*)\s+as\s+config\s*$/.exec(entry);
             if (aliased !== null) {
@@ -259,16 +315,12 @@ function exportedConfigLocalNames(masked) {
     }
     return [...names];
 }
-function topLevelObjectBindings(masked) {
+function topLevelObjectBindings(code) {
     const at = /(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*\{/y;
     const found = [];
     let depth = 0;
-    for (let i = 0; i < masked.length; i++) {
-        const ch = masked[i];
-        if (ch === '"' || ch === "'") {
-            i = skipQuoted(masked, i, ch) - 1;
-            continue;
-        }
+    for (let i = 0; i < code.length; i++) {
+        const ch = code[i];
         if (ch === "{" || ch === "(" || ch === "[") {
             depth++;
             continue;
@@ -279,10 +331,10 @@ function topLevelObjectBindings(masked) {
         }
         if (depth !== 0)
             continue;
-        if (i > 0 && /[\w$]/.test(masked[i - 1]))
+        if (i > 0 && /[\w$]/.test(code[i - 1]))
             continue;
         at.lastIndex = i;
-        const m = at.exec(masked);
+        const m = at.exec(code);
         if (m !== null) {
             const openIdx = i + m[0].length - 1;
             found.push({ name: m[1], openIdx });
@@ -292,119 +344,144 @@ function topLevelObjectBindings(masked) {
     }
     return found;
 }
-function extractExportedConfigObject(masked) {
-    const localNames = exportedConfigLocalNames(masked);
+function extractExportedConfigObject(src) {
+    const localNames = exportedConfigLocalNames(src.code);
     if (localNames.length === 0)
         return undefined;
-    const bindings = topLevelObjectBindings(masked).filter((b) => localNames.includes(b.name));
+    const bindings = topLevelObjectBindings(src.code).filter((b) => localNames.includes(b.name));
     if (bindings.length !== 1)
         return undefined;
-    return sliceBalancedObject(masked, bindings[0].openIdx);
+    const end = balancedObjectEnd(src.code, bindings[0].openIdx);
+    return end === undefined ? undefined : sliceAligned(src, bindings[0].openIdx, end);
 }
-function extractIntervalLiteral(masked) {
-    const configObj = extractConfigObject(masked);
+function extractIntervalLiteral(src) {
+    const configObj = extractConfigObject(src);
     if (configObj === undefined)
         return undefined;
-    const m = /scheduled\s*:\s*\{[^}]*?\binterval\s*:\s*["']([^"']+)["']/s.exec(configObj);
+    const m = /scheduled\s*:\s*\{[^}]*?\binterval\s*:\s*["']([^"']+)["']/s.exec(configObj.text);
     return m?.[1];
 }
-function extractTopLevelObject(objSource, key) {
-    const at = new RegExp(`\\b${key}\\s*:\\s*\\{`, "y");
-    let depth = 0;
-    let quote = null;
-    for (let i = 0; i < objSource.length; i++) {
-        const ch = objSource[i];
-        if (quote !== null) {
-            if (ch === "\\") {
-                i++;
-                continue;
-            }
-            if (ch === quote)
-                quote = null;
-            continue;
+const OPEN_BRACKETS = "{[(";
+const CLOSE_BRACKETS = "}])";
+function readTopLevelKey(obj, start) {
+    const code = obj.code;
+    const ch = code[start];
+    const ambiguous = { key: { ambiguous: true }, next: start };
+    if (ch === "[")
+        return ambiguous;
+    if (ch === ".")
+        return ambiguous;
+    if (ch === "*")
+        return ambiguous;
+    let name;
+    let nameEnd;
+    if (ch === '"' || ch === "'") {
+        const span = quotedSpan(code, start);
+        if (span === undefined)
+            return ambiguous;
+        const body = obj.text.slice(start + 1, span.end - 1);
+        if (body.includes("\\"))
+            return { key: { ambiguous: true }, next: span.end };
+        name = body;
+        nameEnd = span.end;
+    }
+    else if (/[A-Za-z_$]/.test(ch)) {
+        let j = start;
+        while (j < code.length && /[\w$]/.test(code[j]))
+            j++;
+        name = code.slice(start, j);
+        nameEnd = j;
+        if (name === "get" || name === "set" || name === "async") {
+            const after = skipSpace(code, nameEnd);
+            if (after < code.length && /["'[*A-Za-z_$]/.test(code[after]))
+                return ambiguous;
         }
-        if (ch === '"' || ch === "'" || ch === "`") {
-            quote = ch;
+    }
+    else if (/[0-9]/.test(ch)) {
+        let j = start;
+        while (j < code.length && /[\w$.]/.test(code[j]))
+            j++;
+        name = code.slice(start, j);
+        nameEnd = j;
+    }
+    else {
+        return ambiguous;
+    }
+    const afterName = skipSpace(code, nameEnd);
+    if (code[afterName] === ":") {
+        const valueStart = skipSpace(code, afterName + 1);
+        return { key: { name, valueStart, ambiguous: false }, next: valueStart };
+    }
+    return { key: { name, ambiguous: false }, next: nameEnd };
+}
+function topLevelKeys(obj) {
+    const code = obj.code;
+    const keys = [];
+    let depth = 0;
+    let expectKey = false;
+    let i = 0;
+    while (i < code.length) {
+        const ch = code[i];
+        if (depth === 1 && expectKey && !/\s/.test(ch) && ch !== "}") {
+            const read = readTopLevelKey(obj, i);
+            keys.push(read.key);
+            expectKey = false;
+            i = read.next;
             continue;
         }
-        if (ch === "{") {
+        if (OPEN_BRACKETS.includes(ch)) {
             depth++;
+            if (depth === 1 && ch === "{")
+                expectKey = true;
+            i++;
             continue;
         }
-        if (ch === "}") {
+        if (CLOSE_BRACKETS.includes(ch)) {
             depth--;
+            i++;
             continue;
         }
-        if (depth !== 1)
-            continue;
-        at.lastIndex = i;
-        const m = at.exec(objSource);
-        if (m !== null)
-            return sliceBalancedObject(objSource, i + m[0].length - 1);
+        if (depth === 1 && ch === ",")
+            expectKey = true;
+        i++;
     }
-    return undefined;
+    return keys;
+}
+const named = (keys, key) => keys.filter((k) => k.name === key);
+function objectAt(obj, valueStart) {
+    if (obj.code[valueStart] !== "{")
+        return undefined;
+    const end = balancedObjectEnd(obj.code, valueStart);
+    return end === undefined ? undefined : sliceAligned(obj, valueStart, end);
 }
-function extractTopLevelValue(objSource, key) {
-    const at = new RegExp(`\\b${key}\\s*:\\s*`, "y");
-    const OPEN = "{[(";
-    const CLOSE = "}])";
+function valueTextAt(obj, valueStart) {
+    const OPEN = OPEN_BRACKETS;
+    const CLOSE = CLOSE_BRACKETS;
     let depth = 0;
-    for (let i = 0; i < objSource.length; i++) {
-        const ch = objSource[i];
-        if (ch === '"' || ch === "'") {
-            i = skipQuoted(objSource, i, ch) - 1;
-            continue;
-        }
-        if (OPEN.includes(ch)) {
+    let j = valueStart;
+    for (; j < obj.code.length; j++) {
+        const c = obj.code[j];
+        if (OPEN.includes(c)) {
             depth++;
             continue;
         }
-        if (CLOSE.includes(ch)) {
+        if (depth === 0 && (c === "," || c === "}"))
+            break;
+        if (CLOSE.includes(c))
             depth--;
-            continue;
-        }
-        if (depth !== 1)
-            continue;
-        at.lastIndex = i;
-        const m = at.exec(objSource);
-        if (m === null)
-            continue;
-        let j = i + m[0].length;
-        let valueDepth = 0;
-        for (; j < objSource.length; j++) {
-            const c = objSource[j];
-            if (c === '"' || c === "'") {
-                j = skipQuoted(objSource, j, c) - 1;
-                continue;
-            }
-            if (OPEN.includes(c)) {
-                valueDepth++;
-                continue;
-            }
-            if (valueDepth === 0 && (c === "," || c === "}"))
-                break;
-            if (CLOSE.includes(c))
-                valueDepth--;
-        }
-        return objSource.slice(i + m[0].length, j).trim();
     }
-    return undefined;
+    return obj.text.slice(valueStart, j).trim();
 }
 function splitArrayEntries(body) {
     const parts = [];
     let start = 0;
-    for (let i = 0; i < body.length; i++) {
-        const ch = body[i];
-        if (ch === '"' || ch === "'") {
-            i = skipQuoted(body, i, ch) - 1;
-            continue;
-        }
-        if (ch === ",") {
-            parts.push(body.slice(start, i));
+    for (let i = 0; i < body.code.length; i++) {
+        if (body.code[i] === ",") {
+            parts.push(body.text.slice(start, i));
             start = i + 1;
         }
     }
-    parts.push(body.slice(start));
+    parts.push(body.text.slice(start));
     return parts.map((p) => p.trim()).filter((p) => p !== "");
 }
 function stringLiteralValue(raw) {
@@ -415,10 +492,18 @@ function stringLiteralValue(raw) {
         return /^'((?:[^'\\]|\\.)*)'$/.exec(s)?.[1];
     return undefined;
 }
-function extractFetchUnfilteredReads(masked) {
-    const configObj = extractExportedConfigObject(masked);
+const duplicateKeyError = (where, key, count) => `config.fetch.unfilteredReads is ambiguous: ${where} declares a duplicate \`${key}\` key (${count} times) — JavaScript keeps only the LAST one, so the declaration in the source is not the declaration that runs. Remove the extra \`${key}\` key(s) so exactly one remains, then push again`;
+const ambiguousKeyError = (where) => `config.fetch.unfilteredReads is ambiguous: ${where} has a property key this push-time parser cannot read statically — a computed \`[key]\`, a spread, an accessor/generator, or a quoted name with escapes. Any of those could shadow \`fetch\`/\`unfilteredReads\`/\`dbs\`/\`why\`, so write those keys literally (bare or plainly quoted) alongside no unreadable siblings, then push again`;
+function readableTopLevelKeys(obj, where) {
+    const keys = topLevelKeys(obj);
+    if (keys.some((k) => k.ambiguous))
+        return { errors: [ambiguousKeyError(where)] };
+    return { keys, errors: [] };
+}
+function extractFetchUnfilteredReads(src) {
+    const configObj = extractExportedConfigObject(src);
     if (configObj === undefined) {
-        if (!hasLiveKey(masked, "unfilteredReads"))
+        if (!mentionsKey(src, "unfilteredReads"))
             return { errors: [] };
         return {
             errors: [
@@ -426,21 +511,53 @@ function extractFetchUnfilteredReads(masked) {
             ],
         };
     }
-    if (!hasLiveKey(configObj, "unfilteredReads"))
+    if (!mentionsKey(configObj, "unfilteredReads"))
         return { errors: [] };
     const shape = 'config.fetch.unfilteredReads must be { dbs: ["db-name"], why: "…" } with static string literals';
-    const fetchObj = extractTopLevelObject(configObj, "fetch");
-    const decl = fetchObj === undefined ? undefined : extractTopLevelObject(fetchObj, "unfilteredReads");
+    const configKeys = readableTopLevelKeys(configObj, "the exported config object");
+    if (configKeys.keys === undefined)
+        return { errors: configKeys.errors };
+    const fetchKeys = named(configKeys.keys, "fetch");
+    if (fetchKeys.length > 1)
+        return { errors: [duplicateKeyError("the exported config object", "fetch", fetchKeys.length)] };
+    const fetchStart = fetchKeys[0]?.valueStart;
+    const fetchObj = fetchStart === undefined ? undefined : objectAt(configObj, fetchStart);
+    if (fetchObj === undefined)
+        return { errors: [shape] };
+    const fetchLaneKeys = readableTopLevelKeys(fetchObj, "config.fetch");
+    if (fetchLaneKeys.keys === undefined)
+        return { errors: fetchLaneKeys.errors };
+    const declKeys = named(fetchLaneKeys.keys, "unfilteredReads");
+    if (declKeys.length > 1)
+        return { errors: [duplicateKeyError("config.fetch", "unfilteredReads", declKeys.length)] };
+    const declStart = declKeys[0]?.valueStart;
+    const decl = declStart === undefined ? undefined : objectAt(fetchObj, declStart);
     if (decl === undefined)
         return { errors: [shape] };
     const errors = [];
-    const dbsValue = extractTopLevelValue(decl, "dbs");
+    const declInner = readableTopLevelKeys(decl, "config.fetch.unfilteredReads");
+    if (declInner.keys === undefined)
+        return { errors: declInner.errors };
+    const dbsKeys = named(declInner.keys, "dbs");
+    const whyKeys = named(declInner.keys, "why");
+    if (dbsKeys.length > 1 || whyKeys.length > 1) {
+        const dupes = [];
+        if (dbsKeys.length > 1)
+            dupes.push(duplicateKeyError("config.fetch.unfilteredReads", "dbs", dbsKeys.length));
+        if (whyKeys.length > 1)
+            dupes.push(duplicateKeyError("config.fetch.unfilteredReads", "why", whyKeys.length));
+        return { errors: dupes };
+    }
+    const dbsStart = dbsKeys[0]?.valueStart;
+    const whyStart = whyKeys[0]?.valueStart;
+    const dbsValue = dbsStart === undefined ? undefined : valueTextAt(decl, dbsStart);
     let dbs;
     if (dbsValue === undefined || !dbsValue.startsWith("[") || !dbsValue.endsWith("]")) {
         errors.push(`${shape} — dbs must be an array literal of string literals`);
     }
     else {
-        const parts = splitArrayEntries(dbsValue.slice(1, -1));
+        const bodyStart = dbsStart + 1;
+        const parts = splitArrayEntries(sliceAligned(decl, bodyStart, bodyStart + dbsValue.length - 2));
         const parsed = parts.map(stringLiteralValue);
         if (parts.length === 0) {
             errors.push(`${shape} — dbs must name at least one database`);
@@ -455,7 +572,7 @@ function extractFetchUnfilteredReads(masked) {
             dbs = parsed;
         }
     }
-    const whyValue = extractTopLevelValue(decl, "why");
+    const whyValue = whyStart === undefined ? undefined : valueTextAt(decl, whyStart);
     const why = whyValue === undefined ? undefined : stringLiteralValue(whyValue);
     if (why === undefined || why.trim() === "") {
         errors.push(`${shape} — why must be a non-empty string literal stating why this handler authorizes these reads itself`);
@@ -469,12 +586,12 @@ export function parseBackendConfig(source) {
     if (source === undefined || source.trim() === "") {
         return { handlers: [], hasConfig: false, errors };
     }
-    const masked = maskNonCode(source);
-    const handlers = HANDLER_NAMES.filter((name) => exportsName(masked, name));
-    const hasConfig = exportsName(masked, "config");
+    const src = viewsOf(source);
+    const handlers = HANDLER_NAMES.filter((name) => exportsName(src.code, name));
+    const hasConfig = exportsName(src.code, "config");
     const hasScheduled = handlers.includes("scheduled");
     let schedule;
-    const rawInterval = extractIntervalLiteral(masked);
+    const rawInterval = extractIntervalLiteral(src);
     if (hasScheduled) {
         if (rawInterval === undefined) {
             errors.push('scheduled handler requires config.scheduled.interval as a static string-literal duration, e.g. { scheduled: { interval: "5m" } }; computed/indirect values are unsupported');
@@ -497,7 +614,7 @@ export function parseBackendConfig(source) {
     }
     let fetchUnfilteredReads;
     if (handlers.includes("fetch")) {
-        const parsedReads = extractFetchUnfilteredReads(masked);
+        const parsedReads = extractFetchUnfilteredReads(src);
         errors.push(...parsedReads.errors);
         fetchUnfilteredReads = parsedReads.value;
     }