@rahul_vendure/vendure-plugin-channel-product-availability 0.0.0-stage → 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+## 1.0.0
+
+Initial release.
+
+### Added
+
+- `ProductChannelAvailability` entity: sparse per-(product, channel) overrides of `Product.enabled`, with a unique key, a lookup index and cascading foreign keys.
+- `ChannelProductAvailabilityMigration1792195200000`: an opt-in migration built from the entity metadata, so it works on any supported database.
+- `ChannelProductAvailabilityService`: the single source of truth for the rule. Reads are batched and cached per request; writes are idempotent and concurrency-safe.
+- Shop API enforcement for `products`, `product` and `Collection.productVariants`, applied in SQL so counts and pagination stay correct.
+- DefaultSearchPlugin index sync: overrides are applied when index rows are written and patched immediately when an override changes.
+- Purchasing of products that are globally disabled but enabled in a channel, via the shop `addItemToOrder` / `addItemsToOrder` and admin `addItemToDraftOrder` mutations.
+- `OrderInterceptor` that rejects adding, or increasing the quantity of, explicitly disabled products.
+- `OrderProcess` that blocks checkout while the cart still contains explicitly disabled products.
+- Admin API queries and mutations, with permission checks in the target channel.
+- `ProductChannelAvailabilityEvent`, plus clean-up of overrides when a product is deleted, a product is removed from a channel, or a channel is deleted.
+- React Dashboard block on the product detail page.
+- Tested on Vendure 3.6.1 and 3.8.0, each on Postgres and SQLite.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rahul Yadav
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,194 @@
-# Temporary Holding Version
+# @rahul_vendure/vendure-plugin-channel-product-availability
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Per-channel product availability for [Vendure](https://vendure.io). Enable a product in one channel and disable it in another, without touching the global `Product.enabled` flag. The rule is enforced in catalog queries, search, cart and checkout.
+
+| Store | Global `Product.enabled` | Override | Customers there… |
+|---|---|---|---|
+| Nepal | `true` | — | can find and buy it |
+| India | `true` | `false` | cannot find or buy it |
+| UK | `false` | `true` | can find and buy it |
+
+- **Explicit overrides always win.** No override means the global flag applies, exactly as in unmodified Vendure.
+- **Overrides are sparse.** No rows are created up front and nothing is back-filled.
+- **Native rules still apply.** An override never assigns a product to a channel and never bypasses variant `enabled`, stock, prices or channel membership.
+- **Standalone.** No other custom plugin is needed, and Vendure core is not modified.
+
+## Install
+
+```bash
+npm install @rahul_vendure/vendure-plugin-channel-product-availability
+```
+
+```ts
+import { ChannelProductAvailabilityPlugin } from '@rahul_vendure/vendure-plugin-channel-product-availability';
+
+export const config: VendureConfig = {
+    plugins: [
+        DefaultSearchPlugin.init({}),
+        ChannelProductAvailabilityPlugin.init({}),
+    ],
+};
+```
+
+### Database migration
+
+The plugin adds one table, `product_channel_availability`. If your project uses `synchronize: false`, pick **one** of the following:
+
+```ts
+// a) use the migration that ships with the plugin (works on Postgres, MySQL/MariaDB and SQLite,
+//    and with integer or UUID ids)
+import { ChannelProductAvailabilityMigration1792195200000 } from '@rahul_vendure/vendure-plugin-channel-product-availability';
+dbConnectionOptions: { migrations: [ChannelProductAvailabilityMigration1792195200000, /* yours */] }
+```
+
+```bash
+# b) generate your own
+npx vendure migrate
+```
+
+| Column | Notes |
+|---|---|
+| `id`, `createdAt`, `updatedAt` | standard Vendure entity columns |
+| `productId` | FK → `product.id`, `ON DELETE CASCADE` |
+| `channelId` | FK → `channel.id`, `ON DELETE CASCADE` |
+| `enabled` | the override value |
+
+Indexes: `UNIQUE (productId, channelId)` and `(channelId, enabled)`.
+
+### Dashboard
+
+The React Dashboard extension is discovered automatically through the plugin's `dashboard` metadata. It adds a **Channel availability** block to the product detail page. For each channel the product is assigned to, the block shows:
+
+- whether the product is available there
+- whether that comes from the global flag or from an override
+- buttons to enable, disable, or go back to the global flag (**Use global**)
+
+The block also warns when a product is disabled globally but explicitly enabled somewhere. Channels where the admin can't update show as read-only.
+
+The backend works without the Dashboard.
+
+## Options
+
+All options default to `true`.
+
+| Option | Effect when `true` |
+|---|---|
+| `enforceCatalog` | Shop API `products`, `product` and `Collection.productVariants` follow the channel rule |
+| `enableOverridePurchasing` | Products that are globally disabled but enabled in the channel can be added to carts (shop) and draft orders (admin) |
+| `syncDefaultSearchIndex` | Keeps the DefaultSearchPlugin index in sync with overrides |
+| `validateOnCheckout` | Blocks `ArrangingPayment` while the cart contains a product explicitly disabled in that channel |
+
+Explicitly disabled products are always rejected when adding to a cart, whatever the options say.
+
+## Admin API
+
+```graphql
+query {
+  productChannelAvailability(productId: "1", channelId: "2") {   # channelId defaults to the active channel
+    channelCode globalEnabled override overrideState effectiveEnabled productInChannel
+  }
+  productChannelAvailabilities(productId: "1") { channelCode overrideState effectiveEnabled }
+  productChannelAvailabilityOverrides(options: { channelId: "2", enabled: false }) {
+    items { productId enabled } totalItems
+  }
+}
+
+mutation {
+  setProductChannelAvailability(input: { productId: "1", channelId: "2", enabled: true }) { effectiveEnabled }
+  clearProductChannelAvailability(input: { productId: "1", channelId: "2" }) { overrideState }   # → INHERITED
+}
+```
+
+**Permissions.** Reads need `ReadCatalog` or `ReadProduct`; writes need `UpdateCatalog` or `UpdateProduct`. The check is made in the **target** channel, not only the active one, so an admin of channel A can't change channel B by passing its `channelId`.
+
+**Validation.** Setting an override on a product that isn't assigned to the channel fails with a clear error. The plugin never assigns products to channels.
+
+## Using the service
+
+`ChannelProductAvailabilityService` is the single source of truth for the rule, and it's exported for your own code:
+
+```ts
+constructor(private availability: ChannelProductAvailabilityService) {}
+
+await this.availability.isEnabled(ctx, productId);              // active channel
+await this.availability.getAvailability(ctx, productId);        // full detail
+await this.availability.getAvailabilityForChannel(ctx, productId, channelId);
+await this.availability.getOverrides(ctx, productIds);          // batched, Map<productId, boolean>
+await this.availability.setOverride(ctx, productId, true, channelId);
+await this.availability.clearOverride(ctx, productId, channelId);
+await this.availability.getEffectiveEnabledProductFilter(ctx);  // ListQueryBuilder filter for custom queries
+```
+
+Behaviour:
+
+- Writes run in the caller's transaction and are idempotent: writing the current value is a no-op.
+- Concurrent writers can't create duplicate rows; the unique key plus an upsert prevents it.
+- Reads are batched and cached for the rest of the request.
+
+### Events
+
+The plugin publishes `ProductChannelAvailabilityEvent` after the transaction commits. Its `type` is one of:
+
+| Type | When |
+|---|---|
+| `set` | an override was created or changed |
+| `cleared` | an override was removed (the product inherits the global flag again) |
+| `removed` | an override was cleaned up because the product was deleted, the product was removed from the channel, or the channel was deleted |
+| `global-changed` | `Product.enabled` changed; `channelId` is `null` |
+
+## Search integration contract
+
+**DefaultSearchPlugin** is supported out of the box. Its index has one row per (variant, channel, language), and the plugin keeps the `enabled` column correct in two ways:
+
+- when you change an override, it patches the existing rows immediately in the same transaction
+- whenever the indexer writes rows, it corrects them as they're written
+
+As a result, results, `totalItems`, pagination and facet counts are all correct.
+
+**Other search plugins** (Elasticsearch, Meilisearch, Typesense, etc.) need to do three things:
+
+1. Index availability **per channel**. For a variant in channel C:
+   ```ts
+   const overrides = await availabilityService.getOverrides(ctx /* channel C */, productIds);
+   const productEnabled = resolveEffectiveEnabled(product.enabled, overrides.get(String(product.id)));
+   const indexedEnabled = productEnabled && variant.enabled;
+   ```
+2. Reindex `productId` when `ProductChannelAvailabilityEvent` fires. Reindex it in `channelId`, or in every channel when `channelId` is `null`.
+3. Filter on the indexed per-channel flag **in the search engine query**. Filtering results after pagination gives wrong counts.
+
+## Limitations
+
+- **Guest-cart merge at login.** Vendure's `OrderService.mergeOrders` calls core `addItemsToOrder` directly, and plugins can't override that. Suppose a customer adds a product that is *globally disabled but enabled in this channel* to a guest cart, then logs in while they already have an active cart. Core's merge rejects that line, the same way core treats any globally disabled product. Products that are globally enabled are not affected.
+- **Changes during payment.** A product disabled *after* the order reached `ArrangingPayment` is not blocked at payment time; core does the same for globally disabled products.
+- **Admin `modifyOrder`.** Core doesn't check `enabled` when an admin modifies a placed order, and the plugin keeps that behaviour.
+- **Resolver overrides.** The plugin overrides these Shop API resolvers, using the override mechanism documented by Vendure: `products`, `product`, `Collection.productVariants`, `addItemToOrder` and `addItemsToOrder`. It also overrides the Admin API `addItemToDraftOrder`. Another plugin overriding the same fields would conflict. In that case, turn off `enforceCatalog` and/or `enableOverridePurchasing` and call `ChannelProductAvailabilityService` from your own resolver.
+- **Large override sets.** Product lists filter with `id IN (...)` on the overridden ids for the channel, which is fine for thousands of overrides per channel. Overrides are meant to be exceptions, not the norm.
+- **Interceptors called twice.** When an override-enabled product (globally disabled) is added, third-party `OrderInterceptor`s receive both `willAddItemToOrder` and `willAdjustOrderLine`.
+
+## Compatibility
+
+| Vendure | Database | Status |
+|---|---|---|
+| 3.8.0 | Postgres 14+ | ✅ 66/66 tests pass |
+| 3.8.0 | SQLite (sql.js) | ✅ 66/66 tests pass |
+| 3.6.1 | Postgres 14+ | ✅ 66/66 tests pass |
+| 3.6.1 | SQLite (sql.js) | ✅ 66/66 tests pass |
+| 3.7.x | — | expected to work, not tested |
+| MySQL / MariaDB | — | migration is database-agnostic; not tested |
+
+Peer dependency: `@vendure/core ^3.6.0`. Run the suite against any release with `./scripts/test-against-vendure.sh <version>`.
+
+## Development
+
+```bash
+npm run build                 # codegen + compile to dist/
+npm test                      # unit + e2e (sql.js)
+npm run test:e2e:postgres     # e2e on a real Postgres (PGHOST/PGUSER/PGPASSWORD)
+./scripts/test-against-vendure.sh 3.8.0
+```
+
+See [ARCHITECTURE.md](./ARCHITECTURE.md) for every core code path involved and the extension point used for each.
+
+## License
+
+MIT

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

@@ -0,0 +1,18 @@
+import { RequestContext, TransactionalConnection } from '@vendure/core';
+import { MutationClearProductChannelAvailabilityArgs, MutationSetProductChannelAvailabilityArgs, QueryProductChannelAvailabilitiesArgs, QueryProductChannelAvailabilityArgs, QueryProductChannelAvailabilityOverridesArgs } from '../generated-graphql-types';
+import { ChannelAccessService } from '../services/channel-access.service';
+import { ChannelProductAvailabilityService } from '../services/channel-product-availability.service';
+export declare class ChannelProductAvailabilityAdminResolver {
+    private availabilityService;
+    private channelAccess;
+    private connection;
+    constructor(availabilityService: ChannelProductAvailabilityService, channelAccess: ChannelAccessService, connection: TransactionalConnection);
+    productChannelAvailability(ctx: RequestContext, args: QueryProductChannelAvailabilityArgs): Promise<import("../services/channel-product-availability.service").ProductChannelAvailabilityResult>;
+    productChannelAvailabilities(ctx: RequestContext, args: QueryProductChannelAvailabilitiesArgs): Promise<import("../services/channel-product-availability.service").ProductChannelAvailabilityResult[]>;
+    productChannelAvailabilityOverrides(ctx: RequestContext, args: QueryProductChannelAvailabilityOverridesArgs): Promise<{
+        items: import("..").ProductChannelAvailability[];
+        totalItems: number;
+    }>;
+    setProductChannelAvailability(ctx: RequestContext, args: MutationSetProductChannelAvailabilityArgs): Promise<import("../services/channel-product-availability.service").ProductChannelAvailabilityResult>;
+    clearProductChannelAvailability(ctx: RequestContext, args: MutationClearProductChannelAvailabilityArgs): Promise<import("../services/channel-product-availability.service").ProductChannelAvailabilityResult>;
+}

package/dist/api/admin.resolver.js

@@ -0,0 +1,118 @@
+"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.ChannelProductAvailabilityAdminResolver = void 0;
+const graphql_1 = require("@nestjs/graphql");
+const core_1 = require("@vendure/core");
+const channel_access_service_1 = require("../services/channel-access.service");
+const channel_product_availability_service_1 = require("../services/channel-product-availability.service");
+let ChannelProductAvailabilityAdminResolver = class ChannelProductAvailabilityAdminResolver {
+    constructor(availabilityService, channelAccess, connection) {
+        this.availabilityService = availabilityService;
+        this.channelAccess = channelAccess;
+        this.connection = connection;
+    }
+    async productChannelAvailability(ctx, args) {
+        var _a;
+        const channelId = (_a = args.channelId) !== null && _a !== void 0 ? _a : ctx.channelId;
+        this.channelAccess.assertPermissionInChannel(ctx, channelId, channel_access_service_1.READ_PERMISSIONS);
+        return this.availabilityService.getAvailabilityForChannel(ctx, args.productId, channelId);
+    }
+    async productChannelAvailabilities(ctx, args) {
+        const product = await this.connection.getEntityOrThrow(ctx, core_1.Product, args.productId, {
+            relations: ['channels'],
+            loadEagerRelations: false,
+        });
+        const readable = new Set(this.channelAccess.channelIdsWithPermission(ctx, channel_access_service_1.READ_PERMISSIONS));
+        const channelIds = product.channels.map(c => c.id).filter(id => readable.has(String(id)));
+        return this.availabilityService.getAvailabilityForChannels(ctx, product.id, channelIds);
+    }
+    async productChannelAvailabilityOverrides(ctx, args) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        const channelId = (_b = (_a = args.options) === null || _a === void 0 ? void 0 : _a.channelId) !== null && _b !== void 0 ? _b : ctx.channelId;
+        this.channelAccess.assertPermissionInChannel(ctx, channelId, channel_access_service_1.READ_PERMISSIONS);
+        return this.availabilityService.listOverrides(ctx, channelId, {
+            productId: (_d = (_c = args.options) === null || _c === void 0 ? void 0 : _c.productId) !== null && _d !== void 0 ? _d : undefined,
+            enabled: (_f = (_e = args.options) === null || _e === void 0 ? void 0 : _e.enabled) !== null && _f !== void 0 ? _f : undefined,
+            skip: (_h = (_g = args.options) === null || _g === void 0 ? void 0 : _g.skip) !== null && _h !== void 0 ? _h : undefined,
+            take: (_k = (_j = args.options) === null || _j === void 0 ? void 0 : _j.take) !== null && _k !== void 0 ? _k : undefined,
+        });
+    }
+    async setProductChannelAvailability(ctx, args) {
+        var _a;
+        const channelId = (_a = args.input.channelId) !== null && _a !== void 0 ? _a : ctx.channelId;
+        this.channelAccess.assertPermissionInChannel(ctx, channelId, channel_access_service_1.UPDATE_PERMISSIONS);
+        return this.availabilityService.setOverride(ctx, args.input.productId, args.input.enabled, channelId);
+    }
+    async clearProductChannelAvailability(ctx, args) {
+        var _a;
+        const channelId = (_a = args.input.channelId) !== null && _a !== void 0 ? _a : ctx.channelId;
+        this.channelAccess.assertPermissionInChannel(ctx, channelId, channel_access_service_1.UPDATE_PERMISSIONS);
+        return this.availabilityService.clearOverride(ctx, args.input.productId, channelId);
+    }
+};
+exports.ChannelProductAvailabilityAdminResolver = ChannelProductAvailabilityAdminResolver;
+__decorate([
+    (0, graphql_1.Query)(),
+    (0, core_1.Allow)(...channel_access_service_1.READ_PERMISSIONS),
+    __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)
+], ChannelProductAvailabilityAdminResolver.prototype, "productChannelAvailability", null);
+__decorate([
+    (0, graphql_1.Query)(),
+    (0, core_1.Allow)(...channel_access_service_1.READ_PERMISSIONS),
+    __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)
+], ChannelProductAvailabilityAdminResolver.prototype, "productChannelAvailabilities", null);
+__decorate([
+    (0, graphql_1.Query)(),
+    (0, core_1.Allow)(...channel_access_service_1.READ_PERMISSIONS),
+    __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)
+], ChannelProductAvailabilityAdminResolver.prototype, "productChannelAvailabilityOverrides", null);
+__decorate([
+    (0, core_1.Transaction)(),
+    (0, graphql_1.Mutation)(),
+    (0, core_1.Allow)(...channel_access_service_1.UPDATE_PERMISSIONS),
+    __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)
+], ChannelProductAvailabilityAdminResolver.prototype, "setProductChannelAvailability", null);
+__decorate([
+    (0, core_1.Transaction)(),
+    (0, graphql_1.Mutation)(),
+    (0, core_1.Allow)(...channel_access_service_1.UPDATE_PERMISSIONS),
+    __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)
+], ChannelProductAvailabilityAdminResolver.prototype, "clearProductChannelAvailability", null);
+exports.ChannelProductAvailabilityAdminResolver = ChannelProductAvailabilityAdminResolver = __decorate([
+    (0, graphql_1.Resolver)(),
+    __metadata("design:paramtypes", [channel_product_availability_service_1.ChannelProductAvailabilityService,
+        channel_access_service_1.ChannelAccessService,
+        core_1.TransactionalConnection])
+], ChannelProductAvailabilityAdminResolver);

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

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

package/dist/api/api-extensions.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adminApiExtensions = void 0;
+const graphql_tag_1 = __importDefault(require("graphql-tag"));
+exports.adminApiExtensions = (0, graphql_tag_1.default) `
+    """
+    INHERITED: no override, the global Product.enabled applies.
+    ENABLED / DISABLED: explicit channel override, takes precedence over Product.enabled.
+    """
+    enum ProductChannelAvailabilityOverrideState {
+        INHERITED
+        ENABLED
+        DISABLED
+    }
+
+    type ProductChannelAvailability {
+        productId: ID!
+        channelId: ID!
+        channelCode: String!
+        "The global Product.enabled value."
+        globalEnabled: Boolean!
+        "The explicit override for this channel, or null when inherited."
+        override: Boolean
+        overrideState: ProductChannelAvailabilityOverrideState!
+        "What the storefront and checkout enforce in this channel."
+        effectiveEnabled: Boolean!
+        productInChannel: Boolean!
+        updatedAt: DateTime
+    }
+
+    type ProductChannelAvailabilityOverride {
+        id: ID!
+        createdAt: DateTime!
+        updatedAt: DateTime!
+        productId: ID!
+        channelId: ID!
+        enabled: Boolean!
+    }
+
+    type ProductChannelAvailabilityOverrideList {
+        items: [ProductChannelAvailabilityOverride!]!
+        totalItems: Int!
+    }
+
+    input ProductChannelAvailabilityOverrideListOptions {
+        "Defaults to the active channel."
+        channelId: ID
+        productId: ID
+        enabled: Boolean
+        skip: Int
+        take: Int
+    }
+
+    input SetProductChannelAvailabilityInput {
+        productId: ID!
+        "Defaults to the active channel."
+        channelId: ID
+        enabled: Boolean!
+    }
+
+    input ClearProductChannelAvailabilityInput {
+        productId: ID!
+        "Defaults to the active channel."
+        channelId: ID
+    }
+
+    extend type Query {
+        "Availability of a product in one channel (default: the active channel)."
+        productChannelAvailability(productId: ID!, channelId: ID): ProductChannelAvailability!
+        "Availability of a product in every channel it is assigned to that the current administrator can read."
+        productChannelAvailabilities(productId: ID!): [ProductChannelAvailability!]!
+        "Explicit overrides in a channel (default: the active channel)."
+        productChannelAvailabilityOverrides(
+            options: ProductChannelAvailabilityOverrideListOptions
+        ): ProductChannelAvailabilityOverrideList!
+    }
+
+    extend type Mutation {
+        "Sets an explicit override. Does not change Product.enabled or channel assignment."
+        setProductChannelAvailability(input: SetProductChannelAvailabilityInput!): ProductChannelAvailability!
+        "Removes the override so the product inherits Product.enabled again."
+        clearProductChannelAvailability(input: ClearProductChannelAvailabilityInput!): ProductChannelAvailability!
+    }
+`;

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

@@ -0,0 +1,25 @@
+import { ActiveOrderService, Order, RelationPaths, RequestContext } from '@vendure/core';
+import { OverridePurchaseService } from '../order/override-purchase.service';
+/**
+ * Overrides the Shop API add-to-cart mutations. Same decorators and semantics as
+ * core; items whose product is globally disabled but explicitly enabled in the
+ * channel are routed around core's hard `product.enabled` check.
+ */
+export declare class ShopOrderAvailabilityResolver {
+    private activeOrderService;
+    private purchaseService;
+    constructor(activeOrderService: ActiveOrderService, purchaseService: OverridePurchaseService);
+    addItemToOrder(ctx: RequestContext, args: any, relations: RelationPaths<Order>): Promise<import("../order/override-purchase.service").OrderErrorResult | Order>;
+    addItemsToOrder(ctx: RequestContext, args: any): Promise<{
+        order: Order;
+        errorResults: import("../order/override-purchase.service").OrderErrorResult[];
+    }>;
+}
+/**
+ * Overrides the Admin API `addItemToDraftOrder` mutation with the same routing.
+ */
+export declare class AdminDraftOrderAvailabilityResolver {
+    private purchaseService;
+    constructor(purchaseService: OverridePurchaseService);
+    addItemToDraftOrder(ctx: RequestContext, args: any): Promise<import("../order/override-purchase.service").OrderErrorResult | Order>;
+}

package/dist/api/order.resolver.js

@@ -0,0 +1,96 @@
+"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.AdminDraftOrderAvailabilityResolver = exports.ShopOrderAvailabilityResolver = void 0;
+const graphql_1 = require("@nestjs/graphql");
+const core_1 = require("@vendure/core");
+const override_purchase_service_1 = require("../order/override-purchase.service");
+/**
+ * Overrides the Shop API add-to-cart mutations. Same decorators and semantics as
+ * core; items whose product is globally disabled but explicitly enabled in the
+ * channel are routed around core's hard `product.enabled` check.
+ */
+let ShopOrderAvailabilityResolver = class ShopOrderAvailabilityResolver {
+    constructor(activeOrderService, purchaseService) {
+        this.activeOrderService = activeOrderService;
+        this.purchaseService = purchaseService;
+    }
+    async addItemToOrder(ctx, args, relations) {
+        const order = await this.activeOrderService.getActiveOrder(ctx, args[core_1.ACTIVE_ORDER_INPUT_FIELD_NAME], true);
+        return this.purchaseService.addItemToOrder(ctx, order.id, { productVariantId: args.productVariantId, quantity: args.quantity, customFields: args.customFields }, relations);
+    }
+    async addItemsToOrder(ctx, args) {
+        const order = await this.activeOrderService.getActiveOrder(ctx, args[core_1.ACTIVE_ORDER_INPUT_FIELD_NAME], true);
+        const result = await this.purchaseService.addItemsToOrder(ctx, order.id, args.inputs);
+        return { order: result.order, errorResults: result.errorResults };
+    }
+};
+exports.ShopOrderAvailabilityResolver = ShopOrderAvailabilityResolver;
+__decorate([
+    (0, core_1.Transaction)(),
+    (0, graphql_1.Mutation)(),
+    (0, core_1.Allow)(core_1.Permission.UpdateOrder, core_1.Permission.Owner),
+    __param(0, (0, core_1.Ctx)()),
+    __param(1, (0, graphql_1.Args)()),
+    __param(2, (0, core_1.Relations)({ entity: core_1.Order, omit: ['aggregateOrder', 'sellerOrders'] })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext, Object, Array]),
+    __metadata("design:returntype", Promise)
+], ShopOrderAvailabilityResolver.prototype, "addItemToOrder", null);
+__decorate([
+    (0, core_1.Transaction)(),
+    (0, graphql_1.Mutation)(),
+    (0, core_1.Allow)(core_1.Permission.UpdateOrder, 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)
+], ShopOrderAvailabilityResolver.prototype, "addItemsToOrder", null);
+exports.ShopOrderAvailabilityResolver = ShopOrderAvailabilityResolver = __decorate([
+    (0, graphql_1.Resolver)(),
+    __metadata("design:paramtypes", [core_1.ActiveOrderService,
+        override_purchase_service_1.OverridePurchaseService])
+], ShopOrderAvailabilityResolver);
+/**
+ * Overrides the Admin API `addItemToDraftOrder` mutation with the same routing.
+ */
+let AdminDraftOrderAvailabilityResolver = class AdminDraftOrderAvailabilityResolver {
+    constructor(purchaseService) {
+        this.purchaseService = purchaseService;
+    }
+    async addItemToDraftOrder(ctx, args) {
+        const { orderId, input } = args;
+        return this.purchaseService.addItemToOrder(ctx, orderId, {
+            productVariantId: input.productVariantId,
+            quantity: input.quantity,
+            customFields: input.customFields,
+        });
+    }
+};
+exports.AdminDraftOrderAvailabilityResolver = AdminDraftOrderAvailabilityResolver;
+__decorate([
+    (0, core_1.Transaction)(),
+    (0, graphql_1.Mutation)(),
+    (0, core_1.Allow)(core_1.Permission.CreateOrder),
+    __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)
+], AdminDraftOrderAvailabilityResolver.prototype, "addItemToDraftOrder", null);
+exports.AdminDraftOrderAvailabilityResolver = AdminDraftOrderAvailabilityResolver = __decorate([
+    (0, graphql_1.Resolver)(),
+    __metadata("design:paramtypes", [override_purchase_service_1.OverridePurchaseService])
+], AdminDraftOrderAvailabilityResolver);

package/dist/api/shop-catalog.resolver.d.ts

@@ -0,0 +1,34 @@
+import { ApiType, Collection, Product, ProductService, ProductVariant, ProductVariantService, RelationPaths, RequestContext, TransactionalConnection } from '@vendure/core';
+import { ChannelProductAvailabilityService } from '../services/channel-product-availability.service';
+/**
+ * Overrides the Shop API `products` and `product` queries. Identical to core except
+ * that the `enabled` guard is replaced by the channel-aware rule, applied in SQL so
+ * that counts and pagination stay correct.
+ */
+export declare class ShopCatalogAvailabilityResolver {
+    private productService;
+    private availabilityService;
+    constructor(productService: ProductService, availabilityService: ChannelProductAvailabilityService);
+    products(ctx: RequestContext, args: any, relations: RelationPaths<Product>): Promise<import("@vendure/core").PaginatedList<import("@vendure/core").Translated<Product>>>;
+    product(ctx: RequestContext, args: {
+        id?: string;
+        slug?: string;
+    }, relations: RelationPaths<Product>): Promise<Product | undefined>;
+}
+/**
+ * Overrides `Collection.productVariants` in the Shop API so that variants of
+ * products explicitly enabled in the channel are listed, and variants of products
+ * explicitly disabled are not. The Admin API delegates to core unchanged.
+ */
+export declare class ShopCollectionAvailabilityResolver {
+    private productVariantService;
+    private connection;
+    constructor(productVariantService: ProductVariantService, connection: TransactionalConnection);
+    productVariants(ctx: RequestContext, collection: Collection, args: any, apiType: ApiType, relations: RelationPaths<ProductVariant>): Promise<import("@vendure/core").PaginatedList<import("@vendure/core").Translated<ProductVariant>>>;
+    /**
+     * Products with variants in the collection that are effectively disabled in the
+     * active channel: globally disabled without an enabling override, or explicitly
+     * disabled.
+     */
+    private getEffectivelyDisabledProductIds;
+}