@supabase/pg-delta 1.0.0-alpha.3 → 1.0.0-alpha.5

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

@@ -0,0 +1,37 @@
+import type { CommaStyle, NormalizedOptions } from "./types.ts";
+export declare function splitSqlStatements(sql: string): string[];
+export declare function splitLeadingComments(statement: string): {
+    commentLines: string[];
+    body: string;
+};
+export declare function formatColumnList(content: string, options: NormalizedOptions): string[] | null;
+type DefinitionBounds = {
+    nameStart: number;
+    nameEnd: number;
+    typeStart: number;
+    typeEnd: number;
+    tailStart: number;
+};
+type ParsedDefinitionItem = {
+    name: string;
+    type: string;
+    tail: string;
+    bounds: DefinitionBounds;
+};
+export declare function parseDefinitionItem(definition: string): ParsedDefinitionItem | null;
+export declare function formatKeyValueItems(items: string[], options: NormalizedOptions, indentOverride?: string): string[];
+export declare function formatListItems(items: string[], indent: string, style: CommaStyle): string[];
+/**
+ * Format a mixed list of key-value pairs and plain items (e.g. aggregate options).
+ * Items with `=` are formatted as key-value, others are formatted as-is.
+ * Reuses `parseKeyValue` — items without `=` are left as-is.
+ */
+export declare function formatMixedItems(items: string[], options: NormalizedOptions, indentOverride?: string): string[];
+/**
+ * Join a header line with indented clause strings.
+ * An optional `clauseTransform` can modify each clause before indenting
+ * (e.g. to expand OPTIONS(...) sub-clauses).
+ */
+export declare function joinHeaderAndClauses(header: string, clauses: string[], options: NormalizedOptions, clauseTransform?: (clause: string, indent: string, options: NormalizedOptions) => string[]): string;
+export declare function indentString(size: number): string;
+export {};

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

@@ -0,0 +1,274 @@
+import { isWordChar, walkSql } from "./sql-scanner.js";
+import { scanTokens, splitByCommas } from "./tokenizer.js";
+export function splitSqlStatements(sql) {
+    const statements = [];
+    let buffer = "";
+    walkSql(sql, (_index, char) => {
+        if (char === ";") {
+            const trimmed = trimOuterBlankLines(buffer);
+            if (trimmed.length > 0) {
+                statements.push(trimmed);
+            }
+            buffer = "";
+            return true;
+        }
+        buffer += char;
+        return true;
+    }, {
+        onSkipped: (chunk) => {
+            buffer += chunk;
+        },
+    });
+    const trailing = trimOuterBlankLines(buffer);
+    if (trailing.length > 0) {
+        statements.push(trailing);
+    }
+    return statements;
+}
+export function splitLeadingComments(statement) {
+    const lines = statement.split(/\r?\n/);
+    const commentLines = [];
+    let index = 0;
+    while (index < lines.length &&
+        (lines[index].trim().startsWith("--") || lines[index].trim() === "")) {
+        commentLines.push(lines[index]);
+        index += 1;
+    }
+    const body = trimOuterBlankLines(lines.slice(index).join("\n"));
+    return { commentLines, body };
+}
+function trimOuterBlankLines(text) {
+    const lines = text.split(/\r?\n/);
+    while (lines.length > 0 && lines[0].trim().length === 0) {
+        lines.shift();
+    }
+    while (lines.length > 0 && lines[lines.length - 1].trim().length === 0) {
+        lines.pop();
+    }
+    return lines.join("\n");
+}
+export function formatColumnList(content, options) {
+    if (content.trim().length === 0) {
+        return null;
+    }
+    const items = splitByCommas(content);
+    if (items.length === 0)
+        return null;
+    const parsed = items.map((item) => parseDefinitionItem(item));
+    const maxName = parsed.reduce((max, column) => (column ? Math.max(max, column.name.length) : max), 0);
+    const maxType = parsed.reduce((max, column) => (column ? Math.max(max, column.type.length) : max), 0);
+    const indent = indentString(options.indent);
+    const lines = [];
+    for (let index = 0; index < items.length; index += 1) {
+        const item = items[index].trim();
+        const column = parsed[index];
+        let line = item;
+        if (column) {
+            const name = options.alignColumns
+                ? column.name.padEnd(maxName)
+                : column.name;
+            const type = options.alignColumns
+                ? column.type.padEnd(maxType)
+                : column.type;
+            line = `${name} ${type}`;
+            if (column.tail) {
+                line += ` ${column.tail}`;
+            }
+            else {
+                line = line.trimEnd();
+            }
+        }
+        const lineWithComma = applyCommaStyle(line, index, items.length, options.commaStyle);
+        lines.push(`${indent}${lineWithComma}`);
+    }
+    return lines;
+}
+export function parseDefinitionItem(definition) {
+    let i = 0;
+    const trimmed = definition.trim();
+    if (trimmed.length === 0)
+        return null;
+    let name = "";
+    if (trimmed[i] === '"') {
+        i += 1;
+        while (i < trimmed.length) {
+            if (trimmed[i] === '"') {
+                if (trimmed[i + 1] === '"') {
+                    i += 2;
+                    continue;
+                }
+                i += 1;
+                break;
+            }
+            i += 1;
+        }
+        name = trimmed.slice(0, i);
+    }
+    else {
+        while (i < trimmed.length && isWordChar(trimmed[i])) {
+            i += 1;
+        }
+        name = trimmed.slice(0, i);
+    }
+    if (name.length === 0)
+        return null;
+    const nameUpper = name.replace(/^"|"$/g, "").toUpperCase();
+    const constraintStarts = new Set([
+        "PRIMARY",
+        "UNIQUE",
+        "CHECK",
+        "FOREIGN",
+        "CONSTRAINT",
+    ]);
+    if (constraintStarts.has(nameUpper)) {
+        return null;
+    }
+    let restStart = i;
+    while (restStart < trimmed.length && /\s/.test(trimmed[restStart])) {
+        restStart += 1;
+    }
+    if (restStart >= trimmed.length)
+        return null;
+    const rest = trimmed.slice(restStart);
+    const boundaryKeywords = new Set([
+        "COLLATE",
+        "DEFAULT",
+        "NOT",
+        "GENERATED",
+        "CONSTRAINT",
+        "CHECK",
+        "REFERENCES",
+        "PRIMARY",
+        "UNIQUE",
+    ]);
+    const tokens = scanTokens(rest);
+    let boundaryIndex = null;
+    for (const token of tokens) {
+        if (token.depth !== 0)
+            continue;
+        if (boundaryKeywords.has(token.upper)) {
+            boundaryIndex = token.start;
+            break;
+        }
+    }
+    let typeEnd = boundaryIndex === null ? trimmed.length : restStart + boundaryIndex;
+    while (typeEnd > restStart && /\s/.test(trimmed[typeEnd - 1])) {
+        typeEnd -= 1;
+    }
+    let tailStart = typeEnd;
+    if (boundaryIndex !== null) {
+        tailStart = restStart + boundaryIndex;
+        while (tailStart < trimmed.length && /\s/.test(trimmed[tailStart])) {
+            tailStart += 1;
+        }
+    }
+    const type = trimmed.slice(restStart, typeEnd);
+    const tail = boundaryIndex === null ? "" : trimmed.slice(tailStart).trim();
+    if (type.length === 0)
+        return null;
+    return {
+        name,
+        type,
+        tail,
+        bounds: {
+            nameStart: 0,
+            nameEnd: name.length,
+            typeStart: restStart,
+            typeEnd,
+            tailStart,
+        },
+    };
+}
+export function formatKeyValueItems(items, options, indentOverride) {
+    const indent = indentOverride ?? indentString(options.indent);
+    const parsed = items.map((item) => parseKeyValue(item));
+    const maxKey = parsed.reduce((max, entry) => (entry ? Math.max(max, entry.key.length) : max), 0);
+    return parsed.map((entry, index) => {
+        let line = items[index].trim();
+        if (entry) {
+            let key = entry.key;
+            if (options.alignKeyValues) {
+                key = key.padEnd(maxKey);
+            }
+            line = `${key} = ${entry.value}`;
+        }
+        const lineWithComma = applyCommaStyle(line, index, items.length, options.commaStyle);
+        return `${indent}${lineWithComma}`;
+    });
+}
+function parseKeyValue(item) {
+    const trimmed = item.trim();
+    if (trimmed.length === 0)
+        return null;
+    let result = null;
+    walkSql(trimmed, (index, char, depth) => {
+        if (char === "(" || char === ")")
+            return true;
+        if (char === "=" && depth === 0) {
+            const key = trimmed.slice(0, index).trim();
+            const value = trimmed.slice(index + 1).trim();
+            if (key.length > 0 && value.length > 0) {
+                result = { key, value };
+            }
+            return false;
+        }
+        return true;
+    }, { trackDepth: true });
+    return result;
+}
+function applyCommaStyle(line, index, total, style) {
+    if (style === "leading") {
+        return index === 0 ? `  ${line}` : `, ${line}`;
+    }
+    return index < total - 1 ? `${line},` : line;
+}
+export function formatListItems(items, indent, style) {
+    return items.map((item, index) => {
+        const line = item.trim();
+        const lineWithComma = applyCommaStyle(line, index, items.length, style);
+        return `${indent}${lineWithComma}`;
+    });
+}
+/**
+ * Format a mixed list of key-value pairs and plain items (e.g. aggregate options).
+ * Items with `=` are formatted as key-value, others are formatted as-is.
+ * Reuses `parseKeyValue` — items without `=` are left as-is.
+ */
+export function formatMixedItems(items, options, indentOverride) {
+    const indent = indentOverride ?? indentString(options.indent);
+    const parsed = items.map((item) => parseKeyValue(item));
+    const maxKey = parsed.reduce((max, entry) => (entry ? Math.max(max, entry.key.length) : max), 0);
+    return parsed.map((entry, index) => {
+        let line = items[index].trim();
+        if (entry) {
+            let key = entry.key;
+            if (options.alignKeyValues) {
+                key = key.padEnd(maxKey);
+            }
+            line = `${key} = ${entry.value}`;
+        }
+        const lineWithComma = applyCommaStyle(line, index, items.length, options.commaStyle);
+        return `${indent}${lineWithComma}`;
+    });
+}
+/**
+ * Join a header line with indented clause strings.
+ * An optional `clauseTransform` can modify each clause before indenting
+ * (e.g. to expand OPTIONS(...) sub-clauses).
+ */
+export function joinHeaderAndClauses(header, clauses, options, clauseTransform) {
+    const indent = indentString(options.indent);
+    const lines = [header];
+    for (const clause of clauses) {
+        if (clauseTransform) {
+            lines.push(...clauseTransform(clause, indent, options));
+        }
+        else {
+            lines.push(`${indent}${clause}`);
+        }
+    }
+    return lines.join("\n");
+}
+export function indentString(size) {
+    return " ".repeat(size);
+}

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

@@ -0,0 +1,20 @@
+import type { NormalizedOptions, Token } from "./types.ts";
+export declare function formatCreateDomain(statement: string, tokens: Token[], options: NormalizedOptions): string | null;
+export declare function formatCreateEnum(statement: string, tokens: Token[], options: NormalizedOptions): string | null;
+export declare function formatCreateCompositeType(statement: string, tokens: Token[], options: NormalizedOptions): string | null;
+export declare function formatCreateTable(statement: string, tokens: Token[], options: NormalizedOptions): string | null;
+export declare function formatCreateRange(statement: string, tokens: Token[], options: NormalizedOptions): string | null;
+export declare function formatCreateCollation(statement: string, tokens: Token[], options: NormalizedOptions): string | null;
+export declare function formatCreateFunction(statement: string, tokens: Token[], options: NormalizedOptions): string | null;
+export declare function formatCreatePolicy(statement: string, tokens: Token[], options: NormalizedOptions): string | null;
+export declare function formatCreateTrigger(statement: string, tokens: Token[], options: NormalizedOptions): string | null;
+export declare function formatCreateIndex(statement: string, tokens: Token[], options: NormalizedOptions): string | null;
+export declare function formatAlterTable(statement: string, tokens: Token[], options: NormalizedOptions): string | null;
+export declare function formatCreateAggregate(statement: string, tokens: Token[], options: NormalizedOptions): string | null;
+export declare function formatCreateLanguage(statement: string, tokens: Token[], options: NormalizedOptions): string | null;
+export declare function formatCreateMaterializedView(statement: string, tokens: Token[], options: NormalizedOptions): string | null;
+export declare function formatCreateSubscription(statement: string, tokens: Token[], options: NormalizedOptions): string | null;
+export declare function formatCreateFDW(statement: string, tokens: Token[], options: NormalizedOptions): string | null;
+export declare function formatCreateServer(statement: string, tokens: Token[], options: NormalizedOptions): string | null;
+export declare function formatAlterGeneric(statement: string, tokens: Token[], options: NormalizedOptions): string | null;
+export declare function formatGeneric(statement: string, _tokens: Token[], _options: NormalizedOptions): string;