apify-schema-tools 2.0.4 → 2.1.0

package/src/typescript.ts

@@ -1,7 +1,7 @@
 import type { JSONSchema4 } from "json-schema";
-import * as R from "ramda";
+import { equals } from "ramda";
 import { readFile, writeFile } from "./filesystem.js";
-import { type ObjectSchema, isArraySchema, isObjectSchema } from "./json-schemas.js";
+import { isArraySchema, isObjectSchema, type ObjectSchema } from "./json-schemas.js";
 
 const TYPESCRIPT_FILE_HEADER = `\
 /**
@@ -57,6 +57,7 @@ function isTypeScriptEnum(schema: TypeScriptSchema): schema is TypeScriptEnum {
 
 export interface TypeScriptInterface extends TypeScriptBasicData {
 	properties: Record<string, TypeScriptSchema>;
+	additionalProperties?: TypeScriptSchema;
 }
 
 function isTypeScriptInterface(schema: TypeScriptSchema): schema is TypeScriptInterface {
@@ -65,34 +66,51 @@ function isTypeScriptInterface(schema: TypeScriptSchema): schema is TypeScriptIn
 
 export type TypeScriptSchema = TypeScriptBasicType | TypeScriptEnum | TypeScriptInterface;
 
-function jsonSchemaToTypeScriptSchema(
-	schema: JSONSchema4,
+function createTypeScriptInterface(
+	schema: ObjectSchema,
+	doc: string | undefined,
 	isArray: boolean,
 	isRequired: boolean,
-	inheritedDoc?: string,
-): TypeScriptSchema {
-	const doc = inheritedDoc ?? schema.description;
-	if (isObjectSchema(schema)) {
-		const requiredProperties = schema.required ?? [];
-		const properties = Object.fromEntries(
-			Object.entries(schema.properties ?? {}).map(([key, value]) => {
-				return [key, jsonSchemaToTypeScriptSchema(value, false, requiredProperties.includes(key))];
-			}),
-		);
-		return { doc, isArray, isRequired, properties };
+): TypeScriptInterface {
+	const requiredProperties = schema.required ?? [];
+
+	const properties = Object.fromEntries(
+		Object.entries(schema.properties ?? {}).map(([key, value]) => {
+			return [key, jsonSchemaToTypeScriptSchema(value, false, requiredProperties.includes(key))];
+		}),
+	);
+
+	let additionalProperties: TypeScriptSchema | undefined;
+	if (schema.additionalProperties === true || schema.additionalProperties === undefined) {
+		// If additionalProperties is true or undefined, we parse it as an "empty" schema
+		additionalProperties = { doc: undefined, isArray: false, isRequired: true, type: "unknown" };
+	} else if (schema.additionalProperties !== false) {
+		additionalProperties = jsonSchemaToTypeScriptSchema(schema.additionalProperties, false, true);
 	}
-	if (isArraySchema(schema)) {
-		if (Array.isArray(schema.items)) {
-			throw new Error("Array schema with multiple items is not supported");
-		}
-		if (!schema.items) {
-			return { doc, isArray, isRequired, type: "unknown" };
-		}
-		return jsonSchemaToTypeScriptSchema(schema.items, true, isRequired, doc);
+
+	return { doc, isArray, isRequired, properties, additionalProperties };
+}
+
+function createTypeScriptArraySchema(
+	schema: JSONSchema4 & { type: "array" },
+	doc: string | undefined,
+	isRequired: boolean,
+): TypeScriptSchema {
+	if (Array.isArray(schema.items)) {
+		throw new Error("Array schema with multiple items is not supported");
 	}
-	if (schema.enum) {
-		return { doc, isArray, isRequired, enum: schema.enum };
+	if (!schema.items) {
+		return { doc, isArray: true, isRequired, type: "unknown" };
 	}
+	return jsonSchemaToTypeScriptSchema(schema.items, true, isRequired, doc);
+}
+
+function createTypeScriptBasicType(
+	schema: JSONSchema4,
+	doc: string | undefined,
+	isArray: boolean,
+	isRequired: boolean,
+): TypeScriptBasicType {
 	const types: AllowedType[] = [];
 	for (const type of Array.isArray(schema.type) ? schema.type : [schema.type ?? "unknown"]) {
 		const tsType = JSON_SCHEMA_TYPE_TO_TS_TYPE[type] ?? type;
@@ -112,41 +130,76 @@ function jsonSchemaToTypeScriptSchema(
 	};
 }
 
+function jsonSchemaToTypeScriptSchema(
+	schema: JSONSchema4,
+	isArray: boolean,
+	isRequired: boolean,
+	inheritedDoc?: string,
+): TypeScriptSchema {
+	const doc = inheritedDoc ?? schema.description;
+
+	if (isObjectSchema(schema)) {
+		return createTypeScriptInterface(schema, doc, isArray, isRequired);
+	}
+
+	if (isArraySchema(schema)) {
+		return createTypeScriptArraySchema(schema, doc, isRequired);
+	}
+
+	if (schema.enum) {
+		return { doc, isArray, isRequired, enum: schema.enum };
+	}
+
+	return createTypeScriptBasicType(schema, doc, isArray, isRequired);
+}
+
 export function jsonSchemaToTypeScriptInterface(schema: ObjectSchema): TypeScriptInterface {
 	return jsonSchemaToTypeScriptSchema(schema, false, true) as TypeScriptInterface;
 }
 
-export function serializeTypeScriptSchema(schema: TypeScriptSchema, indentLevel = 0): string {
+function serializeInterfaceSchema(schema: TypeScriptInterface, indentLevel: number): string {
 	const indent = "\t".repeat(indentLevel);
-	let result = "";
+	const properties = Object.entries(schema.properties);
+	if (properties.length === 0) {
+		return "{}";
+	}
+	const innerIndentLevel = indentLevel + 1;
+	const innerIndent = "\t".repeat(innerIndentLevel);
+	let result = "{";
+	for (const [key, value] of properties) {
+		if (value.doc) {
+			result += `\n${innerIndent}/**\n${innerIndent} * ${value.doc}\n${innerIndent} */`;
+		}
+		result += `\n${innerIndent}${key}${value.isRequired ? "" : "?"}: ${serializeTypeScriptSchema(value, innerIndentLevel)};`;
+	}
+	if (schema.additionalProperties) {
+		result += `\n${innerIndent}[key: string]: ${serializeTypeScriptSchema(schema.additionalProperties, innerIndentLevel)};`;
+	}
+	result += `\n${indent}}`;
+	return result;
+}
+
+function serializeEnumSchema(schema: TypeScriptEnum): string {
+	const serializedEnum = JSON.stringify(schema.enum).replace(/\[|\]/g, "").replace(/,/g, " | ");
+	return schema.isArray && schema.enum.length > 1 ? `(${serializedEnum})` : serializedEnum;
+}
+
+function serializeBasicTypeSchema(schema: TypeScriptBasicType): string {
+	if (Array.isArray(schema.type)) {
+		return schema.isArray ? `(${schema.type.join(" | ")})` : schema.type.join(" | ");
+	}
+	return schema.type;
+}
 
+export function serializeTypeScriptSchema(schema: TypeScriptSchema, indentLevel = 0): string {
+	let result = "";
 	if (isTypeScriptInterface(schema)) {
-		const properties = Object.entries(schema.properties);
-		if (properties.length === 0) {
-			return "{}";
-		}
-		const innerIndentLevel = indentLevel + 1;
-		const innerIndent = "\t".repeat(innerIndentLevel);
-		result += "{";
-		for (const [key, value] of properties) {
-			if (value.doc) {
-				result += `\n${innerIndent}/**\n${innerIndent} * ${value.doc}\n${innerIndent} */`;
-			}
-			result += `\n${innerIndent}${key}${
-				value.isRequired ? "" : "?"
-			}: ${serializeTypeScriptSchema(value, innerIndentLevel)};`;
-		}
-		result += `\n${indent}}`;
+		result = serializeInterfaceSchema(schema, indentLevel);
 	} else if (isTypeScriptEnum(schema)) {
-		const serializedEnum = JSON.stringify(schema.enum).replace(/\[|\]/g, "").replace(/,/g, " | ");
-		result += schema.isArray && schema.enum.length > 1 ? `(${serializedEnum})` : serializedEnum;
-	} else if (Array.isArray(schema.type)) {
-		const serializedTypes = schema.type.join(" | ");
-		result += schema.isArray ? `(${serializedTypes})` : serializedTypes;
-	} else {
-		result += schema.type;
+		result = serializeEnumSchema(schema);
+	} else if (isTypeScriptBasicType(schema)) {
+		result = serializeBasicTypeSchema(schema);
 	}
-
 	if (schema.isArray) {
 		result += "[]";
 	}
@@ -159,9 +212,11 @@ export function serializeTypeScriptInterface(name: string, schema: TypeScriptInt
 	return `${docComment}export interface ${name} ${serializedSchema}${schema.isRequired ? "" : " | undefined"}`;
 }
 
+const TYPESCRIPT_HEADER_REGEX = /\/\*\*[\s\S]*?\*\//;
+
 export function removeTypeScriptHeader(fileContent: string): string {
 	// Match the first jsdoc and remove it
-	const headerMatch = fileContent.match(/\/\*\*[\s\S]*?\*\//);
+	const headerMatch = fileContent.match(TYPESCRIPT_HEADER_REGEX);
 	if (!headerMatch || headerMatch.index === undefined) {
 		throw new Error("No header found in the TypeScript file");
 	}
@@ -169,149 +224,293 @@ export function removeTypeScriptHeader(fileContent: string): string {
 	return fileContent.slice(headerEndIndex).trim();
 }
 
-function parseInterfaceProperties(body: string): Record<string, TypeScriptSchema> {
-	const properties: Record<string, TypeScriptSchema> = {};
-	let i = 0;
-	let currentDoc: string | undefined;
+const WHITESPACE_REGEX = /\s/;
 
-	while (i < body.length) {
-		const char = body[i];
+function skipWhitespace(body: string, i: number): number {
+	let cursor = i;
+	while (cursor < body.length && WHITESPACE_REGEX.test(body[cursor])) {
+		cursor++;
+	}
+	return cursor;
+}
 
-		// Skip whitespace
-		if (/\s/.test(char)) {
-			i++;
-			continue;
+const TYPESCRIPT_DOC_DECORATIONS_REGEX = /^\s*\*\s?/;
+const TYPESCRIPT_DOC_PREFIX = "/**";
+
+function tryParseJsDoc(body: string, i: number): { doc: string | undefined; nextIndex: number } | null {
+	if (body.slice(i, i + TYPESCRIPT_DOC_PREFIX.length) === TYPESCRIPT_DOC_PREFIX) {
+		const docEnd = body.indexOf("*/", i);
+		if (docEnd !== -1) {
+			const docContent = body.slice(i + TYPESCRIPT_DOC_PREFIX.length, docEnd);
+			const docLines = docContent.split("\n");
+			const cleanDoc = docLines
+				.map((line) => line.replace(TYPESCRIPT_DOC_DECORATIONS_REGEX, "").trim())
+				.filter((line) => line.length > 0)
+				.join(" ");
+			return { doc: cleanDoc || undefined, nextIndex: docEnd + 2 };
 		}
+	}
+	return null;
+}
 
-		// Parse JSDoc comment
-		if (body.slice(i, i + 3) === "/**") {
-			const docEnd = body.indexOf("*/", i);
-			if (docEnd !== -1) {
-				const docContent = body.slice(i + 3, docEnd);
-				const docLines = docContent.split("\n");
-				const cleanDoc = docLines
-					.map((line) => line.replace(/^\s*\*\s?/, "").trim())
-					.filter((line) => line.length > 0)
-					.join(" ");
-				currentDoc = cleanDoc || undefined;
-				i = docEnd + 2;
-				continue;
+function extractTypeString(body: string, i: number): { typeStr: string; isArray: boolean; typeEnd: number } {
+	let braceDepth = 0;
+	let typeEnd = i;
+
+	while (typeEnd < body.length) {
+		const char = body[typeEnd];
+		if (char === "{") {
+			braceDepth++;
+		} else if (char === "}") {
+			braceDepth--;
+			if (braceDepth < 0) {
+				break;
 			}
+		} else if (char === ";" && braceDepth === 0) {
+			break;
 		}
+		typeEnd++;
+	}
 
-		// Parse property
-		const propMatch = body.slice(i).match(/^(\w+)(\?)?:\s*/);
-		if (propMatch) {
-			const propName = propMatch[1];
-			const isRequired = !propMatch[2];
-			i += propMatch[0].length;
-
-			// Find the type
-			const typeStart = i;
-			let braceDepth = 0;
-			let typeEnd = i;
-
-			while (typeEnd < body.length) {
-				const char = body[typeEnd];
-				if (char === "{") {
-					braceDepth++;
-				} else if (char === "}") {
-					braceDepth--;
-					if (braceDepth < 0) {
-						break;
-					}
-				} else if (char === ";" && braceDepth === 0) {
-					break;
-				}
-				typeEnd++;
-			}
-
-			let typeStr = body.slice(typeStart, typeEnd).trim();
-			const isArray = typeStr.endsWith("[]");
-			if (isArray) {
-				typeStr = typeStr.slice(0, -2).trim(); // Remove the "[]" part
-			}
+	let typeStr = body.slice(i, typeEnd).trim();
+	const isArray = typeStr.endsWith("[]");
+	if (isArray) {
+		typeStr = typeStr.slice(0, -2).trim();
+	}
+	return { typeStr, isArray, typeEnd };
+}
 
-			// Parse the type
-			let schema: TypeScriptSchema;
-			if (typeStr.startsWith("{") && typeStr.endsWith("}")) {
-				// Object type
-				const objectBody = typeStr.slice(1, -1); // Remove { and }
-				const nestedProperties = parseInterfaceProperties(objectBody);
-				schema = {
-					doc: currentDoc,
-					isArray,
-					isRequired,
-					properties: nestedProperties,
-				};
-			} else if (typeStr.includes("|")) {
-				const unionBody = isArray
-					? typeStr.slice(1, -1) // Remove ( and )
-					: typeStr;
-				const unionParts = unionBody.split("|").map((part) => part.trim());
-				if (unionParts.every((part) => isAllowedType(part))) {
-					// Multiple primitive types
-					schema = {
-						doc: currentDoc,
-						isArray,
-						isRequired,
-						type: unionParts,
-					};
-				} else {
-					// Enum
-					try {
-						const enumValues = JSON.parse(`[${unionBody.replace(/\|/g, ",")}]`);
-						schema = {
-							doc: currentDoc,
-							isArray,
-							isRequired,
-							enum: enumValues,
-						};
-					} catch {
-						throw new Error(`Invalid enum format for property "${propName}": ${typeStr}`);
-					}
-				}
-			} else {
-				// Primitive type
+function extractSchemaFromText(
+	text: string,
+	currentDoc: string | undefined,
+	isRequired: boolean,
+	isArray: boolean,
+): TypeScriptSchema {
+	let schema: TypeScriptSchema;
+
+	if (text.startsWith("{") && text.endsWith("}")) {
+		const objectBody = text.slice(1, -1);
+		const { properties: nestedProperties, additionalProperties: additionalNestedProperties } =
+			parseInterfaceProperties(objectBody);
+		schema = {
+			doc: currentDoc,
+			isArray,
+			isRequired,
+			properties: nestedProperties,
+			additionalProperties: additionalNestedProperties,
+		};
+	} else if (text.includes("|")) {
+		const unionBody = isArray ? text.slice(1, -1) : text;
+		const unionParts = unionBody.split("|").map((part) => part.trim());
+		if (unionParts.every((part) => isAllowedType(part))) {
+			schema = {
+				doc: currentDoc,
+				isArray,
+				isRequired,
+				type: unionParts,
+			};
+		} else {
+			try {
+				const enumValues = JSON.parse(`[${unionBody.replace(/\|/g, ",")}]`);
 				schema = {
 					doc: currentDoc,
 					isArray,
 					isRequired,
-					type: typeStr,
+					enum: enumValues,
 				};
+			} catch {
+				throw new Error(`Invalid enum format for TypeScript text: ${text}`);
 			}
+		}
+	} else {
+		schema = {
+			doc: currentDoc,
+			isArray,
+			isRequired,
+			type: text,
+		};
+	}
 
-			properties[propName] = schema;
-			currentDoc = undefined;
-			i = typeEnd;
+	return schema;
+}
+
+const TYPESCRIPT_ADDITIONAL_PROPERTIES_REGEX = /^\s*\[\s*key\s*:\s*string\s*\]\s*:\s*/;
+const TYPESCRIPT_PROPERTY_REGEX = /^(\w+)(\?)?:\s*/;
+
+function tryParseProperty(
+	body: string,
+	i: number,
+	currentDoc: string | undefined,
+): { propName?: string; schema: TypeScriptSchema; nextIndex: number } | null {
+	let cursor = i;
+
+	let propName: string | undefined;
+	let isRequired: boolean;
+
+	const bodySlice = body.slice(cursor);
+	const additionalPropertiesMatch = bodySlice.match(TYPESCRIPT_ADDITIONAL_PROPERTIES_REGEX);
+	if (additionalPropertiesMatch) {
+		cursor += additionalPropertiesMatch[0].length;
+		isRequired = true;
+	} else {
+		const propMatch = bodySlice.match(TYPESCRIPT_PROPERTY_REGEX);
+		if (!propMatch) {
+			return null;
+		}
+
+		propName = propMatch[1];
+		isRequired = !propMatch[2];
+		cursor += propMatch[0].length;
+	}
+
+	const { typeStr, isArray, typeEnd } = extractTypeString(body, cursor);
+	const schema = extractSchemaFromText(typeStr, currentDoc, isRequired, isArray);
+
+	let nextIndex = typeEnd;
+	if (body[nextIndex] === ";") {
+		nextIndex++;
+	}
+
+	return { propName, schema, nextIndex };
+}
+
+function parseInterfaceProperties(body: string): {
+	properties: Record<string, TypeScriptSchema>;
+	additionalProperties?: TypeScriptSchema;
+} {
+	const properties: Record<string, TypeScriptSchema> = {};
+	let additionalProperties: TypeScriptSchema | undefined;
+	let i = 0;
+	let currentDoc: string | undefined;
+
+	while (i < body.length) {
+		i = skipWhitespace(body, i);
 
-			// Skip semicolon
-			if (body[i] === ";") {
-				i++;
+		const docResult = tryParseJsDoc(body, i);
+		if (docResult) {
+			currentDoc = docResult.doc;
+			i = docResult.nextIndex;
+			continue;
+		}
+
+		const propResult = tryParseProperty(body, i, currentDoc);
+		if (propResult) {
+			if (propResult.propName) {
+				properties[propResult.propName] = propResult.schema;
+			} else {
+				additionalProperties = propResult.schema;
 			}
-		} else {
-			i++;
+			currentDoc = undefined;
+			i = propResult.nextIndex;
+			continue;
 		}
+
+		i++;
 	}
 
-	return properties;
+	return { properties, additionalProperties };
 }
 
+const TYPESCRIPT_JSDOC_REGEX = /\/\*\*\s*\n\s*\*\s*(.*?)\s*\n\s*\*\//;
+const TYPESCRIPT_INTERFACE_REGEX = /export interface (\w+) \{([\s\S]*)\}$/;
+
 export function parseTypeScriptInterface(text: string): TypeScriptInterface {
 	// Extract JSDoc comment
-	const docMatch = text.match(/\/\*\*\s*\n\s*\*\s*(.*?)\s*\n\s*\*\//);
+	const docMatch = text.match(TYPESCRIPT_JSDOC_REGEX);
 	const doc = docMatch ? docMatch[1] : undefined;
 
 	// Extract interface declaration
-	const interfaceMatch = text.match(/export interface (\w+) \{([\s\S]*)\}$/);
+	const interfaceMatch = text.match(TYPESCRIPT_INTERFACE_REGEX);
 	if (!interfaceMatch) {
 		throw new Error("Invalid TypeScript interface format");
 	}
 
 	const body = interfaceMatch[2];
-	const properties = parseInterfaceProperties(body);
+	const { properties, additionalProperties } = parseInterfaceProperties(body);
+
+	return { doc, isArray: false, isRequired: true, properties, additionalProperties };
+}
+
+function compareInterfaceProperty(
+	key: string,
+	propA: TypeScriptInterface,
+	propB: TypeScriptSchema,
+	ignoreDocs?: boolean,
+): boolean {
+	if (!isTypeScriptInterface(propB)) {
+		console.error(`Property "${key}" is an interface in one schema but not in the other.`);
+		return false;
+	}
+	if (!compareTypescriptInterfaces(propA, propB, ignoreDocs)) {
+		console.error(`Property "${key}" interfaces do not match.`);
+		return false;
+	}
+	return true;
+}
+
+function compareEnumProperty(key: string, propA: TypeScriptSchema, propB: TypeScriptSchema): boolean {
+	if (!isTypeScriptEnum(propB)) {
+		console.error(`Property "${key}" is an enum in one schema but not in the other.`);
+		return false;
+	}
+	if (JSON.stringify((propA as TypeScriptEnum).enum) !== JSON.stringify((propB as TypeScriptEnum).enum)) {
+		console.error(
+			`Property "${key}" enums do not match: ${JSON.stringify((propA as TypeScriptEnum).enum)} vs ${JSON.stringify((propB as TypeScriptEnum).enum)}`,
+		);
+		return false;
+	}
+	return true;
+}
 
-	return { doc, isArray: false, isRequired: true, properties };
+function compareBasicTypeProperty(key: string, propA: TypeScriptSchema, propB: TypeScriptSchema): boolean {
+	if (!isTypeScriptBasicType(propB)) {
+		console.error(`Property "${key}" is a basic type in one schema but not in the other.`);
+		return false;
+	}
+	if (!equals((propA as TypeScriptBasicType).type, (propB as TypeScriptBasicType).type)) {
+		console.error(
+			`Property "${key}" types do not match: ${JSON.stringify((propA as TypeScriptBasicType).type)} vs ${JSON.stringify((propB as TypeScriptBasicType).type)}`,
+		);
+		return false;
+	}
+	return true;
+}
+
+function compareProperty(key: string, propA: TypeScriptSchema, propB: TypeScriptSchema, ignoreDocs?: boolean): boolean {
+	if (propA.isArray !== propB.isArray) {
+		console.error(`Property "${key}" has different array status: ${propA.isArray} vs ${propB.isArray}`);
+		return false;
+	}
+
+	if (propA.isRequired !== propB.isRequired) {
+		console.error(`Property "${key}" has different required status: ${propA.isRequired} vs ${propB.isRequired}`);
+		return false;
+	}
+
+	if (!ignoreDocs && propA.doc !== propB.doc) {
+		console.error(`Property "${key}" has different documentation: "${propA.doc}" vs "${propB.doc}"`);
+		return false;
+	}
+
+	if (isTypeScriptInterface(propA)) {
+		return compareInterfaceProperty(key, propA, propB, ignoreDocs);
+	}
+	if (isTypeScriptEnum(propA)) {
+		return compareEnumProperty(key, propA, propB);
+	}
+	return compareBasicTypeProperty(key, propA, propB);
+}
+
+function compareAdditionalProperties(a: TypeScriptInterface, b: TypeScriptInterface, ignoreDocs?: boolean): boolean {
+	if (!(a.additionalProperties || b.additionalProperties)) {
+		return true; // Both have no additional properties
+	}
+	if (!(a.additionalProperties && b.additionalProperties)) {
+		console.error(`One interface has additionalProperties defined, but the other does not.
+If you generated an interface from a JSON schema, pay attention that "additionalProperties" is set to an empty schema by default.`);
+		return false;
+	}
+	return compareProperty("[key: string]", a.additionalProperties, b.additionalProperties, ignoreDocs);
 }
 
 export function compareTypescriptInterfaces(
@@ -325,57 +524,21 @@ export function compareTypescriptInterfaces(
 	}
 
 	for (const key in a.properties) {
-		if (!(key in b.properties)) {
-			return false;
-		}
-		const propA = a.properties[key];
-		const propB = b.properties[key];
-
-		if (propA.isArray !== propB.isArray) {
-			console.error(`Property "${key}" has different array status: ${propA.isArray} vs ${propB.isArray}`);
-			return false;
-		}
-
-		if (propA.isRequired !== propB.isRequired) {
-			console.error(`Property "${key}" has different required status: ${propA.isRequired} vs ${propB.isRequired}`);
-			return false;
-		}
-
-		if (!ignoreDocs && propA.doc !== propB.doc) {
-			console.error(`Property "${key}" has different documentation: "${propA.doc}" vs "${propB.doc}"`);
-			return false;
-		}
-
-		if (isTypeScriptInterface(propA)) {
-			if (!isTypeScriptInterface(propB)) {
-				console.error(`Property "${key}" is an interface in one schema but not in the other.`);
-				return false;
-			}
-			if (!compareTypescriptInterfaces(propA, propB, ignoreDocs)) {
-				console.error(`Property "${key}" interfaces do not match.`);
+		if (Object.hasOwn(a.properties, key)) {
+			if (!(key in b.properties)) {
 				return false;
 			}
-		} else if (isTypeScriptEnum(propA)) {
-			if (!isTypeScriptEnum(propB)) {
-				console.error(`Property "${key}" is an enum in one schema but not in the other.`);
+			const propA = a.properties[key];
+			const propB = b.properties[key];
+			if (!compareProperty(key, propA, propB, ignoreDocs)) {
 				return false;
 			}
-			if (JSON.stringify(propA.enum) !== JSON.stringify(propB.enum)) {
-				console.error(
-					`Property "${key}" enums do not match: ${JSON.stringify(propA.enum)} vs ${JSON.stringify(propB.enum)}`,
-				);
-				return false;
-			}
-		} else if (!isTypeScriptBasicType(propB)) {
-			console.error(`Property "${key}" is a basic type in one schema but not in the other.`);
-			return false;
-		} else if (!R.equals(propA.type, propB.type)) {
-			console.error(
-				`Property "${key}" types do not match: ${JSON.stringify(propA.type)} vs ${JSON.stringify(propB.type)}`,
-			);
-			return false;
 		}
 	}
 
+	if (!compareAdditionalProperties(a, b, ignoreDocs)) {
+		return false;
+	}
+
 	return true;
 }