@xyd-js/uniform 0.0.0-build-8b31648-20250923204702 → 0.0.0-build-9f87f13-20250930210637

package/src/converters.test.ts

@@ -0,0 +1,74 @@
+import {describe, it, expect} from "vitest";
+import {JSONSchema7} from "json-schema";
+import fs from "fs";
+import path from "path";
+
+import {uniformPropertiesToJsonSchema, uniformToInputJsonSchema} from "./converters";
+import {
+    DefinitionProperty,
+    DEFINED_DEFINITION_PROPERTY_TYPE,
+    Reference,
+} from "./types";
+
+describe("uniformPropertiesToJsonSchema", () => {
+    const tests = [
+        {
+            input: "./__fixtures__/1.basic/input.json",
+            output: "./__fixtures__/1.basic/output.json",
+        },
+        {
+            input: "./__fixtures__/2.advanced/input.json",
+            output: "./__fixtures__/2.advanced/output.json",
+        },
+        {
+            input: "./__fixtures__/2.advanced.livesession/input.json",
+            output: "./__fixtures__/2.advanced.livesession/output.json",
+        },
+    ];
+
+    describe("fixture-based tests", () => {
+        tests.forEach((testCase, index) => {
+            it(`should convert ${testCase.input} correctly`, () => {
+                // Check if input file exists
+                const inputPath = path.resolve(__dirname, testCase.input);
+                const outputPath = path.resolve(__dirname, testCase.output);
+
+                if (!fs.existsSync(inputPath)) {
+                    console.warn(`Input file ${inputPath} does not exist, skipping test`);
+                    return;
+                }
+
+                if (!fs.existsSync(outputPath)) {
+                    console.warn(
+                        `Output file ${outputPath} does not exist, skipping test`
+                    );
+                    return;
+                }
+
+                // Read input file
+                const inputData = JSON.parse(fs.readFileSync(inputPath, "utf8"));
+                const expectedOutput = JSON.parse(fs.readFileSync(outputPath, "utf8"));
+                // Convert input data
+
+                let inputCheck: JSONSchema7[] | JSONSchema7 | null = null;
+
+                if (Array.isArray(inputData)) {
+                    inputCheck = []
+                    for (const def of inputData) {
+                        const inputJsonSchema = uniformToInputJsonSchema(def);
+                        if (inputJsonSchema) {
+                            inputCheck.push(inputJsonSchema);
+                        }
+                    }
+                } else {
+                    const inputJsonSchema = uniformToInputJsonSchema(inputData);
+                    inputCheck = inputJsonSchema
+                }
+
+                // Compare with expected output
+                expect(inputCheck).toEqual(expectedOutput);
+                // fs.writeFileSync(outputPath, JSON.stringify(inputCheck, null, 2))
+            });
+        });
+    });
+});

package/src/converters.ts

@@ -0,0 +1,215 @@
+import {DEFINED_DEFINITION_PROPERTY_TYPE, DefinitionProperty, Reference} from "./types";
+import {JSONSchema7, JSONSchema7TypeName} from "json-schema";
+
+export function uniformToInputJsonSchema(reference: Reference): JSONSchema7 | null {
+    if (!reference?.definitions?.length) {
+        return null;
+    }
+
+    const inputDefinitions: JSONSchema7[] = [];
+
+    for (const def of reference.definitions) {
+        if (def?.type === "return") {
+            continue;
+        }
+
+        // Process each definition
+        const definitionSchemas: JSONSchema7[] = [];
+
+        // Add main properties if they exist
+        if (def?.properties?.length) {
+            const result = uniformPropertiesToJsonSchema(def.properties, def.type);
+            if (result) {
+                definitionSchemas.push(result as JSONSchema7);
+            }
+        }
+
+        // Add variant properties if they exist
+        if (def?.variants?.length) {
+            const variantSchemas: JSONSchema7[] = [];
+            
+            for (const variant of def.variants) {
+                if (variant?.properties?.length) {
+                    const result = uniformPropertiesToJsonSchema(variant.properties, def.type);
+                    if (result) {
+                        variantSchemas.push(result as JSONSchema7);
+                    }
+                }
+            }
+
+            // If there are variants, use oneOf
+            if (variantSchemas.length > 0) {
+                if (variantSchemas.length === 1) {
+                    definitionSchemas.push(variantSchemas[0]);
+                } else {
+                    definitionSchemas.push({
+                        oneOf: variantSchemas
+                    });
+                }
+            }
+        }
+
+        // Add this definition's schema(s) to the input definitions
+        if (definitionSchemas.length === 1) {
+            inputDefinitions.push(definitionSchemas[0]);
+        } else if (definitionSchemas.length > 1) {
+            inputDefinitions.push({
+                allOf: definitionSchemas
+            });
+        }
+    }
+
+    // Return the final schema
+    if (inputDefinitions.length === 0) {
+        return null;
+    } else if (inputDefinitions.length === 1) {
+        return inputDefinitions[0];
+    } else {
+        // Multiple definitions use allOf
+        return {
+            allOf: inputDefinitions
+        };
+    }
+}
+
+export function uniformPropertiesToJsonSchema(
+    properties: DefinitionProperty[] | DefinitionProperty,
+    id?: string
+): JSONSchema7 | null {
+    if (Array.isArray(properties)) {
+        let jsonSchemaProps: { [key: string]: JSONSchema7 } = {};
+        let requiredFields: string[] = [];
+
+        if (properties.length) {
+            for (const property of properties) {
+                const v = uniformPropertiesToJsonSchema(property);
+                if (v) {
+                    jsonSchemaProps[property.name] = v;
+                }
+
+                // Check if property is required
+                const isRequired = property.meta?.some(
+                    (meta) => meta.name === "required" && meta.value === "true"
+                );
+                if (isRequired) {
+                    requiredFields.push(property.name);
+                }
+            }
+        }
+
+        const schema: JSONSchema7 = {
+            $id: id || undefined,
+            type: "object",
+            properties: jsonSchemaProps,
+        };
+
+        // Only add required array if there are required fields
+        if (requiredFields.length > 0) {
+            schema.required = requiredFields;
+        }
+
+        return schema;
+    }
+
+    // Handle enum types
+    if (properties.type === DEFINED_DEFINITION_PROPERTY_TYPE.ENUM) {
+        const schema: JSONSchema7 = {
+            description: properties.description as string,
+        };
+
+        // Get the base type from ofProperty or meta
+        const enumType: string =
+            (properties.ofProperty && (properties.ofProperty as any).type) ||
+            (properties.meta?.find((meta) => meta.name === "enum-type")
+                ?.value as string) ||
+            "string";
+
+        schema.type = enumType as JSONSchema7TypeName;
+
+        // Extract enum values from properties array
+        if (properties.properties && properties.properties.length > 0) {
+            schema.enum = properties.properties.map((prop) => prop.name);
+        }
+
+        return schema;
+    }
+
+    // Handle array types
+    if (properties.type === DEFINED_DEFINITION_PROPERTY_TYPE.ARRAY) {
+        const schema: JSONSchema7 = {
+            type: "array",
+            description: properties.description as string,
+        };
+
+        // Set items schema from ofProperty
+        if (properties.ofProperty) {
+            const itemsSchema = uniformPropertiesToJsonSchema(properties.ofProperty);
+            if (itemsSchema) {
+                schema.items = itemsSchema;
+            }
+        }
+
+        return schema;
+    }
+
+    // Handle XOR (oneOf) types
+    if (properties.type === DEFINED_DEFINITION_PROPERTY_TYPE.XOR) {
+        const schema: JSONSchema7 = {
+            description: properties.description as string,
+        };
+
+        // Convert properties array to oneOf schemas
+        if (properties.properties && properties.properties.length > 0) {
+            schema.oneOf = properties.properties
+                .map((prop) => {
+                    const propSchema = uniformPropertiesToJsonSchema(prop);
+                    return propSchema || {};
+                })
+                .filter((schema) => Object.keys(schema).length > 0);
+        }
+
+        return schema;
+    }
+
+    // Handle UNION (anyOf) types
+    if (properties.type === DEFINED_DEFINITION_PROPERTY_TYPE.UNION) {
+        const schema: JSONSchema7 = {
+            description: properties.description as string,
+        };
+
+        // Convert properties array to anyOf schemas
+        if (properties.properties && properties.properties.length > 0) {
+            schema.anyOf = properties.properties
+                .map((prop) => {
+                    const propSchema = uniformPropertiesToJsonSchema(prop);
+                    return propSchema || {};
+                })
+                .filter((schema) => Object.keys(schema).length > 0);
+        }
+
+        return schema;
+    }
+
+    if (properties.ofProperty) {
+        return uniformPropertiesToJsonSchema(properties.ofProperty);
+    }
+
+    // Build the schema for single property
+    const schema: JSONSchema7 = {
+        type: properties.type as JSONSchema7TypeName,
+        description: properties.description as string,
+    };
+
+    // Handle object types with nested properties
+    if (properties.type === "object" && properties.properties && properties.properties.length > 0) {
+        const nestedSchema = uniformPropertiesToJsonSchema(properties.properties);
+        if (nestedSchema && nestedSchema.properties) {
+            schema.properties = nestedSchema.properties;
+            if (nestedSchema.required) {
+                schema.required = nestedSchema.required;
+            }
+        }
+    }
+
+    return schema;
+}

package/src/index.ts

@@ -1,6 +1,11 @@
 // Define the new PluginV type with a callback function that returns another function
 import {Reference} from "./types";
 
+export {
+    uniformToInputJsonSchema,
+    uniformPropertiesToJsonSchema
+} from "./converters";
+
 export * from "./types";
 
 // Define the new PluginV type with a callback function that returns another function

package/src/types.ts

@@ -40,6 +40,8 @@ export type SymbolDef = {
     canonical?: string | string[];
 }
 
+export type DefinitionTypeREST = "$rest.param.path" | "$rest.param.query" | "$rest.param.header" | "$rest.param.cookie" | "$rest.request.body"
+
 export interface Definition<
     M extends DefinitionMeta = DefinitionMeta,
     VM extends DefinitionVariantMeta = DefinitionVariantMeta
@@ -69,7 +71,7 @@ export interface Definition<
     /**
      * @internal
      */
-    type?: string;
+    type?: "return" | DefinitionTypeREST
 }
 
 export type DefinitionVariantOpenAPIMeta = Meta<"status" | "contentType" | "definitionDescription" | "required">;