@lucaapp/service-utils 1.22.0 → 1.23.0

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export * from './lib/api';
 export * from './lib/kafka';
 export * from './lib/serviceIdentity';
 export * from './lib/urlEncoded';

package/dist/index.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lib/api"), exports);
 __exportStar(require("./lib/kafka"), exports);
 __exportStar(require("./lib/serviceIdentity"), exports);
 __exportStar(require("./lib/urlEncoded"), exports);

package/dist/lib/api/api.d.ts

@@ -0,0 +1,29 @@
+import { Router } from 'express';
+import 'express-async-errors';
+import { OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+import { EndpointHandler, EndpointOptions } from './types/endpoint';
+import { Middleware, EndpointResponseSchema } from './types/middleware';
+type OpenApiVersion = '3.0.0' | '3.0.1' | '3.0.2' | '3.0.3' | '3.1.0';
+type ApiConstructorOptions = {
+    prefixPath?: string;
+    openApiVersion?: OpenApiVersion;
+    apiVersion?: string;
+    apiTitle?: string;
+    apiDescription?: string;
+};
+export declare class Api {
+    router: Router;
+    registry: OpenAPIRegistry;
+    openApiVersion: OpenApiVersion;
+    apiVersion: string;
+    apiTitle: string;
+    apiDescription: string;
+    private prefixPath;
+    constructor(options?: ApiConstructorOptions);
+    get<TResponseSchemas extends ReadonlyArray<EndpointResponseSchema>, TRequestBody = undefined, TRequestParams = undefined, TRequestQuery = undefined, TRequestHeaders = undefined, TMiddlewares extends ReadonlyArray<Middleware<any, any, any, any, any, any>> | undefined = undefined>(path: string, summary: string, options: EndpointOptions<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TMiddlewares>, handler: EndpointHandler<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TMiddlewares>): void;
+    post<TResponseSchemas extends ReadonlyArray<EndpointResponseSchema>, TRequestBody = undefined, TRequestParams = undefined, TRequestQuery = undefined, TRequestHeaders = undefined, TMiddlewares extends ReadonlyArray<Middleware<any, any, any, any, any, any>> | undefined = undefined>(path: string, summary: string, options: EndpointOptions<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TMiddlewares>, handler: EndpointHandler<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TMiddlewares>): void;
+    patch<TResponseSchemas extends ReadonlyArray<EndpointResponseSchema>, TRequestBody = undefined, TRequestParams = undefined, TRequestQuery = undefined, TRequestHeaders = undefined, TMiddlewares extends ReadonlyArray<Middleware<any, any, any, any, any, any>> | undefined = undefined>(path: string, summary: string, options: EndpointOptions<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TMiddlewares>, handler: EndpointHandler<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TMiddlewares>): void;
+    generateOpenAPISpec(): import("openapi3-ts").OpenAPIObject;
+    mountSwaggerMiddlewares(): void;
+}
+export {};

package/dist/lib/api/api.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Api = void 0;
+const express_1 = require("express");
+require("express-async-errors");
+const swagger_ui_express_1 = __importDefault(require("swagger-ui-express"));
+const zod_to_openapi_1 = require("@asteasolutions/zod-to-openapi");
+const endpoint_1 = require("./endpoint");
+class Api {
+    constructor(options = {}) {
+        this.router = (0, express_1.Router)();
+        this.registry = new zod_to_openapi_1.OpenAPIRegistry();
+        this.prefixPath = options.prefixPath || '';
+        this.openApiVersion = options.openApiVersion || '3.0.0';
+        this.apiVersion = options.apiVersion || '1.0.0';
+        this.apiTitle = options.apiTitle || 'API';
+        this.apiDescription = options.apiDescription || '';
+        this.mountSwaggerMiddlewares();
+    }
+    get(path, summary, options, handler) {
+        (0, endpoint_1.mountEndpoint)(this.router, 'get', path, options, handler);
+        (0, endpoint_1.registerEndpoint)(this.registry, 'get', this.prefixPath, path, summary, options);
+    }
+    post(path, summary, options, handler) {
+        (0, endpoint_1.mountEndpoint)(this.router, 'post', path, options, handler);
+        (0, endpoint_1.registerEndpoint)(this.registry, 'post', this.prefixPath, path, summary, options);
+    }
+    patch(path, summary, options, handler) {
+        (0, endpoint_1.mountEndpoint)(this.router, 'patch', path, options, handler);
+        (0, endpoint_1.registerEndpoint)(this.registry, 'patch', this.prefixPath, path, summary, options);
+    }
+    generateOpenAPISpec() {
+        const generator = new zod_to_openapi_1.OpenAPIGenerator(this.registry.definitions, this.openApiVersion);
+        const spec = generator.generateDocument({
+            info: {
+                version: this.apiVersion,
+                title: this.apiTitle,
+                description: this.apiDescription,
+            },
+        });
+        return spec;
+    }
+    mountSwaggerMiddlewares() {
+        this.router.use('/swagger', swagger_ui_express_1.default.serve);
+        this.router.get('/swagger', (request, response, next) => {
+            const spec = this.generateOpenAPISpec();
+            swagger_ui_express_1.default.setup(spec)(request, response, next);
+        });
+        this.router.get('/swagger.json', (request, response) => {
+            const spec = this.generateOpenAPISpec();
+            response.send(spec);
+        });
+    }
+}
+exports.Api = Api;

package/dist/lib/api/endpoint.d.ts

@@ -0,0 +1,8 @@
+import { Router } from 'express';
+import { OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+import { Middleware, EndpointResponseSchema } from './types/middleware';
+import { EndpointOptions, EndpointHandler } from './types/endpoint';
+type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch';
+export declare const mountEndpoint: <TResponseSchemas extends readonly EndpointResponseSchema[], TRequestBody = undefined, TRequestParams = undefined, TRequestQuery = undefined, TRequestHeaders = undefined, TMiddlewares extends readonly Middleware<any, any, any, any, any, any>[] | undefined = undefined>(router: Router, method: HttpMethod, path: string, options: EndpointOptions<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TMiddlewares>, handler: EndpointHandler<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TMiddlewares>) => void;
+export declare const registerEndpoint: (registry: OpenAPIRegistry, method: HttpMethod, prefixPath: string, path: string, summary: string, options: EndpointOptions<any, any, any, any, any, any>) => void;
+export {};

package/dist/lib/api/endpoint.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerEndpoint = exports.mountEndpoint = void 0;
+const zod_1 = require("zod");
+const assert_1 = __importDefault(require("assert"));
+const buildResponseConfig = (responseOptions) => {
+    const responses = {};
+    responseOptions.forEach(response => {
+        responses[String(response.status)] = {
+            description: response.description,
+            ...(!(response.schema instanceof zod_1.ZodVoid) && {
+                content: {
+                    'application/json': {
+                        schema: response.schema,
+                    },
+                },
+            }),
+        };
+    });
+    return responses;
+};
+const mountEndpoint = (router, method, path, options, handler) => {
+    (0, assert_1.default)(options.responses.length > 0, 'You need to specify at least one response');
+    router[method](path, async (request, response) => {
+        // parse request schemas
+        const handlerRequestBody = ((await options.schemas?.body?.parseAsync(request.body)) || undefined);
+        const handlerRequestParams = ((await options.schemas?.params?.parseAsync(request.params)) || undefined);
+        const handlerRequestQuery = ((await options.schemas?.query?.parseAsync(request.query)) || undefined);
+        const handlerRequestHeaders = ((await options.schemas?.headers?.parseAsync(request.headers)) || undefined);
+        const handlerRequest = {
+            body: handlerRequestBody,
+            params: handlerRequestParams,
+            query: handlerRequestQuery,
+            headers: handlerRequestHeaders,
+        };
+        // TODO: handle middlewares and build context object
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const ctx = {};
+        await handler(handlerRequest, ctx, controllerResponse => {
+            // this assertion is necessary due to the type possibly being unknown because of the edge case of an schema array with 0 elements
+            (0, assert_1.default)(typeof controllerResponse.status === 'number');
+            // get schema respective to status code
+            const { schema } = options.responses.find(responseSchema => responseSchema.status === controllerResponse.status);
+            // validate response schema
+            const validatedResponseBody = schema.parse(controllerResponse.body);
+            if (validatedResponseBody === undefined) {
+                // No Content Response
+                return response.status(controllerResponse.status).end();
+            }
+            response.status(controllerResponse.status).send(validatedResponseBody);
+        });
+    });
+};
+exports.mountEndpoint = mountEndpoint;
+const registerEndpoint = (registry, method, prefixPath, path, summary, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+options) => {
+    let bodySchema = options.schemas?.body || undefined;
+    let paramsSchema = options.schemas?.params || undefined;
+    let querySchema = options.schemas?.query || undefined;
+    let headersSchema = options.schemas?.headers || undefined;
+    let responseSchemas = options.responses;
+    for (const middleware of options.middlewares || []) {
+        if (middleware.options.schemas?.body) {
+            bodySchema = bodySchema
+                ? bodySchema.merge(middleware.options.schemas.body)
+                : middleware.options.schemas.body;
+        }
+        if (middleware.options.schemas?.params) {
+            paramsSchema = paramsSchema
+                ? paramsSchema.merge(middleware.options.schemas.params)
+                : middleware.options.schemas.params;
+        }
+        if (middleware.options.schemas?.query) {
+            querySchema = querySchema
+                ? querySchema.merge(middleware.options.schemas.query)
+                : middleware.options.schemas.query;
+        }
+        if (middleware.options.schemas?.headers) {
+            headersSchema = headersSchema
+                ? headersSchema.merge(middleware.options.schemas.headers)
+                : middleware.options.schemas.headers;
+        }
+        if (middleware.options.responses) {
+            responseSchemas = responseSchemas.concat(middleware.options.responses);
+        }
+    }
+    const responseMap = buildResponseConfig(responseSchemas);
+    registry.registerPath({
+        method,
+        path: prefixPath + path,
+        summary,
+        // description: summary,
+        request: {
+            ...(bodySchema && {
+                body: {
+                    content: {
+                        'application/json': {
+                            schema: bodySchema,
+                        },
+                    },
+                },
+            }),
+            params: paramsSchema,
+            query: querySchema,
+            headers: headersSchema ? [headersSchema] : [],
+        },
+        // tags: ['meep'],
+        responses: responseMap,
+    });
+};
+exports.registerEndpoint = registerEndpoint;

package/dist/lib/api/index.d.ts

@@ -0,0 +1,6 @@
+export { extendZodWithOpenApi } from '@asteasolutions/zod-to-openapi';
+export * from './api';
+export * from './endpoint';
+export * from './middleware';
+export * from './response';
+export * from './send';

package/dist/lib/api/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendZodWithOpenApi = void 0;
+var zod_to_openapi_1 = require("@asteasolutions/zod-to-openapi");
+Object.defineProperty(exports, "extendZodWithOpenApi", { enumerable: true, get: function () { return zod_to_openapi_1.extendZodWithOpenApi; } });
+__exportStar(require("./api"), exports);
+__exportStar(require("./endpoint"), exports);
+__exportStar(require("./middleware"), exports);
+__exportStar(require("./response"), exports);
+__exportStar(require("./send"), exports);

package/dist/lib/api/middleware.d.ts

@@ -0,0 +1,2 @@
+import { Middleware, MiddlewareOptions, MiddlewareHandler, EndpointResponseSchema } from './types/middleware';
+export declare const createMiddleware: <TResponseSchemas extends readonly EndpointResponseSchema[], TRequestBody = undefined, TRequestParams = undefined, TRequestQuery = undefined, TRequestHeaders = undefined, TContext = undefined>(options: MiddlewareOptions<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TContext>, handler: MiddlewareHandler<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TContext>) => Middleware<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TContext>;

package/dist/lib/api/middleware.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMiddleware = void 0;
+const createMiddleware = (options, handler) => {
+    return {
+        options,
+        handler,
+    };
+};
+exports.createMiddleware = createMiddleware;

package/dist/lib/api/response.d.ts

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+declare const noContentSchema: z.ZodVoid;
+declare const badRequestErrorSchema: z.ZodObject<{
+    statusCode: z.ZodLiteral<400>;
+    error: z.ZodString;
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    error: string;
+    message: string;
+    statusCode: 400;
+}, {
+    error: string;
+    message: string;
+    statusCode: 400;
+}>;
+declare const unauthorizedErrorSchema: z.ZodObject<{
+    statusCode: z.ZodLiteral<401>;
+    error: z.ZodString;
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    error: string;
+    message: string;
+    statusCode: 401;
+}, {
+    error: string;
+    message: string;
+    statusCode: 401;
+}>;
+declare const forbiddenErrorSchema: z.ZodObject<{
+    statusCode: z.ZodLiteral<403>;
+    error: z.ZodString;
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    error: string;
+    message: string;
+    statusCode: 403;
+}, {
+    error: string;
+    message: string;
+    statusCode: 403;
+}>;
+declare const notFoundErrorSchema: z.ZodObject<{
+    statusCode: z.ZodLiteral<404>;
+    error: z.ZodString;
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    error: string;
+    message: string;
+    statusCode: 404;
+}, {
+    error: string;
+    message: string;
+    statusCode: 404;
+}>;
+export declare const okResponse: <T>(schema: z.ZodType<T, z.ZodTypeDef, T>) => {
+    status: 200;
+    description: string;
+    schema: z.ZodType<T, z.ZodTypeDef, T>;
+};
+export declare const noContentResponse: () => {
+    status: 204;
+    description: string;
+    schema: typeof noContentSchema;
+};
+export declare const badRequestResponse: () => {
+    status: 400;
+    description: string;
+    schema: typeof badRequestErrorSchema;
+};
+export declare const unauthorizedResponse: () => {
+    status: 401;
+    description: string;
+    schema: typeof unauthorizedErrorSchema;
+};
+export declare const forbiddenResponse: () => {
+    status: 403;
+    description: string;
+    schema: typeof forbiddenErrorSchema;
+};
+export declare const notFoundResponse: () => {
+    status: 404;
+    description: string;
+    schema: typeof notFoundErrorSchema;
+};
+export {};

package/dist/lib/api/response.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notFoundResponse = exports.forbiddenResponse = exports.unauthorizedResponse = exports.badRequestResponse = exports.noContentResponse = exports.okResponse = void 0;
+const zod_to_openapi_1 = require("@asteasolutions/zod-to-openapi");
+const zod_1 = require("zod");
+(0, zod_to_openapi_1.extendZodWithOpenApi)(zod_1.z);
+// response schemas
+const noContentSchema = zod_1.z.void();
+const badRequestErrorSchema = zod_1.z.object({
+    statusCode: zod_1.z.literal(400),
+    error: zod_1.z.string(),
+    message: zod_1.z.string(),
+});
+const unauthorizedErrorSchema = zod_1.z.object({
+    statusCode: zod_1.z.literal(401),
+    error: zod_1.z.string(),
+    message: zod_1.z.string(),
+});
+const forbiddenErrorSchema = zod_1.z.object({
+    statusCode: zod_1.z.literal(403),
+    error: zod_1.z.string(),
+    message: zod_1.z.string(),
+});
+const notFoundErrorSchema = zod_1.z.object({
+    statusCode: zod_1.z.literal(404),
+    error: zod_1.z.string(),
+    message: zod_1.z.string(),
+});
+// response functions
+const okResponse = (schema) => ({
+    status: 200,
+    description: 'OK',
+    schema,
+});
+exports.okResponse = okResponse;
+const noContentResponse = () => ({
+    status: 204,
+    description: 'No Content',
+    schema: noContentSchema,
+});
+exports.noContentResponse = noContentResponse;
+const badRequestResponse = () => ({
+    status: 400,
+    description: 'Bad Request',
+    schema: badRequestErrorSchema,
+});
+exports.badRequestResponse = badRequestResponse;
+const unauthorizedResponse = () => ({
+    status: 401,
+    description: 'Unauthorized',
+    schema: unauthorizedErrorSchema,
+});
+exports.unauthorizedResponse = unauthorizedResponse;
+const forbiddenResponse = () => ({
+    status: 403,
+    description: 'Forbidden',
+    schema: forbiddenErrorSchema,
+});
+exports.forbiddenResponse = forbiddenResponse;
+const notFoundResponse = () => ({
+    status: 404,
+    description: 'Not Found',
+    schema: notFoundErrorSchema,
+});
+exports.notFoundResponse = notFoundResponse;

package/dist/lib/api/send.d.ts

@@ -0,0 +1,40 @@
+export declare const ok: <T>(body: T) => {
+    status: 200;
+    body: T;
+};
+export declare const noContent: () => {
+    status: 204;
+    body: void;
+};
+export declare const badRequest: (message?: string) => {
+    status: 400;
+    body: {
+        statusCode: 400;
+        error: string;
+        message: string;
+    };
+};
+export declare const unauthorized: (message?: string) => {
+    status: 401;
+    body: {
+        statusCode: 401;
+        error: string;
+        message: string;
+    };
+};
+export declare const forbidden: (message?: string) => {
+    status: 403;
+    body: {
+        statusCode: 403;
+        error: string;
+        message: string;
+    };
+};
+export declare const notFound: (message?: string) => {
+    status: 404;
+    body: {
+        statusCode: 404;
+        error: string;
+        message: string;
+    };
+};

package/dist/lib/api/send.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notFound = exports.forbidden = exports.unauthorized = exports.badRequest = exports.noContent = exports.ok = void 0;
+const ok = (body) => ({
+    status: 200,
+    body,
+});
+exports.ok = ok;
+const noContent = () => ({
+    status: 204,
+    body: undefined,
+});
+exports.noContent = noContent;
+const badRequest = (message) => ({
+    status: 400,
+    body: {
+        statusCode: 400,
+        error: 'Bad request',
+        message: message || 'Bad request',
+    },
+});
+exports.badRequest = badRequest;
+const unauthorized = (message) => ({
+    status: 401,
+    body: {
+        statusCode: 401,
+        error: 'Unauthorized',
+        message: message || 'Unauthorized',
+    },
+});
+exports.unauthorized = unauthorized;
+const forbidden = (message) => ({
+    status: 403,
+    body: {
+        statusCode: 403,
+        error: 'Forbidden',
+        message: message || 'Forbidden',
+    },
+});
+exports.forbidden = forbidden;
+const notFound = (message) => ({
+    status: 404,
+    body: {
+        statusCode: 404,
+        error: 'Not found',
+        message: message || 'Not found',
+    },
+});
+exports.notFound = notFound;

package/dist/lib/api/types/endpoint.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { Middleware, EndpointResponseSchema } from './middleware';
+import { ArrayToUnion, ExtractZodOutput, ExtractZodOutputFromMiddleware, Always, Merge } from './utils';
+export type EndpointHandler<TResponse, TRequestBody = undefined, TRequestParams = undefined, TRequestQuery = undefined, TRequestHeaders = undefined, TMiddlewares = undefined> = (request: {
+    body: TRequestBody;
+    params: TRequestParams;
+    query: TRequestQuery;
+    headers: TRequestHeaders;
+}, context: Merge<Always<ExtractZodOutputFromMiddleware<ArrayToUnion<TMiddlewares>>>>, send: (response: ExtractZodOutput<ArrayToUnion<TResponse>>) => void) => Promise<void>;
+export type EndpointOptions<TResponseSchemas extends ReadonlyArray<EndpointResponseSchema>, TRequestBody = undefined, TRequestParams = undefined, TRequestQuery = undefined, TRequestHeaders = undefined, TMiddlewares extends ReadonlyArray<Middleware<any, any, any, any, any, any>> | undefined = undefined> = {
+    schemas?: {
+        body?: z.ZodObject<z.ZodRawShape, 'strip', z.ZodTypeAny, TRequestBody>;
+        params?: z.ZodObject<z.ZodRawShape, 'strip', z.ZodTypeAny, TRequestParams>;
+        query?: z.ZodObject<z.ZodRawShape, 'strip', z.ZodTypeAny, TRequestQuery>;
+        headers?: z.ZodObject<z.ZodRawShape, 'strip', z.ZodTypeAny, TRequestHeaders>;
+    };
+    middlewares?: TMiddlewares;
+    responses: TResponseSchemas;
+};

package/dist/lib/api/types/endpoint.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/api/types/middleware.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { ArrayToUnion, ExtractZodOutput } from './utils';
+export type EndpointResponseSchema = {
+    status: number;
+    description: string;
+    schema: z.ZodSchema<any> | z.ZodVoid;
+};
+export type MiddlewareHandler<TResponseSchema, TRequestBody = undefined, TRequestParams = undefined, TRequestQuery = undefined, TRequestHeaders = undefined, TContext = undefined> = (request: {
+    body: TRequestBody;
+    params: TRequestParams;
+    query: TRequestQuery;
+    headers: TRequestHeaders;
+}, send: (response: ExtractZodOutput<ArrayToUnion<TResponseSchema>>) => void, next: (context: TContext) => void) => Promise<void>;
+export type MiddlewareOptions<TResponseSchemas extends ReadonlyArray<EndpointResponseSchema>, TRequestBody = undefined, TRequestParams = undefined, TRequestQuery = undefined, TRequestHeaders = undefined, TContext = undefined> = {
+    schemas?: {
+        body?: z.ZodSchema<TRequestBody>;
+        params?: z.ZodObject<z.ZodRawShape, 'strip', z.ZodTypeAny, TRequestParams>;
+        query?: z.ZodObject<z.ZodRawShape, 'strip', z.ZodTypeAny, TRequestQuery>;
+        headers?: z.ZodObject<z.ZodRawShape, 'strip', z.ZodTypeAny, TRequestHeaders>;
+        context?: z.ZodSchema<TContext>;
+    };
+    responses: TResponseSchemas;
+};
+export type Middleware<TResponseSchemas extends ReadonlyArray<EndpointResponseSchema>, TRequestBody = undefined, TRequestParams = undefined, TRequestQuery = undefined, TRequestHeaders = undefined, TContext = undefined> = {
+    options: MiddlewareOptions<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TContext>;
+    handler: MiddlewareHandler<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TContext>;
+};

package/dist/lib/api/types/middleware.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/api/types/utils.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export type ArrayToUnion<T> = T[keyof T];
+export type ExtractZodOutput<T> = T extends {
+    status: infer Z;
+    schema: z.ZodSchema<infer V>;
+} ? {
+    status: Z;
+    body: V;
+} : never;
+export type ExtractZodOutputFromMiddleware<T> = T extends {
+    options: {
+        schemas?: {
+            context?: z.ZodSchema<infer V>;
+        };
+    };
+} ? V : undefined;
+export type Always<T> = T extends object ? T : {};
+type AllKeys<T> = T extends any ? keyof T : never;
+type PickType<T, K extends AllKeys<T>> = T extends {
+    [k in K]: any;
+} ? T[K] : never;
+export type Merge<T extends object> = {
+    [k in AllKeys<T>]: PickType<T, k>;
+};
+export {};

package/dist/lib/api/types/utils.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/kafka/events/location.d.ts

@@ -1,6 +1,6 @@
 type Location = {
     uuid: string;
-    groupId: string;
+    groupId?: string;
     createdAt: Date;
     updatedAt: Date;
 };

package/dist/lib/kafka/index.d.ts

@@ -1,3 +1,3 @@
 export { KafkaClient } from './kafkaClient';
 export { KafkaTopic } from './events';
-export type { KafkaEvent, EventPayloadHandler, KafkaConfiguration } from './types';
+export type { KafkaEvent, EventPayloadHandler, KafkaConfiguration, } from './types';

package/dist/lib/kafka/types.d.ts

@@ -17,4 +17,4 @@ type KafkaConfiguration = {
 type EventPayloadHandler<T extends KafkaTopic> = (message: Omit<KafkaMessage, 'value'> & {
     value: KafkaEvent<T>;
 }) => Promise<void>;
-export type { KafkaEvent, KafkaConfiguration, EventPayloadHandler, };
+export type { KafkaEvent, KafkaConfiguration, EventPayloadHandler };

package/dist/lib/wsEvent/index.js

@@ -7,7 +7,9 @@ const generateSubscriptionId = () => {
     return (0, crypto_1.randomBytes)(32).toString('base64');
 };
 exports.generateSubscriptionId = generateSubscriptionId;
-const emitWebsocketEvent = async (kafkaClient, subId, type, data) => {
+const emitWebsocketEvent = async (kafkaClient, subId, type, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+data) => {
     const issuer = kafkaClient.serviceIdentity.identityName;
     // using WS_EVENT_backend since all WS_EVENTs use same schema
     const topic = `wsevent_${issuer}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucaapp/service-utils",
-  "version": "1.22.0",
+  "version": "1.23.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -26,20 +26,28 @@
     "@typescript-eslint/parser": "^5.30.6",
     "conventional-changelog-conventionalcommits": "^5.0.0",
     "eslint": "^8.19.0",
+    "eslint-plugin-prettier": "4.2.1",
     "improved-yarn-audit": "^3.0.0",
     "jest": "^28.1.2",
     "jest-junit": "^14.0.0",
+    "prettier": "2.7.1",
     "semantic-release": "^19.0.3",
     "semantic-release-monorepo": "^7.0.5",
+    "supertest": "^6.3.3",
     "ts-jest": "^28.0.5",
     "typescript": "^4.7.4"
   },
   "dependencies": {
+    "@asteasolutions/zod-to-openapi": "4.1.0",
     "@hapi/boom": "^10.0.0",
     "@types/express": "4.17.13",
     "@types/response-time": "^2.3.5",
+    "@types/supertest": "^2.0.12",
+    "@types/swagger-ui-express": "4.1.3",
     "axios": "^0.27.2",
     "cls-rtracer": "^2.6.2",
+    "express": "4.18.1",
+    "express-async-errors": "3.1.1",
     "jose": "4.9.2",
     "kafkajs": "2.1.0",
     "lodash": "^4.17.21",
@@ -47,7 +55,9 @@
     "pino-http": "8.2.1",
     "prom-client": "14.1.0",
     "response-time": "^2.3.2",
+    "swagger-ui-express": "4.5.0",
     "url-value-parser": "^2.2.0",
-    "uuid": "^9.0.0"
+    "uuid": "^9.0.0",
+    "zod": "3.11.6"
   }
 }