s3db.js 13.6.1 → 14.0.2

package/src/plugins/costs.plugin.js

@@ -396,7 +396,13 @@
  *   const hourlyCost = currentCosts - hourStartCosts;
  *
  *   if (hourlyCost > HOURLY_COST_LIMIT) {
- *     throw new Error('Hourly cost limit exceeded');
+ *     throw new PluginError('Hourly cost limit exceeded', {
+ *       pluginName: 'CostsPlugin',
+ *       operation: 'rateLimiter',
+ *       statusCode: 429,
+ *       retriable: true,
+ *       suggestion: 'Delay the operation until costs fall below the configured threshold.'
+ *     });
  *   }
  *
  *   // Proceed with operation

package/src/plugins/eventual-consistency/analytics.js

@@ -5,6 +5,7 @@
 
 import tryFn from "../../concerns/try-fn.js";
 import { groupByCohort, ensureCohortHours } from "./utils.js";
+import { PluginError, AnalyticsNotEnabledError } from '../../errors.js';
 
 /**
  * Update analytics with consolidated transactions
@@ -20,13 +21,19 @@ export async function updateAnalytics(transactions, analyticsResource, config) {
   // CRITICAL VALIDATION: Ensure field is set in config
   // This can be undefined due to race conditions when multiple handlers share config
   if (!config.field) {
-    throw new Error(
-      `[EventualConsistency] CRITICAL BUG: config.field is undefined in updateAnalytics()!\n` +
-      `This indicates a race condition in the plugin where multiple handlers are sharing the same config object.\n` +
-      `Config: ${JSON.stringify({ resource: config.resource, field: config.field })}\n` +
-      `Transactions count: ${transactions.length}\n` +
-      `AnalyticsResource: ${analyticsResource?.name || 'unknown'}`
-    );
+    throw new PluginError('config.field is undefined in updateAnalytics()', {
+      pluginName: 'EventualConsistencyPlugin',
+      operation: 'updateAnalytics',
+      statusCode: 500,
+      retriable: false,
+      suggestion: 'Ensure each field handler uses its own configuration object when invoking analytics updates.',
+      context: {
+        resource: config.resource,
+        field: config.field,
+        transactions: transactions.length,
+        analyticsResource: analyticsResource?.name || 'unknown'
+      }
+    });
   }
 
   if (config.verbose) {
@@ -93,9 +100,16 @@ export async function updateAnalytics(transactions, analyticsResource, config) {
       }
     );
     // Re-throw to prevent silent failures
-    throw new Error(
-      `Analytics update failed for ${config.resource}.${config.field}: ${error.message}`
-    );
+    throw new PluginError(`Analytics update failed for ${config.resource}.${config.field}: ${error.message}`, {
+      pluginName: 'EventualConsistencyPlugin',
+      operation: 'updateAnalytics',
+      statusCode: 500,
+      retriable: true,
+      suggestion: 'Check the console logs above for the failing transaction and fix the reducer or analytics configuration.',
+      resource: config.resource,
+      field: config.field,
+      original: error
+    });
   }
 }
 
@@ -447,16 +461,31 @@ export async function getAnalytics(resourceName, field, options, fieldHandlers)
   // Get handler for this resource/field combination
   const resourceHandlers = fieldHandlers.get(resourceName);
   if (!resourceHandlers) {
-    throw new Error(`No eventual consistency configured for resource: ${resourceName}`);
+    throw new PluginError(`No eventual consistency configured for resource: ${resourceName}`, {
+      pluginName: 'EventualConsistencyPlugin',
+      operation: 'getAnalytics',
+      statusCode: 404,
+      retriable: false,
+      suggestion: 'Ensure the resource is registered under EventualConsistencyPlugin resources.',
+      resourceName
+    });
   }
 
   const handler = resourceHandlers.get(field);
   if (!handler) {
-    throw new Error(`No eventual consistency configured for field: ${resourceName}.${field}`);
+    throw new PluginError(`No eventual consistency configured for field: ${resourceName}.${field}`, {
+      pluginName: 'EventualConsistencyPlugin',
+      operation: 'getAnalytics',
+      statusCode: 404,
+      retriable: false,
+      suggestion: 'Add the field to EventualConsistencyPlugin resources configuration.',
+      resourceName,
+      field
+    });
   }
 
   if (!handler.analyticsResource) {
-    throw new Error('Analytics not enabled for this plugin');
+    throw new AnalyticsNotEnabledError({ resourceName, field, pluginName: 'EventualConsistencyPlugin' });
   }
 
   const { period = 'day', date, startDate, endDate, month, year, breakdown = false, recordId } = options;
@@ -898,16 +927,39 @@ export async function getTopRecords(resourceName, field, options, fieldHandlers)
   // Get handler for this resource/field combination
   const resourceHandlers = fieldHandlers.get(resourceName);
   if (!resourceHandlers) {
-    throw new Error(`No eventual consistency configured for resource: ${resourceName}`);
+    throw new PluginError(`No eventual consistency configured for resource: ${resourceName}`, {
+      pluginName: 'EventualConsistencyPlugin',
+      operation: 'getTopRecords',
+      statusCode: 404,
+      retriable: false,
+      suggestion: 'Add the resource to EventualConsistencyPlugin resources configuration.',
+      resourceName
+    });
   }
 
   const handler = resourceHandlers.get(field);
   if (!handler) {
-    throw new Error(`No eventual consistency configured for field: ${resourceName}.${field}`);
+    throw new PluginError(`No eventual consistency configured for field: ${resourceName}.${field}`, {
+      pluginName: 'EventualConsistencyPlugin',
+      operation: 'getTopRecords',
+      statusCode: 404,
+      retriable: false,
+      suggestion: 'Ensure the field is configured for eventual consistency before querying analytics.',
+      resourceName,
+      field
+    });
   }
 
   if (!handler.transactionResource) {
-    throw new Error('Transaction resource not initialized');
+    throw new PluginError('Transaction resource not initialized', {
+      pluginName: 'EventualConsistencyPlugin',
+      operation: 'getTopRecords',
+      statusCode: 500,
+      retriable: false,
+      suggestion: 'Verify plugin installation completed successfully and transaction resources were created.',
+      resourceName,
+      field
+    });
   }
 
   const { period = 'day', date, metric = 'transactionCount', limit = 10 } = options;
@@ -1254,16 +1306,39 @@ export async function getRawEvents(resourceName, field, options, fieldHandlers)
   // Get handler for this resource/field combination
   const resourceHandlers = fieldHandlers.get(resourceName);
   if (!resourceHandlers) {
-    throw new Error(`No eventual consistency configured for resource: ${resourceName}`);
+    throw new PluginError(`No eventual consistency configured for resource: ${resourceName}`, {
+      pluginName: 'EventualConsistencyPlugin',
+      operation: 'getRawEvents',
+      statusCode: 404,
+      retriable: false,
+      suggestion: 'Add the resource under EventualConsistencyPlugin configuration to retrieve raw events.',
+      resourceName
+    });
   }
 
   const handler = resourceHandlers.get(field);
   if (!handler) {
-    throw new Error(`No eventual consistency configured for field: ${resourceName}.${field}`);
+    throw new PluginError(`No eventual consistency configured for field: ${resourceName}.${field}`, {
+      pluginName: 'EventualConsistencyPlugin',
+      operation: 'getRawEvents',
+      statusCode: 404,
+      retriable: false,
+      suggestion: 'Ensure the field is included in EventualConsistencyPlugin configuration.',
+      resourceName,
+      field
+    });
   }
 
   if (!handler.transactionResource) {
-    throw new Error('Transaction resource not initialized');
+    throw new PluginError('Transaction resource not initialized', {
+      pluginName: 'EventualConsistencyPlugin',
+      operation: 'getRawEvents',
+      statusCode: 500,
+      retriable: false,
+      suggestion: 'Verify plugin installation completed successfully and transaction resources were created.',
+      resourceName,
+      field
+    });
   }
 
   const {

package/src/plugins/eventual-consistency/config.js

@@ -2,6 +2,7 @@
  * Configuration handling for EventualConsistencyPlugin
  * @module eventual-consistency/config
  */
+import { PluginError } from '../../errors.js';
 
 /**
  * Create default configuration with options
@@ -96,17 +97,24 @@ export function createConfig(options, detectedTimezone) {
  */
 export function validateResourcesConfig(resources) {
   if (!resources || typeof resources !== 'object') {
-    throw new Error(
-      "EventualConsistencyPlugin requires 'resources' option.\n" +
-      "Example: { resources: { urls: ['clicks', 'views'], posts: ['likes'] } }"
-    );
+    throw new PluginError("EventualConsistencyPlugin requires a 'resources' option", {
+      pluginName: 'EventualConsistencyPlugin',
+      operation: 'validateResourcesConfig',
+      statusCode: 400,
+      retriable: false,
+      suggestion: "Provide resources configuration, e.g., { resources: { urls: ['clicks', 'views'] } }"
+    });
   }
 
   for (const [resourceName, fields] of Object.entries(resources)) {
     if (!Array.isArray(fields)) {
-      throw new Error(
-        `EventualConsistencyPlugin resources.${resourceName} must be an array of field names`
-      );
+      throw new PluginError(`EventualConsistencyPlugin resources.${resourceName} must be an array of field names`, {
+        pluginName: 'EventualConsistencyPlugin',
+        operation: 'validateResourcesConfig',
+        statusCode: 400,
+        retriable: false,
+        suggestion: 'Ensure each resource entry maps to an array of field names (e.g., resources.users = ["logins", "visits"]).'
+      });
     }
   }
 }

package/src/plugins/eventual-consistency/consolidation.js

@@ -7,6 +7,7 @@ import tryFn from "../../concerns/try-fn.js";
 import { PromisePool } from "@supercharge/promise-pool";
 import { idGenerator } from "../../concerns/id.js";
 import { getCohortInfo, createSyntheticSetTransaction, ensureCohortHour } from "./utils.js";
+import { PluginError } from '../../errors.js';
 
 /**
  * Start consolidation timer for a handler
@@ -696,12 +697,17 @@ export async function consolidateRecord(
     return consolidatedValue;
   } finally {
     // Always release the lock
-    const [lockReleased, lockReleaseErr] = await tryFn(() =>
-      storage.releaseLock(lockKey)
-    );
+    if (lock) {
+      const [lockReleased, lockReleaseErr] = await tryFn(() =>
+        storage.releaseLock(lock)
+      );
 
-    if (!lockReleased && config.verbose) {
-      console.warn(`[EventualConsistency] Failed to release lock ${lockKey}:`, lockReleaseErr?.message);
+      if (!lockReleased && config.verbose) {
+        console.warn(
+          `[EventualConsistency] Failed to release lock ${lock?.name || lockKey}:`,
+          lockReleaseErr?.message
+        );
+      }
     }
   }
 }
@@ -853,7 +859,14 @@ export async function recalculateRecord(
     if (config.verbose) {
       console.log(`[EventualConsistency] Recalculate lock for ${originalId} already held, skipping`);
     }
-    throw new Error(`Cannot recalculate ${originalId}: lock already held by another worker`);
+    throw new PluginError(`Cannot recalculate ${originalId}: lock already held by another worker`, {
+      pluginName: 'EventualConsistencyPlugin',
+      operation: 'recalculateRecord',
+      statusCode: 409,
+      retriable: true,
+      suggestion: 'Retry after the other worker releases the lock or increase lock TTL if necessary.',
+      recordId: originalId
+    });
   }
 
   try {
@@ -997,12 +1010,17 @@ export async function recalculateRecord(
     return consolidatedValue;
   } finally {
     // Always release the lock
-    const [lockReleased, lockReleaseErr] = await tryFn(() =>
-      storage.releaseLock(lockKey)
-    );
+    if (lock) {
+      const [lockReleased, lockReleaseErr] = await tryFn(() =>
+        storage.releaseLock(lock)
+      );
 
-    if (!lockReleased && config.verbose) {
-      console.warn(`[EventualConsistency] Failed to release recalculate lock ${lockKey}:`, lockReleaseErr?.message);
+      if (!lockReleased && config.verbose) {
+        console.warn(
+          `[EventualConsistency] Failed to release recalculate lock ${lock?.name || lockKey}:`,
+          lockReleaseErr?.message
+        );
+      }
     }
   }
 }

package/src/plugins/eventual-consistency/garbage-collection.js

@@ -119,6 +119,8 @@ export async function runGarbageCollection(transactionResource, storage, config,
     }
   } finally {
     // Always release GC lock
-    await tryFn(() => storage.releaseLock(lockKey));
+    if (lock) {
+      await tryFn(() => storage.releaseLock(lock));
+    }
   }
 }

package/src/plugins/eventual-consistency/helpers.js

@@ -6,6 +6,7 @@
 import { idGenerator } from "../../concerns/id.js";
 import tryFn from "../../concerns/try-fn.js";
 import { getCohortInfo, resolveFieldAndPlugin } from "./utils.js";
+import { PluginError } from '../../errors.js';
 
 /**
  * Add helper methods to resources
@@ -155,17 +156,27 @@ export function addHelperMethods(resource, plugin, config) {
   // Signature: consolidate(id, field)
   resource.consolidate = async (id, field) => {
     if (!field) {
-      throw new Error(`Field parameter is required: consolidate(id, field)`);
+      throw new PluginError('Field parameter is required: consolidate(id, field)', {
+        pluginName: 'EventualConsistencyPlugin',
+        operation: 'resource.consolidate',
+        statusCode: 400,
+        retriable: false,
+        suggestion: 'Invoke consolidate with both id and field parameters.'
+      });
     }
 
     const handler = resource._eventualConsistencyPlugins[field];
 
     if (!handler) {
       const availableFields = Object.keys(resource._eventualConsistencyPlugins).join(', ');
-      throw new Error(
-        `No eventual consistency plugin found for field "${field}". ` +
-        `Available fields: ${availableFields}`
-      );
+      throw new PluginError(`No eventual consistency plugin found for field "${field}"`, {
+        pluginName: 'EventualConsistencyPlugin',
+        operation: 'resource.consolidate',
+        statusCode: 404,
+        retriable: false,
+        suggestion: `Available fields: ${availableFields}`,
+        field
+      });
     }
 
     return await plugin._consolidateWithHandler(handler, id);
@@ -178,10 +189,14 @@ export function addHelperMethods(resource, plugin, config) {
 
     if (!handler) {
       const availableFields = Object.keys(resource._eventualConsistencyPlugins).join(', ');
-      throw new Error(
-        `No eventual consistency plugin found for field "${field}". ` +
-        `Available fields: ${availableFields}`
-      );
+      throw new PluginError(`No eventual consistency plugin found for field "${field}"`, {
+        pluginName: 'EventualConsistencyPlugin',
+        operation: 'resource.getConsolidatedValue',
+        statusCode: 404,
+        retriable: false,
+        suggestion: `Available fields: ${availableFields}`,
+        field
+      });
     }
 
     return await plugin._getConsolidatedValueWithHandler(handler, id, options);
@@ -191,17 +206,27 @@ export function addHelperMethods(resource, plugin, config) {
   // Signature: recalculate(id, field)
   resource.recalculate = async (id, field) => {
     if (!field) {
-      throw new Error(`Field parameter is required: recalculate(id, field)`);
+      throw new PluginError('Field parameter is required: recalculate(id, field)', {
+        pluginName: 'EventualConsistencyPlugin',
+        operation: 'resource.recalculate',
+        statusCode: 400,
+        retriable: false,
+        suggestion: 'Invoke recalculate with both id and field parameters.'
+      });
     }
 
     const handler = resource._eventualConsistencyPlugins[field];
 
     if (!handler) {
       const availableFields = Object.keys(resource._eventualConsistencyPlugins).join(', ');
-      throw new Error(
-        `No eventual consistency plugin found for field "${field}". ` +
-        `Available fields: ${availableFields}`
-      );
+      throw new PluginError(`No eventual consistency plugin found for field "${field}"`, {
+        pluginName: 'EventualConsistencyPlugin',
+        operation: 'resource.recalculate',
+        statusCode: 404,
+        retriable: false,
+        suggestion: `Available fields: ${availableFields}`,
+        field
+      });
     }
 
     return await plugin._recalculateWithHandler(handler, id);

package/src/plugins/eventual-consistency/install.js

@@ -9,6 +9,7 @@ import { addHelperMethods } from "./helpers.js";
 import { flushPendingTransactions } from "./transactions.js";
 import { startConsolidationTimer } from "./consolidation.js";
 import { startGarbageCollectionTimer } from "./garbage-collection.js";
+import { PluginError } from '../../errors.js';
 
 /**
  * Install plugin for all configured resources
@@ -115,7 +116,16 @@ export async function completeFieldSetup(handler, database, config, plugin) {
   );
 
   if (!ok && !database.resources[transactionResourceName]) {
-    throw new Error(`Failed to create transaction resource for ${resourceName}.${fieldName}: ${err?.message}`);
+    throw new PluginError(`Failed to create transaction resource for ${resourceName}.${fieldName}`, {
+      pluginName: 'EventualConsistencyPlugin',
+      operation: 'createTransactionResource',
+      statusCode: 500,
+      retriable: false,
+      suggestion: 'Verify database permissions and configuration for creating plugin resources.',
+      resourceName,
+      fieldName,
+      original: err
+    });
   }
 
   handler.transactionResource = ok ? transactionResource : database.resources[transactionResourceName];
@@ -200,7 +210,16 @@ async function createAnalyticsResource(handler, database, resourceName, fieldNam
   );
 
   if (!ok && !database.resources[analyticsResourceName]) {
-    throw new Error(`Failed to create analytics resource for ${resourceName}.${fieldName}: ${err?.message}`);
+    throw new PluginError(`Failed to create analytics resource for ${resourceName}.${fieldName}`, {
+      pluginName: 'EventualConsistencyPlugin',
+      operation: 'createAnalyticsResource',
+      statusCode: 500,
+      retriable: false,
+      suggestion: 'Verify database permissions and configuration for creating analytics resources.',
+      resourceName,
+      fieldName,
+      original: err
+    });
   }
 
   handler.analyticsResource = ok ? analyticsResource : database.resources[analyticsResourceName];

package/src/plugins/eventual-consistency/utils.js

@@ -1,3 +1,5 @@
+import { PluginError } from '../../errors.js';
+
 /**
  * Utility functions for EventualConsistencyPlugin
  * @module eventual-consistency/utils
@@ -291,7 +293,13 @@ export function validateNestedPath(resource, fieldPath) {
  */
 export function resolveFieldAndPlugin(resource, field, value) {
   if (!resource._eventualConsistencyPlugins) {
-    throw new Error(`No eventual consistency plugins configured for this resource`);
+    throw new PluginError('No eventual consistency plugins configured for this resource', {
+      pluginName: 'EventualConsistencyPlugin',
+      operation: 'resolveFieldAndPlugin',
+      statusCode: 404,
+      retriable: false,
+      suggestion: 'Configure EventualConsistencyPlugin resources before using helper methods.'
+    });
   }
 
   // Check if field contains dot notation (nested path)
@@ -299,7 +307,13 @@ export function resolveFieldAndPlugin(resource, field, value) {
     const validation = validateNestedPath(resource, field);
 
     if (!validation.valid) {
-      throw new Error(validation.error);
+      throw new PluginError(validation.error, {
+        pluginName: 'EventualConsistencyPlugin',
+        operation: 'resolveFieldAndPlugin',
+        statusCode: 400,
+        retriable: false,
+        suggestion: 'Ensure nested field paths exist on the resource before using dot notation.'
+      });
     }
 
     // Get plugin for root field
@@ -308,10 +322,14 @@ export function resolveFieldAndPlugin(resource, field, value) {
 
     if (!fieldPlugin) {
       const availableFields = Object.keys(resource._eventualConsistencyPlugins).join(', ');
-      throw new Error(
-        `No eventual consistency plugin found for root field "${rootField}". ` +
-        `Available fields: ${availableFields}`
-      );
+      throw new PluginError(`No eventual consistency plugin found for root field "${rootField}"`, {
+        pluginName: 'EventualConsistencyPlugin',
+        operation: 'resolveFieldAndPlugin',
+        statusCode: 404,
+        retriable: false,
+        suggestion: `Available fields: ${availableFields}`,
+        field: rootField
+      });
     }
 
     return {
@@ -327,10 +345,14 @@ export function resolveFieldAndPlugin(resource, field, value) {
 
   if (!fieldPlugin) {
     const availableFields = Object.keys(resource._eventualConsistencyPlugins).join(', ');
-    throw new Error(
-      `No eventual consistency plugin found for field "${field}". ` +
-      `Available fields: ${availableFields}`
-    );
+    throw new PluginError(`No eventual consistency plugin found for field "${field}"`, {
+      pluginName: 'EventualConsistencyPlugin',
+      operation: 'resolveFieldAndPlugin',
+      statusCode: 404,
+      retriable: false,
+      suggestion: `Available fields: ${availableFields}`,
+      field
+    });
   }
 
   return { field, fieldPath: field, value, plugin: fieldPlugin };

package/src/plugins/fulltext.plugin.js

@@ -485,11 +485,18 @@
 import { Plugin } from "./plugin.class.js";
 import tryFn from "../concerns/try-fn.js";
 import { FulltextError } from "./fulltext.errors.js";
+import { resolveResourceName } from "./concerns/resource-names.js";
 
 export class FullTextPlugin extends Plugin {
   constructor(options = {}) {
-    super();
+    super(options);
     this.indexResource = null;
+    const resourceNamesOption = options.resourceNames || {};
+    this._indexResourceDescriptor = {
+      defaultName: 'plg_fulltext_indexes',
+      override: resourceNamesOption.index || options.indexResource
+    };
+    this.indexResourceName = this._resolveIndexResourceName();
     this.config = {
       minWordLength: options.minWordLength || 3,
       maxResults: options.maxResults || 100,
@@ -500,11 +507,21 @@ export class FullTextPlugin extends Plugin {
     this.deletedIndexes = new Set(); // Track deleted index keys
   }
 
+  _resolveIndexResourceName() {
+    return resolveResourceName('fulltext', this._indexResourceDescriptor, {
+      namespace: this.namespace
+    });
+  }
+
+  onNamespaceChanged() {
+    this.indexResourceName = this._resolveIndexResourceName();
+  }
+
   async onInstall() {
     
     // Create index resource if it doesn't exist
     const [ok, err, indexResource] = await tryFn(() => this.database.createResource({
-        name: 'plg_fulltext_indexes',
+        name: this.indexResourceName,
         attributes: {
           id: 'string|required',
           resourceName: 'string|required',
@@ -519,7 +536,13 @@ export class FullTextPlugin extends Plugin {
         },
         behavior: 'body-overflow'
       }));
-    this.indexResource = ok ? indexResource : this.database.resources.fulltext_indexes;
+    if (ok) {
+      this.indexResource = indexResource;
+    } else if (this.database.resources[this.indexResourceName]) {
+      this.indexResource = this.database.resources[this.indexResourceName];
+    } else {
+      throw err;
+    }
 
     // Load existing indexes
     await this.loadIndexes();
@@ -543,6 +566,10 @@ export class FullTextPlugin extends Plugin {
     this.removeDatabaseHooks();
   }
 
+  isInternalResource(name) {
+    return name === this.indexResourceName || name === 'plg_fulltext_indexes';
+  }
+
   async loadIndexes() {
     if (!this.indexResource) return;
     
@@ -631,7 +658,7 @@ export class FullTextPlugin extends Plugin {
   installDatabaseHooks() {
     // Use the new database hooks system for automatic resource discovery
     this.database.addHook('afterCreateResource', (resource) => {
-      if (resource.name !== 'plg_fulltext_indexes') {
+      if (!this.isInternalResource(resource.name)) {
         this.installResourceHooks(resource);
       }
     });
@@ -650,7 +677,7 @@ export class FullTextPlugin extends Plugin {
     this.database.plugins.fulltext = this;
 
     for (const resource of Object.values(this.database.resources)) {
-      if (resource.name === 'plg_fulltext_indexes') continue;
+      if (this.isInternalResource(resource.name)) continue;
       
       this.installResourceHooks(resource);
     }
@@ -661,9 +688,9 @@ export class FullTextPlugin extends Plugin {
       this.database._previousCreateResourceForFullText = this.database.createResource;
       this.database.createResource = async function (...args) {
         const resource = await this._previousCreateResourceForFullText(...args);
-        if (this.plugins?.fulltext && resource.name !== 'plg_fulltext_indexes') {
-          this.plugins.fulltext.installResourceHooks(resource);
-        }
+      if (this.plugins?.fulltext && !this.plugins.fulltext.isInternalResource(resource.name)) {
+        this.plugins.fulltext.installResourceHooks(resource);
+      }
         return resource;
       };
       this.database._fulltextProxyInstalled = true;
@@ -671,7 +698,7 @@ export class FullTextPlugin extends Plugin {
 
     // Ensure all existing resources have hooks (even if created before plugin setup)
     for (const resource of Object.values(this.database.resources)) {
-      if (resource.name !== 'plg_fulltext_indexes') {
+      if (!this.isInternalResource(resource.name)) {
         this.installResourceHooks(resource);
       }
     }
@@ -1009,7 +1036,7 @@ export class FullTextPlugin extends Plugin {
   }
 
   async _rebuildAllIndexesInternal() {
-    const resourceNames = Object.keys(this.database.resources).filter(name => name !== 'plg_fulltext_indexes');
+    const resourceNames = Object.keys(this.database.resources).filter(name => !this.isInternalResource(name));
     
     // Process resources sequentially to avoid overwhelming the system
     for (const resourceName of resourceNames) {
@@ -1038,4 +1065,4 @@ export class FullTextPlugin extends Plugin {
     // Save changes
     await this.saveIndexes();
   }
-} 
+}