@apideck/unify 0.38.0 → 0.38.1

package/src/models/operations/proxyputproxy.ts

@@ -0,0 +1,215 @@
+/*
+ * 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 * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type ProxyPutProxyGlobals = {
+  /**
+   * ID of the consumer which you want to get or push data from
+   */
+  consumerId?: string | undefined;
+  /**
+   * The ID of your Unify application
+   */
+  appId?: string | undefined;
+};
+
+export type RequestBody3 = {};
+
+export type RequestBody1 = {};
+
+export type ProxyPutProxyRequest = {
+  /**
+   * ID of the consumer which you want to get or push data from
+   */
+  consumerId?: string | undefined;
+  /**
+   * The ID of your Unify application
+   */
+  appId?: string | undefined;
+  /**
+   * Provide the service id you want to call (e.g., pipedrive). Only needed when a consumer has activated multiple integrations for a Unified API.
+   */
+  serviceId: string;
+  /**
+   * Specify which unified API to use for the connection lookup. Required for multi-API connectors (e.g., Workday) to ensure the correct credentials are used.
+   */
+  unifiedApi?: string | undefined;
+  /**
+   * Downstream URL
+   */
+  downstreamUrl: string;
+  /**
+   * Downstream authorization header. This will skip the Vault token injection.
+   */
+  downstreamAuthorization?: string | undefined;
+  /**
+   * Depending on the verb/method of the request this will contain the request body you want to POST/PATCH/PUT.
+   */
+  requestBody?:
+    | ReadableStream<Uint8Array>
+    | Blob
+    | ArrayBuffer
+    | Uint8Array
+    | undefined;
+};
+
+export type ProxyPutProxyResponse = {
+  httpMeta: components.HTTPMetadata;
+  /**
+   * Ok
+   */
+  responseJson?: { [k: string]: any } | undefined;
+  /**
+   * Ok
+   */
+  responseBinary?: ReadableStream<Uint8Array> | undefined;
+  /**
+   * Ok
+   */
+  responsePdf?: ReadableStream<Uint8Array> | undefined;
+  /**
+   * Ok
+   */
+  responseXml?: string | undefined;
+  /**
+   * Ok
+   */
+  responseCsv?: string | undefined;
+  /**
+   * Ok
+   */
+  responseText?: string | undefined;
+  /**
+   * Proxy error
+   */
+  errorJson?: { [k: string]: any } | undefined;
+  /**
+   * Proxy error
+   */
+  errorXml?: string | undefined;
+  /**
+   * Proxy error
+   */
+  errorHtml?: string | undefined;
+  /**
+   * Proxy error
+   */
+  errorText?: string | undefined;
+};
+
+/** @internal */
+export type RequestBody3$Outbound = {};
+
+/** @internal */
+export const RequestBody3$outboundSchema: z.ZodType<
+  RequestBody3$Outbound,
+  z.ZodTypeDef,
+  RequestBody3
+> = z.object({});
+
+export function requestBody3ToJSON(requestBody3: RequestBody3): string {
+  return JSON.stringify(RequestBody3$outboundSchema.parse(requestBody3));
+}
+
+/** @internal */
+export type RequestBody1$Outbound = {};
+
+/** @internal */
+export const RequestBody1$outboundSchema: z.ZodType<
+  RequestBody1$Outbound,
+  z.ZodTypeDef,
+  RequestBody1
+> = z.object({});
+
+export function requestBody1ToJSON(requestBody1: RequestBody1): string {
+  return JSON.stringify(RequestBody1$outboundSchema.parse(requestBody1));
+}
+
+/** @internal */
+export type ProxyPutProxyRequest$Outbound = {
+  consumerId?: string | undefined;
+  appId?: string | undefined;
+  serviceId: string;
+  unifiedApi?: string | undefined;
+  downstreamUrl: string;
+  downstreamAuthorization?: string | undefined;
+  RequestBody?:
+    | ReadableStream<Uint8Array>
+    | Blob
+    | ArrayBuffer
+    | Uint8Array
+    | undefined;
+};
+
+/** @internal */
+export const ProxyPutProxyRequest$outboundSchema: z.ZodType<
+  ProxyPutProxyRequest$Outbound,
+  z.ZodTypeDef,
+  ProxyPutProxyRequest
+> = z.object({
+  consumerId: z.string().optional(),
+  appId: z.string().optional(),
+  serviceId: z.string(),
+  unifiedApi: z.string().optional(),
+  downstreamUrl: z.string(),
+  downstreamAuthorization: z.string().optional(),
+  requestBody: z.union([
+    z.instanceof(ReadableStream<Uint8Array>),
+    z.instanceof(Blob),
+    z.instanceof(ArrayBuffer),
+    z.instanceof(Uint8Array),
+  ]).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    requestBody: "RequestBody",
+  });
+});
+
+export function proxyPutProxyRequestToJSON(
+  proxyPutProxyRequest: ProxyPutProxyRequest,
+): string {
+  return JSON.stringify(
+    ProxyPutProxyRequest$outboundSchema.parse(proxyPutProxyRequest),
+  );
+}
+
+/** @internal */
+export const ProxyPutProxyResponse$inboundSchema: z.ZodType<
+  ProxyPutProxyResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  HttpMeta: components.HTTPMetadata$inboundSchema,
+  responseJson: types.optional(z.record(z.any())),
+  responseBinary: types.optional(z.instanceof(ReadableStream<Uint8Array>)),
+  responsePdf: types.optional(z.instanceof(ReadableStream<Uint8Array>)),
+  responseXml: types.optional(types.string()),
+  responseCsv: types.optional(types.string()),
+  responseText: types.optional(types.string()),
+  errorJson: types.optional(z.record(z.any())),
+  errorXml: types.optional(types.string()),
+  errorHtml: types.optional(types.string()),
+  errorText: types.optional(types.string()),
+}).transform((v) => {
+  return remap$(v, {
+    "HttpMeta": "httpMeta",
+  });
+});
+
+export function proxyPutProxyResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ProxyPutProxyResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProxyPutProxyResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProxyPutProxyResponse' from JSON`,
+  );
+}

package/src/sdk/proxy.ts

@@ -0,0 +1,135 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { DeleteAcceptEnum, proxyDelete } from "../funcs/proxyDelete.js";
+import { GetAcceptEnum, proxyGet } from "../funcs/proxyGet.js";
+import { OptionsAcceptEnum, proxyOptions } from "../funcs/proxyOptions.js";
+import { PatchAcceptEnum, proxyPatch } from "../funcs/proxyPatch.js";
+import { PostAcceptEnum, proxyPost } from "../funcs/proxyPost.js";
+import { proxyPut, PutAcceptEnum } from "../funcs/proxyPut.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export { GetAcceptEnum } from "../funcs/proxyGet.js";
+
+export { OptionsAcceptEnum } from "../funcs/proxyOptions.js";
+
+export { PostAcceptEnum } from "../funcs/proxyPost.js";
+
+export { PutAcceptEnum } from "../funcs/proxyPut.js";
+
+export { PatchAcceptEnum } from "../funcs/proxyPatch.js";
+
+export { DeleteAcceptEnum } from "../funcs/proxyDelete.js";
+
+export class Proxy extends ClientSDK {
+  /**
+   * GET
+   *
+   * @remarks
+   * Proxies a downstream GET request to a service and injects the necessary credentials into a request stored in Vault. This allows you to have an additional security layer and logging without needing to rely on Unify for normalization.
+   * **Note**: Vault will proxy all data to the downstream URL and method/verb in the headers.
+   */
+  async get(
+    request: operations.ProxyGetProxyRequest,
+    options?: RequestOptions & { acceptHeaderOverride?: GetAcceptEnum },
+  ): Promise<operations.ProxyGetProxyResponse> {
+    return unwrapAsync(proxyGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * OPTIONS
+   *
+   * @remarks
+   * Proxies a downstream OPTION request to a service and injects the necessary credentials into a request stored in Vault. This allows you to have an additional security layer and logging without needing to rely on Unify for normalization.
+   * **Note**: Vault will proxy all data to the downstream URL and method/verb in the headers.
+   */
+  async options(
+    request: operations.ProxyOptionsProxyRequest,
+    options?: RequestOptions & { acceptHeaderOverride?: OptionsAcceptEnum },
+  ): Promise<operations.ProxyOptionsProxyResponse> {
+    return unwrapAsync(proxyOptions(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * POST
+   *
+   * @remarks
+   * Proxies a downstream POST request to a service and injects the necessary credentials into a request stored in Vault. This allows you to have an additional security layer and logging without needing to rely on Unify for normalization.
+   * **Note**: Vault will proxy all data to the downstream URL and method/verb in the headers.
+   */
+  async post(
+    request: operations.ProxyPostProxyRequest,
+    options?: RequestOptions & { acceptHeaderOverride?: PostAcceptEnum },
+  ): Promise<operations.ProxyPostProxyResponse> {
+    return unwrapAsync(proxyPost(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * PUT
+   *
+   * @remarks
+   * Proxies a downstream PUT request to a service and injects the necessary credentials into a request stored in Vault. This allows you to have an additional security layer and logging without needing to rely on Unify for normalization.
+   * **Note**: Vault will proxy all data to the downstream URL and method/verb in the headers.
+   */
+  async put(
+    request: operations.ProxyPutProxyRequest,
+    options?: RequestOptions & { acceptHeaderOverride?: PutAcceptEnum },
+  ): Promise<operations.ProxyPutProxyResponse> {
+    return unwrapAsync(proxyPut(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * PATCH
+   *
+   * @remarks
+   * Proxies a downstream PATCH request to a service and injects the necessary credentials into a request stored in Vault. This allows you to have an additional security layer and logging without needing to rely on Unify for normalization.
+   * **Note**: Vault will proxy all data to the downstream URL and method/verb in the headers.
+   */
+  async patch(
+    request: operations.ProxyPatchProxyRequest,
+    options?: RequestOptions & { acceptHeaderOverride?: PatchAcceptEnum },
+  ): Promise<operations.ProxyPatchProxyResponse> {
+    return unwrapAsync(proxyPatch(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * DELETE
+   *
+   * @remarks
+   * Proxies a downstream DELETE request to a service and injects the necessary credentials into a request stored in Vault. This allows you to have an additional security layer and logging without needing to rely on Unify for normalization.
+   * **Note**: Vault will proxy all data to the downstream URL and method/verb in the headers.
+   */
+  async delete(
+    request: operations.ProxyDeleteProxyRequest,
+    options?: RequestOptions & { acceptHeaderOverride?: DeleteAcceptEnum },
+  ): Promise<operations.ProxyDeleteProxyResponse> {
+    return unwrapAsync(proxyDelete(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/sdk.ts

@@ -11,6 +11,7 @@ import { Ecommerce } from "./ecommerce.js";
 import { FileStorage } from "./filestorage.js";
 import { Hris } from "./hris.js";
 import { IssueTracking } from "./issuetracking.js";
+import { Proxy } from "./proxy.js";
 import { Sms } from "./sms.js";
 import { Vault } from "./vault.js";
 import { Webhook } from "./webhook.js";
@@ -61,6 +62,11 @@ export class Apideck extends ClientSDK {
     return (this._connector ??= new Connector(this._options));
   }
 
+  private _proxy?: Proxy;
+  get proxy(): Proxy {
+    return (this._proxy ??= new Proxy(this._options));
+  }
+
   private _vault?: Vault;
   get vault(): Vault {
     return (this._vault ??= new Vault(this._options));