stella-ops.org/git.stella-ops.org
1
0
Fork 0
Code Issues Pull Requests Actions 2 Releases Wiki Activity

Search/AdvisoryAI and DAL conversion to EF finishes up. Preparation for microservices consolidation.

Browse Source
This commit is contained in:
master
2026-02-25 18:19:22 +02:00
parent 4db038123b
commit 63c70a6d37
447 changed files with 52257 additions and 2636 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/ExportCenter/StellaOps.ExportCenter/StellaOps.ExportCenter.Infrastructure/EfCore/CompiledModels/ExportCenterDbContextAssemblyAttributes.cs Normal file
View File

@@ -0,0 +1,9 @@
// <auto-generated />
using Microsoft.EntityFrameworkCore.Infrastructure;
using StellaOps.ExportCenter.Infrastructure.EfCore.CompiledModels;
using StellaOps.ExportCenter.Infrastructure.EfCore.Context;
#pragma warning disable 219, 612, 618
#nullable disable
[assembly: DbContextModel(typeof(ExportCenterDbContext), typeof(ExportCenterDbContextModel))]

48
src/ExportCenter/StellaOps.ExportCenter/StellaOps.ExportCenter.Infrastructure/EfCore/CompiledModels/ExportCenterDbContextModel.cs Normal file
View File

@@ -0,0 +1,48 @@
// <auto-generated />
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;
using StellaOps.ExportCenter.Infrastructure.EfCore.Context;
#pragma warning disable 219, 612, 618
#nullable disable
namespace StellaOps.ExportCenter.Infrastructure.EfCore.CompiledModels
{
[DbContext(typeof(ExportCenterDbContext))]
public partial class ExportCenterDbContextModel : RuntimeModel
{
private static readonly bool _useOldBehavior31751 =
System.AppContext.TryGetSwitch("Microsoft.EntityFrameworkCore.Issue31751", out var enabled31751) && enabled31751;
static ExportCenterDbContextModel()
{
var model = new ExportCenterDbContextModel();
if (_useOldBehavior31751)
{
model.Initialize();
}
else
{
var thread = new System.Threading.Thread(RunInitialization, 10 * 1024 * 1024);
thread.Start();
thread.Join();
void RunInitialization()
{
model.Initialize();
}
}
model.Customize();
_instance = (ExportCenterDbContextModel)model.FinalizeModel();
}
private static ExportCenterDbContextModel _instance;
public static IModel Instance => _instance;
partial void Initialize();
partial void Customize();
}
}

40
src/ExportCenter/StellaOps.ExportCenter/StellaOps.ExportCenter.Infrastructure/EfCore/CompiledModels/ExportCenterDbContextModelBuilder.cs Normal file
View File

@@ -0,0 +1,40 @@
// <auto-generated />
using System;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;
using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
#pragma warning disable 219, 612, 618
#nullable disable
namespace StellaOps.ExportCenter.Infrastructure.EfCore.CompiledModels
{
public partial class ExportCenterDbContextModel
{
private ExportCenterDbContextModel()
: base(skipDetectChanges: false, modelId: new Guid("91afe562-6329-48a5-ac6c-63831c1d5c27"), entityTypeCount: 4)
{
}
partial void Initialize()
{
var exportDistributionEntity = ExportDistributionEntityEntityType.Create(this);
var exportInputEntity = ExportInputEntityEntityType.Create(this);
var exportProfileEntity = ExportProfileEntityEntityType.Create(this);
var exportRunEntity = ExportRunEntityEntityType.Create(this);
ExportDistributionEntityEntityType.CreateForeignKey1(exportDistributionEntity, exportRunEntity);
ExportInputEntityEntityType.CreateForeignKey1(exportInputEntity, exportRunEntity);
ExportRunEntityEntityType.CreateForeignKey1(exportRunEntity, exportProfileEntity);
ExportDistributionEntityEntityType.CreateAnnotations(exportDistributionEntity);
ExportInputEntityEntityType.CreateAnnotations(exportInputEntity);
ExportProfileEntityEntityType.CreateAnnotations(exportProfileEntity);
ExportRunEntityEntityType.CreateAnnotations(exportRunEntity);
AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
AddAnnotation("ProductVersion", "10.0.0");
AddAnnotation("Relational:MaxIdentifierLength", 63);
}
}
}

239
src/ExportCenter/StellaOps.ExportCenter/StellaOps.ExportCenter.Infrastructure/EfCore/CompiledModels/ExportDistributionEntityEntityType.cs Normal file
View File

@@ -0,0 +1,239 @@
// <auto-generated />
using System;
using System.Collections.Generic;
using System.Reflection;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;
using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
using StellaOps.ExportCenter.Infrastructure.EfCore.Models;
#pragma warning disable 219, 612, 618
#nullable disable
namespace StellaOps.ExportCenter.Infrastructure.EfCore.CompiledModels
{
[EntityFrameworkInternal]
public partial class ExportDistributionEntityEntityType
{
public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null)
{
var runtimeEntityType = model.AddEntityType(
"StellaOps.ExportCenter.Infrastructure.EfCore.Models.ExportDistributionEntity",
typeof(ExportDistributionEntity),
baseEntityType,
propertyCount: 16,
navigationCount: 1,
foreignKeyCount: 1,
namedIndexCount: 2,
keyCount: 1);
var distributionId = runtimeEntityType.AddProperty(
"DistributionId",
typeof(Guid),
propertyInfo: typeof(ExportDistributionEntity).GetProperty("DistributionId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportDistributionEntity).GetField("<DistributionId>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
valueGenerated: ValueGenerated.OnAdd,
afterSaveBehavior: PropertySaveBehavior.Throw,
sentinel: new Guid("00000000-0000-0000-0000-000000000000"));
distributionId.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
distributionId.AddAnnotation("Relational:ColumnName", "distribution_id");
var artifactHash = runtimeEntityType.AddProperty(
"ArtifactHash",
typeof(string),
propertyInfo: typeof(ExportDistributionEntity).GetProperty("ArtifactHash", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportDistributionEntity).GetField("<ArtifactHash>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
artifactHash.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
artifactHash.AddAnnotation("Relational:ColumnName", "artifact_hash");
var artifactPath = runtimeEntityType.AddProperty(
"ArtifactPath",
typeof(string),
propertyInfo: typeof(ExportDistributionEntity).GetProperty("ArtifactPath", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportDistributionEntity).GetField("<ArtifactPath>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
artifactPath.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
artifactPath.AddAnnotation("Relational:ColumnName", "artifact_path");
var attemptCount = runtimeEntityType.AddProperty(
"AttemptCount",
typeof(int),
propertyInfo: typeof(ExportDistributionEntity).GetProperty("AttemptCount", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportDistributionEntity).GetField("<AttemptCount>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
valueGenerated: ValueGenerated.OnAdd,
sentinel: 0);
attemptCount.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
attemptCount.AddAnnotation("Relational:ColumnName", "attempt_count");
attemptCount.AddAnnotation("Relational:DefaultValue", 0);
var contentType = runtimeEntityType.AddProperty(
"ContentType",
typeof(string),
propertyInfo: typeof(ExportDistributionEntity).GetProperty("ContentType", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportDistributionEntity).GetField("<ContentType>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
contentType.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
contentType.AddAnnotation("Relational:ColumnName", "content_type");
var createdAt = runtimeEntityType.AddProperty(
"CreatedAt",
typeof(DateTime),
propertyInfo: typeof(ExportDistributionEntity).GetProperty("CreatedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportDistributionEntity).GetField("<CreatedAt>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
valueGenerated: ValueGenerated.OnAdd,
sentinel: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified));
createdAt.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
createdAt.AddAnnotation("Relational:ColumnName", "created_at");
createdAt.AddAnnotation("Relational:DefaultValueSql", "(NOW() AT TIME ZONE 'UTC')");
var distributedAt = runtimeEntityType.AddProperty(
"DistributedAt",
typeof(DateTime?),
propertyInfo: typeof(ExportDistributionEntity).GetProperty("DistributedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportDistributionEntity).GetField("<DistributedAt>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
distributedAt.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
distributedAt.AddAnnotation("Relational:ColumnName", "distributed_at");
var errorJson = runtimeEntityType.AddProperty(
"ErrorJson",
typeof(string),
propertyInfo: typeof(ExportDistributionEntity).GetProperty("ErrorJson", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportDistributionEntity).GetField("<ErrorJson>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
errorJson.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
errorJson.AddAnnotation("Relational:ColumnName", "error_json");
errorJson.AddAnnotation("Relational:ColumnType", "jsonb");
var kind = runtimeEntityType.AddProperty(
"Kind",
typeof(short),
propertyInfo: typeof(ExportDistributionEntity).GetProperty("Kind", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportDistributionEntity).GetField("<Kind>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
sentinel: (short)0);
kind.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
kind.AddAnnotation("Relational:ColumnName", "kind");
var metadataJson = runtimeEntityType.AddProperty(
"MetadataJson",
typeof(string),
propertyInfo: typeof(ExportDistributionEntity).GetProperty("MetadataJson", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportDistributionEntity).GetField("<MetadataJson>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
metadataJson.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
metadataJson.AddAnnotation("Relational:ColumnName", "metadata_json");
metadataJson.AddAnnotation("Relational:ColumnType", "jsonb");
var runId = runtimeEntityType.AddProperty(
"RunId",
typeof(Guid),
propertyInfo: typeof(ExportDistributionEntity).GetProperty("RunId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportDistributionEntity).GetField("<RunId>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
sentinel: new Guid("00000000-0000-0000-0000-000000000000"));
runId.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
runId.AddAnnotation("Relational:ColumnName", "run_id");
var sizeBytes = runtimeEntityType.AddProperty(
"SizeBytes",
typeof(long),
propertyInfo: typeof(ExportDistributionEntity).GetProperty("SizeBytes", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportDistributionEntity).GetField("<SizeBytes>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
valueGenerated: ValueGenerated.OnAdd,
sentinel: 0L);
sizeBytes.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
sizeBytes.AddAnnotation("Relational:ColumnName", "size_bytes");
sizeBytes.AddAnnotation("Relational:DefaultValue", 0L);
var status = runtimeEntityType.AddProperty(
"Status",
typeof(short),
propertyInfo: typeof(ExportDistributionEntity).GetProperty("Status", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportDistributionEntity).GetField("<Status>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
sentinel: (short)0);
status.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
status.AddAnnotation("Relational:ColumnName", "status");
var target = runtimeEntityType.AddProperty(
"Target",
typeof(string),
propertyInfo: typeof(ExportDistributionEntity).GetProperty("Target", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportDistributionEntity).GetField("<Target>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
target.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
target.AddAnnotation("Relational:ColumnName", "target");
var tenantId = runtimeEntityType.AddProperty(
"TenantId",
typeof(Guid),
propertyInfo: typeof(ExportDistributionEntity).GetProperty("TenantId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportDistributionEntity).GetField("<TenantId>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
sentinel: new Guid("00000000-0000-0000-0000-000000000000"));
tenantId.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
tenantId.AddAnnotation("Relational:ColumnName", "tenant_id");
var verifiedAt = runtimeEntityType.AddProperty(
"VerifiedAt",
typeof(DateTime?),
propertyInfo: typeof(ExportDistributionEntity).GetProperty("VerifiedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportDistributionEntity).GetField("<VerifiedAt>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
verifiedAt.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
verifiedAt.AddAnnotation("Relational:ColumnName", "verified_at");
var key = runtimeEntityType.AddKey(
new[] { distributionId });
runtimeEntityType.SetPrimaryKey(key);
key.AddAnnotation("Relational:Name", "export_distributions_pkey");
var ix_export_distributions_run_status = runtimeEntityType.AddIndex(
new[] { runId, status },
name: "ix_export_distributions_run_status");
var ix_export_distributions_tenant_kind = runtimeEntityType.AddIndex(
new[] { tenantId, kind },
name: "ix_export_distributions_tenant_kind");
return runtimeEntityType;
}
public static RuntimeForeignKey CreateForeignKey1(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType)
{
var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("RunId") },
principalEntityType.FindKey(new[] { principalEntityType.FindProperty("RunId") }),
principalEntityType,
deleteBehavior: DeleteBehavior.Cascade,
required: true);
var run = declaringEntityType.AddNavigation("Run",
runtimeForeignKey,
onDependent: true,
typeof(ExportRunEntity),
propertyInfo: typeof(ExportDistributionEntity).GetProperty("Run", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportDistributionEntity).GetField("<Run>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
var distributions = principalEntityType.AddNavigation("Distributions",
runtimeForeignKey,
onDependent: false,
typeof(ICollection<ExportDistributionEntity>),
propertyInfo: typeof(ExportRunEntity).GetProperty("Distributions", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportRunEntity).GetField("<Distributions>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
runtimeForeignKey.AddAnnotation("Relational:Name", "fk_distributions_run");
return runtimeForeignKey;
}
public static void CreateAnnotations(RuntimeEntityType runtimeEntityType)
{
runtimeEntityType.AddAnnotation("Relational:FunctionName", null);
runtimeEntityType.AddAnnotation("Relational:Schema", "export_center");
runtimeEntityType.AddAnnotation("Relational:SqlQuery", null);
runtimeEntityType.AddAnnotation("Relational:TableName", "export_distributions");
runtimeEntityType.AddAnnotation("Relational:ViewName", null);
runtimeEntityType.AddAnnotation("Relational:ViewSchema", null);
Customize(runtimeEntityType);
}
static partial void Customize(RuntimeEntityType runtimeEntityType);
}
}

215
src/ExportCenter/StellaOps.ExportCenter/StellaOps.ExportCenter.Infrastructure/EfCore/CompiledModels/ExportInputEntityEntityType.cs Normal file
View File

@@ -0,0 +1,215 @@
// <auto-generated />
using System;
using System.Collections.Generic;
using System.Reflection;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;
using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
using StellaOps.ExportCenter.Infrastructure.EfCore.Models;
#pragma warning disable 219, 612, 618
#nullable disable
namespace StellaOps.ExportCenter.Infrastructure.EfCore.CompiledModels
{
[EntityFrameworkInternal]
public partial class ExportInputEntityEntityType
{
public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null)
{
var runtimeEntityType = model.AddEntityType(
"StellaOps.ExportCenter.Infrastructure.EfCore.Models.ExportInputEntity",
typeof(ExportInputEntity),
baseEntityType,
propertyCount: 13,
navigationCount: 1,
foreignKeyCount: 1,
namedIndexCount: 3,
keyCount: 1);
var inputId = runtimeEntityType.AddProperty(
"InputId",
typeof(Guid),
propertyInfo: typeof(ExportInputEntity).GetProperty("InputId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportInputEntity).GetField("<InputId>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
valueGenerated: ValueGenerated.OnAdd,
afterSaveBehavior: PropertySaveBehavior.Throw,
sentinel: new Guid("00000000-0000-0000-0000-000000000000"));
inputId.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
inputId.AddAnnotation("Relational:ColumnName", "input_id");
var contentHash = runtimeEntityType.AddProperty(
"ContentHash",
typeof(string),
propertyInfo: typeof(ExportInputEntity).GetProperty("ContentHash", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportInputEntity).GetField("<ContentHash>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
contentHash.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
contentHash.AddAnnotation("Relational:ColumnName", "content_hash");
var createdAt = runtimeEntityType.AddProperty(
"CreatedAt",
typeof(DateTime),
propertyInfo: typeof(ExportInputEntity).GetProperty("CreatedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportInputEntity).GetField("<CreatedAt>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
valueGenerated: ValueGenerated.OnAdd,
sentinel: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified));
createdAt.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
createdAt.AddAnnotation("Relational:ColumnName", "created_at");
createdAt.AddAnnotation("Relational:DefaultValueSql", "(NOW() AT TIME ZONE 'UTC')");
var errorJson = runtimeEntityType.AddProperty(
"ErrorJson",
typeof(string),
propertyInfo: typeof(ExportInputEntity).GetProperty("ErrorJson", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportInputEntity).GetField("<ErrorJson>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
errorJson.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
errorJson.AddAnnotation("Relational:ColumnName", "error_json");
errorJson.AddAnnotation("Relational:ColumnType", "jsonb");
var kind = runtimeEntityType.AddProperty(
"Kind",
typeof(short),
propertyInfo: typeof(ExportInputEntity).GetProperty("Kind", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportInputEntity).GetField("<Kind>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
sentinel: (short)0);
kind.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
kind.AddAnnotation("Relational:ColumnName", "kind");
var metadataJson = runtimeEntityType.AddProperty(
"MetadataJson",
typeof(string),
propertyInfo: typeof(ExportInputEntity).GetProperty("MetadataJson", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportInputEntity).GetField("<MetadataJson>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
metadataJson.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
metadataJson.AddAnnotation("Relational:ColumnName", "metadata_json");
metadataJson.AddAnnotation("Relational:ColumnType", "jsonb");
var name = runtimeEntityType.AddProperty(
"Name",
typeof(string),
propertyInfo: typeof(ExportInputEntity).GetProperty("Name", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportInputEntity).GetField("<Name>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
name.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
name.AddAnnotation("Relational:ColumnName", "name");
var processedAt = runtimeEntityType.AddProperty(
"ProcessedAt",
typeof(DateTime?),
propertyInfo: typeof(ExportInputEntity).GetProperty("ProcessedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportInputEntity).GetField("<ProcessedAt>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
processedAt.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
processedAt.AddAnnotation("Relational:ColumnName", "processed_at");
var runId = runtimeEntityType.AddProperty(
"RunId",
typeof(Guid),
propertyInfo: typeof(ExportInputEntity).GetProperty("RunId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportInputEntity).GetField("<RunId>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
sentinel: new Guid("00000000-0000-0000-0000-000000000000"));
runId.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
runId.AddAnnotation("Relational:ColumnName", "run_id");
var sizeBytes = runtimeEntityType.AddProperty(
"SizeBytes",
typeof(long),
propertyInfo: typeof(ExportInputEntity).GetProperty("SizeBytes", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportInputEntity).GetField("<SizeBytes>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
valueGenerated: ValueGenerated.OnAdd,
sentinel: 0L);
sizeBytes.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
sizeBytes.AddAnnotation("Relational:ColumnName", "size_bytes");
sizeBytes.AddAnnotation("Relational:DefaultValue", 0L);
var sourceRef = runtimeEntityType.AddProperty(
"SourceRef",
typeof(string),
propertyInfo: typeof(ExportInputEntity).GetProperty("SourceRef", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportInputEntity).GetField("<SourceRef>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
sourceRef.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
sourceRef.AddAnnotation("Relational:ColumnName", "source_ref");
var status = runtimeEntityType.AddProperty(
"Status",
typeof(short),
propertyInfo: typeof(ExportInputEntity).GetProperty("Status", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportInputEntity).GetField("<Status>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
sentinel: (short)0);
status.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
status.AddAnnotation("Relational:ColumnName", "status");
var tenantId = runtimeEntityType.AddProperty(
"TenantId",
typeof(Guid),
propertyInfo: typeof(ExportInputEntity).GetProperty("TenantId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportInputEntity).GetField("<TenantId>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
sentinel: new Guid("00000000-0000-0000-0000-000000000000"));
tenantId.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
tenantId.AddAnnotation("Relational:ColumnName", "tenant_id");
var key = runtimeEntityType.AddKey(
new[] { inputId });
runtimeEntityType.SetPrimaryKey(key);
key.AddAnnotation("Relational:Name", "export_inputs_pkey");
var ix_export_inputs_run_status = runtimeEntityType.AddIndex(
new[] { runId, status },
name: "ix_export_inputs_run_status");
var ix_export_inputs_source_ref = runtimeEntityType.AddIndex(
new[] { tenantId, sourceRef },
name: "ix_export_inputs_source_ref");
var ix_export_inputs_tenant_kind = runtimeEntityType.AddIndex(
new[] { tenantId, kind },
name: "ix_export_inputs_tenant_kind");
return runtimeEntityType;
}
public static RuntimeForeignKey CreateForeignKey1(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType)
{
var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("RunId") },
principalEntityType.FindKey(new[] { principalEntityType.FindProperty("RunId") }),
principalEntityType,
deleteBehavior: DeleteBehavior.Cascade,
required: true);
var run = declaringEntityType.AddNavigation("Run",
runtimeForeignKey,
onDependent: true,
typeof(ExportRunEntity),
propertyInfo: typeof(ExportInputEntity).GetProperty("Run", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportInputEntity).GetField("<Run>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
var inputs = principalEntityType.AddNavigation("Inputs",
runtimeForeignKey,
onDependent: false,
typeof(ICollection<ExportInputEntity>),
propertyInfo: typeof(ExportRunEntity).GetProperty("Inputs", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportRunEntity).GetField("<Inputs>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
runtimeForeignKey.AddAnnotation("Relational:Name", "fk_inputs_run");
return runtimeForeignKey;
}
public static void CreateAnnotations(RuntimeEntityType runtimeEntityType)
{
runtimeEntityType.AddAnnotation("Relational:FunctionName", null);
runtimeEntityType.AddAnnotation("Relational:Schema", "export_center");
runtimeEntityType.AddAnnotation("Relational:SqlQuery", null);
runtimeEntityType.AddAnnotation("Relational:TableName", "export_inputs");
runtimeEntityType.AddAnnotation("Relational:ViewName", null);
runtimeEntityType.AddAnnotation("Relational:ViewSchema", null);
Customize(runtimeEntityType);
}
static partial void Customize(RuntimeEntityType runtimeEntityType);
}
}

185
src/ExportCenter/StellaOps.ExportCenter/StellaOps.ExportCenter.Infrastructure/EfCore/CompiledModels/ExportProfileEntityEntityType.cs Normal file
View File

@@ -0,0 +1,185 @@
// <auto-generated />
using System;
using System.Reflection;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;
using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
using StellaOps.ExportCenter.Infrastructure.EfCore.Models;
#pragma warning disable 219, 612, 618
#nullable disable
namespace StellaOps.ExportCenter.Infrastructure.EfCore.CompiledModels
{
[EntityFrameworkInternal]
public partial class ExportProfileEntityEntityType
{
public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null)
{
var runtimeEntityType = model.AddEntityType(
"StellaOps.ExportCenter.Infrastructure.EfCore.Models.ExportProfileEntity",
typeof(ExportProfileEntity),
baseEntityType,
propertyCount: 13,
navigationCount: 1,
namedIndexCount: 2,
keyCount: 1);
var profileId = runtimeEntityType.AddProperty(
"ProfileId",
typeof(Guid),
propertyInfo: typeof(ExportProfileEntity).GetProperty("ProfileId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportProfileEntity).GetField("<ProfileId>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
valueGenerated: ValueGenerated.OnAdd,
afterSaveBehavior: PropertySaveBehavior.Throw,
sentinel: new Guid("00000000-0000-0000-0000-000000000000"));
profileId.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
profileId.AddAnnotation("Relational:ColumnName", "profile_id");
var archivedAt = runtimeEntityType.AddProperty(
"ArchivedAt",
typeof(DateTime?),
propertyInfo: typeof(ExportProfileEntity).GetProperty("ArchivedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportProfileEntity).GetField("<ArchivedAt>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
archivedAt.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
archivedAt.AddAnnotation("Relational:ColumnName", "archived_at");
var createdAt = runtimeEntityType.AddProperty(
"CreatedAt",
typeof(DateTime),
propertyInfo: typeof(ExportProfileEntity).GetProperty("CreatedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportProfileEntity).GetField("<CreatedAt>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
valueGenerated: ValueGenerated.OnAdd,
sentinel: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified));
createdAt.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
createdAt.AddAnnotation("Relational:ColumnName", "created_at");
createdAt.AddAnnotation("Relational:DefaultValueSql", "(NOW() AT TIME ZONE 'UTC')");
var description = runtimeEntityType.AddProperty(
"Description",
typeof(string),
propertyInfo: typeof(ExportProfileEntity).GetProperty("Description", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportProfileEntity).GetField("<Description>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
description.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
description.AddAnnotation("Relational:ColumnName", "description");
var formatJson = runtimeEntityType.AddProperty(
"FormatJson",
typeof(string),
propertyInfo: typeof(ExportProfileEntity).GetProperty("FormatJson", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportProfileEntity).GetField("<FormatJson>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
formatJson.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
formatJson.AddAnnotation("Relational:ColumnName", "format_json");
formatJson.AddAnnotation("Relational:ColumnType", "jsonb");
var kind = runtimeEntityType.AddProperty(
"Kind",
typeof(short),
propertyInfo: typeof(ExportProfileEntity).GetProperty("Kind", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportProfileEntity).GetField("<Kind>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
sentinel: (short)0);
kind.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
kind.AddAnnotation("Relational:ColumnName", "kind");
var name = runtimeEntityType.AddProperty(
"Name",
typeof(string),
propertyInfo: typeof(ExportProfileEntity).GetProperty("Name", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportProfileEntity).GetField("<Name>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
name.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
name.AddAnnotation("Relational:ColumnName", "name");
var schedule = runtimeEntityType.AddProperty(
"Schedule",
typeof(string),
propertyInfo: typeof(ExportProfileEntity).GetProperty("Schedule", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportProfileEntity).GetField("<Schedule>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
schedule.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
schedule.AddAnnotation("Relational:ColumnName", "schedule");
var scopeJson = runtimeEntityType.AddProperty(
"ScopeJson",
typeof(string),
propertyInfo: typeof(ExportProfileEntity).GetProperty("ScopeJson", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportProfileEntity).GetField("<ScopeJson>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
scopeJson.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
scopeJson.AddAnnotation("Relational:ColumnName", "scope_json");
scopeJson.AddAnnotation("Relational:ColumnType", "jsonb");
var signingJson = runtimeEntityType.AddProperty(
"SigningJson",
typeof(string),
propertyInfo: typeof(ExportProfileEntity).GetProperty("SigningJson", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportProfileEntity).GetField("<SigningJson>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
signingJson.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
signingJson.AddAnnotation("Relational:ColumnName", "signing_json");
signingJson.AddAnnotation("Relational:ColumnType", "jsonb");
var status = runtimeEntityType.AddProperty(
"Status",
typeof(short),
propertyInfo: typeof(ExportProfileEntity).GetProperty("Status", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportProfileEntity).GetField("<Status>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
sentinel: (short)0);
status.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
status.AddAnnotation("Relational:ColumnName", "status");
var tenantId = runtimeEntityType.AddProperty(
"TenantId",
typeof(Guid),
propertyInfo: typeof(ExportProfileEntity).GetProperty("TenantId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportProfileEntity).GetField("<TenantId>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
sentinel: new Guid("00000000-0000-0000-0000-000000000000"));
tenantId.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
tenantId.AddAnnotation("Relational:ColumnName", "tenant_id");
var updatedAt = runtimeEntityType.AddProperty(
"UpdatedAt",
typeof(DateTime),
propertyInfo: typeof(ExportProfileEntity).GetProperty("UpdatedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportProfileEntity).GetField("<UpdatedAt>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
valueGenerated: ValueGenerated.OnAdd,
sentinel: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified));
updatedAt.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
updatedAt.AddAnnotation("Relational:ColumnName", "updated_at");
updatedAt.AddAnnotation("Relational:DefaultValueSql", "(NOW() AT TIME ZONE 'UTC')");
var key = runtimeEntityType.AddKey(
new[] { profileId });
runtimeEntityType.SetPrimaryKey(key);
key.AddAnnotation("Relational:Name", "export_profiles_pkey");
var ix_export_profiles_tenant_status = runtimeEntityType.AddIndex(
new[] { tenantId, status },
name: "ix_export_profiles_tenant_status");
var uq_export_profiles_tenant_name = runtimeEntityType.AddIndex(
new[] { tenantId, name },
name: "uq_export_profiles_tenant_name",
unique: true);
uq_export_profiles_tenant_name.AddAnnotation("Relational:Filter", "(archived_at IS NULL)");
return runtimeEntityType;
}
public static void CreateAnnotations(RuntimeEntityType runtimeEntityType)
{
runtimeEntityType.AddAnnotation("Relational:FunctionName", null);
runtimeEntityType.AddAnnotation("Relational:Schema", "export_center");
runtimeEntityType.AddAnnotation("Relational:SqlQuery", null);
runtimeEntityType.AddAnnotation("Relational:TableName", "export_profiles");
runtimeEntityType.AddAnnotation("Relational:ViewName", null);
runtimeEntityType.AddAnnotation("Relational:ViewSchema", null);
Customize(runtimeEntityType);
}
static partial void Customize(RuntimeEntityType runtimeEntityType);
}
}

249
src/ExportCenter/StellaOps.ExportCenter/StellaOps.ExportCenter.Infrastructure/EfCore/CompiledModels/ExportRunEntityEntityType.cs Normal file
View File

@@ -0,0 +1,249 @@
// <auto-generated />
using System;
using System.Collections.Generic;
using System.Reflection;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;
using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
using StellaOps.ExportCenter.Infrastructure.EfCore.Models;
#pragma warning disable 219, 612, 618
#nullable disable
namespace StellaOps.ExportCenter.Infrastructure.EfCore.CompiledModels
{
[EntityFrameworkInternal]
public partial class ExportRunEntityEntityType
{
public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null)
{
var runtimeEntityType = model.AddEntityType(
"StellaOps.ExportCenter.Infrastructure.EfCore.Models.ExportRunEntity",
typeof(ExportRunEntity),
baseEntityType,
propertyCount: 16,
navigationCount: 3,
foreignKeyCount: 1,
namedIndexCount: 3,
keyCount: 1);
var runId = runtimeEntityType.AddProperty(
"RunId",
typeof(Guid),
propertyInfo: typeof(ExportRunEntity).GetProperty("RunId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportRunEntity).GetField("<RunId>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
valueGenerated: ValueGenerated.OnAdd,
afterSaveBehavior: PropertySaveBehavior.Throw,
sentinel: new Guid("00000000-0000-0000-0000-000000000000"));
runId.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
runId.AddAnnotation("Relational:ColumnName", "run_id");
var completedAt = runtimeEntityType.AddProperty(
"CompletedAt",
typeof(DateTime?),
propertyInfo: typeof(ExportRunEntity).GetProperty("CompletedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportRunEntity).GetField("<CompletedAt>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
completedAt.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
completedAt.AddAnnotation("Relational:ColumnName", "completed_at");
var correlationId = runtimeEntityType.AddProperty(
"CorrelationId",
typeof(string),
propertyInfo: typeof(ExportRunEntity).GetProperty("CorrelationId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportRunEntity).GetField("<CorrelationId>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
correlationId.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
correlationId.AddAnnotation("Relational:ColumnName", "correlation_id");
var createdAt = runtimeEntityType.AddProperty(
"CreatedAt",
typeof(DateTime),
propertyInfo: typeof(ExportRunEntity).GetProperty("CreatedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportRunEntity).GetField("<CreatedAt>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
valueGenerated: ValueGenerated.OnAdd,
sentinel: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified));
createdAt.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
createdAt.AddAnnotation("Relational:ColumnName", "created_at");
createdAt.AddAnnotation("Relational:DefaultValueSql", "(NOW() AT TIME ZONE 'UTC')");
var errorJson = runtimeEntityType.AddProperty(
"ErrorJson",
typeof(string),
propertyInfo: typeof(ExportRunEntity).GetProperty("ErrorJson", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportRunEntity).GetField("<ErrorJson>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
errorJson.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
errorJson.AddAnnotation("Relational:ColumnName", "error_json");
errorJson.AddAnnotation("Relational:ColumnType", "jsonb");
var expiresAt = runtimeEntityType.AddProperty(
"ExpiresAt",
typeof(DateTime?),
propertyInfo: typeof(ExportRunEntity).GetProperty("ExpiresAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportRunEntity).GetField("<ExpiresAt>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
expiresAt.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
expiresAt.AddAnnotation("Relational:ColumnName", "expires_at");
var failedItems = runtimeEntityType.AddProperty(
"FailedItems",
typeof(int),
propertyInfo: typeof(ExportRunEntity).GetProperty("FailedItems", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportRunEntity).GetField("<FailedItems>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
valueGenerated: ValueGenerated.OnAdd,
sentinel: 0);
failedItems.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
failedItems.AddAnnotation("Relational:ColumnName", "failed_items");
failedItems.AddAnnotation("Relational:DefaultValue", 0);
var initiatedBy = runtimeEntityType.AddProperty(
"InitiatedBy",
typeof(string),
propertyInfo: typeof(ExportRunEntity).GetProperty("InitiatedBy", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportRunEntity).GetField("<InitiatedBy>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
initiatedBy.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
initiatedBy.AddAnnotation("Relational:ColumnName", "initiated_by");
var processedItems = runtimeEntityType.AddProperty(
"ProcessedItems",
typeof(int),
propertyInfo: typeof(ExportRunEntity).GetProperty("ProcessedItems", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportRunEntity).GetField("<ProcessedItems>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
valueGenerated: ValueGenerated.OnAdd,
sentinel: 0);
processedItems.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
processedItems.AddAnnotation("Relational:ColumnName", "processed_items");
processedItems.AddAnnotation("Relational:DefaultValue", 0);
var profileId = runtimeEntityType.AddProperty(
"ProfileId",
typeof(Guid),
propertyInfo: typeof(ExportRunEntity).GetProperty("ProfileId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportRunEntity).GetField("<ProfileId>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
sentinel: new Guid("00000000-0000-0000-0000-000000000000"));
profileId.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
profileId.AddAnnotation("Relational:ColumnName", "profile_id");
var startedAt = runtimeEntityType.AddProperty(
"StartedAt",
typeof(DateTime?),
propertyInfo: typeof(ExportRunEntity).GetProperty("StartedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportRunEntity).GetField("<StartedAt>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
nullable: true);
startedAt.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
startedAt.AddAnnotation("Relational:ColumnName", "started_at");
var status = runtimeEntityType.AddProperty(
"Status",
typeof(short),
propertyInfo: typeof(ExportRunEntity).GetProperty("Status", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportRunEntity).GetField("<Status>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
sentinel: (short)0);
status.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
status.AddAnnotation("Relational:ColumnName", "status");
var tenantId = runtimeEntityType.AddProperty(
"TenantId",
typeof(Guid),
propertyInfo: typeof(ExportRunEntity).GetProperty("TenantId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportRunEntity).GetField("<TenantId>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
sentinel: new Guid("00000000-0000-0000-0000-000000000000"));
tenantId.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
tenantId.AddAnnotation("Relational:ColumnName", "tenant_id");
var totalItems = runtimeEntityType.AddProperty(
"TotalItems",
typeof(int),
propertyInfo: typeof(ExportRunEntity).GetProperty("TotalItems", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportRunEntity).GetField("<TotalItems>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
valueGenerated: ValueGenerated.OnAdd,
sentinel: 0);
totalItems.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
totalItems.AddAnnotation("Relational:ColumnName", "total_items");
totalItems.AddAnnotation("Relational:DefaultValue", 0);
var totalSizeBytes = runtimeEntityType.AddProperty(
"TotalSizeBytes",
typeof(long),
propertyInfo: typeof(ExportRunEntity).GetProperty("TotalSizeBytes", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportRunEntity).GetField("<TotalSizeBytes>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
valueGenerated: ValueGenerated.OnAdd,
sentinel: 0L);
totalSizeBytes.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
totalSizeBytes.AddAnnotation("Relational:ColumnName", "total_size_bytes");
totalSizeBytes.AddAnnotation("Relational:DefaultValue", 0L);
var trigger = runtimeEntityType.AddProperty(
"Trigger",
typeof(short),
propertyInfo: typeof(ExportRunEntity).GetProperty("Trigger", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportRunEntity).GetField("<Trigger>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly),
sentinel: (short)0);
trigger.AddAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.None);
trigger.AddAnnotation("Relational:ColumnName", "trigger");
var key = runtimeEntityType.AddKey(
new[] { runId });
runtimeEntityType.SetPrimaryKey(key);
key.AddAnnotation("Relational:Name", "export_runs_pkey");
var ix_export_runs_correlation = runtimeEntityType.AddIndex(
new[] { correlationId },
name: "ix_export_runs_correlation");
ix_export_runs_correlation.AddAnnotation("Relational:Filter", "(correlation_id IS NOT NULL)");
var ix_export_runs_profile_created = runtimeEntityType.AddIndex(
new[] { profileId, createdAt },
name: "ix_export_runs_profile_created");
var ix_export_runs_tenant_status = runtimeEntityType.AddIndex(
new[] { tenantId, status },
name: "ix_export_runs_tenant_status");
return runtimeEntityType;
}
public static RuntimeForeignKey CreateForeignKey1(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType)
{
var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("ProfileId") },
principalEntityType.FindKey(new[] { principalEntityType.FindProperty("ProfileId") }),
principalEntityType,
deleteBehavior: DeleteBehavior.Cascade,
required: true);
var profile = declaringEntityType.AddNavigation("Profile",
runtimeForeignKey,
onDependent: true,
typeof(ExportProfileEntity),
propertyInfo: typeof(ExportRunEntity).GetProperty("Profile", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportRunEntity).GetField("<Profile>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
var runs = principalEntityType.AddNavigation("Runs",
runtimeForeignKey,
onDependent: false,
typeof(ICollection<ExportRunEntity>),
propertyInfo: typeof(ExportProfileEntity).GetProperty("Runs", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly),
fieldInfo: typeof(ExportProfileEntity).GetField("<Runs>k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
runtimeForeignKey.AddAnnotation("Relational:Name", "fk_runs_profile");
return runtimeForeignKey;
}
public static void CreateAnnotations(RuntimeEntityType runtimeEntityType)
{
runtimeEntityType.AddAnnotation("Relational:FunctionName", null);
runtimeEntityType.AddAnnotation("Relational:Schema", "export_center");
runtimeEntityType.AddAnnotation("Relational:SqlQuery", null);
runtimeEntityType.AddAnnotation("Relational:TableName", "export_runs");
runtimeEntityType.AddAnnotation("Relational:ViewName", null);
runtimeEntityType.AddAnnotation("Relational:ViewSchema", null);
Customize(runtimeEntityType);
}
static partial void Customize(RuntimeEntityType runtimeEntityType);
}
}

11
src/ExportCenter/StellaOps.ExportCenter/StellaOps.ExportCenter.Infrastructure/Postgres/ExportCenterDbContextFactory.cs
View File

@@ -1,6 +1,7 @@
using System;
using Microsoft.EntityFrameworkCore;
using Npgsql;
using StellaOps.ExportCenter.Infrastructure.EfCore.CompiledModels;
using StellaOps.ExportCenter.Infrastructure.EfCore.Context;
namespace StellaOps.ExportCenter.Infrastructure.Postgres;
@@ -18,12 +19,10 @@ internal static class ExportCenterDbContextFactory
var optionsBuilder = new DbContextOptionsBuilder<ExportCenterDbContext>()
.UseNpgsql(connection, npgsql => npgsql.CommandTimeout(commandTimeoutSeconds));
// Compiled model hookup point: when compiled models are generated,
// uncomment the following to use them for default schema:
// if (string.Equals(normalizedSchema, DefaultSchemaName, StringComparison.Ordinal))
// {
// optionsBuilder.UseModel(ExportCenterDbContextModel.Instance);
// }
if (string.Equals(normalizedSchema, DefaultSchemaName, StringComparison.Ordinal))
{
optionsBuilder.UseModel(ExportCenterDbContextModel.Instance);
}
return new ExportCenterDbContext(optionsBuilder.Options, normalizedSchema);
}

58
src/ExportCenter/StellaOps.ExportCenter/StellaOps.ExportCenter.Tests/CompiledModelGuardTests.cs Normal file
View File

@@ -0,0 +1,58 @@
using FluentAssertions;
using Microsoft.EntityFrameworkCore;
using StellaOps.ExportCenter.Infrastructure.EfCore.CompiledModels;
using StellaOps.ExportCenter.Infrastructure.EfCore.Models;
using StellaOps.TestKit;
using Xunit;
namespace StellaOps.ExportCenter.Tests;
/// <summary>
/// Guard tests ensuring the EF Core compiled model is real (not a stub)
/// and contains all expected entity type registrations.
/// </summary>
public sealed class CompiledModelGuardTests
{
[Trait("Category", TestCategories.Unit)]
[Fact]
public void CompiledModel_Instance_IsNotNull()
{
ExportCenterDbContextModel.Instance.Should().NotBeNull(
"compiled model must be generated via 'dotnet ef dbcontext optimize', not a stub");
}
[Trait("Category", TestCategories.Unit)]
[Fact]
public void CompiledModel_HasExpectedEntityTypeCount()
{
var entityTypes = ExportCenterDbContextModel.Instance.GetEntityTypes().ToList();
entityTypes.Should().HaveCount(4,
"export-center compiled model must contain exactly 4 entity types (regenerate with 'dotnet ef dbcontext optimize' if count differs)");
}
[Trait("Category", TestCategories.Unit)]
[Theory]
[InlineData(typeof(ExportDistributionEntity))]
[InlineData(typeof(ExportInputEntity))]
[InlineData(typeof(ExportProfileEntity))]
[InlineData(typeof(ExportRunEntity))]
public void CompiledModel_ContainsEntityType(Type entityType)
{
var found = ExportCenterDbContextModel.Instance.FindEntityType(entityType);
found.Should().NotBeNull(
$"compiled model must contain entity type '{entityType.Name}' — regenerate if missing");
}
[Trait("Category", TestCategories.Unit)]
[Fact]
public void CompiledModel_EntityTypes_HaveTableNames()
{
var entityTypes = ExportCenterDbContextModel.Instance.GetEntityTypes();
foreach (var entityType in entityTypes)
{
var tableName = entityType.GetTableName();
tableName.Should().NotBeNullOrWhiteSpace(
$"entity type '{entityType.ClrType.Name}' must have a table name configured");
}
}
}