relq 1.0.4 → 1.0.6

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;
+}

package/dist/cjs/utils/aws-dsql.cjs

@@ -0,0 +1,177 @@
+"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.getAwsDsqlToken = getAwsDsqlToken;
+exports.clearAwsDsqlToken = clearAwsDsqlToken;
+exports.isAwsDsql = isAwsDsql;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const node_crypto_1 = require("node:crypto");
+const node_constants_1 = require("node:constants");
+const relq_errors_1 = require("../errors/relq-errors.cjs");
+const tokenCache = new Map();
+function getCacheKey(config) {
+    const hash = (0, node_crypto_1.createHash)('md5')
+        .update(`${config.secretAccessKey ?? ''}-${config.accessKeyId ?? ''}-${config.region}-${config.hostname}`)
+        .digest('hex');
+    return hash;
+}
+function getTempFolder() {
+    return (0, node_path_1.join)((0, node_os_1.tmpdir)(), '.dsql_');
+}
+function isTempFolderAvailable() {
+    const tempFolder = getTempFolder();
+    try {
+        (0, node_fs_1.mkdirSync)(tempFolder, { recursive: true });
+        (0, node_fs_1.accessSync)(tempFolder, node_constants_1.F_OK | node_constants_1.R_OK | node_constants_1.W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getFromCache(cacheKey) {
+    const memoryToken = tokenCache.get(cacheKey);
+    if (memoryToken && memoryToken.expiresAt > Date.now()) {
+        return memoryToken;
+    }
+    const envName = `DSQL_TOKEN_${cacheKey}`;
+    const envToken = process.env[envName];
+    if (envToken) {
+        try {
+            const parsed = JSON.parse(envToken);
+            if (parsed.expiresAt > Date.now()) {
+                tokenCache.set(cacheKey, parsed);
+                return parsed;
+            }
+        }
+        catch { }
+    }
+    if (isTempFolderAvailable()) {
+        const tokenFile = (0, node_path_1.join)(getTempFolder(), `${cacheKey}.json`);
+        if ((0, node_fs_1.existsSync)(tokenFile)) {
+            try {
+                const parsed = JSON.parse((0, node_fs_1.readFileSync)(tokenFile, 'utf8'));
+                if (parsed.expiresAt > Date.now()) {
+                    tokenCache.set(cacheKey, parsed);
+                    process.env[envName] = JSON.stringify(parsed);
+                    return parsed;
+                }
+            }
+            catch { }
+        }
+    }
+    return null;
+}
+function saveToCache(cacheKey, token) {
+    tokenCache.set(cacheKey, token);
+    const envName = `DSQL_TOKEN_${cacheKey}`;
+    process.env[envName] = JSON.stringify(token);
+    if (isTempFolderAvailable()) {
+        const tokenFile = (0, node_path_1.join)(getTempFolder(), `${cacheKey}.json`);
+        try {
+            (0, node_fs_1.writeFileSync)(tokenFile, JSON.stringify(token));
+        }
+        catch { }
+    }
+}
+let DsqlSigner = null;
+async function loadAwsSdk() {
+    if (!DsqlSigner) {
+        try {
+            const sdk = await Promise.resolve().then(() => __importStar(require('@aws-sdk/dsql-signer')));
+            DsqlSigner = sdk.DsqlSigner;
+        }
+        catch (error) {
+            throw new relq_errors_1.RelqConfigError('AWS DSQL requires @aws-sdk/dsql-signer package.\n\n' +
+                'Install it with:\n' +
+                '  npm install @aws-sdk/dsql-signer\n' +
+                '  # or\n' +
+                '  bun add @aws-sdk/dsql-signer', { field: '@aws-sdk/dsql-signer', value: 'not installed' });
+        }
+    }
+    return DsqlSigner;
+}
+async function getAwsDsqlToken(config) {
+    const cacheKey = getCacheKey(config);
+    const cached = getFromCache(cacheKey);
+    if (cached) {
+        return cached.token;
+    }
+    if (!config.useDefaultCredentials && (!config.accessKeyId || !config.secretAccessKey)) {
+        throw new relq_errors_1.RelqConfigError('AWS DSQL requires credentials. Either provide accessKeyId + secretAccessKey, ' +
+            'or set useDefaultCredentials: true to use AWS credential chain.', { field: 'aws.credentials', value: 'missing' });
+    }
+    const SignerClass = await loadAwsSdk();
+    const expiresIn = config.tokenExpiresIn ?? 604800;
+    const signerConfig = {
+        hostname: config.hostname,
+        region: config.region,
+        expiresIn,
+    };
+    if (!config.useDefaultCredentials) {
+        signerConfig.credentials = {
+            accessKeyId: config.accessKeyId,
+            secretAccessKey: config.secretAccessKey,
+        };
+    }
+    const signer = new SignerClass(signerConfig);
+    const token = await signer.getDbConnectAdminAuthToken();
+    const cachedToken = {
+        token,
+        expiresAt: Date.now() + ((expiresIn - 30) * 1000)
+    };
+    saveToCache(cacheKey, cachedToken);
+    return token;
+}
+function clearAwsDsqlToken(config) {
+    const cacheKey = getCacheKey(config);
+    tokenCache.delete(cacheKey);
+    const envName = `DSQL_TOKEN_${cacheKey}`;
+    delete process.env[envName];
+    if (isTempFolderAvailable()) {
+        const tokenFile = (0, node_path_1.join)(getTempFolder(), `${cacheKey}.json`);
+        try {
+            if ((0, node_fs_1.existsSync)(tokenFile)) {
+                (0, node_fs_1.writeFileSync)(tokenFile, '');
+            }
+        }
+        catch { }
+    }
+}
+function isAwsDsql(config) {
+    return !!config.aws?.hostname && !!config.aws?.region;
+}