How to use fast-xml-parser - 10 common examples

function assertXML(xml) {
    const err = parser.validate(xml);
    if (err !== true) {
        // console.error(xml);
        throw new Chai.AssertionError(err.err.code + ": " + err.err.msg);
    }
}

export default function(xmlData: string) {
    // when a tag has attributes
    const options = {
        attrPrefix: "@_",
        textNodeName: "#text",
        ignoreNonTextNodeAttr: true,
        ignoreTextNodeAttr: true,
        ignoreNameSpace: true,
        ignoreRootElement: false,
        textNodeConversion: true,
        textAttrConversion: false
    };
    if (fastXmlParser.validate(xmlData) === true) {
        //optional
        const jsonObj = fastXmlParser.parse(xmlData, options);
        var array = jsonToArray(jsonObj);
        const data = {
            data: array,
            meta: {
                fields: ["name", "value"],
                type: "tabular"
            }
        };
        return data;
    }
    return null;
}

static getFromXML(contents: string, name = 'New Event'): Promise {
    const json = parser.parse(contents).sml;

    // debugger;

    //  A few mods here to convert it to compatible json suunto string
    json.DeviceLog.Samples = json.DeviceLog.Samples.Sample;

    const samplesWithUTC: any[]  =  json.DeviceLog.Samples.filter((sample: any) => !!sample.UTC);

    // Find the first UTC timestamped sample and use it later for start date
    const startDate = samplesWithUTC.length ? new Date(samplesWithUTC[0].UTC) : new Date(json.DeviceLog.Header.DateTime);


    // Determine the end date
    const endDate = samplesWithUTC.length > 1 ? samplesWithUTC[samplesWithUTC.length - 1].UTC : (new Date((startDate.getTime() + json.DeviceLog.Header.Duration * 1000)));

    // Filter out the old activity type

async function getModuleConfig(root: string, path: string): Promise {
    const configPath = join(root, path, 'etc', 'module.xml');
    const rawConfig = await fs.readFile(configPath, 'utf8');
    const parsedConfig = parse(rawConfig, {
        ignoreAttributes: false,
        attributeNamePrefix: '',
        ignoreNameSpace: true,
    });

    const config = {
        moduleID: parsedConfig.config.module.name as string,
        sequence: [] as string[],
        pathFromStoreRoot: join(sep, path),
    };
    const { sequence } = parsedConfig.config.module;

    if (!sequence) return config;

    if (Array.isArray(sequence.module)) {
        // multiple dependencies

configureBuckets,
      ...serverOptions
    } = defaults({}, options, S3rver.defaultOptions);
    this.serverOptions = serverOptions;
    this._configureBuckets = configureBuckets;
    this.silent = silent;
    this.resetOnClose = resetOnClose;
    this.allowMismatchedSignatures = allowMismatchedSignatures;
    this.store = this.context.store = new FilesystemStore(directory);

    // Log all requests
    this.use(loggerMiddleware(this, silent));

    try {
      // encode object responses as XML
      const parser = new xmlParser.j2xParser({
        ignoreAttributes: false,
        attrNodeName: '@',
        tagValueProcessor: a => he.escape(a.toString()),
      });
      this.use(async (ctx, next) => {
        await next();
        if (isPlainObject(ctx.body)) {
          ctx.type = 'application/xml';
          ctx.body =
            '\n' + parser.parse(ctx.body);
        }
      });

      // Express mount interop
      this.use((ctx, next) => {
        ctx.mountPath = ctx.mountPath || ctx.req.baseUrl;

protected async _request(method: string, headers: any, resource: Resource, body?: any): Promise {
    headers['date'] = new Date().toUTCString()

    const uri = getResourceUri(resource)

    // 并不知道设置错误的 content-type 会有什么影响，但是设置了就没错
    if (body) {
      if (typeof body === 'object' && body.constructor === Object) {
        body = new j2xParser({}).parse(CamelCaseObject(body))
        headers['content-type'] = 'application/xml;charset=UTF-8'
      } else {
        headers['content-type'] = mime.getType(uri) || 'application/octet-stream'
      }
    }

    if (body instanceof Buffer || typeof body === 'string') {
      headers['content-md5'] = md5sum(body)
      headers['content-length'] = headers['content-length'] || body.length
    }

    const sign = signature(this.options.accessSecret, method, headers, resource)
    headers['authorization'] = `NOS ${this.options.accessKey}:${sign}`

    return await fetch(url.resolve(this.options.endpoint, uri), {
      method,

it('should return valid xml when sane inputs provided', () => {
      expect(parser.validate(toSVG(network, options))).toBe(true);
    });
  });

test: (contentType: string, content: string) => {
    const doesContentTypeMatch = !!typeIs.is(contentType, [
      'application/xml',
      'application/*+xml',
      'text/xml',
    ]);
    const isContentXML = parser.validate(content) === true;

    return doesContentTypeMatch || isContentXML;
  },
  validate: (expected: Result, output: Result) => {

export const getGamesJapan = async (): Promise => {
  try {
    const gamesJP = await fetch(constants.JP_GET_GAMES_URL);

    if (!gamesJP.ok) throw new Error('JP_games_request_failed');

    const parsedGamesJP = xml2json(await gamesJP.text());

    const allGamesJP: interfaces.GameJP[] = parsedGamesJP.TitleInfoList.TitleInfo;

    return allGamesJP;
  } catch (err) {
    if (/(?:JP_games_request_failed)/i.test(err.toString())) throw new constants.EshopError('Fetching of JP Games failed');
    throw err;
  }
};

function validateSyntax(fileName) {
	try {
		if (fileName.endsWith(".json")) {
			require('jsonlint').parse(fs.readFileSync(fileName, {
				encoding: 'utf-8'
			}));
			console.log("Validated successfully");
		} else if (fileName.endsWith(".yaml") || fileName.endsWith(".yml")) {
			require('yamljs').parseFile(fileName);
			console.log("Validated successfully");
		}else if(fileName.endsWith(".xml")){
			var result = require('fast-xml-parser').validate(fs.readFileSync(fileName, {
				encoding: 'utf-8'
			}));
			if(result === true) {
				console.log("Validated successfully");
			}else{
				console.log("Validation failed");
			}
		}else {
			console.log("Unsupported file");
		}
	} catch (e) {
		console.log("Validation failed");
		console.log(color(e, 'red'));
		//if(e.line) console.log("line number: " + e.line + ":" + e.column);
	}
}