How to use json-schema-to-typescript - 10 common examples

;(async function () {
  for (let schema of schemas) {
    // Have to pass an empty options object, otherwise we trigger a bug where
    // the cwd for the JSON schema $ref resolver defaults to the current
    // working directory instead of the file's directory.
    let ts = await compileFromFile(resolve(__dirname, '../src/schemas/', schema), {})

    if (schema === 'Config.json') {
      ts = ts
        // This is the only way to let Config inherit from the interface without
        // redefining all the fields.
        .replace('export interface Config', 'export class Config')
        // Ignore the error stating that `accounts` isn't assigned in the
        // constructor.
        .replace('accounts: {', 'accounts!: {')
    }

    fs.writeFileSync(resolve(__dirname, '../src/schemas/', schema.split('.')[0] + 'Typing.ts'), ts)
  }
})()
  .catch(err => console.error(err))

['json-schema-draft-07', 'settings', 'site'].map(async file => {
      let schema = await readFile(path.join(schemaDir, `${file}.schema.json`), 'utf8')
      // HACK: Rewrite absolute $refs to be relative. They need to be absolute for Monaco to resolve them
      // when the schema is in a oneOf (to be merged with extension schemas).
      schema = schema.replace(
        /https:\/\/sourcegraph\.com\/v1\/settings\.schema\.json#\/definitions\//g,
        '#/definitions/'
      )

      const types = await compileJSONSchema(JSON.parse(schema), 'settings.schema', {
        cwd: schemaDir,
        $refOptions: {
          resolve: /** @type {import('json-schema-ref-parser').Options['resolve']} */ ({
            draftV7resolver,
            // there should be no reason to make network calls during this process,
            // and if there are we've broken env for offline devs/increased dev startup time
            http: false,
          }),
        },
      })
      await writeFile(path.join(outputDir, `${file}.schema.d.ts`), types)
    })
  )

const processTSResult = async (resource, schema) => {
    const tsCode = await converter.compile(schema, resource.name.capitalize());
    const output = tsLintDisable +
        tsCode.replace(regexpExport, `\nexport interface I${resource.name.capitalize()} {\n`);

    await fs.writeFile(path.join(outputPath, 'resources', `${resource.name}.ts` ), output);

    console.log(`wrote interface ${resource.name}.ts`);

    for (let str of ['import', 'export']) {
        resourceInterface += `${str} {I${resource.name.capitalize()}} from './resources/${resource.name}';\n`;
    }
}

}
  const fixturePath = `${fixturesDir}/${name}.data.json`;
  jsosnfile.writeFileSync(fixturePath, humps.camelizeKeys(data));
  console.log(chalk.green(`[task:prepbuild] writing fixture ${fixturePath}`));

  const schemaPath = `${schemaDir}/${name}.schema.json`;
  const schema = schemify(humps.camelizeKeys(data));
  jsosnfile.writeFileSync(schemaPath, schema, {
    spaces: 2,
  });
  console.log(
    chalk.green(`[task:prepbuild] writing json schema ${schemaPath}`),
  );

  const interfacesPath = `./src/interfaces/${name}.interface.ts`;
  const interfaces = await compileFromFile(
    `${buildRoot}/json-schemas/${name}.schema.json`,
  );
  fs.writeFileSync(interfacesPath, interfaces);
  console.log(
    chalk.green(`[task:prepbuild] writing interface ${interfacesPath}`),
  );
}

fs.readdirSync('./src/schemas').forEach(file => {
  console.log(file);
  const { name: fileName } = parse(file)
  const resultPath = `${process.cwd()}/src/types/${fileName}.ts`
  if (fs.existsSync(resultPath)) {
    console.log(`${resultPath} already exists, skipping`)
    return null
  }
  compileFromFile(`${process.cwd()}/src/schemas/${file}`, { bannerComment: `/**\n\t* Value representing a ${fileName}.\n\t*/` })
  .then(ts => fs.writeFileSync(resultPath, ts))
});

async function generateClassFromJSON(property: string) {
  writeFileSync(`${outputPath}/${property}.d.ts`, await compileFromFile(`${outputPath}/${property}.json`, {
    style: {
      singleQuote: true
    }
  }));

  console.log(`Type definition for '${property}' has been saved to: ${outputPath}/${property}.d.ts`);
}

return __generator(this, function (_c) {
            switch (_c.label) {
                case 0:
                    _a = fs_1.writeFileSync;
                    _b = [outputPath + "/" + property + ".d.ts"];
                    return [4 /*yield*/, json_schema_to_typescript_1.compileFromFile(outputPath + "/" + property + ".json", {
                            style: {
                                singleQuote: true
                            }
                        })];
                case 1:
                    _a.apply(void 0, _b.concat([_c.sent()]));
                    console.log("Type definition for '" + property + "' has been saved to: " + outputPath + "/" + property + ".d.ts");
                    return [2 /*return*/];
            }
        });
    });

const transformer = useCallback(async ({ value }) => {
    return compile(JSON.parse(value), "MySchema", {
      bannerComment: ""
    });
  }, []);

Object.entries(schemas).map(([name, schema]) => {
        if (!name.match(/Schema$/)) {
          return '';
        }
        return compile(schema, schema.title || firstUp(name), opts);
      })
    );