ce-storefront 0.7.3 → 0.8.2

package/src/funcs/ordersRetryOrderPayment.ts

@@ -21,6 +21,7 @@ import {
 import * as errors from "../models/errors/index.js";
 import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
 import * as operations from "../models/operations/index.js";
+import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 
 /**
@@ -29,11 +30,11 @@ import { Result } from "../types/fp.js";
  * @remarks
  * To generate new payment request if first payment request is failed or expired. Retry payment request can be made after 15 mins of last request or immediately after last payment request is marked as failed.
  */
-export async function ordersRetryOrderPayment(
+export function ordersRetryOrderPayment(
   client: CeStorefrontCore,
   request: operations.RetryOrderPaymentRequest,
   options?: RequestOptions,
-): Promise<
+): APIPromise<
   Result<
     operations.RetryOrderPaymentResponseBody,
     | errors.BadRequest
@@ -47,6 +48,35 @@ export async function ordersRetryOrderPayment(
     | RequestTimeoutError
     | ConnectionError
   >
+> {
+  return new APIPromise($do(
+    client,
+    request,
+    options,
+  ));
+}
+
+async function $do(
+  client: CeStorefrontCore,
+  request: operations.RetryOrderPaymentRequest,
+  options?: RequestOptions,
+): Promise<
+  [
+    Result<
+      operations.RetryOrderPaymentResponseBody,
+      | errors.BadRequest
+      | errors.Unauthorized
+      | errors.NotFound
+      | CeError
+      | SDKValidationError
+      | UnexpectedClientError
+      | InvalidRequestError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | ConnectionError
+    >,
+    APICall,
+  ]
 > {
   const parsed = safeParse(
     request,
@@ -54,7 +84,7 @@ export async function ordersRetryOrderPayment(
     "Input validation failed",
   );
   if (!parsed.ok) {
-    return parsed;
+    return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
   const body = encodeJSON("body", payload.RequestBody, { explode: true });
@@ -78,7 +108,7 @@ export async function ordersRetryOrderPayment(
   const requestSecurity = resolveGlobalSecurity(securityInput);
 
   const context = {
-    baseURL: options?.serverURL ?? "",
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
     operationID: "retry-order-payment",
     oAuth2Scopes: [],
 
@@ -101,7 +131,7 @@ export async function ordersRetryOrderPayment(
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
   }, options);
   if (!requestRes.ok) {
-    return requestRes;
+    return [requestRes, { status: "invalid" }];
   }
   const req = requestRes.value;
 
@@ -112,7 +142,7 @@ export async function ordersRetryOrderPayment(
     retryCodes: context.retryCodes,
   });
   if (!doResult.ok) {
-    return doResult;
+    return [doResult, { status: "request-error", request: req }];
   }
   const response = doResult.value;
 
@@ -141,8 +171,8 @@ export async function ordersRetryOrderPayment(
     M.fail("5XX"),
   )(response, { extraFields: responseFields });
   if (!result.ok) {
-    return result;
+    return [result, { status: "complete", request: req, response }];
   }
 
-  return result;
+  return [result, { status: "complete", request: req, response }];
 }

package/src/funcs/shippingCheckDeliveryAvailability.ts

@@ -21,6 +21,7 @@ import {
 import * as errors from "../models/errors/index.js";
 import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
 import * as operations from "../models/operations/index.js";
+import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 
 /**
@@ -29,11 +30,11 @@ import { Result } from "../types/fp.js";
  * @remarks
  * Check shipment delivery availability in an area by pincode
  */
-export async function shippingCheckDeliveryAvailability(
+export function shippingCheckDeliveryAvailability(
   client: CeStorefrontCore,
   request: operations.CheckDeliveryAvailabilityRequest,
   options?: RequestOptions,
-): Promise<
+): APIPromise<
   Result<
     operations.CheckDeliveryAvailabilityResponseBody,
     | errors.Unauthorized
@@ -45,6 +46,33 @@ export async function shippingCheckDeliveryAvailability(
     | RequestTimeoutError
     | ConnectionError
   >
+> {
+  return new APIPromise($do(
+    client,
+    request,
+    options,
+  ));
+}
+
+async function $do(
+  client: CeStorefrontCore,
+  request: operations.CheckDeliveryAvailabilityRequest,
+  options?: RequestOptions,
+): Promise<
+  [
+    Result<
+      operations.CheckDeliveryAvailabilityResponseBody,
+      | errors.Unauthorized
+      | CeError
+      | SDKValidationError
+      | UnexpectedClientError
+      | InvalidRequestError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | ConnectionError
+    >,
+    APICall,
+  ]
 > {
   const parsed = safeParse(
     request,
@@ -53,7 +81,7 @@ export async function shippingCheckDeliveryAvailability(
     "Input validation failed",
   );
   if (!parsed.ok) {
-    return parsed;
+    return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
   const body = null;
@@ -78,7 +106,7 @@ export async function shippingCheckDeliveryAvailability(
   const requestSecurity = resolveGlobalSecurity(securityInput);
 
   const context = {
-    baseURL: options?.serverURL ?? "",
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
     operationID: "check-delivery-availability",
     oAuth2Scopes: [],
 
@@ -101,7 +129,7 @@ export async function shippingCheckDeliveryAvailability(
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
   }, options);
   if (!requestRes.ok) {
-    return requestRes;
+    return [requestRes, { status: "invalid" }];
   }
   const req = requestRes.value;
 
@@ -112,7 +140,7 @@ export async function shippingCheckDeliveryAvailability(
     retryCodes: context.retryCodes,
   });
   if (!doResult.ok) {
-    return doResult;
+    return [doResult, { status: "request-error", request: req }];
   }
   const response = doResult.value;
 
@@ -137,8 +165,8 @@ export async function shippingCheckDeliveryAvailability(
     M.fail("5XX"),
   )(response, { extraFields: responseFields });
   if (!result.ok) {
-    return result;
+    return [result, { status: "complete", request: req, response }];
   }
 
-  return result;
+  return [result, { status: "complete", request: req, response }];
 }

package/src/hooks/types.ts

@@ -9,7 +9,7 @@ import { SecurityState } from "../lib/security.js";
 export type HookContext = {
   baseURL: string | URL;
   operationID: string;
-  oAuth2Scopes?: string[];
+  oAuth2Scopes: string[] | null;
   securitySource?: any | (() => Promise<any>);
   retryConfig: RetryConfig;
   resolvedSecurity: SecurityState | null;

package/src/lib/config.ts

@@ -26,21 +26,21 @@ export const ServerList = {
 } as const;
 
 export type SDKOptions = {
-  authorization?: string | (() => Promise<string>);
+  authorization?: string | (() => Promise<string>) | undefined;
 
   httpClient?: HTTPClient;
   /**
    * Allows overriding the default server used by the SDK
    */
-  server?: keyof typeof ServerList;
+  server?: keyof typeof ServerList | undefined;
   /**
    * Sets the store_id variable for url substitution
    */
-  storeId?: string;
+  storeId?: string | undefined;
   /**
    * Allows overriding the default server URL used by the SDK
    */
-  serverURL?: string;
+  serverURL?: string | undefined;
   /**
    * Allows overriding the default retry config used by the SDK
    */
@@ -76,7 +76,7 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "1.0",
-  sdkVersion: "0.7.3",
-  genVersion: "2.512.4",
-  userAgent: "speakeasy-sdk/typescript 0.7.3 2.512.4 1.0 ce-storefront",
+  sdkVersion: "0.8.2",
+  genVersion: "2.563.0",
+  userAgent: "speakeasy-sdk/typescript 0.8.2 2.563.0 1.0 ce-storefront",
 } as const;

package/src/lib/files.ts

@@ -36,5 +36,5 @@ export async function readableStreamToArrayBuffer(
     offset += chunk.length;
   }
 
-  return concatenatedChunks.buffer;
+  return concatenatedChunks.buffer as ArrayBuffer;
 }

package/src/lib/primitives.ts

@@ -134,3 +134,17 @@ export function compactMap<T>(
 
   return out;
 }
+
+export function allRequired<V extends Record<string, unknown>>(
+  v: V,
+):
+  | {
+      [K in keyof V]: NonNullable<V[K]>;
+    }
+  | undefined {
+  if (Object.values(v).every((x) => x == null)) {
+    return void 0;
+  }
+
+  return v as ReturnType<typeof allRequired<V>>;
+}

package/src/lib/sdks.ts

@@ -78,7 +78,7 @@ export class ClientSDK {
   readonly #httpClient: HTTPClient;
   readonly #hooks: SDKHooks;
   readonly #logger?: Logger | undefined;
-  protected readonly _baseURL: URL | null;
+  public readonly _baseURL: URL | null;
   public readonly _options: SDKOptions & { hooks?: SDKHooks };
 
   constructor(options: SDKOptions = {}) {
@@ -191,14 +191,9 @@ export class ClientSDK {
 
     if (conf.body instanceof ReadableStream) {
       if (!fetchOptions) {
-        fetchOptions = {
-          // @ts-expect-error see https://github.com/node-fetch/node-fetch/issues/1769
-          duplex: "half",
-        };
-      } else {
-        // @ts-expect-error see https://github.com/node-fetch/node-fetch/issues/1769
-        fetchOptions.duplex = "half";
+        fetchOptions = {};
       }
+      Object.assign(fetchOptions, { duplex: "half" });
     }
 
     let input;

package/src/lib/security.ts

@@ -3,6 +3,7 @@
  */
 
 import * as components from "../models/components/index.js";
+
 type OAuth2PasswordFlow = {
   username: string;
   password?: string | undefined;
@@ -84,7 +85,9 @@ type SecurityInputOAuth2ClientCredentials = {
   value:
     | { clientID?: string | undefined; clientSecret?: string | undefined }
     | null
+    | string
     | undefined;
+  fieldName?: string;
 };
 
 type SecurityInputOAuth2PasswordCredentials = {
@@ -93,13 +96,13 @@ type SecurityInputOAuth2PasswordCredentials = {
     | string
     | null
     | undefined;
-  fieldName: string;
+  fieldName?: string;
 };
 
 type SecurityInputCustom = {
   type: "http:custom";
   value: any | null | undefined;
-  fieldName: string;
+  fieldName?: string;
 };
 
 export type SecurityInput =
@@ -136,6 +139,9 @@ export function resolveSecurity(
           typeof o.value === "string" && !!o.value
         );
       } else if (o.type === "oauth2:client_credentials") {
+        if (typeof o.value == "string") {
+          return !!o.value;
+        }
         return o.value.clientID != null || o.value.clientSecret != null;
       } else if (typeof o.value === "string") {
         return !!o.value;
@@ -224,7 +230,9 @@ function applyBearer(
     value = `Bearer ${value}`;
   }
 
-  state.headers[spec.fieldName] = value;
+  if (spec.fieldName !== undefined) {
+    state.headers[spec.fieldName] = value;
+  }
 }
 
 export function resolveGlobalSecurity(

package/src/mcp-server/cli/start/command.ts

@@ -0,0 +1,113 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { buildCommand } from "@stricli/core";
+import * as z from "zod";
+import { ServerList } from "../../../lib/config.js";
+import { consoleLoggerLevels } from "../../console-logger.js";
+import { mcpScopes } from "../../scopes.js";
+
+export const startCommand = buildCommand({
+  loader: async () => {
+    const { main } = await import("./impl.js");
+    return main;
+  },
+  parameters: {
+    flags: {
+      transport: {
+        kind: "enum",
+        brief: "The transport to use for communicating with the server",
+        default: "stdio",
+        values: ["stdio", "sse"],
+      },
+      port: {
+        kind: "parsed",
+        brief: "The port to use when the SSE transport is enabled",
+        default: "2718",
+        parse: (val: string) =>
+          z.coerce.number().int().gte(0).lt(65536).parse(val),
+      },
+      tool: {
+        kind: "parsed",
+        brief: "Specify tools to mount on the server",
+        optional: true,
+        variadic: true,
+        parse: (value) => {
+          return z.string().parse(value);
+        },
+      },
+      ...(mcpScopes.length
+        ? {
+          scope: {
+            kind: "enum",
+            brief:
+              "Mount tools/resources that match given scope (repeatable flag)",
+            values: mcpScopes,
+            variadic: true,
+            optional: true,
+          },
+        }
+        : {}),
+      authorization: {
+        kind: "parsed",
+        brief: "Sets the authorization auth field for the API",
+        optional: true,
+        parse: (value) => {
+          return z.string().parse(value);
+        },
+      },
+      "server-url": {
+        kind: "parsed",
+        brief: "Overrides the default server URL used by the SDK",
+        optional: true,
+        parse: (value) => new URL(value).toString(),
+      },
+      server: {
+        kind: "enum",
+        brief: "Selects a predefined server used by the SDK",
+        optional: true,
+        values: Object.keys(ServerList) as Array<keyof typeof ServerList>,
+      },
+      "store-id": {
+        kind: "parsed",
+        brief: "Sets the store_id variable for url substitution",
+        optional: true,
+        parse: (value) => value,
+      },
+      "log-level": {
+        kind: "enum",
+        brief: "The log level to use for the server",
+        default: "info",
+        values: consoleLoggerLevels,
+      },
+      env: {
+        kind: "parsed",
+        brief: "Environment variables made available to the server",
+        optional: true,
+        variadic: true,
+        parse: (val: string) => {
+          const sepIdx = val.indexOf("=");
+          if (sepIdx === -1) {
+            throw new Error("Invalid environment variable format");
+          }
+
+          const key = val.slice(0, sepIdx);
+          const value = val.slice(sepIdx + 1);
+
+          return [
+            z.string().nonempty({
+              message: "Environment variable key must be a non-empty string",
+            }).parse(key),
+            z.string().nonempty({
+              message: "Environment variable value must be a non-empty string",
+            }).parse(value),
+          ] satisfies [string, string];
+        },
+      },
+    },
+  },
+  docs: {
+    brief: "Run the Model Context Protocol server",
+  },
+});

package/src/mcp-server/cli/start/impl.ts

@@ -0,0 +1,137 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import express from "express";
+import { SDKOptions } from "../../../lib/config.js";
+import { LocalContext } from "../../cli.js";
+import {
+  ConsoleLoggerLevel,
+  createConsoleLogger,
+} from "../../console-logger.js";
+import { MCPScope } from "../../scopes.js";
+import { createMCPServer } from "../../server.js";
+
+interface StartCommandFlags {
+  readonly transport: "stdio" | "sse";
+  readonly port: number;
+  readonly tool?: string[];
+  readonly scope?: MCPScope[];
+  readonly authorization?: string | undefined;
+  readonly "server-url"?: string;
+  readonly server?: SDKOptions["server"];
+  readonly "store-id"?: SDKOptions["storeId"];
+  readonly "log-level": ConsoleLoggerLevel;
+  readonly env?: [string, string][];
+}
+
+export async function main(this: LocalContext, flags: StartCommandFlags) {
+  flags.env?.forEach(([key, value]) => {
+    process.env[key] = value;
+  });
+
+  switch (flags.transport) {
+    case "stdio":
+      await startStdio(flags);
+      break;
+    case "sse":
+      await startSSE(flags);
+      break;
+    default:
+      throw new Error(`Invalid transport: ${flags.transport}`);
+  }
+}
+
+async function startStdio(flags: StartCommandFlags) {
+  const logger = createConsoleLogger(flags["log-level"]);
+  const transport = new StdioServerTransport();
+  const server = createMCPServer({
+    logger,
+    allowedTools: flags.tool,
+    scopes: flags.scope,
+    ...{ authorization: flags.authorization },
+    serverURL: flags["server-url"],
+    server: flags.server,
+    storeId: flags["store-id"],
+  });
+  await server.connect(transport);
+
+  const abort = async () => {
+    await server.close();
+    process.exit(0);
+  };
+  process.on("SIGTERM", abort);
+  process.on("SIGINT", abort);
+}
+
+async function startSSE(flags: StartCommandFlags) {
+  const logger = createConsoleLogger(flags["log-level"]);
+  const app = express();
+  const mcpServer = createMCPServer({
+    logger,
+    allowedTools: flags.tool,
+    scopes: flags.scope,
+    ...{ authorization: flags.authorization },
+    serverURL: flags["server-url"],
+    server: flags.server,
+    storeId: flags["store-id"],
+  });
+  let transport: SSEServerTransport | undefined;
+  const controller = new AbortController();
+
+  app.get("/sse", async (_req, res) => {
+    transport = new SSEServerTransport("/message", res);
+
+    await mcpServer.connect(transport);
+
+    mcpServer.server.onclose = async () => {
+      res.end();
+    };
+  });
+
+  app.post("/message", async (req, res) => {
+    if (!transport) {
+      throw new Error("Server transport not initialized");
+    }
+
+    await transport.handlePostMessage(req, res);
+  });
+
+  const httpServer = app.listen(flags.port, "0.0.0.0", () => {
+    const ha = httpServer.address();
+    const host = typeof ha === "string" ? ha : `${ha?.address}:${ha?.port}`;
+    logger.info("MCP HTTP server started", { host });
+  });
+
+  let closing = false;
+  controller.signal.addEventListener("abort", async () => {
+    if (closing) {
+      logger.info("Received second signal. Forcing shutdown.");
+      process.exit(1);
+    }
+    closing = true;
+
+    logger.info("Shutting down MCP server");
+
+    await mcpServer.close();
+
+    logger.info("Shutting down HTTP server");
+
+    const timer = setTimeout(() => {
+      logger.info("Forcing shutdown");
+      process.exit(1);
+    }, 5000);
+
+    httpServer.close(() => {
+      clearTimeout(timer);
+      logger.info("Graceful shutdown complete");
+      process.exit(0);
+    });
+  });
+
+  const abort = () => controller.abort();
+  process.on("SIGTERM", abort);
+  process.on("SIGINT", abort);
+}

package/src/mcp-server/cli.ts

@@ -0,0 +1,13 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { CommandContext, StricliProcess } from "@stricli/core";
+
+export interface LocalContext extends CommandContext {
+  readonly process: StricliProcess;
+}
+
+export function buildContext(process: NodeJS.Process): LocalContext {
+  return { process: process as StricliProcess };
+}

package/src/mcp-server/console-logger.ts

@@ -0,0 +1,71 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+export const consoleLoggerLevels = [
+  "debug",
+  "warning",
+  "info",
+  "error",
+] as const;
+
+export type ConsoleLoggerLevel = (typeof consoleLoggerLevels)[number];
+
+export type ConsoleLogger = {
+  [key in ConsoleLoggerLevel]: (
+    message: string,
+    data?: Record<string, unknown>,
+  ) => void;
+};
+
+export function createConsoleLogger(level: ConsoleLoggerLevel): ConsoleLogger {
+  const min = consoleLoggerLevels.indexOf(level);
+  const noop = () => {};
+
+  const logger: ConsoleLogger = {
+    debug: noop,
+    warning: noop,
+    info: noop,
+    error: noop,
+  };
+
+  return consoleLoggerLevels.reduce((logger, level, i) => {
+    if (i < min) {
+      return logger;
+    }
+
+    logger[level] = log.bind(null, level);
+
+    return logger;
+  }, logger);
+}
+
+function log(
+  level: ConsoleLoggerLevel,
+  message: string,
+  data?: Record<string, unknown>,
+) {
+  let line = "";
+  const allData = [{ msg: message, l: level }, data];
+
+  for (const ctx of allData) {
+    for (const [key, value] of Object.entries(ctx || {})) {
+      if (value == null) {
+        line += ` ${key}=<${value}>`;
+      } else if (typeof value === "function") {
+        line += ` ${key}=<function>`;
+      } else if (typeof value === "symbol") {
+        line += ` ${key}=${value.toString()}`;
+      } else if (typeof value === "string") {
+        const v = value.search(/\s/g) >= 0 ? JSON.stringify(value) : value;
+        line += ` ${key}=${v}`;
+      } else if (typeof value !== "object") {
+        line += ` ${key}=${value}`;
+      } else {
+        line += ` ${key}="${JSON.stringify(value)}"`;
+      }
+    }
+  }
+
+  console.error(line);
+}