@use-stall/core 0.0.1 → 0.0.2

package/dist/index.js

@@ -20,20 +20,1300 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  capitalize: () => capitalize,
-  toPureString: () => toPureString
+  BaseService: () => BaseService,
+  ConnectorLoader: () => ConnectorLoader,
+  ErrorCodes: () => ErrorCodes,
+  Logger: () => Logger,
+  MockConnectorPlugin: () => MockConnectorPlugin,
+  OrdersService: () => OrdersService,
+  PluginManager: () => PluginManager,
+  ProductsService: () => ProductsService,
+  StallConnectorError: () => StallConnectorError,
+  StallCore: () => StallCore,
+  createErrorResponse: () => createErrorResponse,
+  createLogger: () => createLogger,
+  generateRequestId: () => generateRequestId,
+  handleConnectorError: () => handleConnectorError
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/lib/utils.ts
-var capitalize = (str) => {
-  return str.charAt(0).toUpperCase() + str.slice(1);
+// src/utils/logger.ts
+var Logger = class {
+  level;
+  context;
+  constructor(context = "Stall", level = "info") {
+    this.context = context;
+    this.level = level;
+  }
+  shouldLog(level) {
+    const levels = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3
+    };
+    return levels[level] >= levels[this.level];
+  }
+  format(level, message, data) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const prefix = `[${timestamp}] [${this.context}] [${level.toUpperCase()}]`;
+    if (data) {
+      return `${prefix} ${message} ${JSON.stringify(data)}`;
+    }
+    return `${prefix} ${message}`;
+  }
+  debug(message, data) {
+    if (this.shouldLog("debug")) {
+      console.debug(this.format("debug", message, data));
+    }
+  }
+  info(message, data) {
+    if (this.shouldLog("info")) {
+      console.info(this.format("info", message, data));
+    }
+  }
+  warn(message, data) {
+    if (this.shouldLog("warn")) {
+      console.warn(this.format("warn", message, data));
+    }
+  }
+  error(message, error) {
+    if (this.shouldLog("error")) {
+      const data = error instanceof Error ? { message: error.message, stack: error.stack } : error;
+      console.error(this.format("error", message, data));
+    }
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+};
+function createLogger(context = "Stall", level = "info") {
+  return new Logger(context, level);
+}
+
+// src/utils/error-handler.ts
+var StallConnectorError = class extends Error {
+  code;
+  details;
+  statusCode;
+  constructor(message, code, statusCode, details) {
+    super(message);
+    this.name = "StallConnectorError";
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+  }
+};
+var ErrorCodes = {
+  // Initialization errors
+  INVALID_CONFIGURATION: "INVALID_CONFIGURATION",
+  MISSING_CREDENTIALS: "MISSING_CREDENTIALS",
+  INVALID_CREDENTIALS: "INVALID_CREDENTIALS",
+  PLUGIN_LOAD_FAILED: "PLUGIN_LOAD_FAILED",
+  PLUGIN_NOT_FOUND: "PLUGIN_NOT_FOUND",
+  // Operation errors
+  OPERATION_FAILED: "OPERATION_FAILED",
+  OPERATION_TIMEOUT: "OPERATION_TIMEOUT",
+  OPERATION_NOT_SUPPORTED: "OPERATION_NOT_SUPPORTED",
+  // Network errors
+  NETWORK_ERROR: "NETWORK_ERROR",
+  REQUEST_FAILED: "REQUEST_FAILED",
+  RATE_LIMITED: "RATE_LIMITED",
+  // Validation errors
+  VALIDATION_FAILED: "VALIDATION_FAILED",
+  INVALID_DATA: "INVALID_DATA",
+  MISSING_REQUIRED_FIELD: "MISSING_REQUIRED_FIELD",
+  // Authentication errors
+  UNAUTHORIZED: "UNAUTHORIZED",
+  FORBIDDEN: "FORBIDDEN",
+  TOKEN_EXPIRED: "TOKEN_EXPIRED",
+  // Server errors
+  INTERNAL_ERROR: "INTERNAL_ERROR",
+  SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE"
+};
+function handleConnectorError(error, context) {
+  if (error instanceof StallConnectorError) {
+    return error;
+  }
+  if (error?.response) {
+    const statusCode = error.response.status;
+    const data = error.response.data || error.response.body;
+    let code = ErrorCodes.REQUEST_FAILED;
+    if (statusCode === 401) code = ErrorCodes.UNAUTHORIZED;
+    else if (statusCode === 403) code = ErrorCodes.FORBIDDEN;
+    else if (statusCode === 429) code = ErrorCodes.RATE_LIMITED;
+    else if (statusCode >= 500) code = ErrorCodes.INTERNAL_ERROR;
+    return new StallConnectorError(
+      `${context}: ${data?.message || error.message}`,
+      code,
+      statusCode,
+      data
+    );
+  }
+  if (error?.code === "ECONNABORTED" || error?.message?.includes("timeout")) {
+    return new StallConnectorError(
+      `${context}: Operation timed out`,
+      ErrorCodes.OPERATION_TIMEOUT
+    );
+  }
+  if (error?.code === "ECONNREFUSED" || error?.code === "ENOTFOUND" || error?.message?.includes("network")) {
+    return new StallConnectorError(
+      `${context}: Network error - ${error.message}`,
+      ErrorCodes.NETWORK_ERROR
+    );
+  }
+  if (error?.name === "ValidationError") {
+    return new StallConnectorError(
+      `${context}: Validation failed - ${error.message}`,
+      ErrorCodes.VALIDATION_FAILED,
+      400,
+      error.details
+    );
+  }
+  return new StallConnectorError(
+    `${context}: ${error.message || "Unknown error"}`,
+    ErrorCodes.OPERATION_FAILED,
+    void 0,
+    error
+  );
+}
+function createErrorResponse(error, operation, connectorId) {
+  const isStallError = error instanceof StallConnectorError;
+  return {
+    success: false,
+    error: {
+      code: isStallError ? error.code : ErrorCodes.OPERATION_FAILED,
+      message: error.message,
+      details: isStallError ? error.details : void 0
+    },
+    metadata: {
+      connector_id: connectorId,
+      operation,
+      timestamp: Date.now(),
+      request_id: generateRequestId()
+    }
+  };
+}
+function generateRequestId() {
+  return `req_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+
+// src/core/connector-loader.ts
+var ConnectorLoader = class {
+  logger;
+  connectorUrl;
+  cache = /* @__PURE__ */ new Map();
+  cacheTtl;
+  constructor(options) {
+    this.logger = new Logger("ConnectorLoader");
+    this.connectorUrl = options.connectorUrl;
+    this.cacheTtl = options.cacheTtl || 60 * 60 * 1e3;
+  }
+  /**
+   * Load a connector plugin from public URL
+   * URL pattern: {connectorUrl}/{integrationId}/index.js
+   */
+  async loadConnector(integrationId) {
+    const cacheKey = integrationId;
+    if (this.cache.has(cacheKey)) {
+      this.logger.debug(`Loaded ${integrationId} from cache`);
+      return this.cache.get(cacheKey);
+    }
+    try {
+      this.logger.info(`Loading connector plugin: ${integrationId}`);
+      const url = this.buildConnectorUrl(integrationId);
+      this.logger.debug(`Fetching from: ${url}`);
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(
+          `Failed to fetch connector: ${response.statusText} (${response.status})`
+        );
+      }
+      const code = await response.text();
+      const plugin = await this.instantiatePlugin(code, integrationId);
+      this.logger.info(`Successfully loaded ${integrationId}`);
+      this.cache.set(cacheKey, plugin);
+      return plugin;
+    } catch (error) {
+      this.logger.error(
+        `Failed to load connector ${integrationId}`,
+        error
+      );
+      throw new StallConnectorError(
+        `Failed to load connector plugin: ${integrationId}`,
+        ErrorCodes.PLUGIN_LOAD_FAILED,
+        void 0,
+        { originalError: error.message }
+      );
+    }
+  }
+  /**
+   * Instantiate a plugin from code
+   */
+  async instantiatePlugin(code, integrationId) {
+    try {
+      const moduleExports = {};
+      const module2 = { exports: moduleExports };
+      const fn = new Function(
+        "module",
+        "exports",
+        "require",
+        code + "\nreturn module.exports;"
+      );
+      const pluginModule = fn(
+        module2,
+        moduleExports,
+        this.createRequireProxy()
+      );
+      const PluginClass = pluginModule.default || pluginModule.Plugin;
+      if (!PluginClass) {
+        throw new Error("Plugin module does not export a default or Plugin");
+      }
+      const instance = new PluginClass();
+      if (!this.validatePlugin(instance)) {
+        throw new Error("Plugin does not implement IConnectorPlugin interface");
+      }
+      return instance;
+    } catch (error) {
+      throw new StallConnectorError(
+        `Failed to instantiate plugin: ${integrationId}`,
+        ErrorCodes.PLUGIN_LOAD_FAILED,
+        void 0,
+        { originalError: error.message }
+      );
+    }
+  }
+  /**
+   * Validate that an object implements IConnectorPlugin
+   */
+  validatePlugin(plugin) {
+    const requiredMethods = ["initialize", "verify", "getSupportedModules"];
+    const requiredModules = ["orders", "products", "customers", "inventory"];
+    for (const method of requiredMethods) {
+      if (typeof plugin[method] !== "function") {
+        this.logger.warn(`Plugin missing method: ${method}`);
+      }
+    }
+    for (const module2 of requiredModules) {
+      if (typeof plugin[module2] !== "object") {
+        this.logger.warn(`Plugin missing module: ${module2}`);
+      }
+    }
+    return true;
+  }
+  /**
+   * Build the connector plugin URL
+   * Pattern: {connectorUrl}/{integrationId}/index.js
+   */
+  buildConnectorUrl(integrationId) {
+    const baseUrl = this.connectorUrl.endsWith("/") ? this.connectorUrl.slice(0, -1) : this.connectorUrl;
+    return `${baseUrl}/${integrationId}/index.js`;
+  }
+  /**
+   * Create a proxy for require() in loaded plugins
+   */
+  createRequireProxy() {
+    return (id) => {
+      if (id === "@use-stall/types") {
+        return require("@use-stall/types");
+      }
+      if (id === "node:crypto" || id === "crypto") {
+        return require("crypto");
+      }
+      this.logger.warn(`Attempted to require unsupported module: ${id}`);
+      return {};
+    };
+  }
+  /**
+   * Clear the cache
+   */
+  clearCache() {
+    this.cache.clear();
+    this.logger.info("Plugin cache cleared");
+  }
+  /**
+   * Remove a specific plugin from cache
+   */
+  removeCacheEntry(integrationId) {
+    this.cache.delete(integrationId);
+    this.logger.info(`Removed ${integrationId} from cache`);
+  }
+};
+
+// src/core/plugin-manager.ts
+var PluginManager = class {
+  plugin = null;
+  logger;
+  connectorLoader = null;
+  initialized = false;
+  constructor(logLevel = "info") {
+    this.logger = new Logger("PluginManager", logLevel);
+  }
+  /**
+   * Initialize the plugin manager with a plugin
+   */
+  async initialize(plugin, options) {
+    try {
+      if (!plugin) {
+        const connectorUrl = options.options?.connectorUrl || "https://connectors.myapp.xyz";
+        this.connectorLoader = new ConnectorLoader({
+          connectorUrl,
+          cache: options.options?.cachePlugins !== false
+        });
+        plugin = await this.connectorLoader.loadConnector(
+          options.integration_id
+        );
+      }
+      if (!plugin) {
+        throw new StallConnectorError(
+          "Failed to load connector plugin",
+          ErrorCodes.PLUGIN_NOT_FOUND
+        );
+      }
+      this.plugin = plugin;
+      const pluginConfig = {
+        connectorId: options.id,
+        integrationId: options.integration_id,
+        organizationId: options.id,
+        // Use the config id as org context
+        configuration: options.configuration,
+        options: options.options
+      };
+      await this.plugin.initialize(pluginConfig);
+      this.logger.info(
+        `Plugin initialized: ${this.plugin.metadata.name}@${this.plugin.metadata.version}`
+      );
+      this.initialized = true;
+    } catch (error) {
+      this.logger.error("Failed to initialize plugin manager", error);
+      throw error;
+    }
+  }
+  /**
+   * Get the loaded plugin
+   */
+  getPlugin() {
+    if (!this.plugin) {
+      throw new StallConnectorError(
+        "Plugin not initialized",
+        ErrorCodes.INVALID_CONFIGURATION
+      );
+    }
+    return this.plugin;
+  }
+  /**
+   * Check if plugin is initialized
+   */
+  isInitialized() {
+    return this.initialized && this.plugin !== null;
+  }
+  /**
+   * Verify the plugin configuration
+   */
+  async verify() {
+    if (!this.isInitialized()) {
+      throw new StallConnectorError(
+        "Plugin not initialized",
+        ErrorCodes.INVALID_CONFIGURATION
+      );
+    }
+    const result = await this.plugin.verify();
+    return result.success && result.data === true;
+  }
+  /**
+   * Get metadata about the loaded plugin
+   */
+  getMetadata() {
+    if (!this.plugin) {
+      throw new StallConnectorError(
+        "Plugin not initialized",
+        ErrorCodes.INVALID_CONFIGURATION
+      );
+    }
+    return {
+      id: this.plugin.metadata.id,
+      name: this.plugin.metadata.name,
+      version: this.plugin.metadata.version,
+      description: this.plugin.metadata.description,
+      supportedModules: this.plugin.getSupportedModules()
+    };
+  }
+  /**
+   * Check if a module is supported
+   */
+  isModuleSupported(module2) {
+    if (!this.plugin) return false;
+    return this.plugin.getSupportedModules().includes(module2);
+  }
+  /**
+   * Clear plugin cache (if using remote loading)
+   */
+  clearCache() {
+    if (this.connectorLoader) {
+      this.connectorLoader.clearCache();
+      this.logger.info("Plugin cache cleared");
+    }
+  }
 };
-var toPureString = (str) => {
-  return str.replace(/\s+/gi, "").toLowerCase();
+
+// src/services/base.service.ts
+var BaseService = class {
+  logger;
+  pluginManager;
+  connectorId;
+  constructor(pluginManager, connectorId, serviceName) {
+    this.pluginManager = pluginManager;
+    this.connectorId = connectorId;
+    this.logger = new Logger(serviceName);
+  }
+  /**
+   * Wrap a connector operation with error handling and logging
+   */
+  async executeOperation(operation, fn) {
+    const requestId = generateRequestId();
+    const startTime = Date.now();
+    try {
+      this.logger.debug(`[${requestId}] Starting operation: ${operation}`);
+      const result = await fn();
+      const duration = Date.now() - startTime;
+      this.logger.info(
+        `[${requestId}] Operation completed: ${operation} (${duration}ms)`,
+        { success: result.success }
+      );
+      return {
+        ...result,
+        metadata: {
+          ...result.metadata,
+          connector_id: this.connectorId,
+          operation,
+          timestamp: Date.now(),
+          request_id: requestId
+        }
+      };
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      this.logger.error(
+        `[${requestId}] Operation failed: ${operation} (${duration}ms)`,
+        error
+      );
+      return createErrorResponse(
+        error,
+        operation,
+        this.connectorId
+      );
+    }
+  }
+  /**
+   * Check if a module is supported
+   */
+  isModuleSupported(module2) {
+    return this.pluginManager.isModuleSupported(module2);
+  }
+  /**
+   * Get the plugin instance
+   */
+  getPlugin() {
+    return this.pluginManager.getPlugin();
+  }
+  /**
+   * Verify plugin is ready
+   */
+  ensurePluginInitialized() {
+    if (!this.pluginManager.isInitialized()) {
+      throw new StallConnectorError(
+        "Plugin not initialized",
+        ErrorCodes.INVALID_CONFIGURATION
+      );
+    }
+  }
+};
+
+// src/services/orders.service.ts
+var OrdersService = class extends BaseService {
+  constructor(pluginManager, connectorId) {
+    super(pluginManager, connectorId, "OrdersService");
+  }
+  /**
+   * Create a new order
+   */
+  async createOrder(order) {
+    return this.executeOperation("orders.create", async () => {
+      this.ensurePluginInitialized();
+      if (!this.isModuleSupported("orders")) {
+        return {
+          success: false,
+          error: {
+            code: "MODULE_NOT_SUPPORTED",
+            message: "Orders module is not supported by this connector"
+          }
+        };
+      }
+      const plugin = this.getPlugin();
+      return plugin.orders.create(order);
+    });
+  }
+  /**
+   * Get an order by ID
+   */
+  async getOrder(orderId) {
+    return this.executeOperation("orders.get", async () => {
+      this.ensurePluginInitialized();
+      if (!this.isModuleSupported("orders")) {
+        return {
+          success: false,
+          error: {
+            code: "MODULE_NOT_SUPPORTED",
+            message: "Orders module is not supported by this connector"
+          }
+        };
+      }
+      const plugin = this.getPlugin();
+      return plugin.orders.get(orderId);
+    });
+  }
+  /**
+   * Update an existing order
+   */
+  async updateOrder(orderId, order) {
+    return this.executeOperation("orders.update", async () => {
+      this.ensurePluginInitialized();
+      if (!this.isModuleSupported("orders")) {
+        return {
+          success: false,
+          error: {
+            code: "MODULE_NOT_SUPPORTED",
+            message: "Orders module is not supported by this connector"
+          }
+        };
+      }
+      const plugin = this.getPlugin();
+      return plugin.orders.update(orderId, order);
+    });
+  }
+  /**
+   * Delete/cancel an order
+   */
+  async deleteOrder(orderId) {
+    return this.executeOperation("orders.delete", async () => {
+      this.ensurePluginInitialized();
+      if (!this.isModuleSupported("orders")) {
+        return {
+          success: false,
+          error: {
+            code: "MODULE_NOT_SUPPORTED",
+            message: "Orders module is not supported by this connector"
+          }
+        };
+      }
+      const plugin = this.getPlugin();
+      return plugin.orders.delete(orderId);
+    });
+  }
+  /**
+   * List orders with optional filtering
+   */
+  async listOrders(options) {
+    return this.executeOperation("orders.list", async () => {
+      this.ensurePluginInitialized();
+      if (!this.isModuleSupported("orders")) {
+        return {
+          success: false,
+          error: {
+            code: "MODULE_NOT_SUPPORTED",
+            message: "Orders module is not supported by this connector"
+          }
+        };
+      }
+      const plugin = this.getPlugin();
+      return plugin.orders.list(options);
+    });
+  }
+  /**
+   * Create a refund for an order
+   */
+  async createRefund(orderId, refund) {
+    return this.executeOperation("refunds.create", async () => {
+      this.ensurePluginInitialized();
+      if (!this.isModuleSupported("orders")) {
+        return {
+          success: false,
+          error: {
+            code: "MODULE_NOT_SUPPORTED",
+            message: "Orders module is not supported by this connector"
+          }
+        };
+      }
+      const plugin = this.getPlugin();
+      return plugin.refunds.create(orderId, refund);
+    });
+  }
+  /**
+   * Get a refund by ID
+   */
+  async getRefund(refundId) {
+    return this.executeOperation("refunds.get", async () => {
+      this.ensurePluginInitialized();
+      if (!this.isModuleSupported("orders")) {
+        return {
+          success: false,
+          error: {
+            code: "MODULE_NOT_SUPPORTED",
+            message: "Orders module is not supported by this connector"
+          }
+        };
+      }
+      const plugin = this.getPlugin();
+      return plugin.refunds.get(refundId);
+    });
+  }
+  /**
+   * List refunds for an order
+   */
+  async listRefunds(orderId, options) {
+    return this.executeOperation("refunds.list", async () => {
+      this.ensurePluginInitialized();
+      if (!this.isModuleSupported("orders")) {
+        return {
+          success: false,
+          error: {
+            code: "MODULE_NOT_SUPPORTED",
+            message: "Orders module is not supported by this connector"
+          }
+        };
+      }
+      const plugin = this.getPlugin();
+      return plugin.refunds.list(orderId, options);
+    });
+  }
+};
+
+// src/services/products.service.ts
+var ProductsService = class extends BaseService {
+  constructor(pluginManager, connectorId) {
+    super(pluginManager, connectorId, "ProductsService");
+  }
+  /**
+   * Create a new product
+   */
+  async createProduct(product) {
+    return this.executeOperation("products.create", async () => {
+      this.ensurePluginInitialized();
+      if (!this.isModuleSupported("products")) {
+        return {
+          success: false,
+          error: {
+            code: "MODULE_NOT_SUPPORTED",
+            message: "Products module is not supported by this connector"
+          }
+        };
+      }
+      const plugin = this.getPlugin();
+      return plugin.products.create(product);
+    });
+  }
+  /**
+   * Get a product by ID
+   */
+  async getProduct(productId) {
+    return this.executeOperation("products.get", async () => {
+      this.ensurePluginInitialized();
+      if (!this.isModuleSupported("products")) {
+        return {
+          success: false,
+          error: {
+            code: "MODULE_NOT_SUPPORTED",
+            message: "Products module is not supported by this connector"
+          }
+        };
+      }
+      const plugin = this.getPlugin();
+      return plugin.products.get(productId);
+    });
+  }
+  /**
+   * Update an existing product
+   */
+  async updateProduct(productId, product) {
+    return this.executeOperation("products.update", async () => {
+      this.ensurePluginInitialized();
+      if (!this.isModuleSupported("products")) {
+        return {
+          success: false,
+          error: {
+            code: "MODULE_NOT_SUPPORTED",
+            message: "Products module is not supported by this connector"
+          }
+        };
+      }
+      const plugin = this.getPlugin();
+      return plugin.products.update(productId, product);
+    });
+  }
+  /**
+   * Delete a product
+   */
+  async deleteProduct(productId) {
+    return this.executeOperation("products.delete", async () => {
+      this.ensurePluginInitialized();
+      if (!this.isModuleSupported("products")) {
+        return {
+          success: false,
+          error: {
+            code: "MODULE_NOT_SUPPORTED",
+            message: "Products module is not supported by this connector"
+          }
+        };
+      }
+      const plugin = this.getPlugin();
+      return plugin.products.delete(productId);
+    });
+  }
+  /**
+   * List products with optional filtering
+   */
+  async listProducts(options) {
+    return this.executeOperation("products.list", async () => {
+      this.ensurePluginInitialized();
+      if (!this.isModuleSupported("products")) {
+        return {
+          success: false,
+          error: {
+            code: "MODULE_NOT_SUPPORTED",
+            message: "Products module is not supported by this connector"
+          }
+        };
+      }
+      const plugin = this.getPlugin();
+      return plugin.products.list(options);
+    });
+  }
+};
+
+// src/core/sdk.ts
+var StallCore = class _StallCore {
+  pluginManager;
+  logger;
+  options;
+  // Service instances
+  orders;
+  products;
+  constructor(options) {
+    this.options = options;
+    const logLevel = options.options?.logLevel || "info";
+    this.logger = new Logger("StallSDK", logLevel);
+    this.pluginManager = new PluginManager(logLevel);
+    this.orders = new OrdersService(this.pluginManager, options.id);
+    this.products = new ProductsService(this.pluginManager, options.id);
+  }
+  /**
+   * Firebase-style initialization with automatic plugin loading
+   * Loads connector from public URL: {connectorUrl}/{integration_id}/index.js
+   * Default URL: https://connectors.myapp.xyz
+   */
+  static async initialize(options) {
+    const sdk = new _StallCore(options);
+    try {
+      await sdk.pluginManager.initialize(null, options);
+      sdk.logger.info("StallSDK initialized successfully");
+    } catch (error) {
+      sdk.logger.error("Failed to initialize StallSDK", error);
+      throw error;
+    }
+    return sdk;
+  }
+  /**
+   * Initialize with a provided plugin instance (for testing/custom plugins)
+   * Useful for mock plugins or custom implementations
+   */
+  static async initializeWithPlugin(options, plugin) {
+    const sdk = new _StallCore(options);
+    try {
+      await sdk.pluginManager.initialize(plugin, options);
+      sdk.logger.info("StallSDK initialized with custom plugin");
+    } catch (error) {
+      sdk.logger.error("Failed to initialize StallSDK", error);
+      throw error;
+    }
+    return sdk;
+  }
+  /**
+   * Get plugin metadata
+   */
+  getMetadata() {
+    return this.pluginManager.getMetadata();
+  }
+  /**
+   * Verify the connector configuration
+   */
+  async verify() {
+    return this.pluginManager.verify();
+  }
+  /**
+   * Check if a module is supported
+   */
+  isModuleSupported(module2) {
+    return this.pluginManager.isModuleSupported(module2);
+  }
+  /**
+   * Check if SDK is initialized
+   */
+  isInitialized() {
+    return this.pluginManager.isInitialized();
+  }
+  /**
+   * Clear plugin cache
+   */
+  clearCache() {
+    this.pluginManager.clearCache();
+  }
+  /**
+   * Get the underlying plugin instance
+   */
+  getPlugin() {
+    return this.pluginManager.getPlugin();
+  }
+  /**
+   * Get SDK configuration
+   */
+  getConfiguration() {
+    return {
+      id: this.options.id,
+      integration_id: this.options.integration_id,
+      created_at: this.options.created_at,
+      updated_at: this.options.updated_at
+    };
+  }
+};
+
+// src/plugins/mock-connector.plugin.ts
+var MockConnectorPlugin = class {
+  metadata = {
+    id: "mock",
+    name: "Mock Connector",
+    version: "1.0.0",
+    description: "Mock connector for development and testing purposes"
+  };
+  config = null;
+  initialized = false;
+  async initialize(config) {
+    this.config = config;
+    this.initialized = true;
+    console.log(`Mock connector initialized for: ${config.integrationId}`);
+  }
+  async verify() {
+    if (!this.initialized) {
+      return {
+        success: false,
+        error: {
+          code: "NOT_INITIALIZED",
+          message: "Plugin not initialized"
+        }
+      };
+    }
+    return {
+      success: true,
+      data: true,
+      metadata: {
+        connector_id: this.config?.connectorId || "mock",
+        operation: "verify",
+        timestamp: Date.now(),
+        request_id: `req_${Date.now()}`
+      }
+    };
+  }
+  getSupportedModules() {
+    return ["orders", "products", "customers", "inventory", "refunds", "payments"];
+  }
+  orders = {
+    create: async (order) => ({
+      success: true,
+      data: {
+        ...order,
+        id: `mock_order_${Date.now()}`,
+        created_at: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      metadata: {
+        connector_id: this.config?.connectorId || "mock",
+        operation: "orders.create",
+        timestamp: Date.now(),
+        request_id: `req_${Date.now()}`
+      }
+    }),
+    get: async (orderId) => ({
+      success: true,
+      data: {
+        id: orderId,
+        order_number: `ORD-${orderId}`,
+        status: "completed",
+        total: 100
+      },
+      metadata: {
+        connector_id: this.config?.connectorId || "mock",
+        operation: "orders.get",
+        timestamp: Date.now(),
+        request_id: `req_${Date.now()}`
+      }
+    }),
+    update: async (orderId, order) => ({
+      success: true,
+      data: {
+        id: orderId,
+        ...order,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      metadata: {
+        connector_id: this.config?.connectorId || "mock",
+        operation: "orders.update",
+        timestamp: Date.now(),
+        request_id: `req_${Date.now()}`
+      }
+    }),
+    delete: async (orderId) => ({
+      success: true,
+      data: null,
+      metadata: {
+        connector_id: this.config?.connectorId || "mock",
+        operation: "orders.delete",
+        timestamp: Date.now(),
+        request_id: `req_${Date.now()}`
+      }
+    }),
+    list: async (options) => {
+      const limit = options?.limit || 10;
+      const orders = Array.from({ length: limit }, (_, i) => ({
+        id: `mock_order_${i}`,
+        order_number: `ORD-${i}`,
+        status: "completed",
+        total: (i + 1) * 100
+      }));
+      return {
+        success: true,
+        data: orders,
+        metadata: {
+          connector_id: this.config?.connectorId || "mock",
+          operation: "orders.list",
+          timestamp: Date.now(),
+          request_id: `req_${Date.now()}`
+        }
+      };
+    }
+  };
+  products = {
+    create: async (product) => ({
+      success: true,
+      data: {
+        ...product,
+        id: `mock_product_${Date.now()}`,
+        created_at: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      metadata: {
+        connector_id: this.config?.connectorId || "mock",
+        operation: "products.create",
+        timestamp: Date.now(),
+        request_id: `req_${Date.now()}`
+      }
+    }),
+    get: async (productId) => ({
+      success: true,
+      data: {
+        id: productId,
+        title: "Mock Product",
+        price: 99.99,
+        sku: `MOCK-${productId}`
+      },
+      metadata: {
+        connector_id: this.config?.connectorId || "mock",
+        operation: "products.get",
+        timestamp: Date.now(),
+        request_id: `req_${Date.now()}`
+      }
+    }),
+    update: async (productId, product) => ({
+      success: true,
+      data: {
+        id: productId,
+        ...product,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      metadata: {
+        connector_id: this.config?.connectorId || "mock",
+        operation: "products.update",
+        timestamp: Date.now(),
+        request_id: `req_${Date.now()}`
+      }
+    }),
+    delete: async (productId) => ({
+      success: true,
+      data: null,
+      metadata: {
+        connector_id: this.config?.connectorId || "mock",
+        operation: "products.delete",
+        timestamp: Date.now(),
+        request_id: `req_${Date.now()}`
+      }
+    }),
+    list: async (options) => {
+      const limit = options?.limit || 10;
+      const products = Array.from({ length: limit }, (_, i) => ({
+        id: `mock_product_${i}`,
+        title: `Mock Product ${i}`,
+        price: (i + 1) * 10,
+        sku: `MOCK-${i}`
+      }));
+      return {
+        success: true,
+        data: products,
+        metadata: {
+          connector_id: this.config?.connectorId || "mock",
+          operation: "products.list",
+          timestamp: Date.now(),
+          request_id: `req_${Date.now()}`
+        }
+      };
+    }
+  };
+  customers = {
+    create: async (customer) => ({
+      success: true,
+      data: {
+        ...customer,
+        id: `mock_customer_${Date.now()}`,
+        created_at: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      metadata: {
+        connector_id: this.config?.connectorId || "mock",
+        operation: "customers.create",
+        timestamp: Date.now(),
+        request_id: `req_${Date.now()}`
+      }
+    }),
+    get: async (customerId) => ({
+      success: true,
+      data: {
+        id: customerId,
+        email: "customer@example.com",
+        name: "Mock Customer"
+      },
+      metadata: {
+        connector_id: this.config?.connectorId || "mock",
+        operation: "customers.get",
+        timestamp: Date.now(),
+        request_id: `req_${Date.now()}`
+      }
+    }),
+    update: async (customerId, customer) => ({
+      success: true,
+      data: {
+        id: customerId,
+        ...customer,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      metadata: {
+        connector_id: this.config?.connectorId || "mock",
+        operation: "customers.update",
+        timestamp: Date.now(),
+        request_id: `req_${Date.now()}`
+      }
+    }),
+    delete: async (customerId) => ({
+      success: true,
+      data: null,
+      metadata: {
+        connector_id: this.config?.connectorId || "mock",
+        operation: "customers.delete",
+        timestamp: Date.now(),
+        request_id: `req_${Date.now()}`
+      }
+    }),
+    list: async (options) => {
+      const limit = options?.limit || 10;
+      const customers = Array.from({ length: limit }, (_, i) => ({
+        id: `mock_customer_${i}`,
+        email: `customer${i}@example.com`,
+        name: `Customer ${i}`
+      }));
+      return {
+        success: true,
+        data: customers,
+        metadata: {
+          connector_id: this.config?.connectorId || "mock",
+          operation: "customers.list",
+          timestamp: Date.now(),
+          request_id: `req_${Date.now()}`
+        }
+      };
+    }
+  };
+  inventory = {
+    get: async (productId, variantId) => ({
+      success: true,
+      data: {
+        product_id: productId,
+        variant_id: variantId,
+        in_stock: 100,
+        committed: 0,
+        on_hand: 100
+      },
+      metadata: {
+        connector_id: this.config?.connectorId || "mock",
+        operation: "inventory.get",
+        timestamp: Date.now(),
+        request_id: `req_${Date.now()}`
+      }
+    }),
+    update: async (productId, inventory, variantId) => ({
+      success: true,
+      data: {
+        product_id: productId,
+        variant_id: variantId,
+        ...inventory,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      metadata: {
+        connector_id: this.config?.connectorId || "mock",
+        operation: "inventory.update",
+        timestamp: Date.now(),
+        request_id: `req_${Date.now()}`
+      }
+    }),
+    list: async (options) => {
+      const limit = options?.limit || 10;
+      const inventoryItems = Array.from({ length: limit }, (_, i) => ({
+        product_id: `mock_product_${i}`,
+        in_stock: (i + 1) * 10,
+        committed: 0,
+        on_hand: (i + 1) * 10
+      }));
+      return {
+        success: true,
+        data: inventoryItems,
+        metadata: {
+          connector_id: this.config?.connectorId || "mock",
+          operation: "inventory.list",
+          timestamp: Date.now(),
+          request_id: `req_${Date.now()}`
+        }
+      };
+    }
+  };
+  refunds = {
+    create: async (orderId, refund) => ({
+      success: true,
+      data: {
+        ...refund,
+        id: `mock_refund_${Date.now()}`,
+        order_id: orderId,
+        created_at: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      metadata: {
+        connector_id: this.config?.connectorId || "mock",
+        operation: "refunds.create",
+        timestamp: Date.now(),
+        request_id: `req_${Date.now()}`
+      }
+    }),
+    get: async (refundId) => ({
+      success: true,
+      data: {
+        id: refundId,
+        amount: 100,
+        reason: "Customer request",
+        status: "completed"
+      },
+      metadata: {
+        connector_id: this.config?.connectorId || "mock",
+        operation: "refunds.get",
+        timestamp: Date.now(),
+        request_id: `req_${Date.now()}`
+      }
+    }),
+    list: async (orderId, options) => {
+      const limit = options?.limit || 10;
+      const refunds = Array.from({ length: limit }, (_, i) => ({
+        id: `mock_refund_${i}`,
+        order_id: orderId,
+        amount: (i + 1) * 10,
+        reason: "Customer request",
+        status: "completed"
+      }));
+      return {
+        success: true,
+        data: refunds,
+        metadata: {
+          connector_id: this.config?.connectorId || "mock",
+          operation: "refunds.list",
+          timestamp: Date.now(),
+          request_id: `req_${Date.now()}`
+        }
+      };
+    }
+  };
+  payments = {
+    create: async (payment) => ({
+      success: true,
+      data: {
+        ...payment,
+        id: `mock_payment_${Date.now()}`,
+        status: "successful",
+        created_at: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      metadata: {
+        connector_id: this.config?.connectorId || "mock",
+        operation: "payments.create",
+        timestamp: Date.now(),
+        request_id: `req_${Date.now()}`
+      }
+    }),
+    get: async (paymentId) => ({
+      success: true,
+      data: {
+        id: paymentId,
+        amount: 100,
+        status: "successful",
+        method: "card"
+      },
+      metadata: {
+        connector_id: this.config?.connectorId || "mock",
+        operation: "payments.get",
+        timestamp: Date.now(),
+        request_id: `req_${Date.now()}`
+      }
+    }),
+    list: async (options) => {
+      const limit = options?.limit || 10;
+      const payments = Array.from({ length: limit }, (_, i) => ({
+        id: `mock_payment_${i}`,
+        amount: (i + 1) * 100,
+        status: "successful",
+        method: "card"
+      }));
+      return {
+        success: true,
+        data: payments,
+        metadata: {
+          connector_id: this.config?.connectorId || "mock",
+          operation: "payments.list",
+          timestamp: Date.now(),
+          request_id: `req_${Date.now()}`
+        }
+      };
+    }
+  };
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  capitalize,
-  toPureString
+  BaseService,
+  ConnectorLoader,
+  ErrorCodes,
+  Logger,
+  MockConnectorPlugin,
+  OrdersService,
+  PluginManager,
+  ProductsService,
+  StallConnectorError,
+  StallCore,
+  createErrorResponse,
+  createLogger,
+  generateRequestId,
+  handleConnectorError
 });