@based/schema 2.2.10 → 2.2.12

package/dist/test/text.js

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

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

@@ -0,0 +1,17 @@
+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.d.ts

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

package/dist/test/validateSchema.js

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

package/dist/test/walker.d.ts

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

package/dist/test/walker.js

@@ -0,0 +1,289 @@
+import test from 'ava';
+import { setWalker, walk } from '../src/index.js';
+const schema = {
+    types: {
+        thing: {
+            prefix: 'ti',
+            fields: {
+                priority: { type: 'number' },
+                something: { type: 'string', format: 'strongPassword' },
+            },
+        },
+        bla: {
+            prefix: 'bl',
+            fields: {
+                referencesToThings: {
+                    type: 'references',
+                    allowedTypes: ['thing'],
+                },
+                referenceToThing: {
+                    type: 'reference',
+                    allowedTypes: ['thing'],
+                },
+                enum: {
+                    enum: ['tony', 'jim'],
+                },
+                exclusiveminmax: {
+                    type: 'number',
+                    minimum: 3,
+                    exclusiveMinimum: true,
+                    maximum: 6,
+                    exclusiveMaximum: true,
+                },
+                text: {
+                    type: 'text',
+                    pattern: '[^xz]{1,10}',
+                },
+                timestamp: {
+                    type: 'timestamp',
+                },
+                setOfNumbers: {
+                    type: 'set',
+                    items: {
+                        type: 'number',
+                    },
+                },
+                intarray: {
+                    type: 'array',
+                    values: {
+                        type: 'integer',
+                    },
+                },
+                object: {
+                    type: 'object',
+                    properties: {
+                        flap: { type: 'boolean' },
+                    },
+                },
+                name: {
+                    minLength: 3,
+                    maxLength: 6,
+                    type: 'string',
+                },
+                phonkName: {
+                    type: 'string',
+                    pattern: '\\${1,4}',
+                },
+                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',
+    },
+};
+test('backtracking', async (t) => {
+    const results = [];
+    const setObj = {
+        x: {
+            y: {
+                a: 10,
+                bla: [1, 2, 3, 4, 5],
+            },
+            c: 40,
+        },
+    };
+    await walk(schema, {
+        init: async () => {
+            return { target: { lullz: true } };
+        },
+        parsers: {
+            keys: {},
+            fields: {},
+            any: async (args) => {
+                args.collect();
+                return args;
+            },
+        },
+        collect: (args) => {
+            return args.path.join('.');
+        },
+        backtrack: (args, fromBt, collected) => {
+            results.push({ path: args.path, bt: [...fromBt] });
+            return fromBt.length ? fromBt : collected;
+        },
+    }, setObj);
+    t.deepEqual(results, [
+        { path: ['x', 'y', 'bla'], bt: [] },
+        {
+            path: ['x', 'y'],
+            bt: [['x.y.bla.0', 'x.y.bla.1', 'x.y.bla.2', 'x.y.bla.3', 'x.y.bla.4']],
+        },
+        {
+            path: ['x'],
+            bt: [[['x.y.bla.0', 'x.y.bla.1', 'x.y.bla.2', 'x.y.bla.3', 'x.y.bla.4']]],
+        },
+        {
+            path: [],
+            bt: [
+                [[['x.y.bla.0', 'x.y.bla.1', 'x.y.bla.2', 'x.y.bla.3', 'x.y.bla.4']]],
+            ],
+        },
+    ]);
+    const results2 = [];
+    await walk(schema, {
+        init: async () => {
+            return { target: { lullz: true } };
+        },
+        parsers: {
+            keys: {},
+            fields: {},
+            any: async (args) => {
+                args.collect();
+                return { target: { lullz: true } };
+            },
+        },
+        collect: (args) => {
+            return args.path.join('.');
+        },
+        backtrack: (args, fromBt, collected) => {
+            results2.push({ path: args.path, bt: [...fromBt] });
+            return fromBt.length ? fromBt : collected;
+        },
+    }, setObj);
+    t.deepEqual(results, results2);
+    const results3 = [];
+    let cnt = 0;
+    await walk(schema, {
+        init: async () => {
+            return { target: { lullz: true } };
+        },
+        parsers: {
+            keys: {},
+            fields: {},
+            any: async (args) => {
+                cnt++;
+                args.collect();
+                return cnt % 2 ? args : { target: { lullz: true } };
+            },
+        },
+        collect: (args) => {
+            return args.path.join('.');
+        },
+        backtrack: (args, fromBt, collected) => {
+            results3.push({ path: args.path, bt: [...fromBt] });
+            return fromBt.length ? fromBt : collected;
+        },
+    }, setObj);
+    t.deepEqual(results, results3);
+});
+test.only('parseTop update target', async (t) => {
+    const parsed = [];
+    await walk(schema, {
+        init: async () => {
+            return { target: { path: [] } };
+        },
+        parsers: {
+            keys: {},
+            fields: {},
+            any: async (args) => {
+                args.collect();
+                if (args.prev.key !== args.key) {
+                    return {
+                        parseTopLevel: true,
+                        target: {
+                            path: args.path.join('.'),
+                            prevTarget: args.target.id,
+                            id: args.id,
+                        },
+                        value: args.value,
+                    };
+                }
+            },
+        },
+        collect: (args) => {
+            parsed.push({ path: args.path, target: args.target });
+            return args.path.join('.');
+        },
+    }, {
+        x: {
+            y: {
+                z: 'bla!',
+            },
+        },
+    });
+    t.deepEqual(parsed, [
+        { path: ['x'], target: { path: [] } },
+        {
+            path: ['x'],
+            target: { path: 'x', prevTarget: undefined, id: 2 },
+        },
+        {
+            path: ['x', 'y'],
+            target: { path: 'x', prevTarget: undefined, id: 2 },
+        },
+        { path: ['x', 'y'], target: { path: 'x.y', prevTarget: 2, id: 4 } },
+        {
+            path: ['x', 'y', 'z'],
+            target: { path: 'x.y', prevTarget: 2, id: 4 },
+        },
+        {
+            path: ['x', 'y', 'z'],
+            target: { path: 'x.y.z', prevTarget: 4, id: 6 },
+        },
+    ]);
+});
+test.serial('perf setWalker', async (t) => {
+    let d = Date.now();
+    let collected = 0;
+    let errs = 0;
+    for (let i = 0; i < 1e5; i++) {
+        const x = await setWalker(schema, {
+            $id: 'bl120',
+            name: 'blasdsdsd',
+            x: { flap: true },
+        });
+        errs += x.errors.length;
+        collected += x.collected.length;
+    }
+    d = Date.now() - d;
+    console.info('setting 200k', d, 'ms');
+    t.true(d < 1e3);
+});
+//# sourceMappingURL=walker.js.map