@based/schema 3.2.0 → 4.1.0

package/dist/parseSchema/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/parseSchema/index.d.ts

@@ -0,0 +1,20 @@
+import { Schema, SchemaType } from '../types.js';
+import { getPropType } from './utils.js';
+export { getPropType };
+export declare class Parser {
+    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 parseSchema: (schema: Schema) => {
+    schema: Schema;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/parseSchema/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 Parser {
+    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 Parser(proxy(schema));
+    try {
+        parser.parse();
+    }
+    catch (e) {
+        e.message += '\n\n' + print(schema, curr) + '\n';
+        e.cause = curr;
+        throw e;
+    }
+};
+export const parseSchema = (schema) => {
+    try {
+        new Parser(schema).parse();
+        return { schema };
+    }
+    catch (e) {
+        debug(schema);
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/parseSchema/props.d.ts

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

package/dist/parseSchema/props.js

@@ -0,0 +1,256 @@
+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 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.boolean = propParser({}, {
+    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);
+p.number = propParser({
+    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);
+            }
+        }
+    },
+}, 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);
+            let targetProp = schema.types[prop.ref].props[propKey];
+            if ('items' in targetProp) {
+                targetProp = targetProp.items;
+            }
+            if ('ref' in targetProp && 'prop' in targetProp) {
+                let t = schema.types[targetProp.ref].props[targetProp.prop];
+                if ('items' in t) {
+                    t = t.items;
+                }
+                if (t === 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);
+            p[edgePropType](val, ctx);
+            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({}, {
+    default(val) {
+        expectString(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');
+        //   if (typeof val !== 'string') {
+        //     throwErr(ERRORS.EXPECTED_STR, prop, 'default')
+        //   }
+    },
+}, 0);
+p.timestamp = propParser({}, {
+    default(val) {
+        if (typeof val !== 'number' && !(val instanceof Date)) {
+            throw Error(EXPECTED_DATE);
+        }
+    },
+}, 0);
+export default p;
+//# sourceMappingURL=props.js.map

package/dist/parseSchema/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/parseSchema/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/src/compat/index.js

@@ -21,7 +21,7 @@ const convertNewToOldMeta = (props) => {
         if (i[0] !== '$') {
             const v = props[i];
             meta ??= {};
-            if (i === 'allowedTypes') {
+            if (i === 'allowedType') {
                 meta.refTypes = v;
             }
             else if (i === 'display' && v === 'bytes') {
@@ -42,7 +42,7 @@ const convertOldToNewMeta = (props) => {
     for (const i in props) {
         const v = props[i];
         if (i === 'refTypes') {
-            meta.allowedTypes = v;
+            meta.allowedType = v; // TODO
         }
         else if (i === 'format' && v === 'bytes') {
             meta.display = 'bytes';

package/dist/src/set/fields/references.js

@@ -22,36 +22,9 @@ async function parseOperator(args, key) {
     return [n.value];
 }
 const typeIsAllowed = (args, type) => {
-    if ('allowedTypes' in args.fieldSchema) {
-        let typeMatches = false;
-        for (const t of args.fieldSchema.allowedTypes) {
-            if (typeof t === 'string') {
-                if (t === type) {
-                    return true;
-                }
-            }
-            else {
-                if (t.type && t.type === type) {
-                    typeMatches = true;
-                    if (t.$filter) {
-                        // stage on requires validation in target
-                        // TODO: ASYNC REQUIRED HOOK
-                        // if(!(await args.target.referenceFilterCondition(value, t.$filter))){
-                        //     error(args, ParseError.referenceIsIncorrectType)
-                        //     return
-                        // }
-                    }
-                }
-                else if (!t.type && t.$filter) {
-                    // if(!(await args.target.referenceFilterCondition))
-                    // error(args, ParseError.referenceIsIncorrectType, )
-                    // return
-                }
-            }
-        }
-        if (typeMatches === false) {
-            return false;
-        }
+    if ('allowedType' in args.fieldSchema) {
+        const t = args.fieldSchema.allowedType;
+        return typeof t === 'string' && t === type;
     }
     return true;
 };

package/dist/src/types.d.ts

@@ -5,11 +5,7 @@ import { ArgsClass, Path } from './walker/index.js';
 import { StringFormat } from './display/string.js';
 import { NumberFormat } from './display/number.js';
 import { DateFormat } from './display/timestamp.js';
-export type AllowedTypes = (string | {
-    type?: string;
-    $filter: any | any[];
-})[];
-export declare const basedSchemaFieldTypes: readonly ["array", "object", "record", "set", "string", "boolean", "number", "json", "integer", "timestamp", "reference", "references", "text", "enum", "cardinality", "any"];
+export declare const basedSchemaFieldTypes: readonly ["array", "object", "record", "set", "string", "boolean", "number", "json", "integer", "timestamp", "created", "updated", "reference", "references", "text", "enum", "cardinality", "any"];
 export type BasedSchemaFieldType = (typeof basedSchemaFieldTypes)[number];
 export declare const isCollection: (type: string) => boolean;
 export type BasedSchemaPattern = string;
@@ -123,18 +119,14 @@ export type BasedSchemaFieldSet = {
 export type BasedSchemaFieldEnumerable = BasedSchemaFieldText | BasedSchemaFieldObject | BasedSchemaFieldRecord | BasedSchemaFieldArray | BasedSchemaFieldSet;
 export type BasedSchemaFieldReference = {
     type: 'reference';
-    bidirectional?: {
-        fromField: string;
-    };
-    allowedTypes?: AllowedTypes;
+    allowedType: string;
+    inverseProperty?: string;
 } & BasedSchemaFieldShared;
 export type BasedSchemaFieldReferences = {
     type: 'references';
-    bidirectional?: {
-        fromField: string;
-    };
+    allowedType: string;
+    inverseProperty?: string;
     sortable?: boolean;
-    allowedTypes?: AllowedTypes;
 } & BasedSchemaFieldShared;
 export type BasedSchemaFields = {
     string: BasedSchemaFieldString;

package/dist/src/types.js

@@ -1,4 +1,16 @@
 import { languages as allLanguages } from './languages.js';
+// Schema type
+// inspiration from https://json-schema.org/understanding-json-schema/index.html
+// but added a few extra types
+//   reference
+//   references
+//   set
+//   record
+// https://json-schema.org/learn/examples/geographical-location.schema.json
+// contentSchema can be used for JSON types as well
+// contentSchema can be used for reference / refrences
+// TODO parser / validator / parseOut / parseIn (parsIn after validator)
+// for refs etc check https://json-schema.org/understanding-json-schema/structuring.html#defs
 export const basedSchemaFieldTypes = [
     'array',
     'object',
@@ -10,6 +22,8 @@ export const basedSchemaFieldTypes = [
     'json',
     'integer',
     'timestamp',
+    'created',
+    'updated',
     'reference',
     'references',
     'text',

package/dist/src/validateSchema/fieldValidators.js

@@ -333,22 +333,22 @@ export const basedSchemaFieldSetValidator = {
 };
 export const basedSchemaFieldReferenceValidator = {
     ...basedSchemaFieldSharedValidator,
-    bidirectional: {
+    inverseProperty: {
         validator: mustBeBidirectional,
         optional: true,
     },
-    allowedTypes: {
+    allowedType: {
         // TODO: validator
         optional: true,
     },
 };
 export const basedSchemaFieldReferencesValidator = {
     ...basedSchemaFieldSharedValidator,
-    bidirectional: {
+    inverseProperty: {
         validator: mustBeBidirectional,
         optional: true,
     },
-    allowedTypes: {
+    allowedType: {
         // TODO: validator
         optional: true,
     },

package/dist/test/compat.js

@@ -45,7 +45,7 @@ test('refTypes', async (t) => {
         },
     });
     // @ts-ignore
-    t.is(newSchema.types.youzi.fields.image.allowedTypes[0], 'youzi');
+    t.is(newSchema.types.youzi.fields.image.allowedType, 'youzi');
     const oldSchema = convertNewToOld(newSchema);
     // @ts-ignore
     t.is(oldSchema.types.youzi.fields.image.meta.refTypes[0], 'youzi');