11911066930

Committed 19 Nov 2024 10:25AM UTC coverage: 81.029% (+4.2%) from 76.855%

Build # 11911066930

Build Type

push

github

Committed by

lucaslorentz

Commit Message

Improve EFCore computeds

Run Details

27 of 85 new or added lines in 12 files covered. (31.76%)

3 existing lines in 1 file now uncovered.

1465 of 1808 relevant lines covered (81.03%)

115.3 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

22.58

/src/LLL.AutoCompute.EFCore/Extensions/EntityTypeBuilderExtensions.cs

﻿using System.Linq.Expressions;
using LLL.AutoCompute.EFCore.Metadata.Internal;
using Microsoft.EntityFrameworkCore.Metadata.Builders;

namespace LLL.AutoCompute.EFCore;

public static class EntityTypeBuilderExtensions
{
    public static PropertyBuilder<TProperty> ComputedProperty<TEntity, TProperty>(
        this EntityTypeBuilder<TEntity> entityTypeBuilder,
        Expression<Func<TEntity, TProperty>> propertyExpression,
        Expression<Func<TEntity, TProperty>> computedExpression)
        where TEntity : class
    {
        return ComputedProperty(
            entityTypeBuilder,
            propertyExpression,
            computedExpression,
            static c => c.CurrentValue());
    }

    public static PropertyBuilder<TProperty> ComputedProperty<TEntity, TProperty>(
        this EntityTypeBuilder<TEntity> entityTypeBuilder,
        Expression<Func<TEntity, TProperty>> propertyExpression,
        Expression<Func<TEntity, TProperty>> computedExpression,
        ChangeCalculationSelector<TProperty, TProperty> calculationSelector)
        where TEntity : class
    {
        return entityTypeBuilder.Property(propertyExpression)
            .AutoCompute(computedExpression, calculationSelector);
    }

    public static NavigationBuilder<TEntity, TReference> ComputedNavigation<TEntity, TReference>(
        this EntityTypeBuilder<TEntity> entityTypeBuilder,
        Expression<Func<TEntity, TReference>> navigationExpression,
        Expression<Func<TEntity, TReference>> computedExpression)
        where TEntity : class
        where TReference : class
    {
        return entityTypeBuilder.ComputedNavigation(
            navigationExpression,
            computedExpression,
            static c => c.CurrentValue());
    }

    public static NavigationBuilder<TEntity, TProperty> ComputedNavigation<TEntity, TProperty>(
        this EntityTypeBuilder<TEntity> entityTypeBuilder,
        Expression<Func<TEntity, TProperty>> navigationExpression,
        Expression<Func<TEntity, TProperty>> computedExpression,
        ChangeCalculationSelector<TProperty, TProperty> calculationSelector)
        where TEntity : class
        where TProperty : class
    {
        return entityTypeBuilder.Navigation(navigationExpression!)
            .AutoCompute(computedExpression, calculationSelector);
    }

    public static void ComputedObserver<TEntity, TValue, TChange>(
        this EntityTypeBuilder<TEntity> entityTypeBuilder,
        Expression<Func<TEntity, TValue>> computedExpression,
        ChangeCalculationSelector<TValue, TChange> calculationSelector,
        Func<TEntity, TChange?, Task> callback)
        where TEntity : class
    {
        entityTypeBuilder
            .ComputedObserver(
                computedExpression,
                calculationSelector,
                async (ComputedChangeEventData<TEntity, TChange> eventData) =>
                {
                    foreach (var (entity, change) in eventData.Changes)
                    {
                        await callback(entity, change);
                    }
                }
            );
    }

    public static void ComputedObserver<TEntity, TValue, TChange>(
        this EntityTypeBuilder<TEntity> entityTypeBuilder,
        Expression<Func<TEntity, TValue>> computedExpression,
        ChangeCalculationSelector<TValue, TChange> calculationSelector,
        Func<ComputedChangeEventData<TEntity, TChange>, Task> callback)
        where TEntity : class
    {
        var changeCalculation = calculationSelector(ChangeCalculations<TValue>.Instance);

        entityTypeBuilder.Metadata.AddObserverFactory(
            ObserverFactory.CreateObserverFactory(
                computedExpression,
                changeCalculation,
                callback));
    }
}

1	using System.Linq.Expressions;
2	using LLL.AutoCompute.EFCore.Metadata.Internal;
3	using Microsoft.EntityFrameworkCore.Metadata.Builders;
4
5	namespace LLL.AutoCompute.EFCore;
6
7	public static class EntityTypeBuilderExtensions
8	{
9	public static PropertyBuilder<TProperty> ComputedProperty<TEntity, TProperty>(
10	this EntityTypeBuilder<TEntity> entityTypeBuilder,
11	Expression<Func<TEntity, TProperty>> propertyExpression,
12	Expression<Func<TEntity, TProperty>> computedExpression)
13	where TEntity : class
14	{
15	return ComputedProperty(	8✔
16	entityTypeBuilder,	8✔
17	propertyExpression,	8✔
18	computedExpression,	8✔
19	static c => c.CurrentValue());	16✔
20	}
21
22	public static PropertyBuilder<TProperty> ComputedProperty<TEntity, TProperty>(
23	this EntityTypeBuilder<TEntity> entityTypeBuilder,
24	Expression<Func<TEntity, TProperty>> propertyExpression,
25	Expression<Func<TEntity, TProperty>> computedExpression,
26	ChangeCalculationSelector<TProperty, TProperty> calculationSelector)
27	where TEntity : class
28	{
29	return entityTypeBuilder.Property(propertyExpression)	12✔
30	.AutoCompute(computedExpression, calculationSelector);	12✔
31	}
32
33	public static NavigationBuilder<TEntity, TReference> ComputedNavigation<TEntity, TReference>(
34	this EntityTypeBuilder<TEntity> entityTypeBuilder,
35	Expression<Func<TEntity, TReference>> navigationExpression,
36	Expression<Func<TEntity, TReference>> computedExpression)
37	where TEntity : class
38	where TReference : class
39	{
40	return entityTypeBuilder.ComputedNavigation(	×
41	navigationExpression,	×
42	computedExpression,	×
43	static c => c.CurrentValue());	×
44	}
45
46	public static NavigationBuilder<TEntity, TProperty> ComputedNavigation<TEntity, TProperty>(
47	this EntityTypeBuilder<TEntity> entityTypeBuilder,
48	Expression<Func<TEntity, TProperty>> navigationExpression,
49	Expression<Func<TEntity, TProperty>> computedExpression,
50	ChangeCalculationSelector<TProperty, TProperty> calculationSelector)
51	where TEntity : class
52	where TProperty : class
53	{
54	return entityTypeBuilder.Navigation(navigationExpression!)	×
55	.AutoCompute(computedExpression, calculationSelector);	×
56	}
57
58	public static void ComputedObserver<TEntity, TValue, TChange>(
59	this EntityTypeBuilder<TEntity> entityTypeBuilder,
60	Expression<Func<TEntity, TValue>> computedExpression,
61	ChangeCalculationSelector<TValue, TChange> calculationSelector,
62	Func<TEntity, TChange?, Task> callback)
63	where TEntity : class
64	{
65	entityTypeBuilder	×
66	.ComputedObserver(	×
67	computedExpression,	×
68	calculationSelector,	×
69	async (ComputedChangeEventData<TEntity, TChange> eventData) =>	×
70	{	×
71	foreach (var (entity, change) in eventData.Changes)	×
72	{	×
73	await callback(entity, change);	×
74	}	×
75	}	×
76	);	×
77	}
78
79	public static void ComputedObserver<TEntity, TValue, TChange>(
80	this EntityTypeBuilder<TEntity> entityTypeBuilder,
81	Expression<Func<TEntity, TValue>> computedExpression,
82	ChangeCalculationSelector<TValue, TChange> calculationSelector,
83	Func<ComputedChangeEventData<TEntity, TChange>, Task> callback)
84	where TEntity : class
85	{
86	var changeCalculation = calculationSelector(ChangeCalculations<TValue>.Instance);	×
87
NEW 88	entityTypeBuilder.Metadata.AddObserverFactory(	×
NEW 89	ObserverFactory.CreateObserverFactory(	×
90	computedExpression,	×
91	changeCalculation,	×
92	callback));	×
93	}
94	}

lucaslorentz / auto-compute / 11911066930

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous