apify-schema-tools 3.1.0 → 3.2.1

package/test/cli/sync.test.ts

@@ -0,0 +1,341 @@
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { afterEach, beforeAll, describe, expect, it } from "vitest";
+import { type ObjectSchema, readJsonSchema, writeJsonSchema } from "../../src/utils/json-schemas.js";
+import {
+	cleanupTestDirectory,
+	getDatasetSchemaPath,
+	getInputSchemaPath,
+	getTestDir,
+	setupTestDirectory,
+	setupTestDirectoryFiles,
+} from "../common.js";
+
+const EXEC_CMD = `node ${import.meta.dirname}/../../dist/apify-schema-tools.js`;
+
+const TEST_DIR = getTestDir("sync-command");
+const INPUT_SCHEMA_PATH = getInputSchemaPath(TEST_DIR);
+const DATASET_SCHEMA_PATH = getDatasetSchemaPath(TEST_DIR);
+
+describe("sync command", () => {
+	beforeAll(() => {
+		execSync("npm run build", { stdio: "inherit" });
+	});
+	afterEach(() => {
+		cleanupTestDirectory(TEST_DIR);
+	});
+
+	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({
+			testDirPath: TEST_DIR,
+			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({
+			testDirPath: TEST_DIR,
+			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({
+			testDirPath: TEST_DIR,
+			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({
+			testDirPath: TEST_DIR,
+			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);
+	});
+});

package/test/common.ts

@@ -1,10 +1,25 @@
 import { existsSync, mkdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
+import type { JSONSchema4 } from "json-schema";
+import { writeFile } from "../src/utils/filesystem.js";
+import { type ObjectSchema, writeJsonSchema } from "../src/utils/json-schemas.js";
 
 export function getTestDir(suffix: string): string {
 	return join(__dirname, `test-temp-${suffix}`);
 }
 
+export function getActorDir(testDirPath: string): string {
+	return join(testDirPath, ".actor");
+}
+
+export function getInputSchemaPath(testDirPath: string): string {
+	return join(getActorDir(testDirPath), "input_schema.json");
+}
+
+export function getDatasetSchemaPath(testDirPath: string): string {
+	return join(getActorDir(testDirPath), "dataset_schema.json");
+}
+
 export function setupTestDirectory(dirPath: string): void {
 	// Create directory if it doesn't exist, do nothing if it already exists
 	if (!existsSync(dirPath)) {
@@ -12,6 +27,59 @@ export function setupTestDirectory(dirPath: string): void {
 	}
 }
 
+type SetupTestDirectoryFilesOptions = {
+	testDirPath: string;
+	srcInputPath: string;
+	srcInput: ObjectSchema;
+	srcDatasetPath: string;
+	srcDataset: ObjectSchema;
+	addDir?: string;
+	addInputPath?: string;
+	addInput?: ObjectSchema;
+	addDatasetPath?: string;
+	addDataset?: ObjectSchema;
+};
+
+export function setupTestDirectoryFiles({
+	testDirPath,
+	srcInputPath,
+	srcInput,
+	srcDatasetPath,
+	srcDataset,
+	addDir,
+	addInputPath,
+	addInput,
+	addDatasetPath,
+	addDataset,
+}: SetupTestDirectoryFilesOptions): void {
+	const inputSchemaPath = getInputSchemaPath(testDirPath);
+	const datasetSchemaPath = getDatasetSchemaPath(testDirPath);
+	const baseInputSchema: JSONSchema4 = {
+		title: "Input Schema",
+		type: "object",
+		properties: {},
+	};
+	writeFile(inputSchemaPath, JSON.stringify(baseInputSchema, null, 4));
+
+	const datasetSchemaWrapper: JSONSchema4 = {
+		title: "Dataset Schema",
+		fields: {},
+	};
+	writeFile(datasetSchemaPath, 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);
+		}
+	}
+}
+
 export function cleanupTestDirectory(dirPath: string): void {
 	if (existsSync(dirPath)) {
 		rmSync(dirPath, { recursive: true, force: true });

package/test/configuration.test.ts

@@ -3,8 +3,8 @@ import type { ArgumentParser } from "argparse";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import {
 	addCommonCliArgs,
+	CONFIGURATION_SCHEMA,
 	type CommonCliArgs,
-	Configuration,
 	parseConfigurationFromFileOrDefault,
 	writeConfigurationToPackageJson,
 } from "../src/configuration.js";
@@ -16,14 +16,14 @@ vi.mock("node:fs", () => ({
 	rmSync: vi.fn(),
 }));
 
-vi.mock("../src/filesystem.js", () => ({
+vi.mock("../src/utils/filesystem.js", () => ({
 	readFile: vi.fn(),
 	writeFile: vi.fn(),
 }));
 
 const mockExistsSync = vi.mocked(existsSync);
-const mockReadFile = vi.mocked(await import("../src/filesystem.js")).readFile;
-const mockWriteFile = vi.mocked(await import("../src/filesystem.js")).writeFile;
+const mockReadFile = vi.mocked(await import("../src/utils/filesystem.js")).readFile;
+const mockWriteFile = vi.mocked(await import("../src/utils/filesystem.js")).writeFile;
 
 describe("parseConfigurationFromFileOrDefault", () => {
 	beforeEach(() => {
@@ -203,7 +203,7 @@ describe("addCommonCLIArgs", () => {
 	});
 
 	it("should add all CLI arguments with default configuration", () => {
-		const defaultConfig = Configuration.parse({});
+		const defaultConfig = CONFIGURATION_SCHEMA.parse({});
 
 		addCommonCliArgs(parser, defaultConfig);
 
@@ -276,7 +276,7 @@ describe("addCommonCLIArgs", () => {
 	});
 
 	it("should add CLI arguments with custom configuration", () => {
-		const customConfig = Configuration.parse({
+		const customConfig = CONFIGURATION_SCHEMA.parse({
 			input: ["input"],
 			output: ["ts-types"],
 			srcInput: "custom-input.json",
@@ -331,7 +331,7 @@ describe("addCommonCLIArgs", () => {
 	});
 
 	it("should preserve argument order", () => {
-		const config = Configuration.parse({});
+		const config = CONFIGURATION_SCHEMA.parse({});
 
 		addCommonCliArgs(parser, config);
 
@@ -349,7 +349,7 @@ describe("addCommonCLIArgs", () => {
 	});
 
 	it("should handle empty arrays in configuration", () => {
-		const configWithEmptyArrays = Configuration.parse({
+		const configWithEmptyArrays = CONFIGURATION_SCHEMA.parse({
 			input: [],
 			output: [],
 		});