@glossarist/concept-browser 0.7.115 → 0.7.117

package/scripts/validate-yaml.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+
+// scripts/validate-yaml.ts
+import { readFileSync, readdirSync, statSync, existsSync } from "node:fs";
+import { join, extname, resolve } from "node:path";
+import { cwd } from "node:process";
+import yaml from "js-yaml";
+var SCHEMA_PATH = join(cwd(), "data", "concept-model", "shapes", "glossarist.concept.yaml.schema.json");
+function loadSchema() {
+  if (!existsSync(SCHEMA_PATH)) {
+    throw new Error(`Schema not found: ${SCHEMA_PATH}`);
+  }
+  return JSON.parse(readFileSync(SCHEMA_PATH, "utf8"));
+}
+function validateValue(value, schema, path, rootSchema, errors) {
+  if (schema.$ref) {
+    const ref = schema.$ref.replace(/^#\/\$defs\//, "");
+    validateValue(value, rootSchema.$defs?.[ref] ?? {}, path, rootSchema, errors);
+    return;
+  }
+  if (schema.type === "array") {
+    if (!Array.isArray(value)) {
+      errors.push({ path, message: `Expected array, got ${typeof value}` });
+      return;
+    }
+    for (let i = 0; i < value.length; i++) {
+      validateValue(value[i], schema.items ?? {}, `${path}[${i}]`, rootSchema, errors);
+    }
+    return;
+  }
+  if (schema.type && typeof value !== schema.type) {
+    errors.push({ path, message: `Expected ${schema.type}, got ${typeof value}` });
+    return;
+  }
+  if (schema.enum && !schema.enum.includes(value)) {
+    errors.push({ path, message: `"${value}" is not one of [${schema.enum.join(", ")}]` });
+    return;
+  }
+  if (schema.type === "object" && schema.properties) {
+    for (const [key, subSchema] of Object.entries(schema.properties)) {
+      if (value[key] !== void 0) {
+        validateValue(value[key], subSchema, `${path}.${key}`, rootSchema, errors);
+      }
+    }
+    if (schema.required) {
+      for (const req of schema.required) {
+        if (!(req in value)) {
+          errors.push({ path: `${path}.${req}`, message: `Missing required field: ${req}` });
+        }
+      }
+    }
+    if (schema.patternProperties) {
+      for (const [pattern, subSchema] of Object.entries(schema.patternProperties)) {
+        const re = new RegExp(pattern);
+        for (const key of Object.keys(value)) {
+          if (re.test(key) && !(key in (schema.properties ?? {}))) {
+            validateValue(value[key], subSchema, `${path}.${key}`, rootSchema, errors);
+          }
+        }
+      }
+    }
+  }
+  if (schema.type === "array" && Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      validateValue(value[i], schema.items ?? {}, `${path}[${i}]`, rootSchema, errors);
+    }
+  }
+}
+function validateYaml(yamlContent, schema) {
+  const data = yaml.load(yamlContent);
+  const errors = [];
+  if (Array.isArray(data)) {
+    for (let i = 0; i < data.length; i++) {
+      validateValue(data[i], schema, `doc[${i}]`, schema, errors);
+    }
+  } else if (data && typeof data === "object") {
+    validateValue(data, schema, "root", schema, errors);
+  } else {
+    errors.push({ path: "root", message: "YAML must be an object or array of objects" });
+  }
+  return { valid: errors.length === 0, errors };
+}
+function walkYaml(dir) {
+  const out = [];
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    const st = statSync(full);
+    if (st.isDirectory()) out.push(...walkYaml(full));
+    else if ([".yaml", ".yml"].includes(extname(entry))) out.push(full);
+  }
+  return out;
+}
+function main() {
+  const target = process.argv[2];
+  if (!target) {
+    console.error("Usage: validate-yaml <path-to-yaml-or-dir>");
+    process.exit(1);
+  }
+  const schema = loadSchema();
+  const resolvedTarget = resolve(target);
+  if (!existsSync(resolvedTarget)) {
+    console.error(`Path not found: ${resolvedTarget}`);
+    process.exit(1);
+  }
+  const files = statSync(resolvedTarget).isDirectory() ? walkYaml(resolvedTarget) : [resolvedTarget];
+  let totalValid = 0;
+  let totalErrors = 0;
+  for (const file of files) {
+    const content = readFileSync(file, "utf8");
+    const result = validateYaml(content, schema);
+    if (result.valid) {
+      totalValid++;
+    } else {
+      totalErrors += result.errors.length;
+      console.error(`FAIL: ${file}`);
+      for (const err of result.errors) console.error(`  ${err.path}: ${err.message}`);
+    }
+  }
+  console.log(`
+${totalValid}/${files.length} files valid, ${totalErrors} errors`);
+  process.exit(totalErrors > 0 ? 1 : 0);
+}
+var isDirect = process.argv[1] && resolve(process.argv[1]) === fileURLToPathPath();
+function fileURLToPathPath() {
+  return resolve(new URL(import.meta.url).pathname);
+}
+if (isDirect) main();
+export {
+  loadSchema,
+  validateValue,
+  validateYaml
+};

package/src/__tests__/published-package-contract.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect } from 'vitest';
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve, join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, '..', '..');
+const SCRIPTS_DIR = join(ROOT, 'scripts');
+
+const LIBRARY_SCRIPTS = [
+  'load-site-config',
+  'validate-yaml',
+  'normalize-yaml',
+  'extract-source-refs',
+  'migrate-v1-to-v3',
+];
+
+const PIPELINE_SCRIPTS = [
+  'fetch-datasets',
+  'generate-data',
+  'build-edges',
+  'process-about-pages',
+  'generate-ontology-data',
+  'generate-ontology-schema',
+  'doctor',
+  'validate-shacl',
+  'bridge-to-astro',
+  'sync-concept-model',
+  'generate-404',
+];
+
+function runPlain(args: string[], opts?: Parameters<typeof spawnSync>[2]): { status: number | null; stdout: string; stderr: string } {
+  const result = spawnSync('node', args, { encoding: 'utf8', cwd: ROOT, ...opts });
+  return {
+    status: result.status,
+    stdout: typeof result.stdout === 'string' ? result.stdout : result.stdout?.toString('utf8') ?? '',
+    stderr: typeof result.stderr === 'string' ? result.stderr : result.stderr?.toString('utf8') ?? '',
+  };
+}
+
+describe('published-package contract — compiled .js scripts load under plain node (no tsx)', () => {
+  it('npm run build:scripts produces .js for every script', () => {
+    const build = spawnSync('node', [join(ROOT, 'scripts', 'build-scripts.mjs')], {
+      encoding: 'utf8',
+      cwd: ROOT,
+    });
+    expect(build.status).toBe(0);
+
+    for (const name of [...LIBRARY_SCRIPTS, ...PIPELINE_SCRIPTS]) {
+      const jsPath = join(SCRIPTS_DIR, `${name}.js`);
+      expect(existsSync(jsPath)).toBe(true);
+    }
+  }, 30000);
+
+  it('library scripts export functions under plain node (ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING regression)', () => {
+    for (const name of LIBRARY_SCRIPTS) {
+      const jsPath = `./scripts/${name}.js`;
+      const result = runPlain(['--input-type=module', '-e', `import(${JSON.stringify(jsPath)}).then(m => console.log('OK', Object.keys(m).length)).catch(e => { console.error('FAIL', e.message); process.exit(1); })`]);
+      expect(result.stderr).not.toContain('ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING');
+      expect(result.status).toBe(0);
+      expect(result.stdout).toContain('OK');
+    }
+  }, 60000);
+
+  it('pipeline scripts do not throw ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING (may fail on missing config, that is OK)', () => {
+    for (const name of PIPELINE_SCRIPTS) {
+      const result = runPlain(['--input-type=module', '-e', `import(${JSON.stringify(`./scripts/${name}.js`)}).then(() => console.log('OK')).catch(e => { console.error(e.message); })`]);
+      expect(result.stderr).not.toContain('ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING');
+    }
+  }, 60000);
+
+  it('validate-yaml.js exports validateYaml function', () => {
+    const result = runPlain(['--input-type=module', '-e', `
+      import { validateYaml } from './scripts/validate-yaml.js';
+      const schema = { type: 'object', required: ['termid'], properties: { termid: { type: 'string' } } };
+      const r = validateYaml('termid: test', schema);
+      console.log('valid=' + r.valid);
+    `]);
+    expect(result.status).toBe(0);
+    expect(result.stdout).toContain('valid=true');
+  });
+
+  it('compiled scripts do not import devDependencies (runtime packaging regression)', () => {
+    const pkg = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf8'));
+    const deps = new Set(Object.keys(pkg.dependencies || {}));
+    const devDeps = new Set(Object.keys(pkg.devDependencies || {}));
+    for (const name of LIBRARY_SCRIPTS) {
+      const jsPath = join(SCRIPTS_DIR, `${name}.js`);
+      if (!existsSync(jsPath)) continue;
+      const src = readFileSync(jsPath, 'utf8');
+      for (const devDep of devDeps) {
+        if (deps.has(devDep)) continue;
+        expect(src).not.toContain(`from "${devDep}"`);
+        expect(src).not.toContain(`from '${devDep}'`);
+        expect(src).not.toMatch(new RegExp(`import\\s*\\(\\s*["']${devDep}["']`));
+      }
+    }
+  });
+});

package/src/__tests__/scripts-syntax.test.ts

@@ -13,7 +13,7 @@ describe('scripts syntax gate', () => {
     const result = spawnSync(
       process.execPath,
       ['--import', 'tsx', path.join(repoRoot, 'scripts', 'check-syntax.ts')],
-      { encoding: 'utf8' },
+      { encoding: 'utf8', timeout: 60000 },
     );
 
     if (result.status !== 0) {
@@ -24,5 +24,5 @@ describe('scripts syntax gate', () => {
 
     expect(result.status).toBe(0);
     expect(result.stdout).toMatch(/syntax OK:/);
-  });
+  }, 120000);
 });