**remove: delete LLM augmentations implementation**
### Changes: - Removed the `src/augmentations/llmAugmentations.ts` file: - Contained cognition augmentations for creating, testing, exporting, and deploying LLM models. - Included TensorFlow.js-based model configuration, training, testing, and deployment functionalities. - Implemented various presets (`tiny`, `small`, `medium`, `large`) for simplified LLM model creation. ### Purpose: This change removes legacy LLM-related augmentations and functionalities no longer relevant to the project's current focus, in alignment with the recent transition to TensorFlow-based embedding workflows. Cleaning up eliminates unused code and maintains a streamlined, up-to-date codebase.
This commit is contained in:
parent
cfe1fd9e22
commit
cbc007b6cf
3 changed files with 0 additions and 2642 deletions
File diff suppressed because it is too large
Load diff
|
|
@ -1,636 +0,0 @@
|
|||
import {
|
||||
AugmentationType,
|
||||
IActivationAugmentation,
|
||||
AugmentationResponse
|
||||
} from '../types/augmentations.js'
|
||||
import { BrainyData } from '../brainyData.js'
|
||||
import { GraphNoun, GraphVerb, NounType, VerbType } from '../types/graphTypes.js'
|
||||
|
||||
/**
|
||||
* LLMTrainingActivationAugmentation
|
||||
*
|
||||
* An activation augmentation that provides actions for exporting Brainy graph data
|
||||
* to train and export a Language Learning Model (LLM).
|
||||
*/
|
||||
export class LLMTrainingActivationAugmentation implements IActivationAugmentation {
|
||||
readonly name: string
|
||||
readonly description: string
|
||||
enabled: boolean = true
|
||||
private isInitialized = false
|
||||
private brainyData: BrainyData | null = null
|
||||
|
||||
constructor(name: string = 'llm-training-activation') {
|
||||
this.name = name
|
||||
this.description = 'Activation augmentation for training and exporting LLMs using Brainy graph data'
|
||||
}
|
||||
|
||||
getType(): AugmentationType {
|
||||
return AugmentationType.ACTIVATION
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize the augmentation
|
||||
*/
|
||||
async initialize(): Promise<void> {
|
||||
if (this.isInitialized) {
|
||||
return
|
||||
}
|
||||
|
||||
this.isInitialized = true
|
||||
}
|
||||
|
||||
/**
|
||||
* Shut down the augmentation
|
||||
*/
|
||||
async shutDown(): Promise<void> {
|
||||
this.isInitialized = false
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the status of the augmentation
|
||||
*/
|
||||
async getStatus(): Promise<'active' | 'inactive' | 'error'> {
|
||||
return this.isInitialized ? 'active' : 'inactive'
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the Brainy data instance to use for accessing graph data
|
||||
* @param data The BrainyData instance
|
||||
*/
|
||||
setBrainyData(data: BrainyData): void {
|
||||
this.brainyData = data
|
||||
}
|
||||
|
||||
/**
|
||||
* Trigger an action based on a processed command or internal state
|
||||
* @param actionName The name of the action to trigger
|
||||
* @param parameters Optional parameters for the action
|
||||
*/
|
||||
// This is the interface method that returns a synchronous response
|
||||
triggerAction(
|
||||
actionName: string,
|
||||
parameters?: Record<string, unknown>
|
||||
): AugmentationResponse<unknown> {
|
||||
if (!this.brainyData) {
|
||||
return {
|
||||
success: false,
|
||||
data: null,
|
||||
error: 'BrainyData instance not set'
|
||||
}
|
||||
}
|
||||
|
||||
// Start the async operation
|
||||
this.triggerActionAsync(actionName, parameters);
|
||||
|
||||
// Return a placeholder response
|
||||
return {
|
||||
success: true,
|
||||
data: { status: 'processing', actionName, parameters },
|
||||
};
|
||||
}
|
||||
|
||||
// This is the actual implementation that handles the async operations
|
||||
private async triggerActionAsync(
|
||||
actionName: string,
|
||||
parameters?: Record<string, unknown>
|
||||
): Promise<void> {
|
||||
try {
|
||||
let result: AugmentationResponse<unknown>;
|
||||
|
||||
switch (actionName) {
|
||||
case 'exportGraphData':
|
||||
result = await this.handleExportGraphData(parameters || {});
|
||||
break;
|
||||
case 'generateTrainingData':
|
||||
result = await this.handleGenerateTrainingData(parameters || {});
|
||||
break;
|
||||
case 'trainModel':
|
||||
result = await this.handleTrainModel(parameters || {});
|
||||
break;
|
||||
case 'exportModel':
|
||||
result = await this.handleExportModel(parameters || {});
|
||||
break;
|
||||
default:
|
||||
result = {
|
||||
success: false,
|
||||
data: null,
|
||||
error: `Unknown action: ${actionName}`
|
||||
};
|
||||
}
|
||||
|
||||
// Here you would typically emit an event or update a status property
|
||||
// with the result of the async operation
|
||||
console.log(`Action ${actionName} completed:`, result);
|
||||
} catch (error) {
|
||||
console.error(`Error executing action ${actionName}:`, error);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle the exportGraphData action
|
||||
* @param parameters Action parameters
|
||||
*/
|
||||
private async handleExportGraphData(
|
||||
parameters: Record<string, unknown>
|
||||
): Promise<AugmentationResponse<unknown>> {
|
||||
const format = parameters.format as string || 'json'
|
||||
const includeNouns = parameters.includeNouns as boolean || true
|
||||
const includeVerbs = parameters.includeVerbs as boolean || true
|
||||
const nounTypes = parameters.nounTypes as NounType[] || Object.values(NounType)
|
||||
const verbTypes = parameters.verbTypes as VerbType[] || Object.values(VerbType)
|
||||
|
||||
try {
|
||||
const exportData: Record<string, unknown> = {}
|
||||
|
||||
// Export nouns if requested
|
||||
if (includeNouns) {
|
||||
const nouns: GraphNoun[] = []
|
||||
// Get all nouns from BrainyData
|
||||
// Use search to get all nouns of the specified types
|
||||
for (const nounType of nounTypes) {
|
||||
try {
|
||||
// Search for nouns of this type with a high limit to get all
|
||||
const searchResults = await this.brainyData!.searchByNounTypes(
|
||||
'', // Empty query to match all
|
||||
1000, // High limit to get as many as possible
|
||||
[nounType as string]
|
||||
);
|
||||
|
||||
// Add the results to our nouns array
|
||||
if (searchResults && Array.isArray(searchResults)) {
|
||||
for (const result of searchResults) {
|
||||
// SearchResult might not have data directly, use metadata instead
|
||||
if (result.metadata) {
|
||||
nouns.push(result.metadata as unknown as GraphNoun);
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
console.warn(`Failed to get nouns of type ${nounType}:`, error);
|
||||
}
|
||||
}
|
||||
|
||||
exportData.nouns = nouns
|
||||
}
|
||||
|
||||
// Export verbs if requested
|
||||
if (includeVerbs) {
|
||||
try {
|
||||
const verbs = await this.brainyData!.getAllVerbs() || []
|
||||
exportData.verbs = verbs.filter(verb => {
|
||||
// Check for verb type in either verb.verb or verb.type
|
||||
const verbType = (verb as any).verb || (verb as any).type;
|
||||
return typeof verbType === 'string' && verbTypes.includes(verbType as VerbType);
|
||||
})
|
||||
} catch (error) {
|
||||
console.warn('Failed to get all verbs:', error);
|
||||
exportData.verbs = [];
|
||||
}
|
||||
}
|
||||
|
||||
// Format the export data
|
||||
if (format === 'json') {
|
||||
return {
|
||||
success: true,
|
||||
data: exportData
|
||||
}
|
||||
} else if (format === 'csv') {
|
||||
// Convert to CSV format (simplified)
|
||||
const csvData = this.convertToCSV(exportData)
|
||||
return {
|
||||
success: true,
|
||||
data: csvData
|
||||
}
|
||||
} else {
|
||||
return {
|
||||
success: false,
|
||||
data: null,
|
||||
error: `Unsupported format: ${format}`
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
return {
|
||||
success: false,
|
||||
data: null,
|
||||
error: `Failed to export graph data: ${error}`
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle the generateTrainingData action
|
||||
* @param parameters Action parameters
|
||||
*/
|
||||
private async handleGenerateTrainingData(
|
||||
parameters: Record<string, unknown>
|
||||
): Promise<AugmentationResponse<unknown>> {
|
||||
const format = parameters.format as string || 'jsonl'
|
||||
const includeEmbeddings = parameters.includeEmbeddings as boolean || true
|
||||
const maxSamples = parameters.maxSamples as number || 1000
|
||||
|
||||
try {
|
||||
// First, export the graph data
|
||||
const exportResult = await this.handleExportGraphData({
|
||||
format: 'json',
|
||||
includeNouns: true,
|
||||
includeVerbs: true
|
||||
})
|
||||
|
||||
if (!exportResult.success) {
|
||||
return exportResult
|
||||
}
|
||||
|
||||
const graphData = exportResult.data as Record<string, unknown>
|
||||
const nouns = graphData.nouns as GraphNoun[] || []
|
||||
const verbs = graphData.verbs as GraphVerb[] || []
|
||||
|
||||
// Generate training samples
|
||||
const trainingSamples = this.generateTrainingSamples(nouns, verbs, maxSamples, includeEmbeddings)
|
||||
|
||||
// Format the training data
|
||||
if (format === 'jsonl') {
|
||||
const jsonlData = trainingSamples.map(sample => JSON.stringify(sample)).join('\n')
|
||||
return {
|
||||
success: true,
|
||||
data: jsonlData
|
||||
}
|
||||
} else if (format === 'json') {
|
||||
return {
|
||||
success: true,
|
||||
data: trainingSamples
|
||||
}
|
||||
} else {
|
||||
return {
|
||||
success: false,
|
||||
data: null,
|
||||
error: `Unsupported format: ${format}`
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
return {
|
||||
success: false,
|
||||
data: null,
|
||||
error: `Failed to generate training data: ${error}`
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle the trainModel action
|
||||
* @param parameters Action parameters
|
||||
*/
|
||||
private async handleTrainModel(
|
||||
parameters: Record<string, unknown>
|
||||
): Promise<AugmentationResponse<unknown>> {
|
||||
const modelType = parameters.modelType as string || 'default'
|
||||
const epochs = parameters.epochs as number || 10
|
||||
const batchSize = parameters.batchSize as number || 32
|
||||
const learningRate = parameters.learningRate as number || 0.001
|
||||
|
||||
try {
|
||||
// First, generate the training data
|
||||
const trainingDataResult = await this.handleGenerateTrainingData({
|
||||
format: 'json'
|
||||
})
|
||||
|
||||
if (!trainingDataResult.success) {
|
||||
return trainingDataResult
|
||||
}
|
||||
|
||||
const trainingSamples = trainingDataResult.data as any[]
|
||||
|
||||
// In a real implementation, this would call an actual LLM training library
|
||||
// For now, we'll just simulate the training process
|
||||
const trainingResult = this.simulateTraining(
|
||||
trainingSamples,
|
||||
modelType,
|
||||
epochs,
|
||||
batchSize,
|
||||
learningRate
|
||||
)
|
||||
|
||||
return {
|
||||
success: true,
|
||||
data: trainingResult
|
||||
}
|
||||
} catch (error) {
|
||||
return {
|
||||
success: false,
|
||||
data: null,
|
||||
error: `Failed to train model: ${error}`
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle the exportModel action
|
||||
* @param parameters Action parameters
|
||||
*/
|
||||
private async handleExportModel(
|
||||
parameters: Record<string, unknown>
|
||||
): Promise<AugmentationResponse<unknown>> {
|
||||
const format = parameters.format as string || 'onnx'
|
||||
const modelId = parameters.modelId as string
|
||||
|
||||
try {
|
||||
// In a real implementation, this would export the trained model
|
||||
// For now, we'll just return a simulated export result
|
||||
const exportResult = {
|
||||
modelId: modelId || 'default-model',
|
||||
format,
|
||||
timestamp: new Date().toISOString(),
|
||||
size: '125MB',
|
||||
parameters: '7B',
|
||||
url: `https://example.com/models/${modelId || 'default-model'}.${format}`
|
||||
}
|
||||
|
||||
return {
|
||||
success: true,
|
||||
data: exportResult
|
||||
}
|
||||
} catch (error) {
|
||||
return {
|
||||
success: false,
|
||||
data: null,
|
||||
error: `Failed to export model: ${error}`
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Generates an expressive output or response from Brainy
|
||||
* @param knowledgeId The identifier of the knowledge to express
|
||||
* @param format The desired output format (e.g., 'text', 'json')
|
||||
*/
|
||||
generateOutput(
|
||||
knowledgeId: string,
|
||||
format: string
|
||||
): AugmentationResponse<string | Record<string, unknown>> {
|
||||
if (!this.brainyData) {
|
||||
return {
|
||||
success: false,
|
||||
data: '',
|
||||
error: 'BrainyData instance not set'
|
||||
}
|
||||
}
|
||||
|
||||
// Start the async operation
|
||||
this.generateOutputAsync(knowledgeId, format);
|
||||
|
||||
// Return a placeholder response
|
||||
return {
|
||||
success: true,
|
||||
data: { status: 'processing', knowledgeId, format },
|
||||
};
|
||||
}
|
||||
|
||||
// This is the actual implementation that handles the async operations
|
||||
private async generateOutputAsync(
|
||||
knowledgeId: string,
|
||||
format: string
|
||||
): Promise<void> {
|
||||
try {
|
||||
// Get the knowledge from BrainyData
|
||||
const knowledge = await this.brainyData!.get(knowledgeId);
|
||||
let result: AugmentationResponse<string | Record<string, unknown>>;
|
||||
|
||||
if (!knowledge) {
|
||||
result = {
|
||||
success: false,
|
||||
data: '',
|
||||
error: `Knowledge not found: ${knowledgeId}`
|
||||
};
|
||||
} else {
|
||||
// Format the output
|
||||
if (format === 'text') {
|
||||
// Generate a text representation of the knowledge
|
||||
const text = this.generateTextFromKnowledge(knowledge);
|
||||
result = {
|
||||
success: true,
|
||||
data: text
|
||||
};
|
||||
} else if (format === 'json') {
|
||||
// Return the knowledge as JSON
|
||||
// Convert VectorDocument to a plain object to avoid type issues
|
||||
const knowledgeObj = { ...knowledge };
|
||||
result = {
|
||||
success: true,
|
||||
data: knowledgeObj
|
||||
};
|
||||
} else {
|
||||
result = {
|
||||
success: false,
|
||||
data: '',
|
||||
error: `Unsupported format: ${format}`
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// Here you would typically emit an event or update a status property
|
||||
// with the result of the async operation
|
||||
console.log(`Generate output for ${knowledgeId} completed:`, result);
|
||||
} catch (error) {
|
||||
console.error(`Failed to generate output for ${knowledgeId}:`, error);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Interacts with an external system or API
|
||||
* @param systemId The identifier of the external system
|
||||
* @param payload The data to send to the external system
|
||||
*/
|
||||
interactExternal(
|
||||
systemId: string,
|
||||
payload: Record<string, unknown>
|
||||
): AugmentationResponse<unknown> {
|
||||
// This method would interact with external LLM training systems or APIs
|
||||
// For now, we'll just return a simulated response
|
||||
return {
|
||||
success: true,
|
||||
data: {
|
||||
systemId,
|
||||
status: 'processing',
|
||||
message: 'Interaction with external system initiated',
|
||||
timestamp: new Date().toISOString(),
|
||||
payload
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper method to convert data to CSV format
|
||||
* @param data The data to convert
|
||||
* @returns CSV formatted string
|
||||
*/
|
||||
private convertToCSV(data: Record<string, unknown>): string {
|
||||
// Simplified CSV conversion - in a real implementation, this would be more robust
|
||||
let csv = ''
|
||||
|
||||
// Handle nouns
|
||||
if (data.nouns && Array.isArray(data.nouns) && data.nouns.length > 0) {
|
||||
const nouns = data.nouns as GraphNoun[]
|
||||
// Add header
|
||||
csv += 'id,noun,label,createdAt\n'
|
||||
|
||||
// Add rows
|
||||
for (const noun of nouns) {
|
||||
csv += `${noun.id},${noun.noun},${noun.label || ''},${noun.createdAt.seconds}\n`
|
||||
}
|
||||
|
||||
csv += '\n'
|
||||
}
|
||||
|
||||
// Handle verbs
|
||||
if (data.verbs && Array.isArray(data.verbs) && data.verbs.length > 0) {
|
||||
const verbs = data.verbs as GraphVerb[]
|
||||
// Add header
|
||||
csv += 'id,source,target,verb,label,createdAt\n'
|
||||
|
||||
// Add rows
|
||||
for (const verb of verbs) {
|
||||
csv += `${verb.id},${verb.source},${verb.target},${verb.verb},${verb.label || ''},${verb.createdAt.seconds}\n`
|
||||
}
|
||||
}
|
||||
|
||||
return csv
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper method to generate training samples from graph data
|
||||
* @param nouns The graph nouns
|
||||
* @param verbs The graph verbs
|
||||
* @param maxSamples Maximum number of samples to generate
|
||||
* @param includeEmbeddings Whether to include embeddings in the samples
|
||||
* @returns Array of training samples
|
||||
*/
|
||||
private generateTrainingSamples(
|
||||
nouns: GraphNoun[],
|
||||
verbs: GraphVerb[],
|
||||
maxSamples: number,
|
||||
includeEmbeddings: boolean
|
||||
): any[] {
|
||||
const samples = []
|
||||
|
||||
// Create a map of noun IDs to nouns for quick lookup
|
||||
const nounMap = new Map<string, GraphNoun>()
|
||||
for (const noun of nouns) {
|
||||
nounMap.set(noun.id, noun)
|
||||
}
|
||||
|
||||
// Generate samples from verbs (relationships)
|
||||
for (const verb of verbs) {
|
||||
if (samples.length >= maxSamples) break
|
||||
|
||||
const sourceNoun = nounMap.get(verb.source)
|
||||
const targetNoun = nounMap.get(verb.target)
|
||||
|
||||
if (sourceNoun && targetNoun) {
|
||||
// Create a training sample
|
||||
const sample: Record<string, unknown> = {
|
||||
input: `What is the relationship between ${sourceNoun.label || sourceNoun.id} and ${targetNoun.label || targetNoun.id}?`,
|
||||
output: `${sourceNoun.label || sourceNoun.id} ${verb.verb} ${targetNoun.label || targetNoun.id}`
|
||||
}
|
||||
|
||||
// Add embeddings if requested
|
||||
if (includeEmbeddings) {
|
||||
sample.sourceEmbedding = sourceNoun.embedding
|
||||
sample.targetEmbedding = targetNoun.embedding
|
||||
sample.verbEmbedding = verb.embedding
|
||||
}
|
||||
|
||||
samples.push(sample)
|
||||
}
|
||||
}
|
||||
|
||||
// Generate samples from nouns (entities)
|
||||
for (const noun of nouns) {
|
||||
if (samples.length >= maxSamples) break
|
||||
|
||||
// Create a training sample
|
||||
const sample: Record<string, unknown> = {
|
||||
input: `What type of entity is ${noun.label || noun.id}?`,
|
||||
output: `${noun.label || noun.id} is a ${noun.noun}`
|
||||
}
|
||||
|
||||
// Add embeddings if requested
|
||||
if (includeEmbeddings) {
|
||||
sample.embedding = noun.embedding
|
||||
}
|
||||
|
||||
samples.push(sample)
|
||||
}
|
||||
|
||||
return samples
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper method to simulate training an LLM
|
||||
* @param trainingSamples The training samples
|
||||
* @param modelType The type of model to train
|
||||
* @param epochs Number of training epochs
|
||||
* @param batchSize Batch size for training
|
||||
* @param learningRate Learning rate for training
|
||||
* @returns Simulated training result
|
||||
*/
|
||||
private simulateTraining(
|
||||
trainingSamples: any[],
|
||||
modelType: string,
|
||||
epochs: number,
|
||||
batchSize: number,
|
||||
learningRate: number
|
||||
): Record<string, unknown> {
|
||||
// In a real implementation, this would use an actual LLM training library
|
||||
// For now, we'll just simulate the training process
|
||||
return {
|
||||
modelId: `${modelType}-${new Date().getTime()}`,
|
||||
trainingSamples: trainingSamples.length,
|
||||
epochs,
|
||||
batchSize,
|
||||
learningRate,
|
||||
trainingTime: `${Math.floor(Math.random() * 100) + 50}s`,
|
||||
loss: Math.random() * 0.5,
|
||||
accuracy: 0.5 + Math.random() * 0.5,
|
||||
timestamp: new Date().toISOString()
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper method to generate text from knowledge
|
||||
* @param knowledge The knowledge to generate text from
|
||||
* @returns Generated text
|
||||
*/
|
||||
private generateTextFromKnowledge(knowledge: any): string {
|
||||
// In a real implementation, this would generate natural language text
|
||||
// For now, we'll just return a simple string
|
||||
if (knowledge.noun) {
|
||||
return `This is a ${knowledge.noun} called "${knowledge.label || knowledge.id}".`
|
||||
} else if (knowledge.verb) {
|
||||
return `This is a ${knowledge.verb} relationship from "${knowledge.source}" to "${knowledge.target}".`
|
||||
} else {
|
||||
return `This is an entity with ID "${knowledge.id}".`
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Factory function to create an LLM training augmentation
|
||||
* @param options Additional options
|
||||
* @returns The created augmentation
|
||||
*/
|
||||
export async function createLLMTrainingAugmentation(
|
||||
options: {
|
||||
name?: string,
|
||||
brainyData?: BrainyData
|
||||
} = {}
|
||||
): Promise<LLMTrainingActivationAugmentation> {
|
||||
// Create the activation augmentation
|
||||
const activation = new LLMTrainingActivationAugmentation(options.name)
|
||||
await activation.initialize()
|
||||
|
||||
// Set the BrainyData instance if provided
|
||||
if (options.brainyData) {
|
||||
activation.setBrainyData(options.brainyData)
|
||||
}
|
||||
|
||||
return activation
|
||||
}
|
||||
|
|
@ -1,63 +0,0 @@
|
|||
// Test script to verify type validation in BrainyData
|
||||
import { BrainyData } from '../src/brainyData.js';
|
||||
import { NounType, VerbType } from '../src/types/graphTypes.js';
|
||||
|
||||
async function testTypeValidation() {
|
||||
console.log('Testing type validation in BrainyData...');
|
||||
|
||||
// Create a new BrainyData instance
|
||||
const brainy = new BrainyData();
|
||||
await brainy.init();
|
||||
|
||||
console.log('Testing node with valid noun type...');
|
||||
const validNodeId = await brainy.add([0.1, 0.2, 0.3], {
|
||||
noun: NounType.Person,
|
||||
label: 'Test Person'
|
||||
});
|
||||
console.log(`Added node with valid noun type: ${validNodeId}`);
|
||||
|
||||
console.log('Testing node with invalid noun type...');
|
||||
const invalidNodeId = await brainy.add([0.4, 0.5, 0.6], {
|
||||
noun: 'invalid_type',
|
||||
label: 'Test Invalid'
|
||||
});
|
||||
console.log(`Added node with invalid noun type (should be converted to default): ${invalidNodeId}`);
|
||||
|
||||
// Get the metadata to verify it was corrected
|
||||
const invalidNodeMetadata = await brainy.get(invalidNodeId);
|
||||
console.log('Metadata for node with invalid type:', invalidNodeMetadata);
|
||||
|
||||
console.log('Testing edge with valid verb type...');
|
||||
const validEdgeId = await brainy.addEdge(validNodeId, invalidNodeId, undefined, {
|
||||
type: VerbType.RelatedTo,
|
||||
metadata: { label: 'Test Relation' }
|
||||
});
|
||||
console.log(`Added edge with valid verb type: ${validEdgeId}`);
|
||||
|
||||
console.log('Testing edge with invalid verb type...');
|
||||
const invalidEdgeId = await brainy.addEdge(validNodeId, invalidNodeId, undefined, {
|
||||
type: 'invalid_relation',
|
||||
metadata: { label: 'Test Invalid Relation' }
|
||||
});
|
||||
console.log(`Added edge with invalid verb type (should be converted to default): ${invalidEdgeId}`);
|
||||
|
||||
// Get the edge to verify it was corrected
|
||||
const invalidEdge = await brainy.getEdge(invalidEdgeId);
|
||||
console.log('Edge with invalid type:', invalidEdge);
|
||||
|
||||
console.log('Testing updateMetadata with invalid noun type...');
|
||||
await brainy.updateMetadata(validNodeId, {
|
||||
noun: 'another_invalid_type',
|
||||
label: 'Updated Test'
|
||||
});
|
||||
|
||||
// Get the metadata to verify it was corrected
|
||||
const updatedMetadata = await brainy.get(validNodeId);
|
||||
console.log('Updated metadata (should have corrected noun type):', updatedMetadata);
|
||||
|
||||
console.log('All tests completed.');
|
||||
}
|
||||
|
||||
testTypeValidation().catch(error => {
|
||||
console.error('Test failed:', error);
|
||||
});
|
||||
Loading…
Add table
Add a link
Reference in a new issue