public static void Write(OutputModel outputModel, DatabasePlan databasePlan, PartitionPlan partitionPlan)
{
if (!partitionPlan.Documents.Any(x => x.IsMutable || x.IsTransient))
{
return;
}
var s = $@"
namespace {databasePlan.Namespace};
public class {partitionPlan.CreateOrReplaceClassName}
{{
protected virtual {databasePlan.Namespace}.{partitionPlan.ClassName} {partitionPlan.ClassName} {{ get; }} = default!;
/// <summary>Mocking constructor</summary>
protected {partitionPlan.CreateOrReplaceClassName}() {{ }}
internal protected {partitionPlan.CreateOrReplaceClassName}({databasePlan.Namespace}.{partitionPlan.ClassName} {partitionPlan.ClassNameArgument})
{{
this.{partitionPlan.ClassName} = {partitionPlan.ClassNameArgument} ?? throw new System.ArgumentNullException(nameof({partitionPlan.ClassNameArgument}));
}}
{string.Concat(partitionPlan.Documents.Select(x => CreateOrReplace(partitionPlan, x)))}
}}
";
outputModel.Context.AddSource($"partition_{partitionPlan.CreateOrReplaceClassName}.cs", s);
}
static string Unions(DatabasePlan databasePlan, PartitionPlan partitionPlan) =>
partitionPlan.Unions.Count == 0 ? "" : $@"
{databasePlan.Namespace}.{partitionPlan.QueryUnionsClassName}? unions;
public virtual {databasePlan.Namespace}.{partitionPlan.QueryUnionsClassName} Unions => this.unions ??= new(
{databasePlan.DbClassNameArgument}: this.{databasePlan.DbClassName},
{partitionPlan.QueryBuilderClassNameArgument}: this.{partitionPlan.QueryBuilderClassName});
";
public static void Write(OutputModel outputModel, DatabasePlan databasePlan, PartitionPlan partitionPlan)
{
var s = $@"
namespace {databasePlan.Namespace};
public class {partitionPlan.QueryBuilderClassName} : Cosmogenesis.Core.DbQueryBuilderBase
{{
protected virtual {databasePlan.Namespace}.{databasePlan.DbClassName} {databasePlan.DbClassName} {{ get; }} = default!;
/// <summary>Mocking constructor</summary>
protected {partitionPlan.QueryBuilderClassName}() {{ }}
internal protected {partitionPlan.QueryBuilderClassName}(
{databasePlan.Namespace}.{databasePlan.DbClassName} {databasePlan.DbClassNameArgument},
Microsoft.Azure.Cosmos.PartitionKey? partitionKey)
: base(
dbBase: {databasePlan.DbClassNameArgument},
partitionKey: partitionKey)
{{
{databasePlan.DbClassName} = {databasePlan.DbClassNameArgument} ?? throw new System.ArgumentNullException(nameof({databasePlan.DbClassNameArgument}));
}}
{string.Concat(partitionPlan.Documents.Select(BuildQuery))}
{Unions(databasePlan, partitionPlan)}
}}
";
if (partitionPlan.Unions.Any())
{
QueryBuilderUnionsWriter.Write(outputModel, databasePlan, partitionPlan);
}
outputModel.Context.AddSource($"partition_{partitionPlan.QueryBuilderClassName}.cs", s);
}
public static void Write(OutputModel outputModel, DatabasePlan databasePlan)
{
var anyUnions = databasePlan.PartitionPlansByName.Values.SelectMany(x => x.Unions).Any();
var s = $@"
namespace {databasePlan.Namespace};
public class {databasePlan.QueryBuilderClassName} : Cosmogenesis.Core.DbQueryBuilderBase
{{
protected virtual {databasePlan.Namespace}.{databasePlan.DbClassName} {databasePlan.DbClassName} {{ get; }} = default!;
/// <summary>Mocking constructor</summary>
protected {databasePlan.QueryBuilderClassName}() {{ }}
internal protected {databasePlan.QueryBuilderClassName}(
{databasePlan.Namespace}.{databasePlan.DbClassName} {databasePlan.DbClassNameArgument})
: base(
dbBase: {databasePlan.DbClassNameArgument},
partitionKey: null)
{{
{databasePlan.DbClassName} = {databasePlan.DbClassNameArgument} ?? throw new System.ArgumentNullException(nameof({databasePlan.DbClassNameArgument}));
}}
{string.Concat(databasePlan.PartitionPlansByName.Values.SelectMany(x => x.Documents).Select(BuildQuery))}
{(anyUnions ? Unions(databasePlan) : "")}
}}
";
if (anyUnions)
{
DbQueryBuilderUnionsWriter.Write(outputModel, databasePlan);
}
outputModel.Context.AddSource($"db_{databasePlan.QueryBuilderClassName}.cs", s);
}
public static void Write(OutputModel outputModel, DatabasePlan databasePlan)
{
var anyUnions = databasePlan.PartitionPlansByName.Values.SelectMany(x => x.Unions).Any();
var s = $@"
namespace {databasePlan.Namespace};
public class {databasePlan.QueryBuilderUnionsClassName} : Cosmogenesis.Core.DbQueryBuilderBase
{{
/// <summary>Mocking constructor</summary>
protected {databasePlan.QueryBuilderUnionsClassName}() {{ }}
internal protected {databasePlan.QueryBuilderUnionsClassName}(
{databasePlan.Namespace}.{databasePlan.DbClassName} {databasePlan.DbClassNameArgument})
: base(
dbBase: {databasePlan.DbClassNameArgument},
partitionKey: null)
{{
}}
{string.Concat(databasePlan.PartitionPlansByName.Values.SelectMany(x => x.Unions).Select(BuildQuery))}
}}
";
outputModel.Context.AddSource($"db_{databasePlan.QueryBuilderUnionsClassName}.cs", s);
}
public static void Write(OutputModel outputModel, DatabasePlan databasePlan)
{
var s = $@"
namespace {databasePlan.Namespace};
public class {databasePlan.ChangeFeedProcessorClassName} : Cosmogenesis.Core.ChangeFeedProcessorBase
{{
/// <summary>Mocking constructor</summary>
protected {databasePlan.ChangeFeedProcessorClassName}() {{ }}
public {databasePlan.ChangeFeedProcessorClassName}(
Microsoft.Azure.Cosmos.Container databaseContainer,
Microsoft.Azure.Cosmos.Container leaseContainer,
string processorName,
{databasePlan.Namespace}.{databasePlan.BatchHandlersClassName} {databasePlan.BatchHandlersArgumentName},
{databasePlan.Namespace}.{databasePlan.SerializerClassName}? serializer = null,
int maxItemsPerBatch = DefaultMaxItemsPerBatch,
System.TimeSpan? pollInterval = null,
System.DateTime? startTime = null)
: base (
serializer: serializer ?? {databasePlan.Namespace}.{databasePlan.SerializerClassName}.Instance,
processorName: processorName,
maxItemsPerBatch: maxItemsPerBatch,
pollInterval: pollInterval,
startTime: startTime,
databaseContainer: databaseContainer,
leaseContainer: leaseContainer,
batchProcessor: new({databasePlan.BatchHandlersArgumentName}))
{{
}}
}}
";
outputModel.Context.AddSource($"feed_{databasePlan.ChangeFeedProcessorClassName}.cs", s);
}
public static void Write(OutputModel outputModel, DatabasePlan databasePlan, PartitionPlan partitionPlan)
{
var s = $@"
namespace {databasePlan.Namespace};
public class {partitionPlan.ReadClassName}
{{
protected virtual {databasePlan.Namespace}.{databasePlan.DbClassName} {databasePlan.DbClassName} {{ get; }} = default!;
protected virtual Microsoft.Azure.Cosmos.PartitionKey PartitionKey {{ get; }} = default!;
/// <summary>Mocking constructor</summary>
protected {partitionPlan.ReadClassName}() {{ }}
internal protected {partitionPlan.ReadClassName}(
{databasePlan.Namespace}.{databasePlan.DbClassName} {databasePlan.DbClassNameArgument},
Microsoft.Azure.Cosmos.PartitionKey partitionKey)
{{
this.{databasePlan.DbClassName} = {databasePlan.DbClassNameArgument} ?? throw new System.ArgumentNullException(nameof({databasePlan.DbClassNameArgument}));
this.PartitionKey = partitionKey;
}}
{string.Concat(partitionPlan.Documents.Select(x => Read(databasePlan, x)))}
{Unions(databasePlan, partitionPlan)}
}}
";
if (partitionPlan.Unions.Count > 0)
{
ReadUnionsWriter.Write(outputModel, databasePlan, partitionPlan);
}
outputModel.Context.AddSource($"partition_{partitionPlan.ReadClassName}.cs", s);
}
public static void Write(OutputModel outputModel, DatabasePlan databasePlan)
{
var s = $@"
namespace {databasePlan.Namespace};
public class {databasePlan.PartitionsClassName}
{{
protected virtual {databasePlan.Namespace}.{databasePlan.DbClassName} {databasePlan.DbClassName} {{ get; }} = default!;
/// <summary>Mocking constructor</summary>
protected {databasePlan.PartitionsClassName}() {{ }}
internal protected {databasePlan.PartitionsClassName}({databasePlan.Namespace}.{databasePlan.DbClassName} {databasePlan.DbClassNameArgument})
{{
this.{databasePlan.DbClassName} = {databasePlan.DbClassNameArgument} ?? throw new System.ArgumentNullException(nameof({databasePlan.DbClassNameArgument}));
}}
{string.Concat(databasePlan.PartitionPlansByName.Values.Select(x => Partition(databasePlan, x)))}
}}
";
outputModel.Context.AddSource($"db_{databasePlan.PartitionsClassName}.cs", s);
foreach (var partition in databasePlan.PartitionPlansByName.Values)
{
PartitionWriter.Write(outputModel, databasePlan, partition);
}
}
public static void Write(OutputModel outputModel, DatabasePlan databasePlan)
{
var s = $@"
namespace {databasePlan.Namespace};
public class {databasePlan.ReadClassName}
{{
protected virtual {databasePlan.Namespace}.{databasePlan.DbClassName} {databasePlan.DbClassName} {{ get; }} = default!;
/// <summary>Mocking constructor</summary>
protected {databasePlan.ReadClassName}() {{ }}
internal protected {databasePlan.ReadClassName}({databasePlan.Namespace}.{databasePlan.DbClassName} {databasePlan.DbClassNameArgument})
{{
this.{databasePlan.DbClassName} = {databasePlan.DbClassNameArgument} ?? throw new System.ArgumentNullException(nameof({databasePlan.DbClassNameArgument}));
}}
/// <summary>
/// Try to load a document by pk & id.
/// id should be transformed using DbDocHelper.GetValidId.
/// Returns the document or null if not found.
/// </summary>
/// <exception cref=""Cosmogenesis.Core.DbOverloadedException"" />
/// <exception cref=""Cosmogenesis.Core.DbUnknownStatusCodeException"" />
public virtual System.Threading.Tasks.Task<Cosmogenesis.Core.DbDoc?> ByIdAsync(string partitionKey, string id) =>
this.{databasePlan.DbClassName}.ReadByIdAsync(
partitionKey: new Microsoft.Azure.Cosmos.PartitionKey(partitionKey),
id: id);
{string.Concat(databasePlan.PartitionPlansByName.Values.SelectMany(x => x.Documents).Select(x => Read(databasePlan, x)))}
}}
";
outputModel.Context.AddSource($"db_{databasePlan.ReadClassName}.cs", s);
}
public static void Write(OutputModel outputModel, DatabasePlan databasePlan)
{
var s = $@"
namespace {databasePlan.Namespace};
public class {databasePlan.QueryUnionsClassName} : Cosmogenesis.Core.DbQueryBase
{{
protected virtual {databasePlan.Namespace}.{databasePlan.DbClassName} {databasePlan.DbClassName} {{ get; }} = default!;
protected virtual {databasePlan.Namespace}.{databasePlan.QueryBuilderClassName} {databasePlan.QueryBuilderClassName} {{ get; }} = default!;
/// <summary>Mocking constructor</summary>
protected {databasePlan.QueryUnionsClassName}() {{ }}
internal protected {databasePlan.QueryUnionsClassName}(
{databasePlan.Namespace}.{databasePlan.DbClassName} {databasePlan.DbClassNameArgument},
{databasePlan.Namespace}.{databasePlan.QueryBuilderClassName} {databasePlan.QueryBuilderClassNameArgument})
: base(
dbBase: {databasePlan.DbClassNameArgument},
queryBuilder: {databasePlan.QueryBuilderClassNameArgument})
{{
this.{databasePlan.DbClassName} = {databasePlan.DbClassNameArgument} ?? throw new System.ArgumentNullException(nameof({databasePlan.DbClassNameArgument}));
this.{databasePlan.QueryBuilderClassName} = {databasePlan.QueryBuilderClassNameArgument} ?? throw new System.ArgumentNullException(nameof({databasePlan.QueryBuilderClassNameArgument}));
}}
{string.Concat(databasePlan.PartitionPlansByName.Values.SelectMany(x => x.Unions).Select(x => Query(databasePlan, x)))}
}}
";
outputModel.Context.AddSource($"db_{databasePlan.QueryUnionsClassName}.cs", s);
}
static string Read(DatabasePlan databasePlan, DocumentPlan documentPlan)
{
if (documentPlan.GetIdPlan.Arguments.Count == 0)
{
return("");
}
var singleType = documentPlan.GetIdPlan.Arguments[0].FullTypeName;
var singleTypeParam = documentPlan.GetIdPlan.Arguments[0].ArgumentName.Pluralize();
var inputParams =
documentPlan.GetIdPlan.Arguments.Count == 1
? $"System.Collections.Generic.IEnumerable<{singleType}> {singleTypeParam}"
: $"System.Collections.Generic.IEnumerable<({documentPlan.GetIdPlan.AsInputParameters()})> ids";
var toId =
documentPlan.GetIdPlan.Arguments.Count == 1
? $"{singleTypeParam}.Select({documentPlan.GetIdPlan.FullMethodName}).Select(Cosmogenesis.Core.DbDocHelper.GetValidId)"
: $"ids.Select(x => {documentPlan.GetIdPlan.FullMethodName}({documentPlan.GetIdPlan.ParametersToParametersMapping("x")})).Select(Cosmogenesis.Core.DbDocHelper.GetValidId)";
return($@"
/// <summary>
/// Try to load {documentPlan.ClassName} documents by id.
/// Returns an array of {documentPlan.ClassName} documents (or null if not found) in the same order as the ids were provided.
/// </summary>
/// <exception cref=""Cosmogenesis.Core.DbOverloadedException"" />
/// <exception cref=""Cosmogenesis.Core.DbUnknownStatusCodeException"" />
public virtual System.Threading.Tasks.Task<{documentPlan.FullTypeName}?[]> {documentPlan.ClassName.Pluralize()}Async({inputParams}) =>
this.{databasePlan.DbClassName}.ReadByIdsAsync<{documentPlan.FullTypeName}>(
partitionKey: this.PartitionKey,
ids: {toId},
type: {documentPlan.ConstDocType});
");
}
public static void Write(OutputModel outputModel, DatabasePlan databasePlan)
{
var s = $@"
namespace {databasePlan.Namespace};
/// <summary>
/// This converter knows how to convert the DbDoc base type into documents from the {databasePlan.Name} database.
/// </summary>
public class {databasePlan.ConverterClassName} : Cosmogenesis.Core.DbDocConverterBase
{{
/// <summary>
/// This converter knows how to convert the DbDoc base type into documents from the {databasePlan.Name} database.
/// </summary>
public static readonly {databasePlan.Namespace}.{databasePlan.ConverterClassName} Instance = new();
protected override Cosmogenesis.Core.DbDoc? DeserializeByType(
System.ReadOnlySpan<byte> data,
string? type,
System.Text.Json.JsonSerializerOptions options) => type switch
{{
{string.Concat(databasePlan.PartitionPlansByName.Values.SelectMany(x => x.Documents).Select(DeserializeType))}
_ => throw new System.NotSupportedException($""We don't know how to deserialize a message of type {{type}}"")
}};
}}
";
outputModel.Context.AddSource($"db_{databasePlan.ConverterClassName}.cs", s);
}
static string Query(DatabasePlan databasePlan, UnionPlan unionPlan) => $@"
/// <summary>
/// Build and execute a query filtered to {unionPlan.CommonName} documents.
/// {unionPlan.CommonName} is a union of: {string.Join(", ", unionPlan.Documents.Select(x => x.ClassName))}
/// <see cref=""https://github.com/Azure/azure-cosmos-dotnet-v3/blob/bb72ba5786d99d928b4774e16810f2655029e8a2/Microsoft.Azure.Cosmos/src/Linq/CosmosLinqExtensions.cs"" />
/// </summary>
public virtual System.Collections.Generic.IAsyncEnumerable<T> {unionPlan.CommonName.Pluralize()}<T>(
System.Func<System.Linq.IQueryable<{unionPlan.FullCommonTypeName}>, System.Linq.IQueryable<T>> createQuery,
System.Threading.CancellationToken cancellationToken = default)
=> this.{databasePlan.DbClassName}
.ExecuteQueryAsync(
query: createQuery(this.{databasePlan.QueryBuilderClassName}.Unions.{unionPlan.CommonName.Pluralize()}()),
cancellationToken: cancellationToken);
/// <summary>
/// Execute a query filtered to {unionPlan.CommonName} documents.
/// {unionPlan.CommonName} is a union of: {string.Join(", ", unionPlan.Documents.Select(x => x.ClassName))}
/// </summary>
public virtual System.Collections.Generic.IAsyncEnumerable<{unionPlan.FullCommonTypeName}> {unionPlan.CommonName.Pluralize()}(
System.Threading.CancellationToken cancellationToken = default)
=> this.{databasePlan.DbClassName}
.ExecuteQueryAsync(
query: this.{databasePlan.QueryBuilderClassName}.Unions.{unionPlan.CommonName.Pluralize()}(),
cancellationToken: cancellationToken);
";
public static void Write(OutputModel outputModel, DatabasePlan databasePlan)
{
var s = $@"
namespace {databasePlan.Namespace};
public class {databasePlan.BatchHandlersClassName} : Cosmogenesis.Core.BatchHandlersBase
{{
/// <summary>Mocking constructor</summary>
protected {databasePlan.BatchHandlersClassName}() {{ }}
public {databasePlan.BatchHandlersClassName}({ConstructorArgs(databasePlan)}
System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task>? newChangeFeedBatch = null,
System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task>? finishingBatch = null)
{{
this.NewChangeFeedBatch = newChangeFeedBatch;
this.FinishingBatch = finishingBatch;
{string.Concat(databasePlan.PartitionPlansByName.Values.Select(AssignArg))}
}}
{string.Concat(databasePlan.PartitionPlansByName.Values.Select(Partition))}
public override System.Threading.Tasks.Task? GetHandlerTask(
Cosmogenesis.Core.DbDoc doc,
System.Threading.CancellationToken cancellationToken) => doc switch
{{
{string.Concat(databasePlan.PartitionPlansByName.Values.SelectMany(x => x.Documents.Select(d => CallHandler(databasePlan, x, d))))}
_ => throw new System.NotSupportedException($""Document of type {{doc?.GetType().Name}} was unexpected"")
}};
}}
";
outputModel.Context.AddSource($"feed_{databasePlan.BatchHandlersClassName}.cs", s);
}
static string Read(DatabasePlan databasePlan, UnionPlan unionPlan) => $@"
/// <summary>
/// Try to load a {unionPlan.CommonName} by id.
/// id should be transformed using Cosmogenesis.Core.DbDocHelper.GetValidId.
/// {unionPlan.CommonName} is a union of: {string.Join(", ", unionPlan.Documents.Select(x => x.ClassName))}
/// </summary>
/// <exception cref=""Cosmogenesis.Core.DbOverloadedException"" />
/// <exception cref=""Cosmogenesis.Core.DbUnknownStatusCodeException"" />
protected virtual async System.Threading.Tasks.Task<{unionPlan.FullCommonTypeName}?> {unionPlan.CommonName}Async(string id) =>
({unionPlan.FullCommonTypeName}?)await this.{databasePlan.DbClassName}.ReadByIdAsync(
partitionKey: this.PartitionKey,
id: id);
/// <summary>
/// Try to load a {unionPlan.CommonName} by id.
/// Returns the {unionPlan.CommonName} or null if not found.
/// {unionPlan.CommonName} is a union of: {string.Join(", ", unionPlan.Documents.Select(x => x.ClassName))}
/// </summary>
/// <exception cref=""Cosmogenesis.Core.DbOverloadedException"" />
/// <exception cref=""Cosmogenesis.Core.DbUnknownStatusCodeException"" />
public virtual async System.Threading.Tasks.Task<{unionPlan.FullCommonTypeName}?> {unionPlan.CommonName}Async({unionPlan.GetIdPlan.AsInputParameters()}) =>
({unionPlan.FullCommonTypeName}?)await this.{databasePlan.DbClassName}.ReadByIdAsync(
partitionKey: this.PartitionKey,
id: Cosmogenesis.Core.DbDocHelper.GetValidId({unionPlan.GetIdPlan.FullMethodName}({unionPlan.GetIdPlan.AsInputParameterMapping()})));
";
public static void Write(OutputModel outputModel, DatabasePlan databasePlan, PartitionPlan partitionPlan)
{
var s = $@"
namespace {databasePlan.Namespace};
public class {partitionPlan.QueryBuilderUnionsClassName} : Cosmogenesis.Core.DbQueryBuilderBase
{{
/// <summary>Mocking constructor</summary>
protected {partitionPlan.QueryBuilderUnionsClassName}() {{ }}
internal protected {partitionPlan.QueryBuilderUnionsClassName}(
{databasePlan.Namespace}.{databasePlan.DbClassName} {databasePlan.DbClassNameArgument},
Microsoft.Azure.Cosmos.PartitionKey? partitionKey)
: base(
dbBase: {databasePlan.DbClassNameArgument},
partitionKey: partitionKey)
{{
}}
{string.Concat(partitionPlan.Unions.Select(BuildQuery))}
}}
";
outputModel.Context.AddSource($"partition_{partitionPlan.QueryBuilderUnionsClassName}.cs", s);
}
static string Read(DatabasePlan databasePlan, DocumentPlan documentPlan) => $@"
/// <summary>
/// Try to load a {documentPlan.ClassName} by id.
/// Returns the {documentPlan.ClassName} or null if not found.
/// </summary>
/// <exception cref=""Cosmogenesis.Core.DbOverloadedException"" />
/// <exception cref=""Cosmogenesis.Core.DbUnknownStatusCodeException"" />
protected virtual System.Threading.Tasks.Task<{documentPlan.FullTypeName}?> {documentPlan.ClassName}ByIdAsync(string id) =>
this.{databasePlan.DbClassName}.ReadByIdAsync<{documentPlan.FullTypeName}>(
partitionKey: this.PartitionKey,
id: id,
type: {documentPlan.ConstDocType});
/// <summary>
/// Try to load a {documentPlan.ClassName} using an id generated by the parameters.
/// Returns the {documentPlan.ClassName} or null if not found.
/// </summary>
/// <exception cref=""Cosmogenesis.Core.DbOverloadedException"" />
/// <exception cref=""Cosmogenesis.Core.DbUnknownStatusCodeException"" />
public virtual System.Threading.Tasks.Task<{documentPlan.FullTypeName}?> {documentPlan.ClassName}Async({documentPlan.GetIdPlan.AsInputParameters()}) =>
this.{databasePlan.DbClassName}.ReadByIdAsync<{documentPlan.FullTypeName}>(
partitionKey: this.PartitionKey,
id: Cosmogenesis.Core.DbDocHelper.GetValidId({documentPlan.GetIdPlan.FullMethodName}({documentPlan.GetIdPlan.AsInputParameterMapping()})),
type: {documentPlan.ConstDocType});
";
static string Unions(DatabasePlan databasePlan, PartitionPlan partitionPlan) =>
partitionPlan.Unions.Count == 0 ? "" : $@"
{databasePlan.Namespace}.{partitionPlan.ReadOrThrowUnionsClassName}? unions;
public virtual {databasePlan.Namespace}.{partitionPlan.ReadOrThrowUnionsClassName} Unions => this.unions ??= new(
{databasePlan.DbClassNameArgument}: this.{databasePlan.DbClassName},
partitionKey: this.PartitionKey);
";
static string CreateOrReplace(DatabasePlan databasePlan, PartitionPlan partitionPlan) =>
!partitionPlan.Documents.Any(x => x.IsTransient || x.IsMutable)
? ""
: $@"
{partitionPlan.CreateOrReplaceClassName}? createOrReplace;
/// <summary>
/// Methods to create or replace (unconditionally overwrite) documents.
/// </summary>
public virtual {databasePlan.Namespace}.{partitionPlan.CreateOrReplaceClassName} CreateOrReplace => this.createOrReplace ??= new(this);
";
static string ReadMany(DatabasePlan databasePlan, PartitionPlan partitionPlan) =>
!partitionPlan.Documents.Any(x => x.GetIdPlan.Arguments.Count > 0)
? ""
: $@"
{partitionPlan.ReadManyClassName}? readMany;
/// <summary>
/// Methods to read multiple documents at once, though not necessarily in a single operation.
/// </summary>
public virtual {databasePlan.Namespace}.{partitionPlan.ReadManyClassName} ReadMany => this.readMany ??= new(
{databasePlan.DbClassNameArgument}: {databasePlan.DbClassName},
partitionKey: this.PartitionKey);
";
static string Replace(DatabasePlan databasePlan, PartitionPlan partitionPlan, DocumentPlan documentPlan) =>
!documentPlan.IsMutable
? ""
: $@"
/// <summary>
/// Queue a {documentPlan.ClassName} for replacement in the batch
/// </summary>
public virtual {databasePlan.Namespace}.{partitionPlan.BatchClassName} Replace({documentPlan.FullTypeName} {documentPlan.ClassNameArgument})
{{
this.ReplaceCore(item: {documentPlan.ClassNameArgument}, type: {documentPlan.ConstDocType});
return this;
}}
";
static string Delete(DatabasePlan databasePlan, PartitionPlan partitionPlan, DocumentPlan documentPlan) =>
!documentPlan.IsTransient
? ""
: $@"
/// <summary>
/// Queue a {documentPlan.ClassName} for deletion in the batch
/// </summary>
public virtual {databasePlan.Namespace}.{partitionPlan.BatchClassName} Delete({documentPlan.FullTypeName} {documentPlan.ClassNameArgument})
{{
this.DeleteCore(item: {documentPlan.ClassNameArgument});
return this;
}}
";
public static void Write(OutputModel outputModel, DatabasePlan databasePlan)
{
var s = $@"
namespace {databasePlan.Namespace};
public static class {databasePlan.TypesClassName}
{{
{string.Concat(databasePlan.PartitionPlansByName.Values.Select(PartitionTypes))}
}}
";
outputModel.Context.AddSource($"db_{databasePlan.TypesClassName}.cs", s);
}
static string Read(DatabasePlan databasePlan, DocumentPlan documentPlan) => $@"
/// <summary>
/// Try to load a {documentPlan.ClassName} by pk & id.
/// id should be transformed using DbDocHelper.GetValidId.
/// Returns the {documentPlan.ClassName} or null if not found.
/// </summary>
/// <exception cref=""Cosmogenesis.Core.DbOverloadedException"" />
/// <exception cref=""Cosmogenesis.Core.DbUnknownStatusCodeException"" />
public virtual System.Threading.Tasks.Task<{documentPlan.FullTypeName}?> {documentPlan.ClassName}ByIdAsync(string partitionKey, string id) =>
this.{databasePlan.DbClassName}.ReadByIdAsync<{documentPlan.FullTypeName}>(
partitionKey: new Microsoft.Azure.Cosmos.PartitionKey(partitionKey),
id: id,
type: {documentPlan.ConstDocType});
";
static string ReadById(DatabasePlan databasePlan, DocumentPlan documentPlan) =>
documentPlan.GetIdPlan.Arguments.Count == 0
? ""
: $@"
/// <summary>
/// Try to load {documentPlan.ClassName} documents by id.
/// id should be transformed using Cosmogenesis.Core.DbDocHelper.GetValidId.
/// Returns an array of {documentPlan.ClassName} documents (or null if not found) in the same order as the ids were provided.
/// </summary>
/// <exception cref=""Cosmogenesis.Core.DbOverloadedException"" />
/// <exception cref=""Cosmogenesis.Core.DbUnknownStatusCodeException"" />
protected virtual System.Threading.Tasks.Task<{documentPlan.FullTypeName}?[]> {documentPlan.ClassName.Pluralize()}ByIdAsync(System.Collections.Generic.IEnumerable<string> ids) =>
this.{databasePlan.DbClassName}.ReadByIdsAsync<{documentPlan.FullTypeName}>(
partitionKey: this.PartitionKey,
ids: ids,
type: {documentPlan.ConstDocType});
";
static string Create(DatabasePlan databasePlan, PartitionPlan partitionPlan, DocumentPlan documentPlan) => $@"
/// <summary>
/// Queue a {documentPlan.ClassName} for creation in the batch
/// </summary>
protected virtual {databasePlan.Namespace}.{partitionPlan.BatchClassName} Create({documentPlan.FullTypeName} {documentPlan.ClassNameArgument})
{{
{DocumentModelWriter.CreateAndCheckPkAndId(partitionPlan, documentPlan, documentPlan.ClassNameArgument)}
this.CreateCore(item: {documentPlan.ClassNameArgument}, type: {documentPlan.ConstDocType});
return this;
}}
/// <summary>
/// Queue a {documentPlan.ClassName} for creation in the batch
/// </summary>
public virtual {databasePlan.Namespace}.{partitionPlan.BatchClassName} Create{documentPlan.ClassName}({documentPlan.PropertiesByName.Values.Where(x => !partitionPlan.GetPkPlan.ArgumentByPropertyName.ContainsKey(x.PropertyName)).AsInputParameters()}) =>
this.Create({documentPlan.ClassNameArgument}: new {documentPlan.FullTypeName} {{ {partitionPlan.AsSettersFromDocumentPlanAndPartitionClass(documentPlan)} }});
";
static string ReadOrThrow(DatabasePlan databasePlan, DocumentPlan documentPlan) => $@"
/// <summary>
/// Try to load a {documentPlan.ClassName} by id.
/// id should be transformed using Cosmogenesis.Core.DbDocHelper.GetValidId.
/// Returns the {documentPlan.ClassName} or throws DbConflictException if not found.
/// </summary>
/// <exception cref=""Cosmogenesis.Core.DbOverloadedException"" />
/// <exception cref=""Cosmogenesis.Core.DbConflictException"" />
/// <exception cref=""Cosmogenesis.Core.DbUnknownStatusCodeException"" />
protected virtual async System.Threading.Tasks.Task<{documentPlan.FullTypeName}> {documentPlan.ClassName}ByIdAsync(string id)
{{
var result = await this.{databasePlan.DbClassName}.ReadByIdAsync<{documentPlan.FullTypeName}>(
partitionKey: this.PartitionKey,
id: id,
type: {documentPlan.ConstDocType}).ConfigureAwait(false);
if (result is null)
{{
throw Cosmogenesis.Core.DbModelFactory.CreateDbConflictException(dbConflictType: Cosmogenesis.Core.DbConflictType.Missing);
}}
return result;
}}
/// <summary>
/// Try to load a {documentPlan.ClassName} using an id generated by the parameters.
/// Returns the {documentPlan.ClassName} or throws DbConflictException if not found.
/// </summary>
/// <exception cref=""Cosmogenesis.Core.DbOverloadedException"" />
/// <exception cref=""Cosmogenesis.Core.DbConflictException"" />
/// <exception cref=""Cosmogenesis.Core.DbUnknownStatusCodeException"" />
public virtual async System.Threading.Tasks.Task<{documentPlan.FullTypeName}> {documentPlan.ClassName}Async({documentPlan.GetIdPlan.AsInputParameters()})
{{
var result = await this.{databasePlan.DbClassName}.ReadByIdAsync<{documentPlan.FullTypeName}>(
partitionKey: this.PartitionKey,
id: Cosmogenesis.Core.DbDocHelper.GetValidId({documentPlan.GetIdPlan.FullMethodName}({documentPlan.GetIdPlan.AsInputParameterMapping()})),
type: {documentPlan.ConstDocType}).ConfigureAwait(false);
if (result is null)
{{
throw Cosmogenesis.Core.DbModelFactory.CreateDbConflictException(dbConflictType: Cosmogenesis.Core.DbConflictType.Missing);
}}
return result;
}}
";
static string ReadOrThrow(DatabasePlan databasePlan, UnionPlan unionPlan) => $@"
/// <summary>
/// Try to load a {unionPlan.CommonName} by id.
/// id should be transformed using Cosmogenesis.Core.DbDocHelper.GetValidId.
/// Returns the {unionPlan.CommonName} or throws DbConflictException if not found.
/// {unionPlan.CommonName} is a union of: {string.Join(", ", unionPlan.Documents.Select(x => x.ClassName))}
/// </summary>
/// <exception cref=""Cosmogenesis.Core.DbOverloadedException"" />
/// <exception cref=""Cosmogenesis.Core.DbConflictException"" />
/// <exception cref=""Cosmogenesis.Core.DbUnknownStatusCodeException"" />
protected virtual async System.Threading.Tasks.Task<{unionPlan.FullCommonTypeName}> {unionPlan.CommonName}Async(string id)
{{
var result = ({unionPlan.FullCommonTypeName}?)await this.{databasePlan.DbClassName}.ReadByIdAsync(
partitionKey: this.PartitionKey,
id: id);
if (result is null)
{{
throw Cosmogenesis.Core.DbModelFactory.CreateDbConflictException(dbConflictType: Cosmogenesis.Core.DbConflictType.Missing);
}}
return result;
}}
/// <summary>
/// Try to load a {unionPlan.CommonName} by id.
/// Returns the {unionPlan.CommonName} or throws DbConflictException if not found.
/// {unionPlan.CommonName} is a union of: {string.Join(", ", unionPlan.Documents.Select(x => x.ClassName))}
/// </summary>
/// <exception cref=""Cosmogenesis.Core.DbOverloadedException"" />
/// <exception cref=""Cosmogenesis.Core.DbConflictException"" />
/// <exception cref=""Cosmogenesis.Core.DbUnknownStatusCodeException"" />
public virtual async System.Threading.Tasks.Task<{unionPlan.FullCommonTypeName}> {unionPlan.CommonName}Async({unionPlan.GetIdPlan.AsInputParameters()})
{{
var result = ({unionPlan.FullCommonTypeName}?)await this.{databasePlan.DbClassName}.ReadByIdAsync(
partitionKey: this.PartitionKey,
id: Cosmogenesis.Core.DbDocHelper.GetValidId({unionPlan.GetIdPlan.FullMethodName}({unionPlan.GetIdPlan.AsInputParameterMapping()})));
if (result is null)
{{
throw Cosmogenesis.Core.DbModelFactory.CreateDbConflictException(dbConflictType: Cosmogenesis.Core.DbConflictType.Missing);
}}
return result;
}}
";
static string ReadById(DatabasePlan databasePlan, UnionPlan unionPlan) => $@"
/// <summary>
/// Try to load {unionPlan.CommonName} documents by id.
/// id should be transformed using Cosmogenesis.Core.DbDocHelper.GetValidId.
/// Returns an array of {unionPlan.CommonName} documents (or null if not found) in the same order as the ids were provided.
/// {unionPlan.CommonName} is a union of: {string.Join(", ", unionPlan.Documents.Select(x => x.ClassName))}
/// </summary>
/// <exception cref=""Cosmogenesis.Core.DbOverloadedException"" />
/// <exception cref=""Cosmogenesis.Core.DbUnknownStatusCodeException"" />
protected virtual async System.Threading.Tasks.Task<{unionPlan.FullCommonTypeName}?[]> {unionPlan.CommonName.Pluralize()}ByIdAsync(System.Collections.Generic.IEnumerable<string> ids)
{{
var docs = await this.{databasePlan.DbClassName}.ReadByIdsAsync(
partitionKey: this.PartitionKey,
ids: ids);
var results = new {unionPlan.FullCommonTypeName}?[docs.Length];
for (var x = 0; x < docs.Length; ++x)
{{
results[x] = ({unionPlan.FullCommonTypeName}?)docs[x];
}}
return results;
}}
";
static string Read(DatabasePlan databasePlan, UnionPlan unionPlan)
{
var singleType = unionPlan.GetIdPlan.Arguments[0].FullTypeName;
var singleTypeParam = unionPlan.GetIdPlan.Arguments[0].ArgumentName.Pluralize();
var inputParams =
unionPlan.GetIdPlan.Arguments.Count == 1
? $"System.Collections.Generic.IEnumerable<{singleType}> {singleTypeParam}"
: $"System.Collections.Generic.IEnumerable<({unionPlan.GetIdPlan.AsInputParameters()})> ids";
var toId =
unionPlan.GetIdPlan.Arguments.Count == 1
? $"{singleTypeParam}.Select({unionPlan.GetIdPlan.FullMethodName}).Select(Cosmogenesis.Core.DbDocHelper.GetValidId)"
: $"ids.Select(x => {unionPlan.GetIdPlan.FullMethodName}({unionPlan.GetIdPlan.ParametersToParametersMapping("x")})).Select(Cosmogenesis.Core.DbDocHelper.GetValidId)";
return($@"
/// <summary>
/// Try to load {unionPlan.CommonName} documents by id.
/// Returns an array of {unionPlan.CommonName} documents (or null if not found) in the same order as the ids were provided.
/// {unionPlan.CommonName} is a union of: {string.Join(", ", unionPlan.Documents.Select(x => x.ClassName))}
/// </summary>
/// <exception cref=""Cosmogenesis.Core.DbOverloadedException"" />
/// <exception cref=""Cosmogenesis.Core.DbUnknownStatusCodeException"" />
public virtual async System.Threading.Tasks.Task<{unionPlan.FullCommonTypeName}?[]> {unionPlan.CommonName.Pluralize()}Async({inputParams})
{{
var docs = await this.{databasePlan.DbClassName}.ReadByIdsAsync(
partitionKey: this.PartitionKey,
ids: {toId});
var results = new {unionPlan.FullCommonTypeName}?[docs.Length];
for (var x = 0; x < docs.Length; ++x)
{{
results[x] = ({unionPlan.FullCommonTypeName}?)docs[x];
}}
return results;
}}
");
}
