mock-config-server 5.0.0-beta.2 → 5.0.0-beta.3

package/dist/src/utils/helpers/isPlainObject/isPlainObject.mjs

@@ -0,0 +1,4 @@
+//#region src/utils/helpers/isPlainObject/isPlainObject.ts
+const isPlainObject = (value) => typeof value === "object" && !Array.isArray(value) && value !== null && !(value instanceof RegExp);
+//#endregion
+export { isPlainObject };

package/dist/src/utils/helpers/isPrimitive/isPrimitive.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/src/utils/helpers/isPrimitive/isPrimitive.mjs

@@ -0,0 +1,4 @@
+//#region src/utils/helpers/isPrimitive/isPrimitive.ts
+const isPrimitive = (value) => value !== Object(value);
+//#endregion
+export { isPrimitive };

package/dist/src/utils/helpers/logger/callRequestLogger/callRequestLogger.d.mts

@@ -0,0 +1 @@
+import { Request } from "express";

package/dist/src/utils/helpers/logger/callRequestLogger/callRequestLogger.mjs

@@ -0,0 +1,37 @@
+import { filterTokens } from "../helpers/filterTokens/filterTokens.mjs";
+import { formatTokens } from "../helpers/formatTokens/formatTokens.mjs";
+//#region src/utils/helpers/logger/callRequestLogger/callRequestLogger.ts
+const DEFAULT_REQUEST_LOGGER_OPTIONS = {
+	type: true,
+	id: true,
+	timestamp: true,
+	method: true,
+	url: true
+};
+const callRequestLogger = ({ logger, request }) => {
+	const filteredTokens = filterTokens({
+		type: "request",
+		id: request.id,
+		timestamp: request.timestamp,
+		method: request.method.toLowerCase(),
+		url: decodeURI(`${request.protocol}://${request.get("host")}${request.originalUrl}`),
+		graphQLOperationType: request.graphQL?.operationType ?? null,
+		graphQLOperationName: request.graphQL?.operationName ?? null,
+		graphQLQuery: request.graphQL?.query ?? null,
+		variables: request.graphQL?.variables ?? null,
+		headers: request.headers,
+		cookies: request.cookies,
+		queries: request.query,
+		params: request.params,
+		body: request.body
+	}, logger?.options ?? DEFAULT_REQUEST_LOGGER_OPTIONS);
+	if (logger?.rewrite) {
+		logger.rewrite(filteredTokens);
+		return filteredTokens;
+	}
+	const formattedTokens = formatTokens(filteredTokens);
+	console.dir(formattedTokens, { depth: null });
+	return filteredTokens;
+};
+//#endregion
+export { callRequestLogger };

package/dist/src/utils/helpers/logger/callResponseLogger/callResponseLogger.d.mts

@@ -0,0 +1 @@
+import { Request, Response } from "express";

package/dist/src/utils/helpers/logger/callResponseLogger/callResponseLogger.mjs

@@ -0,0 +1,41 @@
+import { filterTokens } from "../helpers/filterTokens/filterTokens.mjs";
+import { formatTokens } from "../helpers/formatTokens/formatTokens.mjs";
+//#region src/utils/helpers/logger/callResponseLogger/callResponseLogger.ts
+const DEFAULT_RESPONSE_LOGGER_OPTIONS = {
+	type: true,
+	id: true,
+	timestamp: true,
+	method: true,
+	url: true,
+	statusCode: true,
+	data: true
+};
+const callResponseLogger = ({ logger, data, request, response }) => {
+	const filteredTokens = filterTokens({
+		type: "response",
+		id: request.id,
+		timestamp: Date.now(),
+		method: request.method.toLowerCase(),
+		url: decodeURI(`${request.protocol}://${request.get("host")}${request.originalUrl}`),
+		graphQLOperationType: request.graphQL?.operationType ?? null,
+		graphQLOperationName: request.graphQL?.operationName ?? null,
+		graphQLQuery: request.graphQL?.query ?? null,
+		variables: request.graphQL?.variables ?? null,
+		statusCode: response.statusCode,
+		headers: request.headers,
+		cookies: request.cookies,
+		queries: request.query,
+		params: request.params,
+		body: request.body,
+		data
+	}, logger?.options ?? DEFAULT_RESPONSE_LOGGER_OPTIONS);
+	if (logger?.rewrite) {
+		logger.rewrite(filteredTokens);
+		return filteredTokens;
+	}
+	const formattedTokens = formatTokens(filteredTokens);
+	console.dir(formattedTokens, { depth: null });
+	return filteredTokens;
+};
+//#endregion
+export { callResponseLogger };

package/dist/src/utils/helpers/logger/helpers/filterTokens/filterTokens.mjs

@@ -0,0 +1,28 @@
+import { isPlainObject } from "../../../isPlainObject/isPlainObject.mjs";
+//#region src/utils/helpers/logger/helpers/filterTokens/filterTokens.ts
+const resolveNestedOptionFilterMode = (nestedOption) => {
+	return Object.values(nestedOption).some(Boolean) ? "whitelist" : "blacklist";
+};
+const filterTokens = (tokens, options) => Object.entries(options).reduce((acc, [name, option]) => {
+	const token = tokens[name];
+	if (option === true) {
+		acc[name] = token;
+		return acc;
+	}
+	const isNestedOption = isPlainObject(option);
+	const isNestedToken = isPlainObject(token);
+	if (isNestedOption && isNestedToken) {
+		const nestedOptionFilterMode = resolveNestedOptionFilterMode(option);
+		if (nestedOptionFilterMode === "whitelist") acc[name] = Object.entries(option).reduce((acc, [name, nestedOption]) => {
+			if (nestedOption) acc[name] = token[name];
+			return acc;
+		}, {});
+		if (nestedOptionFilterMode === "blacklist") acc[name] = Object.keys(token).reduce((acc, name) => {
+			if (option[name] !== false) acc[name] = token[name];
+			return acc;
+		}, {});
+	}
+	return acc;
+}, {});
+//#endregion
+export { filterTokens };

package/dist/src/utils/helpers/logger/helpers/formatTokens/formatTokens.mjs

@@ -0,0 +1,12 @@
+import { formatTimestamp } from "../../../date/formatTimestamp/formatTimestamp.mjs";
+//#region src/utils/helpers/logger/helpers/formatTokens/formatTokens.ts
+const formatTokens = (tokens) => {
+	const { timestamp, method } = tokens;
+	return {
+		...tokens,
+		...timestamp && { timestamp: formatTimestamp(timestamp) },
+		...method && { method: method.toUpperCase() }
+	};
+};
+//#endregion
+export { formatTokens };

package/dist/src/utils/helpers/logger/index.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/src/utils/helpers/request/index.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/src/utils/helpers/request/parseCookie/parseCookie.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/src/utils/helpers/request/parseCookie/parseCookie.mjs

@@ -0,0 +1,13 @@
+//#region src/utils/helpers/request/parseCookie/parseCookie.ts
+const parseCookie = (cookieHeader) => {
+	if (!cookieHeader) return {};
+	const cookies = {};
+	cookieHeader.split(";").forEach((cookie) => {
+		const [name, value] = cookie.trim().split("=");
+		if (!name) return;
+		cookies[name.trim()] = value?.trim() ?? "";
+	});
+	return cookies;
+};
+//#endregion
+export { parseCookie };

package/dist/src/utils/helpers/request/parseQuery/parseQuery.mjs

@@ -0,0 +1,20 @@
+//#region src/utils/helpers/request/parseQuery/parseQuery.ts
+const parseQuery = (requestUrl) => {
+	const url = new URL(requestUrl, "http://localhost");
+	const query = {};
+	for (const [key, value] of url.searchParams.entries()) {
+		const currentValue = query[key];
+		if (query[key] === void 0) {
+			query[key] = value;
+			continue;
+		}
+		if (Array.isArray(currentValue)) {
+			currentValue.push(value);
+			continue;
+		}
+		query[key] = [currentValue, value];
+	}
+	return query;
+};
+//#endregion
+export { parseQuery };

package/dist/src/utils/helpers/sleep.mjs

@@ -0,0 +1,6 @@
+//#region src/utils/helpers/sleep.ts
+const sleep = (milliseconds) => new Promise((resolve) => {
+	setTimeout(resolve, milliseconds);
+});
+//#endregion
+export { sleep };

package/dist/src/utils/helpers/url/normalizeUrl/normalizeUrl.mjs

@@ -0,0 +1,7 @@
+//#region src/utils/helpers/url/normalizeUrl/normalizeUrl.ts
+const normalizeUrl = (url) => {
+	if (!url || url === "/") return "/";
+	return url.replace(/\/+$/g, "") || "/";
+};
+//#endregion
+export { normalizeUrl };

package/dist/src/utils/helpers/url/urlJoin/urlJoin.mjs

@@ -0,0 +1,5 @@
+import path from "node:path";
+//#region src/utils/helpers/url/urlJoin/urlJoin.ts
+const urlJoin = (...paths) => path.posix.join(...paths.map((path) => path.replace(/^\\\\\?\\/, "").replace(/\\/g, "/")));
+//#endregion
+export { urlJoin };

package/dist/src/utils/types/cors.d.mts

@@ -0,0 +1,17 @@
+import { MaybePromise } from "./utils.mjs";
+import { RestMethod } from "./rest.mjs";
+import { Request } from "express";
+
+//#region src/utils/types/cors.d.ts
+type CorsHeader = string;
+type CorsOrigin = string | (string | RegExp)[] | RegExp;
+interface Cors {
+  allowedHeaders?: CorsHeader[];
+  credentials?: boolean;
+  exposedHeaders?: CorsHeader[];
+  maxAge?: number;
+  methods?: Uppercase<RestMethod>[];
+  origin: ((request: Request) => MaybePromise<CorsOrigin>) | CorsOrigin;
+}
+//#endregion
+export { Cors, CorsHeader, CorsOrigin };

package/dist/src/utils/types/database.d.mts

@@ -0,0 +1,40 @@
+//#region src/utils/types/database.d.ts
+interface Database extends Record<string, unknown> {}
+type ShallowDatabase = Record<string, unknown>;
+interface DatabaseConfig {
+  data: `${string}.json` | Record<string, unknown>;
+  routes?: `${string}.json` | Record<`/${string}`, `/${string}`>;
+}
+type NestedDatabaseId = number | string;
+type NestedDatabase = Record<string, {
+  id: NestedDatabaseId;
+  [key: string]: unknown;
+}[]>;
+type StorageIndex = number | string;
+interface Storage {
+  delete: (key: StorageIndex | StorageIndex[]) => void;
+  read: (key?: StorageIndex | StorageIndex[]) => any;
+  write: (key: StorageIndex | StorageIndex[], value: unknown) => void;
+}
+interface ShallowOrm<Item = unknown> {
+  get: () => Item;
+  update: (data: Item) => void;
+}
+interface NestedOrm<Item = Record<string, unknown>> {
+  count: () => number;
+  create: (item: Omit<Item, 'id'>) => Item;
+  createMany: (items: Omit<Item, 'id'>[]) => void;
+  delete: (id: StorageIndex) => void;
+  deleteMany: (ids: StorageIndex[]) => void;
+  exists: (filters: Partial<Item>) => boolean;
+  findById: (id: StorageIndex) => Item | undefined;
+  findFirst: (filters?: Partial<Item>) => Item | undefined;
+  findMany: (filters?: Partial<Item>) => Item[];
+  update: (id: StorageIndex, item: Partial<Omit<Item, 'id'>>) => void;
+  updateMany: (ids: StorageIndex[], item: Partial<Omit<Item, 'id'>>) => number;
+}
+type Orm<Database extends Record<string, unknown>> = { [Key in keyof Database]: Database[Key] extends Array<infer Item> ? Item extends {
+  id: StorageIndex;
+} ? NestedOrm<Item> : ShallowOrm<Database[Key]> : ShallowOrm<Database[Key]> };
+//#endregion
+export { Database, DatabaseConfig, NestedDatabase, NestedDatabaseId, NestedOrm, Orm, ShallowDatabase, ShallowOrm, Storage, StorageIndex };

package/dist/src/utils/types/entities.d.mts

@@ -0,0 +1,15 @@
+import { IS_COMPARATOR_SYMBOL } from "../constants/entitites.mjs";
+
+//#region src/utils/types/entities.d.ts
+type Comparator<Actual = unknown, Expected = unknown> = ((actual: Actual, expected: Expected) => boolean) & {
+  [IS_COMPARATOR_SYMBOL]: true;
+};
+type MappedEntityValue = boolean | number | string | (boolean | number | string)[];
+type MappedEntityObject = Record<string, Comparator<MappedEntityValue> | MappedEntityValue>;
+type MappedEntity = Comparator<MappedEntityObject> | MappedEntityObject;
+type BodyEntityValue = string | Record<string, unknown> | unknown[];
+type BodyEntity = BodyEntityValue | Comparator<BodyEntityValue>;
+type VariablesEntityValue = Record<string, unknown>;
+type VariablesEntity = Comparator<VariablesEntityValue> | VariablesEntityValue;
+//#endregion
+export { BodyEntity, Comparator, MappedEntity, VariablesEntity };

package/dist/src/utils/types/files.d.mts

@@ -0,0 +1,9 @@
+import { Buffer } from "node:buffer";
+
+//#region src/utils/types/files.d.ts
+interface FileDescriptor {
+  file: Buffer;
+  path: string;
+}
+//#endregion
+export { FileDescriptor };

package/dist/src/utils/types/graphql-transport-ws.d.mts

@@ -0,0 +1,84 @@
+import { VariablesEntity } from "./entities.mjs";
+import { PlainObject } from "./values.mjs";
+import { MaybePromise } from "./utils.mjs";
+import { GraphQLIdentifier } from "./graphql.mjs";
+import { ExecutionResult, GraphQLError } from "graphql";
+import { RawData, WebSocket } from "ws";
+
+//#region src/utils/types/graphql-transport-ws.d.ts
+type GraphqlTransportWsOperationId = string;
+type GraphqlTransportWsMessagePayload = Record<string, unknown> | null;
+interface GraphqlTransportWsConnectionInitMessage {
+  payload?: GraphqlTransportWsMessagePayload;
+  type: 'connection_init';
+}
+interface GraphqlTransportWsConnectionAckMessage {
+  payload?: GraphqlTransportWsMessagePayload;
+  type: 'connection_ack';
+}
+interface GraphqlTransportWsPingMessage {
+  payload?: GraphqlTransportWsMessagePayload;
+  type: 'ping';
+}
+interface GraphqlTransportWsPongMessage {
+  payload?: GraphqlTransportWsMessagePayload;
+  type: 'pong';
+}
+interface GraphqlTransportWsSubscribeMessage {
+  id: GraphqlTransportWsOperationId;
+  payload: {
+    query: string;
+    operationName?: string | null;
+    variables?: PlainObject | null;
+    extensions?: PlainObject | null;
+  };
+  type: 'subscribe';
+}
+type GraphqlTransportWsExecutionResult = ExecutionResult<Record<string, unknown>, PlainObject>;
+interface GraphqlTransportWsNextMessage {
+  id: GraphqlTransportWsOperationId;
+  payload: GraphqlTransportWsExecutionResult;
+  type: 'next';
+}
+interface GraphqlTransportWsErrorMessage {
+  id: GraphqlTransportWsOperationId;
+  payload: ReadonlyArray<GraphQLError>;
+  type: 'error';
+}
+interface GraphqlTransportWsCompleteMessage {
+  id: GraphqlTransportWsOperationId;
+  type: 'complete';
+}
+type GraphqlTransportWsMessage = GraphqlTransportWsCompleteMessage | GraphqlTransportWsConnectionInitMessage | GraphqlTransportWsPingMessage | GraphqlTransportWsPongMessage | GraphqlTransportWsSubscribeMessage;
+interface GraphqlTransportWsEntitiesByEntityName {
+  variables?: VariablesEntity;
+}
+interface GraphqlTransportWsParams {
+  entities: GraphqlTransportWsEntitiesByEntityName;
+  eventName?: string;
+  operationName?: string;
+  query?: string;
+  raw: RawData;
+  socket: WebSocket;
+  variables?: PlainObject;
+  complete: () => void;
+  next: (payload: GraphqlTransportWsExecutionResult) => void;
+  setDelay: (delay: number) => Promise<void>;
+}
+type GraphqlTransportWsDataResponse = ((params: GraphqlTransportWsParams) => MaybePromise<GraphqlTransportWsExecutionResult>) | GraphqlTransportWsExecutionResult;
+interface GraphqlTransportWsSettings {
+  readonly delay?: number;
+}
+interface GraphqlTransportWsRouteConfig {
+  data: GraphqlTransportWsDataResponse;
+  entities?: GraphqlTransportWsEntitiesByEntityName;
+  settings?: GraphqlTransportWsSettings;
+}
+type GraphqlTransportWsOperationType = 'subscription';
+interface GraphqlTransportWsRequestConfig {
+  identifier: GraphQLIdentifier;
+  operationType: GraphqlTransportWsOperationType;
+  routes: GraphqlTransportWsRouteConfig[];
+}
+//#endregion
+export { GraphqlTransportWsCompleteMessage, GraphqlTransportWsConnectionAckMessage, GraphqlTransportWsConnectionInitMessage, GraphqlTransportWsDataResponse, GraphqlTransportWsEntitiesByEntityName, GraphqlTransportWsErrorMessage, GraphqlTransportWsExecutionResult, GraphqlTransportWsMessage, GraphqlTransportWsMessagePayload, GraphqlTransportWsNextMessage, GraphqlTransportWsOperationId, GraphqlTransportWsOperationType, GraphqlTransportWsParams, GraphqlTransportWsPingMessage, GraphqlTransportWsPongMessage, GraphqlTransportWsRequestConfig, GraphqlTransportWsRouteConfig, GraphqlTransportWsSettings, GraphqlTransportWsSubscribeMessage };

package/dist/src/utils/types/graphql.d.mts

@@ -0,0 +1,71 @@
+import { MappedEntity, VariablesEntity } from "./entities.mjs";
+import { PlainObject } from "./values.mjs";
+import { MaybePromise } from "./utils.mjs";
+import { BaseUrl } from "./server.mjs";
+import { Interceptors } from "./interceptors.mjs";
+import { ExecutionResult } from "graphql";
+import { CookieOptions, Request, Response } from "express";
+
+//#region src/utils/types/graphql.d.ts
+type GraphQLEntityName = 'cookies' | 'headers' | 'queries' | 'variables';
+type GraphQLEntity<EntityName extends GraphQLEntityName = GraphQLEntityName> = EntityName extends 'variables' ? VariablesEntity : MappedEntity;
+type GraphQLOperationType = 'mutation' | 'query';
+type GraphQLIdentifier = string | RegExp;
+type GraphQLEntitiesByEntityName = { [EntityName in GraphQLEntityName]?: GraphQLEntity<EntityName> };
+interface GraphQLSettings {
+  readonly delay?: number;
+  readonly status?: number;
+}
+type GraphQLCookieValue = string | undefined;
+type GraphQLHeaderValue = number | string | string[] | undefined;
+type GraphQLExecutionResult = ExecutionResult<Record<string, unknown>, PlainObject>;
+interface GraphQLParams<Query = Record<string, unknown>, Body = Record<string, unknown>, Params = Record<string, unknown>, Response$1 = any> {
+  entities: GraphQLEntitiesByEntityName;
+  request: Request<Params, Response$1, Body, Query>;
+  response: Response;
+  appendHeader: (field: string, value?: string | string[]) => void;
+  attachment: (filename: string) => void;
+  broadcast: <Response$1>(response: Response$1) => void;
+  clearCookie: (name: string, options?: CookieOptions) => void;
+  getCookie: (name: string) => GraphQLCookieValue;
+  getRequestHeader: (field: string) => GraphQLHeaderValue;
+  getRequestHeaders: () => Record<string, GraphQLHeaderValue>;
+  getResponseHeader: (field: string) => GraphQLHeaderValue;
+  getResponseHeaders: () => Record<string, GraphQLHeaderValue>;
+  next: () => void;
+  setCookie: (name: string, value: string, options?: CookieOptions) => void;
+  setDelay: (delay: number) => Promise<void>;
+  setHeader: (field: string, value?: string | string[]) => void;
+  setStatusCode: (statusCode: number) => void;
+}
+type GraphQLDataResponseFunction = (params: GraphQLParams) => MaybePromise<GraphQLExecutionResult>;
+type GraphQLDataResponse = GraphQLDataResponseFunction | GraphQLExecutionResult;
+interface GraphQLRouteConfig {
+  data: GraphQLDataResponse;
+  entities?: GraphQLEntitiesByEntityName;
+  interceptors?: Interceptors<'graphql'>;
+  settings?: GraphQLSettings;
+}
+interface GraphQLRequestConfig {
+  identifier: GraphQLIdentifier;
+  interceptors?: Interceptors<'graphql'>;
+  operationType: GraphQLOperationType;
+  routes: GraphQLRouteConfig[];
+}
+interface GraphQLRequestArtifact {
+  baseUrl: BaseUrl;
+  componentRequestInterceptor?: Interceptors<'graphql'>['request'];
+  componentResponseInterceptor?: Interceptors<'graphql'>['response'];
+  config: GraphQLRouteConfig;
+  identifier: GraphQLIdentifier;
+  operationType: GraphQLOperationType;
+  requestRequestInterceptor?: Interceptors<'graphql'>['request'];
+  requestResponseInterceptor?: Interceptors<'graphql'>['response'];
+  routeRequestInterceptor?: Interceptors<'graphql'>['request'];
+  routeResponseInterceptor?: Interceptors<'graphql'>['response'];
+  serverRequestInterceptor?: Interceptors<'graphql'>['request'];
+  serverResponseInterceptor?: Interceptors<'graphql'>['response'];
+  weight: number;
+}
+//#endregion
+export { GraphQLDataResponse, GraphQLDataResponseFunction, GraphQLEntitiesByEntityName, GraphQLEntity, GraphQLEntityName, GraphQLExecutionResult, GraphQLIdentifier, GraphQLOperationType, GraphQLParams, GraphQLRequestArtifact, GraphQLRequestConfig, GraphQLRouteConfig, GraphQLSettings };

package/dist/src/utils/types/index.d.mts

@@ -0,0 +1,14 @@
+import { BodyEntity, Comparator, MappedEntity, VariablesEntity } from "./entities.mjs";
+import { Database, DatabaseConfig, NestedDatabase, NestedDatabaseId, NestedOrm, Orm, ShallowDatabase, ShallowOrm, Storage, StorageIndex } from "./database.mjs";
+import { Cookies, Data, Headers, Params, PlainObject, Primitive, Query } from "./values.mjs";
+import { Entries, MaybePromise, ValueOf } from "./utils.mjs";
+import { GraphqlTransportWsCompleteMessage, GraphqlTransportWsConnectionAckMessage, GraphqlTransportWsConnectionInitMessage, GraphqlTransportWsDataResponse, GraphqlTransportWsEntitiesByEntityName, GraphqlTransportWsErrorMessage, GraphqlTransportWsExecutionResult, GraphqlTransportWsMessage, GraphqlTransportWsMessagePayload, GraphqlTransportWsNextMessage, GraphqlTransportWsOperationId, GraphqlTransportWsOperationType, GraphqlTransportWsParams, GraphqlTransportWsPingMessage, GraphqlTransportWsPongMessage, GraphqlTransportWsRequestConfig, GraphqlTransportWsRouteConfig, GraphqlTransportWsSettings, GraphqlTransportWsSubscribeMessage } from "./graphql-transport-ws.mjs";
+import { ConnectionWsRequestArtifact, GraphqlTransportWsRequestArtifact, RawWsRequestArtifact, WsConnectionDataResponse, WsConnectionEntitiesByEntityName, WsConnectionEntityName, WsConnectionParams, WsConnectionRequestConfig, WsConnectionRouteConfig, WsDataResponse, WsFrame, WsFrameBinary, WsFrameText, WsParams, WsRawRequestConfig, WsRawRouteConfig, WsRequestArtifact, WsRequestConfig, WsSettings } from "./ws.mjs";
+import { BaseServerConfig, BaseUrl, MockServerCliArgv, MockServerComponent, MockServerConfig, MockServerSettings, Port, StaticPath } from "./server.mjs";
+import { GraphQLDataResponse, GraphQLDataResponseFunction, GraphQLEntitiesByEntityName, GraphQLEntity, GraphQLEntityName, GraphQLExecutionResult, GraphQLIdentifier, GraphQLOperationType, GraphQLParams, GraphQLRequestArtifact, GraphQLRequestConfig, GraphQLRouteConfig, GraphQLSettings } from "./graphql.mjs";
+import { ApiType } from "./shared.mjs";
+import { Logger, LoggerBaseTokens, LoggerOptions, LoggerTokens, LoggerType } from "./logger.mjs";
+import { Interceptors, RequestInterceptor, RequestInterceptorParams, ResponseInterceptor, ResponseInterceptorParams } from "./interceptors.mjs";
+import { BaseRestRequestConfig, RestDataResponse, RestDataResponseFunction, RestEntitiesByEntityName, RestEntity, RestEntityName, RestEntityNamesByMethod, RestFileResponse, RestMethod, RestParams, RestPathString, RestRequestArtifact, RestRequestConfig, RestRouteConfig, RestSettings } from "./rest.mjs";
+import { Cors, CorsHeader, CorsOrigin } from "./cors.mjs";
+import { FileDescriptor } from "./files.mjs";

package/dist/src/utils/types/interceptors.d.mts

@@ -0,0 +1,44 @@
+import { Database, Orm } from "./database.mjs";
+import { MaybePromise } from "./utils.mjs";
+import { ApiType } from "./shared.mjs";
+import { Logger, LoggerTokens } from "./logger.mjs";
+import { CookieOptions, Request, Response } from "express";
+
+//#region src/utils/types/interceptors.d.ts
+type InterceptorCookieValue = string | undefined;
+type InterceptorHeaderValue = number | string | string[] | undefined;
+interface RequestInterceptorParams<Api extends ApiType = ApiType> {
+  orm: Orm<Database>;
+  request: Request;
+  getCookie: (name: string) => InterceptorCookieValue;
+  getHeader: (field: string) => InterceptorHeaderValue;
+  getHeaders: () => Record<string, InterceptorHeaderValue>;
+  log: (logger?: Logger<'request', Api>) => Partial<LoggerTokens>;
+  setDelay: (delay: number) => Promise<void>;
+}
+type RequestInterceptor<Api extends ApiType = ApiType> = (params: RequestInterceptorParams<Api>) => MaybePromise<void>;
+interface ResponseInterceptorParams<Api extends ApiType = ApiType> {
+  orm: Orm<Database>;
+  request: Request;
+  response: Response;
+  appendHeader: (field: string, value?: string | string[]) => void;
+  attachment: (filename: string) => void;
+  clearCookie: (name: string, options?: CookieOptions) => void;
+  getCookie: (name: string) => InterceptorCookieValue;
+  getRequestHeader: (field: string) => InterceptorHeaderValue;
+  getRequestHeaders: () => Record<string, InterceptorHeaderValue>;
+  getResponseHeader: (field: string) => InterceptorHeaderValue;
+  getResponseHeaders: () => Record<string, InterceptorHeaderValue>;
+  log: (logger?: Logger<'response', Api>) => Partial<LoggerTokens>;
+  setCookie: (name: string, value: string, options?: CookieOptions) => void;
+  setDelay: (delay: number) => Promise<void>;
+  setHeader: (field: string, value?: string | string[]) => void;
+  setStatusCode: (statusCode: number) => void;
+}
+type ResponseInterceptor<Data = any, Api extends ApiType = ApiType> = (data: Data, params: ResponseInterceptorParams<Api>) => any;
+interface Interceptors<Api extends ApiType = ApiType> {
+  request?: RequestInterceptor<Api>;
+  response?: ResponseInterceptor<any, Api>;
+}
+//#endregion
+export { Interceptors, RequestInterceptor, RequestInterceptorParams, ResponseInterceptor, ResponseInterceptorParams };

package/dist/src/utils/types/logger.d.mts

@@ -0,0 +1,43 @@
+import { Cookies, Headers, Params, PlainObject, Query } from "./values.mjs";
+import { GraphQLOperationType } from "./graphql.mjs";
+import { ApiType } from "./shared.mjs";
+import { RestMethod } from "./rest.mjs";
+
+//#region src/utils/types/logger.d.ts
+interface LoggerBaseTokens {
+  body: any;
+  cookies: Cookies;
+  headers: Headers;
+  id: number;
+  method: RestMethod;
+  params: Params;
+  queries: Query;
+  timestamp: number;
+  type: string;
+  url: string;
+}
+interface LoggerRestRequestTokens extends LoggerBaseTokens {}
+interface LoggerRestResponseTokens extends LoggerRestRequestTokens {
+  data: any;
+  statusCode: number;
+}
+interface LoggerGraphQLRequestTokens extends LoggerBaseTokens {
+  graphQLOperationName: string | null;
+  graphQLOperationType: GraphQLOperationType | null;
+  graphQLQuery: string | null;
+  variables: PlainObject | null;
+}
+interface LoggerGraphQLResponseTokens extends LoggerGraphQLRequestTokens {
+  data: any;
+  statusCode: number;
+}
+type LoggerType = 'request' | 'response';
+type LoggerTokens<Type extends LoggerType = LoggerType, Api extends ApiType = ApiType> = Type extends 'request' ? Api extends 'rest' ? LoggerRestRequestTokens : Api extends 'graphql' ? LoggerGraphQLRequestTokens : never : Type extends 'response' ? Api extends 'rest' ? LoggerRestResponseTokens : Api extends 'graphql' ? LoggerGraphQLResponseTokens : never : never;
+type LoggerTokensToLoggerOptions<Type> = { [Key in keyof Type]?: Type[Key] extends PlainObject ? boolean | Record<string, boolean> : boolean };
+type LoggerOptions<Type extends LoggerType = LoggerType, Api extends ApiType = ApiType> = LoggerTokensToLoggerOptions<LoggerTokens<Type, Api>>;
+interface Logger<Type extends LoggerType = LoggerType, Api extends ApiType = ApiType> {
+  options?: LoggerOptions<Type, Api>;
+  rewrite?: (tokens: Partial<LoggerTokens<Type, Api>>) => void;
+}
+//#endregion
+export { Logger, LoggerBaseTokens, LoggerOptions, LoggerTokens, LoggerType };

package/dist/src/utils/types/rest.d.mts

@@ -0,0 +1,78 @@
+import { BodyEntity, MappedEntity } from "./entities.mjs";
+import { Data } from "./values.mjs";
+import { MaybePromise } from "./utils.mjs";
+import { BaseUrl } from "./server.mjs";
+import { Interceptors } from "./interceptors.mjs";
+import { CookieOptions, Request, Response } from "express";
+
+//#region src/utils/types/rest.d.ts
+type RestMethod = 'delete' | 'get' | 'options' | 'patch' | 'post' | 'put';
+type RestEntityName = 'body' | 'cookies' | 'headers' | 'params' | 'queries';
+type RestEntity<EntityName extends RestEntityName = RestEntityName> = EntityName extends 'body' ? BodyEntity : MappedEntity;
+type RestEntityNamesByMethod = { [key in RestMethod]: key extends 'delete' | 'get' | 'options' ? Exclude<RestEntityName, 'body'> : RestEntityName };
+type RestEntitiesByEntityName<Method extends RestMethod = RestMethod> = { [EntityName in RestEntityNamesByMethod[Method]]?: RestEntity<EntityName> };
+interface RestSettings {
+  readonly delay?: number;
+  readonly status?: number;
+}
+type RestCookieValue = string | undefined;
+type RestHeaderValue = number | string | string[] | undefined;
+interface RestParams<Method extends RestMethod = RestMethod, Query = Record<string, unknown>, Body = Record<string, unknown>, Params = Record<string, unknown>, Response$1 = any> {
+  entities: RestEntitiesByEntityName<Method>;
+  request: Request<Params, Response$1, Body, Query>;
+  response: Response;
+  appendHeader: (field: string, value?: string | string[]) => void;
+  attachment: (filename: string) => void;
+  broadcast: <Response$1>(response: Response$1) => void;
+  clearCookie: (name: string, options?: CookieOptions) => void;
+  getCookie: (name: string) => RestCookieValue;
+  getRequestHeader: (field: string) => RestHeaderValue;
+  getRequestHeaders: () => Record<string, RestHeaderValue>;
+  getResponseHeader: (field: string) => RestHeaderValue;
+  getResponseHeaders: () => Record<string, RestHeaderValue>;
+  next: () => void;
+  setCookie: (name: string, value: string, options?: CookieOptions) => void;
+  setDelay: (delay: number) => Promise<void>;
+  setHeader: (field: string, value?: string | string[]) => void;
+  setStatusCode: (statusCode: number) => void;
+}
+type RestDataResponseFunction<Method extends RestMethod = RestMethod> = (params: RestParams<Method>) => MaybePromise<Data>;
+type RestDataResponse<Method extends RestMethod = RestMethod> = Data | RestDataResponseFunction<Method>;
+type RestFileResponse = string;
+interface RestRouteConfig<Method extends RestMethod> {
+  data: RestDataResponse<Method>;
+  entities?: RestEntitiesByEntityName<Method>;
+  interceptors?: Interceptors<'rest'>;
+  settings?: RestSettings;
+}
+type RestPathString = `/${string}`;
+interface BaseRestRequestConfig<Method extends RestMethod> {
+  interceptors?: Interceptors<'rest'>;
+  method: Method;
+  path: RegExp | RestPathString;
+  routes: RestRouteConfig<Method>[];
+}
+type RestGetRequestConfig = BaseRestRequestConfig<'get'>;
+type RestPostRequestConfig = BaseRestRequestConfig<'post'>;
+type RestPutRequestConfig = BaseRestRequestConfig<'put'>;
+type RestDeleteRequestConfig = BaseRestRequestConfig<'delete'>;
+type RestPatchRequestConfig = BaseRestRequestConfig<'patch'>;
+type RestOptionsRequestConfig = BaseRestRequestConfig<'options'>;
+type RestRequestConfig = RestDeleteRequestConfig | RestGetRequestConfig | RestOptionsRequestConfig | RestPatchRequestConfig | RestPostRequestConfig | RestPutRequestConfig;
+interface RestRequestArtifact {
+  baseUrl: BaseUrl;
+  componentRequestInterceptor?: Interceptors<'rest'>['request'];
+  componentResponseInterceptor?: Interceptors<'rest'>['response'];
+  config: RestRouteConfig<RestMethod>;
+  method: RestMethod;
+  path: RegExp | RestPathString;
+  requestRequestInterceptor?: Interceptors<'rest'>['request'];
+  requestResponseInterceptor?: Interceptors<'rest'>['response'];
+  routeRequestInterceptor?: Interceptors<'rest'>['request'];
+  routeResponseInterceptor?: Interceptors<'rest'>['response'];
+  serverRequestInterceptor?: Interceptors<'rest'>['request'];
+  serverResponseInterceptor?: Interceptors<'rest'>['response'];
+  weight: number;
+}
+//#endregion
+export { BaseRestRequestConfig, RestDataResponse, RestDataResponseFunction, RestEntitiesByEntityName, RestEntity, RestEntityName, RestEntityNamesByMethod, RestFileResponse, RestMethod, RestParams, RestPathString, RestRequestArtifact, RestRequestConfig, RestRouteConfig, RestSettings };