zibri 2.4.0 → 2.5.0

package/src/entity/decorators/property.decorator.ts

@@ -5,16 +5,16 @@ import { MetadataUtilities } from '../../utilities/metadata.utilities';
 import { AnyObject } from '../any-object.model';
 import type { BaseEntity } from '../base-entity.model';
 import { ArrayPropertyMetadata, ArrayPropertyMetadataInput, ArrayPropertyItemMetadataInput, ArrayPropertyItemMetadata } from '../models/array-property-metadata.model';
-import type { WithDefaultMetadata } from '../models/base-property-metadata.model';
+import { BelongsToOnePropertyMetadata, BelongsToOnePropertyMetadataInput } from '../models/belongs-to-one-property-metadata.model';
 import { BooleanPropertyMetadata, BooleanPropertyMetadataInput } from '../models/boolean-property-metadata.model';
 import { DatePropertyMetadata, DatePropertyMetadataInput } from '../models/date-property-metadata.model';
 import type { FilePropertyMetadata, FilePropertyMetadataInput } from '../models/file-property-metadata.model';
+import { HasOnePropertyMetadata, HasOnePropertyMetadataInput } from '../models/has-one-property-metadata.model';
 import { ManyToManyPropertyMetadata, ManyToManyPropertyMetadataInput } from '../models/many-to-many-property-metadata.model';
 import { ManyToOnePropertyMetadata, ManyToOnePropertyMetadataInput } from '../models/many-to-one-property-metadata.model';
 import { NumberPropertyMetadata, NumberPropertyMetadataInput } from '../models/number-property-metadata.model';
 import { ObjectPropertyMetadata, ObjectPropertyMetadataInput } from '../models/object-property-metadata.model';
 import { OneToManyPropertyMetadata, OneToManyPropertyMetadataInput } from '../models/one-to-many-property-metadata.model';
-import { OneToOnePropertyMetadata, OneToOnePropertyMetadataInput, HasOnePropertyMetadataInput, BelongsToOnePropertyMetadataInput } from '../models/one-to-one-property-metadata.model';
 import { Relation } from '../models/relation.enum';
 import { StringPropertyMetadata, StringPropertyMetadataInput } from '../models/string-property-metadata.model';
 import { UnknownPropertyMetadata, UnknownPropertyMetadataInput } from '../models/unknown-property-metadata.model';
@@ -38,7 +38,8 @@ export type PropertyMetadata = StringPropertyMetadata<any, any, any, any, any>
  */
 export type RelationMetadata<T extends BaseEntity> = ManyToOnePropertyMetadata<T>
     | OneToManyPropertyMetadata<T>
-    | OneToOnePropertyMetadata<T>
+    | HasOnePropertyMetadata<T>
+    | BelongsToOnePropertyMetadata<T>
     | ManyToManyPropertyMetadata<T>;
 
 /**
@@ -54,15 +55,14 @@ export type PropertyMetadataInput = StringPropertyMetadataInput<any, any, any, a
     | BooleanPropertyMetadataInput
     | UnknownPropertyMetadataInput;
 
-/**
- * The metadata input to define a relation property.
- */
-export type RelationMetadataInput<T extends BaseEntity> = ManyToOnePropertyMetadataInput<T>
-    | OneToManyPropertyMetadataInput<T>
-    | OneToOnePropertyMetadataInput<T>
-    | HasOnePropertyMetadataInput<T>
-    | BelongsToOnePropertyMetadataInput<T>
-    | ManyToManyPropertyMetadataInput<T>;
+// /**
+//  * The metadata input to define a relation property.
+//  */
+// export type RelationMetadataInput<T extends BaseEntity> = ManyToOnePropertyMetadataInput<T>
+//     | OneToManyPropertyMetadataInput<T>
+//     | HasOnePropertyMetadataInput<T>
+//     | BelongsToOnePropertyMetadataInput<T>
+//     | ManyToManyPropertyMetadataInput<T>;
 
 /**
  * Bundles decorators for properties.
@@ -99,7 +99,7 @@ export namespace Property {
             hash: false,
             ...data
         };
-        return applyData(fullMetadata, data);
+        return applyData(fullMetadata);
     }
 
     /**
@@ -122,7 +122,7 @@ export namespace Property {
             format: undefined,
             ...data
         };
-        return applyData(fullMetadata, data);
+        return applyData(fullMetadata);
     }
 
     /**
@@ -139,7 +139,7 @@ export namespace Property {
             exclude: false,
             ...data
         };
-        return applyData(fullMetadata, data);
+        return applyData(fullMetadata);
     }
 
     /**
@@ -158,7 +158,7 @@ export namespace Property {
             excludeFromChangeSets: typeof data?.exclude === 'boolean' ? data.exclude : false,
             ...data
         };
-        return applyData(fullMetadata, data);
+        return applyData(fullMetadata);
     }
 
     /**
@@ -175,7 +175,7 @@ export namespace Property {
             allowAdditionalProperties: false,
             ...data
         };
-        return applyData(fullMetadata, data);
+        return applyData(fullMetadata);
     }
 
     /**
@@ -249,24 +249,35 @@ export namespace Property {
             excludeFromChangeSets: typeof data?.exclude === 'boolean' ? data.exclude : false,
             ...data
         };
-        return applyData(fullMetadata, data);
+        return applyData(fullMetadata);
     }
 
+    // eslint-disable-next-line jsdoc/require-returns
     /**
      * Defines a many to one property.
      * @param metadata - Additional data to specify the property.
      */
-    export function manyToOne<T extends BaseEntity>(metadata: ManyToOnePropertyMetadataInput<T>): PropertyDecorator {
+    export function manyToOne<T extends BaseEntity, TJoinKey extends string>(
+        metadata: ManyToOnePropertyMetadataInput<T, TJoinKey>
+    ) {
         const fullMetadata: ManyToOnePropertyMetadata<T> = {
             required: true,
             type: Relation.MANY_TO_ONE,
             cascade: [],
             description: undefined,
+            joinColumn: undefined,
             exclude: false,
             excludeFromChangeSets: typeof metadata?.exclude === 'boolean' ? metadata.exclude : false,
             ...metadata
         };
-        return applyData(fullMetadata as PropertyMetadata, metadata);
+
+        // eslint-disable-next-line typescript/no-explicit-any
+        return <TCurrentEntity extends Partial<Record<TJoinKey, any>>>(
+            target: TCurrentEntity,
+            propertyKey: string | symbol
+        ): void => {
+            applyData(fullMetadata as PropertyMetadata)(target, propertyKey);
+        };
     }
 
     /**
@@ -283,7 +294,7 @@ export namespace Property {
             excludeFromChangeSets: typeof metadata?.exclude === 'boolean' ? metadata.exclude : false,
             ...metadata
         };
-        return applyData(fullMetadata as PropertyMetadata, metadata);
+        return applyData(fullMetadata as PropertyMetadata);
     }
 
     /**
@@ -291,35 +302,44 @@ export namespace Property {
      * @param metadata - Additional data to specify the property.
      */
     export function hasOne<T extends BaseEntity>(metadata: HasOnePropertyMetadataInput<T>): PropertyDecorator {
-        const fullMetadata: OneToOnePropertyMetadata<T> = {
+        const fullMetadata: HasOnePropertyMetadata<T> = {
             required: true,
-            type: Relation.ONE_TO_ONE,
+            type: Relation.HAS_ONE,
             cascade: ['remove', 'insert', 'update'],
-            joinColumn: false,
             description: undefined,
             exclude: false,
             excludeFromChangeSets: typeof metadata?.exclude === 'boolean' ? metadata.exclude : false,
             ...metadata
         };
-        return applyData(fullMetadata as PropertyMetadata, metadata);
+        return applyData(fullMetadata as PropertyMetadata);
     }
 
+    // eslint-disable-next-line jsdoc/require-returns
     /**
      * Defines a belongs to one property.
      * @param metadata - Additional data to specify the property.
      */
-    export function belongsToOne<T extends BaseEntity>(metadata: BelongsToOnePropertyMetadataInput<T>): PropertyDecorator {
-        const fullMetadata: OneToOnePropertyMetadata<T> = {
+    export function belongsToOne<T extends BaseEntity, TJoinKey extends string>(
+        metadata: BelongsToOnePropertyMetadataInput<T, TJoinKey>
+    ) {
+        const fullMetadata: BelongsToOnePropertyMetadata<T> = {
             required: true,
-            type: Relation.ONE_TO_ONE,
+            type: Relation.BELONGS_TO_ONE,
             cascade: [],
-            joinColumn: true,
+            joinColumn: undefined,
             description: undefined,
             exclude: false,
             excludeFromChangeSets: typeof metadata?.exclude === 'boolean' ? metadata.exclude : false,
             ...metadata
         };
-        return applyData(fullMetadata as PropertyMetadata, metadata);
+
+        // eslint-disable-next-line typescript/no-explicit-any
+        return <TCurrentEntity extends Partial<Record<TJoinKey, any>>>(
+            target: TCurrentEntity,
+            propertyKey: string | symbol
+        ): void => {
+            applyData(fullMetadata as PropertyMetadata)(target, propertyKey);
+        };
     }
 
     /**
@@ -330,23 +350,21 @@ export namespace Property {
         const fullMetadata: ManyToManyPropertyMetadata<T> = {
             required: true,
             type: Relation.MANY_TO_MANY,
-            cascade: [],
+            cascade: metadata.joinTable === true ? ['remove'] : [],
             description: undefined,
+            joinTable: undefined,
             persistence: true,
             exclude: false,
             excludeFromChangeSets: typeof metadata?.exclude === 'boolean' ? metadata.exclude : false,
             ...metadata
         };
-        return applyData(fullMetadata as PropertyMetadata, metadata);
+        return applyData(fullMetadata as PropertyMetadata);
     }
 }
 
 // eslint-disable-next-line jsdoc/require-jsdoc
-function applyData(data: PropertyMetadata, inputData: PropertyMetadataInput | undefined): PropertyDecorator {
+function applyData(data: PropertyMetadata): PropertyDecorator {
     return (target, key) => {
-        if (inputData?.required != undefined && (inputData as WithDefaultMetadata<string>).default != undefined) {
-            warn(`${target.constructor.name}.${key.toString()}: setting "required" won't have any effect, because "default" is also set.`);
-        }
         if ('primary' in data && data.primary && data.exclude !== false) {
             throw new Error(`${target.constructor.name}.${key.toString()}: Cannot mark a primary key with "exclude."`);
         }

package/src/entity/entity-metadata-missing.error.ts

@@ -0,0 +1,15 @@
+import { BaseEntity } from './base-entity.model';
+import { Newable } from '../types/newable.type';
+
+/**
+ * An error that gets thrown when entity metadata that is required is missing.
+ */
+export class EntityMetadataMissingError extends Error {
+    constructor(entity: Newable<BaseEntity>, usage: string = '') {
+        super([
+            `Could not find entity metadata for ${entity.name} ${usage}`,
+            'Did you forget to decorate it with @Entity?'
+        ].join('\n'));
+        this.name = 'EntityMetadataMissingError';
+    }
+}

package/src/entity/generation/generate-entity-file.function.ts

@@ -176,7 +176,7 @@ function mapSchemaToDecoratorLines(
                 }
                 return ['    @Property.date({ required: false })'];
             }
-            // TODO
+            // TODO handle enums in entity generation
             // if (schema.enum) {
             //     return { type: schema.enum.map(v => JsonUtilities.stringify(v)).join(' | '), isRef: false };
             // }

package/src/entity/models/base-relation-metadata.model.ts

@@ -16,7 +16,7 @@ export type BaseRelationMetadata<T extends BaseEntity> = BasePropertyMetadata
         target: () => Newable<T>,
         /**
          * The name of the inverse property on the target,
-         * e.g. 'user' if Posts has `@ManyToOne(() => User, 'post')`.
+         * e.g. 'user' if Posts has `@Property.manyToOne(() => User, 'post')`.
          */
         inverseSide: keyof T
     };

package/src/entity/models/belongs-to-one-property-metadata.model.ts

@@ -0,0 +1,34 @@
+import { OmitStrict } from '../../types/omit-strict.type';
+import { BaseEntity } from '../base-entity.model';
+import { BaseRelationMetadata } from './base-relation-metadata.model';
+import { Relation } from './relation.enum';
+
+/**
+ * Metadata for belongs to one properties.
+ */
+export type BelongsToOnePropertyMetadata<T extends BaseEntity> = BaseRelationMetadata<T> & {
+    /**
+     * The type of the property.
+     */
+    type: Relation.BELONGS_TO_ONE,
+    /**
+     * The column on the current entity that holds the foreign key.
+     */
+    joinColumn: string | undefined
+};
+
+/**
+ * Input Metadata for belongs to one properties.
+ */
+export type BelongsToOnePropertyMetadataInput<
+    T extends BaseEntity,
+    TJoinKey extends string
+> = Partial<OmitStrict<BelongsToOnePropertyMetadata<T>, 'type'>>
+    & Pick<BelongsToOnePropertyMetadata<T>, 'target' | 'inverseSide'>
+    & {
+        /**
+         * The column on the current entity that holds the foreign key.
+         * Must be an existing key on the decorated class.
+         */
+        joinColumn?: TJoinKey
+    };

package/src/entity/models/has-one-property-metadata.model.ts

@@ -0,0 +1,20 @@
+import { OmitStrict } from '../../types/omit-strict.type';
+import { BaseEntity } from '../base-entity.model';
+import { BaseRelationMetadata } from './base-relation-metadata.model';
+import { Relation } from './relation.enum';
+
+/**
+ * Metadata for has one properties.
+ */
+export type HasOnePropertyMetadata<T extends BaseEntity> = BaseRelationMetadata<T> & {
+    /**
+     * The type of the property.
+     */
+    type: Relation.HAS_ONE
+};
+
+/**
+ * Input Metadata for has one properties.
+ */
+export type HasOnePropertyMetadataInput<T extends BaseEntity> = Partial<OmitStrict<HasOnePropertyMetadata<T>, 'type'>>
+    & Pick<HasOnePropertyMetadata<T>, 'target' | 'inverseSide'>;

package/src/entity/models/many-to-many-property-metadata.model.ts

@@ -14,14 +14,14 @@ export type ManyToManyPropertyMetadata<T extends BaseEntity> = BaseRelationMetad
     /**
      * Whether or not this entity should own the join table.
      */
-    joinTable: boolean,
+    joinTable: boolean | undefined,
     /**
      * Indicates if persistence is enabled for the relation.
      * By default its enabled, but if you want to avoid any changes
      * in the relation to be reflected in the data source you can disable it.
      * If its disabled you can only change a relation from inverse side
      * of a relation or using relation query builder functionality.
-     * This is useful for performance optimization since its disabling avoid
+     * This is useful for performance optimization since its disabling avoids
      * multiple extra queries during entity save.
      */
     persistence: boolean
@@ -31,4 +31,4 @@ export type ManyToManyPropertyMetadata<T extends BaseEntity> = BaseRelationMetad
  * Input Metadata for many to many properties.
  */
 export type ManyToManyPropertyMetadataInput<T extends BaseEntity> = Partial<OmitStrict<ManyToManyPropertyMetadata<T>, 'type'>>
-    & Pick<ManyToManyPropertyMetadata<T>, 'target' | 'joinTable' | 'inverseSide'>;
+    & Pick<ManyToManyPropertyMetadata<T>, 'target' | 'inverseSide'>;

package/src/entity/models/many-to-one-property-metadata.model.ts

@@ -10,11 +10,25 @@ export type ManyToOnePropertyMetadata<T extends BaseEntity> = BaseRelationMetada
     /**
      * The type of the property.
      */
-    type: Relation.MANY_TO_ONE
+    type: Relation.MANY_TO_ONE,
+    /**
+     * The column on the current entity that holds the foreign key.
+     */
+    joinColumn: string | undefined
 };
 
 /**
  * Input Metadata for many to one properties.
  */
-export type ManyToOnePropertyMetadataInput<T extends BaseEntity> = Partial<OmitStrict<ManyToOnePropertyMetadata<T>, 'type'>>
-    & Pick<ManyToOnePropertyMetadata<T>, 'target' | 'inverseSide'>;
+export type ManyToOnePropertyMetadataInput<
+    T extends BaseEntity,
+    TJoinKey extends string
+> = Partial<OmitStrict<ManyToOnePropertyMetadata<T>, 'type' | 'joinColumn'>>
+    & Pick<ManyToOnePropertyMetadata<T>, 'target' | 'inverseSide'>
+    & {
+        /**
+         * The column on the current entity that holds the foreign key.
+         * Must be an existing key on the decorated class.
+         */
+        joinColumn?: TJoinKey
+    };

package/src/entity/models/relation.enum.ts

@@ -2,7 +2,8 @@
  * All possible relations.
  */
 export enum Relation {
-    ONE_TO_ONE = 'one-to-one',
+    HAS_ONE = 'has-one',
+    BELONGS_TO_ONE = 'belongs-to-one',
     ONE_TO_MANY = 'one-to-many',
     MANY_TO_ONE = 'many-to-one',
     MANY_TO_MANY = 'many-to-many'

package/src/entity/partial-class.model.ts

@@ -17,7 +17,7 @@ export function PartialClass<T>(
     const original: Record<string, PropertyMetadata> = MetadataUtilities.getModelProperties(Base);
     const partialMeta: Record<string, PropertyMetadata> = {};
     for (const [prop, meta] of ObjectUtilities.entries(original)) {
-        partialMeta[prop] = 'required' in meta ? { ...meta, required: false } : meta;
+        partialMeta[prop] = { ...meta, required: false };
     }
     MetadataUtilities.setModelProperties(PartialClass, partialMeta);
 

package/src/event/event-cleanup.cron-job.ts

@@ -28,12 +28,10 @@ export class EventCleanupCronJob extends CronJob {
         await this.logger.info('cleans up past events');
 
         try {
-            // const yesterday: Date = new Date(Date.now() - Ms.DAY);
-            const events: Event<unknown>[] = (await this.repository.findAll({
-                where: { status: EventStatus.FINISHED },
-                relations: ['eventSubscriberRuns']
-            })).filter(e => Date.now() > new Date(e.cleanupAt).getTime());
-            const res: Event<unknown>[] = await this.repository.deleteAll({ id: { oneOf: events.map(e => e.id) } });
+            const res: Event<unknown>[] = await this.repository.deleteAll({
+                status: EventStatus.FINISHED,
+                cleanupAt: { before: new Date() }
+            });
             await this.logger.info(`removed ${res.length} events`);
         }
         catch {

package/src/event/event-subscriber-run.model.ts

@@ -2,7 +2,7 @@ import { Event } from './event.model';
 import { BaseEntity } from '../entity/base-entity.model';
 import { Entity } from '../entity/decorators/entity.decorator';
 import { Property } from '../entity/decorators/property.decorator';
-import { OmitClass } from '../entity/omit-class.model';
+import { OmitStrict } from '../types/omit-strict.type';
 
 /**
  * Data of a event subscriber run.
@@ -17,8 +17,13 @@ export class EventSubscriberRun<T> extends BaseEntity {
     /**
      * The event that triggered this run.
      */
-    @Property.manyToOne({ target: () => Event, inverseSide: 'eventSubscriberRuns' })
+    @Property.manyToOne({ target: () => Event, joinColumn: 'eventId', inverseSide: 'eventSubscriberRuns' })
     event!: Event<T>;
+    /**
+     * The id of the event that this run belongs to.
+     */
+    @Property.string({ format: 'uuid' })
+    eventId!: string;
     /**
      * The id of the subscriber.
      */
@@ -28,16 +33,10 @@ export class EventSubscriberRun<T> extends BaseEntity {
      * The error property if the run failed.
      */
     @Property.unknown({ required: false })
-    error?: Error;
+    error?: Error | null;
 }
 
 /**
  * The data needed to create a new event subscriber run.
  */
-export class EventSubscriberRunCreateData<T> extends OmitClass(EventSubscriberRun<unknown>, ['id', 'event', 'createdAt']) {
-    /**
-     * The event that triggered this run.
-     */
-    @Property.manyToOne({ target: () => Event, inverseSide: 'eventSubscriberRuns' })
-    event!: Event<T>;
-}
+export type EventSubscriberRunCreateData<T> = OmitStrict<EventSubscriberRun<T>, 'id' | 'eventId' | 'createdAt'>;

package/src/event/event.model.ts

@@ -15,7 +15,7 @@ export enum EventStatus {
 /**
  * Definition for an event.
  */
-@Entity({ allowOrphan: true })
+@Entity({ allowOrphan: true, defaultOrder: { createdAt: 'ASC' } })
 export class Event<T> extends BaseEntity {
     /**
      * The timestamp at which the event has been created.

package/src/event/event.service.ts

@@ -78,8 +78,7 @@ implements EventServiceInterface<TEvents>, OnAppInit, OnAppStart, AfterAppShutdo
     async onAppStart(): Promise<void> {
         const events: Event<TEvents[keyof TEvents]>[] = await this.eventRepository.findAll({
             where: { status: { not: EventStatus.FINISHED } },
-            relations: ['eventSubscriberRuns'],
-            order: { createdAt: 'ASC' }
+            relations: ['eventSubscriberRuns']
         });
 
         for (const event of events) {
@@ -222,7 +221,11 @@ implements EventServiceInterface<TEvents>, OnAppInit, OnAppStart, AfterAppShutdo
             await this.logger.error(new EventProcessingError(event, options.subscriberId, error));
         }
 
-        await this.eventSubscriberRunRepository.create({ event, subscriberId: options.subscriberId, error });
+        await this.eventSubscriberRunRepository.create({
+            event,
+            subscriberId: options.subscriberId,
+            error
+        });
         if (await this.eventHasUnfinishedSubscriptions(event)) {
             return;
         }

package/src/global/global-registry.ts

@@ -7,7 +7,7 @@ import { DiProvider } from '../di/models/di-provider.model';
 import { BaseEntity } from '../entity/base-entity.model';
 import { BodyParserInterface } from '../parsing/body-parser.interface';
 import { Newable } from '../types/newable.type';
-import { Version } from '../types/version.type';
+import { SemVerVersion } from '../utilities/sem-ver.utilities';
 
 /**
  * The data of the app.
@@ -28,7 +28,7 @@ export type AppData = {
     /**
      * The current version of the app.
      */
-    version?: Version
+    version?: SemVerVersion
 };
 
 /**

package/src/global/model-registry/default-descriptor.ts

@@ -42,7 +42,8 @@ export class DefaultDescriptor {
                 case Relation.MANY_TO_MANY:
                 case Relation.ONE_TO_MANY:
                 case Relation.MANY_TO_ONE:
-                case Relation.ONE_TO_ONE: {
+                case Relation.HAS_ONE:
+                case Relation.BELONGS_TO_ONE: {
                     const nested: DefaultDescriptor = ModelRegistry.get(metadata.target()).defaultDescriptor;
                     if (nested.hasAnything()) {
                         this.nestedKeys.set(key, nested);

package/src/global/model-registry/encryption-descriptor.ts

@@ -40,7 +40,8 @@ export class EncryptionDescriptor<T> {
 
             switch (metadata.type) {
                 case Relation.MANY_TO_ONE:
-                case Relation.ONE_TO_ONE:
+                case Relation.HAS_ONE:
+                case Relation.BELONGS_TO_ONE:
                 case Relation.MANY_TO_MANY:
                 case Relation.ONE_TO_MANY: {
                     const nested: EncryptionDescriptor<unknown> = ModelRegistry.get(metadata.target()).encryptionDescriptor;

package/src/global/model-registry/exclude-descriptor.ts

@@ -38,7 +38,8 @@ export class ExcludeDescriptor<T> {
 
             switch (metadata.type) {
                 case Relation.MANY_TO_ONE:
-                case Relation.ONE_TO_ONE:
+                case Relation.HAS_ONE:
+                case Relation.BELONGS_TO_ONE:
                 case Relation.MANY_TO_MANY:
                 case Relation.ONE_TO_MANY: {
                     const nested: ExcludeDescriptor<unknown> = ModelRegistry.get(metadata.target()).excludeDescriptor;

package/src/global/model-registry/hash-descriptor.ts

@@ -40,7 +40,8 @@ export class HashDescriptor<T> {
 
             switch (metadata.type) {
                 case Relation.MANY_TO_ONE:
-                case Relation.ONE_TO_ONE:
+                case Relation.HAS_ONE:
+                case Relation.BELONGS_TO_ONE:
                 case Relation.MANY_TO_MANY:
                 case Relation.ONE_TO_MANY: {
                     const nested: HashDescriptor<unknown> = ModelRegistry.get(metadata.target()).hashDescriptor;

package/src/http/http-request.model.ts

@@ -1,7 +1,7 @@
 import { Request } from 'express';
 
+import { Header } from './header.type';
 import { HttpMethod } from './http-method.enum';
-import { KnownHeader } from './known-header.enum';
 import { OmitStrict } from '../types/omit-strict.type';
 
 /**
@@ -11,7 +11,7 @@ export type HttpRequest<
     T = unknown,
     PathParamsObject extends Record<string, unknown> = Record<string, string | undefined>,
     QueryParamsObject extends Record<string, unknown> = Record<string, string | undefined>,
-    HeaderParamsObject extends Record<string, unknown> = Partial<Record<KnownHeader, string | undefined>>
+    HeaderParamsObject extends Record<string, unknown> = Partial<Record<Header, string | undefined>>
 // eslint-disable-next-line typescript/no-explicit-any
 > = OmitStrict<Request<Record<string, string>, any, T>, 'query' | 'headers' | 'params' | 'method'> & {
     /**

package/src/http/known-header.enum.ts

@@ -26,6 +26,7 @@ export enum KnownHeader {
     X_FORWARDED_HOST = 'x-forwarded-host',
     X_FORWARDED_PROTO = 'x-forwarded-proto',
     X_REAL_IP = 'x-real-ip',
+    X_VERSION = 'x-version',
     IF_NONE_MATCH = 'if-none-match',
     IIF_MODIFIED_SINCE = 'if-modified-since',
     CONNECTION = 'connection',

package/src/http-client/http-client.ts

@@ -1,4 +1,3 @@
-
 import axios, { AxiosInstance, AxiosResponse, isAxiosError, RawAxiosRequestConfig, ResponseType } from 'axios';
 
 import { HttpClientResponse, HttpClientResponseForBodyType } from './http-client-response.model';