relq 1.0.5 → 1.0.7

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

package/dist/config.d.ts

@@ -253,6 +253,14 @@ declare class ClientBase extends events.EventEmitter {
 	getTypeParser: typeof getTypeParser;
 	on<E extends "drain" | "error" | "notice" | "notification" | "end">(event: E, listener: E extends "drain" | "end" ? () => void : E extends "error" ? (err: Error) => void : E extends "notice" ? (notice: NoticeMessage) => void : (message: Notification) => void): this;
 }
+/**
+ * Type-safe PostgreSQL DEFAULT value helpers
+ * Covers all PostgreSQL default value types with 100% typed output
+ */
+export interface DefaultValue {
+	readonly $sql: string;
+	readonly $isDefault: true;
+}
 declare const EMPTY_OBJECT: unique symbol;
 declare const EMPTY_ARRAY: unique symbol;
 export interface ColumnConfig<T = unknown> {
@@ -260,7 +268,7 @@ export interface ColumnConfig<T = unknown> {
 	$sqlType?: string;
 	$tsType?: T;
 	$nullable?: boolean;
-	$default?: T | (() => T) | string | object | typeof EMPTY_OBJECT | typeof EMPTY_ARRAY;
+	$default?: T | (() => T) | string | object | typeof EMPTY_OBJECT | typeof EMPTY_ARRAY | DefaultValue;
 	$primaryKey?: boolean;
 	$unique?: boolean;
 	$references?: {
@@ -282,6 +290,7 @@ export interface ColumnConfig<T = unknown> {
 	$scale?: number;
 	$withTimezone?: boolean;
 	$columnName?: string;
+	$trackingId?: string;
 }
 /**
  * Partition Types and Builders
@@ -332,6 +341,58 @@ export interface IndexDefinition {
 	include?: string[];
 	/** Expression for expression-based indexes */
 	expression?: string;
+	/**
+	 * Generate CREATE INDEX IF NOT EXISTS instead of CREATE INDEX.
+	 *
+	 * When true, the generated SQL will be:
+	 * `CREATE INDEX IF NOT EXISTS index_name ON table_name (...)`
+	 *
+	 * This makes index creation idempotent - if the index already exists,
+	 * PostgreSQL will skip creation instead of throwing an error.
+	 *
+	 * Use cases:
+	 * - Idempotent migrations that can be run multiple times safely
+	 * - Manual schema management where you want to avoid errors on re-runs
+	 * - Incremental schema updates in development environments
+	 * - CI/CD pipelines where schema might already exist
+	 *
+	 * @default false
+	 */
+	ifNotExists?: boolean;
+	/**
+	 * Use ON ONLY clause for partitioned tables.
+	 *
+	 * When true, the generated SQL will be:
+	 * `CREATE INDEX index_name ON ONLY table_name (...)`
+	 *
+	 * This creates an index on the parent partitioned table only, without
+	 * automatically creating matching indexes on child partitions. Each
+	 * partition must have its own index created separately.
+	 *
+	 * Use cases:
+	 * - When you want different index configurations per partition
+	 * - When partitions have different access patterns
+	 * - When you want to control index creation timing per partition
+	 * - For declarative partitioning with custom index strategies
+	 * - When some partitions don't need certain indexes (e.g., archive partitions)
+	 *
+	 * @default false
+	 * @see https://www.postgresql.org/docs/current/ddl-partitioning.html#DDL-PARTITIONING-DECLARATIVE-MAINTENANCE
+	 */
+	tableOnly?: boolean;
+	/** Index comment/description */
+	comment?: string;
+	/** Tracking ID for rename detection */
+	trackingId?: string;
+}
+/** Constraint definition result */
+export interface ConstraintDef {
+	readonly $type: "PRIMARY KEY" | "UNIQUE" | "EXCLUDE";
+	readonly $name: string;
+	readonly $columns: string[];
+	readonly $expression?: string;
+	/** Tracking ID for rename detection */
+	readonly $trackingId?: string;
 }
 export type IsSerialType<T extends string> = T extends "SERIAL" | "BIGSERIAL" | "SMALLSERIAL" | "SERIAL4" | "SERIAL2" | "SERIAL8" ? true : false;
 export type HasDefault<C> = C extends {
@@ -417,6 +478,8 @@ export interface TableDefinition<T extends Record<string, ColumnConfig>> {
 		expression: string;
 		name?: string;
 	}>;
+	/** Table-level constraints (composite PKs, etc.) */
+	$constraints?: ConstraintDef[];
 	$foreignKeys?: Array<{
 		columns: string[];
 		references: {
@@ -426,17 +489,93 @@ export interface TableDefinition<T extends Record<string, ColumnConfig>> {
 		onDelete?: string;
 		onUpdate?: string;
 		name?: string;
+		/** Tracking ID for rename detection */
+		trackingId?: string;
 	}>;
 	$indexes?: IndexDefinition[];
 	$inherits?: string[];
 	$partitionBy?: PartitionStrategyDef;
 	$tablespace?: string;
 	$withOptions?: Record<string, unknown>;
+	/** Whether to use CREATE TABLE IF NOT EXISTS */
+	$ifNotExists?: boolean;
+	/** Tracking ID for rename detection */
+	$trackingId?: string;
 	$inferSelect: BuildSelectType<T>;
 	$inferInsert: BuildInsertType<T>;
 	toSQL(): string;
 	toCreateIndexSQL(): string[];
 }
+/**
+ * AWS regions with autocomplete support
+ * Includes all standard AWS regions that may support DSQL
+ */
+export type AwsRegion = "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2" | "eu-west-1" | "eu-west-2" | "eu-west-3" | "eu-central-1" | "eu-central-2" | "eu-north-1" | "eu-south-1" | "eu-south-2" | "ap-east-1" | "ap-south-1" | "ap-south-2" | "ap-northeast-1" | "ap-northeast-2" | "ap-northeast-3" | "ap-southeast-1" | "ap-southeast-2" | "ap-southeast-3" | "ap-southeast-4" | "me-south-1" | "me-central-1" | "af-south-1" | "il-central-1" | "sa-east-1" | "ca-central-1" | "ca-west-1" | "us-gov-east-1" | "us-gov-west-1" | (string & {});
+/**
+ * AWS DSQL (Aurora Serverless) configuration
+ * When provided, Relq automatically handles IAM token generation and caching
+ *
+ * @example
+ * ```typescript
+ * const db = new Relq(schema, {
+ *     database: 'postgres',
+ *     aws: {
+ *         hostname: 'abc123.dsql.us-east-1.on.aws',
+ *         region: 'us-east-1', // Autocomplete supported!
+ *         accessKeyId: 'AKIA...',
+ *         secretAccessKey: '...'
+ *     }
+ * });
+ * ```
+ */
+export interface AwsDbConfig {
+	/**
+	 * DSQL cluster hostname
+	 * @example "7btnrhwkzis7lsxg24cqdyzsm4.dsql.us-east-1.on.aws"
+	 */
+	hostname: string;
+	/**
+	 * AWS region with autocomplete support
+	 * @example "us-east-1"
+	 */
+	region: AwsRegion;
+	/**
+	 * AWS Access Key ID
+	 * Required unless useDefaultCredentials is true
+	 */
+	accessKeyId?: string;
+	/**
+	 * AWS Secret Access Key
+	 * Required unless useDefaultCredentials is true
+	 */
+	secretAccessKey?: string;
+	/**
+	 * Database port (inherited from root config if not specified)
+	 * @default 5432
+	 */
+	port?: number;
+	/**
+	 * Database user (inherited from root config if not specified)
+	 * @default 'admin'
+	 */
+	user?: string;
+	/**
+	 * Enable SSL/TLS for connection
+	 * @default true (DSQL typically requires SSL)
+	 */
+	ssl?: boolean;
+	/**
+	 * Use AWS default credential provider chain
+	 * (env vars, IAM role, ~/.aws/credentials)
+	 * @default false
+	 */
+	useDefaultCredentials?: boolean;
+	/**
+	 * Token expiration time in seconds
+	 * @default 604800 (7 days)
+	 */
+	tokenExpiresIn?: number;
+}
 export interface RelqMigrationConfig {
 	directory: string;
 	tableName?: string;
@@ -466,6 +605,12 @@ export interface RelqCacheConfig {
 export interface RelqConnectionConfig extends Omit<PoolConfig, "ssl"> {
 	url?: string;
 	ssl?: boolean | "require" | "prefer" | "allow" | "disable" | PoolConfig["ssl"];
+	/**
+	 * AWS DSQL configuration
+	 * When provided, enables first-class AWS Aurora DSQL support
+	 * with automatic IAM token generation and caching
+	 */
+	aws?: AwsDbConfig;
 }
 export interface RelqGenerateConfig {
 	outDir: string;
@@ -635,7 +780,7 @@ export interface RelqPlugin {
 	};
 }
 export declare function defineConfig<TTables extends Record<string, TableDefinition<Record<string, ColumnConfig>>> = Record<string, TableDefinition<Record<string, ColumnConfig>>>>(config: RelqConfig<TTables>): RelqConfig<TTables>;
-export declare function loadConfig(path?: string): Promise<RelqConfig>;
+export declare function loadConfig(startPath?: string): Promise<RelqConfig>;
 export declare function parseConnectionUrl(url: string): RelqConnectionConfig;
 export declare function mergeConfigs(...configs: Partial<RelqConfig>[]): RelqConfig;
 export declare function validateConfig(config: RelqConfig): {