@neverinfamous/postgres-mcp 1.0.1

package/dist/adapters/postgresql/prompts/partman.js

@@ -0,0 +1,211 @@
+/**
+ * pg_partman Setup Prompt
+ *
+ * Complete guide for setting up automated partition management with pg_partman.
+ */
+export function createSetupPartmanPrompt() {
+    return {
+        name: "pg_setup_partman",
+        description: "Complete guide for setting up automated partition lifecycle management with pg_partman including time-based and serial partitioning.",
+        arguments: [
+            {
+                name: "partitionType",
+                description: "Partition type: time, serial, id",
+                required: false,
+            },
+            {
+                name: "interval",
+                description: "Partition interval: daily, weekly, monthly, yearly",
+                required: false,
+            },
+        ],
+        // eslint-disable-next-line @typescript-eslint/require-await
+        handler: async (args, _context) => {
+            const partitionType = args["partitionType"] ?? "time";
+            const interval = args["interval"] ?? "daily";
+            let content = `# pg_partman Setup Guide - ${partitionType.charAt(0).toUpperCase() + partitionType.slice(1)} Partitioning
+
+## pg_partman Overview
+
+pg_partman automates partition lifecycle management:
+- Automatic child partition creation
+- Retention policy enforcement
+- Background maintenance
+- Native partitioning support (PostgreSQL 10+)
+
+## Setup Steps
+
+### 1. Install pg_partman
+
+\`\`\`sql
+CREATE EXTENSION IF NOT EXISTS pg_partman;
+SELECT * FROM pg_extension WHERE extname = 'pg_partman';
+\`\`\`
+
+### 2. Create Parent Table
+
+**Important:** Create the parent as a native partitioned table first.
+
+`;
+            if (partitionType === "time") {
+                content += `\`\`\`sql
+-- Time-based partitioning (${interval})
+CREATE TABLE events (
+    id BIGSERIAL,
+    event_time TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    event_type VARCHAR(50),
+    payload JSONB,
+    PRIMARY KEY (id, event_time)
+) PARTITION BY RANGE (event_time);
+
+-- Create default partition for safety
+CREATE TABLE events_default PARTITION OF events DEFAULT;
+\`\`\`
+
+### 3. Configure pg_partman
+
+\`\`\`sql
+SELECT partman.create_parent(
+    p_parent_table => 'public.events',
+    p_control => 'event_time',
+    p_type => 'native',
+    p_interval => '${interval === "daily" ? "1 day" : interval === "weekly" ? "1 week" : interval === "monthly" ? "1 month" : "1 year"}',
+    p_premake => 4,  -- Create 4 future partitions
+    p_start_partition => (NOW() - INTERVAL '1 month')::text
+);
+\`\`\`
+`;
+            }
+            else if (partitionType === "serial" || partitionType === "id") {
+                content += `\`\`\`sql
+-- ID/Serial-based partitioning
+CREATE TABLE orders (
+    id BIGSERIAL,
+    order_date TIMESTAMPTZ DEFAULT NOW(),
+    customer_id INTEGER,
+    total DECIMAL(10,2),
+    PRIMARY KEY (id)
+) PARTITION BY RANGE (id);
+
+-- Create default partition
+CREATE TABLE orders_default PARTITION OF orders DEFAULT;
+\`\`\`
+
+### 3. Configure pg_partman
+
+\`\`\`sql
+SELECT partman.create_parent(
+    p_parent_table => 'public.orders',
+    p_control => 'id',
+    p_type => 'native',
+    p_interval => '1000000',  -- 1 million rows per partition
+    p_premake => 4
+);
+\`\`\`
+`;
+            }
+            content += `
+### 4. Set Retention Policy
+
+\`\`\`sql
+UPDATE partman.part_config
+SET retention = '${interval === "daily" ? "90 days" : interval === "weekly" ? "52 weeks" : interval === "monthly" ? "24 months" : "5 years"}',
+    retention_keep_table = false,  -- Drop old partitions
+    retention_keep_index = false
+WHERE parent_table = 'public.events';
+\`\`\`
+
+Or use the tool: \`pg_partman_set_retention\`
+
+### 5. Schedule Maintenance
+
+**Option A: Using pg_cron (recommended)**
+\`\`\`sql
+-- Run maintenance every hour
+SELECT cron.schedule('partman-maintenance', '0 * * * *',
+    $$CALL partman.run_maintenance_proc()$$);
+\`\`\`
+
+**Option B: External scheduler**
+\`\`\`bash
+# Add to crontab
+0 * * * * psql -d mydb -c "CALL partman.run_maintenance_proc()"
+\`\`\`
+
+### 6. View Configuration
+
+Use \`pg_partman_show_config\` or:
+\`\`\`sql
+SELECT * FROM partman.part_config
+WHERE parent_table = 'public.events';
+\`\`\`
+
+### 7. Monitor Partitions
+
+Use \`pg_partman_show_partitions\` or:
+\`\`\`sql
+SELECT * FROM partman.show_partitions('public.events');
+\`\`\`
+
+### 8. Check for Data in Default Partition
+
+Use \`pg_partman_check_default\` — data in default means partitions need adjustment.
+
+## Available Tools
+
+| Tool | Purpose |
+|------|---------|
+| \`pg_partman_create_parent\` | Create managed partition set |
+| \`pg_partman_run_maintenance\` | Execute maintenance |
+| \`pg_partman_show_partitions\` | List partitions |
+| \`pg_partman_show_config\` | View configuration |
+| \`pg_partman_check_default\` | Check default partition |
+| \`pg_partman_partition_data\` | Move data to partitions |
+| \`pg_partman_set_retention\` | Configure retention |
+| \`pg_partman_undo_partition\` | Convert back to regular table |
+| \`pg_partman_analyze_partition_health\` | Health check |
+
+## Best Practices
+
+1. **Always create a default partition** — Catches data that doesn't match ranges
+2. **Pre-create future partitions** — Avoid write failures
+3. **Schedule regular maintenance** — At least hourly for active tables
+4. **Monitor default partition** — Data there indicates problems
+5. **Use appropriate retention** — Balance storage vs query history needs
+6. **Add indexes to parent** — They propagate to children
+
+## Common Pitfalls
+
+- ❌ Forgetting to schedule maintenance
+- ❌ Not creating default partition
+- ❌ Ignoring data in default partition
+- ❌ Retention too aggressive (losing needed data)
+- ❌ Not considering query patterns when choosing partition key
+
+## Migration: Converting Existing Table
+
+\`\`\`sql
+-- 1. Rename existing table
+ALTER TABLE events RENAME TO events_old;
+
+-- 2. Create new partitioned table
+CREATE TABLE events (...) PARTITION BY RANGE (event_time);
+
+-- 3. Configure pg_partman
+SELECT partman.create_parent(...);
+
+-- 4. Migrate data in batches
+INSERT INTO events SELECT * FROM events_old
+WHERE event_time >= '2024-01-01' AND event_time < '2024-02-01';
+-- Repeat for each period
+
+-- 5. Drop old table when complete
+DROP TABLE events_old;
+\`\`\`
+
+**Pro Tip:** pg_partman + pg_cron = fully automated partition lifecycle!`;
+            return content;
+        },
+    };
+}
+//# sourceMappingURL=partman.js.map

package/dist/adapters/postgresql/prompts/partman.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"partman.js","sourceRoot":"","sources":["../../../../src/adapters/postgresql/prompts/partman.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,MAAM,UAAU,wBAAwB;IACtC,OAAO;QACL,IAAI,EAAE,kBAAkB;QACxB,WAAW,EACT,sIAAsI;QACxI,SAAS,EAAE;YACT;gBACE,IAAI,EAAE,eAAe;gBACrB,WAAW,EAAE,kCAAkC;gBAC/C,QAAQ,EAAE,KAAK;aAChB;YACD;gBACE,IAAI,EAAE,UAAU;gBAChB,WAAW,EAAE,oDAAoD;gBACjE,QAAQ,EAAE,KAAK;aAChB;SACF;QACD,4DAA4D;QAC5D,OAAO,EAAE,KAAK,EACZ,IAA4B,EAC5B,QAAwB,EACP,EAAE;YACnB,MAAM,aAAa,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,MAAM,CAAC;YACtD,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,OAAO,CAAC;YAE7C,IAAI,OAAO,GAAG,8BAA8B,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;CAuB/G,CAAC;YAEI,IAAI,aAAa,KAAK,MAAM,EAAE,CAAC;gBAC7B,OAAO,IAAI;8BACW,QAAQ;;;;;;;;;;;;;;;;;;;;qBAoBjB,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ;;;;;CAKrI,CAAC;YACI,CAAC;iBAAM,IAAI,aAAa,KAAK,QAAQ,IAAI,aAAa,KAAK,IAAI,EAAE,CAAC;gBAChE,OAAO,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;CAyBlB,CAAC;YACI,CAAC;YAED,OAAO,IAAI;;;;;mBAKE,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yEA8FlE,CAAC;YAEpE,OAAO,OAAO,CAAC;QACjB,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/adapters/postgresql/prompts/pgcron.d.ts

@@ -0,0 +1,8 @@
+/**
+ * pg_cron Setup Prompt
+ *
+ * Complete guide for setting up job scheduling with pg_cron.
+ */
+import type { PromptDefinition } from "../../../types/index.js";
+export declare function createSetupPgcronPrompt(): PromptDefinition;
+//# sourceMappingURL=pgcron.d.ts.map

package/dist/adapters/postgresql/prompts/pgcron.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pgcron.d.ts","sourceRoot":"","sources":["../../../../src/adapters/postgresql/prompts/pgcron.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAkB,MAAM,yBAAyB,CAAC;AAEhF,wBAAgB,uBAAuB,IAAI,gBAAgB,CAsO1D"}

package/dist/adapters/postgresql/prompts/pgcron.js

@@ -0,0 +1,233 @@
+/**
+ * pg_cron Setup Prompt
+ *
+ * Complete guide for setting up job scheduling with pg_cron.
+ */
+export function createSetupPgcronPrompt() {
+    return {
+        name: "pg_setup_pgcron",
+        description: "Complete guide for setting up job scheduling with pg_cron including cron syntax, common patterns, and monitoring.",
+        arguments: [
+            {
+                name: "useCase",
+                description: "Use case: maintenance, cleanup, reporting, etl, backup",
+                required: false,
+            },
+        ],
+        // eslint-disable-next-line @typescript-eslint/require-await
+        handler: async (args, _context) => {
+            const useCase = args["useCase"] ?? "maintenance";
+            let content = `# pg_cron Setup Guide - ${useCase.charAt(0).toUpperCase() + useCase.slice(1)}
+
+## pg_cron Overview
+
+pg_cron enables scheduling SQL commands using familiar cron syntax directly in PostgreSQL:
+- No external scheduler needed
+- Jobs run as database superuser
+- Supports cross-database scheduling
+- Persistent job history
+
+## Setup Steps
+
+### 1. Install pg_cron
+
+\`\`\`sql
+-- Requires shared_preload_libraries configuration
+CREATE EXTENSION IF NOT EXISTS pg_cron;
+SELECT * FROM pg_extension WHERE extname = 'pg_cron';
+\`\`\`
+
+**postgresql.conf:**
+\`\`\`
+shared_preload_libraries = 'pg_cron'
+cron.database_name = 'postgres'  -- Database where cron runs
+\`\`\`
+
+**Restart PostgreSQL after configuration!**
+
+### 2. Cron Expression Syntax
+
+\`\`\`
+┌───────────── minute (0 - 59)
+│ ┌───────────── hour (0 - 23)
+│ │ ┌───────────── day of month (1 - 31)
+│ │ │ ┌───────────── month (1 - 12)
+│ │ │ │ ┌───────────── day of week (0 - 6) (Sunday = 0)
+│ │ │ │ │
+* * * * *
+\`\`\`
+
+**Common patterns:**
+- \`0 * * * *\` — Every hour at minute 0
+- \`0 0 * * *\` — Daily at midnight
+- \`0 0 * * 0\` — Weekly on Sunday at midnight
+- \`0 0 1 * *\` — Monthly on the 1st at midnight
+- \`*/5 * * * *\` — Every 5 minutes
+- \`0 2 * * 1-5\` — Weekdays at 2 AM
+
+`;
+            if (useCase === "maintenance") {
+                content += `### 3. Maintenance Jobs
+
+\`\`\`sql
+-- Daily VACUUM ANALYZE at 3 AM
+SELECT cron.schedule('vacuum-analyze', '0 3 * * *',
+    'VACUUM ANALYZE');
+
+-- Weekly REINDEX on weekends
+SELECT cron.schedule('weekend-reindex', '0 4 * * 0',
+    'REINDEX DATABASE CONCURRENTLY current_database()');
+
+-- Hourly statistics refresh
+SELECT cron.schedule('refresh-stats', '0 * * * *',
+    'ANALYZE');
+\`\`\`
+`;
+            }
+            else if (useCase === "cleanup") {
+                content += `### 3. Cleanup Jobs
+
+\`\`\`sql
+-- Delete old logs daily at 2 AM
+SELECT cron.schedule('cleanup-logs', '0 2 * * *',
+    $$DELETE FROM logs WHERE created_at < NOW() - INTERVAL '30 days'$$);
+
+-- Purge expired sessions hourly
+SELECT cron.schedule('purge-sessions', '0 * * * *',
+    $$DELETE FROM sessions WHERE expires_at < NOW()$$);
+
+-- Clean pg_cron history weekly
+SELECT cron.schedule('cleanup-cron-history', '0 5 * * 0',
+    $$DELETE FROM cron.job_run_details 
+      WHERE end_time < NOW() - INTERVAL '7 days'$$);
+\`\`\`
+`;
+            }
+            else if (useCase === "reporting") {
+                content += `### 3. Reporting Jobs
+
+\`\`\`sql
+-- Daily summary at 6 AM
+SELECT cron.schedule('daily-summary', '0 6 * * *',
+    $$INSERT INTO daily_reports (report_date, total_orders, revenue)
+      SELECT CURRENT_DATE - 1, COUNT(*), SUM(amount)
+      FROM orders WHERE created_at::date = CURRENT_DATE - 1$$);
+
+-- Weekly aggregation on Monday
+SELECT cron.schedule('weekly-rollup', '0 1 * * 1',
+    $$REFRESH MATERIALIZED VIEW CONCURRENTLY weekly_metrics$$);
+
+-- Monthly report on 1st at midnight
+SELECT cron.schedule('monthly-report', '0 0 1 * *',
+    $$CALL generate_monthly_report()$$);
+\`\`\`
+`;
+            }
+            else if (useCase === "etl") {
+                content += `### 3. ETL Jobs
+
+\`\`\`sql
+-- Incremental data load every 15 minutes
+SELECT cron.schedule('incremental-load', '*/15 * * * *',
+    $$CALL load_incremental_data()$$);
+
+-- Full data sync daily at 1 AM
+SELECT cron.schedule('full-sync', '0 1 * * *',
+    $$CALL full_data_sync()$$);
+
+-- Refresh staging tables before business hours
+SELECT cron.schedule('refresh-staging', '0 5 * * 1-5',
+    $$TRUNCATE staging_tables; CALL populate_staging()$$);
+\`\`\`
+`;
+            }
+            else {
+                content += `### 3. Backup Jobs
+
+\`\`\`sql
+-- Note: pg_cron runs SQL, not shell commands
+-- For backup, schedule a function that logs backup requests
+
+SELECT cron.schedule('backup-checkpoint', '0 2 * * *',
+    $$CHECKPOINT; SELECT pg_switch_wal()$$);
+
+-- Log backup request for external pickup
+SELECT cron.schedule('request-backup', '0 3 * * *',
+    $$INSERT INTO backup_requests (requested_at, status)
+      VALUES (NOW(), 'pending')$$);
+\`\`\`
+`;
+            }
+            content += `
+### 4. Managing Jobs
+
+**List jobs:** Use \`pg_cron_list_jobs\`
+
+**View history:** Use \`pg_cron_job_run_details\`
+
+**Modify job:** Use \`pg_cron_alter_job\`
+
+**Remove job:** Use \`pg_cron_unschedule\`
+
+### 5. Cross-Database Scheduling
+
+\`\`\`sql
+-- Schedule job in another database
+SELECT cron.schedule_in_database(
+    'other-db-cleanup',
+    '0 4 * * *',
+    $$DELETE FROM logs WHERE age > INTERVAL '30 days'$$,
+    'other_database'
+);
+\`\`\`
+
+### 6. Monitoring Best Practices
+
+1. **Check job history regularly:**
+   \`\`\`sql
+   SELECT * FROM cron.job_run_details
+   WHERE status = 'failed'
+   ORDER BY end_time DESC LIMIT 10;
+   \`\`\`
+
+2. **Set up alerts for failed jobs**
+
+3. **Clean up old history to prevent bloat**
+
+4. **Monitor job duration trends**
+
+## Available Tools
+
+| Tool | Purpose |
+|------|---------|
+| \`pg_cron_create_extension\` | Enable pg_cron extension |
+| \`pg_cron_schedule\` | Schedule a new job |
+| \`pg_cron_schedule_in_database\` | Schedule job in another database |
+| \`pg_cron_unschedule\` | Remove a scheduled job |
+| \`pg_cron_alter_job\` | Modify job schedule or command |
+| \`pg_cron_list_jobs\` | List all scheduled jobs |
+| \`pg_cron_job_run_details\` | View job execution history |
+| \`pg_cron_enable_job\` | Enable a disabled job |
+| \`pg_cron_disable_job\` | Disable a job without removing |
+
+## Best Practices
+
+1. **Use descriptive job names** — Makes management easier
+2. **Schedule during low-traffic periods**
+3. **Add CONCURRENTLY for maintenance on production**
+4. **Wrap multi-statement jobs in transactions**
+5. **Monitor the cron.job_run_details table size**
+
+## Common Pitfalls
+
+- ❌ Running heavy jobs during peak hours
+- ❌ Forgetting to clean up job history
+- ❌ Not checking job failure status
+- ❌ Overlapping job schedules causing conflicts
+
+**Pro Tip:** Combine pg_cron with pg_partman for automatic partition maintenance!`;
+            return content;
+        },
+    };
+}
+//# sourceMappingURL=pgcron.js.map

package/dist/adapters/postgresql/prompts/pgcron.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pgcron.js","sourceRoot":"","sources":["../../../../src/adapters/postgresql/prompts/pgcron.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,MAAM,UAAU,uBAAuB;IACrC,OAAO;QACL,IAAI,EAAE,iBAAiB;QACvB,WAAW,EACT,mHAAmH;QACrH,SAAS,EAAE;YACT;gBACE,IAAI,EAAE,SAAS;gBACf,WAAW,EAAE,wDAAwD;gBACrE,QAAQ,EAAE,KAAK;aAChB;SACF;QACD,4DAA4D;QAC5D,OAAO,EAAE,KAAK,EACZ,IAA4B,EAC5B,QAAwB,EACP,EAAE;YACnB,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,aAAa,CAAC;YAEjD,IAAI,OAAO,GAAG,2BAA2B,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDhG,CAAC;YAEI,IAAI,OAAO,KAAK,aAAa,EAAE,CAAC;gBAC9B,OAAO,IAAI;;;;;;;;;;;;;;;CAelB,CAAC;YACI,CAAC;iBAAM,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;gBACjC,OAAO,IAAI;;;;;;;;;;;;;;;;CAgBlB,CAAC;YACI,CAAC;iBAAM,IAAI,OAAO,KAAK,WAAW,EAAE,CAAC;gBACnC,OAAO,IAAI;;;;;;;;;;;;;;;;;CAiBlB,CAAC;YACI,CAAC;iBAAM,IAAI,OAAO,KAAK,KAAK,EAAE,CAAC;gBAC7B,OAAO,IAAI;;;;;;;;;;;;;;;CAelB,CAAC;YACI,CAAC;iBAAM,CAAC;gBACN,OAAO,IAAI;;;;;;;;;;;;;;CAclB,CAAC;YACI,CAAC;YAED,OAAO,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kFAmEiE,CAAC;YAE7E,OAAO,OAAO,CAAC;QACjB,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/adapters/postgresql/prompts/pgcrypto.d.ts

@@ -0,0 +1,8 @@
+/**
+ * pgcrypto Setup Prompt
+ *
+ * Complete guide for setting up cryptographic functions with pgcrypto.
+ */
+import type { PromptDefinition } from "../../../types/index.js";
+export declare function createSetupPgcryptoPrompt(): PromptDefinition;
+//# sourceMappingURL=pgcrypto.d.ts.map

package/dist/adapters/postgresql/prompts/pgcrypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pgcrypto.d.ts","sourceRoot":"","sources":["../../../../src/adapters/postgresql/prompts/pgcrypto.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAkB,MAAM,yBAAyB,CAAC;AAEhF,wBAAgB,yBAAyB,IAAI,gBAAgB,CA2S5D"}