Previewvendurehq/vendure/bsebestianova/oss-300-cannot-share-roles-across-multiple-channels-in-multi-vendor

Preview: Vendure Core (bsebestianova/oss-300-cannot-share-roles-across-multiple-channels-in-multi-vendor) | Vendure Docs

The Service Layer

The service layer is the core of the application. This is where the business logic is implemented, and where the application interacts with the database. When a request comes in to the API, it gets routed to a resolver which then calls a service method to perform the required operation.

Info

Services are classes which, in NestJS terms, are providers. They follow all the rules of NestJS providers, including dependency injection, scoping, etc.

Services are generally scoped to a specific domain or entity. For instance, in the Vendure core, there is a Product entity, and a corresponding ProductService which contains all the methods for interacting with products.

Here's a simplified example of a ProductService, including an implementation of the findOne() method that was used in the example in the previous section:

src/services/product.service.ts

import { Injectable } from '@nestjs/common';import { IsNull } from 'typeorm';import { ID, Product, RequestContext, TransactionalConnection, TranslatorService } from '@vendure/core';@Injectable()export class ProductService {    constructor(private connection: TransactionalConnection,                private translator: TranslatorService){}    /**     * @description     * Returns a Product with the given id, or undefined if not found.     */    async findOne(ctx: RequestContext, productId: ID): Promise<Product | undefined> {        const product = await this.connection.findOneInChannel(ctx, Product, productId, ctx.channelId, {            where: {                deletedAt: IsNull(),            },        });        if (!product) {            return;        }        return this.translator.translate(product, ctx);    }    // ... other methods    findMany() {}    create() {}    update() {}}

src/my-plugin/my.plugin.ts

import { PluginCommonModule, VendurePlugin } from '@vendure/core';import { MyService } from './services/my.service';@VendurePlugin({    imports: [PluginCommonModule], // [!code highlight]    providers: [MyService], // [!code highlight]})export class MyPlugin {}

src/my-plugin/services/my.service.ts

import { Injectable } from '@nestjs/common';import { ProductService } from '@vendure/core';@Injectable()export class MyService {    constructor(private productService: ProductService) {} // [!code highlight]    // you can now use the productService methods}

src/services/item.service.ts

import { Injectable } from '@nestjs/common';import { ID, RequestContext, TransactionalConnection } from '@vendure/core';import { IsNull } from 'typeorm';import { Item } from '../entities/item.entity';@Injectable()export class ItemService {    constructor(private connection: TransactionalConnection) {}    findById(ctx: RequestContext, itemId: ID): Promise<Item | null> {        return this.connection.getRepository(ctx, Item).findOne({            where: { id: itemId },        });    }    findByName(ctx: RequestContext, name: string): Promise<Item | null> {        return this.connection.getRepository(ctx, Item).findOne({            where: {                // Multiple where clauses can be specified,                // which are joined with AND                name,                deletedAt: IsNull(),            },        });    }    findWithRelations() {        return this.connection.getRepository(ctx, Item).findOne({            where: { name },            relations: {                // Join the `item.customer` relation                customer: true,                product: {                    // Here we are joining a nested relation `item.product.featuredAsset`                    featuredAsset: true,                },            },        });    }    findMany(ctx: RequestContext): Promise<Item[]> {        return this.connection.getRepository(ctx, Item).find({            // Pagination            skip: 0,            take: 10,            // Sorting            order: {                name: 'ASC',            },        });    }}

src/services/item.service.ts

import { Injectable } from '@nestjs/common';import { ID, RequestContext, TransactionalConnection } from '@vendure/core';import { Brackets, IsNull } from 'typeorm';import { Item } from '../entities/item.entity';@Injectable()export class ItemService {    constructor(private connection: TransactionalConnection) {}    findById(ctx: RequestContext, itemId: ID): Promise<Item | null> {        // This is simple enough that you should prefer the Find API,        // but here is how it would be done with the QueryBuilder API:        return this.connection.getRepository(ctx, Item).createQueryBuilder('item')            .where('item.id = :id', { id: itemId })            .getOne();    }    findManyWithSubquery(ctx: RequestContext, name: string) {        // Here's a more complex query that would not be possible using the Find API:        return this.connection.getRepository(ctx, Item).createQueryBuilder('item')            .where('item.name = :name', { name })            .andWhere(                new Brackets(qb1 => {                    qb1.where('item.state = :state1', { state1: 'PENDING' })                       .orWhere('item.state = :state2', { state2: 'RETRYING' });                }),            )            .orderBy('item.createdAt', 'ASC')            .getMany();    }}

const product = await this.connection.getRepository(ctx, Product).findOne({    where: { id: productId },});if (product) {    console.log(product.featuredAsset.preview); // [!code highlight]    // ^ Error: Cannot read property 'preview' of undefined // [!code highlight]}

const product = await this.connection.getRepository(ctx, Product).createQueryBuilder('product')    .leftJoinAndSelect('product.featuredAsset', 'featuredAsset') // [!code highlight]    .where('product.id = :id', { id: productId })    .getOne();

import { EntityHydrator, ShippingCalculator } from '@vendure/core';let entityHydrator: EntityHydrator;const myShippingCalculator = new ShippingCalculator({    // ... rest of config omitted for brevity    init(injector) {        entityHydrator = injector.get(EntityHydrator);    },    calculate: (ctx, order, args) => {      // ensure that the customer and customer.groups relations are joined // [!code highlight]      await entityHydrator.hydrate(ctx, order, { relations: ['customer.groups' ]}); // [!code highlight]      if (order.customer?.groups?.some(g => g.name === 'VIP')) {        // ... do something special for VIP customers      } else {        // ... do something else      }    },});

The Service Layer

The Service Layer

Using core services

Accessing the database

The Find API

The QueryBuilder API

Working with relations

Using the EntityHydrator

Joining relations in built-in service methods