feat: support JSON Schema as input for a Type

ark/jsonschema/CHANGELOG.md

@@ -0,0 +1,13 @@
+# @arktype/jsonschema
+
+## 1.0.0
+
+### Initial Release
+
+Released the initial implementation of the package.
+
+Known limitations:
+
+- No `dependencies` support
+- No `if`/`else`/`then` support
+- `multipleOf` only supports integers

ark/jsonschema/README.md

@@ -0,0 +1,51 @@
+# @arktype/jsonschema
+
+## What is it?
+
+@arktype/jsonschema is a package that allows converting from a JSON Schema schema, to an ArkType type. For example:
+
+```js
+import { parseJsonSchema } from "@ark/jsonschema"
+
+const t = parseJsonSchema({ type: "string", minLength: 5, maxLength: 10 })
+```
+
+is equivalent to:
+
+```js
+import { type } from "arktype"
+
+const t = type("5<=string<=10")
+```
+
+This enables easy adoption of ArkType for people who currently have JSON Schema based runtime validation in their codebase.
+
+Where possible, the library also has TypeScript type inference so that the runtime validation remains typesafe. Extending on the above example, this means that the return type of the below `parseString` function would be correctly inferred as `string`:
+
+```ts
+const assertIsString = (data: unknown)
+    return t.assert(data)
+```
+
+## Extra Type Safety
+
+If you wish to ensure that your JSON Schema schemas are valid, you can do this too! Simply import the relevant `Schema` type from `@ark/jsonschema` like so:
+
+```ts
+import type { JsonSchema } from "arktype"
+
+const integerSchema: JsonSchema.Numeric = {
+	type: "integer",
+	multipleOf: "3" // errors stating that 'multipleOf' must be a number
+}
+```
+
+Note that for string schemas exclusively, you must import the schema type from `@ark/jsonschema` instead of `arktype`. This is because `@ark/jsonschema` doesn't yet support the `format` keyword whilst `arktype` does.
+
+```ts
+import type { StringSchema } from "@ark/jsonschema"
+const stringSchema: StringSchema = {
+	type: "string",
+	minLength: "3" // errors stating that 'minLength' must be a number
+}
+```

ark/jsonschema/__tests__/array.test.ts

@@ -0,0 +1,141 @@
+import { attest, contextualize } from "@ark/attest"
+import { parseJsonSchema } from "@ark/jsonschema"
+
+// TODO: Add compound tests for arrays (e.g. maxItems AND minItems )
+// TODO: Add explicit test for negative length constraint failing (since explicitly mentioned in spec)
+
+contextualize(() => {
+	it("type array", () => {
+		const t = parseJsonSchema({ type: "array" })
+		attest(t.json).snap({ proto: "Array" })
+	})
+
+	it("items & prefixItems", () => {
+		const tItems = parseJsonSchema({ type: "array", items: { type: "string" } })
+		attest(tItems.json).snap({ proto: "Array", sequence: "string" })
+		attest(tItems.allows(["foo"])).equals(true)
+		attest(tItems.allows(["foo", "bar"])).equals(true)
+		attest(tItems.allows(["foo", 3, "bar"])).equals(false)
+
+		const tItemsArr = parseJsonSchema({
+			type: "array",
+			items: [{ type: "string" }, { type: "number" }]
+		})
+		attest(tItemsArr.json).snap({
+			proto: "Array",
+			sequence: { prefix: ["string", "number"] },
+			exactLength: 2
+		})
+		attest(tItemsArr.allows(["foo", 1])).equals(true)
+		attest(tItemsArr.allows([1, "foo"])).equals(false)
+		attest(tItemsArr.allows(["foo", 1, true])).equals(false)
+
+		const tPrefixItems = parseJsonSchema({
+			type: "array",
+			prefixItems: [{ type: "string" }, { type: "number" }]
+		})
+		attest(tPrefixItems.json).snap({
+			proto: "Array",
+			sequence: { prefix: ["string", "number"] },
+			exactLength: 2
+		})
+	})
+
+	it("additionalItems", () => {
+		const tItemsVariadic = parseJsonSchema({
+			type: "array",
+			items: [{ type: "string" }, { type: "number" }],
+			additionalItems: { type: "boolean" }
+		})
+		attest(tItemsVariadic.json).snap({
+			minLength: 2,
+			proto: "Array",
+			sequence: {
+				prefix: ["string", "number"],
+				variadic: [{ unit: false }, { unit: true }]
+			}
+		})
+		attest(tItemsVariadic.allows(["foo", 1])).equals(true)
+		attest(tItemsVariadic.allows([1, "foo", true])).equals(false)
+		attest(tItemsVariadic.allows([false, "foo", 1])).equals(false)
+		attest(tItemsVariadic.allows(["foo", 1, true])).equals(true)
+	})
+
+	it("contains", () => {
+		const tContains = parseJsonSchema({
+			type: "array",
+			contains: { type: "number" }
+		})
+		const predicateRef =
+			tContains.internal.firstReferenceOfKindOrThrow(
+				"predicate"
+			).serializedPredicate
+		attest(tContains.json).snap({
+			proto: "Array",
+			predicate: [predicateRef]
+		})
+		attest(tContains.allows([])).equals(false)
+		attest(tContains.allows([1, 2, 3])).equals(true)
+		attest(tContains.allows(["foo", "bar", "baz"])).equals(false)
+	})
+
+	it("maxItems", () => {
+		const tMaxItems = parseJsonSchema({
+			type: "array",
+			maxItems: 5
+		})
+		attest(tMaxItems.json).snap({
+			proto: "Array",
+			maxLength: 5
+		})
+
+		attest(() => parseJsonSchema({ type: "array", maxItems: -1 })).throws(
+			"maxItems must be an integer >= 0"
+		)
+	})
+
+	it("minItems", () => {
+		const tMinItems = parseJsonSchema({
+			type: "array",
+			minItems: 5
+		})
+		attest(tMinItems.json).snap({
+			proto: "Array",
+			minLength: 5
+		})
+
+		attest(() => parseJsonSchema({ type: "array", minItems: -1 })).throws(
+			"minItems must be an integer >= 0"
+		)
+	})
+
+	it("uniqueItems", () => {
+		const tUniqueItems = parseJsonSchema({
+			type: "array",
+			uniqueItems: true
+		})
+		const predicateRef =
+			tUniqueItems.internal.firstReferenceOfKindOrThrow(
+				"predicate"
+			).serializedPredicate
+		attest(tUniqueItems.json).snap({
+			proto: "Array",
+			predicate: [predicateRef]
+		})
+		attest(tUniqueItems.allows([1, 2, 3])).equals(true)
+		attest(tUniqueItems.allows([1, 1, 2])).equals(false)
+		attest(
+			tUniqueItems.allows([
+				{ foo: { bar: ["baz", { qux: "quux" }] } },
+				{ foo: { bar: ["baz", { qux: "quux" }] } }
+			])
+		).equals(false)
+		attest(
+			// JSON Schema specifies that arrays must be same order to be classified as equal
+			tUniqueItems.allows([
+				{ foo: { bar: ["baz", { qux: "quux" }] } },
+				{ foo: { bar: [{ qux: "quux" }, "baz"] } }
+			])
+		).equals(true)
+	})
+})

ark/jsonschema/__tests__/number.test.ts

@@ -0,0 +1,89 @@
+import { attest, contextualize } from "@ark/attest"
+import { parseJsonSchema } from "@ark/jsonschema"
+
+// TODO: Compound tests for number (e.g. 'minimum' AND 'maximum')
+
+contextualize(() => {
+	it("type number", () => {
+		const jsonSchema = { type: "number" } as const
+		const expectedArkTypeSchema = { domain: "number" } as const
+
+		const parsedNumberValidator = parseJsonSchema(jsonSchema)
+		attest(parsedNumberValidator.json).snap(expectedArkTypeSchema)
+	})
+
+	it("type integer", () => {
+		const t = parseJsonSchema({ type: "integer" })
+		attest(t.json).snap({ domain: "number", divisor: 1 })
+	})
+
+	it("maximum & exclusiveMaximum", () => {
+		const tMax = parseJsonSchema({
+			type: "number",
+			maximum: 5
+		})
+		attest(tMax.json).snap({
+			domain: "number",
+			max: 5
+		})
+
+		const tExclMax = parseJsonSchema({
+			type: "number",
+			exclusiveMaximum: 5
+		})
+		attest(tExclMax.json).snap({
+			domain: "number",
+			max: { rule: 5, exclusive: true }
+		})
+
+		attest(() =>
+			parseJsonSchema({
+				type: "number",
+				maximum: 5,
+				exclusiveMaximum: 5
+			})
+		).throws(
+			"ParseError: Provided number JSON Schema cannot have 'maximum' and 'exclusiveMaximum"
+		)
+	})
+
+	it("minimum & exclusiveMinimum", () => {
+		const tMin = parseJsonSchema({ type: "number", minimum: 5 })
+		attest(tMin.json).snap({ domain: "number", min: 5 })
+
+		const tExclMin = parseJsonSchema({
+			type: "number",
+			exclusiveMinimum: 5
+		})
+		attest(tExclMin.json).snap({
+			domain: "number",
+			min: { rule: 5, exclusive: true }
+		})
+
+		attest(() =>
+			parseJsonSchema({
+				type: "number",
+				minimum: 5,
+				exclusiveMinimum: 5
+			})
+		).throws(
+			"ParseError: Provided number JSON Schema cannot have 'minimum' and 'exclusiveMinimum"
+		)
+	})
+
+	it("multipleOf", () => {
+		const t = parseJsonSchema({ type: "number", multipleOf: 5 })
+		attest(t.json).snap({ domain: "number", divisor: 5 })
+
+		const tInt = parseJsonSchema({
+			type: "integer",
+			multipleOf: 5
+		})
+		attest(tInt.json).snap({ domain: "number", divisor: 5 })
+
+		// JSON Schema allows decimal multipleOf, but ArkType doesn't.
+		attest(() => parseJsonSchema({ type: "number", multipleOf: 5.5 })).throws(
+			"AggregateError: multipleOf must be an integer"
+		)
+	})
+})