@datenlotse/jsonjoy-builder 0.4.0

package/dist/index.js

@@ -0,0 +1,10 @@
+import JsonSchemaEditor from "./components/SchemaEditor/JsonSchemaEditor.js";
+import JsonSchemaVisualizer from "./components/SchemaEditor/JsonSchemaVisualizer.js";
+import SchemaVisualEditor from "./components/SchemaEditor/SchemaVisualEditor.js";
+export * from "./components/features/JsonValidator.js";
+export * from "./components/features/SchemaInferencer.js";
+export * from "./i18n/locales/de.js";
+export * from "./i18n/locales/en.js";
+export * from "./i18n/translation-context.js";
+export * from "./i18n/translation-keys.js";
+export { JsonSchemaEditor, JsonSchemaVisualizer, SchemaVisualEditor };

package/dist/lib/schema-inference.js

@@ -0,0 +1,266 @@
+import { asObjectSchema } from "../types/jsonSchema.js";
+function mergeSchemas(schema1, schema2) {
+    const s1 = asObjectSchema(schema1);
+    const s2 = asObjectSchema(schema2);
+    if (JSON.stringify(s1) === JSON.stringify(s2)) return schema1;
+    if ("integer" === s1.type && "number" === s2.type) return {
+        type: "number"
+    };
+    if ("number" === s1.type && "integer" === s2.type) return {
+        type: "number"
+    };
+    const existingOneOf = Array.isArray(s1.oneOf) ? s1.oneOf : [
+        s1
+    ];
+    const newSchemaToAdd = s2;
+    if (!existingOneOf.some((s)=>JSON.stringify(s) === JSON.stringify(newSchemaToAdd))) {
+        const mergedOneOf = [
+            ...existingOneOf,
+            newSchemaToAdd
+        ];
+        const uniqueSchemas = [
+            ...new Map(mergedOneOf.map((s)=>[
+                    JSON.stringify(s),
+                    s
+                ])).values()
+        ];
+        if (1 === uniqueSchemas.length) return uniqueSchemas[0];
+        return {
+            oneOf: uniqueSchemas
+        };
+    }
+    return s1.oneOf ? s1 : {
+        oneOf: [
+            s1
+        ]
+    };
+}
+function inferObjectSchema(obj) {
+    const properties = {};
+    const required = [];
+    for (const [key, value] of Object.entries(obj)){
+        properties[key] = inferSchema(value);
+        if (null != value) required.push(key);
+    }
+    return {
+        type: "object",
+        properties,
+        required: required.length > 0 ? required.sort() : void 0
+    };
+}
+function detectEnumsInArrayItems(mergedProperties, originalArray, totalItems) {
+    if (totalItems < 10 || 0 === Object.keys(mergedProperties).length) return mergedProperties;
+    const valueMap = {};
+    for (const item of originalArray)for(const key in mergedProperties)if (Object.prototype.hasOwnProperty.call(item, key)) {
+        const value = item[key];
+        if ("string" == typeof value || "number" == typeof value) {
+            if (!valueMap[key]) valueMap[key] = new Set();
+            valueMap[key].add(value);
+        }
+    }
+    const updatedProperties = {
+        ...mergedProperties
+    };
+    for(const key in valueMap){
+        const distinctValues = Array.from(valueMap[key]);
+        if (distinctValues.length > 1 && distinctValues.length <= 10 && distinctValues.length < totalItems / 2) {
+            const currentSchema = asObjectSchema(updatedProperties[key]);
+            if ("string" === currentSchema.type || "number" === currentSchema.type || "integer" === currentSchema.type) updatedProperties[key] = {
+                type: currentSchema.type,
+                enum: distinctValues.sort()
+            };
+        }
+    }
+    return updatedProperties;
+}
+function detectSemanticFormatsInArrayItems(mergedProperties, originalArray) {
+    const updatedProperties = {
+        ...mergedProperties
+    };
+    for(const key in updatedProperties){
+        const currentSchema = asObjectSchema(updatedProperties[key]);
+        if (/coordinates?|coords?|latLon|lonLat|point/i.test(key) && "array" === currentSchema.type) {
+            const itemsSchema = asObjectSchema(currentSchema.items);
+            if (itemsSchema?.type === "number" || itemsSchema?.type === "integer") {
+                let isValidCoordArray = true;
+                let coordLength = null;
+                for (const item of originalArray)if (Object.prototype.hasOwnProperty.call(item, key) && Array.isArray(item[key])) {
+                    const arr = item[key];
+                    if (null === coordLength) coordLength = arr.length;
+                    if (arr.length !== coordLength || 2 !== arr.length && 3 !== arr.length || !arr.every((v)=>"number" == typeof v)) {
+                        isValidCoordArray = false;
+                        break;
+                    }
+                } else if (Object.prototype.hasOwnProperty.call(item, key)) {
+                    isValidCoordArray = false;
+                    break;
+                }
+                if (isValidCoordArray && null !== coordLength) updatedProperties[key] = {
+                    type: "array",
+                    items: {
+                        type: "number"
+                    },
+                    minItems: coordLength,
+                    maxItems: coordLength
+                };
+            }
+        }
+        if (/timestamp|createdAt|updatedAt|occurredAt/i.test(key) && "integer" === currentSchema.type) {
+            let isTimestampLike = true;
+            const now = Date.now();
+            const fiftyYearsAgo = now - 1576800000000;
+            for (const item of originalArray)if (Object.prototype.hasOwnProperty.call(item, key)) {
+                const val = item[key];
+                if ("number" != typeof val || !Number.isInteger(val) || val < fiftyYearsAgo) {
+                    isTimestampLike = false;
+                    break;
+                }
+            }
+            if (isTimestampLike) updatedProperties[key] = {
+                type: "integer",
+                format: "unix-timestamp",
+                description: "Unix timestamp (likely milliseconds)"
+            };
+        }
+    }
+    return updatedProperties;
+}
+function processArrayOfObjects(itemSchemas, originalArray) {
+    let mergedProperties = {};
+    const propertyCounts = {};
+    const totalItems = itemSchemas.length;
+    for (const schema of itemSchemas){
+        const objSchema = asObjectSchema(schema);
+        if (objSchema.properties) for (const [key, value] of Object.entries(objSchema.properties)){
+            propertyCounts[key] = (propertyCounts[key] || 0) + 1;
+            if (key in mergedProperties) mergedProperties[key] = mergeSchemas(mergedProperties[key], value);
+            else mergedProperties[key] = value;
+        }
+    }
+    const requiredProps = Object.entries(propertyCounts).filter(([_, count])=>count === totalItems).map(([key, _])=>key);
+    mergedProperties = detectEnumsInArrayItems(mergedProperties, originalArray, totalItems);
+    mergedProperties = detectSemanticFormatsInArrayItems(mergedProperties, originalArray);
+    return {
+        type: "object",
+        properties: mergedProperties,
+        required: requiredProps.length > 0 ? requiredProps.sort() : void 0
+    };
+}
+function inferArraySchema(obj) {
+    if (0 === obj.length) return {
+        type: "array",
+        items: {}
+    };
+    const itemSchemas = obj.map((item)=>inferSchema(item));
+    const firstItemSchema = asObjectSchema(itemSchemas[0]);
+    const allSameType = itemSchemas.every((schema)=>asObjectSchema(schema).type === firstItemSchema.type);
+    if (allSameType) {
+        if ("object" === firstItemSchema.type) {
+            const itemsSchema = processArrayOfObjects(itemSchemas, obj);
+            return {
+                type: "array",
+                items: itemsSchema,
+                minItems: 0
+            };
+        }
+        return {
+            type: "array",
+            items: itemSchemas[0],
+            minItems: 0
+        };
+    }
+    const uniqueSchemas = [
+        ...new Map(itemSchemas.map((s)=>[
+                JSON.stringify(s),
+                s
+            ])).values()
+    ];
+    if (1 === uniqueSchemas.length && "object" === asObjectSchema(uniqueSchemas[0]).type) return {
+        type: "array",
+        items: uniqueSchemas[0],
+        minItems: 0
+    };
+    return {
+        type: "array",
+        items: 1 === uniqueSchemas.length ? uniqueSchemas[0] : {
+            oneOf: uniqueSchemas
+        },
+        minItems: 0
+    };
+}
+function inferStringSchema(str) {
+    const formats = {
+        date: /^\d{4}-\d{2}-\d{2}$/,
+        "date-time": /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?$/,
+        email: /^[^@]+@[^@]+\.[^@]+$/,
+        uuid: /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+        uri: /^(https?|ftp):\/\/[^\s/$.?#].[^\s]*$/i
+    };
+    for (const [format, regex] of Object.entries(formats))if (regex.test(str)) return {
+        type: "string",
+        format
+    };
+    return {
+        type: "string"
+    };
+}
+function inferNumberSchema(num) {
+    return Number.isInteger(num) ? {
+        type: "integer"
+    } : {
+        type: "number"
+    };
+}
+function inferSchema(obj) {
+    if (null === obj) return {
+        type: "null"
+    };
+    const type = Array.isArray(obj) ? "array" : typeof obj;
+    switch(type){
+        case "object":
+            return inferObjectSchema(obj);
+        case "array":
+            return inferArraySchema(obj);
+        case "string":
+            return inferStringSchema(obj);
+        case "number":
+            return inferNumberSchema(obj);
+        case "boolean":
+            return {
+                type: "boolean"
+            };
+        default:
+            return {};
+    }
+}
+function createSchemaFromJson(jsonObject) {
+    const inferredSchema = inferSchema(jsonObject);
+    const rootSchema = asObjectSchema(inferredSchema);
+    const finalSchema = {
+        $schema: "https://json-schema.org/draft-07/schema",
+        title: "Generated Schema",
+        description: "Generated from JSON data"
+    };
+    if ("object" === rootSchema.type || rootSchema.properties) {
+        finalSchema.type = "object";
+        finalSchema.properties = rootSchema.properties;
+        if (rootSchema.required) finalSchema.required = rootSchema.required;
+    } else if ("array" === rootSchema.type || rootSchema.items) {
+        finalSchema.type = "array";
+        finalSchema.items = rootSchema.items;
+        if (void 0 !== rootSchema.minItems) finalSchema.minItems = rootSchema.minItems;
+        if (void 0 !== rootSchema.maxItems) finalSchema.maxItems = rootSchema.maxItems;
+    } else if (rootSchema.type) {
+        finalSchema.type = "object";
+        finalSchema.properties = {
+            value: rootSchema
+        };
+        finalSchema.required = [
+            "value"
+        ];
+        finalSchema.title = "Generated Schema (Primitive Root)";
+        finalSchema.description = "Input was a primitive value, wrapped in an object.";
+    } else finalSchema.type = "object";
+    return finalSchema;
+}
+export { createSchemaFromJson, inferSchema };

package/dist/lib/schemaCompile.js

@@ -0,0 +1,113 @@
+import { copySchema } from "./schemaEditor.js";
+import { isBooleanSchema } from "../types/jsonSchema.js";
+function compileDependentEnums(schema) {
+    if (isBooleanSchema(schema)) return schema;
+    const transformed = copySchema(schema);
+    return transformObject(transformed);
+}
+function transformObject(obj) {
+    if (!obj.properties) return obj;
+    const props = {
+        ...obj.properties
+    };
+    for (const key of Object.keys(props)){
+        const child = props[key];
+        if ("object" == typeof child && null !== child) props[key] = transformSchema(child);
+    }
+    const dependentProp = Object.entries(props).find(([, s])=>"object" == typeof s && null !== s && "$dependentEnum" in s && null != s.$dependentEnum);
+    if (!dependentProp) return {
+        ...obj,
+        properties: props
+    };
+    const [propName, propSchema] = dependentProp;
+    const dep = propSchema.$dependentEnum;
+    if (!dep) return {
+        ...obj,
+        properties: props
+    };
+    const controllingName = dep.property;
+    const valuesMap = dep.values;
+    const controllingValues = Object.keys(valuesMap);
+    const oneOfBranches = controllingValues.map((ctrlValue)=>{
+        const branchProps = {
+            ...props
+        };
+        const controllingSchema = branchProps[controllingName];
+        if ("object" == typeof controllingSchema && null !== controllingSchema) branchProps[controllingName] = {
+            ...controllingSchema,
+            const: ctrlValue
+        };
+        else branchProps[controllingName] = {
+            const: ctrlValue
+        };
+        const dependentSchema = branchProps[propName];
+        if ("object" == typeof dependentSchema && null !== dependentSchema) {
+            const { $dependentEnum: _d, ...rest } = dependentSchema;
+            branchProps[propName] = {
+                ...rest,
+                enum: valuesMap[ctrlValue] ?? []
+            };
+        }
+        return {
+            type: "object",
+            properties: branchProps,
+            required: obj.required,
+            $propertyOrder: obj.$propertyOrder
+        };
+    });
+    return {
+        ...obj.$schema && {
+            $schema: obj.$schema
+        },
+        ...obj.$id && {
+            $id: obj.$id
+        },
+        type: "object",
+        oneOf: oneOfBranches
+    };
+}
+function transformSchema(schema) {
+    if (isBooleanSchema(schema)) return schema;
+    const obj = schema;
+    if (obj.properties) return transformObject(obj);
+    if (obj.items && "object" == typeof obj.items) return {
+        ...obj,
+        items: transformSchema(obj.items)
+    };
+    if (obj.prefixItems && Array.isArray(obj.prefixItems)) return {
+        ...obj,
+        prefixItems: obj.prefixItems.map((s)=>transformSchema(s))
+    };
+    if (obj.additionalProperties && "object" == typeof obj.additionalProperties) return {
+        ...obj,
+        additionalProperties: transformSchema(obj.additionalProperties)
+    };
+    if (obj.oneOf && Array.isArray(obj.oneOf)) return {
+        ...obj,
+        oneOf: obj.oneOf.map(transformSchema)
+    };
+    if (obj.anyOf && Array.isArray(obj.anyOf)) return {
+        ...obj,
+        anyOf: obj.anyOf.map(transformSchema)
+    };
+    if (obj.allOf && Array.isArray(obj.allOf)) return {
+        ...obj,
+        allOf: obj.allOf.map(transformSchema)
+    };
+    if (obj.if && "object" == typeof obj.if) return {
+        ...obj,
+        if: transformSchema(obj.if),
+        then: obj.then ? transformSchema(obj.then) : void 0,
+        else: obj.else ? transformSchema(obj.else) : void 0
+    };
+    if (obj.$defs) {
+        const defs = {};
+        for (const k of Object.keys(obj.$defs))defs[k] = transformSchema(obj.$defs[k]);
+        return {
+            ...obj,
+            $defs: defs
+        };
+    }
+    return obj;
+}
+export { compileDependentEnums };

package/dist/lib/schemaEditor.js

@@ -0,0 +1,167 @@
+import { isBooleanSchema, isObjectSchema } from "../types/jsonSchema.js";
+function copySchema(schema) {
+    if ("function" == typeof structuredClone) return structuredClone(schema);
+    return JSON.parse(JSON.stringify(schema));
+}
+function updateObjectProperty(schema, propertyName, propertySchema) {
+    if (!isObjectSchema(schema)) return schema;
+    const newSchema = copySchema(schema);
+    if (!newSchema.properties) newSchema.properties = {};
+    const isNewProperty = !(propertyName in newSchema.properties);
+    newSchema.properties[propertyName] = propertySchema;
+    if (newSchema.$propertyOrder) {
+        if (isNewProperty && !newSchema.$propertyOrder.includes(propertyName)) newSchema.$propertyOrder.push(propertyName);
+    } else newSchema.$propertyOrder = Object.keys(newSchema.properties);
+    return newSchema;
+}
+function removeObjectProperty(schema, propertyName) {
+    if (!isObjectSchema(schema) || !schema.properties) return schema;
+    const newSchema = copySchema(schema);
+    const { [propertyName]: _, ...remainingProps } = newSchema.properties;
+    newSchema.properties = remainingProps;
+    if (newSchema.required) newSchema.required = newSchema.required.filter((name)=>name !== propertyName);
+    if (newSchema.$propertyOrder) newSchema.$propertyOrder = newSchema.$propertyOrder.filter((name)=>name !== propertyName);
+    return newSchema;
+}
+function updatePropertyRequired(schema, propertyName, required) {
+    if (!isObjectSchema(schema)) return schema;
+    const newSchema = copySchema(schema);
+    if (!newSchema.required) newSchema.required = [];
+    if (required) {
+        if (!newSchema.required.includes(propertyName)) newSchema.required.push(propertyName);
+    } else newSchema.required = newSchema.required.filter((name)=>name !== propertyName);
+    return newSchema;
+}
+function updateArrayItems(schema, itemsSchema) {
+    if (isObjectSchema(schema) && "array" === schema.type) return {
+        ...schema,
+        items: itemsSchema
+    };
+    return schema;
+}
+function createFieldSchema(field) {
+    const { type, description, default: defaultValue, validation } = field;
+    if (isObjectSchema(validation)) {
+        const schema = {
+            type,
+            description,
+            ...validation
+        };
+        if (void 0 !== defaultValue) schema.default = defaultValue;
+        return schema;
+    }
+    const schema = validation || {
+        type
+    };
+    if (void 0 !== defaultValue) schema.default = defaultValue;
+    return schema;
+}
+function validateFieldName(name) {
+    if (!name || "" === name.trim()) return false;
+    const validNamePattern = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+    return validNamePattern.test(name);
+}
+function getSchemaProperties(schema) {
+    if (!isObjectSchema(schema) || !schema.properties) return [];
+    const required = schema.required || [];
+    const propertyOrder = schema.$propertyOrder || Object.keys(schema.properties);
+    const orderedPropertyNames = propertyOrder.filter((name)=>name in schema.properties);
+    const allPropertyNames = Object.keys(schema.properties);
+    const missingProperties = allPropertyNames.filter((name)=>!orderedPropertyNames.includes(name));
+    const finalOrder = [
+        ...orderedPropertyNames,
+        ...missingProperties
+    ];
+    return finalOrder.map((name)=>({
+            name,
+            schema: schema.properties[name],
+            required: required.includes(name)
+        }));
+}
+function hasPathTo(graph, from, to) {
+    const visited = new Set();
+    let current = from;
+    while(current){
+        if (current === to) return true;
+        if (visited.has(current)) break;
+        visited.add(current);
+        current = graph.get(current);
+    }
+    return false;
+}
+function getEligibleEnumControllingProperties(parentSchema, propertyName) {
+    if (!parentSchema.properties) return [];
+    const graph = new Map();
+    for (const k of Object.keys(parentSchema.properties)){
+        const prop = parentSchema.properties[k];
+        if ("object" != typeof prop || null === prop) continue;
+        const dep = prop.$dependentEnum?.property;
+        if (dep) graph.set(k, dep);
+    }
+    const result = [];
+    const siblings = Object.keys(parentSchema.properties).filter((n)=>n !== propertyName);
+    for (const name of siblings){
+        if (hasPathTo(graph, name, propertyName)) continue;
+        const prop = parentSchema.properties[name];
+        if ("boolean" == typeof prop) continue;
+        if (!prop) continue;
+        let values;
+        if (Array.isArray(prop.enum) && prop.enum.length > 0) values = prop.enum;
+        else if (void 0 !== prop.const) values = [
+            prop.const
+        ];
+        if (void 0 !== values) result.push({
+            name,
+            values
+        });
+    }
+    return result;
+}
+function getArrayItemsSchema(schema) {
+    if (isBooleanSchema(schema)) return null;
+    if ("array" !== schema.type) return null;
+    return schema.items || null;
+}
+function renameObjectProperty(schema, oldName, newName) {
+    if (!isObjectSchema(schema) || !schema.properties) return schema;
+    const newSchema = copySchema(schema);
+    const newProperties = {};
+    const propertyOrder = newSchema.$propertyOrder || Object.keys(newSchema.properties);
+    for (const key of propertyOrder)if (key === oldName) newProperties[newName] = newSchema.properties[oldName];
+    else if (key in newSchema.properties) newProperties[key] = newSchema.properties[key];
+    for (const [key, value] of Object.entries(newSchema.properties))if (!(key in newProperties)) newProperties[key] = value;
+    newSchema.properties = newProperties;
+    if (newSchema.required) newSchema.required = newSchema.required.map((field)=>field === oldName ? newName : field);
+    if (newSchema.$propertyOrder) newSchema.$propertyOrder = newSchema.$propertyOrder.map((name)=>name === oldName ? newName : name);
+    return newSchema;
+}
+function reorderObjectProperty(schema, propertyName, direction) {
+    if (!isObjectSchema(schema) || !schema.properties) return schema;
+    const newSchema = copySchema(schema);
+    if (!newSchema.$propertyOrder) newSchema.$propertyOrder = Object.keys(newSchema.properties);
+    const propertyOrder = [
+        ...newSchema.$propertyOrder
+    ];
+    const currentIndex = propertyOrder.indexOf(propertyName);
+    if (-1 === currentIndex) return schema;
+    if ("up" === direction && 0 === currentIndex) return schema;
+    if ("down" === direction && currentIndex === propertyOrder.length - 1) return schema;
+    const targetIndex = "up" === direction ? currentIndex - 1 : currentIndex + 1;
+    [propertyOrder[currentIndex], propertyOrder[targetIndex]] = [
+        propertyOrder[targetIndex],
+        propertyOrder[currentIndex]
+    ];
+    const newProperties = {};
+    for (const name of propertyOrder)if (name in newSchema.properties) newProperties[name] = newSchema.properties[name];
+    for (const [key, value] of Object.entries(newSchema.properties))if (!(key in newProperties)) newProperties[key] = value;
+    newSchema.properties = newProperties;
+    newSchema.$propertyOrder = propertyOrder;
+    return newSchema;
+}
+function hasChildren(schema) {
+    if (!isObjectSchema(schema)) return false;
+    if ("object" === schema.type && schema.properties) return Object.keys(schema.properties).length > 0;
+    if ("array" === schema.type && schema.items && isObjectSchema(schema.items)) return "object" === schema.items.type && !!schema.items.properties;
+    return false;
+}
+export { copySchema, createFieldSchema, getArrayItemsSchema, getEligibleEnumControllingProperties, getSchemaProperties, hasChildren, removeObjectProperty, renameObjectProperty, reorderObjectProperty, updateArrayItems, updateObjectProperty, updatePropertyRequired, validateFieldName };

package/dist/lib/utils.js

@@ -0,0 +1,40 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}
+const getTypeColor = (type)=>{
+    switch(type){
+        case "string":
+            return "text-blue-500 bg-blue-50";
+        case "number":
+        case "integer":
+            return "text-purple-500 bg-purple-50";
+        case "boolean":
+            return "text-green-500 bg-green-50";
+        case "object":
+            return "text-orange-500 bg-orange-50";
+        case "array":
+            return "text-pink-500 bg-pink-50";
+        case "null":
+            return "text-gray-500 bg-gray-50";
+    }
+};
+const getTypeLabel = (t, type)=>{
+    switch(type){
+        case "string":
+            return t.schemaTypeString;
+        case "number":
+        case "integer":
+            return t.schemaTypeNumber;
+        case "boolean":
+            return t.schemaTypeBoolean;
+        case "object":
+            return t.schemaTypeObject;
+        case "array":
+            return t.schemaTypeArray;
+        case "null":
+            return t.schemaTypeNull;
+    }
+};
+export { cn, getTypeColor, getTypeLabel };