@reactionary/bazaarvoice 0.9.16

package/README.md

@@ -0,0 +1,41 @@
+# @reactionary/bazaarvoice
+
+Bazaarvoice Conversations REST API v5 adapter for `@reactionary/core`.
+
+Implements `ProductReviewsCapability` — ratings summaries, paginated review lists, and review submission — by calling the Bazaarvoice Conversations REST API directly using passKey authentication.
+
+## Usage
+
+```typescript
+import { withBazaarvoiceCapabilities } from '@reactionary/bazaarvoice';
+
+const getCapabilities = withBazaarvoiceCapabilities(
+  {
+    passKey: process.env.BV_PASS_KEY!,
+    // apiUrl: 'https://api.bazaarvoice.com',  // production (default)
+    // apiUrl: 'https://stg.api.bazaarvoice.com', // staging
+  },
+  {
+    productReviews: { enabled: true },
+  },
+);
+
+// In a request handler:
+const capabilities = getCapabilities(cache, requestContext);
+const summary = await capabilities.productReviews.getRatingSummary({ product: { key: 'MY-PRODUCT-001' } });
+```
+
+## Configuration
+
+| Field        | Type     | Default                       | Description                                         |
+| ------------ | -------- | ----------------------------- | --------------------------------------------------- |
+| `passKey`    | `string` | required                      | Bazaarvoice API passkey                             |
+| `apiUrl`     | `string` | `https://api.bazaarvoice.com` | Base API URL; use staging URL for test environments |
+| `apiVersion` | `string` | `5.4`                         | Conversations API version                           |
+| `locale`     | `string` | `en_US`                       | BCP47-style locale passed to BV API                 |
+
+## Notes
+
+- **Passkey scope**: Bazaarvoice may issue separate read and write passkeys. Ensure the passkey configured is write-enabled if `submitReview` is used.
+- **Product ID alignment**: The `product.key` in queries must match the Bazaarvoice product ID (typically the same as the HCL `partNumber`).
+- **Review moderation**: Submitted reviews enter the Bazaarvoice moderation queue and will not be immediately visible.

package/capabilities/index.js

@@ -0,0 +1 @@
+export * from "./product-reviews.capability.js";

package/capabilities/product-reviews.capability.js

@@ -0,0 +1,152 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import {
+  ProductReviewPaginatedResultSchema,
+  ProductRatingSummarySchema,
+  ProductReviewSchema,
+  ProductReviewsCapability,
+  Reactionary,
+  error,
+  success
+} from "@reactionary/core";
+import {
+  BvReviewsResponseSchema,
+  BvStatisticsResponseSchema,
+  BvSubmitReviewResponseSchema
+} from "../schema/bazaarvoice.schema.js";
+class BazaarvoiceProductReviewsCapability extends ProductReviewsCapability {
+  constructor(cache, context, config, client, factory) {
+    super(cache, context);
+    this.config = config;
+    this.client = client;
+    this.factory = factory;
+  }
+  async getRatingSummary(query) {
+    const response = await this.client.callGet(
+      this.getStatisticsUrl(),
+      this.getStatisticsParams(query.product.key),
+      BvStatisticsResponseSchema
+    );
+    if (response.HasErrors || response.Results.length === 0) {
+      return success(
+        this.createEmptyProductRatingSummary({
+          product: query.product
+        })
+      );
+    }
+    return success(this.factory.parseRatingSummary(this.context, response));
+  }
+  async findReviews(query) {
+    const pageSize = query.paginationOptions?.pageSize ?? 10;
+    const pageNumber = query.paginationOptions?.pageNumber ?? 1;
+    const offset = (pageNumber - 1) * pageSize;
+    const response = await this.client.callGet(
+      this.getReviewsUrl(),
+      this.getReviewsParams(query.product.key, pageSize, offset),
+      BvReviewsResponseSchema
+    );
+    return success(
+      this.factory.parseReviewPaginatedResult(this.context, {
+        ...response,
+        Limit: pageSize,
+        Offset: offset
+      })
+    );
+  }
+  async submitReview(mutation) {
+    if (this.context.session.identityContext.identity.type !== "Registered") {
+      return error({
+        type: "InvalidInput",
+        error: "Only registered users can submit reviews."
+      });
+    }
+    const response = await this.client.callPost(
+      this.getSubmitReviewUrl(),
+      this.getSubmitReviewBody(mutation),
+      BvSubmitReviewResponseSchema
+    );
+    if (response.HasErrors || !response.Review) {
+      const fieldErrors = response.FormErrors?.FieldErrors ? Object.values(response.FormErrors.FieldErrors).map((e) => e.Message).join("; ") : response.Errors?.[0]?.Message ?? "Review submission failed.";
+      return error({
+        type: "InvalidInput",
+        error: fieldErrors
+      });
+    }
+    return success(this.factory.parseReview(this.context, response.Review));
+  }
+  // ---------------------------------------------------------------------------
+  // Extension points — override in subclasses to customise API calls
+  // ---------------------------------------------------------------------------
+  getStatisticsUrl() {
+    return `${this.client.baseUrl}/data/statistics.json`;
+  }
+  getStatisticsParams(productId) {
+    const params = new URLSearchParams();
+    params.set("Filter", `ProductId:eq:${productId}`);
+    params.set("stats", "Reviews");
+    return params;
+  }
+  getReviewsUrl() {
+    return `${this.client.baseUrl}/data/reviews.json`;
+  }
+  getReviewsParams(productId, limit, offset) {
+    const params = new URLSearchParams();
+    params.set("Filter", `ProductId:eq:${productId}`);
+    params.set("Limit", String(limit));
+    params.set("Offset", String(offset));
+    params.set("Sort", "SubmissionTime:desc");
+    return params;
+  }
+  getSubmitReviewUrl() {
+    return `${this.client.baseUrl}/data/submitreview.json`;
+  }
+  getSubmitReviewBody(mutation) {
+    const body = new URLSearchParams();
+    body.set("Action", "Submit");
+    body.set("ProductId", mutation.product.key);
+    body.set("Rating", String(mutation.rating));
+    body.set("Title", mutation.title);
+    body.set("ReviewText", mutation.content);
+    body.set("UserNickname", mutation.authorName);
+    return body;
+  }
+}
+__decorateClass([
+  Reactionary({
+    outputSchema: ProductRatingSummarySchema,
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false
+  })
+], BazaarvoiceProductReviewsCapability.prototype, "getRatingSummary", 1);
+__decorateClass([
+  Reactionary({
+    outputSchema: ProductReviewPaginatedResultSchema,
+    cache: true,
+    cacheTimeToLiveInSeconds: 60,
+    currencyDependentCaching: false,
+    localeDependentCaching: false
+  })
+], BazaarvoiceProductReviewsCapability.prototype, "findReviews", 1);
+__decorateClass([
+  Reactionary({
+    outputSchema: ProductReviewSchema,
+    cache: false,
+    cacheTimeToLiveInSeconds: 0,
+    currencyDependentCaching: false,
+    localeDependentCaching: false
+  })
+], BazaarvoiceProductReviewsCapability.prototype, "submitReview", 1);
+export {
+  BazaarvoiceProductReviewsCapability
+};

package/core/client.js

@@ -0,0 +1,73 @@
+class BazaarvoiceClient {
+  constructor(config, context) {
+    this.config = config;
+    this.context = context;
+    this.baseUrl = config.apiUrl.replace(/\/+$/, "");
+  }
+  /** Base API URL, e.g. https://api.bazaarvoice.com */
+  baseUrl;
+  async callGet(url, params, schema) {
+    const merged = this.buildParams(params);
+    const query = merged.toString() ? `?${merged.toString()}` : "";
+    const response = await fetch(`${url}${query}`);
+    if (!response.ok) {
+      throw new Error(
+        `Bazaarvoice GET ${url} error ${response.status} ${response.statusText}`
+      );
+    }
+    const json = await response.json();
+    return schema.parse(json);
+  }
+  async callPost(url, body, schema) {
+    const merged = this.buildBody(body);
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: merged.toString()
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Bazaarvoice POST ${url} error ${response.status} ${response.statusText}`
+      );
+    }
+    const json = await response.json();
+    return schema.parse(json);
+  }
+  /**
+   * Merges caller-supplied params with the default BV params (passKey,
+   * apiVersion, Locale). Caller-supplied values always win.
+   */
+  buildParams(params) {
+    const merged = new URLSearchParams(params);
+    if (!merged.has("passKey"))
+      merged.set("passKey", this.config.passKey);
+    if (!merged.has("apiVersion"))
+      merged.set("apiVersion", this.config.apiVersion);
+    if (!merged.has("Locale"))
+      merged.set("Locale", this.bvLocale());
+    return merged;
+  }
+  /**
+   * Merges caller-supplied POST body with the default BV fields (passKey,
+   * apiVersion, Locale). Caller-supplied values always win.
+   */
+  buildBody(body) {
+    const merged = new URLSearchParams(body);
+    if (!merged.has("passKey"))
+      merged.set("passKey", this.config.passKey);
+    if (!merged.has("apiVersion"))
+      merged.set("apiVersion", this.config.apiVersion);
+    if (!merged.has("Locale"))
+      merged.set("Locale", this.bvLocale());
+    return merged;
+  }
+  /**
+   * Converts a BCP 47 locale (e.g. `en-US`) to BV's expected `en_US` format.
+   */
+  bvLocale() {
+    return this.context.languageContext.locale.replace("-", "_");
+  }
+}
+export {
+  BazaarvoiceClient
+};

package/core/initialize.js

@@ -0,0 +1,51 @@
+import {
+  ProductRatingSummarySchema,
+  ProductReviewPaginatedResultSchema,
+  ProductReviewSchema
+} from "@reactionary/core";
+import { BazaarvoiceProductReviewsCapability } from "../capabilities/product-reviews.capability.js";
+import { BazaarvoiceProductReviewsFactory } from "../factories/product-reviews/product-reviews.factory.js";
+import { BazaarvoiceCapabilitiesSchema } from "../schema/capabilities.schema.js";
+import { BazaarvoiceConfigurationSchema } from "../schema/configuration.schema.js";
+import { BazaarvoiceClient } from "./client.js";
+import {
+  resolveCapabilityWithFactory
+} from "./initialize.types.js";
+function withBazaarvoiceCapabilities(configuration, capabilities) {
+  return (cache, context) => {
+    const client = {};
+    const config = BazaarvoiceConfigurationSchema.parse(configuration);
+    const caps = BazaarvoiceCapabilitiesSchema.parse(capabilities);
+    const bvClient = new BazaarvoiceClient(config, context);
+    if (caps.productReviews?.enabled) {
+      client.productReviews = resolveCapabilityWithFactory(
+        capabilities.productReviews,
+        {
+          factory: new BazaarvoiceProductReviewsFactory(
+            ProductRatingSummarySchema,
+            ProductReviewSchema,
+            ProductReviewPaginatedResultSchema
+          ),
+          capability: (args) => new BazaarvoiceProductReviewsCapability(
+            args.cache,
+            args.context,
+            args.config,
+            args.client,
+            args.factory
+          )
+        },
+        (factory) => ({
+          cache,
+          context,
+          config,
+          client: bvClient,
+          factory
+        })
+      );
+    }
+    return client;
+  };
+}
+export {
+  withBazaarvoiceCapabilities
+};

package/core/initialize.types.js

@@ -0,0 +1,8 @@
+function resolveCapabilityWithFactory(capability, defaults, buildCapabilityArgs) {
+  const factory = capability?.factory ?? defaults.factory;
+  const capabilityFactory = capability?.capability ?? defaults.capability;
+  return capabilityFactory(buildCapabilityArgs(factory));
+}
+export {
+  resolveCapabilityWithFactory
+};

package/factories/index.js

@@ -0,0 +1 @@
+export * from "./product-reviews/product-reviews.factory.js";

package/factories/product-reviews/product-reviews.factory.js

@@ -0,0 +1,65 @@
+class BazaarvoiceProductReviewsFactory {
+  constructor(ratingSummarySchema, reviewSchema, reviewPaginatedSchema) {
+    this.ratingSummarySchema = ratingSummarySchema;
+    this.reviewSchema = reviewSchema;
+    this.reviewPaginatedSchema = reviewPaginatedSchema;
+  }
+  parseRatingSummary(_context, data) {
+    const result = data.Results[0];
+    const stats = result?.ProductStatistics?.ReviewStatistics;
+    if (!result || !stats) {
+      return this.ratingSummarySchema.parse({
+        identifier: { product: { key: "" } },
+        averageRating: 0,
+        totalRatings: void 0,
+        ratingDistribution: void 0
+      });
+    }
+    const distribution = stats.RatingDistribution ? Object.fromEntries(
+      stats.RatingDistribution.map((entry) => [
+        String(entry.RatingValue),
+        entry.Count
+      ])
+    ) : void 0;
+    return this.ratingSummarySchema.parse({
+      identifier: { product: { key: result.ProductStatistics.ProductId } },
+      averageRating: stats.AverageOverallRating,
+      totalRatings: stats.TotalReviewCount,
+      ratingDistribution: distribution
+    });
+  }
+  parseReview(_context, data) {
+    return this.reviewSchema.parse({
+      identifier: { key: data.Id },
+      product: { key: data.ProductId ?? "" },
+      authorName: data.UserNickname ?? "Anonymous",
+      authorId: data.AuthorId,
+      rating: data.Rating,
+      title: data.Title ?? "",
+      content: data.ReviewText ?? "",
+      reply: void 0,
+      repliedAt: void 0,
+      createdAt: data.SubmissionTime,
+      updatedAt: data.LastModificationTime,
+      verified: data.IsVerifiedPurchaser ?? false
+    });
+  }
+  parseReviewPaginatedResult(context, data) {
+    const totalResults = data.TotalResults ?? data.Results.length;
+    const limit = data.Limit ?? data.Results.length;
+    const offset = data.Offset ?? 0;
+    const pageSize = limit > 0 ? limit : 10;
+    const pageNumber = pageSize > 0 ? Math.floor(offset / pageSize) + 1 : 1;
+    const totalPages = pageSize > 0 ? Math.ceil(totalResults / pageSize) : 1;
+    return this.reviewPaginatedSchema.parse({
+      items: data.Results.map((review) => this.parseReview(context, review)),
+      totalCount: totalResults,
+      pageSize,
+      pageNumber,
+      totalPages
+    });
+  }
+}
+export {
+  BazaarvoiceProductReviewsFactory
+};

package/index.js

@@ -0,0 +1,7 @@
+export * from "./core/initialize.js";
+export * from "./core/initialize.types.js";
+export * from "./capabilities/index.js";
+export * from "./factories/index.js";
+export * from "./schema/configuration.schema.js";
+export * from "./schema/capabilities.schema.js";
+export * from "./schema/bazaarvoice.schema.js";

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@reactionary/bazaarvoice",
+  "version": "0.9.16",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./src/index.d.ts",
+  "dependencies": {
+    "@reactionary/core": "0.9.16",
+    "zod": "4.1.9"
+  },
+  "devDependencies": {
+    "@nx/vite": "22.4.5",
+    "vitest": "^4.0.9"
+  },
+  "sideEffects": false
+}

package/schema/bazaarvoice.schema.js

@@ -0,0 +1,63 @@
+import * as z from "zod";
+const BvRatingDistributionEntrySchema = z.looseObject({
+  RatingValue: z.number(),
+  Count: z.number()
+});
+const BvReviewStatisticsSchema = z.looseObject({
+  TotalReviewCount: z.number(),
+  AverageOverallRating: z.number(),
+  OverallRatingRange: z.number().optional(),
+  RatingDistribution: z.array(BvRatingDistributionEntrySchema).optional()
+});
+const BvProductStatisticsSchema = z.looseObject({
+  ProductId: z.string(),
+  ReviewStatistics: BvReviewStatisticsSchema
+});
+const BvStatisticsResultSchema = z.looseObject({
+  ProductStatistics: BvProductStatisticsSchema
+});
+const BvStatisticsResponseSchema = z.looseObject({
+  HasErrors: z.boolean(),
+  TotalResults: z.number().nullable().optional(),
+  Results: z.array(BvStatisticsResultSchema),
+  Errors: z.array(z.looseObject({ Message: z.string(), Code: z.string() })).optional()
+});
+const BvReviewSchema = z.looseObject({
+  Id: z.string(),
+  AuthorId: z.string().optional(),
+  UserNickname: z.string().optional(),
+  Rating: z.number(),
+  Title: z.string().optional(),
+  ReviewText: z.string().optional(),
+  SubmissionTime: z.string(),
+  LastModificationTime: z.string().optional(),
+  IsVerifiedPurchaser: z.boolean().optional(),
+  ModerationStatus: z.string().optional(),
+  ProductId: z.string().optional()
+});
+const BvReviewsResponseSchema = z.looseObject({
+  HasErrors: z.boolean(),
+  TotalResults: z.number().nullable().optional(),
+  Offset: z.number().nullable().optional(),
+  Limit: z.number().nullable().optional(),
+  Results: z.array(BvReviewSchema),
+  Errors: z.array(z.looseObject({ Message: z.string(), Code: z.string() })).optional()
+});
+const BvSubmitReviewResponseSchema = z.looseObject({
+  HasErrors: z.boolean(),
+  SubmissionId: z.string().optional(),
+  Review: BvReviewSchema.optional(),
+  FormErrors: z.looseObject({
+    FieldErrors: z.record(
+      z.string(),
+      z.looseObject({ Message: z.string(), Code: z.string() })
+    ).optional()
+  }).optional(),
+  Errors: z.array(z.looseObject({ Message: z.string(), Code: z.string() })).optional()
+});
+export {
+  BvReviewSchema,
+  BvReviewsResponseSchema,
+  BvStatisticsResponseSchema,
+  BvSubmitReviewResponseSchema
+};

package/schema/capabilities.schema.js

@@ -0,0 +1,15 @@
+import { CapabilitiesSchema } from "@reactionary/core";
+import * as z from "zod";
+const ProductReviewsCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  factory: z.unknown().optional(),
+  capability: z.unknown().optional()
+});
+const BazaarvoiceCapabilitiesSchema = CapabilitiesSchema.pick({
+  productReviews: true
+}).extend({
+  productReviews: ProductReviewsCapabilitySchema.optional()
+}).partial();
+export {
+  BazaarvoiceCapabilitiesSchema
+};

package/schema/configuration.schema.js

@@ -0,0 +1,11 @@
+import * as z from "zod";
+const BazaarvoiceConfigurationSchema = z.looseObject({
+  passKey: z.string().meta({ description: "Bazaarvoice API passkey." }),
+  apiUrl: z.string().default("https://api.bazaarvoice.com").meta({
+    description: "Base API URL. Use https://stg.api.bazaarvoice.com for staging."
+  }),
+  apiVersion: z.string().default("5.4").meta({ description: "Conversations API version." })
+});
+export {
+  BazaarvoiceConfigurationSchema
+};

package/src/capabilities/index.d.ts

@@ -0,0 +1 @@
+export * from './product-reviews.capability.js';

package/src/capabilities/product-reviews.capability.d.ts

@@ -0,0 +1,19 @@
+import { ProductReviewsCapability, type Cache, type ProductReviewMutationSubmit, type ProductReviewsFactory, type ProductReviewsFactoryRatingOutput, type ProductReviewsFactoryReviewOutput, type ProductReviewsFactoryReviewPaginatedOutput, type ProductReviewsFactoryWithOutput, type ProductReviewsGetRatingSummaryQuery, type ProductReviewsListQuery, type RequestContext, type Result } from '@reactionary/core';
+import type { BazaarvoiceConfiguration } from '../schema/configuration.schema.js';
+import type { BazaarvoiceClient } from '../core/client.js';
+import type { BazaarvoiceProductReviewsFactory } from '../factories/product-reviews/product-reviews.factory.js';
+export declare class BazaarvoiceProductReviewsCapability<TFactory extends ProductReviewsFactory = BazaarvoiceProductReviewsFactory> extends ProductReviewsCapability<ProductReviewsFactoryRatingOutput<TFactory>, ProductReviewsFactoryReviewPaginatedOutput<TFactory>, ProductReviewsFactoryReviewOutput<TFactory>> {
+    protected readonly config: BazaarvoiceConfiguration;
+    protected readonly client: BazaarvoiceClient;
+    protected readonly factory: ProductReviewsFactoryWithOutput<TFactory>;
+    constructor(cache: Cache, context: RequestContext, config: BazaarvoiceConfiguration, client: BazaarvoiceClient, factory: ProductReviewsFactoryWithOutput<TFactory>);
+    getRatingSummary(query: ProductReviewsGetRatingSummaryQuery): Promise<Result<ProductReviewsFactoryRatingOutput<TFactory>>>;
+    findReviews(query: ProductReviewsListQuery): Promise<Result<ProductReviewsFactoryReviewPaginatedOutput<TFactory>>>;
+    submitReview(mutation: ProductReviewMutationSubmit): Promise<Result<ProductReviewsFactoryReviewOutput<TFactory>>>;
+    protected getStatisticsUrl(): string;
+    protected getStatisticsParams(productId: string): URLSearchParams;
+    protected getReviewsUrl(): string;
+    protected getReviewsParams(productId: string, limit: number, offset: number): URLSearchParams;
+    protected getSubmitReviewUrl(): string;
+    protected getSubmitReviewBody(mutation: ProductReviewMutationSubmit): URLSearchParams;
+}

package/src/core/client.d.ts

@@ -0,0 +1,39 @@
+import type { RequestContext } from '@reactionary/core';
+import type { BazaarvoiceConfiguration } from '../schema/configuration.schema.js';
+/**
+ * Thin HTTP client for the Bazaarvoice Conversations REST API.
+ *
+ * Handles only transport concerns — authentication params (passKey, apiVersion)
+ * and locale (derived from the request context) are injected automatically on
+ * every request via `buildParams` / `buildBody`.
+ *
+ * URL construction and request-specific parameters are the responsibility of
+ * capability subclasses (extension-point pattern).
+ */
+export declare class BazaarvoiceClient {
+    protected readonly config: BazaarvoiceConfiguration;
+    protected readonly context: RequestContext;
+    /** Base API URL, e.g. https://api.bazaarvoice.com */
+    readonly baseUrl: string;
+    constructor(config: BazaarvoiceConfiguration, context: RequestContext);
+    callGet<T>(url: string, params: URLSearchParams, schema: {
+        parse(data: unknown): T;
+    }): Promise<T>;
+    callPost<T>(url: string, body: URLSearchParams, schema: {
+        parse(data: unknown): T;
+    }): Promise<T>;
+    /**
+     * Merges caller-supplied params with the default BV params (passKey,
+     * apiVersion, Locale). Caller-supplied values always win.
+     */
+    protected buildParams(params: URLSearchParams): URLSearchParams;
+    /**
+     * Merges caller-supplied POST body with the default BV fields (passKey,
+     * apiVersion, Locale). Caller-supplied values always win.
+     */
+    protected buildBody(body: URLSearchParams): URLSearchParams;
+    /**
+     * Converts a BCP 47 locale (e.g. `en-US`) to BV's expected `en_US` format.
+     */
+    protected bvLocale(): string;
+}

package/src/core/initialize.d.ts

@@ -0,0 +1,5 @@
+import type { Cache, RequestContext } from '@reactionary/core';
+import type { BazaarvoiceCapabilities } from '../schema/capabilities.schema.js';
+import type { BazaarvoiceConfiguration } from '../schema/configuration.schema.js';
+import { type BazaarvoiceClientFromCapabilities } from './initialize.types.js';
+export declare function withBazaarvoiceCapabilities<T extends BazaarvoiceCapabilities>(configuration: BazaarvoiceConfiguration, capabilities: T): (cache: Cache, context: RequestContext) => BazaarvoiceClientFromCapabilities<T>;

package/src/core/initialize.types.d.ts

@@ -0,0 +1,34 @@
+import type { ClientFromCapabilities, ProductReviewsFactory } from '@reactionary/core';
+import type { BazaarvoiceCapabilities } from '../schema/capabilities.schema.js';
+import type { BazaarvoiceProductReviewsFactory } from '../factories/product-reviews/product-reviews.factory.js';
+import type { BazaarvoiceProductReviewsCapability } from '../capabilities/product-reviews.capability.js';
+type EnabledCapability<TCapability> = TCapability extends {
+    enabled: true;
+} ? true : false;
+type NormalizeConfiguredCapabilities<T extends BazaarvoiceCapabilities> = Omit<T, 'productReviews'> & {
+    productReviews?: EnabledCapability<T['productReviews']>;
+};
+type ExtractCapabilityFactory<TCapability, TContract, TDefaultFactory> = TCapability extends {
+    enabled: true;
+    factory?: infer TFactory;
+} ? TFactory extends TContract ? TFactory : TDefaultFactory : TDefaultFactory;
+type ExtractCapabilityImplementation<TCapability, TDefaultCapability> = TCapability extends {
+    enabled: true;
+    capability?: infer TCapabilityFactory;
+} ? TCapabilityFactory extends (...args: unknown[]) => infer TResolvedCapability ? TResolvedCapability : TDefaultCapability : TDefaultCapability;
+type CapabilityOverride<TCapability, TKey extends string, TResolvedCapability> = TCapability extends {
+    enabled: true;
+} ? {
+    [K in TKey]: TResolvedCapability;
+} : Record<never, never>;
+type ProductReviewsFactoryFor<T extends BazaarvoiceCapabilities> = ExtractCapabilityFactory<T['productReviews'], ProductReviewsFactory, BazaarvoiceProductReviewsFactory>;
+type ProductReviewsCapabilityFor<T extends BazaarvoiceCapabilities> = ExtractCapabilityImplementation<T['productReviews'], BazaarvoiceProductReviewsCapability<ProductReviewsFactoryFor<T>>>;
+export type BazaarvoiceClientFromCapabilities<T extends BazaarvoiceCapabilities> = Omit<ClientFromCapabilities<NormalizeConfiguredCapabilities<T>>, 'productReviews'> & CapabilityOverride<T['productReviews'], 'productReviews', ProductReviewsCapabilityFor<T>>;
+export declare function resolveCapabilityWithFactory<TFactory, TResolvedCapability, TCapabilityArgs>(capability: {
+    factory?: TFactory;
+    capability?: (args: TCapabilityArgs) => TResolvedCapability;
+} | undefined, defaults: {
+    factory: TFactory;
+    capability: (args: TCapabilityArgs) => TResolvedCapability;
+}, buildCapabilityArgs: (factory: TFactory) => TCapabilityArgs): TResolvedCapability;
+export {};

package/src/factories/index.d.ts

@@ -0,0 +1 @@
+export * from './product-reviews/product-reviews.factory.js';

package/src/factories/product-reviews/product-reviews.factory.d.ts

@@ -0,0 +1,12 @@
+import type * as z from 'zod';
+import type { AnyProductRatingSummarySchema, AnyProductReviewPaginatedSchema, AnyProductReviewSchema, ProductReviewsFactory, RequestContext, ProductRatingSummarySchema, ProductReviewSchema, ProductReviewPaginatedResultSchema } from '@reactionary/core';
+import type { BvReview, BvReviewsResponse, BvStatisticsResponse } from '../../schema/bazaarvoice.schema.js';
+export declare class BazaarvoiceProductReviewsFactory<TRatingSummarySchema extends AnyProductRatingSummarySchema = typeof ProductRatingSummarySchema, TReviewSchema extends AnyProductReviewSchema = typeof ProductReviewSchema, TReviewPaginatedSchema extends AnyProductReviewPaginatedSchema = typeof ProductReviewPaginatedResultSchema> implements ProductReviewsFactory<TRatingSummarySchema, TReviewSchema, TReviewPaginatedSchema> {
+    readonly ratingSummarySchema: TRatingSummarySchema;
+    readonly reviewSchema: TReviewSchema;
+    readonly reviewPaginatedSchema: TReviewPaginatedSchema;
+    constructor(ratingSummarySchema: TRatingSummarySchema, reviewSchema: TReviewSchema, reviewPaginatedSchema: TReviewPaginatedSchema);
+    parseRatingSummary(_context: RequestContext, data: BvStatisticsResponse): z.output<TRatingSummarySchema>;
+    parseReview(_context: RequestContext, data: BvReview): z.output<TReviewSchema>;
+    parseReviewPaginatedResult(context: RequestContext, data: BvReviewsResponse): z.output<TReviewPaginatedSchema>;
+}

package/src/index.d.ts

@@ -0,0 +1,7 @@
+export * from './core/initialize.js';
+export * from './core/initialize.types.js';
+export * from './capabilities/index.js';
+export * from './factories/index.js';
+export * from './schema/configuration.schema.js';
+export * from './schema/capabilities.schema.js';
+export * from './schema/bazaarvoice.schema.js';

package/src/schema/bazaarvoice.schema.d.ts

@@ -0,0 +1,101 @@
+import * as z from 'zod';
+declare const BvReviewStatisticsSchema: z.ZodObject<{
+    TotalReviewCount: z.ZodNumber;
+    AverageOverallRating: z.ZodNumber;
+    OverallRatingRange: z.ZodOptional<z.ZodNumber>;
+    RatingDistribution: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        RatingValue: z.ZodNumber;
+        Count: z.ZodNumber;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export declare const BvStatisticsResponseSchema: z.ZodObject<{
+    HasErrors: z.ZodBoolean;
+    TotalResults: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    Results: z.ZodArray<z.ZodObject<{
+        ProductStatistics: z.ZodObject<{
+            ProductId: z.ZodString;
+            ReviewStatistics: z.ZodObject<{
+                TotalReviewCount: z.ZodNumber;
+                AverageOverallRating: z.ZodNumber;
+                OverallRatingRange: z.ZodOptional<z.ZodNumber>;
+                RatingDistribution: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    RatingValue: z.ZodNumber;
+                    Count: z.ZodNumber;
+                }, z.core.$loose>>>;
+            }, z.core.$loose>;
+        }, z.core.$loose>;
+    }, z.core.$loose>>;
+    Errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        Message: z.ZodString;
+        Code: z.ZodString;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export type BvStatisticsResponse = z.infer<typeof BvStatisticsResponseSchema>;
+export type BvReviewStatistics = z.infer<typeof BvReviewStatisticsSchema>;
+export declare const BvReviewSchema: z.ZodObject<{
+    Id: z.ZodString;
+    AuthorId: z.ZodOptional<z.ZodString>;
+    UserNickname: z.ZodOptional<z.ZodString>;
+    Rating: z.ZodNumber;
+    Title: z.ZodOptional<z.ZodString>;
+    ReviewText: z.ZodOptional<z.ZodString>;
+    SubmissionTime: z.ZodString;
+    LastModificationTime: z.ZodOptional<z.ZodString>;
+    IsVerifiedPurchaser: z.ZodOptional<z.ZodBoolean>;
+    ModerationStatus: z.ZodOptional<z.ZodString>;
+    ProductId: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const BvReviewsResponseSchema: z.ZodObject<{
+    HasErrors: z.ZodBoolean;
+    TotalResults: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    Offset: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    Limit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    Results: z.ZodArray<z.ZodObject<{
+        Id: z.ZodString;
+        AuthorId: z.ZodOptional<z.ZodString>;
+        UserNickname: z.ZodOptional<z.ZodString>;
+        Rating: z.ZodNumber;
+        Title: z.ZodOptional<z.ZodString>;
+        ReviewText: z.ZodOptional<z.ZodString>;
+        SubmissionTime: z.ZodString;
+        LastModificationTime: z.ZodOptional<z.ZodString>;
+        IsVerifiedPurchaser: z.ZodOptional<z.ZodBoolean>;
+        ModerationStatus: z.ZodOptional<z.ZodString>;
+        ProductId: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    Errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        Message: z.ZodString;
+        Code: z.ZodString;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export type BvReview = z.infer<typeof BvReviewSchema>;
+export type BvReviewsResponse = z.infer<typeof BvReviewsResponseSchema>;
+export declare const BvSubmitReviewResponseSchema: z.ZodObject<{
+    HasErrors: z.ZodBoolean;
+    SubmissionId: z.ZodOptional<z.ZodString>;
+    Review: z.ZodOptional<z.ZodObject<{
+        Id: z.ZodString;
+        AuthorId: z.ZodOptional<z.ZodString>;
+        UserNickname: z.ZodOptional<z.ZodString>;
+        Rating: z.ZodNumber;
+        Title: z.ZodOptional<z.ZodString>;
+        ReviewText: z.ZodOptional<z.ZodString>;
+        SubmissionTime: z.ZodString;
+        LastModificationTime: z.ZodOptional<z.ZodString>;
+        IsVerifiedPurchaser: z.ZodOptional<z.ZodBoolean>;
+        ModerationStatus: z.ZodOptional<z.ZodString>;
+        ProductId: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    FormErrors: z.ZodOptional<z.ZodObject<{
+        FieldErrors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            Message: z.ZodString;
+            Code: z.ZodString;
+        }, z.core.$loose>>>;
+    }, z.core.$loose>>;
+    Errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        Message: z.ZodString;
+        Code: z.ZodString;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export type BvSubmitReviewResponse = z.infer<typeof BvSubmitReviewResponseSchema>;
+export {};

package/src/schema/capabilities.schema.d.ts

@@ -0,0 +1,26 @@
+import type { Cache, ProductReviewsCapability, ProductReviewsFactory, ProductReviewsFactoryWithOutput, RequestContext } from '@reactionary/core';
+import type { BazaarvoiceConfiguration } from './configuration.schema.js';
+import type { BazaarvoiceClient } from '../core/client.js';
+import * as z from 'zod';
+export declare const BazaarvoiceCapabilitiesSchema: z.ZodObject<{
+    productReviews: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export type BazaarvoiceCapabilities = z.infer<typeof BazaarvoiceCapabilitiesSchema>;
+export interface BazaarvoiceCapabilityFactoryArgs {
+    cache: Cache;
+    context: RequestContext;
+    config: BazaarvoiceConfiguration;
+}
+export interface BazaarvoiceProductReviewsCapabilityFactoryArgs<TFactory extends ProductReviewsFactory = ProductReviewsFactory> extends BazaarvoiceCapabilityFactoryArgs {
+    client: BazaarvoiceClient;
+    factory: ProductReviewsFactoryWithOutput<TFactory>;
+}
+export interface BazaarvoiceProductReviewsCapabilityConfig<TFactory extends ProductReviewsFactory = ProductReviewsFactory, TCapability extends ProductReviewsCapability = ProductReviewsCapability> {
+    enabled: boolean;
+    factory?: ProductReviewsFactoryWithOutput<TFactory>;
+    capability?: (args: BazaarvoiceProductReviewsCapabilityFactoryArgs<TFactory>) => TCapability;
+}

package/src/schema/configuration.schema.d.ts

@@ -0,0 +1,7 @@
+import * as z from 'zod';
+export declare const BazaarvoiceConfigurationSchema: z.ZodObject<{
+    passKey: z.ZodString;
+    apiUrl: z.ZodDefault<z.ZodString>;
+    apiVersion: z.ZodDefault<z.ZodString>;
+}, z.core.$loose>;
+export type BazaarvoiceConfiguration = z.infer<typeof BazaarvoiceConfigurationSchema>;