@medusajs/dashboard 0.0.1

package/src/lib/discounts.ts

@@ -0,0 +1,32 @@
+import { Discount } from "@medusajs/medusa"
+import { end, parse } from "iso8601-duration"
+
+export enum PromotionStatus {
+  SCHEDULED = "SCHEDULED",
+  EXPIRED = "EXPIRED",
+  ACTIVE = "ACTIVE",
+  DISABLED = "DISABLED",
+}
+
+export const getDiscountStatus = (discount: Discount) => {
+  if (discount.is_disabled) {
+    return PromotionStatus.DISABLED
+  }
+
+  const date = new Date()
+  if (new Date(discount.starts_at) > date) {
+    return PromotionStatus.SCHEDULED
+  }
+
+  if (
+    (discount.ends_at && new Date(discount.ends_at) < date) ||
+    (discount.valid_duration &&
+      date >
+        end(parse(discount.valid_duration), new Date(discount.starts_at))) ||
+    discount.usage_count === discount.usage_limit
+  ) {
+    return PromotionStatus.EXPIRED
+  }
+
+  return PromotionStatus.ACTIVE
+}

package/src/lib/format-provider.ts

@@ -0,0 +1,18 @@
+/**
+ * Providers only have an ID to identify them. This function formats the ID
+ * into a human-readable string.
+ *
+ * Format example: pp_stripe-blik_dkk
+ *
+ * @param id - The ID of the provider
+ * @returns A formatted string
+ */
+export const formatProvider = (id: string) => {
+  const [_, name, type] = id.split("_")
+  return (
+    name
+      .split("-")
+      .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
+      .join(" ") + (type ? ` (${type.toUpperCase()})` : "")
+  )
+}

package/src/lib/is-axios-error.ts

@@ -0,0 +1,5 @@
+import type { AxiosError } from "axios"
+
+export const isAxiosError = (error: any): error is AxiosError => {
+  return error.isAxiosError
+}

package/src/lib/medusa.ts

@@ -0,0 +1,19 @@
+import Medusa from "@medusajs/medusa-js"
+import { QueryClient } from "@tanstack/react-query"
+
+export const MEDUSA_BACKEND_URL = __BACKEND_URL__ || "http://localhost:9000"
+
+export const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      refetchOnWindowFocus: false,
+      staleTime: 90000,
+      retry: 1,
+    },
+  },
+})
+
+export const medusa = new Medusa({
+  baseUrl: MEDUSA_BACKEND_URL,
+  maxRetries: 1,
+})

package/src/lib/metadata.ts

@@ -0,0 +1,84 @@
+export type MetadataField = {
+  key: string
+  value: string
+  /**
+   * Is the field provided as initial data
+   */
+  isInitial?: boolean
+  /**
+   * Whether the row was deleted
+   */
+  isDeleted?: boolean
+  /**
+   * True for initial values that are not primitives
+   */
+  isIgnored?: boolean
+}
+
+const isPrimitive = (value: any): boolean => {
+  return (
+    value === null ||
+    value === undefined ||
+    typeof value === "string" ||
+    typeof value === "number" ||
+    typeof value === "boolean"
+  )
+}
+
+/**
+ * Convert metadata property to an array of form filed values.
+ */
+export const metadataToFormValues = (
+  metadata?: Record<string, any> | null
+): MetadataField[] => {
+  const data: MetadataField[] = []
+
+  if (metadata) {
+    Object.entries(metadata).forEach(([key, value]) => {
+      data.push({
+        key,
+        value: value as string,
+        isInitial: true,
+        isIgnored: !isPrimitive(value),
+        isDeleted: false,
+      })
+    })
+  }
+
+  // DEFAULT field for adding a new metadata record
+  // it's added here so it's registered as a default value
+  data.push({
+    key: "",
+    value: "",
+    isInitial: false,
+    isIgnored: false,
+    isDeleted: false,
+  })
+
+  return data
+}
+
+/**
+ * Convert a form fields array to a metadata object
+ */
+export const formValuesToMetadata = (
+  data: MetadataField[]
+): Record<string, unknown> => {
+  return data.reduce((acc, { key, value, isDeleted, isIgnored, isInitial }) => {
+    if (isIgnored) {
+      acc[key] = value
+      return acc
+    }
+
+    if (isDeleted && isInitial) {
+      acc[key] = ""
+      return acc
+    }
+
+    if (key) {
+      acc[key] = value // TODO: since these are primitives should we parse strings to their primitive format e.g. "123" -> 123 , "true" -> true
+    }
+
+    return acc
+  }, {} as Record<string, unknown>)
+}

package/src/lib/money-amount-helpers.ts

@@ -0,0 +1,95 @@
+import { currencies } from "./currencies"
+
+export const getDecimalDigits = (currency: string) => {
+  return currencies[currency.toUpperCase()]?.decimal_digits ?? 0
+}
+
+/**
+ * Converts an amount from the database format (cents) to the presentational format
+ *
+ * @param amount - The amount to format
+ * @param currency - The currency code to format the amount in
+ * @returns The formatted amount
+ *
+ * @example
+ * getPresentationalAmount(1000, "usd") // 10
+ * getPresentationalAmount(1000, "jpy") // 1000
+ */
+export const getPresentationalAmount = (amount: number, currency: string) => {
+  const decimalDigits = getDecimalDigits(currency)
+
+  if (decimalDigits === undefined) {
+    throw new Error("Currency has no decimal digits")
+  }
+
+  return amount / 10 ** decimalDigits
+}
+
+/**
+ * Converts an amount to the database format (cents)
+ * @param amount - The amount to convert to the database amount
+ * @param currency - The currency code to convert the amount to
+ * @returns The amount in the database format
+ *
+ * @example
+ * getDbAmount(10.5, "usd") // 1050
+ * getDbAmount(10, "jpy") // 10
+ */
+export const getDbAmount = (amount: number, currency: string) => {
+  const decimalDigits = getDecimalDigits(currency)
+
+  if (decimalDigits === undefined) {
+    throw new Error("Currency has no decimal digits")
+  }
+
+  return amount * 10 ** decimalDigits
+}
+
+/**
+ * Returns a formatted amount based on the currency code using the browser's locale
+ * @param amount - The amount to format
+ * @param currencyCode - The currency code to format the amount in
+ * @returns - The formatted amount
+ *
+ * @example
+ * getFormattedAmount(1000, "usd") // '$10.00' if the browser's locale is en-US
+ * getFormattedAmount(1000, "usd") // '10,00 $' if the browser's locale is fr-FR
+ */
+export const getLocaleAmount = (amount: number, currencyCode: string) => {
+  const formatter = new Intl.NumberFormat(undefined, {
+    style: "currency",
+    currencyDisplay: "narrowSymbol",
+    currency: currencyCode,
+  })
+
+  return formatter.format(getPresentationalAmount(amount, currencyCode))
+}
+
+export const getNativeSymbol = (currencyCode: string) => {
+  const formatted = new Intl.NumberFormat(undefined, {
+    style: "currency",
+    currency: currencyCode,
+    currencyDisplay: "narrowSymbol",
+  }).format(0)
+
+  return formatted.replace(/\d/g, "").replace(/[.,]/g, "").trim()
+}
+
+/**
+ * In some cases we want to display the amount with the currency code and symbol,
+ * in the format of "symbol amount currencyCode". This breaks from the
+ * user's locale and is only used in cases where we want to display the
+ * currency code and symbol explicitly, e.g. for totals.
+ */
+export const getStylizedAmount = (amount: number, currencyCode: string) => {
+  const symbol = getNativeSymbol(currencyCode)
+  const decimalDigits = getDecimalDigits(currencyCode)
+  const presentationAmount = getPresentationalAmount(amount, currencyCode)
+
+  const total = presentationAmount.toLocaleString(undefined, {
+    minimumFractionDigits: decimalDigits,
+    maximumFractionDigits: decimalDigits,
+  })
+
+  return `${symbol} ${total} ${currencyCode.toUpperCase()}`
+}

package/src/lib/order-helpers.ts

@@ -0,0 +1,52 @@
+import { FulfillmentStatus, PaymentStatus } from "@medusajs/medusa"
+import { TFunction } from "i18next"
+
+export const getOrderPaymentStatus = (
+  t: TFunction<"translation">,
+  status: PaymentStatus
+) => {
+  const [label, color] = ({
+    not_paid: [t("orders.payment.status.notPaid"), "red"],
+    awaiting: [t("orders.payment.status.awaiting"), "orange"],
+    captured: [t("orders.payment.status.captured"), "green"],
+    refunded: [t("orders.payment.status.refunded"), "green"],
+    partially_refunded: [
+      t("orders.payment.status.partiallyRefunded"),
+      "orange",
+    ],
+    canceled: [t("orders.payment.status.canceled"), "red"],
+    requires_action: [t("orders.payment.status.requiresAction"), "orange"],
+  }[status] ||
+    // TODO: remove this when Order<>Payment are linked
+    "not_paid") as [string, "red" | "orange" | "green"]
+
+  return { label, color }
+}
+
+export const getOrderFulfillmentStatus = (
+  t: TFunction<"translation">,
+  status: FulfillmentStatus
+) => {
+  const [label, color] = {
+    not_fulfilled: [t("orders.fulfillment.status.notFulfilled"), "red"],
+    partially_fulfilled: [
+      t("orders.fulfillment.status.partiallyFulfilled"),
+      "orange",
+    ],
+    fulfilled: [t("orders.fulfillment.status.fulfilled"), "green"],
+    partially_shipped: [
+      t("orders.fulfillment.status.partiallyShipped"),
+      "orange",
+    ],
+    shipped: [t("orders.fulfillment.status.shipped"), "green"],
+    partially_returned: [
+      t("orders.fulfillment.status.partiallyReturned"),
+      "orange",
+    ],
+    returned: [t("orders.fulfillment.status.returned"), "green"],
+    canceled: [t("orders.fulfillment.status.canceled"), "red"],
+    requires_action: [t("orders.fulfillment.status.requiresAction"), "orange"],
+  }[status] as [string, "red" | "orange" | "green"]
+
+  return { label, color }
+}

package/src/lib/percentage-helpers.ts

@@ -0,0 +1,27 @@
+const formatter = new Intl.NumberFormat(undefined, {
+  style: "percent",
+  minimumFractionDigits: 2,
+})
+
+/**
+ * Formats a number as a percentage
+ * @param value - The value to format
+ * @param isPercentageValue - Whether the value is already a percentage value (where `0` is 0%, `0.5` is 50%, `0.75` is 75%, etc). Defaults to false
+ * @returns The formatted percentage in the form of a localized string
+ *
+ * @example
+ * formatPercentage(0.5, true) // "50%"
+ * formatPercentage(50) // "50%"
+ */
+export const formatPercentage = (
+  value?: number | null,
+  isPercentageValue = false
+) => {
+  let val = value || 0
+
+  if (!isPercentageValue) {
+    val = val / 100
+  }
+
+  return formatter.format(val)
+}

package/src/lib/promotions.ts

@@ -0,0 +1,31 @@
+import { PromotionDTO } from "@medusajs/types"
+
+export enum PromotionStatus {
+  SCHEDULED = "SCHEDULED",
+  EXPIRED = "EXPIRED",
+  ACTIVE = "ACTIVE",
+  DISABLED = "DISABLED",
+}
+
+export const getPromotionStatus = (promotion: PromotionDTO) => {
+  const date = new Date()
+  const campaign = promotion.campaign
+
+  if (!campaign) {
+    return PromotionStatus.ACTIVE
+  }
+
+  if (new Date(campaign.starts_at!) > date) {
+    return PromotionStatus.SCHEDULED
+  }
+
+  const campaignBudget = campaign.budget
+  const overBudget =
+    campaignBudget && campaignBudget.used! > campaignBudget.limit!
+
+  if ((campaign.ends_at && new Date(campaign.ends_at) < date) || overBudget) {
+    return PromotionStatus.EXPIRED
+  }
+
+  return PromotionStatus.ACTIVE
+}

package/src/lib/query-key-factory.ts

@@ -0,0 +1,54 @@
+import { QueryKey, UseQueryOptions } from "@tanstack/react-query"
+
+type TQueryKey<TKey, TListQuery = any, TDetailQuery = string> = {
+  all: readonly [TKey]
+  lists: () => readonly [...TQueryKey<TKey>["all"], "list"]
+  list: (
+    query?: TListQuery
+  ) => readonly [
+    ...ReturnType<TQueryKey<TKey>["lists"]>,
+    { query: TListQuery | undefined },
+  ]
+  details: () => readonly [...TQueryKey<TKey>["all"], "detail"]
+  detail: (
+    id: TDetailQuery,
+    query?: TListQuery
+  ) => readonly [
+    ...ReturnType<TQueryKey<TKey>["details"]>,
+    TDetailQuery,
+    { query: TListQuery | undefined },
+  ]
+}
+
+export type UseQueryOptionsWrapper<
+  // Return type of queryFn
+  TQueryFn = unknown,
+  // Type thrown in case the queryFn rejects
+  E = Error,
+  // Query key type
+  TQueryKey extends QueryKey = QueryKey,
+> = Omit<
+  UseQueryOptions<TQueryFn, E, TQueryFn, TQueryKey>,
+  "queryKey" | "queryFn"
+>
+
+export const queryKeysFactory = <
+  T,
+  TListQueryType = any,
+  TDetailQueryType = string,
+>(
+  globalKey: T
+) => {
+  const queryKeyFactory: TQueryKey<T, TListQueryType, TDetailQueryType> = {
+    all: [globalKey],
+    lists: () => [...queryKeyFactory.all, "list"],
+    list: (query?: TListQueryType) => [...queryKeyFactory.lists(), { query }],
+    details: () => [...queryKeyFactory.all, "detail"],
+    detail: (id: TDetailQueryType, query?: TListQueryType) => [
+      ...queryKeyFactory.details(),
+      id,
+      { query },
+    ],
+  }
+  return queryKeyFactory
+}

package/src/lib/rma.ts

@@ -0,0 +1,75 @@
+import { ClaimItem, LineItem, Order } from "@medusajs/medusa"
+
+/**
+ * Return line items that are returnable from an order
+ * @param order
+ * @param isClaim
+ */
+export const getAllReturnableItems = (
+  order: Omit<Order, "beforeInserts">,
+  isClaim: boolean
+) => {
+  let orderItems = order.items.reduce(
+    (map, obj) =>
+      map.set(obj.id, {
+        ...obj,
+      }),
+    new Map<string, Omit<LineItem, "beforeInsert">>()
+  )
+
+  let claimedItems: ClaimItem[] = []
+
+  if (order.claims && order.claims.length) {
+    for (const claim of order.claims) {
+      if (claim.return_order?.status !== "canceled") {
+        claim.claim_items = claim.claim_items ?? []
+        claimedItems = [...claimedItems, ...claim.claim_items]
+      }
+
+      if (
+        claim.fulfillment_status === "not_fulfilled" &&
+        claim.payment_status === "na"
+      ) {
+        continue
+      }
+
+      if (claim.additional_items && claim.additional_items.length) {
+        orderItems = claim.additional_items
+          .filter(
+            (it) =>
+              it.shipped_quantity ||
+              it.shipped_quantity === it.fulfilled_quantity
+          )
+          .reduce((map, obj) => map.set(obj.id, { ...obj }), orderItems)
+      }
+    }
+  }
+
+  if (!isClaim) {
+    if (order.swaps && order.swaps.length) {
+      for (const swap of order.swaps) {
+        if (swap.fulfillment_status === "not_fulfilled") {
+          continue
+        }
+
+        orderItems = swap.additional_items.reduce(
+          (map, obj) =>
+            map.set(obj.id, {
+              ...obj,
+            }),
+          orderItems
+        )
+      }
+    }
+  }
+
+  for (const item of claimedItems) {
+    const i = orderItems.get(item.item_id)
+    if (i) {
+      i.quantity = i.quantity - item.quantity
+      i.quantity !== 0 ? orderItems.set(i.id, i) : orderItems.delete(i.id)
+    }
+  }
+
+  return [...orderItems.values()]
+}

package/src/lib/schemas.ts

@@ -0,0 +1,36 @@
+import i18n from "i18next"
+import { z } from "zod"
+
+export const AddressSchema = z.object({
+  first_name: z.string().min(1),
+  last_name: z.string().min(1),
+  company: z.string().optional(),
+  address_1: z.string().min(1),
+  address_2: z.string().optional(),
+  city: z.string().min(1),
+  postal_code: z.string().min(1),
+  province: z.string().optional(),
+  country_code: z.string().min(1),
+  phone: z.string().optional(),
+})
+
+export const EmailSchema = z.object({
+  email: z.string().email(),
+})
+
+export const TransferOwnershipSchema = z
+  .object({
+    current_owner_id: z.string().min(1),
+    new_owner_id: z
+      .string()
+      .min(1, i18n.t("transferOwnership.validation.required")),
+  })
+  .superRefine((data, ctx) => {
+    if (data.current_owner_id === data.new_owner_id) {
+      return ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["new_owner_id"],
+        message: i18n.t("transferOwnership.validation.mustBeDifferent"),
+      })
+    }
+  })

package/src/lib/shipping-options.ts

@@ -0,0 +1,17 @@
+import { ShippingOptionDTO } from "@medusajs/types"
+
+export function isReturnOption(shippingOption: ShippingOptionDTO) {
+  return !!shippingOption.rules?.find(
+    (r) =>
+      r.attribute === "is_return" && r.value === "true" && r.operator === "eq"
+  )
+}
+
+export function isOptionEnabledInStore(shippingOption: ShippingOptionDTO) {
+  return !!shippingOption.rules?.find(
+    (r) =>
+      r.attribute === "enabled_in_store" &&
+      r.value === "true" &&
+      r.operator === "eq"
+  )
+}

package/src/lib/validation.ts

@@ -0,0 +1,47 @@
+import i18next from "i18next"
+import { z } from "zod"
+import { castNumber } from "./cast-number"
+
+/**
+ * Validates that an optional value is an integer.
+ */
+export const optionalInt = z
+  .union([z.string(), z.number()])
+  .optional()
+  .refine(
+    (value) => {
+      if (value === "" || value === undefined) {
+        return true
+      }
+
+      return Number.isInteger(castNumber(value))
+    },
+    {
+      message: i18next.t("validation.mustBeInt"),
+    }
+  )
+  .refine(
+    (value) => {
+      if (value === "" || value === undefined) {
+        return true
+      }
+
+      return castNumber(value) >= 0
+    },
+    {
+      message: i18next.t("validation.mustBePositive"),
+    }
+  )
+
+/**
+ * Schema for metadata form.
+ */
+export const metadataFormSchema = z.array(
+  z.object({
+    key: z.string(),
+    value: z.unknown(),
+    isInitial: z.boolean().optional(),
+    isDeleted: z.boolean().optional(),
+    isIgnored: z.boolean().optional(),
+  })
+)

package/src/main.tsx

@@ -0,0 +1,9 @@
+import React from "react"
+import ReactDOM from "react-dom/client"
+import App from "./app.js"
+
+ReactDOM.createRoot(document.getElementById("root")!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>
+)

package/src/module.d.ts

@@ -0,0 +1,39 @@
+declare module "medusa-admin:widgets/*" {
+  const widgets: { Component: () => JSX.Element }[]
+
+  export default {
+    widgets,
+  }
+}
+
+declare module "medusa-admin:routes/links" {
+  const links: { path: string; label: string; icon?: React.ComponentType }[]
+
+  export default {
+    links,
+  }
+}
+
+declare module "medusa-admin:routes/pages" {
+  const pages: { path: string; file: string }[]
+
+  export default {
+    pages,
+  }
+}
+
+declare module "medusa-admin:settings/cards" {
+  const cards: { path: string; label: string; description: string }[]
+
+  export default {
+    cards,
+  }
+}
+
+declare module "medusa-admin:settings/pages" {
+  const pages: { path: string; file: string }[]
+
+  export default {
+    pages,
+  }
+}

package/src/providers/feature-provider/feature-context.tsx

@@ -0,0 +1,8 @@
+import { createContext } from "react"
+import { Feature } from "./types"
+
+type FeatureContextValue = {
+  isFeatureEnabled: (feature: Feature) => boolean
+}
+
+export const FeatureContext = createContext<FeatureContextValue | null>(null)