@supabase/pg-delta 1.0.0-alpha.2 → 1.0.0-alpha.4

package/dist/core/plan/sql-format/protect.d.ts

@@ -0,0 +1,3 @@
+import type { NormalizedOptions, ProtectedSegments } from "./types.ts";
+export declare function protectSegments(statement: string, options: NormalizedOptions): ProtectedSegments;
+export declare function restorePlaceholders(text: string, placeholders: Map<string, string>): string;

package/dist/core/plan/sql-format/protect.js

@@ -0,0 +1,269 @@
+import { isEscapeStringQuoteStart, readDollarTag } from "./sql-scanner.js";
+import { scanTokens } from "./tokenizer.js";
+export function protectSegments(statement, options) {
+    let text = statement;
+    const placeholders = new Map();
+    const noWrapPlaceholders = new Set();
+    const state = {
+        placeholders,
+        noWrapPlaceholders,
+        counter: 0,
+        skipCasing: false,
+    };
+    if (options.preserveRoutineBodies) {
+        ({ text } = protectTailAfterAs(text, ["FUNCTION", "PROCEDURE"], state));
+    }
+    if (options.preserveViewBodies) {
+        ({ text } = protectTailAfterAs(text, ["VIEW"], state));
+    }
+    if (options.preserveRuleBodies) {
+        ({ text } = protectTailAfterAs(text, ["RULE"], state));
+    }
+    ({ text } = protectCommentLiteral(text, state));
+    ({ text } = protectDollarQuotes(text, state));
+    return {
+        text,
+        placeholders,
+        noWrapPlaceholders,
+        skipCasing: state.skipCasing,
+    };
+}
+function protectTailAfterAs(text, objectKeywords, state) {
+    const tokens = scanTokens(text);
+    if (tokens.length === 0)
+        return { text };
+    for (let i = 0; i < tokens.length; i += 1) {
+        if (tokens[i].upper !== "CREATE")
+            continue;
+        let cursor = i + 1;
+        if (tokens[cursor]?.upper === "OR" &&
+            tokens[cursor + 1]?.upper === "REPLACE") {
+            cursor += 2;
+        }
+        // Handle compound keywords: MATERIALIZED VIEW, FOREIGN TABLE, EVENT TRIGGER
+        if (tokens[cursor]?.upper === "MATERIALIZED" ||
+            tokens[cursor]?.upper === "FOREIGN" ||
+            tokens[cursor]?.upper === "EVENT") {
+            cursor += 1;
+        }
+        const objectToken = tokens[cursor];
+        if (!objectToken || !objectKeywords.includes(objectToken.upper)) {
+            continue;
+        }
+        const asToken = tokens
+            .slice(cursor + 1)
+            .find((token) => token.upper === "AS" &&
+            token.depth === 0 &&
+            isKeywordBoundary(text, token));
+        if (!asToken)
+            continue;
+        const placeholder = makePlaceholder(state.counter);
+        state.counter += 1;
+        state.placeholders.set(placeholder, text.slice(asToken.start));
+        state.noWrapPlaceholders.add(placeholder);
+        const updated = `${text.slice(0, asToken.start)}${placeholder}`;
+        return { text: updated };
+    }
+    return { text };
+}
+function protectCommentLiteral(text, state) {
+    const tokens = scanTokens(text);
+    if (tokens.length < 4)
+        return { text };
+    if (tokens[0].upper !== "COMMENT" || tokens[1].upper !== "ON") {
+        return { text };
+    }
+    const isToken = tokens
+        .slice(2)
+        .find((token) => token.depth === 0 && token.upper === "IS");
+    if (!isToken)
+        return { text };
+    let literalStart = isToken.end;
+    while (literalStart < text.length && /\s/.test(text[literalStart])) {
+        literalStart += 1;
+    }
+    if (literalStart >= text.length)
+        return { text };
+    if (/^NULL\b/i.test(text.slice(literalStart))) {
+        return { text };
+    }
+    const first = text[literalStart];
+    let quoteStart = -1;
+    let isEscapeString = false;
+    if (first === "'") {
+        quoteStart = literalStart;
+    }
+    else if ((first === "E" || first === "e") &&
+        text[literalStart + 1] === "'") {
+        quoteStart = literalStart + 1;
+        isEscapeString = true;
+    }
+    else if ((first === "U" || first === "u") &&
+        text[literalStart + 1] === "&" &&
+        text[literalStart + 2] === "'") {
+        quoteStart = literalStart + 2;
+    }
+    else {
+        return { text };
+    }
+    let literalEnd = -1;
+    let cursor = quoteStart + 1;
+    while (cursor < text.length) {
+        if (isEscapeString && text[cursor] === "\\") {
+            const hasEscapedChar = cursor + 1 < text.length;
+            cursor += hasEscapedChar ? 2 : 1;
+            continue;
+        }
+        if (text[cursor] === "'") {
+            if (text[cursor + 1] === "'") {
+                cursor += 2;
+                continue;
+            }
+            literalEnd = cursor + 1;
+            break;
+        }
+        cursor += 1;
+    }
+    if (literalEnd === -1) {
+        state.skipCasing = true;
+        return { text };
+    }
+    const placeholder = makePlaceholder(state.counter);
+    state.counter += 1;
+    state.placeholders.set(placeholder, text.slice(literalStart, literalEnd));
+    const updated = `${text.slice(0, literalStart)}${placeholder}${text.slice(literalEnd)}`;
+    return { text: updated };
+}
+function protectDollarQuotes(text, state) {
+    let output = "";
+    let inSingleQuote = false;
+    let singleQuoteEscapeMode = false;
+    let inDoubleQuote = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    let i = 0;
+    while (i < text.length) {
+        const char = text[i];
+        const next = text[i + 1];
+        if (inLineComment) {
+            output += char;
+            if (char === "\n") {
+                inLineComment = false;
+            }
+            i += 1;
+            continue;
+        }
+        if (inBlockComment) {
+            if (char === "*" && next === "/") {
+                output += "*/";
+                inBlockComment = false;
+                i += 2;
+                continue;
+            }
+            output += char;
+            i += 1;
+            continue;
+        }
+        if (inSingleQuote) {
+            if (singleQuoteEscapeMode && char === "\\") {
+                if (next !== undefined) {
+                    output += `\\${next}`;
+                    i += 2;
+                }
+                else {
+                    output += char;
+                    i += 1;
+                }
+                continue;
+            }
+            output += char;
+            if (char === "'") {
+                if (next === "'") {
+                    output += next;
+                    i += 2;
+                    continue;
+                }
+                inSingleQuote = false;
+                singleQuoteEscapeMode = false;
+            }
+            i += 1;
+            continue;
+        }
+        if (inDoubleQuote) {
+            output += char;
+            if (char === '"') {
+                if (next === '"') {
+                    output += next;
+                    i += 2;
+                    continue;
+                }
+                inDoubleQuote = false;
+            }
+            i += 1;
+            continue;
+        }
+        if (char === "-" && next === "-") {
+            output += "--";
+            inLineComment = true;
+            i += 2;
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            output += "/*";
+            inBlockComment = true;
+            i += 2;
+            continue;
+        }
+        if (char === "'") {
+            inSingleQuote = true;
+            singleQuoteEscapeMode = isEscapeStringQuoteStart(text, i);
+            output += char;
+            i += 1;
+            continue;
+        }
+        if (char === '"') {
+            inDoubleQuote = true;
+            output += char;
+            i += 1;
+            continue;
+        }
+        if (char === "$") {
+            const tag = readDollarTag(text, i);
+            if (tag) {
+                const start = i;
+                const end = text.indexOf(tag, i + tag.length);
+                if (end !== -1) {
+                    const placeholder = makePlaceholder(state.counter);
+                    state.counter += 1;
+                    state.placeholders.set(placeholder, text.slice(start, end + tag.length));
+                    output += placeholder;
+                    i = end + tag.length;
+                    continue;
+                }
+                state.skipCasing = true;
+                output += char;
+                i += 1;
+                continue;
+            }
+        }
+        output += char;
+        i += 1;
+    }
+    return { text: output };
+}
+export function restorePlaceholders(text, placeholders) {
+    let output = text;
+    for (const [placeholder, value] of placeholders.entries()) {
+        output = output.replaceAll(placeholder, () => value);
+    }
+    return output;
+}
+function isKeywordBoundary(statement, token) {
+    const before = statement[token.start - 1];
+    const after = statement[token.end];
+    const isBoundary = (value) => value === undefined || !/[A-Za-z0-9_$.]/.test(value);
+    return isBoundary(before) && isBoundary(after);
+}
+function makePlaceholder(index) {
+    return `__PGDELTA_PLACEHOLDER_${index}__`;
+}

package/dist/core/plan/sql-format/sql-scanner.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Unified SQL scanner that handles quote/comment/dollar-tag state machines.
+ */
+/**
+ * Callback invoked for each character that is NOT inside a quoted string,
+ * comment, or dollar-quoted block.
+ *
+ * @param index - position in the text
+ * @param char - the character at that position
+ * @param depth - current parenthesis depth (only tracked when `trackDepth` is true, else always 0)
+ * @returns `false` to stop walking early; `true` to continue
+ */
+type WalkCallback = (index: number, char: string, depth: number) => boolean;
+type WalkSqlOptions = {
+    /** Track parenthesis depth and pass it to the callback. Default: false */
+    trackDepth?: boolean;
+    /** Start scanning from this index. Default: 0 */
+    startIndex?: number;
+    /**
+     * Called for characters/sequences inside quoted strings, comments, and
+     * dollar-quoted blocks (i.e., characters the walker "skips" over).
+     * Also called for quote/comment opener sequences (e.g., `--`, `/*`, `'`, `"`).
+     *
+     * NOT called for top-level characters — those go only to `onTopLevel`.
+     *
+     * For multi-char sequences (block comment open/close, dollar tags, escaped quotes),
+     * called once with the full sequence.
+     */
+    onSkipped?: (chunk: string) => void;
+};
+/**
+ * Fast character-code check: A-Z, a-z, 0-9, _
+ */
+export declare function isWordChar(char: string): boolean;
+/**
+ * Return true when the single quote at `quoteIndex` starts a PostgreSQL
+ * escape string literal (`E'...'`). Only E-strings use backslash escaping;
+ * U&-strings use standard '' quoting (backslash is for Unicode escapes only).
+ */
+export declare function isEscapeStringQuoteStart(text: string, quoteIndex: number): boolean;
+/**
+ * Read a dollar-quote tag starting at `start` (which must be `$`).
+ * Returns the full tag including both `$` delimiters, e.g. `$$` or `$fn$`.
+ */
+export declare function readDollarTag(text: string, start: number): string | null;
+/**
+ * Walk through SQL text, calling `onTopLevel` for each character that is
+ * outside of quotes, comments, and dollar-quoted blocks.
+ *
+ * The walker handles:
+ * - Single-quoted strings (with '' escaping)
+ * - Double-quoted identifiers (with "" escaping)
+ * - Line comments (--)
+ * - Block comments (/* ... * /)
+ * - Dollar-quoted strings ($tag$...$tag$)
+ * - Parenthesis depth tracking (optional)
+ */
+export declare function walkSql(text: string, onTopLevel: WalkCallback, options?: WalkSqlOptions): void;
+export {};

package/dist/core/plan/sql-format/sql-scanner.js

@@ -0,0 +1,202 @@
+/**
+ * Unified SQL scanner that handles quote/comment/dollar-tag state machines.
+ */
+/**
+ * Fast character-code check: A-Z, a-z, 0-9, _
+ */
+export function isWordChar(char) {
+    const c = char.charCodeAt(0);
+    return ((c >= 65 && c <= 90) ||
+        (c >= 97 && c <= 122) ||
+        (c >= 48 && c <= 57) ||
+        c === 95);
+}
+/**
+ * Return true when the single quote at `quoteIndex` starts a PostgreSQL
+ * escape string literal (`E'...'`). Only E-strings use backslash escaping;
+ * U&-strings use standard '' quoting (backslash is for Unicode escapes only).
+ */
+export function isEscapeStringQuoteStart(text, quoteIndex) {
+    if (text[quoteIndex] !== "'")
+        return false;
+    const prev = text[quoteIndex - 1];
+    const prev2 = text[quoteIndex - 2];
+    if ((prev === "E" || prev === "e") &&
+        (prev2 === undefined || !isWordChar(prev2))) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Read a dollar-quote tag starting at `start` (which must be `$`).
+ * Returns the full tag including both `$` delimiters, e.g. `$$` or `$fn$`.
+ */
+export function readDollarTag(text, start) {
+    if (text[start] !== "$")
+        return null;
+    let i = start + 1;
+    while (i < text.length && isWordChar(text[i])) {
+        i += 1;
+    }
+    if (text[i] === "$") {
+        return text.slice(start, i + 1);
+    }
+    return null;
+}
+/**
+ * Walk through SQL text, calling `onTopLevel` for each character that is
+ * outside of quotes, comments, and dollar-quoted blocks.
+ *
+ * The walker handles:
+ * - Single-quoted strings (with '' escaping)
+ * - Double-quoted identifiers (with "" escaping)
+ * - Line comments (--)
+ * - Block comments (/* ... * /)
+ * - Dollar-quoted strings ($tag$...$tag$)
+ * - Parenthesis depth tracking (optional)
+ */
+export function walkSql(text, onTopLevel, options) {
+    const trackDepth = options?.trackDepth ?? false;
+    const startIndex = options?.startIndex ?? 0;
+    const onSkipped = options?.onSkipped;
+    let inSingleQuote = false;
+    let singleQuoteEscapeMode = false;
+    let inDoubleQuote = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    let dollarTag = null;
+    let depth = 0;
+    let i = startIndex;
+    while (i < text.length) {
+        const char = text[i];
+        const next = text[i + 1];
+        // --- Inside line comment ---
+        if (inLineComment) {
+            onSkipped?.(char);
+            if (char === "\n")
+                inLineComment = false;
+            i += 1;
+            continue;
+        }
+        // --- Inside block comment ---
+        if (inBlockComment) {
+            if (char === "*" && next === "/") {
+                onSkipped?.("*/");
+                inBlockComment = false;
+                i += 2;
+                continue;
+            }
+            onSkipped?.(char);
+            i += 1;
+            continue;
+        }
+        // --- Inside dollar-quoted string ---
+        if (dollarTag) {
+            if (text.startsWith(dollarTag, i)) {
+                onSkipped?.(dollarTag);
+                i += dollarTag.length;
+                dollarTag = null;
+                continue;
+            }
+            onSkipped?.(char);
+            i += 1;
+            continue;
+        }
+        // --- Inside single-quoted string ---
+        if (inSingleQuote) {
+            if (singleQuoteEscapeMode && char === "\\") {
+                if (next !== undefined) {
+                    onSkipped?.(`\\${next}`);
+                    i += 2;
+                }
+                else {
+                    onSkipped?.(char);
+                    i += 1;
+                }
+                continue;
+            }
+            if (char === "'") {
+                if (next === "'") {
+                    onSkipped?.("''");
+                    i += 2;
+                    continue;
+                }
+                inSingleQuote = false;
+                singleQuoteEscapeMode = false;
+            }
+            onSkipped?.(char);
+            i += 1;
+            continue;
+        }
+        // --- Inside double-quoted identifier ---
+        if (inDoubleQuote) {
+            if (char === '"') {
+                if (next === '"') {
+                    onSkipped?.('""');
+                    i += 2;
+                    continue;
+                }
+                inDoubleQuote = false;
+            }
+            onSkipped?.(char);
+            i += 1;
+            continue;
+        }
+        // --- Top-level: check for quote/comment openers ---
+        if (char === "-" && next === "-") {
+            onSkipped?.("--");
+            inLineComment = true;
+            i += 2;
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            onSkipped?.("/*");
+            inBlockComment = true;
+            i += 2;
+            continue;
+        }
+        if (char === "'") {
+            inSingleQuote = true;
+            singleQuoteEscapeMode = isEscapeStringQuoteStart(text, i);
+            onSkipped?.(char);
+            i += 1;
+            continue;
+        }
+        if (char === '"') {
+            inDoubleQuote = true;
+            onSkipped?.(char);
+            i += 1;
+            continue;
+        }
+        if (char === "$") {
+            const tag = readDollarTag(text, i);
+            if (tag) {
+                dollarTag = tag;
+                onSkipped?.(tag);
+                i += tag.length;
+                continue;
+            }
+        }
+        // --- Depth tracking ---
+        if (trackDepth) {
+            if (char === "(") {
+                depth += 1;
+                if (onTopLevel(i, char, depth - 1) === false)
+                    return;
+                i += 1;
+                continue;
+            }
+            if (char === ")") {
+                depth = Math.max(0, depth - 1);
+                if (onTopLevel(i, char, depth) === false)
+                    return;
+                i += 1;
+                continue;
+            }
+        }
+        // --- Top-level character: invoke callback ---
+        if (onTopLevel(i, char, depth) === false)
+            return;
+        i += 1;
+    }
+}

package/dist/core/plan/sql-format/tokenizer.d.ts

@@ -0,0 +1,22 @@
+import type { Token } from "./types.ts";
+export declare function scanTokens(statement: string): Token[];
+export declare function findTopLevelParen(statement: string, startIndex: number): {
+    open: number;
+    close: number;
+} | null;
+/**
+ * Collect the starting positions of top-level clause keywords in a token list.
+ * Returns a sorted array of character offsets (Token.start values).
+ */
+export declare function findClausePositions(tokens: Token[], keywords: Set<string>): number[];
+/**
+ * Advance a cursor past a possibly schema-qualified name (e.g. `public.my_table`).
+ * Returns the new cursor position (pointing to the first token after the name).
+ */
+export declare function skipQualifiedName(statement: string, tokens: Token[], cursor: number): number;
+/**
+ * Slice a text into clause strings given sorted clause-start positions.
+ * Returns trimmed, non-empty clause strings.
+ */
+export declare function sliceClauses(text: string, positions: number[]): string[];
+export declare function splitByCommas(content: string): string[];

package/dist/core/plan/sql-format/tokenizer.js

@@ -0,0 +1,118 @@
+import { isWordChar, walkSql } from "./sql-scanner.js";
+export function scanTokens(statement) {
+    const tokens = [];
+    let skipUntil = -1;
+    walkSql(statement, (index, char, depth) => {
+        if (index < skipUntil)
+            return true;
+        if (char === "(" || char === ")")
+            return true;
+        if (isWordChar(char)) {
+            let end = index + 1;
+            while (end < statement.length && isWordChar(statement[end])) {
+                end += 1;
+            }
+            const value = statement.slice(index, end);
+            tokens.push({
+                value,
+                upper: value.toUpperCase(),
+                start: index,
+                end,
+                depth,
+            });
+            skipUntil = end;
+        }
+        return true;
+    }, { trackDepth: true });
+    return tokens;
+}
+export function findTopLevelParen(statement, startIndex) {
+    let result = null;
+    let openIndex = null;
+    walkSql(statement, (index, char, depth) => {
+        if (char === "(") {
+            if (depth === 0) {
+                openIndex = index;
+            }
+            return true;
+        }
+        if (char === ")") {
+            if (depth === 0 && openIndex !== null) {
+                result = { open: openIndex, close: index };
+                return false;
+            }
+        }
+        return true;
+    }, { trackDepth: true, startIndex });
+    return result;
+}
+/**
+ * Collect the starting positions of top-level clause keywords in a token list.
+ * Returns a sorted array of character offsets (Token.start values).
+ */
+export function findClausePositions(tokens, keywords) {
+    const positions = [];
+    for (let i = 0; i < tokens.length; i += 1) {
+        if (tokens[i].depth !== 0)
+            continue;
+        if (keywords.has(tokens[i].upper)) {
+            positions.push(tokens[i].start);
+        }
+    }
+    positions.sort((a, b) => a - b);
+    return positions;
+}
+/**
+ * Advance a cursor past a possibly schema-qualified name (e.g. `public.my_table`).
+ * Returns the new cursor position (pointing to the first token after the name).
+ */
+export function skipQualifiedName(statement, tokens, cursor) {
+    let c = cursor + 1;
+    while (c < tokens.length &&
+        tokens[c].start === tokens[c - 1].end + 1 &&
+        statement[tokens[c - 1].end] === ".") {
+        c += 1;
+    }
+    return c;
+}
+/**
+ * Slice a text into clause strings given sorted clause-start positions.
+ * Returns trimmed, non-empty clause strings.
+ */
+export function sliceClauses(text, positions) {
+    const clauses = [];
+    for (let i = 0; i < positions.length; i += 1) {
+        const start = positions[i];
+        const end = positions[i + 1] ?? text.length;
+        const clause = text.slice(start, end).trim();
+        if (clause.length > 0)
+            clauses.push(clause);
+    }
+    return clauses;
+}
+export function splitByCommas(content) {
+    const items = [];
+    let buffer = "";
+    walkSql(content, (_index, char, depth) => {
+        if (char === "(" || char === ")") {
+            buffer += char;
+            return true;
+        }
+        if (char === "," && depth === 0) {
+            items.push(buffer);
+            buffer = "";
+            return true;
+        }
+        buffer += char;
+        return true;
+    }, {
+        trackDepth: true,
+        onSkipped: (chunk) => {
+            buffer += chunk;
+        },
+    });
+    if (buffer.length > 0) {
+        items.push(buffer);
+    }
+    return items.map((item) => item.trim()).filter((item) => item.length > 0);
+}

package/dist/core/plan/sql-format/types.d.ts

@@ -0,0 +1,28 @@
+type KeywordCase = "upper" | "lower" | "preserve";
+export type CommaStyle = "trailing" | "leading";
+export type SqlFormatOptions = {
+    keywordCase?: KeywordCase;
+    indent?: number;
+    maxWidth?: number;
+    commaStyle?: CommaStyle;
+    alignColumns?: boolean;
+    alignKeyValues?: boolean;
+    preserveRoutineBodies?: boolean;
+    preserveViewBodies?: boolean;
+    preserveRuleBodies?: boolean;
+};
+export type NormalizedOptions = Required<SqlFormatOptions>;
+export type Token = {
+    value: string;
+    upper: string;
+    start: number;
+    end: number;
+    depth: number;
+};
+export type ProtectedSegments = {
+    text: string;
+    placeholders: Map<string, string>;
+    noWrapPlaceholders: Set<string>;
+    skipCasing: boolean;
+};
+export {};