s3db.js 13.6.0 → 14.0.2

package/src/plugins/tfstate/errors.js

@@ -1,3 +1,5 @@
+import { PluginError } from '../../errors.js';
+
 /**
  * TfStatePlugin Error Classes
  * Custom errors for Terraform/OpenTofu state operations
@@ -6,12 +8,19 @@
 /**
  * Base error for all Terraform/OpenTofu state operations
  */
-export class TfStateError extends Error {
+export class TfStateError extends PluginError {
   constructor(message, context = {}) {
-    super(message);
+    const merged = {
+      pluginName: context.pluginName || 'TfStatePlugin',
+      operation: context.operation || 'unknown',
+      statusCode: context.statusCode ?? 500,
+      retriable: context.retriable ?? false,
+      suggestion: context.suggestion ?? 'Verify Terraform/OpenTofu configuration and state storage before retrying.',
+      ...context
+    };
+    super(message, merged);
     this.name = 'TfStateError';
     this.context = context;
-    Error.captureStackTrace(this, this.constructor);
   }
 }
 
@@ -20,7 +29,14 @@ export class TfStateError extends Error {
  */
 export class InvalidStateFileError extends TfStateError {
   constructor(filePath, reason, context = {}) {
-    super(`Invalid Tfstate file "${filePath}": ${reason}`, context);
+    super(`Invalid Tfstate file "${filePath}": ${reason}`, {
+      statusCode: context.statusCode ?? 422,
+      retriable: false,
+      suggestion: context.suggestion ?? 'Validate Terraform state integrity or re-run terraform state pull.',
+      filePath,
+      reason,
+      ...context
+    });
     this.name = 'InvalidStateFileError';
     this.filePath = filePath;
     this.reason = reason;
@@ -34,7 +50,14 @@ export class UnsupportedStateVersionError extends TfStateError {
   constructor(version, supportedVersions, context = {}) {
     super(
       `Tfstate version ${version} is not supported. Supported versions: ${supportedVersions.join(', ')}`,
-      context
+      {
+        statusCode: context.statusCode ?? 400,
+        retriable: false,
+        suggestion: context.suggestion ?? `Upgrade/downgrade Terraform state to one of the supported versions: ${supportedVersions.join(', ')}.`,
+        version,
+        supportedVersions,
+        ...context
+      }
     );
     this.name = 'UnsupportedStateVersionError';
     this.version = version;
@@ -47,7 +70,13 @@ export class UnsupportedStateVersionError extends TfStateError {
  */
 export class StateFileNotFoundError extends TfStateError {
   constructor(filePath, context = {}) {
-    super(`Tfstate file not found: ${filePath}`, context);
+    super(`Tfstate file not found: ${filePath}`, {
+      statusCode: context.statusCode ?? 404,
+      retriable: false,
+      suggestion: context.suggestion ?? 'Ensure the state file exists at the configured path/bucket.',
+      filePath,
+      ...context
+    });
     this.name = 'StateFileNotFoundError';
     this.filePath = filePath;
   }
@@ -60,7 +89,13 @@ export class ResourceExtractionError extends TfStateError {
   constructor(resourceAddress, originalError, context = {}) {
     super(
       `Failed to extract resource "${resourceAddress}": ${originalError.message}`,
-      context
+      {
+        retriable: context.retriable ?? false,
+        suggestion: context.suggestion ?? 'Check resource address and state structure; rerun extraction after fixing the state.',
+        resourceAddress,
+        originalError,
+        ...context
+      }
     );
     this.name = 'ResourceExtractionError';
     this.resourceAddress = resourceAddress;
@@ -75,7 +110,14 @@ export class StateDiffError extends TfStateError {
   constructor(oldSerial, newSerial, originalError, context = {}) {
     super(
       `Failed to calculate diff between state serials ${oldSerial} and ${newSerial}: ${originalError.message}`,
-      context
+      {
+        retriable: context.retriable ?? true,
+        suggestion: context.suggestion ?? 'Refresh the latest state snapshots and retry the diff operation.',
+        oldSerial,
+        newSerial,
+        originalError,
+        ...context
+      }
     );
     this.name = 'StateDiffError';
     this.oldSerial = oldSerial;
@@ -89,7 +131,13 @@ export class StateDiffError extends TfStateError {
  */
 export class FileWatchError extends TfStateError {
   constructor(path, originalError, context = {}) {
-    super(`Failed to watch path "${path}": ${originalError.message}`, context);
+    super(`Failed to watch path "${path}": ${originalError.message}`, {
+      retriable: context.retriable ?? true,
+      suggestion: context.suggestion ?? 'Verify filesystem permissions and that the watch path exists.',
+      path,
+      originalError,
+      ...context
+    });
     this.name = 'FileWatchError';
     this.path = path;
     this.originalError = originalError;
@@ -103,7 +151,14 @@ export class ResourceFilterError extends TfStateError {
   constructor(filterExpression, originalError, context = {}) {
     super(
       `Failed to apply resource filter "${filterExpression}": ${originalError.message}`,
-      context
+      {
+        statusCode: context.statusCode ?? 400,
+        retriable: context.retriable ?? false,
+        suggestion: context.suggestion ?? 'Validate the filter expression syntax and ensure referenced resources exist.',
+        filterExpression,
+        originalError,
+        ...context
+      }
     );
     this.name = 'ResourceFilterError';
     this.filterExpression = filterExpression;

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

@@ -6,8 +6,9 @@
  */
 import { TfStateDriver } from './base-driver.js';
 import { readFile, stat } from 'fs/promises';
-import { join, relative } from 'path';
+import { join } from 'path';
 import { glob } from 'glob';
+import { TfStateError, StateFileNotFoundError } from './errors.js';
 
 export class FilesystemTfStateDriver extends TfStateDriver {
   constructor(config = {}) {
@@ -23,10 +24,23 @@ export class FilesystemTfStateDriver extends TfStateDriver {
     try {
       const stats = await stat(this.basePath);
       if (!stats.isDirectory()) {
-        throw new Error(`Base path is not a directory: ${this.basePath}`);
+        throw new TfStateError(`Base path is not a directory: ${this.basePath}`, {
+          operation: 'initialize',
+          statusCode: 400,
+          retriable: false,
+          suggestion: 'Update the TfState filesystem driver configuration to point to a directory containing .tfstate files.',
+          basePath: this.basePath
+        });
       }
     } catch (error) {
-      throw new Error(`Invalid base path: ${this.basePath} - ${error.message}`);
+      throw new TfStateError(`Invalid base path: ${this.basePath}`, {
+        operation: 'initialize',
+        statusCode: 400,
+        retriable: false,
+        suggestion: 'Ensure the basePath exists and is readable by the current process.',
+        basePath: this.basePath,
+        original: error
+      });
     }
   }
 
@@ -60,7 +74,15 @@ export class FilesystemTfStateDriver extends TfStateDriver {
 
       return stateFiles;
     } catch (error) {
-      throw new Error(`Failed to list state files: ${error.message}`);
+      throw new TfStateError('Failed to list Terraform state files', {
+        operation: 'listStateFiles',
+        statusCode: 500,
+        retriable: false,
+        suggestion: 'Verify filesystem permissions and glob selector pattern.',
+        selector: this.selector,
+        basePath: this.basePath,
+        original: error
+      });
     }
   }
 
@@ -77,9 +99,20 @@ export class FilesystemTfStateDriver extends TfStateDriver {
       return JSON.parse(content);
     } catch (error) {
       if (error.code === 'ENOENT') {
-        throw new Error(`State file not found: ${path}`);
+        throw new StateFileNotFoundError(path, {
+          operation: 'readStateFile',
+          retriable: false,
+          suggestion: 'Ensure the Terraform state file exists at the specified path.',
+          original: error
+        });
       }
-      throw new Error(`Failed to read state file ${path}: ${error.message}`);
+      throw new TfStateError(`Failed to read state file ${path}`, {
+        operation: 'readStateFile',
+        retriable: false,
+        suggestion: 'Validate file permissions and state file contents (must be valid JSON).',
+        path,
+        original: error
+      });
     }
   }
 
@@ -103,9 +136,20 @@ export class FilesystemTfStateDriver extends TfStateDriver {
       };
     } catch (error) {
       if (error.code === 'ENOENT') {
-        throw new Error(`State file not found: ${path}`);
+        throw new StateFileNotFoundError(path, {
+          operation: 'getStateFileMetadata',
+          retriable: false,
+          suggestion: 'Ensure the Terraform state file exists at the specified path.',
+          original: error
+        });
       }
-      throw new Error(`Failed to get metadata for ${path}: ${error.message}`);
+      throw new TfStateError(`Failed to get metadata for ${path}`, {
+        operation: 'getStateFileMetadata',
+        retriable: false,
+        suggestion: 'Check filesystem permissions and path configuration for TfStatePlugin.',
+        path,
+        original: error
+      });
     }
   }
 

package/src/plugins/tfstate/index.js

@@ -249,6 +249,7 @@ import { Plugin } from '../plugin.class.js';
 import tryFn from '../../concerns/try-fn.js';
 import requirePluginDependency from '../concerns/plugin-dependencies.js';
 import { idGenerator } from '../../concerns/id.js';
+import { resolveResourceNames } from '../concerns/resource-names.js';
 import {
   TfStateError,
   InvalidStateFileError,
@@ -271,10 +272,31 @@ export class TfStatePlugin extends Plugin {
     this.driverConfig = config.config || {};
 
     // Resource names
-    const resources = config.resources || {};
-    this.resourceName = resources.resources || config.resourceName || 'plg_tfstate_resources';
-    this.stateFilesName = resources.stateFiles || config.stateFilesName || 'plg_tfstate_state_files';
-    this.diffsName = resources.diffs || config.diffsName || 'plg_tfstate_state_diffs';
+    const resourcesConfig = config.resources || {};
+    const resourceNamesOption = config.resourceNames || {};
+    this._resourceDescriptors = {
+      resources: {
+        defaultName: 'plg_tfstate_resources',
+        override: resourceNamesOption.resources || resourcesConfig.resources || config.resourceName
+      },
+      stateFiles: {
+        defaultName: 'plg_tfstate_state_files',
+        override: resourceNamesOption.stateFiles || resourcesConfig.stateFiles || config.stateFilesName
+      },
+      diffs: {
+        defaultName: 'plg_tfstate_state_diffs',
+        override: resourceNamesOption.diffs || resourcesConfig.diffs || config.diffsName
+      },
+      lineages: {
+        defaultName: 'plg_tfstate_lineages',
+        override: resourceNamesOption.lineages || resourcesConfig.lineages
+      }
+    };
+    const resolvedNames = this._resolveResourceNames();
+    this.resourceName = resolvedNames.resources;
+    this.stateFilesName = resolvedNames.stateFiles;
+    this.diffsName = resolvedNames.diffs;
+    this.lineagesName = resolvedNames.lineages;
 
     // Monitoring configuration
     const monitor = config.monitor || {};
@@ -323,6 +345,20 @@ export class TfStatePlugin extends Plugin {
     };
   }
 
+  _resolveResourceNames() {
+    return resolveResourceNames('tfstate', this._resourceDescriptors, {
+      namespace: this.namespace
+    });
+  }
+
+  onNamespaceChanged() {
+    const names = this._resolveResourceNames();
+    this.resourceName = names.resources;
+    this.stateFilesName = names.stateFiles;
+    this.diffsName = names.diffs;
+    this.lineagesName = names.lineages;
+  }
+
   /**
    * Install the plugin
    * @override
@@ -355,102 +391,131 @@ export class TfStatePlugin extends Plugin {
 
     // Resource 0: Terraform Lineages (Master tracking resource)
     // NEW: Tracks unique Tfstate lineages for efficient diff tracking
-    this.lineagesName = 'plg_tfstate_lineages';
-    this.lineagesResource = await this.database.createResource({
-      name: this.lineagesName,
-      attributes: {
-        id: 'string|required',           // = lineage UUID from Tfstate
-        latestSerial: 'number',           // Track latest for quick access
-        latestStateId: 'string',          // FK to stateFilesResource
-        totalStates: 'number',            // Counter
-        firstImportedAt: 'number',
-        lastImportedAt: 'number',
-        metadata: 'json'                  // Custom tags, project info, etc.
-      },
-      timestamps: true,
-      asyncPartitions: this.asyncPartitions,  // Configurable async partitions
-      partitions: {},                     // No partitions - simple tracking resource
-      createdBy: 'TfStatePlugin'
-    });
+    {
+      const [created, createErr, resource] = await tryFn(() => this.database.createResource({
+        name: this.lineagesName,
+        attributes: {
+          id: 'string|required',
+          latestSerial: 'number',
+          latestStateId: 'string',
+          totalStates: 'number',
+          firstImportedAt: 'number',
+          lastImportedAt: 'number',
+          metadata: 'json'
+        },
+        timestamps: true,
+        asyncPartitions: this.asyncPartitions,
+        partitions: {},
+        createdBy: 'TfStatePlugin'
+      }));
+
+      if (created) {
+        this.lineagesResource = resource;
+      } else {
+        this.lineagesResource = this.database.resources?.[this.lineagesName];
+        if (!this.lineagesResource) {
+          throw createErr;
+        }
+      }
+    }
 
     // Resource 1: Tfstate Files Metadata
     // Dedicated to tracking state file metadata with SHA256 hash for deduplication
-    this.stateFilesResource = await this.database.createResource({
-      name: this.stateFilesName,
-      attributes: {
-        id: 'string|required',
-        lineageId: 'string|required',     // NEW: FK to lineages (= lineage UUID)
-        sourceFile: 'string|required',    // Full path or s3:// URI
-        serial: 'number|required',
-        lineage: 'string|required',       // Denormalized for queries
-        terraformVersion: 'string',
-        stateVersion: 'number|required',
-        resourceCount: 'number',
-        sha256Hash: 'string|required',    // SHA256 hash for deduplication
-        importedAt: 'number|required'
-      },
-      timestamps: true,
-      asyncPartitions: this.asyncPartitions,  // Configurable async partitions
-      partitions: {
-        byLineage: { fields: { lineageId: 'string' } },                        // NEW: Primary lookup
-        byLineageSerial: { fields: { lineageId: 'string', serial: 'number' } }, // NEW: Composite key
-        bySourceFile: { fields: { sourceFile: 'string' } },                    // Legacy support
-        bySerial: { fields: { serial: 'number' } },
-        bySha256: { fields: { sha256Hash: 'string' } }
-      },
-      createdBy: 'TfStatePlugin'
-    });
+    {
+      const [created, createErr, resource] = await tryFn(() => this.database.createResource({
+        name: this.stateFilesName,
+        attributes: {
+          id: 'string|required',
+          lineageId: 'string|required',
+          sourceFile: 'string|required',
+          serial: 'number|required',
+          lineage: 'string|required',
+          terraformVersion: 'string',
+          stateVersion: 'number|required',
+          resourceCount: 'number',
+          sha256Hash: 'string|required',
+          importedAt: 'number|required'
+        },
+        timestamps: true,
+        asyncPartitions: this.asyncPartitions,
+        partitions: {
+          byLineage: { fields: { lineageId: 'string' } },
+          byLineageSerial: { fields: { lineageId: 'string', serial: 'number' } },
+          bySourceFile: { fields: { sourceFile: 'string' } },
+          bySerial: { fields: { serial: 'number' } },
+          bySha256: { fields: { sha256Hash: 'string' } }
+        },
+        createdBy: 'TfStatePlugin'
+      }));
+
+      if (created) {
+        this.stateFilesResource = resource;
+      } else {
+        this.stateFilesResource = this.database.resources?.[this.stateFilesName];
+        if (!this.stateFilesResource) {
+          throw createErr;
+        }
+      }
+    }
 
     // Resource 2: Terraform Resources
     // Store extracted resources with foreign key to state files
-    this.resource = await this.database.createResource({
-      name: this.resourceName,
-      attributes: {
-        id: 'string|required',
-        stateFileId: 'string|required',   // FK to stateFilesResource
-        lineageId: 'string|required',     // NEW: FK to lineages
-        // Denormalized fields for fast queries
-        stateSerial: 'number|required',
-        sourceFile: 'string|required',
-        // Resource data
-        resourceType: 'string|required',
-        resourceName: 'string|required',
-        resourceAddress: 'string|required',
-        providerName: 'string|required',
-        mode: 'string', // managed or data
-        attributes: 'json',
-        dependencies: 'array',
-        importedAt: 'number|required'
-      },
-      timestamps: true,
-      asyncPartitions: this.asyncPartitions,  // Configurable async partitions
-      partitions: {
-        byLineageSerial: { fields: { lineageId: 'string', stateSerial: 'number' } }, // NEW: Efficient diff queries
-        byLineage: { fields: { lineageId: 'string' } },                               // NEW: All resources for lineage
-        byType: { fields: { resourceType: 'string' } },
-        byProvider: { fields: { providerName: 'string' } },
-        bySerial: { fields: { stateSerial: 'number' } },
-        bySourceFile: { fields: { sourceFile: 'string' } },                           // Legacy support
-        byProviderAndType: { fields: { providerName: 'string', resourceType: 'string' } },
-        byLineageType: { fields: { lineageId: 'string', resourceType: 'string' } }   // NEW: Type queries per lineage
-      },
-      createdBy: 'TfStatePlugin'
-    });
+    {
+      const [created, createErr, resource] = await tryFn(() => this.database.createResource({
+        name: this.resourceName,
+        attributes: {
+          id: 'string|required',
+          stateFileId: 'string|required',
+          lineageId: 'string|required',
+          stateSerial: 'number|required',
+          sourceFile: 'string|required',
+          resourceType: 'string|required',
+          resourceName: 'string|required',
+          resourceAddress: 'string|required',
+          providerName: 'string|required',
+          mode: 'string',
+          attributes: 'json',
+          dependencies: 'array',
+          importedAt: 'number|required'
+        },
+        timestamps: true,
+        asyncPartitions: this.asyncPartitions,
+        partitions: {
+          byLineageSerial: { fields: { lineageId: 'string', stateSerial: 'number' } },
+          byLineage: { fields: { lineageId: 'string' } },
+          byType: { fields: { resourceType: 'string' } },
+          byProvider: { fields: { providerName: 'string' } },
+          bySerial: { fields: { stateSerial: 'number' } },
+          bySourceFile: { fields: { sourceFile: 'string' } },
+          byProviderAndType: { fields: { providerName: 'string', resourceType: 'string' } },
+          byLineageType: { fields: { lineageId: 'string', resourceType: 'string' } }
+        },
+        createdBy: 'TfStatePlugin'
+      }));
+
+      if (created) {
+        this.resource = resource;
+      } else {
+        this.resource = this.database.resources?.[this.resourceName];
+        if (!this.resource) {
+          throw createErr;
+        }
+      }
+    }
 
     // Resource 3: Tfstate Diffs
     // Track changes between state versions (if diff tracking enabled)
     if (this.trackDiffs) {
-      this.diffsResource = await this.database.createResource({
+      const [created, createErr, resource] = await tryFn(() => this.database.createResource({
         name: this.diffsName,
         attributes: {
           id: 'string|required',
-          lineageId: 'string|required',     // NEW: FK to lineages
+          lineageId: 'string|required',
           oldSerial: 'number|required',
           newSerial: 'number|required',
-          oldStateId: 'string',              // NEW: FK to stateFilesResource
-          newStateId: 'string|required',     // NEW: FK to stateFilesResource
+          oldStateId: 'string',
+          newStateId: 'string|required',
           calculatedAt: 'number|required',
-          // Summary statistics
           summary: {
             type: 'object',
             props: {
@@ -459,7 +524,6 @@ export class TfStatePlugin extends Plugin {
               deletedCount: 'number'
             }
           },
-          // Detailed changes
           changes: {
             type: 'object',
             props: {
@@ -469,17 +533,26 @@ export class TfStatePlugin extends Plugin {
             }
           }
         },
-        behavior: 'body-only',              // Force all data to body for reliable nested object handling
+        behavior: 'body-only',
         timestamps: true,
-        asyncPartitions: this.asyncPartitions,  // Configurable async partitions
+        asyncPartitions: this.asyncPartitions,
         partitions: {
-          byLineage: { fields: { lineageId: 'string' } },                               // NEW: All diffs for lineage
-          byLineageNewSerial: { fields: { lineageId: 'string', newSerial: 'number' } }, // NEW: Specific version lookup
+          byLineage: { fields: { lineageId: 'string' } },
+          byLineageNewSerial: { fields: { lineageId: 'string', newSerial: 'number' } },
           byNewSerial: { fields: { newSerial: 'number' } },
           byOldSerial: { fields: { oldSerial: 'number' } }
         },
         createdBy: 'TfStatePlugin'
-      });
+      }));
+
+      if (created) {
+        this.diffsResource = resource;
+      } else {
+        this.diffsResource = this.database.resources?.[this.diffsName];
+        if (!this.diffsResource) {
+          throw createErr;
+        }
+      }
     }
 
     if (this.verbose) {

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

@@ -6,6 +6,7 @@
 import { TfStateDriver } from './base-driver.js';
 import { S3Client } from '../../clients/s3-client.class.js';
 import tryFn from '../../concerns/try-fn.js';
+import { TfStateError, InvalidStateFileError, StateFileNotFoundError } from './errors.js';
 
 export class S3TfStateDriver extends TfStateDriver {
   constructor(config = {}) {
@@ -36,7 +37,13 @@ export class S3TfStateDriver extends TfStateDriver {
       const url = new URL(connectionString);
 
       if (url.protocol !== 's3:') {
-        throw new Error('Connection string must use s3:// protocol');
+        throw new TfStateError('Connection string must use s3:// protocol', {
+          operation: 'parseConnectionString',
+          statusCode: 400,
+          retriable: false,
+          suggestion: 'Use format s3://accessKey:secretKey@bucket/prefix?region=us-east-1',
+          connectionString
+        });
       }
 
       const credentials = {};
@@ -61,7 +68,14 @@ export class S3TfStateDriver extends TfStateDriver {
         region
       };
     } catch (error) {
-      throw new Error(`Invalid S3 connection string: ${error.message}`);
+      throw new TfStateError('Invalid S3 connection string', {
+        operation: 'parseConnectionString',
+        statusCode: 400,
+        retriable: false,
+        suggestion: 'Ensure the connection string follows s3://accessKey:secretKey@bucket/prefix?region=REGION.',
+        connectionString,
+        original: error
+      });
     }
   }
 
@@ -95,7 +109,14 @@ export class S3TfStateDriver extends TfStateDriver {
     });
 
     if (!ok) {
-      throw new Error(`Failed to list S3 objects: ${err.message}`);
+      throw new TfStateError('Failed to list Terraform state objects from S3', {
+        operation: 'listStateFiles',
+        retriable: false,
+        suggestion: 'Validate S3 permissions (s3:ListBucket) and prefix configuration.',
+        bucket,
+        prefix,
+        original: err
+      });
     }
 
     const objects = data.Contents || [];
@@ -133,14 +154,35 @@ export class S3TfStateDriver extends TfStateDriver {
     });
 
     if (!ok) {
-      throw new Error(`Failed to read state file ${path}: ${err.message}`);
+      if (err?.$metadata?.httpStatusCode === 404) {
+        throw new StateFileNotFoundError(path, {
+          operation: 'readStateFile',
+          retriable: false,
+          suggestion: 'Ensure the state file exists in S3 and the IAM role can access it.',
+          bucket,
+          original: err
+        });
+      }
+      throw new TfStateError(`Failed to read state file ${path}`, {
+        operation: 'readStateFile',
+        retriable: false,
+        suggestion: 'Verify S3 permissions (s3:GetObject) and network connectivity.',
+        bucket,
+        path,
+        original: err
+      });
     }
 
     try {
       const content = data.Body.toString('utf-8');
       return JSON.parse(content);
     } catch (parseError) {
-      throw new Error(`Failed to parse state file ${path}: ${parseError.message}`);
+      throw new InvalidStateFileError(path, parseError.message, {
+        operation: 'readStateFile',
+        retriable: false,
+        suggestion: 'Check if the state file contains valid JSON exported by Terraform.',
+        original: parseError
+      });
     }
   }
 
@@ -158,7 +200,23 @@ export class S3TfStateDriver extends TfStateDriver {
     });
 
     if (!ok) {
-      throw new Error(`Failed to get metadata for ${path}: ${err.message}`);
+      if (err?.$metadata?.httpStatusCode === 404) {
+        throw new StateFileNotFoundError(path, {
+          operation: 'getStateFileMetadata',
+          retriable: false,
+          suggestion: 'Ensure the state file exists in S3 and the IAM role can access it.',
+          bucket,
+          original: err
+        });
+      }
+      throw new TfStateError(`Failed to get metadata for ${path}`, {
+        operation: 'getStateFileMetadata',
+        retriable: false,
+        suggestion: 'Verify S3 permissions (s3:HeadObject) and bucket configuration.',
+        bucket,
+        path,
+        original: err
+      });
     }
 
     return {