@invariant--labs/foundation 1.1.2 → 1.1.4

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

@@ -1,13 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,82 +0,0 @@
-/* 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

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

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

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

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

@@ -1,11 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

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

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

@@ -1,11 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

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

package/src/index.ts

@@ -1,30 +0,0 @@
-// 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

@@ -1,9 +0,0 @@
-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

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

package/src/modules/graphql/index.ts

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

package/src/modules/graphql/paginated-response.object-type.ts

@@ -1,23 +0,0 @@
-import { Type } from "@nestjs/common";
-import { Field, Int, ObjectType } from "@nestjs/graphql";
-
-export type PaginatedResponse<TItem> = {
-  items: TItem[];
-  total: number;
-  hasMore: boolean;
-};
-
-export function PaginatedResponse<T>(classRef: Type<T>): Type<PaginatedResponse<T>> {
-  @ObjectType(`${classRef.name}Edge`, { isAbstract: true })
-  abstract class PaginatedType {
-    @Field(() => [classRef])
-    items: T[];
-
-    @Field(() => Int)
-    total: number;
-
-    @Field()
-    hasMore: boolean;
-  }
-  return PaginatedType as unknown as Type<PaginatedResponse<T>>;
-}

package/src/modules/healthcheck/healthcheck-out.dto.ts

@@ -1,43 +0,0 @@
-import { Expose, Type } from "class-transformer";
-import { IsOptional } from "class-validator";
-
-export class HealthStatus {
-  @Expose()
-  status: "up" | "down";
-}
-
-export class HealthIndicatorResult {
-  @Expose()
-  @Type(() => HealthStatus)
-  @IsOptional()
-  database?: HealthStatus;
-
-  @Expose()
-  @Type(() => HealthStatus)
-  @IsOptional()
-  memory_heap?: HealthStatus;
-
-  @Expose()
-  @Type(() => HealthStatus)
-  @IsOptional()
-  rabbitmq?: HealthStatus;
-}
-
-export class HealthcheckOutDto {
-  @Expose()
-  status: "error" | "ok" | "shutting_down";
-
-  @Expose()
-  @Type(() => HealthIndicatorResult)
-  details: HealthIndicatorResult;
-
-  @Expose()
-  @Type(() => HealthIndicatorResult)
-  @IsOptional()
-  info?: HealthIndicatorResult;
-
-  @Expose()
-  @Type(() => HealthIndicatorResult)
-  @IsOptional()
-  error?: HealthIndicatorResult;
-}

package/src/modules/healthcheck/index.ts

@@ -1 +0,0 @@
-export * from "./healthcheck-out.dto";

package/src/modules/knex/index.ts

@@ -1,3 +0,0 @@
-export * from "./knex.decorator";
-export * from "./knex.module";
-export * from "./knex.token";