@loopback/example-greeting-app 3.0.1

package/src/__tests__/integration/greeting-service.integration.ts

@@ -0,0 +1,79 @@
+// Copyright IBM Corp. 2019,2020. All Rights Reserved.
+// Node module: @loopback/example-greeting-app
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {
+  Client,
+  createRestAppClient,
+  expect,
+  givenHttpServerConfig,
+} from '@loopback/testlab';
+import {promisify} from 'util';
+import {GreetingApplication} from '../..';
+import {CACHING_SERVICE} from '../../keys';
+
+describe('GreetingApplication', () => {
+  let app: GreetingApplication;
+  let client: Client;
+
+  before(givenRunningApplicationWithCustomConfiguration);
+  after(() => app.stop());
+
+  before(() => {
+    client = createRestAppClient(app);
+  });
+
+  it('gets a greeting in English', async function () {
+    const response = await client
+      .get('/greet/Raymond')
+      .set('Accept-Language', 'en')
+      .expect(200);
+    expect(response.body).to.containEql({
+      language: 'en',
+      greeting: 'Hello, Raymond!',
+    });
+  });
+
+  it('gets a greeting in Chinese', async function () {
+    const response = await client
+      .get('/greet/Raymond')
+      .set('Accept-Language', 'zh')
+      .expect(200);
+    expect(response.body).to.containEql({
+      language: 'zh',
+      greeting: 'Raymond，你好！',
+    });
+  });
+
+  it('gets a greeting from cache', async function () {
+    app.configure(CACHING_SERVICE).to({ttl: 100});
+    let response = await client
+      .get('/greet/Raymond')
+      .set('Accept-Language', 'en')
+      .expect(200);
+    const msg1 = response.body;
+    // Now the result should be cached
+    response = await client
+      .get('/greet/Raymond')
+      .set('Accept-Language', 'en')
+      .expect(200);
+    expect(response.body).to.eql(msg1);
+    // Cache should be expired now
+    await promisify(setTimeout)(200);
+    response = await client
+      .get('/greet/Raymond')
+      .set('Accept-Language', 'en')
+      .expect(200);
+    expect(response.body.timestamp).to.not.eql(msg1.timestamp);
+  });
+
+  async function givenRunningApplicationWithCustomConfiguration() {
+    app = new GreetingApplication({
+      rest: givenHttpServerConfig(),
+    });
+
+    // Start Application
+    await app.main();
+  }
+});

package/src/application.ts

@@ -0,0 +1,27 @@
+// Copyright IBM Corp. 2019. All Rights Reserved.
+// Node module: @loopback/example-greeting-app
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {BootMixin} from '@loopback/boot';
+import {ApplicationConfig, createBindingFromClass} from '@loopback/core';
+import {GreetingComponent} from '@loopback/example-greeter-extension';
+import {RestApplication} from '@loopback/rest';
+import {CachingService} from './caching-service';
+import {CachingInterceptor} from './interceptors';
+import {CACHING_SERVICE} from './keys';
+
+export class GreetingApplication extends BootMixin(RestApplication) {
+  constructor(config: ApplicationConfig = {}) {
+    super(config);
+    this.projectRoot = __dirname;
+    this.add(createBindingFromClass(CachingService, {key: CACHING_SERVICE}));
+    this.add(createBindingFromClass(CachingInterceptor));
+    this.component(GreetingComponent);
+  }
+
+  async main() {
+    await this.boot();
+    await this.start();
+  }
+}

package/src/caching-service.ts

@@ -0,0 +1,146 @@
+// Copyright IBM Corp. 2019. All Rights Reserved.
+// Node module: @loopback/example-greeting-app
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {BindingScope, config, ContextView, injectable} from '@loopback/core';
+import debugFactory from 'debug';
+import {Message} from './types';
+const debug = debugFactory('greeter-extension');
+
+/**
+ * Configuration for CachingService
+ */
+export interface CachingServiceOptions {
+  // The time-to-live setting for a cache entry
+  ttl: number;
+}
+
+/**
+ * Message caching service
+ */
+@injectable({scope: BindingScope.SINGLETON})
+export class CachingService {
+  private timer: NodeJS.Timer;
+  private store: Map<string, Message> = new Map();
+
+  constructor(
+    @config.view()
+    private optionsView: ContextView<CachingServiceOptions>,
+  ) {
+    // Use a view so that we can listen on `refresh` events, which are emitted
+    // when the configuration binding is updated in the context.
+    optionsView.on('refresh', () => {
+      debug('Restarting the service as configuration changes...');
+      this.restart().catch(err => {
+        console.error('Cannot restart the caching service.', err);
+        process.exit(1);
+      });
+    });
+  }
+
+  // We intentionally mark all operations `async` to reflect the commonly used
+  // caching infrastructure even though our in-memory implementation is based
+  // on a `Map` that provides synchronous APIs.
+  /**
+   * Store a message in the cache
+   * @param key - Key for caching
+   * @param message - Message
+   */
+  async set(key: string, message: Message) {
+    this.store.set(key, message);
+  }
+
+  /**
+   * Load a message from the cache by key
+   * @param key - Key for caching
+   */
+  async get(key: string) {
+    const expired = await this.isExpired(key);
+    debug('Getting cache for %s', key, expired);
+    return expired ? undefined : this.store.get(key);
+  }
+
+  /**
+   * Delete a message from the cache by key
+   * @param key - Key for caching
+   */
+  async delete(key: string) {
+    return this.store.delete(key);
+  }
+
+  /**
+   * Clear the cache
+   */
+  async clear() {
+    this.store.clear();
+  }
+
+  /**
+   * Check if the cached item is expired by key
+   * @param key - Key for caching
+   * @param now - The current date
+   */
+  async isExpired(key: string, now = new Date()): Promise<boolean> {
+    const ttl = await this.getTTL();
+    const msg = this.store.get(key);
+    if (!msg) return true;
+    return now.getTime() - msg.timestamp.getTime() > ttl;
+  }
+
+  /**
+   * Get the TTL setting
+   */
+  async getTTL() {
+    const options = await this.optionsView.singleValue();
+    debug('Caching options: %j', options);
+    return options?.ttl ?? 5000;
+  }
+
+  /**
+   * Remove expired items from the cache
+   */
+  async sweep() {
+    debug('Sweeping cache...');
+    for (const key of this.store.keys()) {
+      if (await this.isExpired(key)) {
+        debug('Cache for %s is swept.', key);
+        await this.delete(key);
+      }
+    }
+  }
+
+  /**
+   * This method will be invoked when the application starts
+   */
+  async start(): Promise<void> {
+    debug('Starting caching service');
+    await this.clear();
+    const ttl = await this.getTTL();
+    debug('TTL: %d', ttl);
+    this.timer = setInterval(() => {
+      this.sweep().catch(console.warn);
+    }, ttl);
+  }
+
+  /**
+   * This method will be invoked when the application stops
+   */
+  async stop(): Promise<void> {
+    debug('Stopping caching service');
+    /* istanbul ignore if */
+    if (this.timer) {
+      clearInterval(this.timer);
+    }
+    await this.clear();
+  }
+
+  /**
+   * This method may be used to restart the service (and may be triggered by a
+   * 'refresh' event)
+   */
+  async restart(): Promise<void> {
+    await this.stop();
+    await this.start();
+  }
+}

package/src/controllers/greeting.controller.ts

@@ -0,0 +1,50 @@
+// Copyright IBM Corp. 2019. All Rights Reserved.
+// Node module: @loopback/example-greeting-app
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {inject} from '@loopback/core';
+import {
+  GreetingService,
+  GREETING_SERVICE,
+} from '@loopback/example-greeter-extension';
+import {get, param, Request, RestBindings} from '@loopback/rest';
+import {Message} from '../types';
+
+/* istanbul ignore file */
+export class GreetingController {
+  constructor(
+    @inject(GREETING_SERVICE) private greetingService: GreetingService,
+    @inject(RestBindings.Http.REQUEST) private request: Request,
+  ) {}
+
+  @get('/greet/{name}', {
+    responses: {
+      '200': {
+        description: '',
+        content: {
+          'application/json': {
+            schema: {
+              type: 'object',
+              properties: {
+                timestamp: 'string',
+                language: 'string',
+                message: 'string',
+              },
+            },
+          },
+        },
+      },
+    },
+  })
+  async greet(@param.path.string('name') name: string): Promise<Message> {
+    const language: string =
+      this.request.acceptsLanguages(['en', 'zh']) || 'en';
+    const greeting = await this.greetingService.greet(language, name);
+    return {
+      timestamp: new Date(),
+      language,
+      greeting,
+    };
+  }
+}

package/src/controllers/index.ts

@@ -0,0 +1,6 @@
+// Copyright IBM Corp. 2019. All Rights Reserved.
+// Node module: @loopback/example-greeting-app
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+export * from './greeting.controller';

package/src/index.ts

@@ -0,0 +1,33 @@
+// Copyright IBM Corp. 2019,2020. All Rights Reserved.
+// Node module: @loopback/example-greeting-app
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+export * from './application';
+export * from './keys';
+export * from './types';
+
+import {GreetingApplication} from './application';
+export async function main() {
+  const config = {
+    rest: {
+      port: +(process.env.PORT ?? 3000),
+      host: process.env.HOST ?? '127.0.0.1',
+      openApiSpec: {
+        // useful when used with OpenAPI-to-GraphQL to locate your application
+        setServersFromRequest: true,
+      },
+    },
+  };
+  const app = new GreetingApplication(config);
+  await app.main();
+  const url = app.restServer.url;
+  console.log(`The service is running at ${url}/greet/world.`);
+}
+
+if (require.main === module) {
+  main().catch(err => {
+    console.error('Cannot start the application.', err);
+    process.exit(1);
+  });
+}

package/src/interceptors/caching.interceptor.ts

@@ -0,0 +1,55 @@
+// Copyright IBM Corp. 2019. All Rights Reserved.
+// Node module: @loopback/example-greeting-app
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {
+  asGlobalInterceptor,
+  inject,
+  injectable,
+  Interceptor,
+  InvocationContext,
+  InvocationResult,
+  Provider,
+  ValueOrPromise,
+} from '@loopback/core';
+import {RestBindings} from '@loopback/rest';
+import debugFactory from 'debug';
+import {CachingService} from '../caching-service';
+import {CACHING_SERVICE} from '../keys';
+
+const debug = debugFactory('greeter-extension');
+
+@injectable(asGlobalInterceptor('caching'))
+export class CachingInterceptor implements Provider<Interceptor> {
+  constructor(
+    @inject(CACHING_SERVICE) private cachingService: CachingService,
+  ) {}
+
+  value() {
+    return async (
+      ctx: InvocationContext,
+      next: () => ValueOrPromise<InvocationResult>,
+    ) => {
+      const httpReq = await ctx.get(RestBindings.Http.REQUEST, {
+        optional: true,
+      });
+      /* istanbul ignore if */
+      if (!httpReq) {
+        // Not http request
+        return next();
+      }
+      const key = httpReq.path;
+      const lang = httpReq.acceptsLanguages(['en', 'zh']) || 'en';
+      const cachingKey = `${lang}:${key}`;
+      const cachedResult = await this.cachingService.get(cachingKey);
+      if (cachedResult) {
+        debug('Cache found for %s %j', cachingKey, cachedResult);
+        return cachedResult;
+      }
+      const result = await next();
+      await this.cachingService.set(cachingKey, result);
+      return result;
+    };
+  }
+}

package/src/interceptors/index.ts

@@ -0,0 +1,6 @@
+// Copyright IBM Corp. 2019. All Rights Reserved.
+// Node module: @loopback/example-greeting-app
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+export * from './caching.interceptor';

package/src/keys.ts

@@ -0,0 +1,14 @@
+// Copyright IBM Corp. 2019. All Rights Reserved.
+// Node module: @loopback/example-greeting-app
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {BindingKey} from '@loopback/core';
+import {CachingService} from './caching-service';
+
+/**
+ * Strongly-typed binding key for CachingService
+ */
+export const CACHING_SERVICE = BindingKey.create<CachingService>(
+  'services.CachingService',
+);

package/src/observers/cache.observer.ts

@@ -0,0 +1,34 @@
+// Copyright IBM Corp. 2019. All Rights Reserved.
+// Node module: @loopback/example-greeting-app
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {inject, lifeCycleObserver, LifeCycleObserver} from '@loopback/core';
+import {CachingService} from '../caching-service';
+import {CACHING_SERVICE} from '../keys';
+
+/**
+ * This class will be bound to the application as a `LifeCycleObserver` during
+ * `boot`
+ */
+@lifeCycleObserver('caching')
+export class CacheObserver implements LifeCycleObserver {
+  private timer: NodeJS.Timer;
+  constructor(
+    @inject(CACHING_SERVICE) private cachingService: CachingService,
+  ) {}
+
+  /**
+   * This method will be invoked when the application starts
+   */
+  async start(): Promise<void> {
+    await this.cachingService.start();
+  }
+
+  /**
+   * This method will be invoked when the application stops
+   */
+  async stop(): Promise<void> {
+    await this.cachingService.stop();
+  }
+}