@based/schema 4.1.1 → 5.0.0-alpha.1

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 {};

package/dist/src/compat/index.js

@@ -1,217 +0,0 @@
-const oldToNewType = {
-    id: { type: 'string', format: 'basedId' },
-    int: { type: 'integer' },
-    url: { type: 'string', format: 'URL' },
-    email: { type: 'string', format: 'email' },
-    float: { type: 'number' },
-    phone: { type: 'string', format: 'mobilePhone' },
-    digest: { type: 'string', format: 'strongPassword' },
-};
-const newToOldType = {
-    mobilePhone: { type: 'phone' },
-    basedId: { type: 'id' },
-    integer: { type: 'int' },
-    URL: { type: 'url' },
-    email: { type: 'email' },
-    strongPassword: { type: 'digest' },
-};
-const convertNewToOldMeta = (props) => {
-    let meta;
-    for (const i in props) {
-        if (i[0] !== '$') {
-            const v = props[i];
-            meta ??= {};
-            if (i === 'allowedType') {
-                meta.refTypes = v;
-            }
-            else if (i === 'display' && v === 'bytes') {
-                meta.format = v;
-            }
-            else if (i === 'title') {
-                meta.name = v;
-            }
-            else {
-                meta[i] = v;
-            }
-        }
-    }
-    return meta;
-};
-const convertOldToNewMeta = (props) => {
-    const meta = {};
-    for (const i in props) {
-        const v = props[i];
-        if (i === 'refTypes') {
-            meta.allowedType = v; // TODO
-        }
-        else if (i === 'format' && v === 'bytes') {
-            meta.display = 'bytes';
-        }
-        else if (i === 'name') {
-            meta.title = v;
-        }
-        else {
-            meta[i] = v;
-        }
-    }
-    return meta;
-};
-const convertNewFieldToOldField = (newField) => {
-    // @ts-ignore
-    const { type, bidirectional, properties, values, items, ...props } = newField;
-    const meta = convertNewToOldMeta(props);
-    // @ts-ignore
-    const overwrite = newToOldType[type] || newToOldType[props.format];
-    const oldField = overwrite
-        ? { ...overwrite }
-        : {
-            type,
-        };
-    if (meta) {
-        oldField.meta = meta;
-    }
-    if (bidirectional) {
-        // @ts-ignore
-        oldField.bidirectional = bidirectional;
-    }
-    if (properties) {
-        // @ts-ignore
-        oldField.properties = {};
-        for (const key in properties) {
-            // @ts-ignore
-            oldField.properties[key] = convertNewFieldToOldField(properties[key]);
-        }
-    }
-    if (values) {
-        // @ts-ignore
-        oldField.values = convertNewFieldToOldField(values);
-    }
-    if (items) {
-        // @ts-ignore
-        oldField.items = convertNewFieldToOldField(items);
-    }
-    return oldField;
-};
-const convertNewTypeToOldType = (newType) => {
-    const { prefix, fields, ...props } = newType;
-    const oldType = {};
-    const meta = convertNewToOldMeta(props);
-    if (prefix) {
-        oldType.prefix = prefix;
-    }
-    if (meta) {
-        oldType.meta = meta;
-    }
-    if (fields) {
-        oldType.fields = {};
-        for (const key in fields) {
-            // @ts-ignore
-            oldType.fields[key] = convertNewFieldToOldField(fields[key]);
-        }
-    }
-    return oldType;
-};
-export const convertNewToOld = (newSchema) => {
-    const { root, types, language, translations, prefixToTypeMapping } = newSchema;
-    const oldSchema = {};
-    if (prefixToTypeMapping) {
-        oldSchema.prefixToTypeMapping = prefixToTypeMapping;
-    }
-    if (language) {
-        oldSchema.languages = [language];
-    }
-    if (translations) {
-        oldSchema.languages ??= [];
-        oldSchema.languages.push(...translations);
-    }
-    if (root) {
-        oldSchema.rootType = convertNewTypeToOldType(root);
-    }
-    if (types) {
-        oldSchema.types = {};
-        for (const key in types) {
-            oldSchema.types[key] = convertNewTypeToOldType(types[key]);
-        }
-    }
-    return oldSchema;
-};
-const convertOldFieldToNewField = (oldField) => {
-    // @ts-ignore
-    const { type, bidirectional, properties, values, items, meta = {} } = oldField;
-    const overwrite = oldToNewType[type] || oldToNewType[meta.format];
-    const newField = overwrite
-        ? {
-            ...overwrite,
-            ...convertOldToNewMeta(meta),
-        }
-        : {
-            type,
-            ...convertOldToNewMeta(meta),
-        };
-    if (bidirectional) {
-        // @ts-ignore
-        newField.bidirectional = bidirectional;
-    }
-    if (properties) {
-        // @ts-ignore
-        newField.properties = {};
-        for (const key in properties) {
-            // @ts-ignore
-            newField.properties[key] = convertOldFieldToNewField(properties[key]);
-        }
-    }
-    if (values) {
-        // @ts-ignore
-        newField.values = convertOldFieldToNewField(values);
-    }
-    if (items) {
-        // @ts-ignore
-        newField.items = convertOldFieldToNewField(items);
-    }
-    return newField;
-};
-const convertOldTypeToNewType = (oldType) => {
-    const { prefix, fields, meta } = oldType;
-    const newType = {
-        fields: {},
-    };
-    if (prefix) {
-        newType.prefix = prefix;
-    }
-    if (meta) {
-        Object.assign(newType, convertOldToNewMeta(meta));
-    }
-    if (fields) {
-        for (const key in fields) {
-            newType.fields[key] = convertOldFieldToNewField(fields[key]);
-        }
-    }
-    return newType;
-};
-export const convertOldToNew = (oldSchema) => {
-    const { rootType, types, languages, prefixToTypeMapping } = oldSchema;
-    const newSchema = {};
-    if (prefixToTypeMapping) {
-        newSchema.prefixToTypeMapping = prefixToTypeMapping;
-    }
-    if (languages?.length) {
-        // @ts-ignore
-        newSchema.language = languages[0];
-        const translations = languages.slice(1);
-        if (translations.length) {
-            // @ts-ignore
-            newSchema.translations = translations;
-        }
-    }
-    if (rootType) {
-        newSchema.root = convertOldTypeToNewType(rootType);
-    }
-    if (types) {
-        newSchema.types = {};
-        for (const key in types) {
-            newSchema.types[key] = convertOldTypeToNewType(types[key]);
-        }
-    }
-    return newSchema;
-};
-//# sourceMappingURL=index.js.map

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

@@ -1,93 +0,0 @@
-type FieldType = 'float' | 'boolean' | 'number' | 'int' | 'string' | 'text' | 'id' | 'digest' | 'url' | 'email' | 'phone' | 'geo' | 'type' | 'timestamp';
-export type FieldSchemaObject = {
-    type: 'object';
-    properties: {
-        [key: string]: FieldSchema;
-    };
-    meta?: any;
-    timeseries?: boolean;
-};
-type FieldSchemaJson = {
-    type: 'json';
-    properties?: {
-        [key: string]: FieldSchema;
-    };
-    meta?: any;
-    timeseries?: boolean;
-};
-type FieldSchemaRecord = {
-    type: 'record';
-    values: FieldSchema;
-    meta?: any;
-    timeseries?: boolean;
-};
-type FieldSchemaReferences = {
-    type: 'reference' | 'references';
-    bidirectional?: {
-        fromField: string;
-    };
-    meta?: any;
-    timeseries?: boolean;
-};
-type FieldSchemaOther = {
-    type: FieldType;
-    meta?: any;
-    timeseries?: boolean;
-};
-export type FieldSchemaArrayLike = {
-    type: 'set' | 'array';
-    items: FieldSchema;
-    meta?: any;
-    timeseries?: boolean;
-};
-export type FieldSchema = FieldSchemaObject | FieldSchemaRecord | FieldSchemaArrayLike | FieldSchemaJson | FieldSchemaReferences | FieldSchemaOther;
-type FieldInputSchemaArrayLike = {
-    type: 'set' | 'array';
-    items: FieldInputSchema;
-    meta?: any;
-    timeseries?: boolean;
-};
-type FieldInputSchemaRecord = {
-    type: 'record';
-    values: FieldInputSchema;
-    meta?: any;
-    timeseries?: boolean;
-};
-export type FieldInputSchemaObject = {
-    type: 'object';
-    properties: {
-        [key: string]: FieldInputSchema;
-    };
-    meta?: any;
-    timeseries?: boolean;
-};
-type FieldInputSchema = FieldSchema | FieldInputSchemaArrayLike | FieldInputSchemaRecord | FieldInputSchemaObject | DeleteField;
-type DeleteField = {
-    $delete: boolean;
-};
-type Fields = Record<string, FieldSchema>;
-type HierarchySchema = false | {
-    [key: string]: false | {
-        excludeAncestryWith: string[];
-    } | {
-        includeAncestryWith: string[];
-    };
-};
-export type TypeSchema = {
-    prefix?: string;
-    hierarchy?: HierarchySchema;
-    fields?: Fields;
-    meta?: any;
-};
-type Types = {
-    [key: string]: TypeSchema;
-};
-export type BasedOldSchema = {
-    sha?: string;
-    languages?: string[];
-    types: Types;
-    rootType?: Pick<TypeSchema, 'fields' | 'prefix' | 'meta'>;
-    idSeedCounter?: number;
-    prefixToTypeMapping?: Record<string, string>;
-};
-export {};

package/dist/src/compat/oldSchemaType.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=oldSchemaType.js.map

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

@@ -1,2 +0,0 @@
-import { BasedSchemaField } from '../types.js';
-export declare const display: (value: string | number | undefined, field: BasedSchemaField) => string | number | undefined;

package/dist/src/display/index.js

@@ -1,16 +0,0 @@
-import timestampDisplay from './timestamp.js';
-import numberDisplay from './number.js';
-import stringDisplay from './string.js';
-export const display = (value, field) => {
-    if (field.type === 'timestamp' && typeof value === 'number') {
-        return timestampDisplay(value, field.display);
-    }
-    if (field.type === 'number' && typeof value === 'number') {
-        return numberDisplay(value, field.display);
-    }
-    if (field.type === 'string' && typeof value === 'string') {
-        return stringDisplay(value, field.display);
-    }
-    return value;
-};
-//# sourceMappingURL=index.js.map

package/dist/src/display/number.d.ts

@@ -1,4 +0,0 @@
-export declare const basedSchemaNumberFormats: readonly [any, "short", "human", "ratio", "bytes", "euro", "dollar", "pound"];
-export type NumberFormat = (typeof basedSchemaNumberFormats)[number] | `round-${number}`;
-declare const parseNumber: (nr: number | string, format?: NumberFormat) => string | number;
-export default parseNumber;