feat: improved jsdoc and also introduced a new public method

Author: Gmin2

packages/node-core/src/indexer/dynamic-ds.service.ts

@@ -28,6 +28,7 @@ export interface IDynamicDsService<DS> {
   destroyDynamicDatasource(templateName: string, currentBlockHeight: number, index: number): Promise<void>;
   getDynamicDatasources(forceReload?: boolean): Promise<DS[]>;
   getDynamicDatasourcesByTemplate(templateName: string): DynamicDatasourceInfo[];
+  getDatasourceParamByIndex(index: number): DatasourceParams | undefined;
 }
 
 @Injectable()
@@ -94,6 +95,14 @@ export class DynamicDsService<DS extends BaseDataSource = BaseDataSource, P exte
     }
   }
 
+  /**
+   * Get all active (non-destroyed) dynamic datasources for a specific template.
+   *
+   * @param templateName - The name of the template to filter by
+   * @returns Array of datasource info objects with global indices. The `index` field
+   *          represents the global position in the internal datasource array and should
+   *          be used when calling `destroyDynamicDatasource()`.
+   */
   getDynamicDatasourcesByTemplate(templateName: string): DynamicDatasourceInfo[] {
     if (!this._datasourceParams) {
       throw new Error('DynamicDsService has not been initialized');
@@ -112,6 +121,19 @@ export class DynamicDsService<DS extends BaseDataSource = BaseDataSource, P exte
     }));
   }
 
+  /**
+   * Get datasource parameters by global index.
+   *
+   * @param index - Global index in the internal datasource parameters array
+   * @returns DatasourceParams if found, undefined otherwise
+   */
+  getDatasourceParamByIndex(index: number): DatasourceParams | undefined {
+    if (!this._datasourceParams || index < 0 || index >= this._datasourceParams.length) {
+      return undefined;
+    }
+    return this._datasourceParams[index];
+  }
+
   async destroyDynamicDatasource(
     templateName: string,
     currentBlockHeight: number,
@@ -143,13 +165,17 @@ export class DynamicDsService<DS extends BaseDataSource = BaseDataSource, P exte
       throw new Error(`Dynamic datasource at index ${index} is already destroyed`);
     }
 
-    // Update the datasource
+    // Update the datasource params
     const updatedParams = {...dsParam, endBlock: currentBlockHeight};
     this._datasourceParams[index] = updatedParams;
 
-    if (this._datasources[index]) {
-      (this._datasources[index] as any).endBlock = currentBlockHeight;
+    // Update the datasource object if it exists
+    // Note: _datasources and _datasourceParams arrays should always be in sync.
+    // If the index is valid for params, it must also be valid for datasources.
+    if (!this._datasources[index]) {
+      throw new Error(`Datasources array out of sync with params at index ${index}`);
     }
+    (this._datasources[index] as any).endBlock = currentBlockHeight;
 
     await this.metadata.set(METADATA_KEY, this._datasourceParams, tx);
 

packages/node-core/src/indexer/indexer.manager.ts

@@ -127,12 +127,21 @@ export abstract class BaseIndexerManager<
 
           // Remove the destroyed datasource from current processing
           // The datasource at the global index now has an endBlock set
-          const destroyedDsParam = (this.dynamicDsService as any)._datasourceParams[index];
+          const destroyedDsParam = this.dynamicDsService.getDatasourceParamByIndex(index);
+
+          if (!destroyedDsParam) {
+            logger.warn(`Unable to filter destroyed datasource at index ${index} - params not found`);
+            return;
+          }
 
           // Filter out the destroyed datasource by matching startBlock and args
+          // Note: Reassigning filteredDataSources is intentional - subsequent handlers
+          // within the same block will see the updated filtered list
           filteredDataSources = filteredDataSources.filter((fds) => {
             const fdsStartBlock = (fds as any).startBlock;
-            const fdsArgs = JSON.stringify((fds as any).options || {});
+            // For custom datasources, args are stored in processor.options
+            // For runtime datasources, they may be stored differently
+            const fdsArgs = JSON.stringify((fds as any).processor?.options || (fds as any).options || {});
             const paramArgs = JSON.stringify(destroyedDsParam.args || {});
 
             // Keep datasource if it doesn't match the destroyed one

packages/types-core/src/interfaces.ts

@@ -4,15 +4,26 @@
 export type DynamicDatasourceCreator = (name: string, args: Record<string, unknown>) => Promise<void>;
 export type DynamicDatasourceDestructor = (name: string, index: number) => Promise<void>;
 
+/**
+ * Information about a dynamic datasource instance.
+ */
 export interface DynamicDatasourceInfo {
+  /**
+   * Global index of the datasource in the internal storage array.
+   * Use this value when calling destroyDynamicDatasource().
+   */
   index: number;
+  /** Template name this datasource was created from */
   templateName: string;
+  /** Block height where this datasource starts processing */
   startBlock: number;
+  /** Block height where this datasource stops processing (if destroyed) */
   endBlock?: number;
+  /** Arguments passed when creating this datasource */
   args?: Record<string, unknown>;
 }
 
-export type DynamicDatasourceGetter = (templateName: string) => Promise<DynamicDatasourceInfo[]>;
+export type DynamicDatasourceGetter = (templateName: string) => DynamicDatasourceInfo[];
 
 export interface Cache<T extends Record<string, any> = Record<string, any>> {
   set(key: keyof T, value: T[keyof T]): Promise<void>;