@missioncontrolio/client 0.0.9 → 0.0.11

package/README.md

@@ -65,6 +65,18 @@ const response = await client.product.hasStock.post({
 console.log(response?.hasStock ? "In stock" : "Out of stock");
 ```
 
+### Get redemption instructions
+
+Retrieve a product's redemption instructions (one entry per language) before placing an order.
+
+```ts
+const instructions = await client.product.byProductId(productId).redemptionInstructions.get();
+
+for (const instruction of instructions ?? []) {
+  console.log(`${instruction.languageCode}: ${instruction.text}`);
+}
+```
+
 ### Reserve → claim (place an order)
 
 ```ts
@@ -102,6 +114,24 @@ console.log(`Order ${order!.id} placed.`);
 await client.reservation.byReservationId(reservation!.id!).cancel.post();
 ```
 
+### Get asset packs
+
+Asset packs hold the images, logos and other marketing assets publishers provide for a product. They are served by the Assets API, available on `client.assets`.
+
+```ts
+const product = client.assets.assetPack.byPublisherId(publisherId).byProductId(productId);
+const packs = await product.get();
+
+for (const pack of packs?.result ?? []) {
+  // Fetch a pack to get its assets.
+  const detail = await product.byAssetPackId(pack.id!).get();
+
+  for (const asset of detail?.assets ?? []) {
+    console.log(`${asset.fileName}  ${asset.url}`);
+  }
+}
+```
+
 ### Filtering and pagination
 
 All list endpoints accept an optional `queryParameters` object for filtering and pagination. Every parameter is optional — only set what you need.
@@ -137,6 +167,7 @@ const result = await client.product.get({
 | `withDefaultPartnerId(partnerId)`                                 | Set the `X-Partner-Id` header for every request    |
 | `forEnvironment(env)`                                             | Target `Sandbox` or `Production`                   |
 | `withBaseUrl(url)`                                                | Override the base URL (e.g. for local development) |
+| `withAssetsBaseUrl(url)`                                          | Override the base URL of the Assets API            |
 | `withScope(scope)`                                                | Override the OAuth scope                           |
 | `build()`                                                         | Return the configured `Client` instance            |
 

package/dist/client/autoCancelOrderHandler.d.ts

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

package/dist/client/autoCancelOrderHandler.js

@@ -0,0 +1,95 @@
+import { MissionControlHeaders } from "./missionControlHeaders.js";
+import { nonIdempotentPaths } from "./nonIdempotentPaths.js";
+const CANCEL_TIMEOUT_MS = 30000;
+export class AutoCancelOrderHandler {
+    async execute(url, requestInit, requestOptions) {
+        if (!isAutoCancelEndpoint(url)) {
+            return this.next.execute(url, requestInit, requestOptions);
+        }
+        const requestBody = requestInit.body != null ? String(requestInit.body) : null;
+        let response;
+        try {
+            response = await this.next.execute(url, requestInit, requestOptions);
+        }
+        catch (err) {
+            await this.tryCancelOrderAsync(url, requestInit, requestBody);
+            throw err;
+        }
+        if (isServerError(response)) {
+            await this.tryCancelOrderAsync(url, requestInit, requestBody);
+        }
+        return response;
+    }
+    async tryCancelOrderAsync(originalUrl, originalInit, requestBody) {
+        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");
+            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 = {
+                method: "POST",
+                headers,
+                body: JSON.stringify({ originalRequestId: requestId }),
+                signal: AbortSignal.timeout(CANCEL_TIMEOUT_MS),
+            };
+            await this.next.execute(cancelUrl, cancelInit, undefined);
+        }
+        catch {
+        }
+    }
+}
+function isAutoCancelEndpoint(url) {
+    try {
+        const path = new URL(url).pathname;
+        return nonIdempotentPaths.some((prefix) => path.toLowerCase().includes(prefix.toLowerCase()));
+    }
+    catch {
+        return false;
+    }
+}
+function isServerError(response) {
+    return response.status >= 500;
+}
+function extractRequestId(json) {
+    if (!json)
+        return null;
+    try {
+        const parsed = JSON.parse(json);
+        if (parsed != null &&
+            typeof parsed === "object" &&
+            "requestId" in parsed &&
+            typeof parsed.requestId === "string") {
+            return parsed.requestId;
+        }
+    }
+    catch {
+    }
+    return null;
+}
+function buildCancelUrl(url) {
+    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;
+    }
+}

package/dist/client/clientBuilder.d.ts

@@ -0,0 +1,22 @@
+import { MissionControlEnvironment } from "./missionControlEnvironment.js";
+import { type Client } from "./generated/client.js";
+import { type AssetsClient } from "./generatedAssets/assetsClient.js";
+export type MissionControlClient = Client & {
+    readonly assets: AssetsClient;
+};
+export declare class ClientBuilder {
+    private _baseUrl;
+    private _assetsBaseUrl;
+    private _scope;
+    private _tenantId;
+    private _clientId?;
+    private _clientSecret?;
+    private _defaultPartnerId?;
+    withDefaultPartnerId(partnerId: string): this;
+    withBaseUrl(baseUrl: string): this;
+    withAssetsBaseUrl(assetsBaseUrl: string): this;
+    withScope(scope: string): this;
+    forEnvironment(environment: MissionControlEnvironment): this;
+    withAzureAdClientCredentials(clientId: string, clientSecret: string, tenantId?: string): this;
+    build(): MissionControlClient;
+}

package/dist/client/clientBuilder.js

@@ -0,0 +1,74 @@
+import { ClientSecretCredential } from "@azure/identity";
+import { AzureIdentityAuthenticationProvider } from "@microsoft/kiota-authentication-azure";
+import { FetchRequestAdapter, KiotaClientFactory, } from "@microsoft/kiota-http-fetchlibrary";
+import { getAssetsBaseUrl, getBaseUrl, getScope, MissionControlEnvironment, } from "./missionControlEnvironment.js";
+import { createClient } from "./generated/client.js";
+import { createAssetsClient } from "./generatedAssets/assetsClient.js";
+import { createHandlers } from "./missionControlHandlers.js";
+export class ClientBuilder {
+    constructor() {
+        this._baseUrl = getBaseUrl(MissionControlEnvironment.Production);
+        this._assetsBaseUrl = getAssetsBaseUrl(MissionControlEnvironment.Production);
+        this._scope = getScope(MissionControlEnvironment.Production);
+        this._tenantId = "13d084c1-d072-41f2-878b-c45ca721c9f6";
+    }
+    withDefaultPartnerId(partnerId) {
+        if (!partnerId?.trim())
+            throw new Error("partnerId must not be null or whitespace.");
+        this._defaultPartnerId = partnerId;
+        return this;
+    }
+    withBaseUrl(baseUrl) {
+        if (!baseUrl?.trim())
+            throw new Error("baseUrl must not be null or whitespace.");
+        this._baseUrl = baseUrl;
+        return this;
+    }
+    withAssetsBaseUrl(assetsBaseUrl) {
+        if (!assetsBaseUrl?.trim())
+            throw new Error("assetsBaseUrl must not be null or whitespace.");
+        this._assetsBaseUrl = assetsBaseUrl;
+        return this;
+    }
+    withScope(scope) {
+        if (!scope?.trim())
+            throw new Error("scope must not be null or whitespace.");
+        this._scope = scope;
+        return this;
+    }
+    forEnvironment(environment) {
+        this._baseUrl = getBaseUrl(environment);
+        this._assetsBaseUrl = getAssetsBaseUrl(environment);
+        this._scope = getScope(environment);
+        return this;
+    }
+    withAzureAdClientCredentials(clientId, clientSecret, tenantId) {
+        this._clientId = clientId;
+        this._clientSecret = clientSecret;
+        if (tenantId)
+            this._tenantId = tenantId;
+        return this;
+    }
+    build() {
+        if (!this._clientId || !this._clientSecret) {
+            throw new Error("No credentials configured. " +
+                "Call withAzureAdClientCredentials() before calling build().");
+        }
+        const credential = new ClientSecretCredential(this._tenantId, this._clientId, this._clientSecret);
+        const allowedHosts = new Set([
+            new URL(this._baseUrl).host,
+            new URL(this._assetsBaseUrl).host,
+        ]);
+        const authProvider = new AzureIdentityAuthenticationProvider(credential, [this._scope], undefined, allowedHosts);
+        const middlewares = createHandlers(this._defaultPartnerId);
+        const httpClient = KiotaClientFactory.create(undefined, middlewares);
+        const adapter = new FetchRequestAdapter(authProvider, undefined, undefined, httpClient);
+        adapter.baseUrl = this._baseUrl;
+        const assetsAdapter = new FetchRequestAdapter(authProvider, undefined, undefined, httpClient);
+        assetsAdapter.baseUrl = this._assetsBaseUrl;
+        const assets = createAssetsClient(assetsAdapter);
+        return new Proxy(createClient(adapter), {
+            get: (target, property, receiver) => property === "assets" ? assets : Reflect.get(target, property, receiver),
+        });
+    }
+}

package/dist/client/generated/client.d.ts

@@ -0,0 +1,20 @@
+import { type OrderRequestBuilder } from './order/index.js';
+import { type PartnerRequestBuilder } from './partner/index.js';
+import { type PriceListRequestBuilder } from './priceList/index.js';
+import { type ProductRequestBuilder } from './product/index.js';
+import { type PublisherRequestBuilder } from './publisher/index.js';
+import { type RegionRequestBuilder } from './region/index.js';
+import { type ReservationRequestBuilder } from './reservation/index.js';
+import { type BaseRequestBuilder, type KeysToExcludeForNavigationMetadata, type NavigationMetadata, type RequestAdapter } from '@microsoft/kiota-abstractions';
+export interface Client extends BaseRequestBuilder<Client> {
+    get order(): OrderRequestBuilder;
+    get partner(): PartnerRequestBuilder;
+    get priceList(): PriceListRequestBuilder;
+    get product(): ProductRequestBuilder;
+    get publisher(): PublisherRequestBuilder;
+    get region(): RegionRequestBuilder;
+    get reservation(): ReservationRequestBuilder;
+}
+export declare function createClient(requestAdapter: RequestAdapter): Client;
+export declare const ClientUriTemplate = "{+baseurl}";
+export declare const ClientNavigationMetadata: Record<Exclude<keyof Client, KeysToExcludeForNavigationMetadata>, NavigationMetadata>;

package/{src/client/generated/client.ts → dist/client/generated/client.js}

@@ -1,106 +1,43 @@
-/* tslint:disable */
-/* eslint-disable */
-// Generated by Microsoft Kiota
-// @ts-ignore
-import { OrderRequestBuilderNavigationMetadata, OrderRequestBuilderRequestsMetadata, type OrderRequestBuilder } from './order/index.js';
-// @ts-ignore
-import { PartnerRequestBuilderRequestsMetadata, type PartnerRequestBuilder } from './partner/index.js';
-// @ts-ignore
-import { PriceListRequestBuilderRequestsMetadata, type PriceListRequestBuilder } from './priceList/index.js';
-// @ts-ignore
-import { ProductRequestBuilderNavigationMetadata, ProductRequestBuilderRequestsMetadata, type ProductRequestBuilder } from './product/index.js';
-// @ts-ignore
-import { PublisherRequestBuilderRequestsMetadata, type PublisherRequestBuilder } from './publisher/index.js';
-// @ts-ignore
-import { RegionRequestBuilderRequestsMetadata, type RegionRequestBuilder } from './region/index.js';
-// @ts-ignore
-import { ReservationRequestBuilderNavigationMetadata, ReservationRequestBuilderRequestsMetadata, type ReservationRequestBuilder } from './reservation/index.js';
-// @ts-ignore
-import { apiClientProxifier, ParseNodeFactoryRegistry, SerializationWriterFactoryRegistry, type BaseRequestBuilder, type KeysToExcludeForNavigationMetadata, type NavigationMetadata, type RequestAdapter } from '@microsoft/kiota-abstractions';
-// @ts-ignore
+import { OrderRequestBuilderNavigationMetadata, OrderRequestBuilderRequestsMetadata } from './order/index.js';
+import { PartnerRequestBuilderRequestsMetadata } from './partner/index.js';
+import { PriceListRequestBuilderRequestsMetadata } from './priceList/index.js';
+import { ProductRequestBuilderNavigationMetadata, ProductRequestBuilderRequestsMetadata } from './product/index.js';
+import { PublisherRequestBuilderRequestsMetadata } from './publisher/index.js';
+import { RegionRequestBuilderRequestsMetadata } from './region/index.js';
+import { ReservationRequestBuilderNavigationMetadata, ReservationRequestBuilderRequestsMetadata } from './reservation/index.js';
+import { apiClientProxifier } from '@microsoft/kiota-abstractions';
 import { FormParseNodeFactory, FormSerializationWriterFactory } from '@microsoft/kiota-serialization-form';
-// @ts-ignore
 import { JsonParseNodeFactory, JsonSerializationWriterFactory } from '@microsoft/kiota-serialization-json';
-// @ts-ignore
 import { MultipartSerializationWriterFactory } from '@microsoft/kiota-serialization-multipart';
-// @ts-ignore
 import { TextParseNodeFactory, TextSerializationWriterFactory } from '@microsoft/kiota-serialization-text';
-
-/**
- * The main entry point of the SDK, exposes the configuration and the fluent API.
- */
-export interface Client extends BaseRequestBuilder<Client> {
-    /**
-     * The Order property
-     */
-    get order(): OrderRequestBuilder;
-    /**
-     * The Partner property
-     */
-    get partner(): PartnerRequestBuilder;
-    /**
-     * The PriceList property
-     */
-    get priceList(): PriceListRequestBuilder;
-    /**
-     * The Product property
-     */
-    get product(): ProductRequestBuilder;
-    /**
-     * The Publisher property
-     */
-    get publisher(): PublisherRequestBuilder;
-    /**
-     * The Region property
-     */
-    get region(): RegionRequestBuilder;
-    /**
-     * The Reservation property
-     */
-    get reservation(): ReservationRequestBuilder;
-}
-/**
- * Instantiates a new {@link Client} and sets the default values.
- * @param requestAdapter The request adapter to use to execute the requests.
- */
-// @ts-ignore
-export function createClient(requestAdapter: RequestAdapter) {
+export function createClient(requestAdapter) {
     if (requestAdapter === undefined) {
         throw new Error("requestAdapter cannot be undefined");
     }
-    const serializationWriterFactory = requestAdapter.getSerializationWriterFactory() as SerializationWriterFactoryRegistry;
-    const parseNodeFactoryRegistry = requestAdapter.getParseNodeFactory() as ParseNodeFactoryRegistry;
+    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/partnerApi/v2";
     }
-    const pathParameters: Record<string, unknown> = {
+    const pathParameters = {
         "baseurl": requestAdapter.baseUrl,
     };
-    return apiClientProxifier<Client>(requestAdapter, pathParameters, ClientNavigationMetadata, undefined);
+    return apiClientProxifier(requestAdapter, pathParameters, ClientNavigationMetadata, undefined);
 }
-/**
- * Uri template for the request builder.
- */
 export const ClientUriTemplate = "{+baseurl}";
-/**
- * Metadata for all the navigation properties in the request builder.
- */
-export const ClientNavigationMetadata: Record<Exclude<keyof Client, KeysToExcludeForNavigationMetadata>, NavigationMetadata> = {
+export const ClientNavigationMetadata = {
     order: {
         requestsMetadata: OrderRequestBuilderRequestsMetadata,
         navigationMetadata: OrderRequestBuilderNavigationMetadata,
@@ -126,5 +63,3 @@ export const ClientNavigationMetadata: Record<Exclude<keyof Client, KeysToExclud
         navigationMetadata: ReservationRequestBuilderNavigationMetadata,
     },
 };
-/* tslint:enable */
-/* eslint-enable */