@based/schema 4.1.1 → 5.0.0-alpha.0

package/dist/types.js

@@ -1,4 +1,97 @@
 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',
+    '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',
+    // TODO: for discussion
+    'multiline',
+];
 export const isPropType = (type, prop) => {
     return getPropType(prop) === type;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@based/schema",
-  "version": "4.1.1",
+  "version": "5.0.0-alpha.0",
   "license": "MIT",
   "main": "dist/index.js",
   "files": [
@@ -12,7 +12,8 @@
   "scripts": {
     "build": "tsc",
     "watch": "tsc --watch",
-    "test": "tsc && tsc test/*.ts --noEmit && tsx --test test/*.ts"
+    "test": "tsc && tsc test/*.ts --noEmit && tsx --test test/*.ts",
+    "test1": "tsc && tsc $npm_config --noEmit && tsx --test $npm_config"
   },
   "prettier": "@saulx/prettier-config",
   "sideEffects": false,
@@ -22,7 +23,7 @@
     "@saulx/tsconfig": "^1.1.0",
     "@types/node": "22.5.3",
     "tsx": "^4.19.0",
-    "typescript": "^5.1.6"
+    "typescript": "^5.6.3"
   },
   "dependencies": {
     "picocolors": "^1.1.0"

package/dist/parsePayload/index.d.ts

@@ -1,3 +0,0 @@
-import { Schema } from '../types.js';
-export declare const parsePayload: (payload: any, schema: Schema, type?: string) => void;
-//# sourceMappingURL=index.d.ts.map

package/dist/parsePayload/index.js

@@ -1,2 +0,0 @@
-export const parsePayload = (payload, schema, type) => { };
-//# sourceMappingURL=index.js.map

package/dist/parseSchema/assert.d.ts

@@ -1,6 +0,0 @@
-export declare const expectObject: (obj: 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;
-//# sourceMappingURL=assert.d.ts.map

package/dist/parseSchema/assert.js

@@ -1,27 +0,0 @@
-import { EXPECTED_BOOL, EXPECTED_FN, EXPECTED_NUM, EXPECTED_OBJ, EXPECTED_STR, } from './errors.js';
-export const expectObject = (obj) => {
-    if (typeof obj !== 'object' || obj === null) {
-        throw Error(EXPECTED_OBJ);
-    }
-};
-export const expectString = (obj) => {
-    if (typeof obj !== 'string') {
-        throw Error(EXPECTED_STR);
-    }
-};
-export const expectBoolean = (v) => {
-    if (v !== true && v !== false) {
-        throw Error(EXPECTED_BOOL);
-    }
-};
-export const expectFunction = (v) => {
-    if (typeof v !== 'function') {
-        throw Error(EXPECTED_FN);
-    }
-};
-export const expectNumber = (v) => {
-    if (typeof v !== 'number') {
-        throw Error(EXPECTED_NUM);
-    }
-};
-//# sourceMappingURL=assert.js.map

package/dist/parseSchema/errors.d.ts

@@ -1,19 +0,0 @@
-export declare const OUT_OF_RANGE = "Value is out of range";
-export declare const EXPECTED_VALUE_IN_ENUM = "Expected value in \"enum\" field";
-export declare const EXPECTED_DATE = "Expected number or Date";
-export declare const EXPECTED_BOOL = "Expected boolean";
-export declare const EXPECTED_OBJ = "Expected object";
-export declare const EXPECTED_ARR = "Expected array";
-export declare const EXPECTED_NUM = "Expected number";
-export declare const EXPECTED_STR = "Expected string";
-export declare const EXPECTED_FN = "Expected function";
-export declare const EXPECTED_PRIMITIVE = "Expected primitive value";
-export declare const INVALID_VALUE = "Invalid value";
-export declare const INVALID_SCHEMA = "Invalid schema";
-export declare const MIN_MAX = "Max value must be larger than min value";
-export declare const UNKNOWN_PROP = "Unknown property";
-export declare const MISSING_TYPE = "Missing type";
-export declare const INVALID_TYPE = "Invalid type";
-export declare const TEXT_REQUIRES_LOCALES = "Type text requires locales";
-export declare const TYPE_MISMATCH = "Types do not match";
-//# sourceMappingURL=errors.d.ts.map

package/dist/parseSchema/errors.js

@@ -1,19 +0,0 @@
-export const OUT_OF_RANGE = 'Value is out of range';
-export const EXPECTED_VALUE_IN_ENUM = 'Expected value in "enum" field';
-export const EXPECTED_DATE = 'Expected number or Date';
-export const EXPECTED_BOOL = 'Expected boolean';
-export const EXPECTED_OBJ = 'Expected object';
-export const EXPECTED_ARR = 'Expected array';
-export const EXPECTED_NUM = 'Expected number';
-export const EXPECTED_STR = 'Expected string';
-export const EXPECTED_FN = 'Expected function';
-export const EXPECTED_PRIMITIVE = 'Expected primitive value';
-export const INVALID_VALUE = 'Invalid value';
-export const INVALID_SCHEMA = 'Invalid schema';
-export const MIN_MAX = 'Max value must be larger than min value';
-export const UNKNOWN_PROP = 'Unknown property';
-export const MISSING_TYPE = 'Missing type';
-export const INVALID_TYPE = 'Invalid type';
-export const TEXT_REQUIRES_LOCALES = 'Type text requires locales';
-export const TYPE_MISMATCH = 'Types do not match';
-//# sourceMappingURL=errors.js.map

package/dist/parseSchema/index.d.ts

@@ -1,20 +0,0 @@
-import { Schema, SchemaType } from '../types.js';
-import { getPropType } from './utils.js';
-export { getPropType };
-export declare class Parser {
-    constructor(schema: Schema);
-    inQuery: boolean;
-    schema: Schema;
-    type: SchemaType;
-    parseType(type: SchemaType): void;
-    parseTypes(): void;
-    parseProps(props: any, schemaType?: SchemaType): void;
-    parseLocales(): void;
-    parse(): void;
-}
-export declare const print: (schema: Schema, path: string[]) => string;
-export declare const debug: (schema: Schema) => void;
-export declare const parseSchema: (schema: Schema) => {
-    schema: Schema;
-};
-//# sourceMappingURL=index.d.ts.map

package/dist/parseSchema/index.js

@@ -1,132 +0,0 @@
-import { 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';
-export { getPropType };
-export class Parser {
-    constructor(schema) {
-        this.schema = schema;
-    }
-    inQuery;
-    schema;
-    type;
-    parseType(type) {
-        expectObject(type);
-        this.parseProps(type.props, type);
-    }
-    parseTypes() {
-        const { types } = this.schema;
-        expectObject(types);
-        for (const type in types) {
-            this.parseType(types[type]);
-        }
-    }
-    parseProps(props, schemaType = null) {
-        expectObject(props);
-        this.type = schemaType;
-        for (const key in props) {
-            const prop = props[key];
-            const type = getPropType(prop);
-            if (type in propParsers) {
-                propParsers[type](prop, this);
-            }
-            else {
-                throw Error(INVALID_VALUE);
-            }
-        }
-    }
-    parseLocales() {
-        const { locales } = this.schema;
-        expectObject(locales);
-        for (const locale in locales) {
-            const opts = locales[locale];
-            expectObject(opts);
-            for (const key in opts) {
-                const val = opts[key];
-                if (key === 'required') {
-                    expectBoolean(val);
-                }
-                else if (key === 'fallback') {
-                    if (!Array.isArray(val) || !val.every((v) => typeof v === 'string')) {
-                        throw Error(INVALID_VALUE);
-                    }
-                }
-                else {
-                    throw Error(UNKNOWN_PROP);
-                }
-            }
-        }
-    }
-    parse() {
-        expectObject(this.schema);
-        for (const key in this.schema) {
-            if (key === 'types') {
-                this.parseTypes();
-            }
-            else if (key === 'props') {
-                this.parseProps(this.schema.props);
-            }
-            else if (key === 'locales') {
-                this.parseLocales();
-            }
-            else {
-                throw Error(UNKNOWN_PROP);
-            }
-        }
-    }
-}
-export const print = (schema, path) => {
-    let obj = schema;
-    const depth = path.length - 1;
-    const lines = path.map((key, lvl) => {
-        const v = obj[key];
-        const padding = '  '.repeat(lvl);
-        const prefix = key === Object.keys(obj)[0] ? '' : `${padding}...\n`;
-        if (lvl === depth) {
-            const err = key in obj
-                ? `${key}: ${typeof v === 'object' && v !== null && !Array.isArray(v) ? `{..}` : JSON.stringify(v)}`
-                : key;
-            return `${prefix}${'--'.repeat(lvl - 1)}> ${pc.red(err)}`;
-        }
-        obj = v;
-        return `${prefix}${padding}${key}: {`;
-    });
-    return lines.join('\n');
-};
-export const debug = (schema) => {
-    let curr;
-    const proxy = (obj, path = []) => {
-        const copy = {};
-        return new Proxy(obj, {
-            get(_, key) {
-                const v = obj[key];
-                curr = [...path, key];
-                if (typeof v !== 'object' || v === null) {
-                    return v;
-                }
-                copy[key] ??= proxy(obj[key], curr);
-                return copy[key];
-            },
-        });
-    };
-    const parser = new Parser(proxy(schema));
-    try {
-        parser.parse();
-    }
-    catch (e) {
-        e.message += '\n\n' + print(schema, curr) + '\n';
-        e.cause = curr;
-        throw e;
-    }
-};
-export const parseSchema = (schema) => {
-    try {
-        new Parser(schema).parse();
-        return { schema };
-    }
-    catch (e) {
-        debug(schema);
-    }
-};
-//# sourceMappingURL=index.js.map

package/dist/parseSchema/props.d.ts

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

package/dist/parseSchema/props.js

@@ -1,256 +0,0 @@
-import { expectBoolean, expectFunction, expectObject, expectString, expectNumber, } from './assert.js';
-import { EXPECTED_ARR, EXPECTED_DATE, EXPECTED_OBJ, EXPECTED_PRIMITIVE, EXPECTED_VALUE_IN_ENUM, INVALID_VALUE, MIN_MAX, OUT_OF_RANGE, TEXT_REQUIRES_LOCALES, TYPE_MISMATCH, UNKNOWN_PROP, } from './errors.js';
-import { getPropType } from './utils.js';
-const shared = {
-    type() { },
-    required(val) {
-        expectBoolean(val);
-    },
-    query(val) {
-        expectFunction(val);
-    },
-    path(val, prop, ctx) {
-        expectString(val);
-        const path = val.split('.');
-        let t = ctx.type;
-        for (const key of path) {
-            if ('items' in t) {
-                t = t.items;
-            }
-            if ('ref' in t) {
-                t = ctx.schema.types[t.ref];
-            }
-            t = t.props[key];
-            expectObject(t);
-        }
-        if (t.type !== getPropType(prop)) {
-            throw Error(TYPE_MISMATCH);
-        }
-    },
-};
-function propParser(required, optional, allowShorthand) {
-    return (prop, ctx) => {
-        if (typeof prop === 'string') {
-            // allow string
-            if (allowShorthand === 0) {
-                return;
-            }
-            throw Error(EXPECTED_OBJ);
-        }
-        if (Array.isArray(prop)) {
-            // allow array
-            if (allowShorthand === 1) {
-                return;
-            }
-            throw Error(EXPECTED_OBJ);
-        }
-        for (const key in required) {
-            required[key](prop[key], prop, ctx);
-        }
-        for (const key in prop) {
-            const val = prop[key];
-            if (key in optional) {
-                optional[key](val, prop, ctx);
-            }
-            else if (key in shared) {
-                shared[key](val, prop, ctx);
-            }
-            else if (!(key in required)) {
-                if (key[0] === '$' && 'ref' in prop) {
-                    optional.edge(val, prop, ctx, key);
-                }
-                else {
-                    throw Error(UNKNOWN_PROP);
-                }
-            }
-        }
-    };
-}
-const p = {};
-p.boolean = propParser({}, {
-    default(val) {
-        expectBoolean(val);
-    },
-}, 0);
-p.enum = propParser({
-    enum(items) {
-        if (!Array.isArray(items)) {
-            throw Error(EXPECTED_ARR);
-        }
-        if (items.length > 255) {
-            throw Error('Max enum length (255) exceeded');
-        }
-        for (const item of items) {
-            if (typeof item === 'object') {
-                throw Error(EXPECTED_PRIMITIVE);
-            }
-        }
-    },
-}, {
-    default(val, prop) {
-        if (!prop.enum.includes(val)) {
-            throw Error(EXPECTED_VALUE_IN_ENUM);
-        }
-    },
-}, 1);
-p.number = propParser({
-    min(val) {
-        expectNumber(val);
-    },
-    max(val, prop) {
-        expectNumber(val);
-        if (prop.min > val) {
-            throw Error(MIN_MAX);
-        }
-    },
-    step(val) {
-        if (typeof val !== 'number' && val !== 'any') {
-            throw Error(INVALID_VALUE);
-        }
-    },
-}, {
-    default(val, prop) {
-        expectNumber(val);
-        if (val > prop.max || val < prop.min) {
-            throw Error(OUT_OF_RANGE);
-        }
-        if (prop.step !== 'any') {
-            const min = typeof prop.min !== 'number' || prop.min === Infinity ? 0 : prop.min;
-            const v = val - min;
-            if (~~(v / prop.step) * prop.step !== v) {
-                throw Error(INVALID_VALUE);
-            }
-        }
-    },
-}, 0);
-p.object = propParser({
-    props(val, prop, ctx) {
-        ctx.parseProps(val, ctx.type);
-    },
-}, {
-    default(val) {
-        console.warn('TODO object default value');
-    },
-});
-p.reference = propParser({
-    ref(ref, _prop, { schema }) {
-        schema.types[ref].props;
-    },
-    prop(propKey, prop, { schema, type, inQuery }) {
-        const propAllowed = type && !inQuery;
-        if (propAllowed) {
-            expectString(propKey);
-            let targetProp = schema.types[prop.ref].props[propKey];
-            if ('items' in targetProp) {
-                targetProp = targetProp.items;
-            }
-            if ('ref' in targetProp && 'prop' in targetProp) {
-                let t = schema.types[targetProp.ref].props[targetProp.prop];
-                if ('items' in t) {
-                    t = t.items;
-                }
-                if (t === prop) {
-                    return;
-                }
-            }
-            throw Error(INVALID_VALUE);
-        }
-        if (propKey !== undefined) {
-            throw Error('ref prop not supported on root or edge p');
-        }
-    },
-}, {
-    default(val) {
-        expectString(val);
-    },
-    edge(val, prop, ctx, key) {
-        const edgeAllowed = ctx.type && !ctx.inQuery;
-        if (edgeAllowed) {
-            let t = ctx.schema.types[prop.ref].props[prop.prop];
-            t = t.items || t;
-            if (t[key]) {
-                throw Error('Edge can not be defined on both props');
-            }
-            const edgePropType = getPropType(val);
-            p[edgePropType](val, ctx);
-            return;
-        }
-        throw Error('ref edge not supported on root or edge p');
-    },
-});
-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;
-            p[itemsType](items, ctx);
-            ctx.inQuery = 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);
-        const itemsType = getPropType(items);
-        if (itemsType === 'reference') {
-            ctx.inQuery = 'query' in prop;
-            p[itemsType](items, ctx);
-            ctx.inQuery = 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.string = propParser({}, {
-    default(val) {
-        expectString(val);
-    },
-}, 0);
-p.text = propParser({
-    type(_val, _prop, { schema }) {
-        if (schema.locales) {
-            for (const _ in schema.locales) {
-                return;
-            }
-        }
-        throw Error(TEXT_REQUIRES_LOCALES);
-    },
-}, {
-    default(val, prop) {
-        console.warn('MAKE DEFAULT VALUE FOR TEXT');
-        //   if (typeof val !== 'string') {
-        //     throwErr(ERRORS.EXPECTED_STR, prop, 'default')
-        //   }
-    },
-}, 0);
-p.timestamp = propParser({}, {
-    default(val) {
-        if (typeof val !== 'number' && !(val instanceof Date)) {
-            throw Error(EXPECTED_DATE);
-        }
-    },
-}, 0);
-export default p;
-//# sourceMappingURL=props.js.map

package/dist/parseSchema/utils.d.ts

@@ -1,3 +0,0 @@
-import { SchemaAnyProp, SchemaPropTypes } from '../types.js';
-export declare const getPropType: (prop: SchemaAnyProp) => SchemaPropTypes;
-//# sourceMappingURL=utils.d.ts.map

package/dist/parseSchema/utils.js

@@ -1,29 +0,0 @@
-import { INVALID_TYPE, MISSING_TYPE } from './errors.js';
-export const getPropType = (prop) => {
-    if (typeof prop === 'string') {
-        return prop;
-    }
-    if ('type' in prop) {
-        if (typeof prop.type !== 'string') {
-            throw Error(INVALID_TYPE);
-        }
-        return prop.type;
-    }
-    if ('ref' in prop) {
-        return 'reference';
-    }
-    if ('items' in prop) {
-        if (getPropType(prop.items) === 'reference') {
-            return 'references';
-        }
-        return 'set';
-    }
-    if ('props' in prop) {
-        return 'object';
-    }
-    if ('enum' in prop || Array.isArray(prop)) {
-        return 'enum';
-    }
-    throw Error(MISSING_TYPE);
-};
-//# sourceMappingURL=utils.js.map

package/dist/src/compat/index.d.ts

@@ -1,6 +0,0 @@
-import { BasedSchemaPartial } from '../types.js';
-import { BasedOldSchema } from './oldSchemaType.js';
-type OldSchema = Partial<BasedOldSchema>;
-export declare const convertNewToOld: (newSchema: BasedSchemaPartial) => OldSchema;
-export declare const convertOldToNew: (oldSchema: OldSchema) => BasedSchemaPartial;
-export {};