[WIP] mappings
This commit is contained in:
412
schema-mappings/mapping-manager.js
Normal file
412
schema-mappings/mapping-manager.js
Normal file
@@ -0,0 +1,412 @@
|
||||
// Comprehensive ODMDB Schema Mapping Manager
|
||||
// Handles all objects, detects data availability, and provides intelligent query routing
|
||||
|
||||
import fs from "node:fs";
|
||||
import { seekersMapping } from "./seekers-mapping.js";
|
||||
import { jobadsMapping } from "./jobads-mapping.js";
|
||||
import { recruitersMapping } from "./recruiters-mapping.js";
|
||||
import { personsMapping } from "./persons-mapping.js";
|
||||
import { createSchemaMapping } from "./base-mapping.js";
|
||||
|
||||
const SCHEMA_BASE_PATH = "../smatchitObjectOdmdb/schema";
|
||||
const OBJECTS_BASE_PATH = "../smatchitObjectOdmdb/objects";
|
||||
|
||||
class ODMDBMappingManager {
|
||||
constructor() {
|
||||
this.mappings = new Map();
|
||||
this.dataAvailability = new Map();
|
||||
this.loadAllMappings();
|
||||
this.checkDataAvailability();
|
||||
}
|
||||
|
||||
loadAllMappings() {
|
||||
// Load primary mappings (with custom enhancements)
|
||||
this.mappings.set("seekers", seekersMapping);
|
||||
this.mappings.set("jobads", jobadsMapping);
|
||||
this.mappings.set("recruiters", recruitersMapping);
|
||||
this.mappings.set("persons", personsMapping);
|
||||
|
||||
// Load remaining schemas dynamically
|
||||
const remainingSchemas = [
|
||||
"jobsteps",
|
||||
"jobtitles",
|
||||
"quizz",
|
||||
"screens",
|
||||
"sirets",
|
||||
"trainingprovider",
|
||||
"trainings",
|
||||
];
|
||||
|
||||
remainingSchemas.forEach((schemaName) => {
|
||||
const schemaPath = `${SCHEMA_BASE_PATH}/${schemaName}.json`;
|
||||
try {
|
||||
if (fs.existsSync(schemaPath)) {
|
||||
const schemaData = JSON.parse(fs.readFileSync(schemaPath, "utf-8"));
|
||||
const mapping = createSchemaMapping(schemaData, schemaName);
|
||||
this.mappings.set(schemaName, mapping);
|
||||
}
|
||||
} catch (error) {
|
||||
console.warn(
|
||||
`Warning: Could not load ${schemaName} schema: ${error.message}`
|
||||
);
|
||||
this.mappings.set(schemaName, {
|
||||
objectName: schemaName,
|
||||
available: false,
|
||||
error: error.message,
|
||||
properties: {},
|
||||
synonyms: {},
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
console.log(`🗺️ Loaded ${this.mappings.size} object mappings`);
|
||||
}
|
||||
|
||||
checkDataAvailability() {
|
||||
// Check which objects have actual data files
|
||||
this.mappings.forEach((mapping, objectName) => {
|
||||
const objectPath = `${OBJECTS_BASE_PATH}/${objectName}`;
|
||||
const itemsPath = `${objectPath}/itm`;
|
||||
|
||||
let availability = {
|
||||
schemaAvailable: mapping.available,
|
||||
dataAvailable: false,
|
||||
dataPath: itemsPath,
|
||||
fileCount: 0,
|
||||
sampleFiles: [],
|
||||
};
|
||||
|
||||
try {
|
||||
if (fs.existsSync(itemsPath)) {
|
||||
const files = fs
|
||||
.readdirSync(itemsPath)
|
||||
.filter((f) => f.endsWith(".json") && f !== "backup")
|
||||
.filter((f) => !fs.statSync(`${itemsPath}/${f}`).isDirectory());
|
||||
|
||||
availability.dataAvailable = files.length > 0;
|
||||
availability.fileCount = files.length;
|
||||
availability.sampleFiles = files.slice(0, 3); // First 3 files as samples
|
||||
}
|
||||
} catch (error) {
|
||||
console.warn(
|
||||
`Warning: Could not check data for ${objectName}: ${error.message}`
|
||||
);
|
||||
}
|
||||
|
||||
this.dataAvailability.set(objectName, availability);
|
||||
});
|
||||
|
||||
// Log availability summary
|
||||
const availableObjects = Array.from(this.dataAvailability.entries())
|
||||
.filter(([_, availability]) => availability.dataAvailable)
|
||||
.map(
|
||||
([objectName, availability]) =>
|
||||
`${objectName}(${availability.fileCount})`
|
||||
)
|
||||
.join(", ");
|
||||
|
||||
console.log(`📊 Data available for: ${availableObjects}`);
|
||||
}
|
||||
|
||||
// Intelligent object detection from natural language
|
||||
detectObjectFromQuery(nlQuery) {
|
||||
const query = nlQuery.toLowerCase();
|
||||
const detectedObjects = [];
|
||||
|
||||
// Direct object name mentions
|
||||
this.mappings.forEach((mapping, objectName) => {
|
||||
if (
|
||||
query.includes(objectName) ||
|
||||
query.includes(objectName.slice(0, -1))
|
||||
) {
|
||||
// singular form
|
||||
detectedObjects.push({
|
||||
object: objectName,
|
||||
confidence: 0.9,
|
||||
reason: `Direct mention of '${objectName}'`,
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
// Semantic object detection
|
||||
const objectIndicators = {
|
||||
seekers: [
|
||||
"seekers",
|
||||
"seeker",
|
||||
"job seekers",
|
||||
"candidates",
|
||||
"applicants",
|
||||
"people looking for jobs",
|
||||
"job hunters",
|
||||
"looking for work",
|
||||
"experience",
|
||||
"skills",
|
||||
"salary expectation",
|
||||
"availability",
|
||||
],
|
||||
jobads: [
|
||||
"jobs",
|
||||
"job postings",
|
||||
"job ads",
|
||||
"positions",
|
||||
"openings",
|
||||
"vacancies",
|
||||
"employment opportunities",
|
||||
"job offers",
|
||||
"job description",
|
||||
"job requirements",
|
||||
"salary range",
|
||||
],
|
||||
recruiters: [
|
||||
"recruiters",
|
||||
"recruiter",
|
||||
"hiring managers",
|
||||
"hr",
|
||||
"employers",
|
||||
"hiring",
|
||||
"recruitment",
|
||||
"talent acquisition",
|
||||
"headhunters",
|
||||
],
|
||||
persons: [
|
||||
"people",
|
||||
"users",
|
||||
"profiles",
|
||||
"personal information",
|
||||
"contact details",
|
||||
"names",
|
||||
"demographics",
|
||||
"biography",
|
||||
],
|
||||
sirets: [
|
||||
"companies",
|
||||
"businesses",
|
||||
"organizations",
|
||||
"employers",
|
||||
"firms",
|
||||
"corporations",
|
||||
"enterprises",
|
||||
],
|
||||
};
|
||||
|
||||
Object.entries(objectIndicators).forEach(([objectName, indicators]) => {
|
||||
const matches = indicators.filter((indicator) =>
|
||||
query.includes(indicator)
|
||||
);
|
||||
if (matches.length > 0) {
|
||||
const confidence = Math.min(0.8, matches.length * 0.3);
|
||||
detectedObjects.push({
|
||||
object: objectName,
|
||||
confidence,
|
||||
reason: `Semantic match: ${matches.join(", ")}`,
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
// Sort by confidence and remove duplicates
|
||||
const uniqueObjects = detectedObjects.reduce((acc, current) => {
|
||||
const existing = acc.find((item) => item.object === current.object);
|
||||
if (!existing || current.confidence > existing.confidence) {
|
||||
acc = acc.filter((item) => item.object !== current.object);
|
||||
acc.push(current);
|
||||
}
|
||||
return acc;
|
||||
}, []);
|
||||
|
||||
return uniqueObjects.sort((a, b) => b.confidence - a.confidence);
|
||||
}
|
||||
|
||||
// Get data availability statistics
|
||||
getDataAvailabilityStats() {
|
||||
const availableObjects = [];
|
||||
const objectStats = {};
|
||||
|
||||
for (const [objectType, mapping] of Object.entries(this.mappings)) {
|
||||
if (mapping.available) {
|
||||
availableObjects.push(objectType);
|
||||
objectStats[objectType] = mapping.dataStats.fileCount;
|
||||
}
|
||||
}
|
||||
|
||||
const summary = availableObjects
|
||||
.map((obj) => `${obj}(${objectStats[obj]})`)
|
||||
.join(", ");
|
||||
|
||||
return {
|
||||
availableObjects,
|
||||
objectStats,
|
||||
summary,
|
||||
totalObjects: availableObjects.length,
|
||||
};
|
||||
}
|
||||
|
||||
// Check if a query is feasible given available data
|
||||
validateQueryFeasibility(nlQuery, suggestedObject = null) {
|
||||
const detectedObjects = suggestedObject
|
||||
? [
|
||||
{
|
||||
object: suggestedObject,
|
||||
confidence: 1.0,
|
||||
reason: "Explicitly specified",
|
||||
},
|
||||
]
|
||||
: this.detectObjectFromQuery(nlQuery);
|
||||
|
||||
if (detectedObjects.length === 0) {
|
||||
return {
|
||||
feasible: false,
|
||||
reason: "Cannot determine which object type this query refers to",
|
||||
suggestion:
|
||||
"Please specify if you're looking for seekers, jobs, recruiters, or companies",
|
||||
availableObjects: Array.from(this.dataAvailability.keys()).filter(
|
||||
(obj) => this.dataAvailability.get(obj).dataAvailable
|
||||
),
|
||||
};
|
||||
}
|
||||
|
||||
const primaryObject = detectedObjects[0];
|
||||
const availability = this.dataAvailability.get(primaryObject.object);
|
||||
|
||||
if (!availability) {
|
||||
return {
|
||||
feasible: false,
|
||||
reason: `Unknown object type: ${primaryObject.object}`,
|
||||
suggestion: `Available objects: ${Array.from(this.mappings.keys()).join(
|
||||
", "
|
||||
)}`,
|
||||
};
|
||||
}
|
||||
|
||||
if (!availability.schemaAvailable) {
|
||||
return {
|
||||
feasible: false,
|
||||
reason: `Schema not available for ${primaryObject.object}`,
|
||||
suggestion: `Cannot process queries for ${primaryObject.object} - schema missing`,
|
||||
};
|
||||
}
|
||||
|
||||
if (!availability.dataAvailable) {
|
||||
return {
|
||||
feasible: false,
|
||||
reason: `No data available for ${primaryObject.object}`,
|
||||
suggestion: `${
|
||||
primaryObject.object
|
||||
} schema exists but no data files found. Available data: ${Array.from(
|
||||
this.dataAvailability.entries()
|
||||
)
|
||||
.filter(([_, avail]) => avail.dataAvailable)
|
||||
.map(([name, avail]) => `${name}(${avail.fileCount})`)
|
||||
.join(", ")}`,
|
||||
};
|
||||
}
|
||||
|
||||
// Check if requested fields exist
|
||||
const mapping = this.mappings.get(primaryObject.object);
|
||||
const queryWords = nlQuery.toLowerCase().split(/\s+/);
|
||||
const unmappedWords = [];
|
||||
|
||||
queryWords.forEach((word) => {
|
||||
if (
|
||||
word.length > 2 && // Skip short words
|
||||
!mapping.synonyms[word] &&
|
||||
!Object.keys(mapping.properties).includes(word) &&
|
||||
![
|
||||
"show",
|
||||
"get",
|
||||
"find",
|
||||
"with",
|
||||
"their",
|
||||
"and",
|
||||
"the",
|
||||
"me",
|
||||
"all",
|
||||
].includes(word)
|
||||
) {
|
||||
unmappedWords.push(word);
|
||||
}
|
||||
});
|
||||
|
||||
return {
|
||||
feasible: true,
|
||||
primaryObject,
|
||||
detectedObjects,
|
||||
dataStats: {
|
||||
fileCount: availability.fileCount,
|
||||
sampleFiles: availability.sampleFiles,
|
||||
},
|
||||
fieldWarnings:
|
||||
unmappedWords.length > 0
|
||||
? `Some terms might not map to fields: ${unmappedWords.join(", ")}`
|
||||
: null,
|
||||
};
|
||||
}
|
||||
|
||||
// Get mapping for a specific object
|
||||
getMapping(objectName) {
|
||||
return this.mappings.get(objectName);
|
||||
}
|
||||
|
||||
// Get all available objects with data
|
||||
getAvailableObjects() {
|
||||
return Array.from(this.dataAvailability.entries())
|
||||
.filter(
|
||||
([_, availability]) =>
|
||||
availability.dataAvailable && availability.schemaAvailable
|
||||
)
|
||||
.map(([objectName, availability]) => ({
|
||||
object: objectName,
|
||||
fileCount: availability.fileCount,
|
||||
propertyCount: this.mappings.get(objectName)?.propertyCount || 0,
|
||||
}));
|
||||
}
|
||||
|
||||
// Get comprehensive field suggestions for an object
|
||||
getFieldSuggestions(objectName, queryTerms = []) {
|
||||
const mapping = this.getMapping(objectName);
|
||||
if (!mapping || !mapping.available) return [];
|
||||
|
||||
const suggestions = [];
|
||||
|
||||
// Find fields that match query terms
|
||||
queryTerms.forEach((term) => {
|
||||
const field = mapping.synonyms[term.toLowerCase()];
|
||||
if (field) {
|
||||
const fieldInfo = mapping.properties[field];
|
||||
suggestions.push({
|
||||
field,
|
||||
matchedTerm: term,
|
||||
title: fieldInfo.title,
|
||||
type: fieldInfo.type,
|
||||
synonyms: fieldInfo.synonyms.slice(0, 3), // Top 3 synonyms
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
return suggestions;
|
||||
}
|
||||
|
||||
// Generate intelligent error messages with suggestions
|
||||
generateErrorMessage(nlQuery, error) {
|
||||
const feasibility = this.validateQueryFeasibility(nlQuery);
|
||||
|
||||
if (!feasibility.feasible) {
|
||||
return {
|
||||
error: feasibility.reason,
|
||||
suggestion: feasibility.suggestion,
|
||||
availableObjects:
|
||||
feasibility.availableObjects || this.getAvailableObjects(),
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
error: error.message || "Unknown error",
|
||||
suggestion: "Query seems valid but processing failed",
|
||||
queryAnalysis: feasibility,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// Export class and singleton instance
|
||||
export { ODMDBMappingManager };
|
||||
export const odmdbMappingManager = new ODMDBMappingManager();
|
||||
export default ODMDBMappingManager;
|
Reference in New Issue
Block a user