@based/schema 3.2.0 → 4.1.1

package/dist/src/compat/newToOld.js

@@ -1,218 +0,0 @@
-const metaChecker = (field) => {
-    return (field === 'validation' ||
-        // field === 'format' ||
-        field === 'index' ||
-        field === 'description' ||
-        field === 'title' ||
-        field === 'examples' ||
-        field === 'ui' ||
-        field === 'isRequired' ||
-        field === 'title' ||
-        field === 'description' ||
-        field === 'index' ||
-        field === 'readOnly' ||
-        field === 'writeOnly' ||
-        field === '$comment' ||
-        field === 'examples' ||
-        field === 'default' ||
-        field === 'customValidator' ||
-        field === 'value' ||
-        field === 'path' ||
-        field === 'target' ||
-        field === 'minLength' ||
-        field === 'maxLength' ||
-        field === 'contentMediaEncoding' ||
-        field === 'pattern' ||
-        field === 'display' ||
-        field === 'multiline' ||
-        field === 'multipleOf' ||
-        field === 'minimum' ||
-        field === 'maximum' ||
-        field === 'exclusiveMaximum' ||
-        field === 'exclusiveMinimum' ||
-        field === '$delete' ||
-        field === 'display');
-};
-const DEFAULT_FIELDS = {
-// id: { type: 'string' },
-// createdAt: { type: 'timestamp' },
-// updatedAt: { type: 'timestamp' },
-// type: { type: 'string' },
-// parents: { type: 'references' },
-// children: { type: 'references' },
-// ancestors: { type: 'references' },
-// descendants: { type: 'references' },
-// aliases: {
-//   type: 'set',
-//   items: { type: 'string' },
-// },
-};
-const metaParser = (obj) => {
-    const tmp = {};
-    for (const i in obj) {
-        if (metaChecker(i)) {
-            if (i === 'title') {
-                tmp.name = obj[i];
-            }
-            else if (obj[i] === 'bytes') {
-                tmp.format = obj[i];
-            }
-            else {
-                tmp[i] = obj[i];
-            }
-        }
-    }
-    return Object.keys(tmp).length > 0 ? { meta: tmp } : null;
-};
-const migrateField = (field) => {
-    if (field?.type === 'object') {
-        return {
-            ...metaParser(field),
-            type: 'object',
-            properties: migrateFields(field.properties, true),
-        };
-    }
-    else if (field?.type === 'json') {
-        return {
-            ...field,
-            ...metaParser(field),
-            type: 'json',
-        };
-    }
-    else if (field?.type === 'array') {
-        const values = migrateField(field.values);
-        if (!values) {
-            return null;
-        }
-        return {
-            ...metaParser(field),
-            type: 'array',
-            items: values,
-        };
-    }
-    else if (field?.type === 'set') {
-        return {
-            ...metaParser(field),
-            type: 'set',
-            items: migrateField(field.items),
-        };
-    }
-    else if (field?.type === 'record') {
-        return {
-            ...metaParser(field),
-            type: 'record',
-            values: migrateField(field.values),
-        };
-    }
-    else if (field?.type === 'reference' || field?.type === 'references') {
-        return {
-            ...metaParser(field),
-            type: field?.type,
-            ...(field.bidirectional ? { bidirectional: field.bidirectional } : null),
-        };
-    }
-    else if (field?.type === 'integer') {
-        return {
-            ...metaParser(field),
-            type: 'int',
-        };
-    }
-    else if (field?.format === 'strongPassword') {
-        return { ...metaParser(field), type: 'digest' };
-    }
-    else if (field?.format === 'basedId') {
-        return { ...metaParser(field), type: 'id' };
-    }
-    else if (field?.format === 'URL') {
-        return { ...metaParser(field), type: 'url' };
-    }
-    else if (field?.format === 'email') {
-        return {
-            ...metaParser(field),
-            type: 'email',
-        };
-    }
-    else if (field?.format === 'mobilePhone') {
-        return {
-            ...metaParser(field),
-            type: 'phone',
-        };
-    }
-    else if (field?.format === 'latLong') {
-        return {
-            ...metaParser(field),
-            type: 'geo',
-        };
-    }
-    else {
-        return { ...metaParser(field), type: field?.type };
-    }
-};
-const migrateFields = (oldFields, recursing = false) => {
-    const result = {};
-    if (oldFields) {
-        for (const key in oldFields) {
-            if (oldFields.hasOwnProperty(key)) {
-                if (!recursing && Object.keys(DEFAULT_FIELDS).includes(key)) {
-                    continue;
-                }
-                const field = migrateField(oldFields[key]);
-                if (!field) {
-                    continue;
-                }
-                result[key] = field;
-            }
-        }
-    }
-    return result;
-};
-const migrateTypes = (oldSchema) => {
-    const result = {
-        types: {},
-    };
-    for (const key in oldSchema.types) {
-        if (oldSchema.types.hasOwnProperty(key)) {
-            const type = oldSchema.types[key];
-            result.types[key] = {
-                ...metaParser(type),
-                fields: migrateFields(type.fields),
-            };
-            if (type.prefix) {
-                result.types[key].prefix = type.prefix;
-            }
-        }
-    }
-    return result;
-};
-const convertRoot = (schema) => {
-    const result = {
-        fields: {},
-        ...metaParser(schema.root),
-        ...(schema.root?.prefix ? { prefix: schema.root.prefix } : null),
-    };
-    for (const i in schema.root?.fields) {
-        const field = schema.root?.fields[i];
-        result.fields[i] = {
-            ...metaParser(field),
-            ...migrateField(field),
-        };
-    }
-    return result;
-};
-export const convertNewToOld = (schema) => {
-    const tmpSchema = migrateTypes(schema);
-    if (schema.prefixToTypeMapping) {
-        tmpSchema.prefixToTypeMapping = schema.prefixToTypeMapping;
-    }
-    tmpSchema.languages = [];
-    if (schema.language) {
-        tmpSchema.languages.push(schema.language);
-    }
-    if (schema.translations) {
-        tmpSchema.languages.push(...schema.translations);
-    }
-    tmpSchema.rootType = convertRoot(schema);
-    delete tmpSchema.root;
-    return tmpSchema;
-};
-//# sourceMappingURL=newToOld.js.map

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

@@ -1,3 +0,0 @@
-import { BasedSchema } from '../types.js';
-import { BasedOldSchema } from './oldSchemaType.js';
-export declare const convertOldToNew: (oldSchema: Partial<BasedOldSchema>) => BasedSchema;

package/dist/src/compat/oldToNew.js

@@ -1,210 +0,0 @@
-const DEFAULT_FIELDS = {
-// id: { type: 'string' },
-// createdAt: { type: 'timestamp' },
-// updatedAt: { type: 'timestamp' },
-// type: { type: 'string' },
-// parents: { type: 'references' },
-// children: { type: 'references' },
-// ancestors: { type: 'references' },
-// descendants: { type: 'references' },
-// aliases: {
-//   type: 'set',
-//   items: { type: 'string' },
-// },
-};
-const metaParser = (obj) => {
-    const metaObj = obj?.meta;
-    const tmp = {};
-    for (const i in metaObj) {
-        if (i === 'name') {
-            tmp.title = metaObj[i];
-        }
-        else if (i === 'validation' ||
-            i === 'progress' ||
-            i === 'format' ||
-            i === 'ui') {
-            if (metaObj[i] === 'url') {
-                // tmp.format = 'URL'
-            }
-            if ((metaObj[i] === 'bytes' && obj.type === 'number') ||
-                metaObj.type === 'float') {
-                tmp.display = 'bytes';
-            }
-        }
-        else {
-            tmp[i] = metaObj[i];
-        }
-    }
-    return tmp;
-};
-const migrateField = (oldField) => {
-    switch (oldField.type) {
-        case 'object':
-            return {
-                ...metaParser(oldField),
-                type: 'object',
-                properties: migrateFields(oldField.properties, true),
-            };
-        case 'json':
-            return {
-                ...oldField,
-                ...metaParser(oldField),
-                type: 'json',
-            };
-        case 'array':
-            const values = migrateField(oldField.items);
-            if (!values) {
-                return null;
-            }
-            return {
-                ...metaParser(oldField),
-                type: 'array',
-                values,
-            };
-        case 'set':
-            return {
-                ...metaParser(oldField),
-                type: 'set',
-                items: migrateField(oldField.items),
-            };
-        case 'record':
-            return {
-                ...metaParser(oldField),
-                type: 'record',
-                values: migrateField(oldField.values),
-            };
-        case 'reference':
-        case 'references':
-            return {
-                ...metaParser(oldField),
-                type: oldField.type,
-                ...(oldField.bidirectional
-                    ? { bidirectional: oldField.bidirectional }
-                    : null),
-            };
-        case 'float':
-            return {
-                ...metaParser(oldField),
-                type: 'number',
-            };
-        case 'int':
-            return {
-                ...metaParser(oldField),
-                type: 'integer',
-            };
-        case 'digest':
-            return {
-                ...metaParser(oldField),
-                format: 'strongPassword',
-                type: 'string',
-            };
-        case 'id':
-            return {
-                format: 'basedId',
-                ...metaParser(oldField),
-                type: 'string',
-            };
-        case 'url':
-            return {
-                ...metaParser(oldField),
-                format: 'URL',
-                type: 'string',
-            };
-        case 'email':
-            return {
-                format: 'email',
-                ...metaParser(oldField),
-                type: 'string',
-            };
-        case 'phone':
-            return {
-                ...metaParser(oldField),
-                format: 'mobilePhone',
-                type: 'string',
-            };
-        case 'geo':
-            return {
-                ...metaParser(oldField),
-                format: 'latLong',
-                type: 'string',
-            };
-        case 'type':
-            return {
-                ...metaParser(oldField),
-                type: 'string',
-            };
-        case 'number':
-            return {
-                ...metaParser(oldField),
-                type: 'number',
-            };
-        default:
-            return {
-                ...metaParser(oldField),
-                type: oldField.type,
-            };
-    }
-};
-const migrateFields = (oldFields, recursing = false) => {
-    const result = {};
-    if (oldFields) {
-        for (const key in oldFields) {
-            if (true) {
-                if (!recursing && Object.keys(DEFAULT_FIELDS).includes(key)) {
-                    continue;
-                }
-                const field = migrateField(oldFields[key]);
-                if (!field) {
-                    continue;
-                }
-                result[key] = field;
-            }
-        }
-    }
-    return result;
-};
-const migrateTypes = (oldSchema) => {
-    const result = {
-        types: {},
-    };
-    for (const key in oldSchema.types) {
-        if (oldSchema.types.hasOwnProperty(key)) {
-            const type = oldSchema.types[key];
-            result.types[key] = {
-                ...metaParser(type),
-                prefix: type.prefix,
-                fields: migrateFields(type.fields),
-            };
-        }
-    }
-    return result;
-};
-const convertRoot = (oldSchema) => {
-    const result = {
-        fields: {},
-        ...metaParser(oldSchema.rootType?.meta),
-        ...(oldSchema.rootType?.prefix
-            ? { prefix: oldSchema.rootType.prefix }
-            : null),
-    };
-    for (const i in oldSchema.rootType?.fields) {
-        const field = oldSchema.rootType?.fields[i];
-        result.fields[i] = {
-            ...metaParser(field?.meta),
-            ...migrateField(field),
-        };
-    }
-    return result;
-};
-export const convertOldToNew = (oldSchema) => {
-    const tempSchema = migrateTypes(oldSchema);
-    tempSchema.$defs = {};
-    tempSchema.language = oldSchema.languages[0];
-    tempSchema.prefixToTypeMapping = oldSchema.prefixToTypeMapping;
-    tempSchema.translations = oldSchema.languages.filter((_, i) => i !== 0);
-    tempSchema.root = convertRoot(oldSchema);
-    delete tempSchema.rootType;
-    delete tempSchema.sha;
-    return tempSchema;
-};
-//# sourceMappingURL=oldToNew.js.map

package/dist/src/generateQuery.d.ts

@@ -1,12 +0,0 @@
-import { BasedSchema, BasedSchemaField, BasedSchemaType } from './types.js';
-type Query = Record<string, any>;
-type Transformer = (Query: any, opts: {
-    type: string;
-    schema: BasedSchemaType;
-    depth: number;
-}) => Query;
-export declare const generateQueryForType: (type: string, schema: BasedSchema, depth?: number, transformer?: Transformer, query?: Query, nestedRefs?: Set<BasedSchemaField>) => Query;
-export declare const generateQuery: (query: {
-    $id: string;
-} & Query, schema: BasedSchema, depth?: number, transformer?: Transformer) => Query;
-export {};

package/dist/src/generateQuery.js

@@ -1,75 +0,0 @@
-const parseSchemaField = (schemaField, schema, depth, transformer, nestedRefs, currentQuery) => {
-    if ('values' in schemaField) {
-        return parseSchemaField(schemaField.values, schema, depth, transformer, nestedRefs, currentQuery);
-    }
-    if ('items' in schemaField) {
-        return parseSchemaField(schemaField.items, schema, depth, transformer, nestedRefs, currentQuery);
-    }
-    if ('properties' in schemaField) {
-        currentQuery ??= {};
-        for (const i in schemaField.properties) {
-            const v = currentQuery[i];
-            if (v === true || v === false) {
-                continue;
-            }
-            currentQuery[i] = parseSchemaField(schemaField.properties[i], schema, depth, transformer, nestedRefs, currentQuery[i]);
-        }
-        return currentQuery;
-    }
-    if (schemaField.type === 'reference' || schemaField.type === 'references') {
-        const nestedDepth = depth - 1;
-        if (nestedDepth < 0) {
-            return true;
-        }
-        if (nestedRefs) {
-            if (nestedRefs.has(schemaField)) {
-                return true;
-            }
-            nestedRefs.add(schemaField);
-        }
-        const allowedTypes = schemaField.allowedTypes?.length
-            ? schemaField.allowedTypes
-            : Object.keys(schema.types);
-        for (const i of allowedTypes) {
-            currentQuery = generateQueryForType(typeof i === 'string' ? i : i.type, schema, nestedDepth, transformer, currentQuery, nestedRefs || new Set([schemaField]));
-        }
-        if (schemaField.type === 'references') {
-            currentQuery.$list = true;
-        }
-        return currentQuery;
-    }
-    return true;
-};
-export const generateQueryForType = (type, schema, depth = 0, transformer, query = {}, nestedRefs) => {
-    const schemaType = type === 'root' ? schema.root : schema.types[type];
-    if (!schemaType) {
-        throw new Error('unknown type');
-    }
-    query.id ??= true;
-    query.type ??= true;
-    query.createdAt ??= true;
-    query.updatedAt ??= true;
-    if (schemaType.fields) {
-        for (const key in schemaType.fields) {
-            const v = query[key];
-            if (v === true || v === false) {
-                continue;
-            }
-            const schemaField = schemaType.fields[key];
-            query[key] = parseSchemaField(schemaField, schema, depth, transformer, nestedRefs, query[key]);
-        }
-    }
-    return transformer
-        ? transformer(query, { type, depth, schema: schemaType })
-        : query;
-};
-export const generateQuery = (query, schema, depth, transformer) => {
-    const type = query.$id === 'root'
-        ? query.$id
-        : schema.prefixToTypeMapping[query.$id.substring(0, 2)];
-    if (!type) {
-        throw new Error('invalid type');
-    }
-    return generateQueryForType(type, schema, depth, transformer, query);
-};
-//# sourceMappingURL=generateQuery.js.map

package/dist/test/query.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/query.js

@@ -1,93 +0,0 @@
-import test from 'ava';
-import { generateQuery } from '../src/generateQuery.js';
-const schema = {
-    types: {
-        thing: {
-            prefix: 'ti',
-            fields: {
-                priority: { type: 'number' },
-                something: { type: 'string', format: 'strongPassword' },
-                blaRef: {
-                    type: 'reference',
-                    allowedTypes: ['bla'],
-                },
-            },
-        },
-        bla: {
-            prefix: 'bl',
-            fields: {
-                arr: {
-                    type: 'array',
-                    items: {
-                        type: 'string',
-                    },
-                },
-                refArr: {
-                    type: 'array',
-                    items: {
-                        type: 'reference',
-                    },
-                },
-                refRec: {
-                    type: 'record',
-                    values: {
-                        type: 'reference',
-                    },
-                },
-                obj: {
-                    type: 'object',
-                    properties: {
-                        blafurp: { type: 'string' },
-                        nesto: {
-                            type: 'object',
-                            properties: {
-                                nestfield: { type: 'string' },
-                            },
-                        },
-                        reffie: { type: 'reference' },
-                    },
-                },
-                ref: {
-                    type: 'reference',
-                },
-                children: {
-                    type: 'references',
-                },
-                referencesToThings: {
-                    type: 'references',
-                    allowedTypes: ['thing'],
-                },
-                referenceToThing: {
-                    type: 'reference',
-                    allowedTypes: ['thing'],
-                },
-            },
-        },
-    },
-    $defs: {},
-    language: 'en',
-    translations: ['de', 'nl', 'ro', 'za', 'ae'],
-    root: {
-        fields: {},
-    },
-    prefixToTypeMapping: {
-        bl: 'bla',
-        ti: 'thing',
-    },
-};
-test('generate query', async (t) => {
-    const query = generateQuery({
-        $id: 'bl1',
-        $language: 'en',
-        children: {
-            id: false,
-        },
-        refArr: {
-            id: false,
-            obj: false,
-        },
-    }, schema, 1);
-    console.dir(query, { depth: null });
-    t.pass();
-});
-//# sourceMappingURL=query.js.map

package/dist/updateSchema.d.ts

@@ -1,2 +0,0 @@
-import { BasedSchema, BasedSchemaPartial } from './types';
-export declare const updateSchema: (newSchema: BasedSchemaPartial, oldSchema?: BasedSchema) => Promise<BasedSchema>;

package/dist/updateSchema.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateSchema = void 0;
-const updateSchema = async (newSchema, oldSchema = {
-    $defs: {},
-    types: {},
-    language: 'en',
-    root: { fields: {} },
-    prefixToTypeMapping: {},
-}) => {
-    // add sha
-    // put isRequired on the new schema in REQUIRED arrays
-    return oldSchema;
-};
-exports.updateSchema = updateSchema;
-//# sourceMappingURL=updateSchema.js.map

package/dist/validateSchema.d.ts

@@ -1,4 +0,0 @@
-import { BasedSchemaPartial, BasedSchemaFieldPartial, BasedSchemaTypePartial } from './types';
-export declare const validateType: (fromSchema: BasedSchemaPartial, typeName: string, type: BasedSchemaTypePartial) => void;
-export declare const validateField: (fromSchema: BasedSchemaPartial, path: string[], field: BasedSchemaFieldPartial) => void;
-export declare const validateSchema: (schema: BasedSchemaPartial) => BasedSchemaPartial;

package/dist/validateSchema.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateSchema = exports.validateField = exports.validateType = void 0;
-// gaurd in the schema for refs in arrays
-const validateType = (fromSchema, typeName, type) => {
-    if (type.prefix &&
-        (typeof type.prefix !== 'string' || type.prefix.length !== 2)) {
-        throw new Error(`Incorrect prefix "${type.prefix}" for type "${typeName}" has to be a string of 2 alphanumerical characters e.g. "Az", "ab", "cc", "10"`);
-    }
-};
-exports.validateType = validateType;
-const validateField = (fromSchema, path, field) => {
-    //
-};
-exports.validateField = validateField;
-const validateSchema = (schema) => {
-    // rewrite schema things like required / required: []
-    if (typeof schema !== 'object') {
-        throw new Error('Schema is not an object');
-    }
-    if (schema.language && typeof schema.language !== 'string') {
-        throw new Error('Language must be a string');
-    }
-    if (schema.translations && !Array.isArray(schema.translations)) {
-        throw new Error('Translations needs to be an array');
-    }
-    if (schema.$defs) {
-        // first defs ofc
-    }
-    if (schema.root) {
-        (0, exports.validateType)(schema, 'root', schema.root);
-    }
-    if (schema.types) {
-        for (const type in schema.types) {
-            (0, exports.validateType)(schema, type, schema.types[type]);
-        }
-    }
-    return schema;
-};
-exports.validateSchema = validateSchema;
-//# sourceMappingURL=validateSchema.js.map