@codai/cbd/dist/universal/UniversalDataModel.js

Codai Better Database - High-Performance Vector Memory System with HPKV-inspired architecture and MCP server

/**
 * CBD Universal Data Model
 * Foundation for multi-paradigm database support
 *
 * Phase 1: Core unified data model supporting all database paradigms
 */
import { z } from 'zod';
/**
 * Schema validation using Zod for runtime type safety
 */
export const UniversalRecordSchema = z.object({
    id: z.object({
        id: z.string(),
        version: z.number(),
        createdAt: z.date(),
        updatedAt: z.date(),
        sqlTable: z.string().optional(),
        docCollection: z.string().optional(),
        graphType: z.enum(['node', 'edge']).optional(),
        vectorDimensions: z.number().optional(),
        timeSeriesMetric: z.string().optional(),
        keyValueNamespace: z.string().optional(),
    }),
    data: z.union([
        z.object({ type: z.literal('relational'), schema: z.string(), table: z.string(), columns: z.record(z.any()) }),
        z.object({ type: z.literal('document'), collection: z.string(), document: z.record(z.any()) }),
        z.object({ type: z.literal('graph'), properties: z.record(z.any()) }),
        z.object({ type: z.literal('vector'), dimensions: z.number(), vector: z.array(z.number()) }),
        z.object({ type: z.literal('timeseries'), metric: z.string(), timestamp: z.date(), value: z.any() }),
        z.object({ type: z.literal('keyvalue'), key: z.string(), value: z.any() }),
    ]),
    indexes: z.record(z.any()),
    metadata: z.object({
        createdBy: z.string(),
        createdAt: z.date(),
        updatedBy: z.string(),
        updatedAt: z.date(),
        accessCount: z.number(),
        lastAccessed: z.date(),
    }),
    version: z.number(),
});
/**
 * Factory functions for creating data containers
 */
export class DataContainerFactory {
    static createRelational(schema, table, columns) {
        return {
            type: 'relational',
            schema,
            table,
            columns
        };
    }
    static createDocument(collection, document) {
        return {
            type: 'document',
            collection,
            document
        };
    }
    static createVector(dimensions, vector, metadata) {
        const result = {
            type: 'vector',
            dimensions,
            vector: new Float32Array(vector)
        };
        if (metadata !== undefined) {
            result.metadata = metadata;
        }
        return result;
    }
    static createTimeSeries(metric, value, tags) {
        const result = {
            type: 'timeseries',
            metric,
            timestamp: new Date(),
            value
        };
        if (tags !== undefined) {
            result.tags = tags;
        }
        return result;
    }
    static createKeyValue(key, value, namespace) {
        const result = {
            type: 'keyvalue',
            key,
            value
        };
        if (namespace !== undefined) {
            result.namespace = namespace;
        }
        return result;
    }
    static createGraphNode(labels, properties) {
        return {
            type: 'graph',
            labels,
            properties
        };
    }
    static createGraphEdge(sourceNodeId, targetNodeId, edgeType, properties = {}) {
        return {
            type: 'graph',
            edgeType,
            sourceNodeId,
            targetNodeId,
            properties,
            directed: true
        };
    }
}
/**
 * Universal record utilities
 */
export class UniversalRecordUtils {
    /**
     * Generate a new universal record ID
     */
    static generateId(paradigm, identifier) {
        const now = new Date();
        const baseId = {
            id: `${paradigm}_${identifier}_${now.getTime()}`,
            version: 1,
            createdAt: now,
            updatedAt: now
        };
        // Set paradigm-specific fields
        switch (paradigm) {
            case 'sql':
                baseId.sqlTable = identifier;
                break;
            case 'document':
                baseId.docCollection = identifier;
                break;
            case 'vector':
                baseId.vectorDimensions = parseInt(identifier) || 1536;
                break;
            case 'timeseries':
                baseId.timeSeriesMetric = identifier;
                break;
            case 'keyvalue':
                baseId.keyValueNamespace = identifier;
                break;
        }
        return baseId;
    }
    /**
     * Validate a universal record
     */
    static validate(record) {
        try {
            UniversalRecordSchema.parse(record);
            return { valid: true, errors: [] };
        }
        catch (error) {
            return {
                valid: false,
                errors: error.errors?.map((e) => `${e.path.join('.')}: ${e.message}`) || [error.message]
            };
        }
    }
    /**
     * Create metadata with defaults
     */
    static createMetadata(createdBy, tenantId) {
        const now = new Date();
        const result = {
            createdBy,
            createdAt: now,
            updatedBy: createdBy,
            updatedAt: now,
            accessCount: 0,
            lastAccessed: now,
            classification: 'internal'
        };
        if (tenantId !== undefined) {
            result.tenantId = tenantId;
        }
        return result;
    }
}
//# sourceMappingURL=UniversalDataModel.js.map