@based/schema 2.2.9 → 2.2.11

package/dist/test/rest.js

@@ -0,0 +1,168 @@
+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',
+                                values: {
+                                    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

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

package/dist/test/set.js

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

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

package/dist/test/string.js

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

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