apify-schema-tools 3.1.0 → 3.2.1

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

@@ -1,2216 +0,0 @@
-import { execSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import type { JSONSchema4 } from "json-schema";
-import { afterEach, beforeAll, describe, expect, it } from "vitest";
-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";
-import { cleanupTestDirectory, getTestDir, setupTestDirectory } from "./common.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");
-
-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/;
-
-function setupTestDirectoryFiles(
-	srcInputPath: string,
-	srcInput: ObjectSchema,
-	srcDatasetPath: string,
-	srcDataset: ObjectSchema,
-	addDir?: string,
-	addInputPath?: string,
-	addInput?: ObjectSchema,
-	addDatasetPath?: string,
-	addDataset?: ObjectSchema,
-): void {
-	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);
-
-	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");
-			writeFile(
-				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",
-			};
-			writeFile(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("./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");
-			writeFile(
-				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",
-			};
-			writeFile(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");
-			writeFile(
-				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");
-			writeFile(
-				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",
-			};
-			writeFile(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");
-			writeFile(
-				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");
-			writeFile(
-				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",
-			};
-			writeFile(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(preExistingSchema);
-
-			// 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");
-			writeFile(
-				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");
-			writeFile(
-				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();
-		});
-
-		it("should fix the dataset path in actor.json", () => {
-			setupTestDirectory(TEST_DIR);
-
-			const packageJsonPath = join(TEST_DIR, "package.json");
-			writeFile(
-				packageJsonPath,
-				JSON.stringify(
-					{
-						name: "test-project",
-						version: "1.0.0",
-					},
-					null,
-					2,
-				),
-			);
-
-			// Create existing actor config with incorrect dataset path
-			const actorConfigPath = join(TEST_DIR, ACTOR_CONFIG_PATH);
-			const existingActorConfig = {
-				actorSpecification: 1,
-				name: "test-actor",
-				version: "1.0.0",
-				storages: {
-					dataset: "wrong/dataset/path.json",
-				},
-			};
-			writeFile(actorConfigPath, JSON.stringify(existingActorConfig, null, 4));
-
-			execSync(`${EXEC_CMD} init --input dataset`, {
-				cwd: TEST_DIR,
-				stdio: "inherit",
-			});
-
-			// Check that actor config was updated with the correct dataset path
-			const updatedActorConfig = JSON.parse(readFileSync(actorConfigPath, "utf8"));
-			expect(updatedActorConfig.storages?.dataset).toBe("./dataset_schema.json");
-		});
-	});
-
-	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(srcInputPath, srcInput, srcDatasetPath, srcDataset);
-			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 = {
-				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 = {
-				type: "object",
-				properties: {
-					description: { type: "string" },
-					timestamp: { type: "string", format: "date-time" },
-				},
-				required: ["description"],
-			};
-
-			setupTestDirectoryFiles(
-				srcInputPath,
-				srcInput,
-				srcDatasetPath,
-				srcDataset,
-				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: "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: "Dataset Item Schema",
-					type: "object",
-					properties: {
-						id: { type: "string" },
-						value: { type: "number" },
-						description: { type: "string" },
-						timestamp: { type: "string", format: "date-time" },
-					},
-					required: ["id", "description"],
-				},
-			});
-		});
-
-		it("throws an error when there is a conflict and the --fail-on-conflict option is used", () => {
-			setupTestDirectory(TEST_DIR);
-			const srcDir = join(TEST_DIR, "src-schemas");
-			const srcInputPath = join(srcDir, "input.json");
-			const srcDatasetPath = join(srcDir, "dataset-item.json");
-
-			// Create source schema with one title
-			const srcInput: ObjectSchema = {
-				title: "Source Input Schema", // This will conflict with existing schema
-				type: "object",
-				properties: {
-					name: { type: "string" },
-				},
-				required: ["name"],
-			};
-			const srcDataset: ObjectSchema = {
-				title: "Dataset Item Schema",
-				type: "object",
-				properties: {
-					id: { type: "string" },
-				},
-				required: ["id"],
-			};
-
-			setupTestDirectoryFiles(srcInputPath, srcInput, srcDatasetPath, srcDataset);
-
-			// Create existing schema with different title to cause conflict
-			const existingInputSchema: ObjectSchema = {
-				title: "Existing Input Schema", // Different title causes conflict
-				type: "object",
-				properties: {
-					name: { type: "string" },
-				},
-				required: ["name"],
-			};
-			writeJsonSchema(INPUT_SCHEMA_PATH, existingInputSchema);
-
-			// Should throw an error due to --fail-on-conflict
-			expect(() =>
-				execSync(
-					[
-						`${EXEC_CMD} sync`,
-						"--fail-on-conflict",
-						"-i input",
-						"-o json-schemas",
-						`--src-input ${srcInputPath}`,
-						`--src-dataset ${srcDatasetPath}`,
-					].join(" "),
-					{
-						cwd: TEST_DIR,
-						stdio: "inherit",
-					},
-				),
-			).toThrow();
-
-			// Verify the existing schema was not overwritten
-			expect(readJsonSchema(INPUT_SCHEMA_PATH)).toEqual(existingInputSchema);
-		});
-
-		it("logs a warning when there is a conflict and the --force option is used", () => {
-			setupTestDirectory(TEST_DIR);
-			const srcDir = join(TEST_DIR, "src-schemas");
-			const srcInputPath = join(srcDir, "input.json");
-			const srcDatasetPath = join(srcDir, "dataset-item.json");
-
-			// Create source schema with one title
-			const srcInput: ObjectSchema = {
-				title: "Source Input Schema", // This will conflict with existing schema
-				type: "object",
-				properties: {
-					name: { type: "string" },
-				},
-				required: ["name"],
-			};
-			const srcDataset: ObjectSchema = {
-				title: "Dataset Item Schema",
-				type: "object",
-				properties: {
-					id: { type: "string" },
-				},
-				required: ["id"],
-			};
-
-			setupTestDirectoryFiles(srcInputPath, srcInput, srcDatasetPath, srcDataset);
-
-			// Create existing schema with different title to cause conflict
-			const existingInputSchema: ObjectSchema = {
-				title: "Existing Input Schema", // Different title causes conflict
-				type: "object",
-				properties: {
-					name: { type: "string" },
-				},
-				required: ["name"],
-			};
-			writeJsonSchema(INPUT_SCHEMA_PATH, existingInputSchema);
-
-			// Should NOT throw an error due to --force, just log warning
-			expect(() =>
-				execSync(
-					[
-						`${EXEC_CMD} sync`,
-						"--force",
-						"-i input",
-						"-o json-schemas",
-						`--src-input ${srcInputPath}`,
-						`--src-dataset ${srcDatasetPath}`,
-					].join(" "),
-					{
-						cwd: TEST_DIR,
-						stdio: "inherit",
-					},
-				),
-			).not.toThrow();
-
-			// Verify the existing schema was overwritten
-			expect(readJsonSchema(INPUT_SCHEMA_PATH)).toEqual(srcInput);
-		});
-	});
-
-	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");
-			setupTestDirectoryFiles(srcInputPath, inputSchema, srcDatasetPath, 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(
-				srcInputPath,
-				inputSchema,
-				srcDatasetPath,
-				{} as ObjectSchema,
-				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");
-			setupTestDirectoryFiles(srcInputPath, inputSchemaWithPositions, srcDatasetPath, {} 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(srcInputPath, inputSchemaWithInvalidFields, srcDatasetPath, {} 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(srcInputPath, complexSourceSchema, srcDatasetPath, {} 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(
-				srcInputPath,
-				baseInputSchema,
-				srcDatasetPath,
-				{} as ObjectSchema,
-				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");
-			setupTestDirectoryFiles(srcInputPath, sourceSchemaWithInvalidFields, srcDatasetPath, {} 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(srcInputPath, sourceInputSchema, srcDatasetPath, {} 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(srcInputPath, sourceInputSchema, srcDatasetPath, {} 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(
-				srcInputPath,
-				baseInputSchema,
-				srcDatasetPath,
-				{} as ObjectSchema,
-				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");
-			setupTestDirectoryFiles(srcInputPath, {} as ObjectSchema, srcDatasetPath, 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(srcInputPath, sourceInputSchema, srcDatasetPath, {} 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(srcInputPath, sourceInputSchema, srcDatasetPath, 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(srcInputPath, sourceInputSchema, srcDatasetPath, {} 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(srcInputPath, sourceInputSchema, srcDatasetPath, {} 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(srcInputPath, sourceInputSchema, srcDatasetPath, {} 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(srcInputPath, sourceInputSchema, srcDatasetPath, {} 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(srcInputPath, sourceInputSchema, srcDatasetPath, {} 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(srcInputPath, sourceInputSchema, srcDatasetPath, {} 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(
-				srcInputPath,
-				baseInputSchema,
-				srcDatasetPath,
-				{} as ObjectSchema,
-				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;
-}
-`;
-			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(srcInputPath, sourceInputSchema, srcDatasetPath, {} 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(srcInputPath, sourceInputSchema, srcDatasetPath, {} 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(srcInputPath, sourceInputSchema, srcDatasetPath, 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();
-		});
-	});
-});