apify-schema-tools 3.0.0 → 3.2.0

package/test/cli/init.test.ts

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