@based/schema 2.5.3 → 2.7.0

package/dist/src/compat/Untitled-1.d.ts

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

package/dist/src/compat/Untitled-1.js

@@ -0,0 +1,205 @@
+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');
+};
+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' },
+    },
+};
+const metaParser = (obj) => {
+    const tmp = {};
+    for (const i in obj) {
+        if (metaChecker(i)) {
+            if (i === 'title') {
+                tmp.name = obj[i];
+            }
+            else {
+                tmp[i] = obj[i];
+            }
+        }
+    }
+    return Object.keys({ meta: tmp }.meta).length > 0 ? { meta: tmp } : null;
+};
+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',
+                items: 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 {
+                format: 'strongPassword',
+                type: 'string',
+            };
+        case 'id':
+            return {
+                ...metaParser(oldField),
+                type: 'string',
+            };
+        case 'url':
+            return {
+                ...metaParser(oldField),
+                format: 'URL',
+                type: 'string',
+            };
+        case 'email':
+            return {
+                ...metaParser(oldField),
+                type: 'string',
+            };
+        case 'phone':
+            return {
+                format: 'mobilePhone',
+                type: 'string',
+            };
+        case 'geo':
+            return {
+                format: 'latLong',
+                type: 'string',
+            };
+        case 'type':
+            return {
+                ...metaParser(oldField),
+                type: 'string',
+            };
+        default:
+            return {
+                ...metaParser(oldField),
+                type: oldField.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),
+                prefix: type.prefix,
+                fields: migrateFields(type.fields),
+            };
+        }
+    }
+    return result;
+};
+export const convertNewToOld222 = (schema) => {
+    const tmpSchema = migrateTypes(schema);
+    tmpSchema.prefixToTypeMapping = schema.prefixToTypeMapping;
+    tmpSchema.languages = [schema.language, ...schema?.translations];
+    delete tmpSchema.root;
+    return tmpSchema;
+};
+//# sourceMappingURL=Untitled-1.js.map

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

@@ -0,0 +1,2 @@
+export * from './newToOld.js';
+export * from './oldToNew.js';

package/dist/src/compat/index.js

@@ -0,0 +1,3 @@
+export * from './newToOld.js';
+export * from './oldToNew.js';
+//# sourceMappingURL=index.js.map

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

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

package/dist/src/compat/newToOld.js

@@ -0,0 +1,213 @@
+// import { BasedSchema } from '../types.js'
+// import { BasedOldSchema } from './oldSchemaType.js'
+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 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' },
+// },
+};
+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({ meta: tmp }.meta).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),
+                prefix: type.prefix,
+                fields: migrateFields(type.fields),
+            };
+        }
+    }
+    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);
+    tmpSchema.prefixToTypeMapping = schema.prefixToTypeMapping;
+    tmpSchema.languages = [schema.language, ...schema?.translations];
+    tmpSchema.rootType = convertRoot(schema);
+    delete tmpSchema.root;
+    return tmpSchema;
+};
+//# sourceMappingURL=newToOld.js.map

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

@@ -0,0 +1,69 @@
+type FieldType = 'float' | 'boolean' | 'number' | 'int' | 'string' | 'text' | 'id' | 'digest' | 'url' | 'email' | 'phone' | 'geo' | 'type' | 'timestamp';
+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;
+};
+type FieldSchemaArrayLike = {
+    type: 'set' | 'array';
+    items: FieldSchema;
+    meta?: any;
+    timeseries?: boolean;
+};
+type FieldSchema = FieldSchemaObject | FieldSchemaRecord | FieldSchemaArrayLike | FieldSchemaJson | FieldSchemaReferences | FieldSchemaOther;
+type Fields = Record<string, FieldSchema>;
+type HierarchySchema = false | {
+    [key: string]: false | {
+        excludeAncestryWith: string[];
+    } | {
+        includeAncestryWith: string[];
+    };
+};
+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

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

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

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