metadata.ts

// metadata.ts
// Utility functions to generate valid Catalog metadata

import { Generator } from "./generator.js";
import { Parser } from "./parser.js";
import { Validator } from "./validator.js";
import {
  type SchemaName,
  type SchemaVersion,
  supportedVersions,
  supportedVersionsTypeMapping,
  validateVersion,
} from "./versions.js";

export { validateVersion, supportedVersions, supportedVersionsTypeMapping };
export type JSONLike = Record<string, unknown>;

export function generateMetadata<T extends SchemaName>(
  version: string,
  data: JSONLike,
): string {
  validateVersion(version);
  const generator = new Generator<T>(version);
  return generator.generateJSON(data);
}

export function parseMetadata<T extends SchemaName>(
  version: string,
  json: string,
): unknown {
  validateVersion(version);
  const parser = new Parser<T>(version);
  return parser.parse(json);
}

export function validateMetadata<T extends SchemaName>(
  version: string,
  data: JSONLike,
): boolean {
  validateVersion(version);
  const validator = new Validator<T>(version);
  return validator.validate(data);
}

export function getMetadataErrors<T extends SchemaName>(
  version: string,
  data: JSONLike,
): string[] | null {
  validateVersion(version);
  const validator = new Validator<T>(version);
  if (validator.validate(data)) {
    return null;
  }
  const errors = validator.getErrors();
  return errors
    ? errors
        .map((e) => `${e.instancePath} ${e.message}`)
        .filter((message): message is string => message !== undefined)
    : null;
}

export function isValidVersion(version: string): boolean {
  try {
    validateVersion(version);
    return true;
  } catch {
    return false;
  }
}

export function getSupportedVersions<T extends SchemaName>(
  schemaName: T,
): SchemaVersion<T>[] {
  return supportedVersions[schemaName];
}