feat: support JSON Schema as input for a Type

.changeset/brave-plums-clap.md

@@ -0,0 +1,9 @@
+---
+"@arktype/schema": patch
+---
+
+(see [arktype CHANGELOG](../type/CHANGELOG.md))
+
+### Fix a ParseError compiling certain morphs with cyclic inputs
+
+### Rename RegexNode to PatternNode

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,33 @@
+# @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 `JsonSchema` namespace type from `@ark/jsonschema`, and use the appropriate member like so:
+```ts
+import type { JsonSchema } from "@ark/jsonschema"
+
+const schema: JsonSchema.StringSchema = {
+    type: "string",
+    minLength: "3" // errors stating that 'minLength' must be a number
+}
+```

ark/jsonschema/__tests__/array.test.ts

@@ -0,0 +1,130 @@
+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<unknown[]>(t.infer)
+		attest(t.json).snap({ proto: "Array" })
+	})
+
+	it("items & additionalItems", () => {
+		const tItems = parseJsonSchema({
+			type: "array",
+			items: [{ type: "string" }, { type: "number" }]
+		})
+		attest<[string, number]>(tItems.infer)
+		attest(tItems.json).snap({
+			proto: "Array",
+			sequence: { prefix: ["string", "number"] },
+			exactLength: 2
+		})
+		attest(tItems.allows(["foo", 1])).equals(true)
+		attest(tItems.allows([1, "foo"])).equals(false)
+		attest(tItems.allows(["foo", 1, true])).equals(false)
+
+		const tItemsVariadic = parseJsonSchema({
+			type: "array",
+			items: [{ type: "string" }, { type: "number" }],
+			additionalItems: { type: "boolean" }
+		})
+		attest<[string, number, ...boolean[]]>(tItemsVariadic.infer)
+		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<unknown[]>(tContains.infer)
+		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<unknown[]>(tMaxItems.infer)
+		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<unknown[]>(tMinItems.infer)
+		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<unknown[]>(tUniqueItems.infer)
+		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__/json.test.ts

@@ -0,0 +1,88 @@
+import { attest, contextualize } from "@ark/attest"
+import { parseJsonSchema } from "@ark/jsonschema"
+import type { applyConstraintSchema, number } from "arktype"
+
+contextualize(() => {
+	it("array", () => {
+		// unknown[]
+		const parsedJsonSchemaArray = parseJsonSchema({ type: "array" } as const)
+		attest<unknown[]>(parsedJsonSchemaArray.infer)
+		attest(parsedJsonSchemaArray.json).snap({ proto: "Array" })
+
+		// number[]
+		const parsedJsonSchemaArrayVariadic = parseJsonSchema({
+			type: "array",
+			items: { type: "number", minimum: 3 }
+		} as const)
+		attest<number[]>(parsedJsonSchemaArrayVariadic.infer)
+		attest(parsedJsonSchemaArrayVariadic.json).snap({
+			proto: "Array",
+			sequence: { domain: "number", min: 3 }
+		})
+		attest<number.atLeast<3>[]>(parsedJsonSchemaArrayVariadic.inferBrandableOut)
+
+		// [string]
+		const parsedJsonSchemaArrayFixed = parseJsonSchema({
+			type: "array",
+			items: [{ type: "string" }]
+		} as const)
+		attest<[string]>(parsedJsonSchemaArrayFixed.infer)
+		attest(parsedJsonSchemaArrayFixed.json).snap({
+			exactLength: 1,
+			proto: "Array",
+			sequence: { prefix: ["string"] }
+		})
+
+		// [string, ...number[]]
+		const parsedJsonSchemaArrayFixedWithVariadic = parseJsonSchema({
+			type: "array",
+			items: [{ type: "string" }],
+			additionalItems: { type: "number" }
+		} as const)
+		attest<[string, ...number[]]>(parsedJsonSchemaArrayFixedWithVariadic.infer)
+
+		// Maximum Length
+		const parsedJsonSchemaArrayMaxLength = parseJsonSchema({
+			type: "array",
+			items: { type: "string" },
+			maxItems: 5
+		} as const)
+		attest<string[]>(parsedJsonSchemaArrayMaxLength.infer)
+		attest<applyConstraintSchema<string[], "maxLength", 5>>(
+			parsedJsonSchemaArrayMaxLength.tOut
+		)
+
+		// Minimum Length
+		const parsedJsonSchemaArrayMinLength = parseJsonSchema({
+			type: "array",
+			items: { type: "number" },
+			minItems: 3
+		} as const)
+		attest<number[]>(parsedJsonSchemaArrayMinLength.infer)
+		attest<applyConstraintSchema<number[], "minLength", 3>>(
+			parsedJsonSchemaArrayMinLength.tOut
+		)
+
+		// Maximum & Minimum Length
+		const parsedJsonSchemaArrayMaxAndMinLength = parseJsonSchema({
+			type: "array",
+			items: { type: "array", items: { type: "string" } },
+			maxItems: 5,
+			minItems: 3
+		} as const)
+		attest<string[][]>(parsedJsonSchemaArrayMaxAndMinLength.infer)
+		attest<
+			applyConstraintSchema<
+				applyConstraintSchema<string[][], "maxLength", 5>,
+				"minLength",
+				3
+			>
+		>(parsedJsonSchemaArrayMaxAndMinLength.tOut)
+	})
+
+	it("number", () => {})
+
+	it("object", () => {})
+
+	it("string", () => {})
+})

ark/jsonschema/__tests__/number.test.ts

@@ -0,0 +1,97 @@
+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<number>(parsedNumberValidator.infer)
+		attest(parsedNumberValidator.json).snap(expectedArkTypeSchema)
+	})
+
+	it("type integer", () => {
+		const t = parseJsonSchema({ type: "integer" })
+		attest<number>(t.infer)
+		attest(t.json).snap({ domain: "number", divisor: 1 })
+	})
+
+	it("maximum & exclusiveMaximum", () => {
+		const tMax = parseJsonSchema({
+			type: "number",
+			maximum: 5
+		})
+		attest<number>(tMax.infer)
+		attest(tMax.json).snap({
+			domain: "number",
+			max: 5
+		})
+
+		const tExclMax = parseJsonSchema({
+			type: "number",
+			exclusiveMaximum: 5
+		})
+		attest<number>(tExclMax.infer)
+		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<number>(tMin.infer)
+		attest(tMin.json).snap({ domain: "number", min: 5 })
+
+		const tExclMin = parseJsonSchema({
+			type: "number",
+			exclusiveMinimum: 5
+		})
+		attest<number>(tExclMin.infer)
+		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<number>(t.infer)
+		attest(t.json).snap({ domain: "number", divisor: 5 })
+
+		const tInt = parseJsonSchema({
+			type: "integer",
+			multipleOf: 5
+		})
+		attest<number>(tInt.infer)
+		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"
+		)
+	})
+})