Profile cover photo
Profile photo
Demis Bellot
Demis Bellot's interests
View all
Demis Bellot's posts

Post has attachment
We've created a GitHub issue to help us decide on whether we should we sign all NuGet packages by default in v5?

Please vote if you have an interest on whether or not you want ServiceStack packages signed by default at:

Post has attachment
v4.5.10 Released!

We've developed new Angular4, React, Aurelia and Vue.js Single Page App VS.NET templates for ASP .NET which have been re-imagined to incorporate the latest gold standard in modern Single Page App development and integrated to provide the ideal development experience within VS.NET, optimal bundling and packaging for production including one-click Web App deployments using MS Web Deploy.

Please see the v4.5.10 Release Notes for the full details:

Full support for VS.NET 2017

We've added complete support for VS.NET 2017 with the ServiceStackVS VS.NET Extension and have migrated all ServiceStack code-bases for all of ServiceStack's NuGet packages to VS2017's new MSBuild format which is now being used to generate the different .NET 4.5 and .NET Standard platform builds used in all .NET Core packages including our multi-target Test projects.

Webpack-powered Single Page App Templates

We've developed a new Single Page App template for the simple and elegant Vue.js ( and our existing Angular, Aurelia, React and React Desktop Single Page App templates have been rewritten to completely embrace Webpack ( - the most advanced module bundler for JavaScript Apps. Webpack is used to power the development, testing and production builds of your Web App.

The release notes contains a detailed overview of Webpack and how to use it from within VS.NET and command-line which support both of Webpack's popular developer options of watching for changes and regenerating its outputs as well as Live Reload support using the Webpack Dev Server which automatically reloads the current page after processing any changes.

Single Page App Template features

The templates provide a highly productive base that's ideal for developing small to medium-sized JavaScript Web Apps including just the core essentials that pack the most productive punch whilst adding minimal complexity and required configuration, whilst still remaining open-ended to easily plug-in other tools into your Webpack configuration you believe will improve your development workflow.

With these goals in mind we've hand-picked and integrated a number of simple best-of-breed technologies so you'll be immediately productive:

- Integrated Bootstrap v4 UI framework and font-awesome Vector Icons
- Angular4 uses the more natural Material Design Lite UI framework and Design Icons
- High-level TypeScrpt and Sass support andstandard .js or .css when preferred
- End-to-end Typed APIs pre-configured with TypeScript JsonServiceClient and Server DTOs
- All templates have Routing Enabled in a Multi-page Layout
- Deep linkable Pretty URLs
- JavaScript Unit Testing
- Live Unit Testing which automatically re-runs tests when sources have changed
- Built-in Test Coverage
- Single Click Deployments using MS WebDeploy

Gistlyn Updated was upgraded to use the new Webpack-powered React Desktop Apps template.

Simple command-line utilities for ServiceStack

The new servicestack-cli ( npm package replaces our existing `ss-util.exe` and OSX `swiftref` command-line programs to provide simple command-line utilities to easily Add and Update ServiceStack References for all of ServiceStack's 7 supported languages. Using it is as easy as choosing the language you want and the BaseUrl of the remote ServiceStack instance you want to download the Server DTOs for, e.g:

$ csharp-ref

Major Memory and Performance Improvements to ServiceStack.Text

We've replaced our internal string parsing in ServiceStack.Text's serializers to use .NET Core's new `StringSegment` class (polyfilled in .NET 4.5) which dramatically reduces the memory allocations needed and execution time for deserialization. Parsing implementations of primitive .NET Types like integers, decimal and Guid types were also replaced with custom implementations utilizing `StringSegment` which sees their performance improved by 2.5-4x. These improvements are best seen in large complex types with nested arrays like MiniProfiler's DTO where memory allocations were reduced by 5.3x and performance improved by 33%.

Vulnerability with object Properties

We've resolved a vulnerability using public `object` properties on DTOs where we've needed to adopt a whitelist to limit the Types that are allowed to create instances of. Please see the release notes for full details.

Fast Reflection APIs

We've consolidated functionality for populating the fields and properties of a runtime `Type` behind a formal API which includes multiple cascading implementations so it's able to use the fastest implementation available in each supported platform, i.e. for most .NET platforms we use the Reflection.Emit implementations when possible, when not available it falls back to using Compiled Expression trees, then finally falling back to using a Reflection-based implementation.

This functionality is available using the `CreateGetter()` and `CreateSetter()` extension methods on both `PropertyInfo` or `FieldInfo` which you may find useful if you'd like to get better performance when populating runtime types dynamically, e.g:

var runtimeType = typeof(MyType);

object instance = runtimeType.CreateInstance();
PropertyInfo pi = runtimeType.GetProperty("Id");
var idSetter = pi.CreateSetter();
var idGetter = pi.CreateGetter();

idSetter(instance, 1);
var idValue = idGetter(instance);

Support for C# 7 Value Tuples in OrmLite

The fast, new C# 7 Value Tuple support in OrmLite enables an alternative terse, clean and typed API for accessing the Dynamic Result Sets returned when using a custom Select expression, e.g:

var query = db.From<Employee>()
.OrderBy(e => e.Id)
.Select<Employee, Department>(
(e, d) => new { e.Id, e.LastName, d.Name });

var results = db.Select<(int id, string lastName, string deptName)>(query);

var row = results[i];
$"row: ${}, ${row.lastName}, ${row.deptName}".Print();

Expanded Typed SqlExpresion Surface Area

OrmLite's Typed SqlExpression has been expanded to support up to 15 tables* in a single SQL Condition and up to *4 tables in a JOIN expression.

Proxy Feature

The new `ProxyFeature` plugin is an application-level proxy that can be used to transparently proxy HTTP Requests through to
downstream servers whose behavior can be customized with custom C# hooks to control how requests are proxied.

`ProxyFeature` registers an async/non-blocking `RawHttpHandler` which bypasses ServiceStack's Request Pipeline that in ASP.NET is executed as an ASP.NET `IHttpAsyncHandler` so it should be flexible and performant enough to handle many demanding workloads.

Autowired Typed Request Filters

Josh Engler contributed support for Autowired Request and Response Filters which lets you handle Request DTOs in a Typed Filter similar to how Autowired Services handles Typed Request DTOs with access to IOC injected dependencies.Refinements to Open API, Server Events, JWT

Driven by customer requests we've added support to Open API, Server Events, JWT

HTTP Caching static Files

Returning a static Virtual File or FileInfo in a `HttpResult` now sets the *Last-Modified* HTTP Response Header whose behavior instructs the pre-configured `HttpCacheFeature` to generate the necessary HTTP Headers so HTTP Clients are able to validate subsequent requests using the If-Modified-Since HTTP Request Header, allowing them to skip re-downloading files they've already cached locally.


We've changed the default behavior to no longer skipping Authenticating existing Authenticated Users. This resolves an issue for not being able to retrieve JWT Refresh Tokens if you're already Authenticated, previous behavior can be restored with:

Plugins.Add(new AuthFeature(...) {
SkipAuthenticationIfAlreadyAuthenticated = true

API Key Auth Provider

You can opt-in to allow API Keys to be passed on the *QueryString* (e.g. `?apikey={APIKEY}`) or HTTP POST *Form Data* with:

Plugins.Add(new ApiKeyAuthProvider {
AllowInHttpParams = true


The home page and directories are no longer cached in DebugMode to better be able to reflect changes during development.


The `WebServiceException` Message returns the the more appropriate `ResponseStatus.ErrorMessage` if available. The previous StatusDescription text can be retrieved from the `WebServiceException.StatusDescription` property.

Other Changes

- The `RemoveHeader()` API has been added to `IResponse` and all implementations
- The HTTP Request/Response Preview in Metadata pages uses the Verb, URL and Request Body of the preferred HTTP Method for each Service
- The Basic Auth Credentials are auto-sent in `JsonHttpClient` 401 Challenged Responses
- Empty Collections are now ignored AutoQuery Filters

That's a high-level overview, please see the v4.5.10 Release Notes for the full details:


Post has attachment
v4.5.8 Released!

We've got a another feature-packed release with a number of exciting new features new support for the Open API specification enabling new integration possibilities with Azure API Management and Azure AutoRest, our real-time Server Events solution extending to new Mobile, Desktop and Server platforms, more flexible Authentication options to dramatically simplify integration with Mobile, Desktop and Web clients, effortless JWT Refresh Tokens, enhanced support for TypeScript and Java client libraries, new compression options, upgrades to the latest Fluent Validation with support for Async validators, Async Request Filters, a number of new quality OSS ServiceStack projects developed by the community and lots more use-case driven features and refinements across the entire ServiceStack suite!

Please see the v4.5.8 Release Notes for the full details:

For a quick summary we'll highlight the major features below:

Open API

We've added support for the Open API Specification which opens up several new integration possibilities including importing your Services into Azure API Management and generating native clients with Azure's AutoRest. The Open API plugin also embeds Swagger UI letting you quickly explore and interact with your services.

Server Events

We've made great strides in this release towards our goal of expanding the Server Event ecosystem in popular Mobile, Desktop and Server platforms with new first-class implementations for Android, Java and TypeScript which now includes:

- C# Server Events Client
- Xamarin.iOS
- Xamarin.Android
- .NET Framework 4.5+
- .NET Core (.NET Standard 1.3+)
- TypeScript Server Events Client
- Web
- Node.js Server
- React Native
- iOS
- Android
- Java Server Events Client
- Android
- JVM 1.7+ (Java, Kotlin, Scala, etc)
- Java Clients
- Java Servers
- JavaScript (jQuery plugin)
- Web

Android Java Chat

To showcase real-world usage of `AndroidServerEventsClient` in an Android App we've ported C# Xamarin Android Chat into Java 8 using Google's recommended Android Studio Development Environment:

In addition to retaining the same functionality as the original C# Xamarin.Android Chat App, it also leverages the native Facebook, Twitter and Google SDK's to enable seamless and persistent authentication when signing in with Facebook, Twitter or Google User accounts.

Web, Node.js and React Native ServerEvents Apps

The TypeScript servicestack-client npm package is a cross-platform library enabling a rich, productive end-to-end Typed development experience on Web, node.js Server projects, node.js test suites, React Native iOS and Android Mobile Apps - written in either TypeScript or plain JavaScript.

To help getting started using servicestack-client in each of JavaScript's most popular platforms we've developed a simple Server Events Web, Node.js and React Native Mobile iOS App that can connect to any Server Events Server and listen to messages published on the subscribed channel. The App also maintains a live synchronized list of Users in the channel that's automatically updated whenever Users join or leave the channel:

Each App uses the optimal starting configuration that enables a productive workflow on each platform and uses the minimum runtime dependencies - essentially just servicestack-clientand its es6-shim and W3C `EventSource` polyfills on Node.js and React Native where it's missing a native implementation.

TypeScript servicestack-client improvements

New APIs have been added to TypeScript's servicestack-client to catch up with the additional flexibility and features available in C#/.NET Service Clients:

Sending additional arguments with Typed API Requests

Many AutoQuery Services utilize implicit conventions to query fields that aren't explicitly defined on AutoQuery Request DTOs, these can now be queried by specifying additional arguments with the typed Request DTO, e.g:

const request = new FindTechStacks();

client.get(request, { VendorName: "ServiceStack" })
.then(r => { }) // typed to QueryResponse<TechnologyStack>

Calling APIs with Custom URLs

In addition to Typed API Requests you can now also call Services using relative or absolute urls, e.g:



// GET
client.get<GetTechnologyResponse>("/technology", { Slug: "ServiceStack" })

Relaxed TypeScript Definitions

The metadata requirements in TypeScript Ambient Interface definitions generated by Add ServiceStack Reference's `/types/typescript.d` have been relaxed so they can be used to Type Object Literals:

let request:QueryContracts = { accountId: 1234 };

Authentication via OAuth AccessTokens

To improve OAuth Sign In integration from native Mobile or Desktop Apps we've added support for direct Authentication via AccessTokens which can dramatically simplify the Development and User Experience by being able to leverage the Native Facebook, Twitter and Google Client SDK's to Sign In users locally then reuse their local AccessToken to Authenticate with back-end ServiceStack Servers.

This feature is what's used to enable Integrated Facebook, Twitter and Google Logins in Android Java Chat and be able to Automatically Sign In users with saved AccessTokens.

This capability is now available on the popular OAuth Providers below:

- `FacebookAuthProvider` - Sign in with Facebook
- `TwitterAuthProvider` - Sign in with Twitter
- `GithubAuthProvider` - Sign in with Github
- `GoogleOAuth2Provider` - Sign in with Google

Client Authentication with AccessToken

Clients can utilize this feature with the new `AccessToken` and `AccessTokenSecret` properties on the existing `Authenticate` request DTO, sent with the provider that the AccessToken is for, e.g:

var response = client.Post(new Authenticate {
provider = "facebook",
AccessToken = facebookAccessToken,
RememberMe = true,

JWT Refresh Tokens

Support for Refresh Tokens is now available in the JWT Auth Provider where new JWT Tokens can now be generated from a longer-lived `RefreshToken` which can be used to fetch new JWT Tokens without needing to re-authenticate with a separate Auth Provider.

Accessing Refresh Tokens

Just like JWT Tokens, Refresh Tokens are populated on the `AuthenticateResponse` DTO after successfully authenticating via any registered Auth Provider, e.g:

var response = client.Post(new Authenticate {
provider = "credentials",
UserName = userName,
Password = password,

var jwtToken = response.BearerToken;
var refreshToken = response.RefreshToken;

Lifetimes of tokens

The default expiry time of JWT and Refresh Tokens below can be overridden when registering the `JwtAuthProvider`:

new JwtAuthProvider {
ExpireTokensIn = TimeSpan.FromDays(14), // JWT Token Expiry
ExpireRefreshTokensIn = TimeSpan.FromDays(365), // Refresh Token Expiry

Using JWT and Refresh Tokens

In order to provide the simplest development experience possible you only need to specify the Refresh Token on the Service Client and it will take care of transparently fetching a new JWT Token behind-the-scenes. You don't even need to configure the client with a JWT Token as it will just fetch a new one on first use, e.g:

var client = new JsonServiceClient(baseUrl) {
RefreshToken = refreshToken,

var response = client.Send(new Secured());

Fluent Validation Upgraded

Another major feature added in this release was contributed by the community with +Scott Mackay upgrading our internal Fluent Validation implementation to the latest version of FluentValidation. Special care was taken to maintain backwards compatibility where ServiceStack enhancements were retrofitted on top of the new version and existing Error Codes were preserved to ensure minimal disruption with existing code bases.

### Async Validators

One of the benefits from using the latest version of Fluent Validation is we now have support for Async Validators! Async validators can be registered using the `MustAsync` validator where you could simulate the following built-in Not Empty validation:

public class MyRequestValidator : AbstractValidator<MyRequest>
public MyRequestValidator()
RuleFor(x => x.Name).NotEmpty();

And replace it with an Async version that uses the Service Gateway to call a custom Async `GetStringLength` Service that returns the same `ErrorCode` and Error Message as the Not Empty validator:

public class MyRequestValidator : AbstractValidator<MyRequest>
public MyRequestValidator()
RuleFor(x => x.Name).MustAsync(async (s, token) =>
(await Gateway.SendAsync(new GetStringLength { Value = s })).Result > 0)
.WithMessage("'Name' should not be empty.")

Async Global Request Filters

To properly implement Async Validators we also needed Async Request Filters which were also added in this release where you can now register non-blocking Request Filters with:

GlobalRequestFiltersAsync.Add(async (req,res,dto) => {
var response = await client.Send(new CheckRateLimit {
Service = dto.GetType().Name,
IpAddress = req.UserHostAddress,
if (response.RateLimitExceeded)
res.StatusCode = 403;
res.StatusDescription = "RateLimitExceeded";

Enhanced Compression Options

We've followed up Request Compression added in the last release with more compression features in this release including:

[CompressResponse] Attribute

You can now selectively choose which Services should be compressed with the new `[CompressResponse]` attribute to compress responses for clients which support compression, which can be applied to most Response Types, e.g:

public class CompressedServices : Service
public object Any(CompressDto request) => new CompressExamplesResponse();
public object Any(CompressString request) => "foo";
public object Any(CompressBytes request) => "foo".ToUtf8Bytes();
public object Any(CompressStream request) => new MemoryStream("foo".ToUtf8Bytes());
public object Any(CompressFile request) => new HttpResult(VirtualFileSources.GetFile("/foo"));

public object Any(CompressAnyHttpResult request)
return new HttpResult(new CompressExamplesResponse()); // DTO
return new HttpResult("foo", "text/plain"); // string
return new HttpResult("foo".ToUtf8Bytes(), "text/plain"); // bytes

> Note using `[CompressResponse]` is unnecessary when returning cached responses as ServiceStack automatically caches and returns the most optimal Response - typically compressed bytes for clients that supports compression

Static File Compression

ServiceStack can also be configured to compress static files with specific file extensions that are larger than specific size with the new opt-in Config options below:

SetConfig(new HostConfig {
CompressFilesWithExtensions = { "js", "css" },
// (optional), only compress .js or .css files > 10k
CompressFilesLargerThanBytes = 10 * 1024

When more fine-grained logic is needed you can override `ShouldCompressFile()` in your AppHost to choose which static files you want to compress on a per-file basis, e.g:

public override bool ShouldCompressFile(IVirtualFile file)
return base.ShouldCompressFile(file) || file.Name == "large.csv";


We've been lucky to receive a number of quality contributions from the Community in this release starting with the new Serilog Logging provider contributed by +Josh Engler:


To Configure Serilog Logging, first download ServiceStack.Logging.Serilog from NuGet:

PM> Install-Package ServiceStack.Logging.Serilog

Then configure ServiceStack to use `SerilogFactory`:

LogManager.LogFactory = new SerilogFactory();

Community Projects

There's also been a number of quality OSS Community projects that's surfaced recently that you may find useful to enable in your ServiceStack projects:


If you need to implement a Webhooks solution for your Services you'll definitely want to check out ServiceStack.Webhooks +Jezz Santos. ServiceStack.Webhooks is a high-quality, actively developed, well documented solution for raising and managing application-level "events" raised by your services:


is a fork of ServiceStack.Authentication.Aad developed by +Ian Kulmatycki which provides an `AzureAuthenticationProvider` for easily authenticating users with Office365 and hybrid Azure Active Directories:


is a `UserAuthRepository` repository developed by +Michal Gajek for persisting users in Marten - a Document Database for PostgreSQL.


Another feature contributed by +Josh Engler is the `MultiAppSettingsBuilder` which adds a fluent discoverable API for configuring ServiceStack's various App Setting Providers, e.g:

AppSettings = new MultiAppSettingsBuilder()
.AddDictionarySettings(new Dictionary<string,string> { "override" : "setting" })

CacheClient with Prefix

The `CacheClientWithPrefix` class contributed by +Joël Harkes lets you decorate any `ICacheClient` to prefix all cache keys using the `.WithPrefix()` extension method. This could be used to easily enable multi-tenant usage of a single redis instance, e.g:

container.Register(c =>

OrmLite Soft Deletes

Select Filters were added to OrmLite to let you specify a custom `SelectFilter` that lets you modify queries
that use `SqlExpression<T>` before they're executed. This could be used to make working with "Soft Deletes"
Tables easier where it can be made to apply a custom `x.IsDeleted != true` condition on every `SqlExpression`.

By either using a `SelectFilter` on concrete POCO Table Types, e.g:

SqlExpression<Table1>.SelectFilter = q => q.Where(x => x.IsDeleted != true);
SqlExpression<Table2>.SelectFilter = q => q.Where(x => x.IsDeleted != true);

Or alternatively you can configure a global `SqlExpressionSelectFilter` with:

OrmLiteConfig.SqlExpressionSelectFilter = q =>
if (q.ModelDef.ModelType.HasInterface(typeof(ISoftDelete)))
q.Where<ISoftDelete>(x => x.IsDeleted != true);

Both solutions above will transparently add the `x.IsDeleted != true` to all `SqlExpression<T>` based queries so it only returns results which aren't `IsDeleted` from any of queries below:

var results = db.Select(db.From<Table>());
var result = db.Single(db.From<Table>().Where(x => x.Name == "foo"));
var result = db.Single(x => x.Name == "foo");


You can easily escape HTML Entities characters (`<`, `>`, `&`, `=`, `'`) when serializing JSON strings with:

JsConfig.EscapeHtmlChars = true;

This can also be requested by clients using Customized JSON Responses, e.g:


Rabbit MQ

A strong-named version of ServiceStack.RabbitMq is now available at:

PM> Install-Package ServiceStack.RabbitMq.Signed

The new `CreateQueueFilter` and `CreateTopicFilter` filters added to the Rabbit MQ Server will let you customize what options Rabbit MQ Queue's and topics are created with.

Startup Errors

To better highlight the presence of Startup Errors we're now adding a red warning banner in `/metadata` pages when in DebugMode.
The number of Startup Errors is also added to the `X-Startup-Errors: n` Global HTTP Header so you'll be able to notice it when debugging HTTP Traffic.

Forcing a Content Type

Whilst ServiceStack Services are typically available on any endpoint and format, there are times when you only want adhoc Services available in a particular format, for instance you may only want the View Models for your dynamic Web Views available in HTML. This can now be easily enabled with the new `[HtmlOnly]` Request Filter Attribute, e.g:

public class HtmlServices : Service
public object Any(MyRequest request) => new MyViewModel { .. };

This feature is also available for other built-in Content Types: `[JsonOnly]`, `[XmlOnly]`, `[JsvOnly]` and `[CsvOnly]`.

AuthProvider available on IAuthSession

You can now determine what Auth Provider was used to populate a User's Session with the new `IAuthSession.AuthProvider` property. This could be used for instance to detect and ensure highly-sensitive services are only available to users that authenticated using a specific Auth Provider.

All .NET Core Examples upgraded to .NET Core 1.1

All .NET Core Live examples including the redis-geo project used in Deploy .NET Core with Docker to AWS ECS Guide were upgraded to .NET Core 1.1 and has been changed to use the `microsoft/dotnet:1.1-sdk-projectjson` Docker Image since `microsoft/dotnet:latest` was changed to only support projects with VS 2017 `.csproj` msbuild format.

This covers a high-level view of the major features added in this release, please see the v4.5.8 Release Notes for the full details and other features added in this release:

- Enjoy!

Post has attachment
Hi All,

We've released significant updates to our TypeScript ServerEventsClient that is an idiomatic port with full feature parity with our original C# Server Events Client.

It's an isomorphic library that can be used to create either TypeScript or JavaScript client Web Apps, node.js Server Apps or React Native Mobile Apps with maximum code-reuse as seen in:

Docs for the TypeScript ServerEventsClient are also available at:

Post has attachment
v4.5.6 Released!

For anyone who's missed last week's v4.5.6 release here's a quick re-cap below. For the full details please see the full release notes at:

New Angular2 Single Page App template!

We've added a new modern SPA http://VS.NET Template for Angular2 which is built the same npm-based TypeScript / JSPM / Gulp technology stack that's solidified in our other SPA templates with the main difference being that it's based on the Material Design Lite theme.

The Angular2 template also takes advantage of Angular2's modular architecture with a physical structure optimal for small-to-medium sized projects where its modular layout is compartmentalized into multiple independent sub modules which can easily scale to support large code bases.

Simpler and Optimized Single Page App Templates

We've also simplified all our existing npm-based SPA Templates to take advantage of the latest dependencies which can simplify our existing development workflow, some changes include:

- Upgraded to JSPM 0.17 beta

One of the benefits of using JSPM 0.17 beta is we're now using its built-in static builds with Rollup optimizations for production deployments which statically links your entire App's JavaScript into
a single `app.js`, eliminating the need for `system.js` at runtime and removing the packaging overhead from using modules.

- Removed interim deps.tsx

The interim `deps.tsx` file used to minimize the number of requests required during development is no longer needed.
We're now able to generate a cache of 3rd party npm dependencies using your App's main .js file and your dependencies listed in npm's `package.json`.

- Simplified Typings

The typings dependency manager has been removed leaving one less `typings.json` that needs to be maintained. Templates now use TypeScript's new @types definitions directly from npm or when they exist, the definitions contained in each npm package that's referenced in devDependencies.

- Upgraded to latest Bootstrap v4

The React and Aurelia SPA Templates have been upgraded to use the just released Bootstrap v4 alpha-6.

Enhanced TypeScript Support

The SPA Templates also benefit from our enhanced TypeScript support with improvements to both the generated TypeScript DTOs and the `JsonServiceClient` which now includes TypeScript Definitions published with the npm package.

- Support for Basic Auth - Basic Auth support is now implemented in `JsonServiceClient` and follows the same API made available in the C# Service Clients
- Raw Data Responses - The `JsonServiceClient` also supports Raw Data responses like `string` and `byte[]`

Swift 3

Swift Add ServiceStack Reference and the Swift `JsonServiceClient` has been upgraded to Swift 3 including its embedded PromiseKit implementation. The earlier Swift 2 compiler bugs preventing AutoQuery Services from working have now been resolved.

swiftref OSX command-line utility

In response to XcodeGhost, Apple has killed support for plugins in Xcode 8 disabling all existing 3rd party plugins from working, and along with it our Integration with Xcode built into ServiceStack Xcode Plugin.

To enable the best development experience we can without using an Xcode plugin we've developed the swiftref OSX command-line utility to provide a simple command-line UX to easily Add and Update Swift
ServiceStack References.

Installation and Usage instructions for swiftref are available from:

All Swift Example Apps upgraded to Swift 3

Our existing Swift Example Apps have all been upgraded to use ServiceStack's new Swift 3 Support:

- TechStacks iOS App -
- TechStacks Desktop Cocoa OSX App -
- AutoQuery Viewer iOS App -
- 101 Swift LINQ Samples -

Swift Package Manager Apps

In its quest to become a popular mainstream language, Swift now includes a built-in Package Manager to simplify the maintenance, distribution and building of Swift code. Swift Package Manager can be used to build native statically-linked modules or Console Apps but currently has no support for iOS, watchOS, or tvOS platforms.

Nevertheless it's simple console and text-based programming model provides a great way to quickly develop prototypes or Console-based Swift Apps like swiftref using your favorite text editor. To support this
environment we've packaged ServiceStack's Swift Service clients into a ServiceStackClient package so it can be easily referenced in Swift PM projects.

A step-by-step guide showing how to build Swift PM Apps is available at:

Service Fabric Example

Another Example project developed during this release is Hello ServiceFabric (
to show a Hello World example of running a ServiceStack Self Hosted Service inside Microsoft's Service Fabric platform.

Performance Improvements

Our first support for .NET Core was primarily focused on compatibility and deep integration with .NET Core's Pipeline, Modules and Conventions. In this release we focused on performance and memory usage which we kicked off by developing a benchmarking solution for automatically spinning up Azure VM's that we use to run
benchmarking and load tests against:

A simple JSON Service running our initial .NET Core support in v4.5.4 release yields Requests/Sec Average:

- .NET Core 1.1 *26179*
- mono 4.6.2 (nginx+hyperfasctcgi) *6428*

Running on Standard_F4s azure instance (4 Core, 8GB RAM) using the following wrk benchmarking tool command.

Using 8 threads, keeping 256 concurrent HTTP Connections open, Running for 30s.

With the profiling and performance improvements added in this release, the same service now yields:

- .NET Core 1.1 *37073*
- mono 4.6.2 (nginx+hyperfasctcgi) *6840*

Which is over a 40% improvement for this benchmark since last release. Running the same ServiceStack Service on the same VM also shows us that .NET Core is 5.4x faster than Mono.

Upgraded to .NET Core 1.1

We're closely following .NET Core's progress and continue to upgrade ServiceStack libraries and their test suites to run on the latest stable .NET Core 1.1 release.

Client/Server Request Compression

You can now also elect to compress HTTP Requests in any C#/.NET Service Clients by specifying the Compression
Type you wish to use, e.g:

var client = new JsonServiceClient(baseUrl) {
RequestCompressionType = CompressionTypes.GZip,

FileSystem Mapping

Custom FileSystem mappings can now be easily registered under a specific alias by overriding your AppHost's `GetVirtualFileSources()` and registering a custom `FileSystemMapping`, e.g:

public override List<IVirtualPathProvider> GetVirtualFileSources()
var existingProviders = base.GetVirtualFileSources();
existingProviders.Add(new FileSystemMapping(this, "img", "i:\\images"));
existingProviders.Add(new FileSystemMapping(this, "docs", "d:\\documents"));
return existingProviders;

This will let you access File System Resources under the custom `/img` and `/doc` routes, e.g:

- http://host/img/the-image.jpg
- http://host/docs/word.doc

SQL Server Features

+Kevin Howard has continued enhancing the SQL Server Support in OrmLite with access to advanced SQL Server features including Memory-Optimized Tables where you can tell SQL Server to maintain specific tables in Memory using the `[SqlServerMemoryOptimized]` attribute, e.g:

public class SqlServerMemoryOptimizedCacheEntry : ICacheEntry
public string Id { get; set; }
public string Data { get; set; }
public DateTime CreatedDate { get; set; }
public DateTime? ExpiryDate { get; set; }
public DateTime ModifiedDate { get; set; }

The new Memory Optimized support can be used to improve the performance of SQL Server `OrmLiteCacheClient` by configuring it to use the above In Memory Table Schema instead, e.g:

container.Register<ICacheClient>(c =>
new OrmLiteCacheClient<SqlServerMemoryOptimizedCacheEntry>());

PostgreSQL Data Types

To make it a little nicer to be define custom PostgreSQL columns, we've added `[PgSql*]` specific attributes which will let you use a typed `[PgSqlJson]` instead of previously needing to use `[CustomField("json")]`.

The list of PostgreSQL Attributes include:

- [PgSqlJson]
- [PgSqlJsonB]
- [PgSqlTextArray]
- [PgSqlIntArray]
- [PgSqlBigIntArray]

.NET Core support for MySql

You can now use OrmLite with MySQL in .NET Core using the new ServiceStack.OrmLite.MySql.Core NuGet package.

Create Tables without Foreign Keys

You can temporarily disable and tell OrmLite to create tables without Foreign Keys by setting OrmLiteConfig.SkipForeignKeys.

Custom SqlExpression Filter

The generated SQL from a Typed `SqlExpression` can now be customized using the new `.WithSqlFilter()`, e.g:

var q = db.From<Table>()
.Where(x => x.Age == 27)
.WithSqlFilter(sql => sql + " option (recompile)");

var q = db.From<Table>()
.Where(x => x.Age == 27)
.WithSqlFilter(sql => sql + " WITH UPDLOCK");

var results = db.Select(q);

Custom SQL Fragments

The new `Sql.Custom()` API lets you use raw SQL Fragments in Custom `.Select()` expressions, e.g:

var q = db.From<Table>()
.Select(x => new {
FirstName = x.FirstName,
LastName = x.LastName,
Initials = Sql.Custom("CONCAT(LEFT(FirstName,1), LEFT(LastName,1))")

Cached API Key Sessions

You can reduce the number of I/O Requests and improve the performance of API Key Auth Provider Requests by specifying a `SessionCacheDuration` to temporarily store the Authenticated UserSession against the API Key which will reduce subsequent API Key requests down to 1 DB call to fetch and validate the API Key + 1 Cache Hit to restore the User's Session which if you're using the default in-memory Cache will mean it only requires 1 I/O
call for the DB request. This can be enabled with:

Plugins.Add(new AuthFeature(...,
new IAuthProvider[] {
new ApiKeyAuthProvider(AppSettings) {
SessionCacheDuration = TimeSpan.FromMinutes(10),

That covers the major features, for the full details please see the full release notes at:

- Enjoy!

Post has attachment
.NET Core for ServiceStack is here!

We’re super excited to announce ServiceStack is now running on .NET Core.
If you're interested running on .NET Core, please see the v4.5.2 Release Notes for the full details on ServiceStack's integration story and the different conventions in .NET Core:

.NET Core was the most requested feature request of all time and was the also the feature we've been most looking forward to ourselves as we finally have a clean, fast, stable platform for running .NET Server Apps on Linux that we can recommend for running production workloads on. We've published this release late last week and have already had a tremendous response from the announcement: - the resulting momentum even got us featured in a Hanselman post :)

Whilst I encourage you to read the full release notes, I'll do my best to summarize here. Nearly all of ServiceStack’s features are now available across 21 of our most popular NuGet packages, inc. OrmLite support for SQL Server, PostgreSQL and Sqlite. We’ve been able to achieve excellent integration and code-reuse where your ServiceStack AppHost can be registered as a .NET Core module and most of your Service Implementation that uses ServiceStack libraries remains unchanged.

.NET Core Live Demos running in Linux/Docker

We’ve ported a number of existing Live Demos to .NET Core providing example projects so you can easily compare .NET 4.5 ServiceStack code-bases with what it looks like in .NET Core at:

All .NET Core Live Demos are running on Linux / Docker using AWS ECS Container Service. We're particularly optimistic about .NET Core Apps being able to natively participate in the thriving Linux / Docker ecosystem and believe it's the future for deployment / hosting where you can package your App and it's dependencies in a Container image and manage deployment / hosting and scaling instances as an opaque unit. After it's packaged in a Docker Container the fact that your App runs .NET becomes a transparent implementation detail, e.g. you're able to take advantage of the same tooling ecosystem being built around Docker on the same playing field as if it were a pure LAMP stack.

We’re maintaining .NET Core packages isolated from the Main NuGet packages separated with a `.Core` suffix until we’re satisfied .NET Core has been battle-tested in the wild which will enable us to make frequent releases outside of the main .NET 4.5 release cycle. We recommend using the "1.0.**" to reference all ServiceStack .NET Core packages that way you'll get the latest version whenever you run `dotnet restore`

New Docs Website

Whilst .NET Core was the predominant feature in this release we've also moved docs in the ServiceStack wiki to the new ServiceStack Docs website at: - The new website is built using Github's new Docs Pages feature which is powered behind-the-scenes by its Jekyll static website generator which will automatically regenerate the docs website on every commit to where the docs are now maintained.

New Wire Binary Format

A new fast binary format for the Wire serializer developed by the Akka was contributed by +Scott Mackay which also includes a generic Typed `WireServiceClient` - Wire is a fast POCO alternative with comparable performance to ProtoBuf and MessagePack.

MongoDB AuthRepository upgraded

The `MongoDbAuthRepository` has been upgraded to use the latest v2.3.0 of the mongocsharpdriver that now also implements the new `IManageApiKeys` interface so it can now also be used as the persistent back-end for the API Key AuthProvider. Special thanks to +Ivan Fioravanti for contributing the upgrade.

Facebook AuthProvider upgraded to 2.8

As Facebook is deprecating its older v2.1 API at the end of this month we've upgraded the Facebook AuthProvider to use their latest v2.8 APIs.


OrmLite added support for deleting rows by querying from a joined table using a Typed SqlExpression, e.g:

var q = db.From<Person>()
.Join<PersonJoin>((x, y) => http://x.Id == y.PersonId)
.Where<PersonJoin>(x => http://x.Id == 2);


Please see the full release notes includes for a number of other minor features added in this release:

If you're currently running ServiceStack on Linux with Mono we strongly recommend upgrading to .NET Core to take advantage of its superior performance, stability and great support - which is finally a production-grade platform for running ServiceStack/.NET Server Apps on Linux we can recommend. We'll be on standby to quickly resolve any issues you may hit and are very interested in hearing about your experience with upgrading your existing code-bases to use .NET Core - feel free to drop us a line here or in the Customer Forums.


Post has attachment
v4.5.0 Released!

This is a quick release where the major change is that all packages have been upgraded to .NET 4.5 including upgrading to use the most appropriate 3rd party dependencies, e.g ServiceStack.Razor now references the official
Microsoft.AspNet.Razor NuGet package.

.NET Core support for ServiceStack.Redis!

We've extended our support for .NET Core in this release to now also include
ServiceStack.Redis. To make it easy to start using Redis in a .NET Core App we've created a step-by-step guide for using ServiceStack.Redis on .NET Core in both Windows and Linux at:

New Xamarin.Forms TechStacks App

We've published an Xamarin.Forms demo for TechStacks App that shows sharing both UI code and C# Service Clients for both iOS and Android Apps at:

We've prepared a youtube video showing what Xamarin.Forms App looks like on both iOS/Android at:

AutoQuery Viewer Saved Queries

You can now save multiple queries for each AutoQuery Service in AutoQuery Viewer:

Create Live Executable Docs with Gistlyn

We've greatly simplified the UX and effort to create collections in Gistlyn complete with built-in Markdown Editor, Live Preview, multi image uploads and easy linking to existing/new C# Gists and collections.

We've prepared a video showcasing the new UX in action:

The Truly Empty ASP.NET Template

Since the default Empty ASP.NET Template continues to get more bloated with each passing year, we've created our own bloat-free Empty ASP.NET project VS.NET Template with Roslyn being the only dependency.

It doesn't have any dependency on ServiceStack, but it's easy to configure by just adding ServiceStack NuGet packages, Handler mapping in Web.config and AppHost in Global.asax.

Auto rewriting of HTTPS Links

ServiceStack now rewrites outgoing links to use https if ServiceStack is being hosted behind a SSL-terminated proxy which is configured to send `X-Forwarded-Proto = https` HTTP Request Header.

For more info you can read a summary of the release notes at:

Or for the complete details check out the full release notes at:

Post has attachment
v4.0.62 Released!

We've got another jam-packed release with features added across the board, I'll do my best to list the main highlights but please see the release notes for the full details:

We're excited to announce to the world - Gistlyn is a C# Gist IDE for creating, running and sharing stand-alone, executable C# snippets!

Born from our goal to improve ServiceStack's documentation, we set out to create the best way for developers to learn and explore different features in ServiceStack, Gistlyn is the result of this effort which lets you try out and explore C# and .NET libraries using just a modern browser, making it the ideal companion tool for trying out libraries during development or on the go from the comfort of your iPad or recent Android tablets by going to:

Gistlyn lets you run any valid C# fragments will execute your code on Gistlyn's server, running in an isolated context where each of the variables defined in the top-level scope can be inspected further. The preview inspector also includes an Expression evaluator that can be used to evaluate C# expressions against the live server session.

Gistlyn is also an Open platform where anyone can create Collections - A simple markdown document with info about a feature and links to source code where users can try it out "live" in the browser, with instant feedback so you can quickly preview the results at a glance.

OrmLite Interactive Tour

The OrmLite Collection ( is a great example of this which is now the best way to learn about and try OrmLite with walk through guides that takes you through different OrmLite features. We intend to add more guides like this in future so Gistlyn becomes the best place to learn about and test different features. In the meantime we've added simple TODO examples pre-configured with the necessary Nuget packages to explore OrmLite, Redis and PocoDynamo at:


Add ServiceStack Reference in Gistlyn

One feature that will add a lot of complementary value to your ServiceStack Services is Gistlyn's integrated support for Add ServiceStack Reference feature which will generate a Typed API for your remote ServiceStack Services and let you call them using ServiceStack's typed C# Service Clients and view their results - within seconds!

The easiest way to use this feature is to add the BaseUrl for your remote ServiceStack instance to the `?AddServiceStackReference` query string, e.g:


Which will create a new Gist with your Typed DTOs attached and an example request using a pre-configured JsonServiceClient and the first GET Request DTO it can find. So without having written any code you can Press play to execute a Typed API Request against your ServiceStack Services.

The URL can be further customized to tell Gistlyn which Request DTO and C# expression it should use and whether to auto run it, more info at:

This feature should make it easier to collaborate with others about your ServiceStack Services as you can send a url so they can test it out without having the proper developer environment setup. For more advanced scenarios you can easily save a modified script as a gist and send a link to that instead.

Gistlyn Snapshots

Snapshots lets you save the entire client state of your current workspace (excluding your login info)
into a generated url which you can use to revert back in time from when the snapshot was taken or send to someone else who can instantly see and run what you're working on, who'll be able to continue working from the same place you're at.

Gistlyn's Stateless Architecture

One surprising thing about Gistlyn is that it's entirely stateless where it runs without any kind of backend db persistence. All state is either persisted to Github gists or in your browser's `localStorage`. Not even your Authenticated Github session is retained on the server as it's immediately converted into an encrypted JWT Cookie that is sent with every Ajax request, so redeployments (or even clean server rebuilds) won't lose any of your work or force you to Sign In again until the JWT Token expires.

Gistlyn's Github Repo provides a good example of a modern medium-sized ServiceStack, React + TypeScript App that takes advantage of a number of different ServiceStack Features:

- React Desktop Apps - tooling for packaging Gistlyn's ASP.NET Web App into a Winforms Desktop and Console App
- Server Events - providing real-time Script Status updates and Console logging
- TypeScript - enabling end-to-end Typed API requests
- Github OAuth - authentication with Github
- JWT Auth Provider - enabling both JWT and JWE ecrypted stateless Sessions
- HTTP Utils - consuming Github's REST API and creating an authenticated HTTP Proxy in GitHubServices.cs

Run Gistlyn on your Desktop

Thanks to ServiceStack's React Desktop Apps VS.NET Template Gistlyn is available in a variety of different flavours:

Deployed as an ASP.NET Web Application on both Windows / .NET and Linux / Mono servers at:

- - Ubuntu / Vagrant / Win 2012 VM / IIS / .NET 4.6
- - Ubuntu / Docker / mono / nginx / HyperFastCGI

In addition to a running as an ASP.NET Web App, Gistlyn is also available as a self-hosting Winforms Desktop or cross-platform OSX/Linux/Windows Console App:

Running Gistlyn on your Desktop lets you take advantage of the full resources of your CPU for faster build and response times and as they're run locally they'll be able to access your RDBMS or other Networked Servers and Services available from your local Intranet.

1st class TypeScript support

TypeScript has become a core part of our overall recommended solution that's integrated into all ServiceStackVS's React and Aurelia Single Page App VS.NET Templatesoffering a seamless development experience with access to advanced ES6 features like modules, classes and arrow functions whilst still being able to target most web browsers with its down-level ES5 support.

We've added even deeper integration with TypeScript in this release with several enhancements to the generated TypeScript DTOs which graduates TypeScript to a 1st class supported language that together with the new TypeScript `JsonServiceClient` available in the servicestack-client npm package enables the same productive, typed API development experience available in our other 1st-class supported client platforms, e.g:
.then(r => {
console.log(`New C# Gist was created with id: ${r.gist}`);
.catch(e => {
console.log("Failed to create Gist: ", e.responseStatus);

Where the `r` param in the returned `then()` Promise callback is typed to Response DTO Type.

Isomorphic Fetch

The `servicestack-client` is a clean "jQuery-free" implementation based on JavaScript's new Fetch API standard utilizing nodes isomorphic-fetch implementation so it can be used in both JavaScript client web apps as well as node.js server projects.


In addition to `JsonServiceClient` we've ported most of the JavaScript utils in ss-utils.js including the new `ServerEventsClient` which Gistlyn uses to process real-time Server Events with:

const channels = ["gist"];
const sse = new ServerEventsClient("/", channels, {
handlers: {
onConnect(activeSub:ISseConnect) {
store.dispatch({ type: 'SSE_CONNECT', activeSub });
fetch("/session-to-token", {
method:"POST", credentials:"include"
ConsoleMessage(m, e) {
batchLogs.queue({ msg: m.message });
ScriptExecutionResult(m:ScriptExecutionResult, e) {

.NET Core support for ServiceStack.Client

We're happy to be able to release our initial library support for .NET Core with .NET Core builds for ServiceStack.Client and its dependencies, available in the following NuGet packages:

- ServiceStack.Client.Core
- ServiceStack.Text.Core
- ServiceStack.Interfaces.Core

Until we've completed our transition, we'll be maintaining .NET Core builds in separate NuGet packages containing a `.Core` suffix as seen above. This leaves our existing .NET packages unaffected, whilst letting us increase our release cadence of .NET Core packages until support for .NET Core libraries has stabilized.

We've published a step-by-step guide showing how to Install ServiceStack.Client in a .NET Core App at:

ServiceStack.Text is now Free!

To celebrate our initial release supporting .NET Core, we're now making ServiceStack.Text completely free for commercial or non-commercial use. We've removed all free-quota restrictions and are no longer selling licenses for ServiceStack.Text. By extension this also extends to our client libraries that just depend on ServiceStack.Text, including ServiceStack.Client and ServiceStack.Stripe which are also both free of any technical restrictions.

Encrypted Service Clients for iOS, Android and OSX

The `EncryptedServiceClient` is now available in Xamarin iOS, Android and OSX packages so your Xamarin Mobile and OSX Desktop Apps are now able to benefit from transparent encrypted service client requests without needing to configure back-end HTTP servers with SSL.

Last release supporting .NET 4.0

As announced earlier this year in preparation for .NET Core, this will be our last release supporting .NET 4.0. Starting from next release all projects will be upgraded to .NET 4.5. Should you need it, the .NET 4.0 compatible ServiceStack source code will remain accessible in the `net40` branches of all major ServiceStack Github repositories.

Aurelia updated to 1.0

To coincide with the v1.0 release of Aurelia the Aurelia VS.NET template has been updated to v1.0 using bootstrap.native and is now pre-configured with both the new `servicestack-client` and local `src/dtos.ts` TypeScript Reference that includes an end-to-end Typed DTO integrated example.

Improved Razor intellisense

We've updated all our ASP.NET Razor VS.NET Templates to use the ideal `Web.config` configuration for editing Razor pages without designer errors in VS.NET 2015.

JWT Auth Provider

The `JwtAuthProvider` has added support for specifying multiple fallback AES Auth Keys and RSA Public Keys allowing for smooth key rotations to newer Auth Keys whilst simultaneously being able to verify JWT Tokens signed with a previous key.

Multitenancy RDBMS AuthProvider

ServiceStack's `IAuthProvider` has been refactored to use the central and overridable `GetAuthRepository(IRequest)` AppHost factory method where just like ServiceStack's other "Multitenancy-aware" dependencies now lets you dynamically change which AuthProvider should be used based on the incoming request.

This can be used with the new `OrmLiteAuthRepositoryMultitenancy` provider to maintain isolated User Accounts per tenant in all major supported RDBMS.


OrmLite continues to see improvements with many of the new features in this release contributed by the Community, with special thanks to @shift-evgeny, @OlegNadymov and @bryancrosby for their contributions. There's too many examples to list here, so please check the release notes for OrmLite's new capabilities.

Dump Utils

To improve their utility in Gistlyn C# gists for quickly dumping and inspecting the contents of an object the `T.PrintDump()` and `T.Dump()` extension methods can now be used on objects with cyclical references where it will display the first-level `ToString()` value of properties that have circular references.

The `Dump()` utils are invaluable when explanatory coding or creating tests as you can quickly see what's in an object without having to set breakpoints and navigate nested properties in VS.NET's Watch window.

PATCH APIs added to HttpUtils

The same HTTP Utils extension methods for Post and Put now also have `Patch()` equivalents.


Transaction support for Complex Type APIs was added to Redis and we've improved resiliency for dealing with failing Sentinels. The Default Auto Retry Timeout was also increased from 3 to 10 seconds.


PocoDynamo now has Typed API support for DynamoDB Conditional Expressions and C# int and string enums.


The `StripeGateway` now supports sending and Receiving Customer `Metadata`, `BusinessVatId` and returning the Customer's `Currency`.

Find free Tcp Port

The new `HostContext.FindFreeTcpPort()` lets you find the first free TCP port within a specified port-range which you can use to start your `AppHost` on the first available port:

var port = HostContext.FindFreeTcpPort(5000, endingAt:6000);
new AppHost()

Other ServiceStack Features:

- Named dependency support for Funq's AutoWired APIs was contributed by @donaldgray
- Compression of `[CacheResponse]` responses can now be disabled with the `NoCompression` property
- `MakeInternal` option was added to C# / F# and VB.NET Native Types to generate internal Types
- OnError callback added to ServerEvents and new `isAuthenticated` property now being returned to Clients
- Can disable the second Total query in AutoQuery with `IncludeTotal = false`
- New Request/Response filters for Service Gateways requests that are also validated against any Validators

This covers most of the features, please see the full release notes for more details on any of the ones you're interested in:

- Enjoy!

Post has attachment
v4.0.60 Released!

We've just published another jam-packed release starting with exciting new API Key and JWT Auth Providers enabling fast, stateless and centralized Auth Services, a modernized API surface for OrmLite, new GEO capabilities in Redis, Logging for Slack, performance and memory improvements across all ServiceStack and libraries including useful utilities you can reuse to improve performance in your own Apps.

You can read a highlights summary in our Customer Forums:

and the full v4.0.60 Release Notes on GitHub:


Post has attachment
Hi Everyone,

Just wanted to make sure everyone knows of Scott Mackay's series of posts he's doing explaining how their Company uses ServiceStack and their ecosystem of OSS ServiceStack Plugins they're developing ( to help them develop their system using Microservices:

It's a nice dive into the world of Microservices and highlights different things to watch out for and evaluates a number of different technologies that help when your system is split into multiple independent Services.

He's first few posts covers benefits of DTOs and Messaging, Event Sourcing, Scaling, Distributed Debugging, Logging, Service discovery, load balancing and Routing with a lot more topics planned for the future.

It's a great read and a good website to bookmark and watch out for as the series progresses!

Wait while more posts are being loaded