@based/schema 2.6.0 → 2.7.0

package/dist/test/validateSchema/basic.js

@@ -0,0 +1,94 @@
+import anyTest from 'ava';
+import { validateSchema } from '../../src/validateSchema/index.js';
+import { ParseError } from '../../src/error.js';
+const test = anyTest;
+test('invalid properties in schema root should fail', async (t) => {
+    // @ts-ignore
+    t.deepEqual(await validateSchema({ invalidProperty: true }), {
+        errors: [{ code: ParseError.invalidProperty, path: ['invalidProperty'] }],
+    });
+});
+test('root', async (t) => {
+    t.deepEqual(await validateSchema({
+        root: {
+            // @ts-ignore
+            wawa: true,
+        },
+    }), {
+        errors: [{ code: ParseError.invalidProperty, path: ['root', 'wawa'] }],
+    });
+    for (const key of ['directory', 'title', 'description']) {
+        const result = await validateSchema({
+            root: {
+                // @ts-ignore
+                [key]: true,
+            },
+        });
+        t.deepEqual(result, {
+            errors: [{ code: ParseError.incorrectFormat, path: ['root', key] }],
+        });
+    }
+    t.deepEqual(await validateSchema({
+        root: {
+            // @ts-ignore
+            fields: 'wa',
+        },
+    }), {
+        errors: [{ code: ParseError.incorrectFormat, path: ['root', 'fields'] }],
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            prefix: 'wa',
+        },
+    }), {
+        errors: [{ code: ParseError.incorrectFormat, path: ['root', 'prefix'] }],
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            // @ts-ignore
+            prefix: true,
+        },
+    }), {
+        errors: [{ code: ParseError.incorrectFormat, path: ['root', 'prefix'] }],
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            prefix: 'ro',
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            required: ['astring'],
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            // @ts-ignore
+            required: 'anotherString',
+        },
+    }), {
+        errors: [
+            { code: ParseError.incorrectFormat, path: ['root', 'required'] },
+        ],
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            $delete: true,
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            // @ts-ignore
+            $delete: 'aString',
+        },
+    }), {
+        errors: [{ code: ParseError.incorrectFormat, path: ['root', '$delete'] }],
+    });
+});
+//# sourceMappingURL=basic.js.map

package/dist/test/validateSchema/fields.d.ts

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

package/dist/test/validateSchema/fields.js

@@ -0,0 +1,366 @@
+import anyTest from 'ava';
+import { validateSchema } from '../../src/validateSchema/index.js';
+import { ParseError } from '../../src/error.js';
+const test = anyTest;
+test('shared', async (t) => {
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                stringField: {
+                    type: 'string',
+                    // @ts-ignore
+                    wawa: true,
+                },
+            },
+        },
+    }), {
+        errors: [
+            {
+                code: ParseError.invalidProperty,
+                path: ['root', 'fields', 'stringField', 'wawa'],
+            },
+        ],
+    }, 'invalid property');
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                stringField: {
+                    type: 'string',
+                    hooks: { hook: 'aHook' },
+                },
+            },
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                stringField: {
+                    type: 'string',
+                    hooks: [
+                        { hook: 'aHook', interval: 1000 },
+                        { hook: 'anotherHook', interval: 2000 },
+                    ],
+                },
+            },
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                stringField: {
+                    type: 'string',
+                    // @ts-ignore
+                    hooks: true,
+                },
+            },
+        },
+    }), {
+        errors: [
+            {
+                code: ParseError.incorrectFormat,
+                path: ['root', 'fields', 'stringField', 'hooks'],
+            },
+        ],
+    }, 'hooks format is wrong');
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                stringField: {
+                    type: 'string',
+                    // @ts-ignore
+                    hooks: {
+                        hook: 'aHook',
+                        // @ts-ignore
+                        interval: '2000',
+                    },
+                },
+            },
+        },
+    }), {
+        errors: [
+            {
+                code: ParseError.incorrectFormat,
+                path: ['root', 'fields', 'stringField', 'hooks', 'interval'],
+            },
+        ],
+    }, 'hooks format is wrong');
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                stringField: {
+                    type: 'string',
+                    // @ts-ignore
+                    hooks: [
+                        { hook: 'aHook', interval: 1000 },
+                        // @ts-ignore
+                        { hook: 'anotherHook', interval: '2000' },
+                    ],
+                },
+            },
+        },
+    }), {
+        errors: [
+            {
+                code: ParseError.incorrectFormat,
+                path: ['root', 'fields', 'stringField', 'hooks', '1', 'interval'],
+            },
+        ],
+    }, 'hooks format is wrong');
+});
+test('string', async (t) => {
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                stringField: {
+                    type: 'string',
+                },
+            },
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        types: {
+            aType: {
+                fields: {
+                    stringField: {
+                        type: 'string',
+                    },
+                },
+            },
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                stringField: {
+                    type: 'string',
+                    // @ts-ignore
+                    values: {
+                        type: 'string',
+                    },
+                },
+            },
+        },
+    }), {
+        errors: [
+            {
+                code: ParseError.invalidProperty,
+                path: ['root', 'fields', 'stringField', 'values'],
+            },
+        ],
+    });
+    t.deepEqual(await validateSchema({
+        types: {
+            aType: {
+                fields: {
+                    stringField: {
+                        type: 'string',
+                        // @ts-ignore
+                        values: {
+                            type: 'string',
+                        },
+                    },
+                },
+            },
+        },
+    }), {
+        errors: [
+            {
+                code: ParseError.invalidProperty,
+                path: ['types', 'aType', 'fields', 'stringField', 'values'],
+            },
+        ],
+    });
+});
+test('objects', async (t) => {
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                objectField: {
+                    type: 'object',
+                    properties: {
+                        aStringField: {
+                            type: 'string',
+                        },
+                    },
+                },
+            },
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                objectField: {
+                    type: 'object',
+                    properties: {
+                        aStringField: {
+                            // @ts-ignore
+                            wawa: true,
+                        },
+                    },
+                },
+            },
+        },
+    }), {
+        errors: [
+            {
+                code: ParseError.invalidProperty,
+                path: [
+                    'root',
+                    'fields',
+                    'objectField',
+                    'properties',
+                    'aStringField',
+                    'wawa',
+                ],
+            },
+        ],
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                objectField: {
+                    type: 'object',
+                    properties: {
+                        anotherObjectField: {
+                            type: 'object',
+                            properties: {
+                                aWrongObjectField: {
+                                    type: 'object',
+                                    // @ts-ignore
+                                    values: { type: 'string' },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    }), {
+        errors: [
+            {
+                code: ParseError.invalidProperty,
+                path: [
+                    'root',
+                    'fields',
+                    'objectField',
+                    'properties',
+                    'anotherObjectField',
+                    'properties',
+                    'aWrongObjectField',
+                    'values',
+                ],
+            },
+        ],
+    });
+});
+test('records', async (t) => {
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                recordField: {
+                    type: 'record',
+                    values: {
+                        type: 'string',
+                    },
+                },
+            },
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                recordField: {
+                    type: 'record',
+                    values: {
+                        type: 'object',
+                        properties: {
+                            aWrongObjectField: {
+                                type: 'object',
+                                // @ts-ignore
+                                values: { type: 'string' },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    }), {
+        errors: [
+            {
+                code: ParseError.invalidProperty,
+                path: [
+                    'root',
+                    'fields',
+                    'recordField',
+                    'values',
+                    'properties',
+                    'aWrongObjectField',
+                    'values',
+                ],
+            },
+        ],
+    });
+});
+test('arrays', async (t) => {
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                arrayField: {
+                    type: 'array',
+                    values: {
+                        type: 'string',
+                    },
+                },
+            },
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        root: {
+            fields: {
+                arrayField: {
+                    type: 'array',
+                    values: {
+                        type: 'object',
+                        properties: {
+                            aWrongObjectField: {
+                                type: 'object',
+                                // @ts-ignore
+                                values: { type: 'string' },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    }), {
+        errors: [
+            {
+                code: ParseError.invalidProperty,
+                path: [
+                    'root',
+                    'fields',
+                    'arrayField',
+                    'values',
+                    'properties',
+                    'aWrongObjectField',
+                    'values',
+                ],
+            },
+        ],
+    });
+});
+//# sourceMappingURL=fields.js.map

package/dist/test/validateSchema/languages.d.ts

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

package/dist/test/validateSchema/languages.js

@@ -0,0 +1,124 @@
+import anyTest from 'ava';
+import { validateSchema } from '../../src/validateSchema/index.js';
+import { ParseError } from '../../src/error.js';
+const test = anyTest;
+test('should not allow non object schemas', async (t) => {
+    t.deepEqual(await validateSchema(undefined), {
+        errors: [{ code: ParseError.invalidSchemaFormat }],
+    });
+    t.deepEqual(await validateSchema(null), {
+        errors: [{ code: ParseError.invalidSchemaFormat }],
+    });
+    // @ts-ignore
+    t.deepEqual(await validateSchema('this is a string'), {
+        errors: [{ code: ParseError.invalidSchemaFormat }],
+    });
+    // @ts-ignore
+    t.deepEqual(await validateSchema(1), {
+        errors: [{ code: ParseError.invalidSchemaFormat }],
+    });
+});
+test('`languages` property', async (t) => {
+    t.deepEqual(await validateSchema({ language: 'en' }), {
+        valid: true,
+    });
+    // @ts-ignore
+    t.deepEqual(await validateSchema({ language: 'xx' }), {
+        errors: [{ code: ParseError.languageNotSupported, path: ['language'] }],
+    });
+});
+test('`translations` property', async (t) => {
+    t.deepEqual(await validateSchema({
+        language: 'en',
+        translations: ['fr', 'pt'],
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        language: 'en',
+        // @ts-ignore
+        translations: 'de',
+    }), {
+        errors: [{ code: ParseError.incorrectFormat, path: ['translations'] }],
+    });
+    t.deepEqual(await validateSchema({
+        language: 'en',
+        // @ts-ignore
+        translations: ['pt', 'xx'],
+    }), {
+        errors: [
+            { code: ParseError.languageNotSupported, path: ['translations'] },
+        ],
+    });
+});
+test('`languageFallbacks` property', async (t) => {
+    t.deepEqual(await validateSchema({
+        language: 'en',
+        translations: ['fr', 'pt'],
+        languageFallbacks: {
+            fr: ['en'],
+            pt: ['fr', 'pt'],
+        },
+    }), {
+        valid: true,
+    });
+    t.deepEqual(await validateSchema({
+        language: 'en',
+        translations: ['fr', 'pt'],
+        // @ts-ignore
+        languageFallbacks: 'pt',
+    }), {
+        errors: [
+            { code: ParseError.incorrectFormat, path: ['languageFallbacks'] },
+        ],
+    });
+    t.deepEqual(await validateSchema({
+        language: 'en',
+        translations: ['fr', 'pt'],
+        // @ts-ignore
+        languageFallbacks: ['pt'],
+    }), {
+        errors: [
+            { code: ParseError.incorrectFormat, path: ['languageFallbacks'] },
+        ],
+    });
+    t.deepEqual(await validateSchema({
+        language: 'en',
+        translations: ['fr', 'pt'],
+        languageFallbacks: {
+            fr: ['en'],
+            // @ts-ignore
+            pt: ['xx', 'pt'],
+        },
+    }), {
+        errors: [
+            { code: ParseError.noLanguageFound, path: ['languageFallbacks'] },
+        ],
+    });
+    t.deepEqual(await validateSchema({
+        language: 'en',
+        translations: ['fr', 'pt'],
+        languageFallbacks: {
+            // @ts-ignore
+            fr: 'en',
+        },
+    }), {
+        errors: [
+            { code: ParseError.incorrectFormat, path: ['languageFallbacks'] },
+        ],
+    });
+    t.deepEqual(await validateSchema({
+        language: 'en',
+        translations: ['fr', 'pt'],
+        languageFallbacks: {
+            fr: ['en'],
+            // @ts-ignore
+            xx: ['fr', 'pt'],
+        },
+    }), {
+        errors: [
+            { code: ParseError.noLanguageFound, path: ['languageFallbacks'] },
+        ],
+    });
+});
+//# sourceMappingURL=languages.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@based/schema",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "license": "MIT",
   "main": "dist/src/index.js",
   "files": [

package/dist/src/validateSchema.d.ts

@@ -1,4 +0,0 @@
-import { BasedSchemaPartial, BasedSchemaFieldPartial, BasedSchemaTypePartial } from './types.js';
-export declare const validateType: (_fromSchema: BasedSchemaPartial, typeName: string, type: BasedSchemaTypePartial) => void;
-export declare const validateField: (_fromSchema: BasedSchemaPartial, _path: string[], _field: BasedSchemaFieldPartial) => void;
-export declare const validateSchema: (schema: BasedSchemaPartial) => BasedSchemaPartial;

package/dist/src/validateSchema.js

@@ -1,35 +0,0 @@
-// gaurd in the schema for refs in arrays
-export const validateType = (_fromSchema, typeName, type) => {
-    if (type.prefix &&
-        (typeof type.prefix !== 'string' || type.prefix.length !== 2)) {
-        throw new Error(`Incorrect prefix "${type.prefix}" for type "${typeName}" has to be a string of 2 alphanumerical characters e.g. "Az", "ab", "cc", "10"`);
-    }
-};
-export const validateField = (_fromSchema, _path, _field) => {
-    //
-};
-export const validateSchema = (schema) => {
-    // rewrite schema things like required / required: []
-    if (typeof schema !== 'object') {
-        throw new Error('Schema is not an object');
-    }
-    if (schema.language && typeof schema.language !== 'string') {
-        throw new Error('Language must be a string');
-    }
-    if (schema.translations && !Array.isArray(schema.translations)) {
-        throw new Error('Translations needs to be an array');
-    }
-    if (schema.$defs) {
-        // first defs ofc
-    }
-    if (schema.root) {
-        validateType(schema, 'root', schema.root);
-    }
-    if (schema.types) {
-        for (const type in schema.types) {
-            validateType(schema, type, schema.types[type]);
-        }
-    }
-    return schema;
-};
-//# sourceMappingURL=validateSchema.js.map

package/dist/test/validateSchema.js

@@ -1,38 +0,0 @@
-import test from 'ava';
-import { validateSchema } from '../src/index.js';
-test.serial('throw on invalid schema', async (t) => {
-    const prefixError = t.throws(() => {
-        validateSchema({
-            $defs: {
-                yuzi: {
-                    type: 'string',
-                    title: 'BLA',
-                    description: 'SNURP',
-                },
-            },
-            types: {
-                bla: {
-                    prefix: 'fix',
-                    fields: {
-                        yuzi: {
-                            type: 'object',
-                            customValidator: async (_value, _path, _target) => {
-                                return true;
-                            },
-                            properties: {
-                                gurt: {
-                                    $ref: '/$defs/yuzi',
-                                },
-                                flap: {
-                                    enum: ['bla', 'blap', 'flip'],
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        });
-    });
-    t.is(prefixError.message, 'Incorrect prefix "fix" for type "bla" has to be a string of 2 alphanumerical characters e.g. "Az", "ab", "cc", "10"');
-});
-//# sourceMappingURL=validateSchema.js.map