@based/schema 5.0.3 → 5.0.4

package/dist/dbSchema.js

@@ -1,6 +1,39 @@
 import { hash } from '@based/hash';
 import { getPropType } from "./parse/utils.js";
 import { deepCopy } from '@based/utils';
+function _makeEdgeTypes(newTypes, typeName, props, propPrefix) {
+    const putEdgeProps = (typeName, refPath, edgeProps) => newTypes[`_${typeName}:${refPath}`] = { 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, 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, 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 +78,10 @@ export const strictSchemaToDbSchema = (schema) => {
         };
         delete dbSchema.props;
     }
+    const edgeTypes = makeEdgeTypes(dbSchema.types);
+    for (const et in edgeTypes) {
+        dbSchema.types[et] = edgeTypes[et];
+    }
     // Assign typeIds
     for (const typeName in dbSchema.types) {
         if (!('id' in dbSchema.types[typeName])) {

package/dist/def/selvaBuffer.js

@@ -48,13 +48,13 @@ function makeEdgeConstraintFlags(refSet, nodeTypeId, prop, dstNodeTypeId, invers
             inverseProp.typeIndex === REFERENCES
             ? EDGE_FIELD_CONSTRAINT_FLAG_SKIP_DUMP
             : 0x00;
-    if (refSet) {
+    if (inverseProp) {
         const x = refSet.add(nodeTypeId, prop.prop, dstNodeTypeId, inverseProp.prop);
         flags |= x ? 0x00 : EDGE_FIELD_CONSTRAINT_FLAG_SKIP_DUMP;
     }
     return flags;
 }
-const propDefBuffer = (refSet, nodeTypeId, schema, prop, isEdge) => {
+const propDefBuffer = (refSet, nodeTypeId, schema, prop) => {
     const type = prop.typeIndex;
     const selvaType = selvaTypeMap[type];
     if (prop.len && (type === MICRO_BUFFER || type === VECTOR)) {
@@ -74,41 +74,22 @@ const propDefBuffer = (refSet, nodeTypeId, schema, prop, isEdge) => {
         return [...buf];
     }
     else if (type === REFERENCE || type === REFERENCES) {
-        const buf = new Uint8Array(9);
+        const buf = new Uint8Array(7);
         const view = new DataView(buf.buffer);
         const dstType = schema[prop.inverseTypeName];
-        let eschema = [];
         // @ts-ignore
-        buf[0] = selvaType + 2 * !!isEdge; // field type
+        buf[0] = selvaType + 2 * !!prop.__isEdge; // field type
         buf[1] = makeEdgeConstraintFlags(refSet, nodeTypeId, prop, dstType.id, dstType.props[prop.inversePropName]); // flags
         view.setUint16(2, dstType.id, true); // dst_node_type
-        view.setUint32(5, 0, true); // schema_len
-        if (!isEdge) {
+        if (prop.__isEdge) {
+            buf[4] = 0;
+            view.setUint16(5, 0, true);
+        }
+        else {
             buf[4] = prop.inversePropNumber;
-            if (prop.edges) {
-                const edgesS = Object.values(prop.edges);
-                if (edgesS.length) {
-                    const props = edgesS
-                        .filter((v) => v.separate === true)
-                        .sort((a, b) => (a.prop > b.prop ? 1 : -1));
-                    const p = [
-                        {
-                            ...EMPTY_MICRO_BUFFER,
-                            len: prop.edgeMainLen || 1, // allow zero here... else useless padding
-                            __isEdgeDef: true,
-                        },
-                        // or handle this here...
-                        ...props,
-                    ];
-                    eschema = p
-                        .map((prop) => propDefBuffer(null, 0, schema, prop, true))
-                        .flat(1);
-                    eschema.unshift(0, 0, 0, 0, sepPropCount(p), 0, 0, 0);
-                    view.setUint32(5, eschema.length, true);
-                }
-            }
+            view.setUint16(5, prop.edgeNodeTypeId, true); // meta_node_type
         }
-        return [...buf, ...eschema];
+        return [...buf];
     }
     else if (type === STRING ||
         type === BINARY ||
@@ -153,7 +134,7 @@ export function schemaToSelvaBuffer(schema) {
             1 + refFields, // u8 nrFixedFields
             virtualFields, // u8 nrVirtualFields
             0, // u8 spare1
-            ...propDefBuffer(null, t.id, schema, {
+            ...propDefBuffer(refSet, t.id, schema, {
                 ...EMPTY_MICRO_BUFFER,
                 len: t.mainLen === 0 ? 1 : t.mainLen,
             }),

package/dist/def/typeDef.js

@@ -1,10 +1,10 @@
 import { isPropType, getPropType, } 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, } from './types.js';
+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';
 import { makeSeparateTextSort } from './makeSeparateTextSort.js';
 import { makeSeparateSort } from './makeSeparateSort.js';
-import { getPropLen, isSeparate, parseMinMaxStep, reorderProps, schemaVectorBaseTypeToEnum, sortMainProps, } from './utils.js';
+import { getPropLen, isSeparate, parseMinMaxStep, reorderProps, schemaVectorBaseTypeToEnum, sortMainProps, cardinalityModeToEnum, } from './utils.js';
 import { addEdges } from './addEdges.js';
 import { createEmptyDef } from './createEmptyDef.js';
 import { fillEmptyMain, isZeroes } from './fillEmptyMain.js';
@@ -17,27 +17,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('.')}`;
+                            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) {
@@ -82,111 +113,120 @@ 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 (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 = {
+            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.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) {
+            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;
+            }
+        }
+        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/types.d.ts

@@ -1,4 +1,4 @@
-import type { LangCode, SchemaHooks, SchemaLocales } from '../index.js';
+import type { LangCode, SchemaHooks, SchemaLocales, SchemaPropHooks } from '../index.js';
 import { Validation } from './validation.js';
 import { TypeIndex, VectorBaseType } from './typeIndexes.js';
 export * from './typeIndexes.js';
@@ -33,6 +33,9 @@ export type PropDef = {
     default: any;
     vectorBaseType?: VectorBaseType;
     vectorSize?: number;
+    cardinalityMode?: number;
+    cardinalityPrecision?: number;
+    edgeNodeTypeId?: number;
     edgeMainLen?: 0;
     hasDefaultEdges?: boolean;
     reverseEnum?: {
@@ -53,6 +56,7 @@ export type PropDef = {
     max?: any;
     min?: any;
     step?: any;
+    hooks?: SchemaPropHooks;
 };
 export type PropDefEdge = Partial<PropDef> & {
     __isPropDef: true;
@@ -86,7 +90,6 @@ export type SchemaTypeDef = {
     cnt: number;
     checksum: number;
     type: string;
-    lastId: number;
     blockCapacity: number;
     mainLen: number;
     insertOnly: boolean;
@@ -128,6 +131,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/utils.d.ts

@@ -1,9 +1,10 @@
 import { PropDef, PropDefEdge, VectorBaseType } from './types.js';
-import { SchemaProp, SchemaVectorBaseType } from '../types.js';
+import { SchemaProp, SchemaVectorBaseType, HLLRegisterRepresentation } 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 const schemaVectorBaseTypeToEnum: (vector: SchemaVectorBaseType) => VectorBaseType;
+export declare const cardinalityModeToEnum: (mode: HLLRegisterRepresentation) => number;
 export declare function getPropLen(schemaProp: SchemaProp): number;
 export declare const parseMinMaxStep: (val: any) => string | number;
 export declare const sortMainProps: (a: PropDef | PropDefEdge, b: PropDef | PropDefEdge) => 0 | 1 | -1;

package/dist/def/utils.js

@@ -1,5 +1,5 @@
 import { INT16, INT32, INT8, UINT16, UINT32, UINT8, NUMBER, TIMESTAMP, SIZE_MAP, VECTOR_BASE_TYPE_SIZE_MAP, VectorBaseType, REVERSE_SIZE_MAP, REFERENCES, REFERENCE, ALIAS, ALIASES, COLVEC, } from './types.js';
-import { isPropType } from '../types.js';
+import { isPropType, } from '../types.js';
 import { getPropType } from '../parse/utils.js';
 import { convertToTimestamp } from '@based/utils';
 export function isSeparate(schemaProp, len) {
@@ -50,6 +50,12 @@ export const schemaVectorBaseTypeToEnum = (vector) => {
             return VectorBaseType.Float64;
     }
 };
+export const cardinalityModeToEnum = (mode) => {
+    if (mode === 'dense')
+        return 1;
+    else
+        0;
+};
 export function getPropLen(schemaProp) {
     let len = SIZE_MAP[getPropType(schemaProp)];
     if (isPropType('string', schemaProp) ||

package/dist/parse/props.js

@@ -58,6 +58,12 @@ const shared = {
     validation(val) {
         expectFunction(val);
     },
+    hooks(val, prop, ctx) {
+        expectObject(val);
+        for (const key in val) {
+            expectFunction(val[key]);
+        }
+    },
 };
 function propParser(required, optional, allowShorthand) {
     return (prop, ctx) => {
@@ -504,6 +510,18 @@ p.cardinality = propParser(STUB, {
     default(val, prop, ctx) {
         return isDefault(val, prop, ctx);
     },
+    mode(val, prop, ctx) {
+        if (!['dense', 'sparse'].includes(val)) {
+            throw Error(INVALID_VALUE);
+        }
+        p.mode = val;
+    },
+    precision(val, prop, ctx) {
+        if (val < 2 || val > 16) {
+            throw Error(INVALID_VALUE);
+        }
+        p.precision = val;
+    },
 }, 0);
 p.json = propParser(STUB, {
     default(val, prop, ctx) {

package/dist/parse/utils.js

@@ -17,6 +17,11 @@ export const getPropType = (prop, props, key) => {
     }
     if ('items' in prop) {
         if (getPropType(prop.items) === 'reference') {
+            Object.keys(prop.items).filter((v) => v[0] === '$').forEach((v) => {
+                if (typeof prop.items[v] === 'string') {
+                    prop.items[v] = { type: prop.items[v] };
+                }
+            });
             return 'references';
         }
         return 'set';

package/dist/types.d.ts

@@ -2,7 +2,7 @@ import type { LangName } from './lang.js';
 import type { Validation } from './def/validation.js';
 type Role = 'title' | 'source' | 'media' | string;
 export declare const numberDisplays: readonly ["short", "human", "ratio", "bytes", "euro", "dollar", "pound", "meter"];
-export declare const dateDisplays: readonly ["date", "date-time", "date-time-text", "date-time-human", "date-time-human-short", "time", "time-precise"];
+export declare const dateDisplays: readonly ["date", "date-time", "date-time-text", "date-time-human", "time", "time-precise"];
 export declare const stringFormats: readonly ["alpha", "alphaLocales", "alphanumeric", "alphanumericLocales", "ascii", "base32", "base58", "base64", "BIC", "btcAddress", "clike", "code", "creditCard", "css", "currency", "dataURI", "EAN", "email", "ethereumAddress", "FQDN", "hexadecimal", "hexColor", "HSL", "html", "IBAN", "identityCard", "IMEI", "IP", "IPRange", "ISBN", "ISIN", "ISO31661Alpha2", "ISO31661Alpha3", "ISO4217", "ISO6391", "ISO8601", "ISRC", "ISSN", "javascript", "json", "JWT", "latLong", "licensePlate", "lowercase", "luhnNumber", "MACAddress", "magnetURI", "markdown", "MD5", "mimeType", "mobilePhone", "mobilePhoneLocales", "octal", "password", "passportNumber", "port", "postalCode", "postalCodeLocales", "python", "RFC3339", "rgbColor", "rust", "semVer", "slug", "surrogatePair", "taxID", "typescript", "uppercase", "URL", "UUID", "VAT", "multiline"];
 type DateDisplay = (typeof dateDisplays)[number];
 type NumberDisplay = (typeof numberDisplays)[number] | `round-${number}`;
@@ -27,6 +27,7 @@ type Prop<V extends PropValues> = {
     readOnly?: boolean;
     examples?: string[];
     validation?: Validation;
+    hooks?: SchemaPropHooks;
 } & V;
 type EnumItem = string | number | boolean;
 type NeverInItems = {
@@ -85,11 +86,12 @@ export type SchemaBoolean = Prop<{
     type: 'boolean';
     default?: boolean;
 }>;
+export type HLLRegisterRepresentation = 'sparse' | 'dense';
 export type SchemaCardinality = Prop<{
     type: 'cardinality';
     maxBytes?: number;
-    mime?: Mime;
-    format?: NumberDisplay;
+    precision?: number;
+    mode?: HLLRegisterRepresentation;
 }>;
 type VectorDefaultType = Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
 export type SchemaVectorBaseType = NumberType | 'float32' | 'float64';
@@ -195,6 +197,19 @@ export type SchemaHooks = {
     groupBy?: (query: BasedDbQuery, field: string) => void;
     aggregate?: (query: BasedDbQuery, fields: Set<string>) => void;
 };
+export type SchemaPropHooks = {
+    create?: (value: any, payload: Record<string, any>) => any;
+    update?: (value: any, payload: Record<string, any>) => any;
+    read?: (value: any, result: Record<string, any>) => any;
+    aggregate?: (query: BasedDbQuery, fields: Set<string>) => void;
+    search?: (query: BasedDbQuery, fields: Set<string>) => void;
+    groupBy?: (query: BasedDbQuery, field: string) => void;
+    filter?: (query: BasedDbQuery, field: string, operator: Operator, value: any) => void;
+    include?: (query: BasedDbQuery, fields: Map<string, {
+        field: string;
+        opts?: any;
+    }>) => void;
+};
 type GenericSchemaType<isStrict = false> = {
     hooks?: SchemaHooks;
     id?: number;

package/dist/types.js

@@ -14,7 +14,6 @@ export const dateDisplays = [
     'date-time',
     'date-time-text',
     'date-time-human',
-    'date-time-human-short',
     'time',
     'time-precise',
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@based/schema",
-  "version": "5.0.3",
+  "version": "5.0.4",
   "files": [
     "dist",
     "README.md",
@@ -15,6 +15,7 @@
     ".": "./dist/index.js"
   },
   "scripts": {
+    "clean": "rm -rf .node_modules ./dist ./tsconfig.tsbuildinfo",
     "build": "tsc",
     "watch": "tsc --watch",
     "test": "tsc && tsc $npm_config --noEmit && tsx --test $npm_config"
@@ -30,7 +31,7 @@
     "typescript": "^5.6.3"
   },
   "dependencies": {
-    "@based/utils": "^1.0.0",
+    "@based/utils": "1.1.1",
     "picocolors": "^1.1.0"
   }
 }