@urugus/slack-cli 0.2.5 → 0.2.7

package/src/utils/validators.ts

@@ -0,0 +1,212 @@
+import { Command } from 'commander';
+import { ERROR_MESSAGES } from './constants';
+
+/**
+ * Common validation functions for CLI commands
+ */
+
+export interface ValidationRule<T = unknown> {
+  validate: (value: T) => boolean | string;
+  errorMessage?: string;
+}
+
+export interface ValidationOptions {
+  required?: boolean;
+  rules?: ValidationRule[];
+}
+
+/**
+ * Validates that a value exists (not undefined, null, or empty string)
+ */
+export function validateRequired(value: unknown, fieldName: string): string | null {
+  if (value === undefined || value === null || value === '') {
+    return `${fieldName} is required`;
+  }
+  return null;
+}
+
+/**
+ * Validates mutually exclusive options
+ */
+export function validateMutuallyExclusive(
+  options: Record<string, unknown>,
+  fields: string[],
+  errorMessage?: string
+): string | null {
+  const presentFields = fields.filter((field) => options[field] !== undefined);
+  if (presentFields.length > 1) {
+    return errorMessage || `Cannot use both ${presentFields.join(' and ')}`;
+  }
+  if (presentFields.length === 0) {
+    return errorMessage || `Must specify one of: ${fields.join(', ')}`;
+  }
+  return null;
+}
+
+/**
+ * Validates string format using regex
+ */
+export function validateFormat(
+  value: string,
+  pattern: RegExp,
+  errorMessage: string
+): string | null {
+  if (!pattern.test(value)) {
+    return errorMessage;
+  }
+  return null;
+}
+
+/**
+ * Validates numeric range
+ */
+export function validateRange(
+  value: number,
+  min?: number,
+  max?: number,
+  fieldName = 'Value'
+): string | null {
+  if (min !== undefined && value < min) {
+    return `${fieldName} must be at least ${min}`;
+  }
+  if (max !== undefined && value > max) {
+    return `${fieldName} must be at most ${max}`;
+  }
+  return null;
+}
+
+/**
+ * Validates date format
+ */
+export function validateDateFormat(dateString: string): string | null {
+  const date = new Date(dateString);
+  if (isNaN(date.getTime())) {
+    return 'Invalid date format';
+  }
+  return null;
+}
+
+/**
+ * Common format validators
+ */
+export const formatValidators = {
+  /**
+   * Validates Slack thread timestamp format (1234567890.123456)
+   */
+  threadTimestamp: (value: string): string | null => {
+    const pattern = /^\d{10}\.\d{6}$/;
+    return validateFormat(value, pattern, ERROR_MESSAGES.INVALID_THREAD_TIMESTAMP);
+  },
+
+  /**
+   * Validates Slack channel ID format (C1234567890, D1234567890, G1234567890)
+   */
+  channelId: (value: string): string | null => {
+    const pattern = /^[CDG][A-Z0-9]{10,}$/;
+    return validateFormat(value, pattern, 'Invalid channel ID format');
+  },
+
+  /**
+   * Validates output format options
+   */
+  outputFormat: (value: string): string | null => {
+    const validFormats = ['table', 'simple', 'json', 'compact'];
+    if (!validFormats.includes(value)) {
+      return `Invalid format. Must be one of: ${validFormats.join(', ')}`;
+    }
+    return null;
+  },
+};
+
+/**
+ * Creates a preAction hook for command validation
+ */
+export function createValidationHook(
+  validations: Array<(options: Record<string, unknown>, command: Command) => string | null>
+): (thisCommand: Command) => void {
+  return (thisCommand: Command) => {
+    const options = thisCommand.opts();
+
+    for (const validation of validations) {
+      const error = validation(options, thisCommand);
+      if (error) {
+        thisCommand.error(`Error: ${error}`);
+        break; // Stop processing after first error
+      }
+    }
+  };
+}
+
+/**
+ * Common command option validators
+ */
+export const optionValidators = {
+  /**
+   * Validates message/file options for send command
+   */
+  messageOrFile: (options: Record<string, unknown>): string | null => {
+    if (!options.message && !options.file) {
+      return ERROR_MESSAGES.NO_MESSAGE_OR_FILE;
+    }
+    if (options.message && options.file) {
+      return ERROR_MESSAGES.BOTH_MESSAGE_AND_FILE;
+    }
+    return null;
+  },
+
+  /**
+   * Validates thread timestamp if provided
+   */
+  threadTimestamp: (options: Record<string, unknown>): string | null => {
+    if (options.thread) {
+      return formatValidators.threadTimestamp(options.thread as string);
+    }
+    return null;
+  },
+
+  /**
+   * Validates message count for history command
+   */
+  messageCount: (options: Record<string, unknown>): string | null => {
+    if (options.number) {
+      const count = parseInt(options.number as string, 10);
+      if (isNaN(count)) {
+        return 'Message count must be a number';
+      }
+      return validateRange(count, 1, 1000, 'Message count');
+    }
+    return null;
+  },
+
+  /**
+   * Validates date format for history command
+   */
+  sinceDate: (options: Record<string, unknown>): string | null => {
+    if (options.since) {
+      const error = validateDateFormat(options.since as string);
+      if (error) {
+        return 'Invalid date format. Use YYYY-MM-DD HH:MM:SS';
+      }
+    }
+    return null;
+  },
+};
+
+/**
+ * Creates a validated option parser
+ */
+export function createOptionParser<T>(
+  parser: (value: string | undefined, defaultValue: T) => T,
+  validator?: (value: T) => string | null
+): (value: string | undefined, defaultValue: T) => T {
+  return (value: string | undefined, defaultValue: T): T => {
+    const parsed = parser(value, defaultValue);
+    if (validator) {
+      const error = validator(parsed);
+      if (error) {
+        throw new Error(error);
+      }
+    }
+    return parsed;
+  };
+}

package/tests/commands/send.test.ts

@@ -47,7 +47,7 @@ describe('send command', () => {
 
       await program.parseAsync(['node', 'slack-cli', 'send', '-c', 'general', '-m', 'Hello, World!']);
 
-      expect(mockSlackClient.sendMessage).toHaveBeenCalledWith('general', 'Hello, World!');
+      expect(mockSlackClient.sendMessage).toHaveBeenCalledWith('general', 'Hello, World!', undefined);
       expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining(SUCCESS_MESSAGES.MESSAGE_SENT('general')));
     });
 
@@ -84,7 +84,74 @@ describe('send command', () => {
       await program.parseAsync(['node', 'slack-cli', 'send', '-c', 'general', '-f', 'message.txt']);
 
       expect(fs.readFile).toHaveBeenCalledWith('message.txt', 'utf-8');
-      expect(mockSlackClient.sendMessage).toHaveBeenCalledWith('general', fileContent);
+      expect(mockSlackClient.sendMessage).toHaveBeenCalledWith('general', fileContent, undefined);
+    });
+  });
+
+  describe('send reply to thread', () => {
+    it('should send a reply to a thread with --thread option', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.sendMessage).mockResolvedValue({
+        ok: true,
+        ts: '1234567890.123456'
+      });
+
+      await program.parseAsync(['node', 'slack-cli', 'send', '-c', 'general', '-m', 'Reply to thread', '--thread', '1719207629.000100']);
+
+      expect(mockSlackClient.sendMessage).toHaveBeenCalledWith('general', 'Reply to thread', '1719207629.000100');
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining(SUCCESS_MESSAGES.MESSAGE_SENT('general')));
+    });
+
+    it('should send a reply to a thread with -t option', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.sendMessage).mockResolvedValue({
+        ok: true,
+        ts: '1234567890.123456'
+      });
+
+      await program.parseAsync(['node', 'slack-cli', 'send', '-c', 'general', '-m', 'Reply to thread', '-t', '1719207629.000100']);
+
+      expect(mockSlackClient.sendMessage).toHaveBeenCalledWith('general', 'Reply to thread', '1719207629.000100');
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining(SUCCESS_MESSAGES.MESSAGE_SENT('general')));
+    });
+
+    it('should validate thread timestamp format', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+
+      const sendCommand = setupSendCommand();
+      sendCommand.exitOverride();
+
+      await expect(
+        sendCommand.parseAsync(['-c', 'general', '-m', 'Reply', '-t', 'invalid-timestamp'], { from: 'user' })
+      ).rejects.toThrow(ERROR_MESSAGES.INVALID_THREAD_TIMESTAMP);
+    });
+
+    it('should send a reply to a thread with file content', async () => {
+      const fileContent = 'Reply from file\nLine 2';
+      vi.mocked(fs.readFile).mockResolvedValue(fileContent);
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.sendMessage).mockResolvedValue({
+        ok: true,
+        ts: '1234567890.123456'
+      });
+
+      await program.parseAsync(['node', 'slack-cli', 'send', '-c', 'general', '-f', 'reply.txt', '-t', '1719207629.000100']);
+
+      expect(fs.readFile).toHaveBeenCalledWith('reply.txt', 'utf-8');
+      expect(mockSlackClient.sendMessage).toHaveBeenCalledWith('general', fileContent, '1719207629.000100');
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining(SUCCESS_MESSAGES.MESSAGE_SENT('general')));
     });
   });
 

package/tests/utils/option-parsers.test.ts

@@ -0,0 +1,173 @@
+import { describe, it, expect } from 'vitest';
+import {
+  parseFormat,
+  parseLimit,
+  parseBoolean,
+  parseCount,
+  parseProfile,
+  parseListOptions,
+  OPTION_DEFAULTS,
+} from '../../src/utils/option-parsers';
+
+describe('option-parsers', () => {
+  describe('parseFormat', () => {
+    it('should return default format when undefined', () => {
+      expect(parseFormat(undefined)).toBe('table');
+    });
+
+    it('should return custom default format when specified', () => {
+      expect(parseFormat(undefined, 'json')).toBe('json');
+    });
+
+    it('should return provided format', () => {
+      expect(parseFormat('compact')).toBe('compact');
+    });
+
+    it('should handle empty string', () => {
+      expect(parseFormat('')).toBe('table');
+    });
+  });
+
+  describe('parseLimit', () => {
+    it('should return default limit when undefined', () => {
+      expect(parseLimit(undefined, 100)).toBe(100);
+    });
+
+    it('should parse string limit', () => {
+      expect(parseLimit('50', 100)).toBe(50);
+    });
+
+    it('should handle invalid number string', () => {
+      expect(parseLimit('abc', 100)).toBe(NaN);
+    });
+
+    it('should handle empty string', () => {
+      expect(parseLimit('', 100)).toBe(100);
+    });
+  });
+
+  describe('parseBoolean', () => {
+    it('should return default value when undefined', () => {
+      expect(parseBoolean(undefined)).toBe(false);
+      expect(parseBoolean(undefined, true)).toBe(true);
+    });
+
+    it('should return provided boolean value', () => {
+      expect(parseBoolean(true)).toBe(true);
+      expect(parseBoolean(false)).toBe(false);
+    });
+
+    it('should handle explicit false over default true', () => {
+      expect(parseBoolean(false, true)).toBe(false);
+    });
+  });
+
+  describe('parseCount', () => {
+    it('should return default count when undefined', () => {
+      expect(parseCount(undefined, 10)).toBe(10);
+    });
+
+    it('should parse string count', () => {
+      expect(parseCount('25', 10)).toBe(25);
+    });
+
+    it('should handle invalid number string', () => {
+      expect(parseCount('invalid', 10)).toBe(10);
+    });
+
+    it('should enforce minimum value', () => {
+      expect(parseCount('5', 10, 10, 100)).toBe(10);
+    });
+
+    it('should enforce maximum value', () => {
+      expect(parseCount('150', 10, 10, 100)).toBe(100);
+    });
+
+    it('should allow values within range', () => {
+      expect(parseCount('50', 10, 10, 100)).toBe(50);
+    });
+
+    it('should handle empty string', () => {
+      expect(parseCount('', 20)).toBe(20);
+    });
+  });
+
+  describe('parseProfile', () => {
+    it('should return undefined when not provided', () => {
+      expect(parseProfile(undefined)).toBeUndefined();
+    });
+
+    it('should return provided profile', () => {
+      expect(parseProfile('production')).toBe('production');
+    });
+
+    it('should handle empty string', () => {
+      expect(parseProfile('')).toBe('');
+    });
+  });
+
+  describe('parseListOptions', () => {
+    it('should use all defaults when no options provided', () => {
+      const result = parseListOptions({});
+      expect(result).toEqual({
+        format: 'table',
+        limit: 100,
+        countOnly: false,
+      });
+    });
+
+    it('should override specific options', () => {
+      const result = parseListOptions({
+        format: 'json',
+        limit: '50',
+        countOnly: true,
+      });
+      expect(result).toEqual({
+        format: 'json',
+        limit: 50,
+        countOnly: true,
+      });
+    });
+
+    it('should use custom defaults', () => {
+      const result = parseListOptions({}, {
+        format: 'compact',
+        limit: 200,
+        countOnly: true,
+      });
+      expect(result).toEqual({
+        format: 'compact',
+        limit: 200,
+        countOnly: true,
+      });
+    });
+
+    it('should override custom defaults with provided options', () => {
+      const result = parseListOptions(
+        {
+          format: 'json',
+        },
+        {
+          format: 'compact',
+          limit: 200,
+        }
+      );
+      expect(result).toEqual({
+        format: 'json',
+        limit: 200,
+        countOnly: false,
+      });
+    });
+  });
+
+  describe('OPTION_DEFAULTS', () => {
+    it('should have expected default values', () => {
+      expect(OPTION_DEFAULTS).toEqual({
+        format: 'table',
+        limit: 100,
+        countOnly: false,
+        includeArchived: false,
+      });
+    });
+  });
+});