@greensecurity/javascript-sdk 0.44.0-beta.2 → 0.44.0-beta.20

package/src/lib/encodings.ts

@@ -3,7 +3,7 @@
  */
 
 import { bytesToBase64 } from "./base64.js";
-import { isPlainObject } from "./is-plain-object.js";
+import { isPlainObject } from "./primitives.js";
 
 export class EncodingError extends Error {
   constructor(message: string) {

package/src/lib/env.ts

@@ -3,7 +3,6 @@
  */
 
 import * as z from "zod/v3";
-import { dlv } from "./dlv.js";
 
 export interface Env {
   GREEN_SECURITY_TOKEN?: string | undefined;
@@ -40,11 +39,16 @@ export function env(): Env {
     return envMemo;
   }
 
+  const globals = globalThis as {
+    Deno?: { env?: { toObject?: () => Record<string, string | undefined> } };
+    process?: { env?: Record<string, string | undefined> };
+  };
+
   let envObject: Record<string, unknown> = {};
   if (isDeno()) {
-    envObject = (globalThis as any).Deno?.env?.toObject?.() ?? {};
+    envObject = globals.Deno?.env?.toObject?.() ?? {};
   } else {
-    envObject = dlv(globalThis, "process.env") ?? {};
+    envObject = globals.process?.env ?? {};
   }
 
   envMemo = envSchema.parse(envObject);

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/sdks.ts

@@ -24,6 +24,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 +133,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 +227,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 +275,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)
         );

package/src/models/components/appointmentsummary.ts

@@ -0,0 +1,59 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * A reduced Event object returned when the `vendor_scan.appointment` expand scope is requested.
+ */
+export type AppointmentSummary = {
+  id: number;
+  title?: string | null | undefined;
+  /**
+   * Event start datetime (ISO 8601).
+   */
+  start?: string | null | undefined;
+  /**
+   * Event end datetime (ISO 8601).
+   */
+  end?: string | null | undefined;
+  allDay?: boolean | null | undefined;
+  standingAppt?: boolean | null | undefined;
+  status?: string | null | undefined;
+};
+
+/** @internal */
+export const AppointmentSummary$inboundSchema: z.ZodType<
+  AppointmentSummary,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: types.number(),
+  title: z.nullable(types.string()).optional(),
+  start: z.nullable(types.string()).optional(),
+  end: z.nullable(types.string()).optional(),
+  all_day: z.nullable(types.boolean()).optional(),
+  standing_appt: z.nullable(types.boolean()).optional(),
+  status: z.nullable(types.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "all_day": "allDay",
+    "standing_appt": "standingAppt",
+  });
+});
+
+export function appointmentSummaryFromJSON(
+  jsonString: string,
+): SafeParseResult<AppointmentSummary, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AppointmentSummary$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AppointmentSummary' from JSON`,
+  );
+}

package/src/models/components/companycredentiallistitem.ts

@@ -0,0 +1,110 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  VendorCredentialSummary,
+  VendorCredentialSummary$inboundSchema,
+} from "./vendorcredentialsummary.js";
+
+export type CompanyCredentialListItemCredential = {
+  id: number;
+  name: string;
+};
+
+export type VendorCredentialLast = {
+  id: number;
+  status: string;
+  version: number;
+  dateExpires?: string | null | undefined;
+};
+
+export type CompanyCredentialListItem = {
+  credential: CompanyCredentialListItemCredential;
+  /**
+   * Reduced list of attributes of Vendor Credential record
+   */
+  vendorCredential: VendorCredentialSummary | null;
+  vendorCredentialLast?: VendorCredentialLast | null | undefined;
+};
+
+/** @internal */
+export const CompanyCredentialListItemCredential$inboundSchema: z.ZodType<
+  CompanyCredentialListItemCredential,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: types.number(),
+  name: types.string(),
+});
+
+export function companyCredentialListItemCredentialFromJSON(
+  jsonString: string,
+): SafeParseResult<CompanyCredentialListItemCredential, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CompanyCredentialListItemCredential$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CompanyCredentialListItemCredential' from JSON`,
+  );
+}
+
+/** @internal */
+export const VendorCredentialLast$inboundSchema: z.ZodType<
+  VendorCredentialLast,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: types.number(),
+  status: types.string(),
+  version: types.number(),
+  date_expires: z.nullable(types.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "date_expires": "dateExpires",
+  });
+});
+
+export function vendorCredentialLastFromJSON(
+  jsonString: string,
+): SafeParseResult<VendorCredentialLast, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VendorCredentialLast$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VendorCredentialLast' from JSON`,
+  );
+}
+
+/** @internal */
+export const CompanyCredentialListItem$inboundSchema: z.ZodType<
+  CompanyCredentialListItem,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  credential: z.lazy(() => CompanyCredentialListItemCredential$inboundSchema),
+  vendor_credential: types.nullable(VendorCredentialSummary$inboundSchema),
+  vendor_credential_last: z.nullable(
+    z.lazy(() => VendorCredentialLast$inboundSchema),
+  ).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "vendor_credential": "vendorCredential",
+    "vendor_credential_last": "vendorCredentialLast",
+  });
+});
+
+export function companyCredentialListItemFromJSON(
+  jsonString: string,
+): SafeParseResult<CompanyCredentialListItem, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CompanyCredentialListItem$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CompanyCredentialListItem' from JSON`,
+  );
+}

package/src/models/components/companytargetfacility.ts

@@ -0,0 +1,124 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { smartUnion } from "../../types/smartUnion.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import { Facility, Facility$inboundSchema } from "./facility.js";
+
+/**
+ * The linked facility. Returns the facility ID by default; pass `company_target_facility.facility` to `expand` to receive the full facility object.
+ */
+export type CompanyTargetFacilityFacility = Facility | number;
+
+/**
+ * Per-facility counts of the company's individuals (vendors) currently targeting this facility.
+ */
+export type IndividualCounts = {
+  /**
+   * Total individuals from the company targeting this facility.
+   */
+  total?: number | undefined;
+  /**
+   * Individuals targeting this facility whose credentialing subscription is active.
+   */
+  active?: number | undefined;
+};
+
+/**
+ * Describes the facilities that a company would like to do business with. These are called "target facilities" for the company. A company may target/untarget any number of facilities which will kick off the process of becoming compliant with that facility's vendor policies.
+ */
+export type CompanyTargetFacility = {
+  /**
+   * CompanyTargetFacility row ID. Null when returned via `include_potential_targets=true` for a facility not yet targeted by the company.
+   */
+  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.
+   */
+  facility: Facility | number | null;
+  /**
+   * Link status (Approved, Pending, or Denied). This value is computed by the daily background job from the company's credential state — it is not directly settable through the API.
+   */
+  status: string | null;
+  contracted?: boolean | undefined;
+  dateCreated?: Date | null | undefined;
+  /**
+   * Per-facility counts of the company's individuals (vendors) currently targeting this facility.
+   */
+  individualCounts?: IndividualCounts | null | undefined;
+};
+
+/** @internal */
+export const CompanyTargetFacilityFacility$inboundSchema: z.ZodType<
+  CompanyTargetFacilityFacility,
+  z.ZodTypeDef,
+  unknown
+> = smartUnion([Facility$inboundSchema, types.number()]);
+
+export function companyTargetFacilityFacilityFromJSON(
+  jsonString: string,
+): SafeParseResult<CompanyTargetFacilityFacility, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CompanyTargetFacilityFacility$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CompanyTargetFacilityFacility' from JSON`,
+  );
+}
+
+/** @internal */
+export const IndividualCounts$inboundSchema: z.ZodType<
+  IndividualCounts,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  total: types.optional(types.number()),
+  active: types.optional(types.number()),
+});
+
+export function individualCountsFromJSON(
+  jsonString: string,
+): SafeParseResult<IndividualCounts, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => IndividualCounts$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'IndividualCounts' from JSON`,
+  );
+}
+
+/** @internal */
+export const CompanyTargetFacility$inboundSchema: z.ZodType<
+  CompanyTargetFacility,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: types.nullable(types.number()),
+  facility: types.nullable(
+    smartUnion([Facility$inboundSchema, types.number()]),
+  ),
+  status: types.nullable(types.string()),
+  contracted: types.optional(types.boolean()),
+  date_created: z.nullable(types.date()).optional(),
+  individual_counts: z.nullable(z.lazy(() => IndividualCounts$inboundSchema))
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "date_created": "dateCreated",
+    "individual_counts": "individualCounts",
+  });
+});
+
+export function companyTargetFacilityFromJSON(
+  jsonString: string,
+): SafeParseResult<CompanyTargetFacility, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CompanyTargetFacility$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CompanyTargetFacility' from JSON`,
+  );
+}

package/src/models/components/csvexportenqueuedresponse.ts

@@ -0,0 +1,58 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * Returned when an asynchronous CSV export job is enqueued. Poll `status_url` until the export is ready,
+ *
+ * @remarks
+ * then retrieve the file from `download_url`.
+ */
+export type CsvExportEnqueuedResponse = {
+  /**
+   * URL to poll for the status of the export job.
+   */
+  statusUrl: string;
+  /**
+   * URL to download the exported CSV file once the job is ready.
+   */
+  downloadUrl: string;
+  /**
+   * Token identifying the export job, used to check its status.
+   */
+  statusId: string;
+};
+
+/** @internal */
+export const CsvExportEnqueuedResponse$inboundSchema: z.ZodType<
+  CsvExportEnqueuedResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  status_url: types.string(),
+  download_url: types.string(),
+  status_id: types.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "status_url": "statusUrl",
+    "download_url": "downloadUrl",
+    "status_id": "statusId",
+  });
+});
+
+export function csvExportEnqueuedResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CsvExportEnqueuedResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CsvExportEnqueuedResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CsvExportEnqueuedResponse' from JSON`,
+  );
+}

package/src/models/components/csvexportstatusresponse.ts

@@ -0,0 +1,79 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * Returned when polling the status of an asynchronous CSV export job. When `ready` is true,
+ *
+ * @remarks
+ * the export is complete and can be downloaded via the URL in `download_url`.
+ */
+export type CsvExportStatusResponse = {
+  /**
+   * When true, the export is ready for download.
+   */
+  ready: boolean;
+  /**
+   * The export job identifier.
+   */
+  statusId: string;
+  /**
+   * URL to download the CSV (present only when `ready` is true).
+   */
+  downloadUrl?: string | undefined;
+  /**
+   * When the export job completed.
+   */
+  finishedAt?: string | undefined;
+  /**
+   * When the export job started.
+   */
+  startedAt?: string | undefined;
+  /**
+   * Timestamp of the last progress heartbeat from the background job. Updated on each pagination loop while the job is running; on completion or failure it equals `finished_at`.
+   */
+  heartbeat?: string | undefined;
+  /**
+   * Error message if the export failed.
+   */
+  error?: string | undefined;
+};
+
+/** @internal */
+export const CsvExportStatusResponse$inboundSchema: z.ZodType<
+  CsvExportStatusResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  ready: types.boolean(),
+  status_id: types.string(),
+  download_url: types.optional(types.string()),
+  finished_at: types.optional(types.string()),
+  started_at: types.optional(types.string()),
+  heartbeat: types.optional(types.string()),
+  error: types.optional(types.string()),
+}).transform((v) => {
+  return remap$(v, {
+    "status_id": "statusId",
+    "download_url": "downloadUrl",
+    "finished_at": "finishedAt",
+    "started_at": "startedAt",
+  });
+});
+
+export function csvExportStatusResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CsvExportStatusResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CsvExportStatusResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CsvExportStatusResponse' from JSON`,
+  );
+}

package/src/models/components/emailpreferences.ts

@@ -11,30 +11,12 @@ import { Result as SafeParseResult } from "../../types/fp.js";
 import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
-/**
- * Who receives vendor-related notification emails:
- *
- * @remarks
- * - `none` — no recipients
- * - `self` — the user (vendor) themselves
- * - `company_manager` — the vendor's company manager only
- * - `self_and_company_manager` — both
- */
 export const NotificationRecipients = {
   None: "none",
   Self: "self",
   CompanyManager: "company_manager",
   SelfAndCompanyManager: "self_and_company_manager",
 } as const;
-/**
- * Who receives vendor-related notification emails:
- *
- * @remarks
- * - `none` — no recipients
- * - `self` — the user (vendor) themselves
- * - `company_manager` — the vendor's company manager only
- * - `self_and_company_manager` — both
- */
 export type NotificationRecipients = OpenEnum<typeof NotificationRecipients>;
 
 /**

package/src/models/components/expand.ts

@@ -15,6 +15,7 @@ export const Expand = {
   CompanyLocation: "company.location",
   CompanyVendorFields: "company.vendor_fields",
   CompanyVendorTypeRestrictions: "company.vendor_type_restrictions",
+  CompanyTargetFacilityFacility: "company_target_facility.facility",
   ContactFacility: "contact.facility",
   ContactSystem: "contact.system",
   ContactDepartment: "contact.department",
@@ -105,6 +106,10 @@ export const Expand = {
   VendorScanBadgeData: "vendor_scan.badge_data",
   VendorScanVendor: "vendor_scan.vendor",
   VendorScanZone: "vendor_scan.zone",
+  VendorScanDepartment: "vendor_scan.department",
+  VendorScanCompany: "vendor_scan.company",
+  VendorScanAppointment: "vendor_scan.appointment",
+  VendorScanScreeningResponses: "vendor_scan.screening_responses",
   ZoneFacility: "zone.facility",
   ZoneDepartment: "zone.department",
   ZoneRules: "zone.rules",