@darksheep/json-schema 0.0.0 → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+## 0.1.0 (2025-01-28)
+
+
+### 🌟 Features
+
+* **json-schema:** Extract schema tool to a package ([292c5a0](https://github.com/DarkSheepSoftware/node-packages/commit/292c5a0c4cfd1b9e82bd179db76c47aa979480bb))
+* Refactor json-schema and add tests. ([5f9669b](https://github.com/DarkSheepSoftware/node-packages/commit/5f9669baddc0d31d1faa5c26c319ec664c2c746b))
+
+
+### 🧹 Chores
+
+* Install ajv-formats ([9ce1702](https://github.com/DarkSheepSoftware/node-packages/commit/9ce170223b8e9dd16cae4a019170d90999589d45))

package/README.md

@@ -1,63 +1,65 @@
-# @darksheep/package.json
-Fetch the package.json of either; the executing program, or a given package by name.
-This is primarily useful when you're making a package, and you need to find the package.json for the service that is executing your package.
-When using pnpm you need to be cautious to set the root directory correctly.
-
-## Examples
-### Common JS
-```js
-const { getPackageJson } = require('@darksheep/package.json');
-(async () => {
-  const { name, version } = await getPackageJson();
-
-  console.info({ name, version });
-})()
-```
-
-### Module JS
-```js
-import { getPackageJson } from '@darksheep/package.json';
-const { name, version } = await getPackageJson();
+# @darksheep/json-schema
+Validate your unkown json types in style!
 
-console.info({ name, version });
-```
+## Example
 
-### Sync API
-This api is only useful for commonjs where top level await is not available.
-If you intend on using this inside a module file, please reconsider!
+```ts
+import { createValidator } from '@darksheep/json-schema';
 
-```js
-const { getPackageJson } = require('@darksheep/package.json/sync');
-const { name, version } = getPackageJson();
+const validate = createValidator({
+  type: 'object',
+  required: [ 'name', 'updatedAt' ],
+  properties: {
+    name: { type: 'string' },
+    description: { type: 'string' },
+    // Defaults are supported!
+    stared: {
+      type: 'boolean',
+      default: false,
+    },
+    // Formats are supported!
+    updatedAt: {
+      type: 'string',
+      format: 'date-time',
+    },
+  },
+});
 
-console.info({ name, version });
+// typeof validate is equal to: (
+//   data: {
+//     description?: string;
+//     stared?: boolean;
+//     name: string;
+//     updatedAt: string;
+//   }
+// ) => Promise<{
+//     description?: string;
+//     name: string;
+//     updatedAt: string;
+//     stared: boolean;
+// }>
 ```
 
-## Detailed Docs
-### Async (`@darksheep/package.json`)
-```js
-/** @typedef {import('@darksheep/package.json').PackageJson} PackageJson */
-
-/**
- *  Attempt to find the package.json for {packageName}
- *
- *  @param {string} [packageName] The name of the npm package (the main package if blank)
- *  @param {string | URL} [root] an optional root url to start from
- *  @returns  {Promise<PackageJson | null>}
- */
-export function getPackageJson(packageName, root);
-```
+### Example with untrusted input
+
+```ts
+import { createValidator, defineSchema } from '@darksheep/json-schema';
+
+const TransferRequestSchema = defineSchema({
+  type: 'object',
+  required: [ 'source', 'destination', 'amount' ],
+  unevaluatedProperties: false,
+  properties: {
+    source: { type: 'string' },
+    destination: { type: 'string' },
+    amount: { type: 'integer' },
+  }
+})
 
-### Sync (`@darksheep/package.json/sync`)
-```js
-/** @typedef {import('@darksheep/package.json').PackageJson} PackageJson */
-
-/**
- *  Attempt to find the package.json for {packageName} synchronously
- *
- *  @param {string} [packageName] The name of the npm package (the main package if blank)
- *  @param {string | URL} [root] an optional root file url to start from
- *  @returns  {PackageJson | null}
- */
-export function getPackageJson(packageName, root);
+const validateTransferRequest = createValidator(
+  TransferRequestSchema,
+  { allowUnknown: true },
+)
+// The `typeof validateTransferRequest` is:
+// (data: unknown) => Promise<{ source: string; destination: string; amount: number }>
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darksheep/json-schema",
-  "version": "0.0.0",
+  "version": "0.1.0",
   "description": "JSON schema validation (with types)",
   "license": "UNLICENCED",
   "type": "module",
@@ -17,12 +17,13 @@
   ],
   "scripts": {
     "prepack": "yarn dlx -q -p typescript tsc",
-    "test": "node --test src/**/*.test.js",
-    "test:watch": "node --watch --test src/**/*.test.js"
+    "test": "node --test --experimental-strip-types src/**/*.test.{ts,js}",
+    "test:watch": "node --test --watch --experimental-strip-types src/**/*.test.{ts,js}"
   },
   "dependencies": {
     "@darksheep/errors": "",
     "ajv": "8.17.1",
+    "ajv-formats": "3.0.1",
     "json-schema-to-ts": "3.1.1"
   },
   "engines": {

package/src/async.js

@@ -0,0 +1,150 @@
+import { Ajv2019 as Ajv } from 'ajv/dist/2019.js';
+import AddFormats from 'ajv-formats';
+import { isSchemaError } from './errors.js';
+
+/**
+ * @import {
+ *   AsyncSchema,
+ *   AsyncValidateFunction,
+ * } from 'ajv';
+ * @import {
+ *   FromSchema,
+ *   JSONSchema,
+ *   TargetError,
+ * } from './types.js';
+ */
+
+/**
+ * @typedef {(
+ *   & { schema: JSONSchema }
+ * )} ToJsonOptions
+ */
+
+const ajv = new Ajv({
+  allErrors: true,
+  verbose: false,
+  allowUnionTypes: false,
+  multipleOfPrecision: 5,
+  ownProperties: true,
+  strict: true,
+  useDefaults: true,
+});
+
+AddFormats.default(ajv);
+
+/**
+ * @type {WeakMap<JSONSchema, AsyncValidateFunction>}
+ */
+const validatorSchema = new WeakMap();
+
+/**
+ * @param {JSONSchema} schema - The original JSONSchema.
+ * @param {{ meta?: boolean | undefined }} [options] - The options for ajv compile.
+ * @returns {AsyncValidateFunction}
+ */
+export function getValidator(schema, options) {
+  const Compiled = validatorSchema.get(schema);
+  if (Compiled != null) {
+    return Compiled;
+  }
+
+  const validator = ajv.compile(
+    /** @type {AsyncSchema} */ ({
+      ...schema,
+      $async: true,
+    }),
+    options?.meta,
+  );
+  validatorSchema.set(schema, validator);
+
+  return validator;
+}
+
+/**
+ * @template {JSONSchema} const Schema - The raw schema type.
+ * @template {boolean} [AllowUnknown=false]
+ * @template {boolean} [ParseNot=false]
+ * @template {boolean} [ParseIfThenElse=false]
+ * @template [DataOptional=FromSchema<Schema, {
+ *   keepDefaultedPropertiesOptional: true,
+ *   parseIfThenElseKeywords: ParseIfThenElse,
+ *   parseNotKeyword: ParseNot,
+ * }>].
+ * @template [DataDefaults=FromSchema<Schema, {
+ *   keepDefaultedPropertiesOptional: false,
+ *   parseIfThenElseKeywords: ParseIfThenElse,
+ *   parseNotKeyword: ParseNot,
+ * }>].
+ * @param {Schema} schema - The request body json schema.
+ * @param {{
+ *   meta?: boolean | undefined,
+ *   allowUnknown?: AllowUnknown | undefined,
+ *   parseIfThenElseKeywords?: ParseIfThenElse | undefined,
+ *   parseNotKeyword?: ParseNot | undefined,
+ * }} [options] - The request body json schema.
+ * @param {TargetError | undefined} [ParentThrownError] - The error type.
+ * @returns {(
+ *   data: AllowUnknown extends true ? unknown : DataOptional,
+ *   TargetError?: TargetError | undefined
+ * ) => Promise<DataDefaults>}
+ */
+export function createValidator(schema, options, ParentThrownError) {
+  /** @type {AsyncValidateFunction<DataDefaults>} */
+  const validator = getValidator(schema, options);
+
+  /**
+   * @param {unknown} data - The raw data.
+   * @param {TargetError | undefined} [ThrownError] - The error type.
+   * @returns {Promise<DataDefaults>}
+   */
+  return async (data, ThrownError = ParentThrownError) => {
+    try {
+      return await validator(data);
+    } catch (error) {
+      if (
+        ThrownError == null ||
+        isSchemaError(error) === false
+      ) {
+        throw error;
+      }
+
+      throw new ThrownError(
+        { cause: error, errors: error.errors },
+      );
+    }
+  };
+}
+
+/**
+ * @template {JSONSchema} const Schema - The raw schema type.
+ * @template {boolean} [ParseNot=false]
+ * @template {boolean} [ParseIfThenElse=false]
+ * @template [DataDefaults=FromSchema<Schema, {
+ *   keepDefaultedPropertiesOptional: false,
+ *   parseIfThenElseKeywords: ParseIfThenElse,
+ *   parseNotKeyword: ParseNot,
+ * }>].
+ * @param {Schema} schema - The request body json schema.
+ * @param {unknown} data - The data to validate.
+ * @param {TargetError | undefined} [ThrownError] - The error type.
+ * @returns {Promise<DataDefaults>}
+ */
+export async function validate(schema, data, ThrownError) {
+  /** @type {AsyncValidateFunction<DataDefaults>} */
+  const validator = getValidator(schema);
+
+  try {
+    return await validator(data);
+  } catch (error) {
+    if (
+      ThrownError == null ||
+      isSchemaError(error) === false
+    ) {
+      throw error;
+    }
+
+    throw new ThrownError(
+      { cause: error, errors: error.errors },
+    );
+  }
+}

package/src/errors.js

@@ -1,26 +1,31 @@
+/**
+ * @import { DefinedError } from 'ajv'
+ * @import { ErrorOptions } from '@darksheep/errors'
+ */
+
+import { ValidationError } from 'ajv';
 import { BadRequest, InternalServerError } from '@darksheep/errors';
 
 /**
  * @typedef {(
- *   & import('@darksheep/errors').ErrorOptions
- *   & { errors: import('ajv').DefinedError[] }
- * )} ErrorOptions
+ *   & ErrorOptions
+ *   & { errors: DefinedError[] }
+ * )} SchemaErrorOptions
  */
 
 /**
  * The server will not process the request body not matching the expected request schema.
  */
 export class RequestSchemaError extends BadRequest {
-  /** @type {import('ajv').DefinedError[]} */
+  /** @type {DefinedError[]} */
   errors = [];
   name = 'RequestSchemaError';
 
   /**
-   * @param {string} message - The custom message for the http error.
-   * @param {ErrorOptions} options - The custom message for the http error.
+   * @param {SchemaErrorOptions} options - The custom message for the http error.
    */
-  constructor(message, { errors, ...options }) {
-    super(message, options);
+  constructor({ errors, ...options }) {
+    super('Request.body does not match Schema', options);
 
     this.errors = errors;
   }
@@ -30,17 +35,84 @@ export class RequestSchemaError extends BadRequest {
  * The server tried sending a response that did not match the expected response schema.
  */
 export class ResponseSchemaError extends InternalServerError {
-  /** @type {import('ajv').DefinedError[]} */
+  /** @type {DefinedError[]} */
   errors = [];
   name = 'ResponseSchemaError';
 
   /**
-   * @param {string} message - The custom message for the http error.
-   * @param {ErrorOptions} options - The custom message for the http error.
+   * @param {SchemaErrorOptions} options - The custom message for the http error.
    */
-  constructor(message, { errors, ...options }) {
-    super(message, options);
+  constructor({ errors, ...options }) {
+    super('Response.body does not match Schema', options);
 
     this.errors = errors;
   }
 }
+
+/** @type {Set<string>} */
+const keywords = new Set(
+  /** @type {DefinedError['keyword'][]} */ ([
+    'false schema',
+    'anyOf',
+    'not',
+    'type',
+    'additionalItems',
+    'items',
+    'contains',
+    'additionalProperties',
+    'dependencies',
+    'if',
+    'oneOf',
+    'propertyNames',
+    'maxItems',
+    'minItems',
+    'maxProperties',
+    'minProperties',
+    'minLength',
+    'maxLength',
+    'maximum',
+    'minimum',
+    'exclusiveMaximum',
+    'exclusiveMinimum',
+    'multipleOf',
+    'pattern',
+    'required',
+    'uniqueItems',
+    'const',
+    'enum',
+    'format',
+    'unevaluatedProperties',
+    'unevaluatedItems',
+    'dependentRequired',
+    'discriminator',
+  ]),
+);
+
+/**
+ * @param {unknown} input - The value to check.
+ * @returns {input is DefinedError}
+ */
+export function isDefinedError(input) {
+  return (
+    input != null &&
+    typeof input === 'object' &&
+    'keyword' in input &&
+    typeof input.keyword === 'string' &&
+    keywords.has(input.keyword) &&
+    'instancePath' in input &&
+    typeof input.instancePath === 'string' &&
+    'schemaPath' in input &&
+    typeof input.schemaPath === 'string'
+  );
+}
+
+/**
+ * @param {unknown} input - The value to check.
+ * @returns {input is import('./types.js').ValidationError}
+ */
+export function isSchemaError(input) {
+  return (
+    input instanceof ValidationError &&
+    input.errors.every(isDefinedError)
+  );
+}

package/src/index.js

@@ -1,18 +1,7 @@
-/**
- * @typedef {import('ajv').DefinedError} DefinedError
- * @typedef {Exclude<import('json-schema-to-ts').JSONSchema, boolean>} JSONSchema
- * @typedef {import('json-schema-to-ts').FromSchemaOptions} FromSchemaOptions
- * @typedef {import('json-schema-to-ts').FromSchemaDefaultOptions} FromSchemaDefaultOptions
- */
+export * from './types.js';
 
 /**
- * @template {JSONSchema} Schema
- * @template {FromSchemaOptions} [Options=FromSchemaDefaultOptions]
- * @typedef {import('json-schema-to-ts').FromSchema<Schema, Options>} FromSchema
- */
-
-/**
- * @template {JSONSchema} const Schema - The raw schema type.
+ * @template {import('./types.js').JSONSchema} const Schema - The raw schema type.
  * @param {Schema} schema - The raw JSON schema.
  * @returns {Schema}
  */
@@ -21,12 +10,18 @@ export function defineSchema(schema) {
 }
 
 export {
+  isDefinedError,
+  isSchemaError,
   RequestSchemaError,
   ResponseSchemaError,
 } from './errors.js';
 
 export {
-  validateData,
-  validateRequestBody,
-  validateResponseBody,
-} from './validator.js';
+  createValidator,
+  validate,
+} from './async.js';
+
+export {
+  createAssertSchema,
+  assertSchema,
+} from './sync.js';

package/src/sync.js

@@ -0,0 +1,112 @@
+import { Ajv2019 as Ajv, ValidationError } from 'ajv/dist/2019.js';
+import AddFormats from 'ajv-formats';
+import { isDefinedError } from './errors.js';
+
+/**
+ * @import {
+ *   SchemaObject,
+ *   ValidateFunction
+ * } from 'ajv'
+ * @import {
+ *   FromSchema,
+ *   JSONSchema,
+ *   TargetError,
+ * } from './types.js'
+ */
+
+/**
+ * @typedef {(
+ *   & { schema: JSONSchema }
+ * )} ToJsonOptions
+ */
+
+const ajv = new Ajv({
+  allErrors: true,
+  verbose: false,
+  allowUnionTypes: false,
+  multipleOfPrecision: 5,
+  ownProperties: true,
+  strict: true,
+  useDefaults: false,
+});
+
+AddFormats.default(ajv);
+
+/**
+ * @type {WeakMap<JSONSchema, ValidateFunction>}
+ */
+const enforcerSchema = new WeakMap();
+
+/**
+ * @param {JSONSchema} schema - The original JSONSchema.
+ * @returns {ValidateFunction}
+ */
+export function getValidator(schema) {
+  const Compiled = enforcerSchema.get(schema);
+  if (Compiled != null) {
+    return Compiled;
+  }
+
+  const enforcer = ajv.compile(
+    /** @type {SchemaObject} */ ({
+      ...schema,
+      $async: false,
+    }),
+  );
+  enforcerSchema.set(schema, enforcer);
+
+  return enforcer;
+}
+
+/**
+ * @template {JSONSchema} const Schema - The raw schema type.
+ * @template [Data=FromSchema<Schema>]
+ * @param {Schema} schema - The request body json schema.
+ * @returns {(data: unknown, TargetError?: TargetError | undefined) => asserts data is Data}
+ */
+export function createAssertSchema(schema) {
+  /** @type {ValidateFunction<Data>} */
+  const validator = getValidator(schema);
+
+  /** @type {(data: unknown, TargetError?: TargetError | undefined) => asserts data is Data} */
+  return (data, TargetError) => {
+    if (validator(data)) {
+      return;
+    }
+
+    const errors = validator.errors
+      ?.filter(isDefinedError) ?? [];
+
+    if (TargetError == null) {
+      throw new ValidationError(errors);
+    }
+
+    throw new TargetError({ errors });
+  };
+}
+
+/**
+ * @template {JSONSchema} const Schema - The raw schema type.
+ * @template [Data=FromSchema<Schema>]
+ * @param {Schema} schema - The request body json schema.
+ * @param {unknown} data - The raw data.
+ * @param {TargetError | undefined} [TargetError] - The error type.
+ * @returns {asserts data is Data}
+ */
+export function assertSchema(schema, data, TargetError) {
+  /** @type {ValidateFunction<Data>} */
+  const validator = getValidator(schema);
+
+  if (validator(data)) {
+    return;
+  }
+
+  const errors = validator.errors
+    ?.filter(isDefinedError) ?? [];
+
+  if (TargetError == null) {
+    throw new ValidationError(errors);
+  }
+
+  throw new TargetError({ errors });
+}

package/src/types.js

@@ -0,0 +1,32 @@
+/**
+ * @import { DefinedError } from 'ajv'
+ */
+export {};
+
+/**
+ * @typedef {(
+ *   & Omit<import('ajv').ValidationError, 'errors'>
+ *   & { errors: DefinedError[] }
+ * )} ValidationError
+ */
+
+/**
+ * @typedef {new (options: { cause?: Error, errors: DefinedError[] }) => Error} TargetError
+ */
+/**
+ * @typedef {Exclude<import('json-schema-to-ts').JSONSchema, boolean>} JSONSchema
+ */
+
+/**
+ * @typedef {import('json-schema-to-ts').FromSchemaOptions} FromSchemaOptions
+ */
+
+/**
+ * @typedef {import('json-schema-to-ts').FromSchemaDefaultOptions} FromSchemaDefaultOptions
+ */
+
+/**
+ * @template {JSONSchema} Schema - The raw schema type.
+ * @template {FromSchemaOptions} [Options=FromSchemaDefaultOptions] - The schema typing options.
+ * @typedef {import('json-schema-to-ts').FromSchema<Schema, Options>} FromSchema
+ */

package/types/async.d.ts

@@ -0,0 +1,76 @@
+/**
+ * @param {JSONSchema} schema - The original JSONSchema.
+ * @param {{ meta?: boolean | undefined }} [options] - The options for ajv compile.
+ * @returns {AsyncValidateFunction}
+ */
+export function getValidator(schema: JSONSchema, options?: {
+    meta?: boolean | undefined;
+}): AsyncValidateFunction;
+/**
+ * @template {JSONSchema} const Schema - The raw schema type.
+ * @template {boolean} [AllowUnknown=false]
+ * @template {boolean} [ParseNot=false]
+ * @template {boolean} [ParseIfThenElse=false]
+ * @template [DataOptional=FromSchema<Schema, {
+ *   keepDefaultedPropertiesOptional: true,
+ *   parseIfThenElseKeywords: ParseIfThenElse,
+ *   parseNotKeyword: ParseNot,
+ * }>].
+ * @template [DataDefaults=FromSchema<Schema, {
+ *   keepDefaultedPropertiesOptional: false,
+ *   parseIfThenElseKeywords: ParseIfThenElse,
+ *   parseNotKeyword: ParseNot,
+ * }>].
+ * @param {Schema} schema - The request body json schema.
+ * @param {{
+ *   meta?: boolean | undefined,
+ *   allowUnknown?: AllowUnknown | undefined,
+ *   parseIfThenElseKeywords?: ParseIfThenElse | undefined,
+ *   parseNotKeyword?: ParseNot | undefined,
+ * }} [options] - The request body json schema.
+ * @param {TargetError | undefined} [ParentThrownError] - The error type.
+ * @returns {(
+ *   data: AllowUnknown extends true ? unknown : DataOptional,
+ *   TargetError?: TargetError | undefined
+ * ) => Promise<DataDefaults>}
+ */
+export function createValidator<const Schema extends JSONSchema, AllowUnknown extends boolean = false, ParseNot extends boolean = false, ParseIfThenElse extends boolean = false, DataOptional = FromSchema<Schema, {
+    keepDefaultedPropertiesOptional: true;
+    parseIfThenElseKeywords: ParseIfThenElse;
+    parseNotKeyword: ParseNot;
+}>, DataDefaults = FromSchema<Schema, {
+    keepDefaultedPropertiesOptional: false;
+    parseIfThenElseKeywords: ParseIfThenElse;
+    parseNotKeyword: ParseNot;
+}>>(schema: Schema, options?: {
+    meta?: boolean | undefined;
+    allowUnknown?: AllowUnknown | undefined;
+    parseIfThenElseKeywords?: ParseIfThenElse | undefined;
+    parseNotKeyword?: ParseNot | undefined;
+}, ParentThrownError?: TargetError | undefined): (data: AllowUnknown extends true ? unknown : DataOptional, TargetError?: TargetError | undefined) => Promise<DataDefaults>;
+/**
+ * @template {JSONSchema} const Schema - The raw schema type.
+ * @template {boolean} [ParseNot=false]
+ * @template {boolean} [ParseIfThenElse=false]
+ * @template [DataDefaults=FromSchema<Schema, {
+ *   keepDefaultedPropertiesOptional: false,
+ *   parseIfThenElseKeywords: ParseIfThenElse,
+ *   parseNotKeyword: ParseNot,
+ * }>].
+ * @param {Schema} schema - The request body json schema.
+ * @param {unknown} data - The data to validate.
+ * @param {TargetError | undefined} [ThrownError] - The error type.
+ * @returns {Promise<DataDefaults>}
+ */
+export function validate<const Schema extends JSONSchema, ParseNot extends boolean = false, ParseIfThenElse extends boolean = false, DataDefaults = FromSchema<Schema, {
+    keepDefaultedPropertiesOptional: false;
+    parseIfThenElseKeywords: ParseIfThenElse;
+    parseNotKeyword: ParseNot;
+}>>(schema: Schema, data: unknown, ThrownError?: TargetError | undefined): Promise<DataDefaults>;
+export type ToJsonOptions = ({
+    schema: JSONSchema;
+});
+import type { JSONSchema } from './types.js';
+import type { AsyncValidateFunction } from 'ajv';
+import type { FromSchema } from './types.js';
+import type { TargetError } from './types.js';

package/types/errors.d.ts

@@ -1,35 +1,45 @@
+/**
+ * @param {unknown} input - The value to check.
+ * @returns {input is DefinedError}
+ */
+export function isDefinedError(input: unknown): input is DefinedError;
+/**
+ * @param {unknown} input - The value to check.
+ * @returns {input is import('./types.js').ValidationError}
+ */
+export function isSchemaError(input: unknown): input is import("./types.js").ValidationError;
 /**
  * @typedef {(
- *   & import('@darksheep/errors').ErrorOptions
- *   & { errors: import('ajv').DefinedError[] }
- * )} ErrorOptions
+ *   & ErrorOptions
+ *   & { errors: DefinedError[] }
+ * )} SchemaErrorOptions
  */
 /**
  * The server will not process the request body not matching the expected request schema.
  */
 export class RequestSchemaError extends BadRequest {
     /**
-     * @param {string} message - The custom message for the http error.
-     * @param {ErrorOptions} options - The custom message for the http error.
+     * @param {SchemaErrorOptions} options - The custom message for the http error.
      */
-    constructor(message: string, { errors, ...options }: ErrorOptions);
-    /** @type {import('ajv').DefinedError[]} */
-    errors: import("ajv").DefinedError[];
+    constructor({ errors, ...options }: SchemaErrorOptions);
+    /** @type {DefinedError[]} */
+    errors: DefinedError[];
 }
 /**
  * The server tried sending a response that did not match the expected response schema.
  */
 export class ResponseSchemaError extends InternalServerError {
     /**
-     * @param {string} message - The custom message for the http error.
-     * @param {ErrorOptions} options - The custom message for the http error.
+     * @param {SchemaErrorOptions} options - The custom message for the http error.
      */
-    constructor(message: string, { errors, ...options }: ErrorOptions);
-    /** @type {import('ajv').DefinedError[]} */
-    errors: import("ajv").DefinedError[];
+    constructor({ errors, ...options }: SchemaErrorOptions);
+    /** @type {DefinedError[]} */
+    errors: DefinedError[];
 }
-export type ErrorOptions = (import("@darksheep/errors").ErrorOptions & {
-    errors: import("ajv").DefinedError[];
+export type SchemaErrorOptions = (ErrorOptions & {
+    errors: DefinedError[];
 });
+import type { DefinedError } from 'ajv';
 import { BadRequest } from '@darksheep/errors';
 import { InternalServerError } from '@darksheep/errors';
+import type { ErrorOptions } from '@darksheep/errors';

package/types/index.d.ts

@@ -1,24 +1,10 @@
 /**
- * @typedef {import('ajv').DefinedError} DefinedError
- * @typedef {Exclude<import('json-schema-to-ts').JSONSchema, boolean>} JSONSchema
- * @typedef {import('json-schema-to-ts').FromSchemaOptions} FromSchemaOptions
- * @typedef {import('json-schema-to-ts').FromSchemaDefaultOptions} FromSchemaDefaultOptions
- */
-/**
- * @template {JSONSchema} Schema
- * @template {FromSchemaOptions} [Options=FromSchemaDefaultOptions]
- * @typedef {import('json-schema-to-ts').FromSchema<Schema, Options>} FromSchema
- */
-/**
- * @template {JSONSchema} const Schema - The raw schema type.
+ * @template {import('./types.js').JSONSchema} const Schema - The raw schema type.
  * @param {Schema} schema - The raw JSON schema.
  * @returns {Schema}
  */
-export function defineSchema<const Schema extends JSONSchema>(schema: Schema): Schema;
-export type DefinedError = import("ajv").DefinedError;
-export type JSONSchema = Exclude<import("json-schema-to-ts").JSONSchema, boolean>;
-export type FromSchemaOptions = import("json-schema-to-ts").FromSchemaOptions;
-export type FromSchemaDefaultOptions = import("json-schema-to-ts").FromSchemaDefaultOptions;
-export type FromSchema<Schema extends JSONSchema, Options extends FromSchemaOptions = import("json-schema-to-ts").FromSchemaDefaultOptions> = import("json-schema-to-ts").FromSchema<Schema, Options>;
-export { RequestSchemaError, ResponseSchemaError } from "./errors.js";
-export { validateData, validateRequestBody, validateResponseBody } from "./validator.js";
+export function defineSchema<const Schema extends import("./types.js").JSONSchema>(schema: Schema): Schema;
+export * from "./types.js";
+export { isDefinedError, isSchemaError, RequestSchemaError, ResponseSchemaError } from "./errors.js";
+export { createValidator, validate } from "./async.js";
+export { createAssertSchema, assertSchema } from "./sync.js";

package/types/sync.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @param {JSONSchema} schema - The original JSONSchema.
+ * @returns {ValidateFunction}
+ */
+export function getValidator(schema: JSONSchema): ValidateFunction;
+/**
+ * @template {JSONSchema} const Schema - The raw schema type.
+ * @template [Data=FromSchema<Schema>]
+ * @param {Schema} schema - The request body json schema.
+ * @returns {(data: unknown, TargetError?: TargetError | undefined) => asserts data is Data}
+ */
+export function createAssertSchema<const Schema extends JSONSchema, Data = FromSchema<Schema>>(schema: Schema): (data: unknown, TargetError?: TargetError | undefined) => asserts data is Data;
+/**
+ * @template {JSONSchema} const Schema - The raw schema type.
+ * @template [Data=FromSchema<Schema>]
+ * @param {Schema} schema - The request body json schema.
+ * @param {unknown} data - The raw data.
+ * @param {TargetError | undefined} [TargetError] - The error type.
+ * @returns {asserts data is Data}
+ */
+export function assertSchema<const Schema extends JSONSchema, Data = FromSchema<Schema>>(schema: Schema, data: unknown, TargetError?: TargetError | undefined): asserts data is Data;
+export type ToJsonOptions = ({
+    schema: JSONSchema;
+});
+import type { JSONSchema } from './types.js';
+import type { ValidateFunction } from 'ajv';
+import type { FromSchema } from './types.js';
+import type { TargetError } from './types.js';

package/types/types.d.ts

@@ -0,0 +1,12 @@
+export type ValidationError = (Omit<import("ajv").ValidationError, "errors"> & {
+    errors: DefinedError[];
+});
+export type TargetError = new (options: {
+    cause?: Error;
+    errors: DefinedError[];
+}) => Error;
+export type JSONSchema = Exclude<import("json-schema-to-ts").JSONSchema, boolean>;
+export type FromSchemaOptions = import("json-schema-to-ts").FromSchemaOptions;
+export type FromSchemaDefaultOptions = import("json-schema-to-ts").FromSchemaDefaultOptions;
+export type FromSchema<Schema extends JSONSchema, Options extends FromSchemaOptions = import("json-schema-to-ts").FromSchemaDefaultOptions> = import("json-schema-to-ts").FromSchema<Schema, Options>;
+import type { DefinedError } from 'ajv';

package/src/validator.js

@@ -1,122 +0,0 @@
-import { Ajv } from 'ajv';
-import { RequestSchemaError, ResponseSchemaError } from './errors.js';
-
-/**
- * @import { DefinedError, AsyncSchema, AsyncValidateFunction, ValidationError } from 'ajv'
- * @import { FromSchema, JSONSchema } from 'json-schema-to-ts'
- */
-
-/**
- * @typedef {(
- *   & { schema: JSONSchema }
- * )} ToJsonOptions
- */
-
-const ajv = new Ajv({
-  allErrors: true,
-  verbose: false,
-  allowUnionTypes: false,
-  multipleOfPrecision: 5,
-  ownProperties: true,
-  strict: true,
-  useDefaults: false,
-});
-
-/**
- * @type {WeakMap<Exclude<JSONSchema, boolean>, AsyncValidateFunction>}
- */
-const compiled = new WeakMap();
-
-/**
- * @param {unknown} input - The value to check.
- * @returns {input is ValidationError & { errors: DefinedError[] }}
- */
-function isAjvError(input) {
-  return (
-    input instanceof Error &&
-    'errors' in input &&
-    Array.isArray(input.errors)
-  );
-}
-
-/**
- * @param {Exclude<JSONSchema, boolean>} schema - The original JSONSchema.
- * @returns {AsyncValidateFunction}
- */
-function getValidator(schema) {
-  const Compiled = compiled.get(schema);
-  if (Compiled != null) {
-    return Compiled;
-  }
-
-  const validator = ajv.compile(
-    /** @type {AsyncSchema} */ ({
-      ...schema,
-      $async: true,
-    }),
-  );
-  compiled.set(schema, validator);
-
-  return validator;
-}
-
-/**
- * @template {Exclude<JSONSchema, boolean>} Schema
- * @template [Data=FromSchema<Schema>]
- * @param {Schema} schema - The request body json schema.
- * @param {unknown} data - The data to validate.
- * @returns {Promise<Data>}
- * @throws {ValidationError & { errors: DefinedError[] }}
- */
-export async function validateData(schema, data) {
-  /** @type {AsyncValidateFunction<Data>} */
-  const validator = getValidator(schema);
-
-  return await validator(data);
-}
-
-/**
- * @template {Exclude<JSONSchema, boolean>} Schema
- * @template [Data=FromSchema<Schema>]
- * @param {Schema} schema - The request body json schema.
- * @param {unknown} data - The data to validate.
- * @returns {Promise<Data>}
- * @throws {RequestSchemaError}
- */
-export async function validateRequestBody(schema, data) {
-  try {
-    return await validateData(schema, data);
-  } catch (error) {
-    if (isAjvError(error)) {
-      throw new RequestSchemaError(
-        'Request.body does not match Schema',
-        { cause: error, errors: error.errors },
-      );
-    }
-
-    throw error;
-  }
-}
-
-/**
- * @template {Exclude<JSONSchema, boolean>} Schema
- * @template [Data=FromSchema<Schema>]
- * @param {Schema} schema - The response body json schema.
- * @param {unknown} data - The data to validate.
- * @returns {Promise<Data>}
- * @throws {ResponseSchemaError}
- */
-export async function validateResponseBody(schema, data) {
-  try {
-    return await validateData(schema, data);
-  } catch (error) {
-    if (isAjvError(error)) {
-      throw new ResponseSchemaError(
-        'Response.body does not match Schema',
-        { cause: error, errors: error.errors },
-      );
-    }
-
-    throw error;
-  }
-}

package/types/validator.d.ts

@@ -1,32 +0,0 @@
-/**
- * @template {Exclude<JSONSchema, boolean>} Schema
- * @template [Data=FromSchema<Schema>]
- * @param {Schema} schema - The request body json schema.
- * @param {unknown} data - The data to validate.
- * @returns {Promise<Data>}
- * @throws {ValidationError & { errors: DefinedError[] }}
- */
-export function validateData<Schema extends Exclude<JSONSchema, boolean>, Data = FromSchema<Schema>>(schema: Schema, data: unknown): Promise<Data>;
-/**
- * @template {Exclude<JSONSchema, boolean>} Schema
- * @template [Data=FromSchema<Schema>]
- * @param {Schema} schema - The request body json schema.
- * @param {unknown} data - The data to validate.
- * @returns {Promise<Data>}
- * @throws {RequestSchemaError}
- */
-export function validateRequestBody<Schema extends Exclude<JSONSchema, boolean>, Data = FromSchema<Schema>>(schema: Schema, data: unknown): Promise<Data>;
-/**
- * @template {Exclude<JSONSchema, boolean>} Schema
- * @template [Data=FromSchema<Schema>]
- * @param {Schema} schema - The response body json schema.
- * @param {unknown} data - The data to validate.
- * @returns {Promise<Data>}
- * @throws {ResponseSchemaError}
- */
-export function validateResponseBody<Schema extends Exclude<JSONSchema, boolean>, Data = FromSchema<Schema>>(schema: Schema, data: unknown): Promise<Data>;
-export type ToJsonOptions = ({
-    schema: JSONSchema;
-});
-import type { JSONSchema } from 'json-schema-to-ts';
-import type { FromSchema } from 'json-schema-to-ts';