@based/schema 5.0.0-alpha.4 → 5.0.0-alpha.5

package/dist/def/selvaBuffer.js

@@ -1,7 +1,7 @@
-import { ALIAS, ALIASES, BINARY, BOOLEAN, CREATED, EMPTY_MICRO_BUFFER, ENUM, CARDINALITY, INT16, INT32, INT64, INT8, MICRO_BUFFER, NULL, NUMBER, REFERENCE, REFERENCES, STRING, TEXT, TIMESTAMP, UINT16, UINT32, UINT8, UPDATED, VECTOR, WEAK_REFERENCE, WEAK_REFERENCES, JSON, } from './types.js';
+import { ALIAS, ALIASES, BINARY, BOOLEAN, CREATED, EMPTY_MICRO_BUFFER, ENUM, CARDINALITY, INT16, INT32, INT8, MICRO_BUFFER, NULL, NUMBER, REFERENCE, REFERENCES, STRING, TEXT, TIMESTAMP, UINT16, UINT32, UINT8, UPDATED, VECTOR, WEAK_REFERENCE, WEAK_REFERENCES, JSON, } from './types.js';
 const selvaTypeMap = [];
 selvaTypeMap[NULL] = 0;
-selvaTypeMap[TIMESTAMP] = 1;
+selvaTypeMap[TIMESTAMP] = 4;
 selvaTypeMap[CREATED] = 1;
 selvaTypeMap[UPDATED] = 1;
 selvaTypeMap[NUMBER] = 4;
@@ -12,7 +12,6 @@ selvaTypeMap[INT16] = 21;
 selvaTypeMap[UINT16] = 22;
 selvaTypeMap[INT32] = 23;
 selvaTypeMap[UINT32] = 7;
-selvaTypeMap[INT64] = 24;
 selvaTypeMap[BOOLEAN] = 9;
 selvaTypeMap[ENUM] = 10;
 selvaTypeMap[STRING] = 11;
@@ -28,6 +27,11 @@ selvaTypeMap[BINARY] = 11;
 selvaTypeMap[VECTOR] = 17;
 selvaTypeMap[JSON] = 11;
 const EDGE_FIELD_CONSTRAINT_FLAG_DEPENDENT = 0x01;
+function blockCapacity(blockCapacity) {
+    const buf = Buffer.allocUnsafe(4);
+    buf.writeInt32LE(blockCapacity);
+    return buf;
+}
 function sepPropCount(props) {
     return props.filter((prop) => prop.separate).length;
 }
@@ -77,11 +81,6 @@ const propDefBuffer = (schema, prop, isEdge) => {
         return [selvaType];
     }
 };
-function makeBlockCapacityBuffer(blockCapacity) {
-    const buf = Buffer.allocUnsafe(4);
-    buf.writeInt32LE(blockCapacity);
-    return buf;
-}
 // todo rewrite
 export function schemaToSelvaBuffer(schema) {
     if (typeof Buffer === 'undefined') {
@@ -102,7 +101,7 @@ export function schemaToSelvaBuffer(schema) {
         }
         rest.sort((a, b) => a.prop - b.prop);
         return Buffer.from([
-            ...makeBlockCapacityBuffer(t.blockCapacity).values(),
+            ...blockCapacity(t.blockCapacity).values(),
             1 + sepPropCount(props),
             1 + refFields,
             ...propDefBuffer(schema, {

package/dist/def/typeDef.js

@@ -1,9 +1,31 @@
 import { isPropType, getPropType, } from '../index.js';
 import { setByPath } from '@saulx/utils';
 import { hashObjectIgnoreKeyOrder } from '@saulx/hash';
-import { SIZE_MAP, TYPE_INDEX_MAP, STRING, ALIAS, CARDINALITY, REFERENCES, REFERENCE, TEXT, } from './types.js';
+import { SIZE_MAP, TYPE_INDEX_MAP, STRING, ALIAS, CARDINALITY, REFERENCES, REFERENCE, TEXT, ENUM, } from './types.js';
 // TMP
 export const DEFAULT_BLOCK_CAPACITY = 100_000;
+function getPropLen(schemaProp) {
+    let len = SIZE_MAP[getPropType(schemaProp)];
+    if (isPropType('string', schemaProp) ||
+        isPropType('alias', schemaProp) ||
+        isPropType('cardinality', schemaProp)) {
+        if (typeof schemaProp === 'object') {
+            if (schemaProp.maxBytes < 61) {
+                len = schemaProp.maxBytes + 1;
+            }
+            else if ('max' in schemaProp && schemaProp.max < 31) {
+                len = schemaProp.max * 2 + 1;
+            }
+        }
+    }
+    else if (isPropType('vector', schemaProp)) {
+        len = 4 * schemaProp.size;
+    }
+    return len;
+}
+function isSeparate(schemaProp, len) {
+    return len === 0 || isPropType('vector', schemaProp);
+}
 const addEdges = (prop, refProp) => {
     let edgesCnt = 0;
     for (const key in refProp) {
@@ -32,7 +54,7 @@ const addEdges = (prop, refProp) => {
                 // [field] [size] [data]
                 prop.edgesTotalLen += 1 + 2 + edge.len; // field len
             }
-            if (edge.typeIndex === 10) {
+            if (edge.typeIndex === ENUM) {
                 edge.enum = Array.isArray(refProp[key])
                     ? refProp[key]
                     : refProp[key].enum;
@@ -41,10 +63,10 @@ const addEdges = (prop, refProp) => {
                     edge.reverseEnum[edge.enum[i]] = i;
                 }
             }
-            else if (edge.typeIndex === 14) {
+            else if (edge.typeIndex === REFERENCES) {
                 edge.inverseTypeName = refProp[key].items.ref;
             }
-            else if (edge.typeIndex === 13) {
+            else if (edge.typeIndex === REFERENCE) {
                 edge.inverseTypeName = refProp[key].ref;
             }
             prop.edges[key] = edge;
@@ -52,6 +74,101 @@ const addEdges = (prop, refProp) => {
         }
     }
 };
+function makePacked(result, typeName, vals, len) {
+    const encoder = new TextEncoder();
+    result.buf = new Uint8Array(len);
+    result.buf[0] = result.idUint8[0];
+    result.buf[1] = result.idUint8[1];
+    const fieldNames = [];
+    const tNameBuf = encoder.encode(typeName);
+    fieldNames.push(tNameBuf);
+    let fieldNameLen = tNameBuf.byteLength + 1;
+    let i = 2;
+    if (result.mainLen) {
+        result.buf[i] = 0;
+        for (const f of vals) {
+            if (!f.separate) {
+                i++;
+                result.buf[i] = f.typeIndex;
+                const name = encoder.encode(f.path.join('.'));
+                fieldNames.push(name);
+                fieldNameLen += name.byteLength + 1;
+            }
+        }
+        i++;
+        result.buf[i] = 0;
+    }
+    for (const f of vals) {
+        if (f.separate) {
+            i++;
+            result.buf[i] = f.prop;
+            i++;
+            result.buf[i] = f.typeIndex;
+            const name = encoder.encode(f.path.join('.'));
+            fieldNames.push(name);
+            fieldNameLen += name.byteLength + 1;
+        }
+    }
+    result.propNames = new Uint8Array(fieldNameLen);
+    let lastWritten = 0;
+    for (const f of fieldNames) {
+        result.propNames[lastWritten] = f.byteLength;
+        result.propNames.set(f, lastWritten + 1);
+        lastWritten += f.byteLength + 1;
+    }
+    let bufLen = result.buf.length;
+    result.packed = new Uint8Array(2 + bufLen + result.propNames.length);
+    result.packed[0] = bufLen;
+    result.packed[1] = bufLen >>>= 8;
+    result.packed.set(result.buf, 2);
+    result.packed.set(result.propNames, result.buf.length + 2);
+}
+function makeSeparateTextSort(result) {
+    result.hasSeperateTextSort = true;
+    let max = 0;
+    for (const f of result.separate) {
+        if (f.typeIndex === TEXT) {
+            if (f.prop > max) {
+                max = f.prop;
+            }
+        }
+    }
+    result.seperateTextSort.buffer = new Uint8Array(max * result.localeSize + 1);
+    for (const f of result.separate) {
+        if (f.typeIndex === TEXT) {
+            result.seperateTextSort.buffer[f.prop] = 1;
+            result.seperateTextSort.props.push(f);
+            result.seperateTextSort.size += result.localeSize;
+        }
+    }
+    result.seperateTextSort.bufferTmp = new Uint8Array(max * result.localeSize + 1);
+    result.seperateTextSort.buffer.set(result.seperateTextSort.bufferTmp);
+}
+function makeSeparateSort(result) {
+    result.hasSeperateSort = true;
+    let max = 0;
+    for (const f of result.separate) {
+        if (f.typeIndex === STRING ||
+            f.typeIndex === ALIAS ||
+            f.typeIndex === CARDINALITY) {
+            if (f.prop > max) {
+                max = f.prop;
+            }
+        }
+    }
+    result.seperateSort.buffer = new Uint8Array(max + 1);
+    for (const f of result.separate) {
+        if (f.typeIndex === STRING ||
+            f.typeIndex === ALIAS ||
+            f.typeIndex === CARDINALITY) {
+            result.seperateSort.buffer[f.prop] = 1;
+            result.seperateSort.props.push(f);
+            result.seperateSort.size++;
+        }
+    }
+    result.seperateSort.bufferTmp = new Uint8Array(max + 1);
+    result.seperateSort.buffer.set(result.seperateSort.bufferTmp);
+}
 export const updateTypeDefs = (schema, schemaTypesParsed, schemaTypesParsedById) => {
     for (const field in schemaTypesParsed) {
         if (field in schema.types) {
@@ -123,7 +240,6 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = {
     result.localeSize = Object.keys(locales).length;
     result.idUint8[0] = result.id & 255;
     result.idUint8[1] = result.id >> 8;
-    const encoder = new TextEncoder();
     const target = type.props;
     let separateSortProps = 0;
     let separateSortText = 0;
@@ -135,18 +251,12 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = {
             createSchemaTypeDef(typeName, schemaProp, parsed, locales, result, propPath, false);
         }
         else {
-            let len = SIZE_MAP[propType];
+            const len = getPropLen(schemaProp);
             if (isPropType('string', schemaProp) ||
                 isPropType('alias', schemaProp) ||
                 isPropType('cardinality', schemaProp)) {
                 if (typeof schemaProp === 'object') {
-                    if (schemaProp.maxBytes < 61) {
-                        len = schemaProp.maxBytes + 1;
-                    }
-                    else if ('max' in schemaProp && schemaProp.max < 31) {
-                        len = schemaProp.max * 2 + 1;
-                    }
-                    else {
+                    if (!(schemaProp.maxBytes < 61) || !('max' in schemaProp && schemaProp.max < 31)) {
                         separateSortProps++;
                     }
                 }
@@ -154,16 +264,10 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = {
                     separateSortProps++;
                 }
             }
-            else if (isPropType('vector', schemaProp)) {
-                len = 4 * schemaProp.size;
-            }
             else if (isPropType('text', schemaProp)) {
                 separateSortText++;
             }
-            const isseparate = len === 0 || isPropType('vector', schemaProp);
-            if (isseparate) {
-                result.cnt++;
-            }
+            const isseparate = isSeparate(schemaProp, len);
             const prop = {
                 typeIndex: TYPE_INDEX_MAP[propType],
                 __isPropDef: true,
@@ -171,7 +275,7 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = {
                 path: propPath,
                 start: 0,
                 len,
-                prop: isseparate ? result.cnt : 0,
+                prop: isseparate ? ++result.cnt : 0,
             };
             if (isPropType('enum', schemaProp)) {
                 prop.enum = Array.isArray(schemaProp) ? schemaProp : schemaProp.enum;
@@ -231,8 +335,7 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = {
         let lastProp = 0;
         for (const p of vals) {
             if (p.separate) {
-                lastProp++;
-                p.prop = lastProp;
+                p.prop = ++lastProp;
             }
         }
         let len = 2;
@@ -251,109 +354,12 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = {
                 setByPath(result.tree, f.path, f);
             }
         }
-        const mainFields = [];
-        const restFields = [];
-        for (const f of vals) {
-            if (f.separate) {
-                restFields.push(f);
-            }
-            else {
-                mainFields.push(f);
-            }
-        }
-        // make packed version
-        result.buf = new Uint8Array(len);
-        result.buf[0] = result.idUint8[0];
-        result.buf[1] = result.idUint8[1];
-        const fieldNames = [];
-        const tNameBuf = encoder.encode(typeName);
-        fieldNames.push(tNameBuf);
-        let fieldNameLen = tNameBuf.byteLength + 1;
-        let i = 2;
-        if (result.mainLen) {
-            result.buf[i] = 0;
-            for (const f of vals) {
-                if (!f.separate) {
-                    i++;
-                    result.buf[i] = f.typeIndex;
-                    const name = encoder.encode(f.path.join('.'));
-                    fieldNames.push(name);
-                    fieldNameLen += name.byteLength + 1;
-                }
-            }
-            i++;
-            result.buf[i] = 0;
-        }
-        for (const f of vals) {
-            if (f.separate) {
-                i++;
-                result.buf[i] = f.prop;
-                i++;
-                result.buf[i] = f.typeIndex;
-                const name = encoder.encode(f.path.join('.'));
-                fieldNames.push(name);
-                fieldNameLen += name.byteLength + 1;
-            }
-        }
-        result.propNames = new Uint8Array(fieldNameLen);
-        let lastWritten = 0;
-        for (const f of fieldNames) {
-            result.propNames[lastWritten] = f.byteLength;
-            result.propNames.set(f, lastWritten + 1);
-            lastWritten += f.byteLength + 1;
-        }
-        let bufLen = result.buf.length;
-        result.packed = new Uint8Array(2 + bufLen + result.propNames.length);
-        result.packed[0] = bufLen;
-        result.packed[1] = bufLen >>>= 8;
-        result.packed.set(result.buf, 2);
-        result.packed.set(result.propNames, result.buf.length + 2);
-        // done making packed bversion
+        makePacked(result, typeName, vals, len);
         if (separateSortText > 0) {
-            result.hasSeperateTextSort = true;
-            let max = 0;
-            for (const f of result.separate) {
-                if (f.typeIndex === TEXT) {
-                    if (f.prop > max) {
-                        max = f.prop;
-                    }
-                }
-            }
-            result.seperateTextSort.buffer = new Uint8Array(max * result.localeSize + 1);
-            for (const f of result.separate) {
-                if (f.typeIndex === TEXT) {
-                    result.seperateTextSort.buffer[f.prop] = 1;
-                    result.seperateTextSort.props.push(f);
-                    result.seperateTextSort.size += result.localeSize;
-                }
-            }
-            result.seperateTextSort.bufferTmp = new Uint8Array(max * result.localeSize + 1);
-            result.seperateTextSort.buffer.set(result.seperateTextSort.bufferTmp);
+            makeSeparateTextSort(result);
         }
         if (separateSortProps > 0) {
-            result.hasSeperateSort = true;
-            let max = 0;
-            for (const f of result.separate) {
-                if (f.typeIndex === STRING ||
-                    f.typeIndex === ALIAS ||
-                    f.typeIndex === CARDINALITY) {
-                    if (f.prop > max) {
-                        max = f.prop;
-                    }
-                }
-            }
-            result.seperateSort.buffer = new Uint8Array(max + 1);
-            for (const f of result.separate) {
-                if (f.typeIndex === STRING ||
-                    f.typeIndex === ALIAS ||
-                    f.typeIndex === CARDINALITY) {
-                    result.seperateSort.buffer[f.prop] = 1;
-                    result.seperateSort.props.push(f);
-                    result.seperateSort.size++;
-                }
-            }
-            result.seperateSort.bufferTmp = new Uint8Array(max + 1);
-            result.seperateSort.buffer.set(result.seperateSort.bufferTmp);
+            makeSeparateSort(result);
         }
         for (const p in result.props) {
             const x = result.props[p];

package/dist/def/types.d.ts

@@ -11,7 +11,6 @@ export declare const INT16 = 21;
 export declare const UINT16 = 22;
 export declare const INT32 = 23;
 export declare const UINT32 = 7;
-export declare const INT64 = 24;
 export declare const BOOLEAN = 9;
 export declare const ENUM = 10;
 export declare const STRING = 11;

package/dist/def/types.js

@@ -11,7 +11,6 @@ export const INT16 = 21;
 export const UINT16 = 22;
 export const INT32 = 23;
 export const UINT32 = 7;
-export const INT64 = 24;
 export const BOOLEAN = 9;
 export const ENUM = 10;
 export const STRING = 11;

package/dist/def/utils.js

@@ -1,7 +1,7 @@
-import { INT16, INT32, INT64, INT8, UINT16, UINT32, UINT8, NUMBER, TIMESTAMP, } from './types.js';
+import { INT16, INT32, INT8, UINT16, UINT32, UINT8, NUMBER, TIMESTAMP, } from './types.js';
 export const propIsSigned = (prop) => {
     const t = prop.typeIndex;
-    if (t === INT16 || t === INT32 || t === INT64 || t === INT8) {
+    if (t === INT16 || t === INT32 || t === INT8) {
         return true;
     }
     return false;
@@ -10,7 +10,6 @@ export const propIsNumerical = (prop) => {
     const t = prop.typeIndex;
     if (t === INT16 ||
         t === INT32 ||
-        t === INT64 ||
         t === INT8 ||
         t === UINT8 ||
         t === UINT16 ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@based/schema",
-  "version": "5.0.0-alpha.4",
+  "version": "5.0.0-alpha.5",
   "license": "MIT",
   "files": [
     "dist",