Add rejectDateType option (YousefED#224)

* Add --rejectDateType option that rejects any type definitions that reference Date

* Add test for date-string format

* Error instead of generating partial schemas for types that can't be represented in JSON-Schema; verify that schema for Date types fails to generate when rejectDateType is set

* Add --rejectDateType to the README

Author: rpetrich

README.md

@@ -45,6 +45,7 @@ Options:
   --ignoreErrors        Generate even if the program has errors.                     [boolean] [default: false]
   --excludePrivate      Exclude private members from the schema                      [boolean] [default: false]
   --uniqueNames         Use unique names for type symbols.                           [boolean] [default: false]
+  --rejectDateType      Rejects Date fields in type definitions.                     [boolean] [default: false]
   --id                  Set schema id.                                               [string] [default: ""]
 ```
 

test/programs/dates/main.ts

@@ -0,0 +1,6 @@
+type DateAlias = Date;
+
+interface MyObject {
+    var1: Date;
+    var2: DateAlias;
+}

test/programs/dates/schema.json

@@ -0,0 +1,21 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "properties": {
+        "var1": {
+            "description": "Enables basic storage and retrieval of dates and times.",
+            "format": "date-time",
+            "type": "string"
+        },
+        "var2": {
+            "description": "Enables basic storage and retrieval of dates and times.",
+            "format": "date-time",
+            "type": "string"
+        }
+    },
+    "required": [
+        "var1",
+        "var2"
+    ],
+    "type": "object"
+}
+

test/schema.test.ts

@@ -65,6 +65,21 @@ export function assertSchemas(group: string, type: string, settings: TJS.Partial
     });
 }
 
+export function assertRejection(group: string, type: string, settings: TJS.PartialArgs = {}, compilerOptions?: TJS.CompilerOptions) {
+    it(group + " should reject input", () => {
+        let schema = null;
+        assert.throws(() => {
+            if (!("required" in settings)) {
+                settings.required = true;
+            }
+
+            const files = [resolve(BASE + group + "/main.ts")];
+            schema = TJS.generateSchema(TJS.getProgramFromFiles(files, compilerOptions), type, settings, files);
+        });
+        assert.equal(schema, null, "Expected no schema to be generated");
+    });
+}
+
 describe("interfaces", () => {
     it("should return an instance of JsonSchemaGenerator", () => {
         const program = TJS.getProgramFromFiles([resolve(BASE + "comments/main.ts")]);
@@ -247,6 +262,13 @@ describe("schema", () => {
         assertSchema("string-literals-inline", "MyObject");
     });
 
+    describe("dates", () => {
+        assertSchema("dates", "MyObject");
+        assertRejection("dates", "MyObject", {
+            rejectDateType: true
+        });
+    });
+
     describe("namespaces", () => {
         assertSchema("namespace", "Type");
         assertSchema("namespace-deep-1", "RootNamespace.Def");

typescript-json-schema-cli.ts

@@ -38,6 +38,8 @@ export function run() {
             .describe("uniqueNames", "Use unique names for type symbols.")
         .array("include").default("*", defaultArgs.include)
             .describe("include", "Further limit tsconfig to include only matching files.")
+        .boolean("rejectDateType").default("rejectDateType", defaultArgs.rejectDateType)
+            .describe("rejectDateType", "Rejects Date fields in type definitions.")
         .string("id").default("id", defaultArgs.id)
             .describe("id", "ID of schema.")
         .argv;
@@ -59,7 +61,8 @@ export function run() {
         include: args.include,
         excludePrivate: args.excludePrivate,
         uniqueNames: args.uniqueNames,
-        id: args.id
+        rejectDateType: args.rejectDateType,
+        id: args.id,
     });
 }
 

typescript-json-schema.ts

@@ -30,7 +30,8 @@ export function getDefaultArgs(): Args {
         include: [],
         excludePrivate: false,
         uniqueNames: false,
-        id: ""
+        rejectDateType: false,
+        id: "",
     };
 }
 
@@ -55,6 +56,7 @@ export type Args = {
     include: string[];
     excludePrivate: boolean;
     uniqueNames: boolean;
+    rejectDateType: boolean;
     id: string;
 };
 
@@ -398,7 +400,7 @@ export class JsonSchemaGenerator {
                 definition.type = "undefined";
             } else if (flags & ts.TypeFlags.Any) {
                 // no type restriction, so that anything will match
-            } else if (propertyTypeString === "Date") {
+            } else if (propertyTypeString === "Date" && !this.args.rejectDateType) {
                 definition.type = "string";
                 definition.format = "date-time";
             }  else if (propertyTypeString === "object") {
@@ -415,11 +417,9 @@ export class JsonSchemaGenerator {
                     definition.items = this.getTypeDefinition(arrayType);
                 } else {
                     // Report that type could not be processed
-                    let info: any = propertyType;
-                    try {
-                        info = JSON.stringify(propertyType);
-                    } catch(err) {}
-                    console.error("Unsupported type: ", info);
+                    const error = new TypeError("Unsupported type: " + propertyTypeString);
+                    (error as any).type = propertyType;
+                    throw error;
                     // definition = this.getTypeDefinition(propertyType, tc);
                 }
             }