bitsnap-checkout/dist/backend.mjs

This is Bitsnap Checkout React library for easy integration with any website which is using React framework

import {
  NotifyUserAboutProductAvailabilityRequestSchema,
  PublicApiService
} from "./chunk-FLQW553F.mjs";
import {
  BitsnapModels
} from "./chunk-ZRKP2UXJ.mjs";
import "./chunk-ZD7AOCMD.mjs";

// src/backend.ts
import { create } from "@bufbuild/protobuf";
import zod from "zod";

// src/public.api.backend.ts
import { createClient } from "@connectrpc/connect";
import { createConnectTransport } from "@connectrpc/connect-node";
var PublicApiClient;
((PublicApiClient2) => {
  function get(host) {
    return createClient(PublicApiService, getTransport(host));
  }
  PublicApiClient2.get = get;
  let transport;
  function getTransport(host) {
    if (transport == null) {
      transport = createConnectTransport({
        httpVersion: "1.1",
        useBinaryFormat: true,
        baseUrl: host + "/api/rpc"
      });
    }
    return transport;
  }
})(PublicApiClient || (PublicApiClient = {}));

// src/backend.ts
var BACKEND_HOST = "https://bitsnap.pl";
var API_KEY;
var BitsnapBackend;
((BitsnapBackend2) => {
  async function setCustomHost(host) {
    BACKEND_HOST = host;
  }
  BitsnapBackend2.setCustomHost = setCustomHost;
  function getHost() {
    return BACKEND_HOST;
  }
  BitsnapBackend2.getHost = getHost;
  async function setApiKey(apiKey) {
    API_KEY = apiKey;
  }
  BitsnapBackend2.setApiKey = setApiKey;
  async function getProduct(projectID, id, requestInit) {
    var _a;
    const payload = {
      "0": {
        projectID,
        id
      }
    };
    const encodedPayload = new URLSearchParams();
    encodedPayload.set("batch", "1");
    encodedPayload.set("input", JSON.stringify(payload));
    const result = await fetch(
      BACKEND_HOST + "/api/trpc/product.getProductById?" + encodedPayload.toString(),
      {
        ...requestInit != null ? requestInit : {},
        headers: {
          ...(_a = requestInit == null ? void 0 : requestInit.headers) != null ? _a : {},
          "Content-Type": "application/json",
          Priority: "u=3, i"
        }
      }
    );
    const downloadedPayload = await result.json();
    const parsedResult = await BitsnapModels.ProductResultSchema.parseAsync(downloadedPayload);
    if (parsedResult.length == 0) {
      return void 0;
    }
    const parsed = parsedResult[0];
    return parsed.result;
  }
  BitsnapBackend2.getProduct = getProduct;
  async function getProducts(projectID, limit, offset, requestInit, opts) {
    var _a;
    const productsPayload = {
      "0": {
        projectID,
        limit,
        offset
      }
    };
    if (opts) {
      if (opts.groupVariants != null) {
        productsPayload[0]["groupVariants"] = opts.groupVariants;
      }
    }
    const encodedPayload = new URLSearchParams();
    encodedPayload.set("batch", "1");
    encodedPayload.set("input", JSON.stringify(productsPayload));
    const result = await fetch(
      BACKEND_HOST + "/api/trpc/product.getProductGrid?" + encodedPayload.toString(),
      {
        ...requestInit != null ? requestInit : {},
        headers: {
          ...(_a = requestInit == null ? void 0 : requestInit.headers) != null ? _a : {},
          "Content-Type": "application/json",
          Priority: "u=3, i"
        }
      }
    );
    const downloadedPayload = await result.json();
    try {
      const parsedResult = await BitsnapModels.ProductsResultElementSchema.parseAsync(
        downloadedPayload
      );
      if (parsedResult.length == 0) {
        return {
          categories: void 0,
          products: void 0
        };
      }
      const parsed = parsedResult[0];
      return parsed.result;
    } catch (error) {
      console.error("Error parsing products result:", JSON.stringify(error));
      throw error;
    }
  }
  BitsnapBackend2.getProducts = getProducts;
  async function sendNotification(request, requestInit) {
    var _a;
    if (API_KEY == null || API_KEY == "") {
      throw new Error(
        'use BitsnapBackend.setApiKey("{{API_KEY}} to setup api key before using this method.")'
      );
    }
    const result = await fetch(BACKEND_HOST + "/api/notification/send", {
      ...requestInit != null ? requestInit : {},
      method: "POST",
      body: JSON.stringify(request),
      headers: {
        ...(_a = requestInit == null ? void 0 : requestInit.headers) != null ? _a : {},
        "Content-Type": "application/json",
        Authorization: "Bearer " + API_KEY
      }
    });
    if (result.status != 200) {
      console.warn(
        "error while sending notification",
        result.status,
        await result.text()
      );
      return "failure";
    }
    return "success";
  }
  BitsnapBackend2.sendNotification = sendNotification;
  async function notifyProductAvailability(request, opts) {
    const req = create(NotifyUserAboutProductAvailabilityRequestSchema, {
      productId: request.productId,
      email: request.email,
      projectId: request.projectId
    });
    try {
      await PublicApiClient.get(
        BACKEND_HOST
      ).notifyUserAboutProductAvailability(req, opts);
      return {
        status: "success"
      };
    } catch (e) {
      console.log("error while sending notification", e);
      return {
        status: "failure",
        message: "failed-to-notify"
      };
    }
  }
  BitsnapBackend2.notifyProductAvailability = notifyProductAvailability;
})(BitsnapBackend || (BitsnapBackend = {}));
var notificationTypes = zod.enum(["push", "email", "sms"]);
var notificationRequestSchema = zod.object({
  to: zod.array(zod.string()),
  title: zod.string(),
  body: zod.string().optional(),
  type: zod.union([notificationTypes, zod.array(notificationTypes)]).default("push"),
  emailOptions: zod.object({
    subject: zod.string().optional(),
    replyTo: zod.string().optional(),
    htmlText: zod.string().optional()
  }).optional(),
  advanced: zod.object({
    /// This is a boolean flag that indicates whether the notification should be shown in the dashboard. DEFAULT: true.
    showInDashboard: zod.boolean().default(false)
  }).optional()
});
export {
  BitsnapBackend
};
//# sourceMappingURL=backend.mjs.map