Импортируем категории товаров

Модель Language

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\Relations\HasManyThrough;

/**php
 * @property string $lang
 * @property string $title
 * @property bool $active
 * @property int $rank
 *
 * @property-read CategoryTranslation[] $categoriesTranslations
 * @property-read Category[] $categories
 */
class Language extends Model
{
    public $timestamps = false;
    protected $primaryKey = 'lang';
    protected $keyType = 'string';
    protected $fillable = ['code', 'title', 'active', 'rank'];
    protected $casts = [
        'active' => 'boolean',
    ];

    public function categoriesTranslations(): HasMany
    {
        return $this->hasMany(CategoryTranslation::class, 'lang');
    }

    public function categories(): HasManyThrough
    {
        return $this->hasManyThrough(
            Category::class,
            CategoryTranslation::class,
            'lang',
            'id',
            'lang',
            'category_id'
        );
    }
}

Модель CategoryTranslation

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;

/**
 * @property int $category_id
 * @property string $lang
 * @property string $title
 * @property string $description
 *
 * @property-read Category $category
 * @property-read Language $language
 */
class CategoryTranslation extends Model
{
    use Traits\CompositeKey;

    public $timestamps = false;
    protected $primaryKey = ['category_id', 'lang'];
    protected $fillable = ['category_id', 'lang', 'title', 'description'];

    public function category(): BelongsTo
    {
        return $this->belongsTo(Category::class);
    }

    public function language(): BelongsTo
    {
        return $this->belongsTo(Language::class, 'lang');
    }
}

Модель Category

/**
 * @property int $id
 * @property int $parent_id
 * @property ?int $file_id
 * @property string $alias
 * @property string $uri
 * @property bool $active
 * @property int $rank
 * @property int $remote_id
 * @property Carbon $created_at
 * @property Carbon $updated_at
 *
 * @property-read Category $parent
 * @property-read CategoryTranslation[] $translations
 * @property-read File $file
 * @property-read Category[] $children
 * @property-read Product[] $products
 */

    protected static function booted(): void
    {
        static::saving(static function (self $model) {
            $uri = [$model->alias];
            if ($model->parent) {
                array_unshift($uri, $model->parent->uri);
            }
            $model->uri = implode('/', $uri);
        });
    }

    public function parent(): BelongsTo
    {
        return $this->belongsTo(__CLASS__);
    }

    public function translations(): HasMany
    {
        return $this->hasMany(CategoryTranslation::class);
    }

    public function file(): BelongsTo
    {
        return $this->belongsTo(File::class);
    }

    public function children(): HasMany
    {
        return $this->hasMany(__CLASS__, 'parent_id');
    }

    public function products(): HasMany
    {
        return $this->hasMany(Product::class);
    }

Засеиваем языки

<?php

use App\Models\Language;
use Phinx\Seed\AbstractSeed;

class Languages extends AbstractSeed
{
    protected array $data = [
        'ru' => [
            'title' => 'Русский',
            'rank' => 0,
        ],
        'en' => [
            'title' => 'English',
            'rank' => 1,
        ],
    ];

    public function run(): void
    {
        foreach ($this->data as $id => $data) {
            /** @var Language $record */
            if (!$record = Language::query()->find($id)) {
                $record = new Language();
                $record->lang = $id;
            }
            $record->fill($data);
            $record->save();
        }
    }
}

Импортируем категории из miniShop2

<?php

use App\Models\Category;
use App\Models\File;
use Phinx\Seed\AbstractSeed;
use Slim\Psr7\UploadedFile;
use Vesp\Services\Eloquent;

class Categories extends AbstractSeed
{
    public function getDependencies(): array
    {
        return ['Languages'];
    }

    public function run(): void
    {
        $tvImageId = 1;

        // Выбираем категории вместе с переводами и картинками
        $pdo = (new Eloquent())->getDatabaseManager()->getPdo();
        $stmt = $pdo->query(
            "SELECT `r`.*, `tv`.`value` AS `image`, `ln`.`pagetitle` as `pagetitle_fr`, `ln`.`content` as `content_fr`
            FROM `modx_site_content` `r`
            LEFT JOIN `modx_site_tmplvar_contentvalues` `tv` ON `tmplvarid` = '$tvImageId' AND `contentid` = `r`.`id`
            LEFT JOIN `modx_lingua_site_content` `ln` ON `resource_id` = `r`.`id`
            WHERE `class_key` = 'msCategory' ORDER BY `parent`,`r`.`id`"
        );

        $parents = [];
        while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
            // Проверяем наличие категории по remote_id
            if (!$category = Category::query()->where('remote_id', $row['id'])->first()) {
                $category = new Category();
                $category->remote_id = $row['id'];
            }

            // Замолняем основные поля
            $category->alias = trim($row['alias']);
            $category->uri = preg_replace('#^shop/#', '', trim($row['uri'], '/'));
            $category->active = empty($row['deleted']) && !empty($row['published']);
            $category->rank = $row['menuindex'];
            $category->created_at = $row['createdon'];
            $category->updated_at = $row['editedon'] ?: null;
            // Заменяем id родителя, если есть
            $category->parent_id = $parents[$row['parent']] ?? null;

            // Если у категории есть картинка - загружаем плейсхолдер
            if (!empty($row['image'])) {
                $filename = tempnam(getenv('UPLOAD_DIR'), 'img_');
                file_put_contents($filename, file_get_contents('https://i.pravatar.cc/500'));
                $data = new UploadedFile($filename, basename($filename), mime_content_type($filename));
                if (!$file = $category->file) {
                    $file = new File();
                }
                $file->uploadFile($data);
                $category->update(['file_id' => $file->id]);
                unlink($filename);
            }
            // --

            // Сохраняем категорию
            $category->save();
            // И сразу создаём переводы через связь модели
            $category->translations()->updateOrCreate(['lang' => 'ru'], [
                'title' => trim($row['pagetitle']) ?: null,
                'description' => trim($row['content']) ?: null,
            ]);
            $category->translations()->updateOrCreate(['lang' => 'en'], [
                'title' => trim($row['pagetitle_fr']) ?: null,
                'description' => trim($row['content_fr']) ?: null,
            ]);

            // Обязательно сохраняем соответствие старого и нового id для
            // добавления дочерних категорий
            $parents[$category->remote_id] = $category->id;
        }
    }
}

Плагин для вывода текста в админке

// Ищет требуемый ключ в переданном объете и возвращает строку,
// если она не пустая
function translate(translations, field, lang = 'ru') {
  const data = translations.filter((i) => i.lang === lang)
  if (data.length > 0 && data[0][field] && data[0][field].length > 0) {
    return data[0][field]
  }
  return null
}

// Плагин Nuxt должен возвращать вот такой объект
export default ({app}, inject) => {
  // Регистрируем глобальную функцию приложения 
  inject('translate', (translations, field = 'title') => {
    // Пробуем вывести строку для требуемого языка
    let text = translate(translations, field, app.i18n.locale)
    if (!text && app.i18n.locale !== app.i18n.defaultLocale) {
      //  Или строку языка по умолчанию
      text = translate(translations, field, app.i18n.defaultLocale)
    }
    // Если переводов нет - надо уведомить разработчика, чтобы добавил
    if (!text) {
      console.info(`Could not find translation for ${field} in ${JSON.stringify(translations)}`)
    }
    return text
  })
}

Config.plugins = ['@/plugins/utils.js']

Дорабатываем таблицу категорий

<?php

namespace App\Controllers\Traits;

use Illuminate\Database\Eloquent\Model;

trait TranslateModelController
{
    protected function afterSave(Model $record): Model
    {
        if ($translations = $this->getProperty('translations')) {
            foreach ($translations as $data) {
                $record->translations()->updateOrCreate(['lang' => $data['lang']], $data);
            }
        }

        return $record;
    }
}

class Categories extends ModelController
{
    // Наши новые трейты для переводов и загрузки файла
    use FileModelController;
    use TranslateModelController;
    //...
    protected $attachments = ['file'];

    // Подключаем нужные модели при выводе для редактирования
    protected function beforeGet(Builder $c): Builder
    {
        $c->with('file:id,updated_at');
        $c->with('translations');

        return $c;
    }

    protected function beforeCount(Builder $c): Builder
    {
        // Поиск категории теперь проводится по таблице текстов
        if ($query = trim($this->getProperty('query', ''))) {
            $c->whereHas('translations', static function (Builder $c) use ($query) {
                $c->where('title', 'LIKE', "%$query%");
                $c->orWhere('description', 'LIKE', "%$query%");
            });
        }

        // Возможность прятать некоторые категории,
        // пригодится для автодополнения
        if ($exclude = $this->getProperty('exclude')) {
            if (is_array($exclude)) {
                $c->whereNotIn('id', $exclude);
            } else {
                $c->where('id', '!=', $exclude);
            }
        }

        return $c;
    }

    // Нужные связи для вывода таблицы категорий
    protected function afterCount(Builder $c): Builder
    {
        $c->with('translations:category_id,lang,title');
        $c->with('parent:id', 'parent.translations:category_id,lang,title');
        $c->with('file:id,updated_at');
        $c->withCount('children');
        $c->withCount('products');

        return $c;
    }

    protected function beforeSave(Model $record): ?ResponseInterface
    {
        /** @var Category $record */
        if (!$record->parent_id) {
            // Фронт может прислать 0 или пустую строку в качестве id родителя
            // Это вызовет ошибку внешнего ключа, так что форсируем null
            $record->parent_id = null;
        }

        // Обрабатываем файлы методом из трейта
        if ($error = $this->processFiles($record)) {
            return $error;
        }

        // Уникальность alias теперь проверяем с учётом родителя
        $c = Category::query()->where('alias', $record->alias);
        if ($record->exists) {
            $c->where('id', '!=', $record->id);
        }
        if ($record->parent_id) {
            $c->where('parent_id', $record->parent_id);
        }
        if ($c->count()) {
            return $this->failure('errors.category.alias_exists');
        }

        return null;
    }

<vesp-table ....>
      <template #cell(title)="{item}">
        {{ $translate(item.translations) }}
        <div class="small text-muted">{{ item.uri }}</div>
      </template>
      <template #cell(parent)="{item}">
        <template v-if="item.parent">
          {{ $translate(item.parent.translations) }}
        </template>
      </template>
      <template #cell(file)="{value}">
        <b-img
          v-if="value.id"
          :key="value.id"
          :src="$image(value, {w: 150, h: 75, fit: 'crop'})"
          :srcset="$image(value, {w: 300, h: 150, fit: 'crop'}) + ' 2x'"
          width="150"
          height="75"
          alt=""
          class="rounded"
        />
      </template>
</vesp-table>

<script>
export default {
  //...
  computed: {
    // ...
    fields() {
      return [
        {key: 'id', label: this.$t('components.table.columns.id'), sortable: true},
        {key: 'file', label: this.$t('models.category.file')},
        {key: 'title', label: this.$t('models.category.title'), sortable: true},
        {key: 'parent', label: this.$t('models.category.parent')},
        {key: 'products_count', label: this.$t('models.product.title_many')},
      ]
    },
  }
}
</script>

Config.i18n.defaultLocale = 'ru'
Config.i18n.locales = [
  {code: 'ru', title: 'Русский'},
  {code: 'en', title: 'English'},
]

Форма редактирования категории

• Новый контроллер Controllers/Admin/Languages.php для получения списка языков системы
• Новый маршрут для него в core/routes.php
• Результат загрузки мы будем хранить в store приложения. Для этого добавим новый ключ в state, новый метод в mutations и заведём action для запроса в API.
• Всякие нужные методы для работы формы сгруппируем в один общий mixin для добавления формам. Это как трейт в PHP, только для Vue.
• Активный язык будем отображать для каждого поля ввода с помощью стилей CSS.
• Ну а сам язык формы будем переключать через отдельный компонент lang-tabs.vue

export const state = () => ({
  // ...
  languages: [],
})

export const mutations = {
  // ...
  languages(state, payload) {
    state.languages = payload
  },
}

export const actions = {
  async languages({commit, state}) {
    if (!state.languages.length) {
      try {
        const {data} = await this.$axios.get('admin/languages', {params: {combo: true}})
        commit('languages', data.rows)
      } catch (e) {}
    }
    return state.languages
  },
}

export default {
  // Работаем до рендера компонента на странице
  async beforeMount() {
    try {
      const translations = []
      // Поулучаем языки
      const languages = await this.$store.dispatch('languages')
      // Проверяем значения для языков в моделе и создаем пустые переводы, если надо
      languages.forEach((v) => {
        const idx = this.record.translations.findIndex((i) => i.lang === v.lang)
        translations.push(idx > -1 ? {...this.record.translations[idx]} : {...this.translationFields, lang: v.lang})
      })
      // Выставляем переводы модели в форму, получая ключи из translationFields
      this.$set(this.record, 'translations', translations)
    } catch (e) {
      console.error(e)
    }
  },
  data() {
    return {
      // Здесь каждый компонент должен указать, какие поля у него переводимые 
      // например {title: '', description: ''}
      translationFields: {},
    }
  },
  directives: {
    // См. ниже
    langIcon: {
      update(el, {value}) {
        if (!el.classList.contains('form-group')) {
          el = el.querySelector('.form-group')
        }
        if (!el) {
          return
        }

        el.classList.forEach((cls) => {
          if (cls.startsWith('icon-')) {
            el.classList.remove(cls)
          }
        })
        el.classList.add('icon-' + value)
      },
    },
  },
}

import Translations from '@/mixins/translations.js'

export default {
  // ...  
  mixins: [Translations],
  data() {
    return {
      lang: this.$i18n.locale || 'ru',
      translationFields: {title: '', description: ''},
    }
  },
  // ...  
}

1. Добавит метод beforeMount(), который пробежится по указанным translationFields, проверит их ключи в переводах редактируемой модели и добавит путые, если нужно. Это чтобы избежать ошибок при создании новой категории, у которой еще не может быть переводов, и добавлении новых языков.
2. Добавит директиву langIcon, котрая будет прикручивать специальный CSS класс для поля ввода, чтобы там появлялся флажочек.

<template>
<!-- -->
        <b-form-group v-lang-icon="lang" :label="$t('models.category.title')">
          <b-form-input
            v-for="(translation, idx) in record.translations"
            v-show="translation.lang === lang"
            :key="idx"
            v-model.trim="translation.title"
            autofocus
            required
          />
        </b-form-group>
<!-- -->
</template>

{
  "id": 20,
  // ...
  "file": null,
  "translations": [
    {
      "category_id": 20,
      "lang": "ru",
      "title": "Дочерняя Категория",
      "description": "Описание дочерней категории"
    },
    {
      "category_id": 20,
      "lang": "en",
      "title": "Children Category",
      "description": "Children Category Description"
    }
  ]
}

<template>
  <b-tabs v-model="tab" :pills="pills" :small="small" :align="align" :active-nav-item-class="activeClass">
    <b-tab v-for="(language, idx) in languages" :key="idx">
      <template #title>
        <div class="d-flex align-items-center">
          <b-img :src="require('~/assets/images/icon-lang-' + language.lang + '.svg')" width="20" height="20" />
          <div class="ml-2">{{ language.title }}</div>
        </div>
      </template>
    </b-tab>
  </b-tabs>
</template>

<script>
export default {
  name: 'LangTabs',
  // ...
  data() {
    // Активная вкладка при загрузке зависит от текущего языка админки
    let tab = 0
    const languages = this.$store.state.languages
    if (this.value && languages.length) {
      tab = languages.findIndex((i) => i.lang === this.value)
    }
    return {tab}
  },
  computed: {
    languages() {
      return this.$store.state.languages
    },
  },
  watch: {
    // Меняем v-model при переключении вкладки
    tab(newValue) {
      if (this.languages[newValue]) {
        this.myValue = this.languages[newValue].lang
      }
    },
  },
}
</script>

<template>
  <div>
    <lang-tabs v-model="lang" />

    <hr />

    <b-row class="mt-4">
<!-- ... -->

Заключение