s3db.js 13.6.1 → 14.0.2

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 {

package/src/plugins/ttl.plugin.js

@@ -1,6 +1,8 @@
 import { Plugin } from "./plugin.class.js";
 import tryFn from "../concerns/try-fn.js";
 import { idGenerator } from "../concerns/id.js";
+import { resolveResourceName } from "./concerns/resource-names.js";
+import { PluginError } from "../errors.js";
 
 // Time constants (in seconds)
 const ONE_MINUTE_SEC = 60;
@@ -171,7 +173,13 @@ export class TTLPlugin extends Plugin {
     this.isRunning = false;
 
     // Expiration index (plugin storage)
+    const resourceNamesOption = config.resourceNames || {};
     this.expirationIndex = null;
+    this._indexResourceDescriptor = {
+      defaultName: 'plg_ttl_expiration_index',
+      override: resourceNamesOption.index || config.indexResourceName
+    };
+    this.indexResourceName = this._resolveIndexResourceName();
   }
 
   /**
@@ -206,23 +214,44 @@ export class TTLPlugin extends Plugin {
     });
   }
 
+  _resolveIndexResourceName() {
+    return resolveResourceName('ttl', this._indexResourceDescriptor, {
+      namespace: this.namespace
+    });
+  }
+
+  onNamespaceChanged() {
+    if (!this._indexResourceDescriptor) return;
+    this.indexResourceName = this._resolveIndexResourceName();
+  }
+
   /**
    * Validate resource configuration
    */
   _validateResourceConfig(resourceName, config) {
     // Must have either ttl or field
     if (!config.ttl && !config.field) {
-      throw new Error(
-        `[TTLPlugin] Resource "${resourceName}" must have either "ttl" (seconds) or "field" (timestamp field name)`
-      );
+      throw new PluginError('[TTLPlugin] Missing TTL configuration', {
+        pluginName: 'TTLPlugin',
+        operation: 'validateResourceConfig',
+        resourceName,
+        statusCode: 400,
+        retriable: false,
+        suggestion: 'Provide either ttl (in seconds) or field (absolute expiration timestamp) for each resource.'
+      });
     }
 
     const validStrategies = ['soft-delete', 'hard-delete', 'archive', 'callback'];
     if (!config.onExpire || !validStrategies.includes(config.onExpire)) {
-      throw new Error(
-        `[TTLPlugin] Resource "${resourceName}" must have an "onExpire" value. ` +
-        `Valid options: ${validStrategies.join(', ')}`
-      );
+      throw new PluginError('[TTLPlugin] Invalid onExpire strategy', {
+        pluginName: 'TTLPlugin',
+        operation: 'validateResourceConfig',
+        resourceName,
+        statusCode: 400,
+        retriable: false,
+        suggestion: `Set onExpire to one of: ${validStrategies.join(', ')}`,
+        onExpire: config.onExpire
+      });
     }
 
     if (config.onExpire === 'soft-delete' && !config.deleteField) {
@@ -230,15 +259,27 @@ export class TTLPlugin extends Plugin {
     }
 
     if (config.onExpire === 'archive' && !config.archiveResource) {
-      throw new Error(
-        `[TTLPlugin] Resource "${resourceName}" with onExpire="archive" must have an "archiveResource" specified`
-      );
+      throw new PluginError('[TTLPlugin] Archive resource required', {
+        pluginName: 'TTLPlugin',
+        operation: 'validateResourceConfig',
+        resourceName,
+        statusCode: 400,
+        retriable: false,
+        suggestion: 'Provide archiveResource pointing to the resource that stores archived records.',
+        onExpire: config.onExpire
+      });
     }
 
     if (config.onExpire === 'callback' && typeof config.callback !== 'function') {
-      throw new Error(
-        `[TTLPlugin] Resource "${resourceName}" with onExpire="callback" must have a "callback" function`
-      );
+      throw new PluginError('[TTLPlugin] Callback handler required', {
+        pluginName: 'TTLPlugin',
+        operation: 'validateResourceConfig',
+        resourceName,
+        statusCode: 400,
+        retriable: false,
+        suggestion: 'Provide a callback function: { onExpire: "callback", callback: async (ctx) => {...} }',
+        onExpire: config.onExpire
+      });
     }
 
     // Set default field if not specified
@@ -249,7 +290,7 @@ export class TTLPlugin extends Plugin {
     // Validate timestamp field availability
     if (config.field === '_createdAt' && this.database) {
       const resource = this.database.resources[resourceName];
-      if (resource && resource.config && resource.config.timestamps === false) {
+      if (resource && resource.$schema.timestamps === false) {
         console.warn(
           `[TTLPlugin] WARNING: Resource "${resourceName}" uses TTL with field "_createdAt" ` +
           `but timestamps are disabled. TTL will be calculated from indexing time, not creation time.`
@@ -266,7 +307,7 @@ export class TTLPlugin extends Plugin {
    */
   async _createExpirationIndex() {
     this.expirationIndex = await this.database.createResource({
-      name: 'plg_ttl_expiration_index',
+      name: this.indexResourceName,
       attributes: {
         resourceName: 'string|required',
         recordId: 'string|required',
@@ -626,7 +667,14 @@ export class TTLPlugin extends Plugin {
   async _archive(resource, record, config) {
     // Check if archive resource exists
     if (!this.database.resources[config.archiveResource]) {
-      throw new Error(`Archive resource "${config.archiveResource}" not found`);
+      throw new PluginError(`Archive resource "${config.archiveResource}" not found`, {
+        pluginName: 'TTLPlugin',
+        operation: '_archive',
+        resourceName: config.archiveResource,
+        statusCode: 404,
+        retriable: false,
+        suggestion: 'Create the archive resource before using onExpire: "archive" or update archiveResource config.'
+      });
     }
 
     const archiveResource = this.database.resources[config.archiveResource];
@@ -666,7 +714,14 @@ export class TTLPlugin extends Plugin {
   async cleanupResource(resourceName) {
     const config = this.resources[resourceName];
     if (!config) {
-      throw new Error(`Resource "${resourceName}" not configured in TTLPlugin`);
+      throw new PluginError(`Resource "${resourceName}" not configured in TTLPlugin`, {
+        pluginName: 'TTLPlugin',
+        operation: 'cleanupResource',
+        resourceName,
+        statusCode: 404,
+        retriable: false,
+        suggestion: 'Add the resource under TTLPlugin configuration before invoking cleanupResource.'
+      });
     }
 
     const granularity = config.granularity;

package/src/plugins/vector/distances.js

@@ -1,3 +1,5 @@
+import { ValidationError } from '../../errors.js';
+
 /**
  * Vector Distance Functions
  *
@@ -5,6 +7,18 @@
  * All distance functions return lower values for more similar vectors.
  */
 
+function assertSameDimensions(a, b, operation) {
+  if (a.length !== b.length) {
+    throw new ValidationError(`Dimension mismatch: ${a.length} vs ${b.length}`, {
+      operation,
+      pluginName: 'VectorPlugin',
+      retriable: false,
+      suggestion: 'Ensure both vectors have identical lengths before calling distance utilities.',
+      metadata: { vectorALength: a.length, vectorBLength: b.length }
+    });
+  }
+}
+
 /**
  * Calculate cosine distance between two vectors
  *
@@ -17,9 +31,7 @@
  * @throws {Error} If vectors have different dimensions
  */
 export function cosineDistance(a, b) {
-  if (a.length !== b.length) {
-    throw new Error(`Dimension mismatch: ${a.length} vs ${b.length}`);
-  }
+  assertSameDimensions(a, b, 'cosineDistance');
 
   let dotProduct = 0;
   let normA = 0;
@@ -56,9 +68,7 @@ export function cosineDistance(a, b) {
  * @throws {Error} If vectors have different dimensions
  */
 export function euclideanDistance(a, b) {
-  if (a.length !== b.length) {
-    throw new Error(`Dimension mismatch: ${a.length} vs ${b.length}`);
-  }
+  assertSameDimensions(a, b, 'euclideanDistance');
 
   let sum = 0;
   for (let i = 0; i < a.length; i++) {
@@ -81,9 +91,7 @@ export function euclideanDistance(a, b) {
  * @throws {Error} If vectors have different dimensions
  */
 export function manhattanDistance(a, b) {
-  if (a.length !== b.length) {
-    throw new Error(`Dimension mismatch: ${a.length} vs ${b.length}`);
-  }
+  assertSameDimensions(a, b, 'manhattanDistance');
 
   let sum = 0;
   for (let i = 0; i < a.length; i++) {
@@ -104,9 +112,7 @@ export function manhattanDistance(a, b) {
  * @throws {Error} If vectors have different dimensions
  */
 export function dotProduct(a, b) {
-  if (a.length !== b.length) {
-    throw new Error(`Dimension mismatch: ${a.length} vs ${b.length}`);
-  }
+  assertSameDimensions(a, b, 'dotProduct');
 
   let sum = 0;
   for (let i = 0; i < a.length; i++) {