oip-common 0.0.2 → 0.0.4

package/ng-package.json

@@ -4,5 +4,16 @@
   "lib": {
     "entryFile": "src/public-api.ts"
   },
-  "assets": [{ "input": "src/assets", "glob": "**/*", "output": "assets" }]
+  "assets": [
+    {
+      "input": "./src/assets",
+      "glob": "**/*",
+      "output": "assets"
+    },
+    {
+      "input": "./templates",
+      "glob": "**/*",
+      "output": "templates"
+    }
+  ]
 }

package/package.json

@@ -1,16 +1,19 @@
-{
-  "name": "oip-common",
-  "version": "0.0.2",
-  "description": "A template for cross-platform web applications based on sakai-ng and primeNG",
-  "main": "index.js",
-  "scripts": {
-    "pub": "npm publish"
-  },
-  "keywords": ["oip", "template"],
-  "author": "Igor Tyulyakov aka g101k",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/g10101k/Oip"
-  }
-}
+{
+  "name": "oip-common",
+  "version": "0.0.4",
+  "description": "A template for cross-platform web applications based on sakai-ng and primeNG",
+  "main": "index.js",
+  "scripts": {
+    "pub": "npm publish"
+  },
+  "keywords": [
+    "oip",
+    "template"
+  ],
+  "author": "Igor Tyulyakov aka g101k",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/g10101k/Oip.git"
+  }
+}

package/src/api/http-client.ts

@@ -11,8 +11,8 @@
  */
 
 import { inject, Injectable } from "@angular/core";
-import { LayoutService, SecurityService } from "oip-common";
-
+import { LayoutService, } from "../services/app.layout.service"
+import { SecurityService } from "../services/security.service";
 export type QueryParamsType = Record<string | number, any>;
 export type ResponseFormat = keyof Omit<Body, "body" | "bodyUsed">;
 
@@ -64,7 +64,7 @@ export enum ContentType {
   Text = "text/plain",
 }
 
-@Injectable({ providedIn: "root" })
+@Injectable({providedIn: "root"})
 export class HttpClient<SecurityDataType = unknown> {
   protected securityService = inject(SecurityService);
   protected layoutService = inject(LayoutService);
@@ -202,16 +202,16 @@ export class HttpClient<SecurityDataType = unknown> {
   };
 
   public request = async <T = any, E = any>({
-    body,
-    secure,
-    path,
-    type,
-    query,
-    format,
-    baseUrl,
-    cancelToken,
-    ...params
-  }: FullRequestParams): Promise<T> => {
+                                              body,
+                                              secure,
+                                              path,
+                                              type,
+                                              query,
+                                              format,
+                                              baseUrl,
+                                              cancelToken,
+                                              ...params
+                                            }: FullRequestParams): Promise<T> => {
     const secureParams =
       ((typeof secure === "boolean" ? secure : this.baseApiParams.secure) &&
         this.securityWorker &&
@@ -229,7 +229,7 @@ export class HttpClient<SecurityDataType = unknown> {
         headers: {
           ...(requestParams.headers || {}),
           ...(type && type !== ContentType.FormData
-            ? { "Content-Type": type }
+            ? {"Content-Type": type}
             : {}),
         },
         signal:
@@ -252,18 +252,18 @@ export class HttpClient<SecurityDataType = unknown> {
       const data = !responseFormat
         ? r
         : await response[responseFormat]()
-            .then((data) => {
-              if (r.ok) {
-                r.data = data;
-              } else {
-                r.error = data;
-              }
-              return r;
-            })
-            .catch((e) => {
-              r.error = e;
-              return r;
-            });
+          .then((data) => {
+            if (r.ok) {
+              r.data = data;
+            } else {
+              r.error = data;
+            }
+            return r;
+          })
+          .catch((e) => {
+            r.error = e;
+            return r;
+          });
 
       if (cancelToken) {
         this.abortControllers.delete(cancelToken);

package/src/components/db-migration/db-migration.component.ts

@@ -1,5 +1,4 @@
 import { Component, inject, OnDestroy, OnInit } from '@angular/core';
-import { BaseModuleComponent, NoSettingsDto, SecurityComponent } from 'oip-common';
 import { TagModule } from 'primeng/tag';
 import { ConfirmationService, SharedModule } from 'primeng/api';
 import { TableModule } from 'primeng/table';
@@ -11,6 +10,9 @@ import { ConfirmDialog } from 'primeng/confirmdialog';
 import { NgIf } from '@angular/common';
 import { Tooltip } from 'primeng/tooltip';
 import { ActivatedRoute } from '@angular/router';
+import { BaseModuleComponent } from "../base-module.component";
+import { NoSettingsDto } from "../../dtos/no-settings.dto";
+import { SecurityComponent } from "../security.component";
 
 export interface MigrationDto {
   name: string;

package/src/components/db-migration.component.ts

@@ -1,5 +1,4 @@
 import { Component, OnDestroy, OnInit } from '@angular/core';
-import { BaseModuleComponent, NoSettingsDto, SecurityComponent } from 'oip-common';
 import { TagModule } from 'primeng/tag';
 import { ConfirmationService, SharedModule } from 'primeng/api';
 import { TableModule } from 'primeng/table';
@@ -10,6 +9,9 @@ import { FormsModule } from '@angular/forms';
 import { ConfirmDialog } from 'primeng/confirmdialog';
 import { NgIf } from '@angular/common';
 import { Tooltip } from 'primeng/tooltip';
+import { BaseModuleComponent } from "./base-module.component";
+import { NoSettingsDto } from "../dtos/no-settings.dto";
+import { SecurityComponent } from "./security.component";
 
 export interface MigrationDto {
   name: string;
@@ -39,7 +41,7 @@ export interface ApplyMigrationRequest {
   selector: 'db-migration',
   template: `
     <div *ngIf="isContent" class="card" style="height: 100%">
-      <p-confirmDialog />
+      <p-confirmDialog/>
       <div>
         <h5>Migration manager</h5>
         <div class="flex flex-row gap-2">
@@ -49,14 +51,14 @@ export interface ApplyMigrationRequest {
             severity="secondary"
             tooltipPosition="bottom"
             [outlined]="true"
-            (click)="refreshAction()" />
+            (click)="refreshAction()"/>
           <p-button
             icon="pi pi-filter-slash"
             pTooltip="Clean filter"
             severity="secondary"
             tooltipPosition="bottom"
             [outlined]="true"
-            (click)="dt.clear()" />
+            (click)="dt.clear()"/>
         </div>
         <div>
           <p-table #dt dataKey="name" editMode="row" size="small" [scrollable]="true" [value]="data">
@@ -64,7 +66,7 @@ export interface ApplyMigrationRequest {
               <tr>
                 <th pSortableColumn="name" scope="col">
                   Migration name
-                  <p-columnFilter display="menu" field="name" type="text" />
+                  <p-columnFilter display="menu" field="name" type="text"/>
                 </th>
                 <th scope="col">Applied</th>
                 <th scope="col">Exist</th>
@@ -89,7 +91,7 @@ export interface ApplyMigrationRequest {
                 </td>
                 <td>
                   @if (rowData.exist) {
-                    <p-button icon="pi pi-check" severity="success" [rounded]="true" [text]="true" />
+                    <p-button icon="pi pi-check" severity="success" [rounded]="true" [text]="true"/>
                   }
                 </td>
                 <td>
@@ -116,15 +118,14 @@ export interface ApplyMigrationRequest {
       </div>
     </div>
     @if (isSecurity) {
-      <security [controller]="controller" [id]="id" />
+      <security [controller]="controller" [id]="id"/>
     }
   `,
   providers: [ConfirmationService]
 })
 export class DbMigrationComponent
   extends BaseModuleComponent<NoSettingsDto, NoSettingsDto>
-  implements OnInit, OnDestroy
-{
+  implements OnInit, OnDestroy {
   data: MigrationDto[];
 
   async ngOnInit() {
@@ -148,7 +149,7 @@ export class DbMigrationComponent
   }
 
   async applyMigration(rowData: MigrationDto) {
-    const request = { name: rowData.name } as ApplyMigrationRequest;
+    const request = {name: rowData.name} as ApplyMigrationRequest;
     return this.baseDataService.sendRequest(`api/${this.controller}/apply-migration`, 'POST', request);
   }
 }

package/src/components/menu/menu-item-create-dialog.component.ts

@@ -4,10 +4,10 @@ import { DialogModule } from 'primeng/dialog';
 import { InputTextModule } from 'primeng/inputtext';
 import { SelectModule } from 'primeng/select';
 import { FormsModule } from '@angular/forms';
-import { MenuService } from 'oip-common';
 import { TranslatePipe } from '@ngx-translate/core';
 import { AddModuleInstanceDto, IntKeyValueDto } from '../../api/data-contracts';
 import { Menu } from '../../api/Menu';
+import { MenuService } from "../../services/app.menu.service";
 
 @Component({
   selector: 'menu-item-create-dialog',
@@ -30,14 +30,14 @@ import { Menu } from '../../api/Menu';
             id="oip-menu-item-create-dialog-parent-input"
             pInputText
             readonly
-            [ngModel]="menuService.contextMenuItem?.label" />
+            [ngModel]="menuService.contextMenuItem?.label"/>
         </div>
       }
       <div class="flex items-center gap-4 mb-4">
         <label class="font-semibold w-1/3" for="oip-menu-item-create-label">
           {{ 'menuItemCreateDialogComponent.label' | translate }}
         </label>
-        <input autocomplete="off" class="flex-auto" id="oip-menu-item-create-label" pInputText [(ngModel)]="label" />
+        <input autocomplete="off" class="flex-auto" id="oip-menu-item-create-label" pInputText [(ngModel)]="label"/>
       </div>
       <div class="flex items-center gap-4 mb-4">
         <label class="font-semibold w-1/3" for="oip-menu-item-create-module">
@@ -51,14 +51,14 @@ import { Menu } from '../../api/Menu';
           optionValue="key"
           placeholder="{{ 'menuItemCreateDialogComponent.selectModule' | translate }}"
           [options]="modules"
-          [(ngModel)]="selectModule" />
+          [(ngModel)]="selectModule"/>
       </div>
       <div class="flex items-center gap-4 mb-4">
         <label class="font-semibold w-1/3" for="oip-menu-item-create-dialog-icon">
           {{ 'menuItemCreateDialogComponent.icon' | translate }}
         </label>
         <i class="{{ selectIcon }}"></i>
-        <input class="flex-auto" id="oip-menu-item-create-dialog-icon" pInputText [(ngModel)]="selectIcon" />
+        <input class="flex-auto" id="oip-menu-item-create-dialog-icon" pInputText [(ngModel)]="selectIcon"/>
       </div>
       <div class="flex justify-end gap-2">
         <p-button
@@ -66,12 +66,12 @@ import { Menu } from '../../api/Menu';
           label="{{ 'menuItemCreateDialogComponent.cancel' | translate }}"
           severity="secondary"
           (click)="changeVisible()"
-          (keydown)="changeVisible()" />
+          (keydown)="changeVisible()"/>
         <p-button
           id="oip-menu-item-create-save"
           label="{{ 'menuItemCreateDialogComponent.save' | translate }}"
           (click)="save()"
-          (keydown)="save()" />
+          (keydown)="save()"/>
       </div>
     </p-dialog>
   `

package/src/components/menu/menu-item-edit-dialog.component.ts

@@ -3,7 +3,8 @@ import { ButtonModule } from 'primeng/button';
 import { DialogModule } from 'primeng/dialog';
 import { InputTextModule } from 'primeng/inputtext';
 import { FormsModule } from '@angular/forms';
-import { MenuService, SecurityDataService } from 'oip-common';
+import { MenuService } from '../../services/app.menu.service'
+import { SecurityDataService, } from '../../services/security-data.service'
 import { TranslatePipe } from '@ngx-translate/core';
 import { EditModuleInstanceDto } from '../../dtos/edit-module-instance.dto';
 import { MultiSelectModule } from 'primeng/multiselect';
@@ -27,7 +28,7 @@ import { MultiSelectModule } from 'primeng/multiselect';
           class="flex-auto"
           id="oip-menu-item-edit-dialog-menu-input"
           pInputText
-          [(ngModel)]="item.label" />
+          [(ngModel)]="item.label"/>
       </div>
 
       <div class="flex items-center gap-4 mb-4">
@@ -35,7 +36,7 @@ import { MultiSelectModule } from 'primeng/multiselect';
           {{ 'menuItemEditDialogComponent.icon' | translate }}
         </label>
         <i class="{{ item.icon }}"></i>
-        <input class="flex-auto" id="oip-menu-item-edit-dialog-icon" pInputText [(ngModel)]="item.icon" />
+        <input class="flex-auto" id="oip-menu-item-edit-dialog-icon" pInputText [(ngModel)]="item.icon"/>
       </div>
 
       <div class="flex items-center gap-4 mb-4">
@@ -49,7 +50,7 @@ import { MultiSelectModule } from 'primeng/multiselect';
           placeholder="Select roles"
           [maxSelectedLabels]="10"
           [options]="roles"
-          [(ngModel)]="item.viewRoles" />
+          [(ngModel)]="item.viewRoles"/>
       </div>
 
       <div class="flex justify-end gap-2">
@@ -58,12 +59,12 @@ import { MultiSelectModule } from 'primeng/multiselect';
           label="{{ 'menuItemEditDialogComponent.cancel' | translate }}"
           severity="secondary"
           (click)="changeVisible()"
-          (keydown)="changeVisible()" />
+          (keydown)="changeVisible()"/>
         <p-button
           id="oip-menu-item-edit-dialog-save-edit-button"
           label="{{ 'menuItemEditDialogComponent.save' | translate }}"
           (click)="save()"
-          (keydown)="save()" />
+          (keydown)="save()"/>
       </div>
     </p-dialog>
   `

package/src/components/profile.component.ts

@@ -2,7 +2,8 @@ import { Component, inject } from '@angular/core';
 import { FileUploadModule } from 'primeng/fileupload';
 import { ImageModule } from 'primeng/image';
 import { AvatarModule } from 'primeng/avatar';
-import { MsgService, UserService } from 'oip-common';
+import { MsgService } from "../services/msg.service";
+import { UserService } from "../services/user.service";
 import { TranslatePipe, TranslateService } from '@ngx-translate/core';
 
 @Component({
@@ -15,7 +16,7 @@ import { TranslatePipe, TranslateService } from '@ngx-translate/core';
       id="oip-user-profile-photo-avatar"
       shape="circle"
       size="xlarge"
-      [image]="userService.photoLoaded ? userService.photo : null" />
+      [image]="userService.photoLoaded ? userService.photo : null"/>
     <div class="mt-2">
       <p-fileupload
         accept="image/*"
@@ -28,7 +29,7 @@ import { TranslatePipe, TranslateService } from '@ngx-translate/core';
         url="/api/user-profile/post-user-photo"
         withCredentials="true"
         [auto]="true"
-        (onUpload)="onBasicUploadAuto($event)" />
+        (onUpload)="onBasicUploadAuto($event)"/>
     </div>
   `
 })

package/src/helpers/date.helper.ts

@@ -60,7 +60,7 @@ export function convertToPrimeNgDateFormat(dateformat: string): string {
 }
 
 /**
- * Преобразовать все свойства объекта со строковыми датами в даты
+ * Convert all properties of an object with string dates to Date objects
  * @param obj
  */
 export function restoreDates(obj: any) {
@@ -86,7 +86,7 @@ export function restoreDates(obj: any) {
 }
 
 /**
- * Проверить, является ли строка датой в ISO формате
+ * Check if a string is a date in ISO format
  * @param str
  */
 export function isIsoDate(str: string) {

package/src/user-api/http-client.ts

@@ -11,7 +11,8 @@
  */
 
 import { inject, Injectable } from '@angular/core';
-import { LayoutService, SecurityService } from 'oip-common';
+import { LayoutService } from '../services/app.layout.service';
+import { SecurityService } from '../services/security.service';
 
 export type QueryParamsType = Record<string | number, any>;
 export type ResponseFormat = keyof Omit<Body, 'body' | 'bodyUsed'>;
@@ -58,7 +59,7 @@ export enum ContentType {
   Text = 'text/plain'
 }
 
-@Injectable({ providedIn: 'root' })
+@Injectable({providedIn: 'root'})
 export class HttpClient<SecurityDataType = unknown> {
   protected securityService = inject(SecurityService);
   public baseUrl: string = '';
@@ -75,6 +76,7 @@ export class HttpClient<SecurityDataType = unknown> {
     const storageData = localStorage.getItem('0-oip-client');
     return JSON.parse(storageData)?.authnResult?.access_token;
   }
+
   private getLanguage(): string {
     // Получаем язык из localStorage или используем значение по умолчанию
     return localStorage.getItem('user-language') || 'en';
@@ -189,16 +191,16 @@ export class HttpClient<SecurityDataType = unknown> {
   };
 
   public request = async <T = any, E = any>({
-    body,
-    secure,
-    path,
-    type,
-    query,
-    format,
-    baseUrl,
-    cancelToken,
-    ...params
-  }: FullRequestParams): Promise<T> => {
+                                              body,
+                                              secure,
+                                              path,
+                                              type,
+                                              query,
+                                              format,
+                                              baseUrl,
+                                              cancelToken,
+                                              ...params
+                                            }: FullRequestParams): Promise<T> => {
     const secureParams =
       ((typeof secure === 'boolean' ? secure : this.baseApiParams.secure) &&
         this.securityWorker &&
@@ -213,7 +215,7 @@ export class HttpClient<SecurityDataType = unknown> {
       ...requestParams,
       headers: {
         ...(requestParams.headers || {}),
-        ...(type && type !== ContentType.FormData ? { 'Content-Type': type } : {})
+        ...(type && type !== ContentType.FormData ? {'Content-Type': type} : {})
       },
       signal: (cancelToken ? this.createAbortSignal(cancelToken) : requestParams.signal) || null,
       body: typeof body === 'undefined' || body === null ? null : payloadFormatter(body)
@@ -227,18 +229,18 @@ export class HttpClient<SecurityDataType = unknown> {
       const data = !responseFormat
         ? r
         : await response[responseFormat]()
-            .then((data) => {
-              if (r.ok) {
-                r.data = data;
-              } else {
-                r.error = data;
-              }
-              return r;
-            })
-            .catch((e) => {
-              r.error = e;
-              return r;
-            });
+          .then((data) => {
+            if (r.ok) {
+              r.data = data;
+            } else {
+              r.error = data;
+            }
+            return r;
+          })
+          .catch((e) => {
+            r.error = e;
+            return r;
+          });
 
       if (cancelToken) {
         this.abortControllers.delete(cancelToken);

package/templates/api.ejs

@@ -0,0 +1,30 @@
+<%
+const { utils, route, config, modelTypes } = it;
+const { _, pascalCase, require } = utils;
+const apiClassName = pascalCase(route.moduleName);
+const routes = route.routes;
+const dataContracts = _.map(modelTypes, "name");
+%>
+
+<% if (config.httpClientType === config.constants.HTTP_CLIENT.AXIOS) { %> import type { AxiosRequestConfig, AxiosResponse } from "axios"; <% } %>
+
+import { HttpClient, RequestParams, ContentType, HttpResponse } from "./<%~ config.fileNames.httpClient %>";
+<% if (dataContracts.length) { %>
+import { <%~ dataContracts.join(", ") %> } from "./<%~ config.fileNames.dataContracts %>"
+<% } %>
+import { Injectable } from "@angular/core";
+
+@Injectable()
+export class <%= apiClassName %><SecurityDataType = unknown><% if (!config.singleHttpClient) { %> extends HttpClient<SecurityDataType> <% } %> {
+<% if(config.singleHttpClient) { %>
+  http: HttpClient<SecurityDataType>;
+
+  constructor (http: HttpClient<SecurityDataType>) {
+    this.http = http;
+  }
+<% } %>
+
+    <% for (const route of routes) { %>
+        <%~ includeFile('./procedure-call.ejs', { ...it, route }) %>
+    <% } %>
+}

package/templates/data-contract-jsdoc.ejs

@@ -0,0 +1,37 @@
+<%
+const { data, utils } = it;
+const { formatDescription, require, _ } = utils;
+
+const stringify = (value) => _.isObject(value) ? JSON.stringify(value) : _.isString(value) ? `"${value}"` : value
+
+const jsDocLines = _.compact([
+    data.title,
+    data.description && formatDescription(data.description),
+    !_.isUndefined(data.deprecated) && data.deprecated && '@deprecated',
+    !_.isUndefined(data.format) && `@format ${data.format}`,
+    !_.isUndefined(data.minimum) && `@min ${data.minimum}`,
+    !_.isUndefined(data.multipleOf) && `@multipleOf ${data.multipleOf}`,
+    !_.isUndefined(data.exclusiveMinimum) && `@exclusiveMin ${data.exclusiveMinimum}`,
+    !_.isUndefined(data.maximum) && `@max ${data.maximum}`,
+    !_.isUndefined(data.minLength) && `@minLength ${data.minLength}`,
+    !_.isUndefined(data.maxLength) && `@maxLength ${data.maxLength}`,
+    !_.isUndefined(data.exclusiveMaximum) && `@exclusiveMax ${data.exclusiveMaximum}`,
+    !_.isUndefined(data.maxItems) && `@maxItems ${data.maxItems}`,
+    !_.isUndefined(data.minItems) && `@minItems ${data.minItems}`,
+    !_.isUndefined(data.uniqueItems) && `@uniqueItems ${data.uniqueItems}`,
+    !_.isUndefined(data.default) && `@default ${stringify(data.default)}`,
+    !_.isUndefined(data.pattern) && `@pattern ${data.pattern}`,
+    !_.isUndefined(data.example) && `@example ${stringify(data.example)}`
+]).join('\n').split('\n');
+%>
+<% if (jsDocLines.every(_.isEmpty)) { %>
+<% } else if (jsDocLines.length === 1) { %>
+/** <%~ jsDocLines[0] %> */
+<% } else if (jsDocLines.length) { %>
+/**
+<% for (jsDocLine of jsDocLines) { %>
+ * <%~ jsDocLine %>
+
+<% } %>
+ */
+<% } %>

package/templates/data-contracts.ejs

@@ -0,0 +1,52 @@
+<%
+const { modelTypes, utils, config } = it;
+const { formatDescription, require, _, Ts } = utils;
+
+
+const buildGenerics = (contract) => {
+  if (!contract.genericArgs || !contract.genericArgs.length) return '';
+
+  return '<' + contract.genericArgs.map(({ name, default: defaultType, extends: extendsType }) => {
+    return [
+      name,
+      extendsType && `extends ${extendsType}`,
+      defaultType && `= ${defaultType}`,
+    ].join('')
+  }).join(',') + '>'
+}
+
+const dataContractTemplates = {
+  enum: (contract) => {
+    return `enum ${contract.name} {\r\n${contract.content} \r\n }`;
+  },
+  interface: (contract) => {
+    return `interface ${contract.name}${buildGenerics(contract)} {\r\n${contract.content}}\r\n\r\n`;
+  },
+  type: (contract) => {
+    return `type ${contract.name}${buildGenerics(contract)} = ${contract.content}`;
+  },
+}
+%>
+
+<% if (config.internalTemplateOptions.addUtilRequiredKeysType) { %>
+type <%~ config.Ts.CodeGenKeyword.UtilRequiredKeys %><T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>
+<% } %>
+
+<% for (const contract of modelTypes) {
+  if (contract.typeIdentifier === 'interface' && contract.rawContent && Array.isArray(contract.rawContent)) {
+    contract.rawContent.forEach((prop) => {
+      if (prop.format ==='date-time') {
+        prop.field = prop.field.replace(': string', ': Date');
+      }
+    })
+      let customContent = '';
+      contract.rawContent.forEach((prop) => {
+          if (prop.description) customContent += `/** ${prop.description} */ \r\n`;
+          customContent += `${prop.field};\r\n`;
+      })
+      contract.content = customContent;
+  }
+%>
+  <%~ includeFile('./data-contract-jsdoc.ejs', { ...it, data: { ...contract, ...contract.typeData } }) %>
+  <%~ contract.internal ? '' : 'export'%> <%~ (dataContractTemplates[contract.typeIdentifier] || dataContractTemplates.type)(contract) %>
+<% } %>

package/templates/enum-data-contract.ejs

@@ -0,0 +1,12 @@
+<%
+const { contract, utils, config } = it;
+const { formatDescription, require, _ } = utils;
+const { name, $content } = contract;
+%>
+<% if (config.generateUnionEnums) { %>
+  export type <%~ name %> = <%~ _.map($content, ({ value }) => value).join(" | ") %>
+<% } else { %>
+  export enum <%~ name %> {
+    <%~ _.map($content, ({ key, value }) => `${key} = ${value}`).join(",\n") %>
+  }
+<% } %>

package/templates/http-client.ejs

@@ -0,0 +1,245 @@
+<%
+const { apiConfig, generateResponses, config } = it;
+%>
+
+import { SecurityService } from "oip-common";
+import { LayoutService } from "oip-common";
+import { inject, Injectable } from "@angular/core";
+
+export type QueryParamsType = Record<string | number, any>;
+export type ResponseFormat = keyof Omit<Body, "body" | "bodyUsed">;
+
+export interface FullRequestParams extends Omit<RequestInit, "body"> {
+  /** set parameter to `true` for call `securityWorker` for this request */
+  secure?: boolean;
+  /** request path */
+  path: string;
+  /** content type of request body */
+  type?: ContentType;
+  /** query params */
+  query?: QueryParamsType;
+  /** format of response (i.e. response.json() -> format: "json") */
+  format?: ResponseFormat;
+  /** request body */
+  body?: unknown;
+  /** base url */
+  baseUrl?: string;
+  /** request cancellation token */
+  cancelToken?: CancelToken;
+}
+
+export type RequestParams = Omit<FullRequestParams, "body" | "method" | "query" | "path">
+
+
+export interface ApiConfig<SecurityDataType = unknown> {
+    baseUrl?: string;
+    baseApiParams?: Omit<RequestParams, "baseUrl" | "cancelToken" | "signal">;
+    securityWorker?: (securityData: SecurityDataType | null) => Promise<RequestParams | void> | RequestParams | void;
+    customFetch?: typeof fetch;
+}
+
+export interface HttpResponse<D extends unknown, E extends unknown = unknown> extends Response {
+    data: D;
+    error: E;
+}
+
+type CancelToken = Symbol | string | number;
+
+export enum ContentType {
+    Json = "application/json",
+    FormData = "multipart/form-data",
+    UrlEncoded = "application/x-www-form-urlencoded",
+    Text = "text/plain",
+}
+
+@Injectable({ providedIn: 'root' })
+export class HttpClient<SecurityDataType = unknown> {
+    protected securityService = inject(SecurityService);
+    protected layoutService = inject(LayoutService);
+    public baseUrl: string = "<%~ apiConfig.baseUrl %>";
+    private securityData: SecurityDataType | null = null;
+    private securityWorker?: ApiConfig<SecurityDataType>["securityWorker"]  =
+      (securityData) => ({
+        headers: {
+          "Accept-language": this.layoutService.language()
+            ? this.layoutService.language()
+            : 'en',
+          "X-Timezone": this.layoutService.timeZone(),
+          Authorization: `Bearer ${securityData}`,
+        },
+      });
+    private abortControllers = new Map<CancelToken, AbortController>();
+    private customFetch = (...fetchParams: Parameters<typeof fetch>) => fetch(...fetchParams);
+
+    private baseApiParams: RequestParams = {
+        credentials: 'same-origin',
+        headers: {},
+        redirect: 'follow',
+        referrerPolicy: 'no-referrer',
+    }
+
+    constructor() {
+      this.securityService.getAccessToken().subscribe((token) => {
+        this.securityData = token;
+      });
+    }
+
+    public setSecurityData = (data: SecurityDataType | null) => {
+        this.securityData = data;
+    }
+
+    protected encodeQueryParam(key: string, value: any) {
+        const encodedKey = encodeURIComponent(key);
+        return `${encodedKey}=${encodeURIComponent(typeof value === "number" ? value : `${value}`)}`;
+    }
+
+    protected addQueryParam(query: QueryParamsType, key: string) {
+        return this.encodeQueryParam(key, query[key]);
+    }
+
+    protected addArrayQueryParam(query: QueryParamsType, key: string) {
+        const value = query[key];
+        return value.map((v: any) => this.encodeQueryParam(key, v)).join("&");
+    }
+
+    protected toQueryString(rawQuery?: QueryParamsType): string {
+        const query = rawQuery || {};
+        const keys = Object.keys(query).filter((key) => "undefined" !== typeof query[key]);
+        return keys
+                .map((key) =>
+                    Array.isArray(query[key])
+                    ? this.addArrayQueryParam(query, key)
+                    : this.addQueryParam(query, key),
+                )
+                .join("&");
+    }
+
+    protected addQueryParams(rawQuery?: QueryParamsType): string {
+        const queryString = this.toQueryString(rawQuery);
+        return queryString ? `?${queryString}` : "";
+    }
+
+    private contentFormatters: Record<ContentType, (input: any) => any> = {
+        [ContentType.Json]: (input:any) => input !== null && (typeof input === "object" || typeof input === "string") ? JSON.stringify(input) : input,
+        [ContentType.Text]: (input:any) => input !== null && typeof input !== "string" ? JSON.stringify(input) : input,
+        [ContentType.FormData]: (input: any) =>
+            Object.keys(input || {}).reduce((formData, key) => {
+                const property = input[key];
+                formData.append(
+                    key,
+                    property instanceof Blob ?
+                        property :
+                    typeof property === "object" && property !== null ?
+                        JSON.stringify(property) :
+                    `${property}`
+                );
+                return formData;
+            }, new FormData()),
+        [ContentType.UrlEncoded]: (input: any) => this.toQueryString(input),
+    }
+
+    protected mergeRequestParams(params1: RequestParams, params2?: RequestParams): RequestParams {
+        return {
+            ...this.baseApiParams,
+            ...params1,
+            ...(params2 || {}),
+            headers: {
+                ...(this.baseApiParams.headers || {}),
+                ...(params1.headers || {}),
+                ...((params2 && params2.headers) || {}),
+            },
+        };
+    }
+
+    protected createAbortSignal = (cancelToken: CancelToken): AbortSignal | undefined => {
+        if (this.abortControllers.has(cancelToken)) {
+            const abortController = this.abortControllers.get(cancelToken);
+            if (abortController) {
+                return abortController.signal;
+            }
+            return void 0;
+        }
+
+        const abortController = new AbortController();
+        this.abortControllers.set(cancelToken, abortController);
+        return abortController.signal;
+    }
+
+    public abortRequest = (cancelToken: CancelToken) => {
+        const abortController = this.abortControllers.get(cancelToken)
+
+        if (abortController) {
+            abortController.abort();
+            this.abortControllers.delete(cancelToken);
+        }
+    }
+
+    public request = async <T = any, E = any>({
+        body,
+        secure,
+        path,
+        type,
+        query,
+        format,
+        baseUrl,
+        cancelToken,
+        ...params
+<% if (config.unwrapResponseData) { %>
+    }: FullRequestParams): Promise<T> => {
+<% } else { %>
+    }: FullRequestParams): Promise<HttpResponse<T, E>> => {
+<% } %>
+        const secureParams = ((typeof secure === 'boolean' ? secure : this.baseApiParams.secure) && this.securityWorker && await this.securityWorker(this.securityData)) || {};
+        const requestParams = this.mergeRequestParams(params, secureParams);
+        const queryString = query && this.toQueryString(query);
+        const payloadFormatter = this.contentFormatters[type || ContentType.Json];
+        let responseFormat = format || requestParams.format;
+
+        return this.customFetch(
+        `${baseUrl || this.baseUrl || ""}${path}${queryString ? `?${queryString}` : ""}`,
+        {
+            ...requestParams,
+            headers: {
+            ...(requestParams.headers || {}),
+            ...(type && type !== ContentType.FormData ? { "Content-Type": type } : {}),
+            },
+            signal: (cancelToken ? this.createAbortSignal(cancelToken) : requestParams.signal) || null,
+            body: typeof body === "undefined" || body === null ? null : payloadFormatter(body),
+        }
+        ).then(async (response) => {
+            const r = response.clone() as HttpResponse<T, E>;
+            r.data = (null as unknown) as T;
+            r.error = (null as unknown) as E;
+
+            if (typeof E !== undefined && responseFormat === undefined)
+              responseFormat = 'json';
+
+            const data = !responseFormat ? r : await response[responseFormat]()
+                .then((data) => {
+                    if (r.ok) {
+                        r.data = data;
+                    } else {
+                        r.error = data;
+                    }
+                    return r;
+                })
+                .catch((e) => {
+                    r.error = e;
+                    return r;
+                });
+
+            if (cancelToken) {
+                this.abortControllers.delete(cancelToken);
+            }
+
+<% if (!config.disableThrowOnError) { %>
+            if (!response.ok) throw data;
+<% } %>
+<% if (config.unwrapResponseData) { %>
+            return data.data;
+<% } else { %>
+            return data;
+<% } %>
+        });
+    };
+}

package/templates/interface-data-contract.ejs

@@ -0,0 +1,10 @@
+<%
+const { contract, utils } = it;
+const { formatDescription, require, _ } = utils;
+%>
+export interface <%~ contract.name %> {
+  <% for (const field of contract.$content) { %>
+    <%~ includeFile('./object-field-jsdoc.ejs', { ...it, field }) %>
+    <%~ field.name %><%~ field.isRequired ? '' : '?' %>: <%~ field.value %><%~ field.isNullable ? ' | null' : ''%>;
+  <% } %>
+}

package/templates/object-field-jsdoc.ejs

@@ -0,0 +1,28 @@
+<%
+const { field, utils } = it;
+const { formatDescription, require, _ } = utils;
+
+const comments = _.uniq(
+    _.compact([
+        field.title,
+        field.description,
+        field.deprecated && ` * @deprecated`,
+        !_.isUndefined(field.format) && `@format ${field.format}`,
+        !_.isUndefined(field.minimum) && `@min ${field.minimum}`,
+        !_.isUndefined(field.maximum) && `@max ${field.maximum}`,
+        !_.isUndefined(field.pattern) && `@pattern ${field.pattern}`,
+        !_.isUndefined(field.example) &&
+        `@example ${_.isObject(field.example) ? JSON.stringify(field.example) : field.example}`,
+    ]).reduce((acc, comment) => [...acc, ...comment.split(/\n/g)], []),
+);
+%>
+<% if (comments.length === 1) { %>
+  /** <%~ comments[0] %> */
+<% } else if (comments.length) { %>
+  /**
+  <% comments.forEach(comment => { %>
+   * <%~ comment %>
+
+  <% }) %>
+   */
+<% } %>

package/templates/procedure-call.ejs

@@ -0,0 +1,100 @@
+<%
+const { utils, route, config } = it;
+const { requestBodyInfo, responseBodyInfo, specificArgNameResolver } = route;
+const { _, getInlineParseContent, getParseContent, parseSchema, getComponentByRef, require } = utils;
+const { parameters, path, method, payload, query, formData, security, requestParams } = route.request;
+const { type, errorType, contentTypes } = route.response;
+const { HTTP_CLIENT, RESERVED_REQ_PARAMS_ARG_NAMES } = config.constants;
+const routeDocs = includeFile("./route-docs", { config, route, utils });
+const queryName = (query && query.name) || "query";
+const pathParams = _.values(parameters);
+const pathParamsNames = _.map(pathParams, "name");
+
+const isFetchTemplate = config.httpClientType === HTTP_CLIENT.FETCH;
+
+const requestConfigParam = {
+    name: specificArgNameResolver.resolve(RESERVED_REQ_PARAMS_ARG_NAMES),
+    optional: true,
+    type: "RequestParams",
+    defaultValue: "{}",
+}
+
+const argToTmpl = ({ name, optional, type, defaultValue }) => `${name}${!defaultValue && optional ? '?' : ''}: ${type}${defaultValue ? ` = ${defaultValue}` : ''}`;
+
+const rawWrapperArgs = config.extractRequestParams ?
+    _.compact([
+        requestParams && {
+          name: pathParams.length ? `{ ${_.join(pathParamsNames, ", ")}, ...${queryName} }` : queryName,
+          optional: false,
+          type: getInlineParseContent(requestParams),
+        },
+        ...(!requestParams ? pathParams : []),
+        payload,
+        requestConfigParam,
+    ]) :
+    _.compact([
+        ...pathParams,
+        query,
+        payload,
+        requestConfigParam,
+    ])
+
+const wrapperArgs = _
+    // Sort by optionality
+    .sortBy(rawWrapperArgs, [o => o.optional])
+    .map(argToTmpl)
+    .join(', ')
+
+// RequestParams["type"]
+const requestContentKind = {
+    "JSON": "ContentType.Json",
+    "URL_ENCODED": "ContentType.UrlEncoded",
+    "FORM_DATA": "ContentType.FormData",
+    "TEXT": "ContentType.Text",
+}
+// RequestParams["format"]
+const responseContentKind = {
+    "JSON": '"json"',
+    "IMAGE": '"blob"',
+    "FORM_DATA": isFetchTemplate ? '"formData"' : '"document"'
+}
+
+const bodyTmpl = _.get(payload, "name") || null;
+const queryTmpl = (query != null && queryName) || null;
+const bodyContentKindTmpl = requestContentKind[requestBodyInfo.contentKind] || null;
+const responseFormatTmpl = responseContentKind[responseBodyInfo.success && responseBodyInfo.success.schema && responseBodyInfo.success.schema.contentKind] || null;
+const securityTmpl = security ? 'true' : null;
+
+const describeReturnType = () => {
+    if (!config.toJS) return "";
+
+    switch(config.httpClientType) {
+        case HTTP_CLIENT.AXIOS: {
+          return `Promise<AxiosResponse<${type}>>`
+        }
+        default: {
+          return `Promise<HttpResponse<${type}, ${errorType}>`
+        }
+    }
+}
+
+%>
+/**
+<%~ routeDocs.description %>
+
+ *<% /* Here you can add some other JSDoc tags */ %>
+
+<%~ routeDocs.lines %>
+
+ */
+<%~ route.routeName.usage %> = (<%~ wrapperArgs %>)<%~ config.toJS ? `: ${describeReturnType()}` : "" %> =>
+    <%~ config.singleHttpClient ? 'this.http.request' : 'this.request' %><<%~ type %>, <%~ errorType %>>({
+        path: `<%~ path %>`,
+        method: '<%~ _.upperCase(method) %>',
+        <%~ queryTmpl ? `query: ${queryTmpl},` : '' %>
+        <%~ bodyTmpl ? `body: ${bodyTmpl},` : '' %>
+        <%~ securityTmpl ? `secure: ${securityTmpl},` : '' %>
+        <%~ bodyContentKindTmpl ? `type: ${bodyContentKindTmpl},` : '' %>
+        <%~ responseFormatTmpl ? `format: ${responseFormatTmpl},` : '' %>
+        ...<%~ _.get(requestConfigParam, "name") %>,
+    })

package/templates/route-docs.ejs

@@ -0,0 +1,29 @@
+<%
+const { config, route, utils } = it;
+const { _, formatDescription, fmtToJSDocLine, pascalCase, require } = utils;
+const { raw, request, routeName } = route;
+
+const jsDocDescription = raw.summary ?
+    ` * @description ${formatDescription(raw.summary, true)}` :
+    fmtToJSDocLine('No description', { eol: false });
+const jsDocLines = _.compact([
+    _.size(raw.tags) && ` * @tags ${raw.tags.join(", ")}`,
+    ` * @name ${_.camelCase(routeName.usage)}`,
+    ` * @request ${_.upperCase(request.method)}:${raw.route}`,
+    raw.deprecated && ` * @deprecated`,
+    routeName.duplicate && ` * @originalName ${routeName.original}`,
+    routeName.duplicate && ` * @duplicate`,
+    request.security && ` * @secure`,
+    ...(config.generateResponses && raw.responsesTypes.length
+    ? raw.responsesTypes.map(
+        ({ type, status, description, isSuccess }) =>
+            ` * @response \`${status}\` \`${_.replace(_.replace(type, /\/\*/g, "\\*"), /\*\//g, "*\\")}\` ${description}`,
+        )
+    : []),
+]).map(str => str.trimEnd()).join("\n");
+
+return {
+  description: jsDocDescription,
+  lines: jsDocLines,
+}
+%>

package/templates/route-name.ejs

@@ -0,0 +1,42 @@
+<%
+const { routeInfo, utils } = it;
+const {
+  operationId,
+  method,
+  route,
+  moduleName,
+  responsesTypes,
+  description,
+  tags,
+  summary,
+  pathArgs,
+} = routeInfo;
+const { _, fmtToJSDocLine, require } = utils;
+
+const methodAliases = {
+  get: (pathName, hasPathInserts) =>  _.camelCase(`${pathName}`),
+  post: (pathName, hasPathInserts) => _.camelCase(`${pathName}`),
+  put: (pathName, hasPathInserts) => _.camelCase(`${pathName}`),
+  patch: (pathName, hasPathInserts) => _.camelCase(`${pathName}`),
+  delete: (pathName, hasPathInserts) => _.camelCase(`${pathName}`),
+};
+
+const createCustomOperationId = (method, route, moduleName) => {
+  const hasPathInserts = /\{(\w){1,}\}$/g.test(route);
+  const splittedRouteBySlash = _.compact(_.replace(route, /\{(\w){1,}\}/g, "").split("/"));
+  const routeParts = (splittedRouteBySlash.length > 1
+    ? splittedRouteBySlash.splice(1)
+    : splittedRouteBySlash
+  ).join("_");
+  return routeParts.length > 3 && methodAliases[method]
+    ? methodAliases[method](routeParts, hasPathInserts)
+    : _.camelCase(_.lowerCase(method) + "_" + [moduleName].join("_")) || "index";
+};
+
+if (operationId)
+  return _.camelCase(operationId);
+if (route === "/")
+  return _.camelCase(`${_.lowerCase(method)}Root`);
+
+return createCustomOperationId(method, route, moduleName);
+%>

package/templates/route-type.ejs

@@ -0,0 +1,23 @@
+<%
+const { route, utils, config } = it;
+const { _, pascalCase, require } = utils;
+const { query, payload, pathParams, headers } = route.request;
+
+const routeDocs = includeFile("./route-docs", { config, route, utils });
+const routeNamespace = pascalCase(route.routeName.usage);
+
+%>
+
+/**
+<%~ routeDocs.description %>
+
+<%~ routeDocs.lines %>
+
+*/
+export namespace <%~ routeNamespace %> {
+  export type RequestParams = <%~ (pathParams && pathParams.type) || '{}' %>;
+  export type RequestQuery = <%~ (query && query.type) || '{}' %>;
+  export type RequestBody = <%~ (payload && payload.type) || 'never' %>;
+  export type RequestHeaders = <%~ (headers && headers.type) || '{}' %>;
+  export type ResponseBody = <%~ route.response.type %>;
+}

package/templates/route-types.ejs

@@ -0,0 +1,18 @@
+<%
+const { utils, config, route, modelTypes } = it;
+const { _, pascalCase } = utils;
+const { routes, moduleName } = route;
+const dataContracts = config.modular ? _.map(modelTypes, "name") : [];
+
+%>
+<% if (dataContracts.length) { %>
+import { <%~ dataContracts.join(", ") %> } from "./<%~ config.fileNames.dataContracts %>"
+<% } %>
+
+export namespace <%~ pascalCase(moduleName) %> {
+    <% for (const route of routes) { %>
+
+        <%~ includeFile('./route-type.ejs', { ...it, route }) %>
+
+    <% } %>
+}

package/templates/type-data-contract.ejs

@@ -0,0 +1,15 @@
+<%
+const { contract, utils } = it;
+const { formatDescription, require, _ } = utils;
+
+%>
+<% if (contract.$content.length) { %>
+export type <%~ contract.name %> = {
+  <% for (const field of contract.$content) { %>
+    <%~ includeFile('./object-field-jsdoc.ejs', { ...it, field }) %>
+    <%~ field.field %>;
+  <% } %>
+}<%~ utils.isNeedToAddNull(contract) ? ' | null' : ''%>
+<% } else { %>
+export type <%~ contract.name %> = Record<string, any>;
+<% } %>