@gxp-dev/tools 2.0.62 → 2.0.64

package/runtime/mock-api/response-generator.js

@@ -5,7 +5,7 @@
  * using Faker.js for realistic values.
  */
 
-const { faker } = require("@faker-js/faker");
+const { faker } = require("@faker-js/faker")
 
 /**
  * Resolve a $ref reference in the spec
@@ -15,22 +15,22 @@ const { faker } = require("@faker-js/faker");
  */
 function resolveRef(ref, spec) {
 	if (!ref || !ref.startsWith("#/")) {
-		return null;
+		return null
 	}
 
-	const parts = ref.slice(2).split("/");
-	let current = spec;
+	const parts = ref.slice(2).split("/")
+	let current = spec
 
 	for (const part of parts) {
 		if (current && typeof current === "object" && part in current) {
-			current = current[part];
+			current = current[part]
 		} else {
-			console.warn(`⚠️  Could not resolve $ref: ${ref}`);
-			return null;
+			console.warn(`⚠️  Could not resolve $ref: ${ref}`)
+			return null
 		}
 	}
 
-	return current;
+	return current
 }
 
 /**
@@ -43,37 +43,37 @@ function resolveRef(ref, spec) {
 function generateValue(type, format, schema = {}) {
 	// Handle enums first
 	if (schema.enum && schema.enum.length > 0) {
-		return faker.helpers.arrayElement(schema.enum);
+		return faker.helpers.arrayElement(schema.enum)
 	}
 
 	// Handle examples
 	if (schema.example !== undefined) {
-		return schema.example;
+		return schema.example
 	}
 
 	// Handle default values
 	if (schema.default !== undefined) {
-		return schema.default;
+		return schema.default
 	}
 
 	switch (type) {
 		case "string":
-			return generateStringValue(format, schema);
+			return generateStringValue(format, schema)
 
 		case "integer":
-			return generateIntegerValue(schema);
+			return generateIntegerValue(schema)
 
 		case "number":
-			return generateNumberValue(schema);
+			return generateNumberValue(schema)
 
 		case "boolean":
-			return faker.datatype.boolean();
+			return faker.datatype.boolean()
 
 		case "null":
-			return null;
+			return null
 
 		default:
-			return faker.lorem.word();
+			return faker.lorem.word()
 	}
 }
 
@@ -86,51 +86,51 @@ function generateValue(type, format, schema = {}) {
 function generateStringValue(format, schema) {
 	switch (format) {
 		case "email":
-			return faker.internet.email();
+			return faker.internet.email()
 
 		case "uuid":
-			return faker.string.uuid();
+			return faker.string.uuid()
 
 		case "uri":
 		case "url":
-			return faker.internet.url();
+			return faker.internet.url()
 
 		case "hostname":
-			return faker.internet.domainName();
+			return faker.internet.domainName()
 
 		case "ipv4":
-			return faker.internet.ipv4();
+			return faker.internet.ipv4()
 
 		case "ipv6":
-			return faker.internet.ipv6();
+			return faker.internet.ipv6()
 
 		case "date":
-			return faker.date.recent().toISOString().split("T")[0];
+			return faker.date.recent().toISOString().split("T")[0]
 
 		case "date-time":
-			return faker.date.recent().toISOString();
+			return faker.date.recent().toISOString()
 
 		case "time":
-			return faker.date.recent().toISOString().split("T")[1].split(".")[0];
+			return faker.date.recent().toISOString().split("T")[1].split(".")[0]
 
 		case "password":
-			return faker.internet.password();
+			return faker.internet.password()
 
 		case "byte":
-			return Buffer.from(faker.lorem.word()).toString("base64");
+			return Buffer.from(faker.lorem.word()).toString("base64")
 
 		case "binary":
-			return faker.string.alphanumeric(32);
+			return faker.string.alphanumeric(32)
 
 		case "phone":
-			return faker.phone.number();
+			return faker.phone.number()
 
 		case "color":
-			return faker.color.rgb();
+			return faker.color.rgb()
 
 		default:
 			// Use property name hints if available
-			return generateStringByPattern(schema);
+			return generateStringByPattern(schema)
 	}
 }
 
@@ -140,48 +140,52 @@ function generateStringValue(format, schema) {
  * @returns {string} Generated string
  */
 function generateStringByPattern(schema) {
-	const name = (schema.propertyName || "").toLowerCase();
+	const name = (schema.propertyName || "").toLowerCase()
 
 	// Common field name patterns
 	if (name.includes("name")) {
-		if (name.includes("first")) return faker.person.firstName();
-		if (name.includes("last")) return faker.person.lastName();
-		if (name.includes("full")) return faker.person.fullName();
-		if (name.includes("company")) return faker.company.name();
-		return faker.person.fullName();
+		if (name.includes("first")) return faker.person.firstName()
+		if (name.includes("last")) return faker.person.lastName()
+		if (name.includes("full")) return faker.person.fullName()
+		if (name.includes("company")) return faker.company.name()
+		return faker.person.fullName()
 	}
 
-	if (name.includes("email")) return faker.internet.email();
+	if (name.includes("email")) return faker.internet.email()
 	if (name.includes("phone") || name.includes("mobile"))
-		return faker.phone.number();
-	if (name.includes("address")) return faker.location.streetAddress();
-	if (name.includes("city")) return faker.location.city();
-	if (name.includes("state")) return faker.location.state();
-	if (name.includes("country")) return faker.location.country();
+		return faker.phone.number()
+	if (name.includes("address")) return faker.location.streetAddress()
+	if (name.includes("city")) return faker.location.city()
+	if (name.includes("state")) return faker.location.state()
+	if (name.includes("country")) return faker.location.country()
 	if (name.includes("zip") || name.includes("postal"))
-		return faker.location.zipCode();
-	if (name.includes("url") || name.includes("link")) return faker.internet.url();
-	if (name.includes("image") || name.includes("avatar") || name.includes("photo"))
-		return faker.image.url();
+		return faker.location.zipCode()
+	if (name.includes("url") || name.includes("link")) return faker.internet.url()
+	if (
+		name.includes("image") ||
+		name.includes("avatar") ||
+		name.includes("photo")
+	)
+		return faker.image.url()
 	if (name.includes("description") || name.includes("bio"))
-		return faker.lorem.paragraph();
-	if (name.includes("title")) return faker.lorem.sentence();
-	if (name.includes("slug")) return faker.helpers.slugify(faker.lorem.words(3));
-	if (name.includes("color")) return faker.color.rgb();
+		return faker.lorem.paragraph()
+	if (name.includes("title")) return faker.lorem.sentence()
+	if (name.includes("slug")) return faker.helpers.slugify(faker.lorem.words(3))
+	if (name.includes("color")) return faker.color.rgb()
 	if (name.includes("token") || name.includes("key"))
-		return faker.string.alphanumeric(32);
+		return faker.string.alphanumeric(32)
 
 	// Apply length constraints
-	const minLength = schema.minLength || 1;
-	const maxLength = schema.maxLength || 50;
-	const length = faker.number.int({ min: minLength, max: maxLength });
+	const minLength = schema.minLength || 1
+	const maxLength = schema.maxLength || 50
+	const length = faker.number.int({ min: minLength, max: maxLength })
 
 	if (schema.pattern) {
 		// Can't easily generate from regex, return simple string
-		return faker.string.alphanumeric(length);
+		return faker.string.alphanumeric(length)
 	}
 
-	return faker.lorem.words(Math.ceil(length / 6));
+	return faker.lorem.words(Math.ceil(length / 6))
 }
 
 /**
@@ -190,15 +194,15 @@ function generateStringByPattern(schema) {
  * @returns {number} Generated integer
  */
 function generateIntegerValue(schema) {
-	const min = schema.minimum ?? 0;
-	const max = schema.maximum ?? 10000;
-	const exclusiveMin = schema.exclusiveMinimum ? 1 : 0;
-	const exclusiveMax = schema.exclusiveMaximum ? 1 : 0;
+	const min = schema.minimum ?? 0
+	const max = schema.maximum ?? 10000
+	const exclusiveMin = schema.exclusiveMinimum ? 1 : 0
+	const exclusiveMax = schema.exclusiveMaximum ? 1 : 0
 
 	return faker.number.int({
 		min: min + exclusiveMin,
 		max: max - exclusiveMax,
-	});
+	})
 }
 
 /**
@@ -207,14 +211,14 @@ function generateIntegerValue(schema) {
  * @returns {number} Generated number
  */
 function generateNumberValue(schema) {
-	const min = schema.minimum ?? 0;
-	const max = schema.maximum ?? 10000;
+	const min = schema.minimum ?? 0
+	const max = schema.maximum ?? 10000
 
 	return faker.number.float({
 		min,
 		max,
 		fractionDigits: 2,
-	});
+	})
 }
 
 /**
@@ -228,59 +232,64 @@ function generateNumberValue(schema) {
 function generateFromSchema(schema, spec = {}, propertyName = "", depth = 0) {
 	// Prevent infinite recursion
 	if (depth > 10) {
-		return null;
+		return null
 	}
 
 	// Handle null/undefined schema
 	if (!schema) {
-		return null;
+		return null
 	}
 
 	// Handle $ref
 	if (schema.$ref) {
-		const resolved = resolveRef(schema.$ref, spec);
+		const resolved = resolveRef(schema.$ref, spec)
 		if (resolved) {
-			return generateFromSchema(resolved, spec, propertyName, depth + 1);
+			return generateFromSchema(resolved, spec, propertyName, depth + 1)
 		}
-		return null;
+		return null
 	}
 
 	// Handle allOf (merge schemas)
 	if (schema.allOf) {
-		const merged = {};
+		const merged = {}
 		for (const subSchema of schema.allOf) {
-			const generated = generateFromSchema(subSchema, spec, propertyName, depth + 1);
+			const generated = generateFromSchema(
+				subSchema,
+				spec,
+				propertyName,
+				depth + 1,
+			)
 			if (generated && typeof generated === "object") {
-				Object.assign(merged, generated);
+				Object.assign(merged, generated)
 			}
 		}
-		return merged;
+		return merged
 	}
 
 	// Handle oneOf/anyOf (pick first)
 	if (schema.oneOf && schema.oneOf.length > 0) {
-		return generateFromSchema(schema.oneOf[0], spec, propertyName, depth + 1);
+		return generateFromSchema(schema.oneOf[0], spec, propertyName, depth + 1)
 	}
 	if (schema.anyOf && schema.anyOf.length > 0) {
-		return generateFromSchema(schema.anyOf[0], spec, propertyName, depth + 1);
+		return generateFromSchema(schema.anyOf[0], spec, propertyName, depth + 1)
 	}
 
 	// Add property name hint to schema for string generation
-	const schemaWithHint = { ...schema, propertyName };
+	const schemaWithHint = { ...schema, propertyName }
 
 	// Handle by type
-	const type = schema.type || "object";
+	const type = schema.type || "object"
 
 	if (type === "object" || schema.properties) {
-		return generateObject(schema, spec, depth);
+		return generateObject(schema, spec, depth)
 	}
 
 	if (type === "array") {
-		return generateArray(schema, spec, depth);
+		return generateArray(schema, spec, depth)
 	}
 
 	// Primitive types
-	return generateValue(type, schema.format, schemaWithHint);
+	return generateValue(type, schema.format, schemaWithHint)
 }
 
 /**
@@ -291,29 +300,31 @@ function generateFromSchema(schema, spec = {}, propertyName = "", depth = 0) {
  * @returns {object} Generated object
  */
 function generateObject(schema, spec, depth) {
-	const result = {};
+	const result = {}
 
 	if (schema.properties) {
 		for (const [key, propSchema] of Object.entries(schema.properties)) {
-			result[key] = generateFromSchema(propSchema, spec, key, depth + 1);
+			result[key] = generateFromSchema(propSchema, spec, key, depth + 1)
 		}
 	}
 
 	// Handle additionalProperties if no properties defined
 	if (!schema.properties && schema.additionalProperties) {
-		const count = faker.number.int({ min: 1, max: 3 });
+		const count = faker.number.int({ min: 1, max: 3 })
 		for (let i = 0; i < count; i++) {
-			const key = faker.lorem.word();
+			const key = faker.lorem.word()
 			result[key] = generateFromSchema(
-				schema.additionalProperties === true ? { type: "string" } : schema.additionalProperties,
+				schema.additionalProperties === true
+					? { type: "string" }
+					: schema.additionalProperties,
 				spec,
 				key,
-				depth + 1
-			);
+				depth + 1,
+			)
 		}
 	}
 
-	return result;
+	return result
 }
 
 /**
@@ -324,18 +335,18 @@ function generateObject(schema, spec, depth) {
  * @returns {array} Generated array
  */
 function generateArray(schema, spec, depth) {
-	const minItems = schema.minItems ?? 1;
-	const maxItems = schema.maxItems ?? 5;
-	const count = faker.number.int({ min: minItems, max: maxItems });
+	const minItems = schema.minItems ?? 1
+	const maxItems = schema.maxItems ?? 5
+	const count = faker.number.int({ min: minItems, max: maxItems })
 
-	const items = [];
-	const itemSchema = schema.items || { type: "string" };
+	const items = []
+	const itemSchema = schema.items || { type: "string" }
 
 	for (let i = 0; i < count; i++) {
-		items.push(generateFromSchema(itemSchema, spec, "", depth + 1));
+		items.push(generateFromSchema(itemSchema, spec, "", depth + 1))
 	}
 
-	return items;
+	return items
 }
 
 /**
@@ -346,28 +357,28 @@ function generateArray(schema, spec, depth) {
  */
 function generateResponse(responseSchema, spec) {
 	if (!responseSchema) {
-		return {};
+		return {}
 	}
 
 	// Handle content type (prefer JSON)
-	const content = responseSchema.content;
+	const content = responseSchema.content
 	if (content) {
 		const jsonContent =
 			content["application/json"] ||
 			content["application/vnd.api+json"] ||
-			content["*/*"];
+			content["*/*"]
 
 		if (jsonContent && jsonContent.schema) {
-			return generateFromSchema(jsonContent.schema, spec);
+			return generateFromSchema(jsonContent.schema, spec)
 		}
 	}
 
 	// Direct schema (OpenAPI 2.0 style)
 	if (responseSchema.schema) {
-		return generateFromSchema(responseSchema.schema, spec);
+		return generateFromSchema(responseSchema.schema, spec)
 	}
 
-	return {};
+	return {}
 }
 
 /**
@@ -382,7 +393,7 @@ function generateErrorResponse(status, message) {
 		status,
 		message,
 		timestamp: new Date().toISOString(),
-	};
+	}
 }
 
 module.exports = {
@@ -391,4 +402,4 @@ module.exports = {
 	generateValue,
 	generateErrorResponse,
 	resolveRef,
-};
+}