feature-flags | Feature flags API written in Go | Access Management library

Yeah your first option is the best one. Most readable.

The linked docs specify two configurable flags:

• __VUE_OPTIONS_API__ (enable/disable Options API support, default: true)
• __VUE_PROD_DEVTOOLS__ (enable/disable devtools support in production, default: false)

For Webpack, use the DefinePlugin to set these flags:

Manifests are a relatively new feature of vcpkg. It allows you to specify (via the vcpkg.json file) what your dependencies are. The old way meant there was really no way for vcpkg to automatically know your dependencies from looking at your project folder. You had to essentially install them manually.

Manifests mode is not enabled by default. It can be enabled by defining the environment variable VCPKG_FEATURE_FLAGS=manifests. It can also be enabled when directly calling vcpkg: D:\_programming\_repos\vcpkg\vcpkg.exe install --feature-flags=manifests,binarycaching --triplet "x64-windows".

From the link you got in the error.

The build will work without configuring these flags, however it is strongly recommended to properly configure them in order to get proper tree-shaking in the final bundle.

This should solve your issues.

DefinePlugin is a plugin which replaces variables inside your bundle with the configured values.

It accepts a regular POJO (Plain Old JavaScript Object), this means that all the rules that applies on POJO's should apply on the config object.

Actually,

You are right, the examples and tutorials are unbelievably shallow, confusing and don't clarify any of the concepts. However I couldn't help but notice that the example suggested above only deals with configuration settings, JSON, etc. but it would be hard to use for your purpose, i.e., querying SQL Server and returning the state of the feature. What you need is an example of how to implement the interface IFeatureDefinitionProvider and be able to query the SQL Server database in a flexible way. This is the way I would do it and not necessarily using the Entity Framework, ADO.NET is enough:

Streaming requires your application to be always alive. This might not be the case in a serverless environment. Furthermore, a streaming solution usually relies on a connection that is always open in the background. This might be costly, so feature flag providers tend to limit the number of concurrent connections you can keep open to their infrastructure. This might be not a problem if you use feature flags only in a few application instances. But you will easily reach the limit if you want to stream feature flag updates to mobile apps or a ton of microservices.

Polling sounds less fancy, but it's a reliable & robust old-school pattern that will work in almost all environments.

There is a third option too: webhooks. The basic idea is that you create an HTTP endpoint on your end and he feature flag service will call that endpoint whenever a feature flag value update happens. This way you get a "notification" about feature flag value changes. For example ConfigCat supports this model. ConfigCat can notify your infrastructure by calling your webhooks and (optionally) pushing new values to your end. Webhooks have the advantage over streaming that they are cheap to maintain, so feature flag service providers don't limit them as much (for example ConfigCat can give you unlimited webhooks).

How I would use the above 3 option really depends on your use-case. A general rule of thumb is: use polling by default and add quasi real-time notifications (by streaming or by webhooks) to the components where it's critical to know about feature flag value updates.

Use Autofac.Extensions.DependencyInjection. There's a builder.Populate(IServiceCollection) extension that does exactly that.

That's probably you are not importing MatInputModule into module: