Отношение многие-ко-многим в EF core 6+

        var mediaItemCategory = await Context.GetTable<MediaItemCategory>()
            .Where(x => x.Id == mediaItemCategoryId && x.AgencyId == agencyId)
            .Select(x => new MediaItemCategoryEditReadModel
            {
                Id                   = x.Id,
                Name                 = x.Name,
                UserGroupIds         = x.UserGroups.Select(y => y.UserGroupId).ToList(),
                PublicApiCategoryIds = x.PublicApiCategories.Select(y => y.PublicApiCategoryId).ToList(),
                Retention            = new MediaItemCategoryRetentionEditReadModel
                {
                    KeepForDays   = x.RetentionKeepForDays,
                    KeepForMonths = x.RetentionKeepForMonths,
                    KeepForYears  = x.RetentionKeepForYears
                }
            })
            .FirstOrDefaultAsync();

        var categoryId = (Guid)await Context.GetTable<MediaItemCategory>()
            .InsertWithIdentityAsync(() => new MediaItemCategory
            {
                AgencyId               = agencyId,
                Name                   = model.Name,
                CreatedAt              = model.CreatedAt,
                RetentionKeepForYears  = model.Retention!.KeepForYears,
                RetentionKeepForMonths = model.Retention!.KeepForMonths,
                RetentionKeepForDays   = model.Retention!.KeepForDays
            });

        await Context.GetTable<MediaItemCategory>()
            .Where(x => x.Id == model.Id && x.AgencyId == agencyId)
            .UpdateAsync(_ => new MediaItemCategory
            {
                Name                   = model.Name,
                RetentionKeepForYears  = model.Retention!.KeepForYears,
                RetentionKeepForMonths = model.Retention!.KeepForMonths,
                RetentionKeepForDays   = model.Retention!.KeepForDays
            });

        await Context.GetTable<MediaItemCategory>()
            .Where(x => x.Id == model.Id && x.AgencyId == agencyId)
            .UpdateAsync(x => new MediaItemCategory
            {
                Name                   = model.Name,
                RetentionKeepForYears  = model.Retention!.KeepForYears + x.RetentionKeepForYears
            });

        await Context.GetTable<MediaItemCategoryUserGroup>()
            .BulkCopyAsync(userGroupIds.Select(x => new MediaItemCategoryUserGroup()
            {
                CategoryId  = mediaItemCategoryId,
                UserGroupId = x
            }));

                .Merge()
                .Using(new []
                {
                    new 
                    {
                        MediaItemId = mediaItemId,
                        CategoryId  = mediaItemCategoryId,
                    }
                })
                .On((target, source) => 
                    source.MediaItemId == target.MediaItemId 
                    && source.CategoryId == target.CategoryId )
                .InsertWhenNotMatched(source => new MediaItemToMediaItemCategory
                {
                    MediaItemId = source.MediaItemId,
                    CategoryId  = source.CategoryId,
                })
                .MergeAsync();

            Context.GetTable<K9Weather>()
                .Merge()
                .Using(request.WeatherIds.Select((weatherId) =>
                    new K9Weather
                    {
                        K9Id = k9Id,
                        K9WeatherId           = weatherId
                    }))
                .On((source, target) => source.K9Id == target.K9Id &&
                                        source.K9WeatherId == target.K9WeatherId)
                .InsertWhenNotMatched()
                .DeleteWhenNotMatchedBySourceAnd(x => x.K9Id == k9Id)
                .Merge();

// Вызовы пользовательских функций
    internal static class Liqn2DbSqlServerFunctions
    {
        [Sql.Extension("dbo.GetFullPersonName({lastName}, {firstName}, {midName})", IsPredicate = true, ServerSideOnly = true)]
        public static string GetFullPersonName(this ISqlServerExtensions ext, [ExprParameter] string lastName, [ExprParameter] string firstName, [ExprParameter] string midName)
        {
            throw new NotSupportedException();
        }
 
        [Sql.Extension("dbo.GetAge({dob}, {date})", IsPredicate = true)]
        public static int? GetAge(this ISqlServerExtensions ext, [ExprParameter] DateTime? dob, [ExprParameter] DateTime? date)
        {
            if (dob is null || date is null)
            {
                return default;
            }
 
            return dob.Value.GetAge(date.Value);
        }
// А тут вообще оператор СУБД можно вызвать. Любой.
        [Sql.Extension("COALESCE(NULLIF({first}, ''), NULLIF({second}, ''))", IsPredicate = true)]
        public static string FirstNonEmpty(this ISqlServerExtensions ext, [ExprParameter] string first, [ExprParameter] string second)
        {
            return first.ValueOrSubstitution(second);
        }
   }
 
               var nameModel = Context.GetTable<InvolvedPerson>()
                .Where(x => x.Id == caseLogNameId)
                .Select(x =>
                    new InvolvedPersonReportModel()
                    {
                        Involvement         = x.Involvement.Code,
                        NameType            = x.NameType.Description,
                        Name                = ext.GetFullPersonName(x.Person.LastName, x.Person.FirstName, x.Person.MidName),
                        DOB                 = x.Person.DOB,
                        Age                 = ext.GetAge(x.Person.DOB, x.Incident.ReportedDateTime ?? now),
                        Race                = x.Person.Race.Code,
                        DriverLicense       = x.Person.DriverLicense + " " + x.Person.DriverLicenseState.Code,
                    })
                .FirstOrDefault();
 
// Ниже функции для работы с криптографией в базе
 
internal static class DbCryptoFunctions
{
    [Sql.Extension("crypt({what}, gen_salt('bf'))", IsPredicate = true, ServerSideOnly = true)]
    public static string EncryptWithGeneratedSalt(this ISqlExtension ext, [ExprParameter] string what)
    {
        throw new NotSupportedException();
    }
 
    [Sql.Extension("crypt({what}, {salt})", IsPredicate = true, ServerSideOnly = true)]
    public static string EncryptWithSalt(this ISqlExtension ext, [ExprParameter] string what, [ExprParameter] string salt)
    {
        throw new NotSupportedException();
    }
}
 
    public async Task Create(UserCreateModel model)
    {
        var userId = (Guid)await Context.GetTable<User>() // User - сущность, и она сильно не похожа на DTO
            .InsertWithIdentityAsync(() => new User
            {
                FirstName     = model.FirstName,
                LastName      = model.LastName,
                Login         = model.Login,
                ExternalLogin = model.ExternalLogin,
                BadgeId       = model.BadgeId,
                Email         = model.Email,
                RoleId        = model.UserRoleId,
                IsActive      = model.IsActive,
                CreatedAt     = model.CreatedAt,
                ModifiedAt    = model.ModifiedAt,
                Password      = Sql.Ext!.EncryptWithGeneratedSalt(model.Password)
            });
 
        await AddUserGroupUsers(userId, model.UserGroupIds); // Отдельно сохраняем группы
    }

        var publicApiCategoriesPlain = publicApiCategories.SelectMany(a => a.Values, 
            (a, b) => new
        {
            Name = a.Name.ToLower(),
            Value = b.ToLower() 
        }).ToList();
 
        return await Context.GetTable<MediaItemCategoryPublicApiCategory>()
            .Where(x => x.Category.AgencyId == agencyId)
            .Where(mic2pac => 
                publicApiCategoriesPlain.Any(pac => 
                    Sql.AsNotNull(pac.Name) == mic2pac.PublicApiCategory.ApiName.ToLower()
                    && mic2pac.PublicApiCategory.Values.Select(mic2pacv =>mic2pacv.Value)
                        .Any(mic2pacv => mic2pacv.ToLower() == Sql.AsNotNull(pac.Value)))
            )
            .Select(x => x.CategoryId)
            .Distinct()
            .ToListAsync();
 
// Под виртуальной таблицей тут имеется в виду такая конструкция, которая будет собрана из коллекции
    SELECT
      *
    FROM
      (VALUES
        ('test','qer'), ('test','qwerqwr'), ('other','uioiuy'),
        ('other','mnnmh')
      ) pac("Name", "Value")