@matimo/postgres 0.1.0-alpha.7.1 → 0.1.0-alpha.8

package/README.md

@@ -144,41 +144,50 @@ The tool automatically detects destructive operations:
 For interactive terminal environments:
 
 ```typescript
-import { getSQLApprovalManager } from '@matimo/core';
+import { MatimoInstance, getGlobalApprovalHandler } from '@matimo/core';
 import * as readline from 'readline';
 
-const manager = getSQLApprovalManager();
+const matimo = await MatimoInstance.init({ autoDiscover: true });
+const handler = getGlobalApprovalHandler();
 
 // Set interactive callback
-manager.setApprovalCallback(async (sql: string, mode: string) => {
+handler.setApprovalCallback(async (request) => {
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout
   });
   
   return new Promise(resolve => {
-    rl.question(`Approve ${mode} operation: ${sql}? (yes/no): `, answer => {
-      rl.close();
-      resolve(answer.toLowerCase() === 'yes');
-    });
+    rl.question(
+      `\nApprove ${request.toolName}?\nSQL: ${request.params.sql}\n(yes/no): `,
+      answer => {
+        rl.close();
+        resolve(answer.toLowerCase() === 'yes');
+      }
+    );
   });
 });
+
+// Approve write operations
+await matimo.execute('postgres-execute-sql', {
+  sql: 'UPDATE users SET active = true'
+});
 ```
 
 #### 2. **Automatic Approval (CI/CD)**
 For automated environments:
 
 ```bash
-# Enable auto-approval for all destructive operations
-export MATIMO_SQL_AUTO_APPROVE=true
+# Enable auto-approval for all operations requiring approval
+export MATIMO_AUTO_APPROVE=true
 ```
 
 #### 3. **Pattern-Based Approval**
 Pre-approve specific patterns:
 
 ```bash
-# Approve all DELETE queries and UPDATE queries on users table
-export MATIMO_SQL_APPROVED_PATTERNS="DELETE.*,UPDATE users.*"
+# Approve only postgres-execute-sql tool
+export MATIMO_APPROVED_PATTERNS="postgres-*"
 ```
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matimo/postgres",
-  "version": "0.1.0-alpha.7.1",
+  "version": "0.1.0-alpha.8",
   "description": "Postgres tools for Matimo",
   "type": "module",
   "files": [
@@ -10,7 +10,7 @@
   ],
   "dependencies": {
     "pg": "^8.18.0",
-    "@matimo/core": "0.1.0-alpha.7.1"
+    "@matimo/core": "0.1.0-alpha.8"
   },
   "devDependencies": {
     "@types/pg": "^8.6.6"

package/tools/execute-sql/execute-sql.ts

@@ -1,5 +1,5 @@
 import { Client } from 'pg';
-import { MatimoError, ErrorCode, getSQLApprovalManager } from '@matimo/core';
+import { MatimoError, ErrorCode } from '@matimo/core';
 
 export default async function (input: Record<string, unknown>) {
   const sql = (input.sql as string) || '';
@@ -15,31 +15,6 @@ export default async function (input: Record<string, unknown>) {
   const envUrl = process.env.MATIMO_POSTGRES_URL;
   let connectionString: string | undefined = envUrl;
 
-  // Detect destructive SQL and require approval
-  const destructiveRegex = /^\s*(CREATE|DROP|ALTER|TRUNCATE|DELETE|UPDATE)\b/i;
-  const isDestructive = destructiveRegex.test(sql);
-  if (isDestructive) {
-    const manager = getSQLApprovalManager();
-    try {
-      const ok = await manager.isApproved(sql, 'write');
-      if (!ok) {
-        throw new MatimoError('Destructive SQL not approved', ErrorCode.EXECUTION_FAILED, {
-          toolName: 'postgres-execute-sql',
-          hint:
-            'Destructive SQL requires approval. Use getSQLApprovalManager().setApprovalCallback() or set MATIMO_SQL_APPROVED_PATTERNS / MATIMO_SQL_AUTO_APPROVE=true',
-        });
-      }
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    } catch (e: any) {
-      // Re-throw MatimoError or wrap
-      if (e instanceof MatimoError) throw e;
-      throw new MatimoError('SQL approval check failed', ErrorCode.EXECUTION_FAILED, {
-        toolName: 'postgres-execute-sql',
-        details: { message: e?.message || String(e) },
-      });
-    }
-  }
-
   if (!connectionString) {
     const host = process.env.MATIMO_POSTGRES_HOST;
     const port = process.env.MATIMO_POSTGRES_PORT || '5432';
@@ -66,13 +41,11 @@ export default async function (input: Record<string, unknown>) {
   const client = new Client({ connectionString });
   try {
     await client.connect();
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const result = await client.query(sql, (params ?? []) as any);
+    const result = await client.query(sql, (params ?? []) as unknown[]);
     return { rows: result.rows, rowCount: result.rowCount };
   } catch (err) {
     // Extract meaningful error message
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const originalError = (err as any)?.message || String(err);
+    const originalError = String((err as Record<string, unknown>).message || err);
     const details: Record<string, unknown> = {
       originalMessage: originalError,
     };
@@ -90,11 +63,8 @@ export default async function (input: Record<string, unknown>) {
       details,
     });
   } finally {
-    try {
-      await client.end();
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    } catch (_e) {
-      // ignore
-    }
+    await client.end().catch(() => {
+      // Ignore connection close errors
+    });
   }
 }