relq 1.0.5 → 1.0.7

package/dist/cjs/schema-definition/index.cjs

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateChildPartitionSQL = exports.generatePartitionBySQL = exports.partitionStrategyFactory = exports.isSequenceConfig = exports.dropSequenceSQL = exports.generateSequenceSQL = exports.pgSequence = exports.isTriggerConfig = exports.dropTriggerSQL = exports.generateTriggerSQL = exports.pgTrigger = exports.isFunctionConfig = exports.dropFunctionSQL = exports.generateFunctionSQL = exports.pgFunction = exports.addEnumValueSQL = exports.dropEnumSQL = exports.generateEnumSQL = exports.pgEnum = exports.manyToMany = exports.many = exports.one = exports.introspectMultiple = exports.introspectSQL = exports.generateSchemaCode = exports.parseCreateTable = exports.createExpressionBuilder = exports.expressionBuilder = exports.createTableColumnRefs = exports.createGeneratedExprBuilder = exports.createWhereBuilder = exports.getSql = exports.pgExtensions = exports.sqlFunctions = exports.defineTable = void 0;
+exports.DEFAULT = exports.generateChildPartitionSQL = exports.generatePartitionBySQL = exports.partitionStrategyFactory = exports.materializedViewToSQL = exports.viewToSQL = exports.pgMaterializedView = exports.pgView = exports.isSequenceConfig = exports.dropSequenceSQL = exports.generateSequenceSQL = exports.pgSequence = exports.isTriggerConfig = exports.dropTriggerSQL = exports.generateTriggerSQL = exports.pgTrigger = exports.isFunctionConfig = exports.dropFunctionSQL = exports.generateFunctionSQL = exports.pgFunction = exports.addEnumValueSQL = exports.dropEnumSQL = exports.generateEnumSQL = exports.pgEnum = exports.matchCodeToString = exports.stringToActionCode = exports.actionCodeToString = exports.generateReferencesSQL = exports.defineRelations = exports.pgRelations = exports.manyToMany = exports.many = exports.one = exports.introspectMultiple = exports.introspectSQL = exports.generateSchemaCode = exports.parseCreateTable = exports.createExpressionBuilder = exports.expressionBuilder = exports.createTableColumnRefs = exports.createGeneratedExprBuilder = exports.createWhereBuilder = exports.getSql = exports.pgExtensions = exports.sqlFunctions = exports.defineTable = void 0;
 __exportStar(require("./column-types.cjs"), exports);
 var table_definition_1 = require("./table-definition.cjs");
 Object.defineProperty(exports, "defineTable", { enumerable: true, get: function () { return table_definition_1.defineTable; } });
@@ -36,6 +36,13 @@ var relations_1 = require("./relations.cjs");
 Object.defineProperty(exports, "one", { enumerable: true, get: function () { return relations_1.one; } });
 Object.defineProperty(exports, "many", { enumerable: true, get: function () { return relations_1.many; } });
 Object.defineProperty(exports, "manyToMany", { enumerable: true, get: function () { return relations_1.manyToMany; } });
+var pg_relations_1 = require("./pg-relations.cjs");
+Object.defineProperty(exports, "pgRelations", { enumerable: true, get: function () { return pg_relations_1.pgRelations; } });
+Object.defineProperty(exports, "defineRelations", { enumerable: true, get: function () { return pg_relations_1.defineRelations; } });
+Object.defineProperty(exports, "generateReferencesSQL", { enumerable: true, get: function () { return pg_relations_1.generateReferencesSQL; } });
+Object.defineProperty(exports, "actionCodeToString", { enumerable: true, get: function () { return pg_relations_1.actionCodeToString; } });
+Object.defineProperty(exports, "stringToActionCode", { enumerable: true, get: function () { return pg_relations_1.stringToActionCode; } });
+Object.defineProperty(exports, "matchCodeToString", { enumerable: true, get: function () { return pg_relations_1.matchCodeToString; } });
 var pg_enum_1 = require("./pg-enum.cjs");
 Object.defineProperty(exports, "pgEnum", { enumerable: true, get: function () { return pg_enum_1.pgEnum; } });
 Object.defineProperty(exports, "generateEnumSQL", { enumerable: true, get: function () { return pg_enum_1.generateEnumSQL; } });
@@ -56,7 +63,14 @@ Object.defineProperty(exports, "pgSequence", { enumerable: true, get: function (
 Object.defineProperty(exports, "generateSequenceSQL", { enumerable: true, get: function () { return pg_sequence_1.generateSequenceSQL; } });
 Object.defineProperty(exports, "dropSequenceSQL", { enumerable: true, get: function () { return pg_sequence_1.dropSequenceSQL; } });
 Object.defineProperty(exports, "isSequenceConfig", { enumerable: true, get: function () { return pg_sequence_1.isSequenceConfig; } });
+var pg_view_1 = require("./pg-view.cjs");
+Object.defineProperty(exports, "pgView", { enumerable: true, get: function () { return pg_view_1.pgView; } });
+Object.defineProperty(exports, "pgMaterializedView", { enumerable: true, get: function () { return pg_view_1.pgMaterializedView; } });
+Object.defineProperty(exports, "viewToSQL", { enumerable: true, get: function () { return pg_view_1.viewToSQL; } });
+Object.defineProperty(exports, "materializedViewToSQL", { enumerable: true, get: function () { return pg_view_1.materializedViewToSQL; } });
 var partitions_1 = require("./partitions.cjs");
 Object.defineProperty(exports, "partitionStrategyFactory", { enumerable: true, get: function () { return partitions_1.partitionStrategyFactory; } });
 Object.defineProperty(exports, "generatePartitionBySQL", { enumerable: true, get: function () { return partitions_1.generatePartitionBySQL; } });
 Object.defineProperty(exports, "generateChildPartitionSQL", { enumerable: true, get: function () { return partitions_1.generateChildPartitionSQL; } });
+var defaults_1 = require("./defaults.cjs");
+Object.defineProperty(exports, "DEFAULT", { enumerable: true, get: function () { return defaults_1.DEFAULT; } });

package/dist/cjs/schema-definition/introspection.cjs

@@ -478,7 +478,7 @@ function generateSchemaCode(table, options) {
             modifiers.push('.unique()');
         }
         if (col.default !== undefined) {
-            const defaultVal = formatDefaultValue(col.default);
+            const defaultVal = formatDefaultValue(col.default, col.type);
             modifiers.push(`.default(${defaultVal})`);
         }
         if (col.references) {
@@ -583,7 +583,7 @@ function toPascalCase(str) {
 function escapeString(str) {
     return str.replace(/'/g, "\\'").replace(/\\/g, '\\\\');
 }
-function formatDefaultValue(value) {
+function formatDefaultValue(value, colType) {
     const upper = value.toUpperCase().trim();
     if (upper === 'NOW()' || upper === 'CURRENT_TIMESTAMP' ||
         upper === 'CURRENT_DATE' || upper === 'CURRENT_TIME') {
@@ -598,7 +598,11 @@ function formatDefaultValue(value) {
     if (upper === 'NULL') {
         return 'null';
     }
-    if (/^-?\d+(\.\d+)?$/.test(value)) {
+    const isBigint = colType?.toLowerCase().startsWith('bigint');
+    if (/^-?\d+$/.test(value)) {
+        return isBigint ? `${value}n` : value;
+    }
+    if (/^-?\d+\.\d+$/.test(value)) {
         return value;
     }
     if (value.includes('(')) {

package/dist/cjs/schema-definition/pg-relations.cjs

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pgRelations = pgRelations;
+exports.defineRelations = defineRelations;
+exports.actionCodeToString = actionCodeToString;
+exports.stringToActionCode = stringToActionCode;
+exports.matchCodeToString = matchCodeToString;
+exports.generateReferencesSQL = generateReferencesSQL;
+function createColumnRef(tableName, columnName, schemaKey) {
+    return {
+        $table: tableName,
+        $column: columnName,
+        $schemaKey: schemaKey,
+    };
+}
+function createTargetColumnRefs(schemaKey, table) {
+    const refs = {};
+    const actualTableName = table.$name;
+    for (const colName of Object.keys(table.$columns)) {
+        const colDef = table.$columns[colName];
+        const actualColName = colDef.$sqlName || colName;
+        refs[colName] = createColumnRef(actualTableName, actualColName, colName);
+    }
+    return refs;
+}
+function createReferenceToBuilder(schema, currentTableKey) {
+    return new Proxy({}, {
+        get(_, targetTableKey) {
+            const targetTable = schema[targetTableKey];
+            if (!targetTable) {
+                throw new Error(`Unknown table: ${targetTableKey}`);
+            }
+            return (callback) => {
+                const targetColRefs = createTargetColumnRefs(targetTableKey, targetTable);
+                const options = callback(targetColRefs);
+                const currentTable = schema[currentTableKey];
+                const currentTableName = currentTable?.$name || currentTableKey;
+                if ('columns' in options && Array.isArray(options.columns)) {
+                    const compositeOpts = options;
+                    return {
+                        $type: 'foreignKey',
+                        $targetTable: targetTable.$name,
+                        $columns: compositeOpts.columns.map(c => ({
+                            table: c.$table,
+                            column: c.$column,
+                        })),
+                        $references: compositeOpts.references.map(r => ({
+                            table: r.$table,
+                            column: r.$column,
+                        })),
+                        $onDelete: compositeOpts.onDelete,
+                        $onUpdate: compositeOpts.onUpdate,
+                        $match: compositeOpts.match,
+                        $deferrable: compositeOpts.deferrable,
+                        $initiallyDeferred: compositeOpts.initiallyDeferred,
+                    };
+                }
+                const singleOpts = options;
+                const referencesCol = singleOpts.references;
+                return {
+                    $type: 'foreignKey',
+                    $targetTable: targetTable.$name,
+                    $columns: [],
+                    $references: referencesCol ? [{
+                            table: referencesCol.$table,
+                            column: referencesCol.$column,
+                        }] : undefined,
+                    $onDelete: singleOpts.onDelete,
+                    $onUpdate: singleOpts.onUpdate,
+                    $match: singleOpts.match,
+                    $deferrable: singleOpts.deferrable,
+                    $initiallyDeferred: singleOpts.initiallyDeferred,
+                };
+            };
+        },
+    });
+}
+function createSourceColumnRefs(schemaKey, table) {
+    const refs = {};
+    const actualTableName = table.$name;
+    for (const colName of Object.keys(table.$columns)) {
+        const colDef = table.$columns[colName];
+        const actualColName = colDef.$sqlName || colName;
+        refs[colName] = createColumnRef(actualTableName, actualColName, colName);
+    }
+    return refs;
+}
+function createFullBuilder(schema, currentTableKey) {
+    const builder = {
+        referenceTo: createReferenceToBuilder(schema, currentTableKey),
+    };
+    for (const [tableName, table] of Object.entries(schema)) {
+        builder[tableName] = createSourceColumnRefs(tableName, table);
+    }
+    return builder;
+}
+function pgRelations(schema, builder) {
+    const tables = {};
+    for (const tableKey of Object.keys(schema)) {
+        tables[tableKey] = (defineRelations) => {
+            const fullBuilder = createFullBuilder(schema, tableKey);
+            return defineRelations(fullBuilder);
+        };
+    }
+    return builder(tables);
+}
+function defineRelations(schema, relationDefs) {
+    const result = {};
+    for (const [tableKey, defFn] of Object.entries(relationDefs)) {
+        if (typeof defFn === 'function') {
+            const fullBuilder = createFullBuilder(schema, tableKey);
+            result[tableKey] = defFn(fullBuilder);
+        }
+    }
+    return result;
+}
+function actionCodeToString(code) {
+    switch (code) {
+        case 'a': return 'NO ACTION';
+        case 'r': return 'RESTRICT';
+        case 'c': return 'CASCADE';
+        case 'n': return 'SET NULL';
+        case 'd': return 'SET DEFAULT';
+        default: return 'NO ACTION';
+    }
+}
+function stringToActionCode(action) {
+    switch (action) {
+        case 'NO ACTION': return 'a';
+        case 'RESTRICT': return 'r';
+        case 'CASCADE': return 'c';
+        case 'SET NULL': return 'n';
+        case 'SET DEFAULT': return 'd';
+        default: return 'a';
+    }
+}
+function matchCodeToString(code) {
+    switch (code) {
+        case 'f': return 'FULL';
+        case 's':
+        default: return 'SIMPLE';
+    }
+}
+function generateReferencesSQL(relation, columnName, columnType = 'uuid') {
+    const parts = [`${columnName} ${columnType}`];
+    if (relation.$references && relation.$references.length > 0) {
+        const refCols = relation.$references.map(r => r.column).join(', ');
+        parts.push(`REFERENCES ${relation.$targetTable}(${refCols})`);
+    }
+    else {
+        parts.push(`REFERENCES ${relation.$targetTable}`);
+    }
+    if (relation.$onDelete && relation.$onDelete !== 'NO ACTION') {
+        parts.push(`ON DELETE ${relation.$onDelete}`);
+    }
+    if (relation.$onUpdate && relation.$onUpdate !== 'NO ACTION') {
+        parts.push(`ON UPDATE ${relation.$onUpdate}`);
+    }
+    if (relation.$match && relation.$match !== 'SIMPLE') {
+        parts.push(`MATCH ${relation.$match}`);
+    }
+    if (relation.$deferrable) {
+        parts.push('DEFERRABLE');
+        if (relation.$initiallyDeferred) {
+            parts.push('INITIALLY DEFERRED');
+        }
+    }
+    return parts.join(' ');
+}

package/dist/cjs/schema-definition/pg-view.cjs

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pgView = pgView;
+exports.pgMaterializedView = pgMaterializedView;
+exports.viewToSQL = viewToSQL;
+exports.materializedViewToSQL = materializedViewToSQL;
+function pgView(name, definition) {
+    return {
+        _type: 'view',
+        name,
+        definition: definition.trim(),
+        isMaterialized: false,
+    };
+}
+function pgMaterializedView(name, definition, options) {
+    return {
+        _type: 'materialized_view',
+        name,
+        definition: definition.trim(),
+        isMaterialized: true,
+        withData: options?.withData,
+    };
+}
+function viewToSQL(view) {
+    return `CREATE OR REPLACE VIEW "${view.name}" AS\n${view.definition};`;
+}
+function materializedViewToSQL(view) {
+    const withData = view.withData !== false ? ' WITH DATA' : ' WITH NO DATA';
+    return `CREATE MATERIALIZED VIEW IF NOT EXISTS "${view.name}" AS\n${view.definition}${withData};`;
+}

package/dist/cjs/schema-definition/table-definition.cjs

@@ -43,6 +43,9 @@ function createColumnExpr(colName) {
         neq(value) {
             return whereCondition(`${this.$sql} != ${formatWhereValue(value)}`);
         },
+        ne(value) {
+            return whereCondition(`${this.$sql} <> ${formatWhereValue(value)}`);
+        },
         gt(value) {
             return whereCondition(`${this.$sql} > ${formatWhereValue(value)}`);
         },
@@ -177,6 +180,9 @@ function createCheckExpr(sql) {
         neq(value) {
             return createCheckWhereCondition(`${this.$sql} != ${formatVal(value)}`);
         },
+        ne(value) {
+            return createCheckWhereCondition(`${this.$sql} <> ${formatVal(value)}`);
+        },
         isNull() {
             return createCheckWhereCondition(`${this.$sql} IS NULL`);
         },
@@ -261,6 +267,53 @@ function createCheckConstraintBuilder() {
         constraint(name, condition) {
             return { name, expression: condition.$sql };
         },
+        raw(expression) {
+            return createCheckWhereCondition(expression);
+        },
+    };
+}
+function createConstraintBuilder() {
+    return {
+        primaryKey(...args) {
+            if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null && 'columns' in args[0]) {
+                const opts = args[0];
+                return {
+                    $type: 'PRIMARY KEY',
+                    $name: opts.name || '',
+                    $columns: opts.columns.map(c => String(c)),
+                };
+            }
+            const columns = args;
+            return {
+                $type: 'PRIMARY KEY',
+                $name: '',
+                $columns: columns.map(c => String(c)),
+            };
+        },
+        unique(...args) {
+            if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null && 'columns' in args[0]) {
+                const opts = args[0];
+                return {
+                    $type: 'UNIQUE',
+                    $name: opts.name || '',
+                    $columns: opts.columns.map(c => String(c)),
+                };
+            }
+            const columns = args;
+            return {
+                $type: 'UNIQUE',
+                $name: '',
+                $columns: columns.map(c => String(c)),
+            };
+        },
+        exclude(name, expression) {
+            return {
+                $type: 'EXCLUDE',
+                $name: name,
+                $columns: [],
+                $expression: expression,
+            };
+        },
     };
 }
 function createColumnRefs(columns) {
@@ -272,6 +325,15 @@ function createColumnRefs(columns) {
     }
     return refs;
 }
+function createIndexTableRefs(columns) {
+    const refs = {};
+    for (const key of Object.keys(columns)) {
+        const col = columns[key];
+        const colName = col.$columnName || key;
+        refs[key] = createColumnExpr(colName);
+    }
+    return refs;
+}
 function createIndexFactory() {
     const factory = (name) => {
         const def = {
@@ -331,6 +393,22 @@ function createIndexFactory() {
                 def._opclass = opclass;
                 return Object.assign(this, { _opclass: opclass });
             },
+            ifNotExists() {
+                def.ifNotExists = true;
+                return Object.assign(this, { ifNotExists: true });
+            },
+            tableOnly() {
+                def.tableOnly = true;
+                return Object.assign(this, { tableOnly: true });
+            },
+            comment(text) {
+                def.comment = text;
+                return Object.assign(this, { comment: text });
+            },
+            $id(trackingId) {
+                def.trackingId = trackingId;
+                return Object.assign(this, { trackingId: trackingId });
+            },
         };
         return {
             on(...columns) {
@@ -354,10 +432,11 @@ function createIndexFactory() {
 const indexFactory = createIndexFactory();
 function defineTable(name, columns, options) {
     const columnRefs = createColumnRefs(columns);
+    const indexTableRefs = createIndexTableRefs(columns);
     let resolvedIndexes;
     if (options?.indexes) {
         if (typeof options.indexes === 'function') {
-            const rawIndexes = options.indexes(columnRefs, indexFactory, sql_expressions_1.sqlFunctions);
+            const rawIndexes = options.indexes(indexTableRefs, indexFactory, sql_expressions_1.sqlFunctions);
             resolvedIndexes = rawIndexes.map(normalizeIndexDef);
         }
         else {
@@ -375,6 +454,11 @@ function defineTable(name, columns, options) {
         const constraints = options.checkConstraints(checkTableRefs, checkBuilder);
         resolvedCheckConstraints = constraints.map(c => ({ expression: c.expression, name: c.name }));
     }
+    let resolvedConstraints;
+    if (options?.constraints) {
+        const constraintBuilder = createConstraintBuilder();
+        resolvedConstraints = options.constraints(columnRefs, constraintBuilder);
+    }
     const definition = {
         $name: name,
         $schema: options?.schema,
@@ -382,12 +466,14 @@ function defineTable(name, columns, options) {
         $primaryKey: options?.primaryKey,
         $uniqueConstraints: options?.uniqueConstraints,
         $checkConstraints: resolvedCheckConstraints,
+        $constraints: resolvedConstraints,
         $foreignKeys: options?.foreignKeys,
         $indexes: resolvedIndexes,
         $inherits: options?.inherits,
         $partitionBy: resolvedPartitionBy,
         $tablespace: options?.tablespace,
         $withOptions: options?.withOptions,
+        $ifNotExists: options?.ifNotExists,
         $inferSelect: {},
         $inferInsert: {},
         toSQL() {
@@ -416,13 +502,16 @@ function normalizeIndexDef(idx) {
         nulls: idx.nulls,
         order: idx.order,
         include: idx.include,
+        ifNotExists: idx.ifNotExists,
+        tableOnly: idx.tableOnly,
     };
 }
 function generateCreateTableSQL(def) {
     const tableName = def.$schema
         ? `${pg_format_1.default.ident(def.$schema)}.${pg_format_1.default.ident(def.$name)}`
         : pg_format_1.default.ident(def.$name);
-    const parts = [`CREATE TABLE ${tableName} (`];
+    const ifNotExistsClause = def.$ifNotExists ? 'IF NOT EXISTS ' : '';
+    const parts = [`CREATE TABLE ${ifNotExistsClause}${tableName} (`];
     const columnDefs = [];
     const constraints = [];
     for (const [colName, colConfig] of Object.entries(def.$columns)) {
@@ -456,6 +545,12 @@ function generateCreateTableSQL(def) {
             }
         }
     }
+    if (def.$constraints) {
+        for (const c of def.$constraints) {
+            const cols = c.$columns.map(col => pg_format_1.default.ident(col)).join(', ');
+            constraints.push(`CONSTRAINT ${pg_format_1.default.ident(c.$name)} ${c.$type} (${cols})`);
+        }
+    }
     if (def.$foreignKeys) {
         for (const fk of def.$foreignKeys) {
             const cols = fk.columns.map(c => pg_format_1.default.ident(c)).join(', ');
@@ -517,7 +612,10 @@ function generateColumnSQL(name, config) {
         const defaultVal = typeof config.$default === 'function'
             ? config.$default()
             : config.$default;
-        if (typeof defaultVal === 'symbol') {
+        if (typeof defaultVal === 'object' && defaultVal !== null && '$isDefault' in defaultVal && '$sql' in defaultVal) {
+            parts.push(`DEFAULT ${defaultVal.$sql}`);
+        }
+        else if (typeof defaultVal === 'symbol') {
             const symDesc = defaultVal.description || String(defaultVal);
             if (symDesc.includes('emptyObject')) {
                 parts.push(`DEFAULT '{}'::jsonb`);
@@ -593,7 +691,15 @@ function generateIndexSQL(def) {
         if (idx.unique) {
             sql += ' UNIQUE';
         }
-        sql += ` INDEX ${pg_format_1.default.ident(indexName)} ON ${tableName}`;
+        sql += ' INDEX';
+        if (idx.ifNotExists) {
+            sql += ' IF NOT EXISTS';
+        }
+        sql += ` ${pg_format_1.default.ident(indexName)} ON`;
+        if (idx.tableOnly) {
+            sql += ' ONLY';
+        }
+        sql += ` ${tableName}`;
         if (idx.using) {
             sql += ` USING ${idx.using}`;
         }

package/dist/cjs/types/config-types.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isPoolingEnabled = isPoolingEnabled;
 exports.toPoolConfig = toPoolConfig;
+exports.isAwsDsqlConfig = isAwsDsqlConfig;
 const pool_defaults_1 = require("../utils/pool-defaults.cjs");
 function isPoolingEnabled(config) {
     return config.pooling !== false;
@@ -10,18 +11,23 @@ function toPoolConfig(config) {
     const smartDefaults = config.disableSmartDefaults
         ? { min: 0, max: 10, idleTimeoutMillis: 30000, connectionTimeoutMillis: 0 }
         : (0, pool_defaults_1.mergeWithDefaults)(config.pool);
+    const isAws = !!config.aws;
+    const host = isAws ? config.aws.hostname : (config.host || 'localhost');
+    const port = config.aws?.port ?? config.port ?? 5432;
+    const user = config.aws?.user ?? config.user ?? (isAws ? 'admin' : undefined);
+    const ssl = isAws ? (config.aws.ssl ?? true) : config.ssl;
     const poolConfig = {
-        host: config.host || 'localhost',
-        port: config.port || 5432,
+        host,
+        port,
         database: config.database,
-        user: config.user,
+        user,
         password: config.password,
         min: config.pool?.min ?? smartDefaults.min,
         max: config.pool?.max ?? smartDefaults.max,
         idleTimeoutMillis: config.pool?.idleTimeoutMillis ?? smartDefaults.idleTimeoutMillis,
         connectionTimeoutMillis: config.pool?.connectionTimeoutMillis ?? smartDefaults.connectionTimeoutMillis,
         application_name: config.pool?.application_name,
-        ssl: config.pool?.ssl,
+        ssl: config.pool?.ssl ?? ssl,
         allowExitOnIdle: true
     };
     if (config.connectionString) {
@@ -38,3 +44,6 @@ function toPoolConfig(config) {
     }
     return poolConfig;
 }
+function isAwsDsqlConfig(config) {
+    return !!config.aws?.hostname && !!config.aws?.region;
+}