@vibes.diy/vibe-runtime 12.1.0 → 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,58 +25,573 @@ function parseDurationMs(raw) {
     const mult = m[2] === "s" ? 1_000 : m[2] === "m" ? 60_000 : 3_600_000;
     return n * mult;
 }
-function sliceBalancedObject(source, openIdx) {
-    let depth = 0;
-    let quote = null;
-    for (let i = openIdx; i < source.length; i++) {
-        const ch = source[i];
-        if (quote !== null) {
-            if (ch === "\\") {
+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) {
+        const ch = src[i];
+        if (ch === "\\") {
+            i += 2;
+            continue;
+        }
+        if (ch === quote)
+            return i + 1;
+        if (ch === "\n")
+            return i;
+        i++;
+    }
+    return src.length;
+}
+function skipTemplate(src, start) {
+    let i = start + 1;
+    while (i < src.length) {
+        const ch = src[i];
+        if (ch === "\\") {
+            i += 2;
+            continue;
+        }
+        if (ch === "`")
+            return i + 1;
+        if (ch === "$" && src[i + 1] === "{") {
+            let depth = 1;
+            i += 2;
+            while (i < src.length && depth > 0) {
+                const c = src[i];
+                if (c === "\\") {
+                    i += 2;
+                    continue;
+                }
+                if (c === '"' || c === "'") {
+                    i = skipQuoted(src, i, c);
+                    continue;
+                }
+                if (c === "`") {
+                    i = skipTemplate(src, i);
+                    continue;
+                }
+                if (c === "{")
+                    depth++;
+                else if (c === "}")
+                    depth--;
                 i++;
-                continue;
             }
-            if (ch === quote)
-                quote = null;
             continue;
         }
-        if (ch === '"' || ch === "'" || ch === "`") {
-            quote = ch;
+        i++;
+    }
+    return src.length;
+}
+function skipRegex(src, start) {
+    let i = start + 1;
+    let inClass = false;
+    while (i < src.length) {
+        const ch = src[i];
+        if (ch === "\\") {
+            i += 2;
+            continue;
         }
-        else if (ch === "{") {
-            depth++;
+        if (ch === "\n")
+            return undefined;
+        if (inClass) {
+            if (ch === "]")
+                inClass = false;
         }
+        else if (ch === "[") {
+            inClass = true;
+        }
+        else if (ch === "/") {
+            i++;
+            while (i < src.length && /[a-z]/i.test(src[i]))
+                i++;
+            return i;
+        }
+        i++;
+    }
+    return undefined;
+}
+const REGEX_PRECEDING_KEYWORDS = new Set([
+    "return",
+    "typeof",
+    "instanceof",
+    "in",
+    "of",
+    "new",
+    "delete",
+    "void",
+    "do",
+    "else",
+    "case",
+    "yield",
+    "await",
+    "throw",
+]);
+function maskNonCode(source) {
+    const chars = source.split("");
+    const blank = (from, to) => {
+        for (let k = from; k < to && k < chars.length; k++) {
+            if (chars[k] !== "\n")
+                chars[k] = " ";
+        }
+    };
+    let prevIsValue = false;
+    let prevIsDot = false;
+    let i = 0;
+    while (i < source.length) {
+        const ch = source[i];
+        if (ch === "/" && source[i + 1] === "/") {
+            let j = i + 2;
+            while (j < source.length && source[j] !== "\n")
+                j++;
+            blank(i, j);
+            i = j;
+            continue;
+        }
+        if (ch === "/" && source[i + 1] === "*") {
+            let j = i + 2;
+            while (j < source.length && !(source[j] === "*" && source[j + 1] === "/"))
+                j++;
+            j = Math.min(j + 2, source.length);
+            blank(i, j);
+            i = j;
+            continue;
+        }
+        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 === "/") {
+            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 blankStrings(masked) {
+    const chars = masked.split("");
+    let i = 0;
+    while (i < masked.length) {
+        const ch = masked[i];
+        if (ch === '"' || ch === "'") {
+            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;
+        }
+        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 balancedObjectEnd(code, openIdx) {
+    let depth = 0;
+    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(source) {
-    const decl = /(?:export\s+)?(?:const|let|var)\s+config\s*=\s*\{/.exec(source);
+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(source, openIdx);
+    const end = balancedObjectEnd(src.code, openIdx);
+    return end === undefined ? undefined : sliceAligned(src, openIdx, end);
 }
-function extractIntervalLiteral(source) {
-    const configObj = extractConfigObject(source);
+function exportedConfigLocalNames(code) {
+    const names = new Set();
+    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(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) {
+                names.add(aliased[1]);
+                continue;
+            }
+            if (/^\s*config\s*$/.test(entry))
+                names.add("config");
+        }
+    }
+    return [...names];
+}
+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 < code.length; i++) {
+        const ch = code[i];
+        if (ch === "{" || ch === "(" || ch === "[") {
+            depth++;
+            continue;
+        }
+        if (ch === "}" || ch === ")" || ch === "]") {
+            depth--;
+            continue;
+        }
+        if (depth !== 0)
+            continue;
+        if (i > 0 && /[\w$]/.test(code[i - 1]))
+            continue;
+        at.lastIndex = i;
+        const m = at.exec(code);
+        if (m !== null) {
+            const openIdx = i + m[0].length - 1;
+            found.push({ name: m[1], openIdx });
+            depth++;
+            i = openIdx;
+        }
+    }
+    return found;
+}
+function extractExportedConfigObject(src) {
+    const localNames = exportedConfigLocalNames(src.code);
+    if (localNames.length === 0)
+        return undefined;
+    const bindings = topLevelObjectBindings(src.code).filter((b) => localNames.includes(b.name));
+    if (bindings.length !== 1)
+        return undefined;
+    const end = balancedObjectEnd(src.code, bindings[0].openIdx);
+    return end === undefined ? undefined : sliceAligned(src, bindings[0].openIdx, end);
+}
+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];
 }
+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;
+        }
+    }
+    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 (OPEN_BRACKETS.includes(ch)) {
+            depth++;
+            if (depth === 1 && ch === "{")
+                expectKey = true;
+            i++;
+            continue;
+        }
+        if (CLOSE_BRACKETS.includes(ch)) {
+            depth--;
+            i++;
+            continue;
+        }
+        if (depth === 1 && ch === ",")
+            expectKey = true;
+        i++;
+    }
+    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 valueTextAt(obj, valueStart) {
+    const OPEN = OPEN_BRACKETS;
+    const CLOSE = CLOSE_BRACKETS;
+    let depth = 0;
+    let j = valueStart;
+    for (; j < obj.code.length; j++) {
+        const c = obj.code[j];
+        if (OPEN.includes(c)) {
+            depth++;
+            continue;
+        }
+        if (depth === 0 && (c === "," || c === "}"))
+            break;
+        if (CLOSE.includes(c))
+            depth--;
+    }
+    return obj.text.slice(valueStart, j).trim();
+}
+function splitArrayEntries(body) {
+    const parts = [];
+    let start = 0;
+    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.text.slice(start));
+    return parts.map((p) => p.trim()).filter((p) => p !== "");
+}
+function stringLiteralValue(raw) {
+    const s = raw.trim();
+    if (s.startsWith('"'))
+        return /^"((?:[^"\\]|\\.)*)"$/.exec(s)?.[1];
+    if (s.startsWith("'"))
+        return /^'((?:[^'\\]|\\.)*)'$/.exec(s)?.[1];
+    return undefined;
+}
+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 (!mentionsKey(src, "unfilteredReads"))
+            return { errors: [] };
+        return {
+            errors: [
+                'config.fetch.unfilteredReads must be declared in the exported top-level config object — declare it as `export const config = { fetch: { unfilteredReads: { dbs: ["db-name"], why: "…" } } }`; a declaration on any other config binding is ignored',
+            ],
+        };
+    }
+    if (!mentionsKey(configObj, "unfilteredReads"))
+        return { errors: [] };
+    const shape = 'config.fetch.unfilteredReads must be { dbs: ["db-name"], why: "…" } with static string literals';
+    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 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 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`);
+        }
+        else if (parsed.some((v) => v === undefined)) {
+            errors.push(`${shape} — dbs entries must be string literals; computed/indirect values are unsupported`);
+        }
+        else if (parsed.some((v) => v?.trim() === "")) {
+            errors.push(`${shape} — dbs entries must be non-empty database names`);
+        }
+        else {
+            dbs = parsed;
+        }
+    }
+    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`);
+    }
+    if (errors.length > 0 || dbs === undefined || why === undefined)
+        return { errors };
+    return { value: { dbs, why }, errors };
+}
 export function parseBackendConfig(source) {
     const errors = [];
     if (source === undefined || source.trim() === "") {
         return { handlers: [], hasConfig: false, errors };
     }
-    const handlers = HANDLER_NAMES.filter((name) => exportsName(source, name));
-    const hasConfig = exportsName(source, "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(source);
+    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');
@@ -97,6 +612,12 @@ export function parseBackendConfig(source) {
             }
         }
     }
-    return { handlers, hasConfig, schedule, errors };
+    let fetchUnfilteredReads;
+    if (handlers.includes("fetch")) {
+        const parsedReads = extractFetchUnfilteredReads(src);
+        errors.push(...parsedReads.errors);
+        fetchUnfilteredReads = parsedReads.value;
+    }
+    return { handlers, hasConfig, schedule, fetchUnfilteredReads, errors };
 }
 //# sourceMappingURL=parse-backend-config.js.map