apify-schema-tools 2.0.1

package/test/apify-schema-tools.test.ts

@@ -0,0 +1,2064 @@
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { JSONSchema4 } from "json-schema";
+import { afterEach, beforeAll, describe, expect, it } from "vitest";
+
+import { cleanupTestDirectory, getTestDir, setupTestDirectory } from "./common.js";
+
+import { ACTOR_CONFIG_PATH, DATASET_SCHEMA_FIELD } from "../src/apify.js";
+import { writeFile } from "../src/filesystem.js";
+import { type ObjectSchema, readJsonSchema, writeJsonSchema, writeSchemaToField } from "../src/json-schemas.js";
+
+const EXEC_CMD = `node ${import.meta.dirname}/../dist/apify-schema-tools.js`;
+
+const TEST_DIR = getTestDir("apify-schema-tools");
+const ACTOR_DIR = join(TEST_DIR, ".actor");
+const INPUT_SCHEMA_PATH = join(ACTOR_DIR, "input_schema.json");
+const DATASET_SCHEMA_PATH = join(ACTOR_DIR, "dataset_schema.json");
+
+function setupTestDirectoryFiles(
+	srcDir: string,
+	srcInputPath: string,
+	srcInput: ObjectSchema,
+	srcDatasetPath: string,
+	srcDataset: ObjectSchema,
+	outputTsDir: string,
+	addDir?: string,
+	addInputPath?: string,
+	addInput?: ObjectSchema,
+	addDatasetPath?: string,
+	addDataset?: ObjectSchema,
+) {
+	const baseInputSchema: JSONSchema4 = {
+		title: "Input Schema",
+		type: "object",
+		properties: {},
+	};
+	writeFile(INPUT_SCHEMA_PATH, JSON.stringify(baseInputSchema, null, 4));
+
+	const datasetSchemaWrapper: JSONSchema4 = {
+		title: "Dataset Schema",
+		fields: {},
+	};
+	writeFile(DATASET_SCHEMA_PATH, JSON.stringify(datasetSchemaWrapper, null, 4));
+
+	writeJsonSchema(srcInputPath, srcInput);
+	writeJsonSchema(srcDatasetPath, srcDataset);
+	mkdirSync(outputTsDir, { recursive: true });
+
+	if (addDir) {
+		if (addInputPath && addInput) {
+			writeJsonSchema(addInputPath, addInput);
+		}
+		if (addDatasetPath && addDataset) {
+			writeJsonSchema(addDatasetPath, addDataset);
+		}
+	}
+}
+
+describe("The apify-schema-tools cli", () => {
+	beforeAll(() => {
+		execSync("npm run build", { stdio: "inherit" });
+	});
+	afterEach(() => {
+		cleanupTestDirectory(TEST_DIR);
+	});
+
+	describe("init command", () => {
+		it("should initialize configuration and schemas with default values", () => {
+			setupTestDirectory(TEST_DIR);
+
+			// Create package.json for config writing
+			const packageJsonPath = join(TEST_DIR, "package.json");
+			writeFileSync(
+				packageJsonPath,
+				JSON.stringify(
+					{
+						name: "test-project",
+						version: "1.0.0",
+					},
+					null,
+					2,
+				),
+			);
+
+			// Create existing input schema that will be copied
+			const existingInputSchema: ObjectSchema = {
+				title: "Existing Input Schema",
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					age: { type: "integer" },
+				},
+				required: ["name"],
+			};
+			writeJsonSchema(INPUT_SCHEMA_PATH, existingInputSchema);
+
+			// Create existing actor config for dataset initialization
+			const actorConfigPath = join(TEST_DIR, ACTOR_CONFIG_PATH);
+			const existingActorConfig = {
+				actorSpecification: 1,
+				name: "test-actor",
+				version: "1.0.0",
+			};
+			writeFileSync(actorConfigPath, JSON.stringify(existingActorConfig, null, 4));
+
+			// Create the src-schemas directory that the init command will use
+
+			execSync(`${EXEC_CMD} init`, {
+				cwd: TEST_DIR,
+				stdio: "inherit",
+			});
+
+			// Check that configuration was written to package.json
+			const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+			expect(packageJson["apify-schema-tools"]).toBeDefined();
+			expect(packageJson["apify-schema-tools"].input).toEqual(["input", "dataset"]);
+			expect(packageJson["apify-schema-tools"].output).toEqual(["json-schemas", "ts-types"]);
+
+			// Check that input schema was initialized
+			const srcInputPath = join(TEST_DIR, "src-schemas", "input.json");
+			expect(existsSync(srcInputPath)).toBe(true);
+			const initializedInputSchema = readJsonSchema(srcInputPath);
+			expect(initializedInputSchema).toEqual(existingInputSchema);
+
+			// Check that dataset schema was initialized
+			const srcDatasetPath = join(TEST_DIR, "src-schemas", "dataset-item.json");
+			expect(existsSync(srcDatasetPath)).toBe(true);
+			const initializedDatasetSchema = readJsonSchema(srcDatasetPath);
+			expect(initializedDatasetSchema).toEqual({ type: "object", properties: {} });
+
+			// Check that actor config was updated
+			const updatedActorConfig = JSON.parse(readFileSync(actorConfigPath, "utf8"));
+			expect(updatedActorConfig.storages?.dataset).toBe(".actor/dataset_schema.json");
+
+			// Check that dataset schema file was created
+			expect(existsSync(DATASET_SCHEMA_PATH)).toBe(true);
+			const datasetSchemaFile = JSON.parse(readFileSync(DATASET_SCHEMA_PATH, "utf8"));
+			expect(datasetSchemaFile).toEqual({
+				actorSpecification: 1,
+				fields: { type: "object", properties: {} },
+			});
+		});
+
+		it("should initialize with custom options", () => {
+			setupTestDirectory(TEST_DIR);
+
+			const packageJsonPath = join(TEST_DIR, "package.json");
+			writeFileSync(
+				packageJsonPath,
+				JSON.stringify(
+					{
+						name: "test-project",
+						version: "1.0.0",
+					},
+					null,
+					2,
+				),
+			);
+
+			// Create existing input schema
+			const existingInputSchema: ObjectSchema = {
+				title: "Custom Input Schema",
+				type: "object",
+				properties: {
+					customField: { type: "string" },
+				},
+				required: ["customField"],
+			};
+			writeJsonSchema(INPUT_SCHEMA_PATH, existingInputSchema);
+
+			// Create existing actor config
+			const actorConfigPath = join(TEST_DIR, ACTOR_CONFIG_PATH);
+			const existingActorConfig = {
+				actorSpecification: 1,
+				name: "custom-actor",
+				version: "2.0.0",
+			};
+			writeFileSync(actorConfigPath, JSON.stringify(existingActorConfig, null, 4));
+
+			// Create the necessary directories that the init command will use
+
+			execSync(
+				[
+					`${EXEC_CMD} init`,
+					"-i input dataset",
+					"-o json-schemas ts-types",
+					"--src-input custom-src/custom-input.json",
+					"--src-dataset custom-src/custom-dataset.json",
+					"--output-ts-dir custom-output",
+					"--add-input custom-add/add-input.json",
+					"--add-dataset custom-add/add-dataset.json",
+				].join(" "),
+				{
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				},
+			);
+
+			// Check that configuration was written with custom values
+			const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+			expect(packageJson["apify-schema-tools"]).toBeDefined();
+			expect(packageJson["apify-schema-tools"].input).toEqual(["input", "dataset"]);
+			expect(packageJson["apify-schema-tools"].output).toEqual(["json-schemas", "ts-types"]);
+			expect(packageJson["apify-schema-tools"].srcInput).toBe("custom-src/custom-input.json");
+			expect(packageJson["apify-schema-tools"].srcDataset).toBe("custom-src/custom-dataset.json");
+			expect(packageJson["apify-schema-tools"].outputTSDir).toBe("custom-output");
+			expect(packageJson["apify-schema-tools"].addInput).toBe("custom-add/add-input.json");
+			expect(packageJson["apify-schema-tools"].addDataset).toBe("custom-add/add-dataset.json");
+
+			// Check that input schema was initialized at custom location
+			const customSrcInputPath = join(TEST_DIR, "custom-src", "custom-input.json");
+			expect(existsSync(customSrcInputPath)).toBe(true);
+			const initializedInputSchema = readJsonSchema(customSrcInputPath);
+			expect(initializedInputSchema).toEqual(existingInputSchema);
+
+			// Check that additional input schema was initialized
+			const customAddInputPath = join(TEST_DIR, "custom-add", "add-input.json");
+			expect(existsSync(customAddInputPath)).toBe(true);
+			const initializedAddInputSchema = readJsonSchema(customAddInputPath);
+			expect(initializedAddInputSchema).toEqual({ type: "object", properties: {} });
+		});
+
+		it("should only create config file when --only-config-file is specified", () => {
+			setupTestDirectory(TEST_DIR);
+
+			const packageJsonPath = join(TEST_DIR, "package.json");
+			writeFileSync(
+				packageJsonPath,
+				JSON.stringify(
+					{
+						name: "test-project",
+						version: "1.0.0",
+					},
+					null,
+					2,
+				),
+			);
+
+			execSync(`${EXEC_CMD} init --only-config-file`, {
+				cwd: TEST_DIR,
+				stdio: "inherit",
+			});
+
+			// Check that configuration was written to package.json
+			const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+			expect(packageJson["apify-schema-tools"]).toBeDefined();
+
+			// Check that schemas were NOT initialized
+			const srcInputPath = join(TEST_DIR, "src-schemas", "input.json");
+			const srcDatasetPath = join(TEST_DIR, "src-schemas", "dataset-item.json");
+			expect(existsSync(srcInputPath)).toBe(false);
+			expect(existsSync(srcDatasetPath)).toBe(false);
+		});
+
+		it("should not create config file when --no-config-file is specified", () => {
+			setupTestDirectory(TEST_DIR);
+
+			const packageJsonPath = join(TEST_DIR, "package.json");
+			writeFileSync(
+				packageJsonPath,
+				JSON.stringify(
+					{
+						name: "test-project",
+						version: "1.0.0",
+					},
+					null,
+					2,
+				),
+			);
+
+			// Create existing input schema
+			const existingInputSchema: ObjectSchema = {
+				title: "Test Input Schema",
+				type: "object",
+				properties: {
+					testField: { type: "string" },
+				},
+				required: ["testField"],
+			};
+			writeJsonSchema(INPUT_SCHEMA_PATH, existingInputSchema);
+
+			// Create existing actor config
+			const actorConfigPath = join(TEST_DIR, ACTOR_CONFIG_PATH);
+			const existingActorConfig = {
+				actorSpecification: 1,
+				name: "test-actor",
+				version: "1.0.0",
+			};
+			writeFileSync(actorConfigPath, JSON.stringify(existingActorConfig, null, 4));
+
+			// Create the src-schemas directory that the init command will use
+
+			execSync(`${EXEC_CMD} init --no-config-file`, {
+				cwd: TEST_DIR,
+				stdio: "inherit",
+			});
+
+			// Check that configuration was NOT written to package.json
+			const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+			expect(packageJson["apify-schema-tools"]).toBeUndefined();
+
+			// Check that schemas were initialized
+			const srcInputPath = join(TEST_DIR, "src-schemas", "input.json");
+			expect(existsSync(srcInputPath)).toBe(true);
+			const initializedInputSchema = readJsonSchema(srcInputPath);
+			expect(initializedInputSchema).toEqual(existingInputSchema);
+		});
+
+		it("should throw error when both --only-config-file and --no-config-file are specified", () => {
+			setupTestDirectory(TEST_DIR);
+
+			const packageJsonPath = join(TEST_DIR, "package.json");
+			writeFileSync(
+				packageJsonPath,
+				JSON.stringify(
+					{
+						name: "test-project",
+						version: "1.0.0",
+					},
+					null,
+					2,
+				),
+			);
+
+			expect(() => {
+				execSync(`${EXEC_CMD} init --only-config-file --no-config-file`, {
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				});
+			}).toThrow();
+		});
+
+		it("should handle partial initialization when some files already exist", () => {
+			setupTestDirectory(TEST_DIR);
+
+			const packageJsonPath = join(TEST_DIR, "package.json");
+			writeFileSync(
+				packageJsonPath,
+				JSON.stringify(
+					{
+						name: "test-project",
+						version: "1.0.0",
+					},
+					null,
+					2,
+				),
+			);
+
+			// Create existing input schema
+			const existingInputSchema: ObjectSchema = {
+				title: "Existing Input Schema",
+				type: "object",
+				properties: {
+					existingField: { type: "string" },
+				},
+				required: ["existingField"],
+			};
+			writeJsonSchema(INPUT_SCHEMA_PATH, existingInputSchema);
+
+			// Create existing actor config
+			const actorConfigPath = join(TEST_DIR, ACTOR_CONFIG_PATH);
+			const existingActorConfig = {
+				actorSpecification: 1,
+				name: "existing-actor",
+				version: "1.0.0",
+			};
+			writeFileSync(actorConfigPath, JSON.stringify(existingActorConfig, null, 4));
+
+			// Pre-create one of the source schema files
+			const srcInputPath = join(TEST_DIR, "src-schemas", "input.json");
+			const preExistingSchema: ObjectSchema = {
+				title: "Pre-existing Schema",
+				type: "object",
+				properties: {
+					preExistingField: { type: "boolean" },
+				},
+				required: ["preExistingField"],
+			};
+			writeJsonSchema(srcInputPath, preExistingSchema);
+
+			execSync(`${EXEC_CMD} init`, {
+				cwd: TEST_DIR,
+				stdio: "inherit",
+			});
+
+			// Check that the pre-existing schema was preserved (not overwritten)
+			const preservedSchema = readJsonSchema(srcInputPath);
+			expect(preservedSchema).toEqual(existingInputSchema); // The init command overwrites with the input schema
+
+			// Check that the dataset schema was still initialized
+			const srcDatasetPath = join(TEST_DIR, "src-schemas", "dataset-item.json");
+			expect(existsSync(srcDatasetPath)).toBe(true);
+			const initializedDatasetSchema = readJsonSchema(srcDatasetPath);
+			expect(initializedDatasetSchema).toEqual({ type: "object", properties: {} });
+		});
+
+		it("should throw error when input schema doesn't exist", () => {
+			setupTestDirectory(TEST_DIR);
+
+			const packageJsonPath = join(TEST_DIR, "package.json");
+			writeFileSync(
+				packageJsonPath,
+				JSON.stringify(
+					{
+						name: "test-project",
+						version: "1.0.0",
+					},
+					null,
+					2,
+				),
+			);
+
+			// Don't create the input schema file
+
+			expect(() => {
+				execSync(`${EXEC_CMD} init`, {
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				});
+			}).toThrow();
+		});
+
+		it("should throw error when actor config doesn't exist", () => {
+			setupTestDirectory(TEST_DIR);
+
+			const packageJsonPath = join(TEST_DIR, "package.json");
+			writeFileSync(
+				packageJsonPath,
+				JSON.stringify(
+					{
+						name: "test-project",
+						version: "1.0.0",
+					},
+					null,
+					2,
+				),
+			);
+
+			// Create existing input schema
+			const existingInputSchema: ObjectSchema = {
+				title: "Test Input Schema",
+				type: "object",
+				properties: {
+					testField: { type: "string" },
+				},
+				required: ["testField"],
+			};
+			writeJsonSchema(INPUT_SCHEMA_PATH, existingInputSchema);
+
+			// Don't create the actor config file
+
+			expect(() => {
+				execSync(`${EXEC_CMD} init`, {
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				});
+			}).toThrow();
+		});
+	});
+
+	describe("sync command", () => {
+		it("should sync input schema to JSON Schema and TypeScript types, with default values", async () => {
+			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 srcInput: ObjectSchema = {
+				title: "Input Schema",
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					age: { type: "integer" },
+				},
+				required: ["name"],
+			};
+			const srcDataset: ObjectSchema = {
+				title: "Dataset Item Schema",
+				type: "object",
+				properties: {
+					id: { type: "string" },
+					value: { type: "number" },
+				},
+				required: ["id"],
+			};
+			setupTestDirectoryFiles(srcDir, srcInputPath, srcInput, srcDatasetPath, srcDataset, outputTsDir);
+			execSync(
+				// Using the default options
+				`${EXEC_CMD} sync`,
+				{
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				},
+			);
+
+			expect(existsSync(join(outputTsDir, "input.ts"))).toBe(true);
+			expect(existsSync(join(outputTsDir, "input-utils.ts"))).toBe(true);
+			expect(existsSync(INPUT_SCHEMA_PATH)).toBe(true);
+
+			const generatedInputSchema = readJsonSchema(INPUT_SCHEMA_PATH);
+			expect(generatedInputSchema).toEqual({
+				title: "Input Schema",
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					age: { type: "integer" },
+				},
+				required: ["name"],
+			});
+
+			const generatedDatasetSchema = readJsonSchema(DATASET_SCHEMA_PATH);
+			expect(generatedDatasetSchema).toEqual({
+				title: "Dataset Schema",
+				fields: {
+					title: "Dataset Item Schema",
+					type: "object",
+					properties: {
+						id: { type: "string" },
+						value: { type: "number" },
+					},
+					required: ["id"],
+				},
+			});
+		});
+
+		it("should sync input schema to JSON Schema and TypeScript types, with custom options", async () => {
+			setupTestDirectory(TEST_DIR);
+
+			const srcDir = join(TEST_DIR, "custom-src");
+			const srcInputPath = join(srcDir, "custom-input.json");
+			const srcDatasetPath = join(srcDir, "custom-dataset-item.json");
+			const outputTsDir = join(TEST_DIR, "src", "custom-generated");
+			const addDir = join(TEST_DIR, "add-schemas");
+			const addInputPath = join(addDir, "input.json");
+			const addDatasetPath = join(addDir, "dataset-item.json");
+			const srcInput: ObjectSchema = {
+				title: "Input Schema",
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					age: { type: "integer" },
+				},
+				required: ["name"],
+			};
+			const addInput: ObjectSchema = {
+				title: "Extended Input Schema",
+				type: "object",
+				properties: {
+					email: { type: "string", format: "email" },
+					isActive: { type: "boolean" },
+				},
+				required: ["email"],
+			};
+			const srcDataset: ObjectSchema = {
+				title: "Dataset Item Schema",
+				type: "object",
+				properties: {
+					id: { type: "string" },
+					value: { type: "number" },
+				},
+				required: ["id"],
+			};
+			const addDataset: ObjectSchema = {
+				title: "Extended Dataset Item Schema",
+				type: "object",
+				properties: {
+					description: { type: "string" },
+					timestamp: { type: "string", format: "date-time" },
+				},
+				required: ["description"],
+			};
+
+			setupTestDirectoryFiles(
+				srcDir,
+				srcInputPath,
+				srcInput,
+				srcDatasetPath,
+				srcDataset,
+				outputTsDir,
+				addDir,
+				addInputPath,
+				addInput,
+				addDatasetPath,
+				addDataset,
+			);
+
+			execSync(
+				[
+					`${EXEC_CMD} sync`,
+					"-i input dataset",
+					"-o json-schemas ts-types",
+					`--src-input ${srcInputPath}`,
+					`--src-dataset ${srcDatasetPath}`,
+					`--output-ts-dir ${outputTsDir}`,
+					`--add-input ${addInputPath}`,
+					`--add-dataset ${addDatasetPath}`,
+					"--deep-merge",
+					"--include-input-utils false",
+				].join(" "),
+				{
+					cwd: TEST_DIR,
+					stdio: "inherit",
+				},
+			);
+
+			expect(existsSync(join(outputTsDir, "input.ts"))).toBe(true);
+			expect(existsSync(INPUT_SCHEMA_PATH)).toBe(true);
+
+			// Not generated because we set the option to false
+			expect(existsSync(join(outputTsDir, "input-utils.ts"))).toBe(false);
+
+			const generatedInputSchema = readJsonSchema(INPUT_SCHEMA_PATH);
+			expect(generatedInputSchema).toEqual({
+				title: "Extended Input Schema",
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					age: { type: "integer" },
+					email: { type: "string" }, // "format" was removed because it is an invalid property in Apify input schema
+					isActive: { type: "boolean" },
+				},
+				required: ["name", "email"],
+			});
+
+			const generatedDatasetSchema = readJsonSchema(DATASET_SCHEMA_PATH);
+			expect(generatedDatasetSchema).toEqual({
+				title: "Dataset Schema",
+				fields: {
+					title: "Extended Dataset Item Schema",
+					type: "object",
+					properties: {
+						id: { type: "string" },
+						value: { type: "number" },
+						description: { type: "string" },
+						timestamp: { type: "string", format: "date-time" },
+					},
+					required: ["id", "description"],
+				},
+			});
+		});
+	});
+
+	describe("check command", () => {
+		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");
+			const outputTsDir = join(TEST_DIR, "src", "generated");
+			setupTestDirectoryFiles(srcDir, srcInputPath, inputSchema, srcDatasetPath, datasetSchema, outputTsDir);
+			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 outputTsDir = join(TEST_DIR, "src", "generated");
+			const addDir = join(TEST_DIR, "add-schemas");
+			const addInputPath = join(addDir, "add-input.json");
+			setupTestDirectoryFiles(
+				srcDir,
+				srcInputPath,
+				inputSchema,
+				srcDatasetPath,
+				{} as ObjectSchema,
+				outputTsDir,
+				addDir,
+				addInputPath,
+				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");
+			const outputTsDir = join(TEST_DIR, "src", "generated");
+			setupTestDirectoryFiles(
+				srcDir,
+				srcInputPath,
+				inputSchemaWithPositions,
+				srcDatasetPath,
+				{} as ObjectSchema,
+				outputTsDir,
+			);
+			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");
+			const outputTsDir = join(TEST_DIR, "src", "generated");
+			setupTestDirectoryFiles(
+				srcDir,
+				srcInputPath,
+				inputSchemaWithInvalidFields,
+				srcDatasetPath,
+				{} as ObjectSchema,
+				outputTsDir,
+			);
+			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");
+			const outputTsDir = join(TEST_DIR, "src", "generated");
+			setupTestDirectoryFiles(
+				srcDir,
+				srcInputPath,
+				complexSourceSchema,
+				srcDatasetPath,
+				{} as ObjectSchema,
+				outputTsDir,
+			);
+			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 outputTsDir = join(TEST_DIR, "src", "generated");
+			const addDir = join(TEST_DIR, "add-schemas");
+			const addInputPath = join(addDir, "add-input.json");
+			setupTestDirectoryFiles(
+				srcDir,
+				srcInputPath,
+				baseInputSchema,
+				srcDatasetPath,
+				{} as ObjectSchema,
+				outputTsDir,
+				addDir,
+				addInputPath,
+				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");
+			const outputTsDir = join(TEST_DIR, "src", "generated");
+			setupTestDirectoryFiles(
+				srcDir,
+				srcInputPath,
+				sourceSchemaWithInvalidFields,
+				srcDatasetPath,
+				{} as ObjectSchema,
+				outputTsDir,
+			);
+			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");
+			const outputTsDir = join(TEST_DIR, "src", "generated");
+			setupTestDirectoryFiles(srcDir, srcInputPath, sourceInputSchema, srcDatasetPath, {} as ObjectSchema, outputTsDir);
+			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");
+			const outputTsDir = join(TEST_DIR, "src", "generated");
+			setupTestDirectoryFiles(srcDir, srcInputPath, sourceInputSchema, srcDatasetPath, {} as ObjectSchema, outputTsDir);
+			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 outputTsDir = join(TEST_DIR, "src", "generated");
+			const addDir = join(TEST_DIR, "add-schemas");
+			const addInputPath = join(addDir, "add-input.json");
+			setupTestDirectoryFiles(
+				srcDir,
+				srcInputPath,
+				baseInputSchema,
+				srcDatasetPath,
+				{} as ObjectSchema,
+				outputTsDir,
+				addDir,
+				addInputPath,
+				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");
+			const outputTsDir = join(TEST_DIR, "src", "generated");
+			setupTestDirectoryFiles(
+				srcDir,
+				srcInputPath,
+				{} as ObjectSchema,
+				srcDatasetPath,
+				sourceDatasetSchema,
+				outputTsDir,
+			);
+			// 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");
+			const outputTsDir = join(TEST_DIR, "src", "generated");
+			setupTestDirectoryFiles(srcDir, srcInputPath, sourceInputSchema, srcDatasetPath, {} as ObjectSchema, outputTsDir);
+			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"],
+			};
+			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(
+				srcDir,
+				srcInputPath,
+				sourceInputSchema,
+				srcDatasetPath,
+				sourceDatasetSchema,
+				outputTsDir,
+			);
+
+			// 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;
+}
+`;
+			writeFileSync(join(outputTsDir, "input.ts"), inputTsContent);
+			writeFileSync(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(srcDir, srcInputPath, sourceInputSchema, srcDatasetPath, {} as ObjectSchema, outputTsDir);
+
+			// 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;
+}
+`;
+			writeFileSync(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(srcDir, srcInputPath, sourceInputSchema, srcDatasetPath, {} as ObjectSchema, outputTsDir);
+
+			// 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;
+}
+`;
+			writeFileSync(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(srcDir, srcInputPath, sourceInputSchema, srcDatasetPath, {} as ObjectSchema, outputTsDir);
+
+			// 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;
+}
+`;
+			writeFileSync(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 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"],
+			};
+			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(srcDir, srcInputPath, sourceInputSchema, srcDatasetPath, {} as ObjectSchema, outputTsDir);
+
+			// 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;
+}
+`;
+			writeFileSync(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(srcDir, srcInputPath, sourceInputSchema, srcDatasetPath, {} as ObjectSchema, outputTsDir);
+
+			// 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;
+}
+`;
+			writeFileSync(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"],
+			};
+			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(
+				srcDir,
+				srcInputPath,
+				baseInputSchema,
+				srcDatasetPath,
+				{} as ObjectSchema,
+				outputTsDir,
+				addDir,
+				addInputPath,
+				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;
+}
+`;
+			writeFileSync(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"],
+							},
+						},
+						required: ["name"],
+					},
+					settings: {
+						type: "array",
+						items: {
+							type: "object",
+							properties: {
+								key: { type: "string" },
+								value: { type: "string" },
+							},
+							required: ["key"],
+						},
+					},
+				},
+				required: ["user"],
+			};
+			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(srcDir, srcInputPath, sourceInputSchema, srcDatasetPath, {} as ObjectSchema, outputTsDir);
+
+			// 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;
+		};
+	};
+	settings?: {
+		key: string;
+		value?: string;
+	}[];
+}
+`;
+			writeFileSync(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"],
+			};
+			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(srcDir, srcInputPath, sourceInputSchema, srcDatasetPath, {} as ObjectSchema, outputTsDir);
+
+			// 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")[];
+}
+`;
+			writeFileSync(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"],
+			};
+			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(
+				srcDir,
+				srcInputPath,
+				sourceInputSchema,
+				srcDatasetPath,
+				sourceDatasetSchema,
+				outputTsDir,
+			);
+
+			// 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;
+}
+`;
+			writeFileSync(join(outputTsDir, "input.ts"), inputTsContent);
+			writeFileSync(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();
+		});
+	});
+});