Ejemplo en JavaScript del Meta-Esquema (Meta-Schema v1)

Aquí tienes un ejemplo en JavaScript para validar cargas útiles utilizando instancias del Meta-Esquema de Definición de Tipo de Producto de Amazon:

Suggest Edits

Implementación de ejemplo del validador para JavaScript

Para aplicaciones en JavaScript, la biblioteca Hyperjump - JSON Schema Validator admite JSON Schema Draft 2019-09 y vocabularios personalizados. El siguiente ejemplo utiliza Node.js para demostrar cómo utilizar la biblioteca Hyperjump - JSON Schema Validator para validar cargas útiles con instancias del Meta-Esquema de Definición de Tipo de Producto de Amazon. El siguiente código de ejemplo no funcionará en un navegador web, sin embargo, la biblioteca no depende de Node.js y se puede usar en un navegador web. No es necesario utilizar esta biblioteca específica o la implementación de ejemplo. Amazon no brinda soporte técnico para bibliotecas de JSON Schema de terceros y esto se proporciona solo como ejemplo.

Configuración del esquema

Cuando se utiliza Hyperjump - JSON Schema Validator para validar instancias del Meta-Esquema de Definición de Tipo de Producto de Amazon con un vocabulario personalizado, el meta-esquema se configura como una instancia de JsonSchema con la validación de keywords (palabras clave) de vocabulario personalizado registrada en Hyperjump - JSON Schema Core.

Constants:

// $id of the Amazon Product Type Definition Meta-Schema.
const schemaId = "https://schemas.amazon.com/selling-partners/definitions/product-types/meta-schema/v1";
// $id of the Amazon Product Type Definition Luggage-Schema.
const luggageSchemaId = "https://schemas.amazon.com/selling-partners/definitions/product-types/schema/v1/LUGGAGE";

// Local copy of the Amazon Product Type Definition Meta-Schema.
const metaSchemaPath = "./amazon-product-type-definition-meta-schema-v1.json";

// Local copy of an instance of the Amazon Product Type Definition Meta-Schema.
const luggageSchemaPath = "./luggage.json";

Configure Meta-Schema:

// Add custom vocabulary and keywords
const { Core, Schema } = require("@hyperjump/json-schema-core");
const maxUniqueItemsKeyword = require("./keywords/MaxUniqueItemsKeyword.js");
const maxUtf8ByteLengthKeyword = require("./keywords/MaxUtf8ByteLengthKeyword.js");
const minUtf8ByteLengthKeyword = require("./keywords/MinUtf8ByteLengthKeyword.js");
const customVocabularyId = "https://schemas.amazon.com/selling-partners/definitions/product-types/vocabulary/v1";

// Configure $vocabulary defined in the schema JSON as vocabularyToken
Schema.setConfig(schemaId, "vocabularyToken", "$vocabulary");

// Add custom vocabulary and keywords
Core.defineVocabulary(customVocabularyId, {
    maxUniqueItems : maxUniqueItemsKeyword,
    minUtf8ByteLength : minUtf8ByteLengthKeyword,
    maxUtf8ByteLength : maxUtf8ByteLengthKeyword
});

// Add local schema JSON in JsonSchema.add() to use local copies of schemas rather than retrieving them from the web.
const JsonSchema = require("@hyperjump/json-schema");

// Add meta schema
const metaSchemaJSON = JSON.parse(fs.readFileSync(metaSchemaPath), "utf8");
JsonSchema.add(metaSchemaJSON, schemaId);

// Add luggage schema
const luggageSchemaJSON = JSON.parse(fs.readFileSync(luggageSchemaPath), "utf8");
JsonSchema.add(luggageSchemaJSON, luggageSchemaId, schemaId);

Cargar instancia del Meta-Schema:

// Retrieve previously added luggage schema from JsonSchema instance
var luggageSchema = await JsonSchema.get(luggageSchemaId);

Validación de Payload

Con una instancia del Meta-Esquema de Definición de Tipo de Producto de Amazon cargado como una instancia de JsonSchema, las cargas útiles se pueden validar utilizando la instancia.

// Load JSON for the payload (this can be constructed in code, read from a file, etc.).
const payload = JSON.parse(fs.readFileSync("./payload.json"), "utf8");

// Validate the payload and get validation result.
const result = await JsonSchema.validate(luggageSchema, payload, JsonSchema.BASIC);
const isValid = result.valid;

Si la carga útil es válida, isValid devolverá true con una lista vacía de keywords (palabras clave) de error. De lo contrario, isValid devolverá false con una lista de keywords (palabras clave) de error.

Ejemplo de mensaje de validación:


{
    keyword: 'https://schemas.amazon.com/selling-partners/definitions/product-types/meta-schema/v1#minUtf8ByteLength',
    absoluteKeywordLocation: 'https://schemas.amazon.com/selling-partners/definitions/product-types/schema/v1/LUGGAGE#/properties/contribution_sku/items/properties/value/minUtf8ByteLength',
    instanceLocation: '#/contribution_sku/0/value',
    valid: false
}

Validación de Keyword

El Hyperjump - JSON Schema Core proporciona un marco que se puede utilizar para validar vocabularios personalizados, keywords (palabras clave) y otras herramientas.

Los siguientes ejemplos ilustran implementaciones de JsonSchema que validan el vocabulario personalizado en instancias del Meta-Esquema de Definición de Tipo de Producto de Amazon.

`MaxUniqueItemsKeyword` script

const { Schema, Instance} = require("@hyperjump/json-schema-core");

const compile = (schema, ast, parentSchema) =>
{
    const maxUniqueItems = Schema.value(schema);
    // Retrieve the selectors defined in meta-schema
    const selectors = parentSchema.value.selectors;
    return [maxUniqueItems, selectors];
}

const interpret = ([maxUniqueItems, selectors], instance, ast) => {
    if (!Instance.typeOf(instance, "array")) {
        return false;
    }

    let uniqueItems = new Array();
    // For each instance in the example schema retrieve selectors combinations
    instance.value.forEach(inst => {
        let selectorCombination = {};
        Object.entries(inst).forEach(([key,value]) => {
            if(selectors != undefined && selectors.includes(key)) {
                selectorCombination[key] = value;
            }});
        uniqueItems.push(JSON.stringify(selectorCombination));
    });

    let countMap = new Map();
    // Add count of each unique selector combination in countMap
    uniqueItems.forEach(item => {
        countMap.get(item) != undefined ? countMap.set(item, countMap.get(item)+ 1): countMap.set(item, 1);
    });
    // Filter the countMap for values greater than maxUniqueItems
    let filteredItems = Array.from(countMap.entries()).filter(item => {
        return item[1] > maxUniqueItems;
    });
    // If filteredItems found then validation fails, else succeeds
    return filteredItems.length > 0 ? false : true;
};

module.exports = { compile, interpret };

`MaxUtf8ByteLengthKeyword` script

const { Schema, Instance} = require("@hyperjump/json-schema-core");

const compile = (schema, ast) => Schema.value(schema);

const interpret = (maxUtf8ByteLength, instance, ast) =>  Instance.typeOf(instance, "string") &&
    Buffer.byteLength(Instance.value(instance)) <= maxUtf8ByteLength;

module.exports = { compile, interpret };

`MinUtf8ByteLengthKeyword` script

const { Schema, Instance} = require("@hyperjump/json-schema-core");

const compile = (schema, ast) => Schema.value(schema);

const interpret = (minUtf8ByteLength, instance, ast) =>
    Instance.typeOf(instance, "string") && Buffer.byteLength(Instance.value(instance)) >= minUtf8ByteLength;

module.exports = { compile, interpret };

Updated over 1 year ago