relq 1.0.1 → 1.0.2

package/dist/esm/cli/utils/relqignore.js

@@ -1,23 +1,88 @@
 import * as fs from 'fs';
 import * as path from '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_*',
 ];
+export 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,
+    };
+}
 export 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;
@@ -28,40 +93,58 @@ export 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
+# =============================================================================
+
+# Ignore specific tables
+# TABLE:debug_*
+# TABLE:test_*
+
+# Ignore sensitive columns (table.column format required)
+# COLUMN:users.password_hash
+# COLUMN:*.api_key
 
-# Relq internal tables (always ignored)
-_relq_*
+# Ignore temporary indexes
+# INDEX:*.idx_temp_*
 
-# PostgreSQL system tables
-pg_*
+# Ignore debug functions
+# FUNCTION:debug_*
 
-# Temporary tables
-_temp_*
-tmp_*
+# Ignore internal triggers
+# TRIGGER:audit_logs.*
 
-# Add your tables/functions to ignore below:
-# analytics_raw
-# debug_*
-# test_*
+# Ignore test enums
+# ENUM:test_*
 `;
     fs.writeFileSync(ignorePath, content, 'utf-8');
 }
-export function isIgnored(name, patterns) {
-    for (const pattern of patterns) {
-        if (matchPattern(name, pattern)) {
-            return true;
-        }
-    }
-    return false;
-}
-export 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, '.*')
@@ -69,6 +152,163 @@ function matchPattern(name, pattern) {
     const regex = new RegExp(`^${regexPattern}$`, 'i');
     return regex.test(name);
 }
+export 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,
+    };
+}
+export function isTableIgnored(tableName, patterns) {
+    return isIgnored('TABLE', tableName, null, patterns);
+}
+export function isColumnIgnored(tableName, columnName, patterns) {
+    return isIgnored('COLUMN', columnName, tableName, patterns);
+}
+export function isIndexIgnored(tableName, indexName, patterns) {
+    return isIgnored('INDEX', indexName, tableName, patterns);
+}
+export function isConstraintIgnored(tableName, constraintName, patterns) {
+    return isIgnored('CONSTRAINT', constraintName, tableName, patterns);
+}
+export function isTriggerIgnored(tableName, triggerName, patterns) {
+    return isIgnored('TRIGGER', triggerName, tableName, patterns);
+}
+export function isEnumIgnored(enumName, patterns) {
+    return isIgnored('ENUM', enumName, null, patterns);
+}
+export function isDomainIgnored(domainName, patterns) {
+    return isIgnored('DOMAIN', domainName, null, patterns);
+}
+export function isSequenceIgnored(sequenceName, patterns) {
+    return isIgnored('SEQUENCE', sequenceName, null, patterns);
+}
+export function isCompositeTypeIgnored(typeName, patterns) {
+    return isIgnored('COMPOSITE_TYPE', typeName, null, patterns);
+}
+export function isFunctionIgnored(functionName, patterns) {
+    return isIgnored('FUNCTION', functionName, null, patterns);
+}
+export function isViewIgnored(viewName, patterns) {
+    return isIgnored('VIEW', viewName, null, patterns);
+}
+export 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;
+}
+export function filterTables(tables, patterns) {
+    return tables.filter(t => !isTableIgnored(t.name, patterns).ignored);
+}
+export function filterColumns(tableName, columns, patterns) {
+    return columns.filter(c => !isColumnIgnored(tableName, c.name, patterns).ignored);
+}
+export function filterIndexes(tableName, indexes, patterns) {
+    return indexes.filter(i => !isIndexIgnored(tableName, i.name, patterns).ignored);
+}
+export function filterEnums(enums, patterns) {
+    return enums.filter(e => !isEnumIgnored(e.name, patterns).ignored);
+}
+export function filterDomains(domains, patterns) {
+    return domains.filter(d => !isDomainIgnored(d.name, patterns).ignored);
+}
 export function getIgnorePatterns(projectRoot = process.cwd()) {
     return loadRelqignore(projectRoot);
 }
+export function filterIgnored(items, patterns) {
+    return items.filter(item => !isTableIgnored(item.name, patterns).ignored);
+}

package/dist/esm/cli/utils/repo-manager.js

@@ -279,7 +279,7 @@ export function hasUncommittedChanges(projectRoot = process.cwd()) {
     return state.staged.length > 0 || state.unstaged.length > 0;
 }
 export async function ensureRemoteTable(connection) {
-    const { Pool } = await import("../../addon/pg.js");
+    const { Pool } = await import("../../addon/pg/index.js");
     const pool = new Pool({
         host: connection.host,
         port: connection.port || 5432,
@@ -311,7 +311,7 @@ export async function ensureRemoteTable(connection) {
     }
 }
 export async function fetchRemoteCommits(connection, limit = 100) {
-    const { Pool } = await import("../../addon/pg.js");
+    const { Pool } = await import("../../addon/pg/index.js");
     const pool = new Pool({
         host: connection.host,
         port: connection.port || 5432,
@@ -347,7 +347,7 @@ export async function getRemoteHead(connection) {
     return commits.length > 0 ? commits[0].hash : null;
 }
 export async function pushCommit(connection, commit) {
-    const { Pool } = await import("../../addon/pg.js");
+    const { Pool } = await import("../../addon/pg/index.js");
     const pool = new Pool({
         host: connection.host,
         port: connection.port || 5432,
@@ -442,3 +442,41 @@ export function migrateSnapshot(snapshot) {
         foreignTables: snapshot.foreignTables || [],
     };
 }
+export 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 {};
+}
+export function saveTags(tags, projectRoot = process.cwd()) {
+    const tagPath = path.join(projectRoot, '.relq', 'tags.json');
+    fs.writeFileSync(tagPath, JSON.stringify(tags, null, 2));
+}
+export 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;
+}
+export function loadParentCommit(hash, projectRoot = process.cwd()) {
+    const commit = loadCommit(hash, projectRoot);
+    if (!commit || !commit.parentHash)
+        return null;
+    return loadCommit(commit.parentHash, projectRoot);
+}

package/dist/esm/cli/utils/schema-introspect.js

@@ -1,6 +1,6 @@
 export async function introspectDatabase(connection, onProgress, options) {
     const { includeFunctions = false, includeTriggers = false } = options || {};
-    const { Pool } = await import("../../addon/pg.js");
+    const { Pool } = await import("../../addon/pg/index.js");
     onProgress?.('connecting', connection.database);
     const pool = new Pool({
         host: connection.host,
@@ -396,7 +396,7 @@ function parseOptions(options) {
     return result;
 }
 export async function tableHasData(connection, tableName) {
-    const { Pool } = await import("../../addon/pg.js");
+    const { Pool } = await import("../../addon/pg/index.js");
     const pool = new Pool({
         host: connection.host,
         port: connection.port || 5432,

package/dist/esm/cli/utils/sql-generator.js

@@ -206,7 +206,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/esm/cli/utils/sql-parser.js

@@ -6,6 +6,9 @@ export function parseSqlFile(sqlContent) {
     const sequences = [];
     const collations = [];
     const foreignTables = [];
+    const views = [];
+    const materializedViews = [];
+    const foreignServers = [];
     const extensions = [];
     const partitions = [];
     const cleanedSql = removeComments(sqlContent);
@@ -18,7 +21,14 @@ export 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, '');
@@ -110,11 +120,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*$/, ''),
             });
         }
     }
@@ -613,9 +623,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);
@@ -991,4 +1001,81 @@ export 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,
+        });
+    }
+}
 export default parseSqlFile;

package/dist/esm/condition/array-condition-builder.js

@@ -1,4 +1,4 @@
-import format from "../../addons/pg-format.js";
+import format from "../addon/pg-format/index.js";
 import { ArrayStringConditionBuilder } from "./array-string-condition-builder.js";
 import { ArrayNumericConditionBuilder } from "./array-numeric-condition-builder.js";
 import { ArrayUuidConditionBuilder, ArrayDateConditionBuilder, ArrayJsonbConditionBuilder } from "./array-specialized-condition-builder.js";

package/dist/esm/condition/condition-collector.js

@@ -1,4 +1,4 @@
-import format from "../../addons/pg-format.js";
+import format from "../addon/pg-format/index.js";
 import { JsonbConditionCollector, buildJsonbConditionSQL } from "./jsonb-condition-builder.js";
 import { ArrayConditionCollector, buildArrayConditionSQL } from "./array-condition-builder.js";
 import { FulltextConditionCollector, buildFulltextConditionSQL } from "./fulltext-condition-builder.js";

package/dist/esm/condition/fulltext-condition-builder.js

@@ -1,4 +1,4 @@
-import format from "../../addons/pg-format.js";
+import format from "../addon/pg-format/index.js";
 export class FulltextConditionCollector {
     parent;
     constructor(parent) {

package/dist/esm/condition/geometric-condition-builder.js

@@ -1,4 +1,4 @@
-import format from "../../addons/pg-format.js";
+import format from "../addon/pg-format/index.js";
 export class GeometricConditionCollector {
     parent;
     constructor(parent) {

package/dist/esm/condition/jsonb-condition-builder.js

@@ -1,4 +1,4 @@
-import format from "../../addons/pg-format.js";
+import format from "../addon/pg-format/index.js";
 export class JsonbConditionCollector {
     parent;
     constructor(parent) {

package/dist/esm/condition/network-condition-builder.js

@@ -1,4 +1,4 @@
-import format from "../../addons/pg-format.js";
+import format from "../addon/pg-format/index.js";
 export class NetworkConditionCollector {
     parent;
     constructor(parent) {

package/dist/esm/condition/range-condition-builder.js

@@ -1,4 +1,4 @@
-import format from "../../addons/pg-format.js";
+import format from "../addon/pg-format/index.js";
 export class RangeConditionCollector {
     parent;
     constructor(parent) {

package/dist/esm/copy/copy-builder.js

@@ -1,4 +1,4 @@
-import format from "../../addons/pg-format.js";
+import format from "../addon/pg-format/index.js";
 import { RelqBuilderError } from "../errors/relq-errors.js";
 export class CopyToBuilder {
     tableName;

package/dist/esm/core/query-builder.js

@@ -22,7 +22,7 @@ import { ExplainBuilder } from "../explain/explain-builder.js";
 import { ListenBuilder, UnlistenBuilder, NotifyBuilder } from "../pubsub/listen-notify-builder.js";
 import { VacuumBuilder, AnalyzeBuilder } from "../maintenance/vacuum-builder.js";
 import { CopyToBuilder, CopyFromBuilder } from "../copy/copy-builder.js";
-import format from "../../addons/pg-format.js";
+import format from "../addon/pg-format/index.js";
 export class TypedSelectBuilder {
     builder;
     constructor(builder) {

package/dist/esm/core/relq-client.js

@@ -14,7 +14,7 @@ import { validatePoolConfig, formatPoolConfig, getSmartPoolDefaults } from "../u
 import { RelqEnvironmentError, RelqConfigError, RelqQueryError, RelqConnectionError, parsePostgresError } from "../errors/relq-errors.js";
 import { randomLimit } from "../types/pagination-types.js";
 import { deserializeValue, serializeValue } from "../utils/type-coercion.js";
-import Cursor from "../../addons/pg-cursor.js";
+import Cursor from "../addon/pg-cursor/index.js";
 const INTERNAL = Symbol('relq-internal');
 let PgPool = null;
 let PgClient = null;
@@ -40,7 +40,7 @@ function registerGlobalCleanupHandlers() {
 async function loadPg() {
     if (!PgPool || !PgClient) {
         try {
-            const pg = await import("../addon/pg.js");
+            const pg = await import("../addon/pg/index.js");
             PgPool = pg.Pool;
             PgClient = pg.Client;
             return { Pool: pg.Pool, Client: pg.Client };

package/dist/esm/count/count-builder.js

@@ -1,4 +1,4 @@
-import format from "../../addons/pg-format.js";
+import format from "../addon/pg-format/index.js";
 import { ConditionCollector, buildConditionsSQL, buildConditionSQL } from "../condition/condition-collector.js";
 export class CountBuilder {
     tableName;