relq 1.0.0 → 1.0.2

package/dist/cjs/cli/utils/relqignore.cjs

@@ -33,31 +33,114 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePattern = parsePattern;
 exports.loadRelqignore = loadRelqignore;
 exports.createDefaultRelqignore = createDefaultRelqignore;
 exports.isIgnored = isIgnored;
-exports.filterIgnored = filterIgnored;
+exports.isTableIgnored = isTableIgnored;
+exports.isColumnIgnored = isColumnIgnored;
+exports.isIndexIgnored = isIndexIgnored;
+exports.isConstraintIgnored = isConstraintIgnored;
+exports.isTriggerIgnored = isTriggerIgnored;
+exports.isEnumIgnored = isEnumIgnored;
+exports.isDomainIgnored = isDomainIgnored;
+exports.isSequenceIgnored = isSequenceIgnored;
+exports.isCompositeTypeIgnored = isCompositeTypeIgnored;
+exports.isFunctionIgnored = isFunctionIgnored;
+exports.isViewIgnored = isViewIgnored;
+exports.validateIgnoreDependencies = validateIgnoreDependencies;
+exports.filterTables = filterTables;
+exports.filterColumns = filterColumns;
+exports.filterIndexes = filterIndexes;
+exports.filterEnums = filterEnums;
+exports.filterDomains = filterDomains;
 exports.getIgnorePatterns = getIgnorePatterns;
+exports.filterIgnored = filterIgnored;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const REQUIRES_PARENT = [
+    'COLUMN', 'INDEX', 'CONSTRAINT', 'CHECK', 'PRIMARY_KEY',
+    'FOREIGN_KEY', 'EXCLUSION', 'PARTITION', 'TRIGGER'
+];
 const DEFAULT_PATTERNS = [
-    '_relq_*',
-    'pg_*',
-    '_temp_*',
-    'tmp_*',
+    'TABLE:_relq_*',
+    'TABLE:pg_*',
+    'TABLE:_temp_*',
+    'TABLE:tmp_*',
 ];
+function parsePattern(line) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) {
+        return null;
+    }
+    let negated = false;
+    let pattern = trimmed;
+    if (pattern.startsWith('!')) {
+        negated = true;
+        pattern = pattern.slice(1);
+    }
+    const colonIndex = pattern.indexOf(':');
+    if (colonIndex > 0) {
+        const typeStr = pattern.slice(0, colonIndex).toUpperCase();
+        const rest = pattern.slice(colonIndex + 1);
+        const validTypes = [
+            'TABLE', 'COLUMN', 'INDEX', 'CONSTRAINT', 'CHECK', 'PRIMARY_KEY',
+            'FOREIGN_KEY', 'EXCLUSION', 'PARTITION', 'ENUM', 'DOMAIN', 'SEQUENCE',
+            'COMPOSITE_TYPE', 'FUNCTION', 'PROCEDURE', 'TRIGGER', 'VIEW',
+            'MATERIALIZED_VIEW', 'FOREIGN_TABLE', 'EXTENSION', 'COLLATION'
+        ];
+        if (validTypes.includes(typeStr)) {
+            const type = typeStr;
+            if (REQUIRES_PARENT.includes(type)) {
+                const dotIndex = rest.indexOf('.');
+                if (dotIndex > 0) {
+                    return {
+                        type,
+                        parent: rest.slice(0, dotIndex),
+                        pattern: rest.slice(dotIndex + 1),
+                        negated,
+                        raw: trimmed,
+                    };
+                }
+                else {
+                    console.warn(`Warning: ${type} pattern requires table name (e.g., ${type}:table_name.pattern)`);
+                    return null;
+                }
+            }
+            else {
+                return {
+                    type,
+                    parent: null,
+                    pattern: rest,
+                    negated,
+                    raw: trimmed,
+                };
+            }
+        }
+    }
+    return {
+        type: 'TABLE',
+        parent: null,
+        pattern,
+        negated,
+        raw: trimmed,
+    };
+}
 function loadRelqignore(projectRoot = process.cwd()) {
     const ignorePath = path.join(projectRoot, '.relqignore');
-    const patterns = [...DEFAULT_PATTERNS];
+    const patterns = [];
+    for (const defaultPattern of DEFAULT_PATTERNS) {
+        const parsed = parsePattern(defaultPattern);
+        if (parsed)
+            patterns.push(parsed);
+    }
     if (fs.existsSync(ignorePath)) {
         const content = fs.readFileSync(ignorePath, 'utf-8');
         const lines = content.split('\n');
         for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed || trimmed.startsWith('#')) {
-                continue;
-            }
-            patterns.push(trimmed);
+            const parsed = parsePattern(line);
+            if (parsed)
+                patterns.push(parsed);
         }
     }
     return patterns;
@@ -68,40 +151,58 @@ function createDefaultRelqignore(projectRoot = process.cwd()) {
         return;
     }
     const content = `# Relq Ignore File
-# Tables and functions matching these patterns will be ignored
+# Objects matching these patterns will be ignored in import/export/add/commit
+
+# =============================================================================
+# PATTERN FORMAT
+# =============================================================================
+# TYPE:pattern              - Match specific object type
+# TYPE:table.pattern        - Match sub-objects (columns, indexes, etc.)
+# pattern                   - Match tables (backward compatible)
+# !pattern                  - Negate (un-ignore) a pattern
+
+# =============================================================================
+# TYPES
+# =============================================================================
+# TABLE, COLUMN, INDEX, CONSTRAINT, CHECK, PRIMARY_KEY, FOREIGN_KEY, EXCLUSION
+# PARTITION, ENUM, DOMAIN, SEQUENCE, COMPOSITE_TYPE, FUNCTION, PROCEDURE
+# TRIGGER, VIEW, MATERIALIZED_VIEW, FOREIGN_TABLE, EXTENSION, COLLATION
+
+# =============================================================================
+# DEFAULT PATTERNS (always applied)
+# =============================================================================
+# TABLE:_relq_*          - Relq internal tables
+# TABLE:pg_*             - PostgreSQL system tables
+# TABLE:_temp_*          - Temporary tables
+# TABLE:tmp_*            - Temporary tables
+
+# =============================================================================
+# EXAMPLES
+# =============================================================================
 
-# Relq internal tables (always ignored)
-_relq_*
+# Ignore specific tables
+# TABLE:debug_*
+# TABLE:test_*
 
-# PostgreSQL system tables
-pg_*
+# Ignore sensitive columns (table.column format required)
+# COLUMN:users.password_hash
+# COLUMN:*.api_key
 
-# Temporary tables
-_temp_*
-tmp_*
+# Ignore temporary indexes
+# INDEX:*.idx_temp_*
 
-# Add your tables/functions to ignore below:
-# analytics_raw
-# debug_*
-# test_*
+# Ignore debug functions
+# FUNCTION:debug_*
+
+# Ignore internal triggers
+# TRIGGER:audit_logs.*
+
+# Ignore test enums
+# ENUM:test_*
 `;
     fs.writeFileSync(ignorePath, content, 'utf-8');
 }
-function isIgnored(name, patterns) {
-    for (const pattern of patterns) {
-        if (matchPattern(name, pattern)) {
-            return true;
-        }
-    }
-    return false;
-}
-function filterIgnored(items, patterns) {
-    return items.filter(item => !isIgnored(item.name, patterns));
-}
-function matchPattern(name, pattern) {
-    if (pattern.startsWith('!')) {
-        return !matchPattern(name, pattern.slice(1));
-    }
+function matchGlob(name, pattern) {
     const regexPattern = pattern
         .replace(/[.+^${}()|[\]\\]/g, '\\$&')
         .replace(/\*/g, '.*')
@@ -109,6 +210,163 @@ function matchPattern(name, pattern) {
     const regex = new RegExp(`^${regexPattern}$`, 'i');
     return regex.test(name);
 }
+function isIgnored(objectType, objectName, parentName, patterns) {
+    let isIgnored = false;
+    let matchedPattern;
+    for (const pattern of patterns) {
+        if (pattern.type !== null && pattern.type !== objectType) {
+            continue;
+        }
+        if (pattern.parent !== null) {
+            if (parentName === null || !matchGlob(parentName, pattern.parent)) {
+                continue;
+            }
+        }
+        if (matchGlob(objectName, pattern.pattern)) {
+            if (pattern.negated) {
+                isIgnored = false;
+                matchedPattern = pattern;
+            }
+            else {
+                isIgnored = true;
+                matchedPattern = pattern;
+            }
+        }
+    }
+    return {
+        ignored: isIgnored,
+        pattern: matchedPattern,
+        reason: matchedPattern ? `Matched pattern: ${matchedPattern.raw}` : undefined,
+    };
+}
+function isTableIgnored(tableName, patterns) {
+    return isIgnored('TABLE', tableName, null, patterns);
+}
+function isColumnIgnored(tableName, columnName, patterns) {
+    return isIgnored('COLUMN', columnName, tableName, patterns);
+}
+function isIndexIgnored(tableName, indexName, patterns) {
+    return isIgnored('INDEX', indexName, tableName, patterns);
+}
+function isConstraintIgnored(tableName, constraintName, patterns) {
+    return isIgnored('CONSTRAINT', constraintName, tableName, patterns);
+}
+function isTriggerIgnored(tableName, triggerName, patterns) {
+    return isIgnored('TRIGGER', triggerName, tableName, patterns);
+}
+function isEnumIgnored(enumName, patterns) {
+    return isIgnored('ENUM', enumName, null, patterns);
+}
+function isDomainIgnored(domainName, patterns) {
+    return isIgnored('DOMAIN', domainName, null, patterns);
+}
+function isSequenceIgnored(sequenceName, patterns) {
+    return isIgnored('SEQUENCE', sequenceName, null, patterns);
+}
+function isCompositeTypeIgnored(typeName, patterns) {
+    return isIgnored('COMPOSITE_TYPE', typeName, null, patterns);
+}
+function isFunctionIgnored(functionName, patterns) {
+    return isIgnored('FUNCTION', functionName, null, patterns);
+}
+function isViewIgnored(viewName, patterns) {
+    return isIgnored('VIEW', viewName, null, patterns);
+}
+function validateIgnoreDependencies(schema, patterns) {
+    const errors = [];
+    const ignoredEnums = new Set();
+    const ignoredDomains = new Set();
+    const ignoredSequences = new Set();
+    const ignoredComposites = new Set();
+    for (const e of schema.enums) {
+        if (isEnumIgnored(e.name, patterns).ignored) {
+            ignoredEnums.add(e.name.toLowerCase());
+        }
+    }
+    for (const d of schema.domains) {
+        if (isDomainIgnored(d.name, patterns).ignored) {
+            ignoredDomains.add(d.name.toLowerCase());
+        }
+    }
+    for (const s of schema.sequences) {
+        if (isSequenceIgnored(s.name, patterns).ignored) {
+            ignoredSequences.add(s.name.toLowerCase());
+        }
+    }
+    for (const c of schema.compositeTypes) {
+        if (isCompositeTypeIgnored(c.name, patterns).ignored) {
+            ignoredComposites.add(c.name.toLowerCase());
+        }
+    }
+    for (const table of schema.tables) {
+        if (isTableIgnored(table.name, patterns).ignored) {
+            continue;
+        }
+        for (const column of table.columns) {
+            if (isColumnIgnored(table.name, column.name, patterns).ignored) {
+                continue;
+            }
+            const typeLower = column.type.toLowerCase().replace(/\[\]$/, '');
+            if (ignoredEnums.has(typeLower)) {
+                errors.push({
+                    type: 'ENUM',
+                    name: column.type,
+                    usedBy: { table: table.name, column: column.name },
+                    message: `Column "${table.name}.${column.name}" uses ignored ENUM "${column.type}". Either un-ignore the ENUM or ignore this column.`,
+                });
+            }
+            if (ignoredDomains.has(typeLower)) {
+                errors.push({
+                    type: 'DOMAIN',
+                    name: column.type,
+                    usedBy: { table: table.name, column: column.name },
+                    message: `Column "${table.name}.${column.name}" uses ignored DOMAIN "${column.type}". Either un-ignore the DOMAIN or ignore this column.`,
+                });
+            }
+            if (ignoredComposites.has(typeLower)) {
+                errors.push({
+                    type: 'COMPOSITE_TYPE',
+                    name: column.type,
+                    usedBy: { table: table.name, column: column.name },
+                    message: `Column "${table.name}.${column.name}" uses ignored COMPOSITE_TYPE "${column.type}". Either un-ignore the type or ignore this column.`,
+                });
+            }
+            if (column.default) {
+                const seqMatch = column.default.match(/nextval\(['"]?([^'"()]+)['"]?/i);
+                if (seqMatch) {
+                    const seqName = seqMatch[1].toLowerCase().replace(/::regclass$/, '');
+                    if (ignoredSequences.has(seqName)) {
+                        errors.push({
+                            type: 'SEQUENCE',
+                            name: seqMatch[1],
+                            usedBy: { table: table.name, column: column.name },
+                            message: `Column "${table.name}.${column.name}" uses ignored SEQUENCE "${seqMatch[1]}". Either un-ignore the SEQUENCE or ignore this column.`,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return errors;
+}
+function filterTables(tables, patterns) {
+    return tables.filter(t => !isTableIgnored(t.name, patterns).ignored);
+}
+function filterColumns(tableName, columns, patterns) {
+    return columns.filter(c => !isColumnIgnored(tableName, c.name, patterns).ignored);
+}
+function filterIndexes(tableName, indexes, patterns) {
+    return indexes.filter(i => !isIndexIgnored(tableName, i.name, patterns).ignored);
+}
+function filterEnums(enums, patterns) {
+    return enums.filter(e => !isEnumIgnored(e.name, patterns).ignored);
+}
+function filterDomains(domains, patterns) {
+    return domains.filter(d => !isDomainIgnored(d.name, patterns).ignored);
+}
 function getIgnorePatterns(projectRoot = process.cwd()) {
     return loadRelqignore(projectRoot);
 }
+function filterIgnored(items, patterns) {
+    return items.filter(item => !isTableIgnored(item.name, patterns).ignored);
+}

package/dist/cjs/cli/utils/repo-manager.cjs

@@ -69,6 +69,10 @@ exports.pushCommit = pushCommit;
 exports.getRepoStatus = getRepoStatus;
 exports.createEmptySchema = createEmptySchema;
 exports.migrateSnapshot = migrateSnapshot;
+exports.loadTags = loadTags;
+exports.saveTags = saveTags;
+exports.resolveRef = resolveRef;
+exports.loadParentCommit = loadParentCommit;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const crypto = __importStar(require("crypto"));
@@ -350,7 +354,7 @@ function hasUncommittedChanges(projectRoot = process.cwd()) {
     return state.staged.length > 0 || state.unstaged.length > 0;
 }
 async function ensureRemoteTable(connection) {
-    const { Pool } = await Promise.resolve().then(() => __importStar(require("../../../addons/pg.js")));
+    const { Pool } = await Promise.resolve().then(() => __importStar(require("../../addon/pg/index.cjs")));
     const pool = new Pool({
         host: connection.host,
         port: connection.port || 5432,
@@ -382,7 +386,7 @@ async function ensureRemoteTable(connection) {
     }
 }
 async function fetchRemoteCommits(connection, limit = 100) {
-    const { Pool } = await Promise.resolve().then(() => __importStar(require("../../../addons/pg.js")));
+    const { Pool } = await Promise.resolve().then(() => __importStar(require("../../addon/pg/index.cjs")));
     const pool = new Pool({
         host: connection.host,
         port: connection.port || 5432,
@@ -418,7 +422,7 @@ async function getRemoteHead(connection) {
     return commits.length > 0 ? commits[0].hash : null;
 }
 async function pushCommit(connection, commit) {
-    const { Pool } = await Promise.resolve().then(() => __importStar(require("../../../addons/pg.js")));
+    const { Pool } = await Promise.resolve().then(() => __importStar(require("../../addon/pg/index.cjs")));
     const pool = new Pool({
         host: connection.host,
         port: connection.port || 5432,
@@ -513,3 +517,41 @@ function migrateSnapshot(snapshot) {
         foreignTables: snapshot.foreignTables || [],
     };
 }
+function loadTags(projectRoot = process.cwd()) {
+    const tagPath = path.join(projectRoot, '.relq', 'tags.json');
+    if (fs.existsSync(tagPath)) {
+        return JSON.parse(fs.readFileSync(tagPath, 'utf-8'));
+    }
+    return {};
+}
+function saveTags(tags, projectRoot = process.cwd()) {
+    const tagPath = path.join(projectRoot, '.relq', 'tags.json');
+    fs.writeFileSync(tagPath, JSON.stringify(tags, null, 2));
+}
+function resolveRef(ref, projectRoot = process.cwd()) {
+    const commit = loadCommit(ref, projectRoot);
+    if (commit)
+        return commit.hash;
+    const tags = loadTags(projectRoot);
+    if (tags[ref])
+        return tags[ref].hash;
+    const headMatch = ref.match(/^HEAD~(\d+)$/);
+    if (headMatch) {
+        const offset = parseInt(headMatch[1]);
+        let current = getHead(projectRoot);
+        for (let i = 0; i < offset && current; i++) {
+            const c = loadCommit(current, projectRoot);
+            if (!c || !c.parentHash)
+                return null;
+            current = c.parentHash;
+        }
+        return current;
+    }
+    return null;
+}
+function loadParentCommit(hash, projectRoot = process.cwd()) {
+    const commit = loadCommit(hash, projectRoot);
+    if (!commit || !commit.parentHash)
+        return null;
+    return loadCommit(commit.parentHash, projectRoot);
+}

package/dist/cjs/cli/utils/schema-introspect.cjs

@@ -37,7 +37,7 @@ exports.introspectDatabase = introspectDatabase;
 exports.tableHasData = tableHasData;
 async function introspectDatabase(connection, onProgress, options) {
     const { includeFunctions = false, includeTriggers = false } = options || {};
-    const { Pool } = await Promise.resolve().then(() => __importStar(require("../../../addons/pg.js")));
+    const { Pool } = await Promise.resolve().then(() => __importStar(require("../../addon/pg/index.cjs")));
     onProgress?.('connecting', connection.database);
     const pool = new Pool({
         host: connection.host,
@@ -433,7 +433,7 @@ function parseOptions(options) {
     return result;
 }
 async function tableHasData(connection, tableName) {
-    const { Pool } = await Promise.resolve().then(() => __importStar(require("../../../addons/pg.js")));
+    const { Pool } = await Promise.resolve().then(() => __importStar(require("../../addon/pg/index.cjs")));
     const pool = new Pool({
         host: connection.host,
         port: connection.port || 5432,

package/dist/cjs/cli/utils/sql-generator.cjs

@@ -222,7 +222,7 @@ function generateColumnSQL(col) {
     if (col.identityGeneration) {
         parts.push(`GENERATED ${col.identityGeneration} AS IDENTITY`);
     }
-    if (!col.isNullable && !col.isPrimaryKey) {
+    if (!col.isNullable && !col.isPrimaryKey && !col.identityGeneration) {
         parts.push('NOT NULL');
     }
     if (col.defaultValue !== null && col.defaultValue !== undefined && !col.isGenerated) {

package/dist/cjs/cli/utils/sql-parser.cjs

@@ -13,6 +13,9 @@ function parseSqlFile(sqlContent) {
     const sequences = [];
     const collations = [];
     const foreignTables = [];
+    const views = [];
+    const materializedViews = [];
+    const foreignServers = [];
     const extensions = [];
     const partitions = [];
     const cleanedSql = removeComments(sqlContent);
@@ -25,7 +28,14 @@ function parseSqlFile(sqlContent) {
     parseTables(cleanedSql, tables, partitions, enums, domains);
     parseIndexes(cleanedSql, tables);
     parseForeignTables(cleanedSql, foreignTables);
-    return { tables, enums, domains, compositeTypes, sequences, collations, foreignTables, extensions, partitions };
+    parseViews(cleanedSql, views);
+    parseMaterializedViews(cleanedSql, materializedViews);
+    parseForeignServers(cleanedSql, foreignServers);
+    return {
+        tables, enums, domains, compositeTypes, sequences, collations,
+        foreignTables, views, materializedViews, foreignServers,
+        extensions, partitions
+    };
 }
 function removeComments(sql) {
     let result = sql.replace(/\/\*[\s\S]*?\*\//g, '');
@@ -117,11 +127,11 @@ function parseCompositeTypeBody(body) {
         const trimmed = line.trim();
         if (!trimmed)
             continue;
-        const attrMatch = trimmed.match(/^(\w+)\s+(.+)$/);
+        const attrMatch = trimmed.match(/^(?:"([^"]+)"|(\w+))\s+(.+)$/);
         if (attrMatch) {
             attributes.push({
-                name: attrMatch[1],
-                type: attrMatch[2].trim().replace(/,\s*$/, ''),
+                name: attrMatch[1] || attrMatch[2],
+                type: attrMatch[3].trim().replace(/,\s*$/, ''),
             });
         }
     }
@@ -366,12 +376,14 @@ function parseTableBody(body, enums, domains) {
         const trimmed = part.trim();
         if (!trimmed)
             continue;
-        if (trimmed.toUpperCase().startsWith('CONSTRAINT') ||
-            trimmed.toUpperCase().startsWith('PRIMARY KEY') ||
-            trimmed.toUpperCase().startsWith('FOREIGN KEY') ||
-            trimmed.toUpperCase().startsWith('UNIQUE') ||
-            trimmed.toUpperCase().startsWith('CHECK') ||
-            trimmed.toUpperCase().startsWith('EXCLUDE')) {
+        const upper = trimmed.toUpperCase();
+        const isConstraint = upper.startsWith('CONSTRAINT ') ||
+            /^PRIMARY\s+KEY\s*\(/i.test(trimmed) ||
+            /^FOREIGN\s+KEY\s*\(/i.test(trimmed) ||
+            /^UNIQUE\s*\(/i.test(trimmed) ||
+            /^CHECK\s*\(/i.test(trimmed) ||
+            /^EXCLUDE\s+(?:USING\s+|ON\s+|\()/i.test(trimmed);
+        if (isConstraint) {
             const constraint = parseConstraint(trimmed);
             if (constraint) {
                 constraints.push(constraint);
@@ -618,9 +630,9 @@ function extractMaxLength(type) {
 }
 function parseConstraint(def) {
     const upper = def.toUpperCase();
-    const namedMatch = def.match(/CONSTRAINT\s+(\w+)\s+(.+)/i);
-    const constraintDef = namedMatch ? namedMatch[2] : def;
-    const constraintName = namedMatch ? namedMatch[1] : '';
+    const namedMatch = def.match(/CONSTRAINT\s+(?:"([^"]+)"|(\w+))\s+(.+)/is);
+    const constraintDef = namedMatch ? namedMatch[3] : def;
+    const constraintName = namedMatch ? (namedMatch[1] || namedMatch[2]) : '';
     const constraintUpper = constraintDef.toUpperCase();
     if (constraintUpper.startsWith('PRIMARY KEY')) {
         const colsMatch = constraintDef.match(/PRIMARY\s+KEY\s*\(\s*([^)]+)\s*\)/i);
@@ -996,4 +1008,81 @@ function parseComments(sql) {
     }
     return comments;
 }
+function parseViews(sql, views) {
+    const viewRegex = /CREATE\s+(?:OR\s+REPLACE\s+)?VIEW\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:(?:"?(\w+)"?\.)?"?(\w+)"?)\s*(?:\(([^)]+)\))?\s+AS\s+([\s\S]+?)(?:;|\s+WITH\s+(?:CASCADED|LOCAL)\s+CHECK\s+OPTION\s*;)/gi;
+    let match;
+    while ((match = viewRegex.exec(sql)) !== null) {
+        const schema = match[1] || 'public';
+        const name = match[2];
+        const columnsStr = match[3];
+        const definition = match[4].trim();
+        const columns = columnsStr
+            ? columnsStr.split(',').map(c => c.trim().replace(/"/g, ''))
+            : undefined;
+        views.push({
+            name,
+            schema,
+            definition,
+            columns,
+        });
+    }
+    const simpleViewRegex = /CREATE\s+(?:OR\s+REPLACE\s+)?VIEW\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:(?:"?(\w+)"?\.)?"?(\w+)"?)\s*AS\s+(SELECT[\s\S]+?);/gi;
+    while ((match = simpleViewRegex.exec(sql)) !== null) {
+        const schema = match[1] || 'public';
+        const name = match[2];
+        const definition = match[3].trim();
+        if (views.some(v => v.name === name))
+            continue;
+        views.push({
+            name,
+            schema,
+            definition,
+        });
+    }
+}
+function parseMaterializedViews(sql, materializedViews) {
+    const mviewRegex = /CREATE\s+MATERIALIZED\s+VIEW\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:(?:"?(\w+)"?\.)?"?(\w+)"?)\s*(?:\(([^)]+)\))?\s+AS\s+([\s\S]+?)(?:WITH\s+(NO\s+)?DATA\s*)?;/gi;
+    let match;
+    while ((match = mviewRegex.exec(sql)) !== null) {
+        const schema = match[1] || 'public';
+        const name = match[2];
+        const columnsStr = match[3];
+        const definition = match[4].trim();
+        const withNoData = match[5] !== undefined;
+        const columns = columnsStr
+            ? columnsStr.split(',').map(c => c.trim().replace(/"/g, ''))
+            : undefined;
+        materializedViews.push({
+            name,
+            schema,
+            definition,
+            columns,
+            withData: !withNoData,
+        });
+    }
+}
+function parseForeignServers(sql, foreignServers) {
+    const serverRegex = /CREATE\s+SERVER\s+(?:IF\s+NOT\s+EXISTS\s+)?"?(\w+)"?\s+FOREIGN\s+DATA\s+WRAPPER\s+"?(\w+)"?\s*(?:OPTIONS\s*\(([^)]+)\))?;/gi;
+    let match;
+    while ((match = serverRegex.exec(sql)) !== null) {
+        const name = match[1];
+        const fdwName = match[2];
+        const optionsStr = match[3];
+        const options = {};
+        if (optionsStr) {
+            const optParts = optionsStr.split(',');
+            for (const part of optParts) {
+                const optMatch = part.trim().match(/(\w+)\s+'([^']+)'/);
+                if (optMatch) {
+                    options[optMatch[1]] = optMatch[2];
+                }
+            }
+        }
+        foreignServers.push({
+            name,
+            fdwName,
+            options: Object.keys(options).length > 0 ? options : undefined,
+        });
+    }
+}
 exports.default = parseSqlFile;

package/dist/cjs/condition/array-condition-builder.cjs

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArrayConditionCollector = void 0;
 exports.buildArrayConditionSQL = buildArrayConditionSQL;
-const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+const pg_format_1 = __importDefault(require("../addon/pg-format/index.cjs"));
 const array_string_condition_builder_1 = require("./array-string-condition-builder.cjs");
 const array_numeric_condition_builder_1 = require("./array-numeric-condition-builder.cjs");
 const array_specialized_condition_builder_1 = require("./array-specialized-condition-builder.cjs");

package/dist/cjs/condition/condition-collector.cjs

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConditionCollector = void 0;
 exports.buildConditionSQL = buildConditionSQL;
 exports.buildConditionsSQL = buildConditionsSQL;
-const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+const pg_format_1 = __importDefault(require("../addon/pg-format/index.cjs"));
 const jsonb_condition_builder_1 = require("./jsonb-condition-builder.cjs");
 const array_condition_builder_1 = require("./array-condition-builder.cjs");
 const fulltext_condition_builder_1 = require("./fulltext-condition-builder.cjs");

package/dist/cjs/condition/fulltext-condition-builder.cjs

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FulltextConditionCollector = void 0;
 exports.buildFulltextConditionSQL = buildFulltextConditionSQL;
-const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+const pg_format_1 = __importDefault(require("../addon/pg-format/index.cjs"));
 class FulltextConditionCollector {
     parent;
     constructor(parent) {

package/dist/cjs/condition/geometric-condition-builder.cjs

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GeometricConditionCollector = void 0;
 exports.buildGeometricConditionSQL = buildGeometricConditionSQL;
-const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+const pg_format_1 = __importDefault(require("../addon/pg-format/index.cjs"));
 class GeometricConditionCollector {
     parent;
     constructor(parent) {