glossarist 0.1.1 → 0.1.2

package/src/uuid.js

@@ -0,0 +1,28 @@
+import { createHash } from 'crypto';
+
+const NAMESPACE_UUID = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+
+export function uuidV5(namespace, name) {
+  const ns = _parseUuid(namespace);
+  const hash = createHash('sha1').update(ns).update(name, 'utf8').digest();
+  hash[6] = (hash[6] & 0x0f) | 0x50;
+  hash[8] = (hash[8] & 0x3f) | 0x80;
+  return _formatUuid(hash);
+}
+
+export function conceptUuid(conceptId, namespace = NAMESPACE_UUID) {
+  return uuidV5(namespace, conceptId);
+}
+
+export function localizedConceptUuid(conceptId, languageCode, namespace = NAMESPACE_UUID) {
+  return uuidV5(namespace, `${conceptId}:${languageCode}`);
+}
+
+function _parseUuid(str) {
+  return Buffer.from(str.replace(/-/g, ''), 'hex');
+}
+
+function _formatUuid(hash) {
+  const h = hash.toString('hex');
+  return [h.slice(0, 8), h.slice(8, 12), h.slice(12, 16), h.slice(16, 20), h.slice(20, 32)].join('-');
+}

package/src/v1-reader.js

@@ -0,0 +1,63 @@
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+import { Concept } from './models/concept.js';
+import { InvalidInputError } from './errors.js';
+
+export class V1Reader {
+  static isV1Directory(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    return entries.some(e =>
+      e.isDirectory() && fs.existsSync(path.join(dir, e.name, 'concept.yaml'))
+    );
+  }
+
+  static readConcept(conceptDir) {
+    const conceptFile = path.join(conceptDir, 'concept.yaml');
+    if (!fs.existsSync(conceptFile)) {
+      throw new InvalidInputError(`No concept.yaml found in ${conceptDir}`);
+    }
+
+    const data = yaml.load(fs.readFileSync(conceptFile, 'utf8'));
+    const localizations = {};
+
+    for (const file of fs.readdirSync(conceptDir)) {
+      if (file === 'concept.yaml' || !file.endsWith('.yaml')) continue;
+      const lang = file.slice(0, -'.yaml'.length);
+      localizations[lang] = yaml.load(fs.readFileSync(path.join(conceptDir, file), 'utf8'));
+    }
+
+    return new Concept({
+      id: String(data.termid ?? data.data?.identifier ?? path.basename(conceptDir)),
+      term: data.term ?? null,
+      localizations,
+      raw: data,
+    });
+  }
+
+  static readAll(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    const concepts = [];
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const conceptDir = path.join(dir, entry.name);
+      if (!fs.existsSync(path.join(conceptDir, 'concept.yaml'))) continue;
+      try {
+        concepts.push(V1Reader.readConcept(conceptDir));
+      } catch { /* skip unreadable concepts */ }
+    }
+
+    return concepts;
+  }
+}
+
+export async function migrateV1ToV2(v1Dir, v2Dir) {
+  const concepts = V1Reader.readAll(v1Dir);
+  const { writeConcept } = await import('./concept-writer.js');
+  fs.mkdirSync(v2Dir, { recursive: true });
+
+  for (const concept of concepts) {
+    writeConcept(v2Dir, concept, 'canonical');
+  }
+}

package/src/validators/concept-validator.js

@@ -0,0 +1,119 @@
+import { ValidationRule } from './validation-rule.js';
+import { ValidationError } from './validation-error.js';
+
+const VALID_DESIGNATION_TYPES = new Set([
+  'expression', 'abbreviation', 'symbol', 'graphical symbol', 'graphical_symbol',
+]);
+
+const VALID_ENTRY_STATUSES = new Set([
+  'valid', 'draft', 'retired', 'notValid', 'superseded', 'withdrawn',
+]);
+
+export class LanguageCodeRule extends ValidationRule {
+  constructor() { super('language-code'); }
+  validate(value, path) {
+    if (!value.localizations) return [];
+    const errors = [];
+    for (const lang of Object.keys(value.localizations)) {
+      if (!/^[a-z]{3}$/.test(lang)) {
+        errors.push(...this.error(`${path}localizations.${lang}`,
+          `Invalid language code '${lang}': expected ISO 639-3 (3 lowercase letters)`));
+      }
+    }
+    return errors;
+  }
+}
+
+export class DesignationTypeRule extends ValidationRule {
+  constructor() { super('designation-type'); }
+  validate(value, path) {
+    if (!value.localizations) return [];
+    const errors = [];
+    for (const [lang, lc] of Object.entries(value.localizations)) {
+      for (let i = 0; i < (lc.terms?.length ?? 0); i++) {
+        const t = lc.terms[i];
+        if (t.type && !VALID_DESIGNATION_TYPES.has(t.type)) {
+          errors.push(...this.error(`${path}localizations.${lang}.terms[${i}].type`,
+            `Unknown designation type '${t.type}'`));
+        }
+      }
+    }
+    return errors;
+  }
+}
+
+export class EntryStatusRule extends ValidationRule {
+  constructor() { super('entry-status'); }
+  validate(value, path) {
+    if (!value.localizations) return [];
+    const errors = [];
+    for (const [lang, lc] of Object.entries(value.localizations)) {
+      if (lc.entry_status && !VALID_ENTRY_STATUSES.has(lc.entry_status)) {
+        errors.push(...this.error(`${path}localizations.${lang}.entry_status`,
+          `Unknown entry status '${lc.entry_status}'`));
+      }
+    }
+    return errors;
+  }
+}
+
+export class ConceptValidator {
+  _rules = [];
+
+  addRule(rule) {
+    this._rules.push(rule);
+    return this;
+  }
+
+  validate(concept) {
+    const errors = [];
+    const json = typeof concept.toJSON === 'function' ? concept.toJSON() : concept;
+
+    if (!json.id) {
+      errors.push(new ValidationError('id', 'Concept must have an id'));
+    }
+    if (!json.localizations || Object.keys(json.localizations).length === 0) {
+      errors.push(new ValidationError('localizations',
+        'Concept must have at least one localization', 'warning'));
+    } else {
+      for (const [lang, lc] of Object.entries(json.localizations)) {
+        if (!lc.terms || lc.terms.length === 0) {
+          errors.push(new ValidationError(
+            `localizations.${lang}.terms`,
+            `Localization '${lang}' must have at least one term`, 'warning'));
+        }
+      }
+    }
+
+    for (const rule of this._rules) {
+      errors.push(...rule.validate(json, ''));
+    }
+
+    return {
+      valid: errors.filter(e => e.severity === 'error').length === 0,
+      errors: errors.filter(e => e.severity === 'error'),
+      warnings: errors.filter(e => e.severity === 'warning'),
+    };
+  }
+}
+
+export class RegisterValidator {
+  validate(register) {
+    const errors = [];
+    if (!register || typeof register !== 'object') {
+      errors.push(new ValidationError('', 'Register must be a non-null object'));
+      return { valid: false, errors, warnings: [] };
+    }
+    if (!register.schema_version) {
+      errors.push(new ValidationError('schema_version', 'Register must have a schema_version', 'warning'));
+    }
+    if (!register.shortname) {
+      errors.push(new ValidationError('shortname', 'Register should have a shortname', 'warning'));
+    }
+    return {
+      valid: errors.filter(e => e.severity === 'error').length === 0,
+      errors: errors.filter(e => e.severity === 'error'),
+      warnings: errors.filter(e => e.severity === 'warning'),
+    };
+  }
+}

package/src/validators/index.d.ts

@@ -0,0 +1,26 @@
+export class ValidationError {
+  readonly path: string;
+  readonly message: string;
+  readonly severity: 'error' | 'warning';
+  toString(): string;
+}
+
+export class ValidationRule {
+  readonly name: string;
+  readonly severity: 'error' | 'warning';
+  validate(value: any, path: string): ValidationError[];
+}
+
+export function validateConcept(concept: any): {
+  valid: boolean;
+  errors: ValidationError[];
+  warnings: ValidationError[];
+};
+
+export function validateRegister(register: any): {
+  valid: boolean;
+  errors: ValidationError[];
+  warnings: ValidationError[];
+};
+
+export function createConceptValidator(): import('./concept-validator').ConceptValidator;

package/src/validators/index.js

@@ -0,0 +1,23 @@
+export { ValidationError } from './validation-error.js';
+export { ValidationRule } from './validation-rule.js';
+export { ConceptValidator, RegisterValidator, LanguageCodeRule, DesignationTypeRule, EntryStatusRule } from './concept-validator.js';
+
+import { ConceptValidator, LanguageCodeRule, DesignationTypeRule, EntryStatusRule } from './concept-validator.js';
+import { RegisterValidator } from './concept-validator.js';
+
+const _default = new ConceptValidator()
+  .addRule(new LanguageCodeRule())
+  .addRule(new DesignationTypeRule())
+  .addRule(new EntryStatusRule());
+
+export function validateConcept(concept) {
+  return _default.validate(concept);
+}
+
+export function createConceptValidator() {
+  return new ConceptValidator();
+}
+
+export function validateRegister(register) {
+  return new RegisterValidator().validate(register);
+}

package/src/validators/validation-error.js

@@ -0,0 +1,11 @@
+export class ValidationError {
+  constructor(path, message, severity = 'error') {
+    this.path = path;
+    this.message = message;
+    this.severity = severity;
+  }
+
+  toString() {
+    return `[${this.severity.toUpperCase()}] ${this.path}: ${this.message}`;
+  }
+}

package/src/validators/validation-rule.js

@@ -0,0 +1,16 @@
+import { ValidationError } from './validation-error.js';
+
+export class ValidationRule {
+  constructor(name, severity = 'error') {
+    this.name = name;
+    this.severity = severity;
+  }
+
+  validate(_value, _path) {
+    throw new Error(`${this.constructor.name} must implement validate()`);
+  }
+
+  error(path, message) {
+    return [new ValidationError(path, message, this.severity)];
+  }
+}