@portone/server-sdk/dist/generated/platform/partner/client.mjs

PortOne JavaScript SDK for server-side usage

import { PartnerError } from "./PartnerError.mjs";
import { USER_AGENT } from "../../../client.mjs";
export function PartnerClient(init) {
  const baseUrl = init.baseUrl ?? "https://api.portone.io";
  const secret = init.secret;
  return {
    getPlatformPartners: async (options) => {
      const page = options?.page;
      const filter = options?.filter;
      const requestBody = JSON.stringify({
        page,
        filter
      });
      const query = [
        ["requestBody", requestBody]
      ].flatMap(([key, value]) => value == null ? [] : `${key}=${encodeURIComponent(value)}`).join("&");
      const response = await fetch(
        new URL(`/platform/partners?${query}`, baseUrl),
        {
          method: "GET",
          headers: {
            Authorization: `PortOne ${secret}`,
            "User-Agent": USER_AGENT
          }
        }
      );
      if (!response.ok) {
        throw new GetPlatformPartnersError(await response.json());
      }
      return response.json();
    },
    createPlatformPartner: async (options) => {
      const {
        id,
        name,
        contact,
        account,
        defaultContractId,
        memo,
        tags,
        type,
        userDefinedProperties
      } = options;
      const requestBody = JSON.stringify({
        id,
        name,
        contact,
        account,
        defaultContractId,
        memo,
        tags,
        type,
        userDefinedProperties
      });
      const response = await fetch(
        new URL("/platform/partners", baseUrl),
        {
          method: "POST",
          headers: {
            Authorization: `PortOne ${secret}`,
            "User-Agent": USER_AGENT
          },
          body: requestBody
        }
      );
      if (!response.ok) {
        throw new CreatePlatformPartnerError(await response.json());
      }
      return response.json();
    },
    createPlatformPartners: async (options) => {
      const {
        partners
      } = options;
      const requestBody = JSON.stringify({
        partners
      });
      const response = await fetch(
        new URL("/platform/partners/batch", baseUrl),
        {
          method: "POST",
          headers: {
            Authorization: `PortOne ${secret}`,
            "User-Agent": USER_AGENT
          },
          body: requestBody
        }
      );
      if (!response.ok) {
        throw new CreatePlatformPartnersError(await response.json());
      }
      return response.json();
    },
    connectBulkPartnerMemberCompany: async (options) => {
      const filter = options?.filter;
      const requestBody = JSON.stringify({
        filter
      });
      const response = await fetch(
        new URL("/platform/partners/member-company-connect", baseUrl),
        {
          method: "POST",
          headers: {
            Authorization: `PortOne ${secret}`,
            "User-Agent": USER_AGENT
          },
          body: requestBody
        }
      );
      if (!response.ok) {
        throw new ConnectBulkPartnerMemberCompanyError(await response.json());
      }
      return response.json();
    },
    connectPartnerMemberCompany: async (options) => {
      const {
        id
      } = options;
      const response = await fetch(
        new URL(`/platform/partners/member-company-connect/${encodeURIComponent(id)}`, baseUrl),
        {
          method: "POST",
          headers: {
            Authorization: `PortOne ${secret}`,
            "User-Agent": USER_AGENT
          }
        }
      );
      if (!response.ok) {
        throw new ConnectPartnerMemberCompanyError(await response.json());
      }
      return response.json();
    },
    disconnectBulkPartnerMemberCompany: async (options) => {
      const filter = options?.filter;
      const requestBody = JSON.stringify({
        filter
      });
      const response = await fetch(
        new URL("/platform/partners/member-company-disconnect", baseUrl),
        {
          method: "POST",
          headers: {
            Authorization: `PortOne ${secret}`,
            "User-Agent": USER_AGENT
          },
          body: requestBody
        }
      );
      if (!response.ok) {
        throw new DisconnectBulkPartnerMemberCompanyError(await response.json());
      }
      return response.json();
    },
    disconnectPartnerMemberCompany: async (options) => {
      const {
        id
      } = options;
      const response = await fetch(
        new URL(`/platform/partners/member-company-disconnect/${encodeURIComponent(id)}`, baseUrl),
        {
          method: "POST",
          headers: {
            Authorization: `PortOne ${secret}`,
            "User-Agent": USER_AGENT
          }
        }
      );
      if (!response.ok) {
        throw new DisconnectPartnerMemberCompanyError(await response.json());
      }
      return response.json();
    },
    getPlatformPartner: async (options) => {
      const {
        id
      } = options;
      const response = await fetch(
        new URL(`/platform/partners/${encodeURIComponent(id)}`, baseUrl),
        {
          method: "GET",
          headers: {
            Authorization: `PortOne ${secret}`,
            "User-Agent": USER_AGENT
          }
        }
      );
      if (!response.ok) {
        throw new GetPlatformPartnerError(await response.json());
      }
      return response.json();
    },
    updatePlatformPartner: async (options) => {
      const {
        id,
        name,
        contact,
        account,
        defaultContractId,
        memo,
        tags,
        type,
        userDefinedProperties
      } = options;
      const requestBody = JSON.stringify({
        name,
        contact,
        account,
        defaultContractId,
        memo,
        tags,
        type,
        userDefinedProperties
      });
      const response = await fetch(
        new URL(`/platform/partners/${encodeURIComponent(id)}`, baseUrl),
        {
          method: "PATCH",
          headers: {
            Authorization: `PortOne ${secret}`,
            "User-Agent": USER_AGENT
          },
          body: requestBody
        }
      );
      if (!response.ok) {
        throw new UpdatePlatformPartnerError(await response.json());
      }
      return response.json();
    },
    archivePlatformPartner: async (options) => {
      const {
        id
      } = options;
      const response = await fetch(
        new URL(`/platform/partners/${encodeURIComponent(id)}/archive`, baseUrl),
        {
          method: "POST",
          headers: {
            Authorization: `PortOne ${secret}`,
            "User-Agent": USER_AGENT
          }
        }
      );
      if (!response.ok) {
        throw new ArchivePlatformPartnerError(await response.json());
      }
      return response.json();
    },
    recoverPlatformPartner: async (options) => {
      const {
        id
      } = options;
      const response = await fetch(
        new URL(`/platform/partners/${encodeURIComponent(id)}/recover`, baseUrl),
        {
          method: "POST",
          headers: {
            Authorization: `PortOne ${secret}`,
            "User-Agent": USER_AGENT
          }
        }
      );
      if (!response.ok) {
        throw new RecoverPlatformPartnerError(await response.json());
      }
      return response.json();
    }
  };
}
export class GetPlatformPartnersError extends PartnerError {
  /** @ignore */
  constructor(data) {
    super(data);
    Object.setPrototypeOf(this, GetPlatformPartnersError.prototype);
    this.name = "GetPlatformPartnersError";
  }
}
export class CreatePlatformPartnerError extends PartnerError {
  /** @ignore */
  constructor(data) {
    super(data);
    Object.setPrototypeOf(this, CreatePlatformPartnerError.prototype);
    this.name = "CreatePlatformPartnerError";
  }
}
export class CreatePlatformPartnersError extends PartnerError {
  /** @ignore */
  constructor(data) {
    super(data);
    Object.setPrototypeOf(this, CreatePlatformPartnersError.prototype);
    this.name = "CreatePlatformPartnersError";
  }
}
export class ConnectBulkPartnerMemberCompanyError extends PartnerError {
  /** @ignore */
  constructor(data) {
    super(data);
    Object.setPrototypeOf(this, ConnectBulkPartnerMemberCompanyError.prototype);
    this.name = "ConnectBulkPartnerMemberCompanyError";
  }
}
export class ConnectPartnerMemberCompanyError extends PartnerError {
  /** @ignore */
  constructor(data) {
    super(data);
    Object.setPrototypeOf(this, ConnectPartnerMemberCompanyError.prototype);
    this.name = "ConnectPartnerMemberCompanyError";
  }
}
export class DisconnectBulkPartnerMemberCompanyError extends PartnerError {
  /** @ignore */
  constructor(data) {
    super(data);
    Object.setPrototypeOf(this, DisconnectBulkPartnerMemberCompanyError.prototype);
    this.name = "DisconnectBulkPartnerMemberCompanyError";
  }
}
export class DisconnectPartnerMemberCompanyError extends PartnerError {
  /** @ignore */
  constructor(data) {
    super(data);
    Object.setPrototypeOf(this, DisconnectPartnerMemberCompanyError.prototype);
    this.name = "DisconnectPartnerMemberCompanyError";
  }
}
export class GetPlatformPartnerError extends PartnerError {
  /** @ignore */
  constructor(data) {
    super(data);
    Object.setPrototypeOf(this, GetPlatformPartnerError.prototype);
    this.name = "GetPlatformPartnerError";
  }
}
export class UpdatePlatformPartnerError extends PartnerError {
  /** @ignore */
  constructor(data) {
    super(data);
    Object.setPrototypeOf(this, UpdatePlatformPartnerError.prototype);
    this.name = "UpdatePlatformPartnerError";
  }
}
export class ArchivePlatformPartnerError extends PartnerError {
  /** @ignore */
  constructor(data) {
    super(data);
    Object.setPrototypeOf(this, ArchivePlatformPartnerError.prototype);
    this.name = "ArchivePlatformPartnerError";
  }
}
export class RecoverPlatformPartnerError extends PartnerError {
  /** @ignore */
  constructor(data) {
    super(data);
    Object.setPrototypeOf(this, RecoverPlatformPartnerError.prototype);
    this.name = "RecoverPlatformPartnerError";
  }
}