@canon-protocol/sdk 8.0.0

package/dist/validation/rules/repository/PropertyRangeReferenceRule.js

@@ -0,0 +1,184 @@
+import { OntologyValidationError } from '../../OntologyValidationError.js';
+import { ValidationSeverity } from '../../ValidationSeverity.js';
+export class PropertyRangeReferenceRule {
+    builtInClasses = new Set([
+        'Resource',
+        'Class',
+        'Literal',
+        'Thing',
+        'Nothing',
+        'Property',
+        'DatatypeProperty',
+        'ObjectProperty',
+        'AnnotationProperty'
+    ]);
+    primitiveTypes = new Set([
+        'string', 'integer', 'int', 'long', 'short', 'byte',
+        'decimal', 'float', 'double', 'boolean', 'bool',
+        'dateTime', 'date', 'time', 'duration',
+        'anyURI', 'anySimpleType',
+        'nonNegativeInteger', 'positiveInteger',
+        'negativeInteger', 'nonPositiveInteger',
+        'unsignedInt', 'unsignedLong', 'unsignedShort', 'unsignedByte',
+        'base64Binary', 'hexBinary',
+        'Literal', 'Resource'
+    ]);
+    get ruleName() {
+        return 'PropertyRangeReference';
+    }
+    async validateAsync(document, repository) {
+        const errors = [];
+        const definedTypes = new Set();
+        for (const [entityName, entityDef] of Object.entries(document.body)) {
+            if (typeof entityDef === 'object' && entityDef !== null && !Array.isArray(entityDef)) {
+                const entity = entityDef;
+                const type = entity['type']?.toString();
+                if (this.isValidRangeTargetType(type)) {
+                    definedTypes.add(entityName);
+                }
+            }
+        }
+        for (const [entityName, entityDef] of Object.entries(document.body)) {
+            if (typeof entityDef === 'object' && entityDef !== null && !Array.isArray(entityDef)) {
+                const entity = entityDef;
+                const type = entity['type']?.toString();
+                if (type !== 'DatatypeProperty' &&
+                    type !== 'ObjectProperty' &&
+                    !type?.endsWith('.DatatypeProperty') &&
+                    !type?.endsWith('.ObjectProperty')) {
+                    continue;
+                }
+                const rangeValue = entity['range'];
+                if (!rangeValue) {
+                    continue; // PropertyRangeRequiredRule handles missing range
+                }
+                const rangeTypes = [];
+                if (Array.isArray(rangeValue)) {
+                    for (const item of rangeValue) {
+                        const itemStr = item?.toString();
+                        if (itemStr) {
+                            rangeTypes.push(itemStr);
+                        }
+                    }
+                }
+                else {
+                    const rangeStr = rangeValue?.toString();
+                    if (rangeStr) {
+                        rangeTypes.push(rangeStr);
+                    }
+                }
+                if (rangeTypes.length === 0) {
+                    continue;
+                }
+                for (const rangeType of rangeTypes) {
+                    if (this.primitiveTypes.has(rangeType)) {
+                        continue;
+                    }
+                    if (this.builtInClasses.has(rangeType)) {
+                        continue;
+                    }
+                    if (definedTypes.has(rangeType)) {
+                        continue;
+                    }
+                    const isAvailable = await this.isTypeAvailableInImports(document, repository, rangeType);
+                    if (!isAvailable) {
+                        const propertyType = type?.includes('ObjectProperty') ? 'ObjectProperty' : 'DatatypeProperty';
+                        const error = new OntologyValidationError();
+                        error.ruleType = this.ruleName;
+                        error.severity = ValidationSeverity.Error;
+                        error.message = `Property '${entityName}' has range '${rangeType}' which is not defined or imported`;
+                        error.suggestion =
+                            propertyType === 'ObjectProperty'
+                                ? `For ObjectProperty:\n` +
+                                    `  1. Define '${rangeType}' as a Class in this namespace, OR\n` +
+                                    `  2. Import the namespace that contains '${rangeType}', OR\n` +
+                                    `  3. Use a qualified reference like 'alias.${rangeType}' if already imported with an alias`
+                                : `For DatatypeProperty:\n` +
+                                    `  1. Use a primitive type (string, integer, boolean, dateTime, etc.), OR\n` +
+                                    `  2. If '${rangeType}' should be a class, change property type to ObjectProperty`;
+                        error.entityName = entityName;
+                        error.propertyName = 'range';
+                        error.actualValue = rangeType;
+                        error.expectedValue =
+                            propertyType === 'ObjectProperty' ? 'A defined or imported class name' : 'A primitive type or defined class';
+                        errors.push(error);
+                    }
+                }
+            }
+        }
+        return errors;
+    }
+    async isTypeAvailableInImports(document, repository, typeName) {
+        if (!document.metadata.imports) {
+            return false;
+        }
+        let namespaceAlias = null;
+        let actualTypeName = typeName;
+        if (typeName.includes('.')) {
+            const parts = typeName.split('.', 2);
+            namespaceAlias = parts[0];
+            actualTypeName = parts[1];
+        }
+        for (const [publisher, imports] of Object.entries(document.metadata.imports)) {
+            for (const import_ of imports) {
+                if (namespaceAlias !== null && import_.alias !== namespaceAlias) {
+                    continue;
+                }
+                const importedDoc = await repository.getHighestCompatibleVersionAsync(publisher, import_);
+                if (importedDoc) {
+                    const lookupName = namespaceAlias !== null ? actualTypeName : typeName;
+                    const entityDef = importedDoc.body[lookupName];
+                    if (entityDef && typeof entityDef === 'object' && !Array.isArray(entityDef)) {
+                        const entity = entityDef;
+                        const type = entity['type']?.toString();
+                        if (this.isValidRangeTargetType(type)) {
+                            return true;
+                        }
+                    }
+                    const visitedDocs = new Set();
+                    if (await this.isTypeAvailableInImportsRecursive(importedDoc, repository, lookupName, visitedDocs)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    async isTypeAvailableInImportsRecursive(document, repository, typeName, visitedDocs) {
+        const docId = document.metadata.namespace_?.toString() ?? '';
+        if (docId && visitedDocs.has(docId)) {
+            return false; // Already checked this document
+        }
+        if (docId) {
+            visitedDocs.add(docId);
+        }
+        if (!document.metadata.imports) {
+            return false;
+        }
+        for (const [publisher, imports] of Object.entries(document.metadata.imports)) {
+            for (const import_ of imports) {
+                const importedDoc = await repository.getHighestCompatibleVersionAsync(publisher, import_);
+                if (importedDoc) {
+                    const entityDef = importedDoc.body[typeName];
+                    if (entityDef && typeof entityDef === 'object' && !Array.isArray(entityDef)) {
+                        const entity = entityDef;
+                        const type = entity['type']?.toString();
+                        if (this.isValidRangeTargetType(type)) {
+                            return true;
+                        }
+                    }
+                    if (await this.isTypeAvailableInImportsRecursive(importedDoc, repository, typeName, visitedDocs)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    isValidRangeTargetType(type) {
+        if (!type)
+            return false;
+        return type === 'Class' || type.endsWith('.Class')
+            || type === 'Datatype' || type.endsWith('.Datatype');
+    }
+}

package/dist/validation/rules/repository/PropertyRangeRequiredRule.d.ts

@@ -0,0 +1,8 @@
+import type { CanonDocument } from '@canon-protocol/types/document/models/types';
+import type { ICanonDocumentRepository } from '@canon-protocol/types/document/models';
+import type { IRepositoryValidationRule } from './IRepositoryValidationRule.js';
+import { OntologyValidationError } from '../../OntologyValidationError.js';
+export declare class PropertyRangeRequiredRule implements IRepositoryValidationRule {
+    get ruleName(): string;
+    validateAsync(document: CanonDocument, _repository: ICanonDocumentRepository): Promise<OntologyValidationError[]>;
+}

package/dist/validation/rules/repository/PropertyRangeRequiredRule.js

@@ -0,0 +1,40 @@
+import { OntologyValidationError } from '../../OntologyValidationError.js';
+import { ValidationSeverity } from '../../ValidationSeverity.js';
+export class PropertyRangeRequiredRule {
+    get ruleName() {
+        return 'PropertyRangeRequired';
+    }
+    async validateAsync(document, _repository) {
+        const errors = [];
+        for (const [entityName, entityDef] of Object.entries(document.body)) {
+            if (typeof entityDef !== 'object' || entityDef === null || Array.isArray(entityDef)) {
+                continue;
+            }
+            const entity = entityDef;
+            const type = entity['type']?.toString();
+            if (type === 'DatatypeProperty' || type === 'ObjectProperty' ||
+                type?.endsWith('.DatatypeProperty') || type?.endsWith('.ObjectProperty')) {
+                const hasRange = 'range' in entity;
+                const rangeValue = entity['range']?.toString().trim();
+                if (!hasRange || !rangeValue) {
+                    const error = new OntologyValidationError();
+                    error.ruleType = this.ruleName;
+                    error.severity = ValidationSeverity.Error;
+                    error.entityName = entityName;
+                    error.propertyName = 'range';
+                    error.message = `Property '${entityName}' must have a 'range' defined.`;
+                    error.suggestion =
+                        type === 'DatatypeProperty'
+                            ? 'Add a range like: range: string (or integer, boolean, etc.)'
+                            : 'Add a range like: range: ClassName (the class this property expects)';
+                    error.expectedValue =
+                        type === 'DatatypeProperty'
+                            ? 'A datatype (string, integer, boolean, decimal, etc.)'
+                            : 'A class name (Character, Scene, Story, etc.)';
+                    errors.push(error);
+                }
+            }
+        }
+        return errors;
+    }
+}

package/dist/validation/rules/repository/PropertyValueTypeRule.d.ts

@@ -0,0 +1,11 @@
+import type { CanonDocument } from '@canon-protocol/types/document/models/types';
+import type { ICanonDocumentRepository } from '@canon-protocol/types/document/models';
+import type { IRepositoryValidationRule } from './IRepositoryValidationRule.js';
+import { OntologyValidationError } from '../../OntologyValidationError.js';
+export declare class PropertyValueTypeRule implements IRepositoryValidationRule {
+    get ruleName(): string;
+    validateAsync(document: CanonDocument, _repository: ICanonDocumentRepository): Promise<OntologyValidationError[]>;
+    private validateDatatypeValue;
+    private getValueTypeName;
+    private getPropertyValue;
+}

package/dist/validation/rules/repository/PropertyValueTypeRule.js

@@ -0,0 +1,171 @@
+import { ValidationSeverity } from '../../ValidationSeverity.js';
+export class PropertyValueTypeRule {
+    get ruleName() {
+        return 'PropertyValueType';
+    }
+    async validateAsync(document, _repository) {
+        const errors = [];
+        const propertyDefinitions = new Map();
+        for (const [entityName, entityDef] of Object.entries(document.body)) {
+            if (typeof entityDef === 'object' && entityDef !== null && !Array.isArray(entityDef)) {
+                const entity = entityDef;
+                const type = this.getPropertyValue(entity, 'type');
+                if (type === 'DatatypeProperty' || type === 'ObjectProperty') {
+                    propertyDefinitions.set(entityName, entity);
+                }
+            }
+        }
+        for (const [entityName, entityDef] of Object.entries(document.body)) {
+            if (typeof entityDef !== 'object' || entityDef === null || Array.isArray(entityDef)) {
+                continue;
+            }
+            const entity = entityDef;
+            const entityType = this.getPropertyValue(entity, 'type');
+            if (!entityType ||
+                entityType === 'Class' ||
+                entityType.endsWith('Property') ||
+                entityType === 'AnnotationProperty') {
+                continue;
+            }
+            for (const [propName, propValue] of Object.entries(entity)) {
+                if (propName === 'type' || propName === 'label' || propName === 'comment') {
+                    continue;
+                }
+                let lookupName = propName;
+                const dotIndex = propName.lastIndexOf('.');
+                if (dotIndex > 0 && dotIndex < propName.length - 1) {
+                    lookupName = propName.substring(dotIndex + 1);
+                }
+                const propDef = propertyDefinitions.get(lookupName);
+                if (!propDef) {
+                    continue;
+                }
+                const propertyType = this.getPropertyValue(propDef, 'type');
+                const propertyRange = this.getPropertyValue(propDef, 'range');
+                if (propertyType === 'DatatypeProperty') {
+                    if ((typeof propValue === 'object' && propValue !== null && !Array.isArray(propValue)) ||
+                        Array.isArray(propValue)) {
+                        errors.push({
+                            ruleType: this.ruleName,
+                            severity: ValidationSeverity.Error,
+                            entityName: entityName,
+                            propertyName: propName,
+                            message: `Property '${propName}' is a DatatypeProperty with range '${propertyRange}' but instance '${entityName}' has a complex object value`,
+                            suggestion: `Either:\n` +
+                                `  1. Create a class for this data and change '${propName}' to an ObjectProperty\n` +
+                                `  2. Store as a JSON string to keep it as DatatypeProperty\n` +
+                                `  3. Use separate properties instead of nesting`,
+                            expectedValue: `A simple value of type '${propertyRange}'`
+                        });
+                    }
+                    else if (!this.validateDatatypeValue(propertyRange, propValue)) {
+                        const error = {
+                            ruleType: this.ruleName,
+                            severity: ValidationSeverity.Error,
+                            entityName: entityName,
+                            propertyName: propName,
+                            message: `Property '${propName}' expects type '${propertyRange}' but instance '${entityName}' has value of type '${this.getValueTypeName(propValue)}'`,
+                            suggestion: `Provide a value of type '${propertyRange}'`,
+                            toString: () => ''
+                        };
+                        if (propertyRange) {
+                            error.expectedValue = propertyRange;
+                        }
+                        errors.push(error);
+                    }
+                }
+                else if (propertyType === 'ObjectProperty') {
+                    if (Array.isArray(propValue)) {
+                        for (let i = 0; i < propValue.length; i++) {
+                            const item = propValue[i];
+                            if (typeof item !== 'string' &&
+                                (typeof item !== 'object' || item === null || Array.isArray(item))) {
+                                errors.push({
+                                    ruleType: this.ruleName,
+                                    severity: ValidationSeverity.Error,
+                                    entityName: entityName,
+                                    propertyName: `${propName}[${i}]`,
+                                    message: `ObjectProperty '${propName}' array item ${i} in instance '${entityName}' has invalid type '${this.getValueTypeName(item)}'`,
+                                    suggestion: 'Array items must be references (strings) or embedded objects (dictionaries)',
+                                    expectedValue: 'string or object'
+                                });
+                            }
+                        }
+                    }
+                    else if (typeof propValue !== 'string' &&
+                        (typeof propValue !== 'object' || propValue === null || Array.isArray(propValue))) {
+                        errors.push({
+                            ruleType: this.ruleName,
+                            severity: ValidationSeverity.Error,
+                            entityName: entityName,
+                            propertyName: propName,
+                            message: `ObjectProperty '${propName}' in instance '${entityName}' has invalid value type '${this.getValueTypeName(propValue)}'`,
+                            suggestion: 'Value must be a reference (string), embedded object (dictionary), or array of these',
+                            expectedValue: `Reference to ${propertyRange} or embedded ${propertyRange} object`
+                        });
+                    }
+                }
+            }
+        }
+        return errors;
+    }
+    validateDatatypeValue(range, value) {
+        const rangeLower = range?.toLowerCase();
+        switch (rangeLower) {
+            case 'string':
+                return typeof value === 'string';
+            case 'integer':
+            case 'int':
+                return typeof value === 'number' && Number.isInteger(value);
+            case 'decimal':
+                return typeof value === 'number';
+            case 'boolean':
+                return typeof value === 'boolean';
+            case 'float':
+            case 'double':
+                return typeof value === 'number';
+            default:
+                return true;
+        }
+    }
+    getValueTypeName(value) {
+        if (typeof value === 'string') {
+            return 'string';
+        }
+        else if (typeof value === 'number') {
+            return Number.isInteger(value) ? 'integer' : 'decimal';
+        }
+        else if (typeof value === 'boolean') {
+            return 'boolean';
+        }
+        else if (Array.isArray(value)) {
+            return 'array';
+        }
+        else if (typeof value === 'object' && value !== null) {
+            return 'object';
+        }
+        else if (value === null) {
+            return 'null';
+        }
+        else if (value === undefined) {
+            return 'undefined';
+        }
+        else {
+            return typeof value;
+        }
+    }
+    getPropertyValue(dict, propertyName) {
+        if (propertyName in dict) {
+            const value = dict[propertyName];
+            if (Array.isArray(value)) {
+                const items = [];
+                for (const item of value) {
+                    items.push(item?.toString() ?? '');
+                }
+                return items.length > 0 ? items[0] : undefined;
+            }
+            return value?.toString();
+        }
+        return undefined;
+    }
+}

package/dist/validation/rules/repository/SubClassOfReferenceRule.d.ts

@@ -0,0 +1,11 @@
+import type { CanonDocument } from '@canon-protocol/types/document/models/types';
+import type { ICanonDocumentRepository } from '@canon-protocol/types/document/models';
+import type { IRepositoryValidationRule } from './IRepositoryValidationRule.js';
+import { OntologyValidationError } from '../../OntologyValidationError.js';
+export declare class SubClassOfReferenceRule implements IRepositoryValidationRule {
+    private readonly builtInClasses;
+    get ruleName(): string;
+    validateAsync(document: CanonDocument, repository: ICanonDocumentRepository): Promise<OntologyValidationError[]>;
+    private isClassAvailableInImports;
+    private isClassAvailableInImportsRecursive;
+}

package/dist/validation/rules/repository/SubClassOfReferenceRule.js

@@ -0,0 +1,133 @@
+import { OntologyValidationError } from '../../OntologyValidationError.js';
+import { ValidationSeverity } from '../../ValidationSeverity.js';
+import { normalizeToStringList } from '../normalizeToStringList.js';
+export class SubClassOfReferenceRule {
+    builtInClasses = new Set([
+        'Resource',
+        'Class',
+        'Literal',
+        'Thing',
+        'Nothing',
+        'Property',
+        'DatatypeProperty',
+        'ObjectProperty',
+        'AnnotationProperty',
+        'FunctionalProperty',
+        'InverseFunctionalProperty',
+        'TransitiveProperty',
+        'SymmetricProperty'
+    ]);
+    get ruleName() {
+        return 'SubClassOfReference';
+    }
+    async validateAsync(document, repository) {
+        const errors = [];
+        const definedClasses = new Set();
+        for (const [entityName, entityDef] of Object.entries(document.body)) {
+            if (typeof entityDef === 'object' && entityDef !== null && !Array.isArray(entityDef)) {
+                const entity = entityDef;
+                const type = entity['type']?.toString();
+                if (type === 'Class' || (type && type.endsWith('.Class'))) {
+                    definedClasses.add(entityName);
+                }
+            }
+        }
+        for (const [entityName, entityDef] of Object.entries(document.body)) {
+            if (typeof entityDef === 'object' && entityDef !== null && !Array.isArray(entityDef)) {
+                const entity = entityDef;
+                const parentClasses = normalizeToStringList(entity['subClassOf']);
+                for (let i = 0; i < parentClasses.length; i++) {
+                    const parentClass = parentClasses[i];
+                    if (this.builtInClasses.has(parentClass)) {
+                        continue;
+                    }
+                    if (definedClasses.has(parentClass)) {
+                        continue;
+                    }
+                    const isAvailable = await this.isClassAvailableInImports(document, repository, parentClass);
+                    if (!isAvailable) {
+                        const indexSuffix = parentClasses.length > 1 ? `[${i}]` : '';
+                        const error = new OntologyValidationError();
+                        error.ruleType = this.ruleName;
+                        error.severity = ValidationSeverity.Error;
+                        error.message = `Class '${parentClass}' referenced in subClassOf${indexSuffix} is not defined or imported`;
+                        error.suggestion = `Define '${parentClass}' as a Class, or import a namespace that contains it`;
+                        error.entityName = entityName;
+                        error.propertyName = 'subClassOf';
+                        error.actualValue = parentClass;
+                        error.expectedValue = 'Defined or imported class';
+                        errors.push(error);
+                    }
+                }
+            }
+        }
+        return errors;
+    }
+    async isClassAvailableInImports(document, repository, className) {
+        if (!document.metadata.imports) {
+            return false;
+        }
+        let namespaceAlias = null;
+        let actualClassName = className;
+        if (className.includes('.')) {
+            const parts = className.split('.', 2);
+            namespaceAlias = parts[0];
+            actualClassName = parts[1];
+        }
+        for (const [publisher, imports] of Object.entries(document.metadata.imports)) {
+            for (const import_ of imports) {
+                if (namespaceAlias !== null && import_.alias !== namespaceAlias) {
+                    continue;
+                }
+                const importedDoc = await repository.getHighestCompatibleVersionAsync(publisher, import_);
+                if (importedDoc) {
+                    const lookupName = namespaceAlias !== null ? actualClassName : className;
+                    const entityDef = importedDoc.body[lookupName];
+                    if (entityDef && typeof entityDef === 'object' && !Array.isArray(entityDef)) {
+                        const entity = entityDef;
+                        const type = entity['type']?.toString();
+                        if (type === 'Class' || (type && type.endsWith('.Class'))) {
+                            return true; // Found the class definition
+                        }
+                    }
+                    const visitedDocs = new Set();
+                    if (await this.isClassAvailableInImportsRecursive(importedDoc, repository, lookupName, visitedDocs)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    async isClassAvailableInImportsRecursive(document, repository, className, visitedDocs) {
+        const docId = document.metadata.namespace_?.toString() ?? '';
+        if (docId && visitedDocs.has(docId)) {
+            return false; // Already checked this document
+        }
+        if (docId) {
+            visitedDocs.add(docId);
+        }
+        if (!document.metadata.imports) {
+            return false;
+        }
+        for (const [publisher, imports] of Object.entries(document.metadata.imports)) {
+            for (const import_ of imports) {
+                const importedDoc = await repository.getHighestCompatibleVersionAsync(publisher, import_);
+                if (importedDoc) {
+                    const entityDef = importedDoc.body[className];
+                    if (entityDef && typeof entityDef === 'object' && !Array.isArray(entityDef)) {
+                        const entity = entityDef;
+                        const type = entity['type']?.toString();
+                        if (type === 'Class' || (type && type.endsWith('.Class'))) {
+                            return true;
+                        }
+                    }
+                    if (await this.isClassAvailableInImportsRecursive(importedDoc, repository, className, visitedDocs)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+}

package/dist/validation/rules/repository/SubPropertyOfReferenceRule.d.ts

@@ -0,0 +1,11 @@
+import type { CanonDocument } from '@canon-protocol/types/document/models/types';
+import type { ICanonDocumentRepository } from '@canon-protocol/types/document/models';
+import type { IRepositoryValidationRule } from './IRepositoryValidationRule.js';
+import { OntologyValidationError } from '../../OntologyValidationError.js';
+export declare class SubPropertyOfReferenceRule implements IRepositoryValidationRule {
+    private readonly builtInProperties;
+    get ruleName(): string;
+    validateAsync(document: CanonDocument, repository: ICanonDocumentRepository): Promise<OntologyValidationError[]>;
+    private isPropertyAvailableInImports;
+    private isPropertyAvailableInImportsRecursive;
+}