bigrequest/dist/index.mjs

A typesafe, servelerless-friendly Node.js HTTP request client for the BigCommerce API

var __getOwnPropNames = Object.getOwnPropertyNames;
var __esm = (fn, res) => function __init() {
  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};

// src/error.ts
var BigRequestError;
var init_error = __esm({
  "src/error.ts"() {
    "use strict";
    BigRequestError = class extends Error {
      constructor(message) {
        super(message);
        this.name = "BigRequestError";
      }
    };
  }
});

// src/oauth.ts
import { jwtVerify } from "jose";
import { z } from "zod";
var oauthConfigSchema, oauth;
var init_oauth = __esm({
  "src/oauth.ts"() {
    "use strict";
    init_error();
    oauthConfigSchema = z.object({
      clientId: z.string().min(1),
      clientSecret: z.string().min(1),
      authCallback: z.string().url()
    });
    oauth = (config) => {
      const oauthConfig = oauthConfigSchema.safeParse(config);
      if (!oauthConfig.success) {
        throw new BigRequestError(
          `Invalid OAuth config: ${JSON.stringify(oauthConfig.error.flatten().fieldErrors, null, 2)}`
        );
      }
      const authCallbackQuerySchema = z.object({
        code: z.string(),
        scope: z.string(),
        context: z.string()
      });
      const authorize = async (query) => {
        const authCallbackQuery = authCallbackQuerySchema.safeParse(query);
        if (!authCallbackQuery.success) {
          throw new BigRequestError(
            `Invalid Auth Callback arguments: ${JSON.stringify(
              authCallbackQuery.error.flatten().fieldErrors,
              null,
              2
            )}`
          );
        }
        const oauthResponse = await fetch(`https://login.bigcommerce.com/oauth2/token`, {
          method: "POST",
          headers: {
            accept: "application/json",
            "content-type": "application/json"
          },
          body: JSON.stringify({
            client_id: oauthConfig.data.clientId,
            client_secret: oauthConfig.data.clientSecret,
            code: authCallbackQuery.data.code,
            context: authCallbackQuery.data.context,
            scope: authCallbackQuery.data.scope,
            grant_type: "authorization_code",
            redirect_uri: oauthConfig.data.authCallback
          })
        });
        const oauthResponseSchema = z.object({
          access_token: z.string(),
          scope: z.string(),
          user: z.object({
            id: z.number(),
            username: z.string(),
            email: z.string()
          }),
          context: z.string(),
          account_uuid: z.string()
        });
        const accessTokenResponse = oauthResponseSchema.safeParse(await oauthResponse.json());
        if (!accessTokenResponse.success) {
          throw new BigRequestError(
            `Invalid access token response: ${JSON.stringify(
              accessTokenResponse.error.flatten().fieldErrors,
              null,
              2
            )}`
          );
        }
        return accessTokenResponse.data;
      };
      const jwtSchema = z.string().min(1);
      const verify = async (signedPayloadJwt) => {
        const parsedJwt = jwtSchema.safeParse(signedPayloadJwt);
        if (!parsedJwt.success) {
          throw new BigRequestError(
            `Invalid signed payload JWT: ${JSON.stringify(
              parsedJwt.error.flatten().fieldErrors,
              null,
              2
            )}`
          );
        }
        const secret = new TextEncoder().encode(oauthConfig.data.clientSecret);
        const decoded = await jwtVerify(parsedJwt.data, secret);
        const verifiedJwtSchema = z.object({
          aud: z.string(),
          iss: z.string(),
          iat: z.number(),
          nbf: z.number(),
          exp: z.number(),
          jti: z.string(),
          sub: z.string(),
          user: z.object({
            id: z.number(),
            email: z.string().email(),
            locale: z.string()
          }),
          owner: z.object({
            id: z.number(),
            email: z.string().email()
          }),
          url: z.string(),
          channel_id: z.number().nullable()
        });
        const parsedVerifiedJwt = verifiedJwtSchema.safeParse(decoded.payload);
        if (!parsedVerifiedJwt.success) {
          throw new BigRequestError(
            `Verified JWT schema invalid: ${JSON.stringify(
              parsedVerifiedJwt.error.flatten().fieldErrors,
              null,
              2
            )}`
          );
        }
        return parsedVerifiedJwt.data;
      };
      return {
        authorize,
        verify
      };
    };
  }
});

// src/rest.ts
import createClient from "openapi-fetch";
import { z as z2 } from "zod";
var restConfigSchema, rest;
var init_rest = __esm({
  "src/rest.ts"() {
    "use strict";
    init_error();
    restConfigSchema = z2.object({
      storeHash: z2.string().min(1),
      accessToken: z2.string().min(1)
    });
    rest = ({ storeHash, accessToken }) => {
      const restConfig = restConfigSchema.safeParse({ storeHash, accessToken });
      if (!restConfig.success) {
        throw new BigRequestError(
          `Invalid REST config: ${JSON.stringify(restConfig.error.flatten().fieldErrors, null, 2)}`
        );
      }
      return {
        v2: createClient({
          baseUrl: `https://api.bigcommerce.com/stores/${restConfig.data.storeHash}/v2`,
          headers: { "x-auth-token": restConfig.data.accessToken }
        }),
        v3: createClient({
          baseUrl: `https://api.bigcommerce.com/stores/${restConfig.data.storeHash}/v3`,
          headers: { "x-auth-token": restConfig.data.accessToken }
        })
      };
    };
  }
});

// src/index.ts
var require_src = __commonJS({
  "src/index.ts"(exports, module) {
    init_oauth();
    init_rest();
    var bigrequest = {
      oauth,
      rest
    };
    module.exports = bigrequest;
  }
});
export default require_src();