@greensecurity/javascript-sdk 0.35.53 → 0.36.0

package/src/lib/matchers.ts

@@ -3,11 +3,10 @@
  */
 
 import { APIError } from "../models/errors/apierror.js";
-import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
-import { Result } from "../types/fp.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { ERR, OK, Result } from "../types/fp.js";
 import { matchResponse, matchStatusCode, StatusCodePredicate } from "./http.js";
 import { isPlainObject } from "./is-plain-object.js";
-import { safeParse } from "./schemas.js";
 
 export type Encoding =
   | "jsonl"
@@ -176,17 +175,19 @@ export type MatchedError<Matchers> = Matchers extends Matcher<any, infer E>[]
   : never;
 export type MatchFunc<T, E> = (
   response: Response,
+  request: Request,
   options?: { resultKey?: string; extraFields?: Record<string, unknown> },
 ) => Promise<[result: Result<T, E>, raw: unknown]>;
 
 export function match<T, E>(
   ...matchers: Array<Matcher<T, E>>
-): MatchFunc<T, E | APIError | SDKValidationError> {
+): MatchFunc<T, E | APIError | ResponseValidationError> {
   return async function matchFunc(
     response: Response,
+    request: Request,
     options?: { resultKey?: string; extraFields?: Record<string, unknown> },
   ): Promise<
-    [result: Result<T, E | APIError | SDKValidationError>, raw: unknown]
+    [result: Result<T, E | APIError | ResponseValidationError>, raw: unknown]
   > {
     let raw: unknown;
     let matcher: Matcher<T, E> | undefined;
@@ -205,21 +206,22 @@ export function match<T, E>(
     }
 
     if (!matcher) {
-      const responseBody = await response.text();
       return [{
         ok: false,
-        error: new APIError(
-          "Unexpected API response status or content-type",
+        error: new APIError("Unexpected Status or Content-Type", {
           response,
-          responseBody,
-        ),
-      }, responseBody];
+          request,
+          body: await response.text().catch(() => ""),
+        }),
+      }, raw];
     }
 
     const encoding = matcher.enc;
+    let body = "";
     switch (encoding) {
       case "json":
-        raw = await response.json();
+        body = await response.text();
+        raw = JSON.parse(body);
         break;
       case "jsonl":
         raw = response.body;
@@ -231,16 +233,19 @@ export function match<T, E>(
         raw = response.body;
         break;
       case "text":
-        raw = await response.text();
+        body = await response.text();
+        raw = body;
         break;
       case "sse":
         raw = response.body;
         break;
       case "nil":
-        raw = await discardResponseBody(response);
+        body = await response.text();
+        raw = undefined;
         break;
       case "fail":
-        raw = await response.text();
+        body = await response.text();
+        raw = body;
         break;
       default:
         encoding satisfies never;
@@ -250,11 +255,7 @@ export function match<T, E>(
     if (matcher.enc === "fail") {
       return [{
         ok: false,
-        error: new APIError(
-          "API error occurred",
-          response,
-          typeof raw === "string" ? raw : "",
-        ),
+        error: new APIError("API error occurred", { request, response, body }),
       }, raw];
     }
 
@@ -266,6 +267,9 @@ export function match<T, E>(
         ...options?.extraFields,
         ...(matcher.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
         ...(isPlainObject(raw) ? raw : null),
+        request$: request,
+        response$: response,
+        body$: body,
       };
     } else if (resultKey) {
       data = {
@@ -284,18 +288,20 @@ export function match<T, E>(
     }
 
     if ("err" in matcher) {
-      const result = safeParse(
+      const result = safeParseResponse(
         data,
         (v: unknown) => matcher.schema.parse(v),
         "Response validation failed",
+        { request, response, body },
       );
       return [result.ok ? { ok: false, error: result.value } : result, raw];
     } else {
       return [
-        safeParse(
+        safeParseResponse(
           data,
           (v: unknown) => matcher.schema.parse(v),
           "Response validation failed",
+          { request, response, body },
         ),
         raw,
       ];
@@ -318,25 +324,22 @@ export function unpackHeaders(headers: Headers): Record<string, string[]> {
   return out;
 }
 
-/**
- * Discards the response body to free up resources.
- *
- * To learn why this is need, see the undici docs:
- * https://undici.nodejs.org/#/?id=garbage-collection
- */
-export async function discardResponseBody(res: Response) {
-  const reader = res.body?.getReader();
-  if (reader == null) {
-    return;
-  }
-
+function safeParseResponse<Inp, Out>(
+  rawValue: Inp,
+  fn: (value: Inp) => Out,
+  errorMessage: string,
+  httpMeta: { response: Response; request: Request; body: string },
+): Result<Out, ResponseValidationError> {
   try {
-    let done = false;
-    while (!done) {
-      const res = await reader.read();
-      done = res.done;
-    }
-  } finally {
-    reader.releaseLock();
+    return OK(fn(rawValue));
+  } catch (err) {
+    return ERR(
+      new ResponseValidationError(errorMessage, {
+        cause: err,
+        rawValue,
+        rawMessage: errorMessage,
+        ...httpMeta,
+      }),
+    );
   }
 }

package/src/lib/security.ts

@@ -7,8 +7,8 @@ import { env } from "./env.js";
 
 type OAuth2PasswordFlow = {
   username: string;
-  password?: string | undefined;
-  clientID: string;
+  password: string;
+  clientID?: string | undefined;
   clientSecret?: string | undefined;
   tokenURL: string;
 };

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

@@ -19,7 +19,7 @@ const routes = buildRouteMap({
 export const app = buildApplication(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.35.53",
+    currentVersion: "0.36.0",
   },
 });
 

package/src/mcp-server/server.ts

@@ -87,7 +87,7 @@ export function createMCPServer(deps: {
 }) {
   const server = new McpServer({
     name: "GreenSecurity",
-    version: "0.35.53",
+    version: "0.36.0",
   });
 
   const client = new GreenSecurityCore({

package/src/models/components/invoice.ts

@@ -28,6 +28,7 @@ export type Invoice = {
   invoiceNumber?: string | null | undefined;
   trackingNumber?: string | null | undefined;
   dateProcessed?: string | null | undefined;
+  dateDue?: string | null | undefined;
   amount?: number | null | undefined;
   status?: string | null | undefined;
   financialStatus?: string | null | undefined;
@@ -47,6 +48,7 @@ export const Invoice$inboundSchema: z.ZodType<Invoice, z.ZodTypeDef, unknown> =
     invoice_number: z.nullable(z.string()).optional(),
     tracking_number: z.nullable(z.string()).optional(),
     date_processed: z.nullable(z.string()).optional(),
+    date_due: z.nullable(z.string()).optional(),
     amount: z.nullable(z.number().int()).optional(),
     status: z.nullable(z.string()).optional(),
     financial_status: z.nullable(z.string()).optional(),
@@ -64,6 +66,7 @@ export const Invoice$inboundSchema: z.ZodType<Invoice, z.ZodTypeDef, unknown> =
       "invoice_number": "invoiceNumber",
       "tracking_number": "trackingNumber",
       "date_processed": "dateProcessed",
+      "date_due": "dateDue",
       "financial_status": "financialStatus",
       "amount_not_paid": "amountNotPaid",
       "convenience_fee": "convenienceFee",
@@ -76,6 +79,7 @@ export type Invoice$Outbound = {
   invoice_number?: string | null | undefined;
   tracking_number?: string | null | undefined;
   date_processed?: string | null | undefined;
+  date_due?: string | null | undefined;
   amount?: number | null | undefined;
   status?: string | null | undefined;
   financial_status?: string | null | undefined;
@@ -98,6 +102,7 @@ export const Invoice$outboundSchema: z.ZodType<
   invoiceNumber: z.nullable(z.string()).optional(),
   trackingNumber: z.nullable(z.string()).optional(),
   dateProcessed: z.nullable(z.string()).optional(),
+  dateDue: z.nullable(z.string()).optional(),
   amount: z.nullable(z.number().int()).optional(),
   status: z.nullable(z.string()).optional(),
   financialStatus: z.nullable(z.string()).optional(),
@@ -114,6 +119,7 @@ export const Invoice$outboundSchema: z.ZodType<
     invoiceNumber: "invoice_number",
     trackingNumber: "tracking_number",
     dateProcessed: "date_processed",
+    dateDue: "date_due",
     financialStatus: "financial_status",
     amountNotPaid: "amount_not_paid",
     convenienceFee: "convenience_fee",

package/src/models/components/zone.ts

@@ -31,7 +31,7 @@ export type Two = {
   name?: string | undefined;
 };
 
-export type ZoneFacility = Two | Facility;
+export type ZoneFacility = Facility | Two;
 
 export type ZoneDepartment = Department | number;
 
@@ -104,7 +104,7 @@ export type GpsCheckinPolicy = {
  */
 export type Zone = {
   id?: number | undefined;
-  facility?: Two | Facility | null | undefined;
+  facility?: Facility | Two | null | undefined;
   department?: Department | number | null | undefined;
   name?: string | null | undefined;
   shortName?: string | null | undefined;
@@ -173,17 +173,17 @@ export const ZoneFacility$inboundSchema: z.ZodType<
   ZoneFacility,
   z.ZodTypeDef,
   unknown
-> = z.union([z.lazy(() => Two$inboundSchema), Facility$inboundSchema]);
+> = z.union([Facility$inboundSchema, z.lazy(() => Two$inboundSchema)]);
 
 /** @internal */
-export type ZoneFacility$Outbound = Two$Outbound | Facility$Outbound;
+export type ZoneFacility$Outbound = Facility$Outbound | Two$Outbound;
 
 /** @internal */
 export const ZoneFacility$outboundSchema: z.ZodType<
   ZoneFacility$Outbound,
   z.ZodTypeDef,
   ZoneFacility
-> = z.union([z.lazy(() => Two$outboundSchema), Facility$outboundSchema]);
+> = z.union([Facility$outboundSchema, z.lazy(() => Two$outboundSchema)]);
 
 /**
  * @internal
@@ -839,7 +839,7 @@ export const Zone$inboundSchema: z.ZodType<Zone, z.ZodTypeDef, unknown> = z
   .object({
     id: z.number().int().optional(),
     facility: z.nullable(
-      z.union([z.lazy(() => Two$inboundSchema), Facility$inboundSchema]),
+      z.union([Facility$inboundSchema, z.lazy(() => Two$inboundSchema)]),
     ).optional(),
     department: z.nullable(
       z.union([Department$inboundSchema, z.number().int()]),
@@ -876,7 +876,7 @@ export const Zone$inboundSchema: z.ZodType<Zone, z.ZodTypeDef, unknown> = z
 /** @internal */
 export type Zone$Outbound = {
   id?: number | undefined;
-  facility?: Two$Outbound | Facility$Outbound | null | undefined;
+  facility?: Facility$Outbound | Two$Outbound | null | undefined;
   department?: Department$Outbound | number | null | undefined;
   name?: string | null | undefined;
   short_name?: string | null | undefined;
@@ -898,7 +898,7 @@ export const Zone$outboundSchema: z.ZodType<Zone$Outbound, z.ZodTypeDef, Zone> =
   z.object({
     id: z.number().int().optional(),
     facility: z.nullable(
-      z.union([z.lazy(() => Two$outboundSchema), Facility$outboundSchema]),
+      z.union([Facility$outboundSchema, z.lazy(() => Two$outboundSchema)]),
     ).optional(),
     department: z.nullable(
       z.union([Department$outboundSchema, z.number().int()]),

package/src/models/errors/apierror.ts

@@ -2,41 +2,33 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
-export class APIError extends Error {
-  /**
-   * HTTP status code
-   */
-  public readonly statusCode: number;
-  /**
-   * HTTP content type
-   */
-  public readonly contentType: string;
-  /**
-   * HTTP body
-   */
-  public readonly body: string;
-  /**
-   * Raw response
-   */
-  public readonly rawResponse: Response;
+import { GreenSecurityError } from "./greensecurityerror.js";
 
+/** The fallback error class if no more specific error class is matched */
+export class APIError extends GreenSecurityError {
   constructor(
     message: string,
-    rawResponse: Response,
-    body: string = "",
+    httpMeta: {
+      response: Response;
+      request: Request;
+      body: string;
+    },
   ) {
-    const statusCode = rawResponse.status;
-    const contentType = rawResponse.headers.get("content-type") || "";
-    const bodyString = body.length > 0 ? `\n${body}` : "";
-    super(
-      `${message}: Status ${statusCode} Content-Type ${contentType} Body ${bodyString}`,
-    );
-
-    this.body = body;
-    this.rawResponse = rawResponse;
-    this.statusCode = statusCode;
-    this.contentType = contentType;
-
+    if (message) {
+      message += `: `;
+    }
+    message += `Status ${httpMeta.response.status}`;
+    const contentType = httpMeta.response.headers.get("content-type") || `""`;
+    if (contentType !== "application/json") {
+      message += ` Content-Type ${
+        contentType.includes(" ") ? `"${contentType}"` : contentType
+      }`;
+    }
+    const body = httpMeta.body || `""`;
+    message += body.length > 100 ? "\n" : " ";
+    message += `Body ${body}`;
+    message = message.trim();
+    super(message, httpMeta);
     this.name = "APIError";
   }
 }

package/src/models/errors/apierrorresponse.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod";
+import { GreenSecurityError } from "./greensecurityerror.js";
 
 /**
  * Green Security uses conventional HTTP response codes to indicate the success or failure of an API request. In general: Codes in the 2xx range indicate success. Codes in the 4xx range indicate an error that failed given the information provided (e.g., a required parameter was omitted, a charge failed, etc.). Codes in the 5xx range indicate an error with Stripe’s servers (these are rare).
@@ -24,7 +25,7 @@ export type ApiErrorResponseData = {
  *
  * Some 4xx errors that could be handled programmatically (e.g., invalid input) include an error description that briefly explains the error reported.
  */
-export class ApiErrorResponse extends Error {
+export class ApiErrorResponse extends GreenSecurityError {
   error: string;
   success: boolean;
   code?: number | null | undefined;
@@ -32,13 +33,15 @@ export class ApiErrorResponse extends Error {
   /** The original data that was passed to this error instance. */
   data$: ApiErrorResponseData;
 
-  constructor(err: ApiErrorResponseData) {
+  constructor(
+    err: ApiErrorResponseData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
     const message = "message" in err && typeof err.message === "string"
       ? err.message
       : `API error occurred: ${JSON.stringify(err)}`;
-    super(message);
+    super(message, httpMeta);
     this.data$ = err;
-
     this.error = err.error;
     this.success = err.success;
     if (err.code != null) this.code = err.code;
@@ -56,9 +59,16 @@ export const ApiErrorResponse$inboundSchema: z.ZodType<
   error: z.string(),
   success: z.boolean(),
   code: z.nullable(z.number().int()).optional(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
 })
   .transform((v) => {
-    return new ApiErrorResponse(v);
+    return new ApiErrorResponse(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
   });
 
 /** @internal */

package/src/models/errors/greensecurityerror.ts

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+/** The base class for all HTTP error responses */
+export class GreenSecurityError extends Error {
+  /** HTTP status code */
+  public readonly statusCode: number;
+  /** HTTP body */
+  public readonly body: string;
+  /** HTTP headers */
+  public readonly headers: Headers;
+  /** HTTP content type */
+  public readonly contentType: string;
+  /** Raw response */
+  public readonly rawResponse: Response;
+
+  constructor(
+    message: string,
+    httpMeta: {
+      response: Response;
+      request: Request;
+      body: string;
+    },
+  ) {
+    super(message);
+    this.statusCode = httpMeta.response.status;
+    this.body = httpMeta.body;
+    this.headers = httpMeta.response.headers;
+    this.contentType = httpMeta.response.headers.get("content-type") || "";
+    this.rawResponse = httpMeta.response;
+
+    this.name = "GreenSecurityError";
+  }
+}

package/src/models/errors/index.ts

@@ -5,4 +5,5 @@
 export * from "./apierror.js";
 export * from "./apierrorresponse.js";
 export * from "./httpclienterrors.js";
+export * from "./responsevalidationerror.js";
 export * from "./sdkvalidationerror.js";

package/src/models/errors/responsevalidationerror.ts

@@ -0,0 +1,50 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { GreenSecurityError } from "./greensecurityerror.js";
+import { formatZodError } from "./sdkvalidationerror.js";
+
+export class ResponseValidationError extends GreenSecurityError {
+  /**
+   * The raw value that failed validation.
+   */
+  public readonly rawValue: unknown;
+
+  /**
+   * The raw message that failed validation.
+   */
+  public readonly rawMessage: unknown;
+
+  constructor(
+    message: string,
+    extra: {
+      response: Response;
+      request: Request;
+      body: string;
+      cause: unknown;
+      rawValue: unknown;
+      rawMessage: unknown;
+    },
+  ) {
+    super(message, extra);
+    this.name = "ResponseValidationError";
+    this.cause = extra.cause;
+    this.rawValue = extra.rawValue;
+    this.rawMessage = extra.rawMessage;
+  }
+
+  /**
+   * Return a pretty-formatted error message if the underlying validation error
+   * is a ZodError or some other recognized error type, otherwise return the
+   * default error message.
+   */
+  public pretty(): string {
+    if (this.cause instanceof z.ZodError) {
+      return `${this.rawMessage}\n${formatZodError(this.cause)}`;
+    } else {
+      return this.toString();
+    }
+  }
+}

package/src/models/errors/sdkvalidationerror.ts

@@ -15,6 +15,18 @@ export class SDKValidationError extends Error {
    */
   public readonly rawMessage: unknown;
 
+  // Allows for backwards compatibility for `instanceof` checks of `ResponseValidationError`
+  static override [Symbol.hasInstance](
+    instance: unknown,
+  ): instance is SDKValidationError {
+    if (!(instance instanceof Error)) return false;
+    if (!("rawValue" in instance)) return false;
+    if (!("rawMessage" in instance)) return false;
+    if (!("pretty" in instance)) return false;
+    if (typeof instance.pretty !== "function") return false;
+    return true;
+  }
+
   constructor(message: string, cause: unknown, rawValue: unknown) {
     super(`${message}: ${cause}`);
     this.name = "SDKValidationError";