@based/schema 4.1.1 → 5.0.0-alpha.1

package/dist/types.d.ts

@@ -1,4 +1,15 @@
+import { LangName } from './lang.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"];
+type DateDisplay = (typeof dateDisplays)[number];
+type NumberDisplay = (typeof numberDisplays)[number] | `round-${number}`;
+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[];
 type Letter = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
+type AllowedKey = `${Letter}${string}`;
 type QueryFn = Function;
 type PropValues = {
     type?: string;
@@ -6,19 +17,25 @@ type PropValues = {
 };
 type Prop<V extends PropValues> = {
     required?: boolean;
-    label?: Record<string, string>;
-    description?: Record<string, string>;
+    title?: string | Record<string, string>;
+    description?: string | Record<string, string>;
     path?: string;
     query?: QueryFn;
+    role?: Role;
+    readOnly?: boolean;
+    examples?: string[];
 } & V;
 type EnumItem = string | number | boolean;
+type NeverInItems = {
+    required?: never;
+};
 export type SchemaReferences = Prop<{
     type?: 'references';
-    items: SchemaReference;
+    items: SchemaReference & NeverInItems;
 }>;
 export type SchemaReferencesOneWay = Prop<{
     type?: 'references';
-    items: SchemaReferenceOneWay;
+    items: SchemaReferenceOneWay & NeverInItems;
 }>;
 export type SchemaText = Prop<{
     type: 'text';
@@ -31,6 +48,7 @@ export type SchemaNumber = Prop<{
     min?: number;
     max?: number;
     step?: number | 'any';
+    display?: NumberDisplay;
 }>;
 export type SchemaString = Prop<{
     type: 'string';
@@ -38,31 +56,49 @@ export type SchemaString = Prop<{
     maxBytes?: number;
     max?: number;
     min?: number;
+    mime?: Mime;
+    format?: StringFormat;
+    compression?: 'none' | 'deflate';
 }>;
 export type SchemaBinary = Prop<{
     type: 'binary';
     default?: ArrayBuffer;
     maxBytes?: number;
+    mime?: Mime;
+    format?: StringFormat;
 }>;
 export type SchemaBoolean = Prop<{
     type: 'boolean';
     default?: boolean;
 }>;
+export type SchemaHll = Prop<{
+    type: 'hll';
+    default?: number;
+}>;
+export type SchemaVector = Prop<{
+    type: 'vector';
+    default?: Float32Array;
+    size: number;
+}>;
 export type SchemaTimestamp = Prop<{
     type: 'timestamp';
     default?: number | Date;
     on?: 'create' | 'update';
+    display?: DateDisplay;
 }>;
 export type SchemaReferenceOneWay = Prop<{
     type?: 'reference';
     default?: string;
     ref: string;
+    mime?: Mime;
 }>;
 export type SchemaReference = Prop<{
     type?: 'reference';
     default?: string;
     ref: string;
     prop: string;
+    dependent?: boolean;
+    mime?: Mime;
 }> & Record<`$${string}`, SchemaPropOneWay>;
 export type SchemaObject = Prop<{
     type?: 'object';
@@ -83,43 +119,54 @@ export type SchemaEnum = Prop<{
     default?: EnumItem;
     enum: EnumItem[];
 }>;
-export type SchemaAlias = SchemaString & {
+export type SchemaAlias = Omit<SchemaString, 'type'> & {
     type: 'alias';
 };
-export type SchemaPropShorthand = 'timestamp' | 'boolean' | 'string' | 'alias' | 'text' | NumberType | EnumItem[];
-type SetItems = SchemaPropShorthand | SchemaTimestamp | SchemaBoolean | SchemaNumber | SchemaString | SchemaEnum;
+export type SchemaPropShorthand = 'timestamp' | 'binary' | 'boolean' | 'string' | 'alias' | 'text' | 'hll' | 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;
+    items: ItemsType & NeverInItems;
 }>;
-type NonRefSchemaProps = SchemaPropShorthand | SchemaTimestamp | SchemaBoolean | SchemaNumber | SchemaString | SchemaAlias | SchemaText | SchemaEnum | SchemaSet;
-export type SchemaProp = SchemaReferencesWithQuery | SchemaReferenceWithQuery | NonRefSchemaProps | SchemaReferences | SchemaReference | SchemaObject | SchemaBinary;
-export type SchemaPropOneWay = SchemaReferencesOneWay | SchemaReferenceOneWay | SchemaObjectOneWay | NonRefSchemaProps;
+type NonRefSchemaProps<isStrict = false> = SchemaTimestamp | SchemaBoolean | SchemaNumber | SchemaString | SchemaAlias | SchemaText | SchemaEnum | SchemaBinary | SchemaHll | SchemaVector | (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 = Record<string, SchemaProp>;
-export type SchemaType = {
+export type SchemaProps<isStrict = false> = Record<AllowedKey, SchemaProp<isStrict>> & {
+    id?: never;
+};
+type GenericSchemaType<isStrict = false> = {
     hooks?: {
         create?: SchemaHook;
         update?: SchemaHook;
         delete?: SchemaHook;
     };
     id?: number;
-    props: SchemaProps;
+    props: SchemaProps<isStrict>;
+};
+export type StrictSchemaType = GenericSchemaType<true>;
+export type SchemaType<isStrict = false> = isStrict extends true ? StrictSchemaType : StrictSchemaType | GenericSchemaType<false> | (SchemaProps & {
+    props?: never;
+});
+export type SchemaTypeName = AllowedKey;
+export type SchemaTypes<isStrict = false> = Record<SchemaTypeName, SchemaType<isStrict>>;
+export type SchemaPropsOneWay<isStrict = false> = Record<AllowedKey, SchemaPropOneWay<isStrict>> & {
+    id?: never;
 };
-export type SchemaTypes = Record<string, SchemaType>;
-export type SchemaPropsOneWay = Record<`${Letter}${string}`, SchemaPropOneWay>;
-export type Schema = {
-    types?: SchemaTypes;
-    props?: SchemaPropsOneWay;
-    locales?: SchemaLocales;
+type GenericSchema<isStrict = false> = {
+    types?: SchemaTypes<isStrict>;
+    props?: SchemaPropsOneWay<isStrict>;
+    locales?: Partial<SchemaLocales>;
 };
-export type SchemaLocales = Record<string, {
+export type StrictSchema = GenericSchema<true>;
+export type Schema = GenericSchema<false> | StrictSchema;
+export type SchemaLocales = Record<LangName, {
     required?: boolean;
-    fallback?: string[];
+    fallback?: LangName[];
 }>;
 export type SchemaPropTypeMap = {
     references: SchemaReferences;
@@ -133,8 +180,10 @@ export type SchemaPropTypeMap = {
     text: SchemaText;
     set: SchemaSet;
     binary: SchemaBinary;
+    hll: SchemaHll;
+    vector: SchemaVector;
 } & Record<NumberType, SchemaNumber>;
 export type SchemaPropTypes = keyof SchemaPropTypeMap;
-export declare const isPropType: <T extends "string" | "boolean" | "object" | "references" | "timestamp" | "alias" | "text" | NumberType | "binary" | "reference" | "enum" | "set">(type: T, prop: SchemaProp) => prop is SchemaPropTypeMap[T];
+export declare const isPropType: <T extends SchemaPropTypes>(type: T, prop: SchemaProp) => prop is SchemaPropTypeMap[T];
 export {};
 //# sourceMappingURL=types.d.ts.map

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.1",
   "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