@based/schema 5.0.0-alpha.8 → 5.0.0

package/dist/types.d.ts

@@ -1,8 +1,9 @@
-import { LangName } from './lang.js';
+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", "passportNumber", "port", "postalCode", "postalCodeLocales", "python", "RFC3339", "rgbColor", "rust", "semVer", "slug", "strongPassword", "surrogatePair", "taxID", "typescript", "uppercase", "URL", "UUID", "VAT", "multiline"];
+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}`;
 type StringFormat = (typeof stringFormats)[number];
@@ -14,6 +15,7 @@ type QueryFn = Function;
 type PropValues = {
     type?: string;
     default?: any;
+    validation?: Validation;
 };
 type Prop<V extends PropValues> = {
     required?: boolean;
@@ -24,6 +26,7 @@ type Prop<V extends PropValues> = {
     role?: Role;
     readOnly?: boolean;
     examples?: string[];
+    validation?: Validation;
 } & V;
 type EnumItem = string | number | boolean;
 type NeverInItems = {
@@ -31,16 +34,19 @@ type NeverInItems = {
 };
 export type SchemaReferences = Prop<{
     type?: 'references';
+    default?: number[];
     items: SchemaReference & NeverInItems;
 }>;
 export type SchemaReferencesOneWay = Prop<{
     type?: 'references';
+    default?: number[];
     items: SchemaReferenceOneWay & NeverInItems;
 }>;
 export type SchemaText = Prop<{
     type: 'text';
     default?: Record<string, string>;
     format?: StringFormat;
+    compression?: 'none' | 'deflate';
 }>;
 type NumberType = 'number' | 'int8' | 'uint8' | 'int16' | 'uint16' | 'int32' | 'uint32';
 export type SchemaNumber = Prop<{
@@ -66,7 +72,7 @@ export type SchemaString = Prop<{
 }>;
 export type SchemaBinary = Prop<{
     type: 'binary';
-    default?: ArrayBuffer;
+    default?: Uint8Array;
     maxBytes?: number;
     mime?: Mime;
     format?: StringFormat;
@@ -81,31 +87,56 @@ export type SchemaBoolean = Prop<{
 }>;
 export type SchemaCardinality = Prop<{
     type: 'cardinality';
-    default?: string;
     maxBytes?: number;
     mime?: Mime;
     format?: NumberDisplay;
 }>;
+type VectorDefaultType = Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
+export type SchemaVectorBaseType = NumberType | 'float32' | 'float64';
 export type SchemaVector = Prop<{
     type: 'vector';
-    default?: Float32Array;
+    default?: VectorDefaultType;
+    /**
+     * Number of elements in the vector.
+     */
     size: number;
+    /**
+     * Base type of the vector.
+     * float64 == number
+     */
+    baseType?: SchemaVectorBaseType;
+}>;
+export type SchemaColvec = Prop<{
+    type: 'colvec';
+    default?: VectorDefaultType;
+    /**
+     * Number of elements in the vector.
+     */
+    size: number;
+    /**
+     * Base type of the vector.
+     * float64 == number
+     */
+    baseType?: SchemaVectorBaseType;
 }>;
 export type SchemaTimestamp = Prop<{
     type: 'timestamp';
-    default?: number | Date;
+    default?: number | Date | string;
     on?: 'create' | 'update';
     display?: DateDisplay;
+    min?: number | string;
+    max?: number | string;
+    step?: number | 'any' | string;
 }>;
 export type SchemaReferenceOneWay = Prop<{
     type?: 'reference';
-    default?: string;
+    default?: number;
     ref: string;
     mime?: Mime;
 }>;
 export type SchemaReference = Prop<{
     type?: 'reference';
-    default?: string;
+    default?: number;
     ref: string;
     prop: string;
     dependent?: boolean;
@@ -127,7 +158,7 @@ export type SchemaReferencesWithQuery = SchemaReferencesOneWay & {
 };
 export type SchemaEnum = Prop<{
     type?: 'enum';
-    default?: EnumItem;
+    default?: EnumItem | undefined;
     enum: EnumItem[];
 }>;
 export type SchemaAlias = Omit<SchemaString, 'type'> & {
@@ -142,21 +173,34 @@ export type SchemaSet<ItemsType extends SetItems = SetItems> = Prop<{
     } ? ItemsType['default'][] : undefined;
     items: ItemsType & NeverInItems;
 }>;
-type NonRefSchemaProps<isStrict = false> = SchemaTimestamp | SchemaBoolean | SchemaNumber | SchemaString | SchemaAlias | SchemaText | SchemaEnum | SchemaJson | SchemaBinary | SchemaCardinality | SchemaVector | (isStrict extends true ? SchemaSet<SetItems<true>> : SchemaPropShorthand | SchemaSet);
+type NonRefSchemaProps<isStrict = false> = SchemaTimestamp | SchemaBoolean | SchemaNumber | SchemaString | SchemaAlias | SchemaText | SchemaEnum | SchemaJson | SchemaBinary | SchemaCardinality | SchemaVector | SchemaColvec | (isStrict extends true ? SchemaSet<SetItems<true>> : SchemaPropShorthand | SchemaSet);
 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;
-export type SchemaHook = string | Function;
 export type SchemaProps<isStrict = false> = Record<AllowedKey, SchemaProp<isStrict>> & {
     id?: never;
 };
+type BasedDbQuery = any;
+type Operator = string;
+export type SchemaHooks = {
+    create?: (payload: Record<string, any>) => void | Record<string, any>;
+    update?: (payload: Record<string, any>) => void | Record<string, any>;
+    read?: (result: Record<string, any>) => void | null | Record<string, any>;
+    search?: (query: BasedDbQuery, fields: Set<string>) => void;
+    include?: (query: BasedDbQuery, fields: Map<string, {
+        field: string;
+        opts?: any;
+    }>) => void;
+    filter?: (query: BasedDbQuery, field: string, operator: Operator, value: any) => void;
+    groupBy?: (query: BasedDbQuery, field: string) => void;
+    aggregate?: (query: BasedDbQuery, fields: Set<string>) => void;
+};
 type GenericSchemaType<isStrict = false> = {
-    hooks?: {
-        create?: SchemaHook;
-        update?: SchemaHook;
-        delete?: SchemaHook;
-    };
+    hooks?: SchemaHooks;
     id?: number;
+    blockCapacity?: number;
+    insertOnly?: boolean;
+    partial?: boolean;
     props: SchemaProps<isStrict>;
 };
 export type StrictSchemaType = GenericSchemaType<true>;
@@ -170,16 +214,25 @@ export type SchemaTypes<isStrict = false> = Record<SchemaTypeName, SchemaType<is
 export type SchemaPropsOneWay<isStrict = false> = Record<AllowedKey, SchemaPropOneWay<isStrict>> & {
     id?: never;
 };
+type MigrateFn = (node: Record<string, any>) => Record<string, any> | [string, Record<string, any>];
+export type MigrateFns = Record<string, MigrateFn>;
 type GenericSchema<isStrict = false> = {
+    version?: string;
     types?: SchemaTypes<isStrict>;
     props?: SchemaPropsOneWay<isStrict>;
     locales?: Partial<SchemaLocales>;
+    defaultTimezone?: string;
+    migrations?: {
+        version: string;
+        migrate: MigrateFns;
+    }[];
 };
 export type StrictSchema = GenericSchema<true>;
-export type Schema = GenericSchema<false> | StrictSchema;
-export type SchemaLocales = Record<LangName, {
+export type NonStrictSchema = GenericSchema<false>;
+export type Schema = NonStrictSchema | StrictSchema;
+export type SchemaLocales = Record<LangName, true | {
     required?: boolean;
-    fallback?: LangName[];
+    fallback?: LangName;
 }>;
 export type SchemaPropTypeMap = {
     references: SchemaReferences;
@@ -196,8 +249,11 @@ export type SchemaPropTypeMap = {
     binary: SchemaBinary;
     cardinality: SchemaCardinality;
     vector: SchemaVector;
+    colvec: SchemaColvec;
 } & Record<NumberType, SchemaNumber>;
 export type SchemaPropTypes = keyof SchemaPropTypeMap;
 export declare const isPropType: <T extends SchemaPropTypes>(type: T, prop: SchemaProp) => prop is SchemaPropTypeMap[T];
+export declare const MAX_ID = 4294967295;
+export declare const MIN_ID = 1;
 export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -71,6 +71,7 @@ export const stringFormats = [
     'mobilePhone',
     'mobilePhoneLocales',
     'octal',
+    'password',
     'passportNumber',
     'port',
     'postalCode',
@@ -81,7 +82,6 @@ export const stringFormats = [
     'rust',
     'semVer',
     'slug',
-    'strongPassword',
     'surrogatePair',
     'taxID',
     'typescript',
@@ -95,4 +95,6 @@ export const stringFormats = [
 export const isPropType = (type, prop) => {
     return getPropType(prop) === type;
 };
+export const MAX_ID = 4294967295;
+export const MIN_ID = 1;
 //# sourceMappingURL=types.js.map

package/package.json

@@ -1,7 +1,6 @@
 {
   "name": "@based/schema",
-  "version": "5.0.0-alpha.8",
-  "license": "MIT",
+  "version": "5.0.0",
   "files": [
     "dist",
     "README.md",
@@ -11,6 +10,8 @@
   "main": "./dist/index.js",
   "exports": {
     "./def": "./dist/def/index.js",
+    "./lang": "./dist/lang.js",
+    "./prop-types": "./dist/def/typeIndexes.js",
     ".": "./dist/index.js"
   },
   "scripts": {
@@ -24,12 +25,13 @@
   "devDependencies": {
     "@saulx/prettier-config": "2.0.0",
     "@saulx/tsconfig": "^1.1.0",
-    "@types/node": "22.5.3",
+    "@types/node": "^22.5.3",
     "tsx": "^4.19.0",
     "typescript": "^5.6.3"
   },
   "dependencies": {
-    "@saulx/utils": "^6.1.1",
+    "@based/utils": "^1.0.0",
+    "@std/semver": "npm:@jsr/std__semver@^1.0.5",
     "picocolors": "^1.1.0"
   }
-}
+}

package/dist/def/getPropLen.d.ts

@@ -1,3 +0,0 @@
-import { SchemaProp } from '../types.js';
-export declare function getPropLen(schemaProp: SchemaProp): any;
-//# sourceMappingURL=getPropLen.d.ts.map

package/dist/def/getPropLen.js

@@ -1,23 +0,0 @@
-import { getPropType } from '../parse/utils.js';
-import { isPropType } from '../types.js';
-import { SIZE_MAP } from './types.js';
-export function getPropLen(schemaProp) {
-    let len = SIZE_MAP[getPropType(schemaProp)];
-    if (isPropType('string', schemaProp) ||
-        isPropType('alias', schemaProp) ||
-        isPropType('cardinality', schemaProp)) {
-        if (typeof schemaProp === 'object') {
-            if (schemaProp.maxBytes < 61) {
-                len = schemaProp.maxBytes + 1;
-            }
-            else if ('max' in schemaProp && schemaProp.max < 31) {
-                len = schemaProp.max * 2 + 1;
-            }
-        }
-    }
-    else if (isPropType('vector', schemaProp)) {
-        len = 4 * schemaProp.size;
-    }
-    return len;
-}
-//# sourceMappingURL=getPropLen.js.map

package/dist/def/makePacked.d.ts

@@ -1,3 +0,0 @@
-import { SchemaTypeDef, PropDef } from './types.js';
-export declare function makePacked(result: Partial<SchemaTypeDef>, typeName: string, vals: PropDef[], len: number): void;
-//# sourceMappingURL=makePacked.d.ts.map

package/dist/def/makePacked.js

@@ -1,50 +0,0 @@
-export function makePacked(result, typeName, vals, len) {
-    const encoder = new TextEncoder();
-    result.buf = new Uint8Array(len);
-    result.buf[0] = result.idUint8[0];
-    result.buf[1] = result.idUint8[1];
-    const fieldNames = [];
-    const tNameBuf = encoder.encode(typeName);
-    fieldNames.push(tNameBuf);
-    let fieldNameLen = tNameBuf.byteLength + 1;
-    let i = 2;
-    if (result.mainLen) {
-        result.buf[i] = 0;
-        for (const f of vals) {
-            if (!f.separate) {
-                i++;
-                result.buf[i] = f.typeIndex;
-                const name = encoder.encode(f.path.join('.'));
-                fieldNames.push(name);
-                fieldNameLen += name.byteLength + 1;
-            }
-        }
-        i++;
-        result.buf[i] = 0;
-    }
-    for (const f of vals) {
-        if (f.separate) {
-            i++;
-            result.buf[i] = f.prop;
-            i++;
-            result.buf[i] = f.typeIndex;
-            const name = encoder.encode(f.path.join('.'));
-            fieldNames.push(name);
-            fieldNameLen += name.byteLength + 1;
-        }
-    }
-    result.propNames = new Uint8Array(fieldNameLen);
-    let lastWritten = 0;
-    for (const f of fieldNames) {
-        result.propNames[lastWritten] = f.byteLength;
-        result.propNames.set(f, lastWritten + 1);
-        lastWritten += f.byteLength + 1;
-    }
-    let bufLen = result.buf.length;
-    result.packed = new Uint8Array(2 + bufLen + result.propNames.length);
-    result.packed[0] = bufLen;
-    result.packed[1] = bufLen >>>= 8;
-    result.packed.set(result.buf, 2);
-    result.packed.set(result.propNames, result.buf.length + 2);
-}
-//# sourceMappingURL=makePacked.js.map

package/dist/def/readFromPacked.d.ts

@@ -1,3 +0,0 @@
-import { SchemaTypeDef } from './types.js';
-export declare const readFromPacked: (packed: Uint8Array) => SchemaTypeDef;
-//# sourceMappingURL=readFromPacked.d.ts.map

package/dist/def/readFromPacked.js

@@ -1,137 +0,0 @@
-import { DEFAULT_MAP, REVERSE_SIZE_MAP, } from './types.js';
-export const readFromPacked = (packed) => {
-    const size = (packed[0] | (packed[1] << 8)) >>> 0;
-    const props = [];
-    const b = packed.subarray(2, 2 + size);
-    let collectMain = false;
-    const mainProps = [];
-    const typeId = b.subarray(0, 2);
-    const typeIdNr = (typeId[0] | (typeId[1] << 8)) >>> 0;
-    for (let i = 2; i < b.length; i++) {
-        const prop = b[i];
-        if (collectMain) {
-            if (prop === 0) {
-                collectMain = false;
-            }
-            else {
-                mainProps.push({
-                    prop: 0,
-                    typeIndex: b[i],
-                });
-            }
-        }
-        else {
-            if (prop == 0) {
-                collectMain = true;
-            }
-            else {
-                props.push({ prop, typeIndex: b[i + 1] });
-                i++;
-            }
-        }
-    }
-    const decoder = new TextDecoder();
-    const fields = [];
-    const f = packed.subarray(2 + size, packed.length);
-    for (let i = 0; i < f.length; i++) {
-        const size = f[i];
-        fields.push(decoder.decode(f.subarray(i + 1, i + 1 + size)));
-        i += size;
-    }
-    for (let i = 0; i < mainProps.length; i++) {
-        mainProps[i].path = fields[i + 1];
-    }
-    for (let i = 0; i < props.length; i++) {
-        props[i].path = fields[i + 1 + mainProps.length];
-    }
-    // Fixed len strings not supported
-    // Refs also not supported
-    // Text not supported yet
-    // Ref not supported yet
-    //   compression: 1 (0)
-    // YET
-    const result = {
-        cnt: 0,
-        checksum: 0,
-        total: 0,
-        type: fields[0],
-        lastId: 0,
-        blockCapacity: 0,
-        mainLen: mainProps.length,
-        buf: b,
-        propNames: f,
-        packed,
-        props: {},
-        reverseProps: {}, // in a bit
-        id: typeIdNr,
-        idUint8: typeId,
-        separate: [],
-        main: {},
-        tree: {},
-        // not nessecary...
-        hasSeperateSort: false,
-        seperateSort: {
-            size: 0,
-            buffer: new Uint8Array([]),
-            bufferTmp: new Uint8Array([]),
-            props: [],
-        },
-        hasSeperateTextSort: false,
-        seperateTextSort: {
-            localeToIndex: new Map(),
-            localeStringToIndex: new Map(),
-            noUndefined: new Uint8Array([]),
-            size: 0,
-            buffer: new Uint8Array([]),
-            bufferTmp: new Uint8Array([]),
-            props: [],
-        },
-        mainEmpty: new Uint8Array([]),
-        mainEmptyAllZeroes: true,
-        // need this...
-        locales: {},
-        localeSize: 0,
-    };
-    let s = 0;
-    for (const p of mainProps) {
-        const len = REVERSE_SIZE_MAP[p.typeIndex];
-        const prop = {
-            prop: p.prop,
-            separate: false,
-            __isPropDef: true,
-            start: s,
-            default: DEFAULT_MAP[p.typeIndex], // tmp
-            typeIndex: p.typeIndex,
-            path: p.path.split('.'),
-            len,
-        };
-        result.props[p.path] = prop;
-        result.main[prop.start] = prop;
-        s += len;
-    }
-    for (const p of props) {
-        const prop = {
-            prop: p.prop,
-            separate: true,
-            __isPropDef: true,
-            start: 0,
-            typeIndex: p.typeIndex,
-            default: DEFAULT_MAP[p.typeIndex], // tmp
-            path: p.path.split('.'),
-            len: 0,
-            compression: 1,
-        };
-        result.props[p.path] = prop;
-        result.reverseProps[prop.prop] = prop;
-    }
-    // make this into a typeDef
-    //   return {
-    //     type: fields[0],
-    //     fields,
-    //     typeId,
-    //     props,
-    //     mainProps,
-    //   }
-    return result;
-};
-//# sourceMappingURL=readFromPacked.js.map

package/dist/mermaid.d.ts

@@ -1,3 +0,0 @@
-import { StrictSchema } from './types.js';
-export declare const mermaid: (schema: StrictSchema) => string;
-//# sourceMappingURL=mermaid.d.ts.map

package/dist/mermaid.js

@@ -1,24 +0,0 @@
-import { getPropType } from './parse/utils.js';
-import { isPropType } from './types.js';
-export const mermaid = (schema) => {
-    let mermaid = 'classDiagram';
-    if (schema.types) {
-        for (const type in schema.types) {
-            for (const key in schema.types[type].props) {
-                const prop = schema.types[type].props[key];
-                const propType = getPropType(prop);
-                if (isPropType('reference', prop)) {
-                    mermaid += `\n${type} --> ${prop.ref} : ${key}`;
-                }
-                else if (isPropType('references', prop)) {
-                    mermaid += `\n${type} --> ${prop.items.ref} : ${key}[]`;
-                }
-                else {
-                    mermaid += `\n${type} : ${propType} ${key}`;
-                }
-            }
-        }
-    }
-    return mermaid;
-};
-//# sourceMappingURL=mermaid.js.map