feat: validate prefix value

Author: thomasthiebaud

bin/fastify-schema-to-typescript.js

@@ -3,14 +3,28 @@
 const { program } = require("commander");
 const { convert } = require("../dist/index");
 
+function parsePrefix(value) {
+  if (!value.match(/^\w/i)) {
+    console.error("Prefix needs to start with a letter");
+    process.exit(-1);
+  }
+
+  return value;
+}
+
 program
   .option(
     "-g, --glob <value>",
     "glob matching JSON schema to convert",
     "src/**/schema.json"
   )
-  .option("-p, --prefix <value>", "prefix to use before interfaces' name", "");
+  .option(
+    "-p, --prefix <value>",
+    "prefix to use before interfaces' name",
+    parsePrefix,
+    ""
+  );
 
 program.parse(process.argv);
 
-convert(program.glob, program.prefix);
+convert({ glob: program.glob, prefix: program.prefix });

src/index.ts

@@ -2,10 +2,16 @@ import glob from "glob";
 import path from "path";
 import fs from "fs";
 import { compile } from "json-schema-to-typescript";
+import { promisify } from "util";
 
-const opts = { bannerComment: "" };
+const compileOptions = { bannerComment: "" };
 const defaultSchema = { type: "object", additionalProperties: false };
 
+export interface Options {
+  glob: string;
+  prefix: string;
+}
+
 export async function generateReplyInterfaces(
   prefix: string,
   replies: Record<any, any> = {}
@@ -18,7 +24,7 @@ export async function generateReplyInterfaces(
       await compile(
         replySchema || defaultSchema,
         prefix + "Reply" + replyCode.toUpperCase(),
-        opts
+        compileOptions
       )
     );
   }
@@ -29,12 +35,13 @@ type ${prefix}Reply = ${generatedReplyNames.join(" | ") || "{}"}
 `.trim();
 }
 
-async function writeFile(
+async function generateInterfaces(
   parsedPath: path.ParsedPath,
-  prefix: string,
-  schema: any
+  schema: any,
+  options: Options
 ) {
-  const template = `/* tslint:disable */
+  return `\
+/* tslint:disable */
 /* eslint-disable */
 /**
  * This file was automatically generated. DO NOT MODIFY IT BY HAND.
@@ -45,38 +52,51 @@ import { RouteHandler } from "fastify"
 
 import schema from './${parsedPath.base}'
 
-${await compile(schema.params || defaultSchema, prefix + "Params", opts)}
+${await compile(
+  schema.params || defaultSchema,
+  options.prefix + "Params",
+  compileOptions
+)}
 ${await compile(
   schema.querystring || schema.query || defaultSchema,
-  prefix + "Query",
-  opts
+  options.prefix + "Query",
+  compileOptions
 )}
-${await compile(schema.body || defaultSchema, prefix + "Body", opts)}
-${await compile(schema.headers || defaultSchema, prefix + "Headers", opts)}
-${await generateReplyInterfaces(prefix, schema.response)}
+${await compile(
+  schema.body || defaultSchema,
+  options.prefix + "Body",
+  compileOptions
+)}
+${await compile(
+  schema.headers || defaultSchema,
+  options.prefix + "Headers",
+  compileOptions
+)}
+${await generateReplyInterfaces(options.prefix, schema.response)}
 
-type ${prefix}Handler = RouteHandler<{
-  Query: ${prefix}Query;
-  Body: ${prefix}Body;
-  Params: ${prefix}Params;
-  Headers: ${prefix}Headers;
-  Reply: ${prefix}Reply;
+type ${options.prefix}Handler = RouteHandler<{
+  Query: ${options.prefix}Query;
+  Body: ${options.prefix}Body;
+  Params: ${options.prefix}Params;
+  Headers: ${options.prefix}Headers;
+  Reply: ${options.prefix}Reply;
 }>;
 
-export { ${prefix}Handler, schema }
-  `;
+export { ${options.prefix}Handler, schema }\
+`;
+}
 
-  fs.writeFileSync(
-    path.join(parsedPath.dir, parsedPath.name + ".ts"),
-    template
-  );
+async function writeFile(parsedPath: path.ParsedPath, template: string) {
+  const write = promisify(fs.writeFile);
+  return write(path.join(parsedPath.dir, parsedPath.name + ".ts"), template);
 }
 
-export function convert(globString: string, prefix: string) {
-  const filePaths = glob.sync(globString);
-  filePaths.forEach((filePath) => {
+export async function convert(options: Options) {
+  const filePaths = glob.sync(options.glob);
+  for (const filePath of filePaths) {
     const parsedPath = path.parse(filePath);
     const schema = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-    writeFile(parsedPath, prefix, schema);
-  });
+    const template = await generateInterfaces(parsedPath, schema, options);
+    await writeFile(parsedPath, template);
+  }
 }