create-jwn-js 1.0.30 → 1.0.32

package/index.js

@@ -5,6 +5,7 @@ const path = require('path')
 const margv = require('margv')
 const argv = margv();
 const prompts = require('prompts');
+const json5 = require('json5');
 
 const {
     yellow,
@@ -40,7 +41,12 @@ const FRAMEWORKS = [
         color: yellow,
         variants: [
             {
-                name: 'lambda-api-ts',
+                name: 'lambda-rest-api-ts',
+                display: 'TypeScript',
+                color: blue
+            },
+            {
+                name: 'lambda-http-api-ts',
                 display: 'TypeScript',
                 color: blue
             }
@@ -186,8 +192,8 @@ async function init() {
 
     // connect.json5
     if(fs.existsSync(path.join(templateDir, `connect-template.json5`))) {
-        const connect = require(path.join(templateDir, `connect-template.json5`));
-        write('connect.json5', JSON.stringify(connect, null, 2));
+        const connect = json5.parse(fs.readFileSync(path.join(templateDir, `connect-template.json5`)).toString());
+        write('connect.json5', json5.stringify(connect, null, 2));
     }
 
     // package.json

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-jwn-js",
-  "version": "1.0.30",
+  "version": "1.0.32",
   "license": "PRIVATE",
   "author": "Webigorkiev",
   "bin": {
@@ -18,6 +18,7 @@
   },
   "homepage": "https://github.com/webigorkiev",
   "dependencies": {
+    "json5": "^2.2.3",
     "kolorist": "^1.5.0",
     "margv": "^1.1.2",
     "prompts": "^2.4.2"
@@ -33,7 +34,7 @@
     "jsdom": "^24.0.0",
     "memjs": "^1.3.2",
     "typescript": "^5.3.3",
-    "vite": "4",
+    "vite": "5",
     "vitepress": "0.22.4",
     "vitest": "^1.2.2"
   }

package/{template-lambda-api-ts → template-lambda-http-api-ts}/package.json

@@ -10,10 +10,12 @@
     "serve": "vite",
     "build": "vite build && cd ./dist && yarn",
     "test": "vitest run",
-    "test:production": "vitest run -c vitest.config.production.mts"
+    "test:production": "vitest run -c vitest.config.production.mts",
+    "deploy": "yarn build && cd dist && zip -r ../dist.zip ."
   },
   "devDependencies": {
     "@types/aws-lambda": "8",
+    "@types/fs-extra": "^11.0.4",
     "@types/node": "20",
     "chalk": "^5.3.0",
     "fs-extra": "^11.2.0",

package/template-lambda-http-api-ts/src/backend/index.mts

@@ -0,0 +1,8 @@
+import type { APIGatewayProxyEventV2, APIGatewayProxyResultV2 } from "aws-lambda";
+
+export const handler = async (event: APIGatewayProxyEventV2): Promise<APIGatewayProxyResultV2> => {
+    return {
+        statusCode: 200,
+        body: JSON.stringify(event),
+    };
+};

package/{template-lambda-api-ts → template-lambda-http-api-ts}/src/scripts/test.setup.mts

@@ -16,6 +16,6 @@ const defaultHeaders = {
 const fetchWrapper = async(
     input: RequestInfo,
     init: RequestInit = {}
-) => crossFetch(input, Object.assign({}, defaultHeaders, init));
+) => fetch(input, Object.assign({}, defaultHeaders, init));
 
 export {fetchWrapper as fetch, testConfig};

package/{template-lambda-api-ts → template-lambda-http-api-ts}/src/scripts/vitest.global.setup.mts

@@ -1,5 +1,5 @@
 import {createServer, ViteDevServer} from "vite";
-import {testConfig} from "./test.setup";
+import {testConfig} from "./test.setup.mts";
 
 declare global {
     var server: ViteDevServer;

package/{template-lambda-api-ts → template-lambda-http-api-ts}/tsconfig.json

@@ -17,6 +17,7 @@
     "strictPropertyInitialization": false,
     "experimentalDecorators": true,
     "emitDecoratorMetadata": true,
+    "allowImportingTsExtensions": true,
     "lib": [
       "esnext",
       "dom"

package/{template-lambda-api-ts → template-lambda-http-api-ts}/vite.config.mts

@@ -1,11 +1,10 @@
-import type { APIGatewayProxyEvent, APIGatewayProxyResult } from "aws-lambda";
+import type { APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2 } from "aws-lambda";
 import * as path from "node:path";
 import {performance} from "node:perf_hooks";
 import chalk from "chalk";
 import {build, defineConfig, mergeConfig, Plugin, ResolvedConfig} from "vite";
 import fs from "fs-extra";
-import type {IncomingMessage} from "vite";
-import querystring from "node:querystring";
+import type {Connect} from "vite";
 
 interface Options {
     entry: string
@@ -16,15 +15,11 @@ const cnf = {
   host: "localhost",
   port: 3000,
 };
-const defaultHedares = {
-    "content-type": "application/json"
-}
-
-const readBody = (req: IncomingMessage) => {
+const readBody = (req: Connect.IncomingMessage): Promise<string> => {
     return new Promise(resolve => {
-        const body = [];
+        const body: Buffer[] = [];
         req
-            .on('data', chunk => {
+            .on('data', (chunk: Buffer) => {
                 body.push(chunk);
             })
             .on('end', () => {
@@ -34,42 +29,42 @@ const readBody = (req: IncomingMessage) => {
 };
 
 // Адаптер для согласованности с AWS Lambda
-const incomingMessageAdapter = async(req: IncomingMessage): Promise<APIGatewayProxyEvent> => {
-        const urlPath = req.originalUrl.split("#")[0];
+const incomingMessageAdapter = async(req: Connect.IncomingMessage): Promise<APIGatewayProxyEventV2> => {
+        const urlPath = (req.originalUrl || "").split("#")[0];
         const path = urlPath.split('?')[0];
-        const multiValueQueryStringParameters = querystring.parse(urlPath.split('?')[1]);
-        const queryStringParameters = Object.keys(multiValueQueryStringParameters).reduce((ac, key) => {
-            ac[key] = ac[key] || multiValueQueryStringParameters[key];
-            if(Array.isArray(ac[key])) {
-                ac[key] = ac[key][ac[key].length - 1];
-            }
-            return ac;
-        }, {})
+        const rawQueryString = urlPath.split('?')[1];
         const headers = (req.rawHeaders || []).reduce((ac, v, index, all) => {
-            index % 2 === 0 ? (ac[v] = ac[v] || "") : (ac[all[index - 1]] = v);
+            index % 2 === 0 ? (ac[v] = (ac[v] || "").toLowerCase()) : (ac[all[index - 1]] = v);
             return ac;
-        }, {});
-        const multiValueHeaders = (req.rawHeaders || []).reduce((ac, v, index, all) => {
-            index % 2 === 0 ? (ac[v] = ac[v] || []) : (ac[all[index - 1]].push(v));
-            return ac;
-        }, {});
+        }, {} as Record<string, string>);
+        const method = (req.method || "").toUpperCase();
+        const resourcePath = path.split("/").slice(1).join("/");
         return {
-            body: await readBody(req),
-            headers: headers,
-            multiValueHeaders,
-            httpMethod: req.method.toUpperCase(),
-            isBase64Encoded: false,
-            // @ts-ignore
-            path,
-            pathParameters: null,
-            queryStringParameters,
-            multiValueQueryStringParameters,
-            stageVariables: null,
+            version: "2.0",
+            routeKey: `${method} ${resourcePath}`,
+            rawPath: path,
+            rawQueryString,
+            headers,
             requestContext: {
-                resourcePath: path,
-                httpMethod: req.method.toUpperCase(),
-            }, // Only for production
-            resource: path,
+                accountId: "",
+                apiId: "",
+                domainName: "",
+                domainPrefix: "",
+                http: {
+                    method,
+                    path,
+                    protocol: "HTTP/1.1",
+                    sourceIp: headers["x-forwarded-for"],
+                    userAgent: headers["user-agent"],
+                },
+                requestId: "",
+                routeKey: `${method} ${resourcePath}`,
+                stage: "",
+                time: "",
+                timeEpoch: Math.round(new Date().getTime()/1000)
+            },
+            body: await readBody(req),
+            isBase64Encoded: false
         }
 }
 const node = (opt: Options): Plugin => {
@@ -80,9 +75,10 @@ const node = (opt: Options): Plugin => {
                 async (req, res, next) => {
                     const ssrModule = await server.ssrLoadModule(path.join(server.config.root, opt.entry));
                     const render = ssrModule.handler || ssrModule.default || ssrModule;
-                    const {statusCode, body, headers, multiValueHeaders} = await render(await incomingMessageAdapter(req), {}) as APIGatewayProxyResult;
-                    const allHeaders = Object.assign({}, defaultHedares, headers || {}, multiValueHeaders || {});
-                    Object.entries(allHeaders).map(([key, value]) => res.setHeader(key, value));
+                    const {headers, statusCode, body, cookies} = (await render(await incomingMessageAdapter(req), {})) as APIGatewayProxyStructuredResultV2;
+                    const allHeaders = Object.assign({}, headers || {}) as Record<string, string|string[]>;
+                    Object.entries(allHeaders).map(([key, value] : [string, string]) => res.setHeader(key, value));
+                    (cookies || []).forEach((cookie) => res.setHeader("Set-Cookie", cookie));
                     res.statusCode = statusCode || 200;
                     res.end(body);
                 });

package/{template-lambda-api-ts → template-lambda-http-api-ts}/yarn.lock

@@ -1329,6 +1329,28 @@
   resolved "https://registry.yarnpkg.com/@types/estree/-/estree-1.0.5.tgz#a6ce3e556e00fd9895dd872dd172ad0d4bd687f4"
   integrity sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw==
 
+"@types/fs-extra@^11.0.4":
+  version "11.0.4"
+  resolved "https://registry.yarnpkg.com/@types/fs-extra/-/fs-extra-11.0.4.tgz#e16a863bb8843fba8c5004362b5a73e17becca45"
+  integrity sha512-yTbItCNreRooED33qjunPthRcSjERP1r4MqCZc7wv0u2sUkzTFp45tgUfS5+r7FrZPdmCCNflLhVSP/o+SemsQ==
+  dependencies:
+    "@types/jsonfile" "*"
+    "@types/node" "*"
+
+"@types/jsonfile@*":
+  version "6.1.4"
+  resolved "https://registry.yarnpkg.com/@types/jsonfile/-/jsonfile-6.1.4.tgz#614afec1a1164e7d670b4a7ad64df3e7beb7b702"
+  integrity sha512-D5qGUYwjvnNNextdU59/+fI+spnwtTFmyQP0h+PfIOSkNfpU6AOICUOkm4i0OnSk+NyjdPJrxCDro0sJsWlRpQ==
+  dependencies:
+    "@types/node" "*"
+
+"@types/node@*":
+  version "22.7.4"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-22.7.4.tgz#e35d6f48dca3255ce44256ddc05dee1c23353fcc"
+  integrity sha512-y+NPi1rFzDs1NdQHHToqeiX2TIS79SWEAw9GYhkkx8bD0ChpfqC+n2j5OXOCpzfojBEBt6DnEnnG9MY0zk1XLg==
+  dependencies:
+    undici-types "~6.19.2"
+
 "@types/node@20":
   version "20.14.12"
   resolved "https://registry.yarnpkg.com/@types/node/-/node-20.14.12.tgz#129d7c3a822cb49fc7ff661235f19cfefd422b49"
@@ -1952,6 +1974,11 @@ undici-types@~5.26.4:
   resolved "https://registry.yarnpkg.com/undici-types/-/undici-types-5.26.5.tgz#bcd539893d00b56e964fd2657a4866b221a65617"
   integrity sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==
 
+undici-types@~6.19.2:
+  version "6.19.8"
+  resolved "https://registry.yarnpkg.com/undici-types/-/undici-types-6.19.8.tgz#35111c9d1437ab83a7cdc0abae2f26d88eda0a02"
+  integrity sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==
+
 universalify@^0.2.0:
   version "0.2.0"
   resolved "https://registry.yarnpkg.com/universalify/-/universalify-0.2.0.tgz#6451760566fa857534745ab1dde952d1b1761be0"

package/template-lambda-rest-api-ts/.gitignore

@@ -0,0 +1,5 @@
+node_modules
+.DS_Store
+*.local
+.idea
+dist

package/template-lambda-rest-api-ts/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "template-lambda-api",
+  "private": true,
+  "author": "webigorkiev",
+  "license": "PRIVATE",
+  "version": "1.0.1",
+  "main": "./index.mts",
+  "scripts": {
+    "dev": "vite",
+    "serve": "vite",
+    "build": "vite build && cd ./dist && yarn",
+    "test": "vitest run",
+    "test:production": "vitest run -c vitest.config.production.mts",
+    "deploy": "yarn build && cd dist && zip -r ../dist.zip ."
+  },
+  "devDependencies": {
+    "@types/aws-lambda": "8",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "20",
+    "chalk": "^5.3.0",
+    "fs-extra": "^11.2.0",
+    "jsdom": "^24.1.1",
+    "typescript": "5",
+    "vite": "5",
+    "vitest": "^2.0.4"
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "3"
+  }
+}

package/template-lambda-rest-api-ts/src/backend/__its__/handler.spec.mts

@@ -0,0 +1,9 @@
+import {fetch, testConfig} from "../../scripts/test.setup";
+
+describe("/", () => {
+    const url = new URL(testConfig.apiUrl + "/test-hello-world");
+    test(`request GET ${testConfig.apiUrl}/test-hello-world`, async() => {
+        const response = await fetch(url.toString());
+        expect(response.ok).toEqual(true);
+    })
+});

package/template-lambda-rest-api-ts/src/scripts/test.setup.mts

@@ -0,0 +1,21 @@
+const env = process.env.TEST_MODE_APP as "test";
+const entryDevelopment = "http://localhost:3000";
+const entryProduction = "https://dpjhcqy0yj.execute-api.eu-central-1.amazonaws.com/default";
+const apiUrl = env === "test" ? entryDevelopment : entryProduction;
+const testConfig = {
+    apiUrl,
+    apiKey: "vOAwIEMvw01UHaJsVuYrD4Kjg6WzXyc6364dMBcX"
+}
+const defaultHeaders = {
+    headers: {
+        "user-agent": "fetch-tests",
+        "content-type": "application/json",
+        "x-api-key": testConfig.apiKey,
+    }
+}
+const fetchWrapper = async(
+    input: RequestInfo,
+    init: RequestInit = {}
+) => fetch(input, Object.assign({}, defaultHeaders, init));
+
+export {fetchWrapper as fetch, testConfig};

package/template-lambda-rest-api-ts/src/scripts/vitest.global.setup.mts

@@ -0,0 +1,26 @@
+import {createServer, ViteDevServer} from "vite";
+import {testConfig} from "./test.setup.mts";
+
+declare global {
+    var server: ViteDevServer;
+}
+
+const start = async(resolve: CallableFunction) => {
+    try {
+        await fetch(`${testConfig.apiUrl}/dev-start'`);
+        resolve();
+    } catch(e: any) {
+        await new Promise(resolve => setTimeout(resolve, 100));
+        await start(resolve);
+    }
+};
+
+export async function setup() {
+    global.server = await createServer();
+    await global.server.listen();
+    await new Promise(resolve => start(resolve));
+}
+
+export async function teardown() {
+    await global.server.close();
+}

package/template-lambda-rest-api-ts/tsconfig.json

@@ -0,0 +1,47 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "esnext",
+    "moduleResolution": "node",
+    "strict": true,
+    "noImplicitThis": true,
+    "jsx": "preserve",
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "allowJs": true,
+    "noImplicitAny": true,
+    "strictFunctionTypes": false,
+    "skipLibCheck": true,
+    "strictPropertyInitialization": false,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "allowImportingTsExtensions": true,
+    "lib": [
+      "esnext",
+      "dom"
+    ],
+    "types": [
+      "vite/client",
+      "node"
+    ],
+    "baseUrl": ".",
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ]
+    }
+  },
+  "include": [
+    "src/**/*.ts",
+    "src/**/*.mts",
+    "src/**/*.d.ts",
+    "src/**/*.tsx",
+    "src/**/*.vue",
+    "node_modules/vitest/globals.d.ts"
+  ],
+  "exclude": [
+    "dist"
+  ]
+}

package/template-lambda-rest-api-ts/vite.config.mts

@@ -0,0 +1,188 @@
+import type { APIGatewayProxyEvent, APIGatewayProxyResult } from "aws-lambda";
+import * as path from "node:path";
+import {performance} from "node:perf_hooks";
+import chalk from "chalk";
+import {build, defineConfig, mergeConfig, Plugin, ResolvedConfig} from "vite";
+import fs from "fs-extra";
+import type {Connect} from "vite";
+import querystring from "node:querystring";
+
+interface Options {
+    entry: string
+}
+
+const cnf = {
+  protocol: "http",
+  host: "localhost",
+  port: 3000,
+};
+const readBody = (req: Connect.IncomingMessage): Promise<string> => {
+    return new Promise(resolve => {
+        const body: Buffer[] = [];
+        req
+            .on('data', (chunk: Buffer) => {
+                body.push(chunk);
+            })
+            .on('end', () => {
+                resolve(Buffer.concat(body).toString());
+            });
+    });
+};
+
+// Адаптер для согласованности с AWS Lambda
+const incomingMessageAdapter = async(req: Connect.IncomingMessage): Promise<APIGatewayProxyEvent> => {
+        const urlPath = (req.originalUrl || "").split("#")[0];
+        const path = urlPath.split('?')[0];
+        const queryStringParameters = querystring.parse(urlPath.split('?')[1]);
+        const queryStringParametersString = Object.keys(queryStringParameters).reduce((ac, key) => {
+            const value = queryStringParameters[key] as string|string[];
+            const valueString: string = !Array.isArray(value)
+                ? value
+                : value[value.length - 1]
+            ac[key] = ac[key] || valueString;
+            return ac;
+        }, {} as Record<string, string>);
+        const multiValueQueryStringParameters = Object.keys(queryStringParameters).reduce((ac, key) => {
+            const value = Array.isArray(queryStringParameters[key]) ? queryStringParameters[key] : [queryStringParameters[key]]
+            ac[key] = ac[key] || value;
+            return ac;
+        }, {} as Record<string, string[]>);
+        const headers = (req.rawHeaders || []).reduce((ac, v, index, all) => {
+            index % 2 === 0 ? (ac[v] = ac[v] || "") : (ac[all[index - 1]] = v);
+            return ac;
+        }, {} as Record<string, any>);
+        const multiValueHeaders = (req.rawHeaders || []).reduce((ac, v, index, all) => {
+            index % 2 === 0 ? (ac[v] = ac[v] || []) : (ac[all[index - 1]].push(v));
+            return ac;
+        }, {} as Record<string, any>);
+        const headersLowerCase = Object.keys(headers).reduce((ac, key) => {
+            const value = headers[key];
+            ac[key.toLowerCase()] = value;
+            return ac;
+        }, {} as Record<string, string>);
+        return {
+            body: await readBody(req),
+            headers,
+            multiValueHeaders,
+            httpMethod: (req.method || "").toUpperCase(),
+            isBase64Encoded: false,
+            // @ts-ignore
+            path,
+            pathParameters: null,
+            queryStringParameters: queryStringParametersString,
+            multiValueQueryStringParameters,
+            stageVariables: null,
+            requestContext: {
+                resourcePath: path.split("/").slice(1).join("/"),
+                httpMethod: (req.method || "").toUpperCase(),
+                accountId: "",
+                apiId: "",
+                authorizer: {},
+                protocol: "http",
+                identity: {
+                    cognitoIdentityPoolId: null,
+                    cognitoIdentityId: null,
+                    apiKey: "",
+                    principalOrgId: null,
+                    cognitoAuthenticationType: null,
+                    userArn: null,
+                    apiKeyId: "",
+                    userAgent: headersLowerCase["user-agent"],
+                    accountId: null,
+                    caller: null,
+                    sourceIp: headersLowerCase["x-forwarded-for"],
+                    accessKey: null,
+                    cognitoAuthenticationProvider: null,
+                    user: null,
+                    clientCert: null
+                },
+                path,
+                stage: "",
+                requestId: "",
+                requestTimeEpoch: 0,
+                resourceId: ""
+            }, // Only for production
+            resource: path,
+        }
+}
+const node = (opt: Options): Plugin => {
+    return {
+        name: "vite-node-js",
+        async configureServer(server) {
+            return () => server.middlewares.use(
+                async (req, res, next) => {
+                    const ssrModule = await server.ssrLoadModule(path.join(server.config.root, opt.entry));
+                    const render = ssrModule.handler || ssrModule.default || ssrModule;
+                    const {statusCode, body, headers, multiValueHeaders} = (await render(await incomingMessageAdapter(req), {})) as APIGatewayProxyResult;
+                    const allHeaders = Object.assign({}, headers || {}, multiValueHeaders || {}) as Record<string, string|string[]>;
+                    Object.entries(allHeaders).map(([key, value] : [string, string]) => res.setHeader(key, value));
+                    res.statusCode = statusCode || 200;
+                    res.end(body);
+                });
+        },
+        async configResolved(configVite:ResolvedConfig) {
+            const time = performance.now();
+            const start = async(resolve: CallableFunction) => {
+                try {
+                    await fetch(`${cnf.protocol}://${cnf.host}:${cnf.port}/start-server`);
+                    const interval = Math.round((performance.now() - time)/10)/100;
+                    console.log(chalk.green('dev server running for ') + chalk.red(`${interval}s`) + chalk.green(' at:'));
+                    console.log(`${cnf.protocol}://${cnf.host}:${cnf.port}`);
+                    resolve();
+                } catch(e: any) {
+                    await start(resolve);
+                }
+            };
+            if(configVite.command === "build") {
+
+                // @ts-ignore
+                if(!configVite.build.isBuild) {
+                    await build(mergeConfig({
+                        build: {
+                            isBuild: true,
+                            outDir: path.resolve(configVite.root, `dist`),
+                            ssr: path.join(configVite.root, opt.entry),
+                        }
+                    }, {}));
+                    const packagePath = path.resolve(configVite.root, "./dist", "./package.json");
+                    await fs.copy("./package.json", packagePath);
+                    const pkg = await fs.readJson(packagePath);
+                    delete(pkg.devDependencies);
+                    delete(pkg.scripts);
+                    await fs.writeJson(packagePath, pkg, {
+                        spaces: 2
+                    });
+                    process.exit(0);
+                }
+            } else {
+                console.log();
+                console.log(chalk.green('dev server starting...'));
+                new Promise(resolve => start(resolve));
+            }
+        },
+        async closeBundle() {}
+    }
+}
+
+export default defineConfig({
+    resolve: {
+        alias: [
+            {
+                find: /@\/(.*)/,
+                replacement: path.resolve("./src") + "/$1"
+            }
+        ],
+    },
+    server: {
+        host: cnf.host,
+        port: cnf.port
+    },
+    optimizeDeps: {
+      include:[]
+    },
+    plugins: [
+        node({
+            entry: "/src/backend/index.mts"
+        })
+    ]
+});

package/template-lambda-rest-api-ts/vitest.config.mts

@@ -0,0 +1,40 @@
+/// <reference types="vitest" />
+import path from 'node:path';
+import { defineConfig } from 'vitest/config';
+
+process.env.TEST_MODE_APP = "test";
+
+export default defineConfig({
+	resolve: {
+		alias: [
+			{
+				find: /^~(.+)/,
+				replacement: path.resolve('./node_modules') + '/$1',
+			},
+			{
+				find: /@\/(.*)/,
+				replacement: path.resolve('./src') + '/$1',
+			},
+		],
+	},
+	plugins: [
+	],
+	test: {
+		root: "./",
+		include: ["**/__its__/**/*.(m)?[jt]s?(x)", "**/__tests__/**/*.(m)?[jt]s?(x)", "**/?(*.)+(spec|test).(m)?[jt]s?(x)"],
+		exclude: ["**/node_modules/**", "./src/certs/**", "./src/scripts/**", "./src/sql/**", "./src/estimation-client/**"],
+		environment: "jsdom",
+		globals: true,
+		globalSetup: ["./src/scripts/vitest.global.setup.mts"],
+		testTimeout: 15000,
+		hookTimeout: 15000,
+		// threads: false
+		// @ts-ignore
+		singleThread: true,
+		poolOptions: {
+			threads: {
+				singleThread: true
+			}
+		}
+	},
+});