@unispechq/unispec-core 0.3.2 → 0.3.3

package/dist/schemas/resolver.js

@@ -1,37 +0,0 @@
-import { normalizeSchemaRef } from "./utils.js";
-/**
- * Resolve a schema reference to its definition in a UniSpec document.
- *
- * @param doc - The UniSpec document containing schemas
- * @param ref - The schema reference to resolve
- * @returns The schema definition or undefined if not found
- */
-export function resolveSchemaRef(doc, ref) {
-    const name = normalizeSchemaRef(ref);
-    if (!name)
-        return undefined;
-    return doc.service?.schemas?.[name];
-}
-/**
- * Register a new schema definition in a UniSpec document.
- * Creates the schemas container if it doesn't exist.
- *
- * @param doc - The UniSpec document to modify
- * @param name - The schema name
- * @param jsonSchema - The JSON Schema definition
- * @returns The created schema definition
- */
-export function registerSchema(doc, name, jsonSchema) {
-    if (!doc.service) {
-        doc.service = { name: "" };
-    }
-    if (!doc.service.schemas) {
-        doc.service.schemas = {};
-    }
-    const definition = {
-        name,
-        jsonSchema,
-    };
-    doc.service.schemas[name] = definition;
-    return definition;
-}

package/dist/schemas/utils.d.ts

@@ -1,20 +0,0 @@
-/**
- * Normalize a schema reference to extract the schema name.
- * Supports multiple formats:
- * - Simple name: "User"
- * - JSON Pointer: "#/service/schemas/User"
- * - Hash format: "#User"
- * - Path format: "path/to/User"
- *
- * @param ref - The schema reference to normalize
- * @returns The normalized schema name
- */
-export declare function normalizeSchemaRef(ref: string): string;
-/**
- * Create a stable string representation of a value for comparison.
- * Used for schema deduplication by creating consistent JSON strings.
- *
- * @param value - The value to stringify
- * @returns A stable JSON string representation
- */
-export declare function stableStringify(value: unknown): string;

package/dist/schemas/utils.js

@@ -1,49 +0,0 @@
-/**
- * Normalize a schema reference to extract the schema name.
- * Supports multiple formats:
- * - Simple name: "User"
- * - JSON Pointer: "#/service/schemas/User"
- * - Hash format: "#User"
- * - Path format: "path/to/User"
- *
- * @param ref - The schema reference to normalize
- * @returns The normalized schema name
- */
-export function normalizeSchemaRef(ref) {
-    const trimmed = ref.trim();
-    if (trimmed.length === 0)
-        return "";
-    // Handle JSON Pointer format: #/service/schemas/SchemaName
-    if (trimmed.startsWith("#/service/schemas/")) {
-        const parts = trimmed.split("/");
-        return parts[parts.length - 1];
-    }
-    // Handle simple name format: SchemaName
-    const withoutHash = trimmed.startsWith("#") ? trimmed.slice(1) : trimmed;
-    const parts = withoutHash.split("/").filter(Boolean);
-    return parts.length > 0 ? parts[parts.length - 1] : withoutHash;
-}
-/**
- * Create a stable string representation of a value for comparison.
- * Used for schema deduplication by creating consistent JSON strings.
- *
- * @param value - The value to stringify
- * @returns A stable JSON string representation
- */
-export function stableStringify(value) {
-    if (value === null)
-        return "null";
-    const t = typeof value;
-    if (t === "number" || t === "boolean")
-        return JSON.stringify(value);
-    if (t === "string")
-        return JSON.stringify(value);
-    if (Array.isArray(value))
-        return `[${value.map(stableStringify).join(",")}]`;
-    if (t !== "object")
-        return JSON.stringify(value);
-    const obj = value;
-    const keys = Object.keys(obj).sort();
-    const entries = keys.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`);
-    return `{${entries.join(",")}}`;
-}

package/dist/types/index.d.ts

@@ -1,433 +0,0 @@
-export interface UniSpecNamedItem {
-    name: string;
-    description?: string;
-}
-export interface UniSpecDeprecatedItem {
-    deprecated?: boolean;
-    deprecationReason?: string;
-}
-export interface UniSpecTaggedItem {
-    tags?: string[];
-}
-export interface UniSpecProtocolBase {
-    url?: string;
-    securitySchemes?: Record<string, UniSpecSecurityScheme>;
-}
-export interface UniSpecSecurityRequirement extends Array<string> {
-}
-export interface UniSpecBaseHeader {
-    name: string;
-    description?: string;
-    required?: boolean;
-}
-export interface UniSpecHeader extends UniSpecBaseHeader {
-    defaultValue?: string;
-    schemaRef?: string;
-}
-export interface UniSpecApiKeyScheme {
-    type: "apiKey";
-    name: string;
-    in: "header" | "query" | "cookie";
-    description?: string;
-}
-export interface UniSpecHttpScheme {
-    type: "http";
-    scheme: "basic" | "bearer" | "digest";
-    bearerFormat?: string;
-    description?: string;
-}
-export interface UniSpecOAuth2Flow {
-    authorizationUrl: string;
-    tokenUrl: string;
-    refreshUrl?: string;
-    scopes: Record<string, string>;
-}
-export interface UniSpecOAuth2Scheme {
-    type: "oauth2";
-    flows: {
-        authorizationCode?: UniSpecOAuth2Flow;
-        clientCredentials?: UniSpecOAuth2Flow;
-        implicit?: UniSpecOAuth2Flow;
-    };
-    description?: string;
-}
-export interface UniSpecJwtScheme {
-    type: "jwt";
-    issuer?: string;
-    audience?: string[];
-    algorithms?: string[];
-    description?: string;
-}
-export type UniSpecSecurityScheme = UniSpecApiKeyScheme | UniSpecHttpScheme | UniSpecOAuth2Scheme | UniSpecJwtScheme;
-export interface UniSpecGraphQLArgument extends UniSpecNamedItem, UniSpecDeprecatedItem {
-    type: string;
-    defaultValue?: unknown;
-}
-export interface UniSpecGraphQLOperation extends UniSpecNamedItem, UniSpecDeprecatedItem, UniSpecTaggedItem {
-    args?: UniSpecGraphQLArgument[];
-    returnType?: string;
-    headers?: UniSpecGraphQLHeader[];
-    security?: UniSpecSecurityRequirement[];
-}
-export interface UniSpecGraphQLHeader extends UniSpecBaseHeader {
-}
-export interface UniSpecGraphQLProtocol extends UniSpecProtocolBase {
-    schema?: string;
-    headers?: UniSpecGraphQLHeader[];
-    queries?: UniSpecGraphQLOperation[];
-    mutations?: UniSpecGraphQLOperation[];
-    subscriptions?: UniSpecGraphQLOperation[];
-}
-export interface UniSpecWebSocketMessage extends UniSpecNamedItem, UniSpecDeprecatedItem {
-    direction?: "publish" | "subscribe" | "both";
-    schemaRef?: string;
-}
-export interface UniSpecWebSocketHeader extends UniSpecBaseHeader {
-}
-export interface UniSpecWebSocketReconnectStrategy {
-    maxAttempts?: number;
-    delay?: number;
-    backoffMultiplier?: number;
-}
-export interface UniSpecWebSocketChannel extends UniSpecNamedItem, UniSpecDeprecatedItem, UniSpecTaggedItem {
-    namespace?: string;
-    direction?: "publish" | "subscribe" | "both";
-    connectionParams?: Record<string, string>;
-    reconnectStrategy?: UniSpecWebSocketReconnectStrategy;
-    headers?: UniSpecWebSocketHeader[];
-    messages?: UniSpecWebSocketMessage[];
-    security?: UniSpecSecurityRequirement[];
-}
-export interface UniSpecWebSocketProtocol extends UniSpecProtocolBase {
-    headers?: UniSpecWebSocketHeader[];
-    channels?: UniSpecWebSocketChannel[];
-}
-export interface UniSpecRestParameter extends UniSpecBaseHeader {
-    schemaRef?: string;
-}
-export interface UniSpecRestMediaType {
-    schemaRef?: string;
-}
-export interface UniSpecRestContent {
-    [mediaType: string]: UniSpecRestMediaType;
-}
-export interface UniSpecRestRequestBody {
-    description?: string;
-    required?: boolean;
-    content?: UniSpecRestContent;
-}
-export interface UniSpecRestResponseHeader extends UniSpecHeader {
-}
-export interface UniSpecRestResponse {
-    description?: string;
-    headers?: UniSpecRestResponseHeader[];
-    content?: UniSpecRestContent;
-}
-export interface UniSpecRestRoute extends UniSpecNamedItem, UniSpecDeprecatedItem, UniSpecTaggedItem {
-    summary?: string;
-    path: string;
-    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
-    pathParams?: UniSpecRestParameter[];
-    queryParams?: UniSpecRestParameter[];
-    headers?: UniSpecRestParameter[];
-    requestBody?: UniSpecRestRequestBody;
-    responses?: Record<string, UniSpecRestResponse>;
-    security?: UniSpecSecurityRequirement[];
-}
-export interface UniSpecRestProtocol extends UniSpecProtocolBase {
-    routes?: UniSpecRestRoute[];
-}
-export interface UniSpecSchemaValidation {
-    strict?: boolean;
-    additionalProperties?: boolean;
-    customValidators?: UniSpecCustomValidator[];
-}
-export interface UniSpecCustomValidator {
-    name: string;
-    rule: string;
-    message: string;
-}
-export interface UniSpecSchemaDefinition extends UniSpecNamedItem, UniSpecDeprecatedItem {
-    examples?: unknown[];
-    jsonSchema: Record<string, unknown>;
-    validation?: UniSpecSchemaValidation;
-}
-export interface UniSpecSchemas {
-    [name: string]: UniSpecSchemaDefinition;
-}
-export interface UniSpecEnvironment {
-    name: string;
-    baseUrl: string;
-    region?: string;
-    labels?: Record<string, string>;
-    isDefault?: boolean;
-}
-export interface UniSpecServer {
-    url: string;
-    description?: string;
-}
-export interface UniSpecContact {
-    name?: string;
-    email?: string;
-    url?: string;
-}
-export interface UniSpecLicense {
-    name?: string;
-    url?: string;
-}
-export interface UniSpecRateLimit {
-    requestsPerMinute?: number;
-    requestsPerHour?: number;
-    requestsPerDay?: number;
-    burstLimit?: number;
-    perUser?: boolean;
-    perApiKey?: boolean;
-    customKey?: string;
-}
-export type UniSpecCompliance = "GDPR" | "SOC2" | "HIPAA" | "PCI-DSS" | "ISO27001" | "CCPA";
-export type UniSpecDataClassification = "public" | "internal" | "confidential" | "restricted";
-export interface UniSpecServiceProtocols {
-    rest?: UniSpecRestProtocol;
-    graphql?: UniSpecGraphQLProtocol;
-    websocket?: UniSpecWebSocketProtocol;
-}
-export interface UniSpecDocument {
-    unispecVersion: string;
-    service: UniSpecService;
-}
-export interface UniSpecService extends UniSpecNamedItem, UniSpecTaggedItem {
-    version?: string;
-    baseUrl?: string;
-    contact?: UniSpecContact;
-    license?: UniSpecLicense;
-    servers?: UniSpecServer[];
-    protocols?: UniSpecServiceProtocols;
-    schemas?: UniSpecSchemas;
-    securitySchemes?: Record<string, UniSpecSecurityScheme>;
-    rateLimit?: UniSpecRateLimit;
-    compliance?: UniSpecCompliance[];
-    dataClassification?: UniSpecDataClassification;
-}
-export interface ValidationError {
-    message: string;
-    path?: string;
-    code?: string;
-}
-export interface ValidationResult {
-    valid: boolean;
-    errors: ValidationError[];
-}
-export interface UniSpecTestRequestBase {
-    headers?: Record<string, unknown>;
-    authProfile?: string;
-}
-export type UniSpecTestProtocol = "rest" | "graphql" | "websocket";
-export interface UniSpecTestTarget {
-    protocol: UniSpecTestProtocol;
-    operationId: string;
-    environment?: string;
-}
-export interface UniSpecRestTestParams {
-    path?: Record<string, unknown>;
-    query?: Record<string, unknown>;
-}
-export interface UniSpecRestTestRequest extends UniSpecTestRequestBase {
-    params?: UniSpecRestTestParams;
-    body?: unknown;
-}
-export type UniSpecRestExpectedStatus = number | number[];
-export interface UniSpecRestBodyExpectation {
-    mode?: "exact" | "contains" | "schemaOnly" | "snapshot";
-    json?: unknown;
-    schemaRef?: string;
-}
-export interface UniSpecRestTestExpect {
-    status: UniSpecRestExpectedStatus;
-    headers?: Record<string, unknown>;
-    body?: UniSpecRestBodyExpectation;
-}
-export interface UniSpecGraphQLTestRequest extends UniSpecTestRequestBase {
-    operationName?: string;
-    query: string;
-    variables?: Record<string, unknown>;
-}
-export interface UniSpecGraphQLTestExpect {
-    data?: unknown;
-    errors?: unknown;
-    bodyMode?: string;
-}
-export type UniSpecWebSocketTestMessageActionType = "send" | "expect";
-export interface UniSpecWebSocketTestMessageAction {
-    type: UniSpecWebSocketTestMessageActionType;
-    messageName: string;
-    payload?: unknown;
-}
-export interface UniSpecWebSocketTestRequest extends UniSpecTestRequestBase {
-    channel: string;
-    direction?: "publish" | "subscribe" | "both";
-    messages?: UniSpecWebSocketTestMessageAction[];
-}
-export interface UniSpecWebSocketTestExpect {
-    messages?: UniSpecWebSocketTestMessageAction[];
-    timeoutMs?: number;
-}
-export interface UniSpecTestRequest {
-    rest?: UniSpecRestTestRequest;
-    graphql?: UniSpecGraphQLTestRequest;
-    websocket?: UniSpecWebSocketTestRequest;
-}
-export interface UniSpecTestExpect {
-    rest?: UniSpecRestTestExpect;
-    graphql?: UniSpecGraphQLTestExpect;
-    websocket?: UniSpecWebSocketTestExpect;
-}
-export interface UniSpecTestCase extends UniSpecNamedItem {
-    target: UniSpecTestTarget;
-    request: UniSpecTestRequest;
-    expect: UniSpecTestExpect;
-    tags?: string[];
-}
-export interface UniSpecTestsDocument {
-    uniSpecTestsVersion: string;
-    target: {
-        serviceName: string;
-        serviceVersion?: string;
-        environment?: string;
-    };
-    tests: UniSpecTestCase[];
-    loadTesting?: {
-        concurrentUsers?: number;
-        duration?: string;
-        rampUp?: string;
-        thresholds?: {
-            responseTime?: string;
-            errorRate?: number;
-            throughput?: string;
-        };
-        scenario?: {
-            weight?: Record<string, number>;
-            thinkTime?: string;
-        };
-    };
-}
-export interface UniSpecConfigDocument {
-    version: number;
-    services: UniSpecConfigServiceEntry[];
-    discovery?: UniSpecConfigDiscovery;
-    environments?: UniSpecConfigEnvironment[];
-}
-export interface UniSpecConfigServiceEntry {
-    name: string;
-    baseUrl?: string;
-    spec: UniSpecConfigSpecReference;
-    health?: UniSpecConfigHealth;
-    discovery?: UniSpecConfigDiscovery;
-    headers?: UniSpecConfigHeader[];
-    security?: UniSpecConfigSecurityRequirement[];
-}
-export type UniSpecConfigSpecReference = string | UniSpecConfigHttpSpecReference | UniSpecConfigFileSpecReference | UniSpecConfigRegistrySpecReference;
-export interface UniSpecConfigHttpSpecReference {
-    type: "http";
-    url?: string;
-    path?: string;
-}
-export interface UniSpecConfigFileSpecReference {
-    type: "file";
-    path: string;
-}
-export interface UniSpecConfigRegistrySpecReference {
-    type: "registry";
-    ref: string;
-}
-export interface UniSpecConfigHealth {
-    path: string;
-}
-export interface UniSpecConfigDiscovery {
-    dnsTemplate?: string;
-}
-export interface UniSpecConfigEnvironment {
-    name: string;
-    overrides?: UniSpecConfigEnvironmentOverrides;
-    observability?: UniSpecConfigObservability;
-    deployment?: UniSpecConfigDeployment;
-    dataResidency?: string;
-    audit?: UniSpecConfigAudit;
-}
-export interface UniSpecConfigEnvironmentOverrides {
-    services?: Record<string, UniSpecConfigServiceOverride>;
-}
-export interface UniSpecConfigServiceOverride {
-    baseUrl?: string;
-    spec?: UniSpecConfigSpecReference;
-    health?: UniSpecConfigHealth;
-    discovery?: UniSpecConfigDiscovery;
-    headers?: UniSpecConfigHeader[];
-    security?: UniSpecConfigSecurityRequirement[];
-}
-export interface UniSpecConfigHeader {
-    name: string;
-    description?: string;
-    required?: boolean;
-    defaultValue?: string;
-}
-export type UniSpecConfigSecurityRequirement = string[];
-export interface UniSpecConfigObservability {
-    logging?: {
-        level?: "debug" | "info" | "warn" | "error";
-        format?: "json" | "text";
-        fields?: string[];
-    };
-    metrics?: {
-        enabled?: boolean;
-        endpoints?: string[];
-        customMetrics?: UniSpecConfigCustomMetric[];
-    };
-    tracing?: {
-        enabled?: boolean;
-        samplingRate?: number;
-        exporter?: string;
-    };
-}
-export interface UniSpecConfigCustomMetric {
-    name: string;
-    type: "counter" | "gauge" | "histogram" | "summary";
-    description?: string;
-    labels?: string[];
-}
-export interface UniSpecConfigDeployment {
-    kubernetes?: UniSpecConfigKubernetesConfig;
-    docker?: UniSpecConfigDockerConfig;
-    replicas?: number;
-    resources?: UniSpecConfigResources;
-}
-export interface UniSpecConfigKubernetesConfig {
-    namespace?: string;
-    image?: string;
-    port?: number;
-    serviceType?: "ClusterIP" | "NodePort" | "LoadBalancer";
-    ingress?: {
-        host?: string;
-        path?: string;
-        tls?: boolean;
-    };
-}
-export interface UniSpecConfigDockerConfig {
-    image?: string;
-    port?: number;
-    environment?: Record<string, string>;
-    volumes?: string[];
-}
-export interface UniSpecConfigResources {
-    cpu?: string;
-    memory?: string;
-    storage?: string;
-}
-export interface UniSpecConfigAudit {
-    enabled?: boolean;
-    retention?: string;
-    fields?: string[];
-    export?: {
-        format?: "json" | "csv";
-        destination?: string;
-    };
-}

package/dist/types/index.js

@@ -1 +0,0 @@
-export {};

package/dist/validator/ajv-validator.d.ts

@@ -1,15 +0,0 @@
-import type { AjvValidateFn, ValidateOptions } from "./types.js";
-declare let cached: {
-    validateUniSpecFn: AjvValidateFn;
-    validateUniSpecTestsFn?: AjvValidateFn;
-    validateUniSpecConfigFn?: AjvValidateFn;
-} | null;
-/**
- * Get compiled AJV validators for different document types.
- */
-export declare function getValidator(options?: ValidateOptions): Promise<NonNullable<typeof cached>>;
-/**
- * Clear cached validators (useful for testing or when schemas change).
- */
-export declare function clearValidatorCache(): void;
-export {};

package/dist/validator/ajv-validator.js

@@ -1,75 +0,0 @@
-import Ajv2020 from "ajv/dist/2020.js";
-import { GENERATED_SCHEMAS } from "../generated-schemas.js";
-let cached = null;
-/**
- * Load default schemas from generated schemas.
- */
-async function loadDefaultSchemas() {
-    // Always use generated schemas - they work in all environments
-    return {
-        unispec: GENERATED_SCHEMAS.unispec,
-        unispecTests: GENERATED_SCHEMAS.unispecTests,
-        unispecConfig: GENERATED_SCHEMAS.unispecConfig,
-        subschemas: GENERATED_SCHEMAS.subschemas,
-    };
-}
-/**
- * Create AJV instance with custom formats and options.
- */
-function createAjv(options) {
-    const ajv = new Ajv2020({
-        allErrors: true,
-        strict: false, // Disabled to support discriminator keyword in new schema
-        ...(options.ajvOptions ?? {}),
-    });
-    // Add format validators
-    ajv.addFormat("uri", true);
-    ajv.addFormat("email", {
-        type: "string",
-        validate: (data) => {
-            // Basic email validation regex
-            const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
-            return typeof data === "string" && emailRegex.test(data);
-        },
-    });
-    return ajv;
-}
-/**
- * Get compiled AJV validators for different document types.
- */
-export async function getValidator(options = {}) {
-    if (cached &&
-        !options.schemas &&
-        !options.schemaProvider &&
-        !options.ajvOptions)
-        return cached;
-    const schemas = options.schemas ?? (await loadDefaultSchemas());
-    const ajv = createAjv(options);
-    if (schemas.subschemas?.length) {
-        ajv.addSchema(schemas.subschemas);
-    }
-    const validateUniSpecFn = ajv.compile(schemas.unispec);
-    let validateUniSpecTestsFn;
-    if (schemas.unispecTests) {
-        validateUniSpecTestsFn = ajv.compile(schemas.unispecTests);
-    }
-    let validateUniSpecConfigFn;
-    if (schemas.unispecConfig) {
-        validateUniSpecConfigFn = ajv.compile(schemas.unispecConfig);
-    }
-    const result = {
-        validateUniSpecFn,
-        validateUniSpecTestsFn,
-        validateUniSpecConfigFn,
-    };
-    if (!options.schemas && !options.schemaProvider && !options.ajvOptions) {
-        cached = result;
-    }
-    return result;
-}
-/**
- * Clear cached validators (useful for testing or when schemas change).
- */
-export function clearValidatorCache() {
-    cached = null;
-}

package/dist/validator/config-validator-main.d.ts

@@ -1,10 +0,0 @@
-import type { UniSpecConfigDocument, ValidationResult } from "../types/index.js";
-import type { ValidateOptions } from "./types.js";
-/**
- * Validate a UniSpec Config document against the UniSpec Config JSON Schema.
- *
- * @param doc - The UniSpec Config document to validate
- * @param options - Validation options including custom schemas
- * @returns Validation result with success status and error details
- */
-export declare function validateUniSpecConfig(doc: UniSpecConfigDocument, options?: ValidateOptions): Promise<ValidationResult>;

package/dist/validator/config-validator-main.js

@@ -1,31 +0,0 @@
-import { ErrorFactory } from "../errors/index.js";
-import { getValidator } from "./ajv-validator.js";
-import { validateConfigCustomRules } from "./config-validator.js";
-import { createValidator } from "./validator-factory.js";
-/**
- * Validate a UniSpec Config document against the UniSpec Config JSON Schema.
- *
- * @param doc - The UniSpec Config document to validate
- * @param options - Validation options including custom schemas
- * @returns Validation result with success status and error details
- */
-export async function validateUniSpecConfig(doc, options = {}) {
-    // Handle null input
-    if (doc === null || doc === undefined) {
-        const error = ErrorFactory.fromError(new Error("Config validation error: input must be an object"), "validation_error");
-        return {
-            valid: false,
-            errors: [error.toJSON()],
-        };
-    }
-    // Use factory for the rest of validation
-    const factoryValidator = createValidator("unispecConfig", async (options) => {
-        // If custom schemas are provided but unispecConfig is missing, return undefined
-        if (options.schemas && !options.schemas.unispecConfig) {
-            return undefined; // Will trigger schema missing error
-        }
-        const { validateUniSpecConfigFn } = await getValidator(options);
-        return validateUniSpecConfigFn;
-    }, validateConfigCustomRules);
-    return await factoryValidator(doc, options);
-}

package/dist/validator/config-validator.d.ts

@@ -1,5 +0,0 @@
-import type { UniSpecConfigDocument, ValidationError } from "../types/index.js";
-/**
- * Custom validation for UniSpec Config documents.
- */
-export declare function validateConfigCustomRules(doc: UniSpecConfigDocument): ValidationError[];

package/dist/validator/config-validator.js

@@ -1,14 +0,0 @@
-import { ErrorFactory } from "../errors/index.js";
-/**
- * Custom validation for UniSpec Config documents.
- */
-export function validateConfigCustomRules(doc) {
-    const customErrors = [];
-    // Check for empty services array
-    if (doc.services &&
-        Array.isArray(doc.services) &&
-        doc.services.length === 0) {
-        customErrors.push(ErrorFactory.createConfigError("services array must contain at least one service", "/services", { code: "minItems" }).toJSON());
-    }
-    return customErrors;
-}