@brand-map/exchange-core 0.0.10-alpha.10

package/dist/exports.js

@@ -0,0 +1,275 @@
+// src/exports.ts
+async function applyExchangeDocument(brandMap, document) {
+  const result = {
+    attributesUpserted: 0,
+    imagesAdded: 0,
+    inventorySynced: 0,
+    priceListPricesSet: 0,
+    priceListsUpserted: 0,
+    pricesSet: 0,
+    productsCreated: 0,
+    productsUpdated: 0,
+    rowsProcessed: document.products.length,
+    source: document.source,
+    variantOptionValuesLinked: 0,
+    variantsCreated: 0,
+    variantsUpdated: 0
+  };
+  for (const productDraft of document.products) {
+    const existingProduct = await findExistingProduct(brandMap, productDraft);
+    const product = existingProduct ? await brandMap.product.update({
+      description: productDraft.description,
+      id: existingProduct.id,
+      metadata: mergeMetadata(productDraft.metadata, document.source),
+      slug: productDraft.slug,
+      subtitle: productDraft.subtitle,
+      thumbnail: productDraft.thumbnail,
+      title: productDraft.title
+    }) : await brandMap.product.create({
+      categoryId: productDraft.categoryId,
+      description: productDraft.description,
+      metadata: mergeMetadata(productDraft.metadata, document.source),
+      slug: productDraft.slug,
+      status: productDraft.status ?? undefined,
+      subtitle: productDraft.subtitle,
+      thumbnail: productDraft.thumbnail,
+      title: productDraft.title
+    });
+    if (!product) {
+      throw new Error(`Failed to persist product "${productDraft.slug}".`);
+    }
+    if (existingProduct)
+      result.productsUpdated++;
+    else
+      result.productsCreated++;
+    for (const image of productDraft.images ?? []) {
+      const hasImage = existingProduct?.images?.some((candidate) => candidate.url === image.url);
+      if (!hasImage) {
+        await brandMap.product.addImage(product.id, image.url, image.rank ?? undefined);
+        result.imagesAdded++;
+      }
+    }
+    for (const attribute of productDraft.attributes ?? []) {
+      await upsertAttributeWithValue(brandMap, product.id, null, attribute);
+      result.attributesUpserted++;
+    }
+    for (const variantDraft of productDraft.variants) {
+      const existingVariant = await brandMap.product.retrieveVariantByExternalSku(variantDraft.externalSku);
+      const variant = existingVariant ? await brandMap.product.updateVariant(existingVariant.id, {
+        externalSku: variantDraft.externalSku,
+        manageInventory: variantDraft.manageInventory ?? undefined,
+        title: variantDraft.title ?? undefined
+      }) : await brandMap.product.createVariant(product.id, {
+        externalSku: variantDraft.externalSku,
+        manageInventory: variantDraft.manageInventory ?? undefined,
+        title: variantDraft.title ?? variantDraft.externalSku
+      });
+      const variantId = readVariantId(variant) ?? existingVariant?.id ?? (await brandMap.product.retrieveVariantByExternalSku(variantDraft.externalSku))?.id;
+      if (!variantId) {
+        throw new Error(`Failed to persist variant "${variantDraft.externalSku}".`);
+      }
+      if (existingVariant)
+        result.variantsUpdated++;
+      else
+        result.variantsCreated++;
+      for (const [optionKey, optionValue] of Object.entries(variantDraft.options ?? {})) {
+        const option = await brandMap.product.upsertOption(product.id, {
+          rank: optionValue.rank ?? undefined,
+          title: optionValue.title ?? toTitle(optionKey)
+        });
+        const value = await brandMap.product.upsertOptionValue(option.id, {
+          colorHex: optionValue.colorHex ?? undefined,
+          rank: optionValue.rank ?? undefined,
+          value: optionValue.value
+        });
+        await brandMap.product.linkVariantOptionValue(variantId, value.id);
+        result.variantOptionValuesLinked++;
+      }
+      for (const attribute of variantDraft.attributes ?? []) {
+        await upsertAttributeWithValue(brandMap, product.id, variantId, attribute);
+        result.attributesUpserted++;
+      }
+      const basePrice = variantDraft.prices?.base;
+      if (basePrice?.amount !== undefined) {
+        await brandMap.price.setBasePrice({
+          amount: basePrice.amount,
+          compareAtAmount: basePrice.compareAtAmount ?? undefined,
+          costAmount: basePrice.costAmount ?? undefined,
+          currencyCode: basePrice.currencyCode ?? "RUB",
+          taxIncluded: true,
+          variantId
+        });
+        result.pricesSet++;
+      }
+      for (const price of variantDraft.prices?.lists ?? []) {
+        const priceList = await upsertPriceList(brandMap, document, price);
+        await upsertPriceListPrice(brandMap, priceList.id, variantId, price);
+        result.priceListsUpserted++;
+        result.priceListPricesSet++;
+      }
+      for (const inventory of variantDraft.inventory ?? []) {
+        const storeId = inventory.storeId ?? document.storeId;
+        if (!storeId) {
+          throw new Error(`Inventory for "${variantDraft.externalSku}" requires storeId.`);
+        }
+        const stockLocation = await brandMap.stockLocation.upsertStockLocation({
+          code: inventory.stockLocationCode,
+          isEnabled: true,
+          metadata: { sourceSystem: document.source },
+          name: inventory.stockLocationName ?? inventory.stockLocationCode,
+          storeId,
+          type: "warehouse"
+        });
+        const item = await brandMap.inventory.enrollVariantInStore({
+          isManaged: true,
+          metadata: { sourceSystem: document.source },
+          sku: inventory.sku ?? variantDraft.externalSku,
+          storeId,
+          variantId
+        });
+        await brandMap.inventory.syncStockLevel({
+          inventoryItemId: item.id,
+          sourceSystem: document.source,
+          stockedQuantity: inventory.stockedQuantity,
+          stockLocationId: stockLocation.id
+        });
+        result.inventorySynced++;
+      }
+    }
+  }
+  return result;
+}
+async function upsertAttributeWithValue(brandMap, productId, variantId, attributeDraft) {
+  const attribute = await brandMap.product.upsertAttribute(productId, {
+    isFilterable: attributeDraft.isFilterable ?? undefined,
+    isSearchable: attributeDraft.isSearchable ?? undefined,
+    key: attributeDraft.key,
+    label: attributeDraft.label ?? toTitle(attributeDraft.key),
+    rank: attributeDraft.rank ?? undefined,
+    type: attributeDraft.type ?? inferAttributeType(attributeDraft.value)
+  });
+  const valueInput = buildAttributeValueInput(attribute.id, productId, variantId, attributeDraft.value);
+  await brandMap.product.upsertAttributeValue(valueInput);
+}
+function buildAttributeValueInput(attributeId, productId, variantId, value) {
+  return {
+    attributeId,
+    productId: variantId ? null : productId,
+    valueBoolean: typeof value === "boolean" ? value : null,
+    valueNumber: typeof value === "number" ? value : null,
+    valueText: typeof value === "string" ? value : null,
+    variantId
+  };
+}
+async function upsertPriceList(brandMap, document, price) {
+  const storeId = document.storeId;
+  if (!storeId) {
+    throw new Error(`Price list "${price.key}" requires storeId.`);
+  }
+  const title = price.title ?? toTitle(price.key);
+  const existing = await brandMap.price.listPriceList({
+    limit: 1,
+    where: { $and: [{ storeId: { $eq: storeId } }, { title: { $eq: title } }] }
+  });
+  const current = existing.data[0];
+  if (current) {
+    const updated = await brandMap.price.updatePriceList({
+      id: current.id,
+      metadata: { key: price.key, sourceSystem: document.source },
+      status: "active",
+      title,
+      type: "override"
+    });
+    return updated ?? current;
+  }
+  return await brandMap.price.createPriceList({
+    automaticallyApplies: true,
+    metadata: { key: price.key, sourceSystem: document.source },
+    priority: 0,
+    status: "active",
+    storeId,
+    title,
+    type: "override"
+  });
+}
+async function upsertPriceListPrice(brandMap, priceListId, variantId, price) {
+  const currencyCode = price.currencyCode ?? "RUB";
+  const existing = await brandMap.price.listPriceListPrice({
+    limit: 1,
+    where: {
+      $and: [
+        { priceListId: { $eq: priceListId } },
+        { variantId: { $eq: variantId } },
+        { currencyCode: { $eq: currencyCode } }
+      ]
+    }
+  });
+  const current = existing.data[0];
+  if (current) {
+    await brandMap.price.updatePriceListPrice({
+      amount: price.amount,
+      compareAtAmount: price.compareAtAmount ?? undefined,
+      currencyCode,
+      id: current.id,
+      metadata: { key: price.key },
+      priceListId,
+      variantId
+    });
+    return;
+  }
+  await brandMap.price.createPriceListPrice({
+    amount: price.amount,
+    compareAtAmount: price.compareAtAmount ?? undefined,
+    currencyCode,
+    metadata: { key: price.key },
+    priceListId,
+    variantId
+  });
+}
+async function findProductBySlug(brandMap, slug) {
+  const result = await brandMap.product.list({
+    joins: { images: { select: ["id", "url", "rank"] } },
+    limit: 1,
+    where: { slug: { $eq: slug } }
+  });
+  return result.data[0] ?? null;
+}
+async function findExistingProduct(brandMap, productDraft) {
+  const productBySlug = await findProductBySlug(brandMap, productDraft.slug);
+  if (productBySlug)
+    return productBySlug;
+  for (const variantDraft of productDraft.variants) {
+    const existingVariant = await brandMap.product.retrieveVariantByExternalSku(variantDraft.externalSku);
+    if (!existingVariant)
+      continue;
+    return await brandMap.product.retrieve(existingVariant.productId, {
+      joins: { images: { select: ["id", "url", "rank"] } }
+    });
+  }
+  return null;
+}
+function mergeMetadata(metadata, source) {
+  return {
+    ...metadata,
+    sourceSystem: source
+  };
+}
+function readVariantId(value) {
+  return value && "productId" in value ? value.id : null;
+}
+function inferAttributeType(value) {
+  if (typeof value === "boolean")
+    return "boolean";
+  if (typeof value === "number")
+    return "number";
+  return isColorHex(value) ? "color" : "string";
+}
+function isColorHex(value) {
+  return /^#[0-9a-f]{6}$/i.test(value);
+}
+function toTitle(value) {
+  return value.replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim().replace(/\b\w/g, (letter) => letter.toUpperCase());
+}
+export {
+  applyExchangeDocument
+};

package/dist/types/exports.d.ts

@@ -0,0 +1,116 @@
+import type { ExtensionBrandMapOperations, ExtensionJson } from "@brand-map/extension-sdk/types";
+
+type ExchangeAttributeType = "string" | "number" | "boolean" | "enum" | "color";
+
+type ExchangeAttributeValue = {
+  isFilterable?: boolean | null;
+  isSearchable?: boolean | null;
+  key: string;
+  label?: string | null;
+  rank?: number | null;
+  type?: ExchangeAttributeType | null;
+  value: boolean | number | string;
+};
+
+type ExchangeOptionValue = {
+  colorHex?: string | null;
+  rank?: number | null;
+  title?: string | null;
+  value: string;
+};
+
+type ExchangePrice = {
+  amount: number;
+  compareAtAmount?: number | null;
+  costAmount?: number | null;
+  currencyCode?: string | null;
+};
+
+type ExchangePriceListPrice = ExchangePrice & {
+  key: string;
+  title?: string | null;
+};
+
+type ExchangeInventoryLevel = {
+  sku?: string | null;
+  stockLocationCode: string;
+  stockLocationName?: string | null;
+  stockedQuantity: number;
+  storeId?: string | null;
+};
+
+type ExchangeImage = {
+  rank?: number | null;
+  url: string;
+};
+
+type ExchangeVariant = {
+  attributes?: ExchangeAttributeValue[];
+  externalSku: string;
+  inventory?: ExchangeInventoryLevel[];
+  isActive?: boolean | null;
+  manageInventory?: boolean | null;
+  metadata?: Record<string, ExtensionJson> | null;
+  options?: Record<string, ExchangeOptionValue>;
+  prices?: {
+    base?: ExchangePrice | null;
+    lists?: ExchangePriceListPrice[];
+  };
+  title?: string | null;
+};
+
+type ExchangeProduct = {
+  attributes?: ExchangeAttributeValue[];
+  categoryId?: string | null;
+  description?: string | null;
+  images?: ExchangeImage[];
+  metadata?: Record<string, ExtensionJson> | null;
+  slug: string;
+  status?: string | null;
+  subtitle?: string | null;
+  thumbnail?: string | null;
+  title: string;
+  variants: ExchangeVariant[];
+};
+
+type ExchangeDocument = {
+  products: ExchangeProduct[];
+  source: string;
+  storeId?: string | null;
+};
+
+type ExchangeApplyResult = {
+  attributesUpserted: number;
+  imagesAdded: number;
+  inventorySynced: number;
+  priceListPricesSet: number;
+  priceListsUpserted: number;
+  pricesSet: number;
+  productsCreated: number;
+  productsUpdated: number;
+  rowsProcessed: number;
+  source: string;
+  variantOptionValuesLinked: number;
+  variantsCreated: number;
+  variantsUpdated: number;
+};
+
+declare function applyExchangeDocument(
+  brandMap: ExtensionBrandMapOperations,
+  document: ExchangeDocument,
+): Promise<ExchangeApplyResult>;
+
+export { applyExchangeDocument };
+export type {
+  ExchangeApplyResult,
+  ExchangeAttributeType,
+  ExchangeAttributeValue,
+  ExchangeDocument,
+  ExchangeImage,
+  ExchangeInventoryLevel,
+  ExchangeOptionValue,
+  ExchangePrice,
+  ExchangePriceListPrice,
+  ExchangeProduct,
+  ExchangeVariant,
+};

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@brand-map/exchange-core",
+  "version": "0.0.10-alpha.10",
+  "type": "module",
+  "main": "./dist/exports.js",
+  "module": "./dist/exports.js",
+  "types": "./dist/types/exports.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/exports.js",
+      "types": "./dist/types/exports.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "dependencies": {
+    "@brand-map/extension-sdk": "0.0.10-alpha.7"
+  }
+}