@based/schema 3.2.0 → 4.1.0

package/dist/index.d.ts

@@ -1,5 +1,3 @@
-export * from './types';
-export * from './validateSchema';
-export * from './walker';
-export * from './set';
-export * from './display';
+export * from './types.js';
+export * from './parse/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,22 +1,3 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./types"), exports);
-__exportStar(require("./validateSchema"), exports);
-__exportStar(require("./walker"), exports);
-__exportStar(require("./set"), exports);
-__exportStar(require("./display"), exports);
+export * from './types.js';
+export * from './parse/index.js';
 //# sourceMappingURL=index.js.map

package/dist/parse/assert.d.ts

@@ -0,0 +1,7 @@
+export declare const expectObject: (obj: any) => void;
+export declare const expectString: (obj: any) => void;
+export declare const expectBoolean: (v: any) => void;
+export declare const expectFunction: (v: any) => void;
+export declare const expectNumber: (v: any) => void;
+export declare const expectPositiveNumber: (v: any) => void;
+//# sourceMappingURL=assert.d.ts.map

package/dist/parse/assert.js

@@ -0,0 +1,33 @@
+import { EXPECTED_BOOL, EXPECTED_FN, EXPECTED_NUM, EXPECTED_OBJ, EXPECTED_STR, } from './errors.js';
+export const expectObject = (obj) => {
+    if (typeof obj !== 'object' || obj === null) {
+        throw Error(EXPECTED_OBJ);
+    }
+};
+export const expectString = (obj) => {
+    if (typeof obj !== 'string') {
+        throw Error(EXPECTED_STR);
+    }
+};
+export const expectBoolean = (v) => {
+    if (v !== true && v !== false) {
+        throw Error(EXPECTED_BOOL);
+    }
+};
+export const expectFunction = (v) => {
+    if (typeof v !== 'function') {
+        throw Error(EXPECTED_FN);
+    }
+};
+export const expectNumber = (v) => {
+    if (typeof v !== 'number') {
+        throw Error(EXPECTED_NUM);
+    }
+};
+export const expectPositiveNumber = (v) => {
+    expectNumber(v);
+    if (v < 0) {
+        throw Error('Expected positive number');
+    }
+};
+//# sourceMappingURL=assert.js.map

package/dist/parse/errors.d.ts

@@ -0,0 +1,19 @@
+export declare const OUT_OF_RANGE = "Value is out of range";
+export declare const EXPECTED_VALUE_IN_ENUM = "Expected value in \"enum\" field";
+export declare const EXPECTED_DATE = "Expected number or Date";
+export declare const EXPECTED_BOOL = "Expected boolean";
+export declare const EXPECTED_OBJ = "Expected object";
+export declare const EXPECTED_ARR = "Expected array";
+export declare const EXPECTED_NUM = "Expected number";
+export declare const EXPECTED_STR = "Expected string";
+export declare const EXPECTED_FN = "Expected function";
+export declare const EXPECTED_PRIMITIVE = "Expected primitive value";
+export declare const INVALID_VALUE = "Invalid value";
+export declare const INVALID_SCHEMA = "Invalid schema";
+export declare const MIN_MAX = "Max value must be larger than min value";
+export declare const UNKNOWN_PROP = "Unknown property";
+export declare const MISSING_TYPE = "Missing type";
+export declare const INVALID_TYPE = "Invalid type";
+export declare const TEXT_REQUIRES_LOCALES = "Type text requires locales";
+export declare const TYPE_MISMATCH = "Types do not match";
+//# sourceMappingURL=errors.d.ts.map

package/dist/parse/errors.js

@@ -0,0 +1,19 @@
+export const OUT_OF_RANGE = 'Value is out of range';
+export const EXPECTED_VALUE_IN_ENUM = 'Expected value in "enum" field';
+export const EXPECTED_DATE = 'Expected number or Date';
+export const EXPECTED_BOOL = 'Expected boolean';
+export const EXPECTED_OBJ = 'Expected object';
+export const EXPECTED_ARR = 'Expected array';
+export const EXPECTED_NUM = 'Expected number';
+export const EXPECTED_STR = 'Expected string';
+export const EXPECTED_FN = 'Expected function';
+export const EXPECTED_PRIMITIVE = 'Expected primitive value';
+export const INVALID_VALUE = 'Invalid value';
+export const INVALID_SCHEMA = 'Invalid schema';
+export const MIN_MAX = 'Max value must be larger than min value';
+export const UNKNOWN_PROP = 'Unknown property';
+export const MISSING_TYPE = 'Missing type';
+export const INVALID_TYPE = 'Invalid type';
+export const TEXT_REQUIRES_LOCALES = 'Type text requires locales';
+export const TYPE_MISMATCH = 'Types do not match';
+//# sourceMappingURL=errors.js.map

package/dist/parse/index.d.ts

@@ -0,0 +1,20 @@
+import { Schema, SchemaType } from '../types.js';
+import { getPropType } from './utils.js';
+export { getPropType };
+export declare class SchemaParser {
+    constructor(schema: Schema);
+    inQuery: boolean;
+    schema: Schema;
+    type: SchemaType;
+    parseType(type: SchemaType): void;
+    parseTypes(): void;
+    parseProps(props: any, schemaType?: SchemaType): void;
+    parseLocales(): void;
+    parse(): void;
+}
+export declare const print: (schema: Schema, path: string[]) => string;
+export declare const debug: (schema: Schema) => void;
+export declare const parse: (schema: Schema) => {
+    schema: Schema;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/parse/index.js

@@ -0,0 +1,132 @@
+import { INVALID_VALUE, UNKNOWN_PROP } from './errors.js';
+import { getPropType } from './utils.js';
+import propParsers from './props.js';
+import pc from 'picocolors';
+import { expectBoolean, expectObject } from './assert.js';
+export { getPropType };
+export class SchemaParser {
+    constructor(schema) {
+        this.schema = schema;
+    }
+    inQuery;
+    schema;
+    type;
+    parseType(type) {
+        expectObject(type);
+        this.parseProps(type.props, type);
+    }
+    parseTypes() {
+        const { types } = this.schema;
+        expectObject(types);
+        for (const type in types) {
+            this.parseType(types[type]);
+        }
+    }
+    parseProps(props, schemaType = null) {
+        expectObject(props);
+        this.type = schemaType;
+        for (const key in props) {
+            const prop = props[key];
+            const type = getPropType(prop);
+            if (type in propParsers) {
+                propParsers[type](prop, this);
+            }
+            else {
+                throw Error(INVALID_VALUE);
+            }
+        }
+    }
+    parseLocales() {
+        const { locales } = this.schema;
+        expectObject(locales);
+        for (const locale in locales) {
+            const opts = locales[locale];
+            expectObject(opts);
+            for (const key in opts) {
+                const val = opts[key];
+                if (key === 'required') {
+                    expectBoolean(val);
+                }
+                else if (key === 'fallback') {
+                    if (!Array.isArray(val) || !val.every((v) => typeof v === 'string')) {
+                        throw Error(INVALID_VALUE);
+                    }
+                }
+                else {
+                    throw Error(UNKNOWN_PROP);
+                }
+            }
+        }
+    }
+    parse() {
+        expectObject(this.schema);
+        for (const key in this.schema) {
+            if (key === 'types') {
+                this.parseTypes();
+            }
+            else if (key === 'props') {
+                this.parseProps(this.schema.props);
+            }
+            else if (key === 'locales') {
+                this.parseLocales();
+            }
+            else {
+                throw Error(UNKNOWN_PROP);
+            }
+        }
+    }
+}
+export const print = (schema, path) => {
+    let obj = schema;
+    const depth = path.length - 1;
+    const lines = path.map((key, lvl) => {
+        const v = obj[key];
+        const padding = '  '.repeat(lvl);
+        const prefix = key === Object.keys(obj)[0] ? '' : `${padding}...\n`;
+        if (lvl === depth) {
+            const err = key in obj
+                ? `${key}: ${typeof v === 'object' && v !== null && !Array.isArray(v) ? `{..}` : JSON.stringify(v)}`
+                : key;
+            return `${prefix}${'--'.repeat(lvl - 1)}> ${pc.red(err)}`;
+        }
+        obj = v;
+        return `${prefix}${padding}${key}: {`;
+    });
+    return lines.join('\n');
+};
+export const debug = (schema) => {
+    let curr;
+    const proxy = (obj, path = []) => {
+        const copy = {};
+        return new Proxy(obj, {
+            get(_, key) {
+                const v = obj[key];
+                curr = [...path, key];
+                if (typeof v !== 'object' || v === null) {
+                    return v;
+                }
+                copy[key] ??= proxy(obj[key], curr);
+                return copy[key];
+            },
+        });
+    };
+    const parser = new SchemaParser(proxy(schema));
+    try {
+        parser.parse();
+    }
+    catch (e) {
+        e.message += '\n\n' + print(schema, curr) + '\n';
+        e.cause = curr;
+        throw e;
+    }
+};
+export const parse = (schema) => {
+    try {
+        new SchemaParser(schema).parse();
+        return { schema };
+    }
+    catch (e) {
+        debug(schema);
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/parse/props.d.ts

@@ -0,0 +1,7 @@
+import { SchemaAnyProp } from '../types.js';
+import type { SchemaParser } from './index.js';
+type PropsFns<PropType> = Record<string, (val: any, prop: PropType, ctx: SchemaParser, key?: string) => void>;
+declare function propParser<PropType extends SchemaAnyProp>(required: PropsFns<PropType>, optional: PropsFns<PropType>, allowShorthand?: number): (prop: any, ctx: SchemaParser) => void;
+declare const p: Record<string, ReturnType<typeof propParser>>;
+export default p;
+//# sourceMappingURL=props.d.ts.map

package/dist/parse/props.js

@@ -0,0 +1,290 @@
+import { expectBoolean, expectFunction, expectObject, expectString, expectNumber, } from './assert.js';
+import { EXPECTED_ARR, EXPECTED_DATE, EXPECTED_OBJ, EXPECTED_PRIMITIVE, EXPECTED_VALUE_IN_ENUM, INVALID_VALUE, MIN_MAX, OUT_OF_RANGE, TEXT_REQUIRES_LOCALES, TYPE_MISMATCH, UNKNOWN_PROP, } from './errors.js';
+import { getPropType } from './utils.js';
+const STUB = {};
+const shared = {
+    type() { },
+    required(val) {
+        expectBoolean(val);
+    },
+    query(val) {
+        expectFunction(val);
+    },
+    path(val, prop, ctx) {
+        expectString(val);
+        const path = val.split('.');
+        let t = ctx.type;
+        for (const key of path) {
+            if ('items' in t) {
+                t = t.items;
+            }
+            if ('ref' in t) {
+                t = ctx.schema.types[t.ref];
+            }
+            t = t.props[key];
+            expectObject(t);
+        }
+        if (t.type !== getPropType(prop)) {
+            throw Error(TYPE_MISMATCH);
+        }
+    },
+};
+function propParser(required, optional, allowShorthand) {
+    return (prop, ctx) => {
+        if (typeof prop === 'string') {
+            // allow string
+            if (allowShorthand === 0) {
+                return;
+            }
+            throw Error(EXPECTED_OBJ);
+        }
+        if (Array.isArray(prop)) {
+            // allow array
+            if (allowShorthand === 1) {
+                return;
+            }
+            throw Error(EXPECTED_OBJ);
+        }
+        for (const key in required) {
+            required[key](prop[key], prop, ctx);
+        }
+        for (const key in prop) {
+            const val = prop[key];
+            if (key in optional) {
+                optional[key](val, prop, ctx);
+            }
+            else if (key in shared) {
+                shared[key](val, prop, ctx);
+            }
+            else if (!(key in required)) {
+                if (key[0] === '$' && 'ref' in prop) {
+                    optional.edge(val, prop, ctx, key);
+                }
+                else {
+                    throw Error(UNKNOWN_PROP);
+                }
+            }
+        }
+    };
+}
+const p = {};
+p.alias = propParser(STUB, {
+    default(val) {
+        expectString(val);
+    },
+}, 0);
+p.boolean = propParser(STUB, {
+    default(val) {
+        expectBoolean(val);
+    },
+}, 0);
+p.enum = propParser({
+    enum(items) {
+        if (!Array.isArray(items)) {
+            throw Error(EXPECTED_ARR);
+        }
+        if (items.length > 255) {
+            throw Error('Max enum length (255) exceeded');
+        }
+        for (const item of items) {
+            if (typeof item === 'object') {
+                throw Error(EXPECTED_PRIMITIVE);
+            }
+        }
+    },
+}, {
+    default(val, prop) {
+        if (!prop.enum.includes(val)) {
+            throw Error(EXPECTED_VALUE_IN_ENUM);
+        }
+    },
+}, 1);
+const numberOpts = {
+    min(val) {
+        expectNumber(val);
+    },
+    max(val, prop) {
+        expectNumber(val);
+        if (prop.min > val) {
+            throw Error(MIN_MAX);
+        }
+    },
+    step(val) {
+        if (typeof val !== 'number' && val !== 'any') {
+            throw Error(INVALID_VALUE);
+        }
+    },
+    default(val, prop) {
+        expectNumber(val);
+        if (val > prop.max || val < prop.min) {
+            throw Error(OUT_OF_RANGE);
+        }
+        if (prop.step !== 'any') {
+            const min = typeof prop.min !== 'number' || prop.min === Infinity ? 0 : prop.min;
+            const v = val - min;
+            if (~~(v / prop.step) * prop.step !== v) {
+                throw Error(INVALID_VALUE);
+            }
+        }
+    },
+};
+p.number = propParser(STUB, numberOpts, 0);
+p.int8 = propParser(STUB, numberOpts, 0);
+p.uint8 = propParser(STUB, numberOpts, 0);
+p.int16 = propParser(STUB, numberOpts, 0);
+p.uint16 = propParser(STUB, numberOpts, 0);
+p.int32 = propParser(STUB, numberOpts, 0);
+p.uint32 = propParser(STUB, numberOpts, 0);
+p.object = propParser({
+    props(val, prop, ctx) {
+        ctx.parseProps(val, ctx.type);
+    },
+}, {
+    default(val) {
+        console.warn('TODO object default value');
+    },
+});
+p.reference = propParser({
+    ref(ref, _prop, { schema }) {
+        schema.types[ref].props;
+    },
+    prop(propKey, prop, { schema, type, inQuery }) {
+        const propAllowed = type && !inQuery;
+        if (propAllowed) {
+            expectString(propKey);
+            const propPath = propKey.split('.');
+            let targetProp = schema.types[prop.ref];
+            for (const key of propPath) {
+                targetProp = targetProp.props[key];
+            }
+            if ('items' in targetProp) {
+                targetProp = targetProp.items;
+            }
+            if ('ref' in targetProp && 'prop' in targetProp) {
+                const inversePath = targetProp.prop.split('.');
+                let inverseProp = schema.types[targetProp.ref];
+                for (const key of inversePath) {
+                    inverseProp = inverseProp.props[key];
+                }
+                if ('items' in inverseProp) {
+                    inverseProp = inverseProp.items;
+                }
+                if (inverseProp === prop) {
+                    return;
+                }
+            }
+            throw Error(INVALID_VALUE);
+        }
+        if (propKey !== undefined) {
+            throw Error('ref prop not supported on root or edge p');
+        }
+    },
+}, {
+    default(val) {
+        expectString(val);
+    },
+    edge(val, prop, ctx, key) {
+        const edgeAllowed = ctx.type && !ctx.inQuery;
+        if (edgeAllowed) {
+            let t = ctx.schema.types[prop.ref].props[prop.prop];
+            t = t.items || t;
+            if (t[key]) {
+                throw Error('Edge can not be defined on both props');
+            }
+            const edgePropType = getPropType(val);
+            const inType = ctx.type;
+            ctx.type = null;
+            p[edgePropType](val, ctx);
+            ctx.type = inType;
+            return;
+        }
+        throw Error('ref edge not supported on root or edge p');
+    },
+});
+p.set = propParser({
+    items(items, prop, ctx) {
+        expectObject(items);
+        const itemsType = getPropType(items);
+        if (itemsType === 'string' ||
+            itemsType === 'number' ||
+            itemsType === 'timestamp' ||
+            itemsType === 'boolean') {
+            ctx.inQuery = 'query' in prop;
+            p[itemsType](items, ctx);
+            ctx.inQuery = false;
+        }
+        else {
+            throw new Error(INVALID_VALUE);
+        }
+    },
+}, {
+    default(val, prop) {
+        console.warn('TODO SET DEFAULT VALUE');
+        // if (typeof val === 'object') {
+        //   throwErr(ERRORS.EXPECTED_PRIMITIVE, prop, 'default')
+        // }
+    },
+});
+p.references = propParser({
+    items(items, prop, ctx) {
+        expectObject(items);
+        const itemsType = getPropType(items);
+        if (itemsType === 'reference') {
+            ctx.inQuery = 'query' in prop;
+            p[itemsType](items, ctx);
+            ctx.inQuery = false;
+        }
+        else {
+            throw new Error(INVALID_VALUE);
+        }
+    },
+}, {
+    default(val, prop) {
+        console.warn('TODO SET DEFAULT VALUE');
+        // if (typeof val === 'object') {
+        //   throwErr(ERRORS.EXPECTED_PRIMITIVE, prop, 'default')
+        // }
+    },
+});
+p.string = propParser(STUB, {
+    default(val) {
+        expectString(val);
+    },
+    maxBytes(val) {
+        expectNumber(val);
+    },
+    min(val) {
+        expectNumber(val);
+    },
+    max(val) {
+        expectNumber(val);
+    },
+}, 0);
+p.text = propParser({
+    type(_val, _prop, { schema }) {
+        if (schema.locales) {
+            for (const _ in schema.locales) {
+                return;
+            }
+        }
+        throw Error(TEXT_REQUIRES_LOCALES);
+    },
+}, {
+    default(val, prop) {
+        console.warn('MAKE DEFAULT VALUE FOR TEXT');
+    },
+}, 0);
+p.timestamp = propParser(STUB, {
+    default(val) {
+        if (typeof val !== 'number' && !(val instanceof Date)) {
+            throw Error(EXPECTED_DATE);
+        }
+    },
+    on(val) {
+        if (val !== 'create' && val !== 'update') {
+            throw Error(INVALID_VALUE);
+        }
+    },
+}, 0);
+export default p;
+//# sourceMappingURL=props.js.map

package/dist/parse/utils.d.ts

@@ -0,0 +1,3 @@
+import { SchemaAnyProp, SchemaPropTypes } from '../types.js';
+export declare const getPropType: (prop: SchemaAnyProp) => SchemaPropTypes;
+//# sourceMappingURL=utils.d.ts.map

package/dist/parse/utils.js

@@ -0,0 +1,29 @@
+import { INVALID_TYPE, MISSING_TYPE } from './errors.js';
+export const getPropType = (prop) => {
+    if (typeof prop === 'string') {
+        return prop;
+    }
+    if ('type' in prop) {
+        if (typeof prop.type !== 'string') {
+            throw Error(INVALID_TYPE);
+        }
+        return prop.type;
+    }
+    if ('ref' in prop) {
+        return 'reference';
+    }
+    if ('items' in prop) {
+        if (getPropType(prop.items) === 'reference') {
+            return 'references';
+        }
+        return 'set';
+    }
+    if ('props' in prop) {
+        return 'object';
+    }
+    if ('enum' in prop || Array.isArray(prop)) {
+        return 'enum';
+    }
+    throw Error(MISSING_TYPE);
+};
+//# sourceMappingURL=utils.js.map

package/dist/parsePayload/index.d.ts

@@ -0,0 +1,3 @@
+import { Schema } from '../types.js';
+export declare const parsePayload: (payload: any, schema: Schema, type?: string) => void;
+//# sourceMappingURL=index.d.ts.map

package/dist/parsePayload/index.js

@@ -0,0 +1,2 @@
+export const parsePayload = (payload, schema, type) => { };
+//# sourceMappingURL=index.js.map

package/dist/parseSchema/assert.d.ts

@@ -0,0 +1,6 @@
+export declare const expectObject: (obj: any) => void;
+export declare const expectString: (obj: any) => void;
+export declare const expectBoolean: (v: any) => void;
+export declare const expectFunction: (v: any) => void;
+export declare const expectNumber: (v: any) => void;
+//# sourceMappingURL=assert.d.ts.map

package/dist/parseSchema/assert.js

@@ -0,0 +1,27 @@
+import { EXPECTED_BOOL, EXPECTED_FN, EXPECTED_NUM, EXPECTED_OBJ, EXPECTED_STR, } from './errors.js';
+export const expectObject = (obj) => {
+    if (typeof obj !== 'object' || obj === null) {
+        throw Error(EXPECTED_OBJ);
+    }
+};
+export const expectString = (obj) => {
+    if (typeof obj !== 'string') {
+        throw Error(EXPECTED_STR);
+    }
+};
+export const expectBoolean = (v) => {
+    if (v !== true && v !== false) {
+        throw Error(EXPECTED_BOOL);
+    }
+};
+export const expectFunction = (v) => {
+    if (typeof v !== 'function') {
+        throw Error(EXPECTED_FN);
+    }
+};
+export const expectNumber = (v) => {
+    if (typeof v !== 'number') {
+        throw Error(EXPECTED_NUM);
+    }
+};
+//# sourceMappingURL=assert.js.map

package/dist/parseSchema/errors.d.ts

@@ -0,0 +1,19 @@
+export declare const OUT_OF_RANGE = "Value is out of range";
+export declare const EXPECTED_VALUE_IN_ENUM = "Expected value in \"enum\" field";
+export declare const EXPECTED_DATE = "Expected number or Date";
+export declare const EXPECTED_BOOL = "Expected boolean";
+export declare const EXPECTED_OBJ = "Expected object";
+export declare const EXPECTED_ARR = "Expected array";
+export declare const EXPECTED_NUM = "Expected number";
+export declare const EXPECTED_STR = "Expected string";
+export declare const EXPECTED_FN = "Expected function";
+export declare const EXPECTED_PRIMITIVE = "Expected primitive value";
+export declare const INVALID_VALUE = "Invalid value";
+export declare const INVALID_SCHEMA = "Invalid schema";
+export declare const MIN_MAX = "Max value must be larger than min value";
+export declare const UNKNOWN_PROP = "Unknown property";
+export declare const MISSING_TYPE = "Missing type";
+export declare const INVALID_TYPE = "Invalid type";
+export declare const TEXT_REQUIRES_LOCALES = "Type text requires locales";
+export declare const TYPE_MISMATCH = "Types do not match";
+//# sourceMappingURL=errors.d.ts.map