@based/schema 4.1.1 → 5.0.0-alpha.1

package/dist/test/text.js

@@ -1,324 +0,0 @@
-import { setWalker } from '../src/index.js';
-import test from 'ava';
-import { resultCollect } from './utils/index.js';
-const schema = {
-    types: {
-        thing: {
-            prefix: 'ti',
-            fields: {
-                something: { type: 'string', format: 'strongPassword' },
-            },
-        },
-        bla: {
-            prefix: 'bl',
-            fields: {
-                text: {
-                    type: 'text',
-                    pattern: '[^xz]{1,10}',
-                },
-            },
-        },
-    },
-    $defs: {},
-    language: 'en',
-    translations: ['de', 'nl', 'ro', 'za', 'ae'],
-    languageFallbacks: {
-        en: ['en'],
-        de: ['en'],
-        fr: ['aa'],
-    },
-    root: {
-        fields: {},
-    },
-    prefixToTypeMapping: {
-        bl: 'bla',
-        ti: 'thing',
-    },
-};
-let r;
-test('throw error no language', async (t) => {
-    let r = await setWalker(schema, {
-        $id: 'bl120',
-        text: { $value: 'x' },
-    });
-    t.true(r.errors.length > 0);
-});
-test('simple case', async (t) => {
-    let r = await setWalker(schema, {
-        $id: 'bl120',
-        text: { en: 'flap' },
-    });
-    t.deepEqual(resultCollect(r), [
-        { path: ['text', 'en'], value: 'flap' },
-        { path: ['text'], value: { en: 'flap' } },
-    ]);
-});
-test('simple case $value', async (t) => {
-    let r = await setWalker(schema, {
-        $id: 'bl120',
-        text: { en: { $value: 'flap' } },
-    });
-    t.deepEqual(resultCollect(r), [
-        { path: ['text', 'en'], value: 'flap' },
-        { path: ['text'], value: { en: { $value: 'flap' } } },
-    ]);
-});
-test('simple case $language', async (t) => {
-    let r = await setWalker(schema, {
-        $id: 'bl120',
-        $language: 'en',
-        text: 'flap',
-    });
-    t.deepEqual(resultCollect(r), [
-        { path: ['text', 'en'], value: 'flap' },
-        { path: ['text'], value: { en: 'flap' } },
-    ]);
-});
-test('simple case with value', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        $language: 'za',
-        text: { $value: 'flap' },
-    });
-    t.deepEqual(resultCollect(r), [
-        { path: ['text', 'za'], value: 'flap' },
-        { path: ['text'], value: { $value: 'flap' } },
-    ]);
-});
-test('simple case $value /w obj', async (t) => {
-    let r = await setWalker(schema, {
-        $id: 'bl120',
-        text: { $value: { en: 'flap' } },
-    });
-    t.deepEqual(resultCollect(r), [
-        { path: ['text', 'en'], value: 'flap' },
-        { path: ['text'], value: { $value: { en: 'flap' } } },
-    ]);
-});
-test('text default', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        $language: 'za',
-        text: { $default: 'sdsdds' },
-    });
-    t.deepEqual(resultCollect(r), [
-        { path: ['text', 'za'], value: { $default: 'sdsdds' } },
-        { path: ['text'], value: { $default: 'sdsdds' } },
-    ]);
-});
-test('default and lang:default', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        $language: 'za',
-        text: { $default: 'sdsdds', en: { $default: 'flapflap' } },
-    });
-    t.deepEqual(resultCollect(r), [
-        { path: ['text', 'za'], value: { $default: 'sdsdds' } },
-        { path: ['text', 'en'], value: { $default: 'flapflap' } },
-        {
-            path: ['text'],
-            value: { $default: 'sdsdds', en: { $default: 'flapflap' } },
-        },
-    ]);
-});
-test('default: lang, lang', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        $language: 'za',
-        text: { $default: { de: 'dsnfds' }, en: { $default: 'flapflap' } },
-    });
-    t.deepEqual(resultCollect(r), [
-        { path: ['text', 'de'], value: { $default: 'dsnfds' } },
-        { path: ['text', 'en'], value: { $default: 'flapflap' } },
-        {
-            path: ['text'],
-            value: { $default: { de: 'dsnfds' }, en: { $default: 'flapflap' } },
-        },
-    ]);
-});
-test('defaullt:lang, lang, lang:default', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        $language: 'za',
-        text: {
-            $default: { de: 'dsnfds' },
-            nl: 'flapperonus',
-            en: { $default: 'flapflap' },
-        },
-    });
-    t.deepEqual(resultCollect(r), [
-        { path: ['text', 'de'], value: { $default: 'dsnfds' } },
-        { path: ['text', 'nl'], value: 'flapperonus' },
-        { path: ['text', 'en'], value: { $default: 'flapflap' } },
-        {
-            path: ['text'],
-            value: {
-                $default: { de: 'dsnfds' },
-                nl: 'flapperonus',
-                en: { $default: 'flapflap' },
-            },
-        },
-    ]);
-});
-test('default:lang, lang, lang:value, lang:default', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        $language: 'za',
-        text: {
-            $default: { de: 'dsnfds' },
-            nl: 'flapperonus',
-            ro: { $value: 'durp' },
-            en: { $default: 'flapflap' },
-        },
-    });
-    t.deepEqual(resultCollect(r), [
-        { path: ['text', 'de'], value: { $default: 'dsnfds' } },
-        { path: ['text', 'nl'], value: 'flapperonus' },
-        { path: ['text', 'ro'], value: 'durp' },
-        { path: ['text', 'en'], value: { $default: 'flapflap' } },
-        {
-            path: ['text'],
-            value: {
-                $default: { de: 'dsnfds' },
-                nl: 'flapperonus',
-                ro: { $value: 'durp' },
-                en: { $default: 'flapflap' },
-            },
-        },
-    ]);
-});
-test('value:lang, lang, default:lang, lang:value, lang:default', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        $language: 'za',
-        text: {
-            $value: 'durp',
-            nl: 'flapperonus',
-            $default: {
-                ae: 'habibi',
-            },
-            ro: { $value: 'durp' },
-            en: { $default: 'flapflap' },
-        },
-    });
-    t.deepEqual(resultCollect(r), [
-        { path: ['text', 'za'], value: 'durp' },
-        { path: ['text', 'nl'], value: 'flapperonus' },
-        { path: ['text', 'ae'], value: { $default: 'habibi' } },
-        { path: ['text', 'ro'], value: 'durp' },
-        { path: ['text', 'en'], value: { $default: 'flapflap' } },
-        {
-            path: ['text'],
-            value: {
-                $value: 'durp',
-                nl: 'flapperonus',
-                $default: {
-                    ae: 'habibi',
-                },
-                ro: { $value: 'durp' },
-                en: { $default: 'flapflap' },
-            },
-        },
-    ]);
-});
-test('value: wrong pattern, lang, default:lang, lang:value, lang:default', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        $language: 'za',
-        text: {
-            $value: 'xz',
-            nl: 'flapperonus',
-            $default: {
-                ae: 'habibi',
-            },
-            ro: { $value: 'durp' },
-            en: { $default: 'xzxz' },
-        },
-    });
-    t.true(r.errors.length > 0);
-});
-test('text delete', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        text: {
-            $delete: true,
-        },
-    });
-    t.deepEqual(resultCollect(r), [{ path: ['text'], value: { $delete: true } }]);
-});
-test('text delete single language', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        text: {
-            en: {
-                $delete: true,
-            },
-        },
-    });
-    t.deepEqual(resultCollect(r), [
-        { path: ['text', 'en'], value: { $delete: true } },
-        {
-            path: ['text'],
-            value: {
-                en: {
-                    $delete: true,
-                },
-            },
-        },
-    ]);
-});
-test('just delete', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        $delete: true,
-    });
-    t.true(r.errors.length === 1);
-});
-test('$default in collected path', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        text: {
-            en: {
-                $default: 'title',
-            },
-        },
-    });
-    t.is(r.errors.length, 0);
-    t.deepEqual(resultCollect(r), [
-        { path: ['text', 'en'], value: { $default: 'title' } },
-        {
-            path: ['text'],
-            value: {
-                en: {
-                    $default: 'title',
-                },
-            },
-        },
-    ]);
-});
-test('$default in collected path + $merge:false', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        text: {
-            $merge: false,
-            en: {
-                $default: 'title',
-            },
-        },
-    });
-    t.is(r.errors.length, 0);
-    t.deepEqual(resultCollect(r), [
-        { path: ['text'], value: { $delete: true } },
-        { path: ['text', 'en'], value: { $default: 'title' } },
-        {
-            path: ['text'],
-            value: {
-                $merge: false,
-                en: {
-                    $default: 'title',
-                },
-            },
-        },
-    ]);
-});
-//# sourceMappingURL=text.js.map

package/dist/test/utils/index.d.ts

@@ -1,11 +0,0 @@
-import { Path } from '@saulx/utils';
-import { BasedSetTarget } from '../../src/index.js';
-import { ParseError } from '../../src/error.js';
-export declare const resultCollect: (...results: BasedSetTarget[]) => {
-    path: Path;
-    value: any;
-}[];
-export declare const errorCollect: (...results: BasedSetTarget[]) => {
-    path: Path;
-    code: ParseError;
-}[];

package/dist/test/utils/index.js

@@ -1,17 +0,0 @@
-export const resultCollect = (...results) => {
-    const assertableResults = [];
-    for (let i = 0; i < results.length; i++) {
-        assertableResults.push(...results[i].collected.map((v) => ({ path: v.path, value: v.value })));
-    }
-    return assertableResults;
-};
-export const errorCollect = (...results) => {
-    const errors = [];
-    for (let i = 0; i < results.length; i++) {
-        if (results[i].errors) {
-            errors.push(...results[i].errors);
-        }
-    }
-    return errors;
-};
-//# sourceMappingURL=index.js.map

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

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

package/dist/test/validateSchema/basic.js

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

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