@rahul_vendure/vendure-plugin-wishlist 1.0.0

package/README.md

@@ -0,0 +1,168 @@
+# @rahul_vendure/vendure-plugin-wishlist
+
+A Vendure plugin that adds wishlist functionality — customers can save product variants to their wishlist with single and bulk add/remove operations.
+
+## Features
+
+- **Add/remove single items** to wishlist
+- **Bulk add/remove** multiple items in one mutation
+- **Idempotent** — adding an already-wishlisted item returns the existing entry
+- **`isInWishlist` field** on `ProductVariant` — easy to check in storefront queries
+- **Paginated list** — uses Vendure's built-in `ListQueryBuilder` for filtering/sorting/pagination
+- **Unique constraint** — a customer can only wishlist a variant once
+
+## Installation
+
+```bash
+npm install @rahul_vendure/vendure-plugin-wishlist
+```
+
+## Setup
+
+```ts
+import { WishlistPlugin } from '@rahul_vendure/vendure-plugin-wishlist';
+
+const config: VendureConfig = {
+    plugins: [
+        WishlistPlugin.init(),
+    ],
+};
+```
+
+> **Important:** This plugin creates a `wishlist_item` table. If your project has
+> `synchronize: false`, you need to generate and run a database migration after
+> adding this plugin:
+>
+> ```bash
+> npx vendure migrate
+> ```
+
+## GraphQL API
+
+All operations are on the **Shop API** and require authentication (`Permission.Owner`).
+
+### Queries
+
+#### `wishlists`
+
+Get the current customer's wishlist with pagination.
+
+```graphql
+query {
+    wishlists(options: { take: 10, skip: 0 }) {
+        items {
+            id
+            createdAt
+            productVariant {
+                id
+                name
+                priceWithTax
+                featuredAsset {
+                    preview
+                }
+            }
+        }
+        totalItems
+    }
+}
+```
+
+### Mutations
+
+#### `addToWishlist`
+
+Add a single product variant. Returns the existing item if already wishlisted.
+
+```graphql
+mutation {
+    addToWishlist(productVariantId: "42") {
+        id
+        productVariant {
+            id
+            name
+        }
+    }
+}
+```
+
+#### `removeFromWishlist`
+
+Remove by wishlist item ID or product variant ID (at least one required).
+
+```graphql
+mutation {
+    removeFromWishlist(productVariantId: "42") {
+        result
+        message
+    }
+}
+```
+
+#### `addMultipleToWishlist`
+
+Bulk add multiple variants at once. Skips duplicates.
+
+```graphql
+mutation {
+    addMultipleToWishlist(productVariantIds: ["42", "43", "44"]) {
+        id
+        productVariant {
+            id
+            name
+        }
+    }
+}
+```
+
+#### `removeMultipleFromWishlist`
+
+Bulk remove by product variant IDs.
+
+```graphql
+mutation {
+    removeMultipleFromWishlist(productVariantIds: ["42", "43"]) {
+        result
+    }
+}
+```
+
+### Extended Fields
+
+#### `ProductVariant.isInWishlist`
+
+Returns `true` if the current customer has this variant in their wishlist.
+Returns `false` for unauthenticated users.
+
+```graphql
+query {
+    product(id: "1") {
+        variants {
+            id
+            name
+            isInWishlist
+        }
+    }
+}
+```
+
+## Database
+
+This plugin creates a `wishlist_item` table with:
+
+| Column | Type | Description |
+| --- | --- | --- |
+| `id` | `ID` | Primary key |
+| `customerId` | `ID` | Foreign key to `customer` |
+| `productVariantId` | `ID` | Foreign key to `product_variant` |
+| `createdAt` | `DateTime` | Auto-set on creation |
+| `updatedAt` | `DateTime` | Auto-set on update |
+
+A unique composite index on `(customerId, productVariantId)` prevents duplicates.
+
+## Compatibility
+
+- Vendure `^3.0.0`
+
+## License
+
+MIT

package/dist/api/api-extensions.d.ts

@@ -0,0 +1 @@
+export declare const shopApiExtensions: import("graphql").DocumentNode;

package/dist/api/api-extensions.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shopApiExtensions = void 0;
+const graphql_tag_1 = __importDefault(require("graphql-tag"));
+exports.shopApiExtensions = (0, graphql_tag_1.default) `
+    type WishlistItem implements Node {
+        id: ID!
+        createdAt: DateTime!
+        updatedAt: DateTime!
+        productVariant: ProductVariant!
+    }
+
+    type WishlistItemList implements PaginatedList {
+        items: [WishlistItem!]!
+        totalItems: Int!
+    }
+
+    input WishlistItemListOptions
+
+    extend type Query {
+        wishlists(options: WishlistItemListOptions): WishlistItemList!
+    }
+
+    extend type Mutation {
+        addToWishlist(productVariantId: ID!): WishlistItem!
+        """
+        Removes a wishlist item by its id or product variant id.
+        At least one must be specified.
+        """
+        removeFromWishlist(id: ID, productVariantId: ID): DeletionResponse!
+        """
+        Adds multiple product variants to wishlist at once.
+        """
+        addMultipleToWishlist(productVariantIds: [ID!]!): [WishlistItem!]!
+        """
+        Removes multiple wishlist items by their product variant ids.
+        """
+        removeMultipleFromWishlist(productVariantIds: [ID!]!): DeletionResponse!
+    }
+
+    extend type ProductVariant {
+        isInWishlist: Boolean!
+    }
+`;

package/dist/api/product-variant-entity.resolver.d.ts

@@ -0,0 +1,8 @@
+import { CustomerService, ProductVariant, RequestContext } from '@vendure/core';
+import { WishlistService } from '../services/wishlist.service';
+export declare class ProductVariantEntityResolver {
+    private customerService;
+    private wishlistService;
+    constructor(customerService: CustomerService, wishlistService: WishlistService);
+    isInWishlist(ctx: RequestContext, productVariant: ProductVariant): Promise<boolean>;
+}

package/dist/api/product-variant-entity.resolver.js

@@ -0,0 +1,50 @@
+"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.ProductVariantEntityResolver = void 0;
+const graphql_1 = require("@nestjs/graphql");
+const core_1 = require("@vendure/core");
+const wishlist_service_1 = require("../services/wishlist.service");
+let ProductVariantEntityResolver = class ProductVariantEntityResolver {
+    constructor(customerService, wishlistService) {
+        this.customerService = customerService;
+        this.wishlistService = wishlistService;
+    }
+    async isInWishlist(ctx, productVariant) {
+        const userId = ctx.activeUserId;
+        if (!userId) {
+            return false;
+        }
+        const customer = await this.customerService.findOneByUserId(ctx, userId);
+        if (!customer) {
+            return false;
+        }
+        return this.wishlistService.isInWishlist(ctx, customer.id, productVariant.id);
+    }
+};
+exports.ProductVariantEntityResolver = ProductVariantEntityResolver;
+__decorate([
+    (0, graphql_1.ResolveField)(),
+    __param(0, (0, core_1.Ctx)()),
+    __param(1, (0, graphql_1.Parent)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext,
+        core_1.ProductVariant]),
+    __metadata("design:returntype", Promise)
+], ProductVariantEntityResolver.prototype, "isInWishlist", null);
+exports.ProductVariantEntityResolver = ProductVariantEntityResolver = __decorate([
+    (0, graphql_1.Resolver)('ProductVariant'),
+    __metadata("design:paramtypes", [core_1.CustomerService,
+        wishlist_service_1.WishlistService])
+], ProductVariantEntityResolver);

package/dist/api/wishlist.resolver.d.ts

@@ -0,0 +1,20 @@
+import { DeletionResponse } from '@vendure/common/lib/generated-types';
+import { CustomerService, ID, PaginatedList, RequestContext } from '@vendure/core';
+import { WishlistItem } from '../entities/wishlist-item.entity';
+import { WishlistService } from '../services/wishlist.service';
+export declare class WishlistShopResolver {
+    private customerService;
+    private wishlistService;
+    constructor(customerService: CustomerService, wishlistService: WishlistService);
+    wishlists(ctx: RequestContext, args: {
+        options?: any;
+    }): Promise<PaginatedList<WishlistItem>>;
+    addToWishlist(ctx: RequestContext, productVariantId: ID): Promise<WishlistItem>;
+    removeFromWishlist(ctx: RequestContext, args: {
+        id?: ID;
+        productVariantId?: ID;
+    }): Promise<DeletionResponse>;
+    addMultipleToWishlist(ctx: RequestContext, productVariantIds: ID[]): Promise<WishlistItem[]>;
+    removeMultipleFromWishlist(ctx: RequestContext, productVariantIds: ID[]): Promise<DeletionResponse>;
+    private getCustomerForOwner;
+}

package/dist/api/wishlist.resolver.js

@@ -0,0 +1,106 @@
+"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.WishlistShopResolver = void 0;
+const graphql_1 = require("@nestjs/graphql");
+const core_1 = require("@vendure/core");
+const wishlist_service_1 = require("../services/wishlist.service");
+let WishlistShopResolver = class WishlistShopResolver {
+    constructor(customerService, wishlistService) {
+        this.customerService = customerService;
+        this.wishlistService = wishlistService;
+    }
+    async wishlists(ctx, args) {
+        const customer = await this.getCustomerForOwner(ctx);
+        return this.wishlistService.findAllByCustomerId(ctx, customer.id, args.options);
+    }
+    async addToWishlist(ctx, productVariantId) {
+        const customer = await this.getCustomerForOwner(ctx);
+        return this.wishlistService.create(ctx, customer.id, productVariantId);
+    }
+    async removeFromWishlist(ctx, args) {
+        const customer = await this.getCustomerForOwner(ctx);
+        return this.wishlistService.delete(ctx, customer.id, args.id, args.productVariantId);
+    }
+    async addMultipleToWishlist(ctx, productVariantIds) {
+        const customer = await this.getCustomerForOwner(ctx);
+        return this.wishlistService.createMultiple(ctx, customer.id, productVariantIds);
+    }
+    async removeMultipleFromWishlist(ctx, productVariantIds) {
+        const customer = await this.getCustomerForOwner(ctx);
+        return this.wishlistService.deleteMultiple(ctx, customer.id, productVariantIds);
+    }
+    async getCustomerForOwner(ctx) {
+        const userId = ctx.activeUserId;
+        if (!userId) {
+            throw new core_1.ForbiddenError();
+        }
+        const customer = await this.customerService.findOneByUserId(ctx, userId);
+        if (!customer) {
+            throw new core_1.InternalServerError('error.no-customer-found-for-current-user');
+        }
+        return customer;
+    }
+};
+exports.WishlistShopResolver = WishlistShopResolver;
+__decorate([
+    (0, graphql_1.Query)(),
+    (0, core_1.Allow)(core_1.Permission.Owner),
+    __param(0, (0, core_1.Ctx)()),
+    __param(1, (0, graphql_1.Args)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext, Object]),
+    __metadata("design:returntype", Promise)
+], WishlistShopResolver.prototype, "wishlists", null);
+__decorate([
+    (0, graphql_1.Mutation)(),
+    (0, core_1.Allow)(core_1.Permission.Owner),
+    __param(0, (0, core_1.Ctx)()),
+    __param(1, (0, graphql_1.Args)('productVariantId')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext, Object]),
+    __metadata("design:returntype", Promise)
+], WishlistShopResolver.prototype, "addToWishlist", null);
+__decorate([
+    (0, graphql_1.Mutation)(),
+    (0, core_1.Allow)(core_1.Permission.Owner),
+    __param(0, (0, core_1.Ctx)()),
+    __param(1, (0, graphql_1.Args)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext, Object]),
+    __metadata("design:returntype", Promise)
+], WishlistShopResolver.prototype, "removeFromWishlist", null);
+__decorate([
+    (0, graphql_1.Mutation)(),
+    (0, core_1.Allow)(core_1.Permission.Owner),
+    __param(0, (0, core_1.Ctx)()),
+    __param(1, (0, graphql_1.Args)('productVariantIds')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext, Array]),
+    __metadata("design:returntype", Promise)
+], WishlistShopResolver.prototype, "addMultipleToWishlist", null);
+__decorate([
+    (0, graphql_1.Mutation)(),
+    (0, core_1.Allow)(core_1.Permission.Owner),
+    __param(0, (0, core_1.Ctx)()),
+    __param(1, (0, graphql_1.Args)('productVariantIds')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext, Array]),
+    __metadata("design:returntype", Promise)
+], WishlistShopResolver.prototype, "removeMultipleFromWishlist", null);
+exports.WishlistShopResolver = WishlistShopResolver = __decorate([
+    (0, graphql_1.Resolver)(),
+    __metadata("design:paramtypes", [core_1.CustomerService,
+        wishlist_service_1.WishlistService])
+], WishlistShopResolver);

package/dist/constants.d.ts

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

package/dist/constants.js

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

package/dist/entities/wishlist-item.entity.d.ts

@@ -0,0 +1,8 @@
+import { Customer, DeepPartial, ID, ProductVariant, VendureEntity } from '@vendure/core';
+export declare class WishlistItem extends VendureEntity {
+    constructor(input?: DeepPartial<WishlistItem>);
+    customer: Customer;
+    customerId: ID;
+    productVariant: ProductVariant;
+    productVariantId: ID;
+}

package/dist/entities/wishlist-item.entity.js

@@ -0,0 +1,43 @@
+"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.WishlistItem = void 0;
+const core_1 = require("@vendure/core");
+const typeorm_1 = require("typeorm");
+let WishlistItem = class WishlistItem extends core_1.VendureEntity {
+    constructor(input) {
+        super(input);
+    }
+};
+exports.WishlistItem = WishlistItem;
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => core_1.Customer, { eager: false }),
+    (0, typeorm_1.JoinColumn)({ name: 'customerId' }),
+    __metadata("design:type", core_1.Customer)
+], WishlistItem.prototype, "customer", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", Object)
+], WishlistItem.prototype, "customerId", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => core_1.ProductVariant, { eager: true }),
+    (0, typeorm_1.JoinColumn)({ name: 'productVariantId' }),
+    __metadata("design:type", core_1.ProductVariant)
+], WishlistItem.prototype, "productVariant", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", Object)
+], WishlistItem.prototype, "productVariantId", void 0);
+exports.WishlistItem = WishlistItem = __decorate([
+    (0, typeorm_1.Entity)(),
+    (0, typeorm_1.Index)(['customerId', 'productVariantId'], { unique: true }),
+    __metadata("design:paramtypes", [Object])
+], WishlistItem);

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { WishlistPlugin } from './wishlist.plugin';
+export { WishlistPluginOptions } from './types';
+export { WishlistItem } from './entities/wishlist-item.entity';
+export { WishlistService } from './services/wishlist.service';

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WishlistService = exports.WishlistItem = exports.WishlistPlugin = void 0;
+var wishlist_plugin_1 = require("./wishlist.plugin");
+Object.defineProperty(exports, "WishlistPlugin", { enumerable: true, get: function () { return wishlist_plugin_1.WishlistPlugin; } });
+var wishlist_item_entity_1 = require("./entities/wishlist-item.entity");
+Object.defineProperty(exports, "WishlistItem", { enumerable: true, get: function () { return wishlist_item_entity_1.WishlistItem; } });
+var wishlist_service_1 = require("./services/wishlist.service");
+Object.defineProperty(exports, "WishlistService", { enumerable: true, get: function () { return wishlist_service_1.WishlistService; } });

package/dist/services/wishlist.service.d.ts

@@ -0,0 +1,16 @@
+import { DeletionResponse } from '@vendure/common/lib/generated-types';
+import { ID, ListQueryBuilder, ListQueryOptions, PaginatedList, ProductVariantService, RequestContext, TransactionalConnection } from '@vendure/core';
+import { WishlistItem } from '../entities/wishlist-item.entity';
+export declare class WishlistService {
+    private connection;
+    private listQueryBuilder;
+    private productVariantService;
+    constructor(connection: TransactionalConnection, listQueryBuilder: ListQueryBuilder, productVariantService: ProductVariantService);
+    findOne(ctx: RequestContext, id: ID): Promise<WishlistItem>;
+    findAllByCustomerId(ctx: RequestContext, customerId: ID, options?: ListQueryOptions<WishlistItem>): Promise<PaginatedList<WishlistItem>>;
+    create(ctx: RequestContext, customerId: ID, productVariantId: ID): Promise<WishlistItem>;
+    createMultiple(ctx: RequestContext, customerId: ID, productVariantIds: ID[]): Promise<WishlistItem[]>;
+    delete(ctx: RequestContext, customerId: ID, id?: ID | null, productVariantId?: ID | null): Promise<DeletionResponse>;
+    deleteMultiple(ctx: RequestContext, customerId: ID, productVariantIds: ID[]): Promise<DeletionResponse>;
+    isInWishlist(ctx: RequestContext, customerId: ID, productVariantId: ID): Promise<boolean>;
+}

package/dist/services/wishlist.service.js

@@ -0,0 +1,143 @@
+"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.WishlistService = void 0;
+const common_1 = require("@nestjs/common");
+const generated_types_1 = require("@vendure/common/lib/generated-types");
+const core_1 = require("@vendure/core");
+const typeorm_1 = require("typeorm");
+const wishlist_item_entity_1 = require("../entities/wishlist-item.entity");
+let WishlistService = class WishlistService {
+    constructor(connection, listQueryBuilder, productVariantService) {
+        this.connection = connection;
+        this.listQueryBuilder = listQueryBuilder;
+        this.productVariantService = productVariantService;
+    }
+    async findOne(ctx, id) {
+        return this.connection.getRepository(ctx, wishlist_item_entity_1.WishlistItem).findOneOrFail({
+            where: { id },
+            relations: ['productVariant', 'productVariant.featuredAsset'],
+        });
+    }
+    async findAllByCustomerId(ctx, customerId, options) {
+        return this.listQueryBuilder
+            .build(wishlist_item_entity_1.WishlistItem, options, {
+            ctx,
+            where: { customerId },
+            relations: ['productVariant', 'productVariant.featuredAsset'],
+        })
+            .getManyAndCount()
+            .then(([items, totalItems]) => ({
+            items,
+            totalItems,
+        }));
+    }
+    async create(ctx, customerId, productVariantId) {
+        const productVariant = await this.productVariantService.findOne(ctx, productVariantId);
+        if (!productVariant) {
+            throw new core_1.UserInputError('Product variant not found');
+        }
+        const existing = await this.connection.getRepository(ctx, wishlist_item_entity_1.WishlistItem).findOne({
+            where: { customerId, productVariantId },
+            relations: ['productVariant', 'productVariant.featuredAsset'],
+        });
+        if (existing) {
+            return existing;
+        }
+        const wishlistItem = new wishlist_item_entity_1.WishlistItem({ customerId, productVariant });
+        const saved = await this.connection.getRepository(ctx, wishlist_item_entity_1.WishlistItem).save(wishlistItem);
+        return (0, core_1.assertFound)(this.findOne(ctx, saved.id));
+    }
+    async createMultiple(ctx, customerId, productVariantIds) {
+        if (!productVariantIds.length) {
+            return [];
+        }
+        const repo = this.connection.getRepository(ctx, wishlist_item_entity_1.WishlistItem);
+        // Fetch existing items and product variants in parallel
+        const [existingItems, productVariants] = await Promise.all([
+            repo.find({
+                where: { customerId, productVariantId: (0, typeorm_1.In)(productVariantIds) },
+                relations: ['productVariant', 'productVariant.featuredAsset'],
+            }),
+            Promise.all(productVariantIds.map((id) => this.productVariantService.findOne(ctx, id))),
+        ]);
+        // Validate all variants exist
+        const missingIdx = productVariants.findIndex((pv) => !pv);
+        if (missingIdx !== -1) {
+            throw new core_1.UserInputError(`Product variant not found: ${productVariantIds[missingIdx]}`);
+        }
+        // Filter out already-existing ones
+        const existingVariantIds = new Set(existingItems.map((item) => String(item.productVariantId)));
+        const newItems = productVariants
+            .filter((pv) => !existingVariantIds.has(String(pv.id)))
+            .map((pv) => new wishlist_item_entity_1.WishlistItem({ customerId, productVariant: pv }));
+        if (newItems.length === 0) {
+            return existingItems;
+        }
+        // Bulk save and re-fetch with relations
+        const savedItems = await repo.save(newItems);
+        const newlyCreated = await repo.find({
+            where: { id: (0, typeorm_1.In)(savedItems.map((i) => i.id)) },
+            relations: ['productVariant', 'productVariant.featuredAsset'],
+        });
+        return [...existingItems, ...newlyCreated];
+    }
+    async delete(ctx, customerId, id, productVariantId) {
+        if (!id && !productVariantId) {
+            throw new core_1.UserInputError('Either id or productVariantId must be provided.');
+        }
+        const where = { customerId };
+        if (id)
+            where.id = id;
+        if (productVariantId)
+            where.productVariantId = productVariantId;
+        const entity = await this.connection.getRepository(ctx, wishlist_item_entity_1.WishlistItem).findOne({ where });
+        if (!entity) {
+            return { result: generated_types_1.DeletionResult.NOT_DELETED, message: 'Wishlist item not found' };
+        }
+        try {
+            await this.connection.getRepository(ctx, wishlist_item_entity_1.WishlistItem).remove(entity);
+            return { result: generated_types_1.DeletionResult.DELETED };
+        }
+        catch (e) {
+            return { result: generated_types_1.DeletionResult.NOT_DELETED, message: e.toString() };
+        }
+    }
+    async deleteMultiple(ctx, customerId, productVariantIds) {
+        if (!productVariantIds.length) {
+            throw new core_1.UserInputError('productVariantIds must be provided.');
+        }
+        try {
+            const result = await this.connection
+                .getRepository(ctx, wishlist_item_entity_1.WishlistItem)
+                .delete({ customerId, productVariantId: (0, typeorm_1.In)(productVariantIds) });
+            return {
+                result: (result.affected || 0) > 0 ? generated_types_1.DeletionResult.DELETED : generated_types_1.DeletionResult.NOT_DELETED,
+            };
+        }
+        catch (e) {
+            return { result: generated_types_1.DeletionResult.NOT_DELETED, message: e.toString() };
+        }
+    }
+    async isInWishlist(ctx, customerId, productVariantId) {
+        const count = await this.connection.getRepository(ctx, wishlist_item_entity_1.WishlistItem).count({
+            where: { customerId, productVariantId },
+        });
+        return count > 0;
+    }
+};
+exports.WishlistService = WishlistService;
+exports.WishlistService = WishlistService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.TransactionalConnection,
+        core_1.ListQueryBuilder,
+        core_1.ProductVariantService])
+], WishlistService);

package/dist/types.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Configuration options for WishlistPlugin.
+ * Currently empty — reserved for future options.
+ */
+export interface WishlistPluginOptions {
+}

package/dist/types.js

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

package/dist/wishlist.plugin.d.ts

@@ -0,0 +1,6 @@
+import { Type } from '@vendure/core';
+import { WishlistPluginOptions } from './types';
+export declare class WishlistPlugin {
+    static options: WishlistPluginOptions;
+    static init(options?: WishlistPluginOptions): Type<WishlistPlugin>;
+}

package/dist/wishlist.plugin.js

@@ -0,0 +1,39 @@
+"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 WishlistPlugin_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WishlistPlugin = void 0;
+const core_1 = require("@vendure/core");
+const api_extensions_1 = require("./api/api-extensions");
+const product_variant_entity_resolver_1 = require("./api/product-variant-entity.resolver");
+const wishlist_resolver_1 = require("./api/wishlist.resolver");
+const constants_1 = require("./constants");
+const wishlist_item_entity_1 = require("./entities/wishlist-item.entity");
+const wishlist_service_1 = require("./services/wishlist.service");
+let WishlistPlugin = WishlistPlugin_1 = class WishlistPlugin {
+    static init(options) {
+        this.options = options || {};
+        return WishlistPlugin_1;
+    }
+};
+exports.WishlistPlugin = WishlistPlugin;
+exports.WishlistPlugin = WishlistPlugin = WishlistPlugin_1 = __decorate([
+    (0, core_1.VendurePlugin)({
+        imports: [core_1.PluginCommonModule],
+        entities: [wishlist_item_entity_1.WishlistItem],
+        providers: [
+            { provide: constants_1.WISHLIST_PLUGIN_OPTIONS, useFactory: () => WishlistPlugin.options },
+            wishlist_service_1.WishlistService,
+        ],
+        shopApiExtensions: {
+            schema: api_extensions_1.shopApiExtensions,
+            resolvers: [wishlist_resolver_1.WishlistShopResolver, product_variant_entity_resolver_1.ProductVariantEntityResolver],
+        },
+        compatibility: '^3.0.0',
+    })
+], WishlistPlugin);

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@rahul_vendure/vendure-plugin-wishlist",
+  "version": "1.0.0",
+  "description": "Vendure plugin for customer wishlists with bulk add/remove support",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc -w",
+    "prepublishOnly": "npm run build"
+  },
+  "peerDependencies": {
+    "@vendure/core": "^3.0.0"
+  },
+  "dependencies": {
+    "graphql-tag": "^2.12.6"
+  },
+  "keywords": [
+    "vendure",
+    "vendure-plugin",
+    "wishlist",
+    "favorites"
+  ],
+  "license": "MIT"
+}