@based/schema 4.1.1 → 5.0.0-alpha.1

package/dist/parse/index.js

@@ -1,4 +1,4 @@
-import { INVALID_VALUE, UNKNOWN_PROP } from './errors.js';
+import { INVALID_KEY, INVALID_VALUE, UNKNOWN_PROP } from './errors.js';
 import { getPropType } from './utils.js';
 import propParsers from './props.js';
 import pc from 'picocolors';
@@ -8,33 +8,55 @@ export class SchemaParser {
     constructor(schema) {
         this.schema = schema;
     }
+    isItems;
     inQuery;
     schema;
     type;
-    parseType(type) {
-        expectObject(type);
-        this.parseProps(type.props, type);
-    }
+    path = [];
+    lvl = 0;
     parseTypes() {
+        this.path[this.lvl++] = 'types';
         const { types } = this.schema;
         expectObject(types);
         for (const type in types) {
-            this.parseType(types[type]);
+            this.lvl++;
+            if (type[0] === '_') {
+                throw new Error(INVALID_KEY);
+            }
+            this.path[this.lvl] = type;
+            expectObject(types[type]);
+            if (!('props' in types[type])) {
+                types[type] = { props: types[type] };
+            }
+            this.lvl--;
+        }
+        for (const type in types) {
+            this.path[this.lvl++] = type;
+            this.parseProps(types[type].props, types[type]);
+            this.lvl--;
         }
+        this.lvl--;
     }
     parseProps(props, schemaType = null) {
+        this.path[this.lvl++] = 'props';
         expectObject(props);
         this.type = schemaType;
         for (const key in props) {
+            if (key[0] === '_') {
+                throw new Error(INVALID_KEY);
+            }
             const prop = props[key];
-            const type = getPropType(prop);
+            const type = getPropType(prop, props, key);
+            this.path[this.lvl++] = key;
             if (type in propParsers) {
                 propParsers[type](prop, this);
             }
             else {
                 throw Error(INVALID_VALUE);
             }
+            this.lvl--;
         }
+        this.lvl--;
     }
     parseLocales() {
         const { locales } = this.schema;
@@ -60,17 +82,18 @@ export class SchemaParser {
     }
     parse() {
         expectObject(this.schema);
+        // always do types first because it removes props shorthand
+        if ('types' in this.schema) {
+            this.parseTypes();
+        }
         for (const key in this.schema) {
-            if (key === 'types') {
-                this.parseTypes();
-            }
-            else if (key === 'props') {
+            if (key === 'props') {
                 this.parseProps(this.schema.props);
             }
             else if (key === 'locales') {
                 this.parseLocales();
             }
-            else {
+            else if (key !== 'types') {
                 throw Error(UNKNOWN_PROP);
             }
         }
@@ -83,7 +106,7 @@ export const print = (schema, path) => {
         const v = obj[key];
         const padding = '  '.repeat(lvl);
         const prefix = key === Object.keys(obj)[0] ? '' : `${padding}...\n`;
-        if (lvl === depth) {
+        if (lvl === depth && lvl !== 0) {
             const err = key in obj
                 ? `${key}: ${typeof v === 'object' && v !== null && !Array.isArray(v) ? `{..}` : JSON.stringify(v)}`
                 : key;
@@ -94,39 +117,18 @@ export const print = (schema, path) => {
     });
     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) => {
+    const parser = new SchemaParser(schema);
     try {
-        new SchemaParser(schema).parse();
+        parser.parse();
+        // @ts-ignore
         return { schema };
     }
     catch (e) {
-        debug(schema);
+        const cause = parser.path.slice(0, Math.min(4, parser.lvl) + 1);
+        e.message += '\n\n' + print(schema, cause) + '\n';
+        e.cause = cause;
+        throw e;
     }
 };
 //# sourceMappingURL=index.js.map

package/dist/parse/props.js

@@ -1,10 +1,20 @@
-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 { stringFormats, dateDisplays, numberDisplays, } from '../types.js';
+import { expectBoolean, expectFloat32Array, expectFunction, expectNumber, expectObject, expectString, } from './assert.js';
+import { EXPECTED_ARR, EXPECTED_DATE, EXPECTED_OBJ, EXPECTED_PRIMITIVE, EXPECTED_VALUE_IN_ENUM, INVALID_VALUE, MIN_MAX, MISSING_TYPE, OUT_OF_RANGE, TEXT_REQUIRES_LOCALES, TYPE_MISMATCH, UNKNOWN_PROP, NOT_ALLOWED_IN_ITEMS, } from './errors.js';
 import { getPropType } from './utils.js';
+let stringFormatsSet;
+let numberDisplaysSet;
+let dateDisplaysSet;
 const STUB = {};
 const shared = {
     type() { },
-    required(val) {
+    role(val) {
+        expectString(val);
+    },
+    required(val, _prop, ctx) {
+        if (ctx.isItems) {
+            throw new Error(NOT_ALLOWED_IN_ITEMS);
+        }
         expectBoolean(val);
     },
     query(val) {
@@ -28,6 +38,10 @@ const shared = {
             throw Error(TYPE_MISMATCH);
         }
     },
+    title(val) { },
+    description(val) { },
+    readOnly(val) { },
+    examples(val) { },
 };
 function propParser(required, optional, allowShorthand) {
     return (prop, ctx) => {
@@ -46,15 +60,21 @@ function propParser(required, optional, allowShorthand) {
             throw Error(EXPECTED_OBJ);
         }
         for (const key in required) {
-            required[key](prop[key], prop, ctx);
+            ctx.path[ctx.lvl] = key;
+            const changed = required[key](prop[key], prop, ctx);
+            if (changed !== undefined) {
+                prop[key] = changed;
+            }
         }
         for (const key in prop) {
+            ctx.path[ctx.lvl] = key;
             const val = prop[key];
+            let changed;
             if (key in optional) {
-                optional[key](val, prop, ctx);
+                changed = optional[key](val, prop, ctx);
             }
             else if (key in shared) {
-                shared[key](val, prop, ctx);
+                changed = shared[key](val, prop, ctx);
             }
             else if (!(key in required)) {
                 if (key[0] === '$' && 'ref' in prop) {
@@ -64,18 +84,25 @@ function propParser(required, optional, allowShorthand) {
                     throw Error(UNKNOWN_PROP);
                 }
             }
+            if (changed !== undefined) {
+                prop[key] = changed;
+            }
         }
     };
 }
 const p = {};
-p.alias = propParser(STUB, {
+p.boolean = propParser(STUB, {
     default(val) {
-        expectString(val);
+        expectBoolean(val);
     },
 }, 0);
-p.boolean = propParser(STUB, {
+p.vector = propParser({
+    size(val) {
+        expectNumber(val);
+    },
+}, {
     default(val) {
-        expectBoolean(val);
+        expectFloat32Array(val);
     },
 }, 0);
 p.enum = propParser({
@@ -100,6 +127,11 @@ p.enum = propParser({
     },
 }, 1);
 const numberOpts = {
+    display(val) {
+        expectString(val);
+        numberDisplaysSet ??= new Set(numberDisplays);
+        numberDisplaysSet.has(val);
+    },
     min(val) {
         expectNumber(val);
     },
@@ -144,63 +176,6 @@ p.object = propParser({
         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);
@@ -210,8 +185,10 @@ p.set = propParser({
             itemsType === 'timestamp' ||
             itemsType === 'boolean') {
             ctx.inQuery = 'query' in prop;
+            ctx.isItems = true;
             p[itemsType](items, ctx);
             ctx.inQuery = false;
+            ctx.isItems = false;
         }
         else {
             throw new Error(INVALID_VALUE);
@@ -231,8 +208,10 @@ p.references = propParser({
         const itemsType = getPropType(items);
         if (itemsType === 'reference') {
             ctx.inQuery = 'query' in prop;
+            ctx.isItems = true;
             p[itemsType](items, ctx);
             ctx.inQuery = false;
+            ctx.isItems = false;
         }
         else {
             throw new Error(INVALID_VALUE);
@@ -246,21 +225,34 @@ p.references = propParser({
         // }
     },
 });
-p.binary = propParser(STUB, {
+const binaryOpts = {
     default(val) {
-        return val instanceof ArrayBuffer;
-    },
-    maxBytes(val) {
-        expectNumber(val);
+        expectString(val);
     },
-}, 0);
-p.string = propParser(STUB, {
-    default(val) {
+    format(val) {
         expectString(val);
+        stringFormatsSet ??= new Set(stringFormats);
+        stringFormatsSet.has(val);
+    },
+    mime(val) {
+        if (Array.isArray(val)) {
+            val.forEach(expectString);
+        }
+        else {
+            expectString(val);
+        }
     },
     maxBytes(val) {
         expectNumber(val);
     },
+    compression(val) {
+        // return the actualy string!
+        return val;
+    },
+};
+p.binary = propParser(STUB, binaryOpts, 0);
+p.string = propParser(STUB, {
+    ...binaryOpts,
     min(val) {
         expectNumber(val);
     },
@@ -283,6 +275,11 @@ p.text = propParser({
     },
 }, 0);
 p.timestamp = propParser(STUB, {
+    display(val) {
+        expectString(val);
+        dateDisplaysSet ??= new Set(dateDisplays);
+        dateDisplaysSet.has(val);
+    },
     default(val) {
         if (typeof val !== 'number' && !(val instanceof Date)) {
             throw Error(EXPECTED_DATE);
@@ -294,5 +291,101 @@ p.timestamp = propParser(STUB, {
         }
     },
 }, 0);
+p.reference = propParser({
+    ref(ref, _prop, { schema }) {
+        if (!schema.types[ref]?.props) {
+            throw Error(MISSING_TYPE);
+        }
+    },
+    prop(propKey, prop, { schema, type, inQuery, path }) {
+        const propAllowed = type && !inQuery;
+        if (propAllowed) {
+            expectString(propKey);
+            const propPath = propKey.split('.');
+            let targetProp = schema.types[prop.ref];
+            expectObject(targetProp, 'expected type');
+            let create;
+            for (const key of propPath) {
+                if (!targetProp.props[key]) {
+                    create = true;
+                    targetProp.props[key] = {};
+                }
+                targetProp = targetProp.props[key];
+            }
+            if (create) {
+                const ref = path[1];
+                let prop = '';
+                for (let i = 3; i < path.length - 1; i += 2) {
+                    prop += prop ? `.${path[i]}` : path[i];
+                }
+                targetProp.readOnly = true;
+                targetProp.items = {
+                    ref,
+                    prop,
+                };
+            }
+            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 (inverseProp && 'items' in inverseProp) {
+                    inverseProp = inverseProp.items;
+                }
+                if (prop === inverseProp) {
+                    return;
+                }
+            }
+            throw Error('expected inverse property');
+        }
+        if (propKey !== undefined) {
+            throw Error('ref prop not supported on root or edge p');
+        }
+    },
+}, {
+    mime: binaryOpts.mime,
+    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] && t !== prop) {
+                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 property');
+    },
+    dependent(val, prop, ctx, key) {
+        expectBoolean(val);
+        const dependentAllowed = ctx.type && !ctx.inQuery;
+        if (!dependentAllowed) {
+            throw Error('ref dependency not supported on root or edge property');
+        }
+    },
+});
+p.alias = propParser(STUB, {
+    default(val) {
+        expectString(val);
+    },
+    format: binaryOpts.format,
+}, 0);
+p.hll = propParser(STUB, {
+    default(val) {
+        expectNumber(val);
+    },
+}, 0);
 export default p;
 //# sourceMappingURL=props.js.map

package/dist/parse/utils.d.ts

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

package/dist/parse/utils.js

@@ -1,6 +1,9 @@
 import { INVALID_TYPE, MISSING_TYPE } from './errors.js';
-export const getPropType = (prop) => {
+export const getPropType = (prop, props, key) => {
     if (typeof prop === 'string') {
+        if (props) {
+            props[key] = { type: prop };
+        }
         return prop;
     }
     if ('type' in prop) {
@@ -21,7 +24,13 @@ export const getPropType = (prop) => {
     if ('props' in prop) {
         return 'object';
     }
-    if ('enum' in prop || Array.isArray(prop)) {
+    if ('enum' in prop) {
+        return 'enum';
+    }
+    if (Array.isArray(prop)) {
+        if (props) {
+            props[key] = { enum: prop };
+        }
         return 'enum';
     }
     throw Error(MISSING_TYPE);