@gbg/go-core 0.0.1-alpha.24 → 0.0.1-alpha.26

package/src/funcs/tokens-generate.ts

@@ -22,7 +22,7 @@ import {
 import { ResponseValidationError } from "../models/errors/response-validation-error.js";
 import { SDKValidationError } from "../models/errors/sdk-validation-error.js";
 import * as operations from "../models/operations/index.js";
-import { PostAuthRealmsGoProtocolOpenidConnectTokenServerList } from "../models/operations/post-auth-realms-go-protocol-openid-connect-token.js";
+import { PostAsTokenOauth2ServerList } from "../models/operations/post-as-token-oauth2.js";
 import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 
@@ -30,17 +30,15 @@ import { Result } from "../types/fp.js";
  * Generate access token
  *
  * @remarks
- * Get an access token to authenticate API requests. If you're unfamiliar with the authentication process, check out the [authentication guide](/docs/developer-integration/execute-customer-journeys/authenticate) for more details.
+ * Get an access token to authenticate API requests. If you're unfamiliar with the authentication process, check out the [authentication guide](/docs/go-v2/developer-integration/execute-customer-journeys/authenticate) for more details.
  */
 export function tokensGenerate(
   client: GoCore,
-  request?:
-    | operations.PostAuthRealmsGoProtocolOpenidConnectTokenRequest
-    | undefined,
+  request?: operations.PostAsTokenOauth2Request | undefined,
   options?: RequestOptions,
 ): APIPromise<
   Result<
-    operations.PostAuthRealmsGoProtocolOpenidConnectTokenResponse,
+    operations.PostAsTokenOauth2Response,
     | GoError
     | ResponseValidationError
     | ConnectionError
@@ -60,14 +58,12 @@ export function tokensGenerate(
 
 async function $do(
   client: GoCore,
-  request?:
-    | operations.PostAuthRealmsGoProtocolOpenidConnectTokenRequest
-    | undefined,
+  request?: operations.PostAsTokenOauth2Request | undefined,
   options?: RequestOptions,
 ): Promise<
   [
     Result<
-      operations.PostAuthRealmsGoProtocolOpenidConnectTokenResponse,
+      operations.PostAsTokenOauth2Response,
       | GoError
       | ResponseValidationError
       | ConnectionError
@@ -84,10 +80,7 @@ async function $do(
     request,
     (value) =>
       z.parse(
-        z.optional(
-          operations
-            .PostAuthRealmsGoProtocolOpenidConnectTokenRequest$outboundSchema,
-        ),
+        z.optional(operations.PostAsTokenOauth2Request$outboundSchema),
         value,
       ),
     "Input validation failed",
@@ -102,11 +95,11 @@ async function $do(
   }).join("&");
 
   const baseURL = options?.serverURL
-    || pathToFunc(PostAuthRealmsGoProtocolOpenidConnectTokenServerList[0], {
+    || pathToFunc(PostAsTokenOauth2ServerList[0], {
       charEncoding: "percent",
     })();
 
-  const path = pathToFunc("/auth/realms/go/protocol/openid-connect/token")();
+  const path = pathToFunc("/as/token.oauth2")();
 
   const headers = new Headers(compactMap({
     "Content-Type": "application/x-www-form-urlencoded",
@@ -116,7 +109,7 @@ async function $do(
   const context = {
     options: client._options,
     baseURL: baseURL ?? "",
-    operationID: "post_/auth/realms/go/protocol/openid-connect/token",
+    operationID: "post_/as/token.oauth2",
     oAuth2Scopes: null,
 
     resolvedSecurity: null,
@@ -155,7 +148,7 @@ async function $do(
   const response = doResult.value;
 
   const [result] = await M.match<
-    operations.PostAuthRealmsGoProtocolOpenidConnectTokenResponse,
+    operations.PostAsTokenOauth2Response,
     | GoError
     | ResponseValidationError
     | ConnectionError
@@ -165,11 +158,7 @@ async function $do(
     | UnexpectedClientError
     | SDKValidationError
   >(
-    M.json(
-      200,
-      operations
-        .PostAuthRealmsGoProtocolOpenidConnectTokenResponse$inboundSchema,
-    ),
+    M.json(200, operations.PostAsTokenOauth2Response$inboundSchema),
     M.fail([400, 401, "4XX"]),
     M.fail("5XX"),
   )(response, req);

package/src/hooks/registration.ts

@@ -1,4 +1,5 @@
 import { Hooks } from "./types.js";
+import { GbgSourceHook } from "./x-gbg-source.js";
 
 /*
  * This file is only ever generated once on the first generation and then is free to be modified.
@@ -6,9 +7,8 @@ import { Hooks } from "./types.js";
  * in this file or in separate files in the hooks folder.
  */
 
-// @ts-expect-error remove this line when you add your first hook and hooks is used
 export function initHooks(hooks: Hooks) {
-  // Add hooks by calling hooks.register{ClientInit/BeforeCreateRequest/BeforeRequest/AfterSuccess/AfterError}Hook
-  // with an instance of a hook that implements that specific Hook interface
-  // Hooks are registered per SDK instance, and are valid for the lifetime of the SDK instance
+  // Stamp an X-GBG-Source usage-tracking header on every outgoing request.
+  // See ./x-gbg-source.ts (GGO-16030 / issue #34).
+  hooks.registerBeforeCreateRequestHook(new GbgSourceHook());
 }

package/src/hooks/types.ts

@@ -15,6 +15,7 @@ export type HookContext = {
   retryConfig: RetryConfig;
   resolvedSecurity: SecurityState | null;
   options: SDKOptions;
+  timeoutMs?: number;
 };
 
 export type Awaitable<T> = T | Promise<T>;

package/src/hooks/x-gbg-source.ts

@@ -0,0 +1,70 @@
+/*
+ * Custom hook: stamps an `X-GBG-Source` usage-tracking header on every
+ * outgoing request.
+ *
+ * This file is NOT managed by Speakeasy — it is not tracked in
+ * `.speakeasy/gen.lock`, and it is imported from `registration.ts` which
+ * Speakeasy generates only once. Both therefore survive the weekly forced SDK
+ * regeneration. Do not move this logic into generated files (`config.ts`,
+ * `sdks.ts`, `index.ts`, `package.json`): those are overwritten on regen.
+ *
+ * See GGO-16030 / GitHub issue #34.
+ */
+
+import { SDK_METADATA, SDKOptions } from "../lib/config.js";
+import { RequestInput } from "../lib/http.js";
+import {
+  BeforeCreateRequestContext,
+  BeforeCreateRequestHook,
+} from "./types.js";
+
+/** The usage-tracking header sent on every request. */
+export const X_GBG_SOURCE_HEADER = "X-GBG-Source";
+
+/**
+ * SDK options extended with the optional `source` override. Use this to get
+ * type-safety for the client-creation override without depending on the
+ * regenerated `SDKOptions` declaration:
+ *
+ * ```ts
+ * import { Go } from "@gbg/go-core";
+ * import type { GoOptions } from "@gbg/go-core/hooks/x-gbg-source";
+ *
+ * const sdk = new Go({ source: "acme-portal" } satisfies GoOptions);
+ * ```
+ */
+export type GoOptions = SDKOptions & {
+  /**
+   * Value sent in the `X-GBG-Source` header on every request, identifying the
+   * integration making the call. Defaults to the SDK's user-agent string. Can
+   * also be overridden per-request via `RequestOptions.headers`.
+   */
+  source?: string | undefined;
+};
+
+/**
+ * Sets the `X-GBG-Source` header on every request. Precedence, highest first:
+ *
+ *   1. a per-request header (set via `RequestOptions.headers`) — left untouched
+ *   2. the client-creation `source` option
+ *   3. the SDK user-agent string (auto-tracks the SDK version)
+ */
+export class GbgSourceHook implements BeforeCreateRequestHook {
+  beforeCreateRequest(
+    hookCtx: BeforeCreateRequestContext,
+    input: RequestInput,
+  ): RequestInput {
+    const options = input.options ?? {};
+    const headers = new Headers(options.headers);
+
+    // Respect a per-request override if one was already set on the request.
+    if (!headers.has(X_GBG_SOURCE_HEADER)) {
+      const source = (hookCtx.options as GoOptions).source;
+      headers.set(X_GBG_SOURCE_HEADER, source ?? SDK_METADATA.userAgent);
+    }
+
+    options.headers = headers;
+    input.options = options;
+    return input;
+  }
+}

package/src/lib/config.ts

@@ -60,8 +60,8 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "1.0.0",
-  sdkVersion: "0.0.1-alpha.24",
-  genVersion: "2.886.1",
+  sdkVersion: "0.0.1-alpha.26",
+  genVersion: "2.915.1",
   userAgent:
-    "speakeasy-sdk/typescript 0.0.1-alpha.24 2.886.1 1.0.0 @gbg/go-core",
+    "speakeasy-sdk/typescript 0.0.1-alpha.26 2.915.1 1.0.0 @gbg/go-core",
 } as const;

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/v4-mini";
-import { dlv } from "./dlv.js";
 
 export interface Env {
   GO_CUSTOMER_ACCESS?: string | undefined;
@@ -38,11 +37,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 { GoDefaultError } from "../models/errors/go-default-error.js";
 import { ResponseValidationError } from "../models/errors/response-validation-error.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

@@ -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";
 
@@ -131,27 +132,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);
@@ -197,9 +226,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) {
@@ -246,10 +274,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/client-credentials-grant-request.ts

@@ -0,0 +1,57 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../lib/primitives.js";
+
+export type ClientCredentialsGrantRequest = {
+  /**
+   * The client ID assigned to your organization.
+   */
+  clientId: string;
+  /**
+   * The client secret assigned to your organization.
+   */
+  clientSecret: string;
+  /**
+   * Must always be set to 'client_credentials'.
+   */
+  grantType: "client_credentials";
+};
+
+/** @internal */
+export type ClientCredentialsGrantRequest$Outbound = {
+  client_id: string;
+  client_secret: string;
+  grant_type: "client_credentials";
+};
+
+/** @internal */
+export const ClientCredentialsGrantRequest$outboundSchema: z.ZodMiniType<
+  ClientCredentialsGrantRequest$Outbound,
+  ClientCredentialsGrantRequest
+> = z.pipe(
+  z.object({
+    clientId: z.string(),
+    clientSecret: z.string(),
+    grantType: z.literal("client_credentials"),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      clientId: "client_id",
+      clientSecret: "client_secret",
+      grantType: "grant_type",
+    });
+  }),
+);
+
+export function clientCredentialsGrantRequestToJSON(
+  clientCredentialsGrantRequest: ClientCredentialsGrantRequest,
+): string {
+  return JSON.stringify(
+    ClientCredentialsGrantRequest$outboundSchema.parse(
+      clientCredentialsGrantRequest,
+    ),
+  );
+}

package/src/models/index.ts

@@ -2,4 +2,6 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
+export * from "./client-credentials-grant-request.js";
+export * from "./password-grant-request.js";
 export * from "./security.js";