jh-be-tools 1.0.90 → 1.0.91

package/dist/api-request/apiRequest.d.ts

@@ -0,0 +1,27 @@
+import { AxiosRequestConfig, AxiosResponse, AxiosHeaders } from 'axios';
+import { RouteDef } from '../route-handler/routeCreation.js';
+export interface QueryData {
+    params?: Record<string, string>;
+    query?: AxiosRequestConfig['params'];
+    headers?: Record<string, string> | AxiosHeaders;
+    body?: unknown;
+}
+export interface Request {
+    baseUrl: string;
+    definition: RouteDef;
+    serviceName: string;
+    queryData?: QueryData;
+}
+export interface ProcessingMethods {
+    pre?: (request: QueryData) => Promise<QueryData>;
+    post?: (response: AxiosResponse | InternalError) => Promise<AxiosResponse | InternalError>;
+    logger?: (value: string) => void;
+    debug?: boolean;
+}
+export interface InternalError {
+    serviceName: string;
+    status: number;
+}
+export declare const isInternalError: <T>(res: AxiosResponse<T> | InternalError) => res is InternalError;
+export declare const isValidResponse: <T>(res: AxiosResponse<T> | InternalError) => res is AxiosResponse<T>;
+export declare const request: <Response>(req: Request, processing?: ProcessingMethods) => Promise<Response>;

package/dist/api-request/apiRequest.js

@@ -0,0 +1,110 @@
+import axios, { AxiosError } from 'axios';
+import { getCorrelationId } from '../correlation-id/correlationContext.js';
+export const isInternalError = (res) => {
+    return res.status >= 400;
+};
+export const isValidResponse = (res) => {
+    return res.status < 400;
+};
+export const request = async (req, processing) => {
+    const { baseUrl, definition, serviceName } = req;
+    let { queryData } = req;
+    let path = `${baseUrl}${definition.path}`;
+    let func;
+    if (processing?.pre) {
+        if (!queryData) {
+            queryData = {};
+        }
+        queryData = await processing.pre(queryData);
+    }
+    switch (definition.method) {
+        case 'get':
+            if (queryData?.body) {
+                throw Error('Get requests with body are not supported.');
+            }
+            func = axios.get;
+            break;
+        case 'post':
+            func = axios.post;
+            if (queryData && !queryData?.body) {
+                queryData.body = {};
+            }
+            break;
+        case 'put':
+            func = axios.put;
+            if (queryData && !queryData?.body) {
+                queryData.body = {};
+            }
+            break;
+        case 'delete':
+            if (queryData?.body) {
+                throw Error('Delete requests with body are not supported.');
+            }
+            func = axios.delete;
+            break;
+    }
+    if (queryData?.params) {
+        path = replaceUrlParams(path, queryData.params);
+    }
+    let response;
+    try {
+        response = await baseQuery(func, path, queryData);
+    }
+    catch (error) {
+        response = errorHandler(error, { serviceName, path, queryData, debug: processing?.debug, logger: processing?.logger });
+    }
+    if (processing?.post) {
+        response = await processing.post(response);
+    }
+    if (isInternalError(response)) {
+        throw response;
+    }
+    return response.data;
+};
+const baseQuery = async (func, path, req) => {
+    const correlationId = getCorrelationId();
+    const options = {
+        headers: {
+            'content-type': 'application/json',
+            'x-correlation-id': correlationId,
+            ...req?.headers,
+        },
+        params: req?.query,
+    };
+    if (req?.body) {
+        return await func(path, req.body, options);
+    }
+    else {
+        return await func(path, options);
+    }
+};
+const errorHandler = (error, { serviceName, path, queryData, debug, logger }) => {
+    if (!(error instanceof AxiosError))
+        throw error;
+    const data = {
+        serviceName: serviceName,
+        status: error.status ?? 500,
+        request: {
+            path,
+            query: queryData?.query,
+            body: debug ? queryData?.body : undefined,
+        },
+        response: error.response ? {
+            status: error.response.status,
+            data: error.response.data,
+            headers: error.response.headers,
+        } : undefined,
+    };
+    if (logger) {
+        logger(JSON.stringify(data));
+    }
+    else {
+        console.error(JSON.stringify(data));
+    }
+    return data;
+};
+const replaceUrlParams = (url, params) => {
+    return url.replace(/:([a-zA-Z0-9_]+)/g, (match, key) => {
+        return params[key] || match;
+    });
+};

package/dist/config/eslint.config.d.mts

@@ -0,0 +1,3 @@
+export default config;
+/** @type {import('@eslint/js').FlatConfig[]} */
+declare const config: import("@eslint/js").FlatConfig[];

package/dist/config/eslint.config.mjs

@@ -0,0 +1,74 @@
+import path from 'path';
+import eslint from '@eslint/js';
+import tsEslint from 'typescript-eslint';
+import importPlugin from 'eslint-plugin-import';
+import prettierConfig from 'eslint-config-prettier';
+import eslintPluginPrettier from 'eslint-plugin-prettier';
+import unusedImports from 'eslint-plugin-unused-imports';
+const tsconfigPath = path.join(process.cwd(), 'tsconfig.json');
+/** @type {import('@eslint/js').FlatConfig[]} */
+const config = [
+    eslint.configs.recommended,
+    ...tsEslint.configs.recommendedTypeChecked,
+    importPlugin.flatConfigs.recommended,
+    importPlugin.flatConfigs.typescript,
+    prettierConfig,
+    {
+        settings: {
+            'import/parsers': {
+                '@typescript-eslint/parser': ['.ts', '.tsx'],
+            },
+            'import/resolver': {
+                typescript: {
+                    project: tsconfigPath,
+                },
+                node: {
+                    extensions: ['.js', '.jsx', '.ts', '.tsx'],
+                },
+            },
+        },
+        plugins: {
+            'unused-imports': unusedImports,
+            prettier: eslintPluginPrettier,
+        },
+        languageOptions: {
+            parser: tsEslint.parser,
+            ecmaVersion: 6,
+            sourceType: 'module',
+            parserOptions: {
+                project: [tsconfigPath],
+                sourceType: 'module',
+                ecmaFeatures: {
+                    modules: true,
+                },
+            },
+        },
+        rules: {
+            '@typescript-eslint/explicit-member-accessibility': 0,
+            '@typescript-eslint/explicit-function-return-type': 0,
+            '@typescript-eslint/consistent-type-definitions': ['error', 'type'],
+            '@typescript-eslint/no-unused-vars': [
+                'error',
+                { vars: 'all', varsIgnorePattern: '^_', args: 'after-used', argsIgnorePattern: '^_', ignoreRestSiblings: true },
+            ],
+            '@typescript-eslint/no-floating-promises': ['error', { ignoreIIFE: true, ignoreVoid: false }],
+            'no-return-await': 'off',
+            '@typescript-eslint/return-await': ['error', 'always'],
+            'require-await': 'off',
+            '@typescript-eslint/require-await': 'error',
+            'prettier/prettier': ['error', { singleQuote: true }],
+            'import/order': ['error', { 'newlines-between': 'always', alphabetize: { order: 'asc' } }],
+            'import/order:/no-named-as-default-member': 0,
+            'unused-imports/no-unused-imports': 'error',
+            '@typescript-eslint/no-non-null-assertion': 'error',
+            eqeqeq: 2,
+            'no-console': 2,
+            'no-unused-expressions': 2,
+            curly: 'error',
+        },
+    },
+    {
+        ignores: ['node_modules', '**/build', '**/coverage', '**/dist/**', 'eslint.config.mjs'],
+    },
+];
+export default config;

package/dist/config/tsconfig.base.json

@@ -0,0 +1,18 @@
+{
+    "compilerOptions": {
+        "incremental": true,
+        "target": "es2023",
+        "module": "NodeNext",
+        "moduleResolution": "NodeNext",
+        "declaration": true,
+        "outDir": "./dist",
+        "esModuleInterop": true,
+        "forceConsistentCasingInFileNames": true,
+        "strict": true,
+        "skipLibCheck": true,
+        "resolveJsonModule": true,
+        "types": ["node"]
+    },
+    "exclude": ["**/*.spec.ts", "**/gen.ts"],
+    "include": ["src/**/*.ts"]
+}

package/dist/correlation-id/correlationContext.d.ts

@@ -0,0 +1,5 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+export declare const als: AsyncLocalStorage<{
+    correlationId: string;
+}>;
+export declare const getCorrelationId: () => string;

package/dist/correlation-id/correlationContext.js

@@ -0,0 +1,4 @@
+// context.js
+import { AsyncLocalStorage } from 'node:async_hooks';
+export const als = new AsyncLocalStorage();
+export const getCorrelationId = () => als.getStore()?.correlationId ?? '-';

package/dist/correlation-id/correlationMiddleware.d.ts

@@ -0,0 +1,2 @@
+import { NextFunction, Request, Response } from 'express';
+export declare function correlationMiddleware(req: Request, res: Response, next: NextFunction): void;

package/dist/correlation-id/correlationMiddleware.js

@@ -0,0 +1,11 @@
+// correlationMiddleware.js
+import { randomUUID } from 'node:crypto';
+import { als } from './correlationContext.js';
+export function correlationMiddleware(req, res, next) {
+    const incoming = req.header('x-correlation-id');
+    // Regenerate if it looks suspicious — don't trust arbitrary client input verbatim
+    const correlationId = isValidId(incoming) ? incoming : randomUUID();
+    res.setHeader('x-correlation-id', correlationId ?? randomUUID());
+    als.run({ correlationId }, () => next());
+}
+const isValidId = (id) => typeof id === 'string' && /^[a-zA-Z0-9._-]{1,128}$/.test(id);

package/dist/cursor/cursor.d.ts

@@ -0,0 +1,7 @@
+export type Cursor = {
+    id: string;
+    sortKey: string;
+    sortValue: string;
+};
+export declare function decodeCursor(cursorStr: string): Cursor;
+export declare function encodeCursor(cursor: Cursor): string;

package/dist/cursor/cursor.js

@@ -0,0 +1,6 @@
+export function decodeCursor(cursorStr) {
+    return JSON.parse(Buffer.from(cursorStr, 'base64').toString());
+}
+export function encodeCursor(cursor) {
+    return Buffer.from(JSON.stringify(cursor)).toString('base64');
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './route-handler/routeHandler.js';
+export * from './route-handler/routeCreation.js';
+export * from './api-request/apiRequest.js';
+export * from './cursor/cursor.js';
+export * from './correlation-id/correlationMiddleware.js';
+export * from './logger.js';

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from './route-handler/routeHandler.js';
+export * from './route-handler/routeCreation.js';
+export * from './api-request/apiRequest.js';
+export * from './cursor/cursor.js';
+export * from './correlation-id/correlationMiddleware.js';
+export * from './logger.js';

package/dist/logger.d.ts

@@ -0,0 +1,2 @@
+import pino from 'pino';
+export declare const logger: pino.Logger<never, boolean>;

package/dist/logger.js

@@ -0,0 +1,8 @@
+// logger.js
+import pino from 'pino';
+import { getCorrelationId } from './correlation-id/correlationContext.js';
+export const logger = pino({
+    mixin() {
+        return { correlationId: getCorrelationId() };
+    },
+});

package/dist/route-handler/routeCreation.d.ts

@@ -0,0 +1,14 @@
+import { Router, Request, Response } from 'express';
+import { RouteSchema } from './routeHandler.js';
+type Next = (err?: unknown) => void;
+export type Middleware = (req: Request, res: Response, next: Next) => void | Promise<void>;
+export type RouteMethods = 'get' | 'post' | 'put' | 'delete';
+export type RouteDef = {
+    method: RouteMethods;
+    path: string;
+    routeSchema: RouteSchema;
+    middleware?: Middleware[];
+};
+export type RouteData = [RouteDef, (req?: any) => any];
+export declare const createRoutes: (routeData: RouteData[], router: Router) => void;
+export {};

package/dist/route-handler/routeCreation.js

@@ -0,0 +1,12 @@
+import { routeHandler } from './routeHandler.js';
+const createRoute = (meta, route) => {
+    return (app) => {
+        const middlewares = meta.middleware ?? [];
+        app[meta.method](meta.path, ...middlewares, async (req, res) => {
+            await routeHandler(req, res, route, meta.routeSchema);
+        });
+    };
+};
+export const createRoutes = (routeData, router) => {
+    routeData.forEach((data) => createRoute(...data)(router));
+};

package/dist/route-handler/routeHandler.d.ts

@@ -0,0 +1,22 @@
+import { Request, Response } from 'express';
+import { z } from "zod";
+export type RouteSchema<ReqBody extends z.ZodTypeAny = z.ZodTypeAny, ResBody extends z.ZodTypeAny = z.ZodTypeAny> = {
+    request?: z.ZodObject<{
+        body?: z.ZodObject<{
+            data: ReqBody;
+        }> | undefined;
+        params?: z.ZodTypeAny;
+        query?: z.ZodTypeAny;
+        headers?: z.ZodTypeAny;
+    }>;
+    response?: z.ZodObject<{
+        data?: ResBody | undefined;
+        meta?: z.ZodTypeAny;
+    }>;
+};
+interface ReturnValue<T> {
+    data: T;
+    status?: number;
+}
+export declare const routeHandler: (req: Request, res: Response, fun: (req?: any) => Promise<ReturnValue<unknown> | void>, schema: RouteSchema) => Promise<Response<any, Record<string, any>> | undefined>;
+export {};

package/dist/route-handler/routeHandler.js

@@ -0,0 +1,58 @@
+export const routeHandler = async (req, res, fun, schema) => {
+    if (!(await parseRequest(schema, req, res)))
+        return;
+    let data;
+    let status;
+    try {
+        const result = await fun(req);
+        data = result;
+        const defaultStatus = result?.data ? 200 : 204;
+        status = result?.status ?? defaultStatus;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            return res.status(500).json(error.message);
+        }
+        return res.status(500).json(error);
+    }
+    if (!(await parseResponse(schema, res, data)))
+        return;
+    res.status(status).json(data);
+};
+const parseRequest = async (schema, req, res) => {
+    if (schema.request) {
+        try {
+            const parsed = await schema.request.parseAsync({
+                body: req.body,
+                query: req.query,
+                params: req.params,
+                headers: req.headers,
+            });
+            if (parsed.body !== undefined)
+                req.body = parsed.body;
+            if (parsed.query !== undefined)
+                Object.assign(req.query, parsed.query);
+            if (parsed.params !== undefined)
+                Object.assign(req.params, parsed.params);
+        }
+        catch (error) {
+            console.log(JSON.stringify(error));
+            res.status(400).json(error);
+            return false;
+        }
+    }
+    return true;
+};
+const parseResponse = async (schema, res, data) => {
+    if (schema.response) {
+        try {
+            await schema.response.parseAsync(data);
+        }
+        catch (error) {
+            console.log(JSON.stringify(error));
+            res.status(500).json(error);
+            return false;
+        }
+    }
+    return true;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "jh-be-tools",
-	"version": "1.0.90",
+	"version": "1.0.91",
 	"description": "",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",