@intuned/browser-dev 0.1.4-dev.1 → 0.1.5-dev.1

package/dist/helpers/tests/testValidateDataUsingSchema.spec.js

@@ -23,10 +23,10 @@ var _extendedTest = require("../../common/extendedTest");
         age: 30,
         extra_field: "allowed"
       };
-      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
         data,
         schema
-      })).resolves.not.toThrow();
+      })).not.toThrow();
     });
     (0, _extendedTest.test)("should validate data using schema with invalid data (missing required field)", async () => {
       const schema = {
@@ -44,12 +44,12 @@ var _extendedTest = require("../../common/extendedTest");
       const invalidData = {
         name: "John Doe"
       };
-      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
         data: invalidData,
         schema
-      })).rejects.toThrow(_types.ValidationError);
+      })).toThrow(_types.ValidationError);
       try {
-        await (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        (0, _validateDataUsingSchema.validateDataUsingSchema)({
           data: invalidData,
           schema
         });
@@ -84,10 +84,10 @@ var _extendedTest = require("../../common/extendedTest");
         age: 25,
         other: "value"
       }];
-      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
         data,
         schema
-      })).resolves.not.toThrow();
+      })).not.toThrow();
     });
     (0, _extendedTest.test)("should validate data using schema with list containing invalid object", async () => {
       const schema = {
@@ -112,12 +112,12 @@ var _extendedTest = require("../../common/extendedTest");
         name: "Jane Doe",
         age: "25"
       }];
-      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
         data: invalidData,
         schema
-      })).rejects.toThrow(_types.ValidationError);
+      })).toThrow(_types.ValidationError);
       try {
-        await (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        (0, _validateDataUsingSchema.validateDataUsingSchema)({
           data: invalidData,
           schema
         });
@@ -128,7 +128,7 @@ var _extendedTest = require("../../common/extendedTest");
         (0, _extendedTest.expect)(error.data).toEqual(invalidData);
       }
     });
-    (0, _extendedTest.test)("should validate data using schema with attachment custom type", async () => {
+    (0, _extendedTest.test)("should validate data using schema with attachment type", async () => {
       const schema = {
         type: "object",
         properties: {
@@ -146,18 +146,19 @@ var _extendedTest = require("../../common/extendedTest");
           fileName: "documents/report.pdf",
           bucket: "my-bucket",
           region: "us-east-1",
+          key: "documents/report.pdf",
           endpoint: null,
           suggestedFileName: "Monthly Report.pdf",
           fileType: "document"
         },
         name: "Test File Upload"
       };
-      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
         data: validData,
         schema
-      })).resolves.not.toThrow();
+      })).not.toThrow();
     });
-    (0, _extendedTest.test)("should validate data using schema with invalid attachment custom type", async () => {
+    (0, _extendedTest.test)("should validate data using schema with invalid attachment type", async () => {
       const schema = {
         type: "object",
         properties: {
@@ -176,19 +177,18 @@ var _extendedTest = require("../../common/extendedTest");
         },
         name: "Test File Upload"
       };
-      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
         data: invalidData,
         schema
-      })).rejects.toThrow(_types.ValidationError);
+      })).toThrow(_types.ValidationError);
       try {
-        await (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        (0, _validateDataUsingSchema.validateDataUsingSchema)({
           data: invalidData,
           schema
         });
       } catch (error) {
         (0, _extendedTest.expect)(error).toBeInstanceOf(_types.ValidationError);
         (0, _extendedTest.expect)(error.message).toContain("Data validation failed");
-        (0, _extendedTest.expect)(error.message).toContain("does not match custom type 'attachment'");
         (0, _extendedTest.expect)(error.data).toEqual(invalidData);
       }
     });
@@ -213,6 +213,7 @@ var _extendedTest = require("../../common/extendedTest");
           fileName: "doc1.pdf",
           bucket: "bucket1",
           region: "us-east-1",
+          key: "files/doc1.pdf",
           suggestedFileName: "Document 1.pdf"
         },
         description: "First document"
@@ -221,14 +222,15 @@ var _extendedTest = require("../../common/extendedTest");
           fileName: "doc2.pdf",
           bucket: "bucket2",
           region: "us-west-2",
+          key: "files/doc2.pdf",
           suggestedFileName: "Document 2.pdf"
         },
         description: "Second document"
       }];
-      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
         data: validData,
         schema
-      })).resolves.not.toThrow();
+      })).not.toThrow();
     });
     (0, _extendedTest.test)("should validate data using schema with invalid attachment in array", async () => {
       const schema = {
@@ -251,6 +253,7 @@ var _extendedTest = require("../../common/extendedTest");
           fileName: "doc1.pdf",
           bucket: "bucket1",
           region: "us-east-1",
+          key: "files/doc1.pdf",
           suggestedFileName: "Document 1.pdf"
         },
         description: "First document"
@@ -260,23 +263,22 @@ var _extendedTest = require("../../common/extendedTest");
         },
         description: "Second document"
       }];
-      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
         data: invalidData,
         schema
-      })).rejects.toThrow(_types.ValidationError);
+      })).toThrow(_types.ValidationError);
       try {
-        await (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        (0, _validateDataUsingSchema.validateDataUsingSchema)({
           data: invalidData,
           schema
         });
       } catch (error) {
         (0, _extendedTest.expect)(error).toBeInstanceOf(_types.ValidationError);
         (0, _extendedTest.expect)(error.message).toContain("Data validation failed");
-        (0, _extendedTest.expect)(error.message).toContain("does not match custom type 'attachment'");
         (0, _extendedTest.expect)(error.data).toEqual(invalidData);
       }
     });
-    (0, _extendedTest.test)("should handle mixed custom and standard types", async () => {
+    (0, _extendedTest.test)("should handle mixed attachment and standard types", async () => {
       const schema = {
         type: "object",
         properties: {
@@ -300,31 +302,33 @@ var _extendedTest = require("../../common/extendedTest");
           fileName: "mixed-test.pdf",
           bucket: "test-bucket",
           region: "us-east-1",
+          key: "files/mixed-test.pdf",
           suggestedFileName: "Mixed Test.pdf"
         },
         title: "Mixed validation test",
         count: 42,
         active: true
       };
-      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
         data: validData,
         schema
-      })).resolves.not.toThrow();
+      })).not.toThrow();
       const invalidStandardData = {
         attachment: {
           fileName: "mixed-test.pdf",
           bucket: "test-bucket",
           region: "us-east-1",
+          key: "files/mixed-test.pdf",
           suggestedFileName: "Mixed Test.pdf"
         },
         title: "Mixed validation test",
         count: "not-a-number",
         active: true
       };
-      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
         data: invalidStandardData,
         schema
-      })).rejects.toThrow(_types.ValidationError);
+      })).toThrow(_types.ValidationError);
       const invalidCustomData = {
         attachment: {
           fileName: "mixed-test.pdf"
@@ -333,10 +337,10 @@ var _extendedTest = require("../../common/extendedTest");
         count: 42,
         active: true
       };
-      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
         data: invalidCustomData,
         schema
-      })).rejects.toThrow(_types.ValidationError);
+      })).toThrow(_types.ValidationError);
     });
   });
 });

package/dist/helpers/tests/testWithDomSettledWait.spec.js

@@ -161,4 +161,123 @@ var _waitForDomSettled = require("../waitForDomSettled");
     const content = await page.textContent("#target");
     (0, _extendedTest.expect)(content).toContain("Locator source content");
   });
+  (0, _extendedTest.test)("should wait for DOM to settle with iframe dynamic content", async () => {
+    await page.goto(`
+      data:text/html,
+      <html>
+        <body>
+          <h1>Main Page</h1>
+          <iframe id="test-iframe"
+                  src="data:text/html,<html><body><div id='iframe-content'>Initial content</div></body></html>"
+                  width="400"
+                  height="300">
+          </iframe>
+        </body>
+      </html>
+    `);
+    await page.waitForTimeout(500);
+    const iframeElement = await page.locator("#test-iframe").elementHandle();
+    const iframeFrame = await (iframeElement === null || iframeElement === void 0 ? void 0 : iframeElement.contentFrame());
+    if (!iframeFrame) {
+      throw new Error("Could not get iframe frame");
+    }
+    await iframeFrame.evaluate(() => {
+      let counter = 0;
+      const intervalId = setInterval(() => {
+        counter++;
+        const div = document.createElement("div");
+        div.textContent = `Dynamic content ${counter}`;
+        div.className = "dynamic-item";
+        document.body.appendChild(div);
+        if (counter >= 3) {
+          clearInterval(intervalId);
+        }
+      }, 200);
+    });
+    const settled = await (0, _waitForDomSettled.waitForDomSettled)({
+      source: page,
+      settleDurationMs: 1000,
+      timeoutInMs: 10000
+    });
+    (0, _extendedTest.expect)(settled).toBe(true);
+    const dynamicItems = await iframeFrame.locator(".dynamic-item").count();
+    (0, _extendedTest.expect)(dynamicItems).toBe(3);
+    for (let i = 0; i < 3; i++) {
+      const content = await iframeFrame.locator(".dynamic-item").nth(i).textContent();
+      (0, _extendedTest.expect)(content).toBe(`Dynamic content ${i + 1}`);
+    }
+  });
+  (0, _extendedTest.test)("should wait for DOM to settle with nested iframes", async () => {
+    await page.goto(`
+      data:text/html,
+      <html>
+        <body>
+          <h1>Main Page</h1>
+          <div id="main-content">Main content</div>
+          <iframe id="outer-iframe"
+                  src="data:text/html,<html><body><h2>Outer iframe</h2><div id='outer-content'>Outer initial</div><iframe id='inner-iframe' src='data:text/html,<html><body><h3>Inner iframe</h3><div id=inner-content>Inner initial</div></body></html>'></iframe></body></html>"
+                  width="500"
+                  height="400">
+          </iframe>
+        </body>
+      </html>
+    `);
+    await page.waitForTimeout(1000);
+    const outerIframeElement = await page.locator("#outer-iframe").elementHandle();
+    const outerFrame = await (outerIframeElement === null || outerIframeElement === void 0 ? void 0 : outerIframeElement.contentFrame());
+    if (!outerFrame) {
+      throw new Error("Could not get outer frame");
+    }
+    const innerIframeElement = await outerFrame.locator("#inner-iframe").elementHandle();
+    const innerFrame = await (innerIframeElement === null || innerIframeElement === void 0 ? void 0 : innerIframeElement.contentFrame());
+    if (!innerFrame) {
+      throw new Error("Could not get inner frame");
+    }
+    await outerFrame.evaluate(() => {
+      let outerCounter = 0;
+      const outerInterval = setInterval(() => {
+        outerCounter++;
+        const div = document.createElement("div");
+        div.textContent = `Outer dynamic ${outerCounter}`;
+        div.className = "outer-dynamic";
+        const outerContent = document.getElementById("outer-content");
+        outerContent === null || outerContent === void 0 || outerContent.appendChild(div);
+        if (outerCounter >= 2) {
+          clearInterval(outerInterval);
+        }
+      }, 150);
+    });
+    await innerFrame.evaluate(() => {
+      let innerCounter = 0;
+      const innerInterval = setInterval(() => {
+        innerCounter++;
+        const div = document.createElement("div");
+        div.textContent = `Inner dynamic ${innerCounter}`;
+        div.className = "inner-dynamic";
+        const innerContent = document.getElementById("inner-content");
+        innerContent === null || innerContent === void 0 || innerContent.appendChild(div);
+        if (innerCounter >= 2) {
+          clearInterval(innerInterval);
+        }
+      }, 200);
+    });
+    const settled = await (0, _waitForDomSettled.waitForDomSettled)({
+      source: page,
+      settleDurationMs: 1000,
+      timeoutInMs: 15000
+    });
+    (0, _extendedTest.expect)(settled).toBe(true);
+    const outerDynamicItems = await outerFrame.locator(".outer-dynamic").count();
+    (0, _extendedTest.expect)(outerDynamicItems).toBe(2);
+    const innerDynamicItems = await innerFrame.locator(".inner-dynamic").count();
+    (0, _extendedTest.expect)(innerDynamicItems).toBe(2);
+    for (let i = 0; i < 2; i++) {
+      const content = await outerFrame.locator(".outer-dynamic").nth(i).textContent();
+      (0, _extendedTest.expect)(content).toBe(`Outer dynamic ${i + 1}`);
+    }
+    for (let i = 0; i < 2; i++) {
+      const content = await innerFrame.locator(".inner-dynamic").nth(i).textContent();
+      (0, _extendedTest.expect)(content).toBe(`Inner dynamic ${i + 1}`);
+    }
+  });
 });

package/dist/helpers/types/Attachment.js

@@ -12,16 +12,18 @@ var _zod = require("zod");
 const AttachmentTypeSchema = exports.AttachmentTypeSchema = _zod.z.literal("document");
 const AttachmentSchema = exports.AttachmentSchema = _zod.z.object({
   fileName: _zod.z.string(),
+  key: _zod.z.string(),
   bucket: _zod.z.string(),
   region: _zod.z.string(),
   suggestedFileName: _zod.z.string(),
-  endpoint: _zod.z.string().optional(),
-  fileType: AttachmentTypeSchema.optional()
+  endpoint: _zod.z.string().nullable().optional(),
+  fileType: AttachmentTypeSchema.optional().nullable()
 });
 class Attachment {
-  constructor(fileName, bucket, region, suggestedFileName, endpoint, fileType) {
+  constructor(fileName, key, bucket, region, suggestedFileName, endpoint, fileType) {
     const validatedData = AttachmentSchema.parse({
       fileName,
+      key,
       bucket,
       region,
       suggestedFileName,
@@ -29,8 +31,10 @@ class Attachment {
       fileType
     });
     this.fileName = validatedData.fileName;
+    this.key = validatedData.key;
     this.bucket = validatedData.bucket;
     this.region = validatedData.region;
+    this.key = validatedData.key;
     this.suggestedFileName = validatedData.suggestedFileName;
     this.endpoint = validatedData.endpoint;
     this.fileType = validatedData.fileType;
@@ -41,6 +45,7 @@ class Attachment {
   toDict() {
     return {
       fileName: this.fileName,
+      key: this.key,
       bucket: this.bucket,
       region: this.region,
       suggestedFileName: this.suggestedFileName,
@@ -54,13 +59,13 @@ class Attachment {
   }
   static fromDict(data) {
     const validatedData = AttachmentSchema.parse(data);
-    return new Attachment(validatedData.fileName, validatedData.bucket, validatedData.region, validatedData.suggestedFileName, validatedData.endpoint, validatedData.fileType);
+    return new Attachment(validatedData.fileName, validatedData.key, 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);
+    const s3Client = (0, _getS3Client.getS3Client)(this.endpoint ?? undefined, this.region);
     try {
       const response = await (0, _s3RequestPresigner.getSignedUrl)(s3Client, new _clientS.GetObjectCommand({
         Bucket: this.bucket,
@@ -94,7 +99,7 @@ class SignedUrlAttachment extends Attachment {
     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);
+    super(fileName, key, bucket, "", suggestedFileName ?? fileName);
     this.downloadSignedUrl = validatedUrl;
   }
   async getSignedUrl() {

package/dist/helpers/types/index.js

@@ -9,24 +9,6 @@ Object.defineProperty(exports, "Attachment", {
     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 () {
@@ -47,5 +29,4 @@ Object.defineProperty(exports, "ValidationError", {
 });
 var _ValidationError = require("./ValidationError");
 var _RunEnvironment = require("./RunEnvironment");
-var _Attachment = require("./Attachment");
-var _CustomTypeRegistry = require("./CustomTypeRegistry");
+var _Attachment = require("./Attachment");

package/dist/helpers/uploadFileToS3.js

@@ -51,7 +51,7 @@ const uploadFileToS3 = async input => {
   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");
+      return new _Attachment.Attachment(`${(0, _uuid.v4)()}/${file.suggestedFilename()}`, `${(0, _uuid.v4)()}/${file.suggestedFilename()}`, "testing_bucket", "testing_region", file.suggestedFilename() || "downloaded_file", endpoint, "document");
     }
   }
   let suggestedFileName;
@@ -93,7 +93,7 @@ const uploadFileToS3 = async input => {
     });
     const response = await s3Client.send(command);
     if (response.$metadata.httpStatusCode === 200) {
-      return new _Attachment.Attachment(key, bucketName, region, suggestedFileName || fileName, endpoint);
+      return new _Attachment.Attachment(key, key, bucketName, region, suggestedFileName || fileName, endpoint);
     } else {
       throw new Error("Error uploading file");
     }

package/dist/helpers/validateDataUsingSchema.js

@@ -3,99 +3,58 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.injectAttachmentType = injectAttachmentType;
 exports.validateDataUsingSchema = void 0;
 var _ajv = _interopRequireDefault(require("ajv"));
+var _zodToJsonSchema = require("zod-to-json-schema");
 var _types = require("./types");
+var _Attachment = require("./types/Attachment");
 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
-      };
+function injectAttachmentType(schema) {
+  const schemaCopy = JSON.parse(JSON.stringify(schema));
+  const attachmentJsonSchema = (0, _zodToJsonSchema.zodToJsonSchema)(_Attachment.AttachmentSchema, {
+    $refStrategy: "none"
+  });
+  const attachmentDefinition = typeof attachmentJsonSchema === "object" && attachmentJsonSchema !== null ? attachmentJsonSchema : {};
+  if (!schemaCopy.$defs) {
+    schemaCopy.$defs = {};
+  }
+  schemaCopy.$defs.attachment = attachmentDefinition;
+  function replaceAttachmentType(node) {
+    if (typeof node !== "object" || node === null) {
+      return node;
     }
-  }
-  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]);
+    if (Array.isArray(node)) {
+      return node.map(item => replaceAttachmentType(item));
     }
-  }
-  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}'`);
+    const result = {};
+    if (node.type === "attachment") {
+      return {
+        $ref: "#/$defs/attachment"
+      };
     }
-    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));
-      }
+    for (const key in node) {
+      result[key] = replaceAttachmentType(node[key]);
     }
+    return result;
   }
-  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;
+  return replaceAttachmentType(schemaCopy);
 }
-const validateDataUsingSchema = async input => {
+const validateDataUsingSchema = input => {
   const {
     data,
     schema
   } = input;
-  const processedSchema = preprocessSchema(schema);
+  const processedSchema = injectAttachmentType(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 errors = ((_validate$errors = validate.errors) === null || _validate$errors === void 0 ? void 0 : _validate$errors.map(err => `${err.instancePath || "root"} ${err.message}`)) || [];
     const errorMessage = errors.join(", ") || "Unknown validation error";
     throw new _types.ValidationError(`Data validation failed: ${errorMessage}`, data);
   }