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

package/src/tools/manage-indexes.ts

@@ -1,99 +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';
-
-export let manageIndexes = SlateTool.create(spec, {
-  name: 'Manage Indexes',
-  key: 'manage_indexes',
-  description: `Create or drop indexes on PostgreSQL tables. Supports B-tree, Hash, GIN, GiST, and other index types.
-Can create unique indexes, partial indexes with WHERE conditions, and multi-column indexes.`,
-  tags: {
-    destructive: true
-  }
-})
-  .input(
-    z.object({
-      action: z.enum(['create', 'drop']).describe('Action to perform'),
-      indexName: z.string().describe('Name of the index'),
-      tableName: z.string().optional().describe('Name of the table (required for create)'),
-      schemaName: z.string().optional().describe('Schema containing the table'),
-
-      // Create options
-      columns: z
-        .array(z.string())
-        .optional()
-        .describe('Column names to include in the index (required for create)'),
-      unique: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe('Whether to create a UNIQUE index'),
-      method: z
-        .enum(['btree', 'hash', 'gin', 'gist', 'spgist', 'brin'])
-        .optional()
-        .default('btree')
-        .describe('Index access method'),
-      where: z.string().optional().describe('WHERE condition for a partial index'),
-      concurrently: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe('Create index concurrently (non-blocking)'),
-      ifNotExists: z.boolean().optional().default(false).describe('Add IF NOT EXISTS clause'),
-
-      // Drop options
-      cascade: z.boolean().optional().default(false).describe('Use CASCADE when dropping'),
-      ifExists: z.boolean().optional().default(false).describe('Add IF EXISTS clause for drop')
-    })
-  )
-  .output(
-    z.object({
-      success: z.boolean().describe('Whether the operation completed successfully'),
-      executedSql: z.string().describe('The SQL statement that was executed')
-    })
-  )
-  .handleInvocation(async ctx => {
-    let client = createClient(ctx.auth, ctx.config);
-    let schema = ctx.input.schemaName || ctx.config.defaultSchema;
-    let sql: string;
-
-    if (ctx.input.action === 'create') {
-      if (!ctx.input.tableName) {
-        throw postgresServiceError('tableName is required for create action');
-      }
-      if (!ctx.input.columns || ctx.input.columns.length === 0) {
-        throw postgresServiceError('columns are required for create action');
-      }
-
-      let fullTableName = qualifiedTableName(ctx.input.tableName, schema);
-      let unique = ctx.input.unique ? 'UNIQUE ' : '';
-      let concurrently = ctx.input.concurrently ? 'CONCURRENTLY ' : '';
-      let ifNotExists = ctx.input.ifNotExists ? 'IF NOT EXISTS ' : '';
-      let method = ctx.input.method !== 'btree' ? ` USING ${ctx.input.method}` : '';
-      let columnList = ctx.input.columns.map(escapeIdentifier).join(', ');
-      let where = ctx.input.where ? ` WHERE ${ctx.input.where}` : '';
-
-      sql = `CREATE ${unique}INDEX ${concurrently}${ifNotExists}${escapeIdentifier(ctx.input.indexName)} ON ${fullTableName}${method} (${columnList})${where}`;
-    } else {
-      let ifExists = ctx.input.ifExists ? 'IF EXISTS ' : '';
-      let cascade = ctx.input.cascade ? ' CASCADE' : '';
-      let fullIndexName = qualifiedTableName(ctx.input.indexName, schema);
-      sql = `DROP INDEX ${ifExists}${fullIndexName}${cascade}`;
-    }
-
-    ctx.info(`Executing: ${sql}`);
-    await client.query(sql, ctx.config.queryTimeout);
-
-    let actionLabel = ctx.input.action === 'create' ? 'Created' : 'Dropped';
-
-    return {
-      output: {
-        success: true,
-        executedSql: sql
-      },
-      message: `${actionLabel} index \`${ctx.input.indexName}\`.`
-    };
-  })
-  .build();

package/src/tools/manage-roles.ts

@@ -1,214 +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';
-
-export let manageRoles = SlateTool.create(spec, {
-  name: 'Manage Roles',
-  key: 'manage_roles',
-  description: `Manage PostgreSQL roles and their privileges. Supports creating and dropping roles, as well as granting and revoking privileges on databases, schemas, tables, and other objects.`,
-  instructions: [
-    'The connecting user must have sufficient privileges to manage roles.',
-    'Use the grant/revoke actions to control access to specific tables or schemas.'
-  ],
-  tags: {
-    destructive: true
-  }
-})
-  .input(
-    z.object({
-      action: z
-        .enum(['create', 'drop', 'grant', 'revoke', 'list'])
-        .describe('Action to perform'),
-
-      // For create/drop
-      roleName: z.string().optional().describe('Name of the role to create or drop'),
-      rolePassword: z.string().optional().describe('Password for the new role (create only)'),
-      canLogin: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe('Whether the role can log in (create only)'),
-      isSuperuser: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe('Whether the role is a superuser (create only)'),
-      canCreateDb: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe('Whether the role can create databases (create only)'),
-      ifExists: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe('Add IF EXISTS clause (drop only)'),
-
-      // For grant/revoke
-      privileges: z
-        .array(
-          z.enum([
-            'SELECT',
-            'INSERT',
-            'UPDATE',
-            'DELETE',
-            'TRUNCATE',
-            'REFERENCES',
-            'TRIGGER',
-            'ALL',
-            'USAGE',
-            'CREATE',
-            'CONNECT',
-            'EXECUTE'
-          ])
-        )
-        .optional()
-        .describe('Privileges to grant or revoke'),
-      on: z
-        .object({
-          objectType: z
-            .enum([
-              'TABLE',
-              'SCHEMA',
-              'DATABASE',
-              'SEQUENCE',
-              'FUNCTION',
-              'ALL TABLES IN SCHEMA',
-              'ALL SEQUENCES IN SCHEMA'
-            ])
-            .describe('Type of object to grant/revoke privileges on'),
-          objectName: z.string().describe('Name of the object'),
-          schemaName: z
-            .string()
-            .optional()
-            .describe('Schema containing the object (for tables, sequences)')
-        })
-        .optional()
-        .describe('Object to grant/revoke privileges on'),
-      grantee: z.string().optional().describe('Role to grant privileges to or revoke from')
-    })
-  )
-  .output(
-    z.object({
-      success: z.boolean().describe('Whether the operation completed successfully'),
-      executedSql: z.string().describe('The SQL statement(s) that were executed'),
-      roles: z
-        .array(
-          z.object({
-            roleName: z.string().describe('Name of the role'),
-            canLogin: z.boolean().describe('Whether the role can log in'),
-            isSuperuser: z.boolean().describe('Whether the role is a superuser'),
-            canCreateDb: z.boolean().describe('Whether the role can create databases'),
-            canCreateRole: z.boolean().describe('Whether the role can create other roles'),
-            connectionLimit: z
-              .number()
-              .describe('Maximum concurrent connections (-1 = unlimited)')
-          })
-        )
-        .optional()
-        .describe('List of roles (for list action)')
-    })
-  )
-  .handleInvocation(async ctx => {
-    let client = createClient(ctx.auth, ctx.config);
-    let sql: string;
-
-    if (ctx.input.action === 'list') {
-      sql = `
-        SELECT
-          rolname AS role_name,
-          rolcanlogin AS can_login,
-          rolsuper AS is_superuser,
-          rolcreatedb AS can_create_db,
-          rolcreaterole AS can_create_role,
-          rolconnlimit AS connection_limit
-        FROM pg_roles
-        WHERE rolname NOT LIKE 'pg_%'
-        ORDER BY rolname
-      `;
-
-      ctx.info('Listing database roles');
-      let result = await client.query(sql, ctx.config.queryTimeout);
-
-      let roles = result.rows.map((row: any) => ({
-        roleName: row.role_name as string,
-        canLogin: row.can_login === true,
-        isSuperuser: row.is_superuser === true,
-        canCreateDb: row.can_create_db === true,
-        canCreateRole: row.can_create_role === true,
-        connectionLimit: Number(row.connection_limit)
-      }));
-
-      return {
-        output: {
-          success: true,
-          executedSql: sql.trim(),
-          roles
-        },
-        message: `Found **${roles.length}** role(s).`
-      };
-    } else if (ctx.input.action === 'create') {
-      if (!ctx.input.roleName)
-        throw postgresServiceError('roleName is required for create action');
-
-      let options: string[] = [];
-      if (ctx.input.canLogin) options.push('LOGIN');
-      else options.push('NOLOGIN');
-      if (ctx.input.isSuperuser) options.push('SUPERUSER');
-      if (ctx.input.canCreateDb) options.push('CREATEDB');
-      if (ctx.input.rolePassword)
-        options.push(`PASSWORD '${ctx.input.rolePassword.replace(/'/g, "''")}'`);
-
-      sql = `CREATE ROLE ${escapeIdentifier(ctx.input.roleName)} ${options.join(' ')}`;
-    } else if (ctx.input.action === 'drop') {
-      if (!ctx.input.roleName)
-        throw postgresServiceError('roleName is required for drop action');
-      let ifExists = ctx.input.ifExists ? 'IF EXISTS ' : '';
-      sql = `DROP ROLE ${ifExists}${escapeIdentifier(ctx.input.roleName)}`;
-    } else if (ctx.input.action === 'grant' || ctx.input.action === 'revoke') {
-      if (!ctx.input.privileges?.length)
-        throw postgresServiceError('privileges are required for grant/revoke actions');
-      if (!ctx.input.on)
-        throw postgresServiceError(
-          'on (object specification) is required for grant/revoke actions'
-        );
-      if (!ctx.input.grantee)
-        throw postgresServiceError('grantee is required for grant/revoke actions');
-
-      let privs = ctx.input.privileges.join(', ');
-      let objectType = ctx.input.on.objectType;
-      let objectName: string;
-
-      if (objectType === 'TABLE' || objectType === 'SEQUENCE') {
-        objectName = qualifiedTableName(ctx.input.on.objectName, ctx.input.on.schemaName);
-      } else if (
-        objectType === 'ALL TABLES IN SCHEMA' ||
-        objectType === 'ALL SEQUENCES IN SCHEMA'
-      ) {
-        objectName = escapeIdentifier(ctx.input.on.objectName);
-      } else {
-        objectName = escapeIdentifier(ctx.input.on.objectName);
-      }
-
-      let verb = ctx.input.action === 'grant' ? 'GRANT' : 'REVOKE';
-      let preposition = ctx.input.action === 'grant' ? 'TO' : 'FROM';
-
-      sql = `${verb} ${privs} ON ${objectType} ${objectName} ${preposition} ${escapeIdentifier(ctx.input.grantee)}`;
-    } else {
-      throw postgresServiceError(`Unknown action: ${ctx.input.action}`);
-    }
-
-    ctx.info(`Executing: ${sql}`);
-    await client.query(sql, ctx.config.queryTimeout);
-
-    return {
-      output: {
-        success: true,
-        executedSql: sql
-      },
-      message: `Successfully executed \`${ctx.input.action.toUpperCase()}\` operation.`
-    };
-  })
-  .build();

package/src/tools/manage-schemas.ts

@@ -1,121 +0,0 @@
-import { SlateTool } from '@slates/provider';
-import { spec } from '../spec';
-import { createClient, escapeIdentifier } from '../lib/helpers';
-import { postgresServiceError } from '../lib/errors';
-import { z } from 'zod';
-
-export let manageSchemas = SlateTool.create(spec, {
-  name: 'Manage Schemas',
-  key: 'manage_schemas',
-  description:
-    'Create, rename, or drop PostgreSQL schemas. Schemas are namespaces for tables, views, functions, and other database objects.',
-  instructions: [
-    'Use create for a suite-owned or application-owned namespace before creating tables or views.',
-    'Dropping a schema requires confirmDrop=true to avoid accidental removal of contained objects.'
-  ],
-  tags: {
-    destructive: true
-  }
-})
-  .input(
-    z.object({
-      action: z.enum(['create', 'rename', 'drop']).describe('Action to perform'),
-      schemaName: z.string().describe('Schema name to create, rename, or drop'),
-      authorizationRole: z
-        .string()
-        .optional()
-        .describe('Role that should own the new schema (create only)'),
-      newSchemaName: z.string().optional().describe('New schema name (rename only)'),
-      ifNotExists: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe('Add IF NOT EXISTS for create action'),
-      ifExists: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe('Add IF EXISTS for drop action'),
-      cascade: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe('Use CASCADE when dropping a schema'),
-      confirmDrop: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe('Must be true for drop action')
-    })
-  )
-  .output(
-    z.object({
-      success: z.boolean().describe('Whether the operation completed successfully'),
-      executedSql: z.string().describe('The SQL statement that was executed'),
-      schemaName: z.string().describe('Schema affected by the operation'),
-      newSchemaName: z.string().optional().describe('New schema name for rename action')
-    })
-  )
-  .handleInvocation(async ctx => {
-    let client = createClient(ctx.auth, ctx.config);
-    let sql: string;
-
-    if (ctx.input.action === 'create') {
-      if (/^pg_/i.test(ctx.input.schemaName)) {
-        throw postgresServiceError(
-          'Schema names beginning with "pg_" are reserved by PostgreSQL.'
-        );
-      }
-
-      let ifNotExists = ctx.input.ifNotExists ? 'IF NOT EXISTS ' : '';
-      let authorization = ctx.input.authorizationRole
-        ? ` AUTHORIZATION ${escapeIdentifier(ctx.input.authorizationRole)}`
-        : '';
-      sql = `CREATE SCHEMA ${ifNotExists}${escapeIdentifier(ctx.input.schemaName)}${authorization}`;
-    } else if (ctx.input.action === 'rename') {
-      if (!ctx.input.newSchemaName) {
-        throw postgresServiceError('newSchemaName is required for rename action.');
-      }
-
-      if (/^pg_/i.test(ctx.input.newSchemaName)) {
-        throw postgresServiceError(
-          'Schema names beginning with "pg_" are reserved by PostgreSQL.'
-        );
-      }
-
-      sql = `ALTER SCHEMA ${escapeIdentifier(ctx.input.schemaName)} RENAME TO ${escapeIdentifier(
-        ctx.input.newSchemaName
-      )}`;
-    } else if (ctx.input.action === 'drop') {
-      if (!ctx.input.confirmDrop) {
-        throw postgresServiceError('confirmDrop must be true to drop a schema.');
-      }
-
-      let ifExists = ctx.input.ifExists ? 'IF EXISTS ' : '';
-      let dropBehavior = ctx.input.cascade ? ' CASCADE' : ' RESTRICT';
-      sql = `DROP SCHEMA ${ifExists}${escapeIdentifier(ctx.input.schemaName)}${dropBehavior}`;
-    } 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 === 'rename'
-          ? 'Renamed'
-          : 'Dropped';
-
-    return {
-      output: {
-        success: true,
-        executedSql: sql,
-        schemaName: ctx.input.schemaName,
-        newSchemaName: ctx.input.newSchemaName
-      },
-      message: `${actionLabel} schema \`${ctx.input.schemaName}\`.`
-    };
-  })
-  .build();

package/src/tools/manage-table.ts

@@ -1,267 +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 columnDefinitionSchema = z.object({
-  columnName: z.string().describe('Name of the column'),
-  dataType: z
-    .string()
-    .describe(
-      'PostgreSQL data type (e.g., text, integer, bigint, boolean, jsonb, timestamptz, uuid)'
-    ),
-  nullable: z
-    .boolean()
-    .optional()
-    .default(true)
-    .describe('Whether the column allows NULL values'),
-  defaultValue: z
-    .string()
-    .optional()
-    .describe(
-      'SQL expression for the default value (e.g., "now()", "0", "gen_random_uuid()")'
-    ),
-  primaryKey: z
-    .boolean()
-    .optional()
-    .default(false)
-    .describe('Whether this column is the primary key'),
-  unique: z
-    .boolean()
-    .optional()
-    .default(false)
-    .describe('Whether this column has a unique constraint'),
-  references: z
-    .object({
-      tableName: z.string().describe('Referenced table name'),
-      columnName: z.string().describe('Referenced column name'),
-      schemaName: z.string().optional().describe('Referenced table schema')
-    })
-    .optional()
-    .describe('Foreign key reference')
-});
-
-export let manageTable = SlateTool.create(spec, {
-  name: 'Manage Table',
-  key: 'manage_table',
-  description: `Create, alter, or drop a PostgreSQL table. Supports creating tables with columns, constraints, and foreign keys.
-For altering tables, supports adding columns, dropping columns, renaming columns, altering column types, and renaming the table.`,
-  instructions: [
-    'For creating tables, provide the full column definitions.',
-    'For altering tables, specify only the changes you want to make.',
-    'Use the "drop" action with caution as it permanently removes the table and all its data.'
-  ],
-  tags: {
-    destructive: true
-  }
-})
-  .input(
-    z.object({
-      action: z.enum(['create', 'alter', 'drop']).describe('Action to perform on the table'),
-      tableName: z.string().describe('Name of the table'),
-      schemaName: z.string().optional().describe('Schema for the table'),
-
-      // Create options
-      columns: z
-        .array(columnDefinitionSchema)
-        .optional()
-        .describe('Column definitions (required for create action)'),
-      ifNotExists: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe('Add IF NOT EXISTS clause for create action'),
-
-      // Alter options
-      addColumns: z
-        .array(columnDefinitionSchema)
-        .optional()
-        .describe('Columns to add to the table'),
-      dropColumns: z
-        .array(z.string())
-        .optional()
-        .describe('Column names to drop from the table'),
-      renameColumn: z
-        .object({
-          from: z.string().describe('Current column name'),
-          to: z.string().describe('New column name')
-        })
-        .optional()
-        .describe('Rename a column'),
-      renameTable: z.string().optional().describe('New table name (for rename operation)'),
-      alterColumns: z
-        .array(
-          z.object({
-            columnName: z.string().describe('Column to alter'),
-            setDataType: z.string().optional().describe('New data type'),
-            setDefault: z.string().optional().describe('New default value expression'),
-            dropDefault: z.boolean().optional().describe('Remove the default value'),
-            setNotNull: z.boolean().optional().describe('Add NOT NULL constraint'),
-            dropNotNull: z.boolean().optional().describe('Remove NOT NULL constraint')
-          })
-        )
-        .optional()
-        .describe('Columns to alter'),
-
-      // Drop options
-      cascade: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe('Use CASCADE when dropping (also drops dependent objects)'),
-      ifExists: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe('Add IF EXISTS clause for drop action')
-    })
-  )
-  .output(
-    z.object({
-      success: z.boolean().describe('Whether the operation completed successfully'),
-      executedSql: z.string().describe('The SQL statement(s) that were executed')
-    })
-  )
-  .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 statements: string[] = [];
-
-    if (ctx.input.action === 'create') {
-      if (!ctx.input.columns || ctx.input.columns.length === 0) {
-        throw postgresServiceError('Column definitions are required for create action');
-      }
-
-      let columnDefs: string[] = [];
-      let pkColumns: string[] = [];
-
-      for (let col of ctx.input.columns) {
-        let def = `${escapeIdentifier(col.columnName)} ${col.dataType}`;
-        if (!col.nullable) def += ' NOT NULL';
-        if (col.defaultValue) def += ` DEFAULT ${col.defaultValue}`;
-        if (col.unique) def += ' UNIQUE';
-        if (col.primaryKey) pkColumns.push(col.columnName);
-        if (col.references) {
-          let refTable = qualifiedTableName(
-            col.references.tableName,
-            col.references.schemaName
-          );
-          def += ` REFERENCES ${refTable}(${escapeIdentifier(col.references.columnName)})`;
-        }
-        columnDefs.push(def);
-      }
-
-      if (pkColumns.length > 0) {
-        columnDefs.push(`PRIMARY KEY (${pkColumns.map(escapeIdentifier).join(', ')})`);
-      }
-
-      let ifNotExists = ctx.input.ifNotExists ? 'IF NOT EXISTS ' : '';
-      statements.push(
-        `CREATE TABLE ${ifNotExists}${fullTableName} (\n  ${columnDefs.join(',\n  ')}\n)`
-      );
-    } else if (ctx.input.action === 'alter') {
-      if (ctx.input.addColumns) {
-        for (let col of ctx.input.addColumns) {
-          let def = `${escapeIdentifier(col.columnName)} ${col.dataType}`;
-          if (!col.nullable) def += ' NOT NULL';
-          if (col.defaultValue) def += ` DEFAULT ${col.defaultValue}`;
-          if (col.unique) def += ' UNIQUE';
-          if (col.references) {
-            let refTable = qualifiedTableName(
-              col.references.tableName,
-              col.references.schemaName
-            );
-            def += ` REFERENCES ${refTable}(${escapeIdentifier(col.references.columnName)})`;
-          }
-          statements.push(`ALTER TABLE ${fullTableName} ADD COLUMN ${def}`);
-        }
-      }
-
-      if (ctx.input.dropColumns) {
-        for (let colName of ctx.input.dropColumns) {
-          statements.push(
-            `ALTER TABLE ${fullTableName} DROP COLUMN ${escapeIdentifier(colName)}`
-          );
-        }
-      }
-
-      if (ctx.input.renameColumn) {
-        statements.push(
-          `ALTER TABLE ${fullTableName} RENAME COLUMN ${escapeIdentifier(ctx.input.renameColumn.from)} TO ${escapeIdentifier(ctx.input.renameColumn.to)}`
-        );
-      }
-
-      if (ctx.input.alterColumns) {
-        for (let alter of ctx.input.alterColumns) {
-          let colName = escapeIdentifier(alter.columnName);
-          if (alter.setDataType) {
-            statements.push(
-              `ALTER TABLE ${fullTableName} ALTER COLUMN ${colName} TYPE ${alter.setDataType}`
-            );
-          }
-          if (alter.setDefault) {
-            statements.push(
-              `ALTER TABLE ${fullTableName} ALTER COLUMN ${colName} SET DEFAULT ${alter.setDefault}`
-            );
-          }
-          if (alter.dropDefault) {
-            statements.push(
-              `ALTER TABLE ${fullTableName} ALTER COLUMN ${colName} DROP DEFAULT`
-            );
-          }
-          if (alter.setNotNull) {
-            statements.push(
-              `ALTER TABLE ${fullTableName} ALTER COLUMN ${colName} SET NOT NULL`
-            );
-          }
-          if (alter.dropNotNull) {
-            statements.push(
-              `ALTER TABLE ${fullTableName} ALTER COLUMN ${colName} DROP NOT NULL`
-            );
-          }
-        }
-      }
-
-      if (ctx.input.renameTable) {
-        statements.push(
-          `ALTER TABLE ${fullTableName} RENAME TO ${escapeIdentifier(ctx.input.renameTable)}`
-        );
-      }
-
-      if (statements.length === 0) {
-        throw postgresServiceError(
-          'No alter operations specified. Provide addColumns, dropColumns, renameColumn, alterColumns, or renameTable.'
-        );
-      }
-    } else if (ctx.input.action === 'drop') {
-      let ifExists = ctx.input.ifExists ? 'IF EXISTS ' : '';
-      let cascade = ctx.input.cascade ? ' CASCADE' : '';
-      statements.push(`DROP TABLE ${ifExists}${fullTableName}${cascade}`);
-    }
-
-    let executedSql = statements.join(';\n');
-    ctx.info(`Executing: ${executedSql}`);
-
-    // Execute all statements
-    for (let stmt of statements) {
-      await client.query(stmt, ctx.config.queryTimeout);
-    }
-
-    let actionLabel =
-      ctx.input.action === 'create'
-        ? 'Created'
-        : ctx.input.action === 'alter'
-          ? 'Altered'
-          : 'Dropped';
-
-    return {
-      output: {
-        success: true,
-        executedSql
-      },
-      message: `${actionLabel} table \`${ctx.input.tableName}\`. Executed **${statements.length}** statement(s).`
-    };
-  })
-  .build();