@loopback/example-references-many 6.0.1

package/src/controllers/customer.controller.ts

@@ -0,0 +1,177 @@
+// Copyright IBM Corp. and LoopBack contributors 2022. All Rights Reserved.
+// Node module: @loopback/example-references-many
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {
+  Count,
+  CountSchema,
+  Filter,
+  FilterExcludingWhere,
+  repository,
+  Where,
+} from '@loopback/repository';
+import {
+  del,
+  get,
+  getModelSchemaRef,
+  param,
+  patch,
+  post,
+  put,
+  requestBody,
+} from '@loopback/rest';
+import {Customer} from '../models';
+import {CustomerRepository} from '../repositories';
+
+export class CustomerController {
+  constructor(
+    @repository(CustomerRepository)
+    public customerRepository: CustomerRepository,
+  ) {}
+
+  @post('/customers', {
+    responses: {
+      '200': {
+        description: 'Customer model instance',
+        content: {'application/json': {schema: getModelSchemaRef(Customer)}},
+      },
+    },
+  })
+  async create(
+    @requestBody({
+      content: {
+        'application/json': {
+          schema: getModelSchemaRef(Customer, {
+            title: 'NewCustomer',
+            exclude: ['id'],
+          }),
+        },
+      },
+    })
+    customer: Omit<Customer, 'id'>,
+  ): Promise<Customer> {
+    return this.customerRepository.create(customer);
+  }
+
+  @get('/customers/count', {
+    responses: {
+      '200': {
+        description: 'Customer model count',
+        content: {'application/json': {schema: CountSchema}},
+      },
+    },
+  })
+  async count(@param.where(Customer) where?: Where<Customer>): Promise<Count> {
+    return this.customerRepository.count(where);
+  }
+
+  @get('/customers', {
+    responses: {
+      '200': {
+        description: 'Array of Customer model instances',
+        content: {
+          'application/json': {
+            schema: {
+              type: 'array',
+              items: getModelSchemaRef(Customer, {includeRelations: true}),
+            },
+          },
+        },
+      },
+    },
+  })
+  async find(
+    @param.filter(Customer) filter?: Filter<Customer>,
+  ): Promise<Customer[]> {
+    return this.customerRepository.find(filter);
+  }
+
+  @patch('/customers', {
+    responses: {
+      '200': {
+        description: 'Customer PATCH success count',
+        content: {'application/json': {schema: CountSchema}},
+      },
+    },
+  })
+  async updateAll(
+    @requestBody({
+      content: {
+        'application/json': {
+          schema: getModelSchemaRef(Customer, {partial: true}),
+        },
+      },
+    })
+    customer: Customer,
+    @param.where(Customer) where?: Where<Customer>,
+  ): Promise<Count> {
+    return this.customerRepository.updateAll(customer, where);
+  }
+
+  @get('/customers/{id}', {
+    responses: {
+      '200': {
+        description: 'Customer model instance',
+        content: {
+          'application/json': {
+            schema: getModelSchemaRef(Customer, {includeRelations: true}),
+          },
+        },
+      },
+    },
+  })
+  async findById(
+    @param.path.number('id') id: number,
+    @param.filter(Customer, {exclude: 'where'})
+    filter?: FilterExcludingWhere<Customer>,
+  ): Promise<Customer> {
+    return this.customerRepository.findById(id, filter);
+  }
+
+  @patch('/customers/{id}', {
+    responses: {
+      '204': {
+        description: 'Customer PATCH success',
+      },
+    },
+  })
+  async updateById(
+    @param.path.number('id') id: number,
+    @requestBody({
+      content: {
+        'application/json': {
+          schema: getModelSchemaRef(Customer, {partial: true}),
+        },
+      },
+    })
+    customer: Customer,
+  ): Promise<void> {
+    await this.customerRepository.updateById(id, customer);
+  }
+
+  @del('/customers/{id}', {
+    responses: {
+      '204': {
+        description: 'Customer DELETE success',
+      },
+    },
+  })
+  async deleteById(@param.path.number('id') id: number): Promise<void> {
+    await this.customerRepository.deleteById(id);
+  }
+
+  @put('/customers/{id}', {
+    responses: {
+      '204': {
+        description: 'Customer PUT success',
+      },
+    },
+  })
+  async replaceById(
+    @param.path.number('id') id: number,
+    @requestBody() customer: Customer,
+  ): Promise<void> {
+    await this.customerRepository.replaceById(id, customer);
+  }
+}

package/src/controllers/index.ts

@@ -0,0 +1,7 @@
+// Copyright IBM Corp. and LoopBack contributors 2022. All Rights Reserved.
+// Node module: @loopback/example-references-many
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+export * from './account.controller';
+export * from './customer.controller';

package/src/datasources/db.datasource.ts

@@ -0,0 +1,34 @@
+// Copyright IBM Corp. and LoopBack contributors 2022. All Rights Reserved.
+// Node module: @loopback/example-references-many
+// 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 {juggler} from '@loopback/repository';
+
+const config = {
+  name: 'db',
+  connector: 'memory',
+  localStorage: '',
+  file: './data/db.json',
+};
+
+// Observe application's life cycle to disconnect the datasource when
+// application is stopped. This allows the application to be shut down
+// gracefully. The `stop()` method is inherited from `juggler.DataSource`.
+// Learn more at https://loopback.io/doc/en/lb4/Life-cycle.html
+@lifeCycleObserver('datasource')
+export class DbDataSource
+  extends juggler.DataSource
+  implements LifeCycleObserver
+{
+  static dataSourceName = 'db';
+  static readonly defaultConfig = config;
+
+  constructor(
+    @inject('datasources.config.db', {optional: true})
+    dsConfig: object = config,
+  ) {
+    super(dsConfig);
+  }
+}

package/src/datasources/index.ts

@@ -0,0 +1,6 @@
+// Copyright IBM Corp. and LoopBack contributors 2018,2020 All Rights Reserved.
+// Node module: @loopback/example-references-many
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+export * from './db.datasource';

package/src/index.ts

@@ -0,0 +1,42 @@
+// Copyright IBM Corp. and LoopBack contributors 2022. All Rights Reserved.
+// Node module: @loopback/example-references-many
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {ApplicationConfig, ReferencesManyApplication} from './application';
+
+export * from './application';
+
+export async function main(options: ApplicationConfig = {}) {
+  const app = new ReferencesManyApplication(options);
+  await app.boot();
+  await app.start();
+
+  const url = app.restServer.url;
+  console.log(`Server is running at ${url}`);
+  return app;
+}
+
+if (require.main === module) {
+  // Run the application
+  const config = {
+    rest: {
+      port: +(process.env.PORT ?? 3000),
+      host: process.env.HOST,
+      // The `gracePeriodForClose` provides a graceful close for http/https
+      // servers with keep-alive clients. The default value is `Infinity`
+      // (don't force-close). If you want to immediately destroy all sockets
+      // upon stop, set its value to `0`.
+      // See https://www.npmjs.com/package/stoppable
+      gracePeriodForClose: 5000, // 5 seconds
+      openApiSpec: {
+        // useful when used with OpenAPI-to-GraphQL to locate your application
+        setServersFromRequest: true,
+      },
+    },
+  };
+  main(config).catch(err => {
+    console.error('Cannot start the application.', err);
+    process.exit(1);
+  });
+}

package/src/migrate.ts

@@ -0,0 +1,25 @@
+// Copyright IBM Corp. and LoopBack contributors 2022. All Rights Reserved.
+// Node module: @loopback/example-references-many
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {ReferencesManyApplication} from './application';
+
+export async function migrate(args: string[]) {
+  const existingSchema = args.includes('--rebuild') ? 'drop' : 'alter';
+  console.log('Migrating schemas (%s existing schema)', existingSchema);
+
+  const app = new ReferencesManyApplication();
+  await app.boot();
+  await app.migrateSchema({existingSchema});
+
+  // Connectors usually keep a pool of opened connections,
+  // this keeps the process running even after all work is done.
+  // We need to exit explicitly.
+  process.exit(0);
+}
+
+migrate(process.argv).catch(err => {
+  console.error('Cannot migrate database schema', err);
+  process.exit(1);
+});

package/src/models/account.model.ts

@@ -0,0 +1,31 @@
+// Copyright IBM Corp. and LoopBack contributors 2022. All Rights Reserved.
+// Node module: @loopback/example-references-many
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+import {Entity, model, property} from '@loopback/repository';
+
+@model()
+export class Account extends Entity {
+  @property({
+    type: 'number',
+    id: true,
+    generated: false,
+  })
+  id: number;
+
+  @property({
+    type: 'number',
+    default: 0,
+  })
+  balance: number;
+
+  constructor(data?: Partial<Account>) {
+    super(data);
+  }
+}
+
+export interface AccountRelations {
+  // describe navigational properties here
+}
+
+export type AccountWithRelations = Account & AccountRelations;

package/src/models/customer.model.ts

@@ -0,0 +1,40 @@
+// Copyright IBM Corp. and LoopBack contributors 2022. All Rights Reserved.
+// Node module: @loopback/example-references-many
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {Entity, model, property, referencesMany} from '@loopback/repository';
+import {Account, AccountWithRelations} from './account.model';
+
+@model()
+export class Customer extends Entity {
+  @property({
+    type: 'number',
+    id: true,
+    generated: true,
+  })
+  id: number;
+
+  @property({
+    type: 'string',
+  })
+  firstName: string;
+
+  @property({
+    type: 'string',
+  })
+  lastName: string;
+
+  @referencesMany(() => Account)
+  accountIds?: number[];
+
+  constructor(data?: Partial<Customer>) {
+    super(data);
+  }
+}
+
+export interface CustomerRelations {
+  accounts?: AccountWithRelations;
+}
+
+export type CustomerWithRelations = Customer & CustomerRelations;

package/src/models/index.ts

@@ -0,0 +1,7 @@
+// Copyright IBM Corp. and LoopBack contributors 2018,2020 All Rights Reserved.
+// Node module: @loopback/example-references-many
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+export * from './account.model';
+export * from './customer.model';

package/src/openapi-spec.ts

@@ -0,0 +1,28 @@
+// Copyright IBM Corp. and LoopBack contributors 2020. All Rights Reserved.
+// Node module: @loopback/example-references-many
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {ApplicationConfig} from '@loopback/core';
+import {ReferencesManyApplication} from './application';
+
+/**
+ * Export the OpenAPI spec from the application
+ */
+async function exportOpenApiSpec(): Promise<void> {
+  const config: ApplicationConfig = {
+    rest: {
+      port: +(process.env.PORT ?? 3000),
+      host: process.env.HOST ?? 'localhost',
+    },
+  };
+  const outFile = process.argv[2] ?? '';
+  const app = new ReferencesManyApplication(config);
+  await app.boot();
+  await app.exportOpenApiSpec(outFile);
+}
+
+exportOpenApiSpec().catch(err => {
+  console.error('Fail to export OpenAPI spec from the application.', err);
+  process.exit(1);
+});

package/src/repositories/account.repository.ts

@@ -0,0 +1,19 @@
+// Copyright IBM Corp. and LoopBack contributors 2022. All Rights Reserved.
+// Node module: @loopback/example-references-many
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {inject} from '@loopback/core';
+import {DefaultCrudRepository} from '@loopback/repository';
+import {DbDataSource} from '../datasources';
+import {Account, AccountRelations} from '../models';
+
+export class AccountRepository extends DefaultCrudRepository<
+  Account,
+  typeof Account.prototype.id,
+  AccountRelations
+> {
+  constructor(@inject('datasources.db') dataSource: DbDataSource) {
+    super(Account, dataSource);
+  }
+}

package/src/repositories/customer.repository.ts

@@ -0,0 +1,42 @@
+// Copyright IBM Corp. and LoopBack contributors 2022. All Rights Reserved.
+// Node module: @loopback/example-references-many
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {Getter, inject} from '@loopback/core';
+import {
+  DefaultCrudRepository,
+  ReferencesManyAccessor,
+  repository,
+} from '@loopback/repository';
+import {DbDataSource} from '../datasources';
+import {Account, Customer, CustomerRelations} from '../models';
+import {AccountRepository} from './account.repository';
+
+export class CustomerRepository extends DefaultCrudRepository<
+  Customer,
+  typeof Customer.prototype.id,
+  CustomerRelations
+> {
+  public readonly accounts: ReferencesManyAccessor<
+    Account,
+    typeof Account.prototype.id
+  >;
+
+  constructor(
+    @inject('datasources.db') dataSource: DbDataSource,
+    @repository.getter('AccountRepository')
+    protected accountRepositoryGetter: Getter<AccountRepository>,
+    @repository.getter('CustomerRepository')
+    protected customerRepositoryGetter: Getter<CustomerRepository>,
+  ) {
+    super(Customer, dataSource);
+
+    this.accounts = this.createReferencesManyAccessorFor(
+      'accounts',
+      accountRepositoryGetter,
+    );
+
+    this.registerInclusionResolver('accounts', this.accounts.inclusionResolver);
+  }
+}

package/src/repositories/index.ts

@@ -0,0 +1,7 @@
+// Copyright IBM Corp. and LoopBack contributors 2022. All Rights Reserved.
+// Node module: @loopback/example-references-many
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+export * from './account.repository';
+export * from './customer.repository';

package/src/sequence.ts

@@ -0,0 +1,8 @@
+// Copyright IBM Corp. and LoopBack contributors 2022. All Rights Reserved.
+// Node module: @loopback/example-references-many
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {MiddlewareSequence} from '@loopback/rest';
+
+export class MySequence extends MiddlewareSequence {}

package/tsconfig.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "http://json.schemastore.org/tsconfig",
+  "extends": "@loopback/build/config/tsconfig.common.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "composite": true
+  },
+  "include": [
+    "src/**/*",
+    "src/**/*.json"
+  ],
+  "references": [
+    {
+      "path": "../../packages/boot/tsconfig.json"
+    },
+    {
+      "path": "../../packages/core/tsconfig.json"
+    },
+    {
+      "path": "../../packages/http-caching-proxy/tsconfig.json"
+    },
+    {
+      "path": "../../packages/repository/tsconfig.json"
+    },
+    {
+      "path": "../../packages/rest-explorer/tsconfig.json"
+    },
+    {
+      "path": "../../packages/rest/tsconfig.json"
+    },
+    {
+      "path": "../../packages/service-proxy/tsconfig.json"
+    },
+    {
+      "path": "../../packages/testlab/tsconfig.json"
+    }
+  ]
+}