rtblint-core 0.7.0 → 0.8.0

package/index.cjs

@@ -41,6 +41,68 @@ function validateResponseAgainstRequest(response, request, version) {
   return wasm.validate_response_against_request(version ?? "", request, response);
 }
 
+/**
+ * Validate an OpenRTB bid request written in a specific JSON dialect.
+ * "spec-json" (default) types flag fields such as imp.secure, regs.coppa and
+ * pmp.private_auction as integers, the way the specification does.
+ * "proto-json" follows the IAB OpenRTB protobuf schema, which declares 28 of
+ * those fields bool; see protoBoolDivergences().
+ * @param {string} input - Raw bid request JSON.
+ * @param {"spec-json"|"proto-json"} dialect - JSON dialect the payload is written in.
+ * @param {string} [version] - OpenRTB version id (default: latest tracked 2.6 snapshot).
+ */
+function validateDialect(input, dialect, version) {
+  return wasm.validate_dialect(version ?? "", dialect, input);
+}
+
+/**
+ * Validate an OpenRTB bid response written in a specific JSON dialect.
+ * @param {string} input - Raw bid response JSON.
+ * @param {"spec-json"|"proto-json"} dialect - JSON dialect the payload is written in.
+ * @param {string} [version] - OpenRTB version id (default: latest tracked 2.6 snapshot).
+ */
+function validateResponseDialect(input, dialect, version) {
+  return wasm.validate_response_dialect(version ?? "", dialect, input);
+}
+
+/** Every field the IAB OpenRTB protobuf schema types differently from the spec. */
+function protoBoolDivergences() {
+  return wasm.proto_bool_divergences();
+}
+
+/**
+ * Validate an ARTF RTBRequest envelope and the OpenRTB payloads it carries.
+ * @param {string} input - Raw RTBRequest JSON.
+ * @param {string} [version] - OpenRTB version id (default: latest tracked 2.6 snapshot).
+ */
+function validateArtfRequest(input, version) {
+  return wasm.validate_artf_request(version ?? "", input);
+}
+
+/**
+ * Validate an ARTF RTBResponse mutation set against the RTBRequest it answers:
+ * intent eligibility, operation and payload coherence, and semantic path
+ * resolution against the auction.
+ * @param {string} rtbResponse - Raw RTBResponse JSON.
+ * @param {string} rtbRequest - Raw RTBRequest envelope JSON.
+ * @param {string} [version] - OpenRTB version id (default: latest tracked 2.6 snapshot).
+ */
+function validateArtfResponse(rtbResponse, rtbRequest, version) {
+  return wasm.validate_artf_response(version ?? "", rtbRequest, rtbResponse);
+}
+
+/**
+ * Apply an ARTF mutation set and revalidate. Returns { result, application }:
+ * result carries the mutation findings plus the OpenRTB findings the mutations
+ * introduced, application carries the mutated payloads.
+ * @param {string} rtbResponse - Raw RTBResponse JSON.
+ * @param {string} rtbRequest - Raw RTBRequest envelope JSON.
+ * @param {string} [version] - OpenRTB version id (default: latest tracked 2.6 snapshot).
+ */
+function validateArtfResponseApplied(rtbResponse, rtbRequest, version) {
+  return wasm.validate_artf_response_applied(version ?? "", rtbRequest, rtbResponse);
+}
+
 /** Every tracked OpenRTB version id. */
 function versions() {
   return wasm.versions();
@@ -60,6 +122,12 @@ module.exports = {
   validate,
   validateResponse,
   validateResponseAgainstRequest,
+  validateDialect,
+  validateResponseDialect,
+  protoBoolDivergences,
+  validateArtfRequest,
+  validateArtfResponse,
+  validateArtfResponseApplied,
   versions,
   rules,
   coreVersion,

package/index.d.ts

@@ -53,6 +53,93 @@ export function validateResponseAgainstRequest(
   version?: string
 ): ValidationResult;
 
+/**
+ * JSON dialect a payload is written in. "spec-json" types flag fields such as
+ * imp.secure, regs.coppa and pmp.private_auction as integers, the way the
+ * OpenRTB specification does. "proto-json" follows the IAB OpenRTB protobuf
+ * schema, which declares 28 of those fields bool.
+ */
+export type Dialect = "spec-json" | "proto-json";
+
+/** A field the OpenRTB protobuf schema types differently from the spec. */
+export interface ProtoBoolField {
+  object: string;
+  field: string;
+}
+
+/** What applying an ARTF mutation set produced. */
+export interface ArtfApplication {
+  /** The bid request after every applicable mutation was applied. */
+  bid_request: string | null;
+  /** The bid response after every applicable mutation was applied. */
+  bid_response: string | null;
+  /** Indexes into `mutations` that were applied. */
+  applied: number[];
+  /** Indexes that were not applied: unresolved target, or no OpenRTB field to write to. */
+  skipped: number[];
+}
+
+export interface ArtfMutationOutcome {
+  result: ValidationResult;
+  application: ArtfApplication;
+}
+
+/**
+ * Validate an OpenRTB bid request written in a specific JSON dialect.
+ * @param input Raw bid request JSON.
+ * @param dialect Dialect the payload is written in.
+ * @param version OpenRTB version id (default: latest tracked 2.6 snapshot).
+ */
+export function validateDialect(
+  input: string,
+  dialect: Dialect,
+  version?: string
+): ValidationResult;
+
+/** Validate an OpenRTB bid response written in a specific JSON dialect. */
+export function validateResponseDialect(
+  input: string,
+  dialect: Dialect,
+  version?: string
+): ValidationResult;
+
+/** Every field the OpenRTB protobuf schema types differently from the spec. */
+export function protoBoolDivergences(): ProtoBoolField[];
+
+/**
+ * Validate an ARTF RTBRequest envelope and the OpenRTB payloads it carries.
+ * @param input Raw RTBRequest JSON.
+ * @param version OpenRTB version id (default: latest tracked 2.6 snapshot).
+ */
+export function validateArtfRequest(input: string, version?: string): ValidationResult;
+
+/**
+ * Validate an ARTF RTBResponse mutation set against the RTBRequest it answers:
+ * intent eligibility, operation and payload coherence, and semantic path
+ * resolution against the auction.
+ * @param rtbResponse Raw RTBResponse JSON.
+ * @param rtbRequest Raw RTBRequest envelope JSON.
+ * @param version OpenRTB version id (default: latest tracked 2.6 snapshot).
+ */
+export function validateArtfResponse(
+  rtbResponse: string,
+  rtbRequest: string,
+  version?: string
+): ValidationResult;
+
+/**
+ * Apply an ARTF mutation set and revalidate, reporting the mutation findings
+ * plus the OpenRTB findings the mutations introduced.
+ * @param rtbResponse Raw RTBResponse JSON.
+ * @param rtbRequest Raw RTBRequest envelope JSON.
+ * @param version OpenRTB version id (default: latest tracked 2.6 snapshot).
+ */
+export function validateArtfResponseApplied(
+  rtbResponse: string,
+  rtbRequest: string,
+  version?: string
+): ArtfMutationOutcome;
+
 /** Every tracked OpenRTB version id. */
 export function versions(): string[];
 

package/index.mjs

@@ -42,6 +42,68 @@ export function validateResponseAgainstRequest(response, request, version) {
   return wasm.validate_response_against_request(version ?? "", request, response);
 }
 
+/**
+ * Validate an OpenRTB bid request written in a specific JSON dialect.
+ * "spec-json" (default) types flag fields such as imp.secure, regs.coppa and
+ * pmp.private_auction as integers, the way the specification does.
+ * "proto-json" follows the IAB OpenRTB protobuf schema, which declares 28 of
+ * those fields bool; see protoBoolDivergences().
+ * @param {string} input - Raw bid request JSON.
+ * @param {"spec-json"|"proto-json"} dialect - JSON dialect the payload is written in.
+ * @param {string} [version] - OpenRTB version id (default: latest tracked 2.6 snapshot).
+ */
+export function validateDialect(input, dialect, version) {
+  return wasm.validate_dialect(version ?? "", dialect, input);
+}
+
+/**
+ * Validate an OpenRTB bid response written in a specific JSON dialect.
+ * @param {string} input - Raw bid response JSON.
+ * @param {"spec-json"|"proto-json"} dialect - JSON dialect the payload is written in.
+ * @param {string} [version] - OpenRTB version id (default: latest tracked 2.6 snapshot).
+ */
+export function validateResponseDialect(input, dialect, version) {
+  return wasm.validate_response_dialect(version ?? "", dialect, input);
+}
+
+/** Every field the IAB OpenRTB protobuf schema types differently from the spec. */
+export function protoBoolDivergences() {
+  return wasm.proto_bool_divergences();
+}
+
+/**
+ * Validate an ARTF RTBRequest envelope and the OpenRTB payloads it carries.
+ * @param {string} input - Raw RTBRequest JSON.
+ * @param {string} [version] - OpenRTB version id (default: latest tracked 2.6 snapshot).
+ */
+export function validateArtfRequest(input, version) {
+  return wasm.validate_artf_request(version ?? "", input);
+}
+
+/**
+ * Validate an ARTF RTBResponse mutation set against the RTBRequest it answers:
+ * intent eligibility, operation and payload coherence, and semantic path
+ * resolution against the auction.
+ * @param {string} rtbResponse - Raw RTBResponse JSON.
+ * @param {string} rtbRequest - Raw RTBRequest envelope JSON.
+ * @param {string} [version] - OpenRTB version id (default: latest tracked 2.6 snapshot).
+ */
+export function validateArtfResponse(rtbResponse, rtbRequest, version) {
+  return wasm.validate_artf_response(version ?? "", rtbRequest, rtbResponse);
+}
+
+/**
+ * Apply an ARTF mutation set and revalidate. Returns { result, application }:
+ * result carries the mutation findings plus the OpenRTB findings the mutations
+ * introduced, application carries the mutated payloads.
+ * @param {string} rtbResponse - Raw RTBResponse JSON.
+ * @param {string} rtbRequest - Raw RTBRequest envelope JSON.
+ * @param {string} [version] - OpenRTB version id (default: latest tracked 2.6 snapshot).
+ */
+export function validateArtfResponseApplied(rtbResponse, rtbRequest, version) {
+  return wasm.validate_artf_response_applied(version ?? "", rtbRequest, rtbResponse);
+}
+
 /** Every tracked OpenRTB version id. */
 export function versions() {
   return wasm.versions();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rtblint-core",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "OpenRTB linter: validates OpenRTB 2.x bid requests and bid responses against versioned IAB spec snapshots",
   "license": "Apache-2.0",
   "author": "Aleks <aleks@vastlint.org>",

package/wasm/rtblint_wasm.d.ts

@@ -6,6 +6,13 @@
  */
 export function core_version(): string;
 
+/**
+ * Every field where the IAB OpenRTB protobuf schema and the specification
+ * disagree on the type, as `{ object, field }` pairs. Drives the dialect
+ * documentation.
+ */
+export function proto_bool_divergences(): any;
+
 /**
  * The full versioned rule catalog: one entry per coded rule across every
  * tracked OpenRTB version. Drives the per-rule documentation pages.
@@ -19,6 +26,33 @@ export function rules(): any;
  */
 export function validate(input: string): any;
 
+/**
+ * Validate an ARTF RTBRequest envelope and the OpenRTB payloads it carries.
+ */
+export function validate_artf_request(version_id: string, input: string): any;
+
+/**
+ * Validate an ARTF RTBResponse mutation set against the RTBRequest envelope
+ * it answers: intent eligibility, operation and payload coherence, and
+ * semantic path resolution against the auction.
+ */
+export function validate_artf_response(version_id: string, rtb_request: string, rtb_response: string): any;
+
+/**
+ * Apply an ARTF mutation set and revalidate: returns `{ result, application }`
+ * where result carries the mutation findings plus the OpenRTB findings the
+ * mutations introduced, and application carries the mutated payloads.
+ */
+export function validate_artf_response_applied(version_id: string, rtb_request: string, rtb_response: string): any;
+
+/**
+ * Validate an OpenRTB bid request written in a specific JSON dialect
+ * ("spec-json" or "proto-json"). protobuf JSON declares 28 of the spec's
+ * integer flag fields as bool, so the two encodings disagree in both
+ * directions; see `proto_bool_divergences`.
+ */
+export function validate_dialect(version_id: string, dialect_id: string, input: string): any;
+
 /**
  * Validate an OpenRTB bid response payload against the latest tracked 2.6 snapshot.
  *
@@ -35,6 +69,11 @@ export function validate_response(input: string): any;
  */
 export function validate_response_against_request(version_id: string, request: string, response: string): any;
 
+/**
+ * Validate an OpenRTB bid response written in a specific JSON dialect.
+ */
+export function validate_response_dialect(version_id: string, dialect_id: string, input: string): any;
+
 /**
  * Validate an OpenRTB bid response payload against a specific tracked version id
  * (for example "2.6-202606"). Unknown ids fall back to the latest 2.6 snapshot.

package/wasm/rtblint_wasm.js

@@ -18,6 +18,21 @@ function core_version() {
 }
 exports.core_version = core_version;
 
+/**
+ * Every field where the IAB OpenRTB protobuf schema and the specification
+ * disagree on the type, as `{ object, field }` pairs. Drives the dialect
+ * documentation.
+ * @returns {any}
+ */
+function proto_bool_divergences() {
+    const ret = wasm.proto_bool_divergences();
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.proto_bool_divergences = proto_bool_divergences;
+
 /**
  * The full versioned rule catalog: one entry per coded rule across every
  * tracked OpenRTB version. Drives the per-rule documentation pages.
@@ -50,6 +65,98 @@ function validate(input) {
 }
 exports.validate = validate;
 
+/**
+ * Validate an ARTF RTBRequest envelope and the OpenRTB payloads it carries.
+ * @param {string} version_id
+ * @param {string} input
+ * @returns {any}
+ */
+function validate_artf_request(version_id, input) {
+    const ptr0 = passStringToWasm0(version_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.validate_artf_request(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.validate_artf_request = validate_artf_request;
+
+/**
+ * Validate an ARTF RTBResponse mutation set against the RTBRequest envelope
+ * it answers: intent eligibility, operation and payload coherence, and
+ * semantic path resolution against the auction.
+ * @param {string} version_id
+ * @param {string} rtb_request
+ * @param {string} rtb_response
+ * @returns {any}
+ */
+function validate_artf_response(version_id, rtb_request, rtb_response) {
+    const ptr0 = passStringToWasm0(version_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(rtb_request, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(rtb_response, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.validate_artf_response(ptr0, len0, ptr1, len1, ptr2, len2);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.validate_artf_response = validate_artf_response;
+
+/**
+ * Apply an ARTF mutation set and revalidate: returns `{ result, application }`
+ * where result carries the mutation findings plus the OpenRTB findings the
+ * mutations introduced, and application carries the mutated payloads.
+ * @param {string} version_id
+ * @param {string} rtb_request
+ * @param {string} rtb_response
+ * @returns {any}
+ */
+function validate_artf_response_applied(version_id, rtb_request, rtb_response) {
+    const ptr0 = passStringToWasm0(version_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(rtb_request, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(rtb_response, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.validate_artf_response_applied(ptr0, len0, ptr1, len1, ptr2, len2);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.validate_artf_response_applied = validate_artf_response_applied;
+
+/**
+ * Validate an OpenRTB bid request written in a specific JSON dialect
+ * ("spec-json" or "proto-json"). protobuf JSON declares 28 of the spec's
+ * integer flag fields as bool, so the two encodings disagree in both
+ * directions; see `proto_bool_divergences`.
+ * @param {string} version_id
+ * @param {string} dialect_id
+ * @param {string} input
+ * @returns {any}
+ */
+function validate_dialect(version_id, dialect_id, input) {
+    const ptr0 = passStringToWasm0(version_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(dialect_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.validate_dialect(ptr0, len0, ptr1, len1, ptr2, len2);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.validate_dialect = validate_dialect;
+
 /**
  * Validate an OpenRTB bid response payload against the latest tracked 2.6 snapshot.
  *
@@ -94,6 +201,28 @@ function validate_response_against_request(version_id, request, response) {
 }
 exports.validate_response_against_request = validate_response_against_request;
 
+/**
+ * Validate an OpenRTB bid response written in a specific JSON dialect.
+ * @param {string} version_id
+ * @param {string} dialect_id
+ * @param {string} input
+ * @returns {any}
+ */
+function validate_response_dialect(version_id, dialect_id, input) {
+    const ptr0 = passStringToWasm0(version_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(dialect_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.validate_response_dialect(ptr0, len0, ptr1, len1, ptr2, len2);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.validate_response_dialect = validate_response_dialect;
+
 /**
  * Validate an OpenRTB bid response payload against a specific tracked version id
  * (for example "2.6-202606"). Unknown ids fall back to the latest 2.6 snapshot.
@@ -149,6 +278,10 @@ exports.versions = versions;
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
+        __wbg_Error_fdd633d4bb5dd76a: function(arg0, arg1) {
+            const ret = Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
         __wbg_String_8564e559799eccda: function(arg0, arg1) {
             const ret = String(arg1);
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -173,11 +306,21 @@ function __wbg_get_imports() {
         __wbg_set_dc601f4a69da0bc2: function(arg0, arg1, arg2) {
             arg0[arg1 >>> 0] = arg2;
         },
-        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000001: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
         },
+        __wbindgen_cast_0000000000000003: function(arg0) {
+            // Cast intrinsic for `U64 -> Externref`.
+            const ret = BigInt.asUintN(64, arg0);
+            return ret;
+        },
         __wbindgen_init_externref_table: function() {
             const table = wasm.__wbindgen_externrefs;
             const offset = table.grow(4);

package/wasm/rtblint_wasm_bg.wasm.d.ts

@@ -2,10 +2,16 @@
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
 export const core_version: () => [number, number];
+export const proto_bool_divergences: () => [number, number, number];
 export const rules: () => [number, number, number];
 export const validate: (a: number, b: number) => [number, number, number];
+export const validate_artf_request: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const validate_artf_response: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+export const validate_artf_response_applied: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+export const validate_dialect: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
 export const validate_response: (a: number, b: number) => [number, number, number];
 export const validate_response_against_request: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+export const validate_response_dialect: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
 export const validate_response_version: (a: number, b: number, c: number, d: number) => [number, number, number];
 export const validate_version: (a: number, b: number, c: number, d: number) => [number, number, number];
 export const versions: () => [number, number, number];