@based/schema 4.1.1 → 5.0.0-alpha.0

package/dist/test/reference.js

@@ -1,188 +0,0 @@
-import test from 'ava';
-import { setWalker } from '../src/index.js';
-import { resultCollect } from './utils/index.js';
-const schema = {
-    types: {
-        thing: {
-            prefix: 'ti',
-            fields: {
-                priority: { type: 'number' },
-                something: { type: 'string', format: 'strongPassword' },
-            },
-        },
-        bla: {
-            prefix: 'bl',
-            fields: {
-                ref: {
-                    type: 'reference',
-                    allowedType: 'bla',
-                },
-                children: {
-                    type: 'references',
-                    allowedType: 'bla',
-                },
-                referencesToThings: {
-                    type: 'references',
-                    allowedType: 'thing',
-                },
-                referenceToThing: {
-                    type: 'reference',
-                    allowedType: 'thing',
-                },
-            },
-        },
-    },
-    $defs: {},
-    language: 'en',
-    translations: ['de', 'nl', 'ro', 'za', 'ae'],
-    root: {
-        fields: {},
-    },
-    prefixToTypeMapping: {
-        bl: 'bla',
-        ti: 'thing',
-    },
-};
-let r;
-test('simple error', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        referenceToThing: 'sdfefewfewfewewffwe',
-    });
-    t.true(r.errors.length === 1);
-});
-test('simple case ', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        referenceToThing: 'tibla',
-    });
-    t.deepEqual(resultCollect(r), [
-        { path: ['referenceToThing'], value: 'tibla' },
-    ]);
-});
-test('reference to wrong type', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        referenceToThing: 'blbla',
-    });
-    t.true(r.errors.length === 1);
-});
-test('references with wrongly formatted ids and incorrect types ', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        referencesToThings: ['blbla', 'ti123', 'ewiohfdoweihfw'],
-    });
-    t.true(r.errors.length === 2);
-});
-test('references to empty array (clear)', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        referencesToThings: [],
-    });
-    t.deepEqual(resultCollect(r), [
-        { path: ['referencesToThings'], value: { $value: [] } },
-    ]);
-    t.is(r.errors.length, 0);
-});
-test('$remove references', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        referencesToThings: { $remove: ['ti123'] },
-    });
-    t.deepEqual(resultCollect(r), [
-        { path: ['referencesToThings'], value: { $remove: ['ti123'] } },
-    ]);
-});
-test('$add 0 2 wrong', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        referencesToThings: { $add: ['blbla', 'ti123', 'ewiohfdoweihfw'] },
-    });
-    t.true(r.errors.length === 2);
-});
-test('$add correct ', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        referencesToThings: { $add: 'ti123' },
-    });
-    t.deepEqual(resultCollect(r), [
-        { path: ['referencesToThings'], value: { $add: ['ti123'] } },
-    ]);
-});
-test('$remove $value not allowed', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        referencesToThings: { $remove: { $value: 'ti123' } },
-    });
-    t.true(r.errors.length > 0);
-});
-test('reference to an object', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        referenceToThing: {
-            type: 'thing',
-            priority: 9000,
-        },
-    }, async (args) => {
-        if (args.value.type === 'thing') {
-            return 'tilil';
-        }
-        else {
-            return 'bl1221';
-        }
-    });
-    t.is(r.errors.length, 0);
-    t.deepEqual(resultCollect(r), [
-        { path: ['referenceToThing'], value: 'tilil' },
-    ]);
-    t.true(true);
-});
-test('nested references + $add (deep)', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl1221',
-        children: {
-            $add: [
-                {
-                    type: 'bla',
-                },
-            ],
-        },
-    }, async (args) => {
-        if (args.value.type === 'thing') {
-            return 'tilil';
-        }
-        else {
-            return 'bl1221';
-        }
-    });
-    t.is(r.errors.length, 0);
-    t.deepEqual(resultCollect(r), [
-        { path: ['children'], value: { $add: ['bl1221'] } },
-    ]);
-});
-test('nested ref + references', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl1221',
-        ref: {
-            $id: 'bl1221',
-        },
-        children: [
-            {
-                $id: 'bl1221',
-            },
-        ],
-    }, async (args) => {
-        if (args.value.type === 'thing') {
-            return 'tilil';
-        }
-        else {
-            return 'bl1221';
-        }
-    });
-    t.is(r.errors.length, 0);
-    t.deepEqual(resultCollect(r), [
-        { path: ['ref'], value: 'bl1221' },
-        { path: ['children'], value: { $value: ['bl1221'] } },
-    ]);
-});
-//# sourceMappingURL=reference.js.map

package/dist/test/rest.d.ts

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

package/dist/test/rest.js

@@ -1,168 +0,0 @@
-import test from 'ava';
-import { setWalker } from '../src/index.js';
-import { resultCollect } from './utils/index.js';
-const schema = {
-    types: {
-        thing: {
-            prefix: 'ti',
-            fields: {
-                priority: { type: 'number' },
-                something: { type: 'string', format: 'strongPassword' },
-            },
-        },
-        bla: {
-            prefix: 'bl',
-            fields: {
-                enum: {
-                    enum: ['tony', 'jim'],
-                },
-                setOfNumbers: {
-                    type: 'set',
-                    items: {
-                        type: 'number',
-                    },
-                },
-                object: {
-                    type: 'object',
-                    properties: {
-                        flap: { type: 'boolean' },
-                    },
-                },
-                flap: {
-                    type: 'boolean',
-                },
-                x: {
-                    type: 'object',
-                    properties: {
-                        flap: {
-                            type: 'boolean',
-                        },
-                    },
-                },
-                record: {
-                    type: 'record',
-                    values: {
-                        type: 'object',
-                        properties: {
-                            bla: {
-                                type: 'array',
-                                items: {
-                                    type: 'object',
-                                    properties: {
-                                        snux: {
-                                            type: 'object',
-                                            properties: {
-                                                x: {
-                                                    type: 'number',
-                                                },
-                                            },
-                                        },
-                                        flap: { type: 'number' },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-                bla: {
-                    type: 'set',
-                    items: { type: 'string', minLength: 3, maxLength: 6 },
-                },
-            },
-        },
-    },
-    $defs: {},
-    language: 'en',
-    translations: ['de', 'nl', 'ro', 'za', 'ae'],
-    root: {
-        fields: {},
-    },
-    prefixToTypeMapping: {
-        bl: 'bla',
-        ti: 'thing',
-    },
-};
-let r;
-test('enum simple', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        enum: 'tony',
-    });
-    t.true(r.errors.length === 0);
-    t.deepEqual(resultCollect(r), [{ path: ['enum'], value: 0 }]);
-});
-test('enum not exist error', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        enum: 'kyle',
-    });
-    t.true(r.errors.length === 1);
-});
-test('default enum', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        enum: { $default: 'tony' },
-    });
-    t.true(r.errors.length === 0);
-    t.deepEqual(resultCollect(r), [{ path: ['enum'], value: { $default: 0 } }]);
-});
-test('value enum ', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        enum: { $value: 'tony' },
-    });
-    t.true(r.errors.length === 0);
-    t.deepEqual(resultCollect(r), [{ path: ['enum'], value: 0 }]);
-});
-test('value &  default enum ', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        enum: { $default: 'jim', $value: 'tony' },
-    });
-    t.true(r.errors.length === 2);
-});
-test('$value & $default enum ', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        enum: { $value: { $default: 'tony' } },
-    });
-    t.true(r.errors.length === 0);
-    t.deepEqual(resultCollect(r), [{ path: ['enum'], value: { $default: 0 } }]);
-});
-test('default: value enum ', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        enum: { $default: { $value: 'tony' } },
-    });
-    t.true(r.errors.length === 0);
-    t.deepEqual(resultCollect(r), [{ path: ['enum'], value: { $default: 0 } }]);
-});
-// ask about alias
-test('$alias ', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        $alias: 'bla',
-    });
-    t.true(r.errors.length === 0);
-});
-test('$alias array', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        $alias: ['bla'],
-    });
-    t.true(r.errors.length === 0);
-});
-test('object: boolean', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        object: {
-            flap: true,
-        },
-    });
-    t.true(r.errors.length === 0);
-    t.deepEqual(resultCollect(r), [
-        { path: ['object', 'flap'], value: true },
-        { path: ['object'], value: { flap: true } },
-    ]);
-});
-//# sourceMappingURL=rest.js.map

package/dist/test/set.d.ts

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

package/dist/test/set.js

@@ -1,95 +0,0 @@
-import test from 'ava';
-import { setWalker } from '../src/index.js';
-import { resultCollect } from './utils/index.js';
-let r;
-const schema = {
-    types: {
-        thing: {
-            prefix: 'ti',
-            fields: {
-                something: { type: 'string', format: 'strongPassword' },
-            },
-        },
-        bla: {
-            prefix: 'bl',
-            fields: {
-                x: {
-                    type: 'object',
-                    properties: {
-                        bla: { type: 'string' },
-                    },
-                },
-                setOfNumbers: {
-                    type: 'set',
-                    items: {
-                        type: 'number',
-                    },
-                },
-                bla: {
-                    type: 'set',
-                    items: { type: 'string', minLength: 3, maxLength: 6 },
-                },
-            },
-        },
-    },
-    $defs: {},
-    language: 'en',
-    translations: ['de', 'nl', 'ro', 'za', 'ae'],
-    root: {
-        fields: {},
-    },
-    prefixToTypeMapping: {
-        bl: 'bla',
-        ti: 'thing',
-    },
-};
-test('simple setNum', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        setOfNumbers: [1, 2, 3, 4, 5],
-    });
-    t.true(r.errors.length === 0);
-    t.deepEqual(resultCollect(r), [
-        { path: ['setOfNumbers'], value: { $value: [1, 2, 3, 4, 5] } },
-    ]);
-});
-test('default arr', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        setOfNumbers: { $add: 20 },
-    });
-    t.true(r.errors.length === 0);
-    t.deepEqual(resultCollect(r), [
-        { path: ['setOfNumbers'], value: { $add: [20] } },
-    ]);
-});
-test('$merge on object', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        x: {
-            $merge: false,
-            bla: 'x',
-        },
-    });
-    t.true(r.errors.length === 0);
-    t.deepEqual(resultCollect(r), [
-        { path: ['x'], value: { $delete: true } },
-        { path: ['x', 'bla'], value: 'x' },
-        { path: ['x'], value: { $merge: false, bla: 'x' } },
-    ]);
-});
-test('$merge on set', async (t) => {
-    r = await setWalker(schema, {
-        $id: 'bl120',
-        $merge: false,
-        x: {
-            bla: 'x',
-        },
-    });
-    t.true(r.errors.length === 0);
-    t.deepEqual(resultCollect(r), [
-        { path: ['x', 'bla'], value: 'x' },
-        { path: ['x'], value: { bla: 'x' } },
-    ]);
-});
-//# sourceMappingURL=set.js.map

package/dist/test/string.d.ts

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

package/dist/test/string.js

@@ -1,120 +0,0 @@
-import test from 'ava';
-import { setWalker } from '../src/index.js';
-import { errorCollect, resultCollect } from './utils/index.js';
-const schema = {
-    types: {
-        bla: {
-            prefix: 'bl',
-            fields: {
-                color: {
-                    type: 'string',
-                    format: 'rgbColor',
-                },
-                name: {
-                    minLength: 3,
-                    maxLength: 6,
-                    type: 'string',
-                },
-                phonkName: {
-                    type: 'string',
-                    pattern: '\\${1,4}',
-                },
-                bla: {
-                    type: 'set',
-                    items: { type: 'string', minLength: 3, maxLength: 6 },
-                },
-            },
-        },
-    },
-    $defs: {},
-    language: 'en',
-    root: {
-        fields: {},
-    },
-    prefixToTypeMapping: {
-        bl: 'bla',
-    },
-};
-test('string max length', async (t) => {
-    const err1 = await setWalker(schema, {
-        $id: 'bl1',
-        name: 'ax',
-    });
-    const err2 = await setWalker(schema, {
-        $id: 'bl1',
-        name: 'axaxaxax',
-    });
-    const res1 = await setWalker(schema, {
-        $id: 'bl1',
-        name: 'xaxx',
-    });
-    t.assert(errorCollect(err1, err2).length > 0);
-    t.deepEqual(resultCollect(res1), [{ path: ['name'], value: 'xaxx' }]);
-});
-//set parser
-test('set with strings', async (t) => {
-    const err1 = await setWalker(schema, {
-        $id: 'bl1',
-        bla: ['ax', 'axa', 'axxxxa'],
-    });
-    const res1 = await setWalker(schema, {
-        $id: 'bl1',
-        bla: ['axx', 'axxxx', 'blaaa'],
-    });
-    t.assert(errorCollect(err1).length > 0);
-    t.deepEqual(resultCollect(res1), [
-        { path: ['bla'], value: { $value: ['axx', 'axxxx', 'blaaa'] } },
-    ]);
-});
-// this one causes weird array lenght issue in string max length test
-test('string pattern', async (t) => {
-    const err1 = await setWalker(schema, {
-        $id: 'bl1',
-        phonkName: 'blabla',
-    });
-    const res1 = await setWalker(schema, {
-        $id: 'bl1',
-        phonkName: 'bla$',
-    });
-    t.assert(errorCollect(err1).length > 0);
-    t.deepEqual(resultCollect(res1), [{ path: ['phonkName'], value: 'bla$' }]);
-});
-test('setting $default', async (t) => {
-    const err = await setWalker(schema, {
-        $id: 'bl1',
-        phonkName: { $default: 'blabla' },
-    });
-    t.assert(err.errors.length > 0);
-    const res1 = await setWalker(schema, {
-        $id: 'bl1',
-        phonkName: { $default: 'bla$' },
-    });
-    t.deepEqual(resultCollect(res1), [
-        { path: ['phonkName'], value: { $default: 'bla$' } },
-    ]);
-});
-test('setting $value', async (t) => {
-    const err = await setWalker(schema, {
-        $id: 'bl1',
-        phonkName: { $value: 'blabla' },
-    });
-    t.is(err.errors.length, 1);
-    const res1 = await setWalker(schema, {
-        $id: 'bl1',
-        phonkName: { $value: 'bla$' },
-    });
-    t.deepEqual(resultCollect(res1), [{ path: ['phonkName'], value: 'bla$' }]);
-});
-test('setting color', async (t) => {
-    const err = await setWalker(schema, {
-        $id: 'bl1',
-        color: 'rgba(255,255,255,0.1)',
-    });
-    t.is(err.errors.length, 0);
-    const err2 = await setWalker(schema, {
-        $id: 'bl1',
-        color: 'rgba(255,255,255,0.1)x',
-    });
-    t.is(err2.errors.length, 1);
-});
-//# sourceMappingURL=string.js.map

package/dist/test/text.d.ts

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