@typed-sql/compiler 1.0.0-beta.1 → 1.0.0-rc.0

package/dist/packages/compiler/src/scanner.js

@@ -1,32 +1,185 @@
-const importPattern = /import\s*\{([\s\S]*?)\}\s*from\s*["']([^"']+)["']/g;
+function isIdentifierStart(char) {
+    if (char === undefined)
+        return false;
+    const code = char.charCodeAt(0);
+    return (code >= 65 && code <= 90) || (code >= 97 && code <= 122) || char === "_" || char === "$";
+}
+function isIdentifierPart(char) {
+    if (isIdentifierStart(char))
+        return true;
+    if (char === undefined)
+        return false;
+    const code = char.charCodeAt(0);
+    return code >= 48 && code <= 57;
+}
+function isWhitespace(char) {
+    return char === " " || char === "\t" || char === "\n" || char === "\r" || char === "\f" || char === "\v";
+}
+function identifierAt(source, start) {
+    if (!isIdentifierStart(source[start]))
+        return undefined;
+    let end = start + 1;
+    while (isIdentifierPart(source[end]))
+        end += 1;
+    return { value: source.slice(start, end), end };
+}
+function skipTrivia(source, start) {
+    let index = start;
+    while (index < source.length) {
+        if (isWhitespace(source[index]))
+            index += 1;
+        else if (source[index] === "/" && source[index + 1] === "/")
+            index = skipLineComment(source, index);
+        else if (source[index] === "/" && source[index + 1] === "*")
+            index = skipBlockComment(source, index);
+        else
+            break;
+    }
+    return index;
+}
+function closingImportBrace(source, start) {
+    let depth = 1;
+    let index = start + 1;
+    while (index < source.length) {
+        const char = source[index];
+        if (char === '"' || char === "'")
+            index = skipQuoted(source, index, char);
+        else if (char === "/" && source[index + 1] === "/")
+            index = skipLineComment(source, index);
+        else if (char === "/" && source[index + 1] === "*")
+            index = skipBlockComment(source, index);
+        else if (char === "{") {
+            depth += 1;
+            index += 1;
+        }
+        else if (char === "}") {
+            depth -= 1;
+            if (depth === 0)
+                return index;
+            index += 1;
+        }
+        else
+            index += 1;
+    }
+    return undefined;
+}
+function importedSqlName(specifier) {
+    const tokens = [];
+    let index = 0;
+    while (index < specifier.length) {
+        index = skipTrivia(specifier, index);
+        const token = identifierAt(specifier, index);
+        if (token === undefined) {
+            index += 1;
+            continue;
+        }
+        tokens.push(token.value);
+        index = token.end;
+    }
+    if (tokens[0] !== "sql")
+        return undefined;
+    if (tokens.length === 1)
+        return "sql";
+    return tokens[1] === "as" && tokens[2] !== undefined ? tokens[2] : undefined;
+}
 function importedSqlNames(source, sqlModules) {
     const names = new Set();
-    for (const match of source.matchAll(importPattern)) {
-        const specifiers = match[1];
-        const moduleName = match[2];
-        if (specifiers === undefined || moduleName === undefined)
+    let index = 0;
+    while (index < source.length) {
+        const char = source[index];
+        if (char === '"' || char === "'" || char === "`") {
+            index = skipQuoted(source, index, char);
+            continue;
+        }
+        if (char === "/" && source[index + 1] === "/") {
+            index = skipLineComment(source, index);
             continue;
-        if (!sqlModules.has(moduleName))
+        }
+        if (char === "/" && source[index + 1] === "*") {
+            index = skipBlockComment(source, index);
             continue;
-        for (const specifier of specifiers.split(",")) {
-            const parts = specifier.trim().split(/\s+as\s+/);
-            if (parts[0] === "sql")
-                names.add(parts[1] ?? "sql");
         }
+        const keyword = identifierAt(source, index);
+        if (keyword === undefined) {
+            index += 1;
+            continue;
+        }
+        index = keyword.end;
+        if (keyword.value !== "import")
+            continue;
+        let cursor = skipTrivia(source, index);
+        if (source[cursor] !== "{")
+            continue;
+        const close = closingImportBrace(source, cursor);
+        if (close === undefined)
+            break;
+        const specifiers = source.slice(cursor + 1, close);
+        cursor = skipTrivia(source, close + 1);
+        const from = identifierAt(source, cursor);
+        if (from?.value !== "from")
+            continue;
+        cursor = skipTrivia(source, from.end);
+        const quote = source[cursor];
+        if (quote !== '"' && quote !== "'")
+            continue;
+        const moduleEnd = skipQuoted(source, cursor, quote);
+        if (moduleEnd > source.length || source[moduleEnd - 1] !== quote)
+            continue;
+        const moduleName = source.slice(cursor + 1, moduleEnd - 1);
+        if (sqlModules.has(moduleName)) {
+            for (const specifier of specifiers.split(",")) {
+                const localName = importedSqlName(specifier);
+                if (localName !== undefined)
+                    names.add(localName);
+            }
+        }
+        index = moduleEnd;
     }
     return names;
 }
+const MAX_LINE_START_CACHE_ENTRIES = 8;
+const lineStartCache = new Map();
+function lineStarts(source) {
+    const cached = lineStartCache.get(source);
+    if (cached !== undefined) {
+        lineStartCache.delete(source);
+        lineStartCache.set(source, cached);
+        return cached;
+    }
+    const starts = [0];
+    for (let index = 0; index < source.length; index += 1) {
+        if (source[index] === "\n")
+            starts.push(index + 1);
+    }
+    lineStartCache.set(source, starts);
+    while (lineStartCache.size > MAX_LINE_START_CACHE_ENTRIES) {
+        lineStartCache.delete(lineStartCache.keys().next().value);
+    }
+    return starts;
+}
 function positionRange(source, start, end) {
-    const before = source.slice(0, start);
-    const lastNewline = before.lastIndexOf("\n");
+    const starts = lineStarts(source);
+    let low = 0;
+    let high = starts.length;
+    while (low < high) {
+        const middle = (low + high) >>> 1;
+        if ((starts[middle] ?? 0) <= start)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    const lineIndex = Math.max(0, low - 1);
+    const lineStart = starts[lineIndex] ?? 0;
     return {
         start,
         end,
-        line: before.split("\n").length,
-        column: start - lastNewline,
+        line: lineIndex + 1,
+        column: start - lineStart + 1,
     };
 }
 function skipQuoted(source, start, quote) {
+    if (quote === "`")
+        return skipTemplate(source, start);
     let index = start + 1;
     while (index < source.length) {
         if (source[index] === "\\")
@@ -38,6 +191,20 @@ function skipQuoted(source, start, quote) {
     }
     return source.length;
 }
+function skipTemplate(source, start) {
+    let index = start + 1;
+    while (index < source.length) {
+        if (source[index] === "\\")
+            index += 2;
+        else if (source[index] === "`")
+            return index + 1;
+        else if (source[index] === "$" && source[index + 1] === "{")
+            index = interpolationEnd(source, index + 2);
+        else
+            index += 1;
+    }
+    return source.length;
+}
 function skipLineComment(source, start) {
     const end = source.indexOf("\n", start + 2);
     return end === -1 ? source.length : end + 1;
@@ -74,11 +241,60 @@ function interpolationEnd(source, start) {
     }
     return source.length;
 }
-function extractTemplate(source, tagName, tagStart, backtick, placeholderFor) {
+function hexadecimalValue(source, start, length) {
+    const value = source.slice(start, start + length);
+    return value.length === length && /^[\dA-Fa-f]+$/u.test(value) ? Number.parseInt(value, 16) : undefined;
+}
+function cookedEscape(source, start) {
+    const escaped = source[start + 1];
+    if (escaped === undefined)
+        return undefined;
+    const simple = {
+        "0": "\0",
+        b: "\b",
+        f: "\f",
+        n: "\n",
+        r: "\r",
+        t: "\t",
+        v: "\v",
+    };
+    if (escaped === "\n")
+        return { text: "", end: start + 2 };
+    if (escaped === "\r") {
+        return { text: "", end: source[start + 2] === "\n" ? start + 3 : start + 2 };
+    }
+    if (escaped === "0" && /\d/u.test(source[start + 2] ?? ""))
+        return undefined;
+    if (escaped in simple)
+        return { text: simple[escaped], end: start + 2 };
+    if (escaped === "x") {
+        const value = hexadecimalValue(source, start + 2, 2);
+        return value === undefined ? undefined : { text: String.fromCodePoint(value), end: start + 4 };
+    }
+    if (escaped === "u") {
+        if (source[start + 2] === "{") {
+            const close = source.indexOf("}", start + 3);
+            if (close === -1)
+                return undefined;
+            const digits = source.slice(start + 3, close);
+            if (!/^[\dA-Fa-f]{1,6}$/u.test(digits))
+                return undefined;
+            const value = Number.parseInt(digits, 16);
+            return value > 0x10ffff ? undefined : { text: String.fromCodePoint(value), end: close + 1 };
+        }
+        const value = hexadecimalValue(source, start + 2, 4);
+        return value === undefined ? undefined : { text: String.fromCodePoint(value), end: start + 6 };
+    }
+    if (/[1-9]/u.test(escaped))
+        return undefined;
+    return { text: escaped, end: start + 2 };
+}
+function extractTemplate(source, tagName, tagStart, backtick, placeholderFor, parameterOffset = 0) {
     let index = backtick + 1;
     let sql = "";
     let parameterCount = 0;
     const sqlOffsetMap = [];
+    const interpolations = [];
     while (index < source.length) {
         const char = source[index];
         if (char === "`") {
@@ -89,21 +305,39 @@ function extractTemplate(source, tagName, tagStart, backtick, placeholderFor) {
                 insertionPosition: tagStart + tagName.length,
                 range: positionRange(source, tagStart, index + 1),
                 sqlOffsetMap,
+                interpolations,
             };
         }
-        if (char === "\\" && index + 1 < source.length) {
-            sql += source[index + 1];
-            sqlOffsetMap.push(index);
-            index += 2;
+        if (char === "\\") {
+            const cooked = cookedEscape(source, index);
+            if (cooked === undefined)
+                return undefined;
+            sql += cooked.text;
+            for (let offset = 0; offset < cooked.text.length; offset += 1)
+                sqlOffsetMap.push(index);
+            index = cooked.end;
             continue;
         }
         if (char === "$" && source[index + 1] === "{") {
             parameterCount += 1;
-            const placeholder = placeholderFor(parameterCount);
+            const sourceStart = index;
+            const expressionStart = index + 2;
+            const sourceEnd = interpolationEnd(source, expressionStart);
+            const sqlStart = sql.length;
+            const placeholder = placeholderFor(parameterOffset + parameterCount);
             sql += placeholder;
             for (let offset = 0; offset < placeholder.length; offset += 1)
                 sqlOffsetMap.push(index);
-            index = interpolationEnd(source, index + 2);
+            interpolations.push({
+                index: parameterCount,
+                sourceStart,
+                expressionStart,
+                expressionEnd: Math.max(expressionStart, sourceEnd - 1),
+                sourceEnd,
+                sqlStart,
+                sqlEnd: sql.length,
+            });
+            index = sourceEnd;
             continue;
         }
         sql += char;
@@ -112,6 +346,181 @@ function extractTemplate(source, tagName, tagStart, backtick, placeholderFor) {
     }
     return undefined;
 }
+function bindingNameBefore(source, start) {
+    let cursor = start - 1;
+    while (cursor >= 0 && isWhitespace(source[cursor]))
+        cursor -= 1;
+    if (source[cursor] !== "=")
+        return undefined;
+    cursor -= 1;
+    while (cursor >= 0 && isWhitespace(source[cursor]))
+        cursor -= 1;
+    const end = cursor + 1;
+    while (cursor >= 0 && isIdentifierPart(source[cursor]))
+        cursor -= 1;
+    const name = source.slice(cursor + 1, end);
+    return name.length > 0 && isIdentifierStart(name[0]) ? name : undefined;
+}
+function closingParenthesis(source, start) {
+    let depth = 1;
+    let index = start + 1;
+    while (index < source.length) {
+        const char = source[index];
+        if (char === '"' || char === "'" || char === "`")
+            index = skipQuoted(source, index, char);
+        else if (char === "/" && source[index + 1] === "/")
+            index = skipLineComment(source, index);
+        else if (char === "/" && source[index + 1] === "*")
+            index = skipBlockComment(source, index);
+        else if (char === "(") {
+            depth += 1;
+            index += 1;
+        }
+        else if (char === ")") {
+            depth -= 1;
+            if (depth === 0)
+                return index;
+            index += 1;
+        }
+        else
+            index += 1;
+    }
+    return undefined;
+}
+function trimmedRange(source, start, end) {
+    let first = start;
+    let last = end;
+    while (first < last && isWhitespace(source[first]))
+        first += 1;
+    while (last > first && isWhitespace(source[last - 1]))
+        last -= 1;
+    return { start: first, end: last };
+}
+function unwrappedRange(source, start, end) {
+    let range = trimmedRange(source, start, end);
+    while (source[range.start] === "(" && closingParenthesis(source, range.start) === range.end - 1) {
+        range = trimmedRange(source, range.start + 1, range.end - 1);
+    }
+    return range;
+}
+function structuralOperand(source, start, end, tagName) {
+    const range = trimmedRange(source, start, end);
+    const empty = `${tagName}.empty`;
+    if (source.slice(range.start, range.end) === empty)
+        return { kind: "empty", ...range };
+    const prefix = `${tagName}.fragment`;
+    if (!source.startsWith(prefix, range.start))
+        return undefined;
+    const backtick = skipTrivia(source, range.start + prefix.length);
+    if (source[backtick] !== "`" || skipQuoted(source, backtick, "`") !== range.end)
+        return undefined;
+    return { kind: "fragment", ...range, backtick };
+}
+function conditionalRanges(source, start, end) {
+    let question;
+    let colon;
+    let round = 0;
+    let square = 0;
+    let curly = 0;
+    let index = start;
+    while (index < end) {
+        const char = source[index];
+        if (char === '"' || char === "'" || char === "`") {
+            index = skipQuoted(source, index, char);
+            continue;
+        }
+        if (char === "/" && source[index + 1] === "/") {
+            index = skipLineComment(source, index);
+            continue;
+        }
+        if (char === "/" && source[index + 1] === "*") {
+            index = skipBlockComment(source, index);
+            continue;
+        }
+        if (char === "(")
+            round += 1;
+        else if (char === ")")
+            round -= 1;
+        else if (char === "[")
+            square += 1;
+        else if (char === "]")
+            square -= 1;
+        else if (char === "{")
+            curly += 1;
+        else if (char === "}")
+            curly -= 1;
+        else if (round === 0 &&
+            square === 0 &&
+            curly === 0 &&
+            char === "?" &&
+            source[index + 1] !== "." &&
+            source[index + 1] !== "?" &&
+            source[index - 1] !== "?" &&
+            question === undefined)
+            question = index;
+        else if (round === 0 && square === 0 && curly === 0 && char === ":" && question !== undefined) {
+            colon = index;
+            break;
+        }
+        index += 1;
+    }
+    if (question === undefined || colon === undefined)
+        return undefined;
+    return {
+        condition: unwrappedRange(source, start, question),
+        truthy: unwrappedRange(source, question + 1, colon),
+        falsy: unwrappedRange(source, colon + 1, end),
+    };
+}
+function bareTemplateRange(source, start, end) {
+    const range = unwrappedRange(source, start, end);
+    if (source[range.start] !== "`" || skipQuoted(source, range.start, "`") !== range.end)
+        return undefined;
+    return positionRange(source, range.start, range.end);
+}
+export function findUntaggedStructuralTemplates(source, query) {
+    const templates = [];
+    for (const interpolation of query.interpolations) {
+        const expression = unwrappedRange(source, interpolation.expressionStart, interpolation.expressionEnd);
+        const conditional = conditionalRanges(source, expression.start, expression.end);
+        if (conditional === undefined)
+            continue;
+        const truthyStructural = structuralOperand(source, conditional.truthy.start, conditional.truthy.end, query.tagName);
+        const falsyStructural = structuralOperand(source, conditional.falsy.start, conditional.falsy.end, query.tagName);
+        const truthyTemplate = bareTemplateRange(source, conditional.truthy.start, conditional.truthy.end);
+        const falsyTemplate = bareTemplateRange(source, conditional.falsy.start, conditional.falsy.end);
+        if (truthyTemplate !== undefined && falsyStructural !== undefined) {
+            templates.push({ tagName: query.tagName, range: truthyTemplate });
+        }
+        if (falsyTemplate !== undefined && truthyStructural !== undefined) {
+            templates.push({ tagName: query.tagName, range: falsyTemplate });
+        }
+    }
+    return templates;
+}
+export function parseStructuralInterpolation(source, interpolation, tagName) {
+    const expression = unwrappedRange(source, interpolation.expressionStart, interpolation.expressionEnd);
+    const { start, end } = expression;
+    const conditional = conditionalRanges(source, start, end);
+    if (conditional === undefined) {
+        const truthy = structuralOperand(source, start, end, tagName);
+        return truthy === undefined ? undefined : { truthy };
+    }
+    const truthy = structuralOperand(source, conditional.truthy.start, conditional.truthy.end, tagName);
+    const falsy = structuralOperand(source, conditional.falsy.start, conditional.falsy.end, tagName);
+    if (truthy === undefined || falsy === undefined)
+        return undefined;
+    return {
+        condition: source.slice(conditional.condition.start, conditional.condition.end).replace(/\s+/gu, " "),
+        truthy,
+        falsy,
+    };
+}
+export function extractStructuralOperand(source, operand, tagName, placeholderFor, parameterOffset) {
+    if (operand.kind === "empty" || operand.backtick === undefined)
+        return undefined;
+    return extractTemplate(source, `${tagName}.fragment`, operand.start, operand.backtick, placeholderFor, parameterOffset);
+}
 export function extractStaticQueries(source, placeholderFor, sqlModules = ["@typed-sql/core"]) {
     const names = importedSqlNames(source, new Set(sqlModules));
     if (names.size === 0)
@@ -136,10 +545,10 @@ export function extractStaticQueries(source, placeholderFor, sqlModules = ["@typ
             index = skipBlockComment(source, index);
             continue;
         }
-        if (char !== undefined && /[A-Za-z_$]/.test(char)) {
+        if (isIdentifierStart(char)) {
             const start = index;
             index += 1;
-            while (index < source.length && /[A-Za-z0-9_$]/.test(source[index]))
+            while (index < source.length && isIdentifierPart(source[index]))
                 index += 1;
             const name = source.slice(start, index);
             if (!names.has(name))
@@ -160,6 +569,116 @@ export function extractStaticQueries(source, placeholderFor, sqlModules = ["@typ
     }
     return queries;
 }
+export function extractAppendFragments(source, placeholderFor, sqlModules = ["@typed-sql/core"], queries = extractStaticQueries(source, placeholderFor, sqlModules)) {
+    const names = importedSqlNames(source, new Set(sqlModules));
+    if (names.size === 0)
+        return [];
+    const bindings = queries.flatMap((query) => {
+        const name = bindingNameBefore(source, query.range.start);
+        return name === undefined ? [] : [{ name, query }];
+    });
+    const fragments = [];
+    let index = 0;
+    while (index < source.length) {
+        const char = source[index];
+        if (char === '"' || char === "'" || char === "`") {
+            index = skipQuoted(source, index, char);
+            continue;
+        }
+        if (char === "/" && source[index + 1] === "/") {
+            index = skipLineComment(source, index);
+            continue;
+        }
+        if (char === "/" && source[index + 1] === "*") {
+            index = skipBlockComment(source, index);
+            continue;
+        }
+        const tag = identifierAt(source, index);
+        if (tag === undefined) {
+            index += 1;
+            continue;
+        }
+        index = tag.end;
+        if (!names.has(tag.value))
+            continue;
+        let cursor = skipTrivia(source, tag.end);
+        if (source[cursor] !== ".")
+            continue;
+        cursor = skipTrivia(source, cursor + 1);
+        const method = identifierAt(source, cursor);
+        if (method?.value !== "append")
+            continue;
+        cursor = skipTrivia(source, method.end);
+        if (source[cursor] !== "(")
+            continue;
+        const close = closingParenthesis(source, cursor);
+        if (close === undefined)
+            continue;
+        let argument = skipTrivia(source, cursor + 1);
+        const baseName = identifierAt(source, argument);
+        if (baseName === undefined) {
+            index = close + 1;
+            continue;
+        }
+        const base = bindings
+            .filter((binding) => binding.name === baseName.value && binding.query.range.start < index)
+            .sort((left, right) => right.query.range.start - left.query.range.start)[0]?.query;
+        argument = skipTrivia(source, baseName.end);
+        if (base === undefined || source[argument] !== ",") {
+            index = close + 1;
+            continue;
+        }
+        let fragmentCursor = argument + 1;
+        const prefix = [];
+        let parameterOffset = base.parameterCount;
+        while (fragmentCursor < close) {
+            const fragmentChar = source[fragmentCursor];
+            if (fragmentChar === '"' || fragmentChar === "'") {
+                fragmentCursor = skipQuoted(source, fragmentCursor, fragmentChar);
+                continue;
+            }
+            if (fragmentChar === "`") {
+                fragmentCursor = skipQuoted(source, fragmentCursor, fragmentChar);
+                continue;
+            }
+            if (fragmentChar === "/" && source[fragmentCursor + 1] === "/") {
+                fragmentCursor = skipLineComment(source, fragmentCursor);
+                continue;
+            }
+            if (fragmentChar === "/" && source[fragmentCursor + 1] === "*") {
+                fragmentCursor = skipBlockComment(source, fragmentCursor);
+                continue;
+            }
+            const fragmentTag = identifierAt(source, fragmentCursor);
+            if (fragmentTag === undefined) {
+                fragmentCursor += 1;
+                continue;
+            }
+            fragmentCursor = fragmentTag.end;
+            if (fragmentTag.value !== tag.value)
+                continue;
+            let memberCursor = skipTrivia(source, fragmentTag.end);
+            if (source[memberCursor] !== ".")
+                continue;
+            memberCursor = skipTrivia(source, memberCursor + 1);
+            const member = identifierAt(source, memberCursor);
+            if (member?.value !== "fragment")
+                continue;
+            const backtick = skipTrivia(source, member.end);
+            if (source[backtick] !== "`")
+                continue;
+            const fragment = extractTemplate(source, `${tag.value}.fragment`, fragmentTag.end - tag.value.length, backtick, placeholderFor, parameterOffset);
+            if (fragment !== undefined) {
+                fragments.push({ base, prefix: [...prefix], fragment, parameterOffset });
+                prefix.push(fragment);
+                parameterOffset += fragment.parameterCount;
+                fragmentCursor = fragment.range.end;
+            }
+        }
+        index = close + 1;
+    }
+    return fragments;
+}
 export function mapSqlRange(source, query, range) {
     const start = query.sqlOffsetMap[range.start] ?? query.range.start;
     const last = range.end > range.start ? query.sqlOffsetMap[range.end - 1] : start;