Automattic\WooCommerce\Vendor\GraphQL\Utils

BreakingChangesFinder::findArgChanges │ public static │ WC 1.0

Given two schemas, returns an Array containing descriptions of any breaking or dangerous changes in the newSchema related to arguments (such as removal or change of type of an argument, or a change in an argument's default value).

Method of the class: BreakingChangesFinder{}

No Hooks.

Returns

Changes.

Usage

$result = BreakingChangesFinder::findArgChanges( $oldSchema, $newSchema ): array;

$oldSchema(Schema) (required)

.

$newSchema(Schema) (required)

.

BreakingChangesFinder::findArgChanges() BreakingChangesFinder::findArgChanges code ^{WC 10.9.1}

public static function findArgChanges(
    Schema $oldSchema,
    Schema $newSchema
): array {
    $oldTypeMap = $oldSchema->getTypeMap();
    $newTypeMap = $newSchema->getTypeMap();

    $breakingChanges = [];
    $dangerousChanges = [];

    foreach ($oldTypeMap as $typeName => $oldType) {
        $newType = $newTypeMap[$typeName] ?? null;
        if (
            ! $oldType instanceof ObjectType && ! $oldType instanceof InterfaceType
            || ! $newType instanceof ObjectType && ! $newType instanceof InterfaceType
            || ! ($newType instanceof $oldType)
        ) {
            continue;
        }

        $oldTypeFields = $oldType->getFields();
        $newTypeFields = $newType->getFields();

        foreach ($oldTypeFields as $fieldName => $oldField) {
            if (! isset($newTypeFields[$fieldName])) {
                continue;
            }

            foreach ($oldField->args as $oldArgDef) {
                $newArgDef = null;
                foreach ($newTypeFields[$fieldName]->args as $newArg) {
                    if ($newArg->name === $oldArgDef->name) {
                        $newArgDef = $newArg;
                    }
                }

                if ($newArgDef !== null) {
                    $isSafe = self::isChangeSafeForInputObjectFieldOrFieldArg(
                        $oldArgDef->getType(),
                        $newArgDef->getType()
                    );
                    $oldArgType = $oldArgDef->getType();
                    $oldArgName = $oldArgDef->name;
                    if (! $isSafe) {
                        $newArgType = $newArgDef->getType();
                        $breakingChanges[] = [
                            'type' => self::BREAKING_CHANGE_ARG_CHANGED_KIND,
                            'description' => "{$typeName}.{$fieldName} arg {$oldArgName} has changed type from {$oldArgType} to {$newArgType}",
                        ];
                    } elseif ($oldArgDef->defaultValueExists() && $oldArgDef->defaultValue !== $newArgDef->defaultValue) {
                        $dangerousChanges[] = [
                            'type' => self::DANGEROUS_CHANGE_ARG_DEFAULT_VALUE_CHANGED,
                            'description' => "{$typeName}.{$fieldName} arg {$oldArgName} has changed defaultValue",
                        ];
                    }
                } else {
                    $breakingChanges[] = [
                        'type' => self::BREAKING_CHANGE_ARG_REMOVED,
                        'description' => "{$typeName}.{$fieldName} arg {$oldArgDef->name} was removed",
                    ];
                }

                // Check if arg was added to the field
                foreach ($newTypeFields[$fieldName]->args as $newTypeFieldArgDef) {
                    $oldArgDef = null;
                    foreach ($oldTypeFields[$fieldName]->args as $oldArg) {
                        if ($oldArg->name === $newTypeFieldArgDef->name) {
                            $oldArgDef = $oldArg;
                        }
                    }

                    if ($oldArgDef !== null) {
                        continue;
                    }

                    $newTypeName = $newType->name;
                    $newArgName = $newTypeFieldArgDef->name;
                    if ($newTypeFieldArgDef->isRequired()) {
                        $breakingChanges[] = [
                            'type' => self::BREAKING_CHANGE_REQUIRED_ARG_ADDED,
                            'description' => "A required arg {$newArgName} on {$newTypeName}.{$fieldName} was added",
                        ];
                    } else {
                        $dangerousChanges[] = [
                            'type' => self::DANGEROUS_CHANGE_OPTIONAL_ARG_ADDED,
                            'description' => "An optional arg {$newArgName} on {$newTypeName}.{$fieldName} was added",
                        ];
                    }
                }
            }
        }
    }

    return [
        'breakingChanges' => $breakingChanges,
        'dangerousChanges' => $dangerousChanges,
    ];
}