mirror of
https://github.com/elastic/kibana.git
synced 2025-04-24 17:59:23 -04:00
e7e9d019ec
* Mark incoming plugin members as readonly
These cannot and should not be modifiable.
* Use env var instead of EnvironmentMode
* There doesn't appear to be an EnvMode in the new platform
* We're only using envMode to check whether we're in production
* We're already using process.env.NODE_ENV elsewhere
We can revisit this, but for now I'm simplifying things under this
assumption.
* Pass our setup context to the compose function
We're going to retrieve our router instance from this, for now.
* Remove unused static files route
I spent a few minutes trying to do this in the new platform, only to
realize that this was cargo culted from another plugin's structure and
never used.
* WIP: convert main GraphQL endpoints to New Platform
Splits the existing dual-method route into separate GET/POST
routes, while converting it to the NP routing syntax
TODO:
* Full route schema declarations
* Address context being moved off of the response object and into its
own object; callWithRequest is currently broken for this reason.
* Remove unnecesary Request type
While the defaultIndex patterns can be retrieved on the request itself,
that requires this special case of our FrameworkRequest.
In my smoke testing, the incoming `indices` argument was never different from
the one present on the request payload. Xavier had mentioned that these
might be redundant and a relic of some quick prototyping, so I'm going
to simplify this logic and delete that type under this assumption.
* Retrieve Elasticsearch client from RequestHandlerContext
In order to minimize the amount of noise on this refactor, I'm adding
the RequestHandlerContext to the existing FrameworkRequest object that
we already pass around.
This also removes some adapter methods that were cribbed from infra but
have since become unused. There are likely more.
* Use uiSettings client from RequestHandlerContext
Pulls from the new platform instead of from request.server.
* Remove unused properties from RequestFacade
One of these was obviated by the refactor to NP routing; the other may
never have been necessary.
* Remove unused interface
This is a relic that is no longer used in the codebase.
* Make error response code dynamic
* Handle GraphQL errors
Refactors to use new platform's responses instead of Boom.
Unless we intentionally do not want isGraphQLError error headers, I saw no
reason for the latter two branches of this method (and merged them).
* Fix graphiQL route
We needed to loosen the restriction on our main POST graphQL route, as
the requests coming from graphiQL do not match our normal format.
* Clean up logging
* Remove unused var injection functionality
I could not find a case where we were using these vars within the siem
app.
* Fix typo on config fetching
* Migrate to NP IndexPatterns service
* Removes unused extra parameter on callWithRequest
* I think this was a relic from the infra code
* Clean up typings of callWithRequest
* GenericParams is, ironically, not generic enough to handle all ES
client calls. Instead we type it as Record<string, any> but ensure
that our function adheres to the APICaller interface.
* Use savedObjects client in request context
These resolvers already receive a request containing the NP context, so
we can retrieve our client directly from that, now.
* Rename dependencies -> plugins to match kibana.json
* Remove unnecessary type annotation
The type of callCluster is already checked due to being passed to the
IndexPatternsFetcher constructor.
* Add siem plugin to new platform
For now this just generates a config observable with some defaults;
everything still lives in the legacy plugin.
* WIP: flattening out plugin initialization
Rather than pass our legacy API around everywhere, let's be explicit
about who needs what, and start flattening things out so that we can
move the legacy-independent stuff over.
* Pass our plugin context to initServerWithKibana
We can get the NP equivalent of `pkg.version` from
context.env.packageInfo.version, so let's do that and remove a usage of
config().
* Simplify siem configuration
As far as I can tell, the only siem config that we're using is
`xpack.siem.enabled`. The `query` was a holdover from infra, and if
we're using the `sources` queries at all, it's only with the default
values. Since our config is not typed, trying to add `sources` config
only results in runtime errors.
This removes the KibanaConfigurationAdapter entirely, and instead passes
what is effectively { sources: {} } to the SourcesConfigurationAdapter.
* Run all legacy-free setup through our plugin
Once this is vetted, we should be able to move the entire tree under the
plugin into the new platform plugin. We can inline the compose and
init_server calls into the plugin once things are vetted and stable; for
now leaving them there cuts down on the diff.
* Temporarily ignore our unused config declaration
* Fix detection engine route tests
While we're passing a properly bound route function in the app, the
tests' interfaces needed to be updated. Adds a helper method for
retrieving a bound route function from a Server object.
* Add some rudimentary schema validation to our graphQL endpoints
* Remove defunct server.config fn
The last remaining usage of this config was removed in #51985.
* Group our dev endpoints together
The graphiQL endpoint is the only thing that currently uses the GET
endpoint; everything else that talks to graphQL uses POST. For that
reason, I'm putting them in the same scope (along with annotating here)
to make that a bit clearer.
* Determine environment from plugin context
The kibana platform did and does provide this interface to check with
environment we're running in.
* Migrate xpack_main to NP features service
* Fix some issues missed in the previous merge
DE added some dependencies on both the server and request objects. Most
have NP equivalents and can be converted, but for now let's just add
them back to the Facades and convert in another PR.
Also changes one function to pull plugins from the server object, rather
than the server object living on the request (as this is how similar
functions are structured right now).
* Fix type resulting from bad merge resolution
* Fix type error due to incorrect usage of Hapi.Request
Pull elasticsearch service off our legacy server object, rather than
indirectly off the request object. Still legacy, but it's one less step
for later.
17 lines
561 B
TypeScript
17 lines
561 B
TypeScript
/*
|
|
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
|
|
* or more contributor license agreements. Licensed under the Elastic License;
|
|
* you may not use this file except in compliance with the Elastic License.
|
|
*/
|
|
|
|
import { PluginInitializerContext } from 'src/core/server';
|
|
import { Plugin } from './plugin';
|
|
import { configSchema, ConfigType } from './config';
|
|
|
|
export const plugin = (context: PluginInitializerContext) => {
|
|
return new Plugin(context);
|
|
};
|
|
|
|
export const config = { schema: configSchema };
|
|
|
|
export { ConfigType };
|