s3db.js 13.6.0 → 14.0.2

package/src/plugins/cache.plugin.js

@@ -5,8 +5,10 @@ import crypto from 'crypto';
 import { Plugin } from "./plugin.class.js";
 import S3Cache from "./cache/s3-cache.class.js";
 import MemoryCache from "./cache/memory-cache.class.js";
+import RedisCache from "./cache/redis-cache.class.js";
 import { FilesystemCache } from "./cache/filesystem-cache.class.js";
 import { PartitionAwareFilesystemCache } from "./cache/partition-aware-filesystem-cache.class.js";
+import MultiTierCache from "./cache/multi-tier-cache.class.js";
 import tryFn from "../concerns/try-fn.js";
 import { CacheError } from "./cache.errors.js";
 
@@ -96,10 +98,21 @@ export class CachePlugin extends Plugin {
   constructor(options = {}) {
     super(options);
 
+    // Detect multi-tier mode (drivers array)
+    const isMultiTier = Array.isArray(options.drivers) && options.drivers.length > 0;
+
     // Clean, consolidated configuration
     this.config = {
-      // Driver configuration
+      // Driver configuration (single-tier or multi-tier)
       driver: options.driver || 's3',
+      drivers: options.drivers, // Array of driver configs for multi-tier
+      isMultiTier,
+
+      // Multi-tier specific options
+      promoteOnHit: options.promoteOnHit !== false,
+      strategy: options.strategy || 'write-through', // 'write-through' | 'lazy-promotion'
+      fallbackOnError: options.fallbackOnError !== false,
+
       config: {
         ttl: options.ttl,
         maxSize: options.maxSize,
@@ -139,30 +152,16 @@ export class CachePlugin extends Plugin {
   }
 
   async onInstall() {
-    // Initialize cache driver
-    if (this.config.driver && typeof this.config.driver === 'object') {
+    // Initialize cache driver (multi-tier or single-tier)
+    if (this.config.isMultiTier) {
+      // Multi-tier mode: create multiple drivers and wrap with MultiTierCache
+      this.driver = await this._createMultiTierDriver();
+    } else if (this.config.driver && typeof this.config.driver === 'object') {
       // Use custom driver instance if provided
       this.driver = this.config.driver;
-    } else if (this.config.driver === 'memory') {
-      this.driver = new MemoryCache(this.config.config);
-    } else if (this.config.driver === 'filesystem') {
-      // Use partition-aware filesystem cache if enabled
-      if (this.config.partitionAware) {
-        this.driver = new PartitionAwareFilesystemCache({
-          partitionStrategy: this.config.partitionStrategy,
-          trackUsage: this.config.trackUsage,
-          preloadRelated: this.config.preloadRelated,
-          ...this.config.config
-        });
-      } else {
-        this.driver = new FilesystemCache(this.config.config);
-      }
     } else {
-      // Default to S3Cache
-      this.driver = new S3Cache({
-        client: this.database.client,
-        ...this.config.config
-      });
+      // Single-tier mode: create single driver
+      this.driver = await this._createSingleDriver(this.config.driver, this.config.config);
     }
 
     // Use database hooks instead of method overwriting
@@ -192,6 +191,66 @@ export class CachePlugin extends Plugin {
     // Cleanup if needed
   }
 
+  /**
+   * Create a single cache driver instance
+   * @private
+   */
+  async _createSingleDriver(driverName, config) {
+    if (driverName === 'memory') {
+      return new MemoryCache(config);
+    } else if (driverName === 'redis') {
+      return new RedisCache(config);
+    } else if (driverName === 'filesystem') {
+      // Use partition-aware filesystem cache if enabled
+      if (this.config.partitionAware) {
+        return new PartitionAwareFilesystemCache({
+          partitionStrategy: this.config.partitionStrategy,
+          trackUsage: this.config.trackUsage,
+          preloadRelated: this.config.preloadRelated,
+          ...config
+        });
+      } else {
+        return new FilesystemCache(config);
+      }
+    } else {
+      // Default to S3Cache
+      return new S3Cache({
+        client: this.database.client,
+        ...config
+      });
+    }
+  }
+
+  /**
+   * Create multi-tier cache driver
+   * @private
+   */
+  async _createMultiTierDriver() {
+    const driverInstances = [];
+
+    // Create each driver instance
+    for (const driverConfig of this.config.drivers) {
+      const driverInstance = await this._createSingleDriver(
+        driverConfig.driver,
+        driverConfig.config || {}
+      );
+
+      driverInstances.push({
+        driver: driverInstance,
+        name: driverConfig.name || `L${driverInstances.length + 1}-${driverConfig.driver}`
+      });
+    }
+
+    // Wrap with MultiTierCache
+    return new MultiTierCache({
+      drivers: driverInstances,
+      promoteOnHit: this.config.promoteOnHit,
+      strategy: this.config.strategy,
+      fallbackOnError: this.config.fallbackOnError,
+      verbose: this.config.verbose
+    });
+  }
+
   // Remove the old installDatabaseProxy method
   installResourceHooks() {
     for (const resource of Object.values(this.database.resources)) {
@@ -204,11 +263,11 @@ export class CachePlugin extends Plugin {
   }
 
   shouldCacheResource(resourceName) {
-    // Get resource metadata to check createdBy
-    const resourceMetadata = this.database.savedMetadata?.resources?.[resourceName];
+    // Use $schema for reliable access to createdBy
+    const resource = this.database.resources[resourceName];
 
     // Skip plugin-created resources by default (unless explicitly included)
-    if (resourceMetadata?.createdBy && resourceMetadata.createdBy !== 'user' && !this.config.include) {
+    if (resource?.$schema?.createdBy && resource.$schema.createdBy !== 'user' && !this.config.include) {
       return false;
     }
 
@@ -233,18 +292,58 @@ export class CachePlugin extends Plugin {
   installResourceHooksForResource(resource) {
     if (!this.driver) return;
 
-    // Add cache methods to resource
-    Object.defineProperty(resource, 'cache', {
-      value: this.driver,
-      writable: true,
-      configurable: true,
-      enumerable: false
-    });
-    resource.cacheKeyFor = async (options = {}) => {
+    const driver = this.driver;
+    const instanceKey = this.instanceName || this.slug;
+
+    resource.cacheInstances = resource.cacheInstances || {};
+    resource.cacheInstances[instanceKey] = driver;
+
+    if (!Object.prototype.hasOwnProperty.call(resource, 'cache')) {
+      Object.defineProperty(resource, 'cache', {
+        value: driver,
+        writable: true,
+        configurable: true,
+        enumerable: false
+      });
+    }
+
+    if (typeof resource.getCacheDriver !== 'function') {
+      Object.defineProperty(resource, 'getCacheDriver', {
+        value: (name = null) => {
+          if (!name) {
+            return resource.cache;
+          }
+          return resource.cacheInstances?.[name] || null;
+        },
+        writable: true,
+        configurable: true,
+        enumerable: false
+      });
+    }
+    const computeCacheKey = async (options = {}) => {
       const { action, params = {}, partition, partitionValues } = options;
       return this.generateCacheKey(resource, action, params, partition, partitionValues);
     };
 
+    resource.cacheKeyResolvers = resource.cacheKeyResolvers || {};
+    resource.cacheKeyResolvers[instanceKey] = computeCacheKey;
+
+    if (!resource.cacheKeyFor) {
+      resource.cacheKeyFor = computeCacheKey;
+    }
+
+    if (typeof resource.getCacheKeyResolver !== 'function') {
+      Object.defineProperty(resource, 'getCacheKeyResolver', {
+        value: (name = null) => {
+          if (!name) return resource.cacheKeyFor;
+          return resource.cacheKeyResolvers?.[name] || null;
+        },
+        writable: true,
+        configurable: true,
+        enumerable: false
+      });
+    }
+
     // Add partition-aware methods if using PartitionAwareFilesystemCache
     if (this.driver instanceof PartitionAwareFilesystemCache) {
       resource.clearPartitionCache = async (partition, partitionValues = {}) => {
@@ -272,6 +371,7 @@ export class CachePlugin extends Plugin {
     
     for (const method of cacheMethods) {
       resource.useMiddleware(method, async (ctx, next) => {
+        const resolveCacheKey = resource.cacheKeyResolvers?.[instanceKey] || computeCacheKey;
         // Check for skipCache option in the last argument
         let skipCache = false;
         const lastArg = ctx.args[ctx.args.length - 1];
@@ -287,17 +387,17 @@ export class CachePlugin extends Plugin {
         // Build cache key
         let key;
         if (method === 'getMany') {
-          key = await resource.cacheKeyFor({ action: method, params: { ids: ctx.args[0] } });
+          key = await resolveCacheKey({ action: method, params: { ids: ctx.args[0] } });
         } else if (method === 'page') {
           const { offset, size, partition, partitionValues } = ctx.args[0] || {};
-          key = await resource.cacheKeyFor({ action: method, params: { offset, size }, partition, partitionValues });
+          key = await resolveCacheKey({ action: method, params: { offset, size }, partition, partitionValues });
         } else if (method === 'list' || method === 'listIds' || method === 'count') {
           const { partition, partitionValues } = ctx.args[0] || {};
-          key = await resource.cacheKeyFor({ action: method, partition, partitionValues });
+          key = await resolveCacheKey({ action: method, partition, partitionValues });
         } else if (method === 'query') {
           const filter = ctx.args[0] || {};
           const options = ctx.args[1] || {};
-          key = await resource.cacheKeyFor({
+          key = await resolveCacheKey({
             action: method,
             params: { filter, options: { limit: options.limit, offset: options.offset } },
             partition: options.partition,
@@ -305,16 +405,16 @@ export class CachePlugin extends Plugin {
           });
         } else if (method === 'getFromPartition') {
           const { id, partitionName, partitionValues } = ctx.args[0] || {};
-          key = await resource.cacheKeyFor({
+          key = await resolveCacheKey({
             action: method,
             params: { id, partitionName },
             partition: partitionName,
             partitionValues
           });
         } else if (method === 'getAll') {
-          key = await resource.cacheKeyFor({ action: method });
+          key = await resolveCacheKey({ action: method });
         } else if (['get', 'exists', 'content', 'hasContent'].includes(method)) {
-          key = await resource.cacheKeyFor({ action: method, params: { id: ctx.args[0] } });
+          key = await resolveCacheKey({ action: method, params: { id: ctx.args[0] } });
         }
         
         // Try cache with partition awareness
@@ -336,7 +436,7 @@ export class CachePlugin extends Plugin {
             partitionValues = pValues;
           }
           
-          const [ok, err, result] = await tryFn(() => resource.cache._get(key, {
+          const [ok, err, result] = await tryFn(() => driver._get(key, {
             resource: resource.name,
             action: method,
             partition,
@@ -358,7 +458,7 @@ export class CachePlugin extends Plugin {
 
           // Store with partition context
           this.stats.writes++;
-          await resource.cache._set(key, freshResult, {
+          await driver._set(key, freshResult, {
             resource: resource.name,
             action: method,
             partition,
@@ -368,7 +468,7 @@ export class CachePlugin extends Plugin {
           return freshResult;
         } else {
           // Standard cache behavior
-          const [ok, err, result] = await tryFn(() => resource.cache.get(key));
+          const [ok, err, result] = await tryFn(() => driver.get(key));
           if (ok && result !== null && result !== undefined) {
             this.stats.hits++;
             return result;
@@ -382,7 +482,7 @@ export class CachePlugin extends Plugin {
           this.stats.misses++;
           const freshResult = await next();
           this.stats.writes++;
-          await resource.cache.set(key, freshResult);
+          await driver.set(key, freshResult);
           return freshResult;
         }
       });
@@ -421,7 +521,8 @@ export class CachePlugin extends Plugin {
   }
 
   async clearCacheForResource(resource, data) {
-    if (!resource.cache) return; // Skip if no cache is available
+    const driver = this._getDriverForResource(resource);
+    if (!driver) return; // Skip if no cache is available
 
     const keyPrefix = `resource=${resource.name}`;
 
@@ -431,7 +532,7 @@ export class CachePlugin extends Plugin {
       const itemSpecificMethods = ['get', 'exists', 'content', 'hasContent'];
       for (const method of itemSpecificMethods) {
         const specificKey = await this.generateCacheKey(resource, method, { id: data.id });
-        const [ok, err] = await this.clearCacheWithRetry(resource.cache, specificKey);
+        const [ok, err] = await this.clearCacheWithRetry(driver, specificKey);
 
         if (!ok) {
           this.emit('plg:cache:clear-error', {
@@ -448,12 +549,12 @@ export class CachePlugin extends Plugin {
       }
       
       // Clear partition-specific caches if this resource has partitions
-      if (this.config.includePartitions === true && resource.config?.partitions && Object.keys(resource.config.partitions).length > 0) {
+      if (this.config.includePartitions === true && resource.$schema.partitions && Object.keys(resource.$schema.partitions).length > 0) {
         const partitionValues = this.getPartitionValues(data, resource);
         for (const [partitionName, values] of Object.entries(partitionValues)) {
           if (values && Object.keys(values).length > 0 && Object.values(values).some(v => v !== null && v !== undefined)) {
             const partitionKeyPrefix = join(keyPrefix, `partition=${partitionName}`);
-            const [ok, err] = await this.clearCacheWithRetry(resource.cache, partitionKeyPrefix);
+          const [ok, err] = await this.clearCacheWithRetry(driver, partitionKeyPrefix);
 
             if (!ok) {
               this.emit('plg:cache:clear-error', {
@@ -472,7 +573,7 @@ export class CachePlugin extends Plugin {
     }
 
     // Clear aggregate caches more broadly to ensure all variants are cleared
-    const [ok, err] = await this.clearCacheWithRetry(resource.cache, keyPrefix);
+    const [ok, err] = await this.clearCacheWithRetry(driver, keyPrefix);
 
     if (!ok) {
       this.emit('plg:cache:clear-error', {
@@ -489,8 +590,8 @@ export class CachePlugin extends Plugin {
       const aggregateMethods = ['count', 'list', 'listIds', 'getAll', 'page', 'query'];
       for (const method of aggregateMethods) {
         // Try multiple key patterns to ensure we catch all variations
-        await this.clearCacheWithRetry(resource.cache, `${keyPrefix}/action=${method}`);
-        await this.clearCacheWithRetry(resource.cache, `resource=${resource.name}/action=${method}`);
+        await this.clearCacheWithRetry(driver, `${keyPrefix}/action=${method}`);
+        await this.clearCacheWithRetry(driver, `resource=${resource.name}/action=${method}`);
       }
     }
   }
@@ -523,6 +624,14 @@ export class CachePlugin extends Plugin {
     return [false, lastError];
   }
 
+  _getDriverForResource(resource) {
+    const instanceKey = this.instanceName || this.slug;
+    if (resource?.cacheInstances && instanceKey && resource.cacheInstances[instanceKey]) {
+      return resource.cacheInstances[instanceKey];
+    }
+    return this.driver;
+  }
+
   async generateCacheKey(resource, action, params = {}, partition = null, partitionValues = null) {
     const keyParts = [
       `resource=${resource.name}`,
@@ -562,10 +671,15 @@ export class CachePlugin extends Plugin {
   async getCacheStats() {
     if (!this.driver) return null;
     
+    const driverStats = typeof this.driver.getStats === 'function'
+      ? this.driver.getStats()
+      : null;
+
     return {
       size: await this.driver.size(),
       keys: await this.driver.keys(),
-      driver: this.driver.constructor.name
+      driver: this.driver.constructor.name,
+      stats: driverStats
     };
   }
 
@@ -573,10 +687,11 @@ export class CachePlugin extends Plugin {
     if (!this.driver) return;
     
     for (const resource of Object.values(this.database.resources)) {
-      if (resource.cache) {
-        const keyPrefix = `resource=${resource.name}`;
-        await resource.cache.clear(keyPrefix);
-      }
+      const driver = this._getDriverForResource(resource);
+      if (!driver) continue;
+
+      const keyPrefix = `resource=${resource.name}`;
+      await driver.clear(keyPrefix);
     }
   }
 
@@ -596,7 +711,7 @@ export class CachePlugin extends Plugin {
 
     // Use partition-aware warming if available
     if (this.driver instanceof PartitionAwareFilesystemCache && resource.warmPartitionCache) {
-      const partitionNames = resource.config.partitions ? Object.keys(resource.config.partitions) : [];
+      const partitionNames = resource.$schema.partitions ? Object.keys(resource.$schema.partitions) : [];
       return await resource.warmPartitionCache(partitionNames, options);
     }
 
@@ -628,8 +743,8 @@ export class CachePlugin extends Plugin {
     }
 
     // Warm partition caches if enabled
-    if (includePartitions && resource.config.partitions && sampledRecords.length > 0) {
-      for (const [partitionName, partitionDef] of Object.entries(resource.config.partitions)) {
+    if (includePartitions && resource.$schema.partitions && sampledRecords.length > 0) {
+      for (const [partitionName, partitionDef] of Object.entries(resource.$schema.partitions)) {
         if (partitionDef.fields) {
           // Get unique partition values from sample
           const partitionValuesSet = new Set();
@@ -653,8 +768,8 @@ export class CachePlugin extends Plugin {
     return {
       resourceName,
       recordsSampled: sampledRecords.length,
-      partitionsWarmed: includePartitions && resource.config.partitions
-        ? Object.keys(resource.config.partitions).length
+      partitionsWarmed: includePartitions && resource.$schema.partitions
+        ? Object.keys(resource.$schema.partitions).length
         : 0
     };
   }

package/src/plugins/cloud-inventory/drivers/alibaba-driver.js

@@ -1,4 +1,5 @@
 import { BaseCloudDriver } from './base-driver.js';
+import { PluginError } from '../../../errors.js';
 
 /**
  * Production-ready Alibaba Cloud (Aliyun) inventory driver using @alicloud SDK.
@@ -57,7 +58,13 @@ export class AlibabaInventoryDriver extends BaseCloudDriver {
     this._accessKeySecret = credentials.accessKeySecret || process.env.ALIBABA_CLOUD_ACCESS_KEY_SECRET;
 
     if (!this._accessKeyId || !this._accessKeySecret) {
-      throw new Error('Alibaba Cloud AccessKeyId and AccessKeySecret are required. Provide via credentials or env vars.');
+      throw new PluginError('Alibaba Cloud AccessKeyId and AccessKeySecret are required. Provide via credentials or env vars.', {
+        pluginName: 'CloudInventoryPlugin',
+        operation: 'alibaba:initCredentials',
+        statusCode: 400,
+        retriable: false,
+        suggestion: 'Pass credentials.accessKeyId/accessKeySecret or set ALIBABA_CLOUD_ACCESS_KEY_ID / ALIBABA_CLOUD_ACCESS_KEY_SECRET environment variables.'
+      });
     }
 
     this.logger('info', 'Alibaba Cloud credentials initialized', {

package/src/plugins/cloud-inventory/drivers/aws-driver.js

@@ -87,7 +87,7 @@ import {
 } from '@aws-sdk/client-api-gateway';
 import {
   ApiGatewayV2Client,
-  paginateGetApis,
+  GetApisCommand,
   GetTagsCommand as GetAPIGatewayV2TagsCommand
 } from '@aws-sdk/client-apigatewayv2';
 import {
@@ -138,8 +138,8 @@ import {
 } from '@aws-sdk/client-sfn';
 import {
   EventBridgeClient,
-  paginateListEventBuses,
-  paginateListRules,
+  ListEventBusesCommand,
+  ListRulesCommand,
   ListTagsForResourceCommand as ListEventBridgeTagsCommand
 } from '@aws-sdk/client-eventbridge';
 import {
@@ -171,12 +171,12 @@ import {
 } from '@aws-sdk/client-acm';
 import {
   WAFClient,
-  paginateListWebACLs as paginateListWAFWebACLs,
+  ListWebACLsCommand as ListWAFWebACLsCommand,
   ListTagsForResourceCommand as ListWAFTagsCommand
 } from '@aws-sdk/client-waf';
 import {
   WAFV2Client,
-  paginateListWebACLs as paginateListWAFV2WebACLs,
+  ListWebACLsCommand as ListWAFV2WebACLsCommand,
   ListTagsForResourceCommand as ListWAFV2TagsCommand
 } from '@aws-sdk/client-wafv2';
 import {
@@ -287,9 +287,22 @@ function extractEc2Tags(instance) {
   return Object.keys(tags).length ? tags : null;
 }
 
+/**
+ * @typedef {Object} AwsClientMap
+ * @property {Map<string, any>} ec2
+ * @property {any} s3
+ * @property {Map<string, any>} rds
+ * @property {any} iam
+ * @property {Map<string, any>} lambda
+ * @property {any} sts
+ * @property {Map<string, any>} ecs
+ * @property {Map<string, any>} eks
+ */
+
 export class AwsInventoryDriver extends BaseCloudDriver {
   constructor(options = {}) {
     super({ ...options, driver: options.driver || 'aws' });
+    /** @type {AwsClientMap} */
     this._clients = {
       ec2: new Map(),
       s3: null,
@@ -952,9 +965,12 @@ export class AwsInventoryDriver extends BaseCloudDriver {
 
       // HTTP/WebSocket APIs (v2)
       const v2Client = this._getApiGatewayV2Client(region);
-      const v2Paginator = paginateGetApis({ client: v2Client }, {});
-      for await (const page of v2Paginator) {
-        const apis = page.Items || [];
+      let nextToken;
+      do {
+        const response = await v2Client.send(new GetApisCommand({ NextToken: nextToken }));
+        const apis = response.Items || [];
+        nextToken = response.NextToken;
+
         for (const api of apis) {
           const tags = await this._safeGetAPIGatewayV2Tags(v2Client, api.ApiId);
           const type = api.ProtocolType?.toLowerCase() || 'http';
@@ -970,7 +986,7 @@ export class AwsInventoryDriver extends BaseCloudDriver {
             configuration: sanitizeConfiguration(api)
           };
         }
-      }
+      } while (nextToken);
     }
   }
 
@@ -1197,9 +1213,12 @@ export class AwsInventoryDriver extends BaseCloudDriver {
       const client = this._getEventBridgeClient(region);
 
       // Event Buses
-      const busPaginator = paginateListEventBuses({ client }, {});
-      for await (const page of busPaginator) {
-        const buses = page.EventBuses || [];
+      let nextBusToken;
+      do {
+        const busResponse = await client.send(new ListEventBusesCommand({ NextToken: nextBusToken }));
+        const buses = busResponse.EventBuses || [];
+        nextBusToken = busResponse.NextToken;
+
         for (const bus of buses) {
           const tags = await this._safeListEventBridgeTags(client, bus.Arn);
           yield {
@@ -1214,12 +1233,15 @@ export class AwsInventoryDriver extends BaseCloudDriver {
             configuration: sanitizeConfiguration(bus)
           };
         }
-      }
+      } while (nextBusToken);
 
       // Rules
-      const rulePaginator = paginateListRules({ client }, {});
-      for await (const page of rulePaginator) {
-        const rules = page.Rules || [];
+      let nextRuleToken;
+      do {
+        const ruleResponse = await client.send(new ListRulesCommand({ NextToken: nextRuleToken }));
+        const rules = ruleResponse.Rules || [];
+        nextRuleToken = ruleResponse.NextToken;
+
         for (const rule of rules) {
           const tags = await this._safeListEventBridgeTags(client, rule.Arn);
           yield {
@@ -1234,7 +1256,7 @@ export class AwsInventoryDriver extends BaseCloudDriver {
             configuration: sanitizeConfiguration(rule)
           };
         }
-      }
+      } while (nextRuleToken);
     }
   }
 
@@ -1380,9 +1402,12 @@ export class AwsInventoryDriver extends BaseCloudDriver {
   async *_collectWAFResources() {
     // WAF Classic (global)
     const wafClient = this._getWafClient();
-    const classicPaginator = paginateListWAFWebACLs({ client: wafClient }, {});
-    for await (const page of classicPaginator) {
-      const webACLs = page.WebACLs || [];
+    let nextMarker;
+    do {
+      const response = await wafClient.send(new ListWAFWebACLsCommand({ NextMarker: nextMarker }));
+      const webACLs = response.WebACLs || [];
+      nextMarker = response.NextMarker;
+
       for (const acl of webACLs) {
         const tags = await this._safeListWAFTags(wafClient, acl.WebACLId);
         yield {
@@ -1397,7 +1422,7 @@ export class AwsInventoryDriver extends BaseCloudDriver {
           configuration: sanitizeConfiguration(acl)
         };
       }
-    }
+    } while (nextMarker);
   }
 
   async *_collectWAFV2Resources() {
@@ -1405,9 +1430,12 @@ export class AwsInventoryDriver extends BaseCloudDriver {
       const client = this._getWafv2Client(region);
 
       // Regional WebACLs
-      const regionalPaginator = paginateListWAFV2WebACLs({ client }, { Scope: 'REGIONAL' });
-      for await (const page of regionalPaginator) {
-        const webACLs = page.WebACLs || [];
+      let nextMarker;
+      do {
+        const response = await client.send(new ListWAFV2WebACLsCommand({ Scope: 'REGIONAL', NextMarker: nextMarker }));
+        const webACLs = response.WebACLs || [];
+        nextMarker = response.NextMarker;
+
         for (const acl of webACLs) {
           const tags = await this._safeListWAFV2Tags(client, acl.ARN);
           yield {
@@ -1422,14 +1450,17 @@ export class AwsInventoryDriver extends BaseCloudDriver {
             configuration: sanitizeConfiguration(acl)
           };
         }
-      }
+      } while (nextMarker);
     }
 
     // CloudFront WebACLs (us-east-1 only)
     const cfClient = this._getWafv2Client(GLOBAL_REGION);
-    const cfPaginator = paginateListWAFV2WebACLs({ client: cfClient }, { Scope: 'CLOUDFRONT' });
-    for await (const page of cfPaginator) {
-      const webACLs = page.WebACLs || [];
+    let cfNextMarker;
+    do {
+      const cfResponse = await cfClient.send(new ListWAFV2WebACLsCommand({ Scope: 'CLOUDFRONT', NextMarker: cfNextMarker }));
+      const webACLs = cfResponse.WebACLs || [];
+      cfNextMarker = cfResponse.NextMarker;
+
       for (const acl of webACLs) {
         const tags = await this._safeListWAFV2Tags(cfClient, acl.ARN);
         yield {
@@ -1444,7 +1475,7 @@ export class AwsInventoryDriver extends BaseCloudDriver {
           configuration: sanitizeConfiguration(acl)
         };
       }
-    }
+    } while (cfNextMarker);
   }
 
   async *_collectCognitoUserPools() {

package/src/plugins/cloud-inventory/drivers/azure-driver.js

@@ -1,4 +1,5 @@
 import { BaseCloudDriver } from './base-driver.js';
+import { PluginError } from '../../../errors.js';
 
 /**
  * Production-ready Microsoft Azure inventory driver using official @azure SDK.
@@ -69,7 +70,13 @@ export class AzureInventoryDriver extends BaseCloudDriver {
     this._subscriptionId = credentials.subscriptionId || this.config?.subscriptionId;
 
     if (!this._subscriptionId) {
-      throw new Error('Azure subscription ID is required. Provide via credentials.subscriptionId or config.subscriptionId.');
+      throw new PluginError('Azure subscription ID is required. Provide via credentials.subscriptionId or config.subscriptionId.', {
+        pluginName: 'CloudInventoryPlugin',
+        operation: 'azure:initCredential',
+        statusCode: 400,
+        retriable: false,
+        suggestion: 'Set credentials.subscriptionId or config.subscriptionId before initializing the Azure inventory driver.'
+      });
     }
 
     this.logger('info', 'Azure credential initialized', {