Function resolveObjectSchema

scripts/codegen/utils.ts:1106–1151

(
    schema: JSONSchema7 | null | undefined,
    definitions: DefinitionCollections | undefined
)

}

export function resolveObjectSchema(
    schema: JSONSchema7 | null | undefined,
    definitions: DefinitionCollections | undefined
): JSONSchema7 | undefined {
    const resolved = resolveSchema(schema, definitions) ?? schema ?? undefined;
    if (!resolved) return undefined;
    const resolvedHasObjectShape = hasObjectShape(resolved);

    if (resolved.allOf) {
        const objectSchemas: JSONSchema7[] = [];
        if (resolvedHasObjectShape) {
            objectSchemas.push(resolved);
        }

        for (const item of resolved.allOf) {
            if (typeof item !== "object") continue;
            const objectSchema = resolveObjectSchema(item as JSONSchema7, definitions);
            if (!objectSchema) continue;
            objectSchemas.push(objectSchema);
        }

        return mergeObjectSchemas(objectSchemas) ?? resolved;
    }

    const singleBranch = (resolved.anyOf ?? resolved.oneOf)
        ?.filter((item): item is JSONSchema7 => {
            if (!item || typeof item !== "object") return false;
            const s = item as JSONSchema7;
            // Filter out null types and `{ not: {} }` (Zod's representation of "nothing" in optional anyOf)
            if (s.type === "null") return false;
            if (isEmptyNotSchema(s)) return false;
            return true;
        });
    if (singleBranch && singleBranch.length === 1) {
        const objectSchema = resolveObjectSchema(singleBranch[0], definitions);
        if (!objectSchema) return resolved;
        if (resolvedHasObjectShape) {
            return mergeObjectSchemas([resolved, objectSchema]) ?? objectSchema;
        }
        return objectSchema;
    }

    if (resolvedHasObjectShape) return resolved;

    return resolved;
}

export function getSessionEventVariantSchemas(
    schema: JSONSchema7,