apify-schema-tools 3.1.0 → 3.2.1

package/test/middle-schema/generate-typescript.test.ts

@@ -0,0 +1,191 @@
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+	readGeneratedTypeScriptFile,
+	serializeMiddleObjectToTypeScript,
+	writeTypeScriptFile,
+} from "../../src/middle-schema/generate-typescript.js";
+import type { AllowedType, MiddleObject } from "../../src/middle-schema/schema.js";
+import { readFile } from "../../src/utils/filesystem.js";
+import { cleanupTestDirectory, getTestDir, setupTestDirectory } from "../common.js";
+
+const TEST_DIR = getTestDir("middle-schema-generate-typescript");
+
+describe("Generate-TypeScript 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("serializeMiddleObjectToTypeScript", () => {
+		it("should serialize MiddleObject to string", () => {
+			const schema = {
+				doc: "Test schema",
+				isRequired: true,
+				isArray: false,
+				properties: {
+					name: {
+						doc: undefined,
+						isRequired: true,
+						isArray: false,
+						type: "string" as AllowedType,
+					},
+					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"] as AllowedType[],
+							},
+						},
+						additionalProperties: {
+							doc: undefined,
+							isRequired: true,
+							isArray: false,
+							type: "boolean" as AllowedType,
+						},
+					},
+					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"] as AllowedType[],
+					},
+				},
+			};
+
+			const serialized = serializeMiddleObjectToTypeScript("Shape", schema);
+			expect(serialized).toBe(`\
+/**
+ * Test schema
+ */
+export interface Shape {
+	name: string;
+	colors?: {
+		name: "red" | "green" | "blue";
+		/**
+		 * The hex color value
+		 */
+		value?: number | string;
+		[key: string]: boolean;
+	}[];
+	features: ("dotted" | "striped" | "solid")[];
+	/**
+	 * Whether the shape is nice
+	 */
+	isNice: boolean | null;
+}`);
+		});
+
+		it("should serialize complex additionalProperties", () => {
+			const schema: MiddleObject = {
+				doc: "Test schema with additional properties",
+				isRequired: true,
+				isArray: false,
+				properties: {
+					name: {
+						doc: undefined,
+						isRequired: true,
+						isArray: false,
+						type: "string",
+					},
+				},
+				additionalProperties: {
+					doc: "Additional properties of any type",
+					isRequired: true,
+					isArray: true,
+					properties: {
+						key: {
+							doc: undefined,
+							isRequired: true,
+							isArray: false,
+							type: "string",
+						},
+						value: {
+							doc: undefined,
+							isRequired: true,
+							isArray: false,
+							type: "number",
+						},
+					},
+				},
+			};
+
+			expect(serializeMiddleObjectToTypeScript("Shape", schema)).toBe(`\
+/**
+ * Test schema with additional properties
+ */
+export interface Shape {
+	name: string;
+	[key: string]: {
+		key: string;
+		value: number;
+	}[];
+}`);
+		});
+
+		it("should serialize a MiddleObject with a property with only additionalProperties", () => {
+			const schema: MiddleObject = {
+				doc: "Test schema with extensible properties",
+				isRequired: true,
+				isArray: false,
+				properties: {
+					extensible: {
+						doc: undefined,
+						isRequired: true,
+						isArray: false,
+						properties: {},
+						additionalProperties: {
+							doc: undefined,
+							isRequired: true,
+							isArray: false,
+							type: "unknown",
+						},
+					},
+				},
+			};
+
+			expect(serializeMiddleObjectToTypeScript("Extensible", schema)).toBe(`\
+/**
+ * Test schema with extensible properties
+ */
+export interface Extensible {
+	extensible: {
+		[key: string]: unknown;
+	};
+}`);
+		});
+	});
+});

package/test/middle-schema/parse-json-schema.test.ts

@@ -0,0 +1,178 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { jsonSchemaToMiddleObject } from "../../src/middle-schema/parse-json-schema.js";
+import type { ObjectSchema } from "../../src/utils/json-schemas.js";
+import { cleanupTestDirectory, getTestDir } from "../common.js";
+
+const TEST_DIR = getTestDir("middle-schema-parse-json-schema");
+
+describe("Parse-JSON-schema utilities", () => {
+	afterEach(() => {
+		cleanupTestDirectory(TEST_DIR);
+	});
+
+	describe("jsonSchemaToMiddleSchema", () => {
+		it("should convert JSON schema to MiddleObject", () => {
+			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"],
+							additionalProperties: {
+								type: "array",
+								items: {
+									type: "object",
+									properties: {
+										key: {
+											type: "string",
+										},
+										value: {
+											type: "number",
+										},
+									},
+									required: ["key", "value"],
+									additionalProperties: false,
+								},
+							},
+						},
+					},
+					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 = jsonSchemaToMiddleObject(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"],
+							},
+						},
+						additionalProperties: {
+							doc: undefined,
+							isRequired: true,
+							isArray: true,
+							properties: {
+								key: {
+									doc: undefined,
+									isRequired: true,
+									isArray: false,
+									type: "string",
+								},
+								value: {
+									doc: undefined,
+									isRequired: true,
+									isArray: false,
+									type: "number",
+								},
+							},
+						},
+					},
+					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"],
+					},
+				},
+				additionalProperties: {
+					doc: undefined,
+					isRequired: true,
+					isArray: false,
+					type: "unknown",
+				},
+			});
+		});
+
+		it("should convert a JSON schema with a property with only additionalProperties", () => {
+			const schema: ObjectSchema = {
+				type: "object",
+				properties: {
+					extensible: {
+						type: "object",
+						additionalProperties: true,
+					},
+				},
+				required: ["extensible"],
+				additionalProperties: false,
+			};
+
+			const tsInterface = jsonSchemaToMiddleObject(schema);
+			expect(tsInterface).toEqual({
+				doc: undefined,
+				isRequired: true,
+				isArray: false,
+				properties: {
+					extensible: {
+						doc: undefined,
+						isRequired: true,
+						isArray: false,
+						properties: {},
+						additionalProperties: {
+							doc: undefined,
+							isRequired: true,
+							isArray: false,
+							type: "unknown",
+						},
+					},
+				},
+				additionalProperties: undefined,
+			});
+		});
+	});
+});

package/test/middle-schema/parse-typescript.test.ts

@@ -0,0 +1,143 @@
+import { describe, expect, it } from "vitest";
+
+import { parseTypeScriptInterface } from "../../src/middle-schema/parse-typescript.js";
+
+describe("Parse-TypeScript utilities", () => {
+	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;
+		[key: string]: {
+			key: string;
+			value: number;
+		}[];
+	}[];
+	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"],
+							},
+						},
+						additionalProperties: {
+							doc: undefined,
+							isRequired: true,
+							isArray: true,
+							properties: {
+								key: {
+									doc: undefined,
+									isRequired: true,
+									isArray: false,
+									type: "string",
+								},
+								value: {
+									doc: undefined,
+									isRequired: true,
+									isArray: false,
+									type: "number",
+								},
+							},
+							additionalProperties: undefined,
+						},
+					},
+					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"],
+					},
+				},
+				additionalProperties: undefined,
+			});
+		});
+
+		it("parses a TS interface where a property can be only a single literal", () => {
+			const tsInterface = `\
+export interface TestInterface {
+	singleValue: "onlyValue";
+}`;
+			const parsed = parseTypeScriptInterface(tsInterface);
+			expect(parsed).toEqual({
+				doc: undefined,
+				isRequired: true,
+				isArray: false,
+				properties: {
+					singleValue: {
+						doc: undefined,
+						isRequired: true,
+						isArray: false,
+						enum: ["onlyValue"],
+					},
+				},
+				additionalProperties: undefined,
+			});
+		});
+
+		it("parses a TS interface where a property can be only a single number", () => {
+			const tsInterface = `\
+export interface TestInterface {
+	singleValue: 42;
+}`;
+			const parsed = parseTypeScriptInterface(tsInterface);
+			expect(parsed).toEqual({
+				doc: undefined,
+				isRequired: true,
+				isArray: false,
+				properties: {
+					singleValue: {
+						doc: undefined,
+						isRequired: true,
+						isArray: false,
+						enum: [42],
+					},
+				},
+				additionalProperties: undefined,
+			});
+		});
+	});
+});

package/test/{json-schema-conflicts.test.ts → utils/json-schemas-interactive-conflict.test.ts}

@@ -1,7 +1,7 @@
 /** biome-ignore-all lint/performance/noAwaitInLoops: testing different configurations */
 
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { ObjectSchema, OmissibleField } from "../src/json-schemas.js";
+import type { ObjectSchema, OmissibleField } from "../../src/utils/json-schemas.js";
 
 const mockSelect = vi.fn();
 
@@ -11,7 +11,7 @@ vi.mock("@inquirer/prompts", () => ({
 }));
 
 // Import after mocking
-const { checkConflicts } = await import("../src/json-schema-conflicts.js");
+const { checkConflicts } = await import("../../src/utils/json-schemas-interactive-conflict.js");
 
 describe("checkConflicts", () => {
 	const baseSchema: ObjectSchema = {

package/test/{json-schemas.test.ts → utils/json-schemas.test.ts}

@@ -1,7 +1,7 @@
 import { join } from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
 
-import { writeFile } from "../src/filesystem.js";
+import { writeFile } from "../../src/utils/filesystem.js";
 import {
 	compareSchemas,
 	filterValidSchemaProperties,
@@ -11,8 +11,8 @@ import {
 	readJsonSchema,
 	readJsonSchemaField,
 	writeSchemaToField,
-} from "../src/json-schemas.js";
-import { cleanupTestDirectory, getTestDir, setupTestDirectory } from "./common.js";
+} from "../../src/utils/json-schemas.js";
+import { cleanupTestDirectory, getTestDir, setupTestDirectory } from "../common.js";
 
 const DESCRIPTION_FIELDS: OmissibleField[] = ["title", "description"];
 const TEST_DIR = getTestDir("json-schemas");