norn-cli 2.2.2 → 2.4.0

package/out/sqlBuiltInAdapters.js

@@ -0,0 +1,604 @@
+"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.getBuiltInSqlAdapters = getBuiltInSqlAdapters;
+exports.getBuiltInSqlAdapter = getBuiltInSqlAdapter;
+exports.isBuiltInSqlAdapter = isBuiltInSqlAdapter;
+exports.getBuiltInSqlAdapterIds = getBuiltInSqlAdapterIds;
+exports.runBuiltInSqlAdapter = runBuiltInSqlAdapter;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const pg_1 = require("pg");
+const mssql = __importStar(require("mssql"));
+const BUILT_IN_SQL_ADAPTERS = [
+    {
+        id: 'postgres',
+        label: 'PostgreSQL',
+        description: 'Built-in PostgreSQL adapter using a connection string.',
+        connectionSetupSummary: 'connectionString',
+        optionalConnectionKeys: []
+    },
+    {
+        id: 'sqlserver',
+        label: 'SQL Server',
+        description: 'Built-in SQL Server adapter using a connection string.',
+        connectionSetupSummary: 'connectionString',
+        optionalConnectionKeys: []
+    },
+    {
+        id: 'sqlserver-windows',
+        label: 'SQL Server (Integrated Auth)',
+        description: 'Built-in SQL Server adapter using PowerShell and Microsoft.Data.SqlClient for Windows/Trusted authentication.',
+        connectionSetupSummary: 'connectionString',
+        optionalConnectionKeys: []
+    }
+];
+const BUILT_IN_SQL_ADAPTER_MAP = new Map(BUILT_IN_SQL_ADAPTERS.map(adapter => [adapter.id.toLowerCase(), adapter]));
+const NAMED_PARAMETER_REGEX = /(?<!:):([A-Za-z_][A-Za-z0-9_]*)\b/g;
+function fail(message) {
+    throw new Error(message);
+}
+function getConnectionValue(values, ...keys) {
+    for (const key of keys) {
+        const value = values[key];
+        if (value !== undefined && value !== null && `${value}`.trim() !== '') {
+            return value;
+        }
+    }
+    return undefined;
+}
+function getConnectionString(values) {
+    return getConnectionValue(values, 'connectionString');
+}
+function usesWindowsIntegratedSqlServerAuth(connectionString) {
+    return /(?:^|;)\s*Integrated\s+Security\s*=\s*(?:true|yes|sspi)\s*(?:;|$)/i.test(connectionString)
+        || /(?:^|;)\s*Trusted_Connection\s*=\s*(?:true|yes|sspi)\s*(?:;|$)/i.test(connectionString);
+}
+function buildMissingConnectionError(adapterLabel, profile) {
+    return `Missing required ${adapterLabel} connection string. Expected 'connectionString ${profile} = ...' in .nornenv.`;
+}
+function getBundledSqlClientDirectory() {
+    return path.resolve(__dirname, '..', 'vendor', 'microsoft.data.sqlclient', 'windows-netfx');
+}
+function ensureBundledSqlClientDirectory() {
+    const sqlClientDir = getBundledSqlClientDirectory();
+    const mainAssemblyPath = path.join(sqlClientDir, 'Microsoft.Data.SqlClient.dll');
+    if (!fs.existsSync(mainAssemblyPath)) {
+        fail(`Missing bundled Microsoft.Data.SqlClient runtime at '${mainAssemblyPath}'.`);
+    }
+    return sqlClientDir;
+}
+let pwshAvailable = null;
+function isPwshAvailable() {
+    if (pwshAvailable !== null) {
+        return pwshAvailable;
+    }
+    try {
+        const result = (0, child_process_1.spawnSync)('pwsh', ['--version'], {
+            timeout: 5000,
+            stdio: 'pipe',
+        });
+        pwshAvailable = result.status === 0;
+    }
+    catch (error) {
+        pwshAvailable = false;
+    }
+    return pwshAvailable;
+}
+function getPowerShellCommand() {
+    return isPwshAvailable() ? 'pwsh' : 'powershell';
+}
+function getIntegratedPowerShellCommand() {
+    if (process.platform === 'win32') {
+        return 'powershell';
+    }
+    return getPowerShellCommand();
+}
+function encodePowerShellCommand(script) {
+    return Buffer.from(script, 'utf16le').toString('base64');
+}
+async function runSqlServerIntegratedViaPowerShell(request) {
+    if (process.platform !== 'win32') {
+        fail('Built-in adapter sqlserver-windows is supported on Windows only.');
+    }
+    const sqlClientDir = ensureBundledSqlClientDirectory();
+    const script = `
+$ErrorActionPreference = 'Stop'
+[Console]::InputEncoding = [System.Text.Encoding]::UTF8
+[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
+
+$raw = [Console]::In.ReadToEnd()
+if ([string]::IsNullOrWhiteSpace($raw)) {
+    throw 'Missing SQL adapter payload.'
+}
+
+$payload = $raw | ConvertFrom-Json
+$connectionString = [string]$payload.connection.values.connectionString
+if ([string]::IsNullOrWhiteSpace($connectionString)) {
+    throw 'Missing SQL Server Integrated Auth connection string.'
+}
+
+$sqlClientDir = [string]$env:NORN_SQLCLIENT_DIR
+if ([string]::IsNullOrWhiteSpace($sqlClientDir) -or -not (Test-Path $sqlClientDir)) {
+    throw 'Missing bundled Microsoft.Data.SqlClient runtime files.'
+}
+
+$env:PATH = "$sqlClientDir;$env:PATH"
+
+$resolveHandler = [System.ResolveEventHandler]{
+    param($sender, $eventArgs)
+
+    $assemblyName = ([System.Reflection.AssemblyName]$eventArgs.Name).Name + '.dll'
+    $candidate = Join-Path $env:NORN_SQLCLIENT_DIR $assemblyName
+    if (Test-Path $candidate) {
+        return [System.Reflection.Assembly]::LoadFrom($candidate)
+    }
+
+    return $null
+}
+
+[System.AppDomain]::CurrentDomain.add_AssemblyResolve($resolveHandler)
+[void][System.Reflection.Assembly]::LoadFrom((Join-Path $sqlClientDir 'Microsoft.Data.SqlClient.dll'))
+
+$sqlText = [string]$payload.operation.sql
+$mode = [string]$payload.mode
+$paramsObject = $payload.params
+$connectionStringHasUserId = $connectionString -match '(?i)(?:^|;)\s*(?:User ID|UID)\s*='
+$connectionStringHasPassword = $connectionString -match '(?i)(?:^|;)\s*(?:Password|PWD)\s*='
+
+$connection = $null
+$connectionBuilder = $null
+try {
+    $connectionBuilder = New-Object Microsoft.Data.SqlClient.SqlConnectionStringBuilder $connectionString
+    $connection = New-Object Microsoft.Data.SqlClient.SqlConnection $connectionString
+    $command = $connection.CreateCommand()
+    $command.CommandText = $sqlText
+
+    if ($null -ne $paramsObject) {
+        foreach ($property in $paramsObject.PSObject.Properties) {
+            $value = $property.Value
+            if ($null -eq $value) {
+                $value = [DBNull]::Value
+            } elseif ($value -is [datetime]) {
+                $value = $value.ToUniversalTime()
+            } elseif ($value -is [System.Collections.IEnumerable] -and -not ($value -is [string]) -and -not ($value -is [byte[]])) {
+                $value = ($value | ConvertTo-Json -Depth 100 -Compress)
+            } elseif ($value -is [pscustomobject]) {
+                $value = ($value | ConvertTo-Json -Depth 100 -Compress)
+            }
+            [void]$command.Parameters.AddWithValue("@$($property.Name)", $value)
+        }
+    }
+
+    $connection.Open()
+
+    if ($mode -eq 'query') {
+        $reader = $command.ExecuteReader()
+        $rows = @()
+
+        try {
+            while ($reader.Read()) {
+                $row = [ordered]@{}
+                for ($i = 0; $i -lt $reader.FieldCount; $i++) {
+                    $value = $reader.GetValue($i)
+                    if ($value -is [DBNull]) {
+                        $value = $null
+                    } elseif ($value -is [datetime]) {
+                        $value = $value.ToString('o')
+                    } elseif ($value -is [byte[]]) {
+                        $value = [Convert]::ToBase64String($value)
+                    }
+                    $row[$reader.GetName($i)] = $value
+                }
+                $rows += [pscustomobject]$row
+            }
+        } finally {
+            $reader.Close()
+        }
+
+        $response = [pscustomobject]@{
+            success = $true
+            result = [pscustomobject]@{
+                kind = 'rows'
+                rowCount = @($rows).Count
+                rows = @($rows)
+            }
+        }
+    } else {
+        $affectedRows = $command.ExecuteNonQuery()
+        if ($affectedRows -lt 0) {
+            $affectedRows = 0
+        }
+        $response = [pscustomobject]@{
+            success = $true
+            result = [pscustomobject]@{
+                kind = 'exec'
+                affectedRows = $affectedRows
+            }
+        }
+    }
+
+    $response | ConvertTo-Json -Depth 100 -Compress
+}
+catch {
+    $details = New-Object System.Collections.Generic.List[string]
+    if ($_.Exception -and $_.Exception.GetType()) {
+        $details.Add("type: $($_.Exception.GetType().FullName)")
+    }
+    if ($_.InvocationInfo -and $_.InvocationInfo.ScriptLineNumber) {
+        $details.Add("line: $($_.InvocationInfo.ScriptLineNumber)")
+    }
+    if ($_.FullyQualifiedErrorId) {
+        $details.Add("id: $($_.FullyQualifiedErrorId)")
+    }
+
+    try {
+        $details.Add("adapter: sqlserver-windows")
+        $details.Add("powershell: $($PSVersionTable.PSVersion)")
+        $details.Add("sqlClientVersion: $(([Microsoft.Data.SqlClient.SqlConnection]).Assembly.GetName().Version)")
+        $details.Add("windowsIdentity: $([System.Security.Principal.WindowsIdentity]::GetCurrent().Name)")
+    } catch {
+    }
+
+    if ($null -ne $connectionBuilder) {
+        if (-not [string]::IsNullOrWhiteSpace([string]$connectionBuilder.DataSource)) {
+            $details.Add("dataSource: $($connectionBuilder.DataSource)")
+        }
+        if (-not [string]::IsNullOrWhiteSpace([string]$connectionBuilder.InitialCatalog)) {
+            $details.Add("database: $($connectionBuilder.InitialCatalog)")
+        }
+        $details.Add("integratedSecurity: $($connectionBuilder.IntegratedSecurity)")
+        $details.Add("encrypt: $($connectionBuilder.Encrypt)")
+        $details.Add("trustServerCertificate: $($connectionBuilder.TrustServerCertificate)")
+        $details.Add("applicationIntent: $($connectionBuilder.ApplicationIntent)")
+        $details.Add("multiSubnetFailover: $($connectionBuilder.MultiSubnetFailover)")
+
+        try {
+            $hostNameInCertificate = [string]$connectionBuilder['HostNameInCertificate']
+            if (-not [string]::IsNullOrWhiteSpace($hostNameInCertificate)) {
+                $details.Add("hostNameInCertificate: $hostNameInCertificate")
+            }
+        } catch {
+        }
+    }
+
+    $details.Add("userIdPresent: $connectionStringHasUserId")
+    $details.Add("passwordPresent: $connectionStringHasPassword")
+
+    $sqlException = $null
+    if ($_.Exception -is [Microsoft.Data.SqlClient.SqlException]) {
+        $sqlException = [Microsoft.Data.SqlClient.SqlException]$_.Exception
+    } elseif ($_.Exception -and $_.Exception.InnerException -is [Microsoft.Data.SqlClient.SqlException]) {
+        $sqlException = [Microsoft.Data.SqlClient.SqlException]$_.Exception.InnerException
+    }
+
+    if ($null -ne $sqlException) {
+        $details.Add("sqlNumber: $($sqlException.Number)")
+        $details.Add("sqlState: $($sqlException.State)")
+        $details.Add("sqlClass: $($sqlException.Class)")
+        if (-not [string]::IsNullOrWhiteSpace([string]$sqlException.Server)) {
+            $details.Add("sqlServer: $($sqlException.Server)")
+        }
+        if (-not [string]::IsNullOrWhiteSpace([string]$sqlException.Procedure)) {
+            $details.Add("sqlProcedure: $($sqlException.Procedure)")
+        }
+        if ($sqlException.LineNumber -gt 0) {
+            $details.Add("sqlLineNumber: $($sqlException.LineNumber)")
+        }
+        if ($sqlException.ClientConnectionId -ne [guid]::Empty) {
+            $details.Add("clientConnectionId: $($sqlException.ClientConnectionId)")
+        }
+        if ($sqlException.Errors -and $sqlException.Errors.Count -gt 0) {
+            $messages = @()
+            foreach ($sqlError in $sqlException.Errors) {
+                if ($sqlError -and -not [string]::IsNullOrWhiteSpace([string]$sqlError.Message)) {
+                    $messages += [string]$sqlError.Message
+                }
+            }
+            if ($messages.Count -gt 0) {
+                $details.Add("sqlErrors: $($messages -join ' | ')")
+            }
+        }
+    }
+
+    if ($_.Exception -and $_.Exception.InnerException) {
+        $details.Add("innerType: $($_.Exception.InnerException.GetType().FullName)")
+        if (-not [string]::IsNullOrWhiteSpace([string]$_.Exception.InnerException.Message)) {
+            $details.Add("innerMessage: $($_.Exception.InnerException.Message)")
+        }
+    }
+
+    [Console]::Error.WriteLine("$($_.Exception.Message)")
+    foreach ($detail in $details) {
+        [Console]::Error.WriteLine("  $detail")
+    }
+    exit 1
+}
+finally {
+    if ($null -ne $resolveHandler) {
+        [System.AppDomain]::CurrentDomain.remove_AssemblyResolve($resolveHandler)
+    }
+    if ($null -ne $connection) {
+        $connection.Dispose()
+    }
+}
+`.trim();
+    const payload = JSON.stringify(request);
+    const command = getIntegratedPowerShellCommand();
+    const commandArgs = ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-OutputFormat', 'Text', '-EncodedCommand', encodePowerShellCommand(script)];
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(command, commandArgs, {
+            cwd: request.context?.workingDir || process.cwd(),
+            shell: false,
+            env: {
+                ...process.env,
+                NORN_SQLCLIENT_DIR: sqlClientDir,
+            }
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+        child.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        child.on('error', (error) => {
+            reject(new Error(`Failed to start PowerShell for SQL Server Integrated Auth: ${error.message}`));
+        });
+        child.on('close', (code) => {
+            if (code !== 0) {
+                reject(new Error((stderr || stdout || `PowerShell exited with code ${code}`).trim()));
+                return;
+            }
+            try {
+                const parsed = JSON.parse(stdout.trim());
+                resolve(parsed);
+            }
+            catch (error) {
+                reject(new Error(`Invalid PowerShell SQL adapter response: ${error instanceof Error ? error.message : String(error)}`));
+            }
+        });
+        child.stdin.write(payload);
+        child.stdin.end();
+    });
+}
+function shouldPassThroughError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return /^(Missing required|Missing SQL parameter|Invalid )/.test(error.message);
+}
+function formatBuiltInDriverError(adapterLabel, error) {
+    if (shouldPassThroughError(error)) {
+        return error;
+    }
+    const candidate = error;
+    const baseMessage = error instanceof Error
+        ? error.message
+        : typeof error === 'string'
+            ? error
+            : 'Unknown database error';
+    const details = [];
+    const append = (label, value) => {
+        if (value === undefined || value === null || `${value}`.trim() === '') {
+            return;
+        }
+        details.push(`${label}: ${value}`);
+    };
+    append('code', candidate?.code);
+    append('number', candidate?.number);
+    append('state', candidate?.state);
+    append('severity', candidate?.severity ?? candidate?.class);
+    append('detail', candidate?.detail);
+    append('hint', candidate?.hint);
+    append('schema', candidate?.schema);
+    append('table', candidate?.table);
+    append('column', candidate?.column);
+    append('constraint', candidate?.constraint);
+    append('routine', candidate?.routine);
+    append('line', candidate?.lineNumber);
+    append('procedure', candidate?.procName);
+    append('server', candidate?.serverName);
+    const precedingErrors = Array.isArray(candidate?.precedingErrors)
+        ? (candidate?.precedingErrors)
+            .map(item => item?.message)
+            .filter((message) => message !== undefined && message !== null && `${message}`.trim() !== '')
+        : [];
+    if (precedingErrors.length > 0) {
+        details.push(`precedingErrors: ${precedingErrors.join(' | ')}`);
+    }
+    const suffix = details.length > 0 ? ` (${details.join(', ')})` : '';
+    return new Error(`${adapterLabel} driver error: ${baseMessage}${suffix}`);
+}
+function compilePostgresSql(sql, params) {
+    const values = [];
+    const positions = new Map();
+    const text = sql.replace(NAMED_PARAMETER_REGEX, (_match, paramName) => {
+        if (!Object.prototype.hasOwnProperty.call(params, paramName)) {
+            fail(`Missing SQL parameter '${paramName}'`);
+        }
+        if (!positions.has(paramName)) {
+            positions.set(paramName, values.length + 1);
+            values.push(params[paramName]);
+        }
+        return `$${positions.get(paramName)}`;
+    });
+    return { text, values };
+}
+function compileSqlServerSql(sql, params) {
+    const names = [];
+    const seen = new Set();
+    const text = sql.replace(NAMED_PARAMETER_REGEX, (_match, paramName) => {
+        if (!Object.prototype.hasOwnProperty.call(params, paramName)) {
+            fail(`Missing SQL parameter '${paramName}'`);
+        }
+        if (!seen.has(paramName)) {
+            seen.add(paramName);
+            names.push(paramName);
+        }
+        return `@${paramName}`;
+    });
+    return { text, names };
+}
+async function runBuiltInPostgresAdapter(request) {
+    const values = request.connection.values;
+    const connectionString = getConnectionString(values);
+    if (!connectionString) {
+        fail(buildMissingConnectionError('Postgres', request.connection.profile));
+    }
+    const client = new pg_1.Client(connectionString);
+    try {
+        await client.connect();
+        const compiled = compilePostgresSql(request.operation.sql, request.params || {});
+        const result = await client.query(compiled.text, compiled.values);
+        if (request.mode === 'query') {
+            return {
+                success: true,
+                result: {
+                    kind: 'rows',
+                    rowCount: result.rowCount ?? result.rows.length,
+                    rows: result.rows
+                }
+            };
+        }
+        return {
+            success: true,
+            result: {
+                kind: 'exec',
+                affectedRows: result.rowCount ?? 0
+            }
+        };
+    }
+    catch (error) {
+        throw formatBuiltInDriverError('Postgres', error);
+    }
+    finally {
+        await client.end().catch(() => undefined);
+    }
+}
+async function runBuiltInSqlServerAdapter(request) {
+    const values = request.connection.values;
+    const connectionString = getConnectionString(values);
+    if (!connectionString) {
+        fail(buildMissingConnectionError('SQL Server', request.connection.profile));
+    }
+    if (usesWindowsIntegratedSqlServerAuth(connectionString)) {
+        fail("This SQL Server connection string uses Windows/Integrated authentication. Use adapter 'sqlserver-windows' in norn.config.json sql.connections.");
+    }
+    const pool = new mssql.ConnectionPool(connectionString);
+    try {
+        await pool.connect();
+        const compiled = compileSqlServerSql(request.operation.sql, request.params || {});
+        const sqlRequest = pool.request();
+        for (const name of compiled.names) {
+            sqlRequest.input(name, request.params[name]);
+        }
+        const result = await sqlRequest.query(compiled.text);
+        if (request.mode === 'query') {
+            const rows = result.recordset ?? [];
+            return {
+                success: true,
+                result: {
+                    kind: 'rows',
+                    rowCount: rows.length,
+                    rows
+                }
+            };
+        }
+        const affectedRows = (result.rowsAffected || []).reduce((sum, count) => sum + count, 0);
+        return {
+            success: true,
+            result: {
+                kind: 'exec',
+                affectedRows
+            }
+        };
+    }
+    catch (error) {
+        throw formatBuiltInDriverError('SQL Server', error);
+    }
+    finally {
+        await pool.close().catch(() => undefined);
+    }
+}
+async function runBuiltInSqlServerIntegratedAdapter(request) {
+    const values = request.connection.values;
+    const connectionString = getConnectionString(values);
+    if (!connectionString) {
+        fail(buildMissingConnectionError('SQL Server (Windows)', request.connection.profile));
+    }
+    const compiled = compileSqlServerSql(request.operation.sql, request.params || {});
+    const compiledRequest = {
+        ...request,
+        operation: {
+            ...request.operation,
+            sql: compiled.text
+        },
+        params: Object.fromEntries(compiled.names.map(name => [name, request.params?.[name] ?? null]))
+    };
+    try {
+        return await runSqlServerIntegratedViaPowerShell(compiledRequest);
+    }
+    catch (error) {
+        throw formatBuiltInDriverError('SQL Server (Windows)', error);
+    }
+}
+function getBuiltInSqlAdapters() {
+    return [...BUILT_IN_SQL_ADAPTERS];
+}
+function getBuiltInSqlAdapter(adapterId) {
+    return BUILT_IN_SQL_ADAPTER_MAP.get(adapterId.toLowerCase());
+}
+function isBuiltInSqlAdapter(adapterId) {
+    return BUILT_IN_SQL_ADAPTER_MAP.has(adapterId.toLowerCase());
+}
+function getBuiltInSqlAdapterIds() {
+    return BUILT_IN_SQL_ADAPTERS.map(adapter => adapter.id);
+}
+async function runBuiltInSqlAdapter(adapterId, request) {
+    switch (adapterId.toLowerCase()) {
+        case 'postgres':
+            return runBuiltInPostgresAdapter(request);
+        case 'sqlserver':
+            return runBuiltInSqlServerAdapter(request);
+        case 'sqlserver-windows':
+            return runBuiltInSqlServerIntegratedAdapter(request);
+        default:
+            fail(`Built-in SQL adapter '${adapterId}' is not supported`);
+    }
+}
+//# sourceMappingURL=sqlBuiltInAdapters.js.map