@cobbled-creators/cobblemon-schemas 1.7.0

package/src/node/load-schemas.mjs

@@ -0,0 +1,35 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import Ajv2020 from 'ajv/dist/2020.js';
+import { packageRoot, schemaRoot } from './package-info.mjs';
+
+const AJV_OPTIONS = { allErrors: true, strict: false, allowUnionTypes: true, verbose: true };
+
+export function loadSchemas(root = schemaRoot, ajvOptions = {}) {
+  const ajv = new Ajv2020({ ...AJV_OPTIONS, ...ajvOptions });
+  for (const file of schemaFiles(root)) {
+    const schema = JSON.parse(fs.readFileSync(file, 'utf8'));
+    ajv.addSchema(schema, schema.$id ?? path.relative(packageRoot, file));
+  }
+  return { ajv, entries: readIndex(root) };
+}
+
+function readIndex(root) {
+  const index = JSON.parse(fs.readFileSync(path.join(root, 'index.json'), 'utf8'));
+  return index.schemas
+    .filter((entry) => !entry.path.startsWith('schemas/_shared/'))
+    .map((entry) => ({ path: entry.path, id: entry.$id, ...(entry.dataPath ? { dataPath: entry.dataPath } : {}) }));
+}
+
+function* schemaFiles(dir) {
+  const children = fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  for (const child of children) {
+    const childPath = path.join(dir, child.name);
+    if (child.isDirectory()) yield* schemaFiles(childPath);
+    else if (isSchemaFile(child.name)) yield childPath;
+  }
+}
+
+function isSchemaFile(name) {
+  return name === 'schema.json' || name.endsWith('.schema.json');
+}

package/src/node/package-info.mjs

@@ -0,0 +1,10 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+export const schemaRoot = path.join(packageRoot, 'schemas');
+export const distRoot = path.join(packageRoot, 'dist');
+
+export const packageJson = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
+export const cobblemon = packageJson.cobblemon;

package/src/node/read-pack.mjs

@@ -0,0 +1,18 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export function readPack(packRoot) {
+  const files = new Map();
+  for (const relativePath of jsonFiles(packRoot, '')) {
+    files.set(relativePath, fs.readFileSync(path.join(packRoot, relativePath)));
+  }
+  return files;
+}
+
+function* jsonFiles(packRoot, relativeDir) {
+  for (const child of fs.readdirSync(path.join(packRoot, relativeDir), { withFileTypes: true })) {
+    const relativePath = relativeDir ? `${relativeDir}/${child.name}` : child.name;
+    if (child.isDirectory()) yield* jsonFiles(packRoot, relativePath);
+    else if (child.isFile() && child.name.endsWith('.json')) yield relativePath;
+  }
+}

package/src/node.d.ts

@@ -0,0 +1,13 @@
+import type { CobblemonTarget, SchemaEngine, SchemaEntry } from './index.js';
+
+export * from './index.js';
+
+export const packageRoot: string;
+export const schemaRoot: string;
+export const cobblemon: CobblemonTarget;
+
+export function loadSchemas(root?: string, ajvOptions?: Record<string, unknown>): { ajv: import('ajv/dist/2020.js').default; entries: SchemaEntry[] };
+
+export function loadEngine(options?: { live?: boolean }): Promise<SchemaEngine>;
+
+export function readPack(dir: string): Map<string, Uint8Array>;

package/src/node.mjs

@@ -0,0 +1,5 @@
+export * from './index.mjs';
+export { packageRoot, schemaRoot, cobblemon } from './node/package-info.mjs';
+export { loadSchemas } from './node/load-schemas.mjs';
+export { loadEngine } from './node/load-engine.mjs';
+export { readPack } from './node/read-pack.mjs';

package/src/schema-engine.mjs

@@ -0,0 +1,43 @@
+import { formatAjvError } from './errors/format.mjs';
+import { decodePointer } from './errors/pointer.mjs';
+import { simplifyAjvErrors } from './errors/simplify.mjs';
+import { SchemaIndex } from './schema-index.mjs';
+
+export class SchemaEngine {
+  #index;
+  #validators;
+
+  constructor({ entries, validators, cobblemon = null }) {
+    this.cobblemon = cobblemon;
+    this.#index = new SchemaIndex(entries);
+    this.#validators = new Map(Object.entries(validators));
+  }
+
+  static fromBundle(bundle, compiled) {
+    const validators = {};
+    for (const entry of bundle.entries) {
+      if (entry.validator) validators[entry.path] = compiled[entry.validator];
+    }
+    return new SchemaEngine({ entries: bundle.entries, validators, cobblemon: bundle.cobblemon });
+  }
+
+  resolve(packPath) {
+    return this.#index.resolve(packPath);
+  }
+
+  validate(schemaPath, value) {
+    const validator = this.#validators.get(schemaPath);
+    if (!validator || validator(value)) return [];
+    return simplifyAjvErrors(validator.errors ?? [], value).map((error) => ({
+      pointer: decodePointer(error.instancePath),
+      keyword: error.keyword,
+      params: error.params ?? {},
+      message: formatAjvError(error),
+    }));
+  }
+
+  check(packPath, value) {
+    const schema = this.resolve(packPath) ?? null;
+    return { schema, errors: schema ? this.validate(schema, value) : [] };
+  }
+}

package/src/schema-index.mjs

@@ -0,0 +1,54 @@
+const SHARED_SCHEMAS = 'schemas/_shared/';
+const POKEMON_RESOLVER_FILE = /^assets\/[^/]+\/bedrock\/pokemon\/resolvers\//;
+const POSER_FILE = /^assets\/[^/]+\/bedrock\/(pokemon|npcs|fossils|block_entities|generic|poke_balls)\/posers\//;
+const DATA_FILE = /^data\/[^/]+\/(.+\.json)$/;
+const PER_FILE_SCHEMA = /^schemas\/(mechanics|ride_settings)\/([^.]+)\.schema\.json$/;
+const FOLDER_SCHEMA = /^schemas\/([^/]+)\/schema\.json$/;
+
+export class SchemaIndex {
+  #byDataPath = new Map();
+  #byFolderAndFile = new Map();
+  #byFolder = new Map();
+
+  constructor(entries) {
+    for (const entry of entries) {
+      if (!entry.path.startsWith(SHARED_SCHEMAS)) this.#add(entry);
+    }
+  }
+
+  resolve(packPath) {
+    if (POKEMON_RESOLVER_FILE.test(packPath)) return 'schemas/bedrock_pokemon_resolvers/schema.json';
+    if (POSER_FILE.test(packPath)) return 'schemas/bedrock_posers/schema.json';
+
+    const dataPath = packPath.match(DATA_FILE)?.[1];
+    if (!dataPath) return undefined;
+    return this.#byDataPath.get(dataPath) ?? this.#resolveByFolder(dataPath);
+  }
+
+  #resolveByFolder(dataPath) {
+    const slash = dataPath.indexOf('/');
+    if (slash === -1) return undefined;
+    const folder = dataPath.slice(0, slash);
+    const fileName = dataPath.slice(dataPath.lastIndexOf('/') + 1);
+    return this.#byFolderAndFile.get(folder)?.get(fileName) ?? this.#byFolder.get(folder);
+  }
+
+  #add(entry) {
+    if (entry.dataPath) {
+      this.#byDataPath.set(entry.dataPath, entry.path);
+      return;
+    }
+
+    const perFile = entry.path.match(PER_FILE_SCHEMA);
+    if (perFile) {
+      const [, folder, name] = perFile;
+      const byFile = this.#byFolderAndFile.get(folder) ?? new Map();
+      byFile.set(`${name}.json`, entry.path);
+      this.#byFolderAndFile.set(folder, byFile);
+      return;
+    }
+
+    const folder = entry.path.match(FOLDER_SCHEMA)?.[1];
+    if (folder && !folder.startsWith('bedrock_')) this.#byFolder.set(folder, entry.path);
+  }
+}

package/src/validate-pack.mjs

@@ -0,0 +1,28 @@
+import { parseJson } from './json/parse-json.mjs';
+
+export function validatePack(files, engine) {
+  const results = [];
+  for (const [file, content] of files) {
+    const schema = engine.resolve(file);
+    if (schema) results.push({ file, schema, errors: validateFile(content, schema, engine) });
+  }
+  return results.sort((a, b) => a.file.localeCompare(b.file));
+}
+
+function validateFile(content, schema, engine) {
+  const parsed = parseJson(content);
+  const syntaxErrors = parsed.syntaxErrors.map((error) => ({ kind: 'syntax', pointer: [], ...error }));
+  if (parsed.value === undefined) return syntaxErrors;
+
+  const schemaErrors = engine.validate(schema, parsed.value).map((error) => ({
+    kind: 'schema',
+    ...error,
+    ...parsed.locate(pointerToHighlight(error)),
+  }));
+  return [...syntaxErrors, ...schemaErrors];
+}
+
+function pointerToHighlight(error) {
+  const unknownProperty = error.keyword === 'additionalProperties' ? error.params.additionalProperty : undefined;
+  return unknownProperty === undefined ? error.pointer : [...error.pointer, unknownProperty];
+}