chore: recovery checkpoint - v3.0 API successfully recovered
CRITICAL CHECKPOINT - DO NOT PUSH TO GITHUB Recovery Status: - Successfully recovered brainy.ts from compiled JavaScript - All core v3.0 API methods functional (add, get, update, delete, relate, find, etc.) - Neural subsystem intact (562KB embedded patterns, NLP working) - Augmentation pipeline operational (20+ augmentations) - HNSW clustering system complete - Triple Intelligence compiled (needs constructor fix) - Test suite validates functionality Changes preserved: - 898 files with changes from last 3 days - 144,475 insertions - All augmentation improvements - All test coverage enhancements - Complete v3.0 feature set This is a LOCAL checkpoint only - contains recovered work after corruption incident. Created backup in .backups/brainy-full-20250910-151314.tar.gz Branch: recovery-checkpoint-20250910-151433 Date: Wed Sep 10 03:18:04 PM PDT 2025
This commit is contained in:
parent
f65455fb22
commit
8ff382ca3b
895 changed files with 143654 additions and 28268 deletions
|
|
@ -0,0 +1,570 @@
|
|||
/**
|
||||
* Base Storage Adapter
|
||||
* Provides common functionality for all storage adapters
|
||||
*/
|
||||
import { BaseStorageAdapter } from './adapters/baseStorageAdapter.js';
|
||||
import { validateNounType, validateVerbType } from '../utils/typeValidation.js';
|
||||
// Common directory/prefix names
|
||||
// Option A: Entity-Based Directory Structure
|
||||
export const ENTITIES_DIR = 'entities';
|
||||
export const NOUNS_VECTOR_DIR = 'entities/nouns/vectors';
|
||||
export const NOUNS_METADATA_DIR = 'entities/nouns/metadata';
|
||||
export const VERBS_VECTOR_DIR = 'entities/verbs/vectors';
|
||||
export const VERBS_METADATA_DIR = 'entities/verbs/metadata';
|
||||
export const INDEXES_DIR = 'indexes';
|
||||
export const METADATA_INDEX_DIR = 'indexes/metadata';
|
||||
// Legacy paths - kept for backward compatibility during migration
|
||||
export const NOUNS_DIR = 'nouns'; // Legacy: now maps to entities/nouns/vectors
|
||||
export const VERBS_DIR = 'verbs'; // Legacy: now maps to entities/verbs/vectors
|
||||
export const METADATA_DIR = 'metadata'; // Legacy: now maps to entities/nouns/metadata
|
||||
export const NOUN_METADATA_DIR = 'noun-metadata'; // Legacy: now maps to entities/nouns/metadata
|
||||
export const VERB_METADATA_DIR = 'verb-metadata'; // Legacy: now maps to entities/verbs/metadata
|
||||
export const INDEX_DIR = 'index'; // Legacy - kept for backward compatibility
|
||||
export const SYSTEM_DIR = '_system'; // System config & metadata indexes
|
||||
export const STATISTICS_KEY = 'statistics';
|
||||
// Migration version to track compatibility
|
||||
export const STORAGE_SCHEMA_VERSION = 3; // v3: Entity-Based Directory Structure (Option A)
|
||||
// Configuration flag to enable new directory structure
|
||||
export const USE_ENTITY_BASED_STRUCTURE = true; // Set to true to use Option A structure
|
||||
/**
|
||||
* Get the appropriate directory path based on configuration
|
||||
*/
|
||||
export function getDirectoryPath(entityType, dataType) {
|
||||
if (USE_ENTITY_BASED_STRUCTURE) {
|
||||
// Option A: Entity-Based Structure
|
||||
if (entityType === 'noun') {
|
||||
return dataType === 'vector' ? NOUNS_VECTOR_DIR : NOUNS_METADATA_DIR;
|
||||
}
|
||||
else {
|
||||
return dataType === 'vector' ? VERBS_VECTOR_DIR : VERBS_METADATA_DIR;
|
||||
}
|
||||
}
|
||||
else {
|
||||
// Legacy structure
|
||||
if (entityType === 'noun') {
|
||||
return dataType === 'vector' ? NOUNS_DIR : METADATA_DIR;
|
||||
}
|
||||
else {
|
||||
return dataType === 'vector' ? VERBS_DIR : VERB_METADATA_DIR;
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Base storage adapter that implements common functionality
|
||||
* This is an abstract class that should be extended by specific storage adapters
|
||||
*/
|
||||
export class BaseStorage extends BaseStorageAdapter {
|
||||
constructor() {
|
||||
super(...arguments);
|
||||
this.isInitialized = false;
|
||||
this.readOnly = false;
|
||||
}
|
||||
/**
|
||||
* Ensure the storage adapter is initialized
|
||||
*/
|
||||
async ensureInitialized() {
|
||||
if (!this.isInitialized) {
|
||||
await this.init();
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Save a noun to storage
|
||||
*/
|
||||
async saveNoun(noun) {
|
||||
await this.ensureInitialized();
|
||||
// Validate noun type before saving - storage boundary protection
|
||||
const metadata = await this.getNounMetadata(noun.id);
|
||||
if (metadata?.noun) {
|
||||
validateNounType(metadata.noun);
|
||||
}
|
||||
return this.saveNoun_internal(noun);
|
||||
}
|
||||
/**
|
||||
* Get a noun from storage
|
||||
*/
|
||||
async getNoun(id) {
|
||||
await this.ensureInitialized();
|
||||
return this.getNoun_internal(id);
|
||||
}
|
||||
/**
|
||||
* Get nouns by noun type
|
||||
* @param nounType The noun type to filter by
|
||||
* @returns Promise that resolves to an array of nouns of the specified noun type
|
||||
*/
|
||||
async getNounsByNounType(nounType) {
|
||||
await this.ensureInitialized();
|
||||
return this.getNounsByNounType_internal(nounType);
|
||||
}
|
||||
/**
|
||||
* Delete a noun from storage
|
||||
*/
|
||||
async deleteNoun(id) {
|
||||
await this.ensureInitialized();
|
||||
return this.deleteNoun_internal(id);
|
||||
}
|
||||
/**
|
||||
* Save a verb to storage
|
||||
*/
|
||||
async saveVerb(verb) {
|
||||
await this.ensureInitialized();
|
||||
// Validate verb type before saving - storage boundary protection
|
||||
if (verb.verb) {
|
||||
validateVerbType(verb.verb);
|
||||
}
|
||||
// Extract the lightweight HNSWVerb data
|
||||
const hnswVerb = {
|
||||
id: verb.id,
|
||||
vector: verb.vector,
|
||||
connections: verb.connections || new Map()
|
||||
};
|
||||
// Extract and save the metadata separately
|
||||
const metadata = {
|
||||
sourceId: verb.sourceId || verb.source,
|
||||
targetId: verb.targetId || verb.target,
|
||||
source: verb.source || verb.sourceId,
|
||||
target: verb.target || verb.targetId,
|
||||
type: verb.type || verb.verb,
|
||||
verb: verb.verb || verb.type,
|
||||
weight: verb.weight,
|
||||
metadata: verb.metadata,
|
||||
data: verb.data,
|
||||
createdAt: verb.createdAt,
|
||||
updatedAt: verb.updatedAt,
|
||||
createdBy: verb.createdBy,
|
||||
embedding: verb.embedding
|
||||
};
|
||||
// Save both the HNSWVerb and metadata atomically
|
||||
try {
|
||||
console.log(`[DEBUG] Saving verb ${verb.id}: sourceId=${verb.sourceId}, targetId=${verb.targetId}`);
|
||||
// Save the HNSWVerb first
|
||||
await this.saveVerb_internal(hnswVerb);
|
||||
console.log(`[DEBUG] Successfully saved HNSWVerb file for ${verb.id}`);
|
||||
// Then save the metadata
|
||||
await this.saveVerbMetadata(verb.id, metadata);
|
||||
console.log(`[DEBUG] Successfully saved metadata file for ${verb.id}`);
|
||||
}
|
||||
catch (error) {
|
||||
console.error(`[ERROR] Failed to save verb ${verb.id}:`, error);
|
||||
// Attempt cleanup - remove verb file if metadata failed
|
||||
try {
|
||||
const verbExists = await this.getVerb_internal(verb.id);
|
||||
if (verbExists) {
|
||||
console.log(`[CLEANUP] Attempting to remove orphaned verb file ${verb.id}`);
|
||||
await this.deleteVerb_internal(verb.id);
|
||||
}
|
||||
}
|
||||
catch (cleanupError) {
|
||||
console.error(`[ERROR] Failed to cleanup orphaned verb ${verb.id}:`, cleanupError);
|
||||
}
|
||||
throw new Error(`Failed to save verb ${verb.id}: ${error instanceof Error ? error.message : String(error)}`);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Get a verb from storage
|
||||
*/
|
||||
async getVerb(id) {
|
||||
await this.ensureInitialized();
|
||||
const hnswVerb = await this.getVerb_internal(id);
|
||||
if (!hnswVerb) {
|
||||
return null;
|
||||
}
|
||||
return this.convertHNSWVerbToGraphVerb(hnswVerb);
|
||||
}
|
||||
/**
|
||||
* Convert HNSWVerb to GraphVerb by combining with metadata
|
||||
*/
|
||||
async convertHNSWVerbToGraphVerb(hnswVerb) {
|
||||
try {
|
||||
const metadata = await this.getVerbMetadata(hnswVerb.id);
|
||||
if (!metadata) {
|
||||
return null;
|
||||
}
|
||||
// Create default timestamp if not present
|
||||
const defaultTimestamp = {
|
||||
seconds: Math.floor(Date.now() / 1000),
|
||||
nanoseconds: (Date.now() % 1000) * 1000000
|
||||
};
|
||||
// Create default createdBy if not present
|
||||
const defaultCreatedBy = {
|
||||
augmentation: 'unknown',
|
||||
version: '1.0'
|
||||
};
|
||||
return {
|
||||
id: hnswVerb.id,
|
||||
vector: hnswVerb.vector,
|
||||
sourceId: metadata.sourceId,
|
||||
targetId: metadata.targetId,
|
||||
source: metadata.source,
|
||||
target: metadata.target,
|
||||
verb: metadata.verb,
|
||||
type: metadata.type,
|
||||
weight: metadata.weight || 1.0,
|
||||
metadata: metadata.metadata || {},
|
||||
createdAt: metadata.createdAt || defaultTimestamp,
|
||||
updatedAt: metadata.updatedAt || defaultTimestamp,
|
||||
createdBy: metadata.createdBy || defaultCreatedBy,
|
||||
data: metadata.data,
|
||||
embedding: hnswVerb.vector
|
||||
};
|
||||
}
|
||||
catch (error) {
|
||||
console.error(`Failed to convert HNSWVerb to GraphVerb for ${hnswVerb.id}:`, error);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Internal method for loading all verbs - used by performance optimizations
|
||||
* @internal - Do not use directly, use getVerbs() with pagination instead
|
||||
*/
|
||||
async _loadAllVerbsForOptimization() {
|
||||
await this.ensureInitialized();
|
||||
// Only use this for internal optimizations when safe
|
||||
const result = await this.getVerbs({
|
||||
pagination: { limit: Number.MAX_SAFE_INTEGER }
|
||||
});
|
||||
// Convert GraphVerbs back to HNSWVerbs for internal use
|
||||
const hnswVerbs = [];
|
||||
for (const graphVerb of result.items) {
|
||||
const hnswVerb = {
|
||||
id: graphVerb.id,
|
||||
vector: graphVerb.vector,
|
||||
connections: new Map()
|
||||
};
|
||||
hnswVerbs.push(hnswVerb);
|
||||
}
|
||||
return hnswVerbs;
|
||||
}
|
||||
/**
|
||||
* Get verbs by source
|
||||
*/
|
||||
async getVerbsBySource(sourceId) {
|
||||
await this.ensureInitialized();
|
||||
// Use the paginated getVerbs method with source filter
|
||||
const result = await this.getVerbs({
|
||||
filter: { sourceId }
|
||||
});
|
||||
return result.items;
|
||||
}
|
||||
/**
|
||||
* Get verbs by target
|
||||
*/
|
||||
async getVerbsByTarget(targetId) {
|
||||
await this.ensureInitialized();
|
||||
// Use the paginated getVerbs method with target filter
|
||||
const result = await this.getVerbs({
|
||||
filter: { targetId }
|
||||
});
|
||||
return result.items;
|
||||
}
|
||||
/**
|
||||
* Get verbs by type
|
||||
*/
|
||||
async getVerbsByType(type) {
|
||||
await this.ensureInitialized();
|
||||
// Use the paginated getVerbs method with type filter
|
||||
const result = await this.getVerbs({
|
||||
filter: { verbType: type }
|
||||
});
|
||||
return result.items;
|
||||
}
|
||||
/**
|
||||
* Internal method for loading all nouns - used by performance optimizations
|
||||
* @internal - Do not use directly, use getNouns() with pagination instead
|
||||
*/
|
||||
async _loadAllNounsForOptimization() {
|
||||
await this.ensureInitialized();
|
||||
// Only use this for internal optimizations when safe
|
||||
const result = await this.getNouns({
|
||||
pagination: { limit: Number.MAX_SAFE_INTEGER }
|
||||
});
|
||||
return result.items;
|
||||
}
|
||||
/**
|
||||
* Get nouns with pagination and filtering
|
||||
* @param options Pagination and filtering options
|
||||
* @returns Promise that resolves to a paginated result of nouns
|
||||
*/
|
||||
async getNouns(options) {
|
||||
await this.ensureInitialized();
|
||||
// Set default pagination values
|
||||
const pagination = options?.pagination || {};
|
||||
const limit = pagination.limit || 100;
|
||||
const offset = pagination.offset || 0;
|
||||
const cursor = pagination.cursor;
|
||||
// Optimize for common filter cases to avoid loading all nouns
|
||||
if (options?.filter) {
|
||||
// If filtering by nounType only, use the optimized method
|
||||
if (options.filter.nounType &&
|
||||
!options.filter.service &&
|
||||
!options.filter.metadata) {
|
||||
const nounType = Array.isArray(options.filter.nounType)
|
||||
? options.filter.nounType[0]
|
||||
: options.filter.nounType;
|
||||
// Get nouns by type directly
|
||||
const nounsByType = await this.getNounsByNounType_internal(nounType);
|
||||
// Apply pagination
|
||||
const paginatedNouns = nounsByType.slice(offset, offset + limit);
|
||||
const hasMore = offset + limit < nounsByType.length;
|
||||
// Set next cursor if there are more items
|
||||
let nextCursor = undefined;
|
||||
if (hasMore && paginatedNouns.length > 0) {
|
||||
const lastItem = paginatedNouns[paginatedNouns.length - 1];
|
||||
nextCursor = lastItem.id;
|
||||
}
|
||||
return {
|
||||
items: paginatedNouns,
|
||||
totalCount: nounsByType.length,
|
||||
hasMore,
|
||||
nextCursor
|
||||
};
|
||||
}
|
||||
}
|
||||
// For more complex filtering or no filtering, use a paginated approach
|
||||
// that avoids loading all nouns into memory at once
|
||||
try {
|
||||
// First, try to get a count of total nouns (if the adapter supports it)
|
||||
let totalCount = undefined;
|
||||
try {
|
||||
// This is an optional method that adapters may implement
|
||||
if (typeof this.countNouns === 'function') {
|
||||
totalCount = await this.countNouns(options?.filter);
|
||||
}
|
||||
}
|
||||
catch (countError) {
|
||||
// Ignore errors from count method, it's optional
|
||||
console.warn('Error getting noun count:', countError);
|
||||
}
|
||||
// Check if the adapter has a paginated method for getting nouns
|
||||
if (typeof this.getNounsWithPagination === 'function') {
|
||||
// Use the adapter's paginated method
|
||||
const result = await this.getNounsWithPagination({
|
||||
limit,
|
||||
cursor,
|
||||
filter: options?.filter
|
||||
});
|
||||
// Apply offset if needed (some adapters might not support offset)
|
||||
const items = result.items.slice(offset);
|
||||
return {
|
||||
items,
|
||||
totalCount: result.totalCount || totalCount,
|
||||
hasMore: result.hasMore,
|
||||
nextCursor: result.nextCursor
|
||||
};
|
||||
}
|
||||
// Storage adapter does not support pagination
|
||||
console.error('Storage adapter does not support pagination. The deprecated getAllNouns_internal() method has been removed. Please implement getNounsWithPagination() in your storage adapter.');
|
||||
return {
|
||||
items: [],
|
||||
totalCount: 0,
|
||||
hasMore: false
|
||||
};
|
||||
}
|
||||
catch (error) {
|
||||
console.error('Error getting nouns with pagination:', error);
|
||||
return {
|
||||
items: [],
|
||||
totalCount: 0,
|
||||
hasMore: false
|
||||
};
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Get verbs with pagination and filtering
|
||||
* @param options Pagination and filtering options
|
||||
* @returns Promise that resolves to a paginated result of verbs
|
||||
*/
|
||||
async getVerbs(options) {
|
||||
await this.ensureInitialized();
|
||||
// Set default pagination values
|
||||
const pagination = options?.pagination || {};
|
||||
const limit = pagination.limit || 100;
|
||||
const offset = pagination.offset || 0;
|
||||
const cursor = pagination.cursor;
|
||||
// Optimize for common filter cases to avoid loading all verbs
|
||||
if (options?.filter) {
|
||||
// If filtering by sourceId only, use the optimized method
|
||||
if (options.filter.sourceId &&
|
||||
!options.filter.verbType &&
|
||||
!options.filter.targetId &&
|
||||
!options.filter.service &&
|
||||
!options.filter.metadata) {
|
||||
const sourceId = Array.isArray(options.filter.sourceId)
|
||||
? options.filter.sourceId[0]
|
||||
: options.filter.sourceId;
|
||||
// Get verbs by source directly
|
||||
const verbsBySource = await this.getVerbsBySource_internal(sourceId);
|
||||
// Apply pagination
|
||||
const paginatedVerbs = verbsBySource.slice(offset, offset + limit);
|
||||
const hasMore = offset + limit < verbsBySource.length;
|
||||
// Set next cursor if there are more items
|
||||
let nextCursor = undefined;
|
||||
if (hasMore && paginatedVerbs.length > 0) {
|
||||
const lastItem = paginatedVerbs[paginatedVerbs.length - 1];
|
||||
nextCursor = lastItem.id;
|
||||
}
|
||||
return {
|
||||
items: paginatedVerbs,
|
||||
totalCount: verbsBySource.length,
|
||||
hasMore,
|
||||
nextCursor
|
||||
};
|
||||
}
|
||||
// If filtering by targetId only, use the optimized method
|
||||
if (options.filter.targetId &&
|
||||
!options.filter.verbType &&
|
||||
!options.filter.sourceId &&
|
||||
!options.filter.service &&
|
||||
!options.filter.metadata) {
|
||||
const targetId = Array.isArray(options.filter.targetId)
|
||||
? options.filter.targetId[0]
|
||||
: options.filter.targetId;
|
||||
// Get verbs by target directly
|
||||
const verbsByTarget = await this.getVerbsByTarget_internal(targetId);
|
||||
// Apply pagination
|
||||
const paginatedVerbs = verbsByTarget.slice(offset, offset + limit);
|
||||
const hasMore = offset + limit < verbsByTarget.length;
|
||||
// Set next cursor if there are more items
|
||||
let nextCursor = undefined;
|
||||
if (hasMore && paginatedVerbs.length > 0) {
|
||||
const lastItem = paginatedVerbs[paginatedVerbs.length - 1];
|
||||
nextCursor = lastItem.id;
|
||||
}
|
||||
return {
|
||||
items: paginatedVerbs,
|
||||
totalCount: verbsByTarget.length,
|
||||
hasMore,
|
||||
nextCursor
|
||||
};
|
||||
}
|
||||
// If filtering by verbType only, use the optimized method
|
||||
if (options.filter.verbType &&
|
||||
!options.filter.sourceId &&
|
||||
!options.filter.targetId &&
|
||||
!options.filter.service &&
|
||||
!options.filter.metadata) {
|
||||
const verbType = Array.isArray(options.filter.verbType)
|
||||
? options.filter.verbType[0]
|
||||
: options.filter.verbType;
|
||||
// Get verbs by type directly
|
||||
const verbsByType = await this.getVerbsByType_internal(verbType);
|
||||
// Apply pagination
|
||||
const paginatedVerbs = verbsByType.slice(offset, offset + limit);
|
||||
const hasMore = offset + limit < verbsByType.length;
|
||||
// Set next cursor if there are more items
|
||||
let nextCursor = undefined;
|
||||
if (hasMore && paginatedVerbs.length > 0) {
|
||||
const lastItem = paginatedVerbs[paginatedVerbs.length - 1];
|
||||
nextCursor = lastItem.id;
|
||||
}
|
||||
return {
|
||||
items: paginatedVerbs,
|
||||
totalCount: verbsByType.length,
|
||||
hasMore,
|
||||
nextCursor
|
||||
};
|
||||
}
|
||||
}
|
||||
// For more complex filtering or no filtering, use a paginated approach
|
||||
// that avoids loading all verbs into memory at once
|
||||
try {
|
||||
// First, try to get a count of total verbs (if the adapter supports it)
|
||||
let totalCount = undefined;
|
||||
try {
|
||||
// This is an optional method that adapters may implement
|
||||
if (typeof this.countVerbs === 'function') {
|
||||
totalCount = await this.countVerbs(options?.filter);
|
||||
}
|
||||
}
|
||||
catch (countError) {
|
||||
// Ignore errors from count method, it's optional
|
||||
console.warn('Error getting verb count:', countError);
|
||||
}
|
||||
// Check if the adapter has a paginated method for getting verbs
|
||||
if (typeof this.getVerbsWithPagination === 'function') {
|
||||
// Use the adapter's paginated method
|
||||
const result = await this.getVerbsWithPagination({
|
||||
limit,
|
||||
cursor,
|
||||
filter: options?.filter
|
||||
});
|
||||
// Apply offset if needed (some adapters might not support offset)
|
||||
const items = result.items.slice(offset);
|
||||
return {
|
||||
items,
|
||||
totalCount: result.totalCount || totalCount,
|
||||
hasMore: result.hasMore,
|
||||
nextCursor: result.nextCursor
|
||||
};
|
||||
}
|
||||
// Storage adapter does not support pagination
|
||||
console.error('Storage adapter does not support pagination. The deprecated getAllVerbs_internal() method has been removed. Please implement getVerbsWithPagination() in your storage adapter.');
|
||||
return {
|
||||
items: [],
|
||||
totalCount: 0,
|
||||
hasMore: false
|
||||
};
|
||||
}
|
||||
catch (error) {
|
||||
console.error('Error getting verbs with pagination:', error);
|
||||
return {
|
||||
items: [],
|
||||
totalCount: 0,
|
||||
hasMore: false
|
||||
};
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Delete a verb from storage
|
||||
*/
|
||||
async deleteVerb(id) {
|
||||
await this.ensureInitialized();
|
||||
return this.deleteVerb_internal(id);
|
||||
}
|
||||
/**
|
||||
* Save noun metadata to storage
|
||||
* This method should be implemented by each specific adapter
|
||||
*/
|
||||
async saveNounMetadata(id, metadata) {
|
||||
// Validate noun type in metadata - storage boundary protection
|
||||
if (metadata?.noun) {
|
||||
validateNounType(metadata.noun);
|
||||
}
|
||||
return this.saveNounMetadata_internal(id, metadata);
|
||||
}
|
||||
/**
|
||||
* Save verb metadata to storage
|
||||
* This method should be implemented by each specific adapter
|
||||
*/
|
||||
async saveVerbMetadata(id, metadata) {
|
||||
// Validate verb type in metadata - storage boundary protection
|
||||
if (metadata?.verb) {
|
||||
validateVerbType(metadata.verb);
|
||||
}
|
||||
return this.saveVerbMetadata_internal(id, metadata);
|
||||
}
|
||||
/**
|
||||
* Helper method to convert a Map to a plain object for serialization
|
||||
*/
|
||||
mapToObject(map, valueTransformer = (v) => v) {
|
||||
const obj = {};
|
||||
for (const [key, value] of map.entries()) {
|
||||
obj[key.toString()] = valueTransformer(value);
|
||||
}
|
||||
return obj;
|
||||
}
|
||||
/**
|
||||
* Save statistics data to storage (public interface)
|
||||
* @param statistics The statistics data to save
|
||||
*/
|
||||
async saveStatistics(statistics) {
|
||||
return this.saveStatisticsData(statistics);
|
||||
}
|
||||
/**
|
||||
* Get statistics data from storage (public interface)
|
||||
* @returns Promise that resolves to the statistics data or null if not found
|
||||
*/
|
||||
async getStatistics() {
|
||||
return this.getStatisticsData();
|
||||
}
|
||||
}
|
||||
//# sourceMappingURL=baseStorage.js.map
|
||||
Loading…
Add table
Add a link
Reference in a new issue