feat(server): Implement Zones

server/src/api/api.module.ts

@@ -1,6 +1,7 @@
 import { Module } from '@nestjs/common';
 import { APP_GUARD, APP_INTERCEPTOR } from '@nestjs/core';
 import { GraphQLModule } from '@nestjs/graphql';
+import { QueryResolvers } from 'shared/generated-types';
 
 import { ConfigModule } from '../config/config.module';
 import { I18nModule } from '../i18n/i18n.module';
@@ -24,6 +25,7 @@ import { OrderResolver } from './resolvers/order.resolver';
 import { ProductOptionResolver } from './resolvers/product-option.resolver';
 import { ProductResolver } from './resolvers/product.resolver';
 import { RoleResolver } from './resolvers/role.resolver';
+import { ZoneResolver } from './resolvers/zone.resolver';
 
 const exportedProviders = [
     AdjustmentSourceResolver,
@@ -39,6 +41,7 @@ const exportedProviders = [
     ProductOptionResolver,
     ProductResolver,
     RoleResolver,
+    ZoneResolver,
 ];
 
 /**

server/src/api/resolvers/country.resolver.ts

@@ -15,30 +15,30 @@ import { Allow } from '../common/auth-guard';
 import { RequestContext } from '../common/request-context';
 import { Ctx } from '../common/request-context.decorator';
 
-@Resolver('Facet')
+@Resolver('Country')
 export class CountryResolver {
     constructor(private countryService: CountryService) {}
 
     @Query()
-    @Allow(Permission.ReadCatalog)
+    @Allow(Permission.ReadSettings)
     countries(@Ctx() ctx: RequestContext, @Args() args: CountriesQueryArgs): Promise<PaginatedList<Country>> {
         return this.countryService.findAll(args.options || undefined);
     }
 
     @Query()
-    @Allow(Permission.ReadCatalog)
+    @Allow(Permission.ReadSettings)
     async country(@Ctx() ctx: RequestContext, @Args() args: CountryQueryArgs): Promise<Country | undefined> {
         return this.countryService.findOne(args.id);
     }
 
     @Mutation()
-    @Allow(Permission.CreateCatalog)
+    @Allow(Permission.CreateSettings)
     async createCountry(@Args() args: CreateCountryMutationArgs): Promise<Country> {
         return this.countryService.create(args.input);
     }
 
     @Mutation()
-    @Allow(Permission.UpdateCatalog)
+    @Allow(Permission.UpdateSettings)
     async updateCountry(@Args() args: UpdateCountryMutationArgs): Promise<Country> {
         return this.countryService.update(args.input);
     }

server/src/api/resolvers/zone.resolver.ts

@@ -0,0 +1,60 @@
+import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
+import {
+    AddMembersToZoneMutationArgs,
+    CreateZoneMutationArgs,
+    Permission,
+    RemoveMembersFromZoneMutationArgs,
+    UpdateZoneMutationArgs,
+    ZoneQueryArgs,
+} from 'shared/generated-types';
+
+import { Zone } from '../../entity/zone/zone.entity';
+import { ZoneService } from '../../service/providers/zone.service';
+import { Allow } from '../common/auth-guard';
+import { Decode } from '../common/id-interceptor';
+import { RequestContext } from '../common/request-context';
+import { Ctx } from '../common/request-context.decorator';
+
+@Resolver('Zone')
+export class ZoneResolver {
+    constructor(private zoneService: ZoneService) {}
+
+    @Query()
+    @Allow(Permission.ReadSettings)
+    zones(@Ctx() ctx: RequestContext): Promise<Zone[]> {
+        return this.zoneService.findAll();
+    }
+
+    @Query()
+    @Allow(Permission.ReadSettings)
+    async zone(@Ctx() ctx: RequestContext, @Args() args: ZoneQueryArgs): Promise<Zone | undefined> {
+        return this.zoneService.findOne(args.id);
+    }
+
+    @Mutation()
+    @Allow(Permission.CreateSettings)
+    @Decode('memberIds')
+    async createZone(@Args() args: CreateZoneMutationArgs): Promise<Zone> {
+        return this.zoneService.create(args.input);
+    }
+
+    @Mutation()
+    @Allow(Permission.UpdateSettings)
+    async updateZone(@Args() args: UpdateZoneMutationArgs): Promise<Zone> {
+        return this.zoneService.update(args.input);
+    }
+
+    @Mutation()
+    @Allow(Permission.UpdateSettings)
+    @Decode('zoneId', 'memberIds')
+    async addMembersToZone(@Args() args: AddMembersToZoneMutationArgs): Promise<Zone> {
+        return this.zoneService.addMembersToZone(args);
+    }
+
+    @Mutation()
+    @Allow(Permission.UpdateSettings)
+    @Decode('zoneId', 'memberIds')
+    async removeMembersFromZone(@Args() args: RemoveMembersFromZoneMutationArgs): Promise<Zone> {
+        return this.zoneService.removeMembersFromZone(args);
+    }
+}

server/src/api/types/zone.api.graphql

@@ -0,0 +1,15 @@
+type Query {
+    zones: [Zone!]!
+    zone(id: ID!): Zone
+}
+
+type Mutation {
+    "Create a new Zone"
+    createZone(input: CreateZoneInput!): Zone!
+    "Update an existing Zone"
+    updateZone(input: UpdateZoneInput!): Zone!
+    "Add members to a Zone"
+    addMembersToZone(zoneId: ID!, memberIds: [ID!]!): Zone!
+    "Remove members from a Zone"
+    removeMembersFromZone(zoneId: ID!, memberIds: [ID!]!): Zone!
+}

server/src/entity/entities.ts

@@ -25,6 +25,7 @@ import { AnonymousSession } from './session/anonymous-session.entity';
 import { AuthenticatedSession } from './session/authenticated-session.entity';
 import { Session } from './session/session.entity';
 import { User } from './user/user.entity';
+import { Zone } from './zone/zone.entity';
 
 /**
  * A map of all the core database entities.
@@ -57,4 +58,5 @@ export const coreEntitiesMap = {
     Role,
     Session,
     User,
+    Zone,
 };

server/src/entity/zone/zone.entity.ts

@@ -0,0 +1,18 @@
+import { DeepPartial } from 'shared/shared-types';
+import { Column, Entity, JoinTable, ManyToMany } from 'typeorm';
+
+import { VendureEntity } from '../base/base.entity';
+import { Country } from '../country/country.entity';
+
+@Entity()
+export class Zone extends VendureEntity {
+    constructor(input?: DeepPartial<Zone>) {
+        super(input);
+    }
+
+    @Column() name: string;
+
+    @ManyToMany(type => Country)
+    @JoinTable()
+    members: Country[];
+}

server/src/entity/zone/zone.graphql

@@ -0,0 +1,17 @@
+type Zone implements Node {
+    id: ID!
+    createdAt: DateTime!
+    updatedAt: DateTime!
+    name: String!
+    members: [Country!]!
+}
+
+input CreateZoneInput {
+    name: String!
+    memberIds: [ID!]
+}
+
+input UpdateZoneInput {
+    id: ID!
+    name: String
+}

server/src/service/providers/country.service.ts

@@ -25,12 +25,12 @@ export class CountryService {
     }
 
     findOne(countryId: ID): Promise<Country | undefined> {
-        return this.connection.manager.findOne(Country, countryId);
+        return this.connection.getRepository(Country).findOne(countryId);
     }
 
     async create(input: CreateCountryInput): Promise<Country> {
         const country = new Country(input);
-        return this.connection.manager.save(country);
+        return this.connection.getRepository(Country).save(country);
     }
 
     async update(input: UpdateCountryInput): Promise<Country> {
@@ -39,7 +39,7 @@ export class CountryService {
             throw new I18nError(`error.entity-with-id-not-found`, { entityName: 'Country', id: input.id });
         }
         const updatedCountry = patchEntity(country, input);
-        await this.connection.manager.save(updatedCountry);
+        await this.connection.getRepository(Country).save(updatedCountry);
         return assertFound(this.findOne(country.id));
     }
 }

server/src/service/providers/zone.service.ts

@@ -0,0 +1,78 @@
+import { Injectable } from '@nestjs/common';
+import { InjectConnection } from '@nestjs/typeorm';
+import {
+    AddMembersToZoneMutationArgs,
+    CreateZoneInput,
+    RemoveMembersFromZoneMutationArgs,
+    UpdateZoneInput,
+} from 'shared/generated-types';
+import { ID } from 'shared/shared-types';
+import { unique } from 'shared/unique';
+import { Connection } from 'typeorm';
+
+import { assertFound } from '../../common/utils';
+import { Country } from '../../entity/country/country.entity';
+import { Zone } from '../../entity/zone/zone.entity';
+import { I18nError } from '../../i18n/i18n-error';
+import { patchEntity } from '../helpers/patch-entity';
+
+@Injectable()
+export class ZoneService {
+    constructor(@InjectConnection() private connection: Connection) {}
+
+    findAll(): Promise<Zone[]> {
+        return this.connection.getRepository(Zone).find({
+            relations: ['members'],
+        });
+    }
+
+    findOne(zoneId: ID): Promise<Zone | undefined> {
+        return this.connection.getRepository(Zone).findOne(zoneId, {
+            relations: ['members'],
+        });
+    }
+
+    async create(input: CreateZoneInput): Promise<Zone> {
+        const zone = new Zone(input);
+        if (input.memberIds) {
+            zone.members = await this.getCountriesFromIds(input.memberIds);
+        }
+        const newZone = await this.connection.getRepository(Zone).save(zone);
+        return assertFound(this.findOne(newZone.id));
+    }
+
+    async update(input: UpdateZoneInput): Promise<Zone> {
+        const zone = await this.getZoneOrThrow(input.id);
+        const updatedZone = patchEntity(zone, input);
+        await this.connection.getRepository(Zone).save(updatedZone);
+        return assertFound(this.findOne(zone.id));
+    }
+
+    async addMembersToZone(input: AddMembersToZoneMutationArgs): Promise<Zone> {
+        const countries = await this.getCountriesFromIds(input.memberIds);
+        const zone = await this.getZoneOrThrow(input.zoneId);
+        const members = unique(zone.members.concat(countries), 'id');
+        zone.members = members;
+        await this.connection.getRepository(Zone).save(zone);
+        return zone;
+    }
+
+    async removeMembersFromZone(input: RemoveMembersFromZoneMutationArgs): Promise<Zone> {
+        const zone = await this.getZoneOrThrow(input.zoneId);
+        zone.members = zone.members.filter(country => !input.memberIds.includes(country.id as string));
+        await this.connection.getRepository(Zone).save(zone);
+        return zone;
+    }
+
+    private async getZoneOrThrow(id: ID): Promise<Zone> {
+        const zone = await this.findOne(id);
+        if (!zone) {
+            throw new I18nError(`error.entity-with-id-not-found`, { entityName: 'Zone', id });
+        }
+        return zone;
+    }
+
+    private getCountriesFromIds(ids: ID[]): Promise<Country[]> {
+        return this.connection.getRepository(Country).findByIds(ids);
+    }
+}

server/src/service/service.module.ts

@@ -22,6 +22,7 @@ import { ProductOptionService } from './providers/product-option.service';
 import { ProductVariantService } from './providers/product-variant.service';
 import { ProductService } from './providers/product.service';
 import { RoleService } from './providers/role.service';
+import { ZoneService } from './providers/zone.service';
 
 const exportedProviders = [
     AdjustmentSourceService,
@@ -39,6 +40,7 @@ const exportedProviders = [
     ProductService,
     ProductVariantService,
     RoleService,
+    ZoneService,
 ];
 
 /**

shared/generated-types.ts

@@ -63,6 +63,8 @@ export interface Query {
     product?: Product | null;
     roles: RoleList;
     role?: Role | null;
+    zones: Zone[];
+    zone?: Zone | null;
     networkStatus: NetworkStatus;
     userStatus: UserStatus;
     uiState: UiState;
@@ -421,6 +423,14 @@ export interface RoleList extends PaginatedList {
     totalItems: number;
 }
 
+export interface Zone extends Node {
+    id: string;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+    name: string;
+    members: Country[];
+}
+
 export interface NetworkStatus {
     inFlightRequests: number;
 }
@@ -467,6 +477,10 @@ export interface Mutation {
     applyFacetValuesToProductVariants: ProductVariant[];
     createRole: Role;
     updateRole: Role;
+    createZone: Zone;
+    updateZone: Zone;
+    addMembersToZone: Zone;
+    removeMembersFromZone: Zone;
     requestStarted: number;
     requestCompleted: number;
     setAsLoggedIn: UserStatus;
@@ -952,6 +966,16 @@ export interface UpdateRoleInput {
     permissions?: Permission[] | null;
 }
 
+export interface CreateZoneInput {
+    name: string;
+    memberIds?: string[] | null;
+}
+
+export interface UpdateZoneInput {
+    id: string;
+    name?: string | null;
+}
+
 export interface CreateProductVariantInput {
     translations: ProductVariantTranslationInput[];
     sku: string;
@@ -1052,6 +1076,9 @@ export interface RolesQueryArgs {
 export interface RoleQueryArgs {
     id: string;
 }
+export interface ZoneQueryArgs {
+    id: string;
+}
 export interface CreateAdjustmentSourceMutationArgs {
     input: CreateAdjustmentSourceInput;
 }
@@ -1155,6 +1182,20 @@ export interface CreateRoleMutationArgs {
 export interface UpdateRoleMutationArgs {
     input: UpdateRoleInput;
 }
+export interface CreateZoneMutationArgs {
+    input: CreateZoneInput;
+}
+export interface UpdateZoneMutationArgs {
+    input: UpdateZoneInput;
+}
+export interface AddMembersToZoneMutationArgs {
+    zoneId: string;
+    memberIds: string[];
+}
+export interface RemoveMembersFromZoneMutationArgs {
+    zoneId: string;
+    memberIds: string[];
+}
 export interface SetAsLoggedInMutationArgs {
     username: string;
     loginTime: string;
@@ -1424,6 +1465,8 @@ export namespace QueryResolvers {
         product?: ProductResolver<Product | null, any, Context>;
         roles?: RolesResolver<RoleList, any, Context>;
         role?: RoleResolver<Role | null, any, Context>;
+        zones?: ZonesResolver<Zone[], any, Context>;
+        zone?: ZoneResolver<Zone | null, any, Context>;
         networkStatus?: NetworkStatusResolver<NetworkStatus, any, Context>;
         userStatus?: UserStatusResolver<UserStatus, any, Context>;
         uiState?: UiStateResolver<UiState, any, Context>;
@@ -1655,6 +1698,17 @@ export namespace QueryResolvers {
         id: string;
     }
 
+    export type ZonesResolver<R = Zone[], Parent = any, Context = any> = Resolver<R, Parent, Context>;
+    export type ZoneResolver<R = Zone | null, Parent = any, Context = any> = Resolver<
+        R,
+        Parent,
+        Context,
+        ZoneArgs
+    >;
+    export interface ZoneArgs {
+        id: string;
+    }
+
     export type NetworkStatusResolver<R = NetworkStatus, Parent = any, Context = any> = Resolver<
         R,
         Parent,
@@ -2654,6 +2708,22 @@ export namespace RoleListResolvers {
     export type TotalItemsResolver<R = number, Parent = any, Context = any> = Resolver<R, Parent, Context>;
 }
 
+export namespace ZoneResolvers {
+    export interface Resolvers<Context = any> {
+        id?: IdResolver<string, any, Context>;
+        createdAt?: CreatedAtResolver<DateTime, any, Context>;
+        updatedAt?: UpdatedAtResolver<DateTime, any, Context>;
+        name?: NameResolver<string, any, Context>;
+        members?: MembersResolver<Country[], any, Context>;
+    }
+
+    export type IdResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
+    export type CreatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
+    export type UpdatedAtResolver<R = DateTime, Parent = any, Context = any> = Resolver<R, Parent, Context>;
+    export type NameResolver<R = string, Parent = any, Context = any> = Resolver<R, Parent, Context>;
+    export type MembersResolver<R = Country[], Parent = any, Context = any> = Resolver<R, Parent, Context>;
+}
+
 export namespace NetworkStatusResolvers {
     export interface Resolvers<Context = any> {
         inFlightRequests?: InFlightRequestsResolver<number, any, Context>;
@@ -2727,6 +2797,10 @@ export namespace MutationResolvers {
         >;
         createRole?: CreateRoleResolver<Role, any, Context>;
         updateRole?: UpdateRoleResolver<Role, any, Context>;
+        createZone?: CreateZoneResolver<Zone, any, Context>;
+        updateZone?: UpdateZoneResolver<Zone, any, Context>;
+        addMembersToZone?: AddMembersToZoneResolver<Zone, any, Context>;
+        removeMembersFromZone?: RemoveMembersFromZoneResolver<Zone, any, Context>;
         requestStarted?: RequestStartedResolver<number, any, Context>;
         requestCompleted?: RequestCompletedResolver<number, any, Context>;
         setAsLoggedIn?: SetAsLoggedInResolver<UserStatus, any, Context>;
@@ -3044,6 +3118,48 @@ export namespace MutationResolvers {
         input: UpdateRoleInput;
     }
 
+    export type CreateZoneResolver<R = Zone, Parent = any, Context = any> = Resolver<
+        R,
+        Parent,
+        Context,
+        CreateZoneArgs
+    >;
+    export interface CreateZoneArgs {
+        input: CreateZoneInput;
+    }
+
+    export type UpdateZoneResolver<R = Zone, Parent = any, Context = any> = Resolver<
+        R,
+        Parent,
+        Context,
+        UpdateZoneArgs
+    >;
+    export interface UpdateZoneArgs {
+        input: UpdateZoneInput;
+    }
+
+    export type AddMembersToZoneResolver<R = Zone, Parent = any, Context = any> = Resolver<
+        R,
+        Parent,
+        Context,
+        AddMembersToZoneArgs
+    >;
+    export interface AddMembersToZoneArgs {
+        zoneId: string;
+        memberIds: string[];
+    }
+
+    export type RemoveMembersFromZoneResolver<R = Zone, Parent = any, Context = any> = Resolver<
+        R,
+        Parent,
+        Context,
+        RemoveMembersFromZoneArgs
+    >;
+    export interface RemoveMembersFromZoneArgs {
+        zoneId: string;
+        memberIds: string[];
+    }
+
     export type RequestStartedResolver<R = number, Parent = any, Context = any> = Resolver<
         R,
         Parent,
@@ -3870,6 +3986,84 @@ export namespace UpdateCountry {
     export type UpdateCountry = Country.Fragment;
 }
 
+export namespace GetZones {
+    export type Variables = {};
+
+    export type Query = {
+        __typename?: 'Query';
+        zones: Zones[];
+    };
+
+    export type Zones = Zone.Fragment;
+}
+
+export namespace GetZone {
+    export type Variables = {
+        id: string;
+    };
+
+    export type Query = {
+        __typename?: 'Query';
+        zone?: Zone | null;
+    };
+
+    export type Zone = Zone.Fragment;
+}
+
+export namespace CreateZone {
+    export type Variables = {
+        input: CreateZoneInput;
+    };
+
+    export type Mutation = {
+        __typename?: 'Mutation';
+        createZone: CreateZone;
+    };
+
+    export type CreateZone = Zone.Fragment;
+}
+
+export namespace UpdateZone {
+    export type Variables = {
+        input: UpdateZoneInput;
+    };
+
+    export type Mutation = {
+        __typename?: 'Mutation';
+        updateZone: UpdateZone;
+    };
+
+    export type UpdateZone = Zone.Fragment;
+}
+
+export namespace AddMembersToZone {
+    export type Variables = {
+        zoneId: string;
+        memberIds: string[];
+    };
+
+    export type Mutation = {
+        __typename?: 'Mutation';
+        addMembersToZone: AddMembersToZone;
+    };
+
+    export type AddMembersToZone = Zone.Fragment;
+}
+
+export namespace RemoveMembersFromZone {
+    export type Variables = {
+        zoneId: string;
+        memberIds: string[];
+    };
+
+    export type Mutation = {
+        __typename?: 'Mutation';
+        removeMembersFromZone: RemoveMembersFromZone;
+    };
+
+    export type RemoveMembersFromZone = Zone.Fragment;
+}
+
 export namespace AdjustmentOperation {
     export type Fragment = {
         __typename?: 'AdjustmentOperation';
@@ -4151,3 +4345,14 @@ export namespace Country {
         enabled: boolean;
     };
 }
+
+export namespace Zone {
+    export type Fragment = {
+        __typename?: 'Zone';
+        id: string;
+        name: string;
+        members: Members[];
+    };
+
+    export type Members = Country.Fragment;
+}