d5-api-initializer 0.0.2-alpha.0 → 0.0.2-alpha.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "d5-api-initializer",
-  "version": "0.0.2-alpha.0",
+  "version": "0.0.2-alpha.2",
   "license": "MIT",
   "dependencies": {},
   "main": "publish/cjs/d5-api-initializer",
@@ -14,6 +14,9 @@
       "default": "./publish/cjs/d5-api-initializer.cjs"
     }
   },
+  "files": [
+    "publish"
+  ],
   "engines": {
     "node": ">=18"
   },

package/publish/d5-api-initializer.d.ts

@@ -1,3 +1,100 @@
+declare namespace jsWapi {
+    type JSWapiInvoker = {
+        setFilters(filters: any): JSWapiInvoker;
+        setParams(params: any): JSWapiInvoker;
+        setRowsPerPage(number: number): JSWapiInvoker;
+        setPage(number: number): JSWapiInvoker;
+        setPagesPredict(number: number): JSWapiInvoker;
+        setColumns(columns: string[]): JSWapiInvoker;
+        addColumns(columns: string[]): JSWapiInvoker;
+        setSorts(sorts: string[]): JSWapiInvoker;
+        addSorts(sorts: string[]): JSWapiInvoker;
+        setAggregatedColumns(columns: any): JSWapiInvoker;
+        putAggregatedColumns(columns: any): JSWapiInvoker;
+        setNestedColumns(columns: any): JSWapiInvoker;
+        putNestedColumns(columns: any): JSWapiInvoker;
+        setHierarchy(parentColumn: string, requestKind?: number): JSWapiInvoker;
+        setSrcRequest(srcRequest: any): JSWapiInvoker;
+        setFirstRows(number: number): JSWapiInvoker;
+        setOperRightCheck(check: boolean): JSWapiInvoker;
+        putRequest(objectName: string, req: any): JSWapiInvoker;
+        setRequest(req: any): JSWapiInvoker;
+        getRequest(objectName?: string): Record<string, any>[];
+        getSrcRequest(): Record<string, any>[];
+        getFirstRows(): number;
+        invoke(): JSWapiResponse;
+    };
+    type JSWapiRequest = {
+        getColumns(): string[];
+        getSorts(): string[];
+        getAggregatedColumns(): any;
+        getNestedColumns(): any;
+        getFilters(): any;
+        getParams(): any;
+        getUserId(): number;
+        getPage(): number;
+        getFirstRows(): number;
+        getRowsPerPage(): number;
+        getLanguage(): string;
+        getRequest(object: string): Record<string, any>[];
+        getFilter(filterName: string): any;
+        getFilterEqualOneValue(filterName: string): any;
+        getParam(filterName: string): any;
+        getExcelFileAsJson(fileRequestId: string): any;
+        getFileAsString(fileRequestId: string): any;
+        setColumns(columns: string[]): JSWapiRequest;
+        setSorts(sorts: string[]): JSWapiRequest;
+        setAggregatedColumns(columns: any): JSWapiRequest;
+        setNestedColumns(columns: any): JSWapiRequest;
+        setFilters(filters: any): JSWapiRequest;
+        setParams(params: any): JSWapiRequest;
+        setPage(number: number): JSWapiRequest;
+        setRowsPerPage(number: number): JSWapiRequest;
+        setFirstRows(number: number): JSWapiRequest;
+        setRequest(request: any): JSWapiRequest;
+        setHierarchy(parentColumn: string, requestKind?: number): JSWapiRequest;
+    };
+    type JSWapiResponse = {};
+    type BinaryDataStream = unknown;
+    interface JSWapiHttpResponse {
+        getStatusCode(): number;
+        getBody(): string;
+        getBodyAsInputStream(): BinaryDataStream;
+        getHeader(name: string): string;
+        isSuccessful(): boolean;
+    }
+    type IHttpCallback = (resp: JSWapiHttpResponse) => any;
+    interface JSWapiHttp {
+        setHeader(key: string, value: string): JSWapiHttp;
+        setTimeout(milliseconds: number): JSWapiHttp;
+        GET(cb: IHttpCallback): any;
+        POST(body: string, cb: IHttpCallback): any;
+        PUT(body: string, cb: IHttpCallback): any;
+        PATCH(body: string, cb: IHttpCallback): any;
+    }
+    type JSWapiMeta<Params = {}> = {
+        parameters?: Params;
+        externalObject?: string;
+        objectName: string;
+        externalFieldsMap?: Record<string, string>;
+    };
+    interface JSWapiObject {
+        getName(): string;
+        newJSWapiHttp(url: string): JSWapiHttp;
+        putJSWapiOper(operation: string, callback: (request: JSWapiRequest, response: JSWapiResponse) => void): void;
+    }
+    function putJSWapiObject(objectName: string, init: (object: JSWapiObject) => void): void;
+    interface JSWapiEngine {
+        getExternalName(): string;
+        getExternalObjectFields(): Record<string, string>;
+        getExternalSystemParameters(): Record<string, any>;
+        getName(): string;
+        newJSWapiHttp(url: string): JSWapiHttp;
+        putJSWapiOper(operation: string, callback: (jsWapiRequest: JSWapiRequest, jsWapiResponse: JSWapiResponse) => void): void;
+    }
+    function setJSWapiEngine(init: (object: JSWapiEngine) => void): void;
+}
+
 declare class ApiHttpResponse {
     private readonly _jsWapiHttpResponse;
     constructor(jsWapiHttpResponse: jsWapi.JSWapiHttpResponse);

package/build.js

@@ -1,14 +0,0 @@
-require('dotenv').config();
-const fs = require('fs');
-const path = require('path');
-const {zipDirectories} = require('./zip-build');
-
-
-const archivePath = path.resolve(__dirname, 'build/initializer.zip');
-
-fs.mkdirSync('build', {recursive: true});
-
-zipDirectories([{
-  'source': path.resolve(__dirname, 'dist'),
-  'put_at_root': true
-}], archivePath);

package/scripts/releaseChangelog.mjs

@@ -1,50 +0,0 @@
-import fs from 'fs';
-import {execSync} from 'child_process';
-import {Command} from 'commander';
-
-
-const program = new Command();
-
-program.name('changelog');
-
-program.command('changelog')
-  .option('-p, --prev-tag <string>', 'previous version')
-  .action(async ({prevTag}) => {
-    // Отримати останній тег
-    const lastTag = execSync('git describe --tags --abbrev=0 --match "v*"').toString().trim();
-
-    // Отримати список комітів з останнього тегу
-    const commits = execSync(`git log ${prevTag}..${lastTag} --format=\"hash:%h;;author:%an;;title:%s\"`).toString().trim().split('\n').map(commit => {
-      const [hash, author, title] = commit.split(';;');
-      return {
-        hash: hash.slice('hash:'.length),
-        author: author.slice('author:'.length),
-        title: title.slice('title:'.length),
-      };
-    }).filter(({title}) => title.startsWith('[LOG]'));
-
-    console.log(lastTag);
-    console.log(commits);
-
-    // Сформувати markdown список
-    const markdown = commits.map(({title, hash, author}) => {
-      return `- ${title.slice('[LOG]'.length)} - @${author} [View](https://bitbucket.org/macc-systems/d5-cli/commits/${hash})`;
-    }).join('\n');
-
-    // Додати список комітів до CHANGELOG.md
-    const changelog = fs.readFileSync('CHANGELOG.md', 'utf-8');
-    const nowFormatted = new Date().toLocaleDateString('en-US', {
-      month: 'short',
-      day: 'numeric',
-      year: 'numeric',
-    });
-    const newChangelog = `## _${lastTag}_\n\n${nowFormatted}\n\n${markdown}\n\n${changelog}`;
-
-    fs.writeFileSync('CHANGELOG.md', newChangelog);
-
-    console.log('Зміни успішно записані в CHANGELOG.md');
-
-  });
-
-
-program.parse();

package/src/api-interfaces.ts

@@ -1,43 +0,0 @@
-import ApiCore from './classes/ApiCore';
-import ApiRequest from './classes/ApiRequest';
-import ApiResponse from './classes/ApiResponse';
-import ApiHttpResponse from './classes/ApiHttpResponse';
-
-export interface IFilterValue {
-    '='?: string | number | Array<string | number>;
-    '>'?: string | number | Array<string | number>;
-    '>='?: string | number | Array<string | number>;
-    '<'?: string | number | Array<string | number>;
-    '<='?: string | number | Array<string | number>;
-    '!='?: string | number | Array<string | number>;
-    'between'?: string | number | Array<string | number>;
-    'like'?: string | number | Array<string | number>;
-    '%'?: string | number | Array<string | number>;
-}
-
-export interface IFilter {
-    [fieldName: string]: IFilterValue;
-}
-
-export interface IFiltersCollection {
-    [property: string]: IFilterValue | IFilter[];
-}
-
-export interface IMappedCollection {
-    [name: string]: any;
-}
-
-type IApiOperation<MetaParams> = (apiCore: ApiCore, apiRequest: ApiRequest, apiResponse: ApiResponse, meta?: jsWapi.JSWapiMeta<MetaParams>) => void;
-
-export interface IApiOperations<MetaParams = Record<string, any>> {
-    [key: string]: IApiOperation<MetaParams>;
-}
-
-export type IHttpCallback = (apiHttpResponse: ApiHttpResponse) => any | void
-
-
-export enum LanguageCode {
-    ua = 'ua',
-    ru = 'ru',
-    en = 'eng',
-}

package/src/classes/ApiCore.ts

@@ -1,74 +0,0 @@
-import ApiHttpRequest from './ApiHttpRequest';
-import ApiInvoker from './ApiInvoker';
-import ApiRequest from './ApiRequest';
-import UserMessages from './UserMessages';
-import {LanguageCode} from '../api-interfaces';
-import ApiObjectCollectionIterator from "./ApiObjectCollectionIterator";
-
-type HTTPSender = {
-  newJSWapiHttp(url: string): jsWapi.JSWapiHttp
-}
-
-export default class ApiCore {
-  private readonly httpSender: HTTPSender;
-  private readonly _request: ApiRequest;
-
-  constructor({http, request}: { http: HTTPSender, request: ApiRequest }) {
-    this.httpSender = http;
-    this._request = request;
-  }
-
-  /**
-   * Переводит и форматирует строку из словаря переводов согласно текущего языка приложения.
-   * @param msgKey
-   * @param params
-   *
-   * @example
-   *  {
-   *    ...
-   *    "myKey": 'some text with {0}'
-   *    ...
-   *  }
-   *  t('myKey', ['placeholder text']) // 'some text with placeholder text'
-   */
-  t(msgKey: string, params?: string[]): string {
-    UserMessages.lang = this._request.lang || LanguageCode.ua;
-    return UserMessages.format(msgKey, params);
-  }
-
-  newHttpRequest(url: string): ApiHttpRequest {
-    return new ApiHttpRequest(this.httpSender.newJSWapiHttp(url));
-  }
-
-  newApiInvoker(objectName: string, operName: string): ApiInvoker {
-    return new ApiInvoker(this._request.newJSWapiInvoker(objectName, operName), objectName);
-  }
-
-  newApiObjectCollectionIterator(objectName: string): ApiObjectCollectionIterator {
-    return new ApiObjectCollectionIterator({
-      invoker: this.newApiInvoker(objectName, 'List')
-    })
-  }
-
-  newApiException(message: string, code?: string | number): Error {
-    if (code) {
-      // @ts-ignore
-      return new JSWapiException(code.toString(), message);
-    }
-
-    // @ts-ignore
-    return new JSWapiException(message);
-  }
-
-  /*
-  * Will be implemented later
-  *
-  newApiJoinInvoker(alias: string, request: ApiRequest | ApiInvoker): ApiJoinInvoker {
-      if (request instanceof ApiRequest) {
-          return new ApiJoinInvoker(this._jsWapiRequest.newJSWapiJoinInvoker(alias, request._jsWapiRequest));
-      } else if (request instanceof ApiInvoker) {
-          return new ApiJoinInvoker(this._jsWapiRequest.newJSWapiJoinInvoker(alias, request._jsWapiInvoker));
-      }
-  }
-   */
-}

package/src/classes/ApiHttpRequest.ts

@@ -1,68 +0,0 @@
-import ApiHttpResponse from './ApiHttpResponse';
-import {IHttpCallback, IMappedCollection} from '../api-interfaces';
-
-export default class ApiHttpRequest {
-  private _jsWapiHttp: jsWapi.JSWapiHttp;
-
-  constructor(jsWapiHttp: jsWapi.JSWapiHttp) {
-    this._jsWapiHttp = jsWapiHttp;
-  }
-
-  set headers(headers: IMappedCollection) {
-    for (const headersKey in headers) {
-      this._jsWapiHttp = this._jsWapiHttp.setHeader(headersKey, JSON.stringify(headers[headersKey]));
-    }
-  }
-
-  set timeout(milliseconds: number) {
-    this._jsWapiHttp = this._jsWapiHttp.setTimeout(milliseconds);
-  }
-
-  setHeader(name: string, value: any): ApiHttpRequest {
-    this._jsWapiHttp = this._jsWapiHttp.setHeader(name, ''.concat(value));
-
-    return this;
-  }
-
-  setHeaders(headers: IMappedCollection): ApiHttpRequest {
-    for (const headersKey in headers) {
-      this._jsWapiHttp = this._jsWapiHttp.setHeader(headersKey, ''.concat(headers[headersKey]));
-    }
-
-    return this;
-  }
-
-  setTimeout(milliseconds: number): ApiHttpRequest {
-    this._jsWapiHttp = this._jsWapiHttp.setTimeout(milliseconds);
-
-    return this;
-  }
-
-  GET(callback?: IHttpCallback): ApiHttpResponse | any | void {
-    return this._jsWapiHttp.GET(this._getWrappedCallback(callback));
-  }
-
-  POST(requestBody: IMappedCollection, callback?: IHttpCallback): ApiHttpResponse | any | void {
-    return this._jsWapiHttp.POST(JSON.stringify(requestBody), this._getWrappedCallback(callback));
-  }
-
-  PUT(requestBody: IMappedCollection, callback?: IHttpCallback): ApiHttpResponse | any | void {
-    return this._jsWapiHttp.PUT(JSON.stringify(requestBody), this._getWrappedCallback(callback));
-  }
-
-  PATCH(requestBody: IMappedCollection, callback: IHttpCallback): ApiHttpResponse | any | void {
-    return this._jsWapiHttp.PATCH(JSON.stringify(requestBody), this._getWrappedCallback(callback));
-  }
-
-  private _getWrappedCallback(callback: IHttpCallback) {
-    /*
-    Wraps this IHttpCallback with simple callback, which is passed to native Wapi,
-    to gain access to ApiHttpResponse methods while processing response in callback
-    */
-    return (res: any) => {
-      if (callback) {
-        return callback(new ApiHttpResponse(res));
-      }
-    };
-  }
-}

package/src/classes/ApiHttpResponse.ts

@@ -1,27 +0,0 @@
-export default class ApiHttpResponse {
-  private readonly _jsWapiHttpResponse: jsWapi.JSWapiHttpResponse;
-
-  constructor(jsWapiHttpResponse: jsWapi.JSWapiHttpResponse) {
-    this._jsWapiHttpResponse = jsWapiHttpResponse;
-  }
-
-  get statusCode(): number {
-    return this._jsWapiHttpResponse.getStatusCode();
-  }
-
-  get body(): string {
-    return this._jsWapiHttpResponse.getBody();
-  }
-
-  get bodyAsStream(): jsWapi.BinaryDataStream {
-    return this._jsWapiHttpResponse.getBodyAsInputStream();
-  }
-
-  getHeader(name: string): string {
-    return this._jsWapiHttpResponse.getHeader(name);
-  }
-
-  isSuccessful(): boolean {
-    return this._jsWapiHttpResponse.isSuccessful();
-  }
-}

package/src/classes/ApiInvoker.ts

@@ -1,199 +0,0 @@
-import ApiResponse from './ApiResponse';
-import {IFiltersCollection, IMappedCollection} from '../api-interfaces';
-
-
-export interface IInvoker<T> {
-  setColumns(columns: string[]): T;
-  setFilters(filters: IFiltersCollection): T;
-  setSorts(sorts: string[]): T;
-  addColumns(columns: string[]): T;
-  addSorts(sorts: string[]): T;
-  objectName: string;
-}
-
-export default class ApiInvoker implements IInvoker<ApiInvoker>{
-  public _jsWapiInvoker: jsWapi.JSWapiInvoker;
-  protected readonly _objectName: string;
-
-  constructor(jsWapiInvoker: jsWapi.JSWapiInvoker, objectName: string) {
-    this._jsWapiInvoker = jsWapiInvoker;
-    this._objectName = objectName;
-  }
-
-  /* ----------------------------Accessors---------------------------- */
-  get objectName(): string {
-    return this._objectName;
-  }
-
-  set filters(filters: IFiltersCollection) {
-    this._jsWapiInvoker = this._jsWapiInvoker.setFilters(filters);
-  }
-
-  set params(params: IMappedCollection) {
-    this._jsWapiInvoker = this._jsWapiInvoker.setParams(params);
-  }
-
-  set rowsPerPage(amount: number) {
-    this._jsWapiInvoker = this._jsWapiInvoker.setRowsPerPage(amount);
-  }
-
-  set page(number: number) {
-    this._jsWapiInvoker = this._jsWapiInvoker.setPage(number);
-  }
-
-  set pagesPredict(amount: number) {
-    this._jsWapiInvoker = this._jsWapiInvoker.setPagesPredict(amount);
-  }
-
-  set request(request: IMappedCollection | any[]) {
-    if (Array.isArray(request)) {
-      this._jsWapiInvoker = this._jsWapiInvoker.putRequest(this._objectName, request);
-    } else {
-      this._jsWapiInvoker = this._jsWapiInvoker.setRequest(request);
-    }
-  }
-
-  get request() {
-    return this._jsWapiInvoker.getRequest();
-  }
-
-  set columns(columns: string[]) {
-    this._jsWapiInvoker = this._jsWapiInvoker.setColumns(columns);
-  }
-
-  set sorts(sorts: string[]) {
-    this._jsWapiInvoker = this._jsWapiInvoker.setSorts(sorts);
-  }
-
-  set aggregatedColumns(aggregatedColumns: IMappedCollection) {
-    this._jsWapiInvoker = this._jsWapiInvoker.setAggregatedColumns(aggregatedColumns);
-  }
-
-  set nestedColumns(nestedColumns: IMappedCollection) {
-    this._jsWapiInvoker = this._jsWapiInvoker.setNestedColumns(nestedColumns);
-  }
-
-  /* -----------------------------Setters----------------------------- */
-  setHierarchy(parentColumn: string, requestKind?: number) {
-    this._jsWapiInvoker = this._jsWapiInvoker.setHierarchy(parentColumn, requestKind);
-    return this;
-  }
-
-  setFilters(filters: IFiltersCollection): ApiInvoker {
-    this.filters = filters;
-
-    return this;
-  }
-
-  setParams(params: IMappedCollection): ApiInvoker {
-    this.params = params;
-    return this;
-  }
-
-  setPage(number: number): ApiInvoker {
-    this.page = number;
-    return this;
-  }
-
-  setRowsPerPage(amount: number): ApiInvoker {
-    this.rowsPerPage = amount;
-
-    return this;
-  }
-
-  setPagesPredict(amount: number): ApiInvoker {
-    this.pagesPredict = amount;
-
-    return this;
-  }
-
-  setRequest(request: IMappedCollection | any[]): ApiInvoker {
-    this.request = request;
-
-    return this;
-  }
-
-  getRequest(requestName: string): IMappedCollection[] {
-    return this._jsWapiInvoker.getRequest(requestName);
-  }
-
-  setSrcRequest(srcRequest: IMappedCollection): ApiInvoker {
-    this._jsWapiInvoker = this._jsWapiInvoker.setSrcRequest(srcRequest);
-    return this;
-  }
-
-  getSrcRequest(): Record<string, any> {
-    throw new Error('not implemented');
-    return this._jsWapiInvoker.getSrcRequest();
-  }
-
-  setColumns(columns: string[]): ApiInvoker {
-    this.columns = columns;
-
-    return this;
-  }
-
-  setAggregatedColumns(aggregatedColumns: IMappedCollection): ApiInvoker {
-    this.aggregatedColumns = aggregatedColumns;
-
-    return this;
-  }
-
-  setNestedColumns(nestedColumns: IMappedCollection): ApiInvoker {
-    this.nestedColumns = nestedColumns;
-
-    return this;
-  }
-
-  setSorts(sorts: string[]): ApiInvoker {
-    this.sorts = sorts;
-
-    return this;
-  }
-
-  setFirstRows(firstRows: number) {
-    this._jsWapiInvoker.setFirstRows(firstRows);
-
-    return this;
-  }
-
-  setOperRightCheck(check: boolean) {
-    this._jsWapiInvoker.setOperRightCheck(check);
-
-    return this;
-  }
-
-  getFirstRows(): number {
-    return this._jsWapiInvoker.getFirstRows();
-  }
-
-  /* -----------------------------Adders------------------------------ */
-  addColumns(columns: string[]): ApiInvoker {
-    this._jsWapiInvoker = this._jsWapiInvoker.addColumns(columns);
-
-    return this;
-  }
-
-  addAggregatedColumns(aggregatedColumns: IMappedCollection): ApiInvoker {
-    this._jsWapiInvoker = this._jsWapiInvoker.putAggregatedColumns(aggregatedColumns);
-
-    return this;
-  }
-
-  addNestedColumns(nestedColumns: IMappedCollection): ApiInvoker {
-    this._jsWapiInvoker = this._jsWapiInvoker.putNestedColumns(nestedColumns);
-
-    return this;
-  }
-
-  addSorts(sorts: string[]): ApiInvoker {
-    this._jsWapiInvoker = this._jsWapiInvoker.addSorts(sorts);
-
-    return this;
-  }
-
-  /* ------------------------------Other------------------------------ */
-  invoke(): ApiResponse {
-    return new ApiResponse(this._jsWapiInvoker.invoke(), this._objectName);
-  }
-}

package/src/classes/ApiJoinInvoker.ts

@@ -1,9 +0,0 @@
-export default class ApiJoinInvoker {
-    readonly _jsWapiJoinInvoker: any;
-
-    constructor(jsWapiJoinInvoker: any) {
-        this._jsWapiJoinInvoker = jsWapiJoinInvoker;
-    }
-
-    //TODO: implement methods.
-}

package/src/classes/ApiObjectCollectionIterator.ts

@@ -1,63 +0,0 @@
-import ApiResponse from "./ApiResponse";
-import ApiInvoker, {IInvoker} from "./ApiInvoker";
-import {IFiltersCollection} from "../api-interfaces";
-
-export default class ApiObjectCollectionIterator implements IInvoker<ApiObjectCollectionIterator> {
-    private _invoker: ApiInvoker;
-
-    constructor({invoker}: {invoker: ApiInvoker}) {
-        this._invoker = invoker;
-    }
-
-    get objectName(): string {
-        return this._invoker.objectName
-    }
-
-    /* -----------------------------Setters----------------------------- */
-    setColumns(columns: string[]): ApiObjectCollectionIterator {
-        this._invoker.setColumns(columns)
-        return this;
-    }
-
-    setFilters(filters: IFiltersCollection): ApiObjectCollectionIterator {
-        this._invoker.setFilters(filters)
-        return this;
-    }
-
-    setSorts(sorts: string[]): ApiObjectCollectionIterator {
-        this._invoker.setSorts(sorts)
-        return this;
-    }
-
-    /* -----------------------------Adders------------------------------ */
-    addSorts(sorts: string[]): ApiObjectCollectionIterator {
-        this._invoker.addSorts(sorts);
-        return this;
-    }
-
-    addColumns(columns: string[]): ApiObjectCollectionIterator {
-        this._invoker.addColumns(columns);
-        return this;
-    }
-
-    /* ------------------------------Other------------------------------ */
-    *invoke(): Generator<ApiResponse> {
-        let data = null,
-            pageCount = 1;
-        let lastPage = false
-        const rowsPerPage = 100;
-        while (!lastPage) {
-            this._invoker.page = pageCount;
-            this._invoker.rowsPerPage = rowsPerPage;
-            data = new ApiResponse(this._invoker.invoke(), this.objectName).getResponse();
-            pageCount++;
-            if(Array.isArray(data)) {
-                for (let i = 0; i < data.length; i++) {
-                    yield data[i];
-                }
-            }
-            lastPage = data.length < rowsPerPage;
-        }
-    }
-
-}