@mrxsys/mrx-core 2.4.0 → 2.5.0

package/dist/chunk-f5z7x01b.js

@@ -0,0 +1,352 @@
+import {
+  filterByKeyExclusionRecursive
+} from "./chunk-cq973ydc.js";
+
+// source/modules/elysia/crudSchema/utils/createCountResponse200Schema.ts
+import { t } from "elysia";
+var createCountResponse200Schema = () => t.Object({
+  message: t.String(),
+  content: t.Number()
+});
+
+// source/modules/elysia/crudSchema/utils/isDateFromElysiaTypeBox.ts
+import { Kind } from "@sinclair/typebox/type";
+var isDateFromElysiaTypeBox = (schema) => schema[Kind] === "Union" && Array.isArray(schema.anyOf) && schema.anyOf.length === 4 && schema.anyOf.some((item) => item[Kind] === "Date") && schema.anyOf.some((item) => item[Kind] === "String" && item.format === "date-time") && schema.anyOf.some((item) => item[Kind] === "String" && item.format === "date") && schema.anyOf.some((item) => item[Kind] === "Number");
+
+// source/modules/elysia/crudSchema/utils/createAdaptiveWhereClauseSchema.ts
+import {
+  TypeGuard
+} from "@sinclair/typebox";
+import { t as t2 } from "elysia";
+var createAdaptiveWhereClauseSchema = (schema) => {
+  const common = {
+    $eq: schema,
+    $neq: schema,
+    $isNull: t2.Boolean()
+  };
+  const strNumDate = TypeGuard.IsString(schema) || TypeGuard.IsNumber(schema) || isDateFromElysiaTypeBox(schema) ? {
+    $in: t2.Array(schema, { minItems: 1, uniqueItems: true }),
+    $nin: t2.Array(schema, { minItems: 1, uniqueItems: true }),
+    $like: t2.String(),
+    $nlike: t2.String()
+  } : {};
+  const numDate = TypeGuard.IsNumber(schema) || isDateFromElysiaTypeBox(schema) ? {
+    $lt: schema,
+    $lte: schema,
+    $gt: schema,
+    $gte: schema,
+    $between: t2.Tuple([schema, schema]),
+    $nbetween: t2.Tuple([schema, schema])
+  } : {};
+  return t2.Partial(t2.Object({ ...common, ...strNumDate, ...numDate }));
+};
+
+// source/modules/elysia/crudSchema/utils/createPropertiesSchema.ts
+import { t as t3 } from "elysia";
+var createPropertiesSchema = (schema) => {
+  const { properties } = schema;
+  const clauseSchema = {};
+  for (const [key, propertySchema] of Object.entries(properties))
+    clauseSchema[key] = t3.Union([
+      createAdaptiveWhereClauseSchema(propertySchema),
+      propertySchema
+    ]);
+  return t3.Object(clauseSchema);
+};
+
+// source/modules/elysia/crudSchema/utils/createQSchema.ts
+import { t as t4 } from "elysia/type-system";
+var createQSchema = (schema) => t4.Union([
+  t4.Object({
+    selectedFields: t4.Union([
+      t4.KeyOf(schema),
+      t4.Array(t4.KeyOf(schema), {
+        minItems: 1,
+        uniqueItems: true
+      })
+    ]),
+    value: t4.Union([
+      t4.Number(),
+      t4.String()
+    ])
+  }),
+  t4.Number(),
+  t4.String()
+]);
+
+// source/modules/elysia/crudSchema/utils/createFiltersSchema.ts
+import { t as t5 } from "elysia";
+var createFiltersSchema = (schema) => t5.Composite([
+  t5.Object({
+    $q: createQSchema(schema)
+  }),
+  createPropertiesSchema(schema)
+], {
+  minProperties: 1
+});
+
+// source/modules/elysia/crudSchema/utils/createCountSchema.ts
+import { t as t6 } from "elysia";
+var createCountSchema = (schema) => {
+  const sanitizedSchema = filterByKeyExclusionRecursive(schema, [
+    "minLength",
+    "maxLength",
+    "pattern",
+    "minimum",
+    "maximum",
+    "exclusiveMinimum",
+    "exclusiveMaximum",
+    "multipleOf",
+    "minItems",
+    "maxItems",
+    "maxContains",
+    "minContains",
+    "minProperties",
+    "maxProperties",
+    "uniqueItems",
+    "minimumTimestamp",
+    "maximumTimestamp",
+    "exclusiveMinimumTimestamp",
+    "exclusiveMaximumTimestamp",
+    "multipleOfTimestamp",
+    "required",
+    "examples",
+    "example",
+    "default",
+    "title",
+    "description"
+  ]);
+  return t6.Partial(t6.Object({
+    queryOptions: t6.Partial(t6.Object({
+      filters: t6.Union([
+        t6.Partial(createFiltersSchema(sanitizedSchema)),
+        t6.Array(t6.Partial(createFiltersSchema(sanitizedSchema)))
+      ])
+    }))
+  }));
+};
+
+// source/modules/elysia/crudSchema/utils/createSelectedFieldsSchema.ts
+import { t as t7 } from "elysia/type-system";
+var createSelectedFieldsSchema = (schema) => t7.Union([
+  t7.KeyOf(schema),
+  t7.Literal("*"),
+  t7.Array(t7.KeyOf(schema), {
+    minItems: 1,
+    uniqueItems: true
+  })
+]);
+
+// source/modules/elysia/crudSchema/utils/createDeleteSchema.ts
+import { t as t8 } from "elysia";
+var createDeleteSchema = (schema) => {
+  const sanitizedSchema = filterByKeyExclusionRecursive(schema, [
+    "minLength",
+    "maxLength",
+    "pattern",
+    "minimum",
+    "maximum",
+    "exclusiveMinimum",
+    "exclusiveMaximum",
+    "multipleOf",
+    "minItems",
+    "maxItems",
+    "maxContains",
+    "minContains",
+    "minProperties",
+    "maxProperties",
+    "uniqueItems",
+    "minimumTimestamp",
+    "maximumTimestamp",
+    "exclusiveMinimumTimestamp",
+    "exclusiveMaximumTimestamp",
+    "multipleOfTimestamp",
+    "required",
+    "examples",
+    "example",
+    "default",
+    "title",
+    "description"
+  ]);
+  return t8.Object({
+    queryOptions: t8.Object({
+      selectedFields: t8.Optional(createSelectedFieldsSchema(sanitizedSchema)),
+      filters: t8.Union([
+        t8.Partial(createFiltersSchema(sanitizedSchema)),
+        t8.Array(t8.Partial(createFiltersSchema(sanitizedSchema)), { minItems: 1 })
+      ])
+    })
+  });
+};
+
+// source/modules/elysia/crudSchema/utils/createOrderSchema.ts
+import { t as t9 } from "elysia/type-system";
+var createOrderSchema = (schema) => t9.Union([
+  t9.Object({
+    selectedField: t9.KeyOf(schema),
+    direction: t9.Union([t9.Literal("asc"), t9.Literal("desc")])
+  }),
+  t9.Array(t9.Object({
+    selectedField: t9.KeyOf(schema),
+    direction: t9.Union([t9.Literal("asc"), t9.Literal("desc")])
+  }), {
+    minItems: 1,
+    uniqueItems: true
+  })
+]);
+
+// source/modules/elysia/crudSchema/utils/createFindSchema.ts
+import { t as t10 } from "elysia";
+var createFindSchema = (schema) => {
+  const sanitizedSchema = filterByKeyExclusionRecursive(schema, [
+    "minLength",
+    "maxLength",
+    "pattern",
+    "minimum",
+    "maximum",
+    "exclusiveMinimum",
+    "exclusiveMaximum",
+    "multipleOf",
+    "minItems",
+    "maxItems",
+    "maxContains",
+    "minContains",
+    "minProperties",
+    "maxProperties",
+    "uniqueItems",
+    "minimumTimestamp",
+    "maximumTimestamp",
+    "exclusiveMinimumTimestamp",
+    "exclusiveMaximumTimestamp",
+    "multipleOfTimestamp",
+    "required",
+    "examples",
+    "example",
+    "default",
+    "title",
+    "description"
+  ]);
+  return t10.Partial(t10.Object({
+    queryOptions: t10.Partial(t10.Object({
+      selectedFields: createSelectedFieldsSchema(sanitizedSchema),
+      orderBy: createOrderSchema(sanitizedSchema),
+      filters: t10.Union([
+        t10.Partial(createFiltersSchema(sanitizedSchema)),
+        t10.Array(t10.Partial(createFiltersSchema(sanitizedSchema)))
+      ]),
+      limit: t10.Number({
+        default: 100,
+        minimum: 1
+      }),
+      offset: t10.Number({
+        default: 0,
+        minimum: 0
+      })
+    }))
+  }));
+};
+
+// source/modules/elysia/crudSchema/utils/createIdParamSchema.ts
+import { t as t11 } from "elysia";
+var createIdParamSchema = () => t11.Object({
+  id: t11.Union([
+    t11.String({
+      format: "uuid"
+    }),
+    t11.Number({
+      minimum: 1,
+      maximum: Number.MAX_SAFE_INTEGER
+    })
+  ])
+});
+
+// source/modules/elysia/crudSchema/utils/createResponse200Schema.ts
+import { TypeGuard as TypeGuard2 } from "@sinclair/typebox";
+import { t as t12 } from "elysia";
+var createResponse200Schema = (schema) => {
+  const sanitizedSchema = filterByKeyExclusionRecursive(schema, [
+    "minLength",
+    "maxLength",
+    "pattern",
+    "format",
+    "minimum",
+    "maximum",
+    "exclusiveMinimum",
+    "exclusiveMaximum",
+    "multipleOf",
+    "minItems",
+    "maxItems",
+    "maxContains",
+    "minContains",
+    "minProperties",
+    "maxProperties",
+    "uniqueItems",
+    "minimumTimestamp",
+    "maximumTimestamp",
+    "exclusiveMinimumTimestamp",
+    "exclusiveMaximumTimestamp",
+    "multipleOfTimestamp",
+    "required",
+    "default"
+  ]);
+  const { properties } = sanitizedSchema;
+  const responseSchema = {};
+  for (const key in properties)
+    responseSchema[key] = TypeGuard2.IsString(properties[key]) ? t12.Union([properties[key], t12.Undefined(), t12.Literal(""), t12.Null()]) : t12.Union([properties[key], t12.Undefined(), t12.Null()]);
+  return t12.Object({
+    message: t12.String(),
+    content: t12.Array(t12.Partial(t12.Object(responseSchema)))
+  });
+};
+
+// source/modules/elysia/crudSchema/utils/createUpdateOneSchema.ts
+import { t as t13 } from "elysia";
+var createUpdateOneSchema = (schema) => t13.Object({
+  data: t13.Partial(schema)
+});
+
+// source/modules/elysia/crudSchema/utils/createUpdateSchema.ts
+import { t as t14 } from "elysia";
+var createUpdateSchema = (schema) => {
+  const sanitizedSchema = filterByKeyExclusionRecursive(schema, [
+    "minLength",
+    "maxLength",
+    "pattern",
+    "minimum",
+    "maximum",
+    "exclusiveMinimum",
+    "exclusiveMaximum",
+    "multipleOf",
+    "minItems",
+    "maxItems",
+    "maxContains",
+    "minContains",
+    "minProperties",
+    "maxProperties",
+    "uniqueItems",
+    "minimumTimestamp",
+    "maximumTimestamp",
+    "exclusiveMinimumTimestamp",
+    "exclusiveMaximumTimestamp",
+    "multipleOfTimestamp",
+    "required",
+    "examples",
+    "example",
+    "default",
+    "title",
+    "description"
+  ]);
+  schema.minProperties = 1;
+  return t14.Object({
+    queryOptions: t14.Object({
+      selectedFields: t14.Optional(createSelectedFieldsSchema(sanitizedSchema)),
+      filters: t14.Union([
+        t14.Partial(createFiltersSchema(sanitizedSchema)),
+        t14.Array(t14.Partial(createFiltersSchema(sanitizedSchema)), { minItems: 1 })
+      ])
+    }),
+    data: t14.Partial(schema)
+  });
+};
+
+export { createCountResponse200Schema, isDateFromElysiaTypeBox, createAdaptiveWhereClauseSchema, createPropertiesSchema, createQSchema, createFiltersSchema, createCountSchema, createSelectedFieldsSchema, createDeleteSchema, createOrderSchema, createFindSchema, createIdParamSchema, createResponse200Schema, createUpdateOneSchema, createUpdateSchema };

package/dist/chunk-pc66jgqv.js

@@ -0,0 +1,220 @@
+import {
+  DATABASE_ERROR_KEYS,
+  Repository
+} from "./chunk-1a3wj3m1.js";
+import {
+  TypedEventEmitter
+} from "./chunk-yvyahr2h.js";
+import {
+  BaseError
+} from "./chunk-vknq69e0.js";
+
+// source/modules/database/table.ts
+class Table extends TypedEventEmitter {
+  _databaseName;
+  _fields = [];
+  _name;
+  _primaryKey;
+  constructor(databaseName, tableName, fields, primaryKey) {
+    super();
+    this._databaseName = databaseName;
+    this._name = tableName;
+    this._fields = fields;
+    this._primaryKey = primaryKey;
+  }
+  get databaseName() {
+    return this._databaseName;
+  }
+  get name() {
+    return this._name;
+  }
+  get fields() {
+    return this._fields;
+  }
+  get primaryKey() {
+    return this._primaryKey;
+  }
+}
+
+// source/modules/database/mssql.ts
+import knex from "knex";
+class MSSQL extends TypedEventEmitter {
+  _isConnected = false;
+  _databaseName;
+  _tables = new Map;
+  _repositories = new Map;
+  _db;
+  _isEventEnabled;
+  constructor(options) {
+    super();
+    this._databaseName = options.databaseName;
+    this._isEventEnabled = options.isEventEnabled ?? false;
+    this._db = knex({
+      client: "mssql",
+      acquireConnectionTimeout: options.connectionTimeout ?? 20000,
+      compileSqlOnError: true,
+      connection: {
+        database: options.databaseName,
+        host: options.host,
+        port: options.port,
+        user: options.user,
+        password: options.password,
+        options: {
+          encrypt: options.encrypt ?? true
+        },
+        bigNumberStrings: false
+      },
+      pool: {
+        min: options.poolMin ?? 2,
+        max: options.poolMax ?? 10
+      }
+    });
+  }
+  async connect() {
+    try {
+      await this._introspectDatabase();
+      this._isConnected = true;
+      if (this._isEventEnabled)
+        this._addEventKnex();
+    } catch (error) {
+      throw new BaseError({
+        message: DATABASE_ERROR_KEYS.MSSQL_CONNECTION_ERROR,
+        cause: {
+          databaseName: this._databaseName,
+          error
+        }
+      });
+    }
+  }
+  async disconnect() {
+    if (!this._isConnected)
+      throw new BaseError({
+        message: DATABASE_ERROR_KEYS.MSSQL_NOT_CONNECTED,
+        cause: { databaseName: this._databaseName }
+      });
+    try {
+      await this._db.destroy();
+      this._isConnected = false;
+    } catch (error) {
+      throw new BaseError({
+        message: DATABASE_ERROR_KEYS.MSSQL_DISCONNECT_ERROR,
+        cause: {
+          databaseName: this._databaseName,
+          error
+        }
+      });
+    }
+  }
+  getRepository(tableName, customRepository) {
+    if (!this._isConnected)
+      throw new BaseError({
+        message: DATABASE_ERROR_KEYS.MSSQL_NOT_CONNECTED,
+        cause: { databaseName: this._databaseName }
+      });
+    if (!this._tables.has(tableName))
+      throw new BaseError({
+        message: DATABASE_ERROR_KEYS.MSSQL_TABLE_NOT_FOUND,
+        cause: { table: tableName }
+      });
+    let repo = this._repositories.get(tableName);
+    if (customRepository) {
+      const table = this._tables.get(tableName);
+      if (repo && repo instanceof customRepository)
+        return repo;
+      repo = new customRepository(this._db, table);
+      this._repositories.set(tableName, repo);
+      return repo;
+    }
+    return this._repositories.get(tableName);
+  }
+  getTable(tableName) {
+    if (!this._isConnected)
+      throw new BaseError({
+        message: DATABASE_ERROR_KEYS.MSSQL_NOT_CONNECTED,
+        cause: { databaseName: this._databaseName }
+      });
+    if (!this._tables.has(tableName))
+      throw new BaseError({
+        message: DATABASE_ERROR_KEYS.MSSQL_TABLE_NOT_FOUND,
+        cause: { table: tableName }
+      });
+    return this._tables.get(tableName);
+  }
+  get databaseName() {
+    return this._databaseName;
+  }
+  get tables() {
+    return this._tables;
+  }
+  get repositories() {
+    return this._repositories;
+  }
+  get isConnected() {
+    return this._isConnected;
+  }
+  get db() {
+    if (!this._isConnected)
+      throw new BaseError({
+        message: DATABASE_ERROR_KEYS.MSSQL_NOT_CONNECTED,
+        cause: { databaseName: this._databaseName }
+      });
+    return this._db;
+  }
+  async _introspectDatabase() {
+    const result = await this._db.from({ c: "information_schema.columns" }).select("c.table_name as tableName").select(this._db.raw("STRING_AGG(c.column_name, ',') AS fields")).select("pk.primaryKeyColumn as primaryKeyColumn").select("pk.primaryKeyType as primaryKeyType").leftJoin(this._db.from({ tc: "information_schema.table_constraints" }).join({ kcu: "information_schema.key_column_usage" }, "tc.constraint_name", "kcu.constraint_name").join({ col: "information_schema.columns" }, (builder) => {
+      builder.on("col.table_name", "=", "kcu.table_name").andOn("col.column_name", "=", "kcu.column_name");
+    }).where("tc.constraint_type", "PRIMARY KEY").groupBy("tc.table_name", "kcu.column_name", "col.data_type").select("tc.table_name as tableName").select("kcu.column_name as primaryKeyColumn").select("col.data_type as primaryKeyType").as("pk"), "c.table_name", "pk.tableName").groupBy("c.table_name", "pk.primaryKeyColumn", "pk.primaryKeyType");
+    const fieldsByTable = result.reduce((acc, { tableName, fields, primaryKeyColumn, primaryKeyType }) => {
+      const primaryKeyTypeTs = primaryKeyType === "int" ? "NUMBER" : "STRING";
+      acc.set(tableName, {
+        fields: fields.split(","),
+        primaryKey: [primaryKeyColumn, primaryKeyTypeTs]
+      });
+      return acc;
+    }, new Map);
+    fieldsByTable.forEach((desc, tableName) => {
+      const table = new Table(this._databaseName, tableName, desc.fields, desc.primaryKey);
+      this._tables.set(tableName, table);
+      this._repositories.set(tableName, new Repository(this._db, table));
+    });
+  }
+  _extractTablesFromSqlQuery(sql) {
+    const tableRegex = /(?:update|insert\s+into|delete\s+from|from|join|with)\s+\[?([^\]\s]+)\]?/gi;
+    const matches = [...sql.matchAll(tableRegex)].map((match) => match[1]);
+    return Array.from(new Set(matches));
+  }
+  _handleQueryResponse(response, queryContext) {
+    const tables = this._extractTablesFromSqlQuery(queryContext.sql);
+    const table = this._tables.get(tables[0]);
+    switch (queryContext.method) {
+      case "select":
+        table?.emit("selected", response, queryContext);
+        break;
+      case "insert":
+        table?.emit("inserted", response, queryContext);
+        break;
+      case "update":
+        table?.emit("updated", response, queryContext);
+        break;
+      case "del":
+        table?.emit("deleted", response, queryContext);
+        break;
+      default:
+        break;
+    }
+  }
+  _addEventKnex() {
+    this._db.on("query", (queryContext) => {
+      this.emit("query", queryContext);
+    });
+    this._db.on("query-error", (error, queryContext) => {
+      this.emit("query:error", error, queryContext);
+    });
+    this._db.on("query-response", (response, queryContext) => {
+      this.emit("query:response", response, queryContext);
+      this._handleQueryResponse(response, queryContext);
+    });
+  }
+}
+
+export { Table, MSSQL };

package/dist/chunk-s07amdhx.js

@@ -0,0 +1,77 @@
+import {
+  createCountResponse200Schema,
+  createCountSchema,
+  createDeleteSchema,
+  createFindSchema,
+  createIdParamSchema,
+  createResponse200Schema,
+  createSelectedFieldsSchema,
+  createUpdateOneSchema,
+  createUpdateSchema
+} from "./chunk-f5z7x01b.js";
+
+// source/modules/elysia/crudSchema/crudSchema.ts
+import { Elysia } from "elysia";
+
+// source/modules/elysia/crudSchema/utils/createInsertSchema.ts
+import { t } from "elysia";
+var createInsertSchema = (schema) => t.Object({
+  queryOptions: t.Optional(t.Object({
+    selectedFields: createSelectedFieldsSchema(schema)
+  })),
+  data: t.Union([
+    schema,
+    t.Array(schema, {
+      minItems: 1,
+      uniqueItems: true
+    })
+  ])
+});
+
+// source/modules/elysia/crudSchema/crudSchema.ts
+var crudSchema = ({
+  sourceSchemaName,
+  sourceSchema,
+  sourceInsertSchema = sourceSchema,
+  sourceFindSchema = sourceSchema,
+  sourceCountSchema = sourceSchema,
+  sourceUpdateSchema = sourceSchema,
+  sourceDeleteSchema = sourceSchema,
+  sourceResponseSchema = sourceSchema,
+  operations = {
+    count: true,
+    find: true,
+    findOne: true,
+    insert: true,
+    update: true,
+    updateOne: true,
+    delete: true,
+    deleteOne: true
+  }
+}) => {
+  const models = {};
+  if (operations.insert)
+    models[`${sourceSchemaName}Insert`] = createInsertSchema(sourceInsertSchema);
+  if (operations.find)
+    models[`${sourceSchemaName}Find`] = createFindSchema(sourceFindSchema);
+  if (operations.count)
+    models[`${sourceSchemaName}Count`] = createCountSchema(sourceCountSchema);
+  if (operations.update)
+    models[`${sourceSchemaName}Update`] = createUpdateSchema(sourceUpdateSchema);
+  if (operations.updateOne)
+    models[`${sourceSchemaName}UpdateOne`] = createUpdateOneSchema(sourceUpdateSchema);
+  if (operations.delete)
+    models[`${sourceSchemaName}Delete`] = createDeleteSchema(sourceDeleteSchema);
+  if (operations.findOne || operations.updateOne || operations.deleteOne)
+    models[`${sourceSchemaName}IdParam`] = createIdParamSchema();
+  if (operations.find || operations.findOne || operations.insert || operations.update || operations.updateOne || operations.delete || operations.deleteOne)
+    models[`${sourceSchemaName}Response200`] = createResponse200Schema(sourceResponseSchema);
+  if (operations.count)
+    models[`${sourceSchemaName}CountResponse200`] = createCountResponse200Schema();
+  const app = new Elysia({
+    name: `crudSchemaPlugin-${sourceSchemaName}`
+  }).model(models);
+  return app;
+};
+
+export { crudSchema };

package/dist/chunk-v8v7982b.js

@@ -0,0 +1,58 @@
+import {
+  SingletonManager
+} from "./chunk-370444pc.js";
+import {
+  MSSQL
+} from "./chunk-pc66jgqv.js";
+import {
+  HttpError
+} from "./chunk-84mqvfsk.js";
+
+// source/modules/elysia/dbResolver/dbResolver.ts
+import { Elysia, t } from "elysia";
+
+// source/modules/elysia/dbResolver/enums/dbResolverErrorKeys.ts
+var DB_RESOLVER_ERROR_KEYS = {
+  DB_RESOLVER_HEADER_KEY_NOT_FOUND: "elysia.dbResolver.error.key_not_found"
+};
+
+// source/modules/elysia/dbResolver/dbResolver.ts
+var _resolveDatabaseConnection = async (database, headers) => {
+  if (typeof database === "string")
+    return {
+      staticDB: SingletonManager.get(`database:${database}`)
+    };
+  const databaseName = headers["database-using"];
+  if (!databaseName)
+    throw new HttpError({
+      message: DB_RESOLVER_ERROR_KEYS.DB_RESOLVER_HEADER_KEY_NOT_FOUND,
+      httpStatusCode: "BAD_REQUEST"
+    });
+  if (!SingletonManager.has(`database:${databaseName}`)) {
+    SingletonManager.register(`database:${databaseName}`, MSSQL, {
+      ...database.config,
+      databaseName
+    });
+    await SingletonManager.get(`database:${databaseName}`).connect();
+  }
+  return {
+    dynamicDB: SingletonManager.get(`database:${databaseName}`)
+  };
+};
+var dbResolver = (database) => {
+  const app = new Elysia({
+    name: "dbResolverPlugin",
+    seed: database
+  }).resolve({ as: "global" }, async ({ headers }) => _resolveDatabaseConnection(database, headers));
+  if (typeof database === "object")
+    app.model({
+      ResolveDbHeader: t.Object({
+        "database-using": t.String({
+          description: "The name of the database to be used for the request"
+        })
+      })
+    });
+  return app;
+};
+
+export { dbResolver };