Medusa Fulfillment Manual

// The service is available through Medusa's container system
const manualFulfillmentService = container.resolve("manualFulfillmentService");

import ManualFulfillmentService from "medusa-fulfillment-manual/src/services/manual-fulfillment";

const plugins = [
  // ... other plugins
  "medusa-fulfillment-manual"
];

module.exports = {
  projectConfig: {
    // ... other config
  },
  plugins,
};

/**
 * Manual fulfillment service that extends Medusa's FulfillmentService
 * Provides no-operation implementations for all fulfillment operations
 */
class ManualFulfillmentService extends FulfillmentService {
  /** Unique identifier for this fulfillment provider */
  static identifier: string; // "manual"

  constructor();

  /** Returns available fulfillment options for orders and returns */
  getFulfillmentOptions(): FulfillmentOption[];

  /** Validates fulfillment data (pass-through implementation) */
  validateFulfillmentData(
    optionData: any,
    data: any,
    cart: any
  ): any;

  /** Validates fulfillment options (always returns true) */
  validateOption(data: any): boolean;

  /** Indicates whether service can calculate shipping prices */
  canCalculate(): boolean; // Always returns false

  /** Throws error - manual service cannot calculate prices */
  calculatePrice(): never;

  /** Creates order fulfillment (no-operation) */
  createOrder(): Promise<{}>;

  /** Creates return fulfillment (no-operation) */
  createReturn(): Promise<{}>;

  /** Creates fulfillment (no-operation) */
  createFulfillment(): Promise<{}>;

  /** Cancels fulfillment (no-operation) */
  cancelFulfillment(): Promise<{}>;

  /** Retrieves fulfillment documents (returns empty array) */
  retrieveDocuments(): Promise<[]>;
}

/**
 * Fulfillment option configuration
 */
interface FulfillmentOption {
  /** Unique identifier for the fulfillment option */
  id: string;
  /** Optional flag indicating if this is a return option */
  is_return?: boolean;
}

/**
 * Static identifier for the manual fulfillment provider
 * Used by Medusa to register and identify this provider
 */
static identifier = "manual";

/**
 * Validates fulfillment data before processing
 * @param optionData - Option-specific data (unused)
 * @param data - Fulfillment data to validate
 * @param cart - Cart object (unused)
 * @returns The original data unchanged
 */
validateFulfillmentData(optionData: any, data: any, cart: any): any;

/**
 * Validates fulfillment options
 * @param data - Option data to validate
 * @returns true - Always validates successfully
 */
validateOption(data: any): boolean;

/**
 * Indicates whether this service can calculate shipping prices
 * @returns false - Manual service cannot calculate prices
 */
canCalculate(): boolean;

/**
 * Attempts to calculate shipping price
 * @throws Error - Manual Fulfillment service cannot calculatePrice
 */
calculatePrice(): never;

/**
 * Creates an order fulfillment
 * @returns Promise resolving to empty object
 */
createOrder(): Promise<{}>;

/**
 * Creates a return fulfillment  
 * @returns Promise resolving to empty object
 */
createReturn(): Promise<{}>;

/**
 * Creates a fulfillment
 * @returns Promise resolving to empty object
 */
createFulfillment(): Promise<{}>;

/**
 * Cancels a fulfillment
 * @returns Promise resolving to empty object
 */
cancelFulfillment(): Promise<{}>;

/**
 * Retrieves fulfillment documents
 * @returns Promise resolving to empty array
 */
retrieveDocuments(): Promise<[]>;

/**
 * Base class from medusa-interfaces
 */
abstract class FulfillmentService {
  // Base implementation provided by Medusa
}