first commit

wp-content/plugins/elementor/modules/variables/storage/entities/variable.php

@@ -0,0 +1,149 @@
+<?php
+
+namespace Elementor\Modules\Variables\Storage\Entities;
+
+use Elementor\Modules\Variables\Adapters\Prop_Type_Adapter;
+use Elementor\Modules\Variables\PropTypes\Size_Variable_Prop_Type;
+use Elementor\Modules\Variables\Storage\Exceptions\Type_Mismatch;
+use InvalidArgumentException;
+
+class Variable {
+	private array $data;
+
+	private function __construct( array $data ) {
+		$this->data = $data;
+	}
+
+	public static function create_new( array $data ): self {
+		$now = gmdate( 'Y-m-d H:i:s' );
+
+		$data['created_at'] = $now;
+		$data['updated_at'] = $now;
+
+		return self::from_array( $data );
+	}
+
+	public static function from_array( array $data ): self {
+		$required = [ 'id', 'type', 'label', 'value' ];
+
+		foreach ( $required as $key ) {
+			if ( ! array_key_exists( $key, $data ) ) {
+				throw new InvalidArgumentException(
+					sprintf(
+						"Missing required field '%s' in %s::from_array()",
+						esc_html( $key ),
+						self::class
+					)
+				);
+			}
+		}
+
+		return new self( $data );
+	}
+
+	public function soft_delete(): void {
+		$this->data['deleted_at'] = $this->now();
+	}
+
+	public function restore(): void {
+		unset( $this->data['deleted_at'] );
+		// TODO to be removed if client is no longer need this
+		unset( $this->data['deleted'] );
+
+		$this->data['updated_at'] = $this->now();
+	}
+
+	private function now() {
+		return gmdate( 'Y-m-d H:i:s' );
+	}
+
+	public function to_array(): array {
+		return array_diff_key( $this->data, array_flip( [ 'id' ] ) );
+	}
+
+	public function id(): string {
+		return $this->data['id'];
+	}
+
+	public function label(): string {
+		return $this->data['label'];
+	}
+
+	public function order(): int {
+		return $this->data['order'];
+	}
+
+	public function value() {
+		return $this->data['value'];
+	}
+
+	public function set_value( $value ) {
+		$this->data['value'] = $value;
+	}
+
+	public function type() {
+		return $this->data['type'];
+	}
+
+	public function set_type( $type ) {
+		$this->data['type'] = $type;
+	}
+
+	public function has_order(): int {
+		return isset( $this->data['order'] );
+	}
+
+	public function is_deleted(): bool {
+		return isset( $this->data['deleted_at'] );
+	}
+
+	/**
+	 * @throws Type_Mismatch If a type that is not allowed to be changed is passed.
+	 */
+	private function maybe_apply_type( array $data ) {
+		if ( ! array_key_exists( 'type', $data ) ) {
+			return false;
+		}
+
+		$current_type = $this->type();
+		$target_type  = $data['type'];
+
+		if ( $current_type === $target_type ) {
+			return false;
+		}
+
+		$custom_size_prop_type = Prop_Type_Adapter::GLOBAL_CUSTOM_SIZE_VARIABLE_KEY;
+		$size_prop_type = Size_Variable_Prop_Type::get_key();
+
+		$allowed_types = [ $custom_size_prop_type, $size_prop_type ];
+
+		$is_valid_transition =
+			in_array( $current_type, $allowed_types, true ) &&
+			in_array( $target_type, $allowed_types, true );
+
+		if ( ! $is_valid_transition ) {
+			throw new Type_Mismatch( 'Type change is forbidden' );
+		}
+
+		$this->set_type( $data['type'] );
+
+		return true;
+	}
+
+	public function apply_changes( array $data ): void {
+		$allowed_fields = [ 'label', 'value', 'order', 'type' ];
+		$has_changes = $this->maybe_apply_type( $data );
+
+		foreach ( $allowed_fields as $field ) {
+			if ( isset( $data[ $field ] ) ) {
+				$this->data[ $field ] = $data[ $field ];
+
+				$has_changes = true;
+			}
+		}
+
+		if ( $has_changes ) {
+			$this->data['updated_at'] = $this->now();
+		}
+	}
+}

wp-content/plugins/elementor/modules/variables/storage/exceptions/batch-operation-failed.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace Elementor\Modules\Variables\Storage\Exceptions;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class BatchOperationFailed extends \Exception {
+	private array $error_details;
+
+	public function __construct( string $message, array $error_details = [] ) {
+		parent::__construct( $message );
+		$this->error_details = $error_details;
+	}
+
+	public function getErrorDetails(): array {
+		return $this->error_details;
+	}
+}

wp-content/plugins/elementor/modules/variables/storage/exceptions/duplicated-label.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Elementor\Modules\Variables\Storage\Exceptions;
+
+use Exception;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class DuplicatedLabel extends Exception {}

wp-content/plugins/elementor/modules/variables/storage/exceptions/fatal-error.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Elementor\Modules\Variables\Storage\Exceptions;
+
+use Exception;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class FatalError extends Exception {}

wp-content/plugins/elementor/modules/variables/storage/exceptions/record-not-found.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Elementor\Modules\Variables\Storage\Exceptions;
+
+use Exception;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class RecordNotFound extends Exception {}

wp-content/plugins/elementor/modules/variables/storage/exceptions/type-mismatch.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Elementor\Modules\Variables\Storage\Exceptions;
+
+use Exception;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class Type_Mismatch extends Exception {}

wp-content/plugins/elementor/modules/variables/storage/exceptions/variables-limit-reached.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Elementor\Modules\Variables\Storage\Exceptions;
+
+use Exception;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class VariablesLimitReached extends Exception {}

wp-content/plugins/elementor/modules/variables/storage/repository.php

@@ -0,0 +1,504 @@
+<?php
+
+namespace Elementor\Modules\Variables\Storage;
+
+use Elementor\Core\Kits\Documents\Kit;
+use Elementor\Modules\AtomicWidgets\Utils\Utils;
+use Elementor\Modules\Variables\Storage\Exceptions\DuplicatedLabel;
+use Elementor\Modules\Variables\Storage\Exceptions\RecordNotFound;
+use Elementor\Modules\Variables\Storage\Exceptions\VariablesLimitReached;
+use Elementor\Modules\Variables\Storage\Exceptions\FatalError;
+use Elementor\Modules\Variables\Storage\Exceptions\BatchOperationFailed;
+use Exception;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class Repository {
+	// TODO: deleted this class later after this PR
+	const TOTAL_VARIABLES_COUNT = 100;
+	const FORMAT_VERSION_V1 = 1;
+	const VARIABLES_META_KEY = '_elementor_global_variables';
+	private Kit $kit;
+
+	public function __construct( Kit $kit ) {
+		$this->kit = $kit;
+	}
+
+	/**
+	 * @throws VariablesLimitReached If database connection fails or query execution errors occur.
+	 */
+	private function assert_if_variables_limit_reached( array $db_record ) {
+		$variables_in_use = 0;
+
+		foreach ( $db_record['data'] as $variable ) {
+			if ( isset( $variable['deleted'] ) && $variable['deleted'] ) {
+				continue;
+			}
+
+			++$variables_in_use;
+		}
+
+		if ( self::TOTAL_VARIABLES_COUNT < $variables_in_use ) {
+			throw new VariablesLimitReached( 'Total variables count limit reached' );
+		}
+	}
+
+	/**
+	 * @throws DuplicatedLabel If variable creation fails or validation errors occur.
+	 */
+	private function assert_if_variable_label_is_duplicated( array $db_record, array $variable = [] ) {
+		foreach ( $db_record['data'] as $id => $existing_variable ) {
+			if ( isset( $existing_variable['deleted'] ) && $existing_variable['deleted'] ) {
+				continue;
+			}
+
+			if ( isset( $variable['id'] ) && $variable['id'] === $id ) {
+				continue;
+			}
+
+			if ( ! isset( $variable['label'] ) || ! isset( $existing_variable['label'] ) ) {
+				continue;
+			}
+
+			if ( strtolower( $existing_variable['label'] ) === strtolower( $variable['label'] ) ) {
+				throw new DuplicatedLabel( 'Variable label already exists' );
+			}
+		}
+	}
+
+	public function variables(): array {
+		$db_record = $this->load();
+
+		return $db_record['data'] ?? [];
+	}
+
+	public function load(): array {
+		$db_record = $this->kit->get_json_meta( static::VARIABLES_META_KEY );
+
+		if ( is_array( $db_record ) && ! empty( $db_record ) ) {
+			return $db_record;
+		}
+
+		return $this->get_default_meta();
+	}
+
+	/**
+	 * @throws FatalError If variable update fails or validation errors occur.
+	 */
+	public function create( array $variable ) {
+		$db_record = $this->load();
+
+		$list_of_variables = $db_record['data'] ?? [];
+
+		$id = $this->new_id_for( $list_of_variables );
+		$new_variable = $this->extract_from( $variable, [
+			'type',
+			'label',
+			'value',
+			'order',
+		] );
+
+		if ( ! isset( $new_variable['order'] ) ) {
+			$new_variable['order'] = $this->get_next_order( $list_of_variables );
+		}
+
+		$this->assert_if_variable_label_is_duplicated( $db_record, $new_variable );
+
+		$list_of_variables[ $id ] = $new_variable;
+		$db_record['data'] = $list_of_variables;
+
+		$this->assert_if_variables_limit_reached( $db_record );
+
+		$watermark = $this->save( $db_record );
+
+		if ( false === $watermark ) {
+			throw new FatalError( 'Failed to create variable' );
+		}
+
+		return [
+			'variable' => array_merge( [ 'id' => $id ], $list_of_variables[ $id ] ),
+			'watermark' => $watermark,
+		];
+	}
+
+	/**
+	 * @throws RecordNotFound If variable deletion fails or database errors occur.
+	 * @throws FatalError If variable deletion fails or database errors occur.
+	 */
+	public function update( string $id, array $variable ) {
+		$db_record = $this->load();
+
+		$list_of_variables = $db_record['data'] ?? [];
+
+		if ( ! isset( $list_of_variables[ $id ] ) ) {
+			throw new RecordNotFound( 'Variable not found' );
+		}
+
+		$updated_variable = array_merge( $list_of_variables[ $id ], $this->extract_from( $variable, [
+			'label',
+			'value',
+			'order',
+		] ) );
+
+		$this->assert_if_variable_label_is_duplicated( $db_record, array_merge( $updated_variable, [ 'id' => $id ] ) );
+
+		$list_of_variables[ $id ] = $updated_variable;
+		$db_record['data'] = $list_of_variables;
+
+		$watermark = $this->save( $db_record );
+
+		if ( false === $watermark ) {
+			throw new FatalError( 'Failed to update variable' );
+		}
+
+		return [
+			'variable' => array_merge( [ 'id' => $id ], $list_of_variables[ $id ] ),
+			'watermark' => $watermark,
+		];
+	}
+
+	/**
+	 * @throws RecordNotFound If bulk operation fails or validation errors occur.
+	 * @throws FatalError If bulk operation fails or validation errors occur.
+	 */
+	public function delete( string $id ) {
+		$db_record = $this->load();
+
+		$list_of_variables = $db_record['data'] ?? [];
+
+		if ( ! isset( $list_of_variables[ $id ] ) ) {
+			throw new RecordNotFound( 'Variable not found' );
+		}
+
+		$list_of_variables[ $id ]['deleted'] = true;
+		$list_of_variables[ $id ]['deleted_at'] = $this->now();
+
+		$db_record['data'] = $list_of_variables;
+
+		$watermark = $this->save( $db_record );
+
+		if ( false === $watermark ) {
+			throw new FatalError( 'Failed to delete variable' );
+		}
+
+		return [
+			'variable' => array_merge( [ 'id' => $id ], $list_of_variables[ $id ] ),
+			'watermark' => $watermark,
+		];
+	}
+
+	/**
+	 * @throws RecordNotFound If export operation fails or data serialization errors occur.
+	 * @throws FatalError If export operation fails or data serialization errors occur.
+	 */
+	public function restore( string $id, $overrides = [] ) {
+		$db_record = $this->load();
+
+		$list_of_variables = $db_record['data'] ?? [];
+
+		if ( ! isset( $list_of_variables[ $id ] ) ) {
+			throw new RecordNotFound( 'Variable not found' );
+		}
+
+		$restored_variable = $this->extract_from( $list_of_variables[ $id ], [
+			'label',
+			'value',
+			'type',
+			'order',
+		] );
+
+		if ( array_key_exists( 'label', $overrides ) ) {
+			$restored_variable['label'] = $overrides['label'];
+		}
+
+		if ( array_key_exists( 'value', $overrides ) ) {
+			$restored_variable['value'] = $overrides['value'];
+		}
+
+		$this->assert_if_variable_label_is_duplicated( $db_record, array_merge( $restored_variable, [ 'id' => $id ] ) );
+
+		$list_of_variables[ $id ] = $restored_variable;
+		$db_record['data'] = $list_of_variables;
+
+		$this->assert_if_variables_limit_reached( $db_record );
+
+		$watermark = $this->save( $db_record );
+
+		if ( false === $watermark ) {
+			throw new FatalError( 'Failed to restore variable' );
+		}
+
+		return [
+			'variable' => array_merge( [ 'id' => $id ], $restored_variable ),
+			'watermark' => $watermark,
+		];
+	}
+
+	/**
+	 * Process multiple operations atomically
+	 *
+	 * @throws BatchOperationFailed If batch operation fails or validation errors occur.
+	 * @throws FatalError If batch operation fails or validation errors occur.
+	 */
+	public function process_atomic_batch( array $operations, int $expected_watermark ): array {
+		$db_record = $this->load();
+		$results = [];
+		$errors = [];
+
+		foreach ( $operations as $index => $operation ) {
+			try {
+				$result = $this->process_single_operation( $db_record, $operation );
+				$results[] = $result;
+			} catch ( Exception $e ) {
+				$operation_id = $this->get_operation_identifier( $operation, $index );
+				$errors[ $operation_id ] = [
+					'status' => $this->get_error_status_code( $e ),
+					'code' => $this->get_error_code( $e ),
+					'message' => $e->getMessage(),
+				];
+			}
+		}
+
+		if ( ! empty( $errors ) ) {
+			$error_details = [];
+
+			foreach ( $errors as $operation_id => $error ) {
+				$error_details[ esc_html( $operation_id ) ] = [
+					'status' => (int) $error['status'],
+					'code' => $error['code'],
+					'message' => esc_html( $error['message'] ),
+				];
+			}
+
+			// phpcs:ignore WordPress.Security.EscapeOutput.ExceptionNotEscaped
+			throw new BatchOperationFailed( 'Batch operation failed', $error_details );
+		}
+
+		$watermark = $this->save( $db_record );
+
+		if ( false === $watermark ) {
+			throw new FatalError( 'Failed to save batch operations' );
+		}
+
+		return [
+			'success' => true,
+			'watermark' => $watermark,
+			'results' => $results,
+		];
+	}
+
+	private function process_single_operation( array &$db_record, array $operation ): array {
+		switch ( $operation['type'] ) {
+			case 'create':
+				return $this->process_create_operation( $db_record, $operation );
+
+			case 'update':
+				return $this->process_update_operation( $db_record, $operation );
+
+			case 'delete':
+				return $this->process_delete_operation( $db_record, $operation );
+
+			case 'restore':
+				return $this->process_restore_operation( $db_record, $operation );
+
+			default:
+				throw new BatchOperationFailed( 'Invalid operation type: ' . esc_html( $operation['type'] ), [] );
+		}
+	}
+
+	private function process_create_operation( array &$db_record, array $operation ): array {
+		$variable_data = $operation['variable'];
+
+		$temp_id = $variable_data['id'] ?? null;
+		$new_variable = $this->extract_from( $variable_data, [ 'type', 'label', 'value', 'order' ] );
+
+		if ( ! isset( $new_variable['order'] ) ) {
+			$new_variable['order'] = $this->get_next_order( $db_record['data'] );
+		}
+
+		$this->assert_if_variable_label_is_duplicated( $db_record, $new_variable );
+
+		$this->assert_if_variables_limit_reached( $db_record );
+
+		$id = $this->new_id_for( $db_record['data'] );
+		$now = $this->now();
+
+		$new_variable['created_at'] = $now;
+		$new_variable['updated_at'] = $now;
+
+		$db_record['data'][ $id ] = $new_variable;
+
+		return [
+			'id' => $id,
+			'type' => 'create',
+			'variable' => array_merge( [ 'id' => $id ], $new_variable ),
+			'temp_id' => $temp_id,
+		];
+	}
+
+	private function process_update_operation( array &$db_record, array $operation ): array {
+		$id = $operation['id'];
+		$variable_data = $operation['variable'];
+
+		if ( ! isset( $db_record['data'][ $id ] ) ) {
+			throw new RecordNotFound( 'Variable not found' );
+		}
+
+		$updated_fields = $this->extract_from( $variable_data, [ 'label', 'value', 'order' ] );
+		$updated_variable = array_merge( $db_record['data'][ $id ], $updated_fields );
+		$updated_variable['updated_at'] = $this->now();
+
+		$this->assert_if_variable_label_is_duplicated( $db_record, array_merge( $updated_variable, [ 'id' => $id ] ) );
+
+		$db_record['data'][ $id ] = $updated_variable;
+
+		return [
+			'id' => $id,
+			'type' => 'update',
+			'variable' => array_merge( [ 'id' => $id ], $updated_variable ),
+		];
+	}
+
+	private function process_delete_operation( array &$db_record, array $operation ): array {
+		$id = $operation['id'];
+
+		if ( ! isset( $db_record['data'][ $id ] ) ) {
+			throw new RecordNotFound( 'Variable not found' );
+		}
+
+		$db_record['data'][ $id ]['deleted'] = true;
+		$db_record['data'][ $id ]['deleted_at'] = $this->now();
+
+		return [
+			'id' => $id,
+			'type' => 'delete',
+			'deleted' => true,
+		];
+	}
+
+	private function process_restore_operation( array &$db_record, array $operation ): array {
+		$id = $operation['id'];
+
+		if ( ! isset( $db_record['data'][ $id ] ) ) {
+			throw new RecordNotFound( 'Variable not found' );
+		}
+
+		$overrides = [];
+
+		if ( isset( $operation['label'] ) ) {
+			$overrides['label'] = $operation['label'];
+		}
+
+		if ( isset( $operation['value'] ) ) {
+			$overrides['value'] = $operation['value'];
+		}
+
+		$restored_variable = $this->extract_from( $db_record['data'][ $id ], [ 'label', 'value', 'type' ] );
+		$restored_variable = array_merge( $restored_variable, $overrides );
+		$restored_variable['updated_at'] = $this->now();
+
+		$this->assert_if_variable_label_is_duplicated( $db_record, array_merge( $restored_variable, [ 'id' => $id ] ) );
+
+		$this->assert_if_variables_limit_reached( $db_record );
+
+		$db_record['data'][ $id ] = $restored_variable;
+
+		return [
+			'id' => $id,
+			'type' => 'restore',
+			'variable' => array_merge( [ 'id' => $id ], $restored_variable ),
+		];
+	}
+
+	private function get_operation_identifier( array $operation, int $index ): string {
+		if ( 'create' === $operation['type'] && isset( $operation['variable']['id'] ) ) {
+			return $operation['variable']['id'];
+		}
+
+		if ( isset( $operation['id'] ) ) {
+			return $operation['id'];
+		}
+
+		return "operation_{$index}";
+	}
+
+	private function get_error_status_code( Exception $e ): int {
+		if ( $e instanceof RecordNotFound ) {
+			return 404;
+		}
+
+		if ( $e instanceof DuplicatedLabel || $e instanceof VariablesLimitReached ) {
+			return 400;
+		}
+
+		return 500;
+	}
+
+	private function get_error_code( Exception $e ): string {
+		if ( $e instanceof VariablesLimitReached ) {
+			return 'invalid_variable_limit_reached';
+		}
+
+		if ( $e instanceof DuplicatedLabel ) {
+			return 'duplicated_label';
+		}
+
+		if ( $e instanceof RecordNotFound ) {
+			return 'variable_not_found';
+		}
+
+		return 'unexpected_server_error';
+	}
+
+	private function save( array $db_record ) {
+		if ( PHP_INT_MAX === $db_record['watermark'] ) {
+			$db_record['watermark'] = 0;
+		}
+
+		++$db_record['watermark'];
+
+		if ( $this->kit->update_json_meta( static::VARIABLES_META_KEY, $db_record ) ) {
+			return $db_record['watermark'];
+		}
+
+		return false;
+	}
+
+	private function new_id_for( array $list_of_variables ): string {
+		return Utils::generate_id( 'e-gv-', array_keys( $list_of_variables ) );
+	}
+
+	private function now(): string {
+		return gmdate( 'Y-m-d H:i:s' );
+	}
+
+	private function extract_from( array $source, array $fields ): array {
+		return array_intersect_key( $source, array_flip( $fields ) );
+	}
+
+	private function get_default_meta(): array {
+		return [
+			'data' => [],
+			'watermark' => 0,
+			'version' => self::FORMAT_VERSION_V1,
+		];
+	}
+
+	private function get_next_order( array $list_of_variables ): int {
+		$highest_order = 0;
+
+		foreach ( $list_of_variables as $variable ) {
+			if ( isset( $variable['deleted'] ) && $variable['deleted'] ) {
+				continue;
+			}
+
+			if ( isset( $variable['order'] ) && $variable['order'] > $highest_order ) {
+				$highest_order = $variable['order'];
+			}
+		}
+
+		return $highest_order + 1;
+	}
+}

wp-content/plugins/elementor/modules/variables/storage/variables-collection.php

@@ -0,0 +1,172 @@
+<?php
+
+namespace Elementor\Modules\Variables\Storage;
+
+use Elementor\Core\Utils\Collection;
+use Elementor\Modules\AtomicWidgets\Utils\Utils;
+use Elementor\Modules\Variables\Storage\Entities\Variable;
+use Elementor\Modules\Variables\Storage\Exceptions\DuplicatedLabel;
+use Elementor\Modules\Variables\Storage\Exceptions\RecordNotFound;
+use Elementor\Modules\Variables\Storage\Exceptions\VariablesLimitReached;
+
+/**
+ * TODO: a tradeoff when you want to use collection base methods they are
+ * performing immutable process ( creating new instances )
+ * we will see if we need to extend collection as time goes on
+ */
+class Variables_Collection extends Collection {
+	const FORMAT_VERSION_V1 = 1;
+	const FORMAT_VERSION_V2 = 2;
+	const TOTAL_VARIABLES_COUNT = 100;
+
+	private int $watermark;
+
+	private int $version;
+
+	private function __construct( array $items = [], ?int $watermark = 0, ?int $version = null ) {
+		parent::__construct();
+
+		$this->items = $items;
+		$this->watermark = $watermark;
+		$this->version = $version ?? self::FORMAT_VERSION_V1;
+	}
+
+	public static function hydrate( array $record ): self {
+		$variables = [];
+
+		foreach ( $record['data'] ?? [] as $id => $item ) {
+			$data = array_merge( [ 'id' => $id ], $item );
+
+			$variables[ $id ] = Variable::from_array( $data );
+		}
+
+		$watermark = $record['watermark'];
+		$version = $record['version'] ?? null;
+
+		return new self( $variables, $watermark, $version );
+	}
+
+	public function serialize( bool $include_deleted_key = false ): array {
+		$data = [];
+
+		foreach ( $this->all() as $variable ) {
+			$var = $variable->to_array();
+
+			if ( $include_deleted_key && $variable->is_deleted() ) {
+				$var['deleted'] = true;
+			}
+
+			$data[ $variable->id() ] = $var;
+		}
+
+		return [
+			'data' => $data,
+			'watermark' => $this->watermark,
+			'version' => $this->version,
+		];
+	}
+
+
+	public function set_version( $version ): void {
+		$this->version = $version;
+	}
+
+
+	public static function default(): self {
+		return new self(
+			[],
+			0,
+			self::FORMAT_VERSION_V1
+		);
+	}
+
+	public function watermark(): int {
+		return $this->watermark;
+	}
+
+	private function reset_watermark() {
+		$this->watermark = 0;
+	}
+
+	public function increment_watermark() {
+		if ( PHP_INT_MAX === $this->watermark ) {
+			$this->reset_watermark();
+		}
+
+		++$this->watermark;
+	}
+
+	public function add_variable( Variable $variable ): void {
+		$this->items[ $variable->id() ] = $variable;
+	}
+
+	/**
+	 * @throws RecordNotFound When a variable is not found.
+	 */
+	public function find_or_fail( string $id ): Variable {
+		$variable = $this->get( $id );
+
+		if ( ! isset( $variable ) ) {
+			throw new RecordNotFound( 'Variable not found' );
+		}
+
+		return $variable;
+	}
+
+	/**
+	 * @throws DuplicatedLabel If there is a duplicate label in the database.
+	 */
+	public function assert_label_is_unique( string $label, ?string $ignore_id = null ): void {
+		foreach ( $this->all() as $variable ) {
+			if ( $variable->is_deleted() ) {
+				continue;
+			}
+
+			if ( null !== $ignore_id && $variable->id() === $ignore_id ) {
+				continue;
+			}
+
+			if ( strcasecmp( $variable->label(), $label ) === 0 ) {
+				throw new DuplicatedLabel( esc_html( "Variable label '$label' already exists." ) );
+			}
+		}
+	}
+
+	/**
+	 * @throws VariablesLimitReached If variable limit reached.
+	 */
+	public function assert_limit_not_reached(): void {
+		$active_count = 0;
+
+		foreach ( $this->all() as $variable ) {
+			if ( ! $variable->is_deleted() ) {
+				++$active_count;
+			}
+		}
+
+		if ( self::TOTAL_VARIABLES_COUNT <= $active_count ) {
+			throw new VariablesLimitReached( 'Total variables count limit reached' );
+		}
+	}
+
+	public function next_id(): string {
+		return Utils::generate_id( 'e-gv-', array_keys( $this->all() ) );
+	}
+
+
+	public function get_next_order(): int {
+		$highest_order = 0;
+
+		foreach ( $this->all() as $variable ) {
+			if ( $variable->is_deleted() ) {
+				continue;
+			}
+
+			if ( $variable->has_order() && $variable->order() > $highest_order ) {
+				$highest_order = $variable->order();
+			}
+		}
+
+		return $highest_order + 1;
+	}
+}

wp-content/plugins/elementor/modules/variables/storage/variables-repository.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace Elementor\Modules\Variables\Storage;
+
+use Elementor\Core\Kits\Documents\Kit;
+use Elementor\Modules\Variables\Adapters\Prop_Type_Adapter;
+
+class Variables_Repository {
+	private const VARIABLES_META_KEY = '_elementor_global_variables';
+
+	private Kit $kit;
+
+	public function __construct( Kit $kit ) {
+		$this->kit = $kit;
+	}
+
+	public function load(): Variables_Collection {
+		$db_record = $this->kit->get_json_meta( self::VARIABLES_META_KEY );
+
+		if ( is_array( $db_record ) && ! empty( $db_record ) ) {
+			$collection = Variables_Collection::hydrate( $db_record );
+
+			Prop_Type_Adapter::from_storage( $collection );
+
+			return $collection;
+		}
+
+		return Variables_Collection::default();
+	}
+
+	public function save( Variables_Collection $collection ) {
+		$collection->increment_watermark();
+
+		$record = Prop_Type_Adapter::to_storage( $collection );
+
+		if ( $this->kit->update_json_meta( static::VARIABLES_META_KEY, $record ) ) {
+			return $collection->watermark();
+		}
+
+		return false;
+	}
+}