taurusdb-core 0.4.0 → 0.5.0-rc.10

package/dist/executor/connection-pool.js

@@ -1,3 +1,4 @@
+import { isIP } from "node:net";
 import { ulid } from "ulid";
 export class ConnectionPoolError extends Error {
     code = "CONNECTION_FAILED";
@@ -9,35 +10,41 @@ export class ConnectionPoolError extends Error {
         }
     }
 }
-function poolKey(datasource, mode) {
-    return `${datasource}:${mode}`;
+function poolKey(datasource, mode, database) {
+    return JSON.stringify([datasource, mode, database ?? null]);
 }
-async function resolveTls(tls, secretResolver) {
-    if (!tls) {
+async function resolveTls(tls, secretResolver, host, requireTls) {
+    if (!tls && !requireTls) {
         return undefined;
     }
+    if (requireTls && tls?.enabled === false) {
+        throw new ConnectionPoolError("TLS is required by server policy and cannot be disabled for this datasource.");
+    }
     const resolved = {
-        enabled: tls.enabled,
-        rejectUnauthorized: tls.rejectUnauthorized,
-        servername: tls.servername,
+        enabled: tls?.enabled ?? true,
+        // Dynamic cloud targets are commonly bound by public IP while the server
+        // certificate is issued to a DNS name. When TLS is explicitly enabled,
+        // make CA/hostname verification a separate profile opt-in.
+        rejectUnauthorized: tls?.rejectUnauthorized ?? false,
+        servername: tls?.servername ?? (isIP(host) === 0 ? host : undefined),
     };
-    if (tls.ca) {
+    if (tls?.ca) {
         resolved.ca = await secretResolver.resolve(tls.ca);
     }
-    if (tls.cert) {
+    if (tls?.cert) {
         resolved.cert = await secretResolver.resolve(tls.cert);
     }
-    if (tls.key) {
+    if (tls?.key) {
         resolved.key = await secretResolver.resolve(tls.key);
     }
     return resolved;
 }
-function selectCredential(profile, mode, _opts = {}) {
-    void mode;
-    if (!profile.user) {
-        throw new ConnectionPoolError(`Datasource "${profile.name}" does not define SQL credentials. Configure a database username and password reference before executing SQL.`);
+function selectCredential(profile, _mode) {
+    const credential = profile.user;
+    if (!credential) {
+        throw new ConnectionPoolError(`Datasource "${profile.name}" has no active SQL credential session. Select a TaurusDB instance and open the returned local login URL, or call begin_sql_login.`);
     }
-    return profile.user;
+    return credential;
 }
 async function resolveCredentialValue(ref, secretResolver, context) {
     try {
@@ -65,7 +72,8 @@ export class ConnectionPoolManager {
         if (!profile) {
             throw new ConnectionPoolError(`Datasource profile not found: "${datasource}".`);
         }
-        const entry = await this.getOrCreatePool(profile, mode, opts);
+        const database = opts.database ?? profile.database;
+        const entry = await this.getOrCreatePool(profile, mode, database);
         let driverSession;
         try {
             driverSession = await entry.pool.acquire();
@@ -79,6 +87,7 @@ export class ConnectionPoolManager {
             entryKey: entry.key,
             driverSession,
             datasource,
+            database,
             mode,
         };
         this.activeSessions.set(sessionId, active);
@@ -86,6 +95,7 @@ export class ConnectionPoolManager {
         return {
             id: sessionId,
             datasource,
+            database,
             mode,
             async execute(sql, options) {
                 return active.driverSession.execute(sql, options);
@@ -151,13 +161,13 @@ export class ConnectionPoolManager {
             };
         }
     }
-    async getOrCreatePool(profile, mode, opts = {}) {
-        const key = poolKey(profile.name, mode);
+    async getOrCreatePool(profile, mode, database) {
+        const key = poolKey(profile.name, mode, database);
         const existing = this.pools.get(key);
         if (existing) {
             return existing instanceof Promise ? existing : existing;
         }
-        const pending = this.createPool(profile, mode, opts)
+        const pending = this.createPool(profile, mode, database)
             .then((entry) => {
             this.pools.set(key, entry);
             return entry;
@@ -169,7 +179,7 @@ export class ConnectionPoolManager {
         this.pools.set(key, pending);
         return pending;
     }
-    async createPool(profile, mode, opts = {}) {
+    async createPool(profile, mode, database) {
         const adapter = this.adapters[profile.engine];
         if (!adapter) {
             throw new ConnectionPoolError(`No driver adapter registered for engine "${profile.engine}".`);
@@ -177,9 +187,9 @@ export class ConnectionPoolManager {
         if (!profile.host) {
             throw new ConnectionPoolError(`Datasource "${profile.name}" does not define a host. Select a cloud instance or configure host in the datasource profile.`);
         }
-        const credential = selectCredential(profile, mode, opts);
+        const credential = selectCredential(profile, mode);
         const password = await resolveCredentialValue(credential.password, this.secretResolver, `${profile.name}.${mode}.password`);
-        const tls = await resolveTls(profile.tls, this.secretResolver);
+        const tls = await resolveTls(profile.tls, this.secretResolver, profile.host, this.config.security.requireTls);
         let pool;
         try {
             pool = await adapter.createPool({
@@ -188,7 +198,7 @@ export class ConnectionPoolManager {
                 engine: profile.engine,
                 host: profile.host,
                 port: profile.port,
-                database: profile.database,
+                database,
                 username: credential.username,
                 password,
                 poolSize: profile.poolSize,
@@ -199,8 +209,9 @@ export class ConnectionPoolManager {
             throw new ConnectionPoolError(`Failed to create ${mode === "ro" ? "readonly" : "mutation"} pool for datasource "${profile.name}".`, error);
         }
         return {
-            key: poolKey(profile.name, mode),
+            key: poolKey(profile.name, mode, database),
             datasource: profile.name,
+            database,
             mode,
             pool,
         };

package/dist/executor/sql-executor.d.ts

@@ -11,6 +11,9 @@ export type SqlExecutorOptions = {
     historyLimit?: number;
     queryTracker?: QueryTracker;
     resultRedactor?: ResultRedactor;
+    maxConcurrentQueries?: number;
+    maxQueuedQueries?: number;
+    queueTimeoutMs?: number;
 };
 export declare class SqlExecutorImpl implements SqlExecutor {
     private readonly connectionPool;

package/dist/executor/sql-executor.js

@@ -3,6 +3,22 @@ import { buildExplainRecommendations, normalizeExplainRows, summarizeExplainRows
 import { createQueryTracker, } from "./query-tracker.js";
 import { createResultRedactor, } from "../safety/redaction.js";
 import { asFiniteNumber, inferColumns, normalizeRows } from "./result-normalizer.js";
+import { QueryConcurrencyLimiter } from "./concurrency-limiter.js";
+import { buildServerBoundedReadonlySql } from "./bounded-sql.js";
+function isTimeoutError(error) {
+    return /timeout|timed out/i.test(error instanceof Error ? error.message : String(error));
+}
+async function cancelTimedOutSession(session, error) {
+    if (!isTimeoutError(error)) {
+        return;
+    }
+    try {
+        await session.cancel();
+    }
+    catch {
+        // Keep the original timeout error.
+    }
+}
 export class SqlExecutorImpl {
     connectionPool;
     now;
@@ -25,7 +41,9 @@ export class SqlExecutorImpl {
     async explain(sql, ctx) {
         const queryId = this.queryIdGenerator();
         const startedAt = this.now();
-        const session = await this.connectionPool.acquire(ctx.datasource, "ro");
+        const session = await this.connectionPool.acquire(ctx.datasource, "ro", {
+            database: ctx.database,
+        });
         const active = this.beginQuery(queryId, session, ctx, "ro", startedAt);
         try {
             const result = await session.execute(`EXPLAIN ${sql}`, {
@@ -45,6 +63,7 @@ export class SqlExecutorImpl {
             };
         }
         catch (error) {
+            await cancelTimedOutSession(session, error);
             const durationMs = this.now() - startedAt;
             this.completeQuery(active.queryId, active.cancelRequested ? "cancelled" : "failed", durationMs, error);
             throw error;
@@ -59,11 +78,16 @@ export class SqlExecutorImpl {
         const maxRows = opts.maxRows ?? ctx.limits.maxRows;
         const maxColumns = opts.maxColumns ?? ctx.limits.maxColumns;
         const maxFieldChars = opts.maxFieldChars ?? ctx.limits.maxFieldChars ?? 2048;
+        const maxResultBytes = opts.maxResultBytes ?? ctx.limits.maxResultBytes ?? 1048576;
+        const maxBlobBytes = opts.maxBlobBytes ?? ctx.limits.maxBlobBytes ?? 65536;
         const timeoutMs = opts.timeoutMs ?? ctx.limits.timeoutMs;
-        const session = await this.connectionPool.acquire(ctx.datasource, "ro");
+        const session = await this.connectionPool.acquire(ctx.datasource, "ro", {
+            database: ctx.database,
+        });
         const active = this.beginQuery(queryId, session, ctx, "ro", startedAt);
         try {
-            const result = await session.execute(sql, { timeoutMs });
+            const executionSql = buildServerBoundedReadonlySql(sql, maxRows);
+            const result = await session.execute(executionSql, { timeoutMs });
             const sourceRows = Array.isArray(result.rows) ? result.rows : [];
             const columns = inferColumns(result, sourceRows);
             const normalizedRows = normalizeRows(sourceRows, columns);
@@ -76,6 +100,9 @@ export class SqlExecutorImpl {
                 maxRows,
                 maxColumns,
                 maxFieldChars,
+                maxResultBytes,
+                maxBlobBytes,
+                maskAllColumns: opts.maskAllColumns,
                 sensitiveColumns: opts.sensitiveColumns,
                 sensitiveStrategy: opts.sensitiveStrategy,
             });
@@ -91,6 +118,8 @@ export class SqlExecutorImpl {
                 rowTruncated: redacted.rowTruncated,
                 columnTruncated: redacted.columnTruncated,
                 fieldTruncated: redacted.fieldTruncated,
+                byteTruncated: redacted.byteTruncated,
+                returnedBytes: redacted.returnedBytes,
                 redactedColumns: redacted.redactedColumns,
                 droppedColumns: redacted.droppedColumns,
                 truncatedColumns: redacted.truncatedColumns,
@@ -98,6 +127,7 @@ export class SqlExecutorImpl {
             };
         }
         catch (error) {
+            await cancelTimedOutSession(session, error);
             const durationMs = this.now() - startedAt;
             this.completeQuery(active.queryId, active.cancelRequested ? "cancelled" : "failed", durationMs, error);
             throw error;
@@ -114,7 +144,7 @@ export class SqlExecutorImpl {
         const startedAt = this.now();
         const timeoutMs = opts.timeoutMs ?? ctx.limits.timeoutMs;
         const session = await this.connectionPool.acquire(ctx.datasource, "rw", {
-            allowReadonlyFallbackForMutations: opts.allowReadonlyFallbackForMutations,
+            database: ctx.database,
         });
         const active = this.beginQuery(queryId, session, ctx, "rw", startedAt);
         try {
@@ -133,11 +163,16 @@ export class SqlExecutorImpl {
             };
         }
         catch (error) {
-            try {
-                await session.execute("ROLLBACK", { timeoutMs });
+            if (isTimeoutError(error)) {
+                await cancelTimedOutSession(session, error);
             }
-            catch {
-                // Ignore rollback failure and keep original error.
+            else {
+                try {
+                    await session.execute("ROLLBACK", { timeoutMs });
+                }
+                catch {
+                    // Ignore rollback failure and keep original error.
+                }
             }
             const durationMs = this.now() - startedAt;
             this.completeQuery(active.queryId, active.cancelRequested ? "cancelled" : "failed", durationMs, error);
@@ -245,5 +280,13 @@ export class SqlExecutorImpl {
     }
 }
 export function createSqlExecutor(options) {
-    return new SqlExecutorImpl(options);
+    const executor = new SqlExecutorImpl(options);
+    const limiter = new QueryConcurrencyLimiter(options.maxConcurrentQueries ?? 8, options.maxQueuedQueries ?? 32, options.queueTimeoutMs ?? 5000);
+    return {
+        explain: (sql, ctx) => limiter.run(() => executor.explain(sql, ctx)),
+        executeReadonly: (sql, ctx, opts) => limiter.run(() => executor.executeReadonly(sql, ctx, opts)),
+        executeMutation: (sql, ctx, opts) => limiter.run(() => executor.executeMutation(sql, ctx, opts)),
+        getQueryStatus: (queryId) => executor.getQueryStatus(queryId),
+        cancelQuery: (queryId) => executor.cancelQuery(queryId),
+    };
 }

package/dist/executor/types.d.ts

@@ -9,13 +9,15 @@ export interface ReadonlyOptions {
     maxRows?: number;
     maxColumns?: number;
     maxFieldChars?: number;
+    maxResultBytes?: number;
+    maxBlobBytes?: number;
+    maskAllColumns?: boolean;
     timeoutMs?: number;
     sensitiveColumns?: Iterable<string>;
     sensitiveStrategy?: SensitiveStrategy;
 }
 export interface MutationOptions {
     timeoutMs?: number;
-    allowReadonlyFallbackForMutations?: boolean;
 }
 export interface QueryResult {
     queryId: string;
@@ -27,6 +29,8 @@ export interface QueryResult {
     rowTruncated: boolean;
     columnTruncated: boolean;
     fieldTruncated: boolean;
+    byteTruncated: boolean;
+    returnedBytes: number;
     redactedColumns: string[];
     droppedColumns: string[];
     truncatedColumns: string[];

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { TaurusDBEngine } from "./engine.js";
 export type { EnhancedExplainResult, ConfirmationOutcome, DataSourceInfo, IssueConfirmationInput, TaurusDBEngineCreateOptions, TaurusDBEngineDeps, } from "./engine.js";
+export { createJsonlAuditWriter, JsonlAuditWriter, type AuditDecision, type AuditEvent, type AuditWriter, type JsonlAuditWriterOptions, } from "./audit/jsonl-writer.js";
 export { createConfigFromEnv, getConfig, redactConfigForLog, resetConfigForTests, } from "./config/index.js";
 export type { Config } from "./config/index.js";
 export { createSqlProfileLoader, RuntimeOverrideProfileLoader, } from "./auth/sql-profile-loader.js";
@@ -7,14 +8,18 @@ export type { DataSourceProfile, DatabaseEngine, ProfileLoader, RuntimeDataSourc
 export { DatasourceResolutionError } from "./context/datasource-resolver.js";
 export type { DatasourceResolveInput, DatasourceResolver, RuntimeLimits, SessionContext, } from "./context/session-context.js";
 export { ConnectionPoolError } from "./executor/connection-pool.js";
+export { QueryConcurrencyError } from "./executor/concurrency-limiter.js";
+export { buildServerBoundedReadonlySql } from "./executor/bounded-sql.js";
 export type { CancelResult, ExplainResult, MutationOptions, MutationResult, QueryResult, QueryStatus, ReadonlyOptions, SqlExecutor, } from "./executor/sql-executor.js";
 export { createCapabilityProbe } from "./capability/probe.js";
 export type { CapabilityProbe } from "./capability/probe.js";
 export { UnsupportedFeatureError } from "./capability/types.js";
 export type { CapabilitySnapshot, FeatureMatrix, FeatureStatus, KernelInfo, TaurusFeatureName, } from "./capability/types.js";
-export { createConfirmationStore, InMemoryConfirmationStore, } from "./safety/confirmation-store.js";
-export type { ConfirmationStore, ConfirmationToken, ConfirmationValidationResult, IssueInput, } from "./safety/confirmation-store.js";
+export { createConfirmationStore, InMemoryConfirmationStore, parseApprovalRequest, signApprovalRequest, } from "./safety/confirmation-store.js";
+export type { ConfirmationStore, ConfirmationRequest, ConfirmationValidationResult, IssueInput, } from "./safety/confirmation-store.js";
 export { createGuardrail } from "./safety/guardrail.js";
+export { createSqlParser } from "./safety/parser/index.js";
+export type { SqlAst, StatementType as ParsedStatementType } from "./safety/parser/index.js";
 export type { Guardrail, GuardrailDecision, GuardrailRuntimeLimits, InspectInput, } from "./safety/guardrail.js";
 export type { ExplainRiskSummary, RiskLevel, ValidationResult } from "./safety/sql-validator.js";
 export { SchemaIntrospectionError } from "./schema/introspector.js";
@@ -41,6 +46,6 @@ export type { RecycleBinListResult, RecycleBinRestoreResult, RestoreRecycleBinTa
 export { createPlaceholderDiagnosticResult } from "./diagnostics/types.js";
 export { buildResolveSlowSqlInput, createSlowSqlSource, TaurusApiSlowSqlSource, } from "./diagnostics/slow-sql-source.js";
 export { CesMetricsSource, createMetricsSource, } from "./diagnostics/metrics-source.js";
-export type { DbHotspotItem, DbHotspotResult, DiagnosticBaseInput, DiagnosticConfidence, DiagnosticEvidenceItem, DiagnosticEvidenceLevel, DiagnosticNextToolInput, DiagnoseDbHotspotInput, DiagnoseServiceLatencyInput, FindTopSlowSqlInput, FindTopSlowSqlResult, DiagnosticResult, DiagnosticRootCauseCandidate, DiagnosticSeverity, DiagnosticStatus, ServiceLatencyCandidate, ServiceLatencyResult, ServiceLatencySuspectedCategory, DiagnosticSuspiciousEntities, DiagnosticToolName, DiagnosisWindow, DiagnoseConnectionSpikeInput, DiagnoseLockContentionInput, DiagnoseSlowQueryInput, DiagnoseStoragePressureInput, PlaceholderDiagnosticOptions, TopSlowSqlItem, } from "./diagnostics/types.js";
+export type { DbHotspotItem, DbHotspotResult, DiagnosticBaseInput, DiagnosticConfidence, DiagnosticEvidenceItem, DiagnosticEvidenceLevel, DiagnosticNextToolInput, DiagnoseDbHotspotInput, DiagnoseServiceLatencyInput, FindTopSlowSqlInput, FindTopSlowSqlResult, DiagnosticResult, DiagnosticRootCauseCandidate, DiagnosticSeverity, DiagnosticStatus, ServiceLatencyCandidate, ServiceLatencyResult, ServiceLatencySuspectedCategory, DiagnosticSuspiciousEntities, DiagnosticToolName, DiagnosisWindow, DiagnoseConnectionSpikeInput, DiagnoseLockContentionInput, DiagnoseReplicationLagInput, DiagnoseSlowQueryInput, DiagnoseStoragePressureInput, PlaceholderDiagnosticOptions, TopSlowSqlItem, } from "./diagnostics/types.js";
 export type { ExternalSlowSqlSample, ResolveSlowSqlInput, SlowSqlSource, } from "./diagnostics/slow-sql-source.js";
 export type { MetricAlias, MetricPoint, MetricSummary, MetricsSource, QueryMetricsInput, } from "./diagnostics/metrics-source.js";

package/dist/index.js

@@ -1,12 +1,16 @@
 export { TaurusDBEngine } from "./engine.js";
+export { createJsonlAuditWriter, JsonlAuditWriter, } from "./audit/jsonl-writer.js";
 export { createConfigFromEnv, getConfig, redactConfigForLog, resetConfigForTests, } from "./config/index.js";
 export { createSqlProfileLoader, RuntimeOverrideProfileLoader, } from "./auth/sql-profile-loader.js";
 export { DatasourceResolutionError } from "./context/datasource-resolver.js";
 export { ConnectionPoolError } from "./executor/connection-pool.js";
+export { QueryConcurrencyError } from "./executor/concurrency-limiter.js";
+export { buildServerBoundedReadonlySql } from "./executor/bounded-sql.js";
 export { createCapabilityProbe } from "./capability/probe.js";
 export { UnsupportedFeatureError } from "./capability/types.js";
-export { createConfirmationStore, InMemoryConfirmationStore, } from "./safety/confirmation-store.js";
+export { createConfirmationStore, InMemoryConfirmationStore, parseApprovalRequest, signApprovalRequest, } from "./safety/confirmation-store.js";
 export { createGuardrail } from "./safety/guardrail.js";
+export { createSqlParser } from "./safety/parser/index.js";
 export { SchemaIntrospectionError } from "./schema/introspector.js";
 export { ErrorCode, formatBlocked, formatConfirmationRequired, formatError, formatSuccess, } from "./utils/formatter.js";
 export { normalizeSql, sqlHash } from "./utils/hash.js";

package/dist/safety/confirmation-store.d.ts

@@ -1,5 +1,20 @@
 import type { SessionContext } from "../context/session-context.js";
 import type { RiskLevel, ValidationResult } from "./sql-validator.js";
+export type ApprovalRequestPayload = {
+    version: 1;
+    requestId: string;
+    sqlHash: string;
+    datasource: string;
+    database?: string;
+    host?: string;
+    port?: number;
+    projectId?: string;
+    instanceId?: string;
+    nodeId?: string;
+    riskLevel: RiskLevel;
+    issuedAt: number;
+    expiresAt: number;
+};
 export type IssueInput = {
     sqlHash: string;
     normalizedSql: string;
@@ -7,38 +22,46 @@ export type IssueInput = {
     riskLevel: RiskLevel;
     ttlSeconds?: number;
 };
-export type ConfirmationToken = {
-    token: string;
+export type ConfirmationRequest = {
+    request: string;
+    requestId: string;
     issuedAt: number;
     expiresAt: number;
 };
 export type ConfirmationValidationResult = ValidationResult & {
     valid: boolean;
+    actor?: string;
     reason?: string;
 };
 export interface ConfirmationStore {
-    issue(input: IssueInput): Promise<ConfirmationToken>;
+    issue(input: IssueInput): Promise<ConfirmationRequest>;
     validate(token: string, currentSql: string, ctx: SessionContext): Promise<ConfirmationValidationResult>;
-    revoke(token: string): Promise<void>;
+    revoke(requestId: string): Promise<void>;
 }
 export type ConfirmationStoreOptions = {
+    approvalSecret?: string | Buffer;
     ttlSeconds?: number;
     cleanupIntervalMs?: number;
+    maxEntries?: number;
     now?: () => number;
     randomBytesFn?: (size: number) => Buffer;
 };
+export declare function parseApprovalRequest(request: string): ApprovalRequestPayload;
+export declare function signApprovalRequest(request: string, actor: string, secret: string | Buffer): string;
 export declare class InMemoryConfirmationStore implements ConfirmationStore {
     private readonly entries;
     private readonly now;
     private readonly ttlSeconds;
+    private readonly maxEntries;
     private readonly randomBytesFn;
+    private readonly approvalSecret?;
     private cleanupTimer?;
     constructor(options?: ConfirmationStoreOptions);
-    issue(input: IssueInput): Promise<ConfirmationToken>;
+    issue(input: IssueInput): Promise<ConfirmationRequest>;
     validate(token: string, currentSql: string, ctx: SessionContext): Promise<ConfirmationValidationResult>;
-    revoke(token: string): Promise<void>;
+    revoke(requestId: string): Promise<void>;
     stop(): void;
     cleanupExpired(now?: number): void;
-    private generateUniqueToken;
+    private generateUniqueRequestId;
 }
 export declare function createConfirmationStore(options?: ConfirmationStoreOptions): ConfirmationStore;