@greensecurity/javascript-sdk 0.44.0-beta.6 → 0.44.0-beta.60

package/src/lib/http.ts

@@ -45,8 +45,10 @@ export class HTTPClient {
   private requestHooks: BeforeRequestHook[] = [];
   private requestErrorHooks: RequestErrorHook[] = [];
   private responseHooks: ResponseHook[] = [];
+  private options: HTTPClientOptions;
 
-  constructor(private options: HTTPClientOptions = {}) {
+  constructor(options: HTTPClientOptions = {}) {
+    this.options = options;
     this.fetcher = options.fetcher || DEFAULT_FETCHER;
   }
 

package/src/lib/matchers.ts

@@ -6,7 +6,7 @@ import { APIError } from "../models/errors/apierror.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 { isPlainObject } from "./primitives.js";
 
 export type Encoding =
   | "jsonl"

package/src/lib/primitives.ts

@@ -148,3 +148,19 @@ export function allRequired<V extends Record<string, unknown>>(
 
   return v as ReturnType<typeof allRequired<V>>;
 }
+
+export function isPlainObject(
+  value: unknown,
+): value is Record<string, unknown> {
+  if (value === null || typeof value !== "object") return false;
+  if (Object.prototype.toString.call(value) !== "[object Object]") return false;
+  const proto = Object.getPrototypeOf(value);
+  if (proto === null || proto === Object.prototype) return true;
+  // cross-realm plain objects (vm contexts, iframes) inherit from a
+  // different realm's Object.prototype, which itself has a null prototype
+  try {
+    return Object.getPrototypeOf(proto) === null;
+  } catch {
+    return false;
+  }
+}

package/src/lib/retries.ts

@@ -194,6 +194,14 @@ async function retryBackoff(
 }
 
 function retryIntervalFromResponse(res: Response): number {
+  const retryAfterMsVal = res.headers.get("retry-after-ms");
+  if (retryAfterMsVal) {
+    const parsedMs = Number(retryAfterMsVal);
+    if (Number.isFinite(parsedMs) && parsedMs >= 0) {
+      return parsedMs;
+    }
+  }
+
   const retryVal = res.headers.get("retry-after") || "";
   if (!retryVal) {
     return 0;

package/src/lib/sdks.ts

@@ -12,6 +12,7 @@ import {
   UnexpectedClientError,
 } from "../models/errors/httpclienterrors.js";
 import { ERR, OK, Result } from "../types/fp.js";
+import { WebhookAuthenticationError } from "../types/webhooks.js";
 import { stringToBase64 } from "./base64.js";
 import { SDK_METADATA, SDKOptions, serverURLFromOptions } from "./config.js";
 import { encodeForm } from "./encodings.js";
@@ -24,6 +25,7 @@ import {
   matchContentType,
 } from "./http.js";
 import { Logger } from "./logger.js";
+import { combineSignals } from "./primitives.js";
 import { retry, RetryConfig } from "./retries.js";
 import { SecurityState } from "./security.js";
 
@@ -132,27 +134,55 @@ export class ClientSDK {
     if (path) {
       baseURL.pathname = baseURL.pathname.replace(/\/+$/, "") + "/";
       reqURL = new URL(path, baseURL);
+      if (!reqURL.search && baseURL.search) {
+        reqURL.search = baseURL.search;
+      }
     } else {
       reqURL = baseURL;
     }
     reqURL.hash = "";
 
-    let finalQuery = query || "";
-
-    const secQuery: string[] = [];
-    for (const [k, v] of Object.entries(security?.queryParams || {})) {
-      const q = encodeForm(k, v, { charEncoding: "percent" });
-      if (typeof q !== "undefined") {
-        secQuery.push(q);
+    // Appends already-encoded query pairs to a query string, replacing any
+    // existing pairs with the same key so later sources take precedence.
+    const mergeQuery = (current: string, additions: string): string => {
+      if (!additions) {
+        return current;
       }
-    }
-    if (secQuery.length) {
-      finalQuery += `&${secQuery.join("&")}`;
-    }
+      const additionKeys = new Set(
+        additions
+          .split("&")
+          .filter((pair) => pair !== "")
+          .map((pair) => pair.split("=")[0] ?? ""),
+      );
+      const kept = current.split("&").filter((pair) => {
+        return pair !== "" && !additionKeys.has(pair.split("=")[0] ?? "");
+      });
+      return [...kept, additions].join("&");
+    };
+
+    const encodeQueryRecord = (record: Record<string, unknown>): string => {
+      return Object.entries(record)
+        .map(([k, v]) => {
+          if (v == null) {
+            return undefined;
+          }
+          const value = v;
+          return encodeForm(k, value, {
+            explode: Array.isArray(value),
+            charEncoding: "percent",
+          });
+        })
+        .filter((pair): pair is string => typeof pair !== "undefined")
+        .join("&");
+    };
+
+    const finalQuery = [
+      query || "",
+      encodeQueryRecord(security?.queryParams || {}),
+    ].reduce(mergeQuery, reqURL.search.slice(1));
 
     if (finalQuery) {
-      const q = finalQuery.startsWith("&") ? finalQuery.slice(1) : finalQuery;
-      reqURL.search = `?${q}`;
+      reqURL.search = `?${finalQuery}`;
     }
 
     const headers = new Headers(opHeaders);
@@ -198,9 +228,8 @@ export class ClientSDK {
       ...options?.fetchOptions,
       ...options,
     };
-    if (!fetchOptions?.signal && conf.timeoutMs && conf.timeoutMs > 0) {
-      const timeoutSignal = AbortSignal.timeout(conf.timeoutMs);
-      fetchOptions.signal = timeoutSignal;
+    if (!fetchOptions?.signal && conf.timeoutMs != null && conf.timeoutMs > 0) {
+      context.timeoutMs = conf.timeoutMs;
     }
 
     if (conf.body instanceof ReadableStream) {
@@ -247,10 +276,19 @@ export class ClientSDK {
     >
   > {
     const { context, isErrorStatusCode } = options;
+    const timeoutMs = context.timeoutMs;
 
     return retry(
       async () => {
-        const req = await this.#hooks.beforeRequest(context, request.clone());
+        const cloned = request.clone();
+        let attempt = cloned;
+        if (timeoutMs != null && timeoutMs > 0) {
+          const timeoutSignal = AbortSignal.timeout(timeoutMs);
+          const combined = combineSignals(cloned.signal, timeoutSignal)
+            ?? timeoutSignal;
+          attempt = new Request(cloned, { signal: combined });
+        }
+        const req = await this.#hooks.beforeRequest(context, attempt);
         await logRequest(this.#logger, req).catch((e) =>
           this.#logger?.log("Failed to log request:", e)
         );
@@ -307,6 +345,12 @@ export class ClientSDK {
       },
     );
   }
+
+  async _verifyWebhook(
+    { request, secret }: { request: Request; secret: string },
+  ): Promise<Result<true, WebhookAuthenticationError>> {
+    return this.#hooks.verifyWebhook({}, { request, secret });
+  }
 }
 
 const jsonLikeContentTypeRE = /^(application|text)\/([^+]+\+)*json.*/;

package/src/lib/security.ts

@@ -13,17 +13,22 @@ type OAuth2PasswordFlow = {
   tokenURL: string;
 };
 
-export enum SecurityErrorCode {
-  Incomplete = "incomplete",
-  UnrecognisedSecurityType = "unrecognized_security_type",
-}
+export const SecurityErrorCode = {
+  Incomplete: "incomplete",
+  UnrecognisedSecurityType: "unrecognized_security_type",
+} as const;
+export type SecurityErrorCode =
+  (typeof SecurityErrorCode)[keyof typeof SecurityErrorCode];
 
 export class SecurityError extends Error {
+  public code: SecurityErrorCode;
+
   constructor(
-    public code: SecurityErrorCode,
+    code: SecurityErrorCode,
     message: string,
   ) {
     super(message);
+    this.code = code;
     this.name = "SecurityError";
   }
 

package/src/models/components/alert.ts

@@ -15,9 +15,30 @@ export const Type = {
   Error: "Error",
   Warning: "Warning",
   Info: "Info",
+  WebNotification: "Web Notification",
+  SmartBadgeScreeningQuestions: "Smart Badge Screening Questions",
 } as const;
 export type Type = OpenEnum<typeof Type>;
 
+export const FollowUpType = {
+  CompleteCheckin: "complete_checkin",
+  AskScreeningQuestions: "ask_screening_questions",
+} as const;
+export type FollowUpType = OpenEnum<typeof FollowUpType>;
+
+/**
+ * Context data for smart badge follow-up alerts.
+ */
+export type AlertContext = {
+  facilityId?: number | null | undefined;
+  handoffId?: number | null | undefined;
+  qrCode?: string | null | undefined;
+  zoneId?: number | null | undefined;
+  vendorScanId?: number | null | undefined;
+  recheckVendorScanId?: number | null | undefined;
+  followUpType?: FollowUpType | null | undefined;
+};
+
 /**
  * A simplified representation of a Alert, typically used in list views.
  */
@@ -31,6 +52,10 @@ export type Alert = {
   type?: Type | null | undefined;
   title?: string | null | undefined;
   plainText?: string | null | undefined;
+  /**
+   * Context data for smart badge follow-up alerts.
+   */
+  alertContext?: AlertContext | null | undefined;
   viewed?: boolean | null | undefined;
   dateViewed?: string | null | undefined;
 };
@@ -39,6 +64,48 @@ export type Alert = {
 export const Type$inboundSchema: z.ZodType<Type, z.ZodTypeDef, unknown> =
   openEnums.inboundSchema(Type);
 
+/** @internal */
+export const FollowUpType$inboundSchema: z.ZodType<
+  FollowUpType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(FollowUpType);
+
+/** @internal */
+export const AlertContext$inboundSchema: z.ZodType<
+  AlertContext,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  facility_id: z.nullable(types.number()).optional(),
+  handoff_id: z.nullable(types.number()).optional(),
+  qr_code: z.nullable(types.string()).optional(),
+  zone_id: z.nullable(types.number()).optional(),
+  vendor_scan_id: z.nullable(types.number()).optional(),
+  recheck_vendor_scan_id: z.nullable(types.number()).optional(),
+  follow_up_type: z.nullable(FollowUpType$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "facility_id": "facilityId",
+    "handoff_id": "handoffId",
+    "qr_code": "qrCode",
+    "zone_id": "zoneId",
+    "vendor_scan_id": "vendorScanId",
+    "recheck_vendor_scan_id": "recheckVendorScanId",
+    "follow_up_type": "followUpType",
+  });
+});
+
+export function alertContextFromJSON(
+  jsonString: string,
+): SafeParseResult<AlertContext, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AlertContext$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AlertContext' from JSON`,
+  );
+}
+
 /** @internal */
 export const Alert$inboundSchema: z.ZodType<Alert, z.ZodTypeDef, unknown> = z
   .object({
@@ -51,6 +118,8 @@ export const Alert$inboundSchema: z.ZodType<Alert, z.ZodTypeDef, unknown> = z
     type: z.nullable(Type$inboundSchema).optional(),
     title: z.nullable(types.string()).optional(),
     plain_text: z.nullable(types.string()).optional(),
+    alert_context: z.nullable(z.lazy(() => AlertContext$inboundSchema))
+      .optional(),
     viewed: z.nullable(types.boolean()).optional(),
     date_viewed: z.nullable(types.string()).optional(),
   }).transform((v) => {
@@ -59,6 +128,7 @@ export const Alert$inboundSchema: z.ZodType<Alert, z.ZodTypeDef, unknown> = z
       "date_added": "dateAdded",
       "date_starts": "dateStarts",
       "plain_text": "plainText",
+      "alert_context": "alertContext",
       "date_viewed": "dateViewed",
     });
   });

package/src/models/components/appointmentsummary.ts

@@ -47,7 +47,44 @@ export const AppointmentSummary$inboundSchema: z.ZodType<
     "standing_appt": "standingAppt",
   });
 });
+/** @internal */
+export type AppointmentSummary$Outbound = {
+  id: number;
+  title?: string | null | undefined;
+  start?: string | null | undefined;
+  end?: string | null | undefined;
+  all_day?: boolean | null | undefined;
+  standing_appt?: boolean | null | undefined;
+  status?: string | null | undefined;
+};
 
+/** @internal */
+export const AppointmentSummary$outboundSchema: z.ZodType<
+  AppointmentSummary$Outbound,
+  z.ZodTypeDef,
+  AppointmentSummary
+> = z.object({
+  id: z.number().int(),
+  title: z.nullable(z.string()).optional(),
+  start: z.nullable(z.string()).optional(),
+  end: z.nullable(z.string()).optional(),
+  allDay: z.nullable(z.boolean()).optional(),
+  standingAppt: z.nullable(z.boolean()).optional(),
+  status: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    allDay: "all_day",
+    standingAppt: "standing_appt",
+  });
+});
+
+export function appointmentSummaryToJSON(
+  appointmentSummary: AppointmentSummary,
+): string {
+  return JSON.stringify(
+    AppointmentSummary$outboundSchema.parse(appointmentSummary),
+  );
+}
 export function appointmentSummaryFromJSON(
   jsonString: string,
 ): SafeParseResult<AppointmentSummary, SDKValidationError> {

package/src/models/components/company.ts

@@ -11,10 +11,14 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   CompanyVendorField,
   CompanyVendorField$inboundSchema,
+  CompanyVendorField$Outbound,
+  CompanyVendorField$outboundSchema,
 } from "./companyvendorfield.js";
 import {
   CompanyVendorTypeRestriction,
   CompanyVendorTypeRestriction$inboundSchema,
+  CompanyVendorTypeRestriction$Outbound,
+  CompanyVendorTypeRestriction$outboundSchema,
 } from "./companyvendortyperestriction.js";
 
 export type CompanyLocation = {
@@ -83,7 +87,35 @@ export const CompanyLocation$inboundSchema: z.ZodType<
   zip: z.nullable(types.string()).optional(),
   country: z.nullable(types.string()).optional(),
 });
+/** @internal */
+export type CompanyLocation$Outbound = {
+  address?: string | null | undefined;
+  phone?: string | null | undefined;
+  city?: string | null | undefined;
+  state?: string | null | undefined;
+  zip?: string | null | undefined;
+  country?: string | null | undefined;
+};
 
+/** @internal */
+export const CompanyLocation$outboundSchema: z.ZodType<
+  CompanyLocation$Outbound,
+  z.ZodTypeDef,
+  CompanyLocation
+> = z.object({
+  address: z.nullable(z.string()).optional(),
+  phone: z.nullable(z.string()).optional(),
+  city: z.nullable(z.string()).optional(),
+  state: z.nullable(z.string()).optional(),
+  zip: z.nullable(z.string()).optional(),
+  country: z.nullable(z.string()).optional(),
+});
+
+export function companyLocationToJSON(
+  companyLocation: CompanyLocation,
+): string {
+  return JSON.stringify(CompanyLocation$outboundSchema.parse(companyLocation));
+}
 export function companyLocationFromJSON(
   jsonString: string,
 ): SafeParseResult<CompanyLocation, SDKValidationError> {
@@ -103,7 +135,25 @@ export const CompanyContact$inboundSchema: z.ZodType<
   name: types.nullable(types.string()),
   email: z.nullable(types.string()).optional(),
 });
+/** @internal */
+export type CompanyContact$Outbound = {
+  name: string | null;
+  email?: string | null | undefined;
+};
+
+/** @internal */
+export const CompanyContact$outboundSchema: z.ZodType<
+  CompanyContact$Outbound,
+  z.ZodTypeDef,
+  CompanyContact
+> = z.object({
+  name: z.nullable(z.string()),
+  email: z.nullable(z.string()).optional(),
+});
 
+export function companyContactToJSON(companyContact: CompanyContact): string {
+  return JSON.stringify(CompanyContact$outboundSchema.parse(companyContact));
+}
 export function companyContactFromJSON(
   jsonString: string,
 ): SafeParseResult<CompanyContact, SDKValidationError> {
@@ -135,7 +185,44 @@ export const Tax$inboundSchema: z.ZodType<Tax, z.ZodTypeDef, unknown> = z
       "w9_updated_at": "w9UpdatedAt",
     });
   });
+/** @internal */
+export type Tax$Outbound = {
+  tax_id: string | null;
+  tax_exempt?: boolean | null | undefined;
+  tax_exempt_code?: string | null | undefined;
+  w9_file_name?: string | null | undefined;
+  w9_content_type?: string | null | undefined;
+  w9_file_size?: string | null | undefined;
+  w9_updated_at?: string | null | undefined;
+};
+
+/** @internal */
+export const Tax$outboundSchema: z.ZodType<Tax$Outbound, z.ZodTypeDef, Tax> = z
+  .object({
+    taxId: z.nullable(z.string()),
+    taxExempt: z.nullable(z.boolean()).optional(),
+    taxExemptCode: z.nullable(z.string()).optional(),
+    w9FileName: z.nullable(z.string()).optional(),
+    w9ContentType: z.nullable(z.string()).optional(),
+    w9FileSize: z.nullable(z.string()).optional(),
+    w9UpdatedAt: z.nullable(
+      z.date().transform(v => v.toISOString().slice(0, "YYYY-MM-DD".length)),
+    ).optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      taxId: "tax_id",
+      taxExempt: "tax_exempt",
+      taxExemptCode: "tax_exempt_code",
+      w9FileName: "w9_file_name",
+      w9ContentType: "w9_content_type",
+      w9FileSize: "w9_file_size",
+      w9UpdatedAt: "w9_updated_at",
+    });
+  });
 
+export function taxToJSON(tax: Tax): string {
+  return JSON.stringify(Tax$outboundSchema.parse(tax));
+}
 export function taxFromJSON(
   jsonString: string,
 ): SafeParseResult<Tax, SDKValidationError> {
@@ -161,7 +248,36 @@ export const Stats$inboundSchema: z.ZodType<Stats, z.ZodTypeDef, unknown> = z
       "facility_approved_count": "facilityApprovedCount",
     });
   });
+/** @internal */
+export type Stats$Outbound = {
+  vendor_inactive_count?: number | null | undefined;
+  vendor_active_count?: number | null | undefined;
+  facility_targeted_count?: number | null | undefined;
+  facility_approved_count?: number | null | undefined;
+};
 
+/** @internal */
+export const Stats$outboundSchema: z.ZodType<
+  Stats$Outbound,
+  z.ZodTypeDef,
+  Stats
+> = z.object({
+  vendorInactiveCount: z.nullable(z.number().int()).optional(),
+  vendorActiveCount: z.nullable(z.number().int()).optional(),
+  facilityTargetedCount: z.nullable(z.number().int()).optional(),
+  facilityApprovedCount: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    vendorInactiveCount: "vendor_inactive_count",
+    vendorActiveCount: "vendor_active_count",
+    facilityTargetedCount: "facility_targeted_count",
+    facilityApprovedCount: "facility_approved_count",
+  });
+});
+
+export function statsToJSON(stats: Stats): string {
+  return JSON.stringify(Stats$outboundSchema.parse(stats));
+}
 export function statsFromJSON(
   jsonString: string,
 ): SafeParseResult<Stats, SDKValidationError> {
@@ -196,7 +312,53 @@ export const Company$inboundSchema: z.ZodType<Company, z.ZodTypeDef, unknown> =
       "vendor_type_restrictions": "vendorTypeRestrictions",
     });
   });
+/** @internal */
+export type Company$Outbound = {
+  id: number;
+  name: string | null;
+  status?: string | null | undefined;
+  credit_balance?: string | null | undefined;
+  location?: CompanyLocation$Outbound | null | undefined;
+  contact?: CompanyContact$Outbound | undefined;
+  tax?: Tax$Outbound | undefined;
+  stats?: Stats$Outbound | undefined;
+  vendor_fields?: Array<CompanyVendorField$Outbound> | null | undefined;
+  vendor_type_restrictions?:
+    | Array<CompanyVendorTypeRestriction$Outbound | null>
+    | null
+    | undefined;
+};
 
+/** @internal */
+export const Company$outboundSchema: z.ZodType<
+  Company$Outbound,
+  z.ZodTypeDef,
+  Company
+> = z.object({
+  id: z.number().int(),
+  name: z.nullable(z.string()),
+  status: z.nullable(z.string()).optional(),
+  creditBalance: z.nullable(z.string()).optional(),
+  location: z.nullable(z.lazy(() => CompanyLocation$outboundSchema)).optional(),
+  contact: z.lazy(() => CompanyContact$outboundSchema).optional(),
+  tax: z.lazy(() => Tax$outboundSchema).optional(),
+  stats: z.lazy(() => Stats$outboundSchema).optional(),
+  vendorFields: z.nullable(z.array(CompanyVendorField$outboundSchema))
+    .optional(),
+  vendorTypeRestrictions: z.nullable(
+    z.array(z.nullable(CompanyVendorTypeRestriction$outboundSchema)),
+  ).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    creditBalance: "credit_balance",
+    vendorFields: "vendor_fields",
+    vendorTypeRestrictions: "vendor_type_restrictions",
+  });
+});
+
+export function companyToJSON(company: Company): string {
+  return JSON.stringify(Company$outboundSchema.parse(company));
+}
 export function companyFromJSON(
   jsonString: string,
 ): SafeParseResult<Company, SDKValidationError> {

package/src/models/components/companytargetfacility.ts

@@ -35,9 +35,9 @@ export type IndividualCounts = {
  */
 export type CompanyTargetFacility = {
   /**
-   * CompanyTargetFacility row ID.
+   * CompanyTargetFacility row ID. Null when returned via `include_potential_targets=true` for a facility not yet targeted by the company.
    */
-  id: number;
+  id: number | null;
   /**
    * The linked facility. Returns the facility ID by default; pass `company_target_facility.facility` to `expand` to receive the full facility object.
    */
@@ -97,7 +97,7 @@ export const CompanyTargetFacility$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: types.number(),
+  id: types.nullable(types.number()),
   facility: types.nullable(
     smartUnion([Facility$inboundSchema, types.number()]),
   ),

package/src/models/components/companyvendorfield.ts

@@ -35,7 +35,38 @@ export const CompanyVendorField$inboundSchema: z.ZodType<
     "field_type": "fieldType",
   });
 });
+/** @internal */
+export type CompanyVendorField$Outbound = {
+  id: number;
+  name: string;
+  show_to_vendor: boolean;
+  field_type: string;
+};
+
+/** @internal */
+export const CompanyVendorField$outboundSchema: z.ZodType<
+  CompanyVendorField$Outbound,
+  z.ZodTypeDef,
+  CompanyVendorField
+> = z.object({
+  id: z.number().int(),
+  name: z.string(),
+  showToVendor: z.boolean(),
+  fieldType: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    showToVendor: "show_to_vendor",
+    fieldType: "field_type",
+  });
+});
 
+export function companyVendorFieldToJSON(
+  companyVendorField: CompanyVendorField,
+): string {
+  return JSON.stringify(
+    CompanyVendorField$outboundSchema.parse(companyVendorField),
+  );
+}
 export function companyVendorFieldFromJSON(
   jsonString: string,
 ): SafeParseResult<CompanyVendorField, SDKValidationError> {