apify-schema-tools 2.0.1

package/test/json-schemas.test.ts

@@ -0,0 +1,587 @@
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { writeFile } from "../src/filesystem.js";
+import {
+	type ObjectSchema,
+	compareDescriptions,
+	compareSchemas,
+	filterValidSchemaProperties,
+	mergeObjectSchemas,
+	readJsonSchema,
+	readJsonSchemaField,
+	writeSchemaToField,
+} from "../src/json-schemas.js";
+import { cleanupTestDirectory, getTestDir, setupTestDirectory } from "./common.js";
+
+const TEST_DIR = getTestDir("json-schemas");
+
+describe("JSON schemas utilities", () => {
+	afterEach(() => {
+		cleanupTestDirectory(TEST_DIR);
+	});
+
+	describe("readJsonSchemaField", () => {
+		it("should read a specific field from a JSON schema file when field is an object schema", () => {
+			setupTestDirectory(TEST_DIR);
+			const filePath = join(TEST_DIR, "wrapper-schema.json");
+			const wrapperSchema = {
+				type: "object",
+				title: "Wrapper Schema",
+				inputSchema: {
+					type: "object",
+					properties: {
+						name: { type: "string" },
+						age: { type: "number" },
+					},
+					required: ["name"],
+				},
+				outputSchema: {
+					type: "object",
+					properties: {
+						result: { type: "string" },
+					},
+				},
+			};
+
+			writeFile(filePath, JSON.stringify(wrapperSchema));
+
+			const inputSchema = readJsonSchemaField(filePath, "inputSchema");
+
+			expect(inputSchema).toEqual({
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					age: { type: "number" },
+				},
+				required: ["name"],
+			});
+		});
+
+		it("should read another field from the same schema file", () => {
+			setupTestDirectory(TEST_DIR);
+			const filePath = join(TEST_DIR, "wrapper-schema.json");
+			const wrapperSchema = {
+				type: "object",
+				title: "Wrapper Schema",
+				inputSchema: {
+					type: "object",
+					properties: {
+						name: { type: "string" },
+						age: { type: "number" },
+					},
+					required: ["name"],
+				},
+				outputSchema: {
+					type: "object",
+					properties: {
+						result: { type: "string" },
+					},
+				},
+			};
+
+			writeFile(filePath, JSON.stringify(wrapperSchema));
+
+			const outputSchema = readJsonSchemaField(filePath, "outputSchema");
+
+			expect(outputSchema).toEqual({
+				type: "object",
+				properties: {
+					result: { type: "string" },
+				},
+			});
+		});
+
+		it("should throw error when field does not exist", () => {
+			setupTestDirectory(TEST_DIR);
+			const filePath = join(TEST_DIR, "schema-without-field.json");
+			const schema = {
+				type: "object",
+				properties: {
+					name: { type: "string" },
+				},
+			};
+
+			writeFile(filePath, JSON.stringify(schema));
+
+			expect(() => {
+				readJsonSchemaField(filePath, "nonExistentField");
+			}).toThrow(`Field "nonExistentField" not found in schema "${filePath}"`);
+		});
+
+		it("should throw error when field is not an object schema", () => {
+			setupTestDirectory(TEST_DIR);
+			const filePath = join(TEST_DIR, "schema-with-non-object-field.json");
+			const schema = {
+				type: "object",
+				properties: {
+					name: { type: "string" },
+				},
+				stringField: "not an object schema",
+				arrayField: ["also", "not", "an", "object", "schema"],
+				primitiveField: {
+					type: "string", // This is a property schema, not an object schema
+				},
+			};
+
+			writeFile(filePath, JSON.stringify(schema));
+
+			expect(() => {
+				readJsonSchemaField(filePath, "stringField");
+			}).toThrow(`Schema "${filePath} > stringField" is not an object schema`);
+
+			expect(() => {
+				readJsonSchemaField(filePath, "arrayField");
+			}).toThrow(`Schema "${filePath} > arrayField" is not an object schema`);
+
+			expect(() => {
+				readJsonSchemaField(filePath, "primitiveField");
+			}).toThrow(`Schema "${filePath} > primitiveField" is not an object schema`);
+		});
+
+		it("should successfully read nested object schemas", () => {
+			setupTestDirectory(TEST_DIR);
+			const filePath = join(TEST_DIR, "complex-schema.json");
+			const complexSchema = {
+				type: "object",
+				title: "Complex Schema",
+				nestedSchema: {
+					type: "object",
+					properties: {
+						profile: {
+							type: "object",
+							properties: {
+								name: { type: "string" },
+								email: { type: "string" },
+							},
+							required: ["name"],
+						},
+						preferences: {
+							type: "object",
+							properties: {
+								theme: { type: "string" },
+								notifications: { type: "boolean" },
+							},
+						},
+					},
+					required: ["profile"],
+				},
+			};
+
+			writeFile(filePath, JSON.stringify(complexSchema));
+
+			const nestedSchema = readJsonSchemaField(filePath, "nestedSchema");
+
+			expect(nestedSchema).toEqual({
+				type: "object",
+				properties: {
+					profile: {
+						type: "object",
+						properties: {
+							name: { type: "string" },
+							email: { type: "string" },
+						},
+						required: ["name"],
+					},
+					preferences: {
+						type: "object",
+						properties: {
+							theme: { type: "string" },
+							notifications: { type: "boolean" },
+						},
+					},
+				},
+				required: ["profile"],
+			});
+		});
+	});
+
+	describe("writeSchemaToField", () => {
+		it("should write a schema to a specific field in an existing JSON schema file", () => {
+			setupTestDirectory(TEST_DIR);
+			const filePath = join(TEST_DIR, "test-schema.json");
+			const wrapperSchema = {
+				fields: {
+					name: { type: "string" },
+					age: { type: "number" },
+				},
+			};
+
+			writeFile(filePath, JSON.stringify(wrapperSchema));
+
+			const schemaToWrite: ObjectSchema = {
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					age: { type: "number" },
+				},
+			};
+
+			writeSchemaToField(filePath, schemaToWrite, "fields");
+
+			const updatedSchema = readJsonSchema(filePath);
+
+			expect(updatedSchema).toEqual({
+				fields: {
+					type: "object",
+					properties: {
+						name: { type: "string" },
+						age: { type: "number" },
+					},
+				},
+			});
+		});
+	});
+
+	describe("filterValidSchemaProperties", () => {
+		it("should filter valid keys", () => {
+			const schema: ObjectSchema = {
+				type: "object",
+				properties: {
+					name: { type: "string", default: "John Doe" },
+					age: { type: "integer", prefill: 30 },
+					address: { type: "string", required: true },
+				},
+				invalidField: "any",
+			};
+
+			const validRootKeys = ["type", "properties"];
+			const validPropertyKeys = ["type"];
+			const validPropertyTypes = ["string", "integer", "array"];
+			const validPropertyKeysByType: Record<string, string[]> = {
+				string: ["default", "prefill"],
+			};
+
+			const filteredSchema = filterValidSchemaProperties(
+				schema,
+				validRootKeys,
+				validPropertyKeys,
+				validPropertyTypes,
+				validPropertyKeysByType,
+			);
+
+			expect(filteredSchema).toEqual({
+				type: "object",
+				properties: {
+					name: { type: "string", default: "John Doe" },
+					age: { type: "integer" },
+					address: { type: "string" },
+				},
+			});
+		});
+
+		it("should throw on invalid property type", () => {
+			const validPropertyTypes = ["string", "boolean", "integer", "object", "array"];
+
+			expect(() =>
+				filterValidSchemaProperties(
+					{
+						type: "object",
+						properties: {
+							string: { type: "string" },
+							boolean: { type: "boolean" },
+							integer: { type: "integer" },
+							object: { type: "object" },
+							array: { type: "array" },
+						},
+					},
+					["type", "properties"],
+					[],
+					validPropertyTypes,
+					{},
+				),
+			).not.toThrow();
+
+			expect(() =>
+				filterValidSchemaProperties(
+					{
+						type: "object",
+						properties: {
+							numberProp: { type: "number" },
+						},
+					},
+					["type", "properties"],
+					[],
+					validPropertyTypes,
+					{},
+				),
+			).toThrow('Invalid property type "number" for property "numberProp" in the input schema');
+
+			expect(() =>
+				filterValidSchemaProperties(
+					{
+						type: "object",
+						properties: {
+							nullProp: { type: "null" },
+						},
+					},
+					["type", "properties"],
+					[],
+					validPropertyTypes,
+					{},
+				),
+			).toThrow('Invalid property type "null" for property "nullProp" in the input schema');
+		});
+
+		it("should throw on multiple types (unsupported)", () => {
+			expect(() =>
+				filterValidSchemaProperties(
+					{
+						type: "object",
+						properties: {
+							multiType: { type: ["string", "integer"] },
+						},
+					},
+					["type", "properties"],
+					[],
+					["string", "integer"],
+					{},
+				),
+			).toThrow(
+				'Property "multiType" has an invalid type "string,integer" in the input schema: non-string types are not supported',
+			);
+		});
+
+		it("should throw on missing type", () => {
+			expect(() =>
+				filterValidSchemaProperties(
+					{
+						type: "object",
+						properties: {
+							missingType: {},
+						},
+					},
+					["type", "properties"],
+					[],
+					["string", "integer"],
+					{},
+				),
+			).toThrow('Property "missingType" is missing a type in the input schema');
+		});
+	});
+
+	describe("mergeObjectSchemas", () => {
+		it("should merge two object schemas", () => {
+			const baseSchema: ObjectSchema = {
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					phone: { type: "integer" },
+				},
+			};
+
+			const additionalSchema: ObjectSchema = {
+				type: "object",
+				properties: {
+					phone: { type: "string" },
+					address: { type: "string" },
+				},
+			};
+
+			const deepMerge = false;
+
+			const mergedSchema = mergeObjectSchemas(baseSchema, additionalSchema, deepMerge);
+
+			expect(mergedSchema).toEqual({
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					phone: { type: "string" }, // phone type changed to string
+					address: { type: "string" },
+				},
+			});
+		});
+
+		it("should deep merge two object schemas", () => {
+			const baseSchema: ObjectSchema = {
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					phone: { type: "integer" },
+					address: {
+						type: "object",
+						properties: {
+							street: { type: "string" },
+							city: { type: "string" },
+						},
+					},
+				},
+			};
+
+			const additionalSchema: ObjectSchema = {
+				type: "object",
+				properties: {
+					phone: { type: "string" }, // changing phone type
+					address: {
+						type: "object",
+						properties: {
+							city: { type: "string", default: "Unknown City" }, // adding default value
+							country: { type: "string" },
+						},
+					},
+				},
+			};
+
+			const deepMerge = true;
+
+			const mergedSchema = mergeObjectSchemas(baseSchema, additionalSchema, deepMerge);
+
+			expect(mergedSchema).toEqual({
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					phone: { type: "string" }, // phone type changed to string
+					address: {
+						type: "object",
+						properties: {
+							street: { type: "string" }, // retained from base schema
+							city: { type: "string", default: "Unknown City" }, // default value added
+							country: { type: "string" }, // new property added
+						},
+					},
+				},
+			});
+		});
+	});
+
+	describe("compareJsonSchemas", () => {
+		it("returns true for identical schemas", () => {
+			const schema1: ObjectSchema = {
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					age: { type: "integer" },
+				},
+			};
+
+			const schema2: ObjectSchema = {
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					age: { type: "integer" },
+				},
+			};
+
+			expect(compareSchemas(schema1, schema2)).toBe(true);
+		});
+
+		it("returns false for different schemas", () => {
+			const schema1: ObjectSchema = {
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					age: { type: "integer" },
+				},
+			};
+
+			const schema2: ObjectSchema = {
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					age: { type: "number" }, // different type
+				},
+			};
+
+			expect(compareSchemas(schema1, schema2)).toBe(false);
+		});
+
+		it("returns true for schemas with different descriptions, if ignoreDescriptions is true", () => {
+			const schema1: ObjectSchema = {
+				type: "object",
+				title: "Person",
+				description: "A person object",
+				properties: {
+					name: { type: "string", description: "Name of the person" },
+					age: { type: "integer", description: "Age of the person" },
+				},
+			};
+
+			const schema2: ObjectSchema = {
+				type: "object",
+				title: "A person", // different title
+				description: "A person object with different descriptions", // different description
+				properties: {
+					name: { type: "string", description: "Full name" }, // different description
+					age: { type: "integer", description: "Person's age" }, // different description
+				},
+			};
+
+			expect(compareSchemas(schema1, schema2, true)).toBe(true);
+		});
+	});
+
+	describe("compareDescriptions", () => {
+		it("returns true for identical descriptions", () => {
+			const sourceSchema: ObjectSchema = {
+				type: "object",
+				title: "Person",
+				description: "A person object",
+				properties: {
+					name: { type: "string", description: "Name of the person" },
+					age: { type: "integer", description: "Age of the person" },
+				},
+			};
+
+			const outputSchema: ObjectSchema = {
+				type: "object",
+				title: "Person",
+				description: "A person object",
+				properties: {
+					name: { type: "string", description: "Name of the person" },
+					age: { type: "integer", description: "Age of the person" },
+				},
+			};
+
+			expect(compareDescriptions(sourceSchema, outputSchema)).toBe(true);
+		});
+
+		it("returns true if the descriptions are the same for common properties", () => {
+			const sourceSchema: ObjectSchema = {
+				type: "object",
+				title: "Person",
+				description: "A person object",
+				properties: {
+					name: { type: "string", description: "Name of the person" },
+					// age property was added to source
+					age: { type: "integer", description: "Age of the person" },
+				},
+			};
+			const outputSchema: ObjectSchema = {
+				type: "object",
+				title: "Person",
+				description: "A person object",
+				properties: {
+					name: { type: "string", description: "Name of the person" },
+					// country property was removed from source
+					country: { type: "string", description: "Country of the person" },
+				},
+			};
+			expect(compareDescriptions(sourceSchema, outputSchema)).toBe(true);
+		});
+
+		it("returns false for different descriptions", () => {
+			const sourceSchema: ObjectSchema = {
+				type: "object",
+				title: "Person",
+				description: "A person object",
+				properties: {
+					name: { type: "string", description: "Name of the person" },
+					age: { type: "integer", description: "Age of the person" },
+				},
+			};
+
+			const outputSchema: ObjectSchema = {
+				type: "object",
+				title: "Person",
+				description: "A different description for a person object",
+				properties: {
+					name: { type: "string", description: "Full name" }, // different description
+					age: { type: "integer", description: "Person's age" }, // different description
+				},
+			};
+
+			expect(compareDescriptions(sourceSchema, outputSchema)).toBe(false);
+		});
+	});
+});