chore(docs): use @loopback/core for imports of @loopback/context

docs/site/BelongsTo-relation.md

@@ -238,7 +238,7 @@ The following code snippet shows how it would look like:
 content="/src/repositories/order.repository.ts" %}
 
 ```ts
-import {Getter, inject} from '@loopback/context';
+import {Getter, inject} from '@loopback/core';
 import {
   BelongsToAccessor,
   DefaultCrudRepository,

docs/site/Binding.md

@@ -32,6 +32,7 @@ There are a few ways to create a binding:
 - Use `Binding` constructor:
 
   ```ts
+  import {Context, Binding} from '@loopback/core';
   const context = new Context();
   const binding = new Binding('my-key');
   ctx.add(binding);
@@ -40,6 +41,7 @@ There are a few ways to create a binding:
 - Use `Binding.bind()`
 
   ```ts
+  import {Context, Binding} from '@loopback/core';
   const context = new Context();
   const binding = Binding.bind('my-key');
   ctx.add(binding);
@@ -48,10 +50,24 @@ There are a few ways to create a binding:
 - Use `context.bind()`
 
   ```ts
+  import {Context, Binding} from '@loopback/core';
   const context = new Context();
   context.bind('my-key');
   ```
 
+  {% include note.html content="The `@loopback/core` package re-exports all
+  public APIs of `@loopback/context`. For consistency, we recommend the usage of
+  `@loopback/core` for imports in LoopBack modules and applications unless they
+  depend on `@loopback/context` explicitly. The two statements below are
+  equivalent:
+
+  ```ts
+  import {inject} from '@loopback/context';
+  import {inject} from '@loopback/core';
+  ```
+
+  " %}
+
 ## How to set up a binding?
 
 The `Binding` class provides a set of fluent APIs to create and configure a
@@ -87,7 +103,7 @@ The factory function can receive extra information about the context, binding,
 and resolution options.
 
 ```ts
-import {ValueFactory} from '@loopback/context';
+import {ValueFactory} from '@loopback/core';
 
 // The factory function now have access extra metadata about the resolution
 const factory: ValueFactory<string> = resolutionCtx => {
@@ -113,7 +129,7 @@ An advanced form of value factory is a class that has a static `value` method
 that allows parameter injection.
 
 ```ts
-import {inject} from '@loopback/context';
+import {inject} from '@loopback/core';
 
 class GreetingProvider {
   static value(@inject('user') user: string) {
@@ -458,7 +474,7 @@ match/find bindings by tag. The search criteria can be one of the followings:
      filterByTag,
      includesTagValue, // Match tag value as an array that includes the item
      TagValueMatcher,
-   } from '@loopback/context';
+   } from '@loopback/core';
    // Match a binding with a named service
    ctx.find(filterByTag({name: ANY_TAG_VALUE, service: 'service'}));
 
@@ -504,7 +520,7 @@ When the class is bound, these attributes are honored to create a binding. You
 can use `@bind` decorator to configure how to bind a class.
 
 ```ts
-import {bind, BindingScope} from '@loopback/context';
+import {bind, BindingScope} from '@loopback/core';
 
 // @bind() accepts scope and tags
 @bind({
@@ -538,7 +554,7 @@ export class YourController {}
 Then a binding can be created by inspecting the class,
 
 ```ts
-import {createBindingFromClass} from '@loopback/context';
+import {createBindingFromClass} from '@loopback/core';
 
 const ctx = new Context();
 const binding = createBindingFromClass(MyService);

docs/site/Context.md

@@ -37,13 +37,26 @@ can be chained using the `parent` to form a hierarchy. For example, the code
 below creates a chain of three contexts: `reqCtx -> serverCtx -> rootCtx`.
 
 ```ts
-import {Context} from '@loopback/context';
+import {Context} from '@loopback/core';
 
 const rootCtx = new Context('root-ctx'); // No parent
 const serverCtx = new Context(rootCtx, 'server-ctx'); // rootCtx as the parent
 const reqCtx = new Context(serverCtx); // No explicit name, a UUID will be generated
 ```
 
+{% include note.html content="The `@loopback/core` package re-exports all public
+APIs of `@loopback/context`. For consistency, we recommend the usage of
+`@loopback/core` for imports in LoopBack modules and applications unless they
+depend on `@loopback/context` explicitly. The two statements below are
+equivalent:
+
+```ts
+import {inject} from '@loopback/context';
+import {inject} from '@loopback/core';
+```
+
+" %}
+
 LoopBack's context system allows an unlimited amount of Context instances, each
 of which may have a parent Context.
 
@@ -180,8 +193,7 @@ However, when using classes, LoopBack provides a better way to get at stuff in
 the context via the `@inject` decorator:
 
 ```ts
-import {inject} from '@loopback/context';
-import {Application} from '@loopback/core';
+import {inject, Application} from '@loopback/core';
 
 const app = new Application();
 app.bind('defaultName').to('John');
@@ -489,7 +501,7 @@ be used to watch a list of bindings matching certain criteria depicted by a
 matched bindings.
 
 ```ts
-import {Context, ContextView} from '@loopback/context';
+import {Context, ContextView} from '@loopback/core';
 
 // Set up a context chain
 const appCtx = new Context('app');

docs/site/Controller-generator.md

@@ -51,7 +51,7 @@ based on the given name:
 ```ts
 // Uncomment these imports to begin using these cool features!
 
-// import {inject} from '@loopback/context';
+// import {inject} from '@loopback/core';
 
 export class FooController {
   constructor() {}

docs/site/Creating-components.md

@@ -90,7 +90,7 @@ function called by [Context](Context.md) when another entity requests a value to
 be injected.
 
 ```ts
-import {Provider} from '@loopback/context';
+import {Provider} from '@loopback/core';
 
 export class MyValueProvider implements Provider<string> {
   value() {
@@ -168,7 +168,7 @@ the list of keys reserved for the framework use.
 Provider's `value()` method can be asynchronous too:
 
 ```ts
-import {Provider} from '@loopback/context';
+import {Provider} from '@loopback/core';
 const request = require('request-promise-native');
 const weatherUrl =
   'http://samples.openweathermap.org/data/2.5/weather?appid=b1b15e88fa797225412429c1c50c122a1';
@@ -192,7 +192,7 @@ dependencies annotated with `@inject` keyword, so that LoopBack runtime can
 resolve them automatically.
 
 ```ts
-import {Provider} from '@loopback/context';
+import {Provider} from '@loopback/core';
 import {Request, RestBindings} from '@loopback/rest';
 import {v4 as uuid} from 'uuid';
 

docs/site/Dependency-injection.md

@@ -22,6 +22,8 @@ the caller specify which strategy to use.
 The implementation of the `authenticate` action is shown below.
 
 ```ts
+import {inject, Provider} from '@loopback/core';
+
 export class AuthenticateActionProvider implements Provider<AuthenticateFn> {
   constructor(
     // The provider is instantiated for Sequence constructor,
@@ -73,6 +75,19 @@ export class AuthenticateActionProvider implements Provider<AuthenticateFn> {
 }
 ```
 
+{% include note.html content="The `@loopback/core` package re-exports all public
+APIs of `@loopback/context`. For consistency, we recommend the usage of
+`@loopback/core` for imports in LoopBack modules and applications unless they
+depend on `@loopback/context` explicitly. The two statements below are
+equivalent:
+
+```ts
+import {inject} from '@loopback/context';
+import {inject} from '@loopback/core';
+```
+
+" %}
+
 Dependency Injection makes the code easier to extend and customize, because the
 dependencies can be easily rewired by the application developer. It makes the
 code easier to test in isolation (in a pure unit test), because the test can
@@ -296,7 +311,7 @@ problem.
 Consider the following example:
 
 ```ts
-import {Context, inject} from '@loopback/context';
+import {Context, inject} from '@loopback/core';
 
 interface Developer {
   // Each developer belongs to a team
@@ -363,7 +378,7 @@ Let's take a look at the following example:
 The corresponding code is:
 
 ```ts
-import {inject, Context, BindingScope} from '@loopback/context';
+import {inject, Context, BindingScope} from '@loopback/core';
 import {RestBindings} from '@loopback/rest';
 
 interface Logger() {

docs/site/Express-middleware.md

@@ -220,7 +220,7 @@ Alternatively, we can create a subclass of
 `ExpressMiddlewareInterceptorProvider`.
 
 ```ts
-import {config} from '@loopback/context';
+import {config} from '@loopback/core';
 import {
   ExpressMiddlewareInterceptorProvider,
   createMiddlewareInterceptorBinding,

docs/site/Extending-LoopBack-4.md

@@ -46,7 +46,7 @@ that the service provider can be injected into the consumer class. The code
 snippet below shows the usage of `@inject` for dependency injection.
 
 ```ts
-import {inject, Context} from '@loopback/context';
+import {inject, Context} from '@loopback/core';
 
 /**
  * A UserController implementation that depends on UserRepository and PasswordHasher

docs/site/Extension-point-and-extensions.md

@@ -68,7 +68,7 @@ decorators and functions are provided to ensure consistency and convention.
 1. Inject a getter function for extensions
 
    ```ts
-   import {Getter} from '@loopback/context';
+   import {Getter} from '@loopback/core';
    import {extensionPoint, extensions} from '@loopback/core';
 
    @extensionPoint('greeters')
@@ -81,7 +81,7 @@ decorators and functions are provided to ensure consistency and convention.
 2. Inject a context view for extensions
 
    ```ts
-   import {ContextView} from '@loopback/context';
+   import {ContextView} from '@loopback/core';
    import {extensionPoint, extensions} from '@loopback/core';
 
    @extensionPoint('greeters')

docs/site/FAQ.md

@@ -135,7 +135,7 @@ headers). This can be accomplished by injecting the `Response` object into the
 controller:
 
 ```ts
-import {inject} from '@loopback/context';
+import {inject} from '@loopback/core';
 import {get, Response, RestBindings} from '@loopback/rest';
 
 export class PingController {

docs/site/File-upload-download.md

@@ -25,7 +25,7 @@ A few steps are involved to create an endpoint for file upload.
    [`FileUploadController`](https://github.com/strongloop/loopback-next/blob/master/examples/file-transfer/src/controllers/file-upload.controller.ts)
 
 ```ts
-import {inject} from '@loopback/context';
+import {inject} from '@loopback/core';
 import {
   post,
   Request,
@@ -110,7 +110,7 @@ To download files from the backend, please follow the following steps.
    [`FileDownloadController`](https://github.com/strongloop/loopback-next/blob/master/examples/file-transfer/src/controllers/file-download.controller.ts)
 
 ```ts
-import {inject} from '@loopback/context';
+import {inject} from '@loopback/core';
 import {
   get,
   HttpErrors,

docs/site/Interceptor-generator.md

@@ -63,7 +63,7 @@ import {
   bind,
   Interceptor,
   Provider,
-} from '@loopback/context';
+} from '@loopback/core';
 
 /**
  * This class will be bound to the application as a global `Interceptor` during
@@ -115,7 +115,7 @@ import {
   bind,
   Interceptor,
   Provider,
-} from '@loopback/context';
+} from '@loopback/core';
 
 /**
  * This class will be bound to the application as a global `Interceptor` during

docs/site/Interceptors.md

@@ -34,7 +34,7 @@ Controller methods decorated with `@intercept` are invoked with applied
 interceptors for corresponding routes upon API requests.
 
 ```ts
-import {intercept} from '@loopback/context';
+import {intercept} from '@loopback/core';
 
 @intercept(log) // `log` is an interceptor function
 export class OrderController {
@@ -74,7 +74,7 @@ services and would like to allow repository or service methods to be
 intercepted.
 
 ```ts
-import {createProxyWithInterceptors} from '@loopback/context';
+import {createProxyWithInterceptors} from '@loopback/core';
 
 const proxy = createProxyWithInterceptors(controllerInstance, ctx);
 const msg = await proxy.greet('John');
@@ -148,7 +148,7 @@ To explicitly invoke a method with interceptors, use `invokeMethod` from
 `RestServer` for controller methods.
 
 ```ts
-import {Context, invokeMethod} from '@loopback/context';
+import {Context, invokeMethod} from '@loopback/core';
 
 const ctx: Context = new Context();
 
@@ -336,7 +336,7 @@ Global interceptors are discovered from the `InvocationContext`. They are
 registered as bindings with `globalInterceptor` tag. For example,
 
 ```ts
-import {asGlobalInterceptor} from '@loopback/context';
+import {asGlobalInterceptor} from '@loopback/core';
 
 app
   .bind('globalInterceptors.MetricsInterceptor')
@@ -747,7 +747,7 @@ Sometimes we want to apply more than one interceptors together as a whole. It
 can be done by `composeInterceptors`:
 
 ```ts
-import {composeInterceptors} from '@loopback/context';
+import {composeInterceptors} from '@loopback/core';
 
 const interceptor = composeInterceptors(
   interceptorFn1,
@@ -768,7 +768,7 @@ is the base class that can be extended to create your own flavor of interceptors
 and chains. For example,
 
 ```ts
-import {GenericInvocationChain, GenericInterceptor} from '@loopback/context';
+import {GenericInvocationChain, GenericInterceptor} from '@loopback/core';
 import {RequestContext} from '@loopback/rest';
 
 export interface RequestInterceptor
@@ -795,7 +795,7 @@ await chain.invokeInterceptors();
 It's also possible to pass in a final handler:
 
 ```ts
-import {Next} from '@loopback/context';
+import {Next} from '@loopback/core';
 const finalHandler: Next = async () => {
   // return ...;
 };

docs/site/LB3-vs-LB4-request-response-cycle.md

@@ -331,7 +331,7 @@ available to them via [dependency injection](./Dependency-injection.md).
 Example of accesssing the request and response object in a Controller:
 
 ```ts
-import {inject} from '@loopback/context';
+import {inject} from '@loopback/core';
 import {Request, Response, RestBindings, get} from '@loopback/rest';
 
 export class ExampleController {