pmxtjs 2.20.2 → 2.21.0

package/dist/esm/pmxt/errors.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Typed error classes for pmxt.
+ *
+ * These mirror the error hierarchy in the core TypeScript library,
+ * enabling users to catch specific error types.
+ */
+export declare class PmxtError extends Error {
+    readonly code: string;
+    readonly retryable: boolean;
+    readonly exchange?: string;
+    constructor(message: string, code?: string, retryable?: boolean, exchange?: string);
+}
+export declare class BadRequest extends PmxtError {
+    constructor(message: string, exchange?: string);
+}
+export declare class AuthenticationError extends PmxtError {
+    constructor(message: string, exchange?: string);
+}
+export declare class PermissionDenied extends PmxtError {
+    constructor(message: string, exchange?: string);
+}
+export declare class NotFoundError extends PmxtError {
+    constructor(message: string, exchange?: string);
+}
+export declare class OrderNotFound extends NotFoundError {
+    constructor(orderId: string, exchange?: string);
+}
+export declare class MarketNotFound extends NotFoundError {
+    constructor(marketId: string, exchange?: string);
+}
+export declare class EventNotFound extends NotFoundError {
+    constructor(identifier: string, exchange?: string);
+}
+export declare class RateLimitExceeded extends PmxtError {
+    readonly retryAfter?: number;
+    constructor(message: string, retryAfter?: number, exchange?: string);
+}
+export declare class InvalidOrder extends PmxtError {
+    constructor(message: string, exchange?: string);
+}
+export declare class InsufficientFunds extends PmxtError {
+    constructor(message: string, exchange?: string);
+}
+export declare class ValidationError extends PmxtError {
+    readonly field?: string;
+    constructor(message: string, field?: string, exchange?: string);
+}
+export declare class NetworkError extends PmxtError {
+    constructor(message: string, exchange?: string);
+}
+export declare class ExchangeNotAvailable extends PmxtError {
+    constructor(message: string, exchange?: string);
+}
+/** Convert a server error response object into a typed PmxtError. */
+export declare function fromServerError(errorData: any): PmxtError;

package/dist/esm/pmxt/errors.js

@@ -0,0 +1,132 @@
+/**
+ * Typed error classes for pmxt.
+ *
+ * These mirror the error hierarchy in the core TypeScript library,
+ * enabling users to catch specific error types.
+ */
+export class PmxtError extends Error {
+    code;
+    retryable;
+    exchange;
+    constructor(message, code = "UNKNOWN_ERROR", retryable = false, exchange) {
+        super(message);
+        this.name = this.constructor.name;
+        this.code = code;
+        this.retryable = retryable;
+        this.exchange = exchange;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}
+// 4xx Client Errors
+export class BadRequest extends PmxtError {
+    constructor(message, exchange) {
+        super(message, "BAD_REQUEST", false, exchange);
+    }
+}
+export class AuthenticationError extends PmxtError {
+    constructor(message, exchange) {
+        super(message, "AUTHENTICATION_ERROR", false, exchange);
+    }
+}
+export class PermissionDenied extends PmxtError {
+    constructor(message, exchange) {
+        super(message, "PERMISSION_DENIED", false, exchange);
+    }
+}
+export class NotFoundError extends PmxtError {
+    constructor(message, exchange) {
+        super(message, "NOT_FOUND", false, exchange);
+    }
+}
+export class OrderNotFound extends NotFoundError {
+    constructor(orderId, exchange) {
+        super(`Order not found: ${orderId}`, exchange);
+        this.code = "ORDER_NOT_FOUND";
+    }
+}
+export class MarketNotFound extends NotFoundError {
+    constructor(marketId, exchange) {
+        super(`Market not found: ${marketId}`, exchange);
+        this.code = "MARKET_NOT_FOUND";
+    }
+}
+export class EventNotFound extends NotFoundError {
+    constructor(identifier, exchange) {
+        super(`Event not found: ${identifier}`, exchange);
+        this.code = "EVENT_NOT_FOUND";
+    }
+}
+export class RateLimitExceeded extends PmxtError {
+    retryAfter;
+    constructor(message, retryAfter, exchange) {
+        super(message, "RATE_LIMIT_EXCEEDED", true, exchange);
+        this.retryAfter = retryAfter;
+    }
+}
+export class InvalidOrder extends PmxtError {
+    constructor(message, exchange) {
+        super(message, "INVALID_ORDER", false, exchange);
+    }
+}
+export class InsufficientFunds extends PmxtError {
+    constructor(message, exchange) {
+        super(message, "INSUFFICIENT_FUNDS", false, exchange);
+    }
+}
+export class ValidationError extends PmxtError {
+    field;
+    constructor(message, field, exchange) {
+        super(message, "VALIDATION_ERROR", false, exchange);
+        this.field = field;
+    }
+}
+// 5xx Server/Network Errors
+export class NetworkError extends PmxtError {
+    constructor(message, exchange) {
+        super(message, "NETWORK_ERROR", true, exchange);
+    }
+}
+export class ExchangeNotAvailable extends PmxtError {
+    constructor(message, exchange) {
+        super(message, "EXCHANGE_NOT_AVAILABLE", true, exchange);
+    }
+}
+// Error code to class mapping
+const ERROR_CODE_MAP = {
+    BAD_REQUEST: BadRequest,
+    AUTHENTICATION_ERROR: AuthenticationError,
+    PERMISSION_DENIED: PermissionDenied,
+    NOT_FOUND: NotFoundError,
+    ORDER_NOT_FOUND: OrderNotFound,
+    MARKET_NOT_FOUND: MarketNotFound,
+    EVENT_NOT_FOUND: EventNotFound,
+    RATE_LIMIT_EXCEEDED: RateLimitExceeded,
+    INVALID_ORDER: InvalidOrder,
+    INSUFFICIENT_FUNDS: InsufficientFunds,
+    VALIDATION_ERROR: ValidationError,
+    NETWORK_ERROR: NetworkError,
+    EXCHANGE_NOT_AVAILABLE: ExchangeNotAvailable,
+};
+/** Convert a server error response object into a typed PmxtError. */
+export function fromServerError(errorData) {
+    if (typeof errorData === "string") {
+        return new PmxtError(errorData);
+    }
+    const message = errorData.message || "Unknown error";
+    const code = errorData.code || "UNKNOWN_ERROR";
+    const retryable = errorData.retryable || false;
+    const exchange = errorData.exchange;
+    const ErrorClass = ERROR_CODE_MAP[code];
+    if (ErrorClass === RateLimitExceeded) {
+        return new RateLimitExceeded(message, errorData.retryAfter, exchange);
+    }
+    if (ErrorClass === ValidationError) {
+        return new ValidationError(message, errorData.field, exchange);
+    }
+    if (ErrorClass) {
+        return new ErrorClass(message, exchange);
+    }
+    return new PmxtError(message, code, retryable, exchange);
+}

package/dist/index.d.ts

@@ -20,13 +20,30 @@
 import { Exchange, Polymarket, Kalshi, KalshiDemo, Limitless, Myriad, Probable, Baozi } from "./pmxt/client.js";
 import { ServerManager } from "./pmxt/server-manager.js";
 import * as models from "./pmxt/models.js";
+import * as errors from "./pmxt/errors.js";
 export { Exchange, Polymarket, Kalshi, KalshiDemo, Limitless, Myriad, Probable, Baozi, PolymarketOptions } from "./pmxt/client.js";
 export { ServerManager } from "./pmxt/server-manager.js";
 export { MarketList } from "./pmxt/models.js";
 export type * from "./pmxt/models.js";
+export * from "./pmxt/errors.js";
 declare function stopServer(): Promise<void>;
 declare function restartServer(): Promise<void>;
 declare const pmxt: {
+    fromServerError(errorData: any): errors.PmxtError;
+    PmxtError: typeof errors.PmxtError;
+    BadRequest: typeof errors.BadRequest;
+    AuthenticationError: typeof errors.AuthenticationError;
+    PermissionDenied: typeof errors.PermissionDenied;
+    NotFoundError: typeof errors.NotFoundError;
+    OrderNotFound: typeof errors.OrderNotFound;
+    MarketNotFound: typeof errors.MarketNotFound;
+    EventNotFound: typeof errors.EventNotFound;
+    RateLimitExceeded: typeof errors.RateLimitExceeded;
+    InvalidOrder: typeof errors.InvalidOrder;
+    InsufficientFunds: typeof errors.InsufficientFunds;
+    ValidationError: typeof errors.ValidationError;
+    NetworkError: typeof errors.NetworkError;
+    ExchangeNotAvailable: typeof errors.ExchangeNotAvailable;
     MarketList: typeof models.MarketList;
     Exchange: typeof Exchange;
     Polymarket: typeof Polymarket;

package/dist/index.js

@@ -51,11 +51,15 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MarketList = exports.ServerManager = exports.Baozi = exports.Probable = exports.Myriad = exports.Limitless = exports.KalshiDemo = exports.Kalshi = exports.Polymarket = exports.Exchange = void 0;
 const client_js_1 = require("./pmxt/client.js");
 const server_manager_js_1 = require("./pmxt/server-manager.js");
 const models = __importStar(require("./pmxt/models.js"));
+const errors = __importStar(require("./pmxt/errors.js"));
 var client_js_2 = require("./pmxt/client.js");
 Object.defineProperty(exports, "Exchange", { enumerable: true, get: function () { return client_js_2.Exchange; } });
 Object.defineProperty(exports, "Polymarket", { enumerable: true, get: function () { return client_js_2.Polymarket; } });
@@ -69,6 +73,7 @@ var server_manager_js_2 = require("./pmxt/server-manager.js");
 Object.defineProperty(exports, "ServerManager", { enumerable: true, get: function () { return server_manager_js_2.ServerManager; } });
 var models_js_1 = require("./pmxt/models.js");
 Object.defineProperty(exports, "MarketList", { enumerable: true, get: function () { return models_js_1.MarketList; } });
+__exportStar(require("./pmxt/errors.js"), exports);
 const defaultManager = new server_manager_js_1.ServerManager();
 async function stopServer() {
     await defaultManager.stop();
@@ -88,6 +93,7 @@ const pmxt = {
     ServerManager: server_manager_js_1.ServerManager,
     stopServer,
     restartServer,
-    ...models
+    ...models,
+    ...errors
 };
 exports.default = pmxt;