@based/schema 4.1.1 → 5.0.0-alpha.0

package/dist/src/validateSchema/fieldValidators.js

@@ -1,360 +0,0 @@
-import { basedSchemaNumberFormats } from '../display/number.js';
-import { basedSchemaDisplayFormats } from '../display/string.js';
-import { basedSchemaDateFormats } from '../display/timestamp.js';
-import { ParseError } from '../error.js';
-import { basedSchemaFieldTypes, basedSchemaStringFormatValues, languages, } from '../types.js';
-import { validate } from './index.js';
-import { mustBeArray, mustBeBidirectional, mustBeBoolean, mustBeNumber, mustBeString, mustBeStringArray, } from './utils.js';
-export const mustBeField = (value, path, newSchema, oldSchema, options) => {
-    if (!(typeof value === 'object' && !Array.isArray(value))) {
-        return [
-            {
-                code: ParseError.incorrectFormat,
-                path,
-            },
-        ];
-    }
-    const type = value.hasOwnProperty('enum') ? 'enum' : value.type;
-    if ((options?.limitTo === 'primitives' &&
-        ![
-            'string',
-            'number',
-            'integer',
-            'timestamp',
-            'json',
-            'boolean',
-            'enum',
-        ].includes(type)) ||
-        (options?.limitTo === 'enumerables' &&
-            !['text', 'object', 'record', 'array', 'set'].includes(type))) {
-        return [
-            {
-                code: ParseError.incorrectFormat,
-                path: path.concat('type'),
-            },
-        ];
-    }
-    let validator;
-    switch (type) {
-        case 'string':
-            validator = basedSchemaStringValidator;
-            break;
-        case 'enum':
-            validator = basedSchemaFieldEnumValidator;
-            break;
-        case 'cardinality':
-            validator = basedSchemaFieldCardinalityValidator;
-            break;
-        case 'number':
-            validator = basedSchemaFieldNumberValidator;
-            break;
-        case 'integer':
-            validator = basedSchemaFieldIntegerValidator;
-            break;
-        case 'timestamp':
-            validator = basedSchemaFieldTimeStampValidator;
-            break;
-        case 'boolean':
-            validator = basedSchemaFieldBooleanValidator;
-            break;
-        case 'json':
-            validator = basedSchemaFieldJSONValidator;
-            break;
-        case 'text':
-            validator = basedSchemaFieldTextValidator;
-            break;
-        case 'object':
-            validator = basedSchemaFieldObjectValidator;
-            break;
-        case 'record':
-            validator = basedSchemaFieldRecordValidator;
-            break;
-        case 'array':
-            validator = basedSchemaFieldArrayValidator;
-            break;
-        case 'set':
-            validator = basedSchemaFieldSetValidator;
-            break;
-        case 'reference':
-            validator = basedSchemaFieldReferenceValidator;
-            break;
-        case 'references':
-            validator = basedSchemaFieldReferencesValidator;
-            break;
-        default:
-            validator = basedSchemaFieldSharedValidator;
-            break;
-    }
-    return validate(validator, value, path, newSchema, oldSchema);
-};
-export const mustBeFields = (value, path, newSchema, oldSchema) => {
-    if (!(typeof value === 'object' && !Array.isArray(value))) {
-        return [
-            {
-                code: ParseError.incorrectFormat,
-                path,
-            },
-        ];
-    }
-    const errors = [];
-    for (const key in value) {
-        if (value.hasOwnProperty(key)) {
-            errors.push(...mustBeField(value[key], path.concat(key), newSchema, oldSchema));
-        }
-    }
-    return errors;
-};
-export const basedSchemaFieldSharedValidator = {
-    type: {
-        validator: (value, path) => basedSchemaFieldTypes.includes(value)
-            ? []
-            : [{ code: ParseError.incorrectFieldType, path }],
-    },
-    hooks: {
-        validator: (value, path) => {
-            if (typeof value !== 'object') {
-                return [{ code: ParseError.incorrectFormat, path }];
-            }
-            const items = Array.isArray(value) ? value : [{ ...value }];
-            const errors = [];
-            items.forEach((item, index) => {
-                if (item.hook) {
-                    errors.push(...mustBeString(item.hook, path.concat(Array.isArray(value) ? String(index) : [], 'hook')));
-                }
-                if (item.interval) {
-                    errors.push(...mustBeNumber(item.interval, path.concat(Array.isArray(value) ? String(index) : [], 'interval')));
-                }
-            });
-            return errors;
-        },
-        optional: true,
-    },
-    $id: {
-        validator: mustBeString,
-        optional: true,
-    },
-    isRequired: {
-        validator: mustBeBoolean,
-        optional: true,
-    },
-    $schema: {
-        validator: mustBeString,
-        optional: true,
-    },
-    title: {
-        validator: mustBeString,
-        optional: true,
-    },
-    description: {
-        validator: mustBeString,
-        optional: true,
-    },
-    index: {
-        validator: mustBeNumber,
-        optional: true,
-    },
-    readOnly: {
-        validator: mustBeBoolean,
-        optional: true,
-    },
-    writeOnly: {
-        validator: mustBeBoolean,
-        optional: true,
-    },
-    $comment: {
-        validator: mustBeString,
-        optional: true,
-    },
-    examples: { optional: true },
-    default: { optional: true },
-    customValidator: { optional: true },
-    $defs: { optional: true },
-    $delete: {
-        validator: mustBeBoolean,
-        optional: true,
-    },
-};
-export const basedSchemaStringSharedValidator = {
-    minLength: {
-        validator: mustBeNumber,
-        optional: true,
-    },
-    maxLength: {
-        validator: mustBeNumber,
-        optional: true,
-    },
-    contentMediaEncoding: {
-        validator: mustBeString,
-        optional: true,
-    },
-    contentMediaType: {
-        validator: (value, path) => /^\w+\/\w+$/.test(value)
-            ? []
-            : [{ code: ParseError.incorrectFormat, path }],
-        optional: true,
-    },
-    pattern: {
-        validator: mustBeString,
-        optional: true,
-    },
-    format: {
-        validator: (value, path) => basedSchemaStringFormatValues.includes(value)
-            ? []
-            : [{ code: ParseError.incorrectFormat, path }],
-        optional: true,
-    },
-    display: {
-        validator: (value, path) => basedSchemaDisplayFormats.includes(value)
-            ? []
-            : [{ code: ParseError.incorrectFormat, path }],
-        optional: true,
-    },
-    multiline: {
-        validator: mustBeBoolean,
-        optional: true,
-    },
-};
-export const basedSchemaStringValidator = {
-    ...basedSchemaFieldSharedValidator,
-    ...basedSchemaStringSharedValidator,
-};
-export const basedSchemaFieldEnumValidator = {
-    ...basedSchemaFieldSharedValidator,
-    enum: {
-        validator: mustBeArray,
-    },
-};
-export const basedSchemaFieldCardinalityValidator = {
-    ...basedSchemaFieldSharedValidator,
-};
-export const basedSchemaNumberDefaultsValidator = {
-    multipleOf: {
-        validator: mustBeNumber,
-        optional: true,
-    },
-    minimum: {
-        validator: mustBeNumber,
-        optional: true,
-    },
-    maximum: {
-        validator: mustBeNumber,
-        optional: true,
-    },
-    exclusiveMaximum: {
-        validator: mustBeBoolean,
-        optional: true,
-    },
-    exclusiveMinimum: {
-        validator: mustBeBoolean,
-        optional: true,
-    },
-};
-export const basedSchemaFieldNumberValidator = {
-    ...basedSchemaFieldSharedValidator,
-    ...basedSchemaNumberDefaultsValidator,
-    display: {
-        validator: (value, path) => basedSchemaNumberFormats.includes(value) || /^round-\d+$/.test(value)
-            ? []
-            : [{ code: ParseError.incorrectFormat, path }],
-        optional: true,
-    },
-};
-export const basedSchemaFieldIntegerValidator = {
-    ...basedSchemaFieldSharedValidator,
-    ...basedSchemaNumberDefaultsValidator,
-    display: {
-        validator: (value, path) => basedSchemaNumberFormats.includes(value) || /^round-\d+$/.test(value)
-            ? []
-            : [{ code: ParseError.incorrectFormat, path }],
-        optional: true,
-    },
-};
-export const basedSchemaFieldTimeStampValidator = {
-    ...basedSchemaFieldSharedValidator,
-    ...basedSchemaNumberDefaultsValidator,
-    display: {
-        validator: (value, path) => basedSchemaDateFormats.includes(value)
-            ? []
-            : [{ code: ParseError.incorrectFormat, path }],
-        optional: true,
-    },
-};
-export const basedSchemaFieldBooleanValidator = {
-    ...basedSchemaFieldSharedValidator,
-};
-export const basedSchemaFieldJSONValidator = {
-    ...basedSchemaFieldSharedValidator,
-    format: {
-        validator: (value, path) => value === 'rich-text' ? [] : [{ code: ParseError.incorrectFormat, path }],
-        optional: true,
-    },
-};
-export const basedSchemaFieldAnyValidator = {
-    ...basedSchemaFieldSharedValidator,
-};
-export const basedSchemaFieldTextValidator = {
-    ...basedSchemaFieldSharedValidator,
-    ...basedSchemaStringSharedValidator,
-    required: {
-        validator: (value, path) => Array.isArray(value) &&
-            value.every((i) => Object.keys(languages).includes(i))
-            ? []
-            : [{ code: ParseError.languageNotSupported, path }],
-        optional: true,
-    },
-};
-export const basedSchemaFieldObjectValidator = {
-    ...basedSchemaFieldSharedValidator,
-    properties: {
-        validator: mustBeFields,
-    },
-    required: {
-        validator: mustBeStringArray,
-        optional: true,
-    },
-};
-export const basedSchemaFieldRecordValidator = {
-    ...basedSchemaFieldSharedValidator,
-    values: {
-        validator: mustBeField,
-    },
-};
-export const basedSchemaFieldArrayValidator = {
-    ...basedSchemaFieldSharedValidator,
-    items: {
-        validator: mustBeField,
-    },
-};
-export const basedSchemaFieldSetValidator = {
-    ...basedSchemaFieldSharedValidator,
-    items: {
-        validator: (value, path, newSchema, oldSchema) => mustBeField(value, path, newSchema, oldSchema, { limitTo: 'primitives' }),
-    },
-};
-export const basedSchemaFieldReferenceValidator = {
-    ...basedSchemaFieldSharedValidator,
-    inverseProperty: {
-        validator: mustBeBidirectional,
-        optional: true,
-    },
-    allowedType: {
-        // TODO: validator
-        optional: true,
-    },
-};
-export const basedSchemaFieldReferencesValidator = {
-    ...basedSchemaFieldSharedValidator,
-    inverseProperty: {
-        validator: mustBeBidirectional,
-        optional: true,
-    },
-    allowedType: {
-        // TODO: validator
-        optional: true,
-    },
-    sortable: {
-        validator: mustBeBoolean,
-        optional: true,
-    },
-};
-//# sourceMappingURL=fieldValidators.js.map

package/dist/src/validateSchema/index.d.ts

@@ -1,17 +0,0 @@
-import { ParseError } from '../error.js';
-import { BasedSchema, BasedSchemaPartial } from '../types.js';
-export type ValidateSchemaError = {
-    code: ParseError;
-    path?: string[];
-};
-export type Validator<T> = {
-    [P in keyof Required<T>]: {
-        optional?: boolean;
-        validator?: (value: any, path: string[], newSchema: BasedSchemaPartial, oldSchema: BasedSchema) => ValidateSchemaError[];
-    };
-};
-export declare const validate: <T>(validator: Validator<T>, target: T, path: string[], newSchema: BasedSchemaPartial, oldSchema: BasedSchema) => ValidateSchemaError[];
-export declare const validateSchema: (newSchema: BasedSchemaPartial, oldSchema?: BasedSchema) => Promise<{
-    valid?: true;
-    errors?: ValidateSchemaError[];
-}>;

package/dist/src/validateSchema/index.js

@@ -1,109 +0,0 @@
-import { ParseError } from '../error.js';
-import { languages, } from '../types.js';
-import { basedSchemaTypeValidator } from './basedSchemaTypeValidator.js';
-const basedSchemaValidator = {
-    language: {
-        validator: (value, path) => 
-        // language not supported
-        languages.includes(value)
-            ? []
-            : [{ code: ParseError.languageNotSupported, path }],
-    },
-    translations: {
-        validator: (value, path, newSchema, oldSchema) => {
-            // translations property needs to be an array
-            if (!Array.isArray(value)) {
-                return [{ code: ParseError.incorrectFormat, path }];
-            }
-            const language = newSchema.language || oldSchema.language;
-            // translations property cannot include language value
-            if (language && value.includes(language)) {
-                return [{ code: ParseError.invalidProperty, path }];
-            }
-            // language not supported
-            return value.every((l) => languages.includes(l))
-                ? []
-                : [{ code: ParseError.languageNotSupported, path }];
-        },
-        optional: true,
-    },
-    languageFallbacks: {
-        validator: (value, path, newSchema, oldSchema) => {
-            // languageFallbacks needs to be an object
-            if (typeof value !== 'object' || Array.isArray(value)) {
-                return [{ code: ParseError.incorrectFormat, path }];
-            }
-            const schemaLangs = [newSchema.language || oldSchema?.language].concat(newSchema.translations || oldSchema?.translations);
-            for (const key in value) {
-                // languageFallbacks keys must be a language or a translation
-                if (!schemaLangs.includes(key)) {
-                    return [{ code: ParseError.noLanguageFound, path }];
-                }
-                // languageFallbacks language values need to be array
-                if (!Array.isArray(value[key])) {
-                    return [{ code: ParseError.incorrectFormat, path }];
-                }
-                if (!value[key].every((l) => schemaLangs.includes(l))) {
-                    return [{ code: ParseError.noLanguageFound, path }];
-                }
-            }
-            return [];
-        },
-        optional: true,
-    },
-    root: {
-        validator: (value, path, newSchema, oldSchema) => validate(basedSchemaTypeValidator, value, path, newSchema, oldSchema),
-    },
-    $defs: {},
-    types: {
-        validator: (value, path, newSchema, oldSchema) => {
-            if (!(typeof value === 'object' && !Array.isArray(value))) {
-                return [
-                    {
-                        code: ParseError.incorrectFormat,
-                        path,
-                    },
-                ];
-            }
-            const errors = [];
-            for (const key in value) {
-                if (value.hasOwnProperty(key)) {
-                    errors.push(...validate(basedSchemaTypeValidator, value[key], path.concat(key), newSchema, oldSchema));
-                }
-            }
-            return errors;
-        },
-    },
-    // TODO:
-    prefixToTypeMapping: {},
-};
-export const validate = (validator, target, path, newSchema, oldSchema) => {
-    const errors = [];
-    for (const key in target) {
-        if (target.hasOwnProperty(key)) {
-            if (validator[key]) {
-                if (validator[key].validator) {
-                    const result = validator[key].validator(target[key], path.concat(key), newSchema, oldSchema);
-                    errors.push(...result);
-                }
-            }
-            else {
-                errors.push({
-                    code: ParseError.invalidProperty,
-                    path: path.concat(key),
-                });
-            }
-        }
-    }
-    return errors;
-};
-export const validateSchema = async (newSchema, oldSchema) => {
-    const errors = [];
-    if (newSchema === null || typeof newSchema !== 'object') {
-        errors.push({ code: ParseError.invalidSchemaFormat });
-        return { errors };
-    }
-    errors.push(...validate(basedSchemaValidator, newSchema, [], newSchema, oldSchema));
-    return errors.length ? { errors } : { valid: true };
-};
-//# sourceMappingURL=index.js.map

package/dist/src/validateSchema/utils.d.ts

@@ -1,25 +0,0 @@
-import { ParseError } from '../error.js';
-export declare const mustBeString: (value: string, path: string[]) => {
-    code: ParseError;
-    path: string[];
-}[];
-export declare const mustBeArray: (value: string[], path: string[]) => {
-    code: ParseError;
-    path: string[];
-}[];
-export declare const mustBeStringArray: (value: string[], path: string[]) => {
-    code: ParseError;
-    path: string[];
-}[];
-export declare const mustBeBoolean: (value: string, path: string[]) => {
-    code: ParseError;
-    path: string[];
-}[];
-export declare const mustBeNumber: (value: string, path: string[]) => {
-    code: ParseError;
-    path: string[];
-}[];
-export declare const mustBeBidirectional: (value: any, path: string[]) => {
-    code: ParseError;
-    path: string[];
-}[];

package/dist/src/validateSchema/utils.js

@@ -1,61 +0,0 @@
-import { ParseError } from '../error.js';
-export const mustBeString = (value, path) => typeof value === 'string'
-    ? []
-    : [
-        {
-            code: ParseError.incorrectFormat,
-            path,
-        },
-    ];
-export const mustBeArray = (value, path) => Array.isArray(value)
-    ? []
-    : [
-        {
-            code: ParseError.incorrectFormat,
-            path,
-        },
-    ];
-export const mustBeStringArray = (value, path) => Array.isArray(value) && value.every((i) => typeof i === 'string')
-    ? []
-    : [
-        {
-            code: ParseError.incorrectFormat,
-            path,
-        },
-    ];
-export const mustBeBoolean = (value, path) => typeof value === 'boolean'
-    ? []
-    : [
-        {
-            code: ParseError.incorrectFormat,
-            path,
-        },
-    ];
-export const mustBeNumber = (value, path) => typeof value === 'number'
-    ? []
-    : [
-        {
-            code: ParseError.incorrectFormat,
-            path,
-        },
-    ];
-export const mustBeBidirectional = (value, path) => {
-    if (!(typeof value === 'object' && !Array.isArray(value))) {
-        return [
-            {
-                code: ParseError.incorrectFormat,
-                path,
-            },
-        ];
-    }
-    return value.hasOwnProperty('fromField') &&
-        typeof value.fromField === 'string'
-        ? []
-        : [
-            {
-                code: ParseError.incorrectFormat,
-                path: path.concat('fromField'),
-            },
-        ];
-};
-//# sourceMappingURL=utils.js.map

package/dist/src/walker/args.d.ts

@@ -1,36 +0,0 @@
-import { BasedSchema } from '../types.js';
-import { BasedSchemaType, BasedSchemaFields } from '../types.js';
-import { ArgsOpts, Path, Opts, Stopped, Collect } from './types.js';
-import { ParseError } from '../error.js';
-export declare class ArgsClass<T, K extends keyof BasedSchemaFields = keyof BasedSchemaFields> {
-    errors: any[];
-    id: number;
-    prev: ArgsClass<T, K>;
-    root: ArgsClass<T, K>;
-    _opts: Opts<T>;
-    _target: T;
-    _stopObject?: boolean;
-    _schema: BasedSchema;
-    parseTopLevel?: boolean;
-    _collectOverride: Collect<T>;
-    fieldSchema?: BasedSchemaFields[K];
-    typeSchema?: BasedSchemaType;
-    path: Path;
-    skipCollection: boolean;
-    value: any;
-    stopped: Stopped | void;
-    fromBackTrack: any[];
-    collectedCommands: any[];
-    constructor(opts: ArgsOpts<T, K>, prev?: ArgsClass<T, K>);
-    get schema(): BasedSchema;
-    get key(): number | string;
-    get target(): T;
-    stop(onllyStopFieldSchemaParser?: boolean): void;
-    create(opts?: ArgsOpts<T>): ArgsClass<T>;
-    parse(opts?: ArgsOpts<T>): Promise<ArgsClass<T> | void>;
-    getTopPaths(): Path[];
-    getBackTrackTarget(): ArgsClass<T>;
-    getCollectTarget(): void;
-    collect(value?: any): void;
-    error(code: ParseError): void;
-}