@based/schema 3.0.0 → 3.1.0

package/dist/src/compat/index.js

@@ -21,7 +21,10 @@ const convertNewToOldMeta = (props) => {
         if (i[0] !== '$') {
             const v = props[i];
             meta ??= {};
-            if (i === 'display' && v === 'bytes') {
+            if (i === 'allowedTypes') {
+                meta.refTypes = v;
+            }
+            else if (i === 'display' && v === 'bytes') {
                 meta.format = v;
             }
             else if (i === 'title') {
@@ -38,7 +41,10 @@ const convertOldToNewMeta = (props) => {
     const meta = {};
     for (const i in props) {
         const v = props[i];
-        if (i === 'format' && v === 'bytes') {
+        if (i === 'refTypes') {
+            meta.allowedTypes = v;
+        }
+        else if (i === 'format' && v === 'bytes') {
             meta.display = 'bytes';
         }
         else if (i === 'name') {

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

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

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,189 +30,47 @@ const metaChecker = (field) => {
         field === 'maximum' ||
         field === 'exclusiveMaximum' ||
         field === 'exclusiveMinimum' ||
-        field === '$delete' ||
-        field === 'display');
+        field === '$delete');
 };
-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 excludedFields = (field) => {
+    return field === 'language' || field === 'translations' || field === '$defs';
 };
-const metaParser = (obj) => {
-    const tmp = {};
-    for (const i in obj) {
-        if (metaChecker(i)) {
-            if (i === 'title') {
-                tmp.name = obj[i];
+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]);
             }
-            else if (obj[i] === 'bytes') {
-                tmp.format = obj[i];
+            else if (!metaChecker(i)) {
+                target[i] = source[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;
+                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];
+                    }
                 }
-                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;
-            }
+    walker(tmpSchema, schema);
+    if ((tmpSchema.meta = {}))
+        delete tmpSchema.meta;
+    for (const i in tmpSchema) {
+        if (excludedFields(i)) {
+            delete tmpSchema[i];
         }
     }
-    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;
+    tmpSchema.languages = [schema.language, ...schema?.translations];
     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: Partial<BasedOldSchema>) => BasedSchema;
+export declare const convertOldToNew: (oldSchema: BasedOldSchema) => BasedSchema;

package/dist/src/compat/oldToNew.js

@@ -1,210 +1,35 @@
-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;
+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);
             }
-            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 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];
+                        }
+                    }
                 }
-                const field = migrateField(oldFields[key]);
-                if (!field) {
-                    continue;
+                else {
+                    target[i] = source[i].length ? [] : {};
+                    walker(source[i], target[i]);
                 }
-                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),
     };
-    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);
+    walker(oldSchema, tempSchema);
     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/set/fields/string.js

@@ -74,6 +74,7 @@ const formatPatterns = {
     clike: () => true,
     // Can add some more checks for this...
     basedId: (value) => typeof value === 'string' && value.length < 16,
+    basedType: (value) => typeof value === 'string' && value.length < 64,
 };
 const validateString = (args, value) => {
     if (typeof value !== 'string') {

package/dist/src/types.d.ts

@@ -43,7 +43,7 @@ export type BasedSchemaFieldShared = {
     };
     $delete?: boolean;
 };
-export declare const basedSchemaStringFormatValues: readonly ["email", "URL", "MACAddress", "IP", "IPRange", "FQDN", "IBAN", "BIC", "alpha", "alphaLocales", "alphanumeric", "alphanumericLocales", "passportNumber", "port", "lowercase", "uppercase", "ascii", "semVer", "surrogatePair", "IMEI", "hexadecimal", "octal", "hexColor", "rgbColor", "HSL", "ISRC", "MD5", "JWT", "UUID", "luhnNumber", "creditCard", "identityCard", "EAN", "ISIN", "ISBN", "ISSN", "mobilePhone", "mobilePhoneLocales", "postalCode", "postalCodeLocales", "ethereumAddress", "currency", "btcAddress", "ISO6391", "ISO8601", "RFC3339", "ISO31661Alpha2", "ISO31661Alpha3", "ISO4217", "base32", "base58", "base64", "dataURI", "magnetURI", "mimeType", "latLong", "slug", "strongPassword", "taxID", "licensePlate", "VAT", "code", "typescript", "javascript", "python", "rust", "css", "html", "json", "markdown", "clike", "basedId"];
+export declare const basedSchemaStringFormatValues: readonly ["email", "URL", "MACAddress", "IP", "IPRange", "FQDN", "IBAN", "BIC", "alpha", "alphaLocales", "alphanumeric", "alphanumericLocales", "passportNumber", "port", "lowercase", "uppercase", "ascii", "semVer", "surrogatePair", "IMEI", "hexadecimal", "octal", "hexColor", "rgbColor", "HSL", "ISRC", "MD5", "JWT", "UUID", "luhnNumber", "creditCard", "identityCard", "EAN", "ISIN", "ISBN", "ISSN", "mobilePhone", "mobilePhoneLocales", "postalCode", "postalCodeLocales", "ethereumAddress", "currency", "btcAddress", "ISO6391", "ISO8601", "RFC3339", "ISO31661Alpha2", "ISO31661Alpha3", "ISO4217", "base32", "base58", "base64", "dataURI", "magnetURI", "mimeType", "latLong", "slug", "strongPassword", "taxID", "licensePlate", "VAT", "code", "typescript", "javascript", "python", "rust", "css", "html", "json", "markdown", "clike", "basedId", "basedType"];
 export type BasedSchemaStringShared = {
     minLength?: number;
     maxLength?: number;

package/dist/src/types.js

@@ -94,5 +94,6 @@ export const basedSchemaStringFormatValues = [
     'markdown',
     'clike',
     'basedId',
+    'basedType',
 ];
 //# sourceMappingURL=types.js.map

package/dist/test/compat.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@based/schema",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "license": "MIT",
   "main": "dist/src/index.js",
   "files": [

package/dist/display/index.d.ts

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

package/dist/display/index.js

@@ -1,26 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.display = void 0;
-const timestamp_1 = __importDefault(require("./timestamp"));
-const number_1 = __importDefault(require("./number"));
-const string_1 = __importDefault(require("./string"));
-const display = (value, field) => {
-    if (field.type === 'timestamp' && typeof value === 'number') {
-        // @ts-ignore
-        return (0, timestamp_1.default)(value, field.display);
-    }
-    if (field.type === 'number' && typeof value === 'number') {
-        // @ts-ignore
-        return (0, number_1.default)(value, field.display);
-    }
-    if (field.type === 'string' && typeof value === 'string') {
-        // @ts-ignore
-        return (0, string_1.default)(value, field.display);
-    }
-    return value;
-};
-exports.display = display;
-//# sourceMappingURL=index.js.map

package/dist/display/number.d.ts

@@ -1,3 +0,0 @@
-export type NumberFormat = 'short' | 'human' | 'ratio' | 'bytes' | 'euro' | 'dollar' | 'pound' | `round-${number}`;
-declare const parseNumber: (nr: number | string, format?: NumberFormat) => string | number;
-export default parseNumber;