infrawise 0.5.0 → 0.6.0

package/README.md

@@ -1,11 +1,9 @@
 # Infrawise
 
-<table><tr>
-<td><a href="https://www.npmjs.com/package/infrawise"><img src="https://img.shields.io/npm/v/infrawise" alt="npm version"></a></td>
-<td><a href="https://github.com/Sidd27/infrawise/actions/workflows/npm-publish.yml"><img src="https://github.com/Sidd27/infrawise/actions/workflows/npm-publish.yml/badge.svg" alt="Publish to npm"></a></td>
-<td><a href="https://github.com/Sidd27/infrawise/actions/workflows/ci.yml"><img src="https://github.com/Sidd27/infrawise/actions/workflows/ci.yml/badge.svg" alt="CI"></a></td>
-<td><a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT"></a></td>
-</tr></table>
+[![npm version](https://img.shields.io/npm/v/infrawise)](https://www.npmjs.com/package/infrawise)
+[![Publish to npm](https://github.com/Sidd27/infrawise/actions/workflows/npm-publish.yml/badge.svg)](https://github.com/Sidd27/infrawise/actions/workflows/npm-publish.yml)
+[![CI](https://github.com/Sidd27/infrawise/actions/workflows/ci.yml/badge.svg)](https://github.com/Sidd27/infrawise/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 
 **Understand your infrastructure, not just your code.**
 
@@ -483,18 +481,14 @@ export class MyAnalyzer implements Analyzer {
 
 ### Releasing
 
-The git tag is the source of truth. The version in root `package.json` and the tag must always match.
-
 ```bash
 pnpm release patch    # 0.1.2 → 0.1.3  (bug fixes)
 pnpm release minor    # 0.1.2 → 0.2.0  (new features, backwards compatible)
 pnpm release major    # 0.1.2 → 1.0.0  (breaking changes)
 pnpm release 1.5.0    # explicit version
-
-git push origin main v1.2.3
 ```
 
-`pnpm release` bumps the version, tags, and creates a draft GitHub release with notes generated from commit messages. Push the tag, then publish the draft on GitHub to trigger npm publish.
+Bumps `package.json`, commits, tags, pushes, and creates a draft GitHub release with notes from commit messages. Then publish the draft on GitHub to trigger npm publish.
 
 ### PR checklist
 

package/dist/adapters/aws.js

@@ -1,32 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractSQSMetadata = extractSQSMetadata;
-exports.validateSQSAccess = validateSQSAccess;
-exports.extractSNSMetadata = extractSNSMetadata;
-exports.validateSNSAccess = validateSNSAccess;
-exports.extractSSMMetadata = extractSSMMetadata;
-exports.validateSSMAccess = validateSSMAccess;
-exports.extractSecretsMetadata = extractSecretsMetadata;
-exports.validateSecretsAccess = validateSecretsAccess;
-exports.extractLambdaMetadata = extractLambdaMetadata;
-exports.validateLambdaAccess = validateLambdaAccess;
-exports.extractRDSMetadata = extractRDSMetadata;
-exports.validateRDSAccess = validateRDSAccess;
-const client_sqs_1 = require("@aws-sdk/client-sqs");
-const client_sns_1 = require("@aws-sdk/client-sns");
-const client_ssm_1 = require("@aws-sdk/client-ssm");
-const client_secrets_manager_1 = require("@aws-sdk/client-secrets-manager");
-const client_lambda_1 = require("@aws-sdk/client-lambda");
-const client_rds_1 = require("@aws-sdk/client-rds");
-const credential_providers_1 = require("@aws-sdk/credential-providers");
-const core_1 = require("../core");
+import { SQSClient, ListQueuesCommand, GetQueueAttributesCommand, } from '@aws-sdk/client-sqs';
+import { SNSClient, ListTopicsCommand, GetTopicAttributesCommand, ListSubscriptionsByTopicCommand, } from '@aws-sdk/client-sns';
+import { SSMClient, DescribeParametersCommand, } from '@aws-sdk/client-ssm';
+import { SecretsManagerClient, ListSecretsCommand, } from '@aws-sdk/client-secrets-manager';
+import { LambdaClient, ListFunctionsCommand, } from '@aws-sdk/client-lambda';
+import { RDSClient, DescribeDBInstancesCommand, } from '@aws-sdk/client-rds';
+import { fromIni } from '@aws-sdk/credential-providers';
+import { logger } from '../core/index.js';
 function clientConfig(cfg) {
     const region = cfg.region ?? 'us-east-1';
     const base = { region };
     if (cfg.endpoint)
         base.endpoint = cfg.endpoint;
     if (cfg.profile)
-        base.credentials = (0, credential_providers_1.fromIni)({ profile: cfg.profile });
+        base.credentials = fromIni({ profile: cfg.profile });
     else if (cfg.endpoint)
         base.credentials = {
             accessKeyId: process.env.AWS_ACCESS_KEY_ID ?? 'test',
@@ -35,20 +21,20 @@ function clientConfig(cfg) {
     return base;
 }
 // ─── SQS ─────────────────────────────────────────────────────────────────────
-async function extractSQSMetadata(cfg = {}) {
-    const client = new client_sqs_1.SQSClient(clientConfig(cfg));
+export async function extractSQSMetadata(cfg = {}) {
+    const client = new SQSClient(clientConfig(cfg));
     const queues = [];
     try {
         let nextToken;
         const queueUrls = [];
         do {
-            const res = await client.send(new client_sqs_1.ListQueuesCommand({ NextToken: nextToken, MaxResults: 1000 }));
+            const res = await client.send(new ListQueuesCommand({ NextToken: nextToken, MaxResults: 1000 }));
             queueUrls.push(...(res.QueueUrls ?? []));
             nextToken = res.NextToken;
         } while (nextToken);
         for (const url of queueUrls) {
             try {
-                const attrs = await client.send(new client_sqs_1.GetQueueAttributesCommand({
+                const attrs = await client.send(new GetQueueAttributesCommand({
                     QueueUrl: url,
                     AttributeNames: [
                         'QueueArn', 'VisibilityTimeout', 'MessageRetentionPeriod',
@@ -79,35 +65,35 @@ async function extractSQSMetadata(cfg = {}) {
                 });
             }
             catch (err) {
-                core_1.logger.warn(`SQS attrs failed for ${url}: ${err instanceof Error ? err.message : String(err)}`);
+                logger.warn(`SQS attrs failed for ${url}: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
     }
     catch (err) {
-        core_1.logger.warn(`SQS list failed: ${err instanceof Error ? err.message : String(err)}`);
+        logger.warn(`SQS list failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     return queues;
 }
-async function validateSQSAccess(cfg = {}) {
-    await new client_sqs_1.SQSClient(clientConfig(cfg)).send(new client_sqs_1.ListQueuesCommand({ MaxResults: 1 }));
+export async function validateSQSAccess(cfg = {}) {
+    await new SQSClient(clientConfig(cfg)).send(new ListQueuesCommand({ MaxResults: 1 }));
 }
 // ─── SNS ─────────────────────────────────────────────────────────────────────
-async function extractSNSMetadata(cfg = {}) {
-    const client = new client_sns_1.SNSClient(clientConfig(cfg));
+export async function extractSNSMetadata(cfg = {}) {
+    const client = new SNSClient(clientConfig(cfg));
     const topics = [];
     try {
         let nextToken;
         const topicArns = [];
         do {
-            const res = await client.send(new client_sns_1.ListTopicsCommand({ NextToken: nextToken }));
+            const res = await client.send(new ListTopicsCommand({ NextToken: nextToken }));
             topicArns.push(...(res.Topics ?? []).map((t) => t.TopicArn ?? '').filter(Boolean));
             nextToken = res.NextToken;
         } while (nextToken);
         for (const arn of topicArns) {
             try {
                 const [attrsRes, subsRes] = await Promise.all([
-                    client.send(new client_sns_1.GetTopicAttributesCommand({ TopicArn: arn })),
-                    client.send(new client_sns_1.ListSubscriptionsByTopicCommand({ TopicArn: arn })),
+                    client.send(new GetTopicAttributesCommand({ TopicArn: arn })),
+                    client.send(new ListSubscriptionsByTopicCommand({ TopicArn: arn })),
                 ]);
                 const attrs = attrsRes.Attributes ?? {};
                 const subs = subsRes.Subscriptions ?? [];
@@ -120,26 +106,26 @@ async function extractSNSMetadata(cfg = {}) {
                 });
             }
             catch (err) {
-                core_1.logger.warn(`SNS attrs failed for ${arn}: ${err instanceof Error ? err.message : String(err)}`);
+                logger.warn(`SNS attrs failed for ${arn}: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
     }
     catch (err) {
-        core_1.logger.warn(`SNS list failed: ${err instanceof Error ? err.message : String(err)}`);
+        logger.warn(`SNS list failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     return topics;
 }
-async function validateSNSAccess(cfg = {}) {
-    await new client_sns_1.SNSClient(clientConfig(cfg)).send(new client_sns_1.ListTopicsCommand({}));
+export async function validateSNSAccess(cfg = {}) {
+    await new SNSClient(clientConfig(cfg)).send(new ListTopicsCommand({}));
 }
 // ─── SSM Parameter Store ──────────────────────────────────────────────────────
-async function extractSSMMetadata(cfg = {}) {
-    const client = new client_ssm_1.SSMClient(clientConfig(cfg));
+export async function extractSSMMetadata(cfg = {}) {
+    const client = new SSMClient(clientConfig(cfg));
     const parameters = [];
     try {
         let nextToken;
         do {
-            const res = await client.send(new client_ssm_1.DescribeParametersCommand({
+            const res = await client.send(new DescribeParametersCommand({
                 NextToken: nextToken,
                 MaxResults: 50,
                 // Only metadata — GetParameter/GetParameters would return values
@@ -158,22 +144,22 @@ async function extractSSMMetadata(cfg = {}) {
         } while (nextToken && parameters.length < 500);
     }
     catch (err) {
-        core_1.logger.warn(`SSM list failed: ${err instanceof Error ? err.message : String(err)}`);
+        logger.warn(`SSM list failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     return parameters;
 }
-async function validateSSMAccess(cfg = {}) {
-    await new client_ssm_1.SSMClient(clientConfig(cfg)).send(new client_ssm_1.DescribeParametersCommand({ MaxResults: 1 }));
+export async function validateSSMAccess(cfg = {}) {
+    await new SSMClient(clientConfig(cfg)).send(new DescribeParametersCommand({ MaxResults: 1 }));
 }
 // ─── Secrets Manager ──────────────────────────────────────────────────────────
-async function extractSecretsMetadata(cfg = {}) {
-    const client = new client_secrets_manager_1.SecretsManagerClient(clientConfig(cfg));
+export async function extractSecretsMetadata(cfg = {}) {
+    const client = new SecretsManagerClient(clientConfig(cfg));
     const secrets = [];
     try {
         let nextToken;
         do {
             // ListSecrets never returns secret values
-            const res = await client.send(new client_secrets_manager_1.ListSecretsCommand({ NextToken: nextToken, MaxResults: 100 }));
+            const res = await client.send(new ListSecretsCommand({ NextToken: nextToken, MaxResults: 100 }));
             for (const s of res.SecretList ?? []) {
                 secrets.push({
                     name: s.Name ?? '',
@@ -189,21 +175,21 @@ async function extractSecretsMetadata(cfg = {}) {
         } while (nextToken && secrets.length < 200);
     }
     catch (err) {
-        core_1.logger.warn(`Secrets Manager list failed: ${err instanceof Error ? err.message : String(err)}`);
+        logger.warn(`Secrets Manager list failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     return secrets;
 }
-async function validateSecretsAccess(cfg = {}) {
-    await new client_secrets_manager_1.SecretsManagerClient(clientConfig(cfg)).send(new client_secrets_manager_1.ListSecretsCommand({ MaxResults: 1 }));
+export async function validateSecretsAccess(cfg = {}) {
+    await new SecretsManagerClient(clientConfig(cfg)).send(new ListSecretsCommand({ MaxResults: 1 }));
 }
 // ─── Lambda ───────────────────────────────────────────────────────────────────
-async function extractLambdaMetadata(cfg = {}) {
-    const client = new client_lambda_1.LambdaClient(clientConfig(cfg));
+export async function extractLambdaMetadata(cfg = {}) {
+    const client = new LambdaClient(clientConfig(cfg));
     const functions = [];
     try {
         let marker;
         do {
-            const res = await client.send(new client_lambda_1.ListFunctionsCommand({ Marker: marker, MaxItems: 50 }));
+            const res = await client.send(new ListFunctionsCommand({ Marker: marker, MaxItems: 50 }));
             for (const fn of res.Functions ?? []) {
                 functions.push({
                     name: fn.FunctionName ?? '',
@@ -221,21 +207,21 @@ async function extractLambdaMetadata(cfg = {}) {
         } while (marker && functions.length < 200);
     }
     catch (err) {
-        core_1.logger.warn(`Lambda list failed: ${err instanceof Error ? err.message : String(err)}`);
+        logger.warn(`Lambda list failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     return functions;
 }
-async function validateLambdaAccess(cfg = {}) {
-    await new client_lambda_1.LambdaClient(clientConfig(cfg)).send(new client_lambda_1.ListFunctionsCommand({ MaxItems: 1 }));
+export async function validateLambdaAccess(cfg = {}) {
+    await new LambdaClient(clientConfig(cfg)).send(new ListFunctionsCommand({ MaxItems: 1 }));
 }
 // ─── RDS ─────────────────────────────────────────────────────────────────────
-async function extractRDSMetadata(cfg = {}) {
-    const client = new client_rds_1.RDSClient(clientConfig(cfg));
+export async function extractRDSMetadata(cfg = {}) {
+    const client = new RDSClient(clientConfig(cfg));
     const instances = [];
     try {
         let marker;
         do {
-            const res = await client.send(new client_rds_1.DescribeDBInstancesCommand({ Marker: marker, MaxRecords: 100 }));
+            const res = await client.send(new DescribeDBInstancesCommand({ Marker: marker, MaxRecords: 100 }));
             for (const db of res.DBInstances ?? []) {
                 instances.push({
                     dbInstanceIdentifier: db.DBInstanceIdentifier ?? '',
@@ -254,10 +240,10 @@ async function extractRDSMetadata(cfg = {}) {
         } while (marker && instances.length < 200);
     }
     catch (err) {
-        core_1.logger.warn(`RDS list failed: ${err instanceof Error ? err.message : String(err)}`);
+        logger.warn(`RDS list failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     return instances;
 }
-async function validateRDSAccess(cfg = {}) {
-    await new client_rds_1.RDSClient(clientConfig(cfg)).send(new client_rds_1.DescribeDBInstancesCommand({ MaxRecords: 20 }));
+export async function validateRDSAccess(cfg = {}) {
+    await new RDSClient(clientConfig(cfg)).send(new DescribeDBInstancesCommand({ MaxRecords: 20 }));
 }

package/dist/adapters/dynamodb.js

@@ -1,11 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractDynamoMetadata = extractDynamoMetadata;
-exports.validateDynamoAccess = validateDynamoAccess;
-exports.probeDynamoAccess = probeDynamoAccess;
-const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
-const credential_providers_1 = require("@aws-sdk/credential-providers");
-const core_1 = require("../core");
+import { DynamoDBClient, ListTablesCommand, DescribeTableCommand, } from '@aws-sdk/client-dynamodb';
+import { fromIni } from '@aws-sdk/credential-providers';
+import { DynamoDBError, logger } from '../core/index.js';
 function createDynamoClient(config) {
     const region = config.aws?.region ?? 'us-east-1';
     const profile = config.aws?.profile;
@@ -14,13 +9,13 @@ function createDynamoClient(config) {
     if (endpoint)
         clientConfig.endpoint = endpoint;
     if (profile)
-        clientConfig.credentials = (0, credential_providers_1.fromIni)({ profile });
+        clientConfig.credentials = fromIni({ profile });
     else if (endpoint)
         clientConfig.credentials = {
             accessKeyId: process.env.AWS_ACCESS_KEY_ID ?? 'test',
             secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY ?? 'test',
         };
-    return new client_dynamodb_1.DynamoDBClient(clientConfig);
+    return new DynamoDBClient(clientConfig);
 }
 function parseTableDescription(desc) {
     const tableName = desc.TableName ?? 'unknown';
@@ -47,7 +42,7 @@ async function listAllTables(client) {
     const tableNames = [];
     let lastEvaluatedTableName;
     do {
-        const command = new client_dynamodb_1.ListTablesCommand({
+        const command = new ListTablesCommand({
             ExclusiveStartTableName: lastEvaluatedTableName,
             Limit: 100,
         });
@@ -59,7 +54,7 @@ async function listAllTables(client) {
     } while (lastEvaluatedTableName);
     return tableNames;
 }
-async function extractDynamoMetadata(config) {
+export async function extractDynamoMetadata(config) {
     const client = createDynamoClient(config);
     const includeTables = config.dynamodb?.includeTables;
     let tableNames;
@@ -67,43 +62,43 @@ async function extractDynamoMetadata(config) {
         const allTables = await listAllTables(client);
         if (includeTables && includeTables.length > 0) {
             tableNames = allTables.filter((name) => includeTables.includes(name));
-            core_1.logger.debug(`Filtered to ${tableNames.length} tables from config`);
+            logger.debug(`Filtered to ${tableNames.length} tables from config`);
         }
         else {
             tableNames = allTables;
         }
-        core_1.logger.debug(`Found ${tableNames.length} DynamoDB table(s)`);
+        logger.debug(`Found ${tableNames.length} DynamoDB table(s)`);
     }
     catch (err) {
-        throw new core_1.DynamoDBError(err instanceof Error ? err.message : 'Failed to list DynamoDB tables');
+        throw new DynamoDBError(err instanceof Error ? err.message : 'Failed to list DynamoDB tables');
     }
     const results = [];
     for (const tableName of tableNames) {
         try {
-            const command = new client_dynamodb_1.DescribeTableCommand({ TableName: tableName });
+            const command = new DescribeTableCommand({ TableName: tableName });
             const response = await client.send(command);
             if (response.Table) {
                 results.push(parseTableDescription(response.Table));
-                core_1.logger.debug(`Described table: ${tableName}`);
+                logger.debug(`Described table: ${tableName}`);
             }
         }
         catch (err) {
-            core_1.logger.warn(`Failed to describe table ${tableName}: ${err instanceof Error ? err.message : String(err)}`);
+            logger.warn(`Failed to describe table ${tableName}: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
     return results;
 }
-async function validateDynamoAccess(config) {
+export async function validateDynamoAccess(config) {
     const client = createDynamoClient(config);
     try {
-        await client.send(new client_dynamodb_1.ListTablesCommand({ Limit: 1 }));
+        await client.send(new ListTablesCommand({ Limit: 1 }));
         return true;
     }
     catch {
         return false;
     }
 }
-async function probeDynamoAccess(config) {
+export async function probeDynamoAccess(config) {
     const client = createDynamoClient(config);
-    await client.send(new client_dynamodb_1.ListTablesCommand({ Limit: 1 }));
+    await client.send(new ListTablesCommand({ Limit: 1 }));
 }

package/dist/adapters/logs.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractLogsMetadata = extractLogsMetadata;
-exports.validateLogsAccess = validateLogsAccess;
-const client_cloudwatch_logs_1 = require("@aws-sdk/client-cloudwatch-logs");
-const credential_providers_1 = require("@aws-sdk/credential-providers");
-const core_1 = require("../core");
+import { CloudWatchLogsClient, DescribeLogGroupsCommand, FilterLogEventsCommand, } from '@aws-sdk/client-cloudwatch-logs';
+import { fromIni } from '@aws-sdk/credential-providers';
+import { logger } from '../core/index.js';
 // Hard caps to prevent context bloat
 const MAX_LOG_GROUPS = 50;
 const MAX_EVENTS_PER_GROUP = 50;
@@ -14,7 +10,7 @@ function clientConfig(cfg) {
     if (cfg.endpoint)
         base.endpoint = cfg.endpoint;
     if (cfg.profile)
-        base.credentials = (0, credential_providers_1.fromIni)({ profile: cfg.profile });
+        base.credentials = fromIni({ profile: cfg.profile });
     else if (cfg.endpoint)
         base.credentials = {
             accessKeyId: process.env.AWS_ACCESS_KEY_ID ?? 'test',
@@ -44,8 +40,8 @@ function topPatterns(messages, limit = 5) {
         .slice(0, limit)
         .map(([pattern, count]) => ({ pattern, count }));
 }
-async function extractLogsMetadata(cfg = {}) {
-    const client = new client_cloudwatch_logs_1.CloudWatchLogsClient(clientConfig(cfg));
+export async function extractLogsMetadata(cfg = {}) {
+    const client = new CloudWatchLogsClient(clientConfig(cfg));
     const windowMs = (cfg.windowHours ?? 24) * 60 * 60 * 1000;
     const startTime = Date.now() - windowMs;
     const summaries = [];
@@ -56,7 +52,7 @@ async function extractLogsMetadata(cfg = {}) {
         for (const prefix of prefixes) {
             let nextToken;
             do {
-                const res = await client.send(new client_cloudwatch_logs_1.DescribeLogGroupsCommand({
+                const res = await client.send(new DescribeLogGroupsCommand({
                     nextToken,
                     limit: Math.min(50, MAX_LOG_GROUPS - logGroups.length),
                     ...(prefix ? { logGroupNamePrefix: prefix } : {}),
@@ -73,7 +69,7 @@ async function extractLogsMetadata(cfg = {}) {
         }
     }
     catch (err) {
-        core_1.logger.warn(`CloudWatch Logs discovery failed: ${err instanceof Error ? err.message : String(err)}`);
+        logger.warn(`CloudWatch Logs discovery failed: ${err instanceof Error ? err.message : String(err)}`);
         return summaries;
     }
     // Sample errors from each group — patterns only, never raw messages for unrelated groups
@@ -85,7 +81,7 @@ async function extractLogsMetadata(cfg = {}) {
             if (errorMessages.length + warnMessages.length >= MAX_EVENTS_PER_GROUP)
                 break;
             try {
-                const res = await client.send(new client_cloudwatch_logs_1.FilterLogEventsCommand({
+                const res = await client.send(new FilterLogEventsCommand({
                     logGroupName: lg.name,
                     filterPattern,
                     startTime,
@@ -119,9 +115,9 @@ async function extractLogsMetadata(cfg = {}) {
             lastErrorTime,
         });
     }
-    core_1.logger.debug(`CloudWatch Logs: sampled ${summaries.length} log group(s)`);
+    logger.debug(`CloudWatch Logs: sampled ${summaries.length} log group(s)`);
     return summaries;
 }
-async function validateLogsAccess(cfg = {}) {
-    await new client_cloudwatch_logs_1.CloudWatchLogsClient(clientConfig(cfg)).send(new client_cloudwatch_logs_1.DescribeLogGroupsCommand({ limit: 1 }));
+export async function validateLogsAccess(cfg = {}) {
+    await new CloudWatchLogsClient(clientConfig(cfg)).send(new DescribeLogGroupsCommand({ limit: 1 }));
 }

package/dist/adapters/mongodb.js

@@ -1,12 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoConnectionError = void 0;
-exports.extractMongoMetadata = extractMongoMetadata;
-exports.validateMongoAccess = validateMongoAccess;
-const mongodb_1 = require("mongodb");
-const core_1 = require("../core");
+import { MongoClient } from 'mongodb';
+import { InfrawiseError, logger } from '../core/index.js';
 const SYSTEM_DATABASES = new Set(['admin', 'local', 'config']);
-class MongoConnectionError extends core_1.InfrawiseError {
+export class MongoConnectionError extends InfrawiseError {
     constructor(details) {
         super('Unable to connect to MongoDB.\n\nPossible reasons:\n- invalid connection string\n- port 27017 not accessible\n- wrong credentials\n\nRun: infrawise doctor', undefined, undefined);
         this.name = 'MongoConnectionError';
@@ -15,9 +10,8 @@ class MongoConnectionError extends core_1.InfrawiseError {
         }
     }
 }
-exports.MongoConnectionError = MongoConnectionError;
-async function extractMongoMetadata(connectionString, databases) {
-    const client = new mongodb_1.MongoClient(connectionString, {
+export async function extractMongoMetadata(connectionString, databases) {
+    const client = new MongoClient(connectionString, {
         serverSelectionTimeoutMS: 5000,
         connectTimeoutMS: 5000,
     });
@@ -35,7 +29,7 @@ async function extractMongoMetadata(connectionString, databases) {
                 .map((d) => d.name)
                 .filter((name) => !SYSTEM_DATABASES.has(name));
         }
-        core_1.logger.debug(`Introspecting ${dbNames.length} MongoDB database(s)`);
+        logger.debug(`Introspecting ${dbNames.length} MongoDB database(s)`);
         const results = [];
         for (const dbName of dbNames) {
             const db = client.db(dbName);
@@ -45,7 +39,7 @@ async function extractMongoMetadata(connectionString, databases) {
                 collectionNames = collections.map((c) => c.name);
             }
             catch (err) {
-                core_1.logger.warn(`Skipping database "${dbName}": ${err instanceof Error ? err.message : String(err)}`);
+                logger.warn(`Skipping database "${dbName}": ${err instanceof Error ? err.message : String(err)}`);
                 continue;
             }
             for (const collName of collectionNames) {
@@ -78,7 +72,7 @@ async function extractMongoMetadata(connectionString, databases) {
                 });
             }
         }
-        core_1.logger.debug(`Found ${results.length} MongoDB collection(s)`);
+        logger.debug(`Found ${results.length} MongoDB collection(s)`);
         return results;
     }
     catch (err) {
@@ -90,8 +84,8 @@ async function extractMongoMetadata(connectionString, databases) {
         await client.close().catch(() => undefined);
     }
 }
-async function validateMongoAccess(connectionString) {
-    const client = new mongodb_1.MongoClient(connectionString, {
+export async function validateMongoAccess(connectionString) {
+    const client = new MongoClient(connectionString, {
         serverSelectionTimeoutMS: 5000,
         connectTimeoutMS: 5000,
     });

package/dist/adapters/mysql.js

@@ -1,15 +1,7 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MySQLConnectionError = void 0;
-exports.extractMySQLMetadata = extractMySQLMetadata;
-exports.validateMySQLAccess = validateMySQLAccess;
-const promise_1 = __importDefault(require("mysql2/promise"));
-const core_1 = require("../core");
+import mysql from 'mysql2/promise';
+import { InfrawiseError, logger } from '../core/index.js';
 const SYSTEM_SCHEMAS = new Set(['information_schema', 'performance_schema', 'mysql', 'sys']);
-class MySQLConnectionError extends core_1.InfrawiseError {
+export class MySQLConnectionError extends InfrawiseError {
     constructor(details) {
         super('Unable to connect to MySQL.\n\nPossible reasons:\n- invalid connection string\n- port 3306 not accessible\n- wrong credentials\n\nRun: infrawise doctor', undefined, undefined);
         this.name = 'MySQLConnectionError';
@@ -18,11 +10,10 @@ class MySQLConnectionError extends core_1.InfrawiseError {
         }
     }
 }
-exports.MySQLConnectionError = MySQLConnectionError;
-async function extractMySQLMetadata(connectionString) {
+export async function extractMySQLMetadata(connectionString) {
     let connection;
     try {
-        connection = await promise_1.default.createConnection(connectionString);
+        connection = await mysql.createConnection(connectionString);
         // Get all user tables
         const [tableRows] = await connection.execute(`
       SELECT TABLE_SCHEMA, TABLE_NAME, ENGINE
@@ -31,7 +22,7 @@ async function extractMySQLMetadata(connectionString) {
         AND TABLE_SCHEMA NOT IN (${[...SYSTEM_SCHEMAS].map(() => '?').join(', ')})
       ORDER BY TABLE_SCHEMA, TABLE_NAME
     `, [...SYSTEM_SCHEMAS]);
-        core_1.logger.debug(`Found ${tableRows.length} MySQL table(s)`);
+        logger.debug(`Found ${tableRows.length} MySQL table(s)`);
         // Get all columns
         const [columnRows] = await connection.execute(`
       SELECT TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME
@@ -117,10 +108,10 @@ async function extractMySQLMetadata(connectionString) {
         }
     }
 }
-async function validateMySQLAccess(connectionString) {
+export async function validateMySQLAccess(connectionString) {
     let connection;
     try {
-        connection = await promise_1.default.createConnection(connectionString);
+        connection = await mysql.createConnection(connectionString);
         await connection.execute('SELECT 1');
         return true;
     }

package/dist/adapters/postgres.js

@@ -1,11 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractPostgresMetadata = extractPostgresMetadata;
-exports.validatePostgresAccess = validatePostgresAccess;
-const pg_1 = require("pg");
-const core_1 = require("../core");
-async function extractPostgresMetadata(connectionString) {
-    const pool = new pg_1.Pool({
+import { Pool } from 'pg';
+import { PostgresConnectionError, logger } from '../core/index.js';
+export async function extractPostgresMetadata(connectionString) {
+    const pool = new Pool({
         connectionString,
         max: 1,
         idleTimeoutMillis: 10000,
@@ -23,7 +19,7 @@ async function extractPostgresMetadata(connectionString) {
           AND table_schema NOT IN ('pg_catalog', 'information_schema')
         ORDER BY table_schema, table_name
       `);
-            core_1.logger.debug(`Found ${tablesResult.rows.length} PostgreSQL table(s)`);
+            logger.debug(`Found ${tablesResult.rows.length} PostgreSQL table(s)`);
             // Get all columns
             const columnsResult = await client.query(`
         SELECT table_schema, table_name, column_name
@@ -102,16 +98,16 @@ async function extractPostgresMetadata(connectionString) {
         }
     }
     catch (err) {
-        if (err instanceof core_1.PostgresConnectionError)
+        if (err instanceof PostgresConnectionError)
             throw err;
-        throw new core_1.PostgresConnectionError(err instanceof Error ? err.message : 'Unknown error connecting to PostgreSQL');
+        throw new PostgresConnectionError(err instanceof Error ? err.message : 'Unknown error connecting to PostgreSQL');
     }
     finally {
         await pool.end();
     }
 }
-async function validatePostgresAccess(connectionString) {
-    const pool = new pg_1.Pool({
+export async function validatePostgresAccess(connectionString) {
+    const pool = new Pool({
         connectionString,
         max: 1,
         connectionTimeoutMillis: 5000,