@slates-integrations/postgresql 0.2.0-rc.6 → 0.2.0-rc.9

package/src/tools/manage-views.ts

@@ -1,193 +0,0 @@
-import { SlateTool } from '@slates/provider';
-import { spec } from '../spec';
-import { createClient, escapeIdentifier, qualifiedTableName } from '../lib/helpers';
-import { postgresServiceError } from '../lib/errors';
-import { z } from 'zod';
-
-let normalizeViewQuery = (query: string | undefined, allowTableQuery: boolean) => {
-  if (!query?.trim()) {
-    throw postgresServiceError('query is required for create action.');
-  }
-
-  let sql = query.trim().replace(/;\s*$/, '');
-  if (sql.includes(';') || sql.includes('\0')) {
-    throw postgresServiceError(
-      'View query must be a single SELECT, WITH, VALUES, or TABLE statement.'
-    );
-  }
-
-  let allowedPattern = allowTableQuery
-    ? /^(SELECT|WITH|VALUES|TABLE)\b/i
-    : /^(SELECT|WITH|VALUES)\b/i;
-  if (!allowedPattern.test(sql)) {
-    throw postgresServiceError(
-      allowTableQuery
-        ? 'Materialized view query must start with SELECT, WITH, VALUES, or TABLE.'
-        : 'View query must start with SELECT, WITH, or VALUES.'
-    );
-  }
-
-  return sql;
-};
-
-export let manageViews = SlateTool.create(spec, {
-  name: 'Manage Views',
-  key: 'manage_views',
-  description:
-    'Create and drop PostgreSQL views or materialized views, and refresh materialized views.',
-  instructions: [
-    'Use regular views for reusable read queries that should always reflect current base-table data.',
-    'Use materialized views when the query result should be persisted and refreshed on demand.',
-    'Dropping a view requires confirmDrop=true to avoid accidentally removing dependent read models.'
-  ],
-  tags: {
-    destructive: true
-  }
-})
-  .input(
-    z.object({
-      action: z.enum(['create', 'drop', 'refresh']).describe('Action to perform'),
-      viewType: z
-        .enum(['view', 'materialized_view'])
-        .optional()
-        .default('view')
-        .describe('Whether to manage a regular view or materialized view'),
-      viewName: z.string().describe('View name'),
-      schemaName: z.string().optional().describe('Schema containing the view'),
-
-      // Create options
-      query: z
-        .string()
-        .optional()
-        .describe('SELECT query used to define the view (create only)'),
-      columns: z
-        .array(z.string())
-        .optional()
-        .describe('Optional output column names for the view'),
-      orReplace: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe('Use CREATE OR REPLACE VIEW (regular views only)'),
-      ifNotExists: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe('Use IF NOT EXISTS for materialized view creation'),
-      checkOption: z
-        .enum(['local', 'cascaded'])
-        .optional()
-        .describe('WITH LOCAL/CASCADED CHECK OPTION for updatable regular views'),
-      withData: z
-        .boolean()
-        .optional()
-        .default(true)
-        .describe('Populate a materialized view during create/refresh'),
-
-      // Drop/refresh options
-      ifExists: z.boolean().optional().default(false).describe('Use IF EXISTS for drop'),
-      cascade: z.boolean().optional().default(false).describe('Use CASCADE for drop'),
-      confirmDrop: z.boolean().optional().default(false).describe('Must be true for drop'),
-      concurrently: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe('Refresh materialized view without blocking concurrent reads')
-    })
-  )
-  .output(
-    z.object({
-      success: z.boolean().describe('Whether the operation completed successfully'),
-      executedSql: z.string().describe('The SQL statement that was executed'),
-      viewName: z.string().describe('View affected by the operation'),
-      schemaName: z.string().describe('Schema containing the view'),
-      viewType: z.enum(['view', 'materialized_view']).describe('Type of view')
-    })
-  )
-  .handleInvocation(async ctx => {
-    let client = createClient(ctx.auth, ctx.config);
-    let schema = ctx.input.schemaName || ctx.config.defaultSchema;
-    let fullViewName = qualifiedTableName(ctx.input.viewName, schema);
-    let columnList = ctx.input.columns?.length
-      ? ` (${ctx.input.columns.map(escapeIdentifier).join(', ')})`
-      : '';
-    let sql: string;
-
-    if (ctx.input.action === 'create') {
-      let query = normalizeViewQuery(
-        ctx.input.query,
-        ctx.input.viewType === 'materialized_view'
-      );
-
-      if (ctx.input.viewType === 'view') {
-        if (ctx.input.ifNotExists) {
-          throw postgresServiceError('ifNotExists is only supported for materialized views.');
-        }
-
-        let orReplace = ctx.input.orReplace ? 'OR REPLACE ' : '';
-        let checkOption = ctx.input.checkOption
-          ? ` WITH ${ctx.input.checkOption.toUpperCase()} CHECK OPTION`
-          : '';
-        sql = `CREATE ${orReplace}VIEW ${fullViewName}${columnList} AS ${query}${checkOption}`;
-      } else {
-        if (ctx.input.orReplace) {
-          throw postgresServiceError('orReplace is not supported for materialized views.');
-        }
-
-        if (ctx.input.checkOption) {
-          throw postgresServiceError('checkOption is only supported for regular views.');
-        }
-
-        let ifNotExists = ctx.input.ifNotExists ? 'IF NOT EXISTS ' : '';
-        let withData = ctx.input.withData ? 'WITH DATA' : 'WITH NO DATA';
-        sql = `CREATE MATERIALIZED VIEW ${ifNotExists}${fullViewName}${columnList} AS ${query} ${withData}`;
-      }
-    } else if (ctx.input.action === 'drop') {
-      if (!ctx.input.confirmDrop) {
-        throw postgresServiceError('confirmDrop must be true to drop a view.');
-      }
-
-      let objectKeyword = ctx.input.viewType === 'view' ? 'VIEW' : 'MATERIALIZED VIEW';
-      let ifExists = ctx.input.ifExists ? 'IF EXISTS ' : '';
-      let dropBehavior = ctx.input.cascade ? ' CASCADE' : ' RESTRICT';
-      sql = `DROP ${objectKeyword} ${ifExists}${fullViewName}${dropBehavior}`;
-    } else if (ctx.input.action === 'refresh') {
-      if (ctx.input.viewType !== 'materialized_view') {
-        throw postgresServiceError('Only materialized views can be refreshed.');
-      }
-
-      if (ctx.input.concurrently && !ctx.input.withData) {
-        throw postgresServiceError(
-          'concurrently cannot be used when withData is false for REFRESH MATERIALIZED VIEW.'
-        );
-      }
-
-      let concurrently = ctx.input.concurrently ? 'CONCURRENTLY ' : '';
-      let withData = ctx.input.withData ? 'WITH DATA' : 'WITH NO DATA';
-      sql = `REFRESH MATERIALIZED VIEW ${concurrently}${fullViewName} ${withData}`;
-    } else {
-      throw postgresServiceError(`Unknown action: ${ctx.input.action}`);
-    }
-
-    ctx.info(`Executing: ${sql}`);
-    await client.query(sql, ctx.config.queryTimeout);
-
-    let actionLabel =
-      ctx.input.action === 'create'
-        ? 'Created'
-        : ctx.input.action === 'drop'
-          ? 'Dropped'
-          : 'Refreshed';
-
-    return {
-      output: {
-        success: true,
-        executedSql: sql,
-        viewName: ctx.input.viewName,
-        schemaName: schema,
-        viewType: ctx.input.viewType
-      },
-      message: `${actionLabel} ${ctx.input.viewType === 'view' ? 'view' : 'materialized view'} \`${schema}.${ctx.input.viewName}\`.`
-    };
-  })
-  .build();

package/src/tools/update-rows.ts

@@ -1,98 +0,0 @@
-import { SlateTool } from '@slates/provider';
-import { spec } from '../spec';
-import {
-  createClient,
-  escapeIdentifier,
-  escapeLiteral,
-  qualifiedTableName
-} from '../lib/helpers';
-import { postgresServiceError } from '../lib/errors';
-import { z } from 'zod';
-
-export let updateRows = SlateTool.create(spec, {
-  name: 'Update Rows',
-  key: 'update_rows',
-  description: `Update rows in a PostgreSQL table based on a WHERE condition. Specify the columns to update and their new values.
-Supports returning updated rows and allows complex WHERE conditions.`,
-  instructions: [
-    'Always specify a WHERE condition to avoid unintended full-table updates.',
-    'Values are automatically escaped to prevent SQL injection.'
-  ],
-  constraints: ['If no WHERE condition is provided, all rows in the table will be updated.'],
-  tags: {
-    destructive: true
-  }
-})
-  .input(
-    z.object({
-      tableName: z.string().describe('Name of the table to update'),
-      schemaName: z.string().optional().describe('Schema containing the table'),
-      set: z
-        .record(z.string(), z.any())
-        .describe('Object of column names and their new values'),
-      where: z
-        .string()
-        .optional()
-        .describe(
-          'SQL WHERE condition (without the WHERE keyword). Example: "id = 1 AND status = \'active\'"'
-        ),
-      returning: z
-        .boolean()
-        .optional()
-        .default(true)
-        .describe('Whether to return the updated rows using RETURNING *')
-    })
-  )
-  .output(
-    z.object({
-      updatedCount: z.number().describe('Number of rows updated'),
-      returnedRows: z
-        .array(z.record(z.string(), z.any()))
-        .describe('Updated rows (if returning was enabled)')
-    })
-  )
-  .handleInvocation(async ctx => {
-    let client = createClient(ctx.auth, ctx.config);
-    let schema = ctx.input.schemaName || ctx.config.defaultSchema;
-    let fullTableName = qualifiedTableName(ctx.input.tableName, schema);
-
-    let setClauses = Object.entries(ctx.input.set).map(([col, val]) => {
-      let sqlVal: string;
-      if (val === null || val === undefined) sqlVal = 'NULL';
-      else if (typeof val === 'number') sqlVal = String(val);
-      else if (typeof val === 'boolean') sqlVal = val ? 'TRUE' : 'FALSE';
-      else if (typeof val === 'object') sqlVal = escapeLiteral(JSON.stringify(val));
-      else sqlVal = escapeLiteral(String(val));
-      return `${escapeIdentifier(col)} = ${sqlVal}`;
-    });
-
-    if (setClauses.length === 0) {
-      throw postgresServiceError(
-        'At least one column must be specified in the "set" parameter'
-      );
-    }
-
-    let sql = `UPDATE ${fullTableName} SET ${setClauses.join(', ')}`;
-
-    if (ctx.input.where) {
-      sql += ` WHERE ${ctx.input.where}`;
-    }
-
-    if (ctx.input.returning) {
-      sql += ' RETURNING *';
-    }
-
-    ctx.info(
-      `Updating rows in ${fullTableName}${ctx.input.where ? ` where ${ctx.input.where}` : ''}`
-    );
-    let result = await client.query(sql, ctx.config.queryTimeout);
-
-    return {
-      output: {
-        updatedCount: result.rowCount ?? 0,
-        returnedRows: result.rows
-      },
-      message: `Updated **${result.rowCount ?? 0}** row(s) in \`${ctx.input.tableName}\`.`
-    };
-  })
-  .build();

package/src/triggers/inbound-webhook.ts

@@ -1,67 +0,0 @@
-import { SlateTrigger } from '@slates/provider';
-import { spec } from '../spec';
-import { z } from 'zod';
-
-/**
- * Generic inbound webhook for providers without a tailored webhook trigger yet.
- * POST JSON is parsed into `payload` (non-objects are wrapped as { _value }).
- * Refine in the workflow mapper or replace with a provider-specific trigger.
- */
-export let inboundWebhook = SlateTrigger.create(spec, {
-  name: 'Inbound Webhook',
-  key: 'inbound_webhook',
-  description:
-    'Receives HTTP POST at the Slates webhook URL. Parses JSON into payload (or stores raw body if not JSON). Configure your provider to POST here when supported.'
-})
-  .input(
-    z.object({
-      payload: z
-        .record(z.string(), z.any())
-        .describe('Parsed JSON object from the request body'),
-      rawBody: z.string().optional().describe('Raw body when JSON parsing failed'),
-      contentType: z.string().optional().describe('Content-Type header')
-    })
-  )
-  .output(
-    z.object({
-      payload: z.record(z.string(), z.any()),
-      rawBody: z.string().optional()
-    })
-  )
-  .webhook({
-    handleRequest: async ctx => {
-      let contentType = ctx.request.headers.get('content-type') ?? '';
-      let text = await ctx.request.text();
-      if (!text || !text.trim()) {
-        return {
-          inputs: [{ payload: {}, contentType }]
-        };
-      }
-      try {
-        let parsed = JSON.parse(text);
-        let payload =
-          parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)
-            ? parsed
-            : { _value: parsed };
-        return {
-          inputs: [{ payload, contentType }]
-        };
-      } catch {
-        return {
-          inputs: [{ payload: {}, rawBody: text, contentType }]
-        };
-      }
-    },
-
-    handleEvent: async ctx => {
-      return {
-        type: 'webhook.inbound',
-        id: `inbound-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`,
-        output: {
-          payload: ctx.input.payload,
-          rawBody: ctx.input.rawBody
-        }
-      };
-    }
-  })
-  .build();

package/src/triggers/index.ts

@@ -1,2 +0,0 @@
-export { tableChanges } from './table-changes';
-export * from './inbound-webhook';

package/src/triggers/table-changes.ts

@@ -1,123 +0,0 @@
-import { SlateTrigger, SlateDefaultPollingIntervalSeconds } from '@slates/provider';
-import { spec } from '../spec';
-import { createClient, escapeIdentifier, qualifiedTableName } from '../lib/helpers';
-import { z } from 'zod';
-
-export let tableChanges = SlateTrigger.create(spec, {
-  name: 'Table Row Changes',
-  key: 'table_row_changes',
-  description:
-    'Polls a PostgreSQL table for new or updated rows based on a timestamp or auto-incrementing column. Detects INSERT and UPDATE operations by tracking the latest value of the specified column.',
-  instructions: [
-    'The table must have a column that monotonically increases with each insert or update (e.g., a created_at, updated_at, or auto-increment id column).',
-    'For detecting both inserts and updates, use a column that updates on modification (e.g., updated_at with a trigger).',
-    'The polling interval determines how frequently the table is checked for changes.'
-  ]
-})
-  .input(
-    z.object({
-      changeType: z
-        .enum(['inserted', 'updated'])
-        .describe('Whether the row was newly inserted or updated'),
-      trackingColumnValue: z.string().describe('Value of the tracking column for this row'),
-      row: z.record(z.string(), z.any()).describe('The full row data'),
-      tableName: z.string().describe('Table that the change was detected in'),
-      schemaName: z.string().describe('Schema of the table')
-    })
-  )
-  .output(
-    z.object({
-      tableName: z.string().describe('Table where the change occurred'),
-      schemaName: z.string().describe('Schema of the table'),
-      changeType: z.enum(['inserted', 'updated']).describe('Type of change detected'),
-      row: z.record(z.string(), z.any()).describe('The full row data')
-    })
-  )
-  .polling({
-    options: {
-      intervalInSeconds: SlateDefaultPollingIntervalSeconds
-    },
-
-    pollEvents: async ctx => {
-      let client = createClient(ctx.auth, ctx.config);
-      let schema = (ctx.input as any).schemaName || ctx.config.defaultSchema;
-      let tableName = (ctx.input as any).tableName as string;
-      let trackingColumn = (ctx.input as any).trackingColumn as string;
-      let trackingColumnType = (ctx.input as any).trackingColumnType as string;
-      let batchSize = (ctx.input as any).batchSize || 100;
-      let fullTableName = qualifiedTableName(tableName, schema);
-      let escapedCol = escapeIdentifier(trackingColumn);
-
-      let lastValue = ctx.state?.lastTrackingValue as string | null | undefined;
-
-      let sql: string;
-      if (lastValue) {
-        let comparison: string;
-        if (trackingColumnType === 'timestamp') {
-          comparison = `${escapedCol} > '${lastValue.replace(/'/g, "''")}'::timestamptz`;
-        } else {
-          comparison = `${escapedCol} > ${parseInt(lastValue, 10)}`;
-        }
-        sql = `SELECT * FROM ${fullTableName} WHERE ${comparison} ORDER BY ${escapedCol} ASC LIMIT ${batchSize}`;
-      } else {
-        // First poll - get the latest rows to establish a baseline
-        sql = `SELECT * FROM ${fullTableName} ORDER BY ${escapedCol} DESC LIMIT 1`;
-      }
-
-      ctx.info(
-        `Polling ${fullTableName} for changes (tracking: ${trackingColumn}, last: ${lastValue || 'initial'})`
-      );
-      let result = await client.query(sql, ctx.config.queryTimeout);
-
-      if (!lastValue) {
-        // First poll - just capture the current max value, don't emit events
-        let maxRow = result.rows[0];
-        let newLastValue = maxRow ? String(maxRow[trackingColumn]) : null;
-        return {
-          inputs: [],
-          updatedState: {
-            lastTrackingValue: newLastValue
-          }
-        };
-      }
-
-      let inputs = result.rows.map((row: any) => ({
-        changeType: 'inserted' as const, // We can't distinguish insert from update with this approach
-        trackingColumnValue: String(row[trackingColumn]),
-        row,
-        tableName,
-        schemaName: schema
-      }));
-
-      let newLastValue =
-        result.rows.length > 0
-          ? String(result.rows[result.rows.length - 1]![trackingColumn])
-          : lastValue;
-
-      return {
-        inputs,
-        updatedState: {
-          lastTrackingValue: newLastValue
-        }
-      };
-    },
-
-    handleEvent: async ctx => {
-      let row = ctx.input.row;
-      // Try to find a suitable ID for deduplication
-      let rowId =
-        row['id'] || row['_id'] || row['uid'] || row['uuid'] || ctx.input.trackingColumnValue;
-
-      return {
-        type: `row.${ctx.input.changeType}`,
-        id: `${ctx.input.schemaName}.${ctx.input.tableName}:${String(rowId)}:${ctx.input.trackingColumnValue}`,
-        output: {
-          tableName: ctx.input.tableName,
-          schemaName: ctx.input.schemaName,
-          changeType: ctx.input.changeType,
-          row: ctx.input.row
-        }
-      };
-    }
-  })
-  .build();

package/tsconfig.json

@@ -1,23 +0,0 @@
-{
-  "compilerOptions": {
-    "types": ["node"],
-    "lib": ["ESNext"],
-    "target": "ESNext",
-    "module": "Preserve",
-    "moduleDetection": "force",
-    "jsx": "react-jsx",
-    "allowJs": true,
-    "moduleResolution": "bundler",
-
-    "noEmit": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "noPropertyAccessFromIndexSignature": false
-  },
-  "include": ["src"]
-}