@missioncontrolio/client 0.0.9 → 0.0.11

package/dist/client/generatedAssets/assetPack/item/item/item/index.js

@@ -0,0 +1,14 @@
+import { createAssetPackDetailFromDiscriminatorValue, createProblemDetailsFromDiscriminatorValue } from '../../../../models/index.js';
+export const WithAssetPackItemRequestBuilderUriTemplate = "{+baseurl}/AssetPack/{publisherId}/{productId}/{assetPackId}";
+export const WithAssetPackItemRequestBuilderRequestsMetadata = {
+    get: {
+        uriTemplate: WithAssetPackItemRequestBuilderUriTemplate,
+        responseBodyContentType: "application/json, text/plain;q=0.9",
+        errorMappings: {
+            400: createProblemDetailsFromDiscriminatorValue,
+            500: createProblemDetailsFromDiscriminatorValue,
+        },
+        adapterMethodName: "send",
+        responseBodyFactory: createAssetPackDetailFromDiscriminatorValue,
+    },
+};

package/dist/client/generatedAssets/assetsClient.d.ts

@@ -0,0 +1,8 @@
+import { type AssetPackRequestBuilder } from './assetPack/index.js';
+import { type BaseRequestBuilder, type KeysToExcludeForNavigationMetadata, type NavigationMetadata, type RequestAdapter } from '@microsoft/kiota-abstractions';
+export interface AssetsClient extends BaseRequestBuilder<AssetsClient> {
+    get assetPack(): AssetPackRequestBuilder;
+}
+export declare function createAssetsClient(requestAdapter: RequestAdapter): AssetsClient;
+export declare const AssetsClientUriTemplate = "{+baseurl}";
+export declare const AssetsClientNavigationMetadata: Record<Exclude<keyof AssetsClient, KeysToExcludeForNavigationMetadata>, NavigationMetadata>;

package/dist/client/generatedAssets/assetsClient.js

@@ -0,0 +1,38 @@
+import { AssetPackRequestBuilderNavigationMetadata } from './assetPack/index.js';
+import { apiClientProxifier } from '@microsoft/kiota-abstractions';
+import { FormParseNodeFactory, FormSerializationWriterFactory } from '@microsoft/kiota-serialization-form';
+import { JsonParseNodeFactory, JsonSerializationWriterFactory } from '@microsoft/kiota-serialization-json';
+import { MultipartSerializationWriterFactory } from '@microsoft/kiota-serialization-multipart';
+import { TextParseNodeFactory, TextSerializationWriterFactory } from '@microsoft/kiota-serialization-text';
+export function createAssetsClient(requestAdapter) {
+    if (requestAdapter === undefined) {
+        throw new Error("requestAdapter cannot be undefined");
+    }
+    const serializationWriterFactory = requestAdapter.getSerializationWriterFactory();
+    const parseNodeFactoryRegistry = requestAdapter.getParseNodeFactory();
+    const backingStoreFactory = requestAdapter.getBackingStoreFactory();
+    if (parseNodeFactoryRegistry.registerDefaultDeserializer) {
+        parseNodeFactoryRegistry.registerDefaultDeserializer(JsonParseNodeFactory, backingStoreFactory);
+        parseNodeFactoryRegistry.registerDefaultDeserializer(TextParseNodeFactory, backingStoreFactory);
+        parseNodeFactoryRegistry.registerDefaultDeserializer(FormParseNodeFactory, backingStoreFactory);
+    }
+    if (serializationWriterFactory.registerDefaultSerializer) {
+        serializationWriterFactory.registerDefaultSerializer(JsonSerializationWriterFactory);
+        serializationWriterFactory.registerDefaultSerializer(TextSerializationWriterFactory);
+        serializationWriterFactory.registerDefaultSerializer(FormSerializationWriterFactory);
+        serializationWriterFactory.registerDefaultSerializer(MultipartSerializationWriterFactory);
+    }
+    if (requestAdapter.baseUrl === undefined || requestAdapter.baseUrl === null || requestAdapter.baseUrl === "") {
+        requestAdapter.baseUrl = "https://api.missioncontrol.io/assets/partnerApi/v1";
+    }
+    const pathParameters = {
+        "baseurl": requestAdapter.baseUrl,
+    };
+    return apiClientProxifier(requestAdapter, pathParameters, AssetsClientNavigationMetadata, undefined);
+}
+export const AssetsClientUriTemplate = "{+baseurl}";
+export const AssetsClientNavigationMetadata = {
+    assetPack: {
+        navigationMetadata: AssetPackRequestBuilderNavigationMetadata,
+    },
+};

package/dist/client/generatedAssets/models/index.d.ts

@@ -0,0 +1,54 @@
+import { type AdditionalDataHolder, type ApiError, type Guid, type Parsable, type ParseNode, type SerializationWriter } from '@microsoft/kiota-abstractions';
+export interface Asset extends Parsable {
+    embargo?: Date | null;
+    fileName?: string | null;
+    folder?: string | null;
+    height?: number | null;
+    lastModified?: Date | null;
+    url?: string | null;
+    width?: number | null;
+}
+export interface AssetPack extends Parsable {
+    countryCodes?: string[] | null;
+    id?: string | null;
+    lastModified?: Date | null;
+    name?: string | null;
+    productId?: Guid | null;
+    productName?: string | null;
+}
+export interface AssetPackDetail extends Parsable {
+    assets?: Asset[] | null;
+    countryCodes?: string[] | null;
+    id?: string | null;
+    lastModified?: Date | null;
+    name?: string | null;
+    productId?: Guid | null;
+    productName?: string | null;
+}
+export interface AssetPackListResult extends Parsable {
+    pageCount?: number | null;
+    result?: AssetPack[] | null;
+    totalCount?: number | null;
+}
+export declare function createAssetFromDiscriminatorValue(parseNode: ParseNode | undefined): ((instance?: Parsable) => Record<string, (node: ParseNode) => void>);
+export declare function createAssetPackDetailFromDiscriminatorValue(parseNode: ParseNode | undefined): ((instance?: Parsable) => Record<string, (node: ParseNode) => void>);
+export declare function createAssetPackFromDiscriminatorValue(parseNode: ParseNode | undefined): ((instance?: Parsable) => Record<string, (node: ParseNode) => void>);
+export declare function createAssetPackListResultFromDiscriminatorValue(parseNode: ParseNode | undefined): ((instance?: Parsable) => Record<string, (node: ParseNode) => void>);
+export declare function createProblemDetailsFromDiscriminatorValue(parseNode: ParseNode | undefined): ((instance?: Parsable) => Record<string, (node: ParseNode) => void>);
+export declare function deserializeIntoAsset(asset?: Partial<Asset> | undefined): Record<string, (node: ParseNode) => void>;
+export declare function deserializeIntoAssetPack(assetPack?: Partial<AssetPack> | undefined): Record<string, (node: ParseNode) => void>;
+export declare function deserializeIntoAssetPackDetail(assetPackDetail?: Partial<AssetPackDetail> | undefined): Record<string, (node: ParseNode) => void>;
+export declare function deserializeIntoAssetPackListResult(assetPackListResult?: Partial<AssetPackListResult> | undefined): Record<string, (node: ParseNode) => void>;
+export declare function deserializeIntoProblemDetails(problemDetails?: Partial<ProblemDetails> | undefined): Record<string, (node: ParseNode) => void>;
+export interface ProblemDetails extends AdditionalDataHolder, ApiError, Parsable {
+    detail?: string | null;
+    instance?: string | null;
+    status?: number | null;
+    title?: string | null;
+    type?: string | null;
+}
+export declare function serializeAsset(writer: SerializationWriter, asset?: Partial<Asset> | undefined | null, isSerializingDerivedType?: boolean): void;
+export declare function serializeAssetPack(writer: SerializationWriter, assetPack?: Partial<AssetPack> | undefined | null, isSerializingDerivedType?: boolean): void;
+export declare function serializeAssetPackDetail(writer: SerializationWriter, assetPackDetail?: Partial<AssetPackDetail> | undefined | null, isSerializingDerivedType?: boolean): void;
+export declare function serializeAssetPackListResult(writer: SerializationWriter, assetPackListResult?: Partial<AssetPackListResult> | undefined | null, isSerializingDerivedType?: boolean): void;
+export declare function serializeProblemDetails(writer: SerializationWriter, problemDetails?: Partial<ProblemDetails> | undefined | null, isSerializingDerivedType?: boolean): void;

package/dist/client/generatedAssets/models/index.js

@@ -0,0 +1,117 @@
+export function createAssetFromDiscriminatorValue(parseNode) {
+    return deserializeIntoAsset;
+}
+export function createAssetPackDetailFromDiscriminatorValue(parseNode) {
+    return deserializeIntoAssetPackDetail;
+}
+export function createAssetPackFromDiscriminatorValue(parseNode) {
+    return deserializeIntoAssetPack;
+}
+export function createAssetPackListResultFromDiscriminatorValue(parseNode) {
+    return deserializeIntoAssetPackListResult;
+}
+export function createProblemDetailsFromDiscriminatorValue(parseNode) {
+    return deserializeIntoProblemDetails;
+}
+export function deserializeIntoAsset(asset = {}) {
+    return {
+        "embargo": n => { asset.embargo = n.getDateValue(); },
+        "fileName": n => { asset.fileName = n.getStringValue(); },
+        "folder": n => { asset.folder = n.getStringValue(); },
+        "height": n => { asset.height = n.getNumberValue(); },
+        "lastModified": n => { asset.lastModified = n.getDateValue(); },
+        "url": n => { asset.url = n.getStringValue(); },
+        "width": n => { asset.width = n.getNumberValue(); },
+    };
+}
+export function deserializeIntoAssetPack(assetPack = {}) {
+    return {
+        "countryCodes": n => { assetPack.countryCodes = n.getCollectionOfPrimitiveValues("string"); },
+        "id": n => { assetPack.id = n.getStringValue(); },
+        "lastModified": n => { assetPack.lastModified = n.getDateValue(); },
+        "name": n => { assetPack.name = n.getStringValue(); },
+        "productId": n => { assetPack.productId = n.getGuidValue(); },
+        "productName": n => { assetPack.productName = n.getStringValue(); },
+    };
+}
+export function deserializeIntoAssetPackDetail(assetPackDetail = {}) {
+    return {
+        "assets": n => { assetPackDetail.assets = n.getCollectionOfObjectValues(createAssetFromDiscriminatorValue); },
+        "countryCodes": n => { assetPackDetail.countryCodes = n.getCollectionOfPrimitiveValues("string"); },
+        "id": n => { assetPackDetail.id = n.getStringValue(); },
+        "lastModified": n => { assetPackDetail.lastModified = n.getDateValue(); },
+        "name": n => { assetPackDetail.name = n.getStringValue(); },
+        "productId": n => { assetPackDetail.productId = n.getGuidValue(); },
+        "productName": n => { assetPackDetail.productName = n.getStringValue(); },
+    };
+}
+export function deserializeIntoAssetPackListResult(assetPackListResult = {}) {
+    return {
+        "pageCount": n => { assetPackListResult.pageCount = n.getNumberValue(); },
+        "result": n => { assetPackListResult.result = n.getCollectionOfObjectValues(createAssetPackFromDiscriminatorValue); },
+        "totalCount": n => { assetPackListResult.totalCount = n.getNumberValue(); },
+    };
+}
+export function deserializeIntoProblemDetails(problemDetails = {}) {
+    return {
+        "detail": n => { problemDetails.detail = n.getStringValue(); },
+        "instance": n => { problemDetails.instance = n.getStringValue(); },
+        "status": n => { problemDetails.status = n.getNumberValue(); },
+        "title": n => { problemDetails.title = n.getStringValue(); },
+        "type": n => { problemDetails.type = n.getStringValue(); },
+    };
+}
+export function serializeAsset(writer, asset = {}, isSerializingDerivedType = false) {
+    if (!asset || isSerializingDerivedType) {
+        return;
+    }
+    writer.writeDateValue("embargo", asset.embargo);
+    writer.writeStringValue("fileName", asset.fileName);
+    writer.writeStringValue("folder", asset.folder);
+    writer.writeNumberValue("height", asset.height);
+    writer.writeDateValue("lastModified", asset.lastModified);
+    writer.writeStringValue("url", asset.url);
+    writer.writeNumberValue("width", asset.width);
+}
+export function serializeAssetPack(writer, assetPack = {}, isSerializingDerivedType = false) {
+    if (!assetPack || isSerializingDerivedType) {
+        return;
+    }
+    writer.writeCollectionOfPrimitiveValues("countryCodes", assetPack.countryCodes);
+    writer.writeStringValue("id", assetPack.id);
+    writer.writeDateValue("lastModified", assetPack.lastModified);
+    writer.writeStringValue("name", assetPack.name);
+    writer.writeGuidValue("productId", assetPack.productId);
+    writer.writeStringValue("productName", assetPack.productName);
+}
+export function serializeAssetPackDetail(writer, assetPackDetail = {}, isSerializingDerivedType = false) {
+    if (!assetPackDetail || isSerializingDerivedType) {
+        return;
+    }
+    writer.writeCollectionOfObjectValues("assets", assetPackDetail.assets, serializeAsset);
+    writer.writeCollectionOfPrimitiveValues("countryCodes", assetPackDetail.countryCodes);
+    writer.writeStringValue("id", assetPackDetail.id);
+    writer.writeDateValue("lastModified", assetPackDetail.lastModified);
+    writer.writeStringValue("name", assetPackDetail.name);
+    writer.writeGuidValue("productId", assetPackDetail.productId);
+    writer.writeStringValue("productName", assetPackDetail.productName);
+}
+export function serializeAssetPackListResult(writer, assetPackListResult = {}, isSerializingDerivedType = false) {
+    if (!assetPackListResult || isSerializingDerivedType) {
+        return;
+    }
+    writer.writeNumberValue("pageCount", assetPackListResult.pageCount);
+    writer.writeCollectionOfObjectValues("result", assetPackListResult.result, serializeAssetPack);
+    writer.writeNumberValue("totalCount", assetPackListResult.totalCount);
+}
+export function serializeProblemDetails(writer, problemDetails = {}, isSerializingDerivedType = false) {
+    if (!problemDetails || isSerializingDerivedType) {
+        return;
+    }
+    writer.writeStringValue("detail", problemDetails.detail);
+    writer.writeStringValue("instance", problemDetails.instance);
+    writer.writeNumberValue("status", problemDetails.status);
+    writer.writeStringValue("title", problemDetails.title);
+    writer.writeStringValue("type", problemDetails.type);
+    writer.writeAdditionalData(problemDetails.additionalData);
+}

package/dist/client/missionControlEnvironment.d.ts

@@ -0,0 +1,7 @@
+export declare enum MissionControlEnvironment {
+    Sandbox = "Sandbox",
+    Production = "Production"
+}
+export declare function getBaseUrl(env: MissionControlEnvironment): string;
+export declare function getAssetsBaseUrl(env: MissionControlEnvironment): string;
+export declare function getScope(env: MissionControlEnvironment): string;

package/dist/client/missionControlEnvironment.js

@@ -0,0 +1,26 @@
+export var MissionControlEnvironment;
+(function (MissionControlEnvironment) {
+    MissionControlEnvironment["Sandbox"] = "Sandbox";
+    MissionControlEnvironment["Production"] = "Production";
+})(MissionControlEnvironment || (MissionControlEnvironment = {}));
+const settings = {
+    [MissionControlEnvironment.Sandbox]: {
+        baseUrl: "https://api.sandbox.missioncontrol.io/partnerApi/v2",
+        assetsBaseUrl: "https://api.sandbox.missioncontrol.io/assets/partnerApi/v1",
+        scope: "api://38fbfaea-5648-4b51-ac09-d5d90117beff/.default",
+    },
+    [MissionControlEnvironment.Production]: {
+        baseUrl: "https://api.missioncontrol.io/partnerApi/v2",
+        assetsBaseUrl: "https://api.missioncontrol.io/assets/partnerApi/v1",
+        scope: "api://1b6f40bc-e051-4b7e-987f-47a4a19fa5ef/.default",
+    },
+};
+export function getBaseUrl(env) {
+    return settings[env].baseUrl;
+}
+export function getAssetsBaseUrl(env) {
+    return settings[env].assetsBaseUrl;
+}
+export function getScope(env) {
+    return settings[env].scope;
+}

package/dist/client/missionControlHandlers.d.ts

@@ -0,0 +1,2 @@
+import { type Middleware } from "@microsoft/kiota-http-fetchlibrary";
+export declare function createHandlers(defaultPartnerId?: string): Middleware[];

package/dist/client/missionControlHandlers.js

@@ -0,0 +1,34 @@
+import { MiddlewareFactory, RetryHandler, RetryHandlerOptions, } from "@microsoft/kiota-http-fetchlibrary";
+import { nonIdempotentPaths } from "./nonIdempotentPaths.js";
+import { AutoCancelOrderHandler } from "./autoCancelOrderHandler.js";
+import { PartnerIdHandler } from "./partnerIdHandler.js";
+function isNoRetryEndpoint(url) {
+    try {
+        const { pathname } = new URL(url);
+        return nonIdempotentPaths.some((prefix) => pathname.toLowerCase().startsWith(prefix.toLowerCase()));
+    }
+    catch {
+        return false;
+    }
+}
+export function createHandlers(defaultPartnerId) {
+    const retryOptions = new RetryHandlerOptions({
+        shouldRetry: (_delay, _attempt, request, _options, response) => {
+            if (isNoRetryEndpoint(request))
+                return false;
+            return (response.status === 429 ||
+                response.status === 503 ||
+                response.status === 504);
+        },
+    });
+    const middlewares = MiddlewareFactory.getDefaultMiddlewares();
+    const retryIndex = middlewares.findIndex((m) => m instanceof RetryHandler);
+    if (retryIndex !== -1) {
+        middlewares[retryIndex] = new RetryHandler(retryOptions);
+    }
+    if (defaultPartnerId) {
+        middlewares.unshift(new PartnerIdHandler(defaultPartnerId));
+    }
+    middlewares.unshift(new AutoCancelOrderHandler());
+    return middlewares;
+}

package/dist/client/missionControlHeaders.d.ts

@@ -0,0 +1,3 @@
+export declare const MissionControlHeaders: {
+    readonly PartnerId: "X-Partner-Id";
+};

package/dist/client/missionControlHeaders.js

@@ -0,0 +1,3 @@
+export const MissionControlHeaders = {
+    PartnerId: "X-Partner-Id",
+};

package/dist/client/nonIdempotentPaths.d.ts

@@ -0,0 +1 @@
+export declare const nonIdempotentPaths: readonly ["/Order/createOrder", "/Order/claimReservation", "/Order/reportOrder"];

package/dist/client/nonIdempotentPaths.js

@@ -0,0 +1,5 @@
+export const nonIdempotentPaths = [
+    "/Order/createOrder",
+    "/Order/claimReservation",
+    "/Order/reportOrder",
+];

package/dist/client/partnerIdHandler.d.ts

@@ -0,0 +1,8 @@
+import type { RequestOption } from "@microsoft/kiota-abstractions";
+import type { Middleware } from "@microsoft/kiota-http-fetchlibrary";
+export declare class PartnerIdHandler implements Middleware {
+    private readonly defaultPartnerId;
+    next: Middleware | undefined;
+    constructor(defaultPartnerId: string);
+    execute(url: string, requestInit: RequestInit, requestOptions?: Record<string, RequestOption>): Promise<Response>;
+}

package/dist/client/partnerIdHandler.js

@@ -0,0 +1,14 @@
+import { MissionControlHeaders } from "./missionControlHeaders.js";
+export class PartnerIdHandler {
+    constructor(defaultPartnerId) {
+        this.defaultPartnerId = defaultPartnerId;
+    }
+    async execute(url, requestInit, requestOptions) {
+        const headers = new Headers(requestInit.headers);
+        if (!headers.has(MissionControlHeaders.PartnerId)) {
+            headers.set(MissionControlHeaders.PartnerId, this.defaultPartnerId);
+            requestInit = { ...requestInit, headers };
+        }
+        return this.next.execute(url, requestInit, requestOptions);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { ClientBuilder, type MissionControlClient } from "./client/clientBuilder.js";
+export { MissionControlEnvironment, getAssetsBaseUrl, getBaseUrl, getScope, } from "./client/missionControlEnvironment.js";
+export type { Client } from "./client/generated/client.js";
+export { createClient } from "./client/generated/client.js";
+export type * from "./client/generated/models/index.js";
+export type { AssetsClient } from "./client/generatedAssets/assetsClient.js";
+export type { Asset, AssetPack, AssetPackDetail, AssetPackListResult, } from "./client/generatedAssets/models/index.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { ClientBuilder } from "./client/clientBuilder.js";
+export { MissionControlEnvironment, getAssetsBaseUrl, getBaseUrl, getScope, } from "./client/missionControlEnvironment.js";
+export { createClient } from "./client/generated/client.js";

package/package.json

@@ -6,15 +6,27 @@
   "homepage": "https://github.com/PandoMC/sdk/tree/main/node",
   "repository": "github:PandoMC/sdk",
   "type": "module",
-  "main": "index.js",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && tsc-alias --resolve-full-paths --resolve-full-extension .js",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:integration": "vitest run --config vitest.integration.config.ts"
   },
   "devDependencies": {
     "@types/node": "^26.0.1",
+    "tsc-alias": "^1.9.0",
     "typescript": "^6.0.3",
     "vitest": "^4.1.9"
   },
@@ -23,5 +35,5 @@
     "@microsoft/kiota-authentication-azure": "^1.0.0-preview.103",
     "@microsoft/kiota-bundle": "^1.0.0-preview.103"
   },
-  "version": "0.0.9"
+  "version": "0.0.11"
 }

package/.env.local.example

@@ -1,9 +0,0 @@
-MC_TENANT_ID=<your-azure-ad-tenant-id>
-MC_CLIENT_ID=<your-client-id>
-MC_CLIENT_SECRET=<your-client-secret>
-MC_PARTNER_ID=<your-partner-id>
-MC_BASE_URL=https://api.sandbox.missioncontrol.io
-MC_SCOPE=api://<app-id>/.default
-MC_PRODUCT_ID=<your-product-id>
-MC_REGION_ID=<your-region-id>
-MC_PUBLISHER_ID=<your-publisher-id>

package/src/client/autoCancelOrderHandler.ts

@@ -1,135 +0,0 @@
-import type { RequestOption } from "@microsoft/kiota-abstractions";
-import type { Middleware } from "@microsoft/kiota-http-fetchlibrary";
-import { MissionControlHeaders } from "./missionControlHeaders";
-import { nonIdempotentPaths } from "./nonIdempotentPaths";
-
-const CANCEL_TIMEOUT_MS = 30_000;
-
-/**
- * A Kiota middleware that automatically attempts to cancel an order when a request to one of
- * the order-mutation endpoints fails with a server error (5xx) or a network/connection error.
- *
- * Affected endpoints: `createOrder`, `claimReservation`, `reportOrder`.
- *
- * The cancellation attempt is best-effort. If it fails the original error is still propagated
- * to the caller unchanged.
- */
-export class AutoCancelOrderHandler implements Middleware {
-  next: Middleware | undefined;
-
-  async execute(
-    url: string,
-    requestInit: RequestInit,
-    requestOptions?: Record<string, RequestOption>,
-  ): Promise<Response> {
-    if (!isAutoCancelEndpoint(url)) {
-      return this.next!.execute(url, requestInit, requestOptions);
-    }
-
-    // Buffer the request body before the inner handler consumes it.
-    const requestBody =
-      requestInit.body != null ? String(requestInit.body) : null;
-
-    let response: Response;
-    try {
-      response = await this.next!.execute(url, requestInit, requestOptions);
-    } catch (err) {
-      // Network/connection error — attempt a best-effort cancel.
-      await this.tryCancelOrderAsync(url, requestInit, requestBody);
-      throw err;
-    }
-
-    if (isServerError(response)) {
-      await this.tryCancelOrderAsync(url, requestInit, requestBody);
-    }
-
-    return response;
-  }
-
-  private async tryCancelOrderAsync(
-    originalUrl: string,
-    originalInit: RequestInit,
-    requestBody: string | null,
-  ): Promise<void> {
-    try {
-      const requestId = extractRequestId(requestBody);
-      if (requestId == null) return;
-
-      const cancelUrl = buildCancelUrl(originalUrl);
-      if (cancelUrl == null) return;
-
-      const headers = new Headers();
-      headers.set("Content-Type", "application/json");
-
-      // Copy auth and partner-id headers so the cancel request is properly authenticated
-      // and attributed — the inner middleware handles retry and other cross-cutting concerns.
-      const originalHeaders = new Headers(originalInit.headers);
-      const auth = originalHeaders.get("Authorization");
-      if (auth) headers.set("Authorization", auth);
-      const partnerId = originalHeaders.get(MissionControlHeaders.PartnerId);
-      if (partnerId) headers.set(MissionControlHeaders.PartnerId, partnerId);
-
-      const cancelInit: RequestInit = {
-        method: "POST",
-        headers,
-        body: JSON.stringify({ originalRequestId: requestId }),
-        signal: AbortSignal.timeout(CANCEL_TIMEOUT_MS),
-      };
-
-      await this.next!.execute(cancelUrl, cancelInit, undefined);
-    } catch {
-      // Best-effort: swallow failures so the original error propagates.
-    }
-  }
-}
-
-function isAutoCancelEndpoint(url: string): boolean {
-  try {
-    const path = new URL(url).pathname;
-    // Use includes so this works regardless of any base-path prefix
-    // (e.g. /partnerApi/v2/Order/createOrder).
-    return nonIdempotentPaths.some((prefix) =>
-      path.toLowerCase().includes(prefix.toLowerCase()),
-    );
-  } catch {
-    return false;
-  }
-}
-
-function isServerError(response: Response): boolean {
-  return response.status >= 500;
-}
-
-function extractRequestId(json: string | null): string | null {
-  if (!json) return null;
-  try {
-    const parsed: unknown = JSON.parse(json);
-    if (
-      parsed != null &&
-      typeof parsed === "object" &&
-      "requestId" in parsed &&
-      typeof (parsed as Record<string, unknown>).requestId === "string"
-    ) {
-      return (parsed as Record<string, unknown>).requestId as string;
-    }
-  } catch {
-    // Malformed body — nothing to extract.
-  }
-  return null;
-}
-
-function buildCancelUrl(url: string): string | null {
-  try {
-    const parsed = new URL(url);
-    const path = parsed.pathname;
-    const orderIndex = path.toLowerCase().indexOf("/order/");
-    if (orderIndex < 0) return null;
-
-    parsed.pathname =
-      path.slice(0, orderIndex + "/Order/".length) + "cancelOrder";
-    parsed.search = "";
-    return parsed.toString();
-  } catch {
-    return null;
-  }
-}