@based/schema 5.0.0-alpha.0 → 5.0.0-alpha.10

package/dist/def/validation.js

@@ -0,0 +1,258 @@
+import { convertToTimestamp } from '@saulx/utils';
+import { TYPE_INDEX_MAP } from './types.js';
+import { MAX_ID, MIN_ID } from '../types.js';
+const EPSILON = 1e-9; // Small tolerance for floating point comparisons
+export const VALIDATION_MAP = {
+    [TYPE_INDEX_MAP.alias]: (value) => {
+        if (typeof value !== 'string') {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.binary]: (value) => {
+        if (value instanceof Uint8Array) {
+            return true;
+        }
+        return false;
+    },
+    [TYPE_INDEX_MAP.boolean]: (value) => {
+        if (typeof value !== 'boolean') {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.cardinality]: (val) => {
+        return (typeof val === 'string' ||
+            (val instanceof Uint8Array && val.byteLength === 8));
+    },
+    [TYPE_INDEX_MAP.timestamp]: (value, t) => {
+        if (typeof value !== 'number' || value % t.step !== 0) {
+            return false;
+        }
+        if (t.min !== undefined) {
+            if (typeof t.min === 'number') {
+                if (value < t.min) {
+                    return false;
+                }
+            }
+            else if (value < convertToTimestamp(t.min)) {
+                return false;
+            }
+        }
+        else {
+            return value > -1;
+        }
+        if (t.max !== undefined) {
+            if (typeof t.max === 'number') {
+                if (value > t.max) {
+                    return false;
+                }
+            }
+            else if (value > convertToTimestamp(t.max)) {
+                return false;
+            }
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.int16]: (value, t) => {
+        if (typeof value !== 'number' || value % t.step !== 0) {
+            return false;
+        }
+        if (value > 32767 || value < -32768) {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.int32]: (value, t) => {
+        if (typeof value !== 'number' || value % t.step !== 0) {
+            return false;
+        }
+        if (value > 2147483647 || value < -2147483648) {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.int8]: (value, t) => {
+        // use % for steps size
+        if (typeof value !== 'number' || value % t.step !== 0) {
+            return false;
+        }
+        if (value > 127 || value < -128) {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.uint8]: (value, t) => {
+        if (typeof value !== 'number' || value % t.step !== 0) {
+            return false;
+        }
+        if (value > 255 || value < 0) {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.uint16]: (value, t) => {
+        if (typeof value !== 'number' || value % t.step !== 0) {
+            return false;
+        }
+        if (value > 65535 || value < 0) {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.uint32]: (value, t) => {
+        if (typeof value !== 'number' || value % t.step !== 0) {
+            return false;
+        }
+        if (value > 4294967295 || value < 0) {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.number]: (value, t) => {
+        if (t.step) {
+            const div = value / t.step;
+            if (Math.abs(div - Math.round(div)) > EPSILON) {
+                return false;
+            }
+        }
+        if (typeof value !== 'number') {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.enum]: (value, prop) => {
+        if (value === null) {
+            return true;
+        }
+        const arr = prop.enum;
+        for (let i = 0; i < arr.length; i++) {
+            if (value === arr[i]) {
+                return true;
+            }
+        }
+        return false;
+    },
+    [TYPE_INDEX_MAP.id]: (value) => {
+        if (typeof value !== 'number' || value % 1 !== 0) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.json]: (value) => {
+        return true;
+    },
+    [TYPE_INDEX_MAP.microbuffer]: (value) => {
+        if (!(value instanceof Uint8Array)) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.reference]: (v) => {
+        if (typeof v !== 'number') {
+            return false;
+        }
+        if (v === 0 || v > MAX_ID) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.references]: (v) => {
+        if (typeof v !== 'number') {
+            return false;
+        }
+        if (v === 0 || v > MAX_ID) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.string]: (value, t) => {
+        // add max etc all here - make a ref to the original SCHEMA on DEF
+        if (typeof value !== 'string' && !(value instanceof Uint8Array)) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.text]: (value, t) => {
+        // add max etc all here - make a ref to the original SCHEMA on DEF
+        if (typeof value !== 'string' && !(value instanceof Uint8Array)) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.aliases]: (value) => {
+        if (!Array.isArray(value)) {
+            return false;
+        }
+        const len = value.length;
+        for (let i = 0; i < len; i++) {
+            if (typeof value[i] !== 'string') {
+                return false;
+            }
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.vector]: (value) => {
+        // Array should be supported
+        if (!(value instanceof Float32Array)) {
+            return false;
+        }
+        return true;
+    },
+};
+export const defaultValidation = () => true;
+export const isValidId = (id) => {
+    if (typeof id != 'number' || id < MIN_ID || id > MAX_ID) {
+        return false;
+    }
+    return true;
+};
+export const isValidString = (v) => {
+    const isVal = typeof v === 'string' ||
+        v instanceof Uint8Array ||
+        ArrayBuffer.isView(v);
+    return isVal;
+};
+//# sourceMappingURL=validation.js.map

package/dist/index.d.ts

@@ -2,4 +2,5 @@ export * from './types.js';
 export * from './parse/index.js';
 export * from './lang.js';
 export * from './mermaid.js';
+export * from './def/validation.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -2,4 +2,5 @@ export * from './types.js';
 export * from './parse/index.js';
 export * from './lang.js';
 export * from './mermaid.js';
+export * from './def/validation.js';
 //# sourceMappingURL=index.js.map

package/dist/lang.d.ts

@@ -146,6 +146,7 @@ declare const langCodes: {
     readonly zu: 144;
 };
 export declare const langCodesMap: Map<string, 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144>;
+export declare const inverseLangMap: Map<any, any>;
 export type LangName = keyof typeof langCodes;
 export type LangCode = (typeof langCodes)[LangName];
 export {};

package/dist/lang.js

@@ -146,4 +146,8 @@ const langCodes = {
     zu: 144,
 };
 export const langCodesMap = new Map(Object.entries(langCodes));
+export const inverseLangMap = new Map();
+langCodesMap.forEach((v, k) => {
+    inverseLangMap.set(v, k);
+});
 //# sourceMappingURL=lang.js.map

package/dist/parse/assert.d.ts

@@ -1,4 +1,5 @@
 export declare const expectObject: (obj: any, msg?: string) => void;
+export declare const expectFloat32Array: (arr: any) => void;
 export declare const expectString: (obj: any) => void;
 export declare const expectBoolean: (v: any) => void;
 export declare const expectFunction: (v: any) => void;

package/dist/parse/assert.js

@@ -1,9 +1,15 @@
-import { EXPECTED_BOOL, EXPECTED_FN, EXPECTED_NUM, EXPECTED_OBJ, EXPECTED_STR, } from './errors.js';
+import { isFloat32Array } from 'util/types';
+import { EXPECTED_ARR, EXPECTED_BOOL, EXPECTED_FN, EXPECTED_NUM, EXPECTED_OBJ, EXPECTED_STR, } from './errors.js';
 export const expectObject = (obj, msg) => {
     if (typeof obj !== 'object' || obj === null) {
         throw Error(msg || EXPECTED_OBJ);
     }
 };
+export const expectFloat32Array = (arr) => {
+    if (!isFloat32Array(arr)) {
+        throw Error(EXPECTED_ARR);
+    }
+};
 export const expectString = (obj) => {
     if (typeof obj !== 'string') {
         throw Error(EXPECTED_STR);

package/dist/parse/index.d.ts

@@ -12,7 +12,7 @@ export declare class SchemaParser {
     parseTypes(): void;
     parseProps(props: any, schemaType?: SchemaType): void;
     parseLocales(): void;
-    parse(): void;
+    parse(): StrictSchema;
 }
 export declare const print: (schema: Schema, path: string[]) => string;
 export declare const parse: (schema: Schema) => {

package/dist/parse/index.js

@@ -3,10 +3,11 @@ import { getPropType } from './utils.js';
 import propParsers from './props.js';
 import pc from 'picocolors';
 import { expectBoolean, expectObject } from './assert.js';
+import { deepCopy } from '@saulx/utils';
 export { getPropType };
 export class SchemaParser {
     constructor(schema) {
-        this.schema = schema;
+        this.schema = deepCopy(schema);
     }
     isItems;
     inQuery;
@@ -20,7 +21,7 @@ export class SchemaParser {
         expectObject(types);
         for (const type in types) {
             this.lvl++;
-            if (type[0] === '_') {
+            if (type === '_root') {
                 throw new Error(INVALID_KEY);
             }
             this.path[this.lvl] = type;
@@ -97,6 +98,7 @@ export class SchemaParser {
                 throw Error(UNKNOWN_PROP);
             }
         }
+        return this.schema;
     }
 }
 export const print = (schema, path) => {
@@ -120,9 +122,7 @@ export const print = (schema, path) => {
 export const parse = (schema) => {
     const parser = new SchemaParser(schema);
     try {
-        parser.parse();
-        // @ts-ignore
-        return { schema };
+        return { schema: parser.parse() };
     }
     catch (e) {
         const cause = parser.path.slice(0, Math.min(4, parser.lvl) + 1);

package/dist/parse/props.d.ts

@@ -3,5 +3,6 @@ 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 declare const isDefault: (val: any, prop: any, ctx: any) => any;
 export default p;
 //# sourceMappingURL=props.d.ts.map

package/dist/parse/props.js

@@ -1,7 +1,12 @@
+import { convertToTimestamp } from '@saulx/utils';
+import { NUMBER, TYPE_INDEX_MAP, } from '../def/types.js';
+import { VALIDATION_MAP } from '../def/validation.js';
 import { stringFormats, dateDisplays, numberDisplays, } from '../types.js';
-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, MISSING_TYPE, OUT_OF_RANGE, TEXT_REQUIRES_LOCALES, TYPE_MISMATCH, UNKNOWN_PROP, NOT_ALLOWED_IN_ITEMS, } from './errors.js';
+import { expectBoolean, expectFunction, expectNumber, expectObject, expectString, } from './assert.js';
+import { EXPECTED_ARR, EXPECTED_OBJ, EXPECTED_PRIMITIVE, INVALID_VALUE, MIN_MAX, MISSING_TYPE, TEXT_REQUIRES_LOCALES, TYPE_MISMATCH, UNKNOWN_PROP, NOT_ALLOWED_IN_ITEMS, } from './errors.js';
 import { getPropType } from './utils.js';
+import { DEFAULT_MAP } from '../def/defaultMap.js';
+import { parseMinMaxStep } from '../def/utils.js';
 let stringFormatsSet;
 let numberDisplaysSet;
 let dateDisplaysSet;
@@ -38,10 +43,21 @@ const shared = {
             throw Error(TYPE_MISMATCH);
         }
     },
-    title(val) { },
-    description(val) { },
-    readOnly(val) { },
-    examples(val) { },
+    title(val) {
+        expectString(val);
+    },
+    description(val) {
+        expectString(val);
+    },
+    readOnly(val) {
+        expectBoolean(val);
+    },
+    examples(val) {
+        expectString(val);
+    },
+    validation(val) {
+        expectFunction(val);
+    },
 };
 function propParser(required, optional, allowShorthand) {
     return (prop, ctx) => {
@@ -91,9 +107,54 @@ function propParser(required, optional, allowShorthand) {
     };
 }
 const p = {};
+export const isDefault = (val, prop, ctx) => {
+    let typeIndex;
+    typeIndex = TYPE_INDEX_MAP[prop.type];
+    if ('enum' in prop) {
+        typeIndex = TYPE_INDEX_MAP['enum'];
+    }
+    if (prop.type === 'timestamp') {
+        val = convertToTimestamp(val);
+    }
+    const validation = prop.validation || VALIDATION_MAP[typeIndex];
+    const propDef = {
+        typeIndex,
+        __isPropDef: true,
+        start: 0,
+        path: [],
+        prop: 0,
+        len: 0,
+        separate: false,
+        enum: prop.enum,
+        validation,
+        default: DEFAULT_MAP[typeIndex],
+        step: parseMinMaxStep(prop.step ?? typeIndex === NUMBER ? 0 : 1),
+        max: parseMinMaxStep(prop.max),
+        min: parseMinMaxStep(prop.min),
+    };
+    if (!validation(val, propDef)) {
+        throw new Error(`Incorrect default for type "${prop.type ?? 'enum'}"`);
+    }
+    if ('enum' in prop) {
+        if (val === undefined) {
+            return 0;
+        }
+        return prop.enum.findIndex((v) => v === val) + 1;
+    }
+    return val;
+};
 p.boolean = propParser(STUB, {
-    default(val) {
-        expectBoolean(val);
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
+    },
+}, 0);
+p.vector = propParser({
+    size(val) {
+        expectNumber(val);
+    },
+}, {
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
     },
 }, 0);
 p.enum = propParser({
@@ -111,10 +172,8 @@ p.enum = propParser({
         }
     },
 }, {
-    default(val, prop) {
-        if (!prop.enum.includes(val)) {
-            throw Error(EXPECTED_VALUE_IN_ENUM);
-        }
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
     },
 }, 1);
 const numberOpts = {
@@ -137,18 +196,8 @@ const numberOpts = {
             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);
-            }
-        }
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
     },
 };
 p.number = propParser(STUB, numberOpts, 0);
@@ -162,11 +211,7 @@ p.object = propParser({
     props(val, prop, ctx) {
         ctx.parseProps(val, ctx.type);
     },
-}, {
-    default(val) {
-        console.warn('TODO object default value');
-    },
-});
+}, {});
 p.set = propParser({
     items(items, prop, ctx) {
         expectObject(items);
@@ -209,16 +254,13 @@ p.references = propParser({
         }
     },
 }, {
-    default(val, prop) {
-        console.warn('TODO SET DEFAULT VALUE');
-        // if (typeof val === 'object') {
-        //   throwErr(ERRORS.EXPECTED_PRIMITIVE, prop, 'default')
-        // }
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
     },
 });
 const binaryOpts = {
-    default(val) {
-        expectString(val);
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
     },
     format(val) {
         expectString(val);
@@ -261,8 +303,10 @@ p.text = propParser({
         throw Error(TEXT_REQUIRES_LOCALES);
     },
 }, {
+    format: binaryOpts.format,
     default(val, prop) {
-        console.warn('MAKE DEFAULT VALUE FOR TEXT');
+        // console.warn('MAKE DEFAULT VALUE FOR TEXT')
+        return true;
     },
 }, 0);
 p.timestamp = propParser(STUB, {
@@ -271,11 +315,27 @@ p.timestamp = propParser(STUB, {
         dateDisplaysSet ??= new Set(dateDisplays);
         dateDisplaysSet.has(val);
     },
-    default(val) {
-        if (typeof val !== 'number' && !(val instanceof Date)) {
-            throw Error(EXPECTED_DATE);
+    min(val) {
+        if (typeof val !== 'string' && typeof val !== 'number') {
+            throw Error(INVALID_VALUE);
         }
     },
+    max(val) {
+        if (typeof val !== 'string' && typeof val !== 'number') {
+            throw Error(INVALID_VALUE);
+        }
+    },
+    step(val) {
+        if (typeof val !== 'string' && typeof val !== 'number') {
+            throw Error(INVALID_VALUE);
+        }
+        if (typeof val === 'string' && val.includes('now')) {
+            throw Error(INVALID_VALUE);
+        }
+    },
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
+    },
     on(val) {
         if (val !== 'create' && val !== 'update') {
             throw Error(INVALID_VALUE);
@@ -339,8 +399,8 @@ p.reference = propParser({
     },
 }, {
     mime: binaryOpts.mime,
-    default(val) {
-        expectString(val);
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
     },
     edge(val, prop, ctx, key) {
         const edgeAllowed = ctx.type && !ctx.inQuery;
@@ -368,14 +428,19 @@ p.reference = propParser({
     },
 });
 p.alias = propParser(STUB, {
-    default(val) {
-        expectString(val);
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
     },
     format: binaryOpts.format,
 }, 0);
-p.hll = propParser(STUB, {
-    default(val) {
-        expectNumber(val);
+p.cardinality = propParser(STUB, {
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
+    },
+}, 0);
+p.json = propParser(STUB, {
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
     },
 }, 0);
 export default p;