@based/schema 5.0.4-alpha.1 → 5.1.0

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,64 @@ 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);
+            const msg = 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,15 +46,18 @@ const shared = {
     description(val) {
         expectString(val);
     },
-    readOnly(val) {
-        expectBoolean(val);
-    },
     examples(val) {
         expectString(val);
     },
     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) => {
@@ -118,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 = {};
@@ -156,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) {
@@ -184,7 +174,6 @@ p.vector = propParser({
         if (![
             'number',
             'int8',
-            ,
             'uint8',
             'int16',
             'uint16',
@@ -242,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);
         }
@@ -277,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);
@@ -377,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);
@@ -436,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,
@@ -474,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,11 +15,15 @@ export const getPropType = (prop, props, key) => {
     if ('ref' in prop) {
         return 'reference';
     }
-    if ('items' in prop) {
-        if (getPropType(prop.items) === 'reference') {
-            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", "date-time-human-short", "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,12 +16,9 @@ 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;
 } & V;
 type EnumItem = string | number | boolean;
 type NeverInItems = {
@@ -54,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';
@@ -120,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';
@@ -143,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';
@@ -166,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;
@@ -196,10 +175,24 @@ 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;
     blockCapacity?: number;
+    capped?: number;
     insertOnly?: boolean;
     partial?: boolean;
     props: SchemaProps<isStrict>;
@@ -246,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,23 +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',
-    'date-time-human-short',
-    'time',
-    'time-precise',
-];
 export const stringFormats = [
     'alpha',
     'alphaLocales',
@@ -90,8 +71,6 @@ export const stringFormats = [
     'URL',
     'UUID',
     'VAT',
-    // TODO: for discussion
-    'multiline',
 ];
 export const isPropType = (type, prop) => {
     return getPropType(prop) === type;