@based/schema 3.1.0 → 3.2.0

package/dist/src/compat/newToOld.js

@@ -1,6 +1,6 @@
 const metaChecker = (field) => {
     return (field === 'validation' ||
-        field === 'format' ||
+        // field === 'format' ||
         field === 'index' ||
         field === 'description' ||
         field === 'title' ||
@@ -30,47 +30,189 @@ const metaChecker = (field) => {
         field === 'maximum' ||
         field === 'exclusiveMaximum' ||
         field === 'exclusiveMinimum' ||
-        field === '$delete');
+        field === '$delete' ||
+        field === 'display');
 };
-const excludedFields = (field) => {
-    return field === 'language' || field === 'translations' || field === '$defs';
+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' },
+// },
 };
-export const convertNewToOld = (schema) => {
-    const tmpSchema = {};
-    const walker = (target, source) => {
-        for (const i in source) {
-            if (source[i] && typeof source[i] === 'object' && i in target === false) {
-                target[i] = source[i].length ? [] : {};
-                walker(target[i], source[i]);
+const metaParser = (obj) => {
+    const tmp = {};
+    for (const i in obj) {
+        if (metaChecker(i)) {
+            if (i === 'title') {
+                tmp.name = obj[i];
             }
-            else if (!metaChecker(i)) {
-                target[i] = source[i];
+            else if (obj[i] === 'bytes') {
+                tmp.format = obj[i];
             }
             else {
-                target.meta = {};
-                for (const i in source) {
-                    if (metaChecker(i) && typeof source[i] !== 'object') {
-                        if (i === 'title') {
-                            target.meta = { ...target.meta, name: source[i] };
-                        }
-                        else {
-                            target.meta = { ...target.meta, [i]: source[i] };
-                        }
-                        delete source[i];
-                    }
+                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: {},
     };
-    walker(tmpSchema, schema);
-    if ((tmpSchema.meta = {}))
-        delete tmpSchema.meta;
-    for (const i in tmpSchema) {
-        if (excludedFields(i)) {
-            delete tmpSchema[i];
+    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;
+            }
         }
     }
-    tmpSchema.languages = [schema.language, ...schema?.translations];
+    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 +1,3 @@
 import { BasedSchema } from '../types.js';
 import { BasedOldSchema } from './oldSchemaType.js';
-export declare const convertOldToNew: (oldSchema: BasedOldSchema) => BasedSchema;
+export declare const convertOldToNew: (oldSchema: Partial<BasedOldSchema>) => BasedSchema;

package/dist/src/compat/oldToNew.js

@@ -1,35 +1,210 @@
-export const convertOldToNew = (oldSchema) => {
-    const tempSchema = {};
-    const walker = (source, target) => {
-        for (const i in source) {
-            if (i === 'languages' && source[i].length) {
-                target.language = source[i][0];
-                target.translations = source[i].filter((_, i) => i !== 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;
             }
-            else if (typeof source[i] === 'object' && i in target === false) {
-                if (i === 'meta' &&
-                    !Object.keys(source[i]).includes('properties' || 'type')) {
-                    for (const j in source[i]) {
-                        if (j === 'name') {
-                            target.title = source[i][j];
-                        }
-                        else {
-                            target[j] = source[i][j];
-                        }
-                    }
+            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;
                 }
-                else {
-                    target[i] = source[i].length ? [] : {};
-                    walker(source[i], target[i]);
+                const field = migrateField(oldFields[key]);
+                if (!field) {
+                    continue;
                 }
+                result[key] = field;
             }
-            else if (i !== 'meta') {
-                target[i] = source[i];
-            }
         }
+    }
+    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),
     };
-    walker(oldSchema, tempSchema);
+    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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,75 @@
+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/src/set/fields/references.js

@@ -86,6 +86,36 @@ export const reference = async (args) => {
         args.error(ParseError.referenceIsIncorrectType);
     }
 };
+function parseSortableOp(args, value, op) {
+    if (typeof value[op] !== 'object') {
+        args.error(ParseError.incorrectFormat);
+        return;
+    }
+    if (!args.fieldSchema.sortable) {
+        args.error(ParseError.incorrectFieldType);
+        return;
+    }
+    switch (typeof value[op].$idx) {
+        case 'bigint':
+            break;
+        case 'number':
+            value[op].$idx = BigInt(value[op].$idx);
+            break;
+        default:
+            args.error(ParseError.incorrectFormat);
+            return;
+    }
+    if (Array.isArray(value[op].$value)) {
+        // NOP
+    }
+    else if (typeof value[op].$value === 'string') {
+        value[op].$value = [value[op].$value];
+    }
+    else {
+        args.error(ParseError.incorrectFormat);
+        return;
+    }
+}
 export const references = async (args) => {
     const { value } = args;
     if (typeof value !== 'object' || value === null) {
@@ -113,6 +143,16 @@ export const references = async (args) => {
             else if (key === '$remove') {
                 args.value.$remove = await parseOperator(args, key);
             }
+            else if (key === '$assign') {
+                parseSortableOp(args, value, '$assign');
+            }
+            else if (key === '$insert') {
+                parseSortableOp(args, value, '$insert');
+            }
+            else if (key === '$move') {
+                parseSortableOp(args, value, '$move');
+                value.$move.$value.reverse();
+            }
             else {
                 args.create({ key }).error(ParseError.fieldDoesNotExist);
             }

package/dist/test/compat.js

@@ -50,6 +50,31 @@ test('refTypes', async (t) => {
     // @ts-ignore
     t.is(oldSchema.types.youzi.fields.image.meta.refTypes[0], 'youzi');
 });
+test('bidirectional', async (t) => {
+    const newSchema = convertOldToNew({
+        types: {
+            youzi: {
+                fields: {
+                    image: {
+                        type: 'reference',
+                        bidirectional: {
+                            fromField: 'success',
+                        },
+                        meta: {
+                            refTypes: ['youzi'],
+                        },
+                    },
+                },
+            },
+        },
+    });
+    console.log(newSchema.types.youzi.fields.image);
+    // @ts-ignore
+    t.is(newSchema.types.youzi.fields.image.bidirectional.fromField, 'success');
+    const oldSchema = convertNewToOld(newSchema);
+    // @ts-ignore
+    t.is(oldSchema.types.youzi.fields.image.bidirectional.fromField, 'success');
+});
 test('old schema compat mode', async (t) => {
     for (let i = 0; i < oldSchemas.length - 1; i++) {
         const oldSchema = oldSchemas[i];

package/dist/test/query.d.ts

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