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

package/jsr.json

@@ -2,7 +2,7 @@
 
 {
   "name": "@gbg/go-core",
-  "version": "0.0.1-alpha.25",
+  "version": "0.0.1-alpha.26",
   "exports": {
     ".": "./src/index.ts",    
     "./models/errors": "./src/models/errors/index.ts",    

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gbg/go-core",
-  "version": "0.0.1-alpha.25",
+  "version": "0.0.1-alpha.26",
   "author": "Speakeasy",
   "type": "module",
   "tshy": {

package/src/__tests__/x-gbg-source.test.mjs

@@ -0,0 +1,59 @@
+/*
+ * Tests for GbgSourceHook (GGO-16030 / issue #34). Not managed by Speakeasy.
+ *
+ * The SDK source uses `.js` import specifiers for `.ts` files, so tests run
+ * against the built output rather than source. This lives in `src/__tests__`,
+ * which tsconfig excludes from the build/publish.
+ *
+ *   npm run build
+ *   node --test src/__tests__/x-gbg-source.test.mjs
+ */
+
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { SDK_METADATA } from "../../dist/esm/lib/config.js";
+import {
+  GbgSourceHook,
+  X_GBG_SOURCE_HEADER,
+} from "../../dist/esm/hooks/x-gbg-source.js";
+
+const hook = new GbgSourceHook();
+
+const ctx = (options = {}) => ({ options });
+const input = (headers) => ({
+  url: new URL("https://example.com/journey/start"),
+  options: { headers },
+});
+const headerOf = (result) =>
+  new Headers(result.options?.headers).get(X_GBG_SOURCE_HEADER);
+
+test("defaults to the SDK user-agent when no source is configured", () => {
+  assert.equal(headerOf(hook.beforeCreateRequest(ctx(), input())),
+    SDK_METADATA.userAgent);
+});
+
+test("uses the client-creation `source` option when provided", () => {
+  assert.equal(
+    headerOf(hook.beforeCreateRequest(ctx({ source: "acme-portal" }), input())),
+    "acme-portal",
+  );
+});
+
+test("a per-request X-GBG-Source header wins over the client option", () => {
+  const result = hook.beforeCreateRequest(
+    ctx({ source: "acme-portal" }),
+    input({ [X_GBG_SOURCE_HEADER]: "checkout-v3" }),
+  );
+  assert.equal(headerOf(result), "checkout-v3");
+});
+
+test("preserves other headers already on the request", () => {
+  const result = hook.beforeCreateRequest(
+    ctx(),
+    input({ "Content-Type": "application/json" }),
+  );
+  const headers = new Headers(result.options?.headers);
+  assert.equal(headers.get("Content-Type"), "application/json");
+  assert.equal(headers.get(X_GBG_SOURCE_HEADER), SDK_METADATA.userAgent);
+});

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/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.25",
-  genVersion: "2.907.0",
+  sdkVersion: "0.0.1-alpha.26",
+  genVersion: "2.915.1",
   userAgent:
-    "speakeasy-sdk/typescript 0.0.1-alpha.25 2.907.0 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/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";

package/src/models/operations/fetch-interaction.ts

@@ -23,6 +23,30 @@ export type FetchInteractionRequest = {
   instanceId: string;
 };
 
+export const JourneyStatus2 = {
+  Completed: "Completed",
+  InProgress: "InProgress",
+  Failed: "Failed",
+  Paused: "Paused",
+} as const;
+export type JourneyStatus2 = OpenEnum<typeof JourneyStatus2>;
+
+export type Journey2 = {
+  status: JourneyStatus2;
+};
+
+export type ResponseBody2 = {
+  /**
+   * Journey instance identifier
+   */
+  instanceId: string;
+  journey: Journey2;
+  /**
+   * True when the journey is still working and no interaction is available yet. Clients should poll /journey/interaction/fetch until this is absent/false and an `interaction` is returned.
+   */
+  processing: boolean;
+};
+
 export const FetchInteractionStatusError = {
   Error: "error",
 } as const;
@@ -42,16 +66,16 @@ export type FetchInteractionError = {
   message: string;
 };
 
-export const JourneyStatus = {
+export const JourneyStatus1 = {
   Completed: "Completed",
   InProgress: "InProgress",
   Failed: "Failed",
   Paused: "Paused",
 } as const;
-export type JourneyStatus = OpenEnum<typeof JourneyStatus>;
+export type JourneyStatus1 = OpenEnum<typeof JourneyStatus1>;
 
-export type Journey = {
-  status: JourneyStatus;
+export type Journey1 = {
+  status: JourneyStatus1;
 };
 
 export const ResourceType = {
@@ -1444,7 +1468,7 @@ export type FetchInteractionContext = {
   subject?: FetchInteractionSubject | undefined;
 };
 
-export type ResponseBody = {
+export type ResponseBody1 = {
   /**
    * Journey instance identifier
    */
@@ -1453,7 +1477,7 @@ export type ResponseBody = {
    * Interaction identifier
    */
   interactionId: string;
-  journey: Journey;
+  journey: Journey1;
   interaction: Interaction;
   context?: FetchInteractionContext | undefined;
   instructions?: Array<string> | undefined;
@@ -1463,7 +1487,10 @@ export type ResponseBody = {
 /**
  * Success
  */
-export type FetchInteractionResponse = ResponseBody | FetchInteractionError;
+export type FetchInteractionResponse =
+  | ResponseBody1
+  | FetchInteractionError
+  | ResponseBody2;
 
 /** @internal */
 export type FetchInteractionSecurity$Outbound = {
@@ -1514,6 +1541,48 @@ export function fetchInteractionRequestToJSON(
   );
 }
 
+/** @internal */
+export const JourneyStatus2$inboundSchema: z.ZodMiniType<
+  JourneyStatus2,
+  unknown
+> = openEnums.inboundSchema(JourneyStatus2);
+
+/** @internal */
+export const Journey2$inboundSchema: z.ZodMiniType<Journey2, unknown> = z
+  .object({
+    status: JourneyStatus2$inboundSchema,
+  });
+
+export function journey2FromJSON(
+  jsonString: string,
+): SafeParseResult<Journey2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Journey2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Journey2' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResponseBody2$inboundSchema: z.ZodMiniType<
+  ResponseBody2,
+  unknown
+> = z.object({
+  instanceId: types.string(),
+  journey: z.lazy(() => Journey2$inboundSchema),
+  processing: types.boolean(),
+});
+
+export function responseBody2FromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseBody2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseBody2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseBody2' from JSON`,
+  );
+}
+
 /** @internal */
 export const FetchInteractionStatusError$inboundSchema: z.ZodMiniEnum<
   typeof FetchInteractionStatusError
@@ -1540,23 +1609,24 @@ export function fetchInteractionErrorFromJSON(
 }
 
 /** @internal */
-export const JourneyStatus$inboundSchema: z.ZodMiniType<
-  JourneyStatus,
+export const JourneyStatus1$inboundSchema: z.ZodMiniType<
+  JourneyStatus1,
   unknown
-> = openEnums.inboundSchema(JourneyStatus);
+> = openEnums.inboundSchema(JourneyStatus1);
 
 /** @internal */
-export const Journey$inboundSchema: z.ZodMiniType<Journey, unknown> = z.object({
-  status: JourneyStatus$inboundSchema,
-});
+export const Journey1$inboundSchema: z.ZodMiniType<Journey1, unknown> = z
+  .object({
+    status: JourneyStatus1$inboundSchema,
+  });
 
-export function journeyFromJSON(
+export function journey1FromJSON(
   jsonString: string,
-): SafeParseResult<Journey, SDKValidationError> {
+): SafeParseResult<Journey1, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => Journey$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Journey' from JSON`,
+    (x) => Journey1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Journey1' from JSON`,
   );
 }
 
@@ -3740,26 +3810,26 @@ export function fetchInteractionContextFromJSON(
 }
 
 /** @internal */
-export const ResponseBody$inboundSchema: z.ZodMiniType<ResponseBody, unknown> =
-  z.object({
-    instanceId: types.string(),
-    interactionId: types.string(),
-    journey: z.lazy(() => Journey$inboundSchema),
-    interaction: z.lazy(() => Interaction$inboundSchema),
-    context: types.optional(
-      z.lazy(() => FetchInteractionContext$inboundSchema),
-    ),
-    instructions: types.optional(z.array(types.string())),
-    outstanding: types.optional(z.array(types.string())),
-  });
+export const ResponseBody1$inboundSchema: z.ZodMiniType<
+  ResponseBody1,
+  unknown
+> = z.object({
+  instanceId: types.string(),
+  interactionId: types.string(),
+  journey: z.lazy(() => Journey1$inboundSchema),
+  interaction: z.lazy(() => Interaction$inboundSchema),
+  context: types.optional(z.lazy(() => FetchInteractionContext$inboundSchema)),
+  instructions: types.optional(z.array(types.string())),
+  outstanding: types.optional(z.array(types.string())),
+});
 
-export function responseBodyFromJSON(
+export function responseBody1FromJSON(
   jsonString: string,
-): SafeParseResult<ResponseBody, SDKValidationError> {
+): SafeParseResult<ResponseBody1, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ResponseBody$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ResponseBody' from JSON`,
+    (x) => ResponseBody1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseBody1' from JSON`,
   );
 }
 
@@ -3768,8 +3838,9 @@ export const FetchInteractionResponse$inboundSchema: z.ZodMiniType<
   FetchInteractionResponse,
   unknown
 > = smartUnion([
-  z.lazy(() => ResponseBody$inboundSchema),
+  z.lazy(() => ResponseBody1$inboundSchema),
   z.lazy(() => FetchInteractionError$inboundSchema),
+  z.lazy(() => ResponseBody2$inboundSchema),
 ]);
 
 export function fetchInteractionResponseFromJSON(

package/src/models/operations/index.ts

@@ -11,7 +11,7 @@ export * from "./get-task-schema.js";
 export * from "./get-tasks-schema.js";
 export * from "./get-tasks.js";
 export * from "./health.js";
-export * from "./post-auth-realms-go-protocol-openid-connect-token.js";
+export * from "./post-as-token-oauth2.js";
 export * from "./start-journey.js";
 export * from "./submit-interaction.js";
 export * from "./update-task.js";

package/src/models/operations/post-as-token-oauth2.ts

@@ -0,0 +1,88 @@
+/*
+ * 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";
+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/sdk-validation-error.js";
+import * as models from "../index.js";
+
+export const PostAsTokenOauth2ServerList = [
+  "https://api.auth.gbgplc.com",
+] as const;
+
+export type PostAsTokenOauth2Request =
+  | models.PasswordGrantRequest
+  | models.ClientCredentialsGrantRequest;
+
+/**
+ * Successfully retrieved access token.
+ */
+export type PostAsTokenOauth2Response = {
+  /**
+   * The access token used for authentication.
+   */
+  accessToken?: string | undefined;
+  /**
+   * Token expiration time in seconds.
+   */
+  expiresIn?: number | undefined;
+  /**
+   * The type of token, usually 'Bearer'.
+   */
+  tokenType?: string | undefined;
+};
+
+/** @internal */
+export type PostAsTokenOauth2Request$Outbound =
+  | models.PasswordGrantRequest$Outbound
+  | models.ClientCredentialsGrantRequest$Outbound;
+
+/** @internal */
+export const PostAsTokenOauth2Request$outboundSchema: z.ZodMiniType<
+  PostAsTokenOauth2Request$Outbound,
+  PostAsTokenOauth2Request
+> = z.union([
+  models.PasswordGrantRequest$outboundSchema,
+  models.ClientCredentialsGrantRequest$outboundSchema,
+]);
+
+export function postAsTokenOauth2RequestToJSON(
+  postAsTokenOauth2Request: PostAsTokenOauth2Request,
+): string {
+  return JSON.stringify(
+    PostAsTokenOauth2Request$outboundSchema.parse(postAsTokenOauth2Request),
+  );
+}
+
+/** @internal */
+export const PostAsTokenOauth2Response$inboundSchema: z.ZodMiniType<
+  PostAsTokenOauth2Response,
+  unknown
+> = z.pipe(
+  z.object({
+    access_token: types.optional(types.string()),
+    expires_in: types.optional(types.number()),
+    token_type: types.optional(types.string()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "access_token": "accessToken",
+      "expires_in": "expiresIn",
+      "token_type": "tokenType",
+    });
+  }),
+);
+
+export function postAsTokenOauth2ResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<PostAsTokenOauth2Response, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PostAsTokenOauth2Response$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PostAsTokenOauth2Response' from JSON`,
+  );
+}