s3db.js 11.3.2 → 12.0.1

package/src/plugins/tfstate/base-driver.js

@@ -0,0 +1,80 @@
+/**
+ * Base Driver Class for TfState Plugin
+ *
+ * All tfstate drivers must extend this class and implement the required methods.
+ */
+export class TfStateDriver {
+  constructor(config = {}) {
+    this.config = config;
+    this.selector = config.selector || '**/*.tfstate';
+  }
+
+  /**
+   * Initialize the driver
+   * Called during plugin installation
+   */
+  async initialize() {
+    throw new Error('Driver must implement initialize()');
+  }
+
+  /**
+   * List all state files matching the selector
+   * @returns {Promise<Array>} Array of state file metadata { path, lastModified, size }
+   */
+  async listStateFiles() {
+    throw new Error('Driver must implement listStateFiles()');
+  }
+
+  /**
+   * Read a state file content
+   * @param {string} path - Path to the state file
+   * @returns {Promise<Object>} Parsed state file content
+   */
+  async readStateFile(path) {
+    throw new Error('Driver must implement readStateFile()');
+  }
+
+  /**
+   * Get state file metadata
+   * @param {string} path - Path to the state file
+   * @returns {Promise<Object>} Metadata { path, lastModified, size, etag }
+   */
+  async getStateFileMetadata(path) {
+    throw new Error('Driver must implement getStateFileMetadata()');
+  }
+
+  /**
+   * Check if a state file has been modified since last check
+   * @param {string} path - Path to the state file
+   * @param {Date} since - Check modifications since this date
+   * @returns {Promise<boolean>} True if modified
+   */
+  async hasBeenModified(path, since) {
+    const metadata = await this.getStateFileMetadata(path);
+    return new Date(metadata.lastModified) > new Date(since);
+  }
+
+  /**
+   * Match a path against the selector pattern
+   * @param {string} path - Path to check
+   * @returns {boolean} True if matches
+   */
+  matchesSelector(path) {
+    const pattern = this.selector
+      .replace(/\*\*/g, '__DOUBLE_STAR__')
+      .replace(/\*/g, '[^/]*')
+      .replace(/__DOUBLE_STAR__/g, '.*')
+      .replace(/\?/g, '.')
+      .replace(/\[([^\]]+)\]/g, '[$1]');
+
+    const regex = new RegExp(`^${pattern}$`);
+    return regex.test(path);
+  }
+
+  /**
+   * Close/cleanup driver resources
+   */
+  async close() {
+    // Optional cleanup, override if needed
+  }
+}

package/src/plugins/tfstate/errors.js

@@ -0,0 +1,112 @@
+/**
+ * TfStatePlugin Error Classes
+ * Custom errors for Terraform/OpenTofu state operations
+ */
+
+/**
+ * Base error for all Terraform/OpenTofu state operations
+ */
+export class TfStateError extends Error {
+  constructor(message, context = {}) {
+    super(message);
+    this.name = 'TfStateError';
+    this.context = context;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+/**
+ * Thrown when state file is invalid or corrupted
+ */
+export class InvalidStateFileError extends TfStateError {
+  constructor(filePath, reason, context = {}) {
+    super(`Invalid Terraform state file "${filePath}": ${reason}`, context);
+    this.name = 'InvalidStateFileError';
+    this.filePath = filePath;
+    this.reason = reason;
+  }
+}
+
+/**
+ * Thrown when state file version is not supported
+ */
+export class UnsupportedStateVersionError extends TfStateError {
+  constructor(version, supportedVersions, context = {}) {
+    super(
+      `Terraform state version ${version} is not supported. Supported versions: ${supportedVersions.join(', ')}`,
+      context
+    );
+    this.name = 'UnsupportedStateVersionError';
+    this.version = version;
+    this.supportedVersions = supportedVersions;
+  }
+}
+
+/**
+ * Thrown when state file cannot be read
+ */
+export class StateFileNotFoundError extends TfStateError {
+  constructor(filePath, context = {}) {
+    super(`Terraform state file not found: ${filePath}`, context);
+    this.name = 'StateFileNotFoundError';
+    this.filePath = filePath;
+  }
+}
+
+/**
+ * Thrown when resource extraction fails
+ */
+export class ResourceExtractionError extends TfStateError {
+  constructor(resourceAddress, originalError, context = {}) {
+    super(
+      `Failed to extract resource "${resourceAddress}": ${originalError.message}`,
+      context
+    );
+    this.name = 'ResourceExtractionError';
+    this.resourceAddress = resourceAddress;
+    this.originalError = originalError;
+  }
+}
+
+/**
+ * Thrown when state diff calculation fails
+ */
+export class StateDiffError extends TfStateError {
+  constructor(oldSerial, newSerial, originalError, context = {}) {
+    super(
+      `Failed to calculate diff between state serials ${oldSerial} and ${newSerial}: ${originalError.message}`,
+      context
+    );
+    this.name = 'StateDiffError';
+    this.oldSerial = oldSerial;
+    this.newSerial = newSerial;
+    this.originalError = originalError;
+  }
+}
+
+/**
+ * Thrown when file watching setup fails
+ */
+export class FileWatchError extends TfStateError {
+  constructor(path, originalError, context = {}) {
+    super(`Failed to watch path "${path}": ${originalError.message}`, context);
+    this.name = 'FileWatchError';
+    this.path = path;
+    this.originalError = originalError;
+  }
+}
+
+/**
+ * Thrown when resource filtering fails
+ */
+export class ResourceFilterError extends TfStateError {
+  constructor(filterExpression, originalError, context = {}) {
+    super(
+      `Failed to apply resource filter "${filterExpression}": ${originalError.message}`,
+      context
+    );
+    this.name = 'ResourceFilterError';
+    this.filterExpression = filterExpression;
+    this.originalError = originalError;
+  }
+}

package/src/plugins/tfstate/filesystem-driver.js

@@ -0,0 +1,129 @@
+/**
+ * Filesystem Driver for TfState Plugin
+ *
+ * Reads Terraform/OpenTofu state files from local filesystem
+ * Useful for development and testing
+ */
+import { TfStateDriver } from './base-driver.js';
+import { readFile, stat } from 'fs/promises';
+import { join, relative } from 'path';
+import { glob } from 'glob';
+
+export class FilesystemTfStateDriver extends TfStateDriver {
+  constructor(config = {}) {
+    super(config);
+    this.basePath = config.basePath || config.path || process.cwd();
+  }
+
+  /**
+   * Initialize filesystem driver
+   */
+  async initialize() {
+    // Verify base path exists
+    try {
+      const stats = await stat(this.basePath);
+      if (!stats.isDirectory()) {
+        throw new Error(`Base path is not a directory: ${this.basePath}`);
+      }
+    } catch (error) {
+      throw new Error(`Invalid base path: ${this.basePath} - ${error.message}`);
+    }
+  }
+
+  /**
+   * List all state files matching the selector
+   */
+  async listStateFiles() {
+    const pattern = join(this.basePath, this.selector);
+
+    try {
+      const files = await glob(pattern, {
+        nodir: true,
+        absolute: false,
+        cwd: this.basePath
+      });
+
+      const stateFiles = await Promise.all(
+        files.map(async (file) => {
+          const fullPath = join(this.basePath, file);
+          const stats = await stat(fullPath);
+
+          return {
+            path: file,
+            fullPath,
+            lastModified: stats.mtime,
+            size: stats.size,
+            etag: `${stats.mtime.getTime()}-${stats.size}` // Pseudo-etag
+          };
+        })
+      );
+
+      return stateFiles;
+    } catch (error) {
+      throw new Error(`Failed to list state files: ${error.message}`);
+    }
+  }
+
+  /**
+   * Read a state file from filesystem
+   */
+  async readStateFile(path) {
+    const fullPath = path.startsWith(this.basePath)
+      ? path
+      : join(this.basePath, path);
+
+    try {
+      const content = await readFile(fullPath, 'utf-8');
+      return JSON.parse(content);
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        throw new Error(`State file not found: ${path}`);
+      }
+      throw new Error(`Failed to read state file ${path}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get state file metadata from filesystem
+   */
+  async getStateFileMetadata(path) {
+    const fullPath = path.startsWith(this.basePath)
+      ? path
+      : join(this.basePath, path);
+
+    try {
+      const stats = await stat(fullPath);
+
+      return {
+        path,
+        fullPath,
+        lastModified: stats.mtime,
+        size: stats.size,
+        etag: `${stats.mtime.getTime()}-${stats.size}`
+      };
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        throw new Error(`State file not found: ${path}`);
+      }
+      throw new Error(`Failed to get metadata for ${path}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Check if state file has been modified
+   */
+  async hasBeenModified(path, since) {
+    const metadata = await this.getStateFileMetadata(path);
+    const lastModified = new Date(metadata.lastModified);
+    const sinceDate = new Date(since);
+
+    return lastModified > sinceDate;
+  }
+
+  /**
+   * Close filesystem driver (no-op)
+   */
+  async close() {
+    // Nothing to close for filesystem
+  }
+}