apify-schema-tools 2.0.1

package/test/typescript.test.ts

@@ -0,0 +1,817 @@
+import { afterEach, describe, expect, it } from "vitest";
+
+import { cleanupTestDirectory, getTestDir, setupTestDirectory } from "./common";
+
+import path from "node:path";
+import { readFile } from "../src/filesystem.js";
+import type { ObjectSchema } from "../src/json-schemas";
+import {
+	compareTypescriptInterfaces,
+	jsonSchemaToTypeScriptInterface,
+	parseTypeScriptInterface,
+	readGeneratedTypeScriptFile,
+	serializeTypeScriptInterface,
+	writeTypeScriptFile,
+} from "../src/typescript.js";
+
+const TEST_DIR = getTestDir("typescript");
+
+describe("TypeScript files utilities", () => {
+	afterEach(() => {
+		cleanupTestDirectory(TEST_DIR);
+	});
+
+	describe("writeTypeScriptFile", () => {
+		it("should add a header to the TypeScript file", () => {
+			setupTestDirectory(TEST_DIR);
+
+			const content = "export const foo = 'bar';";
+			const filePath = path.join(TEST_DIR, "test.ts");
+			writeTypeScriptFile(filePath, content);
+
+			const fullContent = readFile(filePath);
+			expect(fullContent).toContain("generated by apify-schema-tools.");
+
+			const parsedContent = readGeneratedTypeScriptFile(filePath);
+			expect(parsedContent).toBe(content);
+			expect(parsedContent).not.toContain("generated by apify-schema-tools.");
+		});
+	});
+
+	describe("jsonSchemaToTypeScriptInterface", () => {
+		it("should convert JSON schema to TypeScript schema", () => {
+			const schema: ObjectSchema = {
+				description: "Test schema",
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					colors: {
+						type: "array",
+						items: {
+							type: "object",
+							properties: {
+								name: {
+									type: "string",
+									enum: ["red", "green", "blue"],
+								},
+								value: {
+									type: ["integer", "string"],
+									description: "The hex color value",
+								},
+							},
+							required: ["name"],
+						},
+					},
+					features: {
+						type: "array",
+						items: {
+							type: "string",
+							enum: ["dotted", "striped", "solid"],
+						},
+					},
+					isNice: {
+						type: "boolean",
+						description: "Whether the shape is nice",
+						nullable: true,
+					},
+				},
+				required: ["name", "features", "isNice"],
+			};
+
+			const tsInterface = jsonSchemaToTypeScriptInterface(schema);
+
+			expect(tsInterface).toEqual({
+				doc: "Test schema",
+				isRequired: true,
+				isArray: false,
+				properties: {
+					name: {
+						doc: undefined,
+						isRequired: true,
+						isArray: false,
+						type: "string",
+					},
+					colors: {
+						doc: undefined,
+						isRequired: false,
+						isArray: true,
+						properties: {
+							name: {
+								doc: undefined,
+								isRequired: true,
+								isArray: false,
+								enum: ["red", "green", "blue"],
+							},
+							value: {
+								doc: "The hex color value",
+								isRequired: false,
+								isArray: false,
+								type: ["number", "string"],
+							},
+						},
+					},
+					features: {
+						doc: undefined,
+						isRequired: true,
+						isArray: true,
+						enum: ["dotted", "striped", "solid"],
+					},
+					isNice: {
+						doc: "Whether the shape is nice",
+						isRequired: true,
+						isArray: false,
+						type: ["boolean", "null"],
+					},
+				},
+			});
+		});
+	});
+
+	describe("serializeTypeScriptInterface", () => {
+		it("should serialize TypeScript interface to string", () => {
+			const tsSchema = {
+				doc: "Test schema",
+				isRequired: true,
+				isArray: false,
+				properties: {
+					name: {
+						doc: undefined,
+						isRequired: true,
+						isArray: false,
+						type: "string",
+					},
+					colors: {
+						doc: undefined,
+						isRequired: false,
+						isArray: true,
+						properties: {
+							name: {
+								doc: undefined,
+								isRequired: true,
+								isArray: false,
+								enum: ["red", "green", "blue"],
+							},
+							value: {
+								doc: "The hex color value",
+								isRequired: false,
+								isArray: false,
+								type: ["number", "string"],
+							},
+						},
+					},
+					features: {
+						doc: undefined,
+						isRequired: true,
+						isArray: true,
+						enum: ["dotted", "striped", "solid"],
+					},
+					isNice: {
+						doc: "Whether the shape is nice",
+						isRequired: true,
+						isArray: false,
+						type: ["boolean", "null"],
+					},
+				},
+			};
+
+			const serialized = serializeTypeScriptInterface("Shape", tsSchema);
+			expect(serialized).toBe(`\
+/**
+ * Test schema
+ */
+export interface Shape {
+	name: string;
+	colors?: {
+		name: "red" | "green" | "blue";
+		/**
+		 * The hex color value
+		 */
+		value?: number | string;
+	}[];
+	features: ("dotted" | "striped" | "solid")[];
+	/**
+	 * Whether the shape is nice
+	 */
+	isNice: boolean | null;
+}`);
+		});
+	});
+
+	describe("parseTypeScriptInterface", () => {
+		it("should parse TypeScript interface from string", () => {
+			const tsInterface = `\
+/**
+ * Test schema
+ */
+export interface Shape {
+	name: string;
+	colors?: {
+		name: "red" | "green" | "blue";
+		/**
+		 * The hex color value
+		 */
+		value?: number | string;
+	}[];
+	features: ("dotted" | "striped" | "solid")[];
+	/**
+	 * Whether the shape is nice
+	 */
+	isNice: boolean | null;
+}`;
+			const parsed = parseTypeScriptInterface(tsInterface);
+			expect(parsed).toEqual({
+				doc: "Test schema",
+				isRequired: true,
+				isArray: false,
+				properties: {
+					name: {
+						doc: undefined,
+						isRequired: true,
+						isArray: false,
+						type: "string",
+					},
+					colors: {
+						doc: undefined,
+						isRequired: false,
+						isArray: true,
+						properties: {
+							name: {
+								doc: undefined,
+								isRequired: true,
+								isArray: false,
+								enum: ["red", "green", "blue"],
+							},
+							value: {
+								doc: "The hex color value",
+								isRequired: false,
+								isArray: false,
+								type: ["number", "string"],
+							},
+						},
+					},
+					features: {
+						doc: undefined,
+						isRequired: true,
+						isArray: true,
+						enum: ["dotted", "striped", "solid"],
+					},
+					isNice: {
+						doc: "Whether the shape is nice",
+						isRequired: true,
+						isArray: false,
+						type: ["boolean", "null"],
+					},
+				},
+			});
+		});
+	});
+
+	describe("compareTypescriptInterfaces", () => {
+		const baseInterface = {
+			doc: "Base interface",
+			isRequired: true,
+			isArray: false,
+			properties: {
+				name: {
+					doc: "User name",
+					isRequired: true,
+					isArray: false,
+					type: "string",
+				},
+				age: {
+					doc: undefined,
+					isRequired: false,
+					isArray: false,
+					type: "number",
+				},
+			},
+		};
+
+		it("should return true for identical interfaces", () => {
+			const interfaceA = {
+				doc: "Test interface",
+				isRequired: true,
+				isArray: false,
+				properties: {
+					name: {
+						doc: "User name",
+						isRequired: true,
+						isArray: false,
+						type: "string",
+					},
+					age: {
+						doc: undefined,
+						isRequired: false,
+						isArray: false,
+						type: "number",
+					},
+				},
+			};
+			const interfaceB = {
+				doc: "Test interface",
+				isRequired: true,
+				isArray: false,
+				properties: {
+					name: {
+						doc: "User name",
+						isRequired: true,
+						isArray: false,
+						type: "string",
+					},
+					age: {
+						doc: undefined,
+						isRequired: false,
+						isArray: false,
+						type: "number",
+					},
+				},
+			};
+
+			expect(compareTypescriptInterfaces(interfaceA, interfaceB)).toBe(true);
+		});
+
+		it("should return false for interfaces with different number of properties", () => {
+			const interfaceA = baseInterface;
+			const interfaceB = {
+				doc: "Test interface",
+				isRequired: true,
+				isArray: false,
+				properties: {
+					name: {
+						doc: "User name",
+						isRequired: true,
+						isArray: false,
+						type: "string",
+					},
+					age: {
+						doc: undefined,
+						isRequired: false,
+						isArray: false,
+						type: "number",
+					},
+					email: {
+						doc: undefined,
+						isRequired: true,
+						isArray: false,
+						type: "string",
+					},
+				},
+			};
+
+			expect(compareTypescriptInterfaces(interfaceA, interfaceB)).toBe(false);
+		});
+
+		it("should return false for interfaces with different property names", () => {
+			const interfaceA = baseInterface;
+			const interfaceB = {
+				doc: "Test interface",
+				isRequired: true,
+				isArray: false,
+				properties: {
+					fullName: {
+						doc: "User name",
+						isRequired: true,
+						isArray: false,
+						type: "string",
+					},
+					age: {
+						doc: undefined,
+						isRequired: false,
+						isArray: false,
+						type: "number",
+					},
+				},
+			};
+
+			expect(compareTypescriptInterfaces(interfaceA, interfaceB)).toBe(false);
+		});
+
+		it("should return false for properties with different types", () => {
+			const interfaceA = baseInterface;
+			const interfaceB = {
+				doc: "Test interface",
+				isRequired: true,
+				isArray: false,
+				properties: {
+					name: {
+						doc: "User name",
+						isRequired: true,
+						isArray: false,
+						type: "string",
+					},
+					age: {
+						doc: undefined,
+						isRequired: false,
+						isArray: false,
+						type: "string", // Different type
+					},
+				},
+			};
+
+			expect(compareTypescriptInterfaces(interfaceA, interfaceB)).toBe(false);
+		});
+
+		it("should return false for properties with different isRequired values", () => {
+			const interfaceA = baseInterface;
+			const interfaceB = {
+				doc: "Test interface",
+				isRequired: true,
+				isArray: false,
+				properties: {
+					name: {
+						doc: "User name",
+						isRequired: false, // Different isRequired
+						isArray: false,
+						type: "string",
+					},
+					age: {
+						doc: undefined,
+						isRequired: false,
+						isArray: false,
+						type: "number",
+					},
+				},
+			};
+
+			expect(compareTypescriptInterfaces(interfaceA, interfaceB)).toBe(false);
+		});
+
+		it("should return false for properties with different isArray values", () => {
+			const interfaceA = baseInterface;
+			const interfaceB = {
+				doc: "Test interface",
+				isRequired: true,
+				isArray: false,
+				properties: {
+					name: {
+						doc: "User name",
+						isRequired: true,
+						isArray: true, // Different isArray
+						type: "string",
+					},
+					age: {
+						doc: undefined,
+						isRequired: false,
+						isArray: false,
+						type: "number",
+					},
+				},
+			};
+
+			expect(compareTypescriptInterfaces(interfaceA, interfaceB)).toBe(false);
+		});
+
+		it("should return false for properties with different documentation when ignoreDocs is false", () => {
+			const interfaceA = baseInterface;
+			const interfaceB = {
+				doc: "Test interface",
+				isRequired: true,
+				isArray: false,
+				properties: {
+					name: {
+						doc: "Different documentation", // Different doc
+						isRequired: true,
+						isArray: false,
+						type: "string",
+					},
+					age: {
+						doc: undefined,
+						isRequired: false,
+						isArray: false,
+						type: "number",
+					},
+				},
+			};
+
+			expect(compareTypescriptInterfaces(interfaceA, interfaceB, false)).toBe(false);
+			expect(compareTypescriptInterfaces(interfaceA, interfaceB)).toBe(false); // Default is false
+		});
+
+		it("should return true for properties with different documentation when ignoreDocs is true", () => {
+			const interfaceA = baseInterface;
+			const interfaceB = {
+				doc: "Test interface",
+				isRequired: true,
+				isArray: false,
+				properties: {
+					name: {
+						doc: "Different documentation", // Different doc
+						isRequired: true,
+						isArray: false,
+						type: "string",
+					},
+					age: {
+						doc: "Different age doc", // Different doc
+						isRequired: false,
+						isArray: false,
+						type: "number",
+					},
+				},
+			};
+
+			expect(compareTypescriptInterfaces(interfaceA, interfaceB, true)).toBe(true);
+		});
+
+		it("should handle enum properties correctly", () => {
+			const interfaceA = {
+				doc: undefined,
+				isRequired: true,
+				isArray: false,
+				properties: {
+					status: {
+						doc: undefined,
+						isRequired: true,
+						isArray: false,
+						enum: ["active", "inactive", "pending"],
+					},
+				},
+			};
+			const interfaceB = {
+				doc: undefined,
+				isRequired: true,
+				isArray: false,
+				properties: {
+					status: {
+						doc: undefined,
+						isRequired: true,
+						isArray: false,
+						enum: ["active", "inactive", "pending"],
+					},
+				},
+			};
+
+			expect(compareTypescriptInterfaces(interfaceA, interfaceB)).toBe(true);
+		});
+
+		it("should return false for enum properties with different values", () => {
+			const interfaceA = {
+				doc: undefined,
+				isRequired: true,
+				isArray: false,
+				properties: {
+					status: {
+						doc: undefined,
+						isRequired: true,
+						isArray: false,
+						enum: ["active", "inactive", "pending"],
+					},
+				},
+			};
+			const interfaceB = {
+				doc: undefined,
+				isRequired: true,
+				isArray: false,
+				properties: {
+					status: {
+						doc: undefined,
+						isRequired: true,
+						isArray: false,
+						enum: ["active", "inactive", "cancelled"], // Different enum value
+					},
+				},
+			};
+
+			expect(compareTypescriptInterfaces(interfaceA, interfaceB)).toBe(false);
+		});
+
+		it("should handle nested interface properties correctly", () => {
+			const interfaceA = {
+				doc: undefined,
+				isRequired: true,
+				isArray: false,
+				properties: {
+					user: {
+						doc: undefined,
+						isRequired: true,
+						isArray: false,
+						properties: {
+							name: {
+								doc: undefined,
+								isRequired: true,
+								isArray: false,
+								type: "string",
+							},
+							age: {
+								doc: undefined,
+								isRequired: false,
+								isArray: false,
+								type: "number",
+							},
+						},
+					},
+				},
+			};
+			const interfaceB = {
+				doc: undefined,
+				isRequired: true,
+				isArray: false,
+				properties: {
+					user: {
+						doc: undefined,
+						isRequired: true,
+						isArray: false,
+						properties: {
+							name: {
+								doc: undefined,
+								isRequired: true,
+								isArray: false,
+								type: "string",
+							},
+							age: {
+								doc: undefined,
+								isRequired: false,
+								isArray: false,
+								type: "number",
+							},
+						},
+					},
+				},
+			};
+
+			expect(compareTypescriptInterfaces(interfaceA, interfaceB)).toBe(true);
+		});
+
+		it("should return false for nested interfaces with different structures", () => {
+			const interfaceA = {
+				doc: undefined,
+				isRequired: true,
+				isArray: false,
+				properties: {
+					user: {
+						doc: undefined,
+						isRequired: true,
+						isArray: false,
+						properties: {
+							name: {
+								doc: undefined,
+								isRequired: true,
+								isArray: false,
+								type: "string",
+							},
+							age: {
+								doc: undefined,
+								isRequired: false,
+								isArray: false,
+								type: "number",
+							},
+						},
+					},
+				},
+			};
+			const interfaceB = {
+				doc: undefined,
+				isRequired: true,
+				isArray: false,
+				properties: {
+					user: {
+						doc: undefined,
+						isRequired: true,
+						isArray: false,
+						properties: {
+							name: {
+								doc: undefined,
+								isRequired: true,
+								isArray: false,
+								type: "string",
+							},
+							// Missing age property
+						},
+					},
+				},
+			};
+
+			expect(compareTypescriptInterfaces(interfaceA, interfaceB)).toBe(false);
+		});
+
+		it("should handle union types correctly", () => {
+			const interfaceA = {
+				doc: undefined,
+				isRequired: true,
+				isArray: false,
+				properties: {
+					value: {
+						doc: undefined,
+						isRequired: true,
+						isArray: false,
+						type: ["string", "number"],
+					},
+				},
+			};
+			const interfaceB = {
+				doc: undefined,
+				isRequired: true,
+				isArray: false,
+				properties: {
+					value: {
+						doc: undefined,
+						isRequired: true,
+						isArray: false,
+						type: ["string", "number"],
+					},
+				},
+			};
+
+			expect(compareTypescriptInterfaces(interfaceA, interfaceB)).toBe(true);
+		});
+
+		it("should return false for union types with different order", () => {
+			const interfaceA = {
+				doc: undefined,
+				isRequired: true,
+				isArray: false,
+				properties: {
+					value: {
+						doc: undefined,
+						isRequired: true,
+						isArray: false,
+						type: ["string", "number"],
+					},
+				},
+			};
+			const interfaceB = {
+				doc: undefined,
+				isRequired: true,
+				isArray: false,
+				properties: {
+					value: {
+						doc: undefined,
+						isRequired: true,
+						isArray: false,
+						type: ["number", "string"], // Different order
+					},
+				},
+			};
+
+			expect(compareTypescriptInterfaces(interfaceA, interfaceB)).toBe(false);
+		});
+
+		it("should return false when comparing interface property to basic type property", () => {
+			const interfaceA = {
+				doc: undefined,
+				isRequired: true,
+				isArray: false,
+				properties: {
+					data: {
+						doc: undefined,
+						isRequired: true,
+						isArray: false,
+						properties: {
+							name: {
+								doc: undefined,
+								isRequired: true,
+								isArray: false,
+								type: "string",
+							},
+						},
+					},
+				},
+			};
+			const interfaceB = {
+				doc: undefined,
+				isRequired: true,
+				isArray: false,
+				properties: {
+					data: {
+						doc: undefined,
+						isRequired: true,
+						isArray: false,
+						type: "string", // Basic type instead of interface
+					},
+				},
+			};
+
+			expect(compareTypescriptInterfaces(interfaceA, interfaceB)).toBe(false);
+		});
+
+		it("should return false when comparing enum property to basic type property", () => {
+			const interfaceA = {
+				doc: undefined,
+				isRequired: true,
+				isArray: false,
+				properties: {
+					status: {
+						doc: undefined,
+						isRequired: true,
+						isArray: false,
+						enum: ["active", "inactive"],
+					},
+				},
+			};
+			const interfaceB = {
+				doc: undefined,
+				isRequired: true,
+				isArray: false,
+				properties: {
+					status: {
+						doc: undefined,
+						isRequired: true,
+						isArray: false,
+						type: "string", // Basic type instead of enum
+					},
+				},
+			};
+
+			expect(compareTypescriptInterfaces(interfaceA, interfaceB)).toBe(false);
+		});
+	});
+});