@chubbyts/chubbyts-decode-encode 2.5.0 → 2.5.1

package/README.md

@@ -37,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.5.0
+npm i @chubbyts/chubbyts-decode-encode@^2.5.1
 ```
 
 ## Usage
@@ -178,28 +178,22 @@ const contentType = yamlTypeEncoder.contentType;
 
 ### 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):
+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`:
+
+ * `typeDecodersServiceFactory`: all shipped type decoders (json, jsonx, urlencoded, yaml)
+ * `typeEncodersServiceFactory`: all shipped type encoders (json, jsonx, urlencoded, yaml), `config.debug` enables pretty printing for json / jsonx
+ * `decoderServiceFactory`: the decoder, built from the `typeDecoders` service if registered, the shipped type decoders otherwise
+ * `encoderServiceFactory`: the encoder, built from the `typeEncoders` service if registered, the shipped type encoders otherwise
 
 ```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,
-  },
+  debug: false,
   dependencies: {
     factories: new Map<string, ConfigFactory>([
       ['decoder', decoderServiceFactory()],
@@ -212,32 +206,39 @@ 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.
+To replace the type decoders / encoders, register a `typeDecoders` / `typeEncoders` service:
+
+```ts
+import type { TypeDecoder } from '@chubbyts/chubbyts-decode-encode/dist/decoder/decoder';
+import { createJsonTypeDecoder } from '@chubbyts/chubbyts-decode-encode/dist/decoder/json-type-decoder';
+
+const container = createContainerByConfigFactory({
+  dependencies: {
+    factories: new Map<string, ConfigFactory>([
+      ['decoder', decoderServiceFactory()],
+      ['typeDecoders', (): Array<TypeDecoder> => [createJsonTypeDecoder(), createCustomTypeDecoder()]],
+    ]),
+  },
+})();
+```
 
 #### 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`, ...).
+To use different decoders / encoders in different parts of an application, the same factories can be registered multiple times with a name, which gets appended to each service id (`decoderapi`, `typeDecodersapi`, ...).
 
 ```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>([
+      ['decoder', decoderServiceFactory()],
       ['decoderapi', decoderServiceFactory('api')],
-      ['encoderapi', encoderServiceFactory('api')],
-      ['decoderadmin', decoderServiceFactory('admin')],
-      ['encoderadmin', encoderServiceFactory('admin')],
+      ['typeDecodersapi', (): Array<TypeDecoder> => [createJsonTypeDecoder()]],
     ]),
   },
 })();
 
-const apiDecoder = container.get<Decoder>('decoderapi');
-const adminEncoder = container.get<Encoder>('encoderadmin');
+const decoder = container.get<Decoder>('decoder'); // all shipped type decoders
+const apiDecoder = container.get<Decoder>('decoderapi'); // json only
 ```
 
 ## Copyright

package/dist/service-factory.d.ts

@@ -1,37 +1,6 @@
-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>;
+export declare const typeDecodersServiceFactory: import("@chubbyts/chubbyts-dic-config-factory/dist/dic-config-factory").AbstractFactory<TypeDecoder[]>;
+export declare const decoderServiceFactory: import("@chubbyts/chubbyts-dic-config-factory/dist/dic-config-factory").AbstractFactory<Decoder>;
+export declare const typeEncodersServiceFactory: import("@chubbyts/chubbyts-dic-config-factory/dist/dic-config-factory").AbstractFactory<TypeEncoder[]>;
+export declare const encoderServiceFactory: import("@chubbyts/chubbyts-dic-config-factory/dist/dic-config-factory").AbstractFactory<Encoder>;

package/dist/service-factory.js

@@ -9,64 +9,21 @@ 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);
-    }));
+export const typeDecodersServiceFactory = createAbstractFactory(() => {
+    return [createJsonTypeDecoder(), createJsonxTypeDecoder(), createUrlEncodedTypeDecoder(), createYamlTypeDecoder()];
+});
+export const decoderServiceFactory = createAbstractFactory((container, { resolveDependency }) => {
+    return createDecoder(resolveDependency(container, 'typeDecoders', typeDecodersServiceFactory));
+});
+export const typeEncodersServiceFactory = createAbstractFactory((container) => {
+    const { debug = false } = container.get('config');
+    return [
+        createJsonTypeEncoder(debug),
+        createJsonxTypeEncoder(debug),
+        createUrlEncodedTypeEncoder(),
+        createYamlTypeEncoder(),
+    ];
+});
+export const encoderServiceFactory = createAbstractFactory((container, { resolveDependency }) => {
+    return createEncoder(resolveDependency(container, 'typeEncoders', typeEncodersServiceFactory));
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@chubbyts/chubbyts-decode-encode",
   "type": "module",
-  "version": "2.5.0",
+  "version": "2.5.1",
   "description": "A simple decode/encode solution for json / jsonx / url-encoded / xml / yaml.",
   "keywords": [
     "chubbyts",