@based/schema 2.2.10 → 2.2.12

package/dist/src/walker/index.d.ts

@@ -0,0 +1,6 @@
+import { BasedSchema } from '../types.js';
+import { ArgsClass } from './args.js';
+import { AsyncOperation, Opts } from './types.js';
+export declare const walk: <T>(schema: BasedSchema, opts: Opts<T>, value: any, asyncOperationHandler?: AsyncOperation<T>) => Promise<T>;
+export { ArgsClass };
+export * from './types.js';

package/dist/src/walker/index.js

@@ -0,0 +1,31 @@
+import { ArgsClass } from './args.js';
+export const walk = async (schema, opts, value, asyncOperationHandler) => {
+    if (!('collect' in opts)) {
+        opts.collect = () => { };
+    }
+    if (!('error' in opts)) {
+        opts.error = () => { };
+    }
+    if (asyncOperationHandler) {
+        opts = {
+            ...opts,
+            asyncOperationHandler,
+        };
+    }
+    const argsOpts = await opts.init(value, schema, opts.error);
+    if (!argsOpts) {
+        return {};
+    }
+    if (!argsOpts.value) {
+        argsOpts.value = value;
+    }
+    const args = new ArgsClass(argsOpts);
+    args.root = args;
+    args._opts = opts;
+    args._schema = schema;
+    await args.parse();
+    return args.target;
+};
+export { ArgsClass };
+export * from './types.js';
+//# sourceMappingURL=index.js.map

package/dist/{walker → src/walker}/parse.d.ts

@@ -1,3 +1,3 @@
-import { ArgsClass } from './args';
+import { ArgsClass } from './args.js';
 export type ParseResult<T> = ArgsClass<T> | void;
 export declare function parse<T>(args: ArgsClass<T>): Promise<ArgsClass<T> | void>;

package/dist/{walker → src/walker}/parse.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parse = void 0;
-const args_1 = require("./args");
-const types_1 = require("./types");
+import { ArgsClass } from './args.js';
+import { Stopped } from './types.js';
 // TODO needs cleaning
 function createOrUseArgs(from, newArgs) {
     if (!newArgs) {
         return;
     }
-    if (newArgs instanceof args_1.ArgsClass) {
+    if (newArgs instanceof ArgsClass) {
         return newArgs;
     }
     const x = from.create(newArgs);
@@ -17,7 +14,7 @@ function createOrUseArgs(from, newArgs) {
     return x;
 }
 async function parseKey(from, key, parser) {
-    const keyArgs = new args_1.ArgsClass({
+    const keyArgs = new ArgsClass({
         key,
         value: from.value[key],
         fieldSchema: from.fieldSchema,
@@ -29,7 +26,7 @@ async function parseKey(from, key, parser) {
     }
 }
 function createFieldArgs(from, key, fieldSchema) {
-    return new args_1.ArgsClass({
+    return new ArgsClass({
         key,
         value: from.value[key],
         // @ts-ignore needs key
@@ -42,7 +39,7 @@ function getFieldParser(args) {
         : args.root._opts.parsers.fields[args.fieldSchema.type];
     return fieldParser;
 }
-async function parse(args) {
+export async function parse(args) {
     const opts = args.root._opts;
     if (args.parseTopLevel) {
         const parser = opts.parsers.any;
@@ -126,7 +123,7 @@ async function parse(args) {
             return;
         }
         // any
-        if (args.stopped !== types_1.Stopped.stopAll) {
+        if (args.stopped !== Stopped.stopAll) {
             const parser = opts.parsers.any || opts.parsers.catch;
             if (parser) {
                 const q = [];
@@ -182,5 +179,4 @@ async function parse(args) {
         }
     }
 }
-exports.parse = parse;
 //# sourceMappingURL=parse.js.map

package/dist/{walker → src/walker}/types.d.ts

@@ -1,6 +1,6 @@
-import { ParseError } from '../error';
-import { BasedSchemaType, BasedSchemaFields, BasedSchemaField, BasedSchema } from '../types';
-import { ArgsClass } from './args';
+import { ParseError } from '../error.js';
+import { BasedSchemaType, BasedSchemaFields, BasedSchemaField, BasedSchema } from '../types.js';
+import { ArgsClass } from './args.js';
 export type Path = (string | number)[];
 export type ErrorHandler<T> = (code: ParseError, args: ArgsClass<T> | ArgsOpts<T>) => void;
 export type Collect<T> = (args: ArgsClass<T>) => any;

package/dist/{walker → src/walker}/types.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Stopped = void 0;
-var Stopped;
+export var Stopped;
 (function (Stopped) {
     Stopped[Stopped["onlyStopFieldParser"] = 0] = "onlyStopFieldParser";
     Stopped[Stopped["stopAll"] = 1] = "stopAll";
-})(Stopped || (exports.Stopped = Stopped = {}));
+})(Stopped || (Stopped = {}));
 // Add asyncOperations // requiresAsyncValidation -> asyncOperation: () => {}
 //# sourceMappingURL=types.js.map

package/dist/test/array.d.ts

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

package/dist/test/array.js

@@ -0,0 +1,342 @@
+import test from 'ava';
+import { setWalker } from '../src/index.js';
+import { errorCollect, resultCollect } from './utils/index.js';
+const schema = {
+    types: {
+        bla: {
+            prefix: 'bl',
+            fields: {
+                arrNum: {
+                    type: 'array',
+                    values: {
+                        type: 'number',
+                    },
+                },
+                objArray: {
+                    type: 'array',
+                    values: {
+                        type: 'object',
+                        properties: {
+                            snurp: {
+                                type: 'string',
+                            },
+                        },
+                    },
+                },
+                arrStr: {
+                    type: 'array',
+                    values: {
+                        type: 'string',
+                    },
+                },
+                intarray: {
+                    type: 'array',
+                    values: {
+                        type: 'integer',
+                    },
+                },
+            },
+        },
+    },
+    $defs: {},
+    language: 'en',
+    root: {
+        fields: {},
+    },
+    prefixToTypeMapping: {
+        bl: 'bla',
+    },
+};
+test('arrayNum', async (t) => {
+    const err = await setWalker(schema, {
+        $id: 'bl1',
+        arrNum: ['1', '2'],
+    });
+    const err1 = await setWalker(schema, {
+        $id: 'bla',
+        ref: 1,
+    });
+    const res = await setWalker(schema, {
+        $id: 'bla',
+        arrNum: [1, 2],
+    });
+    t.true(errorCollect(err, err1).length > 0);
+    t.deepEqual(resultCollect(res), [
+        { path: ['arrNum'], value: { $delete: true } },
+        { path: ['arrNum', 0], value: 1 },
+        { path: ['arrNum', 1], value: 2 },
+    ]);
+});
+test('value arr', async (t) => {
+    const err = await setWalker(schema, {
+        $id: 'bl1',
+        arrNum: { $value: ['1', '2'] },
+    });
+    t.true(err.errors.length > 1);
+    const res = await setWalker(schema, {
+        $id: 'bla',
+        arrNum: [{ $value: 1 }, { $value: 2 }],
+    });
+    const res1 = await setWalker(schema, {
+        $id: 'bla',
+        arrNum: { $value: [1, 2] },
+    });
+    t.deepEqual(resultCollect(res, res1), [
+        { path: ['arrNum'], value: { $delete: true } },
+        { path: ['arrNum', 0], value: 1 },
+        { path: ['arrNum', 1], value: 2 },
+        { path: ['arrNum'], value: { $delete: true } },
+        { path: ['arrNum', 0], value: 1 },
+        { path: ['arrNum', 1], value: 2 },
+    ]);
+});
+test.only('default arr', async (t) => {
+    const err = await setWalker(schema, {
+        $id: 'bl1',
+        arrNum: ['1', '2'],
+    });
+    const err1 = await setWalker(schema, {
+        $id: 'bla',
+        ref: 1,
+    });
+    const res = await setWalker(schema, {
+        $id: 'bla',
+        arrNum: [{ $default: 1 }, { $default: 2 }],
+    });
+    const res1 = await setWalker(schema, {
+        $id: 'bla',
+        arrNum: { $default: [1, 2] },
+    });
+    t.true(errorCollect(err, err1).length > 0);
+    t.deepEqual(resultCollect(res, res1), [
+        { path: ['arrNum'], value: { $delete: true } },
+        { path: ['arrNum', 0], value: { $default: 1 } },
+        { path: ['arrNum', 1], value: { $default: 2 } },
+        // TODO bit sketchy needs some work
+        { path: ['arrNum'], value: { $default: [1, 2] } },
+    ]);
+});
+let r;
+test('assign idx value', async (t) => {
+    r = await setWalker(schema, {
+        $id: 'bl120',
+        intarray: {
+            $assign: {
+                $idx: 0,
+                $value: 6,
+            },
+        },
+    });
+    t.deepEqual(resultCollect(r), [{ path: ['intarray', 0], value: 6 }]);
+});
+test('push ints', async (t) => {
+    r = await setWalker(schema, {
+        $id: 'bl120',
+        intarray: {
+            $push: [1, 2, 3, 4, 5],
+        },
+    });
+    t.deepEqual(resultCollect(r), [
+        { path: ['intarray'], value: { $push: [1, 2, 3, 4, 5] } },
+    ]);
+});
+test('push objs', async (t) => {
+    r = await setWalker(schema, {
+        $id: 'bl120',
+        objArray: {
+            $push: [{ snurp: 'a' }, { snurp: 'b' }, { snurp: 'c' }],
+        },
+    });
+    t.deepEqual(resultCollect(r), [
+        {
+            path: ['objArray'],
+            value: {
+                $push: [{ snurp: 'a' }, { snurp: 'b' }, { snurp: 'c' }],
+            },
+        },
+        { path: ['objArray', -3, 'snurp'], value: 'a' },
+        { path: ['objArray', -2, 'snurp'], value: 'b' },
+        { path: ['objArray', -1, 'snurp'], value: 'c' },
+        { path: ['objArray', -3], value: { snurp: 'a' } },
+        { path: ['objArray', -2], value: { snurp: 'b' } },
+        { path: ['objArray', -1], value: { snurp: 'c' } },
+    ]);
+});
+test('unshift ints', async (t) => {
+    r = await setWalker(schema, {
+        $id: 'bl120',
+        intarray: {
+            $unshift: [1, 2, 3, 4, 5],
+        },
+    });
+    t.deepEqual(resultCollect(r), [
+        { path: ['intarray'], value: { $unshift: [1, 2, 3, 4, 5] } },
+    ]);
+    t.true(true);
+});
+test('nested default unshift', async (t) => {
+    r = await setWalker(schema, {
+        $id: 'bl120',
+        intarray: {
+            $unshift: [{ $value: 1 }, { $default: 2 }, 3, 4, 5],
+        },
+    });
+    t.is(r.errors.length, 0);
+    t.deepEqual(resultCollect(r), [
+        {
+            path: ['intarray'],
+            value: { $unshift: [1, { $default: 2 }, 3, 4, 5] },
+        },
+    ]);
+});
+test('nested default in push', async (t) => {
+    r = await setWalker(schema, {
+        $id: 'bl120',
+        intarray: {
+            $push: [{ $value: 1 }, { $default: 2 }, 3, 4, 5],
+        },
+    });
+    t.is(r.errors.length, 0);
+    t.deepEqual(resultCollect(r), [
+        {
+            path: ['intarray'],
+            value: { $push: [1, { $default: 2 }, 3, 4, 5] },
+        },
+    ]);
+});
+test('assign idx default value error', async (t) => {
+    r = await setWalker(schema, {
+        $id: 'bl120',
+        intarray: {
+            $assign: {
+                $idx: { $default: 0 },
+                $value: 6,
+            },
+        },
+    });
+    t.true(r.errors.length > 0);
+});
+test('assign idx no value', async (t) => {
+    r = await setWalker(schema, {
+        $id: 'bl120',
+        intarray: {
+            $assign: {
+                $idx: { $default: 0 },
+            },
+        },
+    });
+    t.true(r.errors.length > 0);
+});
+test('assign idx value spelled wrong', async (t) => {
+    r = await setWalker(schema, {
+        $id: 'bl120',
+        intarray: {
+            $assign: {
+                $idx: 0,
+                value: 5,
+            },
+        },
+    });
+    t.true(r.errors.length > 0);
+});
+test('assign idx value wrong type', async (t) => {
+    r = await setWalker(schema, {
+        $id: 'bl120',
+        intarray: {
+            $assign: {
+                $idx: 0,
+                $value: 5.6,
+            },
+        },
+    });
+    t.true(r.errors.length > 0);
+});
+test('assign idx value value wrong type', async (t) => {
+    r = await setWalker(schema, {
+        $id: 'bl120',
+        intarray: {
+            $assign: {
+                $idx: 0,
+                $value: { $value: 5.6 },
+            },
+        },
+    });
+    t.true(r.errors.length > 0);
+});
+test('assign idx default value', async (t) => {
+    r = await setWalker(schema, {
+        $id: 'bl120',
+        intarray: {
+            $assign: {
+                $idx: 0,
+                $value: { $default: 5 },
+            },
+        },
+    });
+    t.deepEqual(resultCollect(r), [
+        { path: ['intarray', 0], value: { $default: 5 } },
+    ]);
+});
+test('assign idx value value error', async (t) => {
+    r = await setWalker(schema, {
+        $id: 'bl120',
+        intarray: {
+            $assign: {
+                $idx: { $value: 0 },
+                $value: 6,
+            },
+        },
+    });
+    t.true(r.errors.length > 0);
+});
+test('insert idx intarray', async (t) => {
+    r = await setWalker(schema, {
+        $id: 'bl120',
+        intarray: {
+            $insert: {
+                $idx: 10,
+                $value: 1212,
+            },
+        },
+    });
+    t.true(r.errors.length === 0);
+    t.deepEqual(resultCollect(r), [
+        {
+            path: ['intarray'],
+            value: { $insert: { $idx: 10, $value: [1212] } },
+        },
+    ]);
+});
+test('unshift array', async (t) => {
+    r = await setWalker(schema, {
+        $id: 'bl120',
+        intarray: {
+            $unshift: { $value: [-10, -20, -30] },
+        },
+    });
+    t.true(r.errors.length === 0);
+    t.deepEqual(resultCollect(r), [
+        { path: ['intarray'], value: { $unshift: [-10, -20, -30] } },
+    ]);
+});
+test('assign + $delete', async (t) => {
+    r = await setWalker(schema, {
+        $id: 'bl120',
+        objArray: {
+            $assign: {
+                $idx: 3,
+                $value: {
+                    snurp: {
+                        $delete: true,
+                    },
+                },
+            },
+        },
+    });
+    t.is(r.errors.length, 0);
+    t.deepEqual(resultCollect(r), [
+        { path: ['objArray', 3, 'snurp'], value: { $delete: true } },
+        { path: ['objArray', 3], value: { snurp: { $delete: true } } },
+    ]);
+});
+//# sourceMappingURL=array.js.map

package/dist/test/display.d.ts

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

package/dist/test/display.js

@@ -0,0 +1,103 @@
+import test from 'ava';
+import { display } from '../src/index.js';
+const schema = {
+    types: {
+        thing: {
+            prefix: 'ti',
+            fields: {
+                dateHuman: { type: 'timestamp', display: 'human' },
+                dateTime: { type: 'timestamp', display: 'date-time' },
+                dateTimeText: { type: 'timestamp', display: 'date-time-text' },
+                time: { type: 'timestamp', display: 'time' },
+                timePrecise: { type: 'timestamp', display: 'time-precise' },
+                capitalize: {
+                    type: 'string',
+                    display: 'capitalize',
+                    format: 'lowercase',
+                },
+                upperCase: { type: 'string', display: 'uppercase' },
+                lowerCase: { type: 'string', display: 'lowercase' },
+                euros: { type: 'number', display: 'euro' },
+                dollars: { type: 'number', display: 'dollar' },
+                pounds: { type: 'number', display: 'pound' },
+                bytes: { type: 'number', display: 'bytes' },
+                humanNumber: { type: 'number', display: 'human' },
+                ratio: { type: 'number', display: 'ratio' },
+                short: { type: 'number', display: 'short' },
+            },
+        },
+    },
+    $defs: {},
+    language: 'en',
+    root: {
+        fields: {},
+    },
+    prefixToTypeMapping: {
+        bl: 'bla',
+        ti: 'thing',
+    },
+};
+test('date display', async (t) => {
+    const now = 1701695869765;
+    const parsed = [
+        display('bla', schema.types.thing.fields.capitalize),
+        display('b', schema.types.thing.fields.capitalize),
+        display(undefined, schema.types.thing.fields.capitalize),
+        display('', schema.types.thing.fields.capitalize),
+        display('bla', schema.types.thing.fields.upperCase),
+        display('BLA', schema.types.thing.fields.lowerCase),
+        display(100000, schema.types.thing.fields.euros),
+        display(100000, schema.types.thing.fields.dollars),
+        display(10.21, schema.types.thing.fields.euros),
+        display(10.2312234342, schema.types.thing.fields.dollars),
+        display(1001.21212, schema.types.thing.fields.euros),
+        display(1001.21212, schema.types.thing.fields.dollars),
+        display(10000.21212, schema.types.thing.fields.euros),
+        display(10000.21212, schema.types.thing.fields.dollars),
+        display(100e6, schema.types.thing.fields.euros),
+        display(100e6, schema.types.thing.fields.dollars),
+        display(100e6, schema.types.thing.fields.bytes),
+        display(100e9, schema.types.thing.fields.bytes),
+        display(100e9, schema.types.thing.fields.short),
+    ];
+    t.deepEqual(parsed, [
+        'Bla',
+        'B',
+        undefined,
+        '',
+        'BLA',
+        'bla',
+        '€100k',
+        '$100k',
+        '€10,21',
+        '$10.23',
+        '€1001,21',
+        '$1001.21',
+        '€10k',
+        '$10k',
+        '€100m',
+        '$100m',
+        '95.37 mb',
+        '93.13 gb',
+        '100b',
+    ]);
+    const dates = [
+        display(now + 20e3, schema.types.thing.fields.dateTimeText),
+        display(now + 20e3, schema.types.thing.fields.timePrecise),
+        display(now + 20e3, schema.types.thing.fields.dateTime),
+        display(now + 20e3, {
+            type: 'timestamp',
+            display: 'date-time-text',
+        }),
+    ];
+    for (const d of dates) {
+        if (!d) {
+            t.fail('date is not parsed');
+        }
+    }
+    t.regex(String(display(now + 20e3, schema.types.thing.fields.dateTimeText)), /^December 4, 2023, *./);
+    t.regex(String(display(now + 20e3, schema.types.thing.fields.timePrecise)), /^[0-9]{2}:18:09$/);
+    t.regex(String(display(now + 20e3, schema.types.thing.fields.dateTime)), /^[0-9]{2}:18 4\/12\/2023$/);
+    t.regex(String(display(now + 20e3, schema.types.thing.fields.time)), /^[0-9]{2}:18$/);
+});
+//# sourceMappingURL=display.js.map

package/dist/test/number.d.ts

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