apify-schema-tools 2.0.1

package/test/apify.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from "vitest";
+import type { ObjectSchema } from "../src/json-schemas";
+
+describe("Apify utilities", () => {
+	describe("generateInputDefaultsTSFileContent", () => {
+		it("should generate TypeScript content with default values", async () => {
+			const inputSchema: ObjectSchema = {
+				type: "object",
+				properties: {
+					name: { type: "string", default: "John Doe" },
+					age: { type: "number", default: 30 },
+					email: { type: "string" },
+				},
+				required: ["name"],
+			};
+
+			const tsContent = await import("../src/apify.js").then((mod) =>
+				mod.generateInputDefaultsTSFileContent(inputSchema),
+			);
+
+			expect(tsContent).toContain("export type InputWithDefaults = Input & {");
+			expect(tsContent).toContain("export const DEFAULT_INPUT_VALUES = {");
+			expect(tsContent).toContain('"name": "John Doe"');
+			expect(tsContent).toContain('"age": 30');
+			expect(tsContent).toContain("age: number;");
+		});
+	});
+});

package/test/common.ts

@@ -0,0 +1,19 @@
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+
+export function getTestDir(suffix: string): string {
+	return join(__dirname, `test-temp-${suffix}`);
+}
+
+export function setupTestDirectory(dirPath: string) {
+	// Create directory if it doesn't exist, do nothing if it already exists
+	if (!existsSync(dirPath)) {
+		mkdirSync(dirPath, { recursive: true });
+	}
+}
+
+export function cleanupTestDirectory(dirPath: string) {
+	if (existsSync(dirPath)) {
+		rmSync(dirPath, { recursive: true, force: true });
+	}
+}

package/test/configuration.test.ts

@@ -0,0 +1,642 @@
+import { existsSync } from "node:fs";
+import type { ArgumentParser } from "argparse";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+	type CommonCLIArgs,
+	Configuration,
+	addCommonCLIArgs,
+	parseConfigurationFromFileOrDefault,
+	writeConfigurationToPackageJson,
+} from "../src/configuration.js";
+
+// Mock filesystem
+vi.mock("node:fs", () => ({
+	existsSync: vi.fn(),
+	writeFileSync: vi.fn(),
+	rmSync: vi.fn(),
+}));
+
+vi.mock("../src/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;
+
+describe("parseConfigurationFromFileOrDefault", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it("should return default configuration when package.json does not exist", () => {
+		mockExistsSync.mockReturnValue(false);
+
+		const result = parseConfigurationFromFileOrDefault();
+
+		expect(result).toEqual({
+			input: ["input", "dataset"],
+			output: ["json-schemas", "ts-types"],
+			srcInput: "src-schemas/input.json",
+			srcDataset: "src-schemas/dataset-item.json",
+			addInput: undefined,
+			addDataset: undefined,
+			inputSchema: ".actor/input_schema.json",
+			datasetSchema: ".actor/dataset_schema.json",
+			outputTSDir: "src/generated",
+		});
+		expect(mockExistsSync).toHaveBeenCalledWith("package.json");
+		expect(mockReadFile).not.toHaveBeenCalled();
+	});
+
+	it("should return default configuration when package.json exists but has no apify-schema-tools config", () => {
+		mockExistsSync.mockReturnValue(true);
+		mockReadFile.mockReturnValue('{"name": "test-package"}');
+
+		const result = parseConfigurationFromFileOrDefault();
+
+		expect(result).toEqual({
+			input: ["input", "dataset"],
+			output: ["json-schemas", "ts-types"],
+			srcInput: "src-schemas/input.json",
+			srcDataset: "src-schemas/dataset-item.json",
+			addInput: undefined,
+			addDataset: undefined,
+			inputSchema: ".actor/input_schema.json",
+			datasetSchema: ".actor/dataset_schema.json",
+			outputTSDir: "src/generated",
+		});
+		expect(mockExistsSync).toHaveBeenCalledWith("package.json");
+		expect(mockReadFile).toHaveBeenCalledWith("package.json");
+	});
+
+	it("should return default configuration when package.json has empty apify-schema-tools config", () => {
+		mockExistsSync.mockReturnValue(true);
+		mockReadFile.mockReturnValue(
+			JSON.stringify({
+				name: "test-package",
+				"apify-schema-tools": {},
+			}),
+		);
+
+		const result = parseConfigurationFromFileOrDefault();
+
+		expect(result).toEqual({
+			input: ["input", "dataset"],
+			output: ["json-schemas", "ts-types"],
+			srcInput: "src-schemas/input.json",
+			srcDataset: "src-schemas/dataset-item.json",
+			addInput: undefined,
+			addDataset: undefined,
+			inputSchema: ".actor/input_schema.json",
+			datasetSchema: ".actor/dataset_schema.json",
+			outputTSDir: "src/generated",
+		});
+		expect(mockExistsSync).toHaveBeenCalledWith("package.json");
+		expect(mockReadFile).toHaveBeenCalledWith("package.json");
+	});
+
+	it("should merge custom configuration from package.json with defaults", () => {
+		mockExistsSync.mockReturnValue(true);
+		mockReadFile.mockReturnValue(
+			JSON.stringify({
+				name: "test-package",
+				"apify-schema-tools": {
+					input: ["input"],
+					srcInput: "custom-schemas/input.json",
+					outputTSDir: "custom/generated",
+				},
+			}),
+		);
+
+		const result = parseConfigurationFromFileOrDefault();
+
+		expect(result).toEqual({
+			input: ["input"],
+			output: ["json-schemas", "ts-types"], // default
+			srcInput: "custom-schemas/input.json",
+			srcDataset: "src-schemas/dataset-item.json", // default
+			addInput: undefined,
+			addDataset: undefined,
+			inputSchema: ".actor/input_schema.json", // default
+			datasetSchema: ".actor/dataset_schema.json", // default
+			outputTSDir: "custom/generated",
+		});
+	});
+
+	it("should handle complete custom configuration", () => {
+		mockExistsSync.mockReturnValue(true);
+		mockReadFile.mockReturnValue(
+			JSON.stringify({
+				name: "test-package",
+				"apify-schema-tools": {
+					input: ["dataset"],
+					output: ["ts-types"],
+					srcInput: "custom-input.json",
+					srcDataset: "custom-dataset.json",
+					addInput: "additional-input.json",
+					addDataset: "additional-dataset.json",
+					inputSchema: "custom-input-schema.json",
+					datasetSchema: "custom-dataset-schema.json",
+					outputTSDir: "custom-output",
+				},
+			}),
+		);
+
+		const result = parseConfigurationFromFileOrDefault();
+
+		expect(result).toEqual({
+			input: ["dataset"],
+			output: ["ts-types"],
+			srcInput: "custom-input.json",
+			srcDataset: "custom-dataset.json",
+			addInput: "additional-input.json",
+			addDataset: "additional-dataset.json",
+			inputSchema: "custom-input-schema.json",
+			datasetSchema: "custom-dataset-schema.json",
+			outputTSDir: "custom-output",
+		});
+	});
+
+	it("should throw error for invalid configuration", () => {
+		mockExistsSync.mockReturnValue(true);
+		mockReadFile.mockReturnValue(
+			JSON.stringify({
+				name: "test-package",
+				"apify-schema-tools": {
+					input: ["invalid-input"], // invalid enum value
+				},
+			}),
+		);
+
+		expect(() => parseConfigurationFromFileOrDefault()).toThrow();
+	});
+
+	it("should throw error for malformed JSON", () => {
+		mockExistsSync.mockReturnValue(true);
+		mockReadFile.mockReturnValue("invalid json");
+
+		expect(() => parseConfigurationFromFileOrDefault()).toThrow();
+	});
+});
+
+describe("addCommonCLIArgs", () => {
+	let parser: ArgumentParser;
+	let mockAddArgument: ReturnType<typeof vi.fn>;
+
+	beforeEach(() => {
+		mockAddArgument = vi.fn();
+		parser = {
+			add_argument: mockAddArgument,
+		} as unknown as ArgumentParser;
+	});
+
+	afterEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it("should add all CLI arguments with default configuration", () => {
+		const defaultConfig = Configuration.parse({});
+
+		addCommonCLIArgs(parser, defaultConfig);
+
+		expect(mockAddArgument).toHaveBeenCalledTimes(9);
+
+		// Check input argument
+		expect(mockAddArgument).toHaveBeenCalledWith("-i", "--input", {
+			help: "specify which sources to use for generation",
+			choices: ["input", "dataset"],
+			default: ["input", "dataset"],
+			nargs: "*",
+		});
+
+		// Check output argument
+		expect(mockAddArgument).toHaveBeenCalledWith("-o", "--output", {
+			help: "specify what to generate",
+			choices: ["json-schemas", "ts-types"],
+			default: ["json-schemas", "ts-types"],
+			nargs: "*",
+		});
+
+		// Check src-input argument
+		expect(mockAddArgument).toHaveBeenCalledWith("--src-input", {
+			help: "path to the input schema source file",
+			default: "src-schemas/input.json",
+		});
+
+		// Check src-dataset argument
+		expect(mockAddArgument).toHaveBeenCalledWith("--src-dataset", {
+			help: "path to the dataset schema source file",
+			default: "src-schemas/dataset-item.json",
+		});
+
+		// Check add-input argument
+		expect(mockAddArgument).toHaveBeenCalledWith("--add-input", {
+			help: "path to an additional schema to merge into the input schema",
+			default: undefined,
+		});
+
+		// Check add-dataset argument
+		expect(mockAddArgument).toHaveBeenCalledWith("--add-dataset", {
+			help: "path to an additional schema to merge into the dataset schema",
+			default: undefined,
+		});
+
+		// Check input-schema argument
+		expect(mockAddArgument).toHaveBeenCalledWith("--input-schema", {
+			help: "the path of the destination input schema file",
+			default: ".actor/input_schema.json",
+		});
+
+		// Check dataset-schema argument
+		expect(mockAddArgument).toHaveBeenCalledWith("--dataset-schema", {
+			help: "the path of the destination dataset schema file",
+			default: ".actor/dataset_schema.json",
+		});
+
+		// Check output-ts-dir argument
+		expect(mockAddArgument).toHaveBeenCalledWith("--output-ts-dir", {
+			help: "path where to save generated TypeScript files",
+			default: "src/generated",
+		});
+	});
+
+	it("should add CLI arguments with custom configuration", () => {
+		const customConfig = Configuration.parse({
+			input: ["input"],
+			output: ["ts-types"],
+			srcInput: "custom-input.json",
+			srcDataset: "custom-dataset.json",
+			addInput: "additional.json",
+			addDataset: "additional-dataset.json",
+			inputSchema: "custom-input-schema.json",
+			datasetSchema: "custom-dataset-schema.json",
+			outputTSDir: "custom-output",
+		});
+
+		addCommonCLIArgs(parser, customConfig);
+
+		expect(mockAddArgument).toHaveBeenCalledTimes(9);
+
+		// Check that custom defaults are used
+		expect(mockAddArgument).toHaveBeenCalledWith("-i", "--input", {
+			help: "specify which sources to use for generation",
+			choices: ["input", "dataset"],
+			default: ["input"],
+			nargs: "*",
+		});
+
+		expect(mockAddArgument).toHaveBeenCalledWith("-o", "--output", {
+			help: "specify what to generate",
+			choices: ["json-schemas", "ts-types"],
+			default: ["ts-types"],
+			nargs: "*",
+		});
+
+		expect(mockAddArgument).toHaveBeenCalledWith("--src-input", {
+			help: "path to the input schema source file",
+			default: "custom-input.json",
+		});
+
+		expect(mockAddArgument).toHaveBeenCalledWith("--add-input", {
+			help: "path to an additional schema to merge into the input schema",
+			default: "additional.json",
+		});
+
+		expect(mockAddArgument).toHaveBeenCalledWith("--output-ts-dir", {
+			help: "path where to save generated TypeScript files",
+			default: "custom-output",
+		});
+	});
+
+	it("should preserve argument order", () => {
+		const config = Configuration.parse({});
+
+		addCommonCLIArgs(parser, config);
+
+		const calls = mockAddArgument.mock.calls;
+		expect(calls[0]).toEqual(["-i", "--input", expect.any(Object)]);
+		expect(calls[1]).toEqual(["-o", "--output", expect.any(Object)]);
+		expect(calls[2]).toEqual(["--src-input", expect.any(Object)]);
+		expect(calls[3]).toEqual(["--src-dataset", expect.any(Object)]);
+		expect(calls[4]).toEqual(["--add-input", expect.any(Object)]);
+		expect(calls[5]).toEqual(["--add-dataset", expect.any(Object)]);
+		expect(calls[6]).toEqual(["--input-schema", expect.any(Object)]);
+		expect(calls[7]).toEqual(["--dataset-schema", expect.any(Object)]);
+		expect(calls[8]).toEqual(["--output-ts-dir", expect.any(Object)]);
+	});
+
+	it("should handle empty arrays in configuration", () => {
+		const configWithEmptyArrays = Configuration.parse({
+			input: [],
+			output: [],
+		});
+
+		addCommonCLIArgs(parser, configWithEmptyArrays);
+
+		expect(mockAddArgument).toHaveBeenCalledWith("-i", "--input", {
+			help: "specify which sources to use for generation",
+			choices: ["input", "dataset"],
+			default: [],
+			nargs: "*",
+		});
+
+		expect(mockAddArgument).toHaveBeenCalledWith("-o", "--output", {
+			help: "specify what to generate",
+			choices: ["json-schemas", "ts-types"],
+			default: [],
+			nargs: "*",
+		});
+	});
+});
+
+describe("writeConfigurationToPackageJson", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it("should write configuration to package.json when file exists", () => {
+		mockExistsSync.mockReturnValue(true);
+		mockReadFile.mockReturnValue(JSON.stringify({ name: "test-package", version: "1.0.0" }));
+
+		const args: CommonCLIArgs = {
+			input: ["input"],
+			output: ["ts-types"],
+			src_input: "custom-input.json",
+			src_dataset: "custom-dataset.json",
+			add_input: "additional-input.json",
+			add_dataset: "additional-dataset.json",
+			input_schema: "custom-input-schema.json",
+			dataset_schema: "custom-dataset-schema.json",
+			output_ts_dir: "custom-output",
+		};
+
+		writeConfigurationToPackageJson(args);
+
+		expect(mockExistsSync).toHaveBeenCalledWith("package.json");
+		expect(mockReadFile).toHaveBeenCalledWith("package.json");
+		expect(mockWriteFile).toHaveBeenCalledWith(
+			"package.json",
+			JSON.stringify(
+				{
+					name: "test-package",
+					version: "1.0.0",
+					"apify-schema-tools": {
+						input: ["input"],
+						output: ["ts-types"],
+						srcInput: "custom-input.json",
+						srcDataset: "custom-dataset.json",
+						addInput: "additional-input.json",
+						addDataset: "additional-dataset.json",
+						inputSchema: "custom-input-schema.json",
+						datasetSchema: "custom-dataset-schema.json",
+						outputTSDir: "custom-output",
+					},
+				},
+				null,
+				2,
+			),
+		);
+	});
+
+	it("should overwrite existing apify-schema-tools configuration", () => {
+		mockExistsSync.mockReturnValue(true);
+		mockReadFile.mockReturnValue(
+			JSON.stringify({
+				name: "test-package",
+				version: "1.0.0",
+				"apify-schema-tools": {
+					input: ["dataset"],
+					output: ["json-schemas"],
+					srcInput: "old-input.json",
+				},
+			}),
+		);
+
+		const args: CommonCLIArgs = {
+			input: ["input", "dataset"],
+			output: ["json-schemas", "ts-types"],
+			src_input: "new-input.json",
+			src_dataset: "new-dataset.json",
+			input_schema: "new-input-schema.json",
+			dataset_schema: "new-dataset-schema.json",
+			output_ts_dir: "new-output",
+		};
+
+		writeConfigurationToPackageJson(args);
+
+		expect(mockWriteFile).toHaveBeenCalledWith(
+			"package.json",
+			JSON.stringify(
+				{
+					name: "test-package",
+					version: "1.0.0",
+					"apify-schema-tools": {
+						input: ["input", "dataset"],
+						output: ["json-schemas", "ts-types"],
+						srcInput: "new-input.json",
+						srcDataset: "new-dataset.json",
+						addInput: undefined,
+						addDataset: undefined,
+						inputSchema: "new-input-schema.json",
+						datasetSchema: "new-dataset-schema.json",
+						outputTSDir: "new-output",
+					},
+				},
+				null,
+				2,
+			),
+		);
+	});
+
+	it("should handle optional fields correctly when undefined", () => {
+		mockExistsSync.mockReturnValue(true);
+		mockReadFile.mockReturnValue(JSON.stringify({ name: "test-package" }));
+
+		const args: CommonCLIArgs = {
+			input: ["input"],
+			output: ["ts-types"],
+			src_input: "input.json",
+			src_dataset: "dataset.json",
+			add_input: undefined,
+			add_dataset: undefined,
+			input_schema: "input-schema.json",
+			dataset_schema: "dataset-schema.json",
+			output_ts_dir: "output",
+		};
+
+		writeConfigurationToPackageJson(args);
+
+		expect(mockWriteFile).toHaveBeenCalledWith(
+			"package.json",
+			JSON.stringify(
+				{
+					name: "test-package",
+					"apify-schema-tools": {
+						input: ["input"],
+						output: ["ts-types"],
+						srcInput: "input.json",
+						srcDataset: "dataset.json",
+						addInput: undefined,
+						addDataset: undefined,
+						inputSchema: "input-schema.json",
+						datasetSchema: "dataset-schema.json",
+						outputTSDir: "output",
+					},
+				},
+				null,
+				2,
+			),
+		);
+	});
+
+	it("should handle optional fields correctly when defined", () => {
+		mockExistsSync.mockReturnValue(true);
+		mockReadFile.mockReturnValue(JSON.stringify({ name: "test-package" }));
+
+		const args: CommonCLIArgs = {
+			input: ["input", "dataset"],
+			output: ["json-schemas", "ts-types"],
+			src_input: "input.json",
+			src_dataset: "dataset.json",
+			add_input: "additional.json",
+			add_dataset: "additional-dataset.json",
+			input_schema: "input-schema.json",
+			dataset_schema: "dataset-schema.json",
+			output_ts_dir: "output",
+		};
+
+		writeConfigurationToPackageJson(args);
+
+		expect(mockWriteFile).toHaveBeenCalledWith(
+			"package.json",
+			JSON.stringify(
+				{
+					name: "test-package",
+					"apify-schema-tools": {
+						input: ["input", "dataset"],
+						output: ["json-schemas", "ts-types"],
+						srcInput: "input.json",
+						srcDataset: "dataset.json",
+						addInput: "additional.json",
+						addDataset: "additional-dataset.json",
+						inputSchema: "input-schema.json",
+						datasetSchema: "dataset-schema.json",
+						outputTSDir: "output",
+					},
+				},
+				null,
+				2,
+			),
+		);
+	});
+
+	it("should throw error when package.json does not exist", () => {
+		mockExistsSync.mockReturnValue(false);
+
+		const args: CommonCLIArgs = {
+			input: ["input"],
+			output: ["ts-types"],
+			src_input: "input.json",
+			src_dataset: "dataset.json",
+			input_schema: "input-schema.json",
+			dataset_schema: "dataset-schema.json",
+			output_ts_dir: "output",
+		};
+
+		expect(() => writeConfigurationToPackageJson(args)).toThrow(
+			"package.json does not exist. Please run this command in the root of your project.",
+		);
+		expect(mockExistsSync).toHaveBeenCalledWith("package.json");
+		expect(mockReadFile).not.toHaveBeenCalled();
+		expect(mockWriteFile).not.toHaveBeenCalled();
+	});
+
+	it("should preserve existing package.json structure and add apify-schema-tools", () => {
+		mockExistsSync.mockReturnValue(true);
+		mockReadFile.mockReturnValue(
+			JSON.stringify({
+				name: "test-package",
+				version: "1.0.0",
+				description: "Test package",
+				scripts: {
+					build: "tsc",
+					test: "vitest",
+				},
+				dependencies: {
+					"some-package": "^1.0.0",
+				},
+				devDependencies: {
+					typescript: "^5.0.0",
+				},
+			}),
+		);
+
+		const args: CommonCLIArgs = {
+			input: ["input"],
+			output: ["ts-types"],
+			src_input: "input.json",
+			src_dataset: "dataset.json",
+			input_schema: "input-schema.json",
+			dataset_schema: "dataset-schema.json",
+			output_ts_dir: "output",
+		};
+
+		writeConfigurationToPackageJson(args);
+
+		expect(mockWriteFile).toHaveBeenCalledWith(
+			"package.json",
+			JSON.stringify(
+				{
+					name: "test-package",
+					version: "1.0.0",
+					description: "Test package",
+					scripts: {
+						build: "tsc",
+						test: "vitest",
+					},
+					dependencies: {
+						"some-package": "^1.0.0",
+					},
+					devDependencies: {
+						typescript: "^5.0.0",
+					},
+					"apify-schema-tools": {
+						input: ["input"],
+						output: ["ts-types"],
+						srcInput: "input.json",
+						srcDataset: "dataset.json",
+						addInput: undefined,
+						addDataset: undefined,
+						inputSchema: "input-schema.json",
+						datasetSchema: "dataset-schema.json",
+						outputTSDir: "output",
+					},
+				},
+				null,
+				2,
+			),
+		);
+	});
+
+	it("should handle malformed package.json", () => {
+		mockExistsSync.mockReturnValue(true);
+		mockReadFile.mockReturnValue("invalid json");
+
+		const args: CommonCLIArgs = {
+			input: ["input"],
+			output: ["ts-types"],
+			src_input: "input.json",
+			src_dataset: "dataset.json",
+			input_schema: "input-schema.json",
+			dataset_schema: "dataset-schema.json",
+			output_ts_dir: "output",
+		};
+
+		expect(() => writeConfigurationToPackageJson(args)).toThrow();
+		expect(mockExistsSync).toHaveBeenCalledWith("package.json");
+		expect(mockReadFile).toHaveBeenCalledWith("package.json");
+		expect(mockWriteFile).not.toHaveBeenCalled();
+	});
+});