apify-schema-tools 3.1.0 → 3.2.0

package/test/cli/check.test.ts

@@ -0,0 +1,1571 @@
+import { execSync } from "node:child_process";
+import { join } from "node:path";
+import { afterEach, beforeAll, describe, expect, it } from "vitest";
+import { DATASET_SCHEMA_FIELD } from "../../src/apify.js";
+import { writeFile } from "../../src/utils/filesystem.js";
+import { type ObjectSchema, writeJsonSchema, writeSchemaToField } from "../../src/utils/json-schemas.js";
+import {
+	cleanupTestDirectory,
+	getDatasetSchemaPath,
+	getInputSchemaPath,
+	getTestDir,
+	setupTestDirectory,
+	setupTestDirectoryFiles,
+} from "../common.js";
+
+const EXEC_CMD = `node ${import.meta.dirname}/../../dist/apify-schema-tools.js`;
+
+const TEST_DIR = getTestDir("check-command");
+const INPUT_SCHEMA_PATH = getInputSchemaPath(TEST_DIR);
+const DATASET_SCHEMA_PATH = getDatasetSchemaPath(TEST_DIR);
+
+const ADDITIONAL_PROPERTIES_ERROR_PATTERN =
+	/If you generated an interface from a JSON schema, pay attention that "additionalProperties" is set to an empty schema by default/;
+
+describe("check command", () => {
+	beforeAll(() => {
+		execSync("npm run build", { stdio: "inherit" });
+	});
+	afterEach(() => {
+		cleanupTestDirectory(TEST_DIR);
+	});
+
+	it("should pass if the schemas match the source schemas", () => {
+		const inputSchema: ObjectSchema = {
+			title: "Input Schema",
+			type: "object",
+			properties: {
+				name: { type: "string" },
+				age: { type: "integer" },
+			},
+			required: ["name"],
+		};
+		const datasetSchema: ObjectSchema = {
+			title: "Dataset Item Schema",
+			type: "object",
+			properties: {
+				id: { type: "string" },
+				value: { type: "number" },
+			},
+			required: ["id"],
+		};
+		setupTestDirectory(TEST_DIR);
+		const srcDir = join(TEST_DIR, "src-schemas");
+		const srcInputPath = join(srcDir, "input.json");
+		const srcDatasetPath = join(srcDir, "dataset-item.json");
+		setupTestDirectoryFiles({
+			testDirPath: TEST_DIR,
+			srcInputPath,
+			srcInput: inputSchema,
+			srcDatasetPath,
+			srcDataset: datasetSchema,
+		});
+		writeJsonSchema(INPUT_SCHEMA_PATH, inputSchema);
+		writeSchemaToField(DATASET_SCHEMA_PATH, datasetSchema, DATASET_SCHEMA_FIELD);
+		expect(() =>
+			execSync(
+				[
+					`${EXEC_CMD} check`,
+					"-i input dataset",
+					"-o json-schemas",
+					`--src-input ${srcInputPath}`,
+					`--src-dataset ${srcDatasetPath}`,
+				].join(" "),
+				{
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				},
+			),
+		).not.toThrow();
+	});
+
+	it("should consider additional schemas", () => {
+		const inputSchema: ObjectSchema = {
+			title: "Input Schema",
+			type: "object",
+			properties: {
+				name: { type: "string" },
+			},
+			required: ["name"],
+		};
+		const additionalSchema: ObjectSchema = {
+			type: "object",
+			properties: {
+				age: { type: "integer" },
+			},
+		};
+		const fullSchema: ObjectSchema = {
+			title: "Input Schema",
+			type: "object",
+			properties: {
+				name: { type: "string" },
+				age: { type: "integer" },
+			},
+			required: ["name"],
+		};
+		setupTestDirectory(TEST_DIR);
+		const srcDir = join(TEST_DIR, "src-schemas");
+		const srcInputPath = join(srcDir, "input.json");
+		const srcDatasetPath = join(srcDir, "dataset-item.json");
+		const addDir = join(TEST_DIR, "add-schemas");
+		const addInputPath = join(addDir, "add-input.json");
+		setupTestDirectoryFiles({
+			testDirPath: TEST_DIR,
+			srcInputPath,
+			srcInput: inputSchema,
+			srcDatasetPath,
+			srcDataset: {} as ObjectSchema,
+			addDir,
+			addInputPath,
+			addInput: additionalSchema,
+		});
+		writeJsonSchema(INPUT_SCHEMA_PATH, fullSchema);
+		expect(() =>
+			execSync(
+				[
+					`${EXEC_CMD} check`,
+					"-i input",
+					"-o json-schemas",
+					`--src-input ${srcInputPath}`,
+					`--src-dataset ${srcDatasetPath}`,
+					`--add-input ${addInputPath}`,
+				].join(" "),
+				{
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				},
+			),
+		).not.toThrow();
+	});
+
+	it("should pass when source schema has position fields that are removed in output", () => {
+		const inputSchemaWithPositions: ObjectSchema = {
+			title: "Input Schema",
+			type: "object",
+			properties: {
+				name: { type: "string", position: 1 },
+				age: { type: "integer", position: 2 },
+				email: { type: "string", position: 0 },
+			},
+			required: ["name"],
+		};
+		// Expected output schema (positions are removed by the filtering process)
+		const expectedOutputSchema: ObjectSchema = {
+			title: "Input Schema",
+			type: "object",
+			properties: {
+				email: { type: "string" }, // position 0 comes first
+				name: { type: "string" }, // position 1 comes second
+				age: { type: "integer" }, // position 2 comes last
+			},
+			required: ["name"],
+		};
+		setupTestDirectory(TEST_DIR);
+		const srcDir = join(TEST_DIR, "src-schemas");
+		const srcInputPath = join(srcDir, "input.json");
+		const srcDatasetPath = join(srcDir, "dataset-item.json");
+		setupTestDirectoryFiles({
+			testDirPath: TEST_DIR,
+			srcInputPath,
+			srcInput: inputSchemaWithPositions,
+			srcDatasetPath,
+			srcDataset: {} as ObjectSchema,
+		});
+		writeJsonSchema(INPUT_SCHEMA_PATH, expectedOutputSchema);
+		expect(() =>
+			execSync(
+				[
+					`${EXEC_CMD} check`,
+					"-i input",
+					"-o json-schemas",
+					`--src-input ${srcInputPath}`,
+					`--src-dataset ${srcDatasetPath}`,
+				].join(" "),
+				{
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				},
+			),
+		).not.toThrow();
+	});
+
+	it("should pass when source schema has invalid input schema fields that are filtered out", () => {
+		const inputSchemaWithInvalidFields: ObjectSchema = {
+			title: "Input Schema",
+			type: "object",
+			properties: {
+				name: {
+					type: "string",
+					format: "email", // Invalid field for Apify input schemas - will be removed
+					custom: "field", // Invalid field - will be removed
+				},
+				age: {
+					type: "integer",
+					invalidField: "value", // Invalid field - will be removed
+				},
+				description: {
+					type: "string",
+					pattern: "^[a-z]+$", // Valid field - will be kept
+				},
+			},
+			required: ["name"],
+			invalidRootField: "should be removed", // Invalid root field - will be removed
+		};
+		// Expected output schema (invalid fields are removed by the filtering process)
+		const expectedOutputSchema: ObjectSchema = {
+			title: "Input Schema",
+			type: "object",
+			properties: {
+				name: { type: "string" },
+				age: { type: "integer" },
+				description: {
+					type: "string",
+					pattern: "^[a-z]+$",
+				},
+			},
+			required: ["name"],
+		};
+		setupTestDirectory(TEST_DIR);
+		const srcDir = join(TEST_DIR, "src-schemas");
+		const srcInputPath = join(srcDir, "input.json");
+		const srcDatasetPath = join(srcDir, "dataset-item.json");
+		setupTestDirectoryFiles({
+			testDirPath: TEST_DIR,
+			srcInputPath,
+			srcInput: inputSchemaWithInvalidFields,
+			srcDatasetPath,
+			srcDataset: {} as ObjectSchema,
+		});
+		writeJsonSchema(INPUT_SCHEMA_PATH, expectedOutputSchema);
+		expect(() =>
+			execSync(
+				[
+					`${EXEC_CMD} check`,
+					"-i input",
+					"-o json-schemas",
+					`--src-input ${srcInputPath}`,
+					`--src-dataset ${srcDatasetPath}`,
+				].join(" "),
+				{
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				},
+			),
+		).not.toThrow();
+	});
+
+	it("should pass when source schema has both position and invalid fields", () => {
+		const complexSourceSchema: ObjectSchema = {
+			title: "Complex Input Schema",
+			type: "object",
+			properties: {
+				priority: {
+					type: "string",
+					position: 0,
+					format: "email", // Invalid - will be removed
+				},
+				name: {
+					type: "string",
+					position: 2,
+					customField: "invalid", // Invalid - will be removed
+				},
+				age: {
+					type: "integer",
+					position: 1,
+					maximum: 100, // Valid - will be kept
+				},
+				settings: {
+					type: "object",
+					position: 3,
+					patternKey: "^[a-z]+$", // Valid for object type - will be kept
+					invalidObjectField: "remove", // Invalid - will be removed
+				},
+			},
+			required: ["priority", "name"],
+			customRootField: "invalid", // Invalid root field - will be removed
+		};
+		// Expected output schema (positions removed, invalid fields removed, properties ordered by position)
+		const expectedOutputSchema: ObjectSchema = {
+			title: "Complex Input Schema",
+			type: "object",
+			properties: {
+				priority: { type: "string" }, // position 0
+				age: { type: "integer", maximum: 100 }, // position 1
+				name: { type: "string" }, // position 2
+				settings: {
+					type: "object",
+					patternKey: "^[a-z]+$",
+				}, // position 3
+			},
+			required: ["priority", "name"],
+		};
+		setupTestDirectory(TEST_DIR);
+		const srcDir = join(TEST_DIR, "src-schemas");
+		const srcInputPath = join(srcDir, "input.json");
+		const srcDatasetPath = join(srcDir, "dataset-item.json");
+		setupTestDirectoryFiles({
+			testDirPath: TEST_DIR,
+			srcInputPath,
+			srcInput: complexSourceSchema,
+			srcDatasetPath,
+			srcDataset: {} as ObjectSchema,
+		});
+		writeJsonSchema(INPUT_SCHEMA_PATH, expectedOutputSchema);
+		expect(() =>
+			execSync(
+				[
+					`${EXEC_CMD} check`,
+					"-i input",
+					"-o json-schemas",
+					`--src-input ${srcInputPath}`,
+					`--src-dataset ${srcDatasetPath}`,
+				].join(" "),
+				{
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				},
+			),
+		).not.toThrow();
+	});
+
+	it("should pass when additional schemas also have fields that get filtered out", () => {
+		const baseInputSchema: ObjectSchema = {
+			title: "Base Input Schema",
+			type: "object",
+			properties: {
+				name: { type: "string", position: 1 },
+			},
+			required: ["name"],
+		};
+		const additionalSchemaWithInvalidFields: ObjectSchema = {
+			type: "object",
+			properties: {
+				email: {
+					type: "string",
+					position: 0,
+					format: "email", // Invalid field - will be removed
+				},
+				age: {
+					type: "integer",
+					position: 2,
+					customField: "invalid", // Invalid field - will be removed
+				},
+			},
+			required: ["email"],
+			invalidAdditionalField: "remove", // Invalid root field - will be removed
+		};
+		// Expected merged output schema (positions and invalid fields removed, properties ordered by position)
+		const expectedMergedSchema: ObjectSchema = {
+			title: "Base Input Schema",
+			type: "object",
+			properties: {
+				email: { type: "string" }, // position 0
+				name: { type: "string" }, // position 1
+				age: { type: "integer" }, // position 2
+			},
+			required: ["name", "email"],
+		};
+		setupTestDirectory(TEST_DIR);
+		const srcDir = join(TEST_DIR, "src-schemas");
+		const srcInputPath = join(srcDir, "input.json");
+		const srcDatasetPath = join(srcDir, "dataset-item.json");
+		const addDir = join(TEST_DIR, "add-schemas");
+		const addInputPath = join(addDir, "add-input.json");
+		setupTestDirectoryFiles({
+			testDirPath: TEST_DIR,
+			srcInputPath,
+			srcInput: baseInputSchema,
+			srcDatasetPath,
+			srcDataset: {} as ObjectSchema,
+			addDir,
+			addInputPath,
+			addInput: additionalSchemaWithInvalidFields,
+		});
+		writeJsonSchema(INPUT_SCHEMA_PATH, expectedMergedSchema);
+		expect(() =>
+			execSync(
+				[
+					`${EXEC_CMD} check`,
+					"-i input",
+					"-o json-schemas",
+					`--src-input ${srcInputPath}`,
+					`--src-dataset ${srcDatasetPath}`,
+					`--add-input ${addInputPath}`,
+				].join(" "),
+				{
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				},
+			),
+		).not.toThrow();
+	});
+
+	it("should fail when output schema doesn't match after filtering", () => {
+		const sourceSchemaWithInvalidFields: ObjectSchema = {
+			title: "Input Schema",
+			type: "object",
+			properties: {
+				name: {
+					type: "string",
+					format: "email", // This will be filtered out
+				},
+			},
+			required: ["name"],
+		};
+		// Incorrect output schema (includes the field that should have been filtered)
+		const incorrectOutputSchema: ObjectSchema = {
+			title: "Input Schema",
+			type: "object",
+			properties: {
+				name: {
+					type: "string",
+					format: "email", // This field should not be in the output
+				},
+			},
+			required: ["name"],
+		};
+		setupTestDirectory(TEST_DIR);
+		const srcDir = join(TEST_DIR, "src-schemas");
+		const srcInputPath = join(srcDir, "input.json");
+		const srcDatasetPath = join(srcDir, "dataset-item.json");
+		setupTestDirectoryFiles({
+			testDirPath: TEST_DIR,
+			srcInputPath,
+			srcInput: sourceSchemaWithInvalidFields,
+			srcDatasetPath,
+			srcDataset: {} as ObjectSchema,
+		});
+		writeJsonSchema(INPUT_SCHEMA_PATH, incorrectOutputSchema);
+		expect(() =>
+			execSync(
+				[
+					`${EXEC_CMD} check`,
+					"-i input",
+					"-o json-schemas",
+					`--src-input ${srcInputPath}`,
+					`--src-dataset ${srcDatasetPath}`,
+				].join(" "),
+				{
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				},
+			),
+		).toThrow();
+	});
+
+	it("should pass when descriptions differ but --ignore-descriptions is set", () => {
+		const sourceInputSchema: ObjectSchema = {
+			title: "Source Input Schema",
+			description: "Original description for input schema",
+			type: "object",
+			properties: {
+				name: {
+					type: "string",
+					description: "Name of the user",
+				},
+				age: {
+					type: "integer",
+					description: "Age in years",
+				},
+			},
+			required: ["name"],
+		};
+		// Output schema with different descriptions but same structure
+		const outputInputSchema: ObjectSchema = {
+			title: "Generated Input Schema", // Different title
+			description: "Auto-generated description for input schema", // Different description
+			type: "object",
+			properties: {
+				name: {
+					type: "string",
+					description: "User's full name", // Different description
+				},
+				age: {
+					type: "integer",
+					description: "User's age", // Different description
+				},
+			},
+			required: ["name"],
+		};
+		setupTestDirectory(TEST_DIR);
+		const srcDir = join(TEST_DIR, "src-schemas");
+		const srcInputPath = join(srcDir, "input.json");
+		const srcDatasetPath = join(srcDir, "dataset-item.json");
+		setupTestDirectoryFiles({
+			testDirPath: TEST_DIR,
+			srcInputPath,
+			srcInput: sourceInputSchema,
+			srcDatasetPath,
+			srcDataset: {} as ObjectSchema,
+		});
+		writeJsonSchema(INPUT_SCHEMA_PATH, outputInputSchema);
+		expect(() =>
+			execSync(
+				[
+					`${EXEC_CMD} check`,
+					"-i input",
+					"-o json-schemas",
+					`--src-input ${srcInputPath}`,
+					`--src-dataset ${srcDatasetPath}`,
+					"--ignore-descriptions",
+				].join(" "),
+				{
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				},
+			),
+		).not.toThrow();
+	});
+
+	it("should fail when descriptions differ and --ignore-descriptions is not set", () => {
+		const sourceInputSchema: ObjectSchema = {
+			title: "Source Input Schema",
+			description: "Original description",
+			type: "object",
+			properties: {
+				name: { type: "string" },
+			},
+			required: ["name"],
+		};
+		// Output schema with different title (same structure otherwise)
+		const outputInputSchema: ObjectSchema = {
+			title: "Different Title", // Different title should cause failure
+			description: "Original description",
+			type: "object",
+			properties: {
+				name: { type: "string" },
+			},
+			required: ["name"],
+		};
+		setupTestDirectory(TEST_DIR);
+		const srcDir = join(TEST_DIR, "src-schemas");
+		const srcInputPath = join(srcDir, "input.json");
+		const srcDatasetPath = join(srcDir, "dataset-item.json");
+		setupTestDirectoryFiles({
+			testDirPath: TEST_DIR,
+			srcInputPath,
+			srcInput: sourceInputSchema,
+			srcDatasetPath,
+			srcDataset: {} as ObjectSchema,
+		});
+		writeJsonSchema(INPUT_SCHEMA_PATH, outputInputSchema);
+		expect(() =>
+			execSync(
+				[
+					`${EXEC_CMD} check`,
+					"-i input",
+					"-o json-schemas",
+					`--src-input ${srcInputPath}`,
+					`--src-dataset ${srcDatasetPath}`,
+					// Note: --ignore-descriptions is NOT set
+				].join(" "),
+				{
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				},
+			),
+		).toThrow();
+	});
+
+	it("should pass with --ignore-descriptions when additional schema has different descriptions", () => {
+		const baseInputSchema: ObjectSchema = {
+			title: "Base Input Schema",
+			description: "Base description",
+			type: "object",
+			properties: {
+				name: {
+					type: "string",
+					description: "Base name description",
+				},
+			},
+			required: ["name"],
+		};
+		const additionalSchema: ObjectSchema = {
+			title: "Additional Schema", // Different title
+			description: "Additional description", // Different description
+			type: "object",
+			properties: {
+				age: {
+					type: "integer",
+					description: "Additional age description",
+				},
+			},
+			required: ["age"],
+		};
+		// Expected merged output with different descriptions
+		const expectedOutputSchema: ObjectSchema = {
+			title: "Generated Combined Schema", // Different from both source schemas
+			description: "Auto-generated combined description", // Different from both
+			type: "object",
+			properties: {
+				name: {
+					type: "string",
+					description: "Generated name description", // Different description
+				},
+				age: {
+					type: "integer",
+					description: "Generated age description", // Different description
+				},
+			},
+			required: ["name", "age"],
+		};
+		setupTestDirectory(TEST_DIR);
+		const srcDir = join(TEST_DIR, "src-schemas");
+		const srcInputPath = join(srcDir, "input.json");
+		const srcDatasetPath = join(srcDir, "dataset-item.json");
+		const addDir = join(TEST_DIR, "add-schemas");
+		const addInputPath = join(addDir, "add-input.json");
+		setupTestDirectoryFiles({
+			testDirPath: TEST_DIR,
+			srcInputPath,
+			srcInput: baseInputSchema,
+			srcDatasetPath,
+			srcDataset: {} as ObjectSchema,
+			addDir,
+			addInputPath,
+			addInput: additionalSchema,
+		});
+		writeJsonSchema(INPUT_SCHEMA_PATH, expectedOutputSchema);
+		expect(() =>
+			execSync(
+				[
+					`${EXEC_CMD} check`,
+					"-i input",
+					"-o json-schemas",
+					`--src-input ${srcInputPath}`,
+					`--src-dataset ${srcDatasetPath}`,
+					`--add-input ${addInputPath}`,
+					"--ignore-descriptions",
+				].join(" "),
+				{
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				},
+			),
+		).not.toThrow();
+	});
+
+	it("should pass with --ignore-descriptions when dataset schema has different descriptions", () => {
+		const sourceDatasetSchema: ObjectSchema = {
+			title: "Source Dataset Item Schema",
+			description: "Original dataset description",
+			type: "object",
+			properties: {
+				id: {
+					type: "string",
+					description: "Unique identifier",
+				},
+				value: {
+					type: "number",
+					description: "Numeric value",
+				},
+			},
+			required: ["id"],
+		};
+		// Output dataset schema with different descriptions
+		const outputDatasetSchema: ObjectSchema = {
+			title: "Generated Dataset Item Schema", // Different title
+			description: "Auto-generated dataset description", // Different description
+			type: "object",
+			properties: {
+				id: {
+					type: "string",
+					description: "Item identifier", // Different description
+				},
+				value: {
+					type: "number",
+					description: "Item value", // Different description
+				},
+			},
+			required: ["id"],
+		};
+		setupTestDirectory(TEST_DIR);
+		const srcDir = join(TEST_DIR, "src-schemas");
+		const srcInputPath = join(srcDir, "input.json");
+		const srcDatasetPath = join(srcDir, "dataset-item.json");
+		setupTestDirectoryFiles({
+			testDirPath: TEST_DIR,
+			srcInputPath,
+			srcInput: {} as ObjectSchema,
+			srcDatasetPath,
+			srcDataset: sourceDatasetSchema,
+		});
+		// Write a simple input schema to avoid validation issues
+		writeJsonSchema(INPUT_SCHEMA_PATH, {
+			title: "Simple Input",
+			type: "object",
+			properties: {},
+		});
+		writeSchemaToField(DATASET_SCHEMA_PATH, outputDatasetSchema, DATASET_SCHEMA_FIELD);
+		expect(() =>
+			execSync(
+				[
+					`${EXEC_CMD} check`,
+					"-i dataset",
+					"-o json-schemas",
+					`--src-input ${srcInputPath}`,
+					`--src-dataset ${srcDatasetPath}`,
+					"--ignore-descriptions",
+				].join(" "),
+				{
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				},
+			),
+		).not.toThrow();
+	});
+
+	it("should fail with --ignore-descriptions when there are structural differences beyond descriptions", () => {
+		const sourceInputSchema: ObjectSchema = {
+			title: "Source Input Schema",
+			description: "Original description",
+			type: "object",
+			properties: {
+				name: {
+					type: "string",
+					description: "Name of the user",
+				},
+				age: {
+					type: "integer",
+					description: "Age in years",
+				},
+			},
+			required: ["name"],
+		};
+		// Output schema with different structure (missing age property)
+		const outputInputSchema: ObjectSchema = {
+			title: "Different Title", // Different title (should be ignored)
+			description: "Different description", // Different description (should be ignored)
+			type: "object",
+			properties: {
+				name: {
+					type: "string",
+					description: "Different name description", // Different description (should be ignored)
+				},
+				// Missing age property - this is a structural difference that should cause failure
+			},
+			required: ["name"],
+		};
+		setupTestDirectory(TEST_DIR);
+		const srcDir = join(TEST_DIR, "src-schemas");
+		const srcInputPath = join(srcDir, "input.json");
+		const srcDatasetPath = join(srcDir, "dataset-item.json");
+		setupTestDirectoryFiles({
+			testDirPath: TEST_DIR,
+			srcInputPath,
+			srcInput: sourceInputSchema,
+			srcDatasetPath,
+			srcDataset: {} as ObjectSchema,
+		});
+		writeJsonSchema(INPUT_SCHEMA_PATH, outputInputSchema);
+		expect(() =>
+			execSync(
+				[
+					`${EXEC_CMD} check`,
+					"-i input",
+					"-o json-schemas",
+					`--src-input ${srcInputPath}`,
+					`--src-dataset ${srcDatasetPath}`,
+					"--ignore-descriptions", // Should still fail despite this flag
+				].join(" "),
+				{
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				},
+			),
+		).toThrow();
+	});
+
+	it("should pass when TypeScript files match the source schemas", () => {
+		const sourceInputSchema: ObjectSchema = {
+			title: "Input Schema",
+			description: "Schema for actor input",
+			type: "object",
+			properties: {
+				name: {
+					type: "string",
+					description: "User's name",
+				},
+				age: {
+					type: "integer",
+					description: "User's age",
+				},
+				isActive: {
+					type: "boolean",
+					description: "Whether user is active",
+				},
+			},
+			required: ["name"],
+			additionalProperties: false,
+		};
+		const sourceDatasetSchema: ObjectSchema = {
+			title: "Dataset Item Schema",
+			description: "Schema for dataset items",
+			type: "object",
+			properties: {
+				id: {
+					type: "string",
+					description: "Unique identifier",
+				},
+				value: {
+					type: "number",
+					description: "Numeric value",
+				},
+			},
+			required: ["id"],
+		};
+		setupTestDirectory(TEST_DIR);
+		const srcDir = join(TEST_DIR, "src-schemas");
+		const srcInputPath = join(srcDir, "input.json");
+		const srcDatasetPath = join(srcDir, "dataset-item.json");
+		const outputTsDir = join(TEST_DIR, "src", "generated");
+		setupTestDirectoryFiles({
+			testDirPath: TEST_DIR,
+			srcInputPath,
+			srcInput: sourceInputSchema,
+			srcDatasetPath,
+			srcDataset: sourceDatasetSchema,
+		});
+
+		// Generate the TypeScript files that should match the schemas
+		const inputTsContent = `/**
+ * This file was automatically generated by apify-schema-tools.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run apify-schema-tools' "sync" command to regenerate this file.
+ */
+
+/**
+ * Schema for actor input
+ */
+export interface Input {
+	/**
+	 * User's name
+	 */
+	name: string;
+	/**
+	 * User's age
+	 */
+	age?: number;
+	/**
+	 * Whether user is active
+	 */
+	isActive?: boolean;
+}
+`;
+		const datasetTsContent = `/**
+ * This file was automatically generated by apify-schema-tools.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run apify-schema-tools' "sync" command to regenerate this file.
+ */
+
+/**
+ * Schema for dataset items
+ */
+export interface DatasetItem {
+	/**
+	 * Unique identifier
+	 */
+	id: string;
+	/**
+	 * Numeric value
+	 */
+	value?: number;
+	[key: string]: unknown;
+}
+`;
+		writeFile(join(outputTsDir, "input.ts"), inputTsContent);
+		writeFile(join(outputTsDir, "dataset.ts"), datasetTsContent);
+
+		expect(() =>
+			execSync(
+				[
+					`${EXEC_CMD} check`,
+					"-i input dataset",
+					"-o ts-types",
+					`--src-input ${srcInputPath}`,
+					`--src-dataset ${srcDatasetPath}`,
+				].join(" "),
+				{
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				},
+			),
+		).not.toThrow();
+	});
+
+	it("should fail when TypeScript interface has different property types", () => {
+		const sourceInputSchema: ObjectSchema = {
+			title: "Input Schema",
+			type: "object",
+			properties: {
+				name: { type: "string" },
+				age: { type: "integer" },
+			},
+			required: ["name"],
+		};
+		setupTestDirectory(TEST_DIR);
+		const srcDir = join(TEST_DIR, "src-schemas");
+		const srcInputPath = join(srcDir, "input.json");
+		const srcDatasetPath = join(srcDir, "dataset-item.json");
+		const outputTsDir = join(TEST_DIR, "src", "generated");
+		setupTestDirectoryFiles({
+			testDirPath: TEST_DIR,
+			srcInputPath,
+			srcInput: sourceInputSchema,
+			srcDatasetPath,
+			srcDataset: {} as ObjectSchema,
+		});
+
+		// Generate TypeScript file with wrong type (age should be number, not string)
+		const incorrectInputTsContent = `/**
+ * This file was automatically generated by apify-schema-tools.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run apify-schema-tools' "sync" command to regenerate this file.
+ */
+
+export interface Input {
+	name: string;
+	age?: string;
+}
+`;
+		writeFile(join(outputTsDir, "input.ts"), incorrectInputTsContent);
+
+		expect(() =>
+			execSync(
+				[
+					`${EXEC_CMD} check`,
+					"-i input",
+					"-o ts-types",
+					`--src-input ${srcInputPath}`,
+					`--src-dataset ${srcDatasetPath}`,
+				].join(" "),
+				{
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				},
+			),
+		).toThrow();
+	});
+
+	it("should fail when TypeScript interface has different required properties", () => {
+		const sourceInputSchema: ObjectSchema = {
+			title: "Input Schema",
+			type: "object",
+			properties: {
+				name: { type: "string" },
+				age: { type: "integer" },
+			},
+			required: ["name", "age"], // Both required
+		};
+		setupTestDirectory(TEST_DIR);
+		const srcDir = join(TEST_DIR, "src-schemas");
+		const srcInputPath = join(srcDir, "input.json");
+		const srcDatasetPath = join(srcDir, "dataset-item.json");
+		const outputTsDir = join(TEST_DIR, "src", "generated");
+		setupTestDirectoryFiles({
+			testDirPath: TEST_DIR,
+			srcInputPath,
+			srcInput: sourceInputSchema,
+			srcDatasetPath,
+			srcDataset: {} as ObjectSchema,
+		});
+
+		// Generate TypeScript file where age is optional but should be required
+		const incorrectInputTsContent = `/**
+ * This file was automatically generated by apify-schema-tools.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run apify-schema-tools' "sync" command to regenerate this file.
+ */
+
+export interface Input {
+	name: string;
+	age?: number;
+}
+`;
+		writeFile(join(outputTsDir, "input.ts"), incorrectInputTsContent);
+
+		expect(() =>
+			execSync(
+				[
+					`${EXEC_CMD} check`,
+					"-i input",
+					"-o ts-types",
+					`--src-input ${srcInputPath}`,
+					`--src-dataset ${srcDatasetPath}`,
+				].join(" "),
+				{
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				},
+			),
+		).toThrow();
+	});
+
+	it("should fail when TypeScript interface has missing properties", () => {
+		const sourceInputSchema: ObjectSchema = {
+			title: "Input Schema",
+			type: "object",
+			properties: {
+				name: { type: "string" },
+				age: { type: "integer" },
+				email: { type: "string" },
+			},
+			required: ["name"],
+		};
+		setupTestDirectory(TEST_DIR);
+		const srcDir = join(TEST_DIR, "src-schemas");
+		const srcInputPath = join(srcDir, "input.json");
+		const srcDatasetPath = join(srcDir, "dataset-item.json");
+		const outputTsDir = join(TEST_DIR, "src", "generated");
+		setupTestDirectoryFiles({
+			testDirPath: TEST_DIR,
+			srcInputPath,
+			srcInput: sourceInputSchema,
+			srcDatasetPath,
+			srcDataset: {} as ObjectSchema,
+		});
+
+		// Generate TypeScript file missing the email property
+		const incompleteInputTsContent = `/**
+ * This file was automatically generated by apify-schema-tools.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run apify-schema-tools' "sync" command to regenerate this file.
+ */
+
+export interface Input {
+	name: string;
+	age?: number;
+}
+`;
+		writeFile(join(outputTsDir, "input.ts"), incompleteInputTsContent);
+
+		expect(() =>
+			execSync(
+				[
+					`${EXEC_CMD} check`,
+					"-i input",
+					"-o ts-types",
+					`--src-input ${srcInputPath}`,
+					`--src-dataset ${srcDatasetPath}`,
+				].join(" "),
+				{
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				},
+			),
+		).toThrow();
+	});
+
+	it("should fail when additionalProperties differ", () => {
+		const sourceInputSchema: ObjectSchema = {
+			title: "Input Schema",
+			type: "object",
+			properties: {
+				name: { type: "string" },
+				age: { type: "integer" },
+			},
+			required: ["name"],
+			additionalProperties: false, // Original schema does not allow additional properties
+		};
+		setupTestDirectory(TEST_DIR);
+		const srcDir = join(TEST_DIR, "src-schemas");
+		const srcInputPath = join(srcDir, "input.json");
+		const srcDatasetPath = join(srcDir, "dataset-item.json");
+		const outputTsDir = join(TEST_DIR, "src", "generated");
+		setupTestDirectoryFiles({
+			testDirPath: TEST_DIR,
+			srcInputPath,
+			srcInput: sourceInputSchema,
+			srcDatasetPath,
+			srcDataset: {} as ObjectSchema,
+		});
+
+		// Generate TypeScript file that allows additional properties
+		const inputTsContentWithAdditionalProperties = `/**
+ * This file was automatically generated by apify-schema-tools.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run apify-schema-tools' "sync" command to regenerate this file.
+ */
+
+export interface Input {
+	name: string;
+	age?: number;
+	[key: string]: unknown;
+}
+`;
+		writeFile(join(outputTsDir, "input.ts"), inputTsContentWithAdditionalProperties);
+		let error: Error | null = null;
+		let stderr = "";
+		try {
+			execSync(
+				[
+					`${EXEC_CMD} check`,
+					"-i input",
+					"-o ts-types",
+					`--src-input ${srcInputPath}`,
+					`--src-dataset ${srcDatasetPath}`,
+				].join(" "),
+				{
+					cwd: TEST_DIR,
+					stdio: ["ignore", "pipe", "pipe"],
+					encoding: "utf8",
+				},
+			);
+			// biome-ignore lint/suspicious/noExplicitAny: for testing purposes
+		} catch (e: any) {
+			error = e;
+			stderr = e.stderr ?? "";
+		}
+		expect(error).toBeTruthy();
+		expect(stderr).toMatch(ADDITIONAL_PROPERTIES_ERROR_PATTERN);
+	});
+
+	it("should pass when TypeScript descriptions differ but --ignore-descriptions is set", () => {
+		const sourceInputSchema: ObjectSchema = {
+			title: "Input Schema",
+			description: "Original input description",
+			type: "object",
+			properties: {
+				name: {
+					type: "string",
+					description: "Original name description",
+				},
+				age: {
+					type: "integer",
+					description: "Original age description",
+				},
+			},
+			required: ["name"],
+			additionalProperties: false,
+		};
+		setupTestDirectory(TEST_DIR);
+		const srcDir = join(TEST_DIR, "src-schemas");
+		const srcInputPath = join(srcDir, "input.json");
+		const srcDatasetPath = join(srcDir, "dataset-item.json");
+		const outputTsDir = join(TEST_DIR, "src", "generated");
+		setupTestDirectoryFiles({
+			testDirPath: TEST_DIR,
+			srcInputPath,
+			srcInput: sourceInputSchema,
+			srcDatasetPath,
+			srcDataset: {} as ObjectSchema,
+		});
+
+		// Generate TypeScript file with different descriptions
+		const inputTsContentWithDifferentDescriptions = `/**
+ * This file was automatically generated by apify-schema-tools.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run apify-schema-tools' "sync" command to regenerate this file.
+ */
+
+/**
+ * Different input description
+ */
+export interface Input {
+	/**
+	 * Different name description
+	 */
+	name: string;
+	/**
+	 * Different age description
+	 */
+	age?: number;
+}
+`;
+		writeFile(join(outputTsDir, "input.ts"), inputTsContentWithDifferentDescriptions);
+
+		expect(() =>
+			execSync(
+				[
+					`${EXEC_CMD} check`,
+					"-i input",
+					"-o ts-types",
+					`--src-input ${srcInputPath}`,
+					`--src-dataset ${srcDatasetPath}`,
+					"--ignore-descriptions",
+				].join(" "),
+				{
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				},
+			),
+		).not.toThrow();
+	});
+
+	it("should fail when TypeScript descriptions differ and --ignore-descriptions is not set", () => {
+		const sourceInputSchema: ObjectSchema = {
+			title: "Input Schema",
+			description: "Original input description",
+			type: "object",
+			properties: {
+				name: {
+					type: "string",
+					description: "Original name description",
+				},
+			},
+			required: ["name"],
+		};
+		setupTestDirectory(TEST_DIR);
+		const srcDir = join(TEST_DIR, "src-schemas");
+		const srcInputPath = join(srcDir, "input.json");
+		const srcDatasetPath = join(srcDir, "dataset-item.json");
+		const outputTsDir = join(TEST_DIR, "src", "generated");
+		setupTestDirectoryFiles({
+			testDirPath: TEST_DIR,
+			srcInputPath,
+			srcInput: sourceInputSchema,
+			srcDatasetPath,
+			srcDataset: {} as ObjectSchema,
+		});
+
+		// Generate TypeScript file with different descriptions
+		const inputTsContentWithDifferentDescriptions = `/**
+ * This file was automatically generated by apify-schema-tools.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run apify-schema-tools' "sync" command to regenerate this file.
+ */
+
+/**
+ * Different input description
+ */
+export interface Input {
+	/**
+	 * Different name description
+	 */
+	name: string;
+}
+`;
+		writeFile(join(outputTsDir, "input.ts"), inputTsContentWithDifferentDescriptions);
+
+		expect(() =>
+			execSync(
+				[
+					`${EXEC_CMD} check`,
+					"-i input",
+					"-o ts-types",
+					`--src-input ${srcInputPath}`,
+					`--src-dataset ${srcDatasetPath}`,
+					// Note: --ignore-descriptions is NOT set
+				].join(" "),
+				{
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				},
+			),
+		).toThrow();
+	});
+
+	it("should pass when TypeScript files match schemas with additional merged schemas", () => {
+		const baseInputSchema: ObjectSchema = {
+			title: "Base Input Schema",
+			type: "object",
+			properties: {
+				name: { type: "string" },
+			},
+			required: ["name"],
+			additionalProperties: false,
+		};
+		const additionalSchema: ObjectSchema = {
+			type: "object",
+			properties: {
+				age: { type: "integer" },
+				email: { type: "string" },
+			},
+			required: ["email"],
+		};
+		setupTestDirectory(TEST_DIR);
+		const srcDir = join(TEST_DIR, "src-schemas");
+		const srcInputPath = join(srcDir, "input.json");
+		const srcDatasetPath = join(srcDir, "dataset-item.json");
+		const outputTsDir = join(TEST_DIR, "src", "generated");
+		const addDir = join(TEST_DIR, "add-schemas");
+		const addInputPath = join(addDir, "add-input.json");
+		setupTestDirectoryFiles({
+			testDirPath: TEST_DIR,
+			srcInputPath,
+			srcInput: baseInputSchema,
+			srcDatasetPath,
+			srcDataset: {} as ObjectSchema,
+			addDir,
+			addInputPath,
+			addInput: additionalSchema,
+		});
+
+		// Generate TypeScript file that matches the merged schema
+		const mergedInputTsContent = `/**
+ * This file was automatically generated by apify-schema-tools.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run apify-schema-tools' "sync" command to regenerate this file.
+ */
+
+/**
+ * Base Input Schema
+ */
+export interface Input {
+	name: string;
+	age?: number;
+	email: string;
+}
+`;
+		writeFile(join(outputTsDir, "input.ts"), mergedInputTsContent);
+
+		expect(() =>
+			execSync(
+				[
+					`${EXEC_CMD} check`,
+					"-i input",
+					"-o ts-types",
+					`--src-input ${srcInputPath}`,
+					`--src-dataset ${srcDatasetPath}`,
+					`--add-input ${addInputPath}`,
+				].join(" "),
+				{
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				},
+			),
+		).not.toThrow();
+	});
+
+	it("should handle complex nested object structures in TypeScript files", () => {
+		const sourceInputSchema: ObjectSchema = {
+			title: "Complex Input Schema",
+			type: "object",
+			properties: {
+				user: {
+					type: "object",
+					properties: {
+						name: { type: "string" },
+						contacts: {
+							type: "object",
+							properties: {
+								email: { type: "string" },
+								phone: { type: "string" },
+							},
+							required: ["email"],
+							additionalProperties: { type: "boolean" },
+						},
+					},
+					required: ["name"],
+				},
+				settings: {
+					type: "array",
+					items: {
+						type: "object",
+						properties: {
+							key: { type: "string" },
+							value: { type: "string" },
+						},
+						required: ["key"],
+						additionalProperties: true,
+					},
+				},
+			},
+			required: ["user"],
+			additionalProperties: false,
+		};
+		setupTestDirectory(TEST_DIR);
+		const srcDir = join(TEST_DIR, "src-schemas");
+		const srcInputPath = join(srcDir, "input.json");
+		const srcDatasetPath = join(srcDir, "dataset-item.json");
+		const outputTsDir = join(TEST_DIR, "src", "generated");
+		setupTestDirectoryFiles({
+			testDirPath: TEST_DIR,
+			srcInputPath,
+			srcInput: sourceInputSchema,
+			srcDatasetPath,
+			srcDataset: {} as ObjectSchema,
+		});
+
+		// Generate TypeScript file with correct nested structure
+		const complexInputTsContent = `/**
+ * This file was automatically generated by apify-schema-tools.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run apify-schema-tools' "sync" command to regenerate this file.
+ */
+
+/**
+ * Complex Input Schema
+ */
+export interface Input {
+	user: {
+		name: string;
+		contacts?: {
+			email: string;
+			phone?: string;
+			[key: string]: boolean;
+		};
+		[key: string]: unknown;
+	};
+	settings?: {
+		key: string;
+		value?: string;
+		[key: string]: unknown;
+	}[];
+}
+`;
+		writeFile(join(outputTsDir, "input.ts"), complexInputTsContent);
+
+		expect(() =>
+			execSync(
+				[
+					`${EXEC_CMD} check`,
+					"-i input",
+					"-o ts-types",
+					`--src-input ${srcInputPath}`,
+					`--src-dataset ${srcDatasetPath}`,
+				].join(" "),
+				{
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				},
+			),
+		).not.toThrow();
+	});
+
+	it("should handle enum types in TypeScript files", () => {
+		const sourceInputSchema: ObjectSchema = {
+			title: "Input Schema with Enums",
+			type: "object",
+			properties: {
+				status: {
+					type: "string",
+					enum: ["active", "inactive", "pending"],
+				},
+				priorities: {
+					type: "array",
+					items: {
+						type: "string",
+						enum: ["high", "medium", "low"],
+					},
+				},
+			},
+			required: ["status"],
+			additionalProperties: false,
+		};
+		setupTestDirectory(TEST_DIR);
+		const srcDir = join(TEST_DIR, "src-schemas");
+		const srcInputPath = join(srcDir, "input.json");
+		const srcDatasetPath = join(srcDir, "dataset-item.json");
+		const outputTsDir = join(TEST_DIR, "src", "generated");
+		setupTestDirectoryFiles({
+			testDirPath: TEST_DIR,
+			srcInputPath,
+			srcInput: sourceInputSchema,
+			srcDatasetPath,
+			srcDataset: {} as ObjectSchema,
+		});
+
+		// Generate TypeScript file with correct enum types
+		const enumInputTsContent = `/**
+ * This file was automatically generated by apify-schema-tools.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run apify-schema-tools' "sync" command to regenerate this file.
+ */
+
+/**
+ * Input Schema with Enums
+ */
+export interface Input {
+	status: "active" | "inactive" | "pending";
+	priorities?: ("high" | "medium" | "low")[];
+}
+`;
+		writeFile(join(outputTsDir, "input.ts"), enumInputTsContent);
+
+		expect(() =>
+			execSync(
+				[
+					`${EXEC_CMD} check`,
+					"-i input",
+					"-o ts-types",
+					`--src-input ${srcInputPath}`,
+					`--src-dataset ${srcDatasetPath}`,
+				].join(" "),
+				{
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				},
+			),
+		).not.toThrow();
+	});
+
+	it("should check both input and dataset TypeScript files when both are specified", () => {
+		const sourceInputSchema: ObjectSchema = {
+			title: "Input Schema",
+			type: "object",
+			properties: {
+				inputField: { type: "string" },
+			},
+			required: ["inputField"],
+			additionalProperties: false,
+		};
+		const sourceDatasetSchema: ObjectSchema = {
+			title: "Dataset Item Schema",
+			type: "object",
+			properties: {
+				dataField: { type: "number" },
+			},
+			required: ["dataField"],
+		};
+		setupTestDirectory(TEST_DIR);
+		const srcDir = join(TEST_DIR, "src-schemas");
+		const srcInputPath = join(srcDir, "input.json");
+		const srcDatasetPath = join(srcDir, "dataset-item.json");
+		const outputTsDir = join(TEST_DIR, "src", "generated");
+		setupTestDirectoryFiles({
+			testDirPath: TEST_DIR,
+			srcInputPath,
+			srcInput: sourceInputSchema,
+			srcDatasetPath,
+			srcDataset: sourceDatasetSchema,
+		});
+
+		// Generate both TypeScript files correctly
+		const inputTsContent = `/**
+ * This file was automatically generated by apify-schema-tools.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run apify-schema-tools' "sync" command to regenerate this file.
+ */
+
+/**
+ * Input Schema
+ */
+export interface Input {
+	inputField: string;
+}
+`;
+		const datasetTsContent = `/**
+ * This file was automatically generated by apify-schema-tools.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run apify-schema-tools' "sync" command to regenerate this file.
+ */
+
+/**
+ * Dataset Item Schema
+ */
+export interface DatasetItem {
+	dataField: number;
+	[key: string]: unknown;
+}
+`;
+		writeFile(join(outputTsDir, "input.ts"), inputTsContent);
+		writeFile(join(outputTsDir, "dataset.ts"), datasetTsContent);
+
+		expect(() =>
+			execSync(
+				[
+					`${EXEC_CMD} check`,
+					"-i input dataset",
+					"-o ts-types",
+					`--src-input ${srcInputPath}`,
+					`--src-dataset ${srcDatasetPath}`,
+				].join(" "),
+				{
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				},
+			),
+		).not.toThrow();
+	});
+});