relq 1.0.94 → 1.0.96

package/dist/cjs/cli/adapters/cockroachdb/index.cjs

@@ -157,7 +157,7 @@ class CockroachDBAdapter {
     id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
     name VARCHAR(255) NOT NULL,
     filename VARCHAR(255) NOT NULL,
-    hash VARCHAR(64) NOT NULL,
+    hash VARCHAR(255) NOT NULL,
     batch INTEGER NOT NULL,
     applied_at TIMESTAMPTZ DEFAULT NOW(),
     execution_time_ms INTEGER,

package/dist/cjs/cli/adapters/cockroachdb/introspect.cjs

@@ -67,6 +67,12 @@ async function introspectCockroachDB(connection, options) {
         const constraints = await introspectConstraints(pool);
         options?.onProgress?.('fetching_enums');
         const enums = await introspectEnums(pool);
+        options?.onProgress?.('fetching_domains');
+        const domains = await introspectDomains(pool);
+        options?.onProgress?.('fetching_sequences');
+        const sequences = await introspectSequences(pool);
+        options?.onProgress?.('fetching_composite_types');
+        const compositeTypes = await introspectCompositeTypes(pool);
         let functions;
         if (options?.includeFunctions) {
             options?.onProgress?.('fetching_functions');
@@ -92,6 +98,9 @@ async function introspectCockroachDB(connection, options) {
             indexes,
             constraints,
             enums,
+            domains,
+            sequences,
+            compositeTypes,
             functions,
             triggers,
             schemas,
@@ -583,3 +592,112 @@ async function introspectTriggers(pool) {
         enabled: row.enabled,
     }));
 }
+async function introspectDomains(pool) {
+    const result = await pool.query(`
+        SELECT
+            t.typname as name,
+            n.nspname as schema,
+            pg_catalog.format_type(t.typbasetype, t.typtypmod) as base_type,
+            t.typnotnull as is_not_null,
+            pg_catalog.pg_get_expr(t.typdefaultbin, 0) as default_value,
+            (SELECT pg_catalog.pg_get_constraintdef(c.oid)
+             FROM pg_constraint c
+             WHERE c.contypid = t.oid
+             LIMIT 1) as check_expression
+        FROM pg_type t
+        JOIN pg_namespace n ON t.typnamespace = n.oid
+        WHERE t.typtype = 'd'
+          AND n.nspname NOT LIKE 'pg_%'
+          AND n.nspname != 'information_schema'
+          AND n.nspname != 'crdb_internal'
+        ORDER BY n.nspname, t.typname
+    `);
+    return result.rows.map((row) => ({
+        name: row.name,
+        baseType: row.base_type,
+        isNotNull: row.is_not_null,
+        defaultValue: row.default_value,
+        checkExpression: row.check_expression,
+    }));
+}
+async function introspectSequences(pool) {
+    const result = await pool.query(`
+        SELECT
+            c.relname as name,
+            n.nspname as schema,
+            s.seqtypid::regtype::text as data_type,
+            s.seqstart::text as start_value,
+            s.seqincrement::text as increment,
+            s.seqmin::text as min_value,
+            s.seqmax::text as max_value,
+            s.seqcache::text as cache,
+            s.seqcycle as cycle,
+            d_table.relname as owned_by_table,
+            a.attname as owned_by_column
+        FROM pg_sequence s
+        JOIN pg_class c ON s.seqrelid = c.oid
+        JOIN pg_namespace n ON c.relnamespace = n.oid
+        LEFT JOIN pg_depend dep ON dep.objid = c.oid
+            AND dep.classid = 'pg_class'::regclass
+            AND dep.deptype = 'a'
+        LEFT JOIN pg_class d_table ON dep.refobjid = d_table.oid
+            AND d_table.relkind = 'r'
+        LEFT JOIN pg_attribute a ON a.attrelid = dep.refobjid
+            AND a.attnum = dep.refobjsubid
+        WHERE n.nspname NOT LIKE 'pg_%'
+          AND n.nspname != 'information_schema'
+          AND n.nspname != 'crdb_internal'
+          AND NOT EXISTS (
+              SELECT 1 FROM pg_depend di
+              WHERE di.objid = c.oid
+                AND di.classid = 'pg_class'::regclass
+                AND di.deptype = 'i'
+          )
+        ORDER BY n.nspname, c.relname
+    `);
+    return result.rows.map((row) => ({
+        name: row.name,
+        dataType: row.data_type,
+        start: row.start_value ? Number(row.start_value) : undefined,
+        increment: row.increment ? Number(row.increment) : undefined,
+        minValue: row.min_value ? Number(row.min_value) : undefined,
+        maxValue: row.max_value ? Number(row.max_value) : undefined,
+        cache: row.cache ? Number(row.cache) : undefined,
+        cycle: row.cycle,
+        ownedBy: row.owned_by_table && row.owned_by_column
+            ? `${row.owned_by_table}.${row.owned_by_column}`
+            : undefined,
+    }));
+}
+async function introspectCompositeTypes(pool) {
+    const result = await pool.query(`
+        SELECT
+            t.typname as name,
+            n.nspname as schema,
+            array_agg(a.attname ORDER BY a.attnum) as attribute_names,
+            array_agg(pg_catalog.format_type(a.atttypid, a.atttypmod) ORDER BY a.attnum) as attribute_types
+        FROM pg_type t
+        JOIN pg_namespace n ON t.typnamespace = n.oid
+        JOIN pg_attribute a ON a.attrelid = t.typrelid
+            AND a.attnum > 0
+            AND NOT a.attisdropped
+        WHERE t.typtype = 'c'
+          AND n.nspname NOT LIKE 'pg_%'
+          AND n.nspname != 'information_schema'
+          AND n.nspname != 'crdb_internal'
+          AND NOT EXISTS (
+              SELECT 1 FROM pg_class c
+              WHERE c.reltype = t.oid
+                AND c.relkind IN ('r', 'v', 'm', 'f')
+          )
+        GROUP BY t.oid, t.typname, n.nspname
+        ORDER BY n.nspname, t.typname
+    `);
+    return result.rows.map((row) => ({
+        name: row.name,
+        attributes: (row.attribute_names || []).map((attrName, i) => ({
+            name: attrName,
+            type: row.attribute_types[i],
+        })),
+    }));
+}

package/dist/cjs/cli/adapters/dsql/index.cjs

@@ -172,7 +172,7 @@ class DsqlAdapter {
     id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
     name VARCHAR(255) NOT NULL,
     filename VARCHAR(255) NOT NULL,
-    hash VARCHAR(64) NOT NULL,
+    hash VARCHAR(255) NOT NULL,
     batch INTEGER NOT NULL,
     applied_at TIMESTAMPTZ DEFAULT NOW(),
     execution_time_ms INTEGER,

package/dist/cjs/cli/adapters/dsql/introspect.cjs

@@ -65,6 +65,12 @@ async function introspectDsql(connection, options) {
         const constraints = await introspectConstraints(pool);
         options?.onProgress?.('fetching_enums');
         const enums = await introspectEnums(pool);
+        options?.onProgress?.('fetching_domains');
+        const domains = await introspectDomains(pool);
+        options?.onProgress?.('fetching_sequences');
+        const sequences = await introspectSequences(pool);
+        options?.onProgress?.('fetching_composite_types');
+        const compositeTypes = await introspectCompositeTypes(pool);
         let functions;
         if (options?.includeFunctions) {
             options?.onProgress?.('fetching_functions');
@@ -89,6 +95,9 @@ async function introspectDsql(connection, options) {
             indexes,
             constraints,
             enums,
+            domains,
+            sequences,
+            compositeTypes,
             functions,
             triggers,
             schemas,
@@ -568,3 +577,119 @@ async function introspectTriggers(pool) {
         enabled: row.enabled,
     }));
 }
+async function introspectDomains(pool) {
+    const result = await pool.query(`
+        SELECT
+            t.typname as name,
+            n.nspname as schema,
+            pg_catalog.format_type(t.typbasetype, t.typtypmod) as base_type,
+            t.typnotnull as is_not_null,
+            pg_catalog.pg_get_expr(t.typdefaultbin, 0) as default_value,
+            (SELECT pg_catalog.pg_get_constraintdef(c.oid)
+             FROM pg_constraint c
+             WHERE c.contypid = t.oid
+             LIMIT 1) as check_expression
+        FROM pg_type t
+        JOIN pg_namespace n ON t.typnamespace = n.oid
+        WHERE t.typtype = 'd'
+          AND n.nspname NOT LIKE 'pg_%'
+          AND n.nspname != 'information_schema'
+        ORDER BY n.nspname, t.typname
+    `);
+    return result.rows.map((row) => ({
+        name: row.name,
+        baseType: row.base_type,
+        isNotNull: row.is_not_null,
+        defaultValue: row.default_value,
+        checkExpression: row.check_expression,
+    }));
+}
+async function introspectSequences(pool) {
+    try {
+        const result = await pool.query(`
+            SELECT
+                c.relname as name,
+                n.nspname as schema,
+                s.seqtypid::regtype::text as data_type,
+                s.seqstart::text as start_value,
+                s.seqincrement::text as increment,
+                s.seqmin::text as min_value,
+                s.seqmax::text as max_value,
+                s.seqcache::text as cache,
+                s.seqcycle as cycle,
+                d_table.relname as owned_by_table,
+                a.attname as owned_by_column
+            FROM pg_sequence s
+            JOIN pg_class c ON s.seqrelid = c.oid
+            JOIN pg_namespace n ON c.relnamespace = n.oid
+            LEFT JOIN pg_depend dep ON dep.objid = c.oid
+                AND dep.classid = 'pg_class'::regclass
+                AND dep.deptype = 'a'
+            LEFT JOIN pg_class d_table ON dep.refobjid = d_table.oid
+                AND d_table.relkind = 'r'
+            LEFT JOIN pg_attribute a ON a.attrelid = dep.refobjid
+                AND a.attnum = dep.refobjsubid
+            WHERE n.nspname NOT LIKE 'pg_%'
+              AND n.nspname != 'information_schema'
+              AND NOT EXISTS (
+                  SELECT 1 FROM pg_depend di
+                  WHERE di.objid = c.oid
+                    AND di.classid = 'pg_class'::regclass
+                    AND di.deptype = 'i'
+              )
+            ORDER BY n.nspname, c.relname
+        `);
+        return result.rows.map((row) => ({
+            name: row.name,
+            dataType: row.data_type,
+            start: row.start_value ? Number(row.start_value) : undefined,
+            increment: row.increment ? Number(row.increment) : undefined,
+            minValue: row.min_value ? Number(row.min_value) : undefined,
+            maxValue: row.max_value ? Number(row.max_value) : undefined,
+            cache: row.cache ? Number(row.cache) : undefined,
+            cycle: row.cycle,
+            ownedBy: row.owned_by_table && row.owned_by_column
+                ? `${row.owned_by_table}.${row.owned_by_column}`
+                : undefined,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+async function introspectCompositeTypes(pool) {
+    try {
+        const result = await pool.query(`
+            SELECT
+                t.typname as name,
+                n.nspname as schema,
+                array_agg(a.attname ORDER BY a.attnum) as attribute_names,
+                array_agg(pg_catalog.format_type(a.atttypid, a.atttypmod) ORDER BY a.attnum) as attribute_types
+            FROM pg_type t
+            JOIN pg_namespace n ON t.typnamespace = n.oid
+            JOIN pg_attribute a ON a.attrelid = t.typrelid
+                AND a.attnum > 0
+                AND NOT a.attisdropped
+            WHERE t.typtype = 'c'
+              AND n.nspname NOT LIKE 'pg_%'
+              AND n.nspname != 'information_schema'
+              AND NOT EXISTS (
+                  SELECT 1 FROM pg_class c
+                  WHERE c.reltype = t.oid
+                    AND c.relkind IN ('r', 'v', 'm', 'f')
+              )
+            GROUP BY t.oid, t.typname, n.nspname
+            ORDER BY n.nspname, t.typname
+        `);
+        return result.rows.map((row) => ({
+            name: row.name,
+            attributes: (row.attribute_names || []).map((attrName, i) => ({
+                name: attrName,
+                type: row.attribute_types[i],
+            })),
+        }));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/cjs/cli/adapters/mysql/index.cjs

@@ -228,7 +228,7 @@ class MySQLAdapter {
     id INT AUTO_INCREMENT PRIMARY KEY,
     name VARCHAR(255) NOT NULL,
     filename VARCHAR(255) NOT NULL,
-    hash VARCHAR(64) NOT NULL,
+    hash VARCHAR(255) NOT NULL,
     batch INT NOT NULL,
     applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
     execution_time_ms INT,

package/dist/cjs/cli/adapters/nile/index.cjs

@@ -161,7 +161,7 @@ class NileAdapter {
     id SERIAL PRIMARY KEY,
     name VARCHAR(255) NOT NULL,
     filename VARCHAR(255) NOT NULL,
-    hash VARCHAR(64) NOT NULL,
+    hash VARCHAR(255) NOT NULL,
     batch INTEGER NOT NULL,
     applied_at TIMESTAMPTZ DEFAULT NOW(),
     execution_time_ms INTEGER,

package/dist/cjs/cli/adapters/nile/introspect.cjs

@@ -64,6 +64,12 @@ async function introspectNile(connection, options) {
         const constraints = await introspectConstraints(pool);
         options?.onProgress?.('fetching_enums');
         const enums = await introspectEnums(pool);
+        options?.onProgress?.('fetching_domains');
+        const domains = await introspectDomains(pool);
+        options?.onProgress?.('fetching_sequences');
+        const sequences = await introspectSequences(pool);
+        options?.onProgress?.('fetching_composite_types');
+        const compositeTypes = await introspectCompositeTypes(pool);
         let functions;
         if (options?.includeFunctions) {
             options?.onProgress?.('fetching_functions');
@@ -88,6 +94,9 @@ async function introspectNile(connection, options) {
             indexes,
             constraints,
             enums,
+            domains,
+            sequences,
+            compositeTypes,
             functions,
             triggers,
             schemas,
@@ -564,3 +573,109 @@ async function introspectTriggers(pool) {
         enabled: row.enabled,
     }));
 }
+async function introspectDomains(pool) {
+    const result = await pool.query(`
+        SELECT
+            t.typname as name,
+            n.nspname as schema,
+            pg_catalog.format_type(t.typbasetype, t.typtypmod) as base_type,
+            t.typnotnull as is_not_null,
+            pg_catalog.pg_get_expr(t.typdefaultbin, 0) as default_value,
+            (SELECT pg_catalog.pg_get_constraintdef(c.oid)
+             FROM pg_constraint c
+             WHERE c.contypid = t.oid
+             LIMIT 1) as check_expression
+        FROM pg_type t
+        JOIN pg_namespace n ON t.typnamespace = n.oid
+        WHERE t.typtype = 'd'
+          AND n.nspname NOT LIKE 'pg_%'
+          AND n.nspname != 'information_schema'
+        ORDER BY n.nspname, t.typname
+    `);
+    return result.rows.map((row) => ({
+        name: row.name,
+        baseType: row.base_type,
+        isNotNull: row.is_not_null,
+        defaultValue: row.default_value,
+        checkExpression: row.check_expression,
+    }));
+}
+async function introspectSequences(pool) {
+    const result = await pool.query(`
+        SELECT
+            c.relname as name,
+            n.nspname as schema,
+            s.seqtypid::regtype::text as data_type,
+            s.seqstart::text as start_value,
+            s.seqincrement::text as increment,
+            s.seqmin::text as min_value,
+            s.seqmax::text as max_value,
+            s.seqcache::text as cache,
+            s.seqcycle as cycle,
+            d_table.relname as owned_by_table,
+            a.attname as owned_by_column
+        FROM pg_sequence s
+        JOIN pg_class c ON s.seqrelid = c.oid
+        JOIN pg_namespace n ON c.relnamespace = n.oid
+        LEFT JOIN pg_depend dep ON dep.objid = c.oid
+            AND dep.classid = 'pg_class'::regclass
+            AND dep.deptype = 'a'
+        LEFT JOIN pg_class d_table ON dep.refobjid = d_table.oid
+            AND d_table.relkind = 'r'
+        LEFT JOIN pg_attribute a ON a.attrelid = dep.refobjid
+            AND a.attnum = dep.refobjsubid
+        WHERE n.nspname NOT LIKE 'pg_%'
+          AND n.nspname != 'information_schema'
+          AND NOT EXISTS (
+              SELECT 1 FROM pg_depend di
+              WHERE di.objid = c.oid
+                AND di.classid = 'pg_class'::regclass
+                AND di.deptype = 'i'
+          )
+        ORDER BY n.nspname, c.relname
+    `);
+    return result.rows.map((row) => ({
+        name: row.name,
+        dataType: row.data_type,
+        start: row.start_value ? Number(row.start_value) : undefined,
+        increment: row.increment ? Number(row.increment) : undefined,
+        minValue: row.min_value ? Number(row.min_value) : undefined,
+        maxValue: row.max_value ? Number(row.max_value) : undefined,
+        cache: row.cache ? Number(row.cache) : undefined,
+        cycle: row.cycle,
+        ownedBy: row.owned_by_table && row.owned_by_column
+            ? `${row.owned_by_table}.${row.owned_by_column}`
+            : undefined,
+    }));
+}
+async function introspectCompositeTypes(pool) {
+    const result = await pool.query(`
+        SELECT
+            t.typname as name,
+            n.nspname as schema,
+            array_agg(a.attname ORDER BY a.attnum) as attribute_names,
+            array_agg(pg_catalog.format_type(a.atttypid, a.atttypmod) ORDER BY a.attnum) as attribute_types
+        FROM pg_type t
+        JOIN pg_namespace n ON t.typnamespace = n.oid
+        JOIN pg_attribute a ON a.attrelid = t.typrelid
+            AND a.attnum > 0
+            AND NOT a.attisdropped
+        WHERE t.typtype = 'c'
+          AND n.nspname NOT LIKE 'pg_%'
+          AND n.nspname != 'information_schema'
+          AND NOT EXISTS (
+              SELECT 1 FROM pg_class c
+              WHERE c.reltype = t.oid
+                AND c.relkind IN ('r', 'v', 'm', 'f')
+          )
+        GROUP BY t.oid, t.typname, n.nspname
+        ORDER BY n.nspname, t.typname
+    `);
+    return result.rows.map((row) => ({
+        name: row.name,
+        attributes: (row.attribute_names || []).map((attrName, i) => ({
+            name: attrName,
+            type: row.attribute_types[i],
+        })),
+    }));
+}

package/dist/cjs/cli/adapters/postgres/index.cjs

@@ -154,7 +154,7 @@ class PostgresAdapter {
     id SERIAL PRIMARY KEY,
     name VARCHAR(255) NOT NULL,
     filename VARCHAR(255) NOT NULL,
-    hash VARCHAR(64) NOT NULL,
+    hash VARCHAR(255) NOT NULL,
     batch INTEGER NOT NULL,
     applied_at TIMESTAMPTZ DEFAULT NOW(),
     execution_time_ms INTEGER,

package/dist/cjs/cli/adapters/postgres/introspect.cjs

@@ -65,6 +65,12 @@ async function introspectPostgres(connection, options) {
         const constraints = await introspectConstraints(pool);
         options?.onProgress?.('fetching_enums');
         const enums = await introspectEnums(pool);
+        options?.onProgress?.('fetching_domains');
+        const domains = await introspectDomains(pool);
+        options?.onProgress?.('fetching_sequences');
+        const sequences = await introspectSequences(pool);
+        options?.onProgress?.('fetching_composite_types');
+        const compositeTypes = await introspectCompositeTypes(pool);
         let functions;
         if (options?.includeFunctions) {
             options?.onProgress?.('fetching_functions');
@@ -89,6 +95,9 @@ async function introspectPostgres(connection, options) {
             indexes,
             constraints,
             enums,
+            domains,
+            sequences,
+            compositeTypes,
             functions,
             triggers,
             schemas,
@@ -568,3 +577,109 @@ async function introspectTriggers(pool) {
         enabled: row.enabled,
     }));
 }
+async function introspectDomains(pool) {
+    const result = await pool.query(`
+        SELECT
+            t.typname as name,
+            n.nspname as schema,
+            pg_catalog.format_type(t.typbasetype, t.typtypmod) as base_type,
+            t.typnotnull as is_not_null,
+            pg_catalog.pg_get_expr(t.typdefaultbin, 0) as default_value,
+            (SELECT pg_catalog.pg_get_constraintdef(c.oid)
+             FROM pg_constraint c
+             WHERE c.contypid = t.oid
+             LIMIT 1) as check_expression
+        FROM pg_type t
+        JOIN pg_namespace n ON t.typnamespace = n.oid
+        WHERE t.typtype = 'd'
+          AND n.nspname NOT LIKE 'pg_%'
+          AND n.nspname != 'information_schema'
+        ORDER BY n.nspname, t.typname
+    `);
+    return result.rows.map((row) => ({
+        name: row.name,
+        baseType: row.base_type,
+        isNotNull: row.is_not_null,
+        defaultValue: row.default_value,
+        checkExpression: row.check_expression,
+    }));
+}
+async function introspectSequences(pool) {
+    const result = await pool.query(`
+        SELECT
+            c.relname as name,
+            n.nspname as schema,
+            s.seqtypid::regtype::text as data_type,
+            s.seqstart::text as start_value,
+            s.seqincrement::text as increment,
+            s.seqmin::text as min_value,
+            s.seqmax::text as max_value,
+            s.seqcache::text as cache,
+            s.seqcycle as cycle,
+            d_table.relname as owned_by_table,
+            a.attname as owned_by_column
+        FROM pg_sequence s
+        JOIN pg_class c ON s.seqrelid = c.oid
+        JOIN pg_namespace n ON c.relnamespace = n.oid
+        LEFT JOIN pg_depend dep ON dep.objid = c.oid
+            AND dep.classid = 'pg_class'::regclass
+            AND dep.deptype = 'a'
+        LEFT JOIN pg_class d_table ON dep.refobjid = d_table.oid
+            AND d_table.relkind = 'r'
+        LEFT JOIN pg_attribute a ON a.attrelid = dep.refobjid
+            AND a.attnum = dep.refobjsubid
+        WHERE n.nspname NOT LIKE 'pg_%'
+          AND n.nspname != 'information_schema'
+          AND NOT EXISTS (
+              SELECT 1 FROM pg_depend di
+              WHERE di.objid = c.oid
+                AND di.classid = 'pg_class'::regclass
+                AND di.deptype = 'i'
+          )
+        ORDER BY n.nspname, c.relname
+    `);
+    return result.rows.map((row) => ({
+        name: row.name,
+        dataType: row.data_type,
+        start: row.start_value ? Number(row.start_value) : undefined,
+        increment: row.increment ? Number(row.increment) : undefined,
+        minValue: row.min_value ? Number(row.min_value) : undefined,
+        maxValue: row.max_value ? Number(row.max_value) : undefined,
+        cache: row.cache ? Number(row.cache) : undefined,
+        cycle: row.cycle,
+        ownedBy: row.owned_by_table && row.owned_by_column
+            ? `${row.owned_by_table}.${row.owned_by_column}`
+            : undefined,
+    }));
+}
+async function introspectCompositeTypes(pool) {
+    const result = await pool.query(`
+        SELECT
+            t.typname as name,
+            n.nspname as schema,
+            array_agg(a.attname ORDER BY a.attnum) as attribute_names,
+            array_agg(pg_catalog.format_type(a.atttypid, a.atttypmod) ORDER BY a.attnum) as attribute_types
+        FROM pg_type t
+        JOIN pg_namespace n ON t.typnamespace = n.oid
+        JOIN pg_attribute a ON a.attrelid = t.typrelid
+            AND a.attnum > 0
+            AND NOT a.attisdropped
+        WHERE t.typtype = 'c'
+          AND n.nspname NOT LIKE 'pg_%'
+          AND n.nspname != 'information_schema'
+          AND NOT EXISTS (
+              SELECT 1 FROM pg_class c
+              WHERE c.reltype = t.oid
+                AND c.relkind IN ('r', 'v', 'm', 'f')
+          )
+        GROUP BY t.oid, t.typname, n.nspname
+        ORDER BY n.nspname, t.typname
+    `);
+    return result.rows.map((row) => ({
+        name: row.name,
+        attributes: (row.attribute_names || []).map((attrName, i) => ({
+            name: attrName,
+            type: row.attribute_types[i],
+        })),
+    }));
+}