@based/schema 5.0.4 → 5.1.1

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,8 +1,8 @@
 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 = (typeName, refPath, edgeProps) => newTypes[`_${typeName}:${refPath}`] = { props: edgeProps };
+    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);
@@ -12,16 +12,20 @@ function _makeEdgeTypes(newTypes, typeName, props, propPrefix) {
         }
         else if (propType === 'reference') {
             const edgeProps = {};
-            Object.keys(prop).filter((k) => k[0] === '$').forEach((k) => edgeProps[k] = prop[k]);
+            Object.keys(prop)
+                .filter((k) => k[0] === '$')
+                .forEach((k) => (edgeProps[k] = prop[k]));
             if (Object.keys(edgeProps).length > 0) {
-                putEdgeProps(typeName, nextPropPrefix, edgeProps);
+                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]);
+            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);
+                putEdgeProps(`${typeName}.${nextPropPrefix}`, `${prop.items.ref}.${prop.items.prop}`, edgeProps);
             }
         }
     }
@@ -79,8 +83,38 @@ 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) {

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 = {};
@@ -53,7 +52,7 @@ export const updateTypeDefs = (schema) => {
                     // Update edgeNodeTypeId
                     if (!prop.edgeNodeTypeId) {
                         if (prop.edges) {
-                            const edgeTypeName = `_${schema.type}:${prop.path.join('.')}`;
+                            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;
@@ -92,6 +91,14 @@ const createSchemaTypeDef = (typeName, type, locales, result = createEmptyDef(ty
                     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;
         }
@@ -141,12 +148,13 @@ const createSchemaTypeDef = (typeName, type, locales, result = createEmptyDef(ty
         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: schemaProp.validation ?? VALIDATION_MAP[typeIndex] ?? defaultValidation,
+            validation: getValidator(schemaProp),
             len,
             default: schemaProp.default ?? DEFAULT_MAP[typeIndex],
             prop: isseparate ? ++result.cnt : 0,
@@ -160,13 +168,13 @@ const createSchemaTypeDef = (typeName, type, locales, result = createEmptyDef(ty
             }
         }
         if (schemaProp.max !== undefined) {
-            prop.max = parseMinMaxStep(schemaProp.max);
+            schemaProp.max = prop.max = parseMinMaxStep(schemaProp.max);
         }
         if (schemaProp.min !== undefined) {
-            prop.min = parseMinMaxStep(schemaProp.min);
+            schemaProp.min = prop.min = parseMinMaxStep(schemaProp.min);
         }
         if (schemaProp.step !== undefined) {
-            prop.step = parseMinMaxStep(schemaProp.step);
+            schemaProp.step = prop.step = parseMinMaxStep(schemaProp.step);
         }
         if (prop.typeIndex !== NUMBER && prop.step === undefined) {
             prop.step = 1;

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, SchemaPropHooks } 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;
@@ -61,6 +62,7 @@ export type PropDef = {
 export type PropDefEdge = Partial<PropDef> & {
     __isPropDef: true;
     typeIndex: TypeIndex;
+    schema: SchemaProp<true>;
     len: number;
     prop: number;
     name: string;
@@ -91,9 +93,10 @@ export type SchemaTypeDef = {
     checksum: number;
     type: string;
     blockCapacity: number;
-    mainLen: number;
+    capped: number;
     insertOnly: boolean;
     partial: boolean;
+    mainLen: number;
     buf: Uint8Array;
     propNames: Uint8Array;
     props: {

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

package/dist/def/validation.js

@@ -1,13 +1,86 @@
 import { convertToTimestamp } from '@based/utils';
-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 { MAX_ID, MIN_ID } 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, TYPE_INDEX_MAP, } from './types.js';
+import { MAX_ID, MIN_ID, } from '../types.js';
+import v from 'validator';
+import { getPropType } from '../parse/index.js';
 const EPSILON = 1e-9; // Small tolerance for floating point comparisons
+const validators = {
+    email: v.isEmail,
+    URL: v.isURL,
+    MACAddress: v.isMACAddress,
+    IP: v.isIP,
+    IPRange: v.isIPRange,
+    FQDN: v.isFQDN,
+    IBAN: v.isIBAN,
+    BIC: v.isBIC,
+    alpha: v.isAlpha,
+    alphaLocales: v.isAlphaLocales,
+    alphanumeric: v.isAlphanumeric,
+    alphanumericLocales: v.isAlphanumericLocales,
+    passportNumber: v.isPassportNumber,
+    port: v.isPort,
+    lowercase: v.isLowercase,
+    uppercase: v.isUppercase,
+    ascii: v.isAscii,
+    semVer: v.isSemVer,
+    surrogatePair: v.isSurrogatePair,
+    IMEI: v.isIMEI,
+    hexadecimal: v.isHexadecimal,
+    octal: v.isOctal,
+    hexColor: v.isHexColor,
+    rgbColor: v.isRgbColor,
+    HSL: v.isHSL,
+    ISRC: v.isISRC,
+    MD5: v.isMD5,
+    JWT: v.isJWT,
+    UUID: v.isUUID,
+    luhnNumber: v.isLuhnNumber,
+    creditCard: v.isCreditCard,
+    identityCard: v.isIdentityCard,
+    EAN: v.isEAN,
+    ISIN: v.isISIN,
+    ISBN: v.isISBN,
+    ISSN: v.isISSN,
+    mobilePhone: v.isMobilePhone,
+    mobilePhoneLocales: v.isMobilePhoneLocales,
+    postalCode: v.isPostalCode,
+    postalCodeLocales: v.isPostalCodeLocales,
+    ethereumAddress: v.isEthereumAddress,
+    currency: v.isCurrency,
+    btcAddress: v.isBtcAddress,
+    ISO6391: v.isISO6391,
+    ISO8601: v.isISO8601,
+    RFC3339: v.isRFC3339,
+    ISO31661Alpha2: v.isISO31661Alpha2,
+    ISO31661Alpha3: v.isISO31661Alpha3,
+    ISO4217: v.isISO4217,
+    base32: v.isBase32,
+    base58: v.isBase58,
+    base64: v.isBase64,
+    dataURI: v.isDataURI,
+    magnetURI: v.isMagnetURI,
+    mimeType: v.isMimeType,
+    latLong: v.isLatLong,
+    slug: v.isSlug,
+    password: v.isStrongPassword,
+    taxID: v.isTaxID,
+    licensePlate: v.isLicensePlate,
+    VAT: v.isVAT,
+    code: () => true,
+    javascript: () => true,
+    typescript: () => true,
+    python: () => true,
+    rust: () => true,
+    css: () => true,
+    html: () => true,
+    json: () => true,
+    markdown: () => true,
+    clike: () => true,
+};
 export const VALIDATION_MAP = {
     [NULL]: () => true,
     [OBJECT]: () => true,
     [COLVEC]: () => true,
-    [WEAK_REFERENCE]: () => true,
-    [WEAK_REFERENCES]: () => true,
     [ALIAS]: (value) => {
         if (typeof value !== 'string') {
             return false;
@@ -31,7 +104,9 @@ export const VALIDATION_MAP = {
             (val instanceof Uint8Array && val.byteLength === 8));
     },
     [TIMESTAMP]: (value, t) => {
-        if (typeof value !== 'number' || value % t.step !== 0) {
+        if (typeof value !== 'number' ||
+            (t.step && value % t.step !== 0) ||
+            isNaN(value)) {
             return false;
         }
         if (t.min !== undefined) {
@@ -57,7 +132,9 @@ export const VALIDATION_MAP = {
         return true;
     },
     [INT16]: (value, t) => {
-        if (typeof value !== 'number' || value % t.step !== 0) {
+        if (typeof value !== 'number' ||
+            (t.step && value % t.step !== 0) ||
+            isNaN(value)) {
             return false;
         }
         if (value > 32767 || value < -32768) {
@@ -72,7 +149,9 @@ export const VALIDATION_MAP = {
         return true;
     },
     [INT32]: (value, t) => {
-        if (typeof value !== 'number' || value % t.step !== 0) {
+        if (typeof value !== 'number' ||
+            (t.step && value % t.step !== 0) ||
+            isNaN(value)) {
             return false;
         }
         if (value > 2147483647 || value < -2147483648) {
@@ -88,7 +167,9 @@ export const VALIDATION_MAP = {
     },
     [INT8]: (value, t) => {
         // use % for steps size
-        if (typeof value !== 'number' || value % t.step !== 0) {
+        if (typeof value !== 'number' ||
+            (t.step && value % t.step !== 0) ||
+            isNaN(value)) {
             return false;
         }
         if (value > 127 || value < -128) {
@@ -103,7 +184,9 @@ export const VALIDATION_MAP = {
         return true;
     },
     [UINT8]: (value, t) => {
-        if (typeof value !== 'number' || value % t.step !== 0) {
+        if (typeof value !== 'number' ||
+            (t.step && value % t.step !== 0) ||
+            isNaN(value)) {
             return false;
         }
         if (value > 255 || value < 0) {
@@ -118,7 +201,9 @@ export const VALIDATION_MAP = {
         return true;
     },
     [UINT16]: (value, t) => {
-        if (typeof value !== 'number' || value % t.step !== 0) {
+        if (typeof value !== 'number' ||
+            (t.step && value % t.step !== 0) ||
+            isNaN(value)) {
             return false;
         }
         if (value > 65535 || value < 0) {
@@ -133,7 +218,9 @@ export const VALIDATION_MAP = {
         return true;
     },
     [UINT32]: (value, t) => {
-        if (typeof value !== 'number' || value % t.step !== 0) {
+        if (typeof value !== 'number' ||
+            (t.step && value % t.step !== 0) ||
+            isNaN(value)) {
             return false;
         }
         if (value > 4294967295 || value < 0) {
@@ -165,11 +252,11 @@ export const VALIDATION_MAP = {
         }
         return true;
     },
-    [ENUM]: (value, prop) => {
+    [ENUM]: (value, t) => {
         if (value === null) {
             return true;
         }
-        const arr = prop.enum;
+        const arr = t.enum;
         for (let i = 0; i < arr.length; i++) {
             if (value === arr[i]) {
                 return true;
@@ -211,18 +298,22 @@ export const VALIDATION_MAP = {
         }
         return true;
     },
-    [STRING]: (value, t) => {
-        // add max etc all here - make a ref to the original SCHEMA on DEF
-        if (typeof value !== 'string' && !(value instanceof Uint8Array)) {
+    [STRING]: (v, t) => {
+        if (v instanceof Uint8Array) {
+            return !!v[1];
+        }
+        if (typeof v !== 'string') {
             return false;
         }
-        return true;
-    },
-    [TEXT]: (value, t) => {
-        // add max etc all here - make a ref to the original SCHEMA on DEF
-        if (typeof value !== 'string' && !(value instanceof Uint8Array)) {
+        if (t.max !== undefined && v.length > t.max) {
+            return false;
+        }
+        if (t.min !== undefined && v.length < t.min) {
             return false;
         }
+        if (t.format !== undefined && t.format in validators) {
+            return validators[t.format](v);
+        }
         return true;
     },
     [ALIASES]: (value) => {
@@ -244,7 +335,9 @@ export const VALIDATION_MAP = {
         }
         return true;
     },
+    [TEXT]: null,
 };
+VALIDATION_MAP[TEXT] = VALIDATION_MAP[STRING];
 export const defaultValidation = () => true;
 export const isValidId = (id) => {
     if (typeof id != 'number' || id < MIN_ID || id > MAX_ID) {
@@ -258,4 +351,113 @@ export const isValidString = (v) => {
         ArrayBuffer.isView(v);
     return isVal;
 };
+const validateObj = (value, props, errors, path, required) => {
+    if (!props) {
+        errors.push({ path, value, error: 'Unexpected property' });
+        return;
+    }
+    if (value === null || typeof value !== 'object') {
+        if (required) {
+            errors.push({ path, value, error: 'Missing required value' });
+            return;
+        }
+    }
+    else {
+        for (const key in value) {
+            if (!(key in props)) {
+                errors.push({
+                    path: [...path, key],
+                    value: value[key],
+                    error: 'Unexpected property',
+                });
+            }
+        }
+    }
+    for (const key in props) {
+        const val = value?.[key];
+        const prop = props[key];
+        if ('props' in prop) {
+            validateObj(val, prop.props, errors, [...path, key], prop.required);
+        }
+        else if (val !== undefined) {
+            const test = getValidator(prop);
+            if ('items' in prop) {
+                if (typeof val !== 'object' || val === null) {
+                    errors.push({
+                        path: [...path, key],
+                        value: val,
+                        error: 'Invalid value',
+                    });
+                }
+                let arr = val;
+                if (!Array.isArray(val)) {
+                    arr = [];
+                    for (const i in val) {
+                        if (i === 'add') {
+                            arr.push(...val.add);
+                        }
+                        else if (i === 'update') {
+                            arr.push(...val.update);
+                        }
+                        else if (i === 'delete') {
+                            arr.push(...val.delete);
+                        }
+                        else {
+                            arr = [];
+                            break;
+                        }
+                    }
+                    if (!arr.length) {
+                        errors.push({
+                            path: [...path, key],
+                            value: arr,
+                            error: 'Invalid value',
+                        });
+                    }
+                }
+                for (const val of arr) {
+                    const msg = typeof val === 'object' ? test(val?.id, prop) : test(val, prop);
+                    if (msg !== true) {
+                        errors.push({
+                            path: [...path, key],
+                            value: val,
+                            error: typeof msg === 'string' ? msg : 'Invalid value',
+                        });
+                    }
+                }
+            }
+            else {
+                const msg = getPropType(prop) === 'reference' && typeof val === 'object'
+                    ? test(val?.id, prop)
+                    : test(val, prop);
+                if (msg !== true) {
+                    errors.push({
+                        path: [...path, key],
+                        value: val,
+                        error: typeof msg === 'string' ? msg : 'Invalid value',
+                    });
+                }
+            }
+        }
+    }
+};
+export const getValidator = (prop) => {
+    const validator = VALIDATION_MAP[TYPE_INDEX_MAP[getPropType(prop)]] ?? defaultValidation;
+    const custom = prop.validation;
+    if (custom) {
+        return (a, b) => {
+            const msg = custom(a, b);
+            return msg === true ? validator(a, b) : msg;
+        };
+    }
+    return validator;
+};
+export function validate(schema, type, payload) {
+    const errors = [];
+    validateObj(payload, schema?.types?.[type]?.props, errors, [], true);
+    return {
+        valid: !errors.length,
+        errors,
+    };
+}
 //# sourceMappingURL=validation.js.map

package/dist/infer.d.ts

@@ -66,7 +66,7 @@ type InferSchemaTypes<T> = {
 type InferSchema<T extends Schema> = T extends {
     types: infer Types;
 } ? Types extends Record<string, any> ? InferSchemaTypes<Types> : never : never;
-export type Infer<T> = InferSchema<T>;
+export type Infer<T extends Schema> = InferSchema<T>;
 export declare const infer: <T extends {
     types: Record<string, any>;
 }>(schema: T) => InferSchema<T>;

package/dist/parse/props.js

@@ -1,15 +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 { getValidator } from '../def/validation.js';
+import { stringFormats, } from '../types.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;
 const STUB = {};
 const shared = {
     type() { },
@@ -49,9 +46,6 @@ const shared = {
     description(val) {
         expectString(val);
     },
-    readOnly(val) {
-        expectBoolean(val);
-    },
     examples(val) {
         expectString(val);
     },
@@ -124,35 +118,25 @@ export const isDefault = (val, prop, ctx) => {
     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],
+    const validation = getValidator(prop);
+    const tmpProp = Object.assign({}, prop, {
         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)) {
+                if (!validation(val[key], tmpProp)) {
                     throw new Error(`Incorrect default for type "text" lang "${key}"`);
                 }
             }
         }
         else {
-            if (!validation(val, propDef)) {
+            if (!validation(val, tmpProp)) {
                 throw new Error(`Incorrect default for type "text"`);
             }
             val = {};
@@ -162,7 +146,7 @@ export const isDefault = (val, prop, ctx) => {
         }
         return val;
     }
-    if (!validation(val, propDef)) {
+    if (!validation(val, tmpProp)) {
         throw new Error(`Incorrect default for type "${prop.type ?? 'enum'}"`);
     }
     if ('enum' in prop) {
@@ -190,7 +174,6 @@ p.vector = propParser({
         if (![
             'number',
             'int8',
-            ,
             'uint8',
             'int16',
             'uint16',
@@ -248,21 +231,16 @@ p.enum = propParser({
     },
 }, 1);
 const numberOpts = {
-    display(val) {
-        expectString(val);
-        numberDisplaysSet ??= new Set(numberDisplays);
-        numberDisplaysSet.has(val);
-    },
-    min(val) {
+    min(val, prop, ctx, key) {
         expectNumber(val);
     },
-    max(val, prop) {
+    max(val, prop, ctx, key) {
         expectNumber(val);
         if (prop.min > val) {
             throw Error(MIN_MAX);
         }
     },
-    step(val) {
+    step(val, prop, ctx, key) {
         if (typeof val !== 'number' && val !== 'any') {
             throw Error(INVALID_VALUE);
         }
@@ -283,32 +261,6 @@ p.object = propParser({
         ctx.parseProps(val, ctx.type);
     },
 }, {});
-p.set = propParser({
-    items(items, prop, ctx) {
-        expectObject(items);
-        const itemsType = getPropType(items);
-        if (itemsType === 'string' ||
-            itemsType === 'number' ||
-            itemsType === 'timestamp' ||
-            itemsType === 'boolean') {
-            ctx.inQuery = 'query' in prop;
-            ctx.isItems = true;
-            p[itemsType](items, ctx);
-            ctx.inQuery = false;
-            ctx.isItems = false;
-        }
-        else {
-            throw new Error(INVALID_VALUE);
-        }
-    },
-}, {
-    default(val, prop) {
-        console.warn('TODO SET DEFAULT VALUE');
-        // if (typeof val === 'object') {
-        //   throwErr(ERRORS.EXPECTED_PRIMITIVE, prop, 'default')
-        // }
-    },
-});
 p.references = propParser({
     items(items, prop, ctx) {
         expectObject(items);
@@ -383,11 +335,6 @@ p.text = propParser({
     },
 }, 0);
 p.timestamp = propParser(STUB, {
-    display(val) {
-        expectString(val);
-        dateDisplaysSet ??= new Set(dateDisplays);
-        dateDisplaysSet.has(val);
-    },
     min(val) {
         if (typeof val !== 'string' && typeof val !== 'number') {
             throw Error(INVALID_VALUE);
@@ -442,7 +389,6 @@ p.reference = propParser({
                 for (let i = 3; i < lvl; i += 2) {
                     prop += prop ? `.${path[i]}` : path[i];
                 }
-                targetProp.readOnly = true;
                 targetProp.items = {
                     ref,
                     prop,
@@ -480,13 +426,15 @@ p.reference = propParser({
         if (edgeAllowed) {
             let t = ctx.schema.types[prop.ref].props[prop.prop];
             t = t.items || t;
-            if (t[key] && t !== prop) {
-                throw Error('Edge can not be defined on both props');
-            }
-            const edgePropType = getPropType(val);
+            // if (t[key] && t !== prop) {
+            //   throw Error('Edge can not be defined on both props')
+            // }
+            // @ts-ignore
+            const edgePropType = getPropType(val, prop, key);
             const inType = ctx.type;
             ctx.type = null;
             p[edgePropType](val, ctx);
+            t[key] = prop[key];
             ctx.type = inType;
             return;
         }

package/dist/parse/utils.js

@@ -15,16 +15,15 @@ export const getPropType = (prop, props, key) => {
     if ('ref' in prop) {
         return 'reference';
     }
-    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';
+    if ('items' in prop && 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';
     }
     if ('props' in prop) {
         return 'object';

package/dist/types.d.ts

@@ -1,11 +1,6 @@
 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", "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}`;
+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"];
 type StringFormat = (typeof stringFormats)[number];
 type MimeString = 'text/html' | 'text/plain' | 'text/markdown' | 'image/png' | 'image/jpeg' | 'video/mp4' | 'video/quicktime' | 'image/*' | 'video/*' | 'audio/*' | '*/*' | `${string}/${string}`;
 type Mime = MimeString | MimeString[];
@@ -21,10 +16,6 @@ type Prop<V extends PropValues> = {
     required?: boolean;
     title?: string | Record<string, string>;
     description?: string | Record<string, string>;
-    path?: string;
-    query?: QueryFn;
-    role?: Role;
-    readOnly?: boolean;
     examples?: string[];
     validation?: Validation;
     hooks?: SchemaPropHooks;
@@ -55,11 +46,7 @@ export type SchemaNumber = Prop<{
     default?: number;
     min?: number;
     max?: number;
-    step?: number | 'any';
-    display?: NumberDisplay;
-    history?: {
-        interval: 'year' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second';
-    };
+    step?: number;
 }>;
 export type SchemaString = Prop<{
     type: 'string';
@@ -121,14 +108,13 @@ export type SchemaColvec = Prop<{
      */
     baseType?: SchemaVectorBaseType;
 }>;
-export type SchemaTimestamp = Prop<{
+export type SchemaTimestamp<isStrict = false> = Prop<{
     type: 'timestamp';
     default?: number | Date | string;
     on?: 'create' | 'update';
-    display?: DateDisplay;
     min?: number | string;
     max?: number | string;
-    step?: number | 'any' | string;
+    step?: isStrict extends true ? number : number | string;
 }>;
 export type SchemaReferenceOneWay = Prop<{
     type?: 'reference';
@@ -144,9 +130,9 @@ export type SchemaReference = Prop<{
     dependent?: boolean;
     mime?: Mime;
 }> & Record<`$${string}`, SchemaPropOneWay>;
-export type SchemaObject = Prop<{
+export type SchemaObject<isStrict = false> = Prop<{
     type?: 'object';
-    props: SchemaProps;
+    props: SchemaProps<isStrict>;
 }>;
 export type SchemaObjectOneWay = Prop<{
     type?: 'object';
@@ -167,15 +153,7 @@ export type SchemaAlias = Omit<SchemaString, 'type'> & {
     type: 'alias';
 };
 export type SchemaPropShorthand = 'timestamp' | 'binary' | 'boolean' | 'string' | 'alias' | 'text' | 'json' | 'cardinality' | NumberType | EnumItem[];
-type SetItems<isStrict = false> = SchemaTimestamp | SchemaBoolean | SchemaNumber | SchemaString | SchemaEnum | (isStrict extends true ? never : 'timestamp' | 'binary' | 'boolean' | 'string' | NumberType | EnumItem[]);
-export type SchemaSet<ItemsType extends SetItems = SetItems> = Prop<{
-    type?: 'set';
-    default?: ItemsType extends {
-        default: any;
-    } ? ItemsType['default'][] : undefined;
-    items: ItemsType & NeverInItems;
-}>;
-type NonRefSchemaProps<isStrict = false> = SchemaTimestamp | SchemaBoolean | SchemaNumber | SchemaString | SchemaAlias | SchemaText | SchemaEnum | SchemaJson | SchemaBinary | SchemaCardinality | SchemaVector | SchemaColvec | (isStrict extends true ? SchemaSet<SetItems<true>> : SchemaPropShorthand | SchemaSet);
+type NonRefSchemaProps<isStrict = false> = SchemaTimestamp<isStrict> | SchemaBoolean | SchemaNumber | SchemaString | SchemaAlias | SchemaText | SchemaEnum | SchemaJson | SchemaBinary | SchemaCardinality | SchemaVector | SchemaColvec | (isStrict extends true ? never : SchemaPropShorthand);
 export type SchemaProp<isStrict = false> = SchemaReferencesWithQuery | SchemaReferenceWithQuery | NonRefSchemaProps<isStrict> | SchemaReferences | SchemaReference | SchemaObject | SchemaBinary;
 export type SchemaPropOneWay<isStrict = false> = SchemaReferencesOneWay | SchemaReferenceOneWay | SchemaObjectOneWay | NonRefSchemaProps<isStrict>;
 export type SchemaAnyProp = SchemaPropOneWay | SchemaProp;
@@ -214,6 +192,7 @@ type GenericSchemaType<isStrict = false> = {
     hooks?: SchemaHooks;
     id?: number;
     blockCapacity?: number;
+    capped?: number;
     insertOnly?: boolean;
     partial?: boolean;
     props: SchemaProps<isStrict>;
@@ -260,7 +239,6 @@ export type SchemaPropTypeMap = {
     enum: SchemaEnum;
     text: SchemaText;
     json: SchemaJson;
-    set: SchemaSet;
     binary: SchemaBinary;
     cardinality: SchemaCardinality;
     vector: SchemaVector;

package/dist/types.js

@@ -1,22 +1,4 @@
 import { getPropType } from './parse/utils.js';
-export const numberDisplays = [
-    'short',
-    'human',
-    'ratio',
-    'bytes',
-    'euro',
-    'dollar',
-    'pound',
-    'meter',
-];
-export const dateDisplays = [
-    'date',
-    'date-time',
-    'date-time-text',
-    'date-time-human',
-    'time',
-    'time-precise',
-];
 export const stringFormats = [
     'alpha',
     'alphaLocales',
@@ -89,8 +71,6 @@ export const stringFormats = [
     'URL',
     'UUID',
     'VAT',
-    // TODO: for discussion
-    'multiline',
 ];
 export const isPropType = (type, prop) => {
     return getPropType(prop) === type;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@based/schema",
-  "version": "5.0.4",
+  "version": "5.1.1",
   "files": [
     "dist",
     "README.md",
@@ -31,7 +31,8 @@
     "typescript": "^5.6.3"
   },
   "dependencies": {
-    "@based/utils": "1.1.1",
-    "picocolors": "^1.1.0"
+    "@based/utils": "1.2.0",
+    "picocolors": "^1.1.0",
+    "validator": "^13.15.20"
   }
 }

package/dist/def/refSet.d.ts

@@ -1,7 +0,0 @@
-export default class RefSet {
-    #private;
-    add(srcType: number, srcField: number, dstType: number, dstField: number): boolean;
-    clear(): void;
-    values(): SetIterator<number>;
-}
-//# sourceMappingURL=refSet.d.ts.map

package/dist/def/refSet.js

@@ -1,25 +0,0 @@
-const packOne = (nodeType, field) => ((nodeType & 0xffff) << 8) | (field & 0xff);
-const packTwo = (a, b) => (a << 24) | (b & 0xffffff);
-const makeTuple = (aType, aField, bType, bField) => {
-    const a = packOne(aType, aField);
-    const b = packOne(bType, bField);
-    return a < b ? packTwo(a, b) : packTwo(b, a);
-};
-export default class RefSet {
-    #s = new Set();
-    add(srcType, srcField, dstType, dstField) {
-        const t = makeTuple(srcType, srcField, dstType, dstField);
-        if (this.#s.has(t)) {
-            return false;
-        }
-        this.#s.add(t);
-        return true;
-    }
-    clear() {
-        this.#s.clear();
-    }
-    values() {
-        return this.#s.values();
-    }
-}
-//# sourceMappingURL=refSet.js.map

package/dist/def/selvaBuffer.d.ts

@@ -1,5 +0,0 @@
-import { SchemaTypeDef } from './types.js';
-export declare function schemaToSelvaBuffer(schema: {
-    [key: string]: SchemaTypeDef;
-}): ArrayBuffer[];
-//# sourceMappingURL=selvaBuffer.d.ts.map

package/dist/def/selvaBuffer.js

@@ -1,145 +0,0 @@
-import { ALIAS, ALIASES, BINARY, EMPTY_MICRO_BUFFER, CARDINALITY, MICRO_BUFFER, REFERENCE, REFERENCES, STRING, TEXT, VECTOR, WEAK_REFERENCE, WEAK_REFERENCES, JSON, COLVEC, VECTOR_BASE_TYPE_SIZE_MAP, } from './types.js';
-import RefSet from './refSet.js';
-const selvaFieldType = {
-    NULL: 0,
-    MICRO_BUFFER: 1,
-    STRING: 2,
-    TEXT: 3,
-    REFERENCE: 4,
-    REFERENCES: 5,
-    WEAK_REFERENCE: 6,
-    WEAK_REFERENCES: 7,
-    ALIAS: 8,
-    ALIASES: 9,
-    COLVEC: 10,
-};
-const selvaTypeMap = new Uint8Array(32); // 1.2x faster than JS array
-selvaTypeMap[MICRO_BUFFER] = selvaFieldType.MICRO_BUFFER;
-selvaTypeMap[VECTOR] = selvaFieldType.MICRO_BUFFER;
-selvaTypeMap[BINARY] = selvaFieldType.STRING;
-selvaTypeMap[CARDINALITY] = selvaFieldType.STRING;
-selvaTypeMap[JSON] = selvaFieldType.STRING;
-selvaTypeMap[STRING] = selvaFieldType.STRING;
-selvaTypeMap[TEXT] = selvaFieldType.TEXT;
-selvaTypeMap[REFERENCE] = selvaFieldType.REFERENCE;
-selvaTypeMap[REFERENCES] = selvaFieldType.REFERENCES;
-selvaTypeMap[WEAK_REFERENCE] = selvaFieldType.WEAK_REFERENCE;
-selvaTypeMap[WEAK_REFERENCES] = selvaFieldType.WEAK_REFERENCES;
-selvaTypeMap[ALIAS] = selvaFieldType.ALIAS;
-selvaTypeMap[ALIASES] = selvaFieldType.ALIASES;
-selvaTypeMap[COLVEC] = selvaFieldType.COLVEC;
-const EDGE_FIELD_CONSTRAINT_FLAG_DEPENDENT = 0x01;
-const EDGE_FIELD_CONSTRAINT_FLAG_SKIP_DUMP = 0x80;
-function blockCapacity(blockCapacity) {
-    const buf = new Uint8Array(Uint32Array.BYTES_PER_ELEMENT);
-    const view = new DataView(buf.buffer);
-    view.setUint32(0, blockCapacity, true);
-    return buf;
-}
-function sepPropCount(props) {
-    return props.filter((prop) => prop.separate).length;
-}
-function makeEdgeConstraintFlags(refSet, nodeTypeId, prop, dstNodeTypeId, inverseProp) {
-    let flags = 0;
-    flags |= prop.dependent ? EDGE_FIELD_CONSTRAINT_FLAG_DEPENDENT : 0x00;
-    flags |=
-        prop.typeIndex === REFERENCE &&
-            inverseProp &&
-            inverseProp.typeIndex === REFERENCES
-            ? EDGE_FIELD_CONSTRAINT_FLAG_SKIP_DUMP
-            : 0x00;
-    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) => {
-    const type = prop.typeIndex;
-    const selvaType = selvaTypeMap[type];
-    if (prop.len && (type === MICRO_BUFFER || type === VECTOR)) {
-        const buf = new Uint8Array(3);
-        const view = new DataView(buf.buffer);
-        buf[0] = selvaType;
-        view.setUint16(1, prop.len, true);
-        return [...buf];
-    }
-    else if (prop.len && type === COLVEC) {
-        const buf = new Uint8Array(5);
-        const view = new DataView(buf.buffer);
-        buf[0] = selvaType;
-        const baseSize = VECTOR_BASE_TYPE_SIZE_MAP[prop.vectorBaseType];
-        view.setUint16(1, prop.len / baseSize, true); // elements
-        view.setUint16(3, baseSize, true); // element size
-        return [...buf];
-    }
-    else if (type === REFERENCE || type === REFERENCES) {
-        const buf = new Uint8Array(7);
-        const view = new DataView(buf.buffer);
-        const dstType = schema[prop.inverseTypeName];
-        // @ts-ignore
-        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
-        if (prop.__isEdge) {
-            buf[4] = 0;
-            view.setUint16(5, 0, true);
-        }
-        else {
-            buf[4] = prop.inversePropNumber;
-            view.setUint16(5, prop.edgeNodeTypeId, true); // meta_node_type
-        }
-        return [...buf];
-    }
-    else if (type === STRING ||
-        type === BINARY ||
-        type === CARDINALITY ||
-        type === JSON) {
-        return [selvaType, prop.len < 50 ? prop.len : 0];
-    }
-    {
-        return [selvaType];
-    }
-};
-// TODO rewrite
-export function schemaToSelvaBuffer(schema) {
-    const refSet = new RefSet();
-    return Object.values(schema).map((t) => {
-        const props = Object.values(t.props);
-        const rest = [];
-        const nrFields = 1 + sepPropCount(props);
-        let refFields = 0;
-        let virtualFields = 0;
-        if (nrFields >= 250) {
-            throw new Error('Too many fields');
-        }
-        for (const f of props) {
-            if (f.separate) {
-                if (f.typeIndex === REFERENCE || f.typeIndex === REFERENCES) {
-                    refFields++;
-                }
-                else if (f.typeIndex === ALIAS ||
-                    f.typeIndex === ALIASES ||
-                    f.typeIndex === COLVEC) {
-                    // We assume that these are always the last props!
-                    virtualFields++;
-                }
-                rest.push(f);
-            }
-        }
-        rest.sort((a, b) => a.prop - b.prop);
-        return Uint8Array.from([
-            ...blockCapacity(t.blockCapacity), // u32 blockCapacity
-            nrFields, // u8 nrFields
-            1 + refFields, // u8 nrFixedFields
-            virtualFields, // u8 nrVirtualFields
-            0, // u8 spare1
-            ...propDefBuffer(refSet, t.id, schema, {
-                ...EMPTY_MICRO_BUFFER,
-                len: t.mainLen === 0 ? 1 : t.mainLen,
-            }),
-            ...rest.map((f) => propDefBuffer(refSet, t.id, schema, f)).flat(1),
-        ]).buffer;
-    });
-}
-//# sourceMappingURL=selvaBuffer.js.map