@based/schema 5.0.0-alpha.2 → 5.0.0-alpha.20

package/dist/def/typeDef.js

@@ -0,0 +1,203 @@
+import { isPropType, getPropType, } from '../index.js';
+import { setByPath } from '@saulx/utils';
+import { TYPE_INDEX_MAP, REFERENCES, REFERENCE, NUMBER, } from './types.js';
+import { DEFAULT_MAP } from './defaultMap.js';
+import { makeSeparateTextSort } from './makeSeparateTextSort.js';
+import { makeSeparateSort } from './makeSeparateSort.js';
+import { getPropLen, isSeparate, parseMinMaxStep } from './utils.js';
+import { addEdges } from './addEdges.js';
+import { createEmptyDef } from './createEmptyDef.js';
+import { fillEmptyMain, isZeroes } from './fillEmptyMain.js';
+import { defaultValidation, VALIDATION_MAP } from './validation.js';
+export const DEFAULT_BLOCK_CAPACITY = 100_000;
+export const updateTypeDefs = (schema) => {
+    const schemaTypesParsed = {};
+    const schemaTypesParsedById = {};
+    for (const field in schemaTypesParsed) {
+        if (field in schema.types) {
+            continue;
+        }
+        const id = schemaTypesParsed[field].id;
+        delete schemaTypesParsed[field];
+        delete schemaTypesParsedById[id];
+    }
+    for (const field in schema.types) {
+        const type = schema.types[field];
+        if (!type.id) {
+            throw new Error('NEED ID ON TYPE');
+        }
+        const def = createSchemaTypeDef(field, type, schemaTypesParsed, schema.locales ?? {
+            en: {},
+        });
+        def.blockCapacity = field === '_root' ? 2147483647 : DEFAULT_BLOCK_CAPACITY;
+        schemaTypesParsed[field] = def;
+        schemaTypesParsedById[type.id] = def;
+    }
+    return { schemaTypesParsed, schemaTypesParsedById };
+};
+export const createSchemaTypeDef = (typeName, type, parsed, locales, result = createEmptyDef(typeName, type, locales), path = [], top = true) => {
+    if (result.id == 0 && top) {
+        if ('id' in type) {
+            result.id = type.id;
+        }
+        else {
+            throw new Error(`Invalid schema type id ${result.type}`);
+        }
+    }
+    result.locales = locales;
+    result.localeSize = Object.keys(locales).length;
+    result.idUint8[0] = result.id & 255;
+    result.idUint8[1] = result.id >> 8;
+    const target = type.props;
+    for (const key in target) {
+        // Create prop def
+        const schemaProp = target[key];
+        const propPath = [...path, key];
+        const propType = getPropType(schemaProp);
+        if (propType === 'object') {
+            createSchemaTypeDef(typeName, schemaProp, parsed, locales, result, propPath, false);
+        }
+        else {
+            const len = getPropLen(schemaProp);
+            if (isPropType('string', schemaProp) ||
+                isPropType('alias', schemaProp) ||
+                isPropType('cardinality', schemaProp)) {
+                if (typeof schemaProp === 'object') {
+                    if (!(schemaProp.maxBytes < 61) ||
+                        !('max' in schemaProp && schemaProp.max < 31)) {
+                        result.separateSortProps++;
+                    }
+                }
+                else {
+                    result.separateSortProps++;
+                }
+            }
+            else if (isPropType('text', schemaProp)) {
+                result.separateSortText++;
+            }
+            const isseparate = isSeparate(schemaProp, len);
+            const typeIndex = TYPE_INDEX_MAP[propType];
+            const prop = {
+                typeIndex,
+                __isPropDef: true,
+                separate: isseparate,
+                path: propPath,
+                start: 0,
+                validation: schemaProp.validation ??
+                    VALIDATION_MAP[typeIndex] ??
+                    defaultValidation,
+                len,
+                default: schemaProp.default ?? DEFAULT_MAP[typeIndex],
+                prop: isseparate ? ++result.cnt : 0,
+            };
+            if (schemaProp.max !== undefined) {
+                prop.max = parseMinMaxStep(schemaProp.max);
+            }
+            if (schemaProp.min !== undefined) {
+                prop.min = parseMinMaxStep(schemaProp.min);
+            }
+            if (schemaProp.step !== undefined) {
+                prop.step = parseMinMaxStep(schemaProp.step);
+            }
+            if (prop.typeIndex !== NUMBER && prop.step === undefined) {
+                prop.step = 1;
+            }
+            if (isPropType('enum', schemaProp)) {
+                prop.enum = Array.isArray(schemaProp) ? schemaProp : schemaProp.enum;
+                prop.reverseEnum = {};
+                for (let i = 0; i < prop.enum.length; i++) {
+                    prop.reverseEnum[prop.enum[i]] = i;
+                }
+            }
+            else if (isPropType('references', schemaProp)) {
+                prop.inversePropName = schemaProp.items.prop;
+                prop.inverseTypeName = schemaProp.items.ref;
+                prop.dependent = schemaProp.items.dependent;
+                addEdges(prop, schemaProp.items);
+            }
+            else if (isPropType('reference', schemaProp)) {
+                prop.inversePropName = schemaProp.prop;
+                prop.inverseTypeName = schemaProp.ref;
+                prop.dependent = schemaProp.dependent;
+                addEdges(prop, schemaProp);
+            }
+            else if (typeof schemaProp === 'object') {
+                if (isPropType('string', schemaProp) ||
+                    isPropType('text', schemaProp)) {
+                    prop.compression =
+                        'compression' in schemaProp && schemaProp.compression === 'none'
+                            ? 0
+                            : 1;
+                }
+                else if (isPropType('timestamp', schemaProp) && 'on' in schemaProp) {
+                    if (schemaProp.on[0] === 'c') {
+                        result.createTs ??= [];
+                        result.createTs.push(prop);
+                    }
+                    else if (schemaProp.on[0] === 'u') {
+                        result.createTs ??= [];
+                        result.createTs.push(prop);
+                        result.updateTs ??= [];
+                        result.updateTs.push(prop);
+                    }
+                }
+            }
+            result.props[propPath.join('.')] = prop;
+            if (isseparate) {
+                result.separate.push(prop);
+            }
+        }
+    }
+    if (top) {
+        // Put top level together
+        const vals = Object.values(result.props);
+        vals.sort((a, b) => {
+            if (b.separate &&
+                (a.typeIndex === REFERENCES || a.typeIndex === REFERENCE)) {
+                return -1;
+            }
+            return a.prop - b.prop;
+        });
+        let lastProp = 0;
+        for (const p of vals) {
+            if (p.separate) {
+                p.prop = ++lastProp;
+            }
+        }
+        let len = 2;
+        for (const f of vals) {
+            if (f.separate) {
+                len += 2;
+                setByPath(result.tree, f.path, f);
+            }
+            else {
+                if (!result.mainLen) {
+                    len += 2;
+                }
+                len += 1;
+                f.start = result.mainLen;
+                result.mainLen += f.len;
+                setByPath(result.tree, f.path, f);
+            }
+        }
+        result.mainEmpty = fillEmptyMain(vals, result.mainLen);
+        result.mainEmptyAllZeroes = isZeroes(result.mainEmpty);
+        if (result.separateSortText > 0) {
+            makeSeparateTextSort(result);
+        }
+        if (result.separateSortProps > 0) {
+            makeSeparateSort(result);
+        }
+        for (const p in result.props) {
+            const x = result.props[p];
+            if (!x.separate) {
+                result.main[x.start] = x;
+            }
+            else {
+                result.reverseProps[x.prop] = x;
+            }
+        }
+    }
+    return result;
+};
+//# sourceMappingURL=typeDef.js.map

package/dist/def/types.d.ts

@@ -0,0 +1,179 @@
+import type { LangCode, SchemaLocales } from '../index.js';
+import { Validation } from './validation.js';
+export declare const NULL = 0;
+export declare const TIMESTAMP = 1;
+export declare const NUMBER = 4;
+export declare const CARDINALITY = 5;
+export declare const INT8 = 20;
+export declare const UINT8 = 6;
+export declare const INT16 = 21;
+export declare const UINT16 = 22;
+export declare const INT32 = 23;
+export declare const UINT32 = 7;
+export declare const BOOLEAN = 9;
+export declare const ENUM = 10;
+export declare const STRING = 11;
+export declare const TEXT = 12;
+export declare const REFERENCE = 13;
+export declare const REFERENCES = 14;
+export declare const WEAK_REFERENCE = 15;
+export declare const WEAK_REFERENCES = 16;
+export declare const MICRO_BUFFER = 17;
+export declare const ALIAS = 18;
+export declare const ALIASES = 19;
+export declare const BINARY = 25;
+export declare const ID = 26;
+export declare const VECTOR = 27;
+export declare const JSON = 28;
+export declare const OBJECT = 29;
+export declare const TYPE_INDEX_MAP: {
+    alias: number;
+    aliases: number;
+    microbuffer: number;
+    references: number;
+    reference: number;
+    timestamp: number;
+    boolean: number;
+    number: number;
+    string: number;
+    text: number;
+    uint16: number;
+    uint32: number;
+    int16: number;
+    int32: number;
+    uint8: number;
+    enum: number;
+    int8: number;
+    id: number;
+    binary: number;
+    vector: number;
+    cardinality: number;
+    json: number;
+    object: number;
+};
+export declare const enum numberTypes {
+    number = 4,
+    uint16 = 22,
+    uint32 = 7,
+    int16 = 21,
+    int32 = 23,
+    uint8 = 6,
+    int8 = 20,
+    cardinality = 5
+}
+export declare function isNumberType(type: TypeIndex): boolean;
+export type InternalSchemaProp = keyof typeof TYPE_INDEX_MAP;
+export type TypeIndex = (typeof TYPE_INDEX_MAP)[InternalSchemaProp];
+export type PropDef = {
+    __isPropDef: true;
+    prop: number;
+    typeIndex: TypeIndex;
+    separate: boolean;
+    path: string[];
+    start: number;
+    len: number;
+    inverseTypeName?: string;
+    inversePropName?: string;
+    compression?: 0 | 1;
+    inverseTypeId?: number;
+    inversePropNumber?: number;
+    enum?: any[];
+    dependent?: boolean;
+    validation: Validation;
+    default: any;
+    edgeMainLen?: 0;
+    reverseEnum?: {
+        [key: string]: number;
+    };
+    edgesSeperateCnt?: number;
+    edges?: {
+        [key: string]: PropDefEdge;
+    };
+    reverseSeperateEdges?: {
+        [prop: string]: PropDefEdge;
+    };
+    reverseMainEdges?: {
+        [start: string]: PropDefEdge;
+    };
+    edgeMainEmpty?: Uint8Array;
+    __isEdge?: boolean;
+    max?: any;
+    min?: any;
+    step?: any;
+};
+export type PropDefEdge = Partial<PropDef> & {
+    __isPropDef: true;
+    typeIndex: TypeIndex;
+    len: number;
+    prop: number;
+    name: string;
+    edgesTotalLen?: number;
+    __isEdge: true;
+};
+export type PropDefAggregate = Partial<PropDef> & {
+    __isPropDef: true;
+    typeIndex: TypeIndex;
+    len: number;
+    prop: number;
+    name: string;
+};
+export type SchemaPropTree = {
+    [key: string]: SchemaPropTree | PropDef;
+};
+export type SchemaSortUndefinedHandler = {
+    size: number;
+    buffer: Uint8Array;
+    bufferTmp: Uint8Array;
+    props: PropDef[];
+};
+export type SchemaTypeDef = {
+    cnt: number;
+    checksum: number;
+    type: string;
+    lastId: number;
+    blockCapacity: number;
+    mainLen: number;
+    buf: Uint8Array;
+    propNames: Uint8Array;
+    props: {
+        [path: string]: PropDef;
+    };
+    reverseProps: {
+        [field: string]: PropDef;
+    };
+    id: number;
+    idUint8: Uint8Array;
+    separate: PropDef[];
+    main: {
+        [start: string]: PropDef;
+    };
+    mainEmpty: Uint8Array;
+    mainEmptyAllZeroes: boolean;
+    tree: SchemaPropTree;
+    separateSortProps: number;
+    separateSortText: number;
+    hasSeperateSort: boolean;
+    seperateSort: SchemaSortUndefinedHandler;
+    hasSeperateTextSort: boolean;
+    seperateTextSort: SchemaSortUndefinedHandler & {
+        noUndefined: Uint8Array;
+        localeStringToIndex: Map<string, Uint8Array>;
+        localeToIndex: Map<LangCode, number>;
+    };
+    createTs?: PropDef[];
+    updateTs?: PropDef[];
+    locales: Partial<SchemaLocales>;
+    localeSize: number;
+};
+export declare const SIZE_MAP: Record<InternalSchemaProp, number>;
+export declare const REVERSE_SIZE_MAP: Record<TypeIndex, number>;
+export declare const REVERSE_TYPE_INDEX_MAP: Record<TypeIndex, InternalSchemaProp>;
+export declare const ID_FIELD_DEF: PropDef;
+export declare const EMPTY_MICRO_BUFFER: PropDef;
+export declare const getPropTypeName: (propType: TypeIndex) => InternalSchemaProp;
+export declare const isPropDef: (prop: any) => prop is PropDef;
+export type SchemaTypesParsed = {
+    [key: string]: SchemaTypeDef;
+};
+export type SchemaTypesParsedById = Record<number, SchemaTypeDef>;
+//# sourceMappingURL=types.d.ts.map

package/dist/def/types.js

@@ -0,0 +1,132 @@
+// WARN: The following type codes are used in js and zig but selva has its own typing.
+export const NULL = 0;
+export const TIMESTAMP = 1;
+export const NUMBER = 4;
+export const CARDINALITY = 5;
+export const INT8 = 20;
+export const UINT8 = 6;
+export const INT16 = 21;
+export const UINT16 = 22;
+export const INT32 = 23;
+export const UINT32 = 7;
+export const BOOLEAN = 9;
+export const ENUM = 10;
+export const STRING = 11;
+export const TEXT = 12;
+export const REFERENCE = 13;
+export const REFERENCES = 14;
+export const WEAK_REFERENCE = 15;
+export const WEAK_REFERENCES = 16;
+export const MICRO_BUFFER = 17;
+export const ALIAS = 18;
+export const ALIASES = 19;
+export const BINARY = 25;
+export const ID = 26;
+export const VECTOR = 27;
+export const JSON = 28;
+export const OBJECT = 29;
+export const TYPE_INDEX_MAP = {
+    alias: ALIAS,
+    aliases: ALIASES,
+    microbuffer: MICRO_BUFFER,
+    references: REFERENCES,
+    reference: REFERENCE,
+    timestamp: TIMESTAMP,
+    boolean: BOOLEAN,
+    number: NUMBER,
+    string: STRING,
+    text: TEXT,
+    uint16: UINT16,
+    uint32: UINT32,
+    int16: INT16,
+    int32: INT32,
+    uint8: UINT8,
+    enum: ENUM,
+    int8: INT8,
+    id: NULL,
+    binary: BINARY,
+    vector: VECTOR,
+    cardinality: CARDINALITY,
+    json: JSON,
+    object: OBJECT,
+};
+const numberTypeValues = [
+    NUMBER,
+    UINT16,
+    UINT32,
+    INT16,
+    INT32,
+    UINT8,
+    INT8,
+    CARDINALITY,
+];
+export function isNumberType(type) {
+    return numberTypeValues.includes(type);
+}
+export const SIZE_MAP = {
+    timestamp: 8, // 64bit
+    // double-precision 64-bit binary format IEEE 754 value
+    number: 8, // 64bit
+    int8: 1,
+    uint8: 1,
+    int16: 2,
+    uint16: 2,
+    int32: 4,
+    uint32: 4,
+    boolean: 1,
+    reference: 0, // separate
+    enum: 1, // enum
+    string: 0, // separate
+    text: 0, // separate
+    cardinality: 0, // separate
+    references: 0, // separate
+    microbuffer: 0, // separate
+    alias: 0,
+    aliases: 0,
+    id: 4,
+    binary: 0,
+    vector: 0, // separate
+    json: 0,
+    object: 0,
+};
+const reverseMap = {};
+for (const k in TYPE_INDEX_MAP) {
+    reverseMap[TYPE_INDEX_MAP[k]] = k;
+}
+export const REVERSE_SIZE_MAP = {};
+for (const k in SIZE_MAP) {
+    REVERSE_SIZE_MAP[TYPE_INDEX_MAP[k]] = SIZE_MAP[k];
+}
+export const REVERSE_TYPE_INDEX_MAP = reverseMap;
+export const ID_FIELD_DEF = {
+    typeIndex: TYPE_INDEX_MAP['id'],
+    separate: true,
+    path: ['id'],
+    start: 0,
+    prop: 255,
+    default: 0,
+    len: 4,
+    validation: () => true,
+    __isPropDef: true,
+};
+export const EMPTY_MICRO_BUFFER = {
+    typeIndex: TYPE_INDEX_MAP['microbuffer'],
+    separate: true,
+    path: [''],
+    start: 0,
+    default: undefined,
+    prop: 0,
+    len: 1,
+    validation: () => true,
+    __isPropDef: true,
+};
+export const getPropTypeName = (propType) => {
+    return REVERSE_TYPE_INDEX_MAP[propType];
+};
+export const isPropDef = (prop) => {
+    if ('__isPropDef' in prop && prop.__isPropDef === true) {
+        return true;
+    }
+    return false;
+};
+//# sourceMappingURL=types.js.map

package/dist/def/utils.d.ts

@@ -0,0 +1,8 @@
+import { PropDef, PropDefEdge } from './types.js';
+import { SchemaProp } from '../types.js';
+export declare function isSeparate(schemaProp: SchemaProp, len: number): boolean;
+export declare const propIsSigned: (prop: PropDef | PropDefEdge) => boolean;
+export declare const propIsNumerical: (prop: PropDef | PropDefEdge) => boolean;
+export declare function getPropLen(schemaProp: SchemaProp): any;
+export declare const parseMinMaxStep: (val: any) => string | number;
+//# sourceMappingURL=utils.d.ts.map

package/dist/def/utils.js

@@ -0,0 +1,59 @@
+import { INT16, INT32, INT8, UINT16, UINT32, UINT8, NUMBER, TIMESTAMP, SIZE_MAP, } from './types.js';
+import { isPropType } from '../types.js';
+import { getPropType } from '../parse/utils.js';
+import { convertToTimestamp } from '@saulx/utils';
+export function isSeparate(schemaProp, len) {
+    return len === 0 || isPropType('vector', schemaProp);
+}
+export const propIsSigned = (prop) => {
+    const t = prop.typeIndex;
+    if (t === INT16 || t === INT32 || t === INT8) {
+        return true;
+    }
+    return false;
+};
+export const propIsNumerical = (prop) => {
+    const t = prop.typeIndex;
+    if (t === INT16 ||
+        t === INT32 ||
+        t === INT8 ||
+        t === UINT8 ||
+        t === UINT16 ||
+        t === UINT32 ||
+        t === NUMBER ||
+        t === TIMESTAMP) {
+        return true;
+    }
+    return false;
+};
+export 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;
+}
+export const parseMinMaxStep = (val) => {
+    if (typeof val === 'number') {
+        return val;
+    }
+    if (typeof val === 'string') {
+        if (!val.includes('now')) {
+            return convertToTimestamp(val);
+        }
+        return val;
+    }
+};
+//# sourceMappingURL=utils.js.map

package/dist/def/validation.d.ts

@@ -0,0 +1,7 @@
+import { TypeIndex, PropDef, PropDefEdge } from './types.js';
+export type Validation = (payload: any, prop: PropDef | PropDefEdge) => boolean;
+export declare const VALIDATION_MAP: Record<TypeIndex, Validation>;
+export declare const defaultValidation: () => boolean;
+export declare const isValidId: (id: number) => boolean;
+export declare const isValidString: (v: any) => boolean;
+//# sourceMappingURL=validation.d.ts.map