@chubbyts/chubbyts-decode-encode 2.1.2 → 2.2.0

package/README.md

@@ -24,17 +24,17 @@ A simple decode/encode solution for json / jsonx / url-encoded / xml / yaml.
 ## Requirements
 
  * node: 20
- * [@chubbyts/chubbyts-throwable-to-error][2]: ^2.0.4
- * [fast-xml-parser][3]: ^5.5.6
- * [qs][4]: ^6.15.0
- * [yaml][5]: ^2.8.2
+ * [@chubbyts/chubbyts-throwable-to-error][2]: ^2.1.0
+ * [fast-xml-parser][3]: ^5.5.11
+ * [qs][4]: ^6.15.1
+ * [yaml][5]: ^2.8.3
 
 ## Installation
 
 Through [NPM](https://www.npmjs.com) as [@chubbyts/chubbyts-decode-encode][1].
 
 ```ts
-npm i @chubbyts/chubbyts-decode-encode@^2.1.2
+npm i @chubbyts/chubbyts-decode-encode@^2.2.0
 ```
 
 ## Usage

package/dist/src/data.d.ts

@@ -0,0 +1,11 @@
+export type Data = {
+    [key: string]: Data;
+} | Array<Data> | string | number | boolean | null;
+export declare const isNull: (value: unknown) => value is null;
+export declare const isBoolean: (value: unknown) => value is boolean;
+export declare const isNumber: (value: unknown) => value is number;
+export declare const isString: (value: unknown) => value is string;
+export declare const isArray: (value: unknown) => value is Array<Data>;
+export declare const isObject: (value: unknown) => value is {
+    [key: string]: Data;
+};

package/dist/src/data.js

@@ -0,0 +1,6 @@
+export const isNull = (value) => value === null;
+export const isBoolean = (value) => typeof value === 'boolean';
+export const isNumber = (value) => typeof value === 'number';
+export const isString = (value) => typeof value === 'string';
+export const isArray = (value) => Array.isArray(value);
+export const isObject = (value) => value !== null && typeof value === 'object' && value.constructor.name == 'Object';

package/dist/src/decoder/decoder.d.ts

@@ -0,0 +1,13 @@
+import type { Data } from '../data.js';
+export declare class DecodeError extends Error {
+    constructor(message: string, stack?: string);
+}
+export type TypeDecoder = {
+    decode: (encodedData: string) => Data;
+    contentType: string;
+};
+export type Decoder = {
+    decode: (encodedData: string, contentType: string, context?: Record<string, unknown>) => Data;
+    contentTypes: Array<string>;
+};
+export declare const createDecoder: (decoderTypes: Array<TypeDecoder>) => Decoder;

package/dist/src/decoder/decoder.js

@@ -0,0 +1,19 @@
+export class DecodeError extends Error {
+    constructor(message, stack) {
+        super(message);
+        this.stack = stack;
+    }
+}
+export const createDecoder = (decoderTypes) => {
+    const decoderTypeMap = new Map(decoderTypes.map((DecoderType) => [DecoderType.contentType, DecoderType]));
+    const contentTypes = Array.from(decoderTypeMap.keys());
+    return {
+        decode: (encodedData, contentType) => {
+            if (decoderTypeMap.has(contentType)) {
+                return decoderTypeMap.get(contentType).decode(encodedData);
+            }
+            throw new Error(`Unsupported contentType "${contentType}", supported contentTypes are "${contentTypes.join('", "')}".`);
+        },
+        contentTypes,
+    };
+};

package/dist/src/decoder/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @deprecated This file re-exports the old API. Use './decoder.ts' directly instead.
+ */
+export { DecodeError, createDecoder } from './decoder.js';
+export type { TypeDecoder, Decoder } from './decoder.js';

package/dist/src/decoder/index.js

@@ -0,0 +1,4 @@
+/**
+ * @deprecated This file re-exports the old API. Use './decoder.ts' directly instead.
+ */
+export { DecodeError, createDecoder } from './decoder.js';

package/dist/src/decoder/json-type-decoder.d.ts

@@ -0,0 +1,2 @@
+import type { TypeDecoder } from './decoder.js';
+export declare const createJsonTypeDecoder: () => TypeDecoder;

package/dist/src/decoder/json-type-decoder.js

@@ -0,0 +1,16 @@
+import { throwableToError } from '@chubbyts/chubbyts-throwable-to-error/dist/throwable-to-error';
+import { DecodeError } from './decoder.js';
+export const createJsonTypeDecoder = () => {
+    return {
+        decode: (encodedData) => {
+            try {
+                return JSON.parse(encodedData);
+            }
+            catch (e) {
+                const error = throwableToError(e);
+                throw new DecodeError(error.message, error.stack);
+            }
+        },
+        contentType: 'application/json',
+    };
+};

package/dist/src/decoder/jsonx-type-decoder.d.ts

@@ -0,0 +1,2 @@
+import type { TypeDecoder } from './decoder.js';
+export declare const createJsonxTypeDecoder: () => TypeDecoder;

package/dist/src/decoder/jsonx-type-decoder.js

@@ -0,0 +1,68 @@
+import { XMLParser } from 'fast-xml-parser';
+import { throwableToError } from '@chubbyts/chubbyts-throwable-to-error/dist/throwable-to-error';
+import { DATATYPE_ARRAY, DATATYPE_BOOLEAN, DATATYPE_NULL, DATATYPE_NUMBER, DATATYPE_OBJECT, DATATYPE_STRING, } from '../jsonx-datatypes.js';
+import { DecodeError } from './decoder.js';
+const decodeHtmlEntities = (string) => string.replace(/&#\d+;/gm, (code) => String.fromCharCode(code.match(/\d+/)[0]));
+const getNodeName = (node) => {
+    return node[':@']?.['@_name'];
+};
+const getNodeType = (node) => {
+    return Object.keys(node)[0];
+};
+const convertNullNode = () => {
+    return null;
+};
+const convertBooleanNode = (node) => {
+    return node['json:boolean'][0]['#text'];
+};
+const convertNumberNode = (node) => {
+    return node['json:number'][0]['#text'];
+};
+const convertStringNode = (node) => {
+    return decodeHtmlEntities(node['json:string'][0]['#text']);
+};
+const convertNode = (node) => {
+    switch (getNodeType(node)) {
+        case DATATYPE_OBJECT:
+            return convertObjectNode(node);
+        case DATATYPE_ARRAY:
+            return convertArrayNode(node);
+        case DATATYPE_STRING:
+            return convertStringNode(node);
+        case DATATYPE_NUMBER:
+            return convertNumberNode(node);
+        case DATATYPE_BOOLEAN:
+            return convertBooleanNode(node);
+        case DATATYPE_NULL:
+            return convertNullNode();
+    }
+    throw new Error(`Unsupported node: ${JSON.stringify(node)}`);
+};
+const convertArrayNode = (node) => {
+    return node['json:array'].map(convertNode);
+};
+const convertNodeWithName = (node) => {
+    const name = getNodeName(node);
+    if (undefined === name) {
+        throw new Error(`Unsupported node: ${JSON.stringify(node)}`);
+    }
+    return [name, convertNode(node)];
+};
+const convertObjectNode = (node) => {
+    return Object.fromEntries(node['json:object'].map(convertNodeWithName));
+};
+export const createJsonxTypeDecoder = () => {
+    return {
+        decode: (encodedData) => {
+            try {
+                const parser = new XMLParser({ preserveOrder: true, ignoreAttributes: false });
+                return convertNode(parser.parse(encodedData)[1]);
+            }
+            catch (e) {
+                const error = throwableToError(e);
+                throw new DecodeError(error.message, error.stack);
+            }
+        },
+        contentType: 'application/jsonx+xml',
+    };
+};

package/dist/src/decoder/url-encoded-type-decoder.d.ts

@@ -0,0 +1,2 @@
+import type { TypeDecoder } from './decoder.js';
+export declare const createUrlEncodedTypeDecoder: () => TypeDecoder;

package/dist/src/decoder/url-encoded-type-decoder.js

@@ -0,0 +1,30 @@
+import { parse } from 'qs';
+import { isArray, isObject } from '../data.js';
+const decodeValue = (value) => {
+    if (isObject(value)) {
+        return Object.fromEntries(Object.entries(value).map(([subKey, subValue]) => [subKey, decodeValue(subValue)]));
+    }
+    if (isArray(value)) {
+        return value.map(decodeValue);
+    }
+    if (value === 'null') {
+        return null;
+    }
+    if (value === 'true') {
+        return true;
+    }
+    if (value === 'false') {
+        return false;
+    }
+    const float = parseFloat(value); // handles integers as well
+    if (float.toString() === value) {
+        return float;
+    }
+    return value;
+};
+export const createUrlEncodedTypeDecoder = () => {
+    return {
+        decode: (encodedData) => decodeValue(parse(encodedData, { depth: 100 })),
+        contentType: 'application/x-www-form-urlencoded',
+    };
+};

package/dist/src/decoder/yaml-type-decoder.d.ts

@@ -0,0 +1,2 @@
+import type { TypeDecoder } from './decoder.js';
+export declare const createYamlTypeDecoder: () => TypeDecoder;

package/dist/src/decoder/yaml-type-decoder.js

@@ -0,0 +1,17 @@
+import { parse } from 'yaml';
+import { throwableToError } from '@chubbyts/chubbyts-throwable-to-error/dist/throwable-to-error';
+import { DecodeError } from './decoder.js';
+export const createYamlTypeDecoder = () => {
+    return {
+        decode: (encodedData) => {
+            try {
+                return parse(encodedData);
+            }
+            catch (e) {
+                const error = throwableToError(e);
+                throw new DecodeError(error.message, error.stack);
+            }
+        },
+        contentType: 'application/x-yaml',
+    };
+};

package/dist/src/encoder/encoder.d.ts

@@ -0,0 +1,13 @@
+import type { Data } from '../data.js';
+export declare class EncodeError extends Error {
+    constructor(message: string, stack?: string);
+}
+export type TypeEncoder = {
+    encode: (data: Data) => string;
+    contentType: string;
+};
+export type Encoder = {
+    encode: (data: Data, contentType: string, context?: Record<string, unknown>) => string;
+    contentTypes: Array<string>;
+};
+export declare const createEncoder: (encoderTypes: Array<TypeEncoder>) => Encoder;

package/dist/src/encoder/encoder.js

@@ -0,0 +1,19 @@
+export class EncodeError extends Error {
+    constructor(message, stack) {
+        super(message);
+        this.stack = stack;
+    }
+}
+export const createEncoder = (encoderTypes) => {
+    const encoderTypeMap = new Map(encoderTypes.map((encoderType) => [encoderType.contentType, encoderType]));
+    const contentTypes = Array.from(encoderTypeMap.keys());
+    return {
+        encode: (data, contentType) => {
+            if (encoderTypeMap.has(contentType)) {
+                return encoderTypeMap.get(contentType).encode(data);
+            }
+            throw new Error(`Unsupported contentType "${contentType}", supported contentTypes are "${contentTypes.join('", "')}".`);
+        },
+        contentTypes,
+    };
+};

package/dist/src/encoder/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @deprecated This file re-exports the old API. Use './encoder.ts' directly instead.
+ */
+export { EncodeError, createEncoder } from './encoder.js';
+export type { TypeEncoder, Encoder } from './encoder.js';

package/dist/src/encoder/index.js

@@ -0,0 +1,4 @@
+/**
+ * @deprecated This file re-exports the old API. Use './encoder.ts' directly instead.
+ */
+export { EncodeError, createEncoder } from './encoder.js';

package/dist/src/encoder/json-type-encoder.d.ts

@@ -0,0 +1,2 @@
+import type { TypeEncoder } from './encoder.js';
+export declare const createJsonTypeEncoder: (prettyPrint?: boolean) => TypeEncoder;

package/dist/src/encoder/json-type-encoder.js

@@ -0,0 +1,6 @@
+export const createJsonTypeEncoder = (prettyPrint = false) => {
+    return {
+        encode: (data) => JSON.stringify(data, undefined, prettyPrint ? 4 : undefined),
+        contentType: 'application/json',
+    };
+};

package/dist/src/encoder/jsonx-type-encoder.d.ts

@@ -0,0 +1,2 @@
+import type { TypeEncoder } from './encoder.js';
+export declare const createJsonxTypeEncoder: (prettyPrint?: boolean) => TypeEncoder;

package/dist/src/encoder/jsonx-type-encoder.js

@@ -0,0 +1,173 @@
+import { XMLBuilder } from 'fast-xml-parser';
+import { throwableToError } from '@chubbyts/chubbyts-throwable-to-error/dist/throwable-to-error';
+import { isArray, isBoolean, isNumber, isObject, isString, isNull } from '../data.js';
+import { DATATYPE_ARRAY, DATATYPE_BOOLEAN, DATATYPE_NULL, DATATYPE_NUMBER, DATATYPE_OBJECT, DATATYPE_STRING, } from '../jsonx-datatypes.js';
+import { EncodeError } from './encoder.js';
+const encodeHtmlEntities = (string) => string.replace(/[\u00A0-\u9999<>&]/g, (i) => '&#' + i.charCodeAt(0) + ';');
+const createXmlNode = () => {
+    return {
+        '?xml': [
+            {
+                '#text': '',
+            },
+        ],
+        ':@': {
+            '@_version': '1.0',
+            '@_encoding': 'UTF-8',
+        },
+    };
+};
+const createJsonxAttributes = () => {
+    return {
+        ':@': {
+            '@_xsi:schemaLocation': 'http://www.datapower.com/schemas/json jsonx.xsd',
+            '@_xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
+            '@_xmlns:json': 'http://www.ibm.com/xmlns/prod/2009/jsonx',
+        },
+    };
+};
+const createNullNode = (key = undefined) => {
+    const node = {
+        [DATATYPE_NULL]: [],
+    };
+    if (key === undefined) {
+        return node;
+    }
+    return {
+        ...node,
+        ':@': {
+            '@_name': key,
+        },
+    };
+};
+const createBooleanNode = (value, key = undefined) => {
+    const node = {
+        [DATATYPE_BOOLEAN]: [
+            {
+                '#text': value,
+            },
+        ],
+    };
+    if (key === undefined) {
+        return node;
+    }
+    return {
+        ...node,
+        ':@': {
+            '@_name': key,
+        },
+    };
+};
+const createNumberNode = (value, key = undefined) => {
+    const node = {
+        [DATATYPE_NUMBER]: [
+            {
+                '#text': value,
+            },
+        ],
+    };
+    if (key === undefined) {
+        return node;
+    }
+    return {
+        ...node,
+        ':@': {
+            '@_name': key,
+        },
+    };
+};
+const createStringNode = (value, key = undefined) => {
+    const node = {
+        [DATATYPE_STRING]: [
+            {
+                '#text': value === value.trim() ? encodeHtmlEntities(value) : `<![CDATA[${encodeHtmlEntities(value)}]]>`,
+            },
+        ],
+    };
+    if (key === undefined) {
+        return node;
+    }
+    return {
+        ...node,
+        ':@': {
+            '@_name': key,
+        },
+    };
+};
+const createNode = (value, key = undefined) => {
+    if (isObject(value)) {
+        return createObjectNode(value, key);
+    }
+    else if (isArray(value)) {
+        return createArrayNode(value, key);
+    }
+    else if (isString(value)) {
+        return createStringNode(value, key);
+    }
+    else if (isNumber(value)) {
+        return createNumberNode(value, key);
+    }
+    else if (isBoolean(value)) {
+        return createBooleanNode(value, key);
+    }
+    else if (isNull(value)) {
+        return createNullNode(key);
+    }
+    throw new Error(`Unsupported value: ${JSON.stringify(value)}`);
+};
+const createArrayNode = (value, key = undefined) => {
+    const elements = value.map((subValue) => createNode(subValue));
+    const node = {
+        [DATATYPE_ARRAY]: elements,
+    };
+    if (key === undefined) {
+        return node;
+    }
+    return {
+        ...node,
+        ':@': {
+            '@_name': key,
+        },
+    };
+};
+const createObjectNode = (value, key = undefined) => {
+    const elements = Object.entries(value).map(([subKey, subValue]) => createNode(subValue, subKey));
+    const node = {
+        [DATATYPE_OBJECT]: elements,
+    };
+    if (key === undefined) {
+        return node;
+    }
+    return {
+        ...node,
+        ':@': {
+            '@_name': key,
+        },
+    };
+};
+export const createJsonxTypeEncoder = (prettyPrint = false) => {
+    const builder = new XMLBuilder({
+        preserveOrder: true,
+        ignoreAttributes: false,
+        processEntities: false,
+        format: prettyPrint,
+    });
+    return {
+        encode: (data) => {
+            try {
+                return builder.build([
+                    createXmlNode(),
+                    {
+                        ...createNode(data),
+                        ...createJsonxAttributes(),
+                    },
+                ]);
+            }
+            catch (e) {
+                const error = throwableToError(e);
+                throw new EncodeError(error.message, error.stack);
+            }
+        },
+        contentType: 'application/jsonx+xml',
+    };
+};

package/dist/src/encoder/url-encoded-type-encoder.d.ts

@@ -0,0 +1,2 @@
+import type { TypeEncoder } from './encoder.js';
+export declare const createUrlEncodedTypeEncoder: () => TypeEncoder;

package/dist/src/encoder/url-encoded-type-encoder.js

@@ -0,0 +1,20 @@
+import { stringify } from 'qs';
+import { isArray, isNull, isObject } from '../data.js';
+const encodeValue = (value) => {
+    if (isObject(value)) {
+        return Object.fromEntries(Object.entries(value).map(([subKey, subValue]) => [subKey, encodeValue(subValue)]));
+    }
+    if (isArray(value)) {
+        return value.map(encodeValue);
+    }
+    if (isNull(value)) {
+        return 'null';
+    }
+    return value;
+};
+export const createUrlEncodedTypeEncoder = () => {
+    return {
+        encode: (data) => stringify(encodeValue(data), { encodeValuesOnly: true }),
+        contentType: 'application/x-www-form-urlencoded',
+    };
+};

package/dist/src/encoder/yaml-type-encoder.d.ts

@@ -0,0 +1,2 @@
+import type { TypeEncoder } from './encoder.js';
+export declare const createYamlTypeEncoder: () => TypeEncoder;

package/dist/src/encoder/yaml-type-encoder.js

@@ -0,0 +1,7 @@
+import { stringify } from 'yaml';
+export const createYamlTypeEncoder = () => {
+    return {
+        encode: (data) => stringify(data, { indent: 4 }),
+        contentType: 'application/x-yaml',
+    };
+};

package/dist/src/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @deprecated This file re-exports the old API. Use './data.ts' directly instead.
+ */
+export { isNull, isBoolean, isNumber, isString, isArray, isObject } from './data.js';
+export type { Data } from './data.js';

package/dist/src/index.js

@@ -0,0 +1,4 @@
+/**
+ * @deprecated This file re-exports the old API. Use './data.ts' directly instead.
+ */
+export { isNull, isBoolean, isNumber, isString, isArray, isObject } from './data.js';

package/dist/src/jsonx-datatypes.d.ts

@@ -0,0 +1,36 @@
+export declare const DATATYPE_OBJECT = "json:object";
+export declare const DATATYPE_ARRAY = "json:array";
+export declare const DATATYPE_BOOLEAN = "json:boolean";
+export declare const DATATYPE_STRING = "json:string";
+export declare const DATATYPE_NUMBER = "json:number";
+export declare const DATATYPE_NULL = "json:null";
+export type WithName = {
+    ':@': {
+        '@_name': string;
+    };
+};
+export type JsonxNullNode = {
+    [DATATYPE_NULL]: Array<never>;
+};
+export type JsonxBooleanNode = {
+    [DATATYPE_BOOLEAN]: Array<{
+        '#text': boolean;
+    }>;
+};
+export type JsonxNumberNode = {
+    [DATATYPE_NUMBER]: Array<{
+        '#text': number;
+    }>;
+};
+export type JsonxStringNode = {
+    [DATATYPE_STRING]: Array<{
+        '#text': string;
+    }>;
+};
+export type JsonxArrayNode = {
+    [DATATYPE_ARRAY]: Array<JsonxNullNode | JsonxBooleanNode | JsonxNumberNode | JsonxStringNode | JsonxArrayNode | JsonxObjectNode>;
+};
+export type JsonxObjectNode = {
+    [DATATYPE_OBJECT]: Array<JsonxNullNode | JsonxBooleanNode | JsonxNumberNode | JsonxStringNode | JsonxArrayNode | JsonxObjectNode>;
+};
+export type JsonxNode = JsonxNullNode | JsonxBooleanNode | JsonxNumberNode | JsonxStringNode | JsonxArrayNode | JsonxObjectNode;

package/dist/src/jsonx-datatypes.js

@@ -0,0 +1,6 @@
+export const DATATYPE_OBJECT = 'json:object';
+export const DATATYPE_ARRAY = 'json:array';
+export const DATATYPE_BOOLEAN = 'json:boolean';
+export const DATATYPE_STRING = 'json:string';
+export const DATATYPE_NUMBER = 'json:number';
+export const DATATYPE_NULL = 'json:null';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@chubbyts/chubbyts-decode-encode",
   "type": "module",
-  "version": "2.1.2",
+  "version": "2.2.0",
   "description": "A simple decode/encode solution for json / jsonx / url-encoded / xml / yaml.",
   "keywords": [
     "chubbyts",
@@ -51,22 +51,22 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@chubbyts/chubbyts-throwable-to-error": "^2.0.4",
-    "fast-xml-parser": "^5.5.6",
-    "qs": "^6.15.0",
-    "yaml": "^2.8.2"
+    "@chubbyts/chubbyts-throwable-to-error": "^2.1.0",
+    "fast-xml-parser": "^5.5.11",
+    "qs": "^6.15.1",
+    "yaml": "^2.8.3"
   },
   "devDependencies": {
-    "@chubbyts/chubbyts-eslint": "^5.0.0",
-    "@chubbyts/chubbyts-function-mock": "^2.0.4",
-    "@stryker-mutator/core": "^9.6.0",
-    "@stryker-mutator/vitest-runner": "^9.6.0",
-    "@types/node": "^25.5.0",
+    "@chubbyts/chubbyts-eslint": "^5.1.0",
+    "@chubbyts/chubbyts-function-mock": "^2.1.0",
+    "@stryker-mutator/core": "^9.6.1",
+    "@stryker-mutator/vitest-runner": "^9.6.1",
+    "@types/node": "^25.6.0",
     "@types/qs": "^6.15.0",
-    "@vitest/coverage-v8": "^4.1.0",
-    "prettier": "^3.8.1",
-    "typescript": "^5.9.3",
-    "vitest": "^4.1.0"
+    "@vitest/coverage-v8": "^4.1.4",
+    "prettier": "^3.8.2",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.4"
   },
   "publishConfig": {
     "access": "public"