testFileApi.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 testCollectionName = null;
  let testRecordId = null;

  try {
    console.log("[INFO] FILE_API.md doc test starting...");
    pb = new BosBase(baseUrl);
    await pb.collection("_superusers").authWithPassword(authEmail, authPassword);
    console.log("[SUCCESS] Authenticated as superuser");

    // Test getToken()
    console.log("\n[INFO] Testing getToken()...");
    const token = await pb.files.getToken();
    if (token && token.length > 0) {
      console.log("[SUCCESS] File token obtained, length:", token.length);
    } else {
      throw new Error("File token is empty");
    }

    // Test getURL() - Create a test collection and record with a file field
    console.log("\n[INFO] Testing getURL()...");
    try {
      // Create a test collection with a file field
      testCollectionName = `file_test_${Date.now()}`;
      const collection = await pb.collections.create({
        name: testCollectionName,
        type: "base",
        schema: [
          { name: "title", type: "text", required: true },
          { name: "image", type: "file" },
        ],
      });
      console.log(`[SUCCESS] Created test collection: ${testCollectionName}`);

      // Create a record (even without a file, we can test URL generation)
      const record = await pb.collection(testCollectionName).create({
        title: "Test Record",
      });
      testRecordId = record.id;
      console.log(`[SUCCESS] Created test record: ${testRecordId}`);

      // Test getURL() with various parameters
      const testFilename = "test_image.jpg";

      // Test basic getURL()
      const basicUrl = pb.files.getURL(record, testFilename);
      // Check that URL contains the record ID and filename (it may use collectionId instead of collectionName)
      if (basicUrl && basicUrl.includes(testRecordId) && basicUrl.includes(testFilename)) {
        console.log("[SUCCESS] Basic getURL() works:", basicUrl.substring(0, 80) + "...");
      } else {
        throw new Error("Basic getURL() did not generate correct URL");
      }

      // Test getURL() with collectionId instead of collectionName
      const recordWithId = { ...record, collectionId: collection.id };
      const urlWithId = pb.files.getURL(recordWithId, testFilename);
      if (urlWithId && urlWithId.includes(collection.id)) {
        console.log("[SUCCESS] getURL() works with collectionId");
      }

      // Test getURL() with thumb parameter
      const thumbUrl = pb.files.getURL(record, testFilename, { thumb: "100x100" });
      if (thumbUrl && thumbUrl.includes("thumb=100x100")) {
        console.log("[SUCCESS] getURL() with thumb parameter works");
      } else {
        throw new Error("getURL() with thumb parameter did not generate correct URL");
      }

      // Test getURL() with download parameter
      const downloadUrl = pb.files.getURL(record, testFilename, { download: true });
      if (downloadUrl && downloadUrl.includes("download=")) {
        console.log("[SUCCESS] getURL() with download parameter works");
      } else {
        throw new Error("getURL() with download parameter did not generate correct URL");
      }

      // Test getURL() with token parameter
      const tokenUrl = pb.files.getURL(record, testFilename, { token: token });
      if (tokenUrl && tokenUrl.includes("token=")) {
        console.log("[SUCCESS] getURL() with token parameter works");
      } else {
        throw new Error("getURL() with token parameter did not generate correct URL");
      }

      // Test getURL() with multiple parameters
      const complexUrl = pb.files.getURL(record, testFilename, {
        thumb: "200x200",
        token: token,
        download: false,
      });
      if (complexUrl && complexUrl.includes("thumb=200x200") && complexUrl.includes("token=")) {
        console.log("[SUCCESS] getURL() with multiple parameters works");
      }

      // Test getURL() edge cases
      console.log("\n[INFO] Testing getURL() edge cases...");
      
      // Test with missing filename
      const emptyUrl = pb.files.getURL(record, "");
      if (emptyUrl === "") {
        console.log("[SUCCESS] getURL() returns empty string for missing filename");
      }

      // Test with missing record id
      const invalidRecord = { collectionName: testCollectionName };
      const invalidUrl = pb.files.getURL(invalidRecord, testFilename);
      if (invalidUrl === "") {
        console.log("[SUCCESS] getURL() returns empty string for invalid record");
      }

      // Test deprecated getUrl() method
      if (typeof pb.files.getUrl === "function") {
        const deprecatedUrl = pb.files.getUrl(record, testFilename);
        if (deprecatedUrl === basicUrl) {
          console.log("[SUCCESS] Deprecated getUrl() works and matches getURL()");
        }
      }

    } catch (urlTestError) {
      console.log(
        "[WARN] getURL() test encountered issues:",
        urlTestError?.response?.data?.message || urlTestError.message,
      );
      // Continue even if URL tests fail - may be due to missing test data
    }

    console.log("\n========== FILE_API.md doc test completed ==========");
  } catch (error) {
    console.error("[ERROR] FILE_API.md 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 {
    // Cleanup: delete test collection if created
    if (pb && testCollectionName) {
      try {
        await pb.collections.delete(testCollectionName);
        console.log(`[CLEANUP] Deleted test collection: ${testCollectionName}`);
      } catch (cleanupError) {
        console.warn(
          "[CLEANUP] Failed to delete test collection:",
          cleanupError?.message || cleanupError,
        );
      }
    }
  }
}

main();