@greensecurity/javascript-sdk 0.43.1-beta.92 → 0.43.1-beta.94

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@greensecurity/javascript-sdk",
-  "version": "0.43.1-beta.92",
+  "version": "0.43.1-beta.94",
   "author": "Green Security LLC",
   "type": "module",
   "tshy": {

package/src/__tests__/users.test.ts

@@ -71,3 +71,23 @@ test("Users Get Linked Users", async () => {
     ],
   });
 });
+
+test("Users Switch Account", async () => {
+  const testHttpClient = createTestHTTPClient("switchAccount");
+
+  const greenSecurity = new GreenSecurity({
+    serverURL: process.env["TEST_SERVER_URL"] ?? "https://localhost:3000/api",
+    httpClient: testHttpClient,
+    security: {
+      token: process.env["GREEN_SECURITY_TOKEN"] ?? "value",
+    },
+  });
+
+  const result = await greenSecurity.users.switchAccount({
+    targetUserId: 999867,
+  });
+  expect(result).toBeDefined();
+  expect(result).toEqual({
+    userToken: {},
+  });
+});

package/src/__tests__/webhooks.test.ts

@@ -20,7 +20,7 @@ test("Webhooks List All Webhook Endpoints", async () => {
   const testWebhookListForVendorUserResult = await greenSecurity.webhooks
     .listAllWebhookEndpoints({
       itemsPerPage: 25,
-      desc: 0,
+      desc: true,
       sort: "",
     });
   expect(testWebhookListForVendorUserResult).toBeDefined();

package/src/funcs/usersSwitchAccount.ts

@@ -0,0 +1,168 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { GreenSecurityCore } from "../core.js";
+import { encodeJSON } from "../lib/encodings.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import { GreenSecurityError } from "../models/errors/greensecurityerror.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../models/errors/httpclienterrors.js";
+import * as errors from "../models/errors/index.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as operations from "../models/operations/index.js";
+import { APICall, APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+
+/**
+ * Switch to linked account
+ *
+ * @remarks
+ * If a user has two different types of accounts (i.e. Company Manager and Vendor) this endpoint allows the integration to swap the token from the existing user to the linked account user. For API integrations, the `source_user_id` field is required and must be the ID of the user whose session will be switched into the target user's token.
+ */
+export function usersSwitchAccount(
+  client: GreenSecurityCore,
+  request: operations.SwitchAccountRequestBody,
+  options?: RequestOptions,
+): APIPromise<
+  Result<
+    operations.SwitchAccountResponseBody,
+    | errors.ApiErrorResponse
+    | GreenSecurityError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >
+> {
+  return new APIPromise($do(
+    client,
+    request,
+    options,
+  ));
+}
+
+async function $do(
+  client: GreenSecurityCore,
+  request: operations.SwitchAccountRequestBody,
+  options?: RequestOptions,
+): Promise<
+  [
+    Result<
+      operations.SwitchAccountResponseBody,
+      | errors.ApiErrorResponse
+      | GreenSecurityError
+      | ResponseValidationError
+      | ConnectionError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | InvalidRequestError
+      | UnexpectedClientError
+      | SDKValidationError
+    >,
+    APICall,
+  ]
+> {
+  const parsed = safeParse(
+    request,
+    (value) => operations.SwitchAccountRequestBody$outboundSchema.parse(value),
+    "Input validation failed",
+  );
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload, { explode: true });
+
+  const path = pathToFunc("/users/switch-account")();
+
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+  }));
+
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "switchAccount",
+    oAuth2Scopes: null,
+
+    resolvedSecurity: requestSecurity,
+
+    securitySource: client._options.security,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+  };
+
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path: path,
+    headers: headers,
+    body: body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["400", "401", "403", "404", "422", "4XX", "500", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req },
+  };
+
+  const [result] = await M.match<
+    operations.SwitchAccountResponseBody,
+    | errors.ApiErrorResponse
+    | GreenSecurityError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >(
+    M.json(200, operations.SwitchAccountResponseBody$inboundSchema),
+    M.jsonErr([400, 401, 403, 404, 422], errors.ApiErrorResponse$inboundSchema),
+    M.fail("4XX"),
+    M.fail([500, "5XX"]),
+  )(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+
+  return [result, { status: "complete", request: req, response }];
+}

package/src/lib/config.ts

@@ -80,8 +80,8 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "0.0.11",
-  sdkVersion: "0.43.1-beta.90",
+  sdkVersion: "0.43.1-beta.92",
   genVersion: "2.794.1",
   userAgent:
-    "speakeasy-sdk/typescript 0.43.1-beta.90 2.794.1 0.0.11 @greensecurity/javascript-sdk",
+    "speakeasy-sdk/typescript 0.43.1-beta.92 2.794.1 0.0.11 @greensecurity/javascript-sdk",
 } as const;

package/src/models/operations/index.ts

@@ -86,6 +86,7 @@ export * from "./securityzonecheckin.js";
 export * from "./senddownloadcode.js";
 export * from "./submitscreeningresponse.js";
 export * from "./submitvendorcredential.js";
+export * from "./switchaccount.js";
 export * from "./updatedatarequest.js";
 export * from "./updateevent.js";
 export * from "./updatefhirconfigbyid.js";

package/src/models/operations/switchaccount.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 { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type SwitchAccountRequestBody = {
+  /**
+   * ID of the linked user to switch to
+   */
+  targetUserId: number;
+  /**
+   * Required for API integrations. The ID of the user whose session will be switched. The API user must have an app activation for this user.
+   *
+   * @remarks
+   */
+  sourceUserId?: number | undefined;
+};
+
+export const TokenType = {
+  Permanent: "permanent",
+} as const;
+export type TokenType = ClosedEnum<typeof TokenType>;
+
+export type UserToken = {
+  token?: string | undefined;
+  tokenType?: TokenType | undefined;
+};
+
+/**
+ * Successfully switched. Use the returned token with GET /users/:id to fetch full user data.
+ */
+export type SwitchAccountResponseBody = {
+  userToken: UserToken;
+  userId?: number | undefined;
+};
+
+/** @internal */
+export type SwitchAccountRequestBody$Outbound = {
+  target_user_id: number;
+  source_user_id?: number | undefined;
+};
+
+/** @internal */
+export const SwitchAccountRequestBody$outboundSchema: z.ZodType<
+  SwitchAccountRequestBody$Outbound,
+  z.ZodTypeDef,
+  SwitchAccountRequestBody
+> = z.object({
+  targetUserId: z.number().int(),
+  sourceUserId: z.number().int().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    targetUserId: "target_user_id",
+    sourceUserId: "source_user_id",
+  });
+});
+
+export function switchAccountRequestBodyToJSON(
+  switchAccountRequestBody: SwitchAccountRequestBody,
+): string {
+  return JSON.stringify(
+    SwitchAccountRequestBody$outboundSchema.parse(switchAccountRequestBody),
+  );
+}
+
+/** @internal */
+export const TokenType$inboundSchema: z.ZodNativeEnum<typeof TokenType> = z
+  .nativeEnum(TokenType);
+
+/** @internal */
+export const UserToken$inboundSchema: z.ZodType<
+  UserToken,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  token: types.optional(types.string()),
+  token_type: types.optional(TokenType$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "token_type": "tokenType",
+  });
+});
+
+export function userTokenFromJSON(
+  jsonString: string,
+): SafeParseResult<UserToken, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UserToken$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UserToken' from JSON`,
+  );
+}
+
+/** @internal */
+export const SwitchAccountResponseBody$inboundSchema: z.ZodType<
+  SwitchAccountResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  user_token: z.lazy(() => UserToken$inboundSchema),
+  user_id: types.optional(types.number()),
+}).transform((v) => {
+  return remap$(v, {
+    "user_token": "userToken",
+    "user_id": "userId",
+  });
+});
+
+export function switchAccountResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<SwitchAccountResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SwitchAccountResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SwitchAccountResponseBody' from JSON`,
+  );
+}

package/src/react-query/index.ts

@@ -50,6 +50,7 @@ export * from "./usersPassword.js";
 export * from "./usersPasswordResetRequest.js";
 export * from "./usersPostAuthenticate.js";
 export * from "./usersRotateApiKey.js";
+export * from "./usersSwitchAccount.js";
 export * from "./vendorsAcceptVendorCredential.js";
 export * from "./vendorsAddVendorCredentialFile.js";
 export * from "./vendorsAddVendorManagedByCompany.js";

package/src/react-query/usersSwitchAccount.ts

@@ -0,0 +1,89 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import {
+  MutationKey,
+  useMutation,
+  UseMutationResult,
+} from "@tanstack/react-query";
+import { GreenSecurityCore } from "../core.js";
+import { usersSwitchAccount } from "../funcs/usersSwitchAccount.js";
+import { combineSignals } from "../lib/primitives.js";
+import { RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+import { useGreenSecurityContext } from "./_context.js";
+import { MutationHookOptions } from "./_types.js";
+
+export type UsersSwitchAccountMutationVariables = {
+  request: operations.SwitchAccountRequestBody;
+  options?: RequestOptions;
+};
+
+export type UsersSwitchAccountMutationData =
+  operations.SwitchAccountResponseBody;
+
+/**
+ * Switch to linked account
+ *
+ * @remarks
+ * If a user has two different types of accounts (i.e. Company Manager and Vendor) this endpoint allows the integration to swap the token from the existing user to the linked account user. For API integrations, the `source_user_id` field is required and must be the ID of the user whose session will be switched into the target user's token.
+ */
+export function useUsersSwitchAccountMutation(
+  options?: MutationHookOptions<
+    UsersSwitchAccountMutationData,
+    Error,
+    UsersSwitchAccountMutationVariables
+  >,
+): UseMutationResult<
+  UsersSwitchAccountMutationData,
+  Error,
+  UsersSwitchAccountMutationVariables
+> {
+  const client = useGreenSecurityContext();
+  return useMutation({
+    ...buildUsersSwitchAccountMutation(client, options),
+    ...options,
+  });
+}
+
+export function mutationKeyUsersSwitchAccount(): MutationKey {
+  return ["@greensecurity/javascript-sdk", "users", "switchAccount"];
+}
+
+export function buildUsersSwitchAccountMutation(
+  client$: GreenSecurityCore,
+  hookOptions?: RequestOptions,
+): {
+  mutationKey: MutationKey;
+  mutationFn: (
+    variables: UsersSwitchAccountMutationVariables,
+  ) => Promise<UsersSwitchAccountMutationData>;
+} {
+  return {
+    mutationKey: mutationKeyUsersSwitchAccount(),
+    mutationFn: function usersSwitchAccountMutationFn({
+      request,
+      options,
+    }): Promise<UsersSwitchAccountMutationData> {
+      const mergedOptions = {
+        ...hookOptions,
+        ...options,
+        fetchOptions: {
+          ...hookOptions?.fetchOptions,
+          ...options?.fetchOptions,
+          signal: combineSignals(
+            hookOptions?.fetchOptions?.signal,
+            options?.fetchOptions?.signal,
+          ),
+        },
+      };
+      return unwrapAsync(usersSwitchAccount(
+        client$,
+        request,
+        mergedOptions,
+      ));
+    },
+  };
+}

package/src/sdk/users.ts

@@ -11,6 +11,7 @@ import { usersPassword } from "../funcs/usersPassword.js";
 import { usersPasswordResetRequest } from "../funcs/usersPasswordResetRequest.js";
 import { usersPostAuthenticate } from "../funcs/usersPostAuthenticate.js";
 import { usersRotateApiKey } from "../funcs/usersRotateApiKey.js";
+import { usersSwitchAccount } from "../funcs/usersSwitchAccount.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as components from "../models/components/index.js";
 import * as operations from "../models/operations/index.js";
@@ -133,6 +134,23 @@ export class Users extends ClientSDK {
     ));
   }
 
+  /**
+   * Switch to linked account
+   *
+   * @remarks
+   * If a user has two different types of accounts (i.e. Company Manager and Vendor) this endpoint allows the integration to swap the token from the existing user to the linked account user. For API integrations, the `source_user_id` field is required and must be the ID of the user whose session will be switched into the target user's token.
+   */
+  async switchAccount(
+    request: operations.SwitchAccountRequestBody,
+    options?: RequestOptions,
+  ): Promise<operations.SwitchAccountResponseBody> {
+    return unwrapAsync(usersSwitchAccount(
+      this,
+      request,
+      options,
+    ));
+  }
+
   /**
    * Magic link
    *