@intuned/browser-dev 0.1.4-dev.0

package/dist/helpers/types/Attachment.js

@@ -0,0 +1,115 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SignedUrlAttachmentSchema = exports.SignedUrlAttachment = exports.AttachmentTypeSchema = exports.AttachmentSchema = 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");
+var _zod = require("zod");
+const AttachmentTypeSchema = exports.AttachmentTypeSchema = _zod.z.literal("document");
+const AttachmentSchema = exports.AttachmentSchema = _zod.z.object({
+  fileName: _zod.z.string(),
+  bucket: _zod.z.string(),
+  region: _zod.z.string(),
+  suggestedFileName: _zod.z.string(),
+  endpoint: _zod.z.string().optional(),
+  fileType: AttachmentTypeSchema.optional()
+});
+class Attachment {
+  constructor(fileName, bucket, region, suggestedFileName, endpoint, fileType) {
+    const validatedData = AttachmentSchema.parse({
+      fileName,
+      bucket,
+      region,
+      suggestedFileName,
+      endpoint,
+      fileType
+    });
+    this.fileName = validatedData.fileName;
+    this.bucket = validatedData.bucket;
+    this.region = validatedData.region;
+    this.suggestedFileName = validatedData.suggestedFileName;
+    this.endpoint = validatedData.endpoint;
+    this.fileType = validatedData.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) {
+    const validatedData = AttachmentSchema.parse(data);
+    return new Attachment(validatedData.fileName, validatedData.bucket, validatedData.region, validatedData.suggestedFileName, validatedData.endpoint, validatedData.fileType);
+  }
+  async getSignedUrl(expiration = 3600 * 24 * 5) {
+    if ((0, _utils.isGenerateCodeMode)()) {
+      return "https://not.real.com";
+    }
+    const s3Client = (0, _getS3Client.getS3Client)(this.endpoint, this.region);
+    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;
+const SignedUrlAttachmentSchema = exports.SignedUrlAttachmentSchema = AttachmentSchema.extend({
+  downloadSignedUrl: _zod.z.string().url()
+});
+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);
+    const validatedUrl = _zod.z.string().url().parse(downloadSignedUrl);
+    super(key, bucket, "", suggestedFileName ?? fileName);
+    this.downloadSignedUrl = validatedUrl;
+  }
+  async getSignedUrl() {
+    return this.downloadSignedUrl;
+  }
+  toDict() {
+    return {
+      ...super.toDict(),
+      downloadSignedUrl: this.downloadSignedUrl
+    };
+  }
+  static fromDict(data) {
+    const validatedData = SignedUrlAttachmentSchema.parse(data);
+    const attachment = new SignedUrlAttachment(validatedData.fileName, validatedData.downloadSignedUrl, validatedData.suggestedFileName);
+    return attachment;
+  }
+}
+exports.SignedUrlAttachment = SignedUrlAttachment;

package/dist/helpers/types/CustomTypeRegistry.js

@@ -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

@@ -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

@@ -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

@@ -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

@@ -0,0 +1,154 @@
+"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 => {
+  const {
+    file,
+    configs,
+    fileNameOverride,
+    contentType
+  } = input;
+  const bucketName = (configs === null || configs === void 0 ? void 0 : configs.bucket) ?? process.env.AWS_BUCKET ?? process.env.INTUNED_S3_BUCKET ?? undefined;
+  const region = (configs === null || configs === void 0 ? void 0 : configs.region) ?? process.env.AWS_REGION ?? process.env.INTUNED_S3_REGION ?? undefined;
+  const endpoint = (configs === null || configs === void 0 ? void 0 : configs.endpoint) ?? process.env.AWS_ENDPOINT_URL ?? process.env.INTUNED_S3_ENDPOINT_URL;
+  const accessKeyId = (configs === null || configs === void 0 ? void 0 : configs.accessKeyId) ?? process.env.AWS_ACCESS_KEY_ID ?? process.env.INTUNED_S3_ACCESS_KEY_ID;
+  const secretAccessKey = (configs === null || configs === void 0 ? void 0 : configs.secretAccessKey) ?? process.env.AWS_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, "document");
+    }
+  }
+  let suggestedFileName;
+  if (isDownloadedFile) {
+    suggestedFileName = file.suggestedFilename();
+  }
+  const fileName = 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,
+      ContentType: contentType
+    });
+    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

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

package/dist/helpers/utils/index.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "GatewayFactory", {
+  enumerable: true,
+  get: function () {
+    return _factory.GatewayFactory;
+  }
+});
+Object.defineProperty(exports, "compressStringSpaces", {
+  enumerable: true,
+  get: function () {
+    return _extractionHelpers.compressStringSpaces;
+  }
+});
+Object.defineProperty(exports, "ensureBrowserScripts", {
+  enumerable: true,
+  get: function () {
+    return _ensureBrowserScripts.ensureBrowserScripts;
+  }
+});
+Object.defineProperty(exports, "getS3Client", {
+  enumerable: true,
+  get: function () {
+    return _getS3Client.getS3Client;
+  }
+});
+Object.defineProperty(exports, "getSimplifiedHtml", {
+  enumerable: true,
+  get: function () {
+    return _getSimplifiedHtml.getSimplifiedHtml;
+  }
+});
+Object.defineProperty(exports, "isDownload", {
+  enumerable: true,
+  get: function () {
+    return _isDownload.isDownload;
+  }
+});
+Object.defineProperty(exports, "isGenerateCodeMode", {
+  enumerable: true,
+  get: function () {
+    return _isGenerateCodeMode.isGenerateCodeMode;
+  }
+});
+Object.defineProperty(exports, "isLocator", {
+  enumerable: true,
+  get: function () {
+    return _isLocator.isLocator;
+  }
+});
+Object.defineProperty(exports, "selectLocatorsUsingXpath", {
+  enumerable: true,
+  get: function () {
+    return _extractionHelpers.selectLocatorsUsingXpath;
+  }
+});
+Object.defineProperty(exports, "splitContainerIntoListLocators", {
+  enumerable: true,
+  get: function () {
+    return _extractionHelpers.splitContainerIntoListLocators;
+  }
+});
+var _isLocator = require("./isLocator");
+var _isGenerateCodeMode = require("./isGenerateCodeMode");
+var _factory = require("../../intunedServices/ApiGateway/factory");
+var _getS3Client = require("./getS3Client");
+var _isDownload = require("./isDownload");
+var _ensureBrowserScripts = require("../../common/ensureBrowserScripts");
+var _extractionHelpers = require("../../common/extractionHelpers");
+var _getSimplifiedHtml = require("../../common/getSimplifiedHtml");

package/dist/helpers/utils/isDownload.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isDownload = isDownload;
+function isDownload(value) {
+  const anyValue = value;
+  return anyValue && typeof anyValue.delete === "function" && typeof anyValue.path === "function" && typeof anyValue.suggestedFilename === "function";
+}

package/dist/helpers/utils/isGenerateCodeMode.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isGenerateCodeMode = isGenerateCodeMode;
+function isGenerateCodeMode() {
+  return process.env.MODE === "generate_code";
+}

package/dist/helpers/utils/isLocator.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isLocator = isLocator;
+function isLocator(locator) {
+  return "count" in locator && typeof locator.count === "function";
+}

package/dist/helpers/utils/jwtTokenManager.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "backendFunctionsTokenManager", {
+  enumerable: true,
+  get: function () {
+    return _jwtTokenManager.backendFunctionsTokenManager;
+  }
+});
+Object.defineProperty(exports, "callBackendFunctionWithToken", {
+  enumerable: true,
+  get: function () {
+    return _jwtTokenManager.callBackendFunctionWithToken;
+  }
+});
+var _jwtTokenManager = require("@intuned/runtime/dist/common/jwtTokenManager");

package/dist/helpers/validateDataUsingSchema.js

@@ -0,0 +1,103 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateDataUsingSchema = void 0;
+var _ajv = _interopRequireDefault(require("ajv"));
+var _types = require("./types");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const ajv = new _ajv.default({
+  strict: false,
+  removeAdditional: false
+});
+ajv.addKeyword({
+  keyword: "x-custom-type",
+  schemaType: "string",
+  compile: () => () => true
+});
+const customTypeRegistry = new _types.CustomTypeRegistry();
+function preprocessSchema(schema) {
+  if (typeof schema !== "object" || schema === null) {
+    return schema;
+  }
+  if (Array.isArray(schema)) {
+    return schema.map(item => preprocessSchema(item));
+  }
+  const processedSchema = {
+    ...schema
+  };
+  if (processedSchema.type && typeof processedSchema.type === "string") {
+    if (customTypeRegistry.isCustomType(processedSchema.type)) {
+      return {
+        type: "object",
+        additionalProperties: true,
+        "x-custom-type": processedSchema.type
+      };
+    }
+  }
+  for (const key in processedSchema) {
+    if (key === "properties" && typeof processedSchema[key] === "object") {
+      const newProperties = {};
+      for (const propKey in processedSchema[key]) {
+        newProperties[propKey] = preprocessSchema(processedSchema[key][propKey]);
+      }
+      processedSchema[key] = newProperties;
+    } else if (key === "items") {
+      processedSchema[key] = preprocessSchema(processedSchema[key]);
+    } else if (typeof processedSchema[key] === "object") {
+      processedSchema[key] = preprocessSchema(processedSchema[key]);
+    }
+  }
+  return processedSchema;
+}
+function validateCustomTypes(data, schema, path = "root") {
+  const errors = [];
+  if (typeof schema !== "object" || schema === null) {
+    return errors;
+  }
+  if (schema["x-custom-type"]) {
+    const customType = schema["x-custom-type"];
+    if (!customTypeRegistry.validate(customType, data)) {
+      errors.push(`${path} does not match custom type '${customType}'`);
+    }
+    return errors;
+  }
+  if (schema.type === "object" && schema.properties && typeof data === "object" && data !== null && !Array.isArray(data)) {
+    for (const [propKey, propSchema] of Object.entries(schema.properties)) {
+      if (Object.prototype.hasOwnProperty.call(data, propKey)) {
+        const propPath = path === "root" ? propKey : `${path}.${propKey}`;
+        errors.push(...validateCustomTypes(data[propKey], propSchema, propPath));
+      }
+    }
+  }
+  if (schema.type === "array" && schema.items && Array.isArray(data)) {
+    data.forEach((item, index) => {
+      const itemPath = `${path}[${index}]`;
+      errors.push(...validateCustomTypes(item, schema.items, itemPath));
+    });
+  }
+  return errors;
+}
+const validateDataUsingSchema = async input => {
+  const {
+    data,
+    schema
+  } = input;
+  const processedSchema = preprocessSchema(schema);
+  const validate = ajv.compile(processedSchema);
+  const valid = validate(data);
+  const errors = [];
+  if (!valid) {
+    var _validate$errors;
+    const schemaErrors = ((_validate$errors = validate.errors) === null || _validate$errors === void 0 ? void 0 : _validate$errors.map(err => `${err.instancePath || "root"} ${err.message}`).filter(error => !error.includes("x-custom-type"))) || [];
+    errors.push(...schemaErrors);
+  }
+  const customTypeErrors = validateCustomTypes(data, processedSchema);
+  errors.push(...customTypeErrors);
+  if (errors.length > 0) {
+    const errorMessage = errors.join(", ") || "Unknown validation error";
+    throw new _types.ValidationError(`Data validation failed: ${errorMessage}`, data);
+  }
+};
+exports.validateDataUsingSchema = validateDataUsingSchema;