Sidub.Platform.Authentication.IsolatedFunction 1.10.27

Sidub.Platform

The Sidub Platform provides business developers with common critical tools — data persistence, filtering, localization, cryptography, authentication, and more. All libraries target .NET Standard 2.0+ for broad compatibility across .NET Framework, .NET Core, Xamarin, Blazor, and modern .NET applications.

Packages

Getting started

Register the platform services using the provided extension methods:

var services = new ServiceCollection();

// Core platform services (entity model, serialization, service registry)
services.AddSidubPlatform();

// Storage query services
services.AddSidubStorage();

// Filter services — specify your parser type(s)
services.AddSidubFilter(FilterParserType.OData);

Entity model

Entities are defined as classes or interfaces decorated with attributes from Sidub.Platform.Core.Attributes. These attributes control field mapping, key identification, serialization, and partition behavior.

[Entity("widget")]
public class Widget : IEntity, IRuntimePartitionStrategy
{
    [EntityKey<Guid>("id")]
    public Guid Id { get; set; }

    [EntityField<string>("name")]
    public string Name { get; set; } = string.Empty;

    [EntityField<decimal>("price")]
    public decimal Price { get; set; }

    [EntityPartitionKey]
    [EntityKey<string>("tenantId")]
    public string TenantId { get; set; } = string.Empty;
}

Partition strategies

Partitioning determines how entities are distributed across logical storage partitions. The strategy is declared by implementing a marker interface on the entity class.

Runtime partition example

[Entity("widget")]
public class Widget : IEntity, IRuntimePartitionStrategy
{
    [EntityKey<Guid>("id")]
    public Guid Id { get; set; }

    [EntityField<string>("name")]
    public string Name { get; set; } = string.Empty;

    [EntityPartitionKey]
    [EntityKey<string>("tenantId")]
    public string TenantId { get; set; } = string.Empty;
}

The TenantId property is both an entity key and the partition key. When querying, you can scope to a specific partition or perform cross-partition scans.

Querying

Query types

The storage layer provides two generic query types that support inline predicate expressions and partition scoping.

Both implement IQueryPartition, allowing partition-scoped queries on entities that use IRuntimePartitionStrategy.

Basic queries

// Single record by key
var query = new EntityRecordQuery<Widget>(w => w.Id == widgetId);
var widget = await queryService.Execute(connector, query);

// All records (no filter)
var query = new EntityEnumerableQuery<Widget>();
var results = queryService.Execute(connector, query);
await foreach (var widget in results) { /* ... */ }

// Filtered list
var query = new EntityEnumerableQuery<Widget>(w => w.Price > 10.0m);

Partition-scoped queries

When querying a partitioned entity, you can provide a partition value to scope the query to a specific partition, or omit it to perform a cross-partition scan.

// Partition via type-safe expression (recommended)
var query = new EntityRecordQuery<Widget>(
    predicate: w => w.Id == widgetId,
    partition: w => w.TenantId == "tenant-01");

// Partition via string value
var query = new EntityRecordQuery<Widget>(
    predicate: w => w.Id == widgetId,
    partitionValue: "tenant-01");

// Cross-partition scan (no partition specified — queries all partitions)
var query = new EntityEnumerableQuery<Widget>(w => w.Price > 10.0m);

// Partition-only (all entities within a partition)
var query = new EntityEnumerableQuery<Widget>(
    partition: w => w.TenantId == "tenant-01");

// Combined predicate + partition
var query = new EntityEnumerableQuery<Widget>(
    predicate: w => w.Name.Contains("Gadget"),
    partition: w => w.TenantId == "tenant-01");

Partition expression mechanics

When using the partition parameter, the expression must be an equality comparison against a property decorated with [EntityPartitionKey]:

// Captured variable works
var tenantId = "tenant-01";
var query = new EntityRecordQuery<Widget>(
    predicate: w => w.Id == widgetId,
    partition: w => w.TenantId == tenantId);

The following will throw at construction time:

• Targeting a property that is not decorated with [EntityPartitionKey]
• Targeting an entity that does not implement IRuntimePartitionStrategy
• Supplying both partition and partitionValue simultaneously
• Using a non-equality operator (e.g., w => w.TenantId != "x")

Cross-partition behavior

When no partition is specified, GetQueryPartitionValue() returns null, signalling the storage connector to perform a cross-partition scan. This is the default behavior — no special configuration is required.

// These are equivalent cross-partition queries:
var query = new EntityEnumerableQuery<Widget>(w => w.Price > 5.0m);
var query = new EntityEnumerableQuery<Widget>(predicate: w => w.Price > 5.0m);

Note: Cross-partition scans may incur higher cost on partitioned stores like Azure Cosmos DB. Prefer partition-scoped queries when the partition key is known.

Filtering

Expression-tree filters

The EntityFilter.Where<T>() method converts a lambda expression into an IFilter tree, resolving property names to entity field names via attribute metadata:

var filter = EntityFilter.Where<Widget>(w => w.Name == "Gadget" && w.Price > 10.0m);

Supported comparison operators: ==, !=, >, >=, <, <=

String method support

String instance methods are translated to the appropriate filter operator for each parser:

// Contains
var filter = EntityFilter.Where<Widget>(w => w.Name.Contains("Gadget"));
// OData:   contains(name,'Gadget')
// Gremlin: values('name').is(containing('Gadget'))
// MySQL:   name LIKE '%Gadget%'

// StartsWith
var filter = EntityFilter.Where<Widget>(w => w.Name.StartsWith("Wid"));

// EndsWith
var filter = EntityFilter.Where<Widget>(w => w.Name.EndsWith("get"));

Collection Contains (IN queries)

When a collection's Contains method is called with an entity property, it produces an IN filter:

var validCategories = new List<string> { "Electronics", "Tools" };
var filter = EntityFilter.Where<Product>(p => validCategories.Contains(p.Category));
// OData:   category in ('Electronics','Tools')
// Gremlin: values('category').is(within('Electronics','Tools'))
// MySQL:   category IN ('Electronics','Tools')

Filter builder

For more granular control, use EntityFilterBuilder<T> or FilterBuilder:

// Type-safe builder
var builder = new EntityFilterBuilder<Widget>();
builder.Add(w => w.Name, ComparisonOperator.Contains, "Gadget")
       .Add(LogicalOperator.And)
       .Add(w => w.Price, ComparisonOperator.GreaterThan, 10.0m);
var filter = builder.Build();

// String-based builder
var builder = new FilterBuilder();
builder.Add("name", ComparisonOperator.Contains, "Gadget")
       .Add(LogicalOperator.And)
       .Add("price", ComparisonOperator.GreaterThan, 10.0m);
var filter = builder.Build();

// Nested groups
var builder = new EntityFilterBuilder<Widget>();
builder.Add(w => w.Price, ComparisonOperator.GreaterThan, 5.0m)
       .Add(LogicalOperator.And)
       .Add(inner => inner
           .Add(w => w.Name, ComparisonOperator.StartsWith, "Wid")
           .Add(LogicalOperator.Or)
           .Add(w => w.Name, ComparisonOperator.EndsWith, "get"));
var filter = builder.Build();

Filter parser output

Filters are rendered to query-language strings via IFilterService<T>:

// Inject the appropriate filter service
IFilterService<ODataFilterConfiguration> odata = ...;
IFilterService<GremlinFilterConfiguration> gremlin = ...;
IFilterService<MySqlFilterConfiguration> mysql = ...;

var filter = EntityFilter.Where<Widget>(w => w.Name == "Gadget");

odata.GetFilterString(filter);   // "name eq 'Gadget'"
gremlin.GetFilterString(filter); // "values('name').is('Gadget')"
mysql.GetFilterString(filter);   // "name = 'Gadget'"

Authentication

Section to be expanded.

Cryptography

Section to be expanded.

Localization

Section to be expanded.

License

This project is dual-licensed by Sidub Inc.:

1. GNU Affero General Public License v3 (AGPLv3) — see LICENSE-AGPLV3.txt
2. Sidub Inc. Proprietary Software License Agreement (PSLA) — see LICENSE-PROPRIETARY.txt

You may choose to use, redistribute, and/or modify the product under the terms of either license. See LICENSE.txt for details or visit sidub.ca/licensing.