@tsofist/schema-forge 2.12.0 → 3.0.0

package/lib/types/db.types.d.ts

@@ -1,96 +0,0 @@
-import { ArrayMay, HexString } from '@tsofist/stem';
-/**
- * Database index types.
- *
- * @see https://www.postgresql.org/docs/current/indexes-types.html PostgreSQL
- */
-export declare const DBIndexTypeList: readonly ["btree", "hash", "gin", "gist", "spgist", "brin"];
-/**
- * Database index type.
- *
- * @see https://www.postgresql.org/docs/current/indexes-types.html PostgreSQL
- * @default 'btree'
- */
-export type DBIndexType = (typeof DBIndexTypeList)[number];
-/**
- * Database index options.
- *
- * @see https://dbml.dbdiagram.io/docs/#index-definition dbml spec
- */
-export type DBIndexOptions = {
-    /**
-     * Type of index.
-     * @default 'btree'
-     */
-    type?: DBIndexType;
-    /**
-     * Name of index.
-     * @default 'ix_[schema]_[table]_[column]'
-     */
-    name?: string;
-    /**
-     * If true, the index will be unique.
-     * @default false
-     */
-    unique?: boolean;
-    /**
-     * Is it a primary key
-     * @default false
-     */
-    pk?: boolean;
-    /**
-     * Any important notes.
-     * Can be used in DDL.
-     */
-    note?: string;
-    /**
-     * Any important developer comments.
-     * Can't be used in DDL.
-     */
-    comment?: string;
-};
-export type DBIndexOptionsDef<B extends boolean = boolean> = ArrayMay<DBIndexOptions | string | B>;
-/**
- * Database entity options.
- *
- * @see https://dbml.dbdiagram.io/docs/#table-definition dbml spec
- */
-export type DBEntityOptions = {
-    /**
-     * Table name.
-     *
-     * @default '[schema].[table]'
-     */
-    name?: string;
-    /**
-     * Indexes of the table.
-     * They can be overridden/added at the column level.
-     *
-     * Use `true` to apply default index options.
-     * Use string literal to set index name.
-     */
-    indexes?: {
-        [field: string]: DBIndexOptionsDef<true>;
-    };
-    /**
-     * Any important notes.
-     * Can be used in DDL.
-     */
-    note?: string;
-    /**
-     * Any important developer comments.
-     * Can't be used in DDL.
-     */
-    comment?: string;
-    /**
-     * Table name alias.
-     */
-    alias?: string;
-    /**
-     * Settings.
-     */
-    settings?: {
-        headercolor: HexString;
-    };
-};
-export type DBEntityOptionsDef = DBEntityOptions | string;

package/lib/types/db.types.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DBIndexTypeList = void 0;
-/**
- * Database index types.
- *
- * @see https://www.postgresql.org/docs/current/indexes-types.html PostgreSQL
- */
-exports.DBIndexTypeList = [
-    //
-    'btree',
-    'hash',
-    'gin',
-    'gist',
-    'spgist',
-    'brin',
-];

package/lib/util/format.error.d.ts

@@ -1 +0,0 @@
-export declare function formatSchemaForgeError(error: Error, dir?: string): string;

package/lib/util/patch.extended-annotations-reader.d.ts

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

package/lib/util/sort-properties.d.ts

@@ -1,2 +0,0 @@
-import { SchemaObject } from 'ajv';
-export declare function sortProperties<T extends SchemaObject>(schema: T): T;

package/lib/validator.d.ts

@@ -1,47 +0,0 @@
-import { ArrayMay, Nullable } from '@tsofist/stem';
-import { ErrorsTextOptions, Options, SchemaObject } from 'ajv';
-import { SchemaDefinitionInfo, SchemaForgeDefinitionRef, SchemaForgeValidationContextBase, SchemaForgeValidationFunction, SchemaForgeValidationReport, SchemaForgeValidationResult } from './types';
-export type SchemaForgeValidator = ReturnType<typeof createSchemaForgeValidator>;
-export type SchemaForgeValidatorOptions = Parameters<typeof createSchemaForgeValidator>;
-/**
- * Create SchemaForge Registry: a json-schema validator with additional features
- */
-export declare function createSchemaForgeValidator(engineOptions?: Options, useAdditionalFormats?: boolean): {
-    readonly compilationArtifactCount: number;
-    readonly rev: number;
-    clear: () => void;
-    clone: (options?: Omit<Options, "schemas">, onSchema?: (value: SchemaObject) => SchemaObject) => {
-        readonly compilationArtifactCount: number;
-        readonly rev: number;
-        clear: () => void;
-        clone: /*elided*/ any;
-        removeSchema: (ref: ArrayMay<SchemaForgeDefinitionRef>) => void;
-        hasValidator: (ref: SchemaForgeDefinitionRef) => boolean;
-        getValidator: <TData = unknown>(ref: SchemaForgeDefinitionRef | SchemaObject) => SchemaForgeValidationFunction<TData> | undefined;
-        getSchema: (ref: SchemaForgeDefinitionRef) => import("ajv").AnySchema | undefined;
-        getRootSchema: (schemaId: string) => (SchemaObject & {
-            definitions?: SchemaObject;
-        }) | undefined;
-        addSchema: (schema: SchemaObject[]) => void;
-        validateBySchema: (ref: SchemaForgeDefinitionRef, data: unknown, instancePath?: string) => SchemaForgeValidationResult;
-        checkBySchema: <T = unknown, Ctx extends SchemaForgeValidationContextBase = SchemaForgeValidationContextBase>(ref: SchemaForgeDefinitionRef, data: unknown, context?: Ctx) => data is T;
-        validationErrorsText: (errors: Nullable<SchemaForgeValidationReport>, options?: ErrorsTextOptions) => string;
-        listDefinitions: (predicate?: (info: SchemaDefinitionInfo) => boolean) => SchemaDefinitionInfo[];
-        warmupCache: (schemasPerIteration?: number, delayMs?: number) => Promise<void>;
-        warmupCacheSync: () => void;
-    };
-    removeSchema: (ref: ArrayMay<SchemaForgeDefinitionRef>) => void;
-    hasValidator: (ref: SchemaForgeDefinitionRef) => boolean;
-    getValidator: <TData = unknown>(ref: SchemaForgeDefinitionRef | SchemaObject) => SchemaForgeValidationFunction<TData> | undefined;
-    getSchema: (ref: SchemaForgeDefinitionRef) => import("ajv").AnySchema | undefined;
-    getRootSchema: (schemaId: string) => (SchemaObject & {
-        definitions?: SchemaObject;
-    }) | undefined;
-    addSchema: (schema: SchemaObject[]) => void;
-    validateBySchema: (ref: SchemaForgeDefinitionRef, data: unknown, instancePath?: string) => SchemaForgeValidationResult;
-    checkBySchema: <T = unknown, Ctx extends SchemaForgeValidationContextBase = SchemaForgeValidationContextBase>(ref: SchemaForgeDefinitionRef, data: unknown, context?: Ctx) => data is T;
-    validationErrorsText: (errors: Nullable<SchemaForgeValidationReport>, options?: ErrorsTextOptions) => string;
-    listDefinitions: (predicate?: (info: SchemaDefinitionInfo) => boolean) => SchemaDefinitionInfo[];
-    warmupCache: (schemasPerIteration?: number, delayMs?: number) => Promise<void>;
-    warmupCacheSync: () => void;
-};

package/lib/validator.js

@@ -1,396 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSchemaForgeValidator = createSchemaForgeValidator;
-const as_array_1 = require("@tsofist/stem/lib/as-array");
-const chunk_1 = require("@tsofist/stem/lib/chunk");
-const error_1 = require("@tsofist/stem/lib/error");
-const entries_1 = require("@tsofist/stem/lib/object/entries");
-const values_1 = require("@tsofist/stem/lib/object/values");
-const delay_1 = require("@tsofist/stem/lib/timers/delay");
-const ajv_1 = require("ajv");
-const ajv_formats_1 = require("ajv-formats");
-const types_1 = require("./types");
-const db_types_1 = require("./types/db.types");
-const index_1 = require("./index");
-const DEF_OPTIONS = {
-    meta: true,
-    defaultMeta: 'http://json-schema.org/draft-07/schema',
-    allErrors: true,
-    strict: true,
-    strictSchema: true,
-    strictTypes: false,
-    strictTuples: false,
-    allowUnionTypes: true,
-    coerceTypes: false,
-    removeAdditional: false,
-    unicodeRegExp: true,
-    useDefaults: false,
-    addUsedSchema: false,
-    inlineRefs: true,
-    ownProperties: true,
-    discriminator: false,
-    code: {
-        es5: false,
-        esm: false,
-        optimize: 2,
-    },
-};
-/**
- * Create SchemaForge Registry: a json-schema validator with additional features
- */
-function createSchemaForgeValidator(engineOptions, useAdditionalFormats = false) {
-    engineOptions = {
-        ...DEF_OPTIONS,
-        ...engineOptions,
-    };
-    const initialSchemas = engineOptions.schemas;
-    if (initialSchemas)
-        delete engineOptions.schemas;
-    let rev = 0;
-    let engine = new ajv_1.default(engineOptions);
-    engine.removeSchema();
-    if (initialSchemas)
-        engine.addSchema(initialSchemas);
-    addJSDocKeywords(engine);
-    if (useAdditionalFormats)
-        engine = (0, ajv_formats_1.default)(engine);
-    /**
-     * Clone validator with overridden options
-     */
-    function clone(options, onSchema) {
-        const schemas = [];
-        for (const env of (0, values_1.nonNullableValues)(engine.schemas)) {
-            if (env.meta)
-                continue;
-            const schema = onSchema
-                ? onSchema(env.schema)
-                : env.schema;
-            schemas.push(schema);
-        }
-        const opts = {
-            ...engineOptions,
-            schemas,
-            ...options,
-        };
-        return createSchemaForgeValidator(opts, useAdditionalFormats);
-    }
-    /**
-     * Get schema (or definition) validation function
-     */
-    function getValidator(ref) {
-        if (typeof ref === 'string')
-            return engine.getSchema(ref);
-        const result = engine.compile(ref);
-        checkIsSyncValidator(result);
-        return result;
-    }
-    /**
-     * Check if schema exists
-     * WARN: this method may compile schema if it's not compiled yet
-     */
-    function hasValidator(ref) {
-        return ref in engine.schemas || ref in engine.refs || engine.getSchema(ref) != null;
-    }
-    /**
-     * Add root schema(s) to registry
-     */
-    function addSchema(schema) {
-        engine.addSchema(schema);
-        rev++;
-    }
-    /**
-     * Remove root schema(s) from registry
-     */
-    function removeSchema(ref) {
-        for (const item of (0, as_array_1.asArray)(ref))
-            engine.removeSchema(item);
-        rev++;
-    }
-    /**
-     * Remove all schemas from registry
-     */
-    function clear() {
-        engine.removeSchema();
-        rev++;
-    }
-    /**
-     * Get validation errors text
-     */
-    function validationErrorsText(errors, options) {
-        return engine.errorsText(errors, options);
-    }
-    /**
-     * Validate data by schema definition reference
-     */
-    function validateBySchema(ref, data, instancePath = '') {
-        const validator = getValidator(ref);
-        if (!validator) {
-            (0, error_1.raiseEx)(types_1.SchemaNotFoundErrorCode, { schema: ref });
-        }
-        const valid = validator(data, {
-            instancePath,
-            parentData: {},
-            parentDataProperty: '',
-            rootData: {},
-            dynamicAnchors: {},
-        });
-        const errors = validator.errors;
-        return {
-            valid,
-            errors,
-            errorsText(options) {
-                return validationErrorsText(errors, options);
-            },
-        };
-    }
-    /**
-     * Check (throw error if invalid) data by schema definition reference
-     */
-    function checkBySchema(ref, data, context) {
-        const result = validateBySchema(ref, data, context?.instancePath);
-        if (!result.valid) {
-            const ctx = {
-                ...context,
-                schema: ref,
-                errors: result.errors,
-            };
-            (0, error_1.raiseEx)(types_1.SchemaForgeValidationErrorCode, ctx, context?.errorMessage);
-        }
-        return result.valid;
-    }
-    function mapDefinitions(callback) {
-        const result = [];
-        for (const [schemaId, env] of (0, entries_1.entries)(engine.schemas)) {
-            if (env &&
-                typeof env.schema === 'object' &&
-                !schemaId.startsWith('http') &&
-                env.schema.definitions &&
-                typeof env.schema.definitions === 'object') {
-                for (const name of Object.keys(env.schema.definitions)) {
-                    result.push(callback(name, schemaId));
-                }
-            }
-        }
-        return result;
-    }
-    /**
-     * List schema definitions
-     */
-    function listDefinitions(predicate) {
-        const result = [];
-        mapDefinitions((name, schemaId) => {
-            const info = (0, index_1.parseSchemaDefinitionInfo)(name, schemaId);
-            if (predicate === undefined || predicate(info))
-                result.push(info);
-        });
-        return result;
-    }
-    /**
-     * Get schema object of definition by reference
-     */
-    function getSchema(ref) {
-        return getValidator(ref)?.schema;
-    }
-    /**
-     * Get root schema object
-     */
-    function getRootSchema(schemaId) {
-        return engine.schemas[schemaId]?.schema;
-    }
-    /**
-     * Synchronously warm up validator cache
-     * This action is useful to pre-compile all schemas and their definitions
-     */
-    function warmupCacheSync() {
-        mapDefinitions((name, schemaId) => {
-            const ref = (0, index_1.buildSchemaDefinitionRef)(name, schemaId);
-            checkIsSyncValidator(engine.getSchema(ref));
-        });
-    }
-    /**
-     * Asynchronously warm up validator cache
-     * This action is useful to pre-compile all schemas and their definitions
-     */
-    async function warmupCache(schemasPerIteration = 5, delayMs = 1) {
-        await (0, chunk_1.chunk)(mapDefinitions((name, schemaId) => (0, index_1.buildSchemaDefinitionRef)(name, schemaId)), schemasPerIteration, async (items) => {
-            for (const ref of items)
-                engine.getSchema(ref);
-            return (0, delay_1.delay)(delayMs);
-        });
-    }
-    return {
-        get compilationArtifactCount() {
-            const names = new Set([
-                //
-                ...Object.keys(engine.refs),
-                ...Object.keys(engine.schemas),
-            ]);
-            return names.size;
-        },
-        get rev() {
-            return rev;
-        },
-        clear,
-        clone,
-        removeSchema,
-        hasValidator,
-        getValidator,
-        getSchema,
-        getRootSchema,
-        addSchema,
-        validateBySchema,
-        checkBySchema,
-        validationErrorsText,
-        listDefinitions,
-        warmupCache,
-        warmupCacheSync,
-    };
-}
-function addJSDocKeywords(engine) {
-    const InterfaceNamePattern = '^[A-Z][a-zA-Z0-9]+$';
-    const PropertyNamePattern = '^[a-z][a-zA-Z0-9]+$';
-    const NestedPropertyNamePattern = '^[a-z][a-zA-Z0-9.-]+$';
-    const MethodNamePattern = PropertyNamePattern;
-    const MemberNamePattern = `${InterfaceNamePattern.substring(0, InterfaceNamePattern.length - 1)}#${PropertyNamePattern.substring(1)}`;
-    const IXNamePattern = '^ix_[a-z][a-zA-Z0-9_]+$';
-    const EntityNamePattern = '^([a-zA-Z_][a-z0-9_]*\\.)?[a-z_][a-z0-9_]*$';
-    const FakerModulePattern = '^[a-zA-Z.]+$';
-    engine.addKeyword({
-        keyword: 'version',
-        metaSchema: {
-            type: 'string',
-        },
-        dependencies: ['$id', '$schema'],
-    });
-    engine.addKeyword({
-        keyword: 'hash',
-        metaSchema: {
-            type: 'string',
-        },
-        dependencies: ['$id', '$schema'],
-    });
-    engine.addKeyword({
-        keyword: 'interface',
-        metaSchema: {
-            type: 'string',
-            pattern: InterfaceNamePattern,
-        },
-    });
-    engine.addKeyword({
-        keyword: 'property',
-        metaSchema: {
-            type: 'string',
-            pattern: PropertyNamePattern,
-        },
-    });
-    engine.addKeyword({
-        keyword: 'method',
-        metaSchema: {
-            type: 'string',
-            pattern: MethodNamePattern,
-        },
-    });
-    engine.addKeyword({
-        keyword: 'member',
-        metaSchema: {
-            type: 'string',
-            pattern: MemberNamePattern,
-        },
-    });
-    /**
-     * @see https://fakerjs.dev/api/person.html
-     */
-    engine.addKeyword({
-        keyword: 'faker',
-        metaSchema: {
-            oneOf: [
-                {
-                    // https://fakerjs.dev/api/person.html
-                    // https://fakerjs.dev/api/company.html#name
-                    // https://github.com/json-schema-faker/json-schema-faker/blob/master/docs/USAGE.md
-                    // example (schema):
-                    //   faker: 'person.fullName'
-                    //   faker: 'person.firstName'
-                    //   faker: 'company.name'
-                    // example (jsdoc):
-                    //   @faker company.name
-                    type: 'string',
-                    pattern: FakerModulePattern,
-                },
-                {
-                    // https://fakerjs.dev/api/lorem.html#words
-                    // example (schema):
-                    //   faker: { 'lorem.words': [{ min: 30, max: 50 }] },
-                    // example (jsdoc):
-                    //   @faker { 'lorem.words': [{ min: 5, max: 10 }] }
-                    type: 'object',
-                    propertyNames: {
-                        pattern: FakerModulePattern,
-                    },
-                },
-            ],
-        },
-    });
-    const DBIndexOptionsProperties = {
-        name: { type: 'string', pattern: IXNamePattern },
-        unique: { type: 'boolean' },
-        pk: { type: 'boolean' },
-        type: {
-            type: 'string',
-            enum: db_types_1.DBIndexTypeList,
-        },
-        note: { type: 'string' },
-        comment: { type: 'string' },
-    };
-    const DBIndexSchema = {
-        type: ['string', 'boolean', 'object', 'array'],
-        pattern: IXNamePattern,
-        additionalProperties: false,
-        properties: DBIndexOptionsProperties,
-        items: {},
-        minItems: 1,
-    };
-    DBIndexSchema.items = {
-        ...DBIndexSchema,
-        type: ['string', 'boolean', 'object'],
-    };
-    engine.addKeyword({
-        keyword: 'dbIndex',
-        metaSchema: DBIndexSchema,
-    });
-    engine.addKeyword({
-        keyword: 'dbEntity',
-        metaSchema: {
-            type: ['string', 'object'],
-            pattern: EntityNamePattern,
-            additionalProperties: false,
-            properties: {
-                name: {
-                    type: 'string',
-                    pattern: EntityNamePattern,
-                },
-                indexes: {
-                    type: 'object',
-                    additionalProperties: DBIndexSchema,
-                    propertyNames: {
-                        pattern: NestedPropertyNamePattern,
-                    },
-                },
-                note: { type: 'string' },
-                comment: { type: 'string' },
-                alias: { type: 'string' },
-                settings: {
-                    type: 'object',
-                    properties: {
-                        headercolor: { type: 'string' },
-                    },
-                },
-            },
-        },
-    });
-}
-function checkIsSyncValidator(fn) {
-    if (typeof fn === 'function' && '$async' in fn) {
-        (0, error_1.raise)('[SchemaForge] Asynchronous validation schemas are not supported');
-    }
-}