eksenos

Plugin eksenos from marketplace eksenos-marketplace in eksenova/EksenOS. Commands read from the repo's manifest — 14 days ago.

Skills (24)

• api-key-authentication

  The EksenOS way to authenticate machine-to-machine callers with Eksen.Authentication.ApiKeys — issue per-user (and per-tenant) API keys as first-class entities, read them from a custom or Authorization header into a ClaimsPrincipal, persist them by EF Core, and surface them as an OpenAPI security sc

• auditing

  The EksenOS way to capture an audit trail with Eksen.Auditing — open a per-request audit scope, record intercepted service-method calls and entity changes against the current user/tenant, persist the trail with EF Core, and query it back through IAuditLogManager. Use when you need "who did what, whe

• code-conventions

  The architectural conventions every EksenOS-based project follows — model domain values as value objects and smart enumerations (never primitives), identify aggregates with ULID strongly-typed ids, persist through IRepository<> inside a unit of work, raise failures as EksenExceptions mapped at the e

• core

  The root of the EksenOS stack — Eksen.Core gives you the AddEksen / IEksenBuilder registration entry point that every other package plugs into, the AppModules registry, and the Specification primitive for reusable query/domain predicates. Use when you are bootstrapping the Eksen service graph, writi

• data-seeding

  The EksenOS way to populate a database with baseline data using Eksen.DataSeeding — write an IDataSeedContributor per concern, order them with [SeedAfter], register them with AddDataSeeding, and run them all inside one transactional unit of work via IDataSeeder. Use when you need idempotent referenc

• distributed-locks

  The EksenOS way to take a mutual-exclusion lock that holds across every process and instance with Eksen.DistributedLocks — resolve IDistributedLockProvider, AcquireAsync/TryAcquireAsync a named IDistributedLockHandle, run the critical section, and release by disposing, backed by PostgreSQL advisory

• distributed-transactions

  The EksenOS way to coordinate a multi-step operation across several resources with Eksen.DistributedTransactions — begin an IDistributedTransaction, add execute/compensate steps, and commit so that any failure rolls back the already-executed steps in reverse (saga-style compensation). Also swaps in

• emailing

  The EksenOS way to send transactional email with Eksen.Emailing — register an IEmailSender backed by SMTP or Gmail, push raw EmailInstance bodies, or render strongly-typed templates through ITemplateEmailSender. Use when an order-management flow must notify a customer (order confirmation, shipment d

• entities

  The EksenOS base abstractions for audit-time and soft-delete domain entities with Eksen.Entities — implement IHasCreationTime, IHasModificationTime, and ISoftDelete so the EF Core layer stamps timestamps and turns deletes into soft deletes automatically. Use when an aggregate needs "created at / las

• entity-framework-core

  The EksenOS EF Core layer — an EksenDbContext base, EfCoreRepository/EfCoreIdRepository implementations of the Eksen.Repositories abstractions, the unit-of-work provider, automatic creation/modification/soft-delete stamping, global query filters, and SqlServer + Sqlite provider wiring through AddEks

• error-handling

  The EksenOS way to raise domain errors with Eksen.ErrorHandling — declare an ErrorDescriptor with a stable code and an ErrorType, raise an ErrorInstance carrying data, throw it as an EksenException, and let the ASP.NET Core EksenExceptionHandler map it to the right HTTP status and JSON body. Use whe

• event-bus

  The EksenOS way to publish integration events and handle them with IEventHandler<TEvent> — an outbox-backed IEventBus with InMemory and RabbitMQ transports, an EF Core outbox/inbox/dead-letter store, a built-in dashboard, and dead-letter alerts (Slack). Use when one part of the system must react to

• identity

  The EksenOS identity model with Eksen.Identity — multi-tenant User/Role/Tenant entities, a claims-based IAuthContext current-user/tenant accessor, ASP.NET Core Identity integration (managers, stores, sign-in, claims factory) and EF Core repositories + type configurations. Use when you need to know w

• localization

  The EksenOS way to turn message templates into final user-facing strings with Eksen.Localization — register an IMessageFormatter, pass named FormatParameter values, and let SmartFormat substitute {Key} placeholders in error messages, notifications, and rendered copy. Use when you have a message stri

• open-api

  OpenAPI document polish for EksenOS APIs with Eksen.OpenApi — a set of IOpenApiSchemaTransformer implementations that render plain C# enums as strings, inject example values via [ExampleValue], drop [NotMapped] properties from request/response schemas, and flag [Obsolete] types as deprecated. Use wh

• permissions

  The EksenOS way to authorize operations with Eksen.Permissions — declare named permissions, register them through AddPermissions, check them with IPermissionChecker, gate endpoints with ASP.NET Core authorization policies, nullify forbidden response fields with [BindPermission], persist grants with

• repositories

  The EksenOS persistence-ignorant data access contract — inject IReadOnlyRepository<TEntity>/IRepository<TEntity> (and their Id-typed variants) and query with strongly-typed filter, include, sorting, pagination, and query-option parameters. Use when an application service needs to load, page, count,

• scalar

  The EksenOS way to brand and harden a Scalar API-reference UI for your OpenAPI document with Eksen.Scalar — chain client-side plugins (logo/footer branding, token-body and autofill fixes, tenant impersonation, an internal-auth wall) onto MapScalarApiReference. Use when you expose a Scalar reference

• smart-enumerations

  The EksenOS way to model a closed set of named values with Eksen.SmartEnums — declare an Enumeration<TSelf>, give it extra data, persist it by code with EF Core, serialize it as a string over JSON/OpenAPI, and handle unknown-code parsing. Use when you would otherwise reach for a C# enum, a status/ty

• templating

  The EksenOS way to turn a domain model into HTML and PDF — render Razor templates (order-confirmation emails, receipts) with Eksen.Templating's ITemplateHtmlRenderer, then convert the HTML to a PDF via IHtmlPdfRenderer. Use when you need a templated email body, an HTML document, or a generated PDF f

• test-base

  The EksenOS way to write unit, service, integration, and end-to-end tests with Eksen.TestBase — xUnit base classes that build a DI container from the IEksenBuilder, spin up a real database via Testcontainers, share a bounded SQL Server container pool across an assembly, and host the full ASP.NET Cor

• ulid

  The EksenOS way to give every aggregate a strongly-typed, ULID-based identifier with Eksen.Ulid — declare an OrderId/CustomerId record over UlidEntityId<TSelf>, generate sortable ids, bind them from routes and JSON in ASP.NET Core, and render them as `format: ulid` strings in OpenAPI. Use when you w

• unit-of-work

  The EksenOS way to wrap a business operation in a single commit/rollback boundary with Eksen.UnitOfWork — an IUnitOfWorkManager that opens scoped, optionally transactional IUnitOfWorkScopes across every registered provider, lifecycle callbacks and post-commit actions, the [UnitOfWork] attribute, and

• value-objects

  The EksenOS way to model immutable, equality-by-value domain types with Eksen.ValueObjects — derive a ValueObject<TSelf, TUnderlyingValue>, validate in the constructor, expose Create/Parse, persist and serialize by the underlying primitive, and bind it from ASP.NET Core requests. Use when a string/d