testBatchApi.js

import BosBase from "bosbase";

const baseUrl = process.env.BOSBASE_BASE_URL ?? "http://127.0.0.1:8090";
const authEmail =
  process.env.BOSBASE_EMAIL ??
  process.env.BOSBASE_SUPERUSER_EMAIL ??
  "try@bosbase.com";
const authPassword =
  process.env.BOSBASE_PASSWORD ??
  process.env.BOSBASE_SUPERUSER_PASSWORD ??
  "bosbasepass";

async function main() {
  let pb;
  let collectionName;
  let originalBatchSettings;
  let batchSettingsChanged = false;
  try {
    console.log("[INFO] BATCH_API doc test starting...");
    pb = new BosBase(baseUrl);
    await pb.collection("_superusers").authWithPassword(authEmail, authPassword);
    console.log("[SUCCESS] Authenticated as superuser");

    originalBatchSettings = await pb.settings.getCategory("batch");
    const maxRequests =
      originalBatchSettings?.maxRequests && originalBatchSettings.maxRequests > 0
        ? originalBatchSettings.maxRequests
        : 50;
    const timeout =
      originalBatchSettings?.timeout && originalBatchSettings.timeout > 0
        ? originalBatchSettings.timeout
        : 3;
    if (!originalBatchSettings?.enabled || maxRequests <= 0) {
      await pb.settings.updateBatch({
        enabled: true,
        maxRequests,
        timeout,
        maxBodySize: originalBatchSettings?.maxBodySize ?? 0,
      });
      batchSettingsChanged = true;
      console.log("[INFO] Enabled batch API for test run");
    } else {
      console.log("[INFO] Batch API already enabled");
    }

    collectionName = `batch_demo_${Date.now()}`;
    await pb.collections.create({
      name: collectionName,
      type: "base",
      schema: [
        { name: "title", type: "text", required: true },
        { name: "flag", type: "bool" },
      ],
    });
    console.log(`[SUCCESS] Collection "${collectionName}" created`);

    const createBatch = pb.createBatch();
    createBatch.collection(collectionName).create({ title: "First", flag: true });
    createBatch.collection(collectionName).create({ title: "Second", flag: false });
    const createResults = await createBatch.send();
    const createdIds = (createResults || [])
      .map((entry) => entry?.body?.id)
      .filter(Boolean);
    console.log("[SUCCESS] Batch created records:", createdIds.join(", ") || "none");
    if (createdIds.length < 2) {
      throw new Error("Batch create did not return at least 2 record ids");
    }

    const updateBatch = pb.createBatch();
    updateBatch
      .collection(collectionName)
      .update(createdIds[0], { title: "Updated First" });
    updateBatch
      .collection(collectionName)
      .upsert({ id: createdIds[0], flag: false });
    updateBatch.collection(collectionName).delete(createdIds[1]);
    const updateResults = await updateBatch.send();
    console.log(
      "[SUCCESS] Batch update/upsert/delete statuses:",
      (updateResults || []).map((r) => r?.status).join(", "),
    );

    const list = await pb.collection(collectionName).getList(1, 10, {
      sort: "-created",
    });
    const remainingTitles = list?.items?.map((item) => item.title) ?? [];
    console.log("[SUCCESS] Records after batch:", remainingTitles.join(", ") || "none");

    console.log("\n========== BATCH_API doc test completed ==========");
  } catch (error) {
    console.error("[ERROR] BATCH_API doc test failed:");
    if (error?.response) {
      console.error("Status:", error.response.status);
      console.error("Data:", JSON.stringify(error.response.data, null, 2));
      if (error.response.data?.message) {
        console.error("Message:", error.response.data.message);
      }
    } else {
      console.error(error);
    }
    process.exit(1);
  } finally {
    if (pb && collectionName) {
      try {
        await pb.collections.delete(collectionName);
        console.log(`[CLEANUP] Collection "${collectionName}" deleted`);
      } catch (cleanupError) {
        console.warn(
          "[WARN] Failed to delete test collection:",
          cleanupError?.message || cleanupError,
        );
      }
    }
    if (pb && batchSettingsChanged && originalBatchSettings) {
      try {
        await pb.settings.updateBatch({
          enabled: !!originalBatchSettings.enabled,
          maxRequests: originalBatchSettings.maxRequests,
          timeout: originalBatchSettings.timeout,
          maxBodySize: originalBatchSettings.maxBodySize,
        });
        console.log("[CLEANUP] Batch settings restored");
      } catch (batchCleanupError) {
        console.warn(
          "[WARN] Failed to restore batch settings:",
          batchCleanupError?.message || batchCleanupError,
        );
      }
    }
  }
}

main();