relq 1.0.66 → 1.0.67

package/dist/cjs/cli/adapters/base.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLPGSQL_LIMITATIONS = exports.UNSUPPORTED_SQL_FEATURES = exports.UNSUPPORTED_DATA_TYPES = exports.COCKROACHDB_FEATURES = void 0;
+exports.COCKROACHDB_FEATURES = {
+    supportsJson: true,
+    supportsJsonb: true,
+    supportsArrays: true,
+    supportsEnums: true,
+    supportsUuid: true,
+    supportsSerial: true,
+    supportsIdentity: true,
+    supportsBigint: true,
+    supportsDecimal: true,
+    supportsGeometry: false,
+    supportsTimestampTz: true,
+    supportsInterval: true,
+    supportsRangeTypes: false,
+    supportsCompositeTypes: false,
+    supportsNetworkTypes: true,
+    supportsFullTextSearch: false,
+    supportsDeferrableConstraints: true,
+    supportsExcludeConstraints: false,
+    supportsGeneratedColumns: true,
+    supportsPartialIndexes: true,
+    supportsCoveringIndexes: true,
+    supportsBtreeIndex: true,
+    supportsHashIndex: true,
+    supportsGistIndex: false,
+    supportsGinIndex: true,
+    supportsBrinIndex: false,
+    supportsSpGistIndex: false,
+    supportsSchemas: true,
+    supportsTablePartitioning: true,
+    supportsTableInheritance: false,
+    supportsMaterializedViews: true,
+    supportsForeignTables: false,
+    supportsTriggers: true,
+    supportsStoredProcedures: true,
+    supportsSequences: true,
+    supportsDomains: false,
+    supportsTransactions: true,
+    supportsSavepoints: true,
+    supportsIsolationLevels: true,
+    supportsReadOnlyTransactions: true,
+    supportsWindowFunctions: true,
+    supportsCTE: true,
+    supportsRecursiveCTE: true,
+    supportsLateralJoin: true,
+    supportsReturning: true,
+    supportsOnConflict: true,
+    supportsDistinctOn: true,
+    supportsGroupingSets: true,
+    supportsFilter: true,
+    supportsListenNotify: false,
+    supportsLogicalReplication: false,
+    supportsComments: true,
+    supportsExtensions: false,
+    supportsCopyCommand: true,
+};
+exports.UNSUPPORTED_DATA_TYPES = [
+    { pattern: /\bMONEY\b/i, name: 'MONEY', alternative: 'NUMERIC(precision, scale)', category: 'monetary' },
+    { pattern: /\bXML\b/i, name: 'XML', alternative: 'TEXT', category: 'text' },
+    { pattern: /\bPOINT\b/i, name: 'POINT', alternative: 'GEOMETRY via spatial extension or two NUMERIC columns', category: 'geometric' },
+    { pattern: /\bLINE\b/i, name: 'LINE', alternative: 'TEXT or GEOMETRY via spatial', category: 'geometric' },
+    { pattern: /\bLSEG\b/i, name: 'LSEG', alternative: 'TEXT or GEOMETRY via spatial', category: 'geometric' },
+    { pattern: /\bBOX\b/i, name: 'BOX', alternative: 'TEXT or GEOMETRY via spatial', category: 'geometric' },
+    { pattern: /\bPATH\b/i, name: 'PATH', alternative: 'TEXT or GEOMETRY via spatial', category: 'geometric' },
+    { pattern: /\bPOLYGON\b/i, name: 'POLYGON', alternative: 'GEOMETRY via spatial extension', category: 'geometric' },
+    { pattern: /\bCIRCLE\b/i, name: 'CIRCLE', alternative: 'TEXT or GEOMETRY via spatial', category: 'geometric' },
+    { pattern: /\bINT4RANGE\b/i, name: 'INT4RANGE', alternative: 'Two INTEGER columns', category: 'range' },
+    { pattern: /\bINT8RANGE\b/i, name: 'INT8RANGE', alternative: 'Two BIGINT columns', category: 'range' },
+    { pattern: /\bNUMRANGE\b/i, name: 'NUMRANGE', alternative: 'Two NUMERIC columns', category: 'range' },
+    { pattern: /\bTSRANGE\b/i, name: 'TSRANGE', alternative: 'Two TIMESTAMP columns', category: 'range' },
+    { pattern: /\bTSTZRANGE\b/i, name: 'TSTZRANGE', alternative: 'Two TIMESTAMPTZ columns', category: 'range' },
+    { pattern: /\bDATERANGE\b/i, name: 'DATERANGE', alternative: 'Two DATE columns', category: 'range' },
+    { pattern: /\b\w+MULTIRANGE\b/i, name: 'Multirange', alternative: 'Multiple rows or JSONB', category: 'range' },
+    { pattern: /\bTSVECTOR\b/i, name: 'TSVECTOR', alternative: 'TEXT + inverted indexes', category: 'fulltext' },
+    { pattern: /\bTSQUERY\b/i, name: 'TSQUERY', alternative: 'Application-layer search', category: 'fulltext' },
+    { pattern: /\bOID\b/i, name: 'OID', alternative: 'INTEGER or BIGINT', category: 'system' },
+    { pattern: /\bREGCLASS\b/i, name: 'REGCLASS', alternative: 'TEXT', category: 'system' },
+    { pattern: /\bREGPROC\b/i, name: 'REGPROC', alternative: 'TEXT', category: 'system' },
+    { pattern: /\bREGTYPE\b/i, name: 'REGTYPE', alternative: 'TEXT', category: 'system' },
+    { pattern: /\bCIDR\b/i, name: 'CIDR', alternative: 'TEXT or INET', category: 'network' },
+    { pattern: /\bMACADDR\b/i, name: 'MACADDR', alternative: 'TEXT or VARCHAR(17)', category: 'network' },
+    { pattern: /\bMACADDR8\b/i, name: 'MACADDR8', alternative: 'TEXT or VARCHAR(23)', category: 'network' },
+    { pattern: /\bpg_lsn\b/i, name: 'pg_lsn', alternative: 'N/A (PostgreSQL internal)', category: 'system' },
+    { pattern: /\bpg_snapshot\b/i, name: 'pg_snapshot', alternative: 'N/A (PostgreSQL internal)', category: 'system' },
+];
+exports.UNSUPPORTED_SQL_FEATURES = [
+    { pattern: /\bLISTEN\b/i, name: 'LISTEN', alternative: 'CockroachDB changefeeds', severity: 'error' },
+    { pattern: /\bNOTIFY\b/i, name: 'NOTIFY', alternative: 'CockroachDB changefeeds', severity: 'error' },
+    { pattern: /\bUNLISTEN\b/i, name: 'UNLISTEN', alternative: 'CockroachDB changefeeds', severity: 'error' },
+    { pattern: /\bCREATE\s+DOMAIN\b/i, name: 'CREATE DOMAIN', alternative: 'CHECK constraints on columns', severity: 'error' },
+    { pattern: /\bCREATE\s+TYPE\s+\w+\s+AS\s*\(/i, name: 'Composite Type', alternative: 'JSONB or separate table', severity: 'error' },
+    { pattern: /\bCREATE\s+EXTENSION\b/i, name: 'CREATE EXTENSION', alternative: 'Built-in features or application-layer', severity: 'error' },
+    { pattern: /\bVACUUM\b/i, name: 'VACUUM', alternative: 'CockroachDB handles this automatically', severity: 'warning' },
+    { pattern: /\bREINDEX\b/i, name: 'REINDEX', alternative: 'CockroachDB handles this automatically', severity: 'warning' },
+    { pattern: /\bCLUSTER\b/i, name: 'CLUSTER', alternative: 'CockroachDB handles this automatically', severity: 'warning' },
+    { pattern: /\bpg_advisory_lock\b/i, name: 'Advisory Locks', alternative: 'Application-layer distributed lock', severity: 'error' },
+    { pattern: /\bpg_try_advisory_lock\b/i, name: 'Advisory Locks', alternative: 'Application-layer distributed lock', severity: 'error' },
+    { pattern: /\bto_tsvector\b/i, name: 'to_tsvector', alternative: 'Inverted indexes', severity: 'error' },
+    { pattern: /\bto_tsquery\b/i, name: 'to_tsquery', alternative: 'Inverted indexes', severity: 'error' },
+    { pattern: /\bplainto_tsquery\b/i, name: 'plainto_tsquery', alternative: 'Inverted indexes', severity: 'error' },
+    { pattern: /\bphraseto_tsquery\b/i, name: 'phraseto_tsquery', alternative: 'Inverted indexes', severity: 'error' },
+    { pattern: /\bwebsearch_to_tsquery\b/i, name: 'websearch_to_tsquery', alternative: 'Inverted indexes', severity: 'error' },
+    { pattern: /\bts_rank\b/i, name: 'ts_rank', alternative: 'Application-layer ranking', severity: 'error' },
+    { pattern: /\bts_rank_cd\b/i, name: 'ts_rank_cd', alternative: 'Application-layer ranking', severity: 'error' },
+];
+exports.PLPGSQL_LIMITATIONS = [
+    { pattern: /%TYPE\b/i, name: '%TYPE', alternative: 'Explicit type declaration' },
+    { pattern: /%ROWTYPE\b/i, name: '%ROWTYPE', alternative: 'RECORD type' },
+    { pattern: /\$\d+\b/, name: 'Ordinal parameter refs ($1, $2)', alternative: 'Named parameters' },
+    { pattern: /\bFOR\s+\w+\s+IN\b/i, name: 'FOR loops', alternative: 'WHILE loop or cursor' },
+    { pattern: /\bFOREACH\b/i, name: 'FOREACH', alternative: 'WHILE loop with array subscript' },
+    { pattern: /\bPERFORM\b/i, name: 'PERFORM', alternative: 'SELECT ... INTO _dummy' },
+    { pattern: /\bEXECUTE\b/i, name: 'EXECUTE', alternative: 'Prepared statements' },
+    { pattern: /\bGET\s+DIAGNOSTICS\b/i, name: 'GET DIAGNOSTICS', alternative: 'Explicit row count check' },
+];

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

@@ -0,0 +1,84 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CockroachDBAdapter = void 0;
+const index_1 = require("../postgres/index.cjs");
+const features_1 = require("./features.cjs");
+const validator_1 = require("./validator.cjs");
+class CockroachDBAdapter extends index_1.PostgresAdapter {
+    dialect = 'cockroachdb';
+    displayName = 'CockroachDB';
+    features = features_1.COCKROACHDB_FEATURES;
+    validate(schema) {
+        return (0, validator_1.validateSchemaForCockroachDB)(schema);
+    }
+    validateSql(sql) {
+        return (0, validator_1.validateSqlForCockroachDB)(sql);
+    }
+    getAlternativeType(type) {
+        return (0, validator_1.getAlternativeType)(type);
+    }
+    isTypeSupported(type) {
+        return (0, validator_1.isTypeSupported)(type);
+    }
+    async getDatabaseVersion(connection) {
+        const { Pool } = await Promise.resolve().then(() => __importStar(require("../../../addon/pg/index.cjs")));
+        const { buildPoolConfig } = await Promise.resolve().then(() => __importStar(require("../../../config/config.cjs")));
+        const config = connection;
+        const poolConfig = await buildPoolConfig({
+            url: config.url,
+            host: config.host,
+            port: config.port,
+            database: config.database,
+            user: config.user,
+            password: config.password,
+            ssl: config.ssl,
+        });
+        const pool = new Pool({ ...poolConfig, max: 1 });
+        try {
+            const result = await pool.query('SELECT version()');
+            const version = result.rows[0]?.version || '';
+            const match = version.match(/CockroachDB\s+\w+\s+(v[\d.]+)/i);
+            return match ? match[1] : version;
+        }
+        finally {
+            await pool.end();
+        }
+    }
+    generateCreateTable(table, options) {
+        return super.generateCreateTable(table, options);
+    }
+}
+exports.CockroachDBAdapter = CockroachDBAdapter;

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

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSqlForCockroachDB = validateSqlForCockroachDB;
+exports.validateSchemaForCockroachDB = validateSchemaForCockroachDB;
+exports.validateTableForCockroachDB = validateTableForCockroachDB;
+exports.getAlternativeType = getAlternativeType;
+exports.isTypeSupported = isTypeSupported;
+const features_1 = require("./features.cjs");
+function validateSqlForCockroachDB(sql) {
+    const issues = [];
+    for (const typeCheck of features_1.UNSUPPORTED_DATA_TYPES) {
+        if (typeCheck.pattern.test(sql)) {
+            issues.push({
+                severity: 'error',
+                category: 'DATA_TYPE',
+                feature: typeCheck.name,
+                message: `Data type '${typeCheck.name}' is not supported in CockroachDB`,
+                alternative: typeCheck.alternative,
+            });
+        }
+    }
+    for (const feature of features_1.UNSUPPORTED_SQL_FEATURES) {
+        if (feature.pattern.test(sql)) {
+            issues.push({
+                severity: feature.severity,
+                category: 'FEATURE',
+                feature: feature.name,
+                message: `'${feature.name}' is not supported in CockroachDB`,
+                alternative: feature.alternative,
+            });
+        }
+    }
+    if (/\bCREATE\s+(OR\s+REPLACE\s+)?FUNCTION\b/i.test(sql)) {
+        for (const limitation of features_1.PLPGSQL_LIMITATIONS) {
+            if (limitation.pattern.test(sql)) {
+                issues.push({
+                    severity: 'error',
+                    category: 'SYNTAX',
+                    feature: limitation.name,
+                    message: `PL/pgSQL feature '${limitation.name}' is not supported in CockroachDB`,
+                    alternative: limitation.alternative,
+                });
+            }
+        }
+    }
+    const errors = issues.filter(i => i.severity === 'error').length;
+    const warnings = issues.filter(i => i.severity === 'warning').length;
+    const info = issues.filter(i => i.severity === 'info').length;
+    return {
+        valid: errors === 0,
+        issues,
+        summary: { errors, warnings, info },
+    };
+}
+function validateSchemaForCockroachDB(schema) {
+    const issues = [];
+    for (const table of schema.tables) {
+        const tableResult = validateTableForCockroachDB(table);
+        issues.push(...tableResult.issues);
+    }
+    const errors = issues.filter(i => i.severity === 'error').length;
+    const warnings = issues.filter(i => i.severity === 'warning').length;
+    const info = issues.filter(i => i.severity === 'info').length;
+    return {
+        valid: errors === 0,
+        issues,
+        summary: { errors, warnings, info },
+    };
+}
+function validateTableForCockroachDB(table) {
+    const issues = [];
+    for (const column of table.columns) {
+        const typeCheck = checkColumnType(column.type);
+        if (typeCheck) {
+            issues.push({
+                severity: 'error',
+                category: 'DATA_TYPE',
+                feature: typeCheck.name,
+                location: `${table.schema}.${table.name}.${column.name}`,
+                message: `Column uses unsupported type '${typeCheck.name}'`,
+                alternative: typeCheck.alternative,
+            });
+        }
+    }
+    const hasSerialPK = table.columns.some(c => c.isPrimaryKey && (c.type === 'serial' || c.type === 'bigserial' || c.isAutoIncrement));
+    if (hasSerialPK) {
+        issues.push({
+            severity: 'warning',
+            category: 'PERFORMANCE',
+            feature: 'SERIAL Primary Key',
+            location: `${table.schema}.${table.name}`,
+            message: 'SERIAL primary key may not distribute well in CockroachDB',
+            alternative: 'Consider UUID with gen_random_uuid() for better distribution',
+        });
+    }
+    const errors = issues.filter(i => i.severity === 'error').length;
+    const warnings = issues.filter(i => i.severity === 'warning').length;
+    const info = issues.filter(i => i.severity === 'info').length;
+    return {
+        valid: errors === 0,
+        issues,
+        summary: { errors, warnings, info },
+    };
+}
+function checkColumnType(type) {
+    const upperType = type.toUpperCase();
+    for (const typeCheck of features_1.UNSUPPORTED_DATA_TYPES) {
+        if (typeCheck.pattern.test(upperType)) {
+            return {
+                name: typeCheck.name,
+                alternative: typeCheck.alternative,
+            };
+        }
+    }
+    return null;
+}
+function getAlternativeType(type) {
+    const upperType = type.toUpperCase();
+    const typeMap = {
+        'MONEY': 'NUMERIC(19,4)',
+        'XML': 'TEXT',
+        'POINT': 'GEOMETRY',
+        'LINE': 'TEXT',
+        'LSEG': 'TEXT',
+        'BOX': 'TEXT',
+        'PATH': 'TEXT',
+        'POLYGON': 'GEOMETRY',
+        'CIRCLE': 'TEXT',
+        'INT4RANGE': 'JSONB',
+        'INT8RANGE': 'JSONB',
+        'NUMRANGE': 'JSONB',
+        'TSRANGE': 'JSONB',
+        'TSTZRANGE': 'JSONB',
+        'DATERANGE': 'JSONB',
+        'TSVECTOR': 'TEXT',
+        'TSQUERY': 'TEXT',
+        'CIDR': 'INET',
+        'MACADDR': 'VARCHAR(17)',
+        'MACADDR8': 'VARCHAR(23)',
+        'OID': 'BIGINT',
+        'REGCLASS': 'TEXT',
+        'REGPROC': 'TEXT',
+        'REGTYPE': 'TEXT',
+    };
+    return typeMap[upperType] || type;
+}
+function isTypeSupported(type) {
+    return checkColumnType(type) === null;
+}

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

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DSQL_ALTERNATIVES = exports.UNSUPPORTED_SQL_OPERATIONS = exports.UNSUPPORTED_COLUMN_TYPES = exports.DSQL_TRANSACTION_LIMITS = exports.DSQL_FEATURES = void 0;
+exports.DSQL_FEATURES = {
+    supportsJson: false,
+    supportsJsonb: false,
+    supportsArrays: false,
+    supportsEnums: true,
+    supportsUuid: true,
+    supportsSerial: false,
+    supportsIdentity: false,
+    supportsBigint: true,
+    supportsDecimal: true,
+    supportsGeometry: false,
+    supportsTimestampTz: true,
+    supportsInterval: true,
+    supportsRangeTypes: false,
+    supportsCompositeTypes: false,
+    supportsNetworkTypes: false,
+    supportsFullTextSearch: false,
+    supportsDeferrableConstraints: false,
+    supportsExcludeConstraints: false,
+    supportsGeneratedColumns: true,
+    supportsPartialIndexes: true,
+    supportsCoveringIndexes: true,
+    supportsBtreeIndex: true,
+    supportsHashIndex: true,
+    supportsGistIndex: false,
+    supportsGinIndex: false,
+    supportsBrinIndex: false,
+    supportsSpGistIndex: false,
+    supportsSchemas: true,
+    supportsTablePartitioning: false,
+    supportsTableInheritance: false,
+    supportsMaterializedViews: true,
+    supportsForeignTables: false,
+    supportsTriggers: false,
+    supportsStoredProcedures: false,
+    supportsSequences: false,
+    supportsDomains: true,
+    supportsTransactions: true,
+    supportsSavepoints: true,
+    supportsIsolationLevels: false,
+    supportsReadOnlyTransactions: true,
+    supportsWindowFunctions: true,
+    supportsCTE: true,
+    supportsRecursiveCTE: true,
+    supportsLateralJoin: true,
+    supportsReturning: true,
+    supportsOnConflict: true,
+    supportsDistinctOn: true,
+    supportsGroupingSets: true,
+    supportsFilter: true,
+    supportsListenNotify: false,
+    supportsLogicalReplication: false,
+    supportsComments: true,
+    supportsExtensions: false,
+    supportsCopyCommand: true,
+};
+exports.DSQL_TRANSACTION_LIMITS = {
+    maxRowsPerTransaction: 3000,
+    connectionTimeoutHours: 1,
+    maxDdlPerTransaction: 1,
+    isolationLevel: 'REPEATABLE READ',
+};
+exports.UNSUPPORTED_COLUMN_TYPES = [
+    'SERIAL',
+    'BIGSERIAL',
+    'SMALLSERIAL',
+    'JSON',
+    'JSONB',
+    'XML',
+    'POINT',
+    'LINE',
+    'LSEG',
+    'BOX',
+    'PATH',
+    'POLYGON',
+    'CIRCLE',
+    'INT4RANGE',
+    'INT8RANGE',
+    'NUMRANGE',
+    'TSRANGE',
+    'TSTZRANGE',
+    'DATERANGE',
+    'BIT',
+    'VARBIT',
+    'BIT VARYING',
+    'CIDR',
+    'MACADDR',
+    'MACADDR8',
+    'MONEY',
+    'OID',
+    'REGPROC',
+    'REGCLASS',
+    'REGTYPE',
+    'TSVECTOR',
+    'TSQUERY',
+];
+exports.UNSUPPORTED_SQL_OPERATIONS = [
+    'CREATE TRIGGER',
+    'DROP TRIGGER',
+    'CREATE SEQUENCE',
+    'CREATE EXTENSION',
+    'CREATE RULE',
+    'TRUNCATE',
+    'VACUUM',
+    'ALTER SYSTEM',
+    'LISTEN',
+    'NOTIFY',
+    'CREATE PUBLICATION',
+    'CREATE SUBSCRIPTION',
+    'DO $$',
+    'LANGUAGE plpgsql',
+    'LANGUAGE plpython',
+    'LANGUAGE plperl',
+];
+exports.DSQL_ALTERNATIVES = {
+    'SERIAL': 'UUID PRIMARY KEY DEFAULT gen_random_uuid()',
+    'BIGSERIAL': 'UUID PRIMARY KEY DEFAULT gen_random_uuid()',
+    'SMALLSERIAL': 'UUID PRIMARY KEY DEFAULT gen_random_uuid()',
+    'JSON': 'TEXT (cast to JSON at runtime: data::json)',
+    'JSONB': 'TEXT (cast to JSONB at runtime: data::jsonb)',
+    'ARRAY': 'TEXT (store as JSON string) or normalize to separate table',
+    'triggers': 'Application code or AWS Lambda/EventBridge',
+    'sequences': 'UUID with gen_random_uuid()',
+    'plpgsql': 'LANGUAGE SQL functions or Lambda',
+    'foreign_keys': 'Application-level referential integrity (JOINs still work)',
+    'listen_notify': 'AWS SNS, SQS, or EventBridge',
+    'extensions': 'Built-in functions only',
+    'truncate': 'DELETE FROM table_name',
+    'temp_tables': 'CTEs (WITH clause) or regular tables with session-specific names',
+};

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

@@ -0,0 +1,135 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DSQL_TRANSACTION_LIMITS = exports.DSQL_FEATURES = exports.DsqlAdapter = void 0;
+const index_1 = require("../postgres/index.cjs");
+const features_1 = require("./features.cjs");
+const validator_1 = require("./validator.cjs");
+class DsqlAdapter extends index_1.PostgresAdapter {
+    dialect = 'dsql';
+    displayName = 'AWS Aurora DSQL';
+    features = features_1.DSQL_FEATURES;
+    getTransactionLimits() {
+        return features_1.DSQL_TRANSACTION_LIMITS;
+    }
+    validate(schema) {
+        return (0, validator_1.validateSchemaForDsql)(schema);
+    }
+    validateTable(table) {
+        const issues = (0, validator_1.validateTableForDsql)(table);
+        const errors = issues.filter(i => i.severity === 'error').length;
+        const warnings = issues.filter(i => i.severity === 'warning').length;
+        const info = issues.filter(i => i.severity === 'info').length;
+        return {
+            valid: errors === 0,
+            issues,
+            summary: { errors, warnings, info },
+        };
+    }
+    validateSql(sql) {
+        return (0, validator_1.validateSqlForDsql)(sql);
+    }
+    isTypeSupported(type) {
+        return (0, validator_1.isTypeSupported)(type);
+    }
+    getAlternative(feature) {
+        return (0, validator_1.getAlternative)(feature);
+    }
+    getAlternativeType(type) {
+        return (0, validator_1.getAlternativeType)(type);
+    }
+    async testConnection(connection) {
+        const pgConfig = connection;
+        try {
+            const { Pool } = await Promise.resolve().then(() => __importStar(require("../../../addon/pg/index.cjs")));
+            const { buildPoolConfig } = await Promise.resolve().then(() => __importStar(require("../../../config/config.cjs")));
+            const poolConfig = await buildPoolConfig({
+                url: pgConfig.url,
+                host: pgConfig.host,
+                port: pgConfig.port,
+                database: pgConfig.database,
+                user: pgConfig.user,
+                password: pgConfig.password,
+                ssl: pgConfig.ssl,
+                aws: pgConfig.aws,
+            });
+            const pool = new Pool({ ...poolConfig, max: 1 });
+            try {
+                const client = await pool.connect();
+                await client.query('SELECT 1');
+                client.release();
+                return true;
+            }
+            finally {
+                await pool.end();
+            }
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async getDatabaseVersion(connection) {
+        const { Pool } = await Promise.resolve().then(() => __importStar(require("../../../addon/pg/index.cjs")));
+        const { buildPoolConfig } = await Promise.resolve().then(() => __importStar(require("../../../config/config.cjs")));
+        const config = connection;
+        const poolConfig = await buildPoolConfig({
+            url: config.url,
+            host: config.host,
+            port: config.port,
+            database: config.database,
+            user: config.user,
+            password: config.password,
+            ssl: config.ssl,
+            aws: config.aws,
+        });
+        const pool = new Pool({ ...poolConfig, max: 1 });
+        try {
+            const result = await pool.query('SHOW server_version');
+            const version = result.rows[0]?.server_version || 'unknown';
+            return `Aurora DSQL (PostgreSQL ${version})`;
+        }
+        finally {
+            await pool.end();
+        }
+    }
+    async introspect(connection, options) {
+        const schema = await super.introspect(connection, options);
+        return schema;
+    }
+}
+exports.DsqlAdapter = DsqlAdapter;
+var features_2 = require("./features.cjs");
+Object.defineProperty(exports, "DSQL_FEATURES", { enumerable: true, get: function () { return features_2.DSQL_FEATURES; } });
+Object.defineProperty(exports, "DSQL_TRANSACTION_LIMITS", { enumerable: true, get: function () { return features_2.DSQL_TRANSACTION_LIMITS; } });