fix code options, allow output of compiled code to stdout, refactor

Author: epoberezkin

README.md

@@ -222,10 +222,10 @@ You can pass the following [Ajv options](https://github.com/ajv-validator/ajv/bl
 | `--loop-enum=`               | max size of `enum` to compile to expression (rather than to loop) |
 | `--own-properties`           | only validate own properties (not relevant for JSON, but can have effect for JavaScript objects) |
 | Code generation |
-| `--code.es5`                 | generate ES5 code |
-| `--code.lines`               | generate multi-line code |
-| `--code.optimize=`           | disable optimization (`false`) or number of optimization passes (1 pass by default) |
-| `--code.formats=`            | code to require formats object (only needed if you generate standalone code and do not use [ajv-formats](https://github.com/ajv-validator/ajv-formats)) |
+| `--code-es5`                 | generate ES5 code |
+| `--code-lines`               | generate multi-line code |
+| `--code-optimize=`           | disable optimization (`false`) or number of optimization passes (1 pass by default) |
+| `--code-formats=`            | code to require formats object (only needed if you generate standalone code and do not use [ajv-formats](https://github.com/ajv-validator/ajv-formats)) |
 
 Options can be passed using either dash-case or camelCase.
 

src/commands/compile.ts

@@ -1,7 +1,7 @@
 import type {Command} from "./types"
 import type {AnyValidateFunction} from "ajv/dist/core"
 import type {ParsedArgs} from "minimist"
-import {getFiles, openFile, all} from "./util"
+import {getFiles, openFile} from "./util"
 import getAjv from "./ajv"
 import standaloneCode from "ajv/dist/standalone"
 import fs = require("fs")
@@ -16,7 +16,7 @@ const cmd: Command = {
       r: {$ref: "#/$defs/stringOrArray"},
       m: {$ref: "#/$defs/stringOrArray"},
       c: {$ref: "#/$defs/stringOrArray"},
-      o: {type: "string", format: "notGlob"},
+      o: {anyOf: [{type: "string", format: "notGlob"}, {type: "boolean"}]},
       spec: {enum: ["draft7", "draft2019"]},
     },
     ajvOptions: true,
@@ -28,19 +28,21 @@ export default cmd
 function execute(argv: ParsedArgs): boolean {
   const ajv = getAjv(argv)
   const schemaFiles = getFiles(argv.s)
-  if (argv.o && schemaFiles.length > 1) return compileMultiExportModule(schemaFiles)
-  return all(schemaFiles, compileSchemaAndSave)
+  if ("o" in argv && schemaFiles.length > 1) return compileMultiExportModule(schemaFiles)
+  return schemaFiles.map(compileSchemaAndSave).every((x) => x)
 
   function compileMultiExportModule(files: string[]): boolean {
-    const allValid = all(files, (file) => !!compileSchema(file))
-    if (allValid) return saveStandaloneCode()
+    const validators = files.map(compileSchema)
+    if (validators.every((v) => v)) {
+      return saveStandaloneCode(getRefs(validators as AnyValidateFunction[], files))
+    }
     console.error("module not saved")
     return false
   }
 
   function compileSchemaAndSave(file: string): boolean {
     const validate = compileSchema(file)
-    if (validate) return argv.o ? saveStandaloneCode(validate) : true
+    if (validate) return "o" in argv ? saveStandaloneCode(validate) : true
     return false
   }
 
@@ -49,8 +51,8 @@ function execute(argv: ParsedArgs): boolean {
     try {
       const id = sch?.$id
       ajv.addSchema(sch, id ? undefined : file )
-      const validate = ajv.getSchema(id)
-      console.log(`schema ${file} is valid`)
+      const validate = ajv.getSchema(id || file)
+      if (argv.o !== true) console.log(`schema ${file} is valid`)
       return validate
     } catch (err) {
       console.error(`schema ${file} is invalid`)
@@ -59,11 +61,21 @@ function execute(argv: ParsedArgs): boolean {
     }
   }
 
-  function saveStandaloneCode(validate?: AnyValidateFunction): boolean {
+  function getRefs(validators: AnyValidateFunction[], files: string[]): {[K in string]?: string}  {
+    const refs: {[K in string]?: string} = {}
+    validators.forEach((v, i) => {
+      const ref = typeof v.schema == "object" ? v.schema.$id || files[i] : files[i]
+      refs[ref] = ref
+    })
+    return refs
+  }
+
+  function saveStandaloneCode(refsOrFunc: AnyValidateFunction | {[K in string]?: string}): boolean {
     try {
-      const moduleCode = standaloneCode(ajv, validate)
+      const moduleCode = standaloneCode(ajv, refsOrFunc)
       try {
-        fs.writeFileSync(argv.o, moduleCode)
+        if (argv.o === true) console.log(moduleCode)
+        else fs.writeFileSync(argv.o, moduleCode)
         return true
       } catch (e) {
         console.error("error saving file:", e)

src/commands/migrate.ts

@@ -1,7 +1,7 @@
 import type {Command} from "./types"
 import type {AnySchemaObject} from "ajv"
 import type {ParsedArgs} from "minimist"
-import {getFiles, getSpec, openFile, all} from "./util"
+import {getFiles, openFile} from "./util"
 import getAjv from "./ajv"
 import fs = require("fs")
 import * as migrate from "json-schema-migrate"
@@ -30,12 +30,13 @@ function execute(argv: ParsedArgs): boolean {
     console.error("multiple schemas cannot be migrated to a named output file")
     return false
   }
-  return all(schemaFiles, migrateSchema)
+  return schemaFiles.map(migrateSchema).every((x) => x)
 
   function migrateSchema(file: string): boolean {
     const sch = openFile(file, `schema ${file}`)
     const migratedSchema: AnySchemaObject = JSON.parse(JSON.stringify(sch))
-    migrate[getSpec(argv)](migratedSchema)
+    const spec = argv.spec === "draft2019" ? "draft2019" : "draft7"
+    migrate[spec](migratedSchema)
     if (argv["validate-schema"] !== false) {
       const ajv = getAjv(argv)
       const valid = ajv.validateSchema(migratedSchema) as boolean

src/commands/options.ts

@@ -4,7 +4,7 @@ import type {ParsedArgs} from "minimist"
 import glob = require("glob")
 
 const boolOrNat = {type: ["boolean", "integer"], minimum: 0}
-const CODE = "code."
+const CODE = "code-"
 const ajvOptions: SchemaMap = {
   strict: boolOrString(["log"]),
   strictTypes: boolOrString(["log"]),

src/commands/test.ts

@@ -1,6 +1,6 @@
 import type {Command} from "./types"
 import type {ParsedArgs} from "minimist"
-import {compile, getFiles, openFile, logJSON, all} from "./util"
+import {compile, getFiles, openFile, logJSON} from "./util"
 import getAjv from "./ajv"
 
 const cmd: Command = {
@@ -33,7 +33,7 @@ function execute(argv: ParsedArgs): boolean {
   const ajv = getAjv(argv)
   const validate = compile(ajv, argv.s)
   const shouldBeValid = !!argv.valid && argv.valid !== "false"
-  return all(getFiles(argv.d), testDataFile)
+  return getFiles(argv.d).map(testDataFile).every((x) => x)
 
   function testDataFile(file: string): boolean {
     const data = openFile(file, `data file ${file}`)

src/commands/util.ts

@@ -1,6 +1,4 @@
 import type Ajv from "ajv"
-import type {ParsedArgs} from "minimist"
-import type {SchemaSpec} from "./types"
 import glob = require("glob")
 import path = require("path")
 import fs = require("fs")
@@ -87,12 +85,3 @@ export function compile(ajv: Ajv, schemaFile: string): AnyValidateFunction {
     process.exit(1)
   }
 }
-
-export function getSpec(argv: ParsedArgs): SchemaSpec {
-  return argv.spec === "draft2019" ? "draft2019" : "draft7"
-}
-
-// Like Array.prototype.every but without short-circuiting (for side-effects)
-export function all<T>(xs: T[], f: (x: T) => boolean): boolean {
-  return xs.reduce((res: boolean, x: T) => f(x) && res, true)
-}

src/commands/validate.ts

@@ -1,6 +1,6 @@
 import type {Command} from "./types"
 import type {ParsedArgs} from "minimist"
-import {compile, getFiles, openFile, logJSON, all} from "./util"
+import {compile, getFiles, openFile, logJSON} from "./util"
 import getAjv from "./ajv"
 import jsonPatch = require("fast-json-patch")
 
@@ -31,7 +31,7 @@ export default cmd
 function execute(argv: ParsedArgs): boolean {
   const ajv = getAjv(argv)
   const validate = compile(ajv, argv.s)
-  return all(getFiles(argv.d), validateDataFile)
+  return getFiles(argv.d).map(validateDataFile).every((x) => x)
 
   function validateDataFile(file: string): boolean {
     const data = openFile(file, `data file ${file}`)

test/compile.spec.ts

@@ -29,13 +29,13 @@ describe("compile", function () {
 
   it("should compile schema to output file", (done) => {
     cli("compile -s test/schema -o test/validate_schema1.js", (error, stdout, stderr) => {
+      const validate = require("./validate_schema1.js")
+      fs.unlinkSync("test/validate_schema1.js")
+
       assert.strictEqual(error, null)
       assertValid(stdout, 1)
       assert.strictEqual(stderr, "")
 
-      const validate = require("./validate_schema1.js")
-      fs.unlinkSync("test/validate_schema1.js")
-
       const validData = require("./valid_data.json")
       const invalidData = require("./invalid_data.json")
       assert.strictEqual(validate(validData), true)
@@ -48,13 +48,13 @@ describe("compile", function () {
     cli(
       "compile -s test/schema -s test/schema_with_ref -o test/validate_schema2.js",
       (error, stdout, stderr) => {
+        const validators = require("./validate_schema2.js")
+        fs.unlinkSync("test/validate_schema2.js")
+
         assert.strictEqual(error, null)
         assertValid(stdout, 2)
         assert.strictEqual(stderr, "")
 
-        const validators = require("./validate_schema2.js")
-        fs.unlinkSync("test/validate_schema2.js")
-
         const validData = require("./valid_data.json")
         const invalidData = require("./invalid_data.json")
         assert.strictEqual(validators["schema.json"](validData), true)