@based/schema 5.0.4-alpha.1 → 5.1.0

package/dist/dbSchema.d.ts

@@ -1,4 +1,4 @@
-import { StrictSchema } from "./types.js";
+import { StrictSchema } from './types.js';
 export type DbSchema = StrictSchema & {
     lastId: number;
     hash: number;

package/dist/dbSchema.js

@@ -1,6 +1,43 @@
 import { hash } from '@based/hash';
-import { getPropType } from "./parse/utils.js";
+import { getPropType } from './parse/utils.js';
 import { deepCopy } from '@based/utils';
+function _makeEdgeTypes(newTypes, typeName, props, propPrefix) {
+    const putEdgeProps = (from, to, edgeProps) => (newTypes[`_${[from, to].sort().join(':')}`] = { props: edgeProps });
+    for (const propName in props) {
+        const prop = props[propName];
+        const propType = getPropType(prop);
+        const nextPropPrefix = propPrefix ? `${propPrefix}.${propName}` : propName;
+        if (propType === 'object') {
+            _makeEdgeTypes(newTypes, typeName, prop.props, nextPropPrefix);
+        }
+        else if (propType === 'reference') {
+            const edgeProps = {};
+            Object.keys(prop)
+                .filter((k) => k[0] === '$')
+                .forEach((k) => (edgeProps[k] = prop[k]));
+            if (Object.keys(edgeProps).length > 0) {
+                putEdgeProps(`${typeName}.${nextPropPrefix}`, `${prop.ref}.${prop.prop}`, edgeProps);
+            }
+        }
+        else if (propType === 'references') {
+            const edgeProps = {};
+            Object.keys(prop.items)
+                .filter((k) => k[0] === '$')
+                .forEach((k) => (edgeProps[k] = prop.items[k]));
+            if (Object.keys(edgeProps).length > 0) {
+                putEdgeProps(`${typeName}.${nextPropPrefix}`, `${prop.items.ref}.${prop.items.prop}`, edgeProps);
+            }
+        }
+    }
+}
+function makeEdgeTypes(types) {
+    const newTypes = {};
+    for (const typeName in types) {
+        const type = types[typeName];
+        _makeEdgeTypes(newTypes, typeName, type.props, '');
+    }
+    return newTypes;
+}
 export const strictSchemaToDbSchema = (schema) => {
     // @ts-ignore
     let dbSchema = deepCopy(schema);
@@ -45,6 +82,40 @@ export const strictSchemaToDbSchema = (schema) => {
         };
         delete dbSchema.props;
     }
+    const edgeTypes = makeEdgeTypes(dbSchema.types);
+    // Create inverse props for reference(s)
+    for (const et in edgeTypes) {
+        dbSchema.types[et] = edgeTypes[et];
+        for (const key in edgeTypes[et].props) {
+            const prop = edgeTypes[et].props[key];
+            const propType = getPropType(prop);
+            let refProp;
+            if (propType === 'reference') {
+                refProp = prop;
+            }
+            else if (propType === 'references') {
+                refProp = prop.items;
+            }
+            else {
+                continue; // not a ref
+            }
+            const type = dbSchema.types[refProp.ref];
+            const inverseKey = `_${et}_${key}`;
+            dbSchema.types[refProp.ref] = {
+                ...type,
+                props: {
+                    ...type.props,
+                    [inverseKey]: {
+                        items: {
+                            ref: et,
+                            prop: key,
+                        },
+                    },
+                },
+            };
+            refProp.prop = inverseKey;
+        }
+    }
     // Assign typeIds
     for (const typeName in dbSchema.types) {
         if (!('id' in dbSchema.types[typeName])) {

package/dist/def/addEdges.js

@@ -1,9 +1,8 @@
-import { getPropType } from '../index.js';
+import { getPropType, getValidator } from '../index.js';
 import { DEFAULT_MAP } from './defaultMap.js';
 import { fillEmptyMain } from './fillEmptyMain.js';
 import { TYPE_INDEX_MAP, REFERENCES, REFERENCE, ENUM, NUMBER, } from './types.js';
 import { getPropLen, isSeparate, parseMinMaxStep, sortMainProps, } from './utils.js';
-import { defaultValidation, VALIDATION_MAP } from './validation.js';
 export const addEdges = (prop, refProp) => {
     const mainEdges = [];
     for (const key in refProp) {
@@ -28,10 +27,11 @@ export const addEdges = (prop, refProp) => {
             }
             // add default
             const edge = {
+                schema: edgeProp,
                 __isPropDef: true,
                 __isEdge: true,
                 prop: separate ? prop.edgesSeperateCnt : 0,
-                validation: edgeProp.validation ?? VALIDATION_MAP[typeIndex] ?? defaultValidation,
+                validation: getValidator(edgeProp),
                 name: key,
                 typeIndex,
                 len,
@@ -44,13 +44,13 @@ export const addEdges = (prop, refProp) => {
                 mainEdges.push(edge);
             }
             if (edgeProp.max !== undefined) {
-                edge.max = parseMinMaxStep(edgeProp.max);
+                edgeProp.max = edge.max = parseMinMaxStep(edgeProp.max);
             }
             if (edgeProp.min !== undefined) {
-                edge.min = parseMinMaxStep(edgeProp.min);
+                edgeProp.min = edge.min = parseMinMaxStep(edgeProp.min);
             }
             if (edgeProp.step !== undefined) {
-                edge.step = parseMinMaxStep(edgeProp.step);
+                edgeProp.step = edge.step = parseMinMaxStep(edgeProp.step);
             }
             if (edge.typeIndex !== NUMBER && edge.step === undefined) {
                 edge.step = 1;

package/dist/def/createEmptyDef.d.ts

@@ -2,6 +2,7 @@ import { SchemaLocales, SchemaObject, StrictSchemaType } from '../types.js';
 export declare const createEmptyDef: (typeName: string, type: StrictSchemaType | SchemaObject, locales: Partial<SchemaLocales>) => {
     cnt: number;
     blockCapacity: number;
+    capped: number;
     insertOnly: boolean;
     partial: boolean;
     checksum: number;

package/dist/def/createEmptyDef.js

@@ -3,6 +3,7 @@ export const createEmptyDef = (typeName, type, locales) => {
     return {
         cnt: 0,
         blockCapacity: 0,
+        capped: 0,
         insertOnly: false,
         partial: false,
         checksum: hashObjectIgnoreKeyOrder(type),

package/dist/def/defaultMap.js

@@ -1,9 +1,7 @@
-import { ALIAS, BINARY, JSON, BOOLEAN, CARDINALITY, TIMESTAMP, INT16, INT32, INT8, UINT8, UINT16, UINT32, NUMBER, ENUM, ID, MICRO_BUFFER, REFERENCE, REFERENCES, STRING, TEXT, ALIASES, VECTOR, COLVEC, WEAK_REFERENCE, WEAK_REFERENCES, NULL, OBJECT, } from './types.js';
+import { ALIAS, BINARY, JSON, BOOLEAN, CARDINALITY, TIMESTAMP, INT16, INT32, INT8, UINT8, UINT16, UINT32, NUMBER, ENUM, ID, MICRO_BUFFER, REFERENCE, REFERENCES, STRING, TEXT, ALIASES, VECTOR, COLVEC, NULL, OBJECT, } from './types.js';
 export const DEFAULT_MAP = {
     [NULL]: 0,
     [OBJECT]: 0,
-    [WEAK_REFERENCE]: 0,
-    [WEAK_REFERENCES]: 0,
     [ALIAS]: '',
     [BINARY]: new Uint8Array(),
     [BOOLEAN]: false,

package/dist/def/index.d.ts

@@ -1,7 +1,6 @@
 export * from './types.js';
 export * from './typeDef.js';
 export * from './utils.js';
-export * from './selvaBuffer.js';
 export * from './createEmptyDef.js';
 export * from './defaultMap.js';
 export * from './validation.js';

package/dist/def/index.js

@@ -2,7 +2,6 @@
 export * from './types.js';
 export * from './typeDef.js';
 export * from './utils.js';
-export * from './selvaBuffer.js';
 export * from './createEmptyDef.js';
 export * from './defaultMap.js';
 export * from './validation.js';

package/dist/def/typeDef.js

@@ -1,4 +1,4 @@
-import { isPropType, getPropType, } from '../index.js';
+import { isPropType, getPropType, getValidator, } from '../index.js';
 import { setByPath } from '@based/utils';
 import { TYPE_INDEX_MAP, REFERENCES, REFERENCE, NUMBER, BLOCK_CAPACITY_MAX, BLOCK_CAPACITY_DEFAULT, BLOCK_CAPACITY_MIN, VECTOR, COLVEC, CARDINALITY, } from './types.js';
 import { DEFAULT_MAP } from './defaultMap.js';
@@ -8,7 +8,6 @@ import { getPropLen, isSeparate, parseMinMaxStep, reorderProps, schemaVectorBase
 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 updateTypeDefs = (schema) => {
     const schemaTypesParsed = {};
     const schemaTypesParsedById = {};
@@ -17,27 +16,58 @@ export const updateTypeDefs = (schema) => {
         if (!type.id) {
             throw new Error('NEED ID ON TYPE');
         }
-        const def = createSchemaTypeDef(typeName, type, schemaTypesParsed, schema.locales ?? {
+        const def = createSchemaTypeDef(typeName, type, schema.locales ?? {
             en: {},
         });
         schemaTypesParsed[typeName] = def;
         schemaTypesParsedById[type.id] = def;
     }
-    // Update inverseProps in references
     for (const schema of Object.values(schemaTypesParsed)) {
         for (const prop of Object.values(schema.props)) {
             if (prop.typeIndex === REFERENCE || prop.typeIndex === REFERENCES) {
+                // FIXME Now references in edgeType are missing __isEdge
+                // However, we can soon just delete weak refs
+                if (!prop.__isEdge && !prop.inversePropName) {
+                    prop.__isEdge = true;
+                }
                 if (!prop.__isEdge) {
+                    // Update inverseProps in references
                     const dstType = schemaTypesParsed[prop.inverseTypeName];
                     prop.inverseTypeId = dstType.id;
                     prop.inversePropNumber = dstType.props[prop.inversePropName].prop;
+                    if (prop.edges) {
+                        if (dstType.props[prop.inversePropName].edges) {
+                            // this currently is not allowed, but might be
+                            const mergedEdges = {
+                                ...dstType.props[prop.inversePropName].edges,
+                                ...prop.edges,
+                            };
+                            dstType.props[prop.inversePropName].edges = mergedEdges;
+                            prop.edges = mergedEdges;
+                        }
+                        else {
+                            dstType.props[prop.inversePropName].edges = prop.edges;
+                        }
+                    }
+                    // Update edgeNodeTypeId
+                    if (!prop.edgeNodeTypeId) {
+                        if (prop.edges) {
+                            const edgeTypeName = `_${[`${schema.type}.${prop.path.join('.')}`, `${dstType.type}.${dstType.props[prop.inversePropName].path.join('.')}`].sort().join(':')}`;
+                            const edgeType = schemaTypesParsed[edgeTypeName];
+                            prop.edgeNodeTypeId = edgeType.id;
+                            dstType.props[prop.inversePropName].edgeNodeTypeId = edgeType.id;
+                        }
+                        else {
+                            prop.edgeNodeTypeId = 0;
+                        }
+                    }
                 }
             }
         }
     }
     return { schemaTypesParsed, schemaTypesParsedById };
 };
-const createSchemaTypeDef = (typeName, type, parsed, locales, result = createEmptyDef(typeName, type, locales), path = [], top = true) => {
+const createSchemaTypeDef = (typeName, type, locales, result = createEmptyDef(typeName, type, locales), path = [], top = true) => {
     if (top) {
         if (result.id == 0) {
             if ('id' in type) {
@@ -61,6 +91,14 @@ const createSchemaTypeDef = (typeName, type, parsed, locales, result = createEmp
                     typeName === '_root' ? BLOCK_CAPACITY_MAX : BLOCK_CAPACITY_DEFAULT;
             }
         }
+        if (result.capped == 0) {
+            if ('capped' in type) {
+                if (typeof type.capped !== 'number' || type.capped < 0) {
+                    throw new Error('Invalid capped');
+                }
+                result.capped = type.capped;
+            }
+        }
         if (result.insertOnly == false && 'insertOnly' in type) {
             result.insertOnly = !!type.insertOnly;
         }
@@ -82,116 +120,121 @@ const createSchemaTypeDef = (typeName, type, parsed, locales, result = createEmp
         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 {
+            createSchemaTypeDef(typeName, schemaProp, locales, result, propPath, false);
+            continue;
+        }
+        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 if (isPropType('text', schemaProp)) {
-                result.separateSortText++;
+            else {
+                result.separateSortProps++;
             }
-            else if (isPropType('colvec', schemaProp)) {
-                if (!result.insertOnly) {
-                    throw new Error('colvec requires insertOnly');
-                }
+        }
+        else if (isPropType('text', schemaProp)) {
+            result.separateSortText++;
+        }
+        else if (isPropType('colvec', schemaProp)) {
+            if (!result.insertOnly) {
+                throw new Error('colvec requires insertOnly');
             }
-            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 (prop.typeIndex === VECTOR || prop.typeIndex === COLVEC) {
-                prop.vectorBaseType = schemaVectorBaseTypeToEnum(schemaProp.baseType ?? 'number');
-            }
-            if (prop.typeIndex === CARDINALITY) {
-                prop.cardinalityMode ??= cardinalityModeToEnum((schemaProp.mode ??= 'sparse'));
-                const prec = typeName == '_root' ? 14 : 8;
-                prop.cardinalityPrecision ??= schemaProp.precision ??= prec;
-            }
-            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;
-                }
+        }
+        const isseparate = isSeparate(schemaProp, len);
+        const typeIndex = TYPE_INDEX_MAP[propType];
+        const prop = {
+            schema: schemaProp,
+            typeIndex,
+            __isPropDef: true,
+            separate: isseparate,
+            path: propPath,
+            start: 0,
+            validation: getValidator(schemaProp),
+            len,
+            default: schemaProp.default ?? DEFAULT_MAP[typeIndex],
+            prop: isseparate ? ++result.cnt : 0,
+        };
+        if (schemaProp.hooks) {
+            result.propHooks ??= {};
+            for (const key in schemaProp.hooks) {
+                prop.hooks = schemaProp.hooks;
+                result.propHooks[key] ??= new Set();
+                result.propHooks[key].add(prop);
             }
-            else if (isPropType('references', schemaProp)) {
-                if (result.partial) {
-                    throw new Error('references is not supported with partial');
-                }
-                prop.inversePropName = schemaProp.items.prop;
-                prop.inverseTypeName = schemaProp.items.ref;
-                prop.dependent = schemaProp.items.dependent;
-                addEdges(prop, schemaProp.items);
-            }
-            else if (isPropType('reference', schemaProp)) {
-                if (result.partial) {
-                    throw new Error('reference is not supported with partial');
-                }
-                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;
+        }
+        if (schemaProp.max !== undefined) {
+            schemaProp.max = prop.max = parseMinMaxStep(schemaProp.max);
+        }
+        if (schemaProp.min !== undefined) {
+            schemaProp.min = prop.min = parseMinMaxStep(schemaProp.min);
+        }
+        if (schemaProp.step !== undefined) {
+            schemaProp.step = prop.step = parseMinMaxStep(schemaProp.step);
+        }
+        if (prop.typeIndex !== NUMBER && prop.step === undefined) {
+            prop.step = 1;
+        }
+        if (prop.typeIndex === VECTOR || prop.typeIndex === COLVEC) {
+            prop.vectorBaseType = schemaVectorBaseTypeToEnum(schemaProp.baseType ?? 'number');
+        }
+        if (prop.typeIndex === CARDINALITY) {
+            prop.cardinalityMode ??= cardinalityModeToEnum((schemaProp.mode ??= 'sparse'));
+            const prec = typeName == '_root' ? 14 : 8;
+            prop.cardinalityPrecision ??= schemaProp.precision ??= prec;
+        }
+        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)) {
+            if (result.partial) {
+                throw new Error('references is not supported with partial');
+            }
+            prop.inversePropName = schemaProp.items.prop;
+            prop.inverseTypeName = schemaProp.items.ref;
+            prop.dependent = schemaProp.items.dependent;
+            addEdges(prop, schemaProp.items);
+        }
+        else if (isPropType('reference', schemaProp)) {
+            if (result.partial) {
+                throw new Error('reference is not supported with partial');
+            }
+            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 (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);
-                    }
+                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);
-            }
+        }
+        result.props[propPath.join('.')] = prop;
+        if (isseparate) {
+            result.separate.push(prop);
         }
     }
     if (top) {

package/dist/def/typeIndexes.d.ts

@@ -14,8 +14,6 @@ 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;
@@ -25,7 +23,7 @@ export declare const VECTOR = 27;
 export declare const JSON = 28;
 export declare const OBJECT = 29;
 export declare const COLVEC = 30;
-export type TypeIndex = typeof NULL | typeof TIMESTAMP | typeof NUMBER | typeof CARDINALITY | typeof INT8 | typeof UINT8 | typeof INT16 | typeof UINT16 | typeof INT32 | typeof UINT32 | typeof BOOLEAN | typeof ENUM | typeof STRING | typeof TEXT | typeof REFERENCE | typeof REFERENCES | typeof WEAK_REFERENCE | typeof WEAK_REFERENCES | typeof MICRO_BUFFER | typeof ALIAS | typeof ALIASES | typeof BINARY | typeof ID | typeof VECTOR | typeof JSON | typeof OBJECT | typeof COLVEC;
+export type TypeIndex = typeof NULL | typeof TIMESTAMP | typeof NUMBER | typeof CARDINALITY | typeof INT8 | typeof UINT8 | typeof INT16 | typeof UINT16 | typeof INT32 | typeof UINT32 | typeof BOOLEAN | typeof ENUM | typeof STRING | typeof TEXT | typeof REFERENCE | typeof REFERENCES | typeof MICRO_BUFFER | typeof ALIAS | typeof ALIASES | typeof BINARY | typeof ID | typeof VECTOR | typeof JSON | typeof OBJECT | typeof COLVEC;
 export declare enum VectorBaseType {
     Int8 = 1,
     Uint8 = 2,

package/dist/def/typeIndexes.js

@@ -15,8 +15,6 @@ 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;

package/dist/def/types.d.ts

@@ -1,4 +1,4 @@
-import type { LangCode, SchemaHooks, SchemaLocales } from '../index.js';
+import type { LangCode, SchemaHooks, SchemaLocales, SchemaProp, SchemaPropHooks } from '../index.js';
 import { Validation } from './validation.js';
 import { TypeIndex, VectorBaseType } from './typeIndexes.js';
 export * from './typeIndexes.js';
@@ -16,6 +16,7 @@ export declare const enum numberTypes {
 export type InternalSchemaProp = keyof typeof TYPE_INDEX_MAP;
 export type PropDef = {
     __isPropDef: true;
+    schema: SchemaProp<true>;
     prop: number;
     typeIndex: TypeIndex;
     separate: boolean;
@@ -35,6 +36,7 @@ export type PropDef = {
     vectorSize?: number;
     cardinalityMode?: number;
     cardinalityPrecision?: number;
+    edgeNodeTypeId?: number;
     edgeMainLen?: 0;
     hasDefaultEdges?: boolean;
     reverseEnum?: {
@@ -55,10 +57,12 @@ export type PropDef = {
     max?: any;
     min?: any;
     step?: any;
+    hooks?: SchemaPropHooks;
 };
 export type PropDefEdge = Partial<PropDef> & {
     __isPropDef: true;
     typeIndex: TypeIndex;
+    schema: SchemaProp<true>;
     len: number;
     prop: number;
     name: string;
@@ -88,11 +92,11 @@ export type SchemaTypeDef = {
     cnt: number;
     checksum: number;
     type: string;
-    lastId: number;
     blockCapacity: number;
-    mainLen: number;
+    capped: number;
     insertOnly: boolean;
     partial: boolean;
+    mainLen: number;
     buf: Uint8Array;
     propNames: Uint8Array;
     props: {
@@ -130,6 +134,9 @@ export type SchemaTypeDef = {
     locales: Partial<SchemaLocales>;
     localeSize: number;
     hooks?: SchemaHooks;
+    propHooks?: {
+        [K in keyof SchemaPropHooks]: Set<PropDef>;
+    };
 };
 export declare const VECTOR_BASE_TYPE_SIZE_MAP: Record<VectorBaseType, number>;
 export declare const SIZE_MAP: Record<InternalSchemaProp, number>;

package/dist/def/types.js

@@ -77,6 +77,7 @@ for (const k in SIZE_MAP) {
 }
 export const REVERSE_TYPE_INDEX_MAP = reverseMap;
 export const ID_FIELD_DEF = {
+    schema: null,
     typeIndex: NULL,
     separate: true,
     path: ['id'],
@@ -88,6 +89,7 @@ export const ID_FIELD_DEF = {
     __isPropDef: true,
 };
 export const EMPTY_MICRO_BUFFER = {
+    schema: null,
     typeIndex: MICRO_BUFFER,
     separate: true,
     path: [''],

package/dist/def/validation.d.ts

@@ -1,7 +1,19 @@
-import { TypeIndex, PropDef, PropDefEdge } from './types.js';
-export type Validation = (payload: any, prop: PropDef | PropDefEdge) => boolean;
+import { TypeIndex } from './types.js';
+import { SchemaProp, StrictSchema } from '../types.js';
+export type Validation = (payload: any, schema: SchemaProp<true>) => boolean | string;
 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;
+type ValidationErrors = {
+    path: string[];
+    value: unknown;
+    error: string;
+}[];
+export declare const getValidator: (prop: SchemaProp<true>) => Validation;
+export declare function validate<S extends StrictSchema = StrictSchema>(schema: S, type: keyof S['types'], payload: unknown): {
+    valid: boolean;
+    errors: ValidationErrors;
+};
+export {};
 //# sourceMappingURL=validation.d.ts.map