feature: parse {} as UnknownSchema

changelog.md

@@ -1,3 +1,7 @@
+# 1.7.5
+
+- parse {} as UnknownSchema [src](https://github.com/xddq/schema2typebox/pull/51)
+
 # 1.7.4
 
 - support unions containing objects and/or arrays [src](https://github.com/xddq/schema2typebox/pull/48)

package.json

@@ -1,6 +1,6 @@
 {
   "name": "schema2typebox",
-  "version": "1.7.4",
+  "version": "1.7.5",
   "main": "dist/src/index.js",
   "description": "Creates typebox code from JSON schemas",
   "source": "dist/src/index.js",

src/schema-matchers.ts

@@ -52,6 +52,13 @@ export const isConstSchema = (schema: JSONSchema7): schema is ConstSchema => {
   return schema.const !== undefined;
 };
 
+export type UnknownSchema = JSONSchema7 & Record<string, never>;
+export const isUnknownSchema = (
+  schema: JSONSchema7
+): schema is UnknownSchema => {
+  return typeof schema === "object" && Object.keys(schema).length === 0;
+};
+
 export type MultipleTypesSchema = JSONSchema7 & { type: JSONSchema7TypeName[] };
 export const isSchemaWithMultipleTypes = (
   schema: JSONSchema7

src/schema-to-typebox.ts

@@ -18,6 +18,7 @@ import {
   NotSchema,
   ObjectSchema,
   OneOfSchema,
+  UnknownSchema,
   isAllOfSchema,
   isAnyOfSchema,
   isArraySchema,
@@ -28,6 +29,7 @@ import {
   isObjectSchema,
   isOneOfSchema,
   isSchemaWithMultipleTypes,
+  isUnknownSchema,
 } from "./schema-matchers";
 
 type Code = string;
@@ -86,6 +88,8 @@ export const collect = (schema: JSONSchema7Definition): Code => {
     return parseWithMultipleTypes(schema);
   } else if (isConstSchema(schema)) {
     return parseConst(schema);
+  } else if (isUnknownSchema(schema)) {
+    return parseUnknown(schema);
   } else if (schema.type !== undefined && !Array.isArray(schema.type)) {
     return parseTypeName(schema.type, schema);
   }
@@ -213,6 +217,10 @@ export const parseConst = (schema: ConstSchema): Code => {
     : `Type.Literal(${schema.const}, ${schemaOptions})`;
 };
 
+export const parseUnknown = (_: UnknownSchema): Code => {
+  return "Type.Unknown()";
+};
+
 export const parseType = (type: JSONSchema7Type): Code => {
   if (isString(type)) {
     return `Type.Literal("${type}")`;

test/parser.spec.ts

@@ -10,6 +10,7 @@ import {
   NotSchema,
   ObjectSchema,
   OneOfSchema,
+  UnknownSchema,
 } from "../src/schema-matchers";
 import {
   parseAllOf,
@@ -21,6 +22,7 @@ import {
   parseObject,
   parseOneOf,
   parseTypeName,
+  parseUnknown,
   parseWithMultipleTypes,
 } from "../src/schema-to-typebox";
 import { expectEqualIgnoreFormatting } from "./util";
@@ -133,6 +135,15 @@ describe("parser unit tests", () => {
     });
   });
 
+  describe("parseUnknown() - when parsing an empty schema", () => {
+    it("returns Type.Unknown()", async () => {
+      const dummySchema: UnknownSchema = {};
+      const result = parseUnknown(dummySchema);
+
+      expect(result).toEqual("Type.Unknown()");
+    });
+  });
+
   describe("parseAnyOf() - when parsing an anyOf schema", () => {
     it("returns Type.Union()", () => {
       const dummySchema: AnyOfSchema = {