11755625072

Committed 09 Nov 2024 10:48AM UTC coverage: 79.945% (-0.09%) from 80.033%

Build # 11755625072

Build Type

push

github

Committed by

lucaslorentz

Commit Message

Add initial support for computed navigations and observers

Run Details

159 of 359 new or added lines in 22 files covered. (44.29%)

41 existing lines in 7 files now uncovered.

1459 of 1825 relevant lines covered (79.95%)

113.62 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.AddComputedFactory(
            ComputedFactory.CreateComputedObserverFactory(
                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	{
NEW 40	return entityTypeBuilder.ComputedNavigation(	×
NEW 41	navigationExpression,	×
NEW 42	computedExpression,	×
NEW 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	{
NEW 54	return entityTypeBuilder.Navigation(navigationExpression!)	×
NEW 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	{
NEW 65	entityTypeBuilder	×
NEW 66	.ComputedObserver(	×
NEW 67	computedExpression,	×
NEW 68	calculationSelector,	×
NEW 69	async (ComputedChangeEventData<TEntity, TChange> eventData) =>	×
NEW 70	{	×
NEW 71	foreach (var (entity, change) in eventData.Changes)	×
NEW 72	{	×
NEW 73	await callback(entity, change);	×
NEW 74	}	×
NEW 75	}	×
NEW 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	{
NEW 86	var changeCalculation = calculationSelector(ChangeCalculations<TValue>.Instance);	×
87
NEW 88	entityTypeBuilder.Metadata.AddComputedFactory(	×
NEW 89	ComputedFactory.CreateComputedObserverFactory(	×
NEW 90	computedExpression,	×
NEW 91	changeCalculation,	×
NEW 92	callback));	×
93	}
94	}

lucaslorentz / auto-compute / 11755625072

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