Defining the API using design-first approach

export let searchableResource = (resource: any, type: string) => ({
  paths: {
    [`/${resource.path}`]: {
      // pattern
      get: {
        parameters: [
          {
            in: 'query',
            name: 'filter',
            type: 'string',
          },
        ],
        responses: {
          200: {
            description:
              resource.description || `Result set of type ${type} returned.`,
            schema: {
              $ref: `#/definitions/${type}`,
              type: 'array',
            },
          },
        },
        'x-controller-name': resource.controller,
        'x-operation-name': 'search',
      },
    },
    [`/${resource.path}/{slug}`]: {
      // pattern
      get: {
        parameters: [
          {
            in: 'path',
            name: 'slug',
            required: true,
            type: 'string',
          },
        ],
        responses: {
          200: {
            description:
              resource.description || `Result of type ${type} returned.`,
            schema: {
              $ref: `#/definitions/${type}`,
            },
          },
        },
        'x-controller-name': resource.controller,
        'x-operation-name': 'getDetails',
      },
    },
  },
});

export let creatableResource = (resource: any, type: string) => ({
  paths: {
    [`/${resource.path}`]: {
      // pattern
      post: {
        parameters: [
          {
            in: 'body',
            name: 'body',
            required: true,
            schema: {
              $ref: `#/definitions/${type}`,
            },
          },
        ],
        responses: {
          201: {
            description:
              resource.description || `The ${type} instance was created.`,
            schema: {
              $ref: `#/definitions/${type}`,
            },
          },
        },
        'x-controller-name': resource.controller,
        'x-operation-name': 'create',
      },
    },
  },
});

import {DefinitionsObject} from '@loopback/openapi-spec';

export let TypeDefinition = (type: any): DefinitionsObject => ({
  definitions: {
    [`${type.name}`]: {
      properties: type.definition,
    },
  },
});

import _ from 'lodash';

// Assuming you have created the "base" schema elsewhere.
// If there are no common properties between all of the endpoint objects,
// then you can ignore this.
import BaseSchema from '../BaseSchema';
// Don't forget to export the template functions under a common file!
import {
  SearchableResource,
  CreatableResource,
  TypeDefinition,
} from './templates';
let ProductAPI: ControllerSpec = {};

const ProductDefinition = {};
// Build type definition using base schema + additional properties.
_.merge(
  ProductDefinition,
  BaseSchema,
  TypeDefinition({
    price: {
      type: 'number',
      minimum: 0,
      exclusiveMinimum: true,
    },
  }),
);

const ProductGetResource = SearchableResource(
  {
    controller: 'ProductController',
    operation: 'search',
    path: 'products',
  },
  'Product',
);

const ProductCreateResource = CreatableResource(
  {
    controller: 'ProductController',
    operation: 'create',
    path: 'products',
  },
  'Product',
);
// Rinse and repeat for PUT, PATCH, DELETE, etc...

// Merge all of the objects together.
// This will mix the product definition into the "definitions" property of the
// OpenAPI spec, and the resources will be mixed into the "paths" property.
_.merge(
  ProductAPI,
  ProductDefinition,
  ProductGetResource,
  ProductCreateResource,
);

// And export it!
export default ProductAPI;

import {api} from '@loopback/core';
import ProductApi from '../apidefs/product.api';

// This decorator binds the Product API to the controller,
// which will establish routing to the specified functions below.
@api(ProductApi)
export class ProductController {
  // Note that the function names here match the strings in the "operation"
  // property you provided to the SearchableResource call in the previous
  // example.
  public search() {
    // your logic here
  }

  // Same goes for this function!
  public create(id: number, name: string, price: number) {
    // your logic here
  }

  // etc...
}

import {ProductAPI, DealAPI, CategoryAPI} from '../apidefs';
import OpenApiSpec from '@loopback/openapi-spec';
import _ from 'lodash';

// Import API fragments here

export const spec: OpenApiSpec = {
  openapi: '3.0.0',
  info: {
    title: 'Your API',
    version: '1.0',
  },
  paths: {},
  servers: [{url: '/'}],
};

_.merge(spec, ProductAPI);
_.merge(spec, DealAPI);
_.merge(spec, CategoryAPI);

export default spec;

// application.ts
// This should be the export from the previous example.
import spec from '../apidefs/swagger';
import {RestApplication, RestServer} from '@loopback/rest';
import {
  ProductController,
  DealController,
  CategoryController,
} from './controllers';
export class YourMicroservice extends RestApplication {
  constructor() {
    super({
      rest: {
        port: 3001,
      },
    });
    const app = this;

    app.controller(ProductController);
    app.controller(DealController);
    app.controller(CategoryController);
    //inject your spec
    app.api(spec);
  }
  // etc...
}

import {validateApiSpec} from '@loopback/testlab';
import {MyApp} from '../..';
import {RestServer} from '@loopback/rest';

describe('API specification', () => {
  it('api spec is valid', async () => {
    const app = new MyApp();
    const server = await app.getServer(RestServer);
    const spec = server.getApiSpec();
    await validateApiSpec(apiSpec);
  });
});