@based/schema 5.0.0-alpha.8 → 5.0.0

package/dist/parse/props.js

@@ -1,7 +1,12 @@
+import { convertToTimestamp } from '@based/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, 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 { 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,16 +43,29 @@ 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) => {
         if (typeof prop === 'string') {
             // allow string
             if (allowShorthand === 0) {
+                // @ts-ignore
+                required?.type?.(prop, { type: prop }, ctx);
                 return;
             }
             throw Error(EXPECTED_OBJ);
@@ -91,9 +109,67 @@ 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 (prop.type === 'text') {
+        if (typeof val === 'object') {
+            for (const key in val) {
+                if (!ctx.schema.locales || !(key in ctx.schema.locales)) {
+                    throw new Error(`Incorrect default for type "text" lang "${key}"`);
+                }
+                if (!validation(val[key], propDef)) {
+                    throw new Error(`Incorrect default for type "text" lang "${key}"`);
+                }
+            }
+        }
+        else {
+            if (!validation(val, propDef)) {
+                throw new Error(`Incorrect default for type "text"`);
+            }
+            val = {};
+            for (const key in ctx.schema.locales) {
+                val[key] = ctx.schema.locales[key];
+            }
+        }
+        return val;
+    }
+    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({
@@ -101,8 +177,49 @@ p.vector = propParser({
         expectNumber(val);
     },
 }, {
-    default(val) {
-        expectFloat32Array(val);
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
+    },
+    baseType(val, prop, ctx) {
+        if (![
+            'number',
+            'int8',
+            ,
+            'uint8',
+            'int16',
+            'uint16',
+            'int32',
+            'uint32',
+            'float32',
+            'float64',
+        ].includes(val)) {
+            throw Error(INVALID_VALUE);
+        }
+    },
+}, 0);
+p.colvec = propParser({
+    size(val) {
+        expectNumber(val);
+    },
+}, {
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
+    },
+    baseType(val, prop, ctx) {
+        if (![
+            'number',
+            'int8',
+            ,
+            'uint8',
+            'int16',
+            'uint16',
+            'int32',
+            'uint32',
+            'float32',
+            'float64',
+        ].includes(val)) {
+            throw Error(INVALID_VALUE);
+        }
     },
 }, 0);
 p.enum = propParser({
@@ -120,10 +237,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 = {
@@ -146,18 +261,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);
@@ -168,14 +273,10 @@ 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) {
+    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);
@@ -218,16 +319,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);
@@ -270,9 +368,12 @@ p.text = propParser({
         throw Error(TEXT_REQUIRES_LOCALES);
     },
 }, {
+    compression(val) {
+        return val;
+    },
     format: binaryOpts.format,
-    default(val, prop) {
-        console.warn('MAKE DEFAULT VALUE FOR TEXT');
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
     },
 }, 0);
 p.timestamp = propParser(STUB, {
@@ -281,11 +382,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);
@@ -298,7 +415,7 @@ p.reference = propParser({
             throw Error(MISSING_TYPE);
         }
     },
-    prop(propKey, prop, { schema, type, inQuery, path }) {
+    prop(propKey, prop, { schema, type, inQuery, path, lvl }) {
         const propAllowed = type && !inQuery;
         if (propAllowed) {
             expectString(propKey);
@@ -316,7 +433,7 @@ p.reference = propParser({
             if (create) {
                 const ref = path[1];
                 let prop = '';
-                for (let i = 3; i < path.length - 1; i += 2) {
+                for (let i = 3; i < lvl; i += 2) {
                     prop += prop ? `.${path[i]}` : path[i];
                 }
                 targetProp.readOnly = true;
@@ -349,8 +466,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;
@@ -378,19 +495,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.cardinality = propParser(STUB, {
-    default(val) {
-        expectNumber(val);
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
     },
 }, 0);
 p.json = propParser(STUB, {
-    default(val) {
-        expectObject(val);
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
     },
 }, 0);
 export default p;

package/dist/serialize.d.ts

@@ -0,0 +1,14 @@
+import { StrictSchema } from './types.js';
+type Opts = {
+    readOnly?: boolean;
+    stripMetaInformation?: boolean;
+};
+export declare const serialize: (schema: any, opts?: Opts) => Uint8Array;
+export declare const deSerializeKey: (buf: Uint8Array, keySize: number, i: number) => {
+    size: number;
+    value: string;
+};
+export declare const deSerializeInner: (buf: Uint8Array, obj: any, start: number, fromArray: boolean) => number;
+export declare const deSerialize: (buf: Uint8Array) => StrictSchema;
+export {};
+//# sourceMappingURL=serialize.d.ts.map