@modulify/validator 0.1.0 → 0.2.1

package/types/json-schema.d.ts

@@ -0,0 +1,75 @@
+import type {
+  Constraint,
+  ConstraintDescriptor,
+  MaybeMany,
+} from './index'
+
+/** JSON Schema primitive `type` values used by `toJsonSchema(...)`. */
+export type JsonSchemaTypeName =
+  | 'string'
+  | 'number'
+  | 'integer'
+  | 'boolean'
+  | 'object'
+  | 'array'
+  | 'null'
+
+/** Minimal JSON Schema object shape emitted by the built-in exporter. */
+export interface JsonSchema {
+  readonly $schema?: string;
+  readonly $id?: string;
+  readonly $comment?: string;
+  readonly title?: string;
+  readonly description?: string;
+  readonly format?: string;
+  readonly default?: unknown;
+  readonly examples?: readonly unknown[];
+  readonly deprecated?: boolean;
+  readonly readOnly?: boolean;
+  readonly writeOnly?: boolean;
+  readonly type?: JsonSchemaTypeName | readonly JsonSchemaTypeName[];
+  readonly const?: unknown;
+  readonly enum?: readonly unknown[];
+  readonly allOf?: readonly JsonSchema[];
+  readonly anyOf?: readonly JsonSchema[];
+  readonly oneOf?: readonly JsonSchema[];
+  readonly properties?: Readonly<Record<string, JsonSchema>>;
+  readonly required?: readonly string[];
+  readonly additionalProperties?: boolean | JsonSchema;
+  readonly items?: JsonSchema;
+  readonly prefixItems?: readonly JsonSchema[];
+  readonly minItems?: number;
+  readonly maxItems?: number;
+  readonly minLength?: number;
+  readonly maxLength?: number;
+  readonly pattern?: string;
+  readonly minimum?: number;
+  readonly maximum?: number;
+  readonly multipleOf?: number;
+}
+
+/** Controls how `toJsonSchema(...)` handles constraints that cannot be represented faithfully. */
+export type JsonSchemaExportMode = 'bestEffort' | 'strict'
+
+/** Options for the JSON Schema exporter. */
+export interface ToJsonSchemaOptions {
+  readonly mode?: JsonSchemaExportMode
+}
+
+/** Error thrown by `toJsonSchema(...)` in strict mode when a node cannot be exported faithfully. */
+export declare class JsonSchemaExportError extends Error {
+  constructor(message: string, options: {
+    descriptor: ConstraintDescriptor
+    reason: string
+    path?: readonly PropertyKey[]
+  })
+  readonly descriptor: ConstraintDescriptor
+  readonly reason: string
+  readonly path: readonly PropertyKey[]
+}
+
+/** Derives a JSON Schema object from one or many public constraint descriptors. */
+export declare const toJsonSchema: <const C extends MaybeMany<Constraint>>(
+  constraints: C,
+  options?: ToJsonSchemaOptions
+) => JsonSchema

package/dist/assertions/Assert.d.ts

@@ -1,2 +0,0 @@
-import { Assertion, Meta, Predicate } from '../../types';
-export declare const Assert: <T = unknown, M = unknown>(predicate: Predicate<T>, options: Meta<M>) => Assertion<T, M>;

package/dist/assertions/HasLength.d.ts

@@ -1,7 +0,0 @@
-import { Assertion } from '../../types';
-export declare const HasLength: ({ exact, max, min, bail, }: {
-    exact?: number | null;
-    max?: number | null;
-    min?: number | null;
-    bail?: boolean;
-}) => Assertion<string | unknown[], unknown>;

package/dist/assertions/check.d.ts

@@ -1,3 +0,0 @@
-import { Assertion, Violation } from '../../types';
-declare const check: <T = unknown, M = unknown>(assert: Assertion<T, M>, value: unknown, path?: PropertyKey[]) => null | Violation<M>;
-export default check;

package/dist/assertions/index.d.ts

@@ -1,16 +0,0 @@
-import { Assert } from './Assert';
-import { Assertion } from '../../types';
-export { Assert };
-export { HasLength } from './HasLength';
-export declare const IsBoolean: Assertion<boolean, unknown>;
-export declare const IsDate: Assertion<Date, unknown>;
-export declare const IsDefined: Assertion<unknown, unknown>;
-export declare const IsEmail: Assertion<string, unknown>;
-export declare const IsNull: Assertion<null, unknown>;
-export declare const IsNumber: Assertion<number, unknown>;
-export declare const IsString: Assertion<string, unknown>;
-export declare const IsSymbol: Assertion<symbol, unknown>;
-export declare const OneOf: <Actual = unknown>(values: Actual[] | Record<string, Actual>, { equalTo, bail, }?: {
-    equalTo?: (a: Actual, b: unknown) => boolean;
-    bail?: boolean;
-}) => Assertion<Actual, Actual[]>;

package/dist/runners/Each.d.ts

@@ -1,3 +0,0 @@
-import { Constraint, MaybeMany, ValidationRunner } from '../../types';
-declare const _default: (constraints: MaybeMany<Constraint>) => ValidationRunner;
-export default _default;

package/dist/runners/HasProperties.d.ts

@@ -1,6 +0,0 @@
-import { Constraint, MaybeMany, ValidationRunner } from '../../types';
-export type Descriptor<T extends object> = {
-    [P in keyof T]: MaybeMany<Constraint>;
-};
-declare const _default: <T extends object>(descriptor: Descriptor<T>) => ValidationRunner;
-export default _default;

package/dist/runners/index.d.ts

@@ -1,2 +0,0 @@
-export { default as Each } from './Each';
-export { default as HasProperties } from './HasProperties';

package/dist/runners.cjs

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const predicates = require("./predicates.cjs");
-const Each = (constraints) => {
-  return {
-    run(validate, value, path) {
-      return predicates.isArray(value) ? value.map((v, i) => validate(v, constraints, [...path, i])) : [validate(value, constraints, [...path])];
-    }
-  };
-};
-const HasProperties = (descriptor) => ({
-  run(validate, value, path) {
-    if (predicates.isRecord(value)) {
-      const fields = Object.keys(descriptor);
-      return fields.reduce((accumulator, key) => [
-        ...accumulator,
-        validate(value[key], descriptor[key], [...path, key])
-      ], []);
-    } else {
-      return [
-        [{
-          value,
-          path,
-          violates: "@modulify/validator/HasProperties",
-          reason: "unsupported"
-        }]
-      ];
-    }
-  }
-});
-exports.Each = Each;
-exports.HasProperties = HasProperties;

package/dist/runners.d.ts

@@ -1,2 +0,0 @@
-export * from './runners/index'
-export {}

package/dist/runners.mjs

@@ -1,32 +0,0 @@
-import { isArray, isRecord } from "./predicates.mjs";
-const Each = (constraints) => {
-  return {
-    run(validate, value, path) {
-      return isArray(value) ? value.map((v, i) => validate(v, constraints, [...path, i])) : [validate(value, constraints, [...path])];
-    }
-  };
-};
-const HasProperties = (descriptor) => ({
-  run(validate, value, path) {
-    if (isRecord(value)) {
-      const fields = Object.keys(descriptor);
-      return fields.reduce((accumulator, key) => [
-        ...accumulator,
-        validate(value[key], descriptor[key], [...path, key])
-      ], []);
-    } else {
-      return [
-        [{
-          value,
-          path,
-          violates: "@modulify/validator/HasProperties",
-          reason: "unsupported"
-        }]
-      ];
-    }
-  }
-});
-export {
-  Each,
-  HasProperties
-};