@based/schema 3.1.0 → 3.2.0

package/dist/walker/parse.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+const args_1 = require("./args");
+const types_1 = require("./types");
+// TODO needs cleaning
+function createOrUseArgs(from, newArgs) {
+    if (!newArgs) {
+        return;
+    }
+    if (newArgs instanceof args_1.ArgsClass) {
+        return newArgs;
+    }
+    const x = from.create(newArgs);
+    // x.collectedCommands = from.collectedCommands
+    // x.fromBackTrack = from.fromBackTrack
+    return x;
+}
+async function parseKey(from, key, parser) {
+    const keyArgs = new args_1.ArgsClass({
+        key,
+        value: from.value[key],
+        fieldSchema: from.fieldSchema,
+    }, from);
+    // if same
+    const newArgs = createOrUseArgs(keyArgs, await parser(keyArgs));
+    if (newArgs) {
+        return newArgs.parse();
+    }
+}
+function createFieldArgs(from, key, fieldSchema) {
+    return new args_1.ArgsClass({
+        key,
+        value: from.value[key],
+        // @ts-ignore needs key
+        fieldSchema,
+    }, from);
+}
+function getFieldParser(args) {
+    const fieldParser = 'enum' in args.fieldSchema
+        ? args.root._opts.parsers.fields.enum
+        : args.root._opts.parsers.fields[args.fieldSchema.type];
+    return fieldParser;
+}
+async function parse(args) {
+    const opts = args.root._opts;
+    if (args.parseTopLevel) {
+        const parser = opts.parsers.any;
+        if (parser) {
+            const nArgs = await parser(args);
+            if (nArgs) {
+                // @ts-ignore
+                return parse(createOrUseArgs(args, nArgs));
+            }
+        }
+    }
+    if (typeof args.value === 'object' && args.value !== null) {
+        const keyQ = [];
+        const keysHandled = new Set();
+        let allKeysHandled = false;
+        for (const key in opts.parsers.keys) {
+            if (key in args.value) {
+                keysHandled.add(key);
+                keyQ.push(parseKey(args, key, opts.parsers.keys[key]));
+            }
+        }
+        await Promise.all(keyQ);
+        if (typeof args.value !== 'object' || args.value === null) {
+            return;
+        }
+        // schema
+        if (args.stopped === undefined) {
+            const fieldQ = [];
+            if (args.typeSchema && !args.fieldSchema) {
+                for (const key in args.typeSchema.fields) {
+                    const fieldSchema = args.typeSchema.fields[key];
+                    if (key in args.value) {
+                        keysHandled.add(key);
+                        fieldQ.push(createFieldArgs(args, key, fieldSchema).parse());
+                    }
+                }
+            }
+            else if (args.fieldSchema && !args.stopped) {
+                if (args.fieldSchema.type === 'object') {
+                    // @ts-ignore should detect from line above
+                    const objFieldSchema = args.fieldSchema;
+                    for (const key in objFieldSchema.properties) {
+                        const fieldSchema = objFieldSchema.properties[key];
+                        if (key in args.value) {
+                            keysHandled.add(key);
+                            fieldQ.push(createFieldArgs(args, key, fieldSchema).parse());
+                        }
+                    }
+                }
+                else if (args.fieldSchema.type === 'record') {
+                    // @ts-ignore should detect from line above
+                    const objFieldSchema = args.fieldSchema;
+                    for (const key in args.value) {
+                        const fieldSchema = objFieldSchema.values;
+                        keysHandled.add(key);
+                        fieldQ.push(createFieldArgs(args, key, fieldSchema).parse());
+                    }
+                }
+                else if (args.fieldSchema) {
+                    const fieldParser = getFieldParser(args);
+                    if (fieldParser) {
+                        const newArgs = createOrUseArgs(args, await fieldParser(args));
+                        if (newArgs) {
+                            return newArgs.parse();
+                        }
+                    }
+                }
+            }
+            await Promise.all(fieldQ);
+            if (args.fieldSchema &&
+                fieldQ.length > 0 &&
+                (args.fieldSchema.type === 'object' ||
+                    args.fieldSchema.type === 'record')) {
+                const fieldParser = getFieldParser(args);
+                if (fieldParser) {
+                    fieldParser(args);
+                }
+            }
+        }
+        if (typeof args.value !== 'object' || args.value === null) {
+            return;
+        }
+        // any
+        if (args.stopped !== types_1.Stopped.stopAll) {
+            const parser = opts.parsers.any || opts.parsers.catch;
+            if (parser) {
+                const q = [];
+                if (Array.isArray(args.value)) {
+                    for (let i = 0; i < args.value.length; i++) {
+                        if ((!opts.parsers.any && keysHandled.has(i)) || allKeysHandled) {
+                            continue;
+                        }
+                        q.push(parseKey(args, i, parser));
+                    }
+                }
+                else {
+                    for (const key in args.value) {
+                        if ((!opts.parsers.any && keysHandled.has(key)) || allKeysHandled) {
+                            continue;
+                        }
+                        q.push(parseKey(args, key, parser));
+                    }
+                }
+                await Promise.all(q);
+            }
+        }
+        if (opts.backtrack &&
+            !args.skipCollection &&
+            (args.fromBackTrack.length || args.collectedCommands.length)) {
+            const backtracked = opts.backtrack(args, args.fromBackTrack ?? [], args.collectedCommands ?? []);
+            if (backtracked) {
+                const target = args.getBackTrackTarget();
+                if (!target.fromBackTrack) {
+                    target.fromBackTrack = [];
+                }
+                target.fromBackTrack.push(backtracked);
+            }
+        }
+    }
+    else {
+        // more
+        if (args.fieldSchema) {
+            const fieldParser = getFieldParser(args);
+            if (fieldParser) {
+                const newArgs = createOrUseArgs(args, await fieldParser(args));
+                if (newArgs) {
+                    return newArgs.parse();
+                }
+            }
+            else {
+                console.warn('fieldSchema type not implemented yet!', args.fieldSchema);
+                const anyParser = opts.parsers.any || opts.parsers.catch;
+                anyParser(args);
+            }
+        }
+        else {
+        }
+    }
+}
+exports.parse = parse;
+//# sourceMappingURL=parse.js.map

package/dist/walker/types.d.ts

@@ -0,0 +1,45 @@
+import { ParseError } from '../error';
+import { BasedSchemaType, BasedSchemaFields, BasedSchemaField, BasedSchema } from '../types';
+import { ArgsClass } from './args';
+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;
+export type FieldParser<K extends keyof BasedSchemaFields, T = any> = (args: ArgsClass<T, K>) => Promise<ArgsClass<T> | ArgsOpts<T> | void>;
+export type KeyParser<T = any> = (args: ArgsClass<T, keyof BasedSchemaFields>) => Promise<ArgsOpts<T> | ArgsClass<T> | void>;
+export type FieldParsers<T = any> = {
+    [Key in keyof BasedSchemaFields]: FieldParser<Key, T>;
+};
+export type AsyncOperation<T> = (args: ArgsClass<T>, type?: string) => Promise<any>;
+export type Opts<T> = {
+    init: (value: any, schema: BasedSchema, error: ErrorHandler<T>) => Promise<ArgsOpts<T>>;
+    parsers: {
+        fields: Partial<{
+            [Key in keyof BasedSchemaFields]: FieldParser<Key, T>;
+        }>;
+        keys: {
+            [key: string]: KeyParser<T>;
+        };
+        any?: KeyParser<T>;
+        catch?: KeyParser<T>;
+    };
+    collect?: (args: ArgsClass<T>) => any;
+    error?: ErrorHandler<T>;
+    backtrack?: (args: ArgsClass<T>, fromBackTrack: any[], collectedCommands: any[]) => any;
+    asyncOperationHandler?: AsyncOperation<T>;
+};
+export declare enum Stopped {
+    onlyStopFieldParser = 0,
+    stopAll = 1
+}
+export type ArgsOpts<T, K extends keyof BasedSchemaFields = keyof BasedSchemaFields> = {
+    parseTopLevel?: boolean;
+    target?: T;
+    key?: string | number;
+    path?: Path;
+    value?: any;
+    prev?: ArgsClass<T, K>;
+    fieldSchema?: BasedSchemaField;
+    typeSchema?: BasedSchemaType;
+    skipCollection?: boolean;
+    collect?: (args: ArgsClass<T, K>, value?: any) => any;
+};

package/dist/walker/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@based/schema",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "license": "MIT",
   "main": "dist/src/index.js",
   "files": [