Performance enhancement in jsonSchemaErrors: redundant disk I/O and duplicate instance conversion

[animeshsahoo1]

Here are the 2 performance enhancement we can do in jsonSchemaErrors
1. Localization.forLocale() reads from disk on every call
Every invocation of jsonSchemaErrors calls Localization.forLocale(), which reads the translation .ftl file from disk, parses it even when the language has not changed between calls.

export const jsonSchemaErrors = async (errorOutput, schemaUri, instance, options = {}) => {
  const normalizedErrors = await normalizedOutput(instance, errorOutput, schemaUri);
  const rootInstance = Instance.fromJs(instance);
  const localization = await Localization.forLocale(options.language ?? "en-US");
  return await getErrors(normalizedErrors, rootInstance, localization);
};

Solution: implement caching with simple Map for localization such that disk read occurs only once.

2. Instance.fromJs() called twice for the same input
Instance.fromJs(instance) is called once inside normalizedOutput and again in the outer jsonSchemaErrors function. Both calls receive the same instance value, meaning the conversion to AST is performed twice unnecessarily on every call.
Solution: call Instance.fromJs() once in jsonSchemaErrors and pass it into normalizedOutput instead of letting it recreate it again.

[jdesrosiers]

Great analysis! These are definitely things we can and should fix.

[animeshsahoo1]

I will share the exact implementation details and code affected, before doing any changes.

[animeshsahoo1]

so the 2nd issue is pretty simple in json-schem-errors.js
jsonSchemaErrors becomes:

export const jsonSchemaErrors = async (errorOutput, schemaUri, instance, options = {}) => {
  const rootInstance = Instance.fromJs(instance);
  const [normalizedErrors, localization] = await Promise.all([
    normalizedOutput(rootInstance, errorOutput, schemaUri),
    Localization.forLocale(options.language ?? "en-US")
  ]);
  return await getErrors(normalizedErrors, rootInstance, localization);
};

normalizedOutput becomes:

async function normalizedOutput(value, errorOutput, subjectUri) {
  const schema = await getSchema(subjectUri);
  const errorIndex = await constructErrorIndex(errorOutput, schema);
  const { schemaUri, ast } = await compile(schema);
  return evaluateSchema(schemaUri, value, { ast, errorIndex, plugins: [...ast.plugins] });
}

for the 1st issue: we can just use a simple map and implement the cache in the existing function in localization.js

/** @type Map<string, Promise<Localization>> */
const localizationCache = new Map();

static async forLocale(locale) {
  if (!localizationCache.has(locale)) {
    localizationCache.set(locale, (async () => {
      try {
        const ftl = await readFile(`${import.meta.dirname}/translations/${locale}.ftl`, "utf-8");
        const resource = new FluentResource(ftl);
        const bundle = new FluentBundle(locale);
        bundle.addResource(resource);
        return new Localization(locale, bundle);
      } catch (error) {
        localizationCache.delete(locale);
        throw Error(`The ${locale} locale is not supported.`, { cause: error });
      }
    })());
  }
  return /** @type Promise<Localization> */ (localizationCache.get(locale));
}

[jdesrosiers]

It's not ideal to discuss code like this in an issue. Just create a PR. I think these are pretty straightforward.