@pinelab/vendure-plugin-customer-managed-groups 0.0.3

package/README.md

@@ -0,0 +1,123 @@
+# Vendure Customer Group Extensions
+
+This plugin allows customers to manage their own groups, called Customer Managed Groups. Customer Managed Groups can have Group Admins and Group members.
+
+- Group admins and members are stored as Vendure's built-in customers, and the groups are the built-in Customer Group entities.
+- Customers can only be in one group, and they are either group participant or group admin. (Customers can still be in multiple)
+- Customers can create groups and add other non-admin customers to their group. Adding others to your group automatically makes you administrator of the group.
+- Group Admins can fetch placed orders for everyone in the group.
+- Group Admins can update profile details of members of their group.
+
+## Getting started
+
+Add the plugin to your config:
+
+```ts
+import { CustomerManagedGroupsPlugin } from 'vendure-plugin-customer-managed-group';
+plugins: [CustomerManagedGroupsPlugin];
+```
+
+You can create your own group via the Shop API, if you are logged in as a customer, by inviting another customer by email:
+
+```graphql
+  mutation {
+    addCustomerToMyCustomerManagedGroup('invitee@gmail.com') {
+        id
+        createdAt
+        updatedAt
+        name
+        administrators {
+            id
+            title
+            firstName
+            lastName
+            emailAddress
+        }
+        participants {
+            id
+            title
+            firstName
+            lastName
+            emailAddress
+        }
+    }
+  }
+```
+
+You can also remove participants again, by passing in the customer id that should be removed:
+
+```graphql
+  mutation {
+    removeCustomerToMyCustomerManagedGroup('2') {
+        id
+        createdAt
+        updatedAt
+        name
+        administrators {
+            id
+            title
+            firstName
+            lastName
+            emailAddress
+        }
+        participants {
+            id
+            title
+            firstName
+            lastName
+            emailAddress
+        }
+    }
+  }
+```
+
+Admins are allowed to fetch orders of all customers in a group. You can do this with the following query:
+
+```graphql
+query {
+  ordersForMyCustomerManagedGroup {
+    items {
+      id
+      code
+      customer {
+        emailAddress
+      }
+    }
+    totalItems
+  }
+}
+```
+
+These are all the GraphQL queries and mutations exposed by this plugin:
+
+```graphql
+extend type Mutation {
+  """
+  Creates a group with the current logged in user as administrator of the group
+  """
+  addCustomerToMyCustomerManagedGroup(
+    input: AddCustomerToMyCustomerManagedGroupInput
+  ): CustomerManagedGroup!
+  """
+  Create an empty group with the current user as Administrator
+  """
+  createCustomerManagedGroup: CustomerManagedGroup!
+
+  removeCustomerFromMyCustomerManagedGroup(
+    customerId: ID!
+  ): CustomerManagedGroup!
+}
+
+extend type Query {
+  """
+  Fetch placed orders for each member of the group
+  """
+  ordersForMyCustomerManagedGroup: OrderList!
+  """
+  Fetch the current logged in group member
+  """
+  activeCustomerManagedGroupMember: CustomerManagedGroupMember
+
+  myCustomerManagedGroup: CustomerManagedGroup
+}
+```

package/dist/api-extensions.d.ts

@@ -0,0 +1,16 @@
+import { ID, Order, PaginatedList, RequestContext } from '@vendure/core';
+import { CustomerManagedGroupsService } from './customer-managed-groups.service';
+import { AddCustomerToMyCustomerManagedGroupInput, CustomerManagedGroup, CustomerManagedGroupMember, UpdateCustomerManagedGroupMemberInput } from './generated/graphql';
+export declare const shopSchema: import("graphql").DocumentNode;
+export declare class CustomerManagedGroupsResolver {
+    private service;
+    constructor(service: CustomerManagedGroupsService);
+    ordersForMyCustomerManagedGroup(ctx: RequestContext): Promise<PaginatedList<Order>>;
+    activeCustomerManagedGroupMember(ctx: RequestContext): Promise<CustomerManagedGroupMember | undefined>;
+    myCustomerManagedGroup(ctx: RequestContext): Promise<CustomerManagedGroup | undefined>;
+    createCustomerManagedGroup(ctx: RequestContext): Promise<CustomerManagedGroup | undefined>;
+    makeCustomerAdminOfCustomerManagedGroup(ctx: RequestContext, groupId: ID, customerId: ID): Promise<CustomerManagedGroup>;
+    addCustomerToMyCustomerManagedGroup(ctx: RequestContext, input: AddCustomerToMyCustomerManagedGroupInput): Promise<CustomerManagedGroup>;
+    updateCustomerManagedGroupMember(ctx: RequestContext, input: UpdateCustomerManagedGroupMemberInput): Promise<CustomerManagedGroup>;
+    removeCustomerFromMyCustomerManagedGroup(ctx: RequestContext, customerId: ID): Promise<CustomerManagedGroup>;
+}

package/dist/api-extensions.js

@@ -0,0 +1,256 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomerManagedGroupsResolver = exports.shopSchema = void 0;
+const graphql_1 = require("@nestjs/graphql");
+const core_1 = require("@vendure/core");
+const graphql_tag_1 = require("graphql-tag");
+const customer_managed_groups_service_1 = require("./customer-managed-groups.service");
+// This is just to enable static codegen, without starting a server
+const scalars = (0, graphql_tag_1.gql) `
+  scalar DateTime
+  scalar OrderList
+  scalar LanguageCode
+  scalar JSON
+`;
+exports.shopSchema = (0, graphql_tag_1.gql) `
+  input AddCustomerToMyCustomerManagedGroupInput {
+    emailAddress: String!
+    isGroupAdmin: Boolean
+  }
+
+  input UpdateCustomerManagedGroupMemberInput {
+    title: String
+    firstName: String
+    lastName: String
+    emailAddress: String
+    addresses: [CustomerManagedGroupAddressInput!]
+    customerId: ID!
+    customFields: JSON
+  }
+
+  """
+  When no ID is given, a new address will be created
+  """
+  input CustomerManagedGroupAddressInput {
+    id: ID
+    fullName: String
+    company: String
+    streetLine1: String
+    streetLine2: String
+    city: String
+    province: String
+    postalCode: String
+    countryCode: String
+    phoneNumber: String
+    defaultShippingAddress: Boolean
+    defaultBillingAddress: Boolean
+  }
+
+  type CustomerManagedGroupMember {
+    customerId: ID!
+    title: String
+    addresses: [CustomerManagedGroupAddress!]
+    firstName: String!
+    lastName: String!
+    emailAddress: String!
+    isGroupAdministrator: Boolean!
+    customFields: JSON
+  }
+
+  type CustomerManagedGroupAddress {
+    id: ID!
+    createdAt: DateTime!
+    updatedAt: DateTime!
+    fullName: String
+    company: String
+    streetLine1: String!
+    streetLine2: String
+    city: String
+    province: String
+    postalCode: String
+    country: CustomerManagedGroupCountry!
+    phoneNumber: String
+    defaultShippingAddress: Boolean
+    defaultBillingAddress: Boolean
+  }
+
+  type CustomerManagedGroupCountry {
+    id: ID!
+    createdAt: DateTime!
+    updatedAt: DateTime!
+    code: String!
+    name: String!
+    enabled: Boolean!
+    translations: [CustomerManagedGroupCountryTranslation!]!
+  }
+
+  type CustomerManagedGroupCountryTranslation {
+    id: ID!
+    languageCode: LanguageCode!
+    name: String!
+  }
+
+  type CustomerManagedGroup {
+    id: ID!
+    createdAt: DateTime!
+    updatedAt: DateTime!
+    name: String!
+    customers: [CustomerManagedGroupMember!]!
+  }
+
+  extend type Mutation {
+    """
+    Creates a group with the current logged in user as administrator of the group
+    """
+    addCustomerToMyCustomerManagedGroup(
+      input: AddCustomerToMyCustomerManagedGroupInput
+    ): CustomerManagedGroup!
+    """
+    Create an empty group with the current user as Administrator
+    """
+    createCustomerManagedGroup: CustomerManagedGroup!
+
+    removeCustomerFromMyCustomerManagedGroup(
+      customerId: ID!
+    ): CustomerManagedGroup!
+
+    """
+    Update a member of one's group
+    """
+    updateCustomerManagedGroupMember(
+      input: UpdateCustomerManagedGroupMemberInput!
+    ): CustomerManagedGroup!
+    makeCustomerAdminOfCustomerManagedGroup(
+      groupId: ID!
+      customerId: ID!
+    ): CustomerManagedGroup!
+  }
+
+  extend type Query {
+    """
+    Fetch placed orders for each member of the group
+    """
+    ordersForMyCustomerManagedGroup: OrderList!
+    """
+    Fetch the current logged in group member
+    """
+    activeCustomerManagedGroupMember: CustomerManagedGroupMember
+
+    myCustomerManagedGroup: CustomerManagedGroup
+  }
+`;
+let CustomerManagedGroupsResolver = class CustomerManagedGroupsResolver {
+    constructor(service) {
+        this.service = service;
+    }
+    async ordersForMyCustomerManagedGroup(ctx) {
+        return this.service.getOrdersForCustomer(ctx);
+    }
+    async activeCustomerManagedGroupMember(ctx) {
+        return this.service.getActiveMember(ctx);
+    }
+    async myCustomerManagedGroup(ctx) {
+        return this.service.myCustomerManagedGroup(ctx);
+    }
+    async createCustomerManagedGroup(ctx) {
+        return this.service.createCustomerManagedGroup(ctx);
+    }
+    async makeCustomerAdminOfCustomerManagedGroup(ctx, groupId, customerId) {
+        return this.service.makeAdminOfGroup(ctx, groupId, customerId);
+    }
+    async addCustomerToMyCustomerManagedGroup(ctx, input) {
+        return this.service.addToGroup(ctx, input);
+    }
+    async updateCustomerManagedGroupMember(ctx, input) {
+        return this.service.updateGroupMember(ctx, input);
+    }
+    async removeCustomerFromMyCustomerManagedGroup(ctx, customerId) {
+        return this.service.removeFromGroup(ctx, customerId);
+    }
+};
+__decorate([
+    (0, graphql_1.Query)(),
+    (0, core_1.Allow)(core_1.Permission.Authenticated),
+    __param(0, (0, core_1.Ctx)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext]),
+    __metadata("design:returntype", Promise)
+], CustomerManagedGroupsResolver.prototype, "ordersForMyCustomerManagedGroup", null);
+__decorate([
+    (0, graphql_1.Query)(),
+    (0, core_1.Allow)(core_1.Permission.Authenticated),
+    __param(0, (0, core_1.Ctx)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext]),
+    __metadata("design:returntype", Promise)
+], CustomerManagedGroupsResolver.prototype, "activeCustomerManagedGroupMember", null);
+__decorate([
+    (0, graphql_1.Query)(),
+    (0, core_1.Allow)(core_1.Permission.Authenticated),
+    __param(0, (0, core_1.Ctx)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext]),
+    __metadata("design:returntype", Promise)
+], CustomerManagedGroupsResolver.prototype, "myCustomerManagedGroup", null);
+__decorate([
+    (0, graphql_1.Mutation)(),
+    (0, core_1.Allow)(core_1.Permission.Authenticated),
+    __param(0, (0, core_1.Ctx)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext]),
+    __metadata("design:returntype", Promise)
+], CustomerManagedGroupsResolver.prototype, "createCustomerManagedGroup", null);
+__decorate([
+    (0, graphql_1.Mutation)(),
+    (0, core_1.Allow)(core_1.Permission.Authenticated),
+    __param(0, (0, core_1.Ctx)()),
+    __param(1, (0, graphql_1.Args)('groupId')),
+    __param(2, (0, graphql_1.Args)('customerId')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext, Object, Object]),
+    __metadata("design:returntype", Promise)
+], CustomerManagedGroupsResolver.prototype, "makeCustomerAdminOfCustomerManagedGroup", null);
+__decorate([
+    (0, graphql_1.Mutation)(),
+    (0, core_1.Allow)(core_1.Permission.Authenticated),
+    __param(0, (0, core_1.Ctx)()),
+    __param(1, (0, graphql_1.Args)('input')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext, Object]),
+    __metadata("design:returntype", Promise)
+], CustomerManagedGroupsResolver.prototype, "addCustomerToMyCustomerManagedGroup", null);
+__decorate([
+    (0, graphql_1.Mutation)(),
+    (0, core_1.Allow)(core_1.Permission.Authenticated),
+    __param(0, (0, core_1.Ctx)()),
+    __param(1, (0, graphql_1.Args)('input')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext, Object]),
+    __metadata("design:returntype", Promise)
+], CustomerManagedGroupsResolver.prototype, "updateCustomerManagedGroupMember", null);
+__decorate([
+    (0, graphql_1.Mutation)(),
+    (0, core_1.Allow)(core_1.Permission.Authenticated),
+    __param(0, (0, core_1.Ctx)()),
+    __param(1, (0, graphql_1.Args)('customerId')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext, Object]),
+    __metadata("design:returntype", Promise)
+], CustomerManagedGroupsResolver.prototype, "removeCustomerFromMyCustomerManagedGroup", null);
+CustomerManagedGroupsResolver = __decorate([
+    (0, graphql_1.Resolver)(),
+    __metadata("design:paramtypes", [customer_managed_groups_service_1.CustomerManagedGroupsService])
+], CustomerManagedGroupsResolver);
+exports.CustomerManagedGroupsResolver = CustomerManagedGroupsResolver;

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const loggerCtx = "CustomerManagedGroupsPlugin";
+export declare const PLUGIN_INIT_OPTIONS: unique symbol;

package/dist/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLUGIN_INIT_OPTIONS = exports.loggerCtx = void 0;
+exports.loggerCtx = 'CustomerManagedGroupsPlugin';
+exports.PLUGIN_INIT_OPTIONS = Symbol('PLUGIN_INIT_OPTIONS');

package/dist/custom-fields.d.ts

@@ -0,0 +1,11 @@
+import { CustomerGroup, Customer, CustomFields } from '@vendure/core';
+export interface CustomerGroupWithCustomFields extends CustomerGroup {
+    customFields: {
+        isCustomerManaged?: boolean;
+        groupAdmins?: Customer[];
+    };
+}
+export interface CustomerWithCustomFields extends Customer {
+    groups: CustomerGroupWithCustomFields[];
+}
+export declare const customFields: CustomFields;

package/dist/custom-fields.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customFields = void 0;
+const core_1 = require("@vendure/core");
+exports.customFields = {
+    CustomerGroup: [
+        {
+            name: 'groupAdmins',
+            list: true,
+            type: 'relation',
+            entity: core_1.Customer,
+            graphQLType: 'Customer',
+            public: true,
+            nullable: true,
+            eager: true,
+            readonly: false,
+            label: [
+                {
+                    languageCode: core_1.LanguageCode.en,
+                    value: 'Administrators of this group',
+                },
+            ],
+            // ui: { component: 'customer-group-admin-selector' },
+        },
+        {
+            name: 'isCustomerManaged',
+            type: 'boolean',
+            public: false,
+            nullable: true,
+            readonly: true,
+            label: [
+                {
+                    languageCode: core_1.LanguageCode.en,
+                    value: 'Is customer managed',
+                },
+            ],
+        },
+    ],
+};

package/dist/customer-managed-groups.plugin.d.ts

@@ -0,0 +1,7 @@
+import { AdminUiExtension } from '@vendure/ui-devkit/compiler';
+export interface ExampleOptions {
+    enabled: boolean;
+}
+export declare class CustomerManagedGroupsPlugin {
+    static ui: AdminUiExtension;
+}

package/dist/customer-managed-groups.plugin.js

@@ -0,0 +1,48 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomerManagedGroupsPlugin = void 0;
+const core_1 = require("@vendure/core");
+const path_1 = __importDefault(require("path"));
+const api_extensions_1 = require("./api-extensions");
+const custom_fields_1 = require("./custom-fields");
+const customer_managed_groups_service_1 = require("./customer-managed-groups.service");
+let CustomerManagedGroupsPlugin = class CustomerManagedGroupsPlugin {
+};
+CustomerManagedGroupsPlugin.ui = {
+    extensionPath: path_1.default.join(__dirname, 'ui'),
+    ngModules: [
+        {
+            type: 'shared',
+            ngModuleFileName: 'customer-group-extension.shared-module.ts',
+            ngModuleName: 'CustomerGroupExtensionSharedModule',
+        },
+    ],
+};
+CustomerManagedGroupsPlugin = __decorate([
+    (0, core_1.VendurePlugin)({
+        imports: [core_1.PluginCommonModule],
+        providers: [customer_managed_groups_service_1.CustomerManagedGroupsService],
+        shopApiExtensions: {
+            resolvers: [api_extensions_1.CustomerManagedGroupsResolver],
+            schema: api_extensions_1.shopSchema,
+        },
+        configuration: (config) => {
+            config.customFields = {
+                ...config.customFields,
+                ...custom_fields_1.customFields,
+            };
+            return config;
+        },
+        compatibility: '^2.0.0',
+    })
+], CustomerManagedGroupsPlugin);
+exports.CustomerManagedGroupsPlugin = CustomerManagedGroupsPlugin;

package/dist/customer-managed-groups.service.d.ts

@@ -0,0 +1,41 @@
+import { Customer, CustomerGroupService, CustomerService, EntityHydrator, ID, Order, OrderService, PaginatedList, RequestContext, TransactionalConnection } from '@vendure/core';
+import { CustomerGroupWithCustomFields, CustomerWithCustomFields } from './custom-fields';
+import { AddCustomerToMyCustomerManagedGroupInput, CustomerManagedGroup, CustomerManagedGroupMember, UpdateCustomerManagedGroupMemberInput } from './generated/graphql';
+export declare class CustomerManagedGroupsService {
+    private orderService;
+    private customerService;
+    private customerGroupService;
+    private hydrator;
+    private transactionalConnection;
+    constructor(orderService: OrderService, customerService: CustomerService, customerGroupService: CustomerGroupService, hydrator: EntityHydrator, transactionalConnection: TransactionalConnection);
+    getOrdersForCustomer(ctx: RequestContext): Promise<PaginatedList<Order>>;
+    addToGroup(ctx: RequestContext, { emailAddress: inviteeEmailAddress, isGroupAdmin: inviteeIsAdmin, }: AddCustomerToMyCustomerManagedGroupInput): Promise<CustomerManagedGroup>;
+    removeFromGroup(ctx: RequestContext, customerIdToRemove: ID): Promise<CustomerManagedGroup>;
+    getOrThrowCustomerByUserId(ctx: RequestContext, userId: ID): Promise<CustomerWithCustomFields>;
+    getOrThrowCustomerByEmail(ctx: RequestContext, emailAddress: string): Promise<Customer>;
+    /**
+     * Get userId from RequestContext or throw a ForbiddenError if not logged in
+     */
+    getOrThrowUserId(ctx: RequestContext): ID;
+    throwIfNotAdministratorOfGroup(userId: ID, group: CustomerGroupWithCustomFields): void;
+    isAdministratorOfGroup(userId: ID, group: CustomerGroupWithCustomFields): boolean;
+    getCustomerManagedGroup(customer: CustomerWithCustomFields): CustomerGroupWithCustomFields | undefined;
+    /**
+     * Get current logged in member, or undefined if not in a group
+     */
+    getActiveMember(ctx: RequestContext): Promise<CustomerManagedGroupMember | undefined>;
+    myCustomerManagedGroup(ctx: RequestContext): Promise<CustomerManagedGroup | undefined>;
+    myCustomerManagedGroupWithCustomFields(ctx: RequestContext): Promise<CustomerGroupWithCustomFields | undefined>;
+    createCustomerManagedGroup(ctx: RequestContext): Promise<CustomerManagedGroup>;
+    /**
+     *
+     * @param ctx Internal function to create a customer managed group based
+     * @param groupAdmin
+     * @param additionalMembers add addtional members to the group. Group admin is already added as member
+     */
+    private createGroup;
+    mapToCustomerManagedGroup(group: CustomerGroupWithCustomFields): CustomerManagedGroup;
+    mapToCustomerManagedGroupMember(customer: Customer, isGroupAdministrator: boolean): CustomerManagedGroupMember;
+    updateGroupMember(ctx: RequestContext, input: UpdateCustomerManagedGroupMemberInput): Promise<CustomerManagedGroup>;
+    makeAdminOfGroup(ctx: RequestContext, groupId: ID, customerId: ID): Promise<CustomerManagedGroup>;
+}

package/dist/customer-managed-groups.service.js

@@ -0,0 +1,380 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomerManagedGroupsService = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@vendure/core");
+const constants_1 = require("./constants");
+let CustomerManagedGroupsService = class CustomerManagedGroupsService {
+    constructor(orderService, customerService, customerGroupService, hydrator, transactionalConnection) {
+        this.orderService = orderService;
+        this.customerService = customerService;
+        this.customerGroupService = customerGroupService;
+        this.hydrator = hydrator;
+        this.transactionalConnection = transactionalConnection;
+    }
+    async getOrdersForCustomer(ctx) {
+        const userId = this.getOrThrowUserId(ctx);
+        const customer = await this.getOrThrowCustomerByUserId(ctx, userId);
+        const customerManagedGroup = this.getCustomerManagedGroup(customer);
+        if (!customerManagedGroup) {
+            throw new core_1.UserInputError(`You are not in a customer managed group`);
+        }
+        const isAdmin = this.isAdministratorOfGroup(userId, customerManagedGroup);
+        const orders = [];
+        // If not admin, only fetch orders for the current user
+        const customers = isAdmin ? customerManagedGroup.customers : [customer];
+        for (const customer of customers) {
+            const ordersForCustomer = await this.orderService.findByCustomerId(ctx, customer.id);
+            core_1.Logger.info(`Found ${ordersForCustomer.items.length} orders for customer ${customer.emailAddress}`, constants_1.loggerCtx);
+            orders.push(...ordersForCustomer.items);
+            if (ordersForCustomer.totalItems > ordersForCustomer.items.length) {
+                throw Error(`Too many orders for customer ${customer.emailAddress}, pagination is not implemented yet.`);
+            }
+        }
+        return {
+            items: orders,
+            totalItems: orders.length,
+        };
+    }
+    async addToGroup(ctx, { emailAddress: inviteeEmailAddress, isGroupAdmin: inviteeIsAdmin, }) {
+        const userId = this.getOrThrowUserId(ctx);
+        let [currentCustomer, invitee] = await Promise.all([
+            this.getOrThrowCustomerByUserId(ctx, userId),
+            this.getOrThrowCustomerByEmail(ctx, inviteeEmailAddress),
+        ]);
+        let customerManagedGroup = this.getCustomerManagedGroup(currentCustomer);
+        if (customerManagedGroup) {
+            this.throwIfNotAdministratorOfGroup(userId, customerManagedGroup);
+        }
+        if (!customerManagedGroup) {
+            customerManagedGroup = await this.createGroup(ctx, currentCustomer, [
+                invitee.id,
+            ]);
+        }
+        const existingAdminIds = (customerManagedGroup.customFields.groupAdmins || []).map((admin) => admin.id);
+        // Add current customer as admin
+        const adminIds = [currentCustomer.id, ...existingAdminIds];
+        core_1.Logger.info(`Adding ${currentCustomer.emailAddress} as administrator of group`, constants_1.loggerCtx);
+        if (inviteeIsAdmin) {
+            // Add invitee as admin
+            adminIds.push(invitee.id);
+            core_1.Logger.info(`Adding ${invitee.emailAddress} as administrator of group`, constants_1.loggerCtx);
+        }
+        // Set group admins
+        customerManagedGroup = await this.customerGroupService.update(ctx, {
+            id: customerManagedGroup.id,
+            customFields: {
+                groupAdmins: adminIds.map((id) => ({ id })),
+            },
+        });
+        await this.hydrator.hydrate(ctx, customerManagedGroup, {
+            relations: ['customers'],
+        });
+        const existingCustomersIds = customerManagedGroup.customers.map((customer) => customer.id);
+        if (!existingCustomersIds.includes(invitee.id)) {
+            // Add invitee to group
+            customerManagedGroup =
+                await this.customerGroupService.addCustomersToGroup(ctx, {
+                    customerGroupId: customerManagedGroup.id,
+                    customerIds: [invitee.id, ...existingCustomersIds],
+                });
+            core_1.Logger.info(`Added ${invitee.emailAddress} as participants of group`, constants_1.loggerCtx);
+        }
+        // Refetch customer and group
+        currentCustomer = await this.getOrThrowCustomerByUserId(ctx, userId);
+        customerManagedGroup = this.getCustomerManagedGroup(currentCustomer);
+        return this.mapToCustomerManagedGroup(customerManagedGroup);
+    }
+    async removeFromGroup(ctx, customerIdToRemove) {
+        const userId = this.getOrThrowUserId(ctx);
+        let customer = await this.getOrThrowCustomerByUserId(ctx, userId);
+        let customerManagedGroup = this.getCustomerManagedGroup(customer);
+        if (!customerManagedGroup) {
+            throw new core_1.UserInputError(`You are not in a customer managed group`);
+        }
+        this.throwIfNotAdministratorOfGroup(userId, customerManagedGroup);
+        const customerToRemove = customerManagedGroup.customers.find((c) => c.id == customerIdToRemove);
+        if (!customerToRemove) {
+            throw new core_1.UserInputError(`Customer '${customerIdToRemove}' is not in your group`);
+        }
+        if (customer.id === customerIdToRemove) {
+            throw new core_1.UserInputError(`You cannot remove yourself from your group`);
+        }
+        customerManagedGroup =
+            await this.customerGroupService.removeCustomersFromGroup(ctx, {
+                customerGroupId: customerManagedGroup.id,
+                customerIds: [customerIdToRemove],
+            });
+        core_1.Logger.info(`Removed customer ${customerToRemove.emailAddress} from group`, constants_1.loggerCtx);
+        const existingAdminIds = customerManagedGroup.customFields.groupAdmins?.map((a) => a.id) || [];
+        if (existingAdminIds.includes(customerToRemove.id)) {
+            const newAdminIds = existingAdminIds.filter((id) => id != customerToRemove.id);
+            customerManagedGroup = await this.customerGroupService.update(ctx, {
+                id: customerManagedGroup.id,
+                customFields: {
+                    groupAdmins: newAdminIds.map((id) => ({ id })),
+                },
+            });
+            core_1.Logger.info(`Removed ${customerToRemove.emailAddress} as group administrator`, constants_1.loggerCtx);
+        }
+        // Refetch customer and group
+        customer = await this.getOrThrowCustomerByUserId(ctx, userId);
+        customerManagedGroup = this.getCustomerManagedGroup(customer);
+        return this.mapToCustomerManagedGroup(customerManagedGroup);
+    }
+    async getOrThrowCustomerByUserId(ctx, userId) {
+        const customerRepo = this.transactionalConnection.getRepository(ctx, core_1.Customer);
+        const customerWithGroupsData = await customerRepo
+            .createQueryBuilder('customer')
+            .leftJoin('customer.channels', 'customer_channel')
+            .leftJoin('customer.user', 'user')
+            .leftJoinAndSelect('customer.addresses', 'customerAddress')
+            .leftJoinAndSelect('customerAddress.country', 'customerCountry')
+            .leftJoinAndSelect('customer.groups', 'groups')
+            .leftJoinAndSelect('groups.customers', 'customers')
+            .leftJoinAndSelect('groups.customFields.groupAdmins', 'groupAdmins')
+            .leftJoinAndSelect('groupAdmins.user', 'groupAdminsUser')
+            .leftJoinAndSelect('groupAdmins.addresses', 'groupAdminAddresses')
+            .leftJoinAndSelect('groupAdminAddresses.country', 'groupAdminCountries')
+            .leftJoinAndSelect('customers.addresses', 'addresses')
+            .leftJoinAndSelect('addresses.country', 'country')
+            .where('user.id = :userId', { userId: userId })
+            .andWhere('customer_channel.id = :customerChannelId', {
+            customerChannelId: ctx.channelId,
+        })
+            .getOne();
+        if (!customerWithGroupsData) {
+            throw new core_1.UserInputError(`No customer found for user with id ${userId}`);
+        }
+        return customerWithGroupsData;
+    }
+    async getOrThrowCustomerByEmail(ctx, emailAddress) {
+        const customers = await this.customerService.findAll(ctx, {
+            filter: {
+                emailAddress: {
+                    eq: emailAddress,
+                },
+            },
+        });
+        if (!customers.items[0]) {
+            throw new core_1.UserInputError(`No customer found for email adress ${emailAddress}`);
+        }
+        return customers.items[0];
+    }
+    /**
+     * Get userId from RequestContext or throw a ForbiddenError if not logged in
+     */
+    getOrThrowUserId(ctx) {
+        if (!ctx.activeUserId) {
+            throw new core_1.ForbiddenError();
+        }
+        return ctx.activeUserId;
+    }
+    throwIfNotAdministratorOfGroup(userId, group) {
+        if (!this.isAdministratorOfGroup(userId, group)) {
+            throw new core_1.UserInputError('You are not administrator of your group');
+        }
+    }
+    isAdministratorOfGroup(userId, group) {
+        return !!group.customFields.groupAdmins?.find((admin) => admin.user.id == userId);
+    }
+    getCustomerManagedGroup(customer) {
+        if (!customer.groups) {
+            throw Error(`Make sure to include groups in the customer query. Can not find customer managed group for customer ${customer.emailAddress}`);
+        }
+        return customer.groups.find((group) => group.customFields.isCustomerManaged);
+    }
+    /**
+     * Get current logged in member, or undefined if not in a group
+     */
+    async getActiveMember(ctx) {
+        const userId = this.getOrThrowUserId(ctx);
+        const customer = await this.getOrThrowCustomerByUserId(ctx, userId);
+        const customerManagedGroup = this.getCustomerManagedGroup(customer);
+        if (!customerManagedGroup) {
+            return;
+        }
+        const isAdministrator = this.isAdministratorOfGroup(userId, customerManagedGroup);
+        return this.mapToCustomerManagedGroupMember(customer, isAdministrator);
+    }
+    async myCustomerManagedGroup(ctx) {
+        let customerManagedGroup = await this.myCustomerManagedGroupWithCustomFields(ctx);
+        if (!customerManagedGroup) {
+            return undefined;
+        }
+        return this.mapToCustomerManagedGroup(customerManagedGroup);
+    }
+    async myCustomerManagedGroupWithCustomFields(ctx) {
+        const userId = this.getOrThrowUserId(ctx);
+        const customer = await this.getOrThrowCustomerByUserId(ctx, userId);
+        let customerManagedGroup = this.getCustomerManagedGroup(customer);
+        if (!customerManagedGroup) {
+            return undefined;
+        }
+        return customerManagedGroup;
+    }
+    async createCustomerManagedGroup(ctx) {
+        const userId = this.getOrThrowUserId(ctx);
+        const currentCustomer = await this.getOrThrowCustomerByUserId(ctx, userId);
+        let customerManagedGroup = this.getCustomerManagedGroup(currentCustomer);
+        if (customerManagedGroup) {
+            throw new core_1.UserInputError(`You are already in a customer managed group`);
+        }
+        customerManagedGroup = await this.createGroup(ctx, currentCustomer);
+        await this.hydrator.hydrate(ctx, customerManagedGroup, {
+            relations: ['customers'],
+        });
+        return this.mapToCustomerManagedGroup(customerManagedGroup);
+    }
+    /**
+     *
+     * @param ctx Internal function to create a customer managed group based
+     * @param groupAdmin
+     * @param additionalMembers add addtional members to the group. Group admin is already added as member
+     */
+    createGroup(ctx, groupAdmin, additionalMembers) {
+        const members = [groupAdmin.id];
+        if (additionalMembers) {
+            members.push(...additionalMembers);
+        }
+        return this.customerGroupService.create(ctx, {
+            name: `${groupAdmin.lastName}'s Group`,
+            customerIds: members,
+            customFields: {
+                isCustomerManaged: true,
+                groupAdmins: [groupAdmin],
+            },
+        });
+    }
+    mapToCustomerManagedGroup(group) {
+        const adminIds = group.customFields.groupAdmins?.map((admin) => admin.id) || [];
+        // Filter out group administrators
+        const participants = group.customers
+            .filter((customer) => !adminIds.includes(customer.id))
+            .map((c) => this.mapToCustomerManagedGroupMember(c, false));
+        const administrators = (group.customFields.groupAdmins || []).map((a) => this.mapToCustomerManagedGroupMember(a, true));
+        return {
+            ...group,
+            customers: [...administrators, ...participants],
+        };
+    }
+    mapToCustomerManagedGroupMember(customer, isGroupAdministrator) {
+        return {
+            ...customer,
+            addresses: customer.addresses,
+            customFields: customer.customFields,
+            customerId: customer.id,
+            isGroupAdministrator,
+        };
+    }
+    async updateGroupMember(ctx, input) {
+        if (!input.title &&
+            !input.firstName &&
+            !input.lastName &&
+            !input.emailAddress &&
+            !input.addresses?.length &&
+            !input.customFields) {
+            throw new core_1.UserInputError(`Make sure to include fields to be updated`);
+        }
+        if (!ctx.activeUserId) {
+            throw new core_1.ForbiddenError();
+        }
+        const myGroup = await this.myCustomerManagedGroupWithCustomFields(ctx);
+        if (!myGroup) {
+            throw new core_1.UserInputError(`No customer managed group exists for the authenticated customer`);
+        }
+        const member = myGroup.customers.find((customer) => customer.id === input.customerId);
+        if (!member) {
+            throw new core_1.UserInputError(`No customer with id ${input.customerId} exists in '${myGroup.name}' customer managed group`);
+        }
+        const customer = await this.customerService.findOne(ctx, member.id, [
+            'user',
+        ]);
+        if (!customer || !customer.user) {
+            throw new core_1.UserInputError(`No customer with id ${input.customerId} exists`);
+        }
+        if (!this.isAdministratorOfGroup(ctx.activeUserId, myGroup) &&
+            customer.user.id !== ctx.activeUserId) {
+            throw new core_1.UserInputError(`You are not allowed to update other member's details`);
+        }
+        const userRepo = this.transactionalConnection.getRepository(ctx, core_1.User);
+        if (input.emailAddress &&
+            (await userRepo.count({
+                where: { identifier: input.emailAddress },
+            }))) {
+            throw new core_1.UserInputError('User with this email already exists');
+        }
+        const updateCustomerData = {
+            id: customer.id,
+            ...(input.title ? { title: input.title } : []),
+            ...(input.firstName ? { firstName: input.firstName } : []),
+            ...(input.lastName ? { lastName: input.lastName } : []),
+            ...(input.emailAddress ? { emailAddress: input.emailAddress } : []),
+            ...(input.customFields ? { customFields: input.customFields } : []),
+        };
+        await this.customerService.update(ctx, updateCustomerData);
+        if (input.addresses?.length) {
+            for (let addressInput of input.addresses) {
+                if (addressInput?.id) {
+                    await this.customerService.updateAddress(ctx, addressInput);
+                }
+                else {
+                    await this.customerService.createAddress(ctx, customer.id, addressInput);
+                }
+            }
+        }
+        const newGroupData = await this.myCustomerManagedGroup(ctx);
+        if (!newGroupData) {
+            throw Error(`Group with id ${myGroup.id} not found`); // Should never happen
+        }
+        return newGroupData;
+    }
+    async makeAdminOfGroup(ctx, groupId, customerId) {
+        const customerGroup = await this.customerGroupService.findOne(ctx, groupId, ['customers', 'customers.user']);
+        if (!customerGroup ||
+            !customerGroup.customFields ||
+            !customerGroup.customFields.isCustomerManaged) {
+            throw new core_1.UserInputError(`No customer managed group with id ${groupId} exists`);
+        }
+        if (!customerGroup.customFields.groupAdmins.find((admin) => admin.user?.id === ctx.activeUserId)) {
+            throw new core_1.UserInputError(`You are not admin of this customer managed group`);
+        }
+        const customerInQuestion = await customerGroup.customers.find((c) => c.id === customerId);
+        if (!customerInQuestion) {
+            throw new core_1.UserInputError(`Customer with id ${customerId} is not part of this customer managed group`);
+        }
+        if (customerGroup.customFields.groupAdmins.find((admin) => admin.id === customerId)) {
+            throw new core_1.UserInputError('Customer is already admin of this customer managed group');
+        }
+        const customerGroupRepo = this.transactionalConnection.getRepository(ctx, core_1.CustomerGroup);
+        const partialValue = {
+            id: customerGroup.id,
+            customFields: {
+                groupAdmins: [
+                    ...customerGroup.customFields.groupAdmins,
+                    customerInQuestion,
+                ],
+            },
+        };
+        await customerGroupRepo.save(partialValue);
+        return this.mapToCustomerManagedGroup((await this.customerGroupService.findOne(ctx, groupId, ['customers'])));
+    }
+};
+CustomerManagedGroupsService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.OrderService,
+        core_1.CustomerService,
+        core_1.CustomerGroupService,
+        core_1.EntityHydrator,
+        core_1.TransactionalConnection])
+], CustomerManagedGroupsService);
+exports.CustomerManagedGroupsService = CustomerManagedGroupsService;

package/dist/generated/graphql.d.ts

@@ -0,0 +1,137 @@
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+    ID: number | string;
+    String: string;
+    Boolean: boolean;
+    Int: number;
+    Float: number;
+    DateTime: any;
+    JSON: any;
+    LanguageCode: any;
+    OrderList: any;
+};
+export type AddCustomerToMyCustomerManagedGroupInput = {
+    emailAddress: Scalars['String'];
+    isGroupAdmin?: InputMaybe<Scalars['Boolean']>;
+};
+export type CustomerManagedGroup = {
+    __typename?: 'CustomerManagedGroup';
+    createdAt: Scalars['DateTime'];
+    customers: Array<CustomerManagedGroupMember>;
+    id: Scalars['ID'];
+    name: Scalars['String'];
+    updatedAt: Scalars['DateTime'];
+};
+export type CustomerManagedGroupAddress = {
+    __typename?: 'CustomerManagedGroupAddress';
+    city?: Maybe<Scalars['String']>;
+    company?: Maybe<Scalars['String']>;
+    country: CustomerManagedGroupCountry;
+    createdAt: Scalars['DateTime'];
+    defaultBillingAddress?: Maybe<Scalars['Boolean']>;
+    defaultShippingAddress?: Maybe<Scalars['Boolean']>;
+    fullName?: Maybe<Scalars['String']>;
+    id: Scalars['ID'];
+    phoneNumber?: Maybe<Scalars['String']>;
+    postalCode?: Maybe<Scalars['String']>;
+    province?: Maybe<Scalars['String']>;
+    streetLine1: Scalars['String'];
+    streetLine2?: Maybe<Scalars['String']>;
+    updatedAt: Scalars['DateTime'];
+};
+/** When no ID is given, a new address will be created */
+export type CustomerManagedGroupAddressInput = {
+    city?: InputMaybe<Scalars['String']>;
+    company?: InputMaybe<Scalars['String']>;
+    countryCode?: InputMaybe<Scalars['String']>;
+    defaultBillingAddress?: InputMaybe<Scalars['Boolean']>;
+    defaultShippingAddress?: InputMaybe<Scalars['Boolean']>;
+    fullName?: InputMaybe<Scalars['String']>;
+    id?: InputMaybe<Scalars['ID']>;
+    phoneNumber?: InputMaybe<Scalars['String']>;
+    postalCode?: InputMaybe<Scalars['String']>;
+    province?: InputMaybe<Scalars['String']>;
+    streetLine1?: InputMaybe<Scalars['String']>;
+    streetLine2?: InputMaybe<Scalars['String']>;
+};
+export type CustomerManagedGroupCountry = {
+    __typename?: 'CustomerManagedGroupCountry';
+    code: Scalars['String'];
+    createdAt: Scalars['DateTime'];
+    enabled: Scalars['Boolean'];
+    id: Scalars['ID'];
+    name: Scalars['String'];
+    translations: Array<CustomerManagedGroupCountryTranslation>;
+    updatedAt: Scalars['DateTime'];
+};
+export type CustomerManagedGroupCountryTranslation = {
+    __typename?: 'CustomerManagedGroupCountryTranslation';
+    id: Scalars['ID'];
+    languageCode: Scalars['LanguageCode'];
+    name: Scalars['String'];
+};
+export type CustomerManagedGroupMember = {
+    __typename?: 'CustomerManagedGroupMember';
+    addresses?: Maybe<Array<CustomerManagedGroupAddress>>;
+    customFields?: Maybe<Scalars['JSON']>;
+    customerId: Scalars['ID'];
+    emailAddress: Scalars['String'];
+    firstName: Scalars['String'];
+    isGroupAdministrator: Scalars['Boolean'];
+    lastName: Scalars['String'];
+    title?: Maybe<Scalars['String']>;
+};
+export type Mutation = {
+    __typename?: 'Mutation';
+    /** Creates a group with the current logged in user as administrator of the group */
+    addCustomerToMyCustomerManagedGroup: CustomerManagedGroup;
+    /** Create an empty group with the current user as Administrator */
+    createCustomerManagedGroup: CustomerManagedGroup;
+    makeCustomerAdminOfCustomerManagedGroup: CustomerManagedGroup;
+    removeCustomerFromMyCustomerManagedGroup: CustomerManagedGroup;
+    /** Update a member of one's group */
+    updateCustomerManagedGroupMember: CustomerManagedGroup;
+};
+export type MutationAddCustomerToMyCustomerManagedGroupArgs = {
+    input?: InputMaybe<AddCustomerToMyCustomerManagedGroupInput>;
+};
+export type MutationMakeCustomerAdminOfCustomerManagedGroupArgs = {
+    customerId: Scalars['ID'];
+    groupId: Scalars['ID'];
+};
+export type MutationRemoveCustomerFromMyCustomerManagedGroupArgs = {
+    customerId: Scalars['ID'];
+};
+export type MutationUpdateCustomerManagedGroupMemberArgs = {
+    input: UpdateCustomerManagedGroupMemberInput;
+};
+export type Query = {
+    __typename?: 'Query';
+    /** Fetch the current logged in group member */
+    activeCustomerManagedGroupMember?: Maybe<CustomerManagedGroupMember>;
+    myCustomerManagedGroup?: Maybe<CustomerManagedGroup>;
+    /** Fetch placed orders for each member of the group */
+    ordersForMyCustomerManagedGroup: Scalars['OrderList'];
+};
+export type UpdateCustomerManagedGroupMemberInput = {
+    addresses?: InputMaybe<Array<CustomerManagedGroupAddressInput>>;
+    customFields?: InputMaybe<Scalars['JSON']>;
+    customerId: Scalars['ID'];
+    emailAddress?: InputMaybe<Scalars['String']>;
+    firstName?: InputMaybe<Scalars['String']>;
+    lastName?: InputMaybe<Scalars['String']>;
+    title?: InputMaybe<Scalars['String']>;
+};

package/dist/generated/graphql.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './customer-managed-groups.plugin';
+export * from './customer-managed-groups.service';
+export * from './api-extensions';
+export * from './custom-fields';

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./customer-managed-groups.plugin"), exports);
+__exportStar(require("./customer-managed-groups.service"), exports);
+__exportStar(require("./api-extensions"), exports);
+__exportStar(require("./custom-fields"), exports);

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@pinelab/vendure-plugin-customer-managed-groups",
+  "version": "0.0.3",
+  "description": "This plugin allows customer groups to have 'Group admins', that are allowed to fetch placed orders for everyone in the group.",
+  "author": "Martijn van de Brug <martijn@pinelab.studio>",
+  "homepage": "https://pinelab-plugins.com/",
+  "repository": "https://github.com/Pinelab-studio/pinelab-vendure-plugins",
+  "license": "MIT",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "yarn ts-node test/dev-server.ts",
+    "build": "rimraf dist && yarn graphql-codegen && tsc",
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "@graphql-codegen/cli": "^2.4.0",
+    "@graphql-codegen/typescript": "^2.4.8",
+    "@graphql-codegen/typescript-operations": "^2.3.5",
+    "@swc/core": "^1.3.59",
+    "@vendure/admin-ui-plugin": "2.0.4",
+    "@vendure/asset-server-plugin": "2.0.4",
+    "@vendure/core": "2.0.4",
+    "@vendure/testing": "2.0.4",
+    "@vendure/ui-devkit": "2.0.4",
+    "rimraf": "^4.1.2",
+    "ts-node": "10.9.1",
+    "typescript": "5.0.4",
+    "unplugin-swc": "^1.3.2",
+    "vitest": "^0.32.0"
+  },
+  "gitHead": "5673faf91c029dc4716226965ce3531931b434b6"
+}