@reactionary/magento 0.0.1

package/factories/index.js

@@ -0,0 +1,7 @@
+export * from "./cart/cart.factory.js";
+export * from "./category/category.factory.js";
+export * from "./identity/identity.factory.js";
+export * from "./inventory/inventory.factory.js";
+export * from "./price/price.factory.js";
+export * from "./product/product.factory.js";
+export * from "./product-search/product-search.factory.js";

package/factories/inventory/inventory.factory.js

@@ -0,0 +1,24 @@
+class MagentoInventoryFactory {
+  inventorySchema;
+  constructor(inventorySchema) {
+    this.inventorySchema = inventorySchema;
+  }
+  parseInventory(_context, data) {
+    const input = data;
+    const { sku, fulfillmentCenterKey, quantity } = input;
+    const identifier = {
+      variant: { sku },
+      fulfillmentCenter: { key: fulfillmentCenterKey }
+    };
+    const status = quantity > 0 ? "inStock" : "outOfStock";
+    const result = {
+      identifier,
+      quantity,
+      status
+    };
+    return this.inventorySchema.parse(result);
+  }
+}
+export {
+  MagentoInventoryFactory
+};

package/factories/price/price.factory.js

@@ -0,0 +1,43 @@
+class MagentoPriceFactory {
+  priceSchema;
+  constructor(priceSchema) {
+    this.priceSchema = priceSchema;
+  }
+  parsePrice(context, data, _options) {
+    const input = data;
+    const { product, sku, mode } = input;
+    const identifier = {
+      variant: { sku }
+    };
+    const basePrice = product.price ?? 0;
+    const specialPriceAttr = product.custom_attributes?.find((a) => a.attribute_code === "special_price");
+    const specialPrice = specialPriceAttr ? Number(specialPriceAttr.value) : void 0;
+    const finalPrice = mode === "customer" && specialPrice !== void 0 ? specialPrice : basePrice;
+    const unitPrice = {
+      value: finalPrice,
+      currency: context.languageContext.currencyCode || "USD"
+    };
+    const tieredPrices = [];
+    if (product.tier_prices) {
+      for (const tier of product.tier_prices) {
+        tieredPrices.push({
+          minimumQuantity: tier.qty,
+          price: {
+            value: tier.value,
+            currency: context.languageContext.currencyCode || "USD"
+          }
+        });
+      }
+    }
+    const result = {
+      identifier,
+      unitPrice,
+      onSale: false,
+      tieredPrices
+    };
+    return this.priceSchema.parse(result);
+  }
+}
+export {
+  MagentoPriceFactory
+};

package/factories/product/product.factory.js

@@ -0,0 +1,115 @@
+import {
+  CategoryIdentifierSchema,
+  ProductIdentifierSchema
+} from "@reactionary/core";
+function getCustomAttribute(product, code) {
+  if (!product.custom_attributes)
+    return void 0;
+  const found = product.custom_attributes.find((a) => a.attribute_code === code);
+  if (found?.value === null || found?.value === void 0)
+    return void 0;
+  return String(found.value);
+}
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/+$/, "");
+}
+function buildMagentoImageUrl(config, file) {
+  const mediaUrl = config.mediaUrl;
+  if (mediaUrl) {
+    return `${mediaUrl.replace(/\/+$/, "")}${file.startsWith("/") ? "" : "/"}${file}`;
+  }
+  const storeBase = `${normalizeBaseUrl(config.baseUrl)}`;
+  return `${storeBase}/media/catalog/product${file.startsWith("/") ? "" : "/"}${file}`;
+}
+class MagentoProductFactory {
+  constructor(productSchema, config) {
+    this.config = config;
+    this.productSchema = productSchema;
+  }
+  productSchema;
+  parseProduct(_context, data) {
+    const sku = data.sku;
+    const idKey = data.id !== void 0 ? String(data.id) : sku;
+    const identifier = ProductIdentifierSchema.parse({ key: idKey });
+    const name = data.name || sku;
+    const slug = getCustomAttribute(data, "url_key") ?? getCustomAttribute(data, "url_path") ?? "";
+    const description = getCustomAttribute(data, "description") ?? getCustomAttribute(data, "short_description") ?? "";
+    const categoryLinks = data.extension_attributes?.category_links;
+    const parentCategories = categoryLinks ? categoryLinks.map((c) => c.category_id).filter((x) => x !== null && x !== void 0).map((cid) => CategoryIdentifierSchema.parse({ key: String(cid) })) : [];
+    const sharedAttributes = this.parseAttributes(data);
+    const mainVariant = this.parseVariant(data);
+    const result = {
+      brand: getCustomAttribute(data, "manufacturer") ?? "",
+      description,
+      identifier,
+      longDescription: "",
+      mainVariant,
+      manufacturer: getCustomAttribute(data, "manufacturer") ?? "",
+      name,
+      options: [],
+      parentCategories,
+      published: true,
+      sharedAttributes,
+      slug,
+      variants: []
+    };
+    return this.productSchema.parse(result);
+  }
+  parseVariant(product) {
+    const sku = product.sku;
+    const ean = getCustomAttribute(product, "ean") ?? getCustomAttribute(product, "gtin") ?? getCustomAttribute(product, "barcode") ?? "";
+    const upc = getCustomAttribute(product, "upc") ?? "";
+    const images = (product.media_gallery_entries ?? []).filter((m) => m.file.length > 0).map((m) => ({
+      sourceUrl: buildMagentoImageUrl(this.config, m.file),
+      altText: product.name || sku
+    }));
+    const options = [];
+    return {
+      identifier: { sku },
+      name: product.name || sku,
+      upc,
+      ean,
+      images,
+      options,
+      gtin: ean,
+      barcode: ean
+    };
+  }
+  createSynthAttribute(key, name, value) {
+    const attributeIdentifier = { key };
+    const valueIdentifier = { key: `${key}-${value}` };
+    return {
+      identifier: attributeIdentifier,
+      name,
+      group: "",
+      values: [
+        {
+          identifier: valueIdentifier,
+          label: String(value),
+          value
+        }
+      ]
+    };
+  }
+  parseAttributes(product) {
+    const sharedAttributes = [];
+    if (!product.custom_attributes)
+      return sharedAttributes;
+    for (const entry of product.custom_attributes) {
+      const key = entry.attribute_code;
+      const value = entry.value;
+      if (!key)
+        continue;
+      if (key === "description" || key === "short_description")
+        continue;
+      if (value === null || value === void 0)
+        continue;
+      const stringValue = typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? String(value) : JSON.stringify(value);
+      sharedAttributes.push(this.createSynthAttribute(key, key, stringValue));
+    }
+    return sharedAttributes;
+  }
+}
+export {
+  MagentoProductFactory
+};

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

@@ -0,0 +1,88 @@
+import {
+  ImageSchema,
+  ProductSearchResultItemVariantSchema,
+  ProductVariantIdentifierSchema
+} from "@reactionary/core";
+function getCustomAttribute(product, code) {
+  if (!product.custom_attributes)
+    return void 0;
+  const found = product.custom_attributes.find((a) => a.attribute_code === code);
+  if (found?.value === null || found?.value === void 0)
+    return void 0;
+  return String(found.value);
+}
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/+$/, "");
+}
+function buildMagentoImageUrl(config, file) {
+  const mediaUrl = config["mediaUrl"];
+  if (mediaUrl) {
+    return `${mediaUrl.replace(/\/+$/, "")}${file.startsWith("/") ? "" : "/"}${file}`;
+  }
+  const storeBase = normalizeBaseUrl(config.baseUrl);
+  return `${storeBase}/media/catalog/product${file.startsWith("/") ? "" : "/"}${file}`;
+}
+class MagentoProductSearchFactory {
+  constructor(productSearchResultSchema, config) {
+    this.config = config;
+    this.productSearchResultSchema = productSearchResultSchema;
+  }
+  productSearchResultSchema;
+  parseSearchResult(context, data, query) {
+    const pageSize = query.search.paginationOptions.pageSize;
+    const currentPage = query.search.paginationOptions.pageNumber;
+    const items = (data.items || []).map(
+      (p) => this.parseProductSearchResultItem(context, p)
+    );
+    const totalCount = data.total_count ?? 0;
+    const totalPages = Math.max(1, Math.ceil(totalCount / pageSize));
+    const result = {
+      identifier: {
+        ...query.search
+      },
+      pageNumber: currentPage,
+      pageSize,
+      totalCount,
+      totalPages,
+      items,
+      facets: []
+    };
+    return this.productSearchResultSchema.parse(result);
+  }
+  parseProductSearchResultItem(_context, product) {
+    const idKey = product.id !== void 0 ? String(product.id) : product.sku;
+    const identifier = { key: idKey };
+    const slug = getCustomAttribute(product, "url_key") ?? getCustomAttribute(product, "url_path") ?? "";
+    const name = product.name || product.sku;
+    const variants = [];
+    if (product.sku) {
+      variants.push(this.parseVariant(product, product));
+    }
+    return {
+      identifier,
+      name,
+      slug,
+      variants
+    };
+  }
+  parseVariant(variant, product) {
+    const media = product.media_gallery_entries;
+    const firstImage = media && media.length > 0 ? media[0].file : null;
+    const img = firstImage ? ImageSchema.parse({
+      sourceUrl: buildMagentoImageUrl(this.config, firstImage),
+      altText: product.name || void 0
+    }) : ImageSchema.parse({
+      sourceUrl: "",
+      altText: product.name || void 0
+    });
+    return ProductSearchResultItemVariantSchema.parse({
+      variant: ProductVariantIdentifierSchema.parse({
+        sku: variant.sku
+      }),
+      image: img
+    });
+  }
+}
+export {
+  MagentoProductSearchFactory
+};

package/index.js

@@ -0,0 +1,14 @@
+export * from "./schema/configuration.schema.js";
+export * from "./schema/capabilities.schema.js";
+export * from "./schema/magento.schema.js";
+export * from "./core/initialize.js";
+export * from "./core/initialize.types.js";
+export * from "./core/client.js";
+export * from "./factories/index.js";
+export * from "./capabilities/product.capability.js";
+export * from "./capabilities/product-search.capability.js";
+export * from "./capabilities/category.capability.js";
+export * from "./capabilities/inventory.capability.js";
+export * from "./capabilities/price.capability.js";
+export * from "./capabilities/identity.capability.js";
+export * from "./capabilities/cart.capability.js";

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@reactionary/magento",
+  "version": "0.0.1",
+  "private": false,
+  "type": "module",
+  "main": "./index.js",
+  "types": "./src/index.d.ts",
+  "dependencies": {
+    "@reactionary/core": "0.0.1",
+    "zod": "4.1.9",
+    "debug": "^4.4.3"
+  },
+  "sideEffets": false
+
+}

package/schema/capabilities.schema.js

@@ -0,0 +1,31 @@
+import { CapabilitiesSchema } from "@reactionary/core";
+import * as z from "zod";
+const OverridableCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  factory: z.unknown().optional(),
+  capability: z.unknown().optional()
+});
+const DirectCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  capability: z.unknown().optional()
+});
+const MagentoCapabilitiesSchema = CapabilitiesSchema.pick({
+  product: true,
+  productSearch: true,
+  category: true,
+  inventory: true,
+  price: true,
+  identity: true,
+  cart: true
+}).extend({
+  product: OverridableCapabilitySchema.optional(),
+  productSearch: OverridableCapabilitySchema.optional(),
+  cart: OverridableCapabilitySchema.optional(),
+  category: OverridableCapabilitySchema.optional(),
+  price: OverridableCapabilitySchema.optional(),
+  inventory: OverridableCapabilitySchema.optional(),
+  identity: DirectCapabilitySchema.optional()
+}).partial();
+export {
+  MagentoCapabilitiesSchema
+};

package/schema/configuration.schema.js

@@ -0,0 +1,13 @@
+import * as z from "zod";
+const MagentoConfigurationSchema = z.looseObject({
+  adminApiKey: z.string().meta({ description: "The API key for Magento admin operations. Needed for the few tasks that require admin access." }),
+  baseUrl: z.string().meta({ description: "The base URL for the Magento installation." }),
+  mediaUrl: z.string().optional().meta({ description: "The base URL for media files. If not provided, it will be derived from the baseUrl." }),
+  defaultCurrency: z.string().default(""),
+  rootCategoryId: z.string().default("2").meta({ description: 'The ID of the root category in Magento. Typically "2" for the default Magento setup.' }),
+  allCurrencies: z.array(z.string()),
+  storeCode: z.string().default("")
+});
+export {
+  MagentoConfigurationSchema
+};

package/schema/magento.schema.js

@@ -0,0 +1,5 @@
+import { CartIdentifierSchema } from "@reactionary/core";
+const MagentoCartIdentifierSchema = CartIdentifierSchema.extend({});
+export {
+  MagentoCartIdentifierSchema
+};

package/src/capabilities/cart.capability.d.ts

@@ -0,0 +1,24 @@
+import { type Cache, type CartFactory, type CartFactoryCartOutput, type CartFactoryWithOutput, type CartIdentifier, type CartMutationApplyCoupon, type CartMutationChangeCurrency, type CartMutationCreateCart, type CartMutationDeleteCart, type CartMutationItemAdd, type CartMutationItemQuantityChange, type CartMutationItemRemove, type CartMutationRemoveCoupon, type CartMutationRenameCart, type CartPaginatedSearchResult, type CartQueryById, type CartQueryList, type NotFoundError, type RequestContext, type Result, CartCapability } from '@reactionary/core';
+import type { MagentoClient } from '../core/client.js';
+import type { MagentoConfiguration } from '../schema/configuration.schema.js';
+import type { MagentoCartFactory } from '../factories/cart/cart.factory.js';
+export declare class MagentoCartCapability<TFactory extends CartFactory = MagentoCartFactory> extends CartCapability<CartFactoryCartOutput<TFactory>> {
+    magentoApi: MagentoClient;
+    protected config: MagentoConfiguration;
+    protected factory: CartFactoryWithOutput<TFactory>;
+    constructor(config: MagentoConfiguration, cache: Cache, context: RequestContext, magentoApi: MagentoClient, factory: CartFactoryWithOutput<TFactory>);
+    getById(payload: CartQueryById): Promise<Result<CartFactoryCartOutput<TFactory>, NotFoundError>>;
+    add(payload: CartMutationItemAdd): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    remove(payload: CartMutationItemRemove): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    changeQuantity(payload: CartMutationItemQuantityChange): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    getActiveCartId(): Promise<Result<CartIdentifier, NotFoundError>>;
+    deleteCart(_payload: CartMutationDeleteCart): Promise<Result<void>>;
+    applyCouponCode(payload: CartMutationApplyCoupon): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    removeCouponCode(payload: CartMutationRemoveCoupon): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    changeCurrency(_payload: CartMutationChangeCurrency): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    listCarts(_payload: CartQueryList): Promise<Result<CartPaginatedSearchResult>>;
+    createCart(_payload: CartMutationCreateCart): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    renameCart(_payload: CartMutationRenameCart): Promise<Result<CartFactoryCartOutput<TFactory>>>;
+    protected createNewCart(): Promise<CartIdentifier>;
+    protected getCartWithTotals(cartId: string): Promise<Record<string, unknown>>;
+}

package/src/capabilities/category.capability.d.ts

@@ -0,0 +1,22 @@
+import type { Cache, CategoryFactory, CategoryFactoryCategoryOutput, CategoryFactoryPaginatedOutput, CategoryFactoryWithOutput } from '@reactionary/core';
+import { CategoryCapability, type CategoryQueryById, type CategoryQueryBySlug, type CategoryQueryForBreadcrumb, type CategoryQueryForChildCategories, type CategoryQueryForTopCategories, type NotFoundError, type RequestContext, type Result } from '@reactionary/core';
+import type { MagentoConfiguration } from '../schema/configuration.schema.js';
+import type { Magento, MagentoClient } from '../core/client.js';
+import type { MagentoCategoryFactory } from '../factories/category/category.factory.js';
+import type { MagentoCategory, MagentoCategorySearchResult } from '../schema/magento.types.js';
+export declare class MagentoCategoryCapability<TFactory extends CategoryFactory = MagentoCategoryFactory> extends CategoryCapability<CategoryFactoryCategoryOutput<TFactory>, CategoryFactoryPaginatedOutput<TFactory>> {
+    magentoApi: MagentoClient;
+    protected config: MagentoConfiguration;
+    protected factory: CategoryFactoryWithOutput<TFactory>;
+    constructor(config: MagentoConfiguration, cache: Cache, context: RequestContext, magentoApi: MagentoClient, factory: CategoryFactoryWithOutput<TFactory>);
+    getById(payload: CategoryQueryById): Promise<Result<CategoryFactoryCategoryOutput<TFactory>, NotFoundError>>;
+    getBySlug(payload: CategoryQueryBySlug): Promise<Result<CategoryFactoryCategoryOutput<TFactory>, NotFoundError>>;
+    getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb): Promise<Result<CategoryFactoryCategoryOutput<TFactory>[]>>;
+    findChildCategories(payload: CategoryQueryForChildCategories): Promise<Result<CategoryFactoryPaginatedOutput<TFactory>>>;
+    findTopCategories(payload: CategoryQueryForTopCategories): Promise<Result<CategoryFactoryPaginatedOutput<TFactory>>>;
+    protected cacheCategoryKeyToIdMapping(key: string, id: string): Promise<void>;
+    protected translateCategoryKeyToMagentoId(client: Magento, key: string): Promise<string | null>;
+    protected translateMagentoIdToCategoryKey(magentoId: string): Promise<string | null>;
+    protected cleanupParentPointersForCategory(category: MagentoCategory): Promise<MagentoCategory>;
+    protected cleanupParentPointersForPaginatedResult(paginatedResult: MagentoCategorySearchResult): Promise<MagentoCategorySearchResult>;
+}

package/src/capabilities/identity.capability.d.ts

@@ -0,0 +1,13 @@
+import { type Identity, type IdentityMutationLogin, type IdentityMutationLogout, type IdentityMutationRegister, type IdentityQuerySelf, type RequestContext, type Cache, IdentityCapability, type AnonymousIdentity, type Result } from '@reactionary/core';
+import type { MagentoClient } from '../core/client.js';
+import type { MagentoConfiguration } from '../schema/configuration.schema.js';
+export declare class MagentoIdentityCapability extends IdentityCapability {
+    magentoApi: MagentoClient;
+    protected config: MagentoConfiguration;
+    constructor(config: MagentoConfiguration, cache: Cache, context: RequestContext, magentoApi: MagentoClient);
+    protected createAnonymousIdentity(): AnonymousIdentity;
+    getSelf(_payload: IdentityQuerySelf): Promise<Result<Identity>>;
+    login(payload: IdentityMutationLogin): Promise<Result<Identity>>;
+    logout(_payload: IdentityMutationLogout): Promise<Result<Identity>>;
+    register(payload: IdentityMutationRegister): Promise<Result<Identity>>;
+}

package/src/capabilities/inventory.capability.d.ts

@@ -0,0 +1,11 @@
+import { type InventoryQueryBySKU, type RequestContext, type Cache, InventoryCapability, type InventoryFactory, type InventoryFactoryOutput, type InventoryFactoryWithOutput, type NotFoundError, type Result } from '@reactionary/core';
+import type { MagentoConfiguration } from '../schema/configuration.schema.js';
+import type { MagentoClient } from '../core/client.js';
+import type { MagentoInventoryFactory } from '../factories/inventory/inventory.factory.js';
+export declare class MagentoInventoryCapability<TFactory extends InventoryFactory = MagentoInventoryFactory> extends InventoryCapability<InventoryFactoryOutput<TFactory>> {
+    magentoApi: MagentoClient;
+    protected config: MagentoConfiguration;
+    protected factory: InventoryFactoryWithOutput<TFactory>;
+    constructor(config: MagentoConfiguration, cache: Cache, context: RequestContext, magentoApi: MagentoClient, factory: InventoryFactoryWithOutput<TFactory>);
+    getBySKU(payload: InventoryQueryBySKU): Promise<Result<InventoryFactoryOutput<TFactory>, NotFoundError>>;
+}

package/src/capabilities/price.capability.d.ts

@@ -0,0 +1,12 @@
+import { PriceCapability, type Cache, type CustomerPriceQuery, type ListPriceQuery, type PriceFactory, type PriceFactoryOutput, type PriceFactoryWithOutput, type RequestContext, type Result } from '@reactionary/core';
+import type { MagentoClient } from '../core/client.js';
+import type { MagentoConfiguration } from '../schema/configuration.schema.js';
+import type { MagentoPriceFactory } from '../factories/price/price.factory.js';
+export declare class MagentoPriceCapability<TFactory extends PriceFactory = MagentoPriceFactory> extends PriceCapability<PriceFactoryOutput<TFactory>> {
+    magentoApi: MagentoClient;
+    protected config: MagentoConfiguration;
+    protected factory: PriceFactoryWithOutput<TFactory>;
+    constructor(config: MagentoConfiguration, cache: Cache, context: RequestContext, magentoApi: MagentoClient, factory: PriceFactoryWithOutput<TFactory>);
+    getListPrice(payload: ListPriceQuery): Promise<Result<PriceFactoryOutput<TFactory>>>;
+    getCustomerPrice(payload: CustomerPriceQuery): Promise<Result<PriceFactoryOutput<TFactory>>>;
+}

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

@@ -0,0 +1,15 @@
+import { ProductSearchCapability, type Cache, type FacetIdentifier, type FacetValueIdentifier, type ProductSearchFactory, type ProductSearchFactoryOutput, type ProductSearchFactoryWithOutput, type ProductSearchQueryByTerm, type ProductSearchQueryCreateNavigationFilter, type ProductSearchResultFacet, type ProductSearchResultFacetValue, type RequestContext, type Result } from '@reactionary/core';
+import type { MagentoConfiguration } from '../schema/configuration.schema.js';
+import type { MagentoClient } from '../core/client.js';
+import type { MagentoProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+export declare class MagentoProductSearchCapability<TFactory extends ProductSearchFactory = MagentoProductSearchFactory> extends ProductSearchCapability<ProductSearchFactoryOutput<TFactory>> {
+    magentoApi: MagentoClient;
+    protected config: MagentoConfiguration;
+    protected factory: ProductSearchFactoryWithOutput<TFactory>;
+    constructor(config: MagentoConfiguration, cache: Cache, context: RequestContext, magentoApi: MagentoClient, factory: ProductSearchFactoryWithOutput<TFactory>);
+    queryByTerm(payload: ProductSearchQueryByTerm): Promise<Result<ProductSearchFactoryOutput<TFactory>>>;
+    createCategoryNavigationFilter(payload: ProductSearchQueryCreateNavigationFilter): Promise<Result<FacetValueIdentifier>>;
+    protected parseFacetValue(_facetValueIdentifier: FacetValueIdentifier, _label: string, _count: number): ProductSearchResultFacetValue;
+    protected parseFacet(_facetIdentifier: FacetIdentifier, _facetValue: unknown): ProductSearchResultFacet;
+    protected parseVariant(): never;
+}

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

@@ -0,0 +1,14 @@
+import type { Cache, NotFoundError, ProductFactory, ProductFactoryOutput, ProductFactoryWithOutput, ProductQueryById, ProductQueryBySKU, ProductQueryBySlug, RequestContext, Result } from '@reactionary/core';
+import { ProductCapability } from '@reactionary/core';
+import type { MagentoClient } from '../core/client.js';
+import type { MagentoConfiguration } from '../schema/configuration.schema.js';
+import type { MagentoProductFactory } from '../factories/product/product.factory.js';
+export declare class MagentoProductCapability<TFactory extends ProductFactory = MagentoProductFactory> extends ProductCapability<ProductFactoryOutput<TFactory>> {
+    magentoApi: MagentoClient;
+    protected config: MagentoConfiguration;
+    protected factory: ProductFactoryWithOutput<TFactory>;
+    constructor(config: MagentoConfiguration, cache: Cache, context: RequestContext, magentoApi: MagentoClient, factory: ProductFactoryWithOutput<TFactory>);
+    getById(payload: ProductQueryById): Promise<Result<ProductFactoryOutput<TFactory>>>;
+    getBySlug(payload: ProductQueryBySlug): Promise<Result<ProductFactoryOutput<TFactory>, NotFoundError>>;
+    getBySKU(payload: ProductQueryBySKU): Promise<Result<ProductFactoryOutput<TFactory>>>;
+}

package/src/core/client.d.ts

@@ -0,0 +1,93 @@
+import type { MagentoConfiguration } from '../schema/configuration.schema.js';
+import type { RequestContext } from '@reactionary/core';
+export declare const SESSION_KEY = "MAGENTO_PROVIDER";
+export interface MagentoCustomStorage {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+}
+export declare class RequestContextTokenStore implements MagentoCustomStorage {
+    protected context: RequestContext;
+    keyPrefix: string;
+    constructor(context: RequestContext, keyPrefix?: string);
+    private ensureNamespace;
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+}
+declare class MagentoRest {
+    private baseUrl;
+    private storeCode;
+    private getAuthHeader;
+    protected apiUrl: string;
+    constructor(baseUrl: string, storeCode: string, getAuthHeader: () => Promise<Record<string, string>>);
+    private normalizeUrl;
+    request<T>(method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', path: string, body?: unknown): Promise<T>;
+}
+export declare class Magento {
+    private rest;
+    private tokenStore;
+    constructor(rest: MagentoRest, tokenStore: RequestContextTokenStore);
+    auth: {
+        login: (email: string, password: string) => Promise<string>;
+        logout: () => Promise<void>;
+    };
+    store: {
+        customer: {
+            register: (customer: any, password?: string) => Promise<any>;
+            me: () => Promise<any>;
+        };
+        product: {
+            getBySKU: (sku: string) => Promise<any>;
+            search: (params: URLSearchParams) => Promise<any>;
+        };
+        category: {
+            getById: (categoryId: string) => Promise<any>;
+            getByExternalId: (externalId: string) => Promise<any>;
+            list: (params: URLSearchParams) => Promise<any>;
+        };
+        inventory: {
+            getStockStatus: (sku: string) => Promise<any>;
+            getSourceItems: (params: URLSearchParams) => Promise<any>;
+        };
+        cart: {
+            create: (customerToken?: string | null) => Promise<string>;
+            get: (cartId?: string | null, customerToken?: string | null) => Promise<any>;
+            getTotals: (cartId?: string | null, customerToken?: string | null) => Promise<any>;
+            addItem: (cartId: string | null, item: any, customerToken?: string | null) => Promise<any>;
+            updateItem: (cartId: string | null, itemId: number, item: any, customerToken?: string | null) => Promise<any>;
+            removeItem: (cartId: string | null, itemId: number, customerToken?: string | null) => Promise<any>;
+            applyCoupon: (cartId: string | null, couponCode: string, customerToken?: string | null) => Promise<any>;
+            removeCoupon: (cartId: string | null, customerToken?: string | null) => Promise<any>;
+        };
+    };
+}
+export declare class MagentoAdminClient {
+    protected rest: MagentoRest;
+    protected client: Magento;
+    constructor(config: MagentoConfiguration, context: RequestContext);
+    getClient(): Promise<Magento>;
+}
+export declare class MagentoClient {
+    protected config: MagentoConfiguration;
+    protected tokenStore: RequestContextTokenStore;
+    protected rest: MagentoRest;
+    protected client: Promise<Magento> | undefined;
+    constructor(config: MagentoConfiguration, context: RequestContext);
+    getClient(): Promise<Magento>;
+    login(email: string, password: string): Promise<string>;
+    logout(): Promise<void>;
+    getMe(): Promise<any>;
+    register(customer: any, password?: string): Promise<any>;
+    getProductBySKU(sku: string): Promise<any>;
+    resolveProductForSKU(sku: string): Promise<any>;
+    createCart(): Promise<string>;
+    getCart(cartId?: string | null): Promise<any>;
+    getCartTotals(cartId?: string | null): Promise<any>;
+    addItemToCart(cartId: string | null, item: any): Promise<any>;
+    updateCartItem(cartId: string | null, itemId: number, item: any): Promise<any>;
+    removeCartItem(cartId: string | null, itemId: number): Promise<any>;
+    applyCoupon(cartId: string | null, couponCode: string): Promise<any>;
+    removeCoupon(cartId: string | null): Promise<any>;
+}
+export {};

package/src/core/initialize.d.ts

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