@lakutata/core 1.0.60 → 3.0.0-beta.1

package/dist/cjs/lib/validation/engine/json-schema/index.d.ts

@@ -0,0 +1,20 @@
+import type { Definitions, JsonSchema, Mode, ParserOptions } from './model.js';
+import { JsonSchemaParser } from './parsers/json.js';
+import { JsonDraft04SchemaParser } from './parsers/json-draft-04.js';
+import { JsonDraft202012SchemaParser } from './parsers/json-2020-12.js';
+import { JsonDraft201909SchemaParser } from './parsers/json-draft-2019-09.js';
+import { OpenApiSchemaParser } from './parsers/open-api.js';
+import { OpenApi31SchemaParser } from './parsers/open-api-3.1.js';
+export type * from './model.js';
+export { JsonSchemaParser, JsonDraft04SchemaParser, JsonDraft202012SchemaParser, JsonDraft201909SchemaParser, OpenApiSchemaParser, OpenApi31SchemaParser };
+/**
+ * Convert a schema into a JSON schema (or an OpenAPI schema object)
+ * @param schemaObj the schema
+ * @param type the output format
+ * @param definitions receives the shared schemas (by id)
+ * @param parserOptions
+ */
+export declare function parse(schemaObj: {
+    describe(): unknown;
+}, type?: Mode, definitions?: Definitions, parserOptions?: ParserOptions): JsonSchema;
+export default parse;

package/dist/cjs/lib/validation/engine/json-schema/index.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenApi31SchemaParser = exports.OpenApiSchemaParser = exports.JsonDraft201909SchemaParser = exports.JsonDraft202012SchemaParser = exports.JsonDraft04SchemaParser = exports.JsonSchemaParser = void 0;
+exports.parse = parse;
+/**
+ * Derived from the upstream index.js (see UPSTREAM.md; MIT, see THIRD_PARTY_NOTICES.md)
+ */
+const SchemaConversionException_js_1 = require("../../exceptions/SchemaConversionException.js");
+const json_js_1 = require("./parsers/json.js");
+Object.defineProperty(exports, "JsonSchemaParser", { enumerable: true, get: function () { return json_js_1.JsonSchemaParser; } });
+const json_draft_04_js_1 = require("./parsers/json-draft-04.js");
+Object.defineProperty(exports, "JsonDraft04SchemaParser", { enumerable: true, get: function () { return json_draft_04_js_1.JsonDraft04SchemaParser; } });
+const json_2020_12_js_1 = require("./parsers/json-2020-12.js");
+Object.defineProperty(exports, "JsonDraft202012SchemaParser", { enumerable: true, get: function () { return json_2020_12_js_1.JsonDraft202012SchemaParser; } });
+const json_draft_2019_09_js_1 = require("./parsers/json-draft-2019-09.js");
+Object.defineProperty(exports, "JsonDraft201909SchemaParser", { enumerable: true, get: function () { return json_draft_2019_09_js_1.JsonDraft201909SchemaParser; } });
+const open_api_js_1 = require("./parsers/open-api.js");
+Object.defineProperty(exports, "OpenApiSchemaParser", { enumerable: true, get: function () { return open_api_js_1.OpenApiSchemaParser; } });
+const open_api_3_1_js_1 = require("./parsers/open-api-3.1.js");
+Object.defineProperty(exports, "OpenApi31SchemaParser", { enumerable: true, get: function () { return open_api_3_1_js_1.OpenApi31SchemaParser; } });
+const parsers = {
+    'json-2020-12': json_2020_12_js_1.JsonDraft202012SchemaParser,
+    'json-draft-2019-09': json_draft_2019_09_js_1.JsonDraft201909SchemaParser,
+    'json-draft-04': json_draft_04_js_1.JsonDraft04SchemaParser,
+    json: json_js_1.JsonSchemaParser,
+    'open-api': open_api_js_1.OpenApiSchemaParser,
+    'open-api-3.1': open_api_3_1_js_1.OpenApi31SchemaParser
+};
+/**
+ * Convert a schema into a JSON schema (or an OpenAPI schema object)
+ * @param schemaObj the schema
+ * @param type the output format
+ * @param definitions receives the shared schemas (by id)
+ * @param parserOptions
+ */
+function parse(schemaObj, type = 'json', definitions = {}, parserOptions = {}) {
+    if (typeof schemaObj.describe !== 'function')
+        throw new SchemaConversionException_js_1.SchemaConversionException('Not a schema object.');
+    const baseSpec = schemaObj.describe();
+    const parser = parsers[type];
+    if (!parser)
+        throw new SchemaConversionException_js_1.SchemaConversionException(`No parser is registered for ${type}`);
+    return new parser(parserOptions).parse(baseSpec, definitions);
+}
+exports.default = parse;

package/dist/cjs/lib/validation/engine/json-schema/model.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Types of the JSON Schema conversion (derived from the upstream index.d.ts, see UPSTREAM.md; MIT, see THIRD_PARTY_NOTICES.md)
+ */
+/**
+ * The output format of a conversion
+ */
+export type Mode = 'json' | 'open-api' | 'open-api-3.1' | 'json-2020-12' | 'json-draft-2019-09' | 'json-draft-04';
+/**
+ * A JSON schema (or OpenAPI schema object) produced by a parser
+ */
+export interface JsonSchema {
+    type?: string | string[];
+    $ref?: string;
+    $schema?: string;
+    properties?: Record<string, JsonSchema>;
+    patternProperties?: Record<string, JsonSchema>;
+    required?: string[];
+    additionalProperties?: unknown;
+    anyOf?: JsonSchema[];
+    oneOf?: JsonSchema[];
+    allOf?: JsonSchema[];
+    not?: JsonSchema;
+    if?: JsonSchema;
+    then?: JsonSchema | false;
+    else?: JsonSchema;
+    items?: JsonSchema | JsonSchema[] | false;
+    prefixItems?: JsonSchema[];
+    contains?: JsonSchema;
+    enum?: unknown[];
+    const?: unknown;
+    examples?: unknown[];
+    example?: unknown;
+    dependentRequired?: Record<string, string[]>;
+    dependencies?: Record<string, string[]>;
+    nullable?: boolean;
+    [keyword: string]: unknown;
+}
+/**
+ * A key dependency of an object schema (and, or, with...), as described by the schema
+ */
+export interface SpecDependency {
+    rel: string;
+    key: string | null;
+    peers: string[];
+    [option: string]: unknown;
+}
+/**
+ * A condition (when() or alternatives conditional()), or an alternatives try() match, as described by the schema
+ */
+export interface SpecCondition {
+    schema?: SchemaSpec;
+    ref?: unknown;
+    is?: SchemaSpec;
+    then?: SchemaSpec;
+    otherwise?: SchemaSpec;
+    switch?: SpecCondition[];
+    [option: string]: unknown;
+}
+/**
+ * A rule, as described by the schema
+ */
+export interface SpecRule {
+    name: string;
+    args?: Record<string, unknown>;
+    [modifier: string]: unknown;
+}
+/**
+ * A schema description (describe() output), as far as the parsers read it
+ */
+export interface SchemaSpec {
+    type: string;
+    flags?: Record<string, unknown>;
+    preferences?: Record<string, unknown>;
+    allow?: unknown[];
+    invalid?: unknown[];
+    rules?: SpecRule[];
+    keys?: Record<string, SchemaSpec>;
+    patterns?: {
+        regex?: string;
+        rule?: SchemaSpec;
+        schema?: SchemaSpec;
+    }[];
+    dependencies?: SpecDependency[];
+    matches?: SpecCondition[];
+    whens?: SpecCondition[];
+    items?: SchemaSpec[];
+    metas?: Record<string, unknown>[];
+    shared?: SchemaSpec[];
+    link?: {
+        ref?: {
+            type?: string;
+            path: string[];
+        };
+    };
+    examples?: unknown[];
+    [term: string]: unknown;
+}
+/**
+ * A parser of a key dependency: sets the matching keywords of the schema (in place)
+ */
+export type LogicalOpParserFn = (schema: JsonSchema, dependency: SpecDependency) => void;
+export interface LogicalOpParserOpts {
+    and?: LogicalOpParserFn | null;
+    nand?: LogicalOpParserFn | null;
+    or?: LogicalOpParserFn | null;
+    xor?: LogicalOpParserFn | null;
+    oxor?: LogicalOpParserFn | null;
+    with?: LogicalOpParserFn | null;
+    without?: LogicalOpParserFn | null;
+}
+/**
+ * The options of a parser (false: the defaults)
+ */
+export interface ParserSettings {
+    $schema?: string;
+    includeSchemaDialect?: boolean;
+    logicalOpParser?: LogicalOpParserOpts | false;
+    preferences?: Record<string, unknown>;
+}
+export type ParserOptions = false | ParserSettings;
+/**
+ * The shared schemas collected by a conversion, by id
+ */
+export type Definitions = Record<string, JsonSchema>;

package/dist/cjs/lib/validation/engine/json-schema/model.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Types of the JSON Schema conversion (derived from the upstream index.d.ts, see UPSTREAM.md; MIT, see THIRD_PARTY_NOTICES.md)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/lib/validation/engine/json-schema/parsers/json-2020-12.d.ts

@@ -0,0 +1,9 @@
+import type { JsonSchema, ParserOptions } from '../model.js';
+import { JsonDraft201909SchemaParser } from './json-draft-2019-09.js';
+/**
+ * Converts schema descriptions into JSON schemas (draft 2020-12)
+ */
+export declare class JsonDraft202012SchemaParser extends JsonDraft201909SchemaParser {
+    constructor(opts?: ParserOptions);
+    protected _setTuple(schema: JsonSchema, ordered: JsonSchema[], rest: JsonSchema | undefined): void;
+}

package/dist/cjs/lib/validation/engine/json-schema/parsers/json-2020-12.js

@@ -0,0 +1,56 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonDraft202012SchemaParser = void 0;
+/**
+ * Not from upstream: JSON Schema 2020-12 (lakutata's own)
+ */
+const _ = __importStar(require("../helpers.js"));
+const json_draft_2019_09_js_1 = require("./json-draft-2019-09.js");
+/**
+ * Converts schema descriptions into JSON schemas (draft 2020-12)
+ */
+class JsonDraft202012SchemaParser extends json_draft_2019_09_js_1.JsonDraft201909SchemaParser {
+    constructor(opts = {}) {
+        super(_.merge({
+            $schema: 'https://json-schema.org/draft/2020-12/schema'
+        }, opts));
+    }
+    _setTuple(schema, ordered, rest) {
+        schema.prefixItems = ordered;
+        schema.items = rest === undefined ? false : rest;
+    }
+}
+exports.JsonDraft202012SchemaParser = JsonDraft202012SchemaParser;

package/dist/cjs/lib/validation/engine/json-schema/parsers/json-draft-04.d.ts

@@ -0,0 +1,17 @@
+import type { SchemaSpec, JsonSchema, ParserOptions } from '../model.js';
+import { JsonSchemaParser } from './json.js';
+/**
+ * Converts schema descriptions into JSON schemas (draft 04)
+ */
+export declare class JsonDraft04SchemaParser extends JsonSchemaParser {
+    constructor(opts?: ParserOptions);
+    protected _isIfThenElseSupported(): boolean;
+    protected _setNumberFieldProperties(fieldSchema: JsonSchema, fieldDefn: SchemaSpec): void;
+    protected _getLocalSchemaBasePath(): string;
+    protected _setContains(_schema: JsonSchema, _contains: JsonSchema, _options: {
+        min?: number;
+        max?: number;
+    }): void;
+    protected _setPropertyNames(_schema: JsonSchema, _names: JsonSchema): void;
+    protected _getValuesSchema(values: unknown[]): JsonSchema;
+}

package/dist/cjs/lib/validation/engine/json-schema/parsers/json-draft-04.js

@@ -0,0 +1,93 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonDraft04SchemaParser = void 0;
+/**
+ * Derived from the upstream lib/parsers/json-draft-04.js (see UPSTREAM.md; MIT, see THIRD_PARTY_NOTICES.md)
+ */
+const _ = __importStar(require("../helpers.js"));
+const json_js_1 = require("./json.js");
+/**
+ * Converts schema descriptions into JSON schemas (draft 04)
+ */
+class JsonDraft04SchemaParser extends json_js_1.JsonSchemaParser {
+    constructor(opts = {}) {
+        super(_.merge({
+            $schema: 'http://json-schema.org/draft-04/schema#',
+            logicalOpParser: {
+                xor: null,
+                with: function (schema, dependency) {
+                    schema.dependencies = schema.dependencies || {};
+                    schema.dependencies[dependency.key] = dependency.peers;
+                },
+                without: null
+            }
+        }, opts));
+    }
+    _isIfThenElseSupported() {
+        return false;
+    }
+    _setNumberFieldProperties(fieldSchema, fieldDefn) {
+        super._setNumberFieldProperties(fieldSchema, fieldDefn);
+        if (typeof fieldSchema.exclusiveMinimum !== 'undefined') {
+            fieldSchema.minimum = fieldSchema.exclusiveMinimum;
+            fieldSchema.exclusiveMinimum = true;
+        }
+        if (typeof fieldSchema.exclusiveMaximum !== 'undefined') {
+            fieldSchema.maximum = fieldSchema.exclusiveMaximum;
+            fieldSchema.exclusiveMaximum = true;
+        }
+        if (typeof fieldSchema.minimum !== 'undefined' && fieldSchema.minimum === fieldSchema.exclusiveMinimum)
+            fieldSchema.exclusiveMinimum = true;
+        if (typeof fieldSchema.maximum !== 'undefined' && fieldSchema.maximum === fieldSchema.exclusiveMaximum)
+            fieldSchema.exclusiveMaximum = true;
+    }
+    _getLocalSchemaBasePath() {
+        return '#/definitions';
+    }
+    _setContains(_schema, _contains, _options) {
+        //Draft 04 has no contains
+        this._inexact();
+    }
+    _setPropertyNames(_schema, _names) {
+        //Draft 04 has no propertyNames
+        this._inexact();
+    }
+    _getValuesSchema(values) {
+        //Draft 04 has no const (upstream also sets the type of a single value)
+        return { enum: values };
+    }
+}
+exports.JsonDraft04SchemaParser = JsonDraft04SchemaParser;

package/dist/cjs/lib/validation/engine/json-schema/parsers/json-draft-2019-09.d.ts

@@ -0,0 +1,13 @@
+import type { JsonSchema, ParserOptions } from '../model.js';
+import { JsonSchemaParser } from './json.js';
+/**
+ * Converts schema descriptions into JSON schemas (draft 2019-09)
+ */
+export declare class JsonDraft201909SchemaParser extends JsonSchemaParser {
+    constructor(opts?: ParserOptions);
+    protected _setContains(schema: JsonSchema, contains: JsonSchema, options: {
+        min?: number;
+        max?: number;
+    }): void;
+    protected _isKnownMetaKey(key: string): boolean;
+}

package/dist/cjs/lib/validation/engine/json-schema/parsers/json-draft-2019-09.js

@@ -0,0 +1,69 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonDraft201909SchemaParser = void 0;
+/**
+ * Derived from the upstream lib/parsers/json-draft-2019-09.js (see UPSTREAM.md; MIT, see THIRD_PARTY_NOTICES.md)
+ */
+const _ = __importStar(require("../helpers.js"));
+const json_js_1 = require("./json.js");
+/**
+ * Converts schema descriptions into JSON schemas (draft 2019-09)
+ */
+class JsonDraft201909SchemaParser extends json_js_1.JsonSchemaParser {
+    constructor(opts = {}) {
+        super(_.merge({
+            $schema: 'https://json-schema.org/draft/2019-09/schema',
+            logicalOpParser: {
+                with: function (schema, dependency) {
+                    schema.dependentRequired = schema.dependentRequired || {};
+                    schema.dependentRequired[dependency.key] = dependency.peers;
+                }
+            }
+        }, opts));
+    }
+    _setContains(schema, contains, options) {
+        const part = { contains };
+        if (options.min !== undefined && options.min !== 1)
+            part.minContains = options.min;
+        if (options.max !== undefined)
+            part.maxContains = options.max;
+        this._mergeKeywords(schema, part);
+    }
+    _isKnownMetaKey(key) {
+        return key === 'deprecated' || key === 'readOnly' || key === 'writeOnly';
+    }
+}
+exports.JsonDraft201909SchemaParser = JsonDraft201909SchemaParser;