@based/schema 2.5.3 → 2.7.0

package/dist/src/validateSchema/fieldValidators.js

@@ -0,0 +1,352 @@
+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 { 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.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;
+        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: {},
+};
+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,
+    values: {
+        validator: mustBeField,
+    },
+};
+export const basedSchemaFieldSetValidator = {
+    ...basedSchemaFieldSharedValidator,
+    items: {
+        validator: (value, path, newSchema, oldSchema) => mustBeField(value, path, newSchema, oldSchema, { limitTo: 'primitives' }),
+    },
+};
+export const basedSchemaFieldReferenceValidator = {
+    ...basedSchemaFieldSharedValidator,
+    bidirectional: {
+        validator: mustBeBidirectional,
+        optional: true,
+    },
+    allowedTypes: {
+        // TODO: validator
+        optional: true,
+    },
+};
+export const basedSchemaFieldReferencesValidator = {
+    ...basedSchemaFieldSharedValidator,
+    bidirectional: {
+        validator: mustBeBidirectional,
+        optional: true,
+    },
+    allowedTypes: {
+        // TODO: validator
+        optional: true,
+    },
+    sortable: {
+        validator: mustBeBoolean,
+        optional: true,
+    },
+};
+//# sourceMappingURL=fieldValidators.js.map

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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,109 @@
+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

@@ -0,0 +1,21 @@
+import { ParseError } from '../error.js';
+export declare const mustBeString: (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

@@ -0,0 +1,53 @@
+import { ParseError } from '../error.js';
+export const mustBeString = (value, path) => typeof value === 'string'
+    ? []
+    : [
+        {
+            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/test/compat.js

@@ -0,0 +1,15 @@
+import test from 'ava';
+// TODO: maybe nice to use for validate import { newSchemas } from './data/newSchemas.js'
+import { oldSchemas } from './data/oldSchemas.js';
+import { convertNewToOld, convertOldToNew, validateSchema, } from '../src/index.js';
+test('old schema compat mode', async (t) => {
+    for (let i = 0; i < oldSchemas.length - 1; i++) {
+        // for (let i = 0; i < 1; i++) {
+        const oldSchema = oldSchemas[i];
+        const newSchema = convertOldToNew(oldSchema);
+        const validation = await validateSchema(newSchema);
+        t.true(validation.valid);
+        t.deepEqual(oldSchema, convertNewToOld(newSchema), `Schema conversion oldSchemas index ${i}`);
+    }
+});
+//# sourceMappingURL=compat.js.map

package/dist/test/data/newSchemas.d.ts

@@ -0,0 +1,2 @@
+import { BasedSchema } from '../../src/types.js';
+export declare const newSchemas: BasedSchema[];