@based/schema 5.0.0-alpha.8 → 5.0.0

package/dist/def/utils.js

@@ -1,8 +1,11 @@
-import { INT16, INT32, INT8, UINT16, UINT32, UINT8, NUMBER, TIMESTAMP, SIZE_MAP, } from './types.js';
+import { INT16, INT32, INT8, UINT16, UINT32, UINT8, NUMBER, TIMESTAMP, SIZE_MAP, VECTOR_BASE_TYPE_SIZE_MAP, VectorBaseType, } from './types.js';
 import { isPropType } from '../types.js';
 import { getPropType } from '../parse/utils.js';
+import { convertToTimestamp } from '@based/utils';
 export function isSeparate(schemaProp, len) {
-    return len === 0 || isPropType('vector', schemaProp);
+    return (len === 0 ||
+        isPropType('vector', schemaProp) ||
+        isPropType('colvec', schemaProp));
 }
 export const propIsSigned = (prop) => {
     const t = prop.typeIndex;
@@ -25,6 +28,28 @@ export const propIsNumerical = (prop) => {
     }
     return false;
 };
+export const schemaVectorBaseTypeToEnum = (vector) => {
+    switch (vector) {
+        case 'int8':
+            return VectorBaseType.Int8;
+        case 'uint8':
+            return VectorBaseType.Uint8;
+        case 'int16':
+            return VectorBaseType.Int16;
+        case 'uint16':
+            return VectorBaseType.Uint16;
+        case 'int32':
+            return VectorBaseType.Int32;
+        case 'uint32':
+            return VectorBaseType.Uint32;
+        case 'float32':
+            return VectorBaseType.Float32;
+        case 'float64':
+            return VectorBaseType.Float64;
+        case 'number':
+            return VectorBaseType.Float64;
+    }
+};
 export function getPropLen(schemaProp) {
     let len = SIZE_MAP[getPropType(schemaProp)];
     if (isPropType('string', schemaProp) ||
@@ -42,6 +67,23 @@ export function getPropLen(schemaProp) {
     else if (isPropType('vector', schemaProp)) {
         len = 4 * schemaProp.size;
     }
+    else if (isPropType('colvec', schemaProp)) {
+        len =
+            schemaProp.size *
+                VECTOR_BASE_TYPE_SIZE_MAP[schemaVectorBaseTypeToEnum(schemaProp.baseType) ??
+                    VectorBaseType.Float64];
+    }
     return len;
 }
+export const parseMinMaxStep = (val) => {
+    if (typeof val === 'number') {
+        return val;
+    }
+    if (typeof val === 'string') {
+        if (!val.includes('now')) {
+            return convertToTimestamp(val);
+        }
+        return val;
+    }
+};
 //# sourceMappingURL=utils.js.map

package/dist/def/validation.d.ts

@@ -0,0 +1,7 @@
+import { TypeIndex, PropDef, PropDefEdge } from './types.js';
+export type Validation = (payload: any, prop: PropDef | PropDefEdge) => boolean;
+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;
+//# sourceMappingURL=validation.d.ts.map

package/dist/def/validation.js

@@ -0,0 +1,261 @@
+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';
+const EPSILON = 1e-9; // Small tolerance for floating point comparisons
+export const VALIDATION_MAP = {
+    [NULL]: () => true,
+    [OBJECT]: () => true,
+    [COLVEC]: () => true,
+    [WEAK_REFERENCE]: () => true,
+    [WEAK_REFERENCES]: () => true,
+    [ALIAS]: (value) => {
+        if (typeof value !== 'string') {
+            return false;
+        }
+        return true;
+    },
+    [BINARY]: (value) => {
+        if (value instanceof Uint8Array) {
+            return true;
+        }
+        return false;
+    },
+    [BOOLEAN]: (value) => {
+        if (typeof value !== 'boolean') {
+            return false;
+        }
+        return true;
+    },
+    [CARDINALITY]: (val) => {
+        return (typeof val === 'string' ||
+            (val instanceof Uint8Array && val.byteLength === 8));
+    },
+    [TIMESTAMP]: (value, t) => {
+        if (typeof value !== 'number' || value % t.step !== 0) {
+            return false;
+        }
+        if (t.min !== undefined) {
+            if (typeof t.min === 'number') {
+                if (value < t.min) {
+                    return false;
+                }
+            }
+            else if (value < convertToTimestamp(t.min)) {
+                return false;
+            }
+        }
+        if (t.max !== undefined) {
+            if (typeof t.max === 'number') {
+                if (value > t.max) {
+                    return false;
+                }
+            }
+            else if (value > convertToTimestamp(t.max)) {
+                return false;
+            }
+        }
+        return true;
+    },
+    [INT16]: (value, t) => {
+        if (typeof value !== 'number' || value % t.step !== 0) {
+            return false;
+        }
+        if (value > 32767 || value < -32768) {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [INT32]: (value, t) => {
+        if (typeof value !== 'number' || value % t.step !== 0) {
+            return false;
+        }
+        if (value > 2147483647 || value < -2147483648) {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [INT8]: (value, t) => {
+        // use % for steps size
+        if (typeof value !== 'number' || value % t.step !== 0) {
+            return false;
+        }
+        if (value > 127 || value < -128) {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [UINT8]: (value, t) => {
+        if (typeof value !== 'number' || value % t.step !== 0) {
+            return false;
+        }
+        if (value > 255 || value < 0) {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [UINT16]: (value, t) => {
+        if (typeof value !== 'number' || value % t.step !== 0) {
+            return false;
+        }
+        if (value > 65535 || value < 0) {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [UINT32]: (value, t) => {
+        if (typeof value !== 'number' || value % t.step !== 0) {
+            return false;
+        }
+        if (value > 4294967295 || value < 0) {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [NUMBER]: (value, t) => {
+        if (t.step) {
+            const div = value / t.step;
+            if (Math.abs(div - Math.round(div)) > EPSILON) {
+                return false;
+            }
+        }
+        if (typeof value !== 'number') {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [ENUM]: (value, prop) => {
+        if (value === null) {
+            return true;
+        }
+        const arr = prop.enum;
+        for (let i = 0; i < arr.length; i++) {
+            if (value === arr[i]) {
+                return true;
+            }
+        }
+        return false;
+    },
+    [ID]: (value) => {
+        if (typeof value !== 'number' || value % 1 !== 0) {
+            return false;
+        }
+        return true;
+    },
+    [JSON]: (value) => {
+        // mep
+        return true;
+    },
+    [MICRO_BUFFER]: (value) => {
+        if (!(value instanceof Uint8Array)) {
+            return false;
+        }
+        return true;
+    },
+    [REFERENCE]: (v) => {
+        if (typeof v !== 'number') {
+            return false;
+        }
+        if (v === 0 || v > MAX_ID) {
+            return false;
+        }
+        return true;
+    },
+    [REFERENCES]: (v) => {
+        if (typeof v !== 'number') {
+            return false;
+        }
+        if (v === 0 || v > MAX_ID) {
+            return false;
+        }
+        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)) {
+            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)) {
+            return false;
+        }
+        return true;
+    },
+    [ALIASES]: (value) => {
+        if (!Array.isArray(value)) {
+            return false;
+        }
+        const len = value.length;
+        for (let i = 0; i < len; i++) {
+            if (typeof value[i] !== 'string') {
+                return false;
+            }
+        }
+        return true;
+    },
+    [VECTOR]: (value) => {
+        // Array should be supported
+        if (!(value instanceof Float32Array)) {
+            return false;
+        }
+        return true;
+    },
+};
+export const defaultValidation = () => true;
+export const isValidId = (id) => {
+    if (typeof id != 'number' || id < MIN_ID || id > MAX_ID) {
+        return false;
+    }
+    return true;
+};
+export const isValidString = (v) => {
+    const isVal = typeof v === 'string' ||
+        v instanceof Uint8Array ||
+        ArrayBuffer.isView(v);
+    return isVal;
+};
+//# sourceMappingURL=validation.js.map

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 export * from './types.js';
 export * from './parse/index.js';
 export * from './lang.js';
-export * from './mermaid.js';
+export * from './def/validation.js';
+export * from './serialize.js';
+export * from './infer.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,5 +1,7 @@
 export * from './types.js';
 export * from './parse/index.js';
 export * from './lang.js';
-export * from './mermaid.js';
+export * from './def/validation.js';
+export * from './serialize.js';
+export * from './infer.js';
 //# sourceMappingURL=index.js.map

package/dist/infer.d.ts

@@ -0,0 +1,82 @@
+import { Schema } from './types.js';
+type InferString = string;
+type InferNumber = number;
+type InferBoolean = boolean;
+type InferText = string;
+type InferJson = any;
+type InferTimestamp = number;
+type InferBinary = Uint8Array;
+type InferCardinality = number;
+type InferVector = Float32Array;
+type InferColvec = Float32Array;
+type InferEnum<T extends readonly (string | number | boolean)[]> = T[number];
+type InferReference<RefName extends string, Types> = RefName extends keyof Types ? {
+    id: number;
+} & InferSchemaType<Types[RefName], Types> : {
+    id: number;
+} | undefined;
+type InferReferences<RefName extends string, Types> = RefName extends keyof Types ? Array<{
+    id: number;
+} & InferSchemaType<Types[RefName], Types>> : Array<{
+    id: number;
+}>;
+type InferObject<T extends Record<string, any>, Types> = {
+    [K in keyof T]: InferProp<T[K], Types>;
+};
+type InferSet<T, Types> = InferProp<T, Types>[];
+type InferProp<T, Types> = T extends {
+    type: 'string';
+} ? InferString : T extends {
+    type: 'number' | 'int8' | 'uint8' | 'int16' | 'uint16' | 'int32' | 'uint32';
+} ? InferNumber : T extends {
+    type: 'boolean';
+} ? InferBoolean : T extends {
+    type: 'text';
+} ? InferText : T extends {
+    type: 'json';
+} ? InferJson : T extends {
+    type: 'timestamp';
+} ? InferTimestamp : T extends {
+    type: 'binary';
+} ? InferBinary : T extends {
+    type: 'cardinality';
+} ? InferCardinality : T extends {
+    type: 'vector';
+} ? InferVector : T extends {
+    type: 'colvec';
+} ? InferColvec : T extends {
+    enum: infer E;
+} ? E extends readonly (string | number | boolean)[] ? InferEnum<E> : never : T extends {
+    ref: infer R extends string;
+} ? InferReference<R, Types> : T extends {
+    items: {
+        ref: infer R extends string;
+    };
+} ? InferReferences<R, Types> : T extends {
+    items: infer I;
+} ? InferSet<I, Types> : T extends {
+    props: infer P;
+} ? InferObject<P, Types> : T extends string ? T extends 'string' ? InferString : T extends 'number' | 'int8' | 'uint8' | 'int16' | 'uint16' | 'int32' | 'uint32' ? InferNumber : T extends 'boolean' ? InferBoolean : T extends 'text' ? InferText : T extends 'json' ? InferJson : T extends 'timestamp' ? InferTimestamp : T extends 'binary' ? InferBinary : T extends 'cardinality' ? InferCardinality : T extends 'vector' ? InferVector : T extends 'colvec' ? InferColvec : never : never;
+type InferSchemaType<T, Types> = T extends {
+    props: infer Props;
+} ? {
+    [K in keyof Props]: InferProp<Props[K], Types>;
+} & {
+    id: number;
+} : {
+    [K in keyof T]: InferProp<T[K], Types>;
+} & {
+    id: number;
+};
+type InferSchemaTypes<T> = {
+    [K in keyof T]: InferSchemaType<T[K], 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 declare const infer: <T extends {
+    types: Record<string, any>;
+}>(schema: T) => InferSchema<T>;
+export {};
+//# sourceMappingURL=infer.d.ts.map

package/dist/infer.js

@@ -0,0 +1,5 @@
+// Main inference function, returns the inferred schema
+export const infer = (schema) => {
+    return schema.types;
+};
+//# sourceMappingURL=infer.js.map

package/dist/lang.d.ts

@@ -144,8 +144,10 @@ declare const langCodes: {
     readonly yi: 142;
     readonly yo: 143;
     readonly zu: 144;
+    readonly ka: 145;
+    readonly cnr: 146;
 };
-export declare const langCodesMap: Map<string, 0 | 2 | 1 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144>;
+export declare const langCodesMap: Map<string, 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | 146>;
 export declare const inverseLangMap: Map<any, any>;
 export type LangName = keyof typeof langCodes;
 export type LangCode = (typeof langCodes)[LangName];

package/dist/lang.js

@@ -144,10 +144,16 @@ const langCodes = {
     yi: 142,
     yo: 143,
     zu: 144,
+    ka: 145,
+    cnr: 146,
 };
 export const langCodesMap = new Map(Object.entries(langCodes));
 export const inverseLangMap = new Map();
 langCodesMap.forEach((v, k) => {
     inverseLangMap.set(v, k);
 });
+// generate this
+// __aaabafaksqamarangyasaevaeyazeubebnbisbsbrbgmycakmcezhcvkwcohrxsdadvnldzenetfofifrffgdgldegswelklguhtahahehihuisiiganiaiuikgaitjaknkskkrwkokukylolalvlblilnltmkmgmsmlmtgvmironmnesenoenbnocoroospsfaplptqurmrusmsascrsdsisklslsostnresswssvtlttattethbotitotstntrktkugukuruzveviwacyfywoxhyiyozukacnr
+// for the reader index = code * 2 [0] [1]
+// add a file to the build step
 //# sourceMappingURL=lang.js.map

package/dist/parse/assert.d.ts

@@ -1,8 +1,12 @@
+import { type SemVer } from '@std/semver';
+export declare const expectVersion: (obj: any) => SemVer;
 export declare const expectObject: (obj: any, msg?: string) => void;
+export declare const expectArray: (obj: any) => void;
 export declare const expectFloat32Array: (arr: any) => void;
 export declare const expectString: (obj: any) => void;
 export declare const expectBoolean: (v: any) => void;
 export declare const expectFunction: (v: any) => void;
 export declare const expectNumber: (v: any) => void;
 export declare const expectPositiveNumber: (v: any) => void;
+export declare const expectTimezoneName: (v: any) => void;
 //# sourceMappingURL=assert.d.ts.map

package/dist/parse/assert.js

@@ -1,12 +1,25 @@
-import { isFloat32Array } from 'util/types';
+import { parse } from '@std/semver';
 import { EXPECTED_ARR, EXPECTED_BOOL, EXPECTED_FN, EXPECTED_NUM, EXPECTED_OBJ, EXPECTED_STR, } from './errors.js';
+export const expectVersion = (obj) => {
+    try {
+        return parse(obj);
+    }
+    catch (e) {
+        throw Error('invalid semver version');
+    }
+};
 export const expectObject = (obj, msg) => {
     if (typeof obj !== 'object' || obj === null) {
         throw Error(msg || EXPECTED_OBJ);
     }
 };
+export const expectArray = (obj) => {
+    if (!Array.isArray(obj)) {
+        throw Error(EXPECTED_ARR);
+    }
+};
 export const expectFloat32Array = (arr) => {
-    if (!isFloat32Array(arr)) {
+    if (!(arr instanceof Float32Array)) {
         throw Error(EXPECTED_ARR);
     }
 };
@@ -36,4 +49,8 @@ export const expectPositiveNumber = (v) => {
         throw Error('Expected positive number');
     }
 };
+export const expectTimezoneName = (v) => {
+    expectString(v);
+    Intl.DateTimeFormat(undefined, { timeZone: v });
+};
 //# sourceMappingURL=assert.js.map

package/dist/parse/index.d.ts

@@ -12,6 +12,8 @@ export declare class SchemaParser {
     parseTypes(): void;
     parseProps(props: any, schemaType?: SchemaType): void;
     parseLocales(): void;
+    parseDefaultTimezone(): void;
+    parseMigrations(): void;
     parse(): StrictSchema;
 }
 export declare const print: (schema: Schema, path: string[]) => string;

package/dist/parse/index.js

@@ -2,11 +2,13 @@ import { INVALID_KEY, INVALID_VALUE, UNKNOWN_PROP } from './errors.js';
 import { getPropType } from './utils.js';
 import propParsers from './props.js';
 import pc from 'picocolors';
-import { expectBoolean, expectObject } from './assert.js';
-import { deepCopy } from '@saulx/utils';
+import { expectArray, expectBoolean, expectFunction, expectObject, expectTimezoneName, expectVersion, } from './assert.js';
+import { deepCopy } from '@based/utils';
+import { satisfies, parseRange, parse as parseVersion, rangeIntersects, } from '@std/semver';
 export { getPropType };
 export class SchemaParser {
     constructor(schema) {
+        // uint8Array is not working
         this.schema = deepCopy(schema);
     }
     isItems;
@@ -64,6 +66,9 @@ export class SchemaParser {
         expectObject(locales);
         for (const locale in locales) {
             const opts = locales[locale];
+            if (opts === true) {
+                continue;
+            }
             expectObject(opts);
             for (const key in opts) {
                 const val = opts[key];
@@ -71,7 +76,7 @@ export class SchemaParser {
                     expectBoolean(val);
                 }
                 else if (key === 'fallback') {
-                    if (!Array.isArray(val) || !val.every((v) => typeof v === 'string')) {
+                    if (Array.isArray(val) || typeof val !== 'string') {
                         throw Error(INVALID_VALUE);
                     }
                 }
@@ -81,6 +86,43 @@ export class SchemaParser {
             }
         }
     }
+    parseDefaultTimezone() {
+        expectTimezoneName(this.schema.defaultTimezone);
+    }
+    parseMigrations() {
+        const { migrations, version } = this.schema;
+        const ranges = new Map();
+        expectArray(migrations);
+        for (const item of migrations) {
+            expectObject(item);
+            expectObject(item.migrate);
+            const targetRange = parseRange(item.version);
+            const currentVersion = parseVersion(version);
+            if (satisfies(currentVersion, targetRange)) {
+                throw Error('migration version can not match current version');
+            }
+            if (Object.keys(item).length > 2) {
+                throw new Error('migrations can only have "version" and "migrate" properties');
+            }
+            for (const type in item.migrate) {
+                expectFunction(item.migrate[type]);
+                if (ranges.has(type)) {
+                    const otherRanges = ranges.get(type);
+                    for (const otherRange of otherRanges) {
+                        if (rangeIntersects(targetRange, otherRange)) {
+                            throw Error('invalid overlapping version for migration for ' +
+                                type +
+                                ` ${JSON.stringify(otherRange)} ${JSON.stringify(targetRange)} ${otherRange === targetRange}`);
+                        }
+                    }
+                    ranges.get(type).push(targetRange);
+                }
+                else {
+                    ranges.set(type, [targetRange]);
+                }
+            }
+        }
+    }
     parse() {
         expectObject(this.schema);
         // always do types first because it removes props shorthand
@@ -88,12 +130,21 @@ export class SchemaParser {
             this.parseTypes();
         }
         for (const key in this.schema) {
-            if (key === 'props') {
+            if (key === 'version') {
+                expectVersion(this.schema.version);
+            }
+            else if (key === 'props') {
                 this.parseProps(this.schema.props);
             }
             else if (key === 'locales') {
                 this.parseLocales();
             }
+            else if (key === 'defaultTimezone') {
+                this.parseDefaultTimezone();
+            }
+            else if (key === 'migrations') {
+                this.parseMigrations();
+            }
             else if (key !== 'types') {
                 throw Error(UNKNOWN_PROP);
             }
@@ -105,6 +156,9 @@ export const print = (schema, path) => {
     let obj = schema;
     const depth = path.length - 1;
     const lines = path.map((key, lvl) => {
+        if (typeof obj !== 'object') {
+            return '';
+        }
         const v = obj[key];
         const padding = '  '.repeat(lvl);
         const prefix = key === Object.keys(obj)[0] ? '' : `${padding}...\n`;

package/dist/parse/props.d.ts

@@ -3,5 +3,6 @@ import type { SchemaParser } from './index.js';
 type PropsFns<PropType> = Record<string, (val: any, prop: PropType, ctx: SchemaParser, key?: string) => void>;
 declare function propParser<PropType extends SchemaAnyProp>(required: PropsFns<PropType>, optional: PropsFns<PropType>, allowShorthand?: number): (prop: any, ctx: SchemaParser) => void;
 declare const p: Record<string, ReturnType<typeof propParser>>;
+export declare const isDefault: (val: any, prop: any, ctx: any) => any;
 export default p;
 //# sourceMappingURL=props.d.ts.map