@chubbyts/chubbyts-decode-encode 2.4.1 → 2.5.0

package/README.md

@@ -24,6 +24,8 @@ A simple decode/encode solution for json / jsonx / url-encoded / xml / yaml.
 ## Requirements
 
  * node: 22
+ * [@chubbyts/chubbyts-dic-config-factory][9]: ^1.0.0
+ * [@chubbyts/chubbyts-dic-types][7]: ^2.3.0
  * [@chubbyts/chubbyts-throwable-to-error][2]: ^2.3.0
  * [fast-xml-builder][3]: ^1.3.0
  * [fast-xml-parser][4]: ^5.10.1
@@ -35,7 +37,7 @@ A simple decode/encode solution for json / jsonx / url-encoded / xml / yaml.
 Through [NPM](https://www.npmjs.com) as [@chubbyts/chubbyts-decode-encode][1].
 
 ```ts
-npm i @chubbyts/chubbyts-decode-encode@^2.4.1
+npm i @chubbyts/chubbyts-decode-encode@^2.5.0
 ```
 
 ## Usage
@@ -174,6 +176,70 @@ const contentType = yamlTypeEncoder.contentType;
 // contentTypes: 'application/x-yaml'
 ```
 
+### Service factories (chubbyts-dic-config)
+
+The package ships service factories (abstract factories built on [chubbyts-dic-config-factory][9]) for a [chubbyts-dic-config][8] (or any [chubbyts-dic-types][7] compatible) container within `@chubbyts/chubbyts-decode-encode/dist/service-factory`, configured through `config.chubbyts.decodeEncode` (everything optional):
+
+```ts
+import type { ConfigFactory } from '@chubbyts/chubbyts-dic-config/dist/dic-config';
+import { createContainerByConfigFactory } from '@chubbyts/chubbyts-dic-config/dist/dic-config';
+import type { Decoder } from '@chubbyts/chubbyts-decode-encode/dist/decoder/decoder';
+import type { Encoder } from '@chubbyts/chubbyts-decode-encode/dist/encoder/encoder';
+import type { DecodeEncodeConfig } from '@chubbyts/chubbyts-decode-encode/dist/service-factory';
+import { decoderServiceFactory, encoderServiceFactory } from '@chubbyts/chubbyts-decode-encode/dist/service-factory';
+
+const container = createContainerByConfigFactory({
+  chubbyts: {
+    decodeEncode: {
+      decoder: {
+        // typeDecoders: ['jsonTypeDecoder', 'jsonxTypeDecoder', 'urlEncodedTypeDecoder', 'yamlTypeDecoder'],
+      },
+      encoder: {
+        // typeEncoders: ['jsonTypeEncoder', 'jsonxTypeEncoder', 'urlEncodedTypeEncoder', 'yamlTypeEncoder'],
+        // prettyPrint: false,
+      },
+    } satisfies DecodeEncodeConfig,
+  },
+  dependencies: {
+    factories: new Map<string, ConfigFactory>([
+      ['decoder', decoderServiceFactory()],
+      ['encoder', encoderServiceFactory()],
+    ]),
+  },
+})();
+
+const decoder = container.get<Decoder>('decoder');
+const encoder = container.get<Encoder>('encoder');
+```
+
+The `decoderServiceFactory` / `encoderServiceFactory` use the services listed in `typeDecoders` / `typeEncoders` (defaults to all shipped ones, order matters) of the container if registered, and creates the shipped ones through `jsonTypeDecoderServiceFactory`, `jsonxTypeDecoderServiceFactory`, `urlEncodedTypeDecoderServiceFactory`, `yamlTypeDecoderServiceFactory` / `jsonTypeEncoderServiceFactory`, `jsonxTypeEncoderServiceFactory`, `urlEncodedTypeEncoderServiceFactory`, `yamlTypeEncoderServiceFactory` otherwise. Register any of them under its name to replace it or to share it with other services, any other id (e.g. `customTypeDecoder`) has to be registered. `prettyPrint` is passed to the json / jsonx type encoders.
+
+#### With names
+
+To use different decoders / encoders in different parts of an application, the same factories can be registered multiple times with a name: the config is then read from `config.chubbyts.decodeEncode.<name>` and the name gets appended to each service id (`decoderapi`, `jsonTypeDecoderapi`, `customTypeDecoderapi`, ...).
+
+```ts
+const container = createContainerByConfigFactory({
+  chubbyts: {
+    decodeEncode: {
+      api: { decoder: { typeDecoders: ['jsonTypeDecoder'] }, encoder: { typeEncoders: ['jsonTypeEncoder'] } },
+      admin: { encoder: { prettyPrint: true } },
+    } satisfies Record<string, DecodeEncodeConfig>,
+  },
+  dependencies: {
+    factories: new Map<string, ConfigFactory>([
+      ['decoderapi', decoderServiceFactory('api')],
+      ['encoderapi', encoderServiceFactory('api')],
+      ['decoderadmin', decoderServiceFactory('admin')],
+      ['encoderadmin', encoderServiceFactory('admin')],
+    ]),
+  },
+})();
+
+const apiDecoder = container.get<Decoder>('decoderapi');
+const adminEncoder = container.get<Encoder>('encoderadmin');
+```
+
 ## Copyright
 
 2026 Dominik Zogg
@@ -184,3 +250,6 @@ const contentType = yamlTypeEncoder.contentType;
 [4]: https://www.npmjs.com/package/fast-xml-parser
 [5]: https://www.npmjs.com/package/qs
 [6]: https://www.npmjs.com/package/yaml
+[7]: https://www.npmjs.com/package/@chubbyts/chubbyts-dic-types
+[8]: https://www.npmjs.com/package/@chubbyts/chubbyts-dic-config
+[9]: https://www.npmjs.com/package/@chubbyts/chubbyts-dic-config-factory

package/dist/service-factory.d.ts

@@ -0,0 +1,37 @@
+import type { AbstractFactory } from '@chubbyts/chubbyts-dic-config-factory/dist/dic-config-factory';
+import type { Decoder, TypeDecoder } from './decoder/decoder.js';
+import type { Encoder, TypeEncoder } from './encoder/encoder.js';
+/**
+ * The configuration read by the service factories from `config.chubbyts.decodeEncode` (or
+ * `config.chubbyts.decodeEncode.<name>` for named factories). Everything is optional.
+ */
+export type DecodeEncodeConfig = {
+    decoder?: {
+        /**
+         * Service ids of the type decoders (order matters), defaults to all shipped ones:
+         * `jsonTypeDecoder`, `jsonxTypeDecoder`, `urlEncodedTypeDecoder`, `yamlTypeDecoder`.
+         */
+        typeDecoders?: Array<string>;
+    };
+    encoder?: {
+        /**
+         * Service ids of the type encoders (order matters), defaults to all shipped ones:
+         * `jsonTypeEncoder`, `jsonxTypeEncoder`, `urlEncodedTypeEncoder`, `yamlTypeEncoder`.
+         */
+        typeEncoders?: Array<string>;
+        /**
+         * Pretty print the output of the json / jsonx type encoders, defaults to `false`.
+         */
+        prettyPrint?: boolean;
+    };
+};
+export declare const jsonTypeDecoderServiceFactory: AbstractFactory<TypeDecoder>;
+export declare const jsonxTypeDecoderServiceFactory: AbstractFactory<TypeDecoder>;
+export declare const urlEncodedTypeDecoderServiceFactory: AbstractFactory<TypeDecoder>;
+export declare const yamlTypeDecoderServiceFactory: AbstractFactory<TypeDecoder>;
+export declare const decoderServiceFactory: AbstractFactory<Decoder>;
+export declare const jsonTypeEncoderServiceFactory: AbstractFactory<TypeEncoder>;
+export declare const jsonxTypeEncoderServiceFactory: AbstractFactory<TypeEncoder>;
+export declare const urlEncodedTypeEncoderServiceFactory: AbstractFactory<TypeEncoder>;
+export declare const yamlTypeEncoderServiceFactory: AbstractFactory<TypeEncoder>;
+export declare const encoderServiceFactory: AbstractFactory<Encoder>;

package/dist/service-factory.js

@@ -0,0 +1,72 @@
+import { createAbstractFactory } from '@chubbyts/chubbyts-dic-config-factory/dist/dic-config-factory';
+import { createDecoder } from './decoder/decoder.js';
+import { createJsonTypeDecoder } from './decoder/json-type-decoder.js';
+import { createJsonxTypeDecoder } from './decoder/jsonx-type-decoder.js';
+import { createUrlEncodedTypeDecoder } from './decoder/url-encoded-type-decoder.js';
+import { createYamlTypeDecoder } from './decoder/yaml-type-decoder.js';
+import { createEncoder } from './encoder/encoder.js';
+import { createJsonTypeEncoder } from './encoder/json-type-encoder.js';
+import { createJsonxTypeEncoder } from './encoder/jsonx-type-encoder.js';
+import { createUrlEncodedTypeEncoder } from './encoder/url-encoded-type-encoder.js';
+import { createYamlTypeEncoder } from './encoder/yaml-type-encoder.js';
+const resolveDecodeEncodeConfig = (container, resolveConfig) => {
+    return resolveConfig(container.get('config').chubbyts?.decodeEncode ?? {});
+};
+export const jsonTypeDecoderServiceFactory = createAbstractFactory(() => {
+    return createJsonTypeDecoder();
+});
+export const jsonxTypeDecoderServiceFactory = createAbstractFactory(() => {
+    return createJsonxTypeDecoder();
+});
+export const urlEncodedTypeDecoderServiceFactory = createAbstractFactory(() => {
+    return createUrlEncodedTypeDecoder();
+});
+export const yamlTypeDecoderServiceFactory = createAbstractFactory(() => {
+    return createYamlTypeDecoder();
+});
+const typeDecoderServiceFactories = new Map([
+    ['jsonTypeDecoder', jsonTypeDecoderServiceFactory],
+    ['jsonxTypeDecoder', jsonxTypeDecoderServiceFactory],
+    ['urlEncodedTypeDecoder', urlEncodedTypeDecoderServiceFactory],
+    ['yamlTypeDecoder', yamlTypeDecoderServiceFactory],
+]);
+export const decoderServiceFactory = createAbstractFactory((container, { name, resolveConfig, resolveDependency }) => {
+    const { typeDecoders = Array.from(typeDecoderServiceFactories.keys()) } = resolveDecodeEncodeConfig(container, resolveConfig).decoder ?? {};
+    return createDecoder(typeDecoders.map((id) => {
+        const typeDecoderServiceFactory = typeDecoderServiceFactories.get(id);
+        // a registered service wins over the shipped factory, so that any part can be replaced or shared between services
+        return typeDecoderServiceFactory
+            ? resolveDependency(container, id, typeDecoderServiceFactory)
+            : container.get(id + name);
+    }));
+});
+export const jsonTypeEncoderServiceFactory = createAbstractFactory((container, { resolveConfig }) => {
+    const { prettyPrint } = resolveDecodeEncodeConfig(container, resolveConfig).encoder ?? {};
+    return createJsonTypeEncoder(prettyPrint);
+});
+export const jsonxTypeEncoderServiceFactory = createAbstractFactory((container, { resolveConfig }) => {
+    const { prettyPrint } = resolveDecodeEncodeConfig(container, resolveConfig).encoder ?? {};
+    return createJsonxTypeEncoder(prettyPrint);
+});
+export const urlEncodedTypeEncoderServiceFactory = createAbstractFactory(() => {
+    return createUrlEncodedTypeEncoder();
+});
+export const yamlTypeEncoderServiceFactory = createAbstractFactory(() => {
+    return createYamlTypeEncoder();
+});
+const typeEncoderServiceFactories = new Map([
+    ['jsonTypeEncoder', jsonTypeEncoderServiceFactory],
+    ['jsonxTypeEncoder', jsonxTypeEncoderServiceFactory],
+    ['urlEncodedTypeEncoder', urlEncodedTypeEncoderServiceFactory],
+    ['yamlTypeEncoder', yamlTypeEncoderServiceFactory],
+]);
+export const encoderServiceFactory = createAbstractFactory((container, { name, resolveConfig, resolveDependency }) => {
+    const { typeEncoders = Array.from(typeEncoderServiceFactories.keys()) } = resolveDecodeEncodeConfig(container, resolveConfig).encoder ?? {};
+    return createEncoder(typeEncoders.map((id) => {
+        const typeEncoderServiceFactory = typeEncoderServiceFactories.get(id);
+        // a registered service wins over the shipped factory, so that any part can be replaced or shared between services
+        return typeEncoderServiceFactory
+            ? resolveDependency(container, id, typeEncoderServiceFactory)
+            : container.get(id + name);
+    }));
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@chubbyts/chubbyts-decode-encode",
   "type": "module",
-  "version": "2.4.1",
+  "version": "2.5.0",
   "description": "A simple decode/encode solution for json / jsonx / url-encoded / xml / yaml.",
   "keywords": [
     "chubbyts",
@@ -54,6 +54,8 @@
     "node": ">=22"
   },
   "dependencies": {
+    "@chubbyts/chubbyts-dic-config-factory": "^1.0.0",
+    "@chubbyts/chubbyts-dic-types": "^2.3.0",
     "@chubbyts/chubbyts-throwable-to-error": "^2.3.0",
     "fast-xml-builder": "^1.3.0",
     "fast-xml-parser": "^5.10.1",
@@ -61,6 +63,7 @@
     "yaml": "^2.9.0"
   },
   "devDependencies": {
+    "@chubbyts/chubbyts-dic-config": "^2.3.0",
     "@chubbyts/chubbyts-function-mock": "^2.3.0",
     "@chubbyts/chubbyts-oxlint": "^1.0.0",
     "@stryker-mutator/core": "^9.6.1",