JSON Schema

import { fromJsonSchema } from "@maroonedog/luq/plugins/jsonSchemaFullFeature";

type Account = { email: string; age?: number };

const accountValidator = fromJsonSchema<Account>({
  type: "object",
  properties: {
    email: { type: "string", format: "email" },
    age: { type: "number", minimum: 18 },
  },
  required: ["email"],
});

const result = accountValidator.validate({ email: "not-an-email" });

if (result.valid) {
  // `data` exists only on this branch — no cast, no non-null assertion.
  console.log(result.data.email);
} else {
  for (const issue of result.issues) {
    // -> "email: stringEmail"
    console.log(`${issue.path}: ${issue.code}`);
  }
}

import { Builder } from "@maroonedog/luq";
import { jsonSchemaPlugin } from "@maroonedog/luq/plugins/jsonSchema";
import { jsonSchemaBag } from "@maroonedog/luq/plugins/jsonSchemaFullFeature";
import { requiredPlugin } from "@maroonedog/luq/plugins/required";

type Envelope = { id: string; payload: Record<string, unknown> };

const PAYLOAD_SCHEMA = {
  type: "object",
  properties: { kind: { type: "string", minLength: 1 } },
  required: ["kind"],
  additionalProperties: false,
};

const envelopeValidator = Builder()
  .use(requiredPlugin)
  .use(jsonSchemaPlugin)
  .for<Envelope>()
  .v("id", (b) => b.string.required())
  .v("payload", (b) => b.object.required().jsonSchema(PAYLOAD_SCHEMA, jsonSchemaBag))
  .build();

// false — payload.kind is empty
envelopeValidator.validate({ id: "e1", payload: { kind: "" } }).valid;

import { Builder } from "@maroonedog/luq";
import { jsonSchemaFullFeaturePlugin } from "@maroonedog/luq/plugins/jsonSchemaFullFeature";

type Reading = { sample: number };

// Same conversion, but the bag is already inside the plugin, so there is no
// second argument. The method NAME differs on purpose: one builder may hold
// both plugins, and two plugins may not claim one method on one slot.
const readingValidator = Builder()
  .use(jsonSchemaFullFeaturePlugin)
  .for<Reading>()
  .v("sample", (b) => b.number.jsonSchemaFullFeature({ type: "number", minimum: 0 }))
  .build();

readingValidator.validate({ sample: -1 }).valid; // false

import { Builder } from "@maroonedog/luq";
import { requiredPlugin } from "@maroonedog/luq/plugins/required";
import { optionalPlugin } from "@maroonedog/luq/plugins/optional";
import { stringMinPlugin } from "@maroonedog/luq/plugins/stringMin";
import { stringEmailPlugin } from "@maroonedog/luq/plugins/stringEmail";
import { numberMinPlugin } from "@maroonedog/luq/plugins/numberMin";
import { toStandardJsonSchema } from "@maroonedog/luq/standard-schema";

type Account = { name: string; email: string; age?: number };

const account = toStandardJsonSchema(
  Builder()
    .use(requiredPlugin)
    .use(optionalPlugin)
    .use(stringMinPlugin)
    .use(stringEmailPlugin)
    .use(numberMinPlugin)
    .for<Account>()
    .v("name", (b) => b.string.required().min(2))
    .v("email", (b) => b.string.required().email())
    .v("age", (b) => b.number.optional().min(18))
    .build()
);

const document = account["~standard"].jsonSchema.input({
  target: "draft-2020-12",
});

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "properties": {
    "name": { "type": "string", "minLength": 2 },
    "email": { "type": "string", "format": "email" },
    "age": { "type": "number", "minimum": 18 }
  },
  "required": ["name", "email"]
}