Contract Dictionary (Like Style Dictionary for Schemas)

index.js

import glob from 'glob';
import fs from 'fs';
import { compile as compileTypeScript } from 'json-schema-to-typescript';
import path from 'path';
import rimraf from 'rimraf';

const FORMATS = Object.freeze({
  json: 'json',
  typescript: 'typescript',
});

const EXTENSIONS = Object.freeze({
  json: '.jsonc',
  typescript: '.ts',
});

const config = {
  buildPath: 'build',
  formats: Object.values(FORMATS),
};

function clean() {
  rimraf.sync(config.buildPath);
  fs.mkdirSync(config.buildPath);
}

function parse(file) {
  return {
    data: JSON.parse(fs.readFileSync(file, 'utf8')),
    name: path.parse(file).name,
  };
}

async function compile({ data, type }) {
  if (type === FORMATS.json) {
    return data;
  }

  if (type === FORMATS.typescript) {
    return await compileTypeScript(data);
  }
}

async function format({ data, name, type }) {
  const result = await compile({ data, type });
  write({ data: result, name, type });
}

function prettify({ data, type }) {
  if (type === FORMATS.typescript) {
    return data;
  }

  if (type === FORMATS.json) {
    // TODO: Use prettier (or similar)
    return JSON.stringify(data, null, 2);
  }
}

function write({ data, name, type }) {
  fs.writeFileSync(`${config.buildPath}/${name}${EXTENSIONS[type]}`, prettify({ data, type }));
}

const options = null;
glob('schemas/**/*.jsonc', options, (error, files) => {
  if (error) {
    throw error;
  }

  clean();

  files.forEach((file) => {
    const { data, name } = parse(file);
    config.formats.forEach((type) => {
      format({ data, name, type });
    });
  });
});