Inventory

"use client"

import { InventoryTable } from "@/components/blocks/inventory/inventory-table"
import type {
  InventoryAdjustment,
  InventoryItem,
  InventoryReason,
  InventorySaveResult,
} from "@/components/blocks/inventory/inventory"

const reasons: Record<InventoryReason, string> = {
  correction: "correction",
  received: "received",
  damaged: "damaged",
  theft_or_loss: "theft_or_loss",
  returned: "restock",
  cycle_count: "cycle_count_available",
}

const mutation = `
  mutation Adjust($input: InventoryAdjustQuantitiesInput!) {
    inventoryAdjustQuantities(input: $input) {
      userErrors { field message }
    }
  }
`

async function adjustOnShopify(
  locationId: string,
  adjustments: InventoryAdjustment[]
): Promise<InventorySaveResult> {
  const failed: InventorySaveResult["failed"] = []
  const groups = new Map<InventoryReason, InventoryAdjustment[]>()
  for (const adjustment of adjustments) {
    groups.set(adjustment.reason, [...(groups.get(adjustment.reason) ?? []), adjustment])
  }
  for (const [reason, group] of groups) {
    const response = await fetch("/api/shopify/graphql", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        query: mutation,
        variables: {
          input: {
            name: "available",
            reason: reasons[reason],
            changes: group.map((adjustment) => ({
              inventoryItemId: adjustment.itemId,
              locationId,
              delta: adjustment.delta,
              changeFromQuantity: adjustment.compareQuantity,
            })),
          },
        },
      }),
    })
    const { data } = await response.json()
    const errors: { field: string[] | null; message: string }[] =
      data.inventoryAdjustQuantities.userErrors
    for (const error of errors) {
      const index = Number(error.field?.[2])
      const itemId = group[index]?.itemId
      if (itemId) failed.push({ itemId, message: error.message })
    }
  }
  return { failed }
}

export function ShopifyInventory({
  items,
  locationId,
  locationName,
  refresh,
}: {
  items: InventoryItem[]
  locationId: string
  locationName: string
  refresh: () => Promise<void>
}) {
  return (
    <InventoryTable
      items={items}
      locationName={locationName}
      onSave={async (adjustments) => {
        const result = await adjustOnShopify(locationId, adjustments)
        await refresh()
        return result
      }}
    />
  )
}

"use client"

import * as React from "react"

import { InventoryTable } from "@/components/blocks/inventory/inventory-table"
import type { InventoryItem } from "@/components/blocks/inventory/inventory"

type MedusaLevel = {
  inventory_item_id: string
  location_id: string
  stocked_quantity: number
  reserved_quantity: number
  incoming_quantity: number
}

type MedusaVariant = {
  id: string
  title: string
  sku: string | null
  manage_inventory: boolean
  product: { title: string; thumbnail: string | null }
  inventory_items: { inventory_item_id: string }[]
}

function toItem(variant: MedusaVariant, level: MedusaLevel | undefined): InventoryItem {
  const stocked = level?.stocked_quantity ?? 0
  const reserved = level?.reserved_quantity ?? 0
  return {
    id: variant.inventory_items[0]?.inventory_item_id ?? variant.id,
    productTitle: variant.product.title,
    variantTitle: variant.title,
    sku: variant.sku ?? undefined,
    image: variant.product.thumbnail ? { src: variant.product.thumbnail } : undefined,
    tracked: variant.manage_inventory,
    available: stocked - reserved,
    committed: reserved,
    incoming: level?.incoming_quantity
      ? [{ id: "incoming", quantity: level.incoming_quantity }]
      : [],
  }
}

export function MedusaInventory({
  variants,
  levels,
  locationId,
}: {
  variants: MedusaVariant[]
  levels: MedusaLevel[]
  locationId: string
}) {
  const [current, setCurrent] = React.useState(levels)
  const items = variants.map((variant) =>
    toItem(
      variant,
      current.find(
        (level) =>
          level.location_id === locationId &&
          level.inventory_item_id === variant.inventory_items[0]?.inventory_item_id
      )
    )
  )

  return (
    <InventoryTable
      items={items}
      onSave={async (adjustments) => {
        const failed = []
        for (const adjustment of adjustments) {
          const response = await fetch(
            `/admin/inventory-items/${adjustment.itemId}/location-levels/${locationId}`,
            {
              method: "POST",
              credentials: "include",
              headers: { "Content-Type": "application/json" },
              body: JSON.stringify({ stocked_quantity: adjustment.compareQuantity + adjustment.delta }),
            }
          )
          if (!response.ok) {
            failed.push({ itemId: adjustment.itemId, message: "Medusa didn’t accept this change" })
            continue
          }
          const { inventory_item } = await response.json()
          setCurrent((levels) =>
            levels.map((level) =>
              level.inventory_item_id === adjustment.itemId && level.location_id === locationId
                ? { ...level, ...inventory_item.location_levels[0] }
                : level
            )
          )
        }
        return { failed }
      }}
    />
  )
}

import {
  fieldValue,
  parseQuantity,
  type InventoryAdjustment,
  type InventoryItem,
  type InventoryReason,
} from "@/components/blocks/inventory/inventory"

type CsvMapping = {
  sku: string
  quantity: string
  field?: "available" | "onHand"
}

type CsvPreview = {
  adjustments: InventoryAdjustment[]
  unknownSkus: string[]
  invalidRows: number[]
}

function parseCsv(text: string) {
  const [header, ...lines] = text.trim().split(/\r?\n/)
  const columns = header.split(",").map((cell) => cell.trim().replace(/^"|"$/g, ""))
  return lines.map((line) => {
    const cells = line.split(",").map((cell) => cell.trim().replace(/^"|"$/g, ""))
    return Object.fromEntries(columns.map((column, index) => [column, cells[index] ?? ""]))
  })
}

export function previewCsvImport(
  text: string,
  items: InventoryItem[],
  mapping: CsvMapping,
  reason: InventoryReason = "cycle_count"
): CsvPreview {
  const field = mapping.field ?? "available"
  const bySku = new Map(items.map((item) => [item.sku?.toLowerCase(), item]))
  const preview: CsvPreview = { adjustments: [], unknownSkus: [], invalidRows: [] }

  parseCsv(text).forEach((row, index) => {
    const sku = row[mapping.sku]?.toLowerCase()
    const item = sku ? bySku.get(sku) : undefined
    const quantity = parseQuantity(row[mapping.quantity] ?? "")
    if (!item) {
      if (sku) preview.unknownSkus.push(row[mapping.sku])
      return
    }
    if (quantity === null || Number.isNaN(quantity) || quantity < 0) {
      preview.invalidRows.push(index + 2)
      return
    }
    const current = fieldValue(item, field)
    if (quantity === current || item.tracked === false) return
    preview.adjustments.push({
      itemId: item.id,
      field,
      delta: quantity - current,
      quantity,
      compareQuantity: current,
      reason,
    })
  })

  return preview
}