npm - @intuned/browser-dev - Versions diffs - 2.2.3-unify-sdks.20 - Mend

@intuned/browser-dev 2.2.3-unify-sdks.20

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (195) hide show

package/dist/helpers/tests/testWaitForDomSettled.spec.js ADDED Viewed

@@ -0,0 +1,169 @@
+"use strict";
+var _extendedTest = require("./extendedTest");
+var _ = require("..");
+var _playwrightCore = require("playwright-core");
+var _waitForDomSettled = require("../waitForDomSettled");
+(0, _extendedTest.describe)("Test waitForDomSettled", () => {
+  let browser;
+  let page;
+  (0, _extendedTest.beforeAll)(async () => {
+    browser = await _playwrightCore.chromium.launch({
+      headless: false
+    });
+  });
+  (0, _extendedTest.afterAll)(async () => {
+    await browser.close();
+  });
+  (0, _extendedTest.beforeEach)(async () => {
+    page = await browser.newPage();
+  });
+  (0, _extendedTest.afterEach)(async () => {
+    await page.close();
+  });
+  (0, _extendedTest.test)("should wait for DOM to settle after navigation", async () => {
+    await page.goto("data:text/html,<html><body><div id='target'></div></body></html>");
+    await page.evaluate(() => {
+      const intervalId = setInterval(() => {
+        const target = document.getElementById("target");
+        const div = document.createElement("div");
+        div.textContent = String(Date.now());
+        target === null || target === void 0 || target.appendChild(div);
+        if (target && target.children.length > 10 && target.firstChild) {
+          target.removeChild(target.firstChild);
+        }
+      }, 100);
+      setTimeout(() => {
+        clearInterval(intervalId);
+      }, 5000);
+    });
+    const settled = await (0, _waitForDomSettled.waitForDomSettled)({
+      source: page,
+      settleDuration: 1,
+      timeoutS: 10
+    });
+    (0, _extendedTest.expect)(settled).toBe(true);
+  });
+  (0, _extendedTest.test)("should wait for specific element to settle while ignoring other mutations", async () => {
+    await page.goto(`
+      data:text/html,
+      <html>
+        <body>
+          <div id='watched-element'></div>
+          <div id='ignored-element'></div>
+        </body>
+      </html>
+    `);
+    await page.evaluate(() => {
+      const watchedElement = document.getElementById("watched-element");
+      const ignoredElement = document.getElementById("ignored-element");
+      const ignoredInterval = setInterval(() => {
+        const div = document.createElement("div");
+        div.textContent = `Ignored: ${Date.now()}`;
+        ignoredElement === null || ignoredElement === void 0 || ignoredElement.appendChild(div);
+        if (ignoredElement && ignoredElement.children.length > 5) {
+          ignoredElement.removeChild(ignoredElement.firstChild);
+        }
+      }, 50);
+      const watchedInterval = setInterval(() => {
+        const div = document.createElement("div");
+        div.textContent = `Watched: ${Date.now()}`;
+        watchedElement === null || watchedElement === void 0 || watchedElement.appendChild(div);
+        if (watchedElement && watchedElement.children.length > 3) {
+          watchedElement.removeChild(watchedElement.firstChild);
+        }
+      }, 200);
+      setTimeout(() => {
+        clearInterval(watchedInterval);
+      }, 3000);
+      setTimeout(() => {
+        clearInterval(ignoredInterval);
+      }, 15000);
+    });
+    const settled = await (0, _waitForDomSettled.waitForDomSettled)({
+      source: page.locator("#watched-element"),
+      settleDuration: 3,
+      timeoutS: 10
+    });
+    (0, _extendedTest.expect)(settled).toBe(true);
+  });
+  (0, _extendedTest.test)("should handle no mutations gracefully", async () => {
+    await page.goto("data:text/html,<html><body><div id='target'></div></body></html>");
+    const settled = await (0, _waitForDomSettled.waitForDomSettled)({
+      source: page.locator("#target"),
+      settleDuration: 1,
+      timeoutS: 10
+    });
+    (0, _extendedTest.expect)(settled).toBe(true);
+  });
+  (0, _extendedTest.test)("should wait for loading to be complete", async () => {
+    await (0, _.goToUrl)({
+      page,
+      url: "https://www.galvestoncountytx.gov/county-offices/purchasing/solicitations-bids",
+      waitForLoadingStateUsingAi: false
+    });
+    const settled = await (0, _waitForDomSettled.waitForDomSettled)({
+      source: page,
+      settleDuration: 1,
+      timeoutS: 10
+    });
+    const loading = await page.getByText("Loading...").isVisible();
+    (0, _extendedTest.expect)(loading).toBe(false);
+  });
+  (0, _extendedTest.test)("should work as a simple decorator", async () => {
+    await page.goto("data:text/html,<html><body><div id='target'></div></body></html>");
+    const decoratedFunction = (0, _waitForDomSettled.waitForDomSettled)(async page => {
+      await page.evaluate(() => {
+        const target = document.getElementById("target");
+        const div = document.createElement("div");
+        div.textContent = "Added content";
+        target === null || target === void 0 || target.appendChild(div);
+      });
+      return "function executed";
+    });
+    const result = await decoratedFunction(page);
+    (0, _extendedTest.expect)(result).toBe("function executed");
+    const content = await page.textContent("#target");
+    (0, _extendedTest.expect)(content).toContain("Added content");
+  });
+  (0, _extendedTest.test)("should work as a parameterized decorator", async () => {
+    await page.goto("data:text/html,<html><body><div id='target'></div></body></html>");
+    const decoratedFunction = (0, _waitForDomSettled.waitForDomSettled)({
+      settleDuration: 2,
+      timeoutS: 30
+    })(async page => {
+      await page.evaluate(() => {
+        const target = document.getElementById("target");
+        const div = document.createElement("div");
+        div.textContent = "Parameterized decorator content";
+        target === null || target === void 0 || target.appendChild(div);
+      });
+      return "parameterized function executed";
+    });
+    const result = await decoratedFunction(page);
+    (0, _extendedTest.expect)(result).toBe("parameterized function executed");
+    const content = await page.textContent("#target");
+    (0, _extendedTest.expect)(content).toContain("Parameterized decorator content");
+  });
+  (0, _extendedTest.test)("should work with direct function call", async () => {
+    await page.goto("data:text/html,<html><body><div id='target'></div></body></html>");
+    const testFunction = async () => {
+      await page.evaluate(() => {
+        const target = document.getElementById("target");
+        const div = document.createElement("div");
+        div.textContent = "Direct call content";
+        target === null || target === void 0 || target.appendChild(div);
+      });
+      return "direct call executed";
+    };
+    const result = await (0, _waitForDomSettled.waitForDomSettled)({
+      source: page,
+      func: testFunction,
+      settleDuration: 1,
+      timeoutS: 30
+    });
+    (0, _extendedTest.expect)(result).toBe("direct call executed");
+    const content = await page.textContent("#target");
+    (0, _extendedTest.expect)(content).toContain("Direct call content");
+  });
+});

package/dist/helpers/tests/testWaitForNetworkIdle.spec.js ADDED Viewed

@@ -0,0 +1,115 @@
+"use strict";
+var _extendedTest = require("./extendedTest");
+var _playwright = require("playwright");
+var _ = require("..");
+(0, _extendedTest.describe)("TestWaitForNetworkIdle", () => {
+  let browser;
+  let page;
+  (0, _extendedTest.beforeEach)(async () => {
+    browser = await _playwright.chromium.launch({
+      headless: false
+    });
+    page = await browser.newPage();
+  });
+  (0, _extendedTest.afterEach)(async () => {
+    await browser.close();
+  });
+  (0, _extendedTest.test)("wait for network idle click element 1", async () => {
+    const clickElement = (0, _.waitForNetworkIdle)({
+      timeoutInMs: 10000
+    })(async (page, selector, timeoutInMs = 10000) => {
+      await page.locator(selector).first().click({
+        timeout: timeoutInMs
+      });
+    });
+    await page.goto("https://www.txsmartbuy.gov/esbd?");
+    await page.waitForTimeout(10000);
+    await clickElement(page, "xpath=(//*[@id='Next'])[1]", 10000);
+    const currentPage = await page.locator("[aria-label='Current Page']").first().textContent();
+    (0, _extendedTest.expect)(currentPage).toBe("2");
+  });
+  (0, _extendedTest.test)("wait for network idle click element 2", async () => {
+    const clickElement = (0, _.waitForNetworkIdle)({
+      timeoutInMs: 10000
+    })(async (page, selector, timeoutInMs = 10000) => {
+      await page.locator(selector).first().click({
+        timeout: timeoutInMs
+      });
+    });
+    await page.goto("https://www.biddingo.com/soundtransit", {
+      timeout: 0
+    });
+    await page.waitForTimeout(3000);
+    await clickElement(page, "[aria-label='Next page']", 10000);
+    const currentPage = await page.locator(".mat-paginator-range-label").first().textContent();
+    (0, _extendedTest.expect)(currentPage).toContain("11");
+  });
+  (0, _extendedTest.test)("wait for network idle press key combination", async () => {
+    const pressKeyCombination = (0, _.waitForNetworkIdle)({
+      timeoutInMs: 10000
+    })(async (page, keyCombination, timeoutInMs = 10000) => {
+      await page.keyboard.press(keyCombination);
+    });
+    await page.goto("https://www.txsmartbuy.gov/esbd?&page=3");
+    await page.waitForTimeout(10000);
+    await page.click("input[name='agencyNumber']");
+    await pressKeyCombination(page, "Enter", 10000);
+    const currentPage = await page.locator("[aria-label='Current Page']").first().textContent();
+    (0, _extendedTest.expect)(currentPage).toBe("1");
+  });
+  (0, _extendedTest.test)("wait for network idle enter text and click", async () => {
+    const enterTextAndClick = (0, _.waitForNetworkIdle)({
+      timeoutInMs: 10000
+    })(async (page, textSelector, clickSelector, text, timeoutInMs = 10000) => {
+      await page.fill(textSelector, text);
+      await page.click(clickSelector);
+    });
+    await page.goto("https://www.txsmartbuy.gov/esbd?&page=3", {
+      timeout: 20000
+    });
+    await page.waitForTimeout(10000);
+    await enterTextAndClick(page, "input[name='agencyNumber']", "#content > div > div > form > div.browse-contract-search-actions [type='submit']", "123456", 10000);
+    await page.getByText("No results found", {
+      exact: false
+    }).first().textContent();
+  });
+  (0, _extendedTest.test)("wait for click element 3", async () => {
+    const clickElement = (0, _.waitForNetworkIdle)({
+      timeoutInMs: 20000
+    })(async (page, selector, timeoutInMs = 10000) => {
+      await page.locator(selector).first().click({
+        timeout: timeoutInMs
+      });
+    });
+    await page.goto("https://www.commbuys.com/bso/view/search/external/advancedSearchBid.xhtml");
+    await page.waitForTimeout(4000);
+    await clickElement(page, "#bidSearchForm\\:btnBidSearch", 10000);
+    (0, _extendedTest.expect)(await page.locator("[aria-label='Page 1']").first().isVisible()).toBe(true);
+  });
+  (0, _extendedTest.test)("simple decorator usage", async () => {
+    const decoratedFunction = (0, _.waitForNetworkIdle)(async page => {
+      await page.goto("data:text/html,<html><body><h1>Test</h1></body></html>");
+      return "navigation complete";
+    });
+    const result = await decoratedFunction(page);
+    (0, _extendedTest.expect)(result).toBe("navigation complete");
+    const title = await page.textContent("h1");
+    (0, _extendedTest.expect)(title).toBe("Test");
+  });
+  (0, _extendedTest.test)("direct call with page and function", async () => {
+    const testFunction = async () => {
+      await page.goto("data:text/html,<html><body><h1>Direct Call</h1></body></html>");
+      return "direct call complete";
+    };
+    const result = await (0, _.waitForNetworkIdle)({
+      page: page,
+      func: testFunction,
+      timeoutInMs: 10000,
+      maxInflightRequests: 0
+    });
+    (0, _extendedTest.expect)(result).toBe("direct call complete");
+    const title = await page.textContent("h1");
+    (0, _extendedTest.expect)(title).toBe("Direct Call");
+  });
+});

package/dist/helpers/types/Attachment.js ADDED Viewed

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SignedUrlAttachment = exports.Attachment = void 0;
+var _clientS = require("@aws-sdk/client-s3");
+var _s3RequestPresigner = require("@aws-sdk/s3-request-presigner");
+var _utils = require("../utils");
+var _getS3Client = require("../utils/getS3Client");
+class Attachment {
+  constructor(fileName, bucket, region, suggestedFileName, endpoint, fileType) {
+    this.fileName = fileName;
+    this.bucket = bucket;
+    this.region = region;
+    this.suggestedFileName = suggestedFileName;
+    this.endpoint = endpoint;
+    this.fileType = fileType;
+  }
+  toJSON() {
+    return this.toDict();
+  }
+  toDict() {
+    return {
+      fileName: this.fileName,
+      bucket: this.bucket,
+      region: this.region,
+      suggestedFileName: this.suggestedFileName,
+      ...(this.endpoint ? {
+        endpoint: this.endpoint
+      } : {}),
+      ...(this.fileType ? {
+        fileType: this.fileType
+      } : {})
+    };
+  }
+  static fromDict(data) {
+    return new Attachment(data.fileName, data.bucket, data.region, data.suggestedFileName, data.endpoint, data.fileType);
+  }
+  async getSignedUrl(expiration = 3600 * 24 * 5) {
+    if ((0, _utils.isGenerateCodeMode)()) {
+      return "https://not.real.com";
+    }
+    const s3Client = (0, _getS3Client.getS3Client)(this.endpoint);
+    try {
+      const response = await (0, _s3RequestPresigner.getSignedUrl)(s3Client, new _clientS.GetObjectCommand({
+        Bucket: this.bucket,
+        Key: this.fileName
+      }), {
+        expiresIn: expiration
+      });
+      return response;
+    } catch (error) {
+      console.log(error);
+      throw new Error("Error generating signed URL");
+    }
+  }
+  getS3Key() {
+    return `https://${this.bucket}.s3.${this.region}.amazonaws.com/${this.fileName}`;
+  }
+  getFilePath() {
+    return this.fileName;
+  }
+  getFileType() {
+    return this.fileType || "";
+  }
+}
+exports.Attachment = Attachment;
+class SignedUrlAttachment extends Attachment {
+  constructor(fileName, downloadSignedUrl, suggestedFileName) {
+    const url = new URL(downloadSignedUrl);
+    const bucket = url.hostname.split(".")[0];
+    const key = url.pathname.substring(1);
+    super(key, bucket, "", suggestedFileName ?? fileName);
+    this.downloadSignedUrl = downloadSignedUrl;
+  }
+  async getSignedUrl() {
+    return this.downloadSignedUrl;
+  }
+}
+exports.SignedUrlAttachment = SignedUrlAttachment;

package/dist/helpers/types/CustomTypeRegistry.js ADDED Viewed

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CustomTypeRegistry = exports.AttachmentValidator = void 0;
+class AttachmentValidator {
+  validate(data) {
+    if (!data || typeof data !== "object") {
+      return false;
+    }
+    const requiredFields = ["fileName", "bucket", "region", "suggestedFileName"];
+    return requiredFields.every(field => field in data && typeof data[field] === "string" && data[field].length > 0);
+  }
+  getName() {
+    return "attachment";
+  }
+}
+exports.AttachmentValidator = AttachmentValidator;
+class CustomTypeRegistry {
+  registry = new Map();
+  constructor(registerIntunedTypes = true) {
+    if (registerIntunedTypes) {
+      this.registerIntunedTypes();
+    }
+  }
+  registerIntunedTypes() {
+    this.register(new AttachmentValidator());
+  }
+  register(validator) {
+    const typeName = validator.getName().toLowerCase();
+    this.registry.set(typeName, validator);
+  }
+  get(typeName) {
+    return this.registry.get(typeName.toLowerCase());
+  }
+  isCustomType(typeName) {
+    return this.registry.has(typeName.toLowerCase());
+  }
+  validate(typeName, data) {
+    const validator = this.get(typeName);
+    return validator ? validator.validate(data) : false;
+  }
+  getAllTypes() {
+    return Array.from(this.registry.keys());
+  }
+}
+exports.CustomTypeRegistry = CustomTypeRegistry;

package/dist/helpers/types/RunEnvironment.js ADDED Viewed

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RunType = exports.RunEnvironment = void 0;
+let RunEnvironment = exports.RunEnvironment = function (RunEnvironment) {
+  RunEnvironment["IDE"] = "IDE";
+  RunEnvironment["DEPLOYED"] = "DEPLOYED";
+  return RunEnvironment;
+}({});
+let RunType = exports.RunType = function (RunType) {
+  RunType["SYNC"] = "SYNC";
+  RunType["ASYNC"] = "ASYNC";
+  RunType["JOB"] = "JOB";
+  RunType["QUEUE"] = "QUEUE";
+  return RunType;
+}({});

package/dist/helpers/types/ValidationError.js ADDED Viewed

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ValidationError = void 0;
+class ValidationError extends Error {
+  constructor(message, data) {
+    super(message);
+    this.name = "ValidationError";
+    this.data = data;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, ValidationError);
+    }
+  }
+}
+exports.ValidationError = ValidationError;

package/dist/helpers/types/index.js ADDED Viewed

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Attachment", {
+  enumerable: true,
+  get: function () {
+    return _Attachment.Attachment;
+  }
+});
+Object.defineProperty(exports, "AttachmentValidator", {
+  enumerable: true,
+  get: function () {
+    return _CustomTypeRegistry.AttachmentValidator;
+  }
+});
+Object.defineProperty(exports, "CustomTypeRegistry", {
+  enumerable: true,
+  get: function () {
+    return _CustomTypeRegistry.CustomTypeRegistry;
+  }
+});
+Object.defineProperty(exports, "CustomTypeValidator", {
+  enumerable: true,
+  get: function () {
+    return _CustomTypeRegistry.CustomTypeValidator;
+  }
+});
+Object.defineProperty(exports, "RunEnvironment", {
+  enumerable: true,
+  get: function () {
+    return _RunEnvironment.RunEnvironment;
+  }
+});
+Object.defineProperty(exports, "RunType", {
+  enumerable: true,
+  get: function () {
+    return _RunEnvironment.RunType;
+  }
+});
+Object.defineProperty(exports, "ValidationError", {
+  enumerable: true,
+  get: function () {
+    return _ValidationError.ValidationError;
+  }
+});
+var _ValidationError = require("./ValidationError");
+var _RunEnvironment = require("./RunEnvironment");
+var _Attachment = require("./Attachment");
+var _CustomTypeRegistry = require("./CustomTypeRegistry");

package/dist/helpers/uploadFileToS3.js ADDED Viewed

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.uploadFileToS3 = void 0;
+var _fsExtra = require("fs-extra");
+var _clientS = require("@aws-sdk/client-s3");
+var _Attachment = require("../helpers/types/Attachment");
+var _uuid = require("uuid");
+var _utils = require("./utils");
+var _fs = _interopRequireDefault(require("fs"));
+var _jwtTokenManager = require("../common/jwtTokenManager");
+var _zod = _interopRequireDefault(require("zod"));
+var _nodeFetch = _interopRequireDefault(require("node-fetch"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function sanitizeKey(key) {
+  let result = key.replace(/[^a-zA-Z0-9.\-_/]/g, "_");
+  result = result.replace(/_{2,}/g, "_");
+  return result;
+}
+const stringToJSONSchema = _zod.default.string().transform((str, ctx) => {
+  try {
+    return JSON.parse(str);
+  } catch (e) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Invalid JSON"
+    });
+    return _zod.default.NEVER;
+  }
+});
+const getUploadSignedUrlResponseSchema = stringToJSONSchema.pipe(_zod.default.object({
+  id: _zod.default.string().uuid(),
+  writeSignedUrl: _zod.default.string().url(),
+  readSignedUrl: _zod.default.string().url()
+}));
+const uploadFileToS3 = async input => {
+  var _configs$s3Configs, _configs$s3Configs2, _configs$s3Configs3, _configs$s3Configs4, _configs$s3Configs5;
+  const {
+    file,
+    configs
+  } = input;
+  const bucketName = (configs === null || configs === void 0 || (_configs$s3Configs = configs.s3Configs) === null || _configs$s3Configs === void 0 ? void 0 : _configs$s3Configs.bucket) ?? process.env.S3_BUCKET ?? process.env.INTUNED_S3_BUCKET ?? undefined;
+  const region = (configs === null || configs === void 0 || (_configs$s3Configs2 = configs.s3Configs) === null || _configs$s3Configs2 === void 0 ? void 0 : _configs$s3Configs2.region) ?? process.env.S3_REGION ?? process.env.INTUNED_S3_REGION ?? undefined;
+  const endpoint = (configs === null || configs === void 0 || (_configs$s3Configs3 = configs.s3Configs) === null || _configs$s3Configs3 === void 0 ? void 0 : _configs$s3Configs3.endpoint) ?? process.env.S3_ENDPOINT_URL ?? process.env.INTUNED_S3_ENDPOINT_URL;
+  const accessKeyId = (configs === null || configs === void 0 || (_configs$s3Configs4 = configs.s3Configs) === null || _configs$s3Configs4 === void 0 ? void 0 : _configs$s3Configs4.accessKeyId) ?? process.env.S3_ACCESS_KEY_ID ?? process.env.INTUNED_S3_ACCESS_KEY_ID;
+  const secretAccessKey = (configs === null || configs === void 0 || (_configs$s3Configs5 = configs.s3Configs) === null || _configs$s3Configs5 === void 0 ? void 0 : _configs$s3Configs5.secretAccessKey) ?? process.env.S3_SECRET_ACCESS_KEY ?? process.env.INTUNED_S3_SECRET_ACCESS_KEY;
+  const isDownloadedFile = (0, _utils.isDownload)(file);
+  if ((0, _utils.isGenerateCodeMode)()) {
+    console.log("Uploaded file successfully");
+    if (isDownloadedFile) {
+      return new _Attachment.Attachment(`${(0, _uuid.v4)()}/${file.suggestedFilename()}`, "testing_bucket", "testing_region", file.suggestedFilename() || "downloaded_file", endpoint);
+    }
+  }
+  let suggestedFileName;
+  if (isDownloadedFile) {
+    suggestedFileName = file.suggestedFilename();
+  }
+  console.log(`suggested_file_name ${suggestedFileName}`);
+  const fileName = (configs === null || configs === void 0 ? void 0 : configs.fileNameOverride) ?? suggestedFileName ?? (0, _uuid.v4)();
+  const fileBody = await getFileBody(file);
+  if (!region || !bucketName) {
+    return await uploadToIntuned({
+      name: fileName,
+      suggestedName: suggestedFileName || fileName,
+      body: fileBody
+    });
+  }
+  if (isDownloadedFile && !(0, _utils.isGenerateCodeMode)() && !(await file.path())) {
+    throw new Error("File path not found");
+  }
+  let credentials = undefined;
+  if (accessKeyId && secretAccessKey) {
+    credentials = {
+      accessKeyId,
+      secretAccessKey
+    };
+  }
+  const s3Client = new _clientS.S3Client({
+    region,
+    endpoint,
+    credentials
+  });
+  try {
+    const cleanedFileName = sanitizeKey(fileName);
+    const key = `${(0, _uuid.v4)()}/${cleanedFileName}`;
+    const command = new _clientS.PutObjectCommand({
+      Bucket: bucketName,
+      Key: key,
+      Body: fileBody
+    });
+    const response = await s3Client.send(command);
+    if (response.$metadata.httpStatusCode === 200) {
+      return new _Attachment.Attachment(key, bucketName, region, suggestedFileName || fileName, endpoint);
+    } else {
+      throw new Error("Error uploading file");
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Credentials")) {
+      throw new Error("Credentials not available");
+    }
+    throw new Error(`Error uploading file: ${error instanceof Error ? error.message : String(error)}`);
+  } finally {
+    if (isDownloadedFile) {
+      var _file$delete;
+      await ((_file$delete = file.delete) === null || _file$delete === void 0 ? void 0 : _file$delete.call(file));
+    }
+    if (typeof file === "string") {
+      try {
+        _fs.default.unlinkSync(file);
+      } catch (e) {}
+    }
+  }
+};
+exports.uploadFileToS3 = uploadFileToS3;
+async function getFileBody(file) {
+  if ((0, _utils.isDownload)(file)) {
+    const filePath = await file.path();
+    if (!filePath) {
+      throw new Error("Downloaded file path not found");
+    }
+    return (0, _fsExtra.readFile)(filePath);
+  } else if (Buffer.isBuffer(file)) {
+    return file;
+  } else {
+    throw new Error("Invalid file type");
+  }
+}
+async function uploadToIntuned({
+  name,
+  suggestedName,
+  body
+}) {
+  const uploadInfoResponse = await (0, _jwtTokenManager.callBackendFunctionWithToken)("files/uploadSignedUrls");
+  if (!uploadInfoResponse.ok) {
+    throw new Error(`Failed to get upload signed URL: ${uploadInfoResponse.statusText}`);
+  }
+  const uploadInfoText = await uploadInfoResponse.text();
+  const uploadInfo = getUploadSignedUrlResponseSchema.parse(uploadInfoText);
+  const uploadResponse = await (0, _nodeFetch.default)(uploadInfo.writeSignedUrl, {
+    method: "PUT",
+    body: await getFileBody(body),
+    headers: {
+      "Content-Type": "application/octet-stream"
+    }
+  });
+  const uploadResponseText = await uploadResponse.text();
+  if (!uploadResponse.ok) {
+    throw new Error(`Failed to upload file: ${uploadResponse.status} - ${uploadResponseText}`);
+  }
+  return new _Attachment.SignedUrlAttachment(name, uploadInfo.readSignedUrl, suggestedName);
+}

package/dist/helpers/utils/getS3Client.js ADDED Viewed

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getS3Client = getS3Client;
+var _clientS = require("@aws-sdk/client-s3");
+let s3ClientInstance = null;
+function getS3Client(endpoint) {
+  if (!s3ClientInstance) {
+    s3ClientInstance = new _clientS.S3Client({
+      region: process.env.S3_REGION,
+      credentials: {
+        accessKeyId: process.env.S3_ACCESS_KEY_ID || "",
+        secretAccessKey: process.env.S3_SECRET_ACCESS_KEY || ""
+      },
+      endpoint: endpoint || undefined
+    });
+  }
+  return s3ClientInstance;
+}