@invariant--labs/foundation 1.1.2

package/src/core/infrastructure/persistence/read-side/knex-query-builder.ts

@@ -0,0 +1,70 @@
+import { Knex } from "knex";
+
+import { QueryBuilder } from "../../../application";
+import { ArchitectureLevel } from "../../../types";
+import { EntityNotFoundError } from "../../../errors";
+import { knexTableAlias } from "./knex-types.definition";
+
+export abstract class KnexQueryBuilder implements QueryBuilder {
+  constructor(private readonly knex: Knex) {}
+
+  private createDefaultQueryBuilder<TModel extends object, TResult = Partial<TModel>>(
+    tableName: string,
+  ): Knex.QueryBuilder<TModel, TResult> {
+    return this.knex.from<TModel, TResult>(tableName);
+  }
+
+  protected exists(tableName: string, id: string): Promise<boolean> {
+    return this.createDefaultQueryBuilder(tableName)
+      .where("id", id)
+      .first()
+      .then((result) => !!result);
+  }
+
+  protected findOne<TModel extends object, TResult = Partial<TModel>>(tableName: string, id: string): Promise<TResult | null> {
+    return this.createDefaultQueryBuilder<TModel, TResult>(tableName)
+      .select("*")
+      .where("id", id)
+      .first()
+      .then((result) => (result as TResult) || null);
+  }
+
+  protected findOneOrFail<TModel extends object, TResult = Partial<TModel>>(tableName: string, id: string): Promise<TResult> {
+    return this.createDefaultQueryBuilder<TModel, TResult>(tableName)
+      .select("*")
+      .where("id", id)
+      .first()
+      .then((result) => {
+        if (!result) {
+          throw new EntityNotFoundError(
+            tableName,
+            { [ArchitectureLevel.INFRASTRUCTURE]: { "persistence-sql": { className: KnexQueryBuilder.name } } },
+            { id },
+          );
+        }
+
+        return result as TResult;
+      });
+  }
+
+  protected findByIds<TModel extends object, TResult = Partial<TModel>>(tableName: string, ids: string[]): Promise<TResult[]> {
+    return this.createDefaultQueryBuilder<TModel, TResult>(tableName)
+      .whereIn("id", ids)
+      .then((result) => result as TResult[]);
+  }
+
+  protected count(tableName: string, options: Record<string, unknown>): Promise<number> {
+    return this.createDefaultQueryBuilder(tableName)
+      .count<Array<{ count: number }>>("*", { as: "count" })
+      .where(options)
+      .then(([{ count }]) => count);
+  }
+
+  get queryBuilder() {
+    return this.knex.queryBuilder();
+  }
+
+  dataSource<T, Alias extends string>(tableName: Alias) {
+    return this.knex<knexTableAlias<T, Alias>>(tableName);
+  }
+}

package/src/core/infrastructure/persistence/read-side/knex-types.definition.ts

@@ -0,0 +1,13 @@
+type CamelToSnakeCase<S extends string> = S extends `${infer T}${infer U}`
+  ? `${T extends Capitalize<T> ? "_" : ""}${Lowercase<T>}${CamelToSnakeCase<U>}`
+  : S;
+
+export type knexInfer<T> = {
+  [K in keyof T as CamelToSnakeCase<Extract<K, string>>]: T[K] extends CallableFunction ? never : T[K];
+};
+
+export type knexTableAlias<Table, Alias extends string> = {
+  [K in keyof Table as `${Alias}.${string & CamelToSnakeCase<Extract<K, string>>}`]: Table[K] extends CallableFunction
+    ? never
+    : Table[K];
+};

package/src/core/infrastructure/persistence/write-side/aggregate-typeorm-repository.ts

@@ -0,0 +1,87 @@
+import { DataSource, EntityManager, ObjectLiteral, SelectQueryBuilder } from "typeorm";
+
+import { Repository } from "../../../application";
+import { AggregateRoot, EntityProps } from "../../../domain";
+import { ArchitectureLevel } from "../../../types";
+import { typeormMetadataParser } from "../../../../nestjs/errors/parsers/typeorm-metadata.parser";
+import { EntityNotFoundError } from "../../../errors";
+import { PersistenceError } from "../errors/persistence.error";
+
+export abstract class AggregateTypeormRepository<
+  DomainAggregate extends AggregateRoot<EntityProps>,
+  OrmModel extends ObjectLiteral,
+> implements Repository<AggregateRoot<EntityProps>>
+{
+  protected abstract createDefaultQueryBuilder(): SelectQueryBuilder<OrmModel>;
+  protected abstract toEntity(model: OrmModel): DomainAggregate;
+  protected abstract toModel(aggregate: DomainAggregate): OrmModel | Promise<OrmModel>;
+  protected manager: EntityManager;
+
+  constructor(
+    dataSource: DataSource,
+    private readonly aggregateName: string,
+  ) {
+    this.manager = dataSource.manager;
+  }
+
+  async count(): Promise<number> {
+    return this.createDefaultQueryBuilder().getCount();
+  }
+
+  async exists(id: string): Promise<boolean> {
+    const count = await this.createDefaultQueryBuilder().where({ id }).getCount();
+    return count === 1;
+  }
+
+  async findOne(id: string): Promise<DomainAggregate | null> {
+    const model = await this.createDefaultQueryBuilder().where({ id }).getOne();
+    return model ? this.toEntity(model) : null;
+  }
+
+  async findOneOrFail(aggregateId: string): Promise<DomainAggregate> {
+    const aggregate = await this.findOne(aggregateId);
+    if (!aggregate) {
+      throw new EntityNotFoundError(
+        this.aggregateName,
+        { [ArchitectureLevel.INFRASTRUCTURE]: { "persistence-sql": { className: "AggregateTypeormRepository" } } },
+        { id: aggregateId },
+      );
+    }
+    return aggregate;
+  }
+
+  async findByIds(ids: string[]): Promise<DomainAggregate[]> {
+    const models = await this.createDefaultQueryBuilder().whereInIds(ids).getMany();
+    return models.map((model) => this.toEntity(model));
+  }
+
+  async save(aggregate: DomainAggregate): Promise<DomainAggregate> {
+    try {
+      const model = await this.manager.save(this.toModel(aggregate));
+      aggregate.commit();
+      return this.toEntity(model);
+    } catch (error) {
+      throw new PersistenceError("Failed to save aggregate", {
+        "aggregate-root": {
+          className: AggregateTypeormRepository.name,
+          meta: typeormMetadataParser(error, { method: this.save.name }),
+        },
+      });
+    }
+  }
+
+  async saveAll(aggregates: DomainAggregate[]): Promise<void> {
+    try {
+      const models = await Promise.all(aggregates.map((a) => Promise.resolve(this.toModel(a))));
+      await this.manager.save(models);
+      aggregates.forEach((a) => a.commit());
+    } catch (error) {
+      throw new PersistenceError("Failed to save aggregates", {
+        "aggregate-root": {
+          className: AggregateTypeormRepository.name,
+          meta: typeormMetadataParser(error, { method: this.saveAll.name }),
+        },
+      });
+    }
+  }
+}

package/src/core/infrastructure/persistence/write-side/entity-typeorm-repository.ts

@@ -0,0 +1,64 @@
+import { DataSource, EntityManager, ObjectLiteral, SelectQueryBuilder } from "typeorm";
+
+import { Repository } from "../../../application";
+import { Entity, EntityProps } from "../../../domain";
+import { ArchitectureLevel } from "../../../types";
+import { EntityNotFoundError } from "../../../errors";
+
+export abstract class EntityTypeormRepository<DomainEntity extends Entity<EntityProps>, OrmModel extends ObjectLiteral>
+  implements Repository<Entity<EntityProps>>
+{
+  protected manager: EntityManager;
+
+  constructor(
+    dataSource: DataSource,
+    private readonly entityName: string,
+  ) {
+    this.manager = dataSource.manager;
+  }
+
+  async count(): Promise<number> {
+    return this.createDefaultQueryBuilder().getCount();
+  }
+
+  async exists(id: string): Promise<boolean> {
+    const count = await this.createDefaultQueryBuilder().where({ id }).getCount();
+    return count === 1;
+  }
+
+  async findOne(id: string): Promise<DomainEntity | null> {
+    const model = await this.createDefaultQueryBuilder().where({ id }).getOne();
+    return model ? this.toEntity(model) : null;
+  }
+
+  async findOneOrFail(entityId: string): Promise<DomainEntity> {
+    const entity = await this.findOne(entityId);
+    if (!entity) {
+      throw new EntityNotFoundError(
+        this.entityName,
+        { [ArchitectureLevel.INFRASTRUCTURE]: { "persistence-sql": { className: "EntityTypeormRepository" } } },
+        { id: entityId },
+      );
+    }
+    return entity;
+  }
+
+  async findByIds(ids: string[]): Promise<DomainEntity[]> {
+    const models = await this.createDefaultQueryBuilder().whereInIds(ids).getMany();
+    return models.map((model) => this.toEntity(model));
+  }
+
+  async save(entity: DomainEntity): Promise<DomainEntity> {
+    const model = await this.manager.save(await this.toModel(entity));
+    return this.toEntity(model);
+  }
+
+  async saveAll(entities: DomainEntity[]): Promise<void> {
+    const models = await Promise.all(entities.map((e) => Promise.resolve(this.toModel(e))));
+    await this.manager.save(models);
+  }
+
+  protected abstract createDefaultQueryBuilder(): SelectQueryBuilder<OrmModel>;
+  protected abstract toEntity(model: OrmModel): DomainEntity;
+  protected abstract toModel(entity: DomainEntity): OrmModel | Promise<OrmModel>;
+}

package/src/core/infrastructure/persistence/write-side/in-memory.repository.ts

@@ -0,0 +1,82 @@
+/* eslint-disable @typescript-eslint/require-await */
+import _ from "lodash";
+
+import { FindManyOptions, Repository } from "../../../application/persistence/repository";
+import { AggregateRoot } from "../../../domain";
+import { Entity, EntityProps } from "../../../domain/entities/entity";
+import { ArchitectureLevel } from "../../../types";
+import { EntityNotFoundError } from "../../../errors";
+
+export class InMemoryRepository<DomainEntity extends Entity<EntityProps> | AggregateRoot<EntityProps>>
+  implements Repository<DomainEntity>
+{
+  protected store: Map<string, DomainEntity>;
+
+  constructor(
+    defaultEntities: DomainEntity[] = [],
+    protected error?: Error,
+  ) {
+    this.store = new Map(defaultEntities.map((e) => [e.id.toString(), e]));
+  }
+
+  async save(entity: DomainEntity): Promise<DomainEntity> {
+    this.checkError();
+    this.store.set(entity.id.toString(), entity);
+    return entity;
+  }
+
+  async saveAll(entities: DomainEntity[]): Promise<void> {
+    this.checkError();
+    for (const entity of entities) {await this.save(entity);}
+  }
+
+  async findOne(id: string): Promise<DomainEntity | null> {
+    return this.store.get(id) ?? null;
+  }
+
+  async findOneOrFail(id: string): Promise<DomainEntity> {
+    const entity = await this.findOne(id);
+    if (!entity) {
+      throw new EntityNotFoundError("InMemoryEntity", {
+        [ArchitectureLevel.INFRASTRUCTURE]: { "persistence-fake": { className: "InMemoryRepository" } },
+      });
+    }
+    return entity;
+  }
+
+  async findByIds(ids: string[]): Promise<DomainEntity[]> {
+    return this.toArray().filter((entity) => ids.includes(entity.id.toString()));
+  }
+
+  async delete(entity: DomainEntity): Promise<void> {
+    this.checkError();
+    this.store.delete(entity.id.toString());
+  }
+
+  async exists(id: string): Promise<boolean> {
+    this.checkError();
+    return this.store.has(id);
+  }
+
+  async count(options: FindManyOptions<DomainEntity>): Promise<number> {
+    this.checkError();
+    return _.filter(this.toArray(), options.filters).length;
+  }
+
+  clear(): void {
+    this.store.clear();
+    this.error = undefined;
+  }
+
+  setError(error: Error): void {
+    this.error = error;
+  }
+
+  protected checkError(): void {
+    if (this.error) {throw this.error;}
+  }
+
+  protected toArray(): DomainEntity[] {
+    return [...this.store.values()];
+  }
+}

package/src/core/infrastructure/persistence/write-side/index.ts

@@ -0,0 +1 @@
+export * from "./typeorm";

package/src/core/infrastructure/persistence/write-side/model-attributes.ts

@@ -0,0 +1,4 @@
+export type ModelAttributes<T> = Omit<
+  T,
+  "createdAt" | "updatedAt" | "updateDateCreation" | "updateDateUpdate" | "deletedAt" | "updateDateDelete"
+>;

package/src/core/infrastructure/persistence/write-side/orm-embedded-mapper.ts

@@ -0,0 +1,11 @@
+import { ValueObject } from "../../../domain";
+
+export interface OrmEmbeddedMapper<
+  DomainValueObject extends ValueObject,
+  OrmEmbeddedModel,
+  ToPersistenceArgs extends unknown[] = [],
+  ToDomainArgs extends unknown[] = [],
+> {
+  toObjectValue(embeddedModel: OrmEmbeddedModel | null, ...args: ToDomainArgs): DomainValueObject | undefined;
+  toEmbeddedModel(valueObject?: DomainValueObject, ...args: ToPersistenceArgs): OrmEmbeddedModel | null;
+}

package/src/core/infrastructure/persistence/write-side/orm-mapper.ts

@@ -0,0 +1,11 @@
+import { AggregateRoot, Entity } from "../../../domain";
+
+export interface OrmMapper<
+  DomainObject extends AggregateRoot | Entity,
+  OrmModel,
+  ToPersistenceArgs extends unknown[] = [],
+  ToDomainArgs extends unknown[] = [],
+> {
+  toEntity(model: OrmModel, ...args: ToDomainArgs): DomainObject;
+  toModel(entity: DomainObject, ...args: ToPersistenceArgs): OrmModel;
+}

package/src/core/infrastructure/persistence/write-side/typeorm/aggregate-typeorm.repository.ts

@@ -0,0 +1,87 @@
+import { DataSource, EntityManager, ObjectLiteral, SelectQueryBuilder } from "typeorm";
+
+import { Repository } from "../../../../application";
+import { AggregateRoot, EntityProps } from "../../../../domain";
+import { ArchitectureLevel } from "../../../../types";
+import { EntityNotFoundError } from "../../../../errors";
+import { typeormMetadataParser } from "../../../../../nestjs/errors/parsers/typeorm-metadata.parser";
+import { PersistenceError } from "../../errors/persistence.error";
+
+export abstract class AggregateTypeormRepository<
+  DomainAggregate extends AggregateRoot<EntityProps>,
+  OrmModel extends ObjectLiteral,
+> implements Repository<AggregateRoot<EntityProps>>
+{
+  protected abstract createDefaultQueryBuilder(): SelectQueryBuilder<OrmModel>;
+  protected abstract toEntity(model: OrmModel): DomainAggregate;
+  protected abstract toModel(aggregate: DomainAggregate): OrmModel | Promise<OrmModel>;
+  protected manager: EntityManager;
+
+  constructor(
+    dataSource: DataSource,
+    private readonly aggregateName: string,
+  ) {
+    this.manager = dataSource.manager;
+  }
+
+  async count(): Promise<number> {
+    return this.createDefaultQueryBuilder().getCount();
+  }
+
+  async exists(id: string): Promise<boolean> {
+    const count = await this.createDefaultQueryBuilder().where({ id }).getCount();
+    return count === 1;
+  }
+
+  async findOne(id: string): Promise<DomainAggregate | null> {
+    const model = await this.createDefaultQueryBuilder().where({ id }).getOne();
+    return model ? this.toEntity(model) : null;
+  }
+
+  async findOneOrFail(aggregateId: string): Promise<DomainAggregate> {
+    const aggregate = await this.findOne(aggregateId);
+    if (!aggregate) {
+      throw new EntityNotFoundError(
+        this.aggregateName,
+        { [ArchitectureLevel.INFRASTRUCTURE]: { "persistence-sql": { className: "AggregateTypeormRepository" } } },
+        { id: aggregateId },
+      );
+    }
+    return aggregate;
+  }
+
+  async findByIds(ids: string[]): Promise<DomainAggregate[]> {
+    const models = await this.createDefaultQueryBuilder().whereInIds(ids).getMany();
+    return models.map((model) => this.toEntity(model));
+  }
+
+  async save(aggregate: DomainAggregate): Promise<DomainAggregate> {
+    try {
+      const model = await this.manager.save(this.toModel(aggregate));
+      aggregate.commit();
+      return this.toEntity(model);
+    } catch (error) {
+      throw new PersistenceError("Failed to save aggregate", {
+        "aggregate-root": {
+          className: AggregateTypeormRepository.name,
+          meta: typeormMetadataParser(error, { method: this.save.name }),
+        },
+      });
+    }
+  }
+
+  async saveAll(aggregates: DomainAggregate[]): Promise<void> {
+    try {
+      const models = await Promise.all(aggregates.map((a) => Promise.resolve(this.toModel(a))));
+      await this.manager.save(models);
+      aggregates.forEach((a) => a.commit());
+    } catch (error) {
+      throw new PersistenceError("Failed to save aggregates", {
+        "aggregate-root": {
+          className: AggregateTypeormRepository.name,
+          meta: typeormMetadataParser(error, { method: this.saveAll.name }),
+        },
+      });
+    }
+  }
+}

package/src/core/infrastructure/persistence/write-side/typeorm/entity-typeorm.repository.ts

@@ -0,0 +1,64 @@
+import { DataSource, EntityManager, ObjectLiteral, SelectQueryBuilder } from "typeorm";
+
+import { Repository } from "../../../../application";
+import { Entity, EntityProps } from "../../../../domain";
+import { ArchitectureLevel } from "../../../../types";
+import { EntityNotFoundError } from "../../../../errors";
+
+export abstract class EntityTypeormRepository<DomainEntity extends Entity<EntityProps>, OrmModel extends ObjectLiteral>
+  implements Repository<Entity<EntityProps>>
+{
+  protected manager: EntityManager;
+
+  constructor(
+    dataSource: DataSource,
+    private readonly entityName: string,
+  ) {
+    this.manager = dataSource.manager;
+  }
+
+  async count(): Promise<number> {
+    return this.createDefaultQueryBuilder().getCount();
+  }
+
+  async exists(id: string): Promise<boolean> {
+    const count = await this.createDefaultQueryBuilder().where({ id }).getCount();
+    return count === 1;
+  }
+
+  async findOne(id: string): Promise<DomainEntity | null> {
+    const model = await this.createDefaultQueryBuilder().where({ id }).getOne();
+    return model ? this.toEntity(model) : null;
+  }
+
+  async findOneOrFail(entityId: string): Promise<DomainEntity> {
+    const entity = await this.findOne(entityId);
+    if (!entity) {
+      throw new EntityNotFoundError(
+        this.entityName,
+        { [ArchitectureLevel.INFRASTRUCTURE]: { "persistence-sql": { className: "EntityTypeormRepository" } } },
+        { id: entityId },
+      );
+    }
+    return entity;
+  }
+
+  async findByIds(ids: string[]): Promise<DomainEntity[]> {
+    const models = await this.createDefaultQueryBuilder().whereInIds(ids).getMany();
+    return models.map((model) => this.toEntity(model));
+  }
+
+  async save(entity: DomainEntity): Promise<DomainEntity> {
+    const model = await this.manager.save(await this.toModel(entity));
+    return this.toEntity(model);
+  }
+
+  async saveAll(entities: DomainEntity[]): Promise<void> {
+    const models = await Promise.all(entities.map((e) => Promise.resolve(this.toModel(e))));
+    await this.manager.save(models);
+  }
+
+  protected abstract createDefaultQueryBuilder(): SelectQueryBuilder<OrmModel>;
+  protected abstract toEntity(model: OrmModel): DomainEntity;
+  protected abstract toModel(entity: DomainEntity): OrmModel | Promise<OrmModel>;
+}

package/src/core/infrastructure/persistence/write-side/typeorm/index.ts

@@ -0,0 +1,5 @@
+export * from "./aggregate-typeorm.repository";
+export * from "./entity-typeorm.repository";
+export * from "./model-attributes";
+export * from "./orm.mapper";
+export * from "./orm-embedded.mapper";

package/src/core/infrastructure/persistence/write-side/typeorm/model-attributes.ts

@@ -0,0 +1,4 @@
+export type ModelAttributes<T> = Omit<
+  T,
+  "createdAt" | "updatedAt" | "updateDateCreation" | "updateDateUpdate" | "deletedAt" | "updateDateDelete"
+>;

package/src/core/infrastructure/persistence/write-side/typeorm/orm-embedded.mapper.ts

@@ -0,0 +1,11 @@
+import { ValueObject } from "../../../../domain";
+
+export interface OrmEmbeddedMapper<
+  DomainValueObject extends ValueObject,
+  OrmEmbeddedModel,
+  ToPersistenceArgs extends unknown[] = [],
+  ToDomainArgs extends unknown[] = [],
+> {
+  toObjectValue(embeddedModel: OrmEmbeddedModel | null, ...args: ToDomainArgs): DomainValueObject | undefined;
+  toEmbeddedModel(valueObject?: DomainValueObject, ...args: ToPersistenceArgs): OrmEmbeddedModel | null;
+}

package/src/core/infrastructure/persistence/write-side/typeorm/orm.mapper.ts

@@ -0,0 +1,11 @@
+import { AggregateRoot, Entity } from "../../../../domain";
+
+export interface OrmMapper<
+  DomainObject extends AggregateRoot | Entity,
+  OrmModel,
+  ToPersistenceArgs extends unknown[] = [],
+  ToDomainArgs extends unknown[] = [],
+> {
+  toEntity(model: OrmModel, ...args: ToDomainArgs): DomainObject;
+  toModel(entity: DomainObject, ...args: ToPersistenceArgs): OrmModel;
+}

package/src/core/types/architecture-layer.ts

@@ -0,0 +1,52 @@
+type Values<V> = V[keyof V];
+type OneOf<V> = Values<{
+  [K in keyof V]: { [K1 in K]: V[K1] };
+}>;
+
+export enum ArchitectureLevel {
+  DOMAIN = "DOMAIN",
+  APPLICATION = "APPLICATION",
+  INFRASTRUCTURE = "INFRASTRUCTURE",
+  UNDEFINED = "UNDEFINED",
+}
+
+export type ArchitectureLayerType =
+  | "aggregate-root"
+  | "entity"
+  | "value-object"
+  | "query"
+  | "command"
+  | "event-handler"
+  | "event-saga"
+  | "service"
+  | "authorization"
+  | "authentication"
+  | "web-dto"
+  | "web-rest"
+  | "web-graphql"
+  | "web-socket"
+  | "web-rpc"
+  | "persistence-sql"
+  | "persistence-saas"
+  | "persistence-fake"
+  | "persistence-other"
+  | "persistence-s3"
+  | "persistence-disk"
+  | "messaging-inmem"
+  | "messaging-pubsub"
+  | "unknown";
+
+export type ArchitectureLayerTraceBase = {
+  [Type in ArchitectureLayerType]: {
+    className: string;
+    meta?: unknown;
+  };
+};
+
+export type ArchitectureLayerTrace = OneOf<ArchitectureLayerTraceBase>;
+
+export type DDD = {
+  [key in `${ArchitectureLevel}`]: ArchitectureLayerTrace;
+};
+
+export type ArchitectureLayer = OneOf<DDD>;

package/src/core/types/array-element.ts

@@ -0,0 +1,5 @@
+import { Type } from "@nestjs/common";
+
+export type ArrayElement<T> = T extends ReadonlyArray<infer E> ? E : never;
+
+export type InstanceOfClasses<T extends Array<Type<unknown>>> = InstanceType<ArrayElement<T>>;

package/src/core/types/index.ts

@@ -0,0 +1,2 @@
+export * from "./architecture-layer";
+export * from "./array-element";

package/src/index.ts

@@ -0,0 +1,30 @@
+// Core
+export * from "./core/domain";
+export * from "./core/application";
+export * from "./core/errors";
+export * from "./core/types";
+export * from "./core/infrastructure/persistence";
+export * from "./core/infrastructure/messaging";
+export * from "./core/infrastructure/config";
+
+// Modules
+export * from "./modules/config";
+export * from "./modules/logger";
+export * from "./modules/messaging";
+export * from "./modules/queue";
+export * from "./modules/knex";
+export * from "./modules/graphql";
+export * from "./modules/healthcheck";
+
+// NestJS Integration
+export * from "./nestjs/http";
+export * from "./nestjs/errors";
+
+// Validation
+export * from "./validation";
+
+// Utils
+export * from "./utils";
+
+// Testing
+export * from "./testing";

package/src/modules/config/config.module.ts

@@ -0,0 +1,9 @@
+import { Module } from "@nestjs/common";
+
+import { ConfigProvider, ConfigService } from "../../core/infrastructure/config";
+
+@Module({
+  providers: [{ provide: ConfigService, useClass: ConfigProvider }],
+  exports: [ConfigService],
+})
+export class ConfigModule {}

package/src/modules/config/index.ts

@@ -0,0 +1,2 @@
+export * from "./config.module";
+export * from "../../core/infrastructure/config";

package/src/modules/graphql/index.ts

@@ -0,0 +1 @@
+export * from "./paginated-response.object-type";