@canon-protocol/sdk 8.0.0

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

@@ -0,0 +1,161 @@
+import { OntologyValidationError } from '../../OntologyValidationError.js';
+import { ValidationSeverity } from '../../ValidationSeverity.js';
+export class InstancePropertyReferenceRule {
+    metadataKeys = new Set([
+        'type',
+        'label',
+        'comment',
+        'subClassOf',
+        'subPropertyOf',
+        'domain',
+        'range',
+        'inverseOf',
+        'transitive',
+        'symmetric',
+        'functional',
+        'inverseFunctional'
+    ]);
+    get ruleName() {
+        return 'InstancePropertyReference';
+    }
+    async validateAsync(document, repository) {
+        const errors = [];
+        const definedProperties = 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.isPropertyType(type)) {
+                    definedProperties.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 (this.isPropertyType(type) || this.isClassType(type)) {
+                    continue;
+                }
+                for (const [propertyName, propertyValue] of Object.entries(entity)) {
+                    if (!propertyName) {
+                        continue;
+                    }
+                    if (this.metadataKeys.has(propertyName)) {
+                        continue;
+                    }
+                    let actualPropertyName = propertyName;
+                    let namespaceAlias = null;
+                    if (propertyName.includes('.')) {
+                        const lastDotIndex = propertyName.lastIndexOf('.');
+                        namespaceAlias = propertyName.substring(0, lastDotIndex);
+                        actualPropertyName = propertyName.substring(lastDotIndex + 1);
+                    }
+                    if (definedProperties.has(actualPropertyName)) {
+                        continue;
+                    }
+                    const isAvailable = await this.isPropertyAvailableInImports(document, repository, actualPropertyName, namespaceAlias);
+                    if (!isAvailable) {
+                        const error = new OntologyValidationError();
+                        error.ruleType = this.ruleName;
+                        error.severity = ValidationSeverity.Error;
+                        error.message = `Property '${propertyName}' is not defined or imported`;
+                        error.suggestion = namespaceAlias
+                            ? `The property '${actualPropertyName}' is not found in the imported namespace with alias '${namespaceAlias}'.\n` +
+                                `  1. Verify the namespace is imported with the correct alias\n` +
+                                `  2. Check if the property name is spelled correctly\n` +
+                                `  3. Ensure the imported namespace version contains this property`
+                            : `The property '${propertyName}' is not defined in this namespace or any imported namespace.\n` +
+                                `  1. Define '${propertyName}' as an ObjectProperty or DatatypeProperty in this namespace, OR\n` +
+                                `  2. Import the namespace that contains '${propertyName}', OR\n` +
+                                `  3. Use a qualified reference like 'alias.${propertyName}' if already imported with an alias`;
+                        error.entityName = entityName;
+                        error.propertyName = propertyName;
+                        error.actualValue = propertyValue?.toString();
+                        error.expectedValue = 'A defined or imported property';
+                        errors.push(error);
+                    }
+                }
+            }
+        }
+        return errors;
+    }
+    isPropertyType(typeStr) {
+        if (!typeStr) {
+            return false;
+        }
+        return (typeStr === 'ObjectProperty' ||
+            typeStr === 'DatatypeProperty' ||
+            typeStr === 'AnnotationProperty' ||
+            typeStr === 'Property' ||
+            typeStr.endsWith('.ObjectProperty') ||
+            typeStr.endsWith('.DatatypeProperty') ||
+            typeStr.endsWith('.AnnotationProperty') ||
+            typeStr.endsWith('.Property'));
+    }
+    isClassType(typeStr) {
+        if (!typeStr) {
+            return false;
+        }
+        return typeStr === 'Class' || typeStr.endsWith('.Class');
+    }
+    async isPropertyAvailableInImports(document, repository, propertyName, namespaceAlias) {
+        if (!document.metadata.imports) {
+            return false;
+        }
+        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 entityDef = importedDoc.body[propertyName];
+                    if (entityDef && typeof entityDef === 'object' && !Array.isArray(entityDef)) {
+                        const entity = entityDef;
+                        const type = entity['type']?.toString();
+                        if (this.isPropertyType(type)) {
+                            return true;
+                        }
+                    }
+                    const visitedDocs = new Set();
+                    if (await this.isPropertyAvailableInImportsRecursive(importedDoc, repository, propertyName, visitedDocs)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    async isPropertyAvailableInImportsRecursive(document, repository, propertyName, visitedDocs) {
+        const docId = document.metadata.namespace_?.toString() ?? '';
+        if (docId && visitedDocs.has(docId)) {
+            return false;
+        }
+        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[propertyName];
+                    if (entityDef && typeof entityDef === 'object' && !Array.isArray(entityDef)) {
+                        const entity = entityDef;
+                        const type = entity['type']?.toString();
+                        if (this.isPropertyType(type)) {
+                            return true;
+                        }
+                    }
+                    if (await this.isPropertyAvailableInImportsRecursive(importedDoc, repository, propertyName, visitedDocs)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+}

package/dist/validation/rules/repository/NamespaceImportCycleRule.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 NamespaceImportCycleRule implements IRepositoryValidationRule {
+    get ruleName(): string;
+    validateAsync(document: CanonDocument, repository: ICanonDocumentRepository): Promise<OntologyValidationError[]>;
+    private buildImportGraph;
+    private detectCycle;
+    private detectCycleRecursive;
+}

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

@@ -0,0 +1,85 @@
+import { OntologyValidationError } from '../../OntologyValidationError.js';
+import { ValidationSeverity } from '../../ValidationSeverity.js';
+export class NamespaceImportCycleRule {
+    get ruleName() {
+        return 'NamespaceImportCycle';
+    }
+    async validateAsync(document, repository) {
+        const errors = [];
+        const currentNamespace = document.metadata.namespace_?.toString();
+        if (!currentNamespace) {
+            return errors; // No namespace, nothing to validate
+        }
+        const importGraph = new Map();
+        const visitedDocs = new Set();
+        await this.buildImportGraph(document, repository, importGraph, visitedDocs);
+        const cycle = this.detectCycle(currentNamespace, importGraph);
+        if (cycle) {
+            const cycleChain = cycle.join(' → ');
+            const error = new OntologyValidationError();
+            error.ruleType = this.ruleName;
+            error.severity = ValidationSeverity.Error;
+            error.message = `Circular namespace import detected: ${cycleChain}`;
+            error.suggestion =
+                'Remove one of the imports to break the circular dependency. ' +
+                    'Circular dependencies prevent proper package resolution.';
+            error.entityName = 'imports';
+            error.propertyName = 'imports';
+            error.actualValue = cycleChain;
+            errors.push(error);
+        }
+        return errors;
+    }
+    async buildImportGraph(document, repository, importGraph, visitedDocs) {
+        const docNamespace = document.metadata.namespace_?.toString() ?? '';
+        if (!docNamespace || visitedDocs.has(docNamespace)) {
+            return; // Already processed this document
+        }
+        visitedDocs.add(docNamespace);
+        if (document.metadata.imports) {
+            const imports = [];
+            for (const [publisher, importList] of Object.entries(document.metadata.imports)) {
+                for (const import_ of importList) {
+                    const importNamespace = `${publisher}/${import_.packageName}@${import_.version}`;
+                    imports.push(importNamespace);
+                    const importedDoc = await repository.getHighestCompatibleVersionAsync(publisher, import_);
+                    if (importedDoc) {
+                        await this.buildImportGraph(importedDoc, repository, importGraph, visitedDocs);
+                    }
+                }
+            }
+            if (imports.length > 0) {
+                importGraph.set(docNamespace, imports);
+            }
+        }
+    }
+    detectCycle(startNamespace, importGraph) {
+        const path = [];
+        const visited = new Set();
+        return this.detectCycleRecursive(startNamespace, importGraph, path, visited);
+    }
+    detectCycleRecursive(currentNamespace, importGraph, path, visited) {
+        const pathIndex = path.indexOf(currentNamespace);
+        if (pathIndex >= 0) {
+            const cycle = path.slice(pathIndex);
+            cycle.push(currentNamespace); // Complete the cycle
+            return cycle;
+        }
+        if (visited.has(currentNamespace)) {
+            return null;
+        }
+        path.push(currentNamespace);
+        visited.add(currentNamespace);
+        const imports = importGraph.get(currentNamespace);
+        if (imports) {
+            for (const importedNamespace of imports) {
+                const cycle = this.detectCycleRecursive(importedNamespace, importGraph, path, visited);
+                if (cycle) {
+                    return cycle;
+                }
+            }
+        }
+        path.pop();
+        return null;
+    }
+}

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

@@ -0,0 +1,9 @@
+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 ObjectPropertyImportRule implements IRepositoryValidationRule {
+    private readonly xsdTypes;
+    get ruleName(): string;
+    validateAsync(document: CanonDocument, repository: ICanonDocumentRepository): Promise<OntologyValidationError[]>;
+}

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

@@ -0,0 +1,113 @@
+import { OntologyValidationError } from '../../OntologyValidationError.js';
+import { ValidationSeverity } from '../../ValidationSeverity.js';
+import { ResourceResolver } from '../../../resolution/ResourceResolver.js';
+export class ObjectPropertyImportRule {
+    xsdTypes = new Set([
+        'string',
+        'integer',
+        'boolean',
+        'decimal',
+        'float',
+        'double',
+        'date',
+        'dateTime',
+        'time',
+        'duration',
+        'anyURI',
+        'base64Binary',
+        'hexBinary',
+        'long',
+        'int',
+        'short',
+        'byte',
+        'unsignedLong',
+        'unsignedInt',
+        'unsignedShort',
+        'unsignedByte',
+        'positiveInteger',
+        'nonPositiveInteger',
+        'negativeInteger',
+        'nonNegativeInteger',
+        'normalizedString',
+        'token',
+        'language',
+        'Name',
+        'NCName',
+        'ENTITY',
+        'ENTITIES',
+        'IDREF',
+        'IDREFS',
+        'NMTOKEN',
+        'NMTOKENS'
+    ]);
+    get ruleName() {
+        return 'ObjectPropertyImport';
+    }
+    async validateAsync(document, repository) {
+        const errors = [];
+        const referencedClasses = new Map(); // class -> properties that reference it
+        const resourceResolver = new ResourceResolver(repository);
+        await resourceResolver.buildEntityIndexAsync(document);
+        for (const [entityName, entityDef] of Object.entries(document.body)) {
+            if (typeof entityDef === 'object' && entityDef !== null && !Array.isArray(entityDef)) {
+                const entity = entityDef;
+                let isObjectProperty = false;
+                const typeValue = entity['type'];
+                if (Array.isArray(typeValue)) {
+                    for (const type of typeValue) {
+                        if (type?.toString() === 'ObjectProperty') {
+                            isObjectProperty = true;
+                            break;
+                        }
+                    }
+                }
+                else if (typeValue?.toString() === 'ObjectProperty') {
+                    isObjectProperty = true;
+                }
+                if (isObjectProperty) {
+                    const rangeValue = entity['range'];
+                    const rangeValues = [];
+                    if (Array.isArray(rangeValue)) {
+                        for (const item of rangeValue) {
+                            const itemStr = item?.toString();
+                            if (itemStr) {
+                                rangeValues.push(itemStr);
+                            }
+                        }
+                    }
+                    else {
+                        const rangeStr = rangeValue?.toString();
+                        if (rangeStr) {
+                            rangeValues.push(rangeStr);
+                        }
+                    }
+                    for (const range of rangeValues) {
+                        if (!this.xsdTypes.has(range)) {
+                            if (!referencedClasses.has(range)) {
+                                referencedClasses.set(range, []);
+                            }
+                            referencedClasses.get(range).push(entityName);
+                        }
+                    }
+                }
+            }
+        }
+        for (const [className, properties] of referencedClasses) {
+            const resolution = await resourceResolver.resolveEntityAsync(className, document);
+            if (!resolution) {
+                for (const propertyName of properties) {
+                    const error = new OntologyValidationError();
+                    error.ruleType = this.ruleName;
+                    error.severity = ValidationSeverity.Warning;
+                    error.message = `ObjectProperty references class '${className}' which may not be imported`;
+                    error.suggestion = `Ensure the namespace containing '${className}' is imported, or define '${className}' in this document`;
+                    error.entityName = propertyName;
+                    error.propertyName = 'range';
+                    error.actualValue = className;
+                    errors.push(error);
+                }
+            }
+        }
+        return errors;
+    }
+}

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

@@ -0,0 +1,12 @@
+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 ObjectPropertyValueValidationRule implements IRepositoryValidationRule {
+    private readonly standardProperties;
+    get ruleName(): string;
+    validateAsync(document: CanonDocument, repository: ICanonDocumentRepository): Promise<OntologyValidationError[]>;
+    private scanEntityForObjectProperties;
+    private validateRangeType;
+    private buildPropertyMetadataAsync;
+}