@based/schema 2.6.0 → 2.7.0

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

@@ -1,11 +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 } from '../src/index.js';
+import { convertNewToOld, convertOldToNew, validateSchema, } from '../src/index.js';
 test('old schema compat mode', async (t) => {
-    for (let i = 0; i < oldSchemas.length; i++) {
+    for (let i = 0; i < oldSchemas.length - 1; i++) {
+        // for (let i = 0; i < 1; i++) {
         const oldSchema = oldSchemas[i];
-        t.deepEqual(convertNewToOld(convertOldToNew(oldSchema)), oldSchema, `Schema conversion oldSchemas index ${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