@based/schema 2.2.10 → 2.2.11

package/dist/test/number.js

@@ -0,0 +1,374 @@
+import test from 'ava';
+import { setWalker } from '../src/index.js';
+import { resultCollect, errorCollect } from './utils/index.js';
+const schema = {
+    types: {
+        bla: {
+            prefix: 'bl',
+            fields: {
+                number: {
+                    type: 'number',
+                    maximum: 6,
+                    minimum: 3,
+                },
+                infiniteNum: {
+                    type: 'number',
+                },
+                infiniteInt: {
+                    type: 'integer',
+                },
+                exclusiveminmax: {
+                    type: 'number',
+                    minimum: 3,
+                    exclusiveMinimum: true,
+                    maximum: 6,
+                    exclusiveMaximum: true,
+                },
+                integer: {
+                    type: 'integer',
+                },
+                multipleOf: {
+                    type: 'integer',
+                    multipleOf: 3,
+                },
+                set: {
+                    type: 'set',
+                    items: { type: 'number', minimum: 3, maximum: 6 },
+                },
+            },
+        },
+    },
+    $defs: {},
+    language: 'en',
+    root: {
+        fields: {},
+    },
+    prefixToTypeMapping: {
+        bl: 'bla',
+    },
+};
+//todo need help typing this maybe
+test('min-max', async (t) => {
+    const e1 = await setWalker(schema, {
+        $id: 'bl1',
+        number: 1,
+    });
+    const e2 = await setWalker(schema, {
+        $id: 'bl1',
+        number: 10,
+    });
+    const res1 = await setWalker(schema, {
+        $id: 'bl1',
+        number: 3,
+    });
+    const res2 = await setWalker(schema, {
+        $id: 'bl1',
+        number: 6,
+    });
+    t.true(errorCollect(e1, e2).length > 0);
+    t.deepEqual(resultCollect(res1, res2), [
+        { path: ['number'], value: 3 },
+        { path: ['number'], value: 6 },
+    ]);
+});
+test('min-max exclusive', async (t) => {
+    const e1 = await setWalker(schema, {
+        $id: 'bl1',
+        exclusiveminmax: 3,
+    });
+    const e2 = await setWalker(schema, {
+        $id: 'bl1',
+        exclusiveminmax: 6,
+    });
+    const res1 = await setWalker(schema, {
+        $id: 'bl1',
+        exclusiveminmax: 4,
+    });
+    const res2 = await setWalker(schema, {
+        $id: 'bl1',
+        exclusiveminmax: 5,
+    });
+    t.assert(errorCollect(e1, e2).length > 0);
+    t.deepEqual(resultCollect(res1, res2), [
+        { path: ['exclusiveminmax'], value: 4 },
+        { path: ['exclusiveminmax'], value: 5 },
+    ]);
+});
+test('isInteger', async (t) => {
+    const e1 = await setWalker(schema, {
+        $id: 'bl1',
+        integer: 6.5,
+    });
+    const res1 = await setWalker(schema, {
+        $id: 'bl1',
+        integer: 5,
+    });
+    t.assert(errorCollect(e1).length > 0);
+    t.deepEqual(resultCollect(res1), [{ path: ['integer'], value: 5 }]);
+});
+test('isMultiple', async (t) => {
+    const e1 = await setWalker(schema, {
+        $id: 'bl1',
+        multipleOf: 7,
+    });
+    const res1 = await setWalker(schema, {
+        $id: 'bl1',
+        multipleOf: 9,
+    });
+    t.assert(errorCollect(e1).length > 0);
+    t.deepEqual(resultCollect(res1), [{ path: ['multipleOf'], value: 9 }]);
+});
+//TODO fix
+test('numbers in a set', async (t) => {
+    const e1 = await setWalker(schema, {
+        $id: 'bl1',
+        set: [9, 4, 5, 2],
+    });
+    const res1 = await setWalker(schema, { $id: 'bl1', set: [3, 3, 3, 3] });
+    t.assert(errorCollect(e1).length > 0);
+    t.deepEqual(resultCollect(res1), [
+        { path: ['set'], value: { $value: [3, 3, 3, 3] } },
+    ]);
+});
+//TODO fix
+test('value', async (t) => {
+    const e1 = await setWalker(schema, {
+        $id: 'bl1',
+        number: { $value: 7 },
+    });
+    const e2 = await setWalker(schema, {
+        $id: 'bl1',
+        exclusiveminmax: { $value: 3 },
+    });
+    const e3 = await setWalker(schema, {
+        $id: 'bl1',
+        integer: { value: 3.5 },
+    });
+    const e4 = await setWalker(schema, {
+        $id: 'bl1',
+        set: { $value: [1, 3, 3, 4] },
+    });
+    const e5 = await setWalker(schema, {
+        $id: 'bl1',
+        multipleOf: { $value: 2 },
+    });
+    const res1 = await setWalker(schema, {
+        $id: 'bl1',
+        number: { $value: 4 },
+    });
+    const res2 = await setWalker(schema, {
+        $id: 'bl1',
+        integer: { $value: 4 },
+    });
+    const res3 = await setWalker(schema, {
+        $id: 'bl1',
+        exclusiveminmax: { $value: 4 },
+    });
+    const res4 = await setWalker(schema, {
+        $id: 'bl1',
+        multipleOf: { $value: 6 },
+    });
+    await setWalker(schema, {
+        $id: 'bl1',
+        set: { $value: [3, 3, 3, 4] },
+    });
+    t.assert(errorCollect(e1, e2, e3, e4, e5).length > 0);
+    t.deepEqual(resultCollect(res1, res2, res3, res4), [
+        { path: ['number'], value: 4 },
+        { path: ['integer'], value: 4 },
+        { path: ['exclusiveminmax'], value: 4 },
+        { path: ['multipleOf'], value: 6 },
+    ]);
+});
+test('default', async (t) => {
+    const e1 = await setWalker(schema, {
+        $id: 'bl1',
+        number: { $default: 7 },
+    });
+    const e2 = await setWalker(schema, {
+        $id: 'bl1',
+        exclusiveminmax: { $default: 3 },
+    });
+    const e3 = await setWalker(schema, {
+        $id: 'bl1',
+        integer: { default: 3.5 },
+    });
+    const e4 = await setWalker(schema, {
+        $id: 'bl1',
+        set: { $default: [1, 3, 3, 4] },
+    });
+    const e5 = await setWalker(schema, {
+        $id: 'bl1',
+        multipleOf: { $default: 2 },
+    });
+    const res1 = await setWalker(schema, {
+        $id: 'bl1',
+        number: { $default: 4 },
+    });
+    const res2 = await setWalker(schema, {
+        $id: 'bl1',
+        integer: { $default: 4 },
+    });
+    const res3 = await setWalker(schema, {
+        $id: 'bl1',
+        exclusiveminmax: { $default: 4 },
+    });
+    const res4 = await setWalker(schema, {
+        $id: 'bl1',
+        multipleOf: { $default: 6 },
+    });
+    const res5 = await setWalker(schema, {
+        $id: 'bl1',
+        set: { $default: [3, 3, 3, 4] },
+    });
+    t.assert(errorCollect(e1, e2, e3, e4, e5).length > 0);
+    t.deepEqual(resultCollect(res1, res2, res3, res4, res5), [
+        { path: ['number'], value: { $default: 4 } },
+        { path: ['integer'], value: { $default: 4 } },
+        { path: ['exclusiveminmax'], value: { $default: 4 } },
+        { path: ['multipleOf'], value: { $default: 6 } },
+        { path: ['set'], value: { $default: { $value: [3, 3, 3, 4] } } },
+    ]);
+});
+test('decrement', async (t) => {
+    //maxmin
+    const e1 = await setWalker(schema, {
+        $id: 'bl1',
+        number: { $decrement: 2 },
+    });
+    const e2 = await setWalker(schema, {
+        $id: 'bl1',
+        number: { $decrement: 7 },
+    });
+    const res1 = await setWalker(schema, {
+        $id: 'bl1',
+        number: { $decrement: 3 },
+    });
+    //exclusiveminmax
+    const e3 = await setWalker(schema, {
+        $id: 'bl1',
+        exclusiveminmax: { $decrement: 3 },
+    });
+    const e4 = await setWalker(schema, {
+        $id: 'bl1',
+        exclusiveminmax: { $decrement: 6 },
+    });
+    const res2 = await setWalker(schema, {
+        $id: 'bl1',
+        exclusiveminmax: { $decrement: 4 },
+    });
+    //integer
+    const e5 = await setWalker(schema, {
+        $id: 'bl1',
+        integer: { $decrement: 3.5 },
+    });
+    const res3 = await setWalker(schema, {
+        $id: 'bl1',
+        integer: { $decrement: 3 },
+    });
+    //multiple of
+    const e6 = await setWalker(schema, {
+        $id: 'bl1',
+        multipleOf: { $decrement: 7 },
+    });
+    const res4 = await setWalker(schema, {
+        $id: 'bl1',
+        multipleOf: { $decrement: 9 },
+    });
+    t.assert(errorCollect(e1, e2, e3, e4, e5, e6).length > 0);
+    t.deepEqual(resultCollect(res1, res2, res3, res4), [
+        { path: ['number'], value: { $decrement: 3 } },
+        { path: ['exclusiveminmax'], value: { $decrement: 4 } },
+        { path: ['integer'], value: { $decrement: 3 } },
+        { path: ['multipleOf'], value: { $decrement: 9 } },
+    ]);
+});
+test('increment', async (t) => {
+    //maxmin
+    const e1 = await setWalker(schema, {
+        $id: 'bl1',
+        number: { $increment: 2 },
+    });
+    const e2 = await setWalker(schema, {
+        $id: 'bl1',
+        number: { $increment: 7 },
+    });
+    const res1 = await setWalker(schema, {
+        $id: 'bl1',
+        number: { $increment: 3 },
+    });
+    //exclusiveminmax
+    const e3 = await setWalker(schema, {
+        $id: 'bl1',
+        exclusiveminmax: { $increment: 3 },
+    });
+    const e4 = await setWalker(schema, {
+        $id: 'bl1',
+        exclusiveminmax: { $increment: 6 },
+    });
+    const res2 = await setWalker(schema, {
+        $id: 'bl1',
+        exclusiveminmax: { $increment: 4 },
+    });
+    //integer
+    const e5 = await setWalker(schema, {
+        $id: 'bl1',
+        integer: { $increment: 3.5 },
+    });
+    const res3 = await setWalker(schema, {
+        $id: 'bl1',
+        integer: { $increment: 3 },
+    });
+    //multiple of
+    const e6 = await setWalker(schema, {
+        $id: 'bl1',
+        multipleOf: { $increment: 7 },
+    });
+    const res4 = await setWalker(schema, {
+        $id: 'bl1',
+        multipleOf: { $increment: 9 },
+    });
+    t.assert(errorCollect(e1, e2, e3, e4, e5, e6).length > 0);
+    t.deepEqual(resultCollect(res1, res2, res3, res4), [
+        { path: ['number'], value: { $increment: 3 } },
+        { path: ['exclusiveminmax'], value: { $increment: 4 } },
+        { path: ['integer'], value: { $increment: 3 } },
+        { path: ['multipleOf'], value: { $increment: 9 } },
+    ]);
+});
+test('NaN', async (t) => {
+    const r = await setWalker(schema, {
+        $id: 'bl120',
+        integer: NaN,
+    });
+    t.is(r.errors.length, 1);
+});
+test('Infinity (integer)', async (t) => {
+    const r = await setWalker(schema, {
+        $id: 'bl120',
+        integer: Infinity,
+    });
+    t.is(r.errors.length, 1);
+});
+test('Infinity (number)', async (t) => {
+    const r = await setWalker(schema, {
+        $id: 'bl120',
+        infiniteNum: Infinity,
+    });
+    t.is(r.errors.length, 1);
+});
+test('number -infinity', async (t) => {
+    const r = await setWalker(schema, {
+        $id: 'bl120',
+        infiniteNum: -Infinity,
+    });
+    t.is(r.errors.length, 1);
+});
+test('number with max infinity', async (t) => {
+    const r = await setWalker(schema, {
+        $id: 'bl120',
+        number: Infinity,
+    });
+    t.is(r.errors.length, 1);
+});
+//# sourceMappingURL=number.js.map

package/dist/test/reference.d.ts

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

package/dist/test/reference.js

@@ -0,0 +1,186 @@
+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',
+                },
+                children: {
+                    type: 'references',
+                },
+                referencesToThings: {
+                    type: 'references',
+                    allowedTypes: ['thing'],
+                },
+                referenceToThing: {
+                    type: 'reference',
+                    allowedTypes: ['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

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