@diia-inhouse/scaffold 2.24.0 → 2.52.2

package/dist/_templates/init/service/01-package.json.t

@@ -12,18 +12,19 @@ to:  <%= serviceName %>/package.json
         "prepare": "ts-patch install -s",
         "build": "rimraf dist/ && mkdir dist && npm run genproto && tsc",
         "start": "node dist/index.js",
-        "semantic-release": "semantic-release",
-        "lint": "eslint --ext .ts . && prettier --check .",
-        "lint-fix": "eslint --ext .ts --fix && prettier --write .",
+        "semantic-release": "semantic-release -e @diia-inhouse/configs/dist/semantic-release/service-stage --debug --ci",
+        "semantic-release-prod": "semantic-release -e @diia-inhouse/configs/dist/semantic-release/service-prod --debug --ci",
+        "lint": "eslint . && prettier --check . && buf format ./proto --diff --exit-code ",
+        "lint-fix": "eslint . --fix && prettier --write . && buf format ./proto --write",
         "lint:lockfile": "lockfile-lint --path package-lock.json --allowed-hosts registry.npmjs.org gitlab.diia.org.ua --validate-https",
-        "test": "NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules\" jest",
-        "test:integration": "npm run test --selectProjects integration --",
-        <%if (h.isOptionSelected(selectedOptions, 'database')) {%>
-        "migrate-deploy": "npm run migrate up",
-        "migrate-ci": "npm run migrate up",
+        "pretest": "npm run genproto -- --generateClient=true",
+        "test": "tsc --project tests/tsconfig.json --noEmit && vitest run",
+        "test:watch": "vitest watch",
+        "test:coverage": "vitest run --coverage",
+        <%if (h.isOptionSelected(selectedDependencies, 'database')) {%>
         "migrate-test": "NODE_ENV=test npm run migrate up",
         "migrate": "sh -c 'ts-node --project migrations/tsconfig.json node_modules/.bin/migrate-mongo $0 $1 -f migrate-mongo-config.ts'",
-        "indexes:sync": "MONGO_INDEXES_SYNC=true MONGO_INDEXES_EXIT_AFTER_SYNC=true npm run start",
+        "indexes:sync": "node -r module-alias/register ./node_modules/.bin/diia-db sync-indexes",
         <%}%>
         "find-circulars": "madge --circular --extensions ts ./",
         "scaffold": "scaffold",
@@ -31,7 +32,7 @@ to:  <%= serviceName %>/package.json
     },
     "keywords": [],
     "engines": {
-        "node": ">=20"
+        "node": ">=22"
     },
     "files": [
         "dist"
@@ -43,29 +44,14 @@ to:  <%= serviceName %>/package.json
         "@src": "dist",
         "@tests": "tests"
     },
-    "jest": {
-        "preset": "@diia-inhouse/configs/dist/jest"
-    },
     "commitlint": {
         "extends": "@diia-inhouse/configs/dist/commitlint"
     },
-    "eslintConfig": {
-        "extends": "@diia-inhouse/eslint-config",
-        "parserOptions": {
-            "project": [
-                "./tsconfig.json",
-                "./tests/tsconfig.json"
-                <%if (h.isOptionSelected(selectedOptions, 'database')) {%>
-                ,"./migrations/tsconfig.json"
-                <%}%>
-            ]
-        }
-    },
-    "release": {
-        "extends": "@diia-inhouse/configs/dist/semantic-release/service"
-    },
     "prettier": "@diia-inhouse/eslint-config/prettier",
     "madge": {
         "tsConfig": "./tsconfig.json"
+    },
+    "overrides": {
+        "protobufjs": "7.2.5"
     }
 }

package/dist/_templates/init/service/01-proto.service.proto.t

@@ -1,10 +1,14 @@
 ---
-to:  <%= serviceName %>/proto/<%= h.changeCase.snakeCase(serviceName) %>.proto
+to:  <%= serviceName %>/proto/<%= h.changeCase.paramCase(serviceName) %>.proto
 ---
 
 syntax = "proto3";
 
 package ua.gov.diia.<%= h.changeCase.pascalCase(serviceName).toLowerCase() %>;
+
+import "google/api/annotations.proto";
+import "google/protobuf/empty.proto";
+
 option java_multiple_files = true;
 option java_package = "ua.gov.diia.<%= h.changeCase.pascalCase(serviceName).toLowerCase() %>";
 
@@ -12,6 +16,12 @@ service <%= h.changeCase.pascalCase(serviceName) %> {
     rpc GetAddResult(GetAddResultReq) returns (GetAddResultRes);
 }
 
+service <%= h.changeCase.pascalCase(serviceName) %>Public {
+  rpc GetPublicResult(google.protobuf.Empty) returns (GetAddResultRes) {
+    option (google.api.http) = {get: "/api/v1/public-service/<%= h.changeCase.snakeCase(serviceName) %>/{param}/data"};
+  }
+}
+
 message GetAddResultReq {
     int32 a = 1;
     int32 b = 2;
@@ -20,3 +30,7 @@ message GetAddResultReq {
 message GetAddResultRes {
     int32 result = 1;
 }
+
+message DesignSystemResponse {
+  
+}

package/dist/_templates/init/service/01-readme.md.t

@@ -2,6 +2,17 @@
 to:  <%= serviceName %>/README.md
 ---
 
+# Service setup instructions. Remove after setup.
+
+- [ ] Init git repo and push separate branch "semantic-dummy-release". It's needed for semantic release mechanism.
+- [ ] Ask DevOps to add service to the infra repo
+- [ ] Create an mr to setup envoy to proxy grpc requests to this service - [example](https://gitlab.diia.org.ua/diia-devops/master-core/-/merge_requests/589/diffs)
+
+
 ### <%= serviceName %>
 
 <%= description %>
+
+<%= selectedReadmePointValues.has('figma') ? `🖼️ [Figma](${selectedReadmePointValues.get('figma')})` : '' %>
+<%= selectedReadmePointValues.has('api') ? `🚪 [API](${selectedReadmePointValues.get('api')})` : '' %>
+<%= selectedReadmePointValues.has('docs') ? `📄 [Docs](${selectedReadmePointValues.get('docs')})` : '' %>

package/dist/_templates/init/service/01-src.actions.v1.getAddResult.ts.t

@@ -3,22 +3,32 @@ to:  <%= serviceName %>/src/actions/v1/getAddResult.ts
 ---
 
 import { GrpcAppAction } from '@diia-inhouse/diia-app'
-
+import { SessionType } from '@diia-inhouse/types'
 import { ValidationSchema } from '@diia-inhouse/validators'
 
+import { GetAddResultReq } from '@src/generated'
+
+import AddService from '@services/add'
+
 import { ActionResult, Context } from '@interfaces/actions/v1/getAddResult'
 
 export default class GetAddResultAction implements GrpcAppAction<Context> {
     readonly name = 'getAddResult'
 
+    readonly sessionType = SessionType.None
+
     readonly validationRules: ValidationSchema<GetAddResultReq> = {
         a: {type: 'number'},
         b: {type: 'number'}
     }
 
+    constructor(private readonly addService: AddService) {}
+
     async handler(args: Context): Promise<ActionResult> {
         const { params: { a, b } } = args
 
-        return { result: a + b }
+        const result = this.addService.add(a, b)
+
+        return { result }
     }
 }

package/dist/_templates/init/service/01-src.bootstrap.ts.t

@@ -2,16 +2,17 @@
 to:  <%= serviceName %>/src/bootstrap.ts
 ---
 
-import { Application, ServiceContext } from '@diia-inhouse/diia-app'
+import { Application, NodeTracerProvider, ServiceContext } from '@diia-inhouse/diia-app'
 
-import configFactory from '@src/config'
+import configFactory from '@src/configs/config'
+import { loggerConfig } from '@src/configs/logger'
 import deps from '@src/deps'
 
 import { AppConfig } from '@interfaces/config'
 import { AppDeps } from '@interfaces/deps'
 
-export async function bootstrap(serviceName: string): Promise<void> {
-    const app = new Application<ServiceContext<AppConfig, AppDeps>>(serviceName)
+export async function bootstrap(serviceName: string, nodeTracerProvider: NodeTracerProvider): Promise<void> {
+    const app = new Application<ServiceContext<AppConfig, AppDeps>>(serviceName, nodeTracerProvider, loggerConfig)
     
     await app.setConfig(configFactory)
     await app.setDeps(deps)

package/dist/_templates/init/service/01-src.configs.config.ts.t

@@ -0,0 +1,150 @@
+---
+to:  <%= serviceName %>/src/configs/config.ts
+---
+
+import { BaseConfig } from '@diia-inhouse/diia-app'
+
+import { EnvService } from '@diia-inhouse/env'
+<%if (h.isOptionSelected(selectedDependencies, ['redis'])) {%>
+import { RedisOptions } from '@diia-inhouse/redis'
+<%}%>
+<%if (h.isOptionSelected(selectedDependencies, ['internal', 'external'])) {%>
+import { QueueConnectionType, QueueTypes } from '@diia-inhouse/diia-queue'
+
+import serviceRulesConfig from '@src/configs/queue'
+<%}%>
+
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+export default async (<%= h.isOptionSelected(selectedDependencies, ['database', 'internal', 'external']) ? "envService: EnvService, " : '' %> <%= h.isOptionSelected(selectedDependencies, ['internal', 'external']) ? "serviceName: string" : '' %>) => ({
+    healthCheck: {
+        isEnabled: EnvService.getVar('HEALTH_CHECK_IS_ENABLED', 'boolean'),
+        port: EnvService.getVar('HEALTH_CHECK_IS_PORT', 'number', 4545),
+    },
+
+    metrics: {
+        custom: {
+            disabled: EnvService.getVar('METRICS_CUSTOM_DISABLED', 'boolean', false),
+            port: EnvService.getVar('METRICS_CUSTOM_PORT', 'number', 3030),
+            disableDefaultMetrics: EnvService.getVar('METRICS_CUSTOM_DISABLE_DEFAULT_METRICS', 'boolean', false),
+            defaultLabels: EnvService.getVar('METRICS_CUSTOM_DEFAULT_LABELS', 'object', {}),
+            pushGateway: {
+                isEnabled: EnvService.getVar('METRICS_PUSH_GATEWAY_IS_ENABLED', 'boolean', false),
+                url: EnvService.getVar('METRICS_PUSH_GATEWAY_URL', 'string', null),
+                intervalMs: EnvService.getVar('METRICS_PUSH_GATEWAY_INTERVAL_MS', 'number', null),
+            },
+        },
+    },
+
+    grpcServer: {
+        isEnabled: EnvService.getVar('GRPC_SERVER_ENABLED', 'boolean', false),
+        port: EnvService.getVar('GRPC_SERVER_PORT', 'number', 5000),
+        services: EnvService.getVar('GRPC_SERVICES', 'object'),
+        isReflectionEnabled: EnvService.getVar('GRPC_REFLECTION_ENABLED', 'boolean', false),
+        maxReceiveMessageLength: EnvService.getVar('GRPC_SERVER_MAX_RECEIVE_MESSAGE_LENGTH', 'number', 1024 * 1024 * 4),
+    },
+
+    grpc: {},
+
+    <%if (h.isOptionSelected(selectedDependencies, 'database')) {%>
+        db: {
+            database: EnvService.getVar('MONGO_DATABASE', 'string'),
+            replicaSet: EnvService.getVar('MONGO_REPLICA_SET', 'string'),
+            user: await envService.getSecret('MONGO_USER', { accessor: 'username', nullable: true }),
+            password: await envService.getSecret('MONGO_PASSWORD', { accessor: 'password', nullable: true }),
+            authSource: EnvService.getVar('MONGO_AUTH_SOURCE', 'string', null),
+            port: EnvService.getVar('MONGO_PORT', 'number'),
+            replicaSetNodes: EnvService
+                .getVar('MONGO_HOSTS', 'string')
+                .split(',')
+                .map((replicaHost: string) => ({ replicaHost })),
+            readPreference: EnvService.getVar('MONGO_READ_PREFERENCE', 'string'),
+            metrics: {
+                enabled: EnvService.getVar('MONGO_METRICS_ENABLED', 'boolean'),
+            },
+        },
+    <%}%>
+
+    <%if (h.isOptionSelected(selectedDependencies, 'redis')) {%>
+        store: {
+            readWrite: EnvService.getVar('STORE_READ_WRITE_OPTIONS', 'object') as RedisOptions,
+            readOnly: EnvService.getVar('STORE_READ_ONLY_OPTIONS', 'object') as RedisOptions,
+        },
+    <%}%>
+
+    <%if (h.isOptionSelected(selectedDependencies, ['internal', 'external'])) {%>
+    rabbit: {
+        serviceRulesConfig,
+        <%if (h.isOptionSelected(selectedDependencies, 'internal')) {%>
+        [QueueConnectionType.Internal]: {
+                connection: {
+                    hostname: EnvService.getVar('RABBIT_HOST', 'string'),
+                    port: EnvService.getVar('RABBIT_PORT', 'number'),
+                    username: await envService.getSecret('RABBIT_USERNAME', { accessor: 'username' }),
+                    password: await envService.getSecret('RABBIT_PASSWORD', { accessor: 'password' }),
+                    heartbeat: EnvService.getVar('RABBIT_HEARTBEAT', 'number'),
+                },
+                socketOptions: {
+                    clientProperties: {
+                        applicationName: `${serviceName} Service`,
+                    },
+                },
+                reconnectOptions: {
+                    reconnectEnabled: true,
+                },
+                listenerOptions: {
+                    prefetchCount: EnvService.getVar('RABBIT_QUEUE_PREFETCH_COUNT', 'number', 10),
+                },
+                declareOptions: {
+                    assertQueues: EnvService.getVar('RABBIT_ASSERT_QUEUES', 'boolean'),
+                    assertExchanges: EnvService.getVar('RABBIT_ASSERT_EXCHANGES', 'boolean'),
+                    queuesOptions: {
+                        type: QueueTypes.Quorum,
+                        options: {
+                            durable: true,
+                        },
+                    },
+                },
+                // Uncomment if listening to scheduled tasks needed
+                // scheduledTaskQueueName: ScheduledTaskQueueName.,
+                // Uncomment if listening to internal bus events needed
+                // queueName: InternalQueueName.,
+            },
+        <%}%>
+        <%if (h.isOptionSelected(selectedDependencies, 'external')) {%>
+        [QueueConnectionType.External]: {
+            connection: {
+                hostname: EnvService.getVar('EXTERNAL_RABBIT_HOST', 'string'),
+                port: EnvService.getVar('EXTERNAL_RABBIT_PORT', 'number'),
+                username: await envService.getSecret('EXTERNAL_RABBIT_USERNAME', { accessor: 'username' }),
+                password: await envService.getSecret('EXTERNAL_RABBIT_PASSWORD', { accessor: 'password' }),
+                heartbeat: EnvService.getVar('EXTERNAL_RABBIT_HEARTBEAT', 'number'),
+            },
+            socketOptions: {
+                clientProperties: {
+                    applicationName: `${serviceName} Service`,
+                },
+            },
+            reconnectOptions: {
+                reconnectEnabled: true,
+            },
+            listenerOptions: {
+                prefetchCount: EnvService.getVar('EXTERNAL_RABBIT_QUEUE_PREFETCH_COUNT', 'number', 1),
+            },
+            declareOptions: {
+                assertQueues: EnvService.getVar('EXTERNAL_RABBIT_ASSERT_QUEUES', 'boolean'),
+                assertExchanges: EnvService.getVar('EXTERNAL_RABBIT_ASSERT_EXCHANGES', 'boolean'),
+                queuesOptions: {
+                    type: QueueTypes.Quorum,
+                    options: {
+                        durable: true,
+                    },
+                },
+            },
+            custom: {
+                responseRoutingKeyPrefix: EnvService.getVar('EXTERNAL_RABBIT_RESPONSE_ROUTING_KEY_PREFIX', 'string', null),
+            },
+        },
+        <%}%>
+    },
+    <%}%>
+}) satisfies BaseConfig & Record<string, unknown>

package/dist/_templates/init/service/01-src.configs.logger.ts.t

@@ -0,0 +1,11 @@
+---
+to:  <%= serviceName %>/src/configs/logger.ts
+---
+
+import { defaultOptions } from '@diia-inhouse/diia-logger'
+import { EnvService } from '@diia-inhouse/env'
+import { LogLevel, LoggerOptions } from '@diia-inhouse/types'
+
+export const loggerConfig: LoggerOptions = {
+    logLevel: EnvService.getVar('LOG_LEVEL', 'string', defaultOptions.logLevel) as LogLevel,
+}

package/dist/_templates/init/service/01-src.configs.queue.ts.t

@@ -0,0 +1,46 @@
+---
+to: "<%= h.isOptionSelected(selectedDependencies, ['internal', 'external']) ? `${serviceName}/src/configs/queue.ts` : null %>"
+---
+import { ServiceRulesConfig, QueueConfigType } from '@diia-inhouse/diia-queue'
+
+import {
+    InternalQueueNames,
+    InternalTopics,
+    ScheduledTaskEvents,
+    ScheduledTaskQueueNames,
+} from '@interfaces/queue'
+
+export default {
+    portalEvents: [],
+    queuesConfig: {
+        [QueueConfigType.Internal]: {
+            [InternalQueueNames.Queue<%= h.changeCase.pascalCase(serviceName) %>]: {
+                topics: [],
+            },
+            [ScheduledTaskQueueNames.ScheduledTasksQueue<%= h.changeCase.pascalCase(serviceName) %>]: {
+                topics: [InternalTopics.TopicScheduledTasks],
+            },
+        },
+    },
+    servicesConfig: {
+        [QueueConfigType.Internal]: {
+            subscribe: [
+                ScheduledTaskQueueNames.ScheduledTasksQueue<%= h.changeCase.pascalCase(serviceName) %>,
+                InternalQueueNames.Queue<%= h.changeCase.pascalCase(serviceName) %>
+            ],
+            publish: [],
+        },
+        [QueueConfigType.External]: {
+            subscribe: [],
+            publish: [],
+        },
+    },
+    topicsConfig: {
+        [QueueConfigType.Internal]: {
+            [InternalTopics.TopicScheduledTasks]: {
+                events: Object.values(ScheduledTaskEvents),
+            },
+        },
+        [QueueConfigType.External]: {},
+    },
+} satisfies ServiceRulesConfig

package/dist/_templates/init/service/01-src.deps.ts.t

@@ -4,8 +4,8 @@ to:  <%= serviceName %>/src/deps.ts
 
 import { DepsFactoryFn } from "@diia-inhouse/diia-app";
 
+import { AppConfig } from '@interfaces/config'
 import { AppDeps } from "@interfaces/deps";
-import { AppConfig } from "@interfaces/config";
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 export default async (_config: AppConfig): ReturnType<DepsFactoryFn<AppConfig, AppDeps>> => {

package/dist/_templates/init/service/01-src.index.ts.t

@@ -3,12 +3,11 @@ to:  <%= serviceName %>/src/index.ts
 ---
 
 import { initTracing } from '@diia-inhouse/diia-app'
+import { utils } from '@diia-inhouse/utils'
 
-const serviceName = '<%= h.changeCase.pascalCase(serviceName) %>'
-
-initTracing(serviceName)
+const nodeTracerProvider = initTracing()
 
 import 'module-alias/register'
 import { bootstrap } from './bootstrap'
 
-bootstrap(serviceName)
+void bootstrap(utils.getServiceName(), nodeTracerProvider)

package/dist/_templates/init/service/01-src.interfaces.config.ts.t

@@ -2,6 +2,6 @@
 to:  <%= serviceName %>/src/interfaces/config.ts
 ---
 
-import config from '@src/config'
+import config from '@src/configs/config'
 
 export type AppConfig = Awaited<ReturnType<typeof config>>

package/dist/_templates/init/service/01-src.interfaces.queue.ts.t

@@ -0,0 +1,23 @@
+---
+to: "<%= h.isOptionSelected(selectedDependencies, ['internal', 'external']) ? `${serviceName}/src/interfaces/queue.ts` : null %>"
+---
+
+export const InternalQueueNames = {
+    Queue<%= h.changeCase.pascalCase(serviceName) %>: 'Queue<%= h.changeCase.pascalCase(serviceName) %>',
+} as const
+
+export const ScheduledTaskQueueNames = {
+    ScheduledTasksQueue<%= h.changeCase.pascalCase(serviceName) %>: 'ScheduledTasksQueue<%= h.changeCase.pascalCase(serviceName) %>',
+} as const
+
+export const InternalTopics = {
+    TopicScheduledTasks: 'TopicScheduledTasks'
+} as const
+
+export const ExternalTopics = {} as const
+
+export const InternalEvents = {} as const
+
+export const ExternalEvents = {} as const
+
+export const ScheduledTaskEvents = {} as const

package/dist/_templates/init/service/01-src.services.add.ts.t

@@ -0,0 +1,9 @@
+---
+to:  <%= serviceName %>/src/services/add.ts
+---
+
+export default class AddService {
+    add(a: number, b: number): number {
+        return a + b
+    }
+}

package/dist/_templates/init/service/01-src.views.exampleViews.index.ts.t

@@ -0,0 +1,7 @@
+---
+to:  <%= serviceName %>/src/views/exampleViews/index.ts
+---
+
+export { <%= h.changeCase.pascalCase(serviceName) %>InfoViews as default } from './view'
+
+export * from './interface'

package/dist/_templates/init/service/01-src.views.exampleViews.interface.ts.t

@@ -0,0 +1,11 @@
+---
+to:  <%= serviceName %>/src/views/exampleViews/interface.ts
+---
+
+import { DesignSystemResponse } from '@diia-inhouse/design-system'
+
+export interface ViewParams {
+
+}
+
+export type ViewScreen = DesignSystemResponse

package/dist/_templates/init/service/01-src.views.exampleViews.view.ts.t

@@ -0,0 +1,15 @@
+---
+to:  <%= serviceName %>/src/views/exampleViews/view.ts
+---
+
+import { ViewParams, ViewScreen } from './interface'
+
+export class <%= h.changeCase.pascalCase(serviceName) %>InfoViews {
+    toScreen(_params: ViewParams): ViewScreen {
+        return {
+            topGroup: [],
+            body: [],
+            bottomGroup: [],
+        }
+    }
+}

package/dist/_templates/init/service/01-tests.integration.actionts.getAddResult.spec.ts.t

@@ -2,7 +2,7 @@
 to:  <%= serviceName %>/tests/integration/actions/v1/getAddResult.spec.ts
 ---
 
-import TestKit from '@diia-inhouse/test'
+import { <%= h.changeCase.pascal(serviceName) %>Client } from '@src/generated'
 
 import { ActionResult } from '@interfaces/actions/v1/getAddResult'
 
@@ -12,28 +12,20 @@ import { getApp } from '@tests/utils/getApp'
 
 describe(`Action ${GetAddResultAction.name}`, () => {
     let app: Awaited<ReturnType<typeof getApp>>
-    let action: GetAddResultAction
-    const testKit = new TestKit()
+    let <%= h.changeCase.camel(serviceName) %>Client: <%= h.changeCase.pascal(serviceName) %>Client
 
     beforeAll(async () => {
         app = await getApp()
-        action = app.container.build(GetAddResultAction)
-    })
-
-    afterAll(async () => {
-        await app.stop()
+        <%= h.changeCase.camel(serviceName) %>Client = app.container.resolve('<%= h.changeCase.camel(serviceName) %>Client')
     })
 
     it('should return correct result', async () => {
         // Arrange
-        const session = testKit.session.getUserSession()
-        const headers = testKit.session.getHeaders()
-        
         const a = 2;
         const b = 3;
         
         // Act
-        const result = await action.handler({ params: { a, b }, session, headers })
+        const result = await <%= h.changeCase.camel(serviceName) %>Client.getAddResult({ a, b })
 
         // Assert
         expect(result).toEqual<ActionResult>({ result: 5 })

package/dist/_templates/init/service/01-tests.interfaces.ts.t

@@ -4,6 +4,9 @@ to:  <%= serviceName %>/tests/interfaces.ts
 
 import TestKit from '@diia-inhouse/test'
 
+import { <%= h.changeCase.pascal(serviceName) %>Client } from '@src/generated'
+
 export interface TestDeps {
     testKit: TestKit
+    <%= h.changeCase.camel(serviceName) %>Client: <%= h.changeCase.pascal(serviceName) %>Client
 }

package/dist/_templates/init/service/01-tests.tsconfig.json.t

@@ -6,10 +6,14 @@ to:  <%= serviceName %>/tests/tsconfig.json
     "extends": "@diia-inhouse/configs/tsconfig",
     "compilerOptions": {
         "baseUrl": "../",
+        "types": ["vite/client", "vitest/globals", "./vitest.d.ts"],
+        "module": "ESNext",
+        "moduleResolution": "Bundler",
+        "isolatedModules": true,
         "paths": {
             "@services/*": ["src/services/*"],
             "@interfaces/*": ["src/interfaces/*"],
-            <%if (h.isOptionSelected(selectedOptions, 'database')) {%>
+            <%if (h.isOptionSelected(selectedDependencies, 'database')) {%>
             "@models/*": ["src/models/*"],
             <%}%>
             "@dataMappers/*": ["src/dataMappers/*"],
@@ -19,5 +23,5 @@ to:  <%= serviceName %>/tests/tsconfig.json
         },
         "noEmit": true
     },
-    "include": ["./**/*"]
+    "include": ["./**/*", "../vitest.config.mts"]
 }

package/dist/_templates/init/service/01-tests.utils.getApp.ts.t

@@ -2,9 +2,11 @@
 to:  <%= serviceName %>/tests/utils/getApp.ts
 ---
 
-import { Application, ServiceContext, ServiceOperator } from '@diia-inhouse/diia-app'
+import { Application, GrpcClientFactory, ServiceContext, ServiceOperator, NodeTracerProvider, asFunction } from '@diia-inhouse/diia-app'
 
-import config from '@src/config'
+import config from '@src/configs/config'
+import { loggerConfig } from '@src/configs/logger'
+import { <%= h.changeCase.pascal(serviceName) %>Definition } from '@src/generated'
 
 import { TestDeps } from '@tests/interfaces'
 import deps from '@tests/utils/getDeps'
@@ -12,15 +14,26 @@ import deps from '@tests/utils/getDeps'
 import { AppConfig } from '@interfaces/config'
 import { AppDeps } from '@interfaces/deps'
 
+const modules = {
+    actions: import.meta.glob('/src/actions/**/*.ts'),
+    services: import.meta.glob('/src/services/**/*.ts'),
+}
+
 export async function getApp(): Promise<ServiceOperator<AppConfig, AppDeps & TestDeps>> {
-    const app = new Application<ServiceContext<AppConfig, AppDeps & TestDeps>>('<%= h.changeCase.pascal(serviceName) %>')
+    const app = new Application<ServiceContext<AppConfig, AppDeps & TestDeps>>('<%= h.changeCase.pascal(serviceName) %>', new NodeTracerProvider(), loggerConfig)
 
     await app.setConfig(config)
     await app.setDeps(deps)
 
-    const appOperator = await app.initialize()
+    const dynamicDeps = await app.extractDependenciesFromModules(modules, 'src')
+    const appOperator = await app.initialize(dynamicDeps)
+    const { grpcService } = await appOperator.start()
 
-    await appOperator.start()
+    appOperator.container.register({
+        <%= h.changeCase.camel(serviceName) %>Client: asFunction((grpcClientFactory: GrpcClientFactory) =>
+            grpcClientFactory.createGrpcClient(<%= h.changeCase.pascal(serviceName) %>Definition, `localhost:${grpcService.serverPort}`),
+        ).singleton(),
+    })
 
     return appOperator
 }

package/dist/_templates/init/service/01-tests.vitest.d.ts.t

@@ -0,0 +1,11 @@
+---
+to:  <%= serviceName %>/tests/vitest.d.ts
+---
+
+import 'vitest'
+import { CustomMatchers } from '@diia-inhouse/test/vitest'
+
+declare module 'vitest' {
+    interface Assertion<T> extends CustomMatchers<T> {}
+    interface AsymmetricMatchersContaining extends CustomMatchers {}
+}

package/dist/_templates/init/service/01-tsconfig.json.t

@@ -11,7 +11,7 @@ to:  <%= serviceName %>/tsconfig.json
         "paths": {
             "@services/*": ["src/services/*"],
             "@interfaces/*": ["src/interfaces/*"],
-            <%if (h.isOptionSelected(selectedOptions, 'database')) {%>
+            <%if (h.isOptionSelected(selectedDependencies, 'database')) {%>
             "@models/*": ["src/models/*"],
             <%}%>
             "@dataMappers/*": ["src/dataMappers/*"],
@@ -20,5 +20,5 @@ to:  <%= serviceName %>/tsconfig.json
             "@tests/*": ["tests/*"]
         }
     },
-    "include": ["src/**/*", "tests/jest.d.ts"]
+    "include": ["src/**/*"]
 }