d5-api-initializer 0.0.2-alpha.0

package/src/classes/ApiRequest.ts

@@ -0,0 +1,337 @@
+import ApiResponse from './ApiResponse';
+import {IMappedCollection, IFiltersCollection, LanguageCode} from '../api-interfaces';
+import UserMessages from './UserMessages';
+import ApiInvoker from "./ApiInvoker";
+
+export default class ApiRequest {
+  private _jsWapiRequest: any;
+  private readonly _objectName: string;
+
+  constructor(jsWapiRequest: any, objectName: string) {
+    this._jsWapiRequest = jsWapiRequest;
+    this._objectName = objectName;
+  }
+
+  /* ----------------------------Accessors---------------------------- */
+  get objectName(): string {
+    return this._objectName;
+  }
+
+  get columns(): string[] {
+    return this._jsWapiRequest.getColumns();
+  }
+
+  get aggregatedColumns(): IMappedCollection {
+    return this._jsWapiRequest.getAggregatedColumns();
+  }
+
+  get nestedColumns(): IMappedCollection {
+    return this._jsWapiRequest.getNestedColumns();
+  }
+
+  get filters(): IFiltersCollection {
+    return this._jsWapiRequest.getFilters();
+  }
+
+  get params(): IMappedCollection {
+    return this._jsWapiRequest.getParams();
+  }
+
+  get request(): IMappedCollection | Array<IMappedCollection> {
+    return this._jsWapiRequest.getRequest(this._objectName);
+  }
+
+  get userId(): number {
+    return this._jsWapiRequest.getUserId();
+  }
+
+  get page(): number {
+    return this._jsWapiRequest.getPage();
+  }
+
+  get rowsPerPage(): number {
+    return this._jsWapiRequest.getRowsPerPage();
+  }
+
+  get sorts(): string[] {
+    return this._jsWapiRequest.getSorts();
+  }
+
+  get lang(): LanguageCode {
+    return this._jsWapiRequest.getLanguage();
+  }
+
+  set columns(columns: string[]) {
+    this._jsWapiRequest = this._jsWapiRequest.setColumns(columns);
+  }
+
+  set aggregatedColumns(columns: IMappedCollection) {
+    this._jsWapiRequest = this._jsWapiRequest.setAggregatedColumns(columns);
+  }
+
+  set nestedColumns(columns: IMappedCollection) {
+    this._jsWapiRequest = this._jsWapiRequest.setNestedColumns(columns);
+  }
+
+  set filters(filters: IFiltersCollection) {
+    this._jsWapiRequest = this._jsWapiRequest.setFilters(filters);
+  }
+
+  set params(params: IMappedCollection) {
+    this._jsWapiRequest = this._jsWapiRequest.setParams(params);
+  }
+
+  set sorts(sorts: string[]) {
+    this._jsWapiRequest = this._jsWapiRequest.setSorts(sorts);
+  }
+
+  set page(number: number) {
+    this._jsWapiRequest = this._jsWapiRequest.setPage(number);
+  }
+
+  set rowsPerPage(amount: number) {
+    this._jsWapiRequest = this._jsWapiRequest.setRowsPerPage(amount);
+  }
+
+  /* -----------------------------Getters----------------------------- */
+  getFilter(filterName: string): any {
+    return this._jsWapiRequest.getFilter(filterName);
+  }
+
+  /**
+   * Вернуть значение фильтра типа "равно".
+   * Возможные варианты:
+   *     "поле": "значение"
+   *     "поле": {"=": "значение"}
+   *     "поле": ["значение"]
+   *     "поле": {"=": [123]}
+   * Это чтобы не парсить каждый раз все эти варианты.
+   *
+   * Работает только для условия "равно", для други возвращает null!!!!
+   */
+  getFilterValue(fieldName: string): any {
+    return this._jsWapiRequest.getFilterEqualOneValue(fieldName)
+  }
+
+  getParam(paramName: string): any {
+    return this._jsWapiRequest.getParam(paramName);
+  }
+
+  getExcelFileAsJson(fileRequestId: string): any {
+    return this._jsWapiRequest.getExcelFileAsJson(fileRequestId);
+  }
+
+  getFileAsString(fileRequestId: string): string {
+    return this._jsWapiRequest.getFileAsString(fileRequestId);
+  }
+
+  getFilesListAsString(filesRequestIds: string[] | number[]): IMappedCollection {
+    return this._jsWapiRequest.getMultiFileAsString(...this._getWithStringifiedElements(filesRequestIds));
+  }
+
+  getExcelFilesListAsJson(filesRequestIds: string[] | number[]): IMappedCollection {
+    return this._jsWapiRequest.getMultiExcelFileAsJson(...this._getWithStringifiedElements(filesRequestIds));
+  }
+
+  getRequest(requestName: string): IMappedCollection[] {
+    return this._jsWapiRequest.getRequest(requestName);
+  }
+
+  /* -----------------------------Setters----------------------------- */
+  setHierarchy(parentColumn: string, requestKind?: number) {
+    this._jsWapiRequest = this._jsWapiRequest.setHierarchy(parentColumn, requestKind);
+    return this;
+  }
+
+  setColumns(columns: string[]) {
+    this.columns = columns;
+
+    return this;
+  }
+
+  setNestedColumns(nestedColumns: IMappedCollection) {
+    this.nestedColumns = nestedColumns;
+
+    return this;
+  }
+
+  setAggregatedColumns(aggregatedColumns: IMappedCollection) {
+    this.aggregatedColumns = aggregatedColumns;
+
+    return this;
+  }
+
+  setFilters(filters: IFiltersCollection): ApiRequest {
+    this.filters = filters;
+
+    return this;
+  }
+
+  setSorts(sorts: string[]) {
+    this.sorts = sorts;
+
+    return this;
+  }
+
+  setParams(params: IMappedCollection): ApiRequest {
+    this.params = params;
+
+    return this;
+  }
+
+  setPage(number: number): ApiRequest {
+    this.page = number;
+
+    return this;
+  }
+
+  setRowsPerPage(amount: number): ApiRequest {
+    this.rowsPerPage = amount;
+
+    return this;
+  }
+
+  setRequest(request: IMappedCollection | any[]): ApiRequest {
+    if (Array.isArray(request)) {
+      this._jsWapiRequest =  this._jsWapiRequest.putRequest(this._objectName, request);
+    } else {
+      this._jsWapiRequest =  this._jsWapiRequest.setRequest(request);
+    }
+    return this;
+  }
+
+  setFirstRows(firstRows: number) {
+    this._jsWapiRequest.setFirstRows(firstRows);
+
+    return this;
+  }
+
+  getFirstRows(): number {
+    return this._jsWapiRequest.getFirstRows();
+  }
+
+
+  addSorts(sorts: string[]): ApiRequest {
+    this._jsWapiRequest = this._jsWapiRequest.addSorts(sorts);
+
+    return this;
+  }
+
+  addColumns(columns: string[]): ApiRequest {
+    this._jsWapiRequest = this._jsWapiRequest.addColumns(columns);
+
+    return this;
+  }
+
+  addAggregatedColumns(columns: IMappedCollection): ApiRequest {
+    this._jsWapiRequest = this._jsWapiRequest.putAggregatedColumns(columns);
+
+    return this;
+  }
+
+  /**
+   * @link http://d5.develop.erp-director.com/userscript-docs/docs/server_scripts/api-request/api-request#addnestedcolumnscolumns
+   * @example
+   * apiRequest.addNestedColumns({
+   *     'AuthorsNested': {
+   *         'Columns': ['ID', 'Name']
+   *     }
+   * });
+   */
+  addNestedColumns(columns: IMappedCollection): ApiRequest {
+    this._jsWapiRequest = this._jsWapiRequest.putNestedColumns(columns);
+
+    return this;
+  }
+
+  addFilters(filters: IFiltersCollection): ApiRequest {
+    this._jsWapiRequest = this._jsWapiRequest.putFilters(filters);
+
+    return this;
+  }
+
+  addParams(params: IMappedCollection): ApiRequest {
+    for (const name in params) {
+      this._jsWapiRequest = this._jsWapiRequest.putParam(name, params[name]);
+    }
+
+    return this;
+  }
+
+  /* ----------------------------Removers----------------------------- */
+  removeSorts(sortsNames: string[]): ApiRequest {
+    this._jsWapiRequest = this._jsWapiRequest.removeSorts(sortsNames);
+
+    return this;
+  }
+
+  removeColumns(columnsNames: string[]): ApiRequest {
+    this._jsWapiRequest = this._jsWapiRequest.removeColumns(columnsNames);
+
+    return this;
+  }
+
+  removeAggregatedColumns(aggregatedColumnsNames: string[]): ApiRequest {
+    this._jsWapiRequest = this._jsWapiRequest.removeAggregatedColumns(aggregatedColumnsNames);
+
+    return this;
+  }
+
+  removeNestedColumns(nestedColumnsNames: string[]): ApiRequest {
+    this._jsWapiRequest = this._jsWapiRequest.removeNestedColumns(nestedColumnsNames);
+
+    return this;
+  }
+
+  removeParams(paramsNames: string[]): ApiRequest {
+    this._jsWapiRequest = this._jsWapiRequest.removeParams(paramsNames);
+
+    return this;
+  }
+
+  removeFilters(filtersNames: string[]): ApiRequest {
+    this._jsWapiRequest = this._jsWapiRequest.removeFilters(filtersNames);
+
+    return this;
+  }
+
+  /* ------------------------------Other------------------------------ */
+  hasFilter(filterName: string): boolean {
+    return this._jsWapiRequest.isFilterExists(filterName);
+  }
+
+  invoke(): ApiResponse {
+    return new ApiResponse(this._jsWapiRequest.invoke(), this._objectName);
+  }
+
+  newJSWapiInvoker(objectName: string, operName: string) {
+    return this._jsWapiRequest.newJSWapiInvoker(objectName, operName);
+  }
+
+  newApiInvoker(objectName: string, operName: string): ApiInvoker {
+    return new ApiInvoker(this.newJSWapiInvoker(objectName, operName), objectName);
+  }
+
+  /**
+   * Переводит и форматирует строку из словаря переводов согласно текущего языка приложения.
+   * @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.lang || LanguageCode.ua;
+    return UserMessages.format(msgKey, params);
+  }
+
+  /* -------------------------Support methods------------------------- */
+  _getWithStringifiedElements(array: any[]): string[] {
+    return array.map((element) => element.toString());
+  }
+}

package/src/classes/ApiResponse.ts

@@ -0,0 +1,72 @@
+import {IMappedCollection} from '../api-interfaces';
+
+export default class ApiResponse {
+  private _jsWapiResponse: any;
+  private readonly _objectName: string;
+
+  constructor(jsWapiResponse: any, objectName: string) {
+    this._jsWapiResponse = jsWapiResponse;
+    this._objectName = objectName;
+  }
+
+  get objectName(): string {
+    return this._objectName;
+  }
+
+  set response(response: IMappedCollection | any[]) {
+    this.setResponse(response);
+  }
+
+  getResponse(responseName?: string): IMappedCollection[] | any {
+    return this._jsWapiResponse.getResponse(responseName || this._objectName);
+  }
+
+  setResponse(response: IMappedCollection | any[], fieldsMap?: Record<string, any>) {
+    if (Array.isArray(response)) {
+      const data = !fieldsMap ? response : response.map(row => {
+        const res: any = {};
+        for (const externalKey in fieldsMap) {
+          res[fieldsMap[externalKey]] = row[externalKey];
+        }
+        return res;
+      });
+      this._jsWapiResponse.putResponse(this._objectName, data);
+    } else {
+      this._jsWapiResponse.setResponse(response);
+    }
+
+    return this;
+  }
+
+  sendHttpResponse(headers: IMappedCollection, body: string | jsWapi.BinaryDataStream) {
+    this._jsWapiResponse.sendHttpResponse(headers, body);
+
+    return this;
+  }
+
+  sendHttpBody(body: string) {
+    this._jsWapiResponse.sendHttpResponse({}, body);
+
+    return this;
+  }
+
+  getPage(): number {
+    return this._jsWapiResponse.getPage();
+  }
+
+  setPage(page: number) {
+    this._jsWapiResponse.setPage(page);
+
+    return this;
+  }
+
+  getPagesPredict(): number {
+    return this._jsWapiResponse.getPagesPredict();
+  }
+
+  setPagesPredict(pagesPredict: number) {
+    this._jsWapiResponse.setPagesPredict(pagesPredict);
+
+    return this;
+  }
+}

package/src/classes/EngineInitializer.ts

@@ -0,0 +1,88 @@
+import {ApiObjectInitializerConstructor} from './ApiObjectInitializer';
+import ApiRequest from './ApiRequest';
+import ApiCore from './ApiCore';
+import ApiResponse from './ApiResponse';
+import {IApiOperations, LanguageCode} from '../api-interfaces';
+import UserMessages from './UserMessages';
+
+export default class EngineInitializer<MetaParams = Record<string, any>>  {
+  private engine: jsWapi.JSWapiEngine;
+  protected _operations: IApiOperations<MetaParams>;
+
+
+  constructor(options: Omit<ApiObjectInitializerConstructor, 'objectName'>);
+  constructor(operations: IApiOperations<MetaParams>);
+  constructor(operations: IApiOperations<MetaParams>, options: Pick<ApiObjectInitializerConstructor, 'translations'>);
+  constructor(arg1: Omit<ApiObjectInitializerConstructor, 'objectName'> | IApiOperations<MetaParams>, arg2?: Pick<ApiObjectInitializerConstructor, 'translations'>) {
+    let operations = arg1.operations || arg1;
+    let translations = arg1.translations || arg2?.translations;
+
+    const throwError = (msg: string) => {
+      throw new Error(msg);
+    };
+
+    if (!operations) throwError('Property "operations" in the settings is required');
+    //@ts-ignore
+    this._operations = operations;
+    this.internalCreate();
+    //@ts-ignore
+    translations && this.initTranslation(translations);
+  }
+
+  private internalCreate() {
+    jsWapi.setJSWapiEngine((engine) => {
+      this.engine = engine;
+      for (const operationName in this._operations) {
+        this.putOperation(operationName);
+      }
+    });
+  }
+
+  private putOperation(operationName: string) {
+    this.engine.putJSWapiOper(operationName, (jsWapiRequest,jsWapiResponse) => {
+      const request = new ApiRequest(jsWapiRequest, this.engine.getName());
+      const apiCore = new ApiCore({http: this.engine, request});
+      return this._operations[operationName](
+        apiCore,
+        request,
+        new ApiResponse(jsWapiResponse, this.engine.getName()),
+        {
+          parameters: this.engine.getExternalSystemParameters() as MetaParams,
+          objectName: this.engine.getName(),
+          externalObject: this.engine.getExternalName(),
+          externalFieldsMap: this.engine.getExternalObjectFields(),
+        }
+      );
+    });
+  }
+
+  /**
+   * Инициализация словаря переводов.
+   * @param translations
+   * @example Пример строки перевода
+   * { ...
+   *  "ru": {"key": 'some text {0} {1}'}
+   *   ...
+   * }
+   *
+   *  core.t('key', ['test1', 'test2']); // 'some text test1 test2'
+   */
+  initTranslation(translations: Record<LanguageCode, Record<string, string>>) {
+    UserMessages.appendDictionary(translations);
+  }
+
+  public call({apiCore, apiRequest, apiResponse, operation, meta}: {
+    apiCore: ApiCore,
+    apiRequest: ApiRequest,
+    apiResponse: ApiResponse
+    operation: string,
+    meta: jsWapi.JSWapiMeta<MetaParams>
+  }) {
+    return this._operations[operation](
+      apiCore,
+      apiRequest,
+      apiResponse,
+      meta
+    );
+  }
+}

package/src/classes/UserMessages.ts

@@ -0,0 +1,38 @@
+import {LanguageCode} from '../api-interfaces';
+
+function formatMessage(text: string, args: string[] = []) {
+  let str = text;
+
+  for (let v in args) {
+    str = str.replace(`{${v}}`, args[v] == null ? '' : args[v]);
+  }
+  return str;
+}
+
+
+class UserMessages {
+  private _messages: Record<string, Record<string, string>> = {};
+  private _lang: LanguageCode = LanguageCode.ua;
+
+  appendDictionary(newDictionary: Record<LanguageCode, Record<string, string>>) {
+    if (Array.isArray(newDictionary) || !newDictionary || typeof newDictionary !== 'object') return;
+
+    for (const key in newDictionary) {
+      if (!this._messages.hasOwnProperty(key)) {
+        this._messages[key] = {};
+      }
+      this._messages[key] = Object.assign(this._messages[key], newDictionary[key as LanguageCode]);
+    }
+  }
+
+  format(msgKey: string, params?: string[]) {
+    const msg = this._messages[this._lang]?.[msgKey] ?? msgKey;
+    return formatMessage(msg, params);
+  }
+
+  set lang(value: LanguageCode) {
+    this._lang = value;
+  }
+}
+
+export default new UserMessages();

package/src/engine-index.ts

@@ -0,0 +1,4 @@
+import EngineInitializer from './classes/EngineInitializer';
+
+export default EngineInitializer;
+

package/src/index.ts

@@ -0,0 +1,3 @@
+import ApiObjectInitializer from './classes/ApiObjectInitializer';
+
+export default ApiObjectInitializer;

package/src/lib-index.ts

@@ -0,0 +1,3 @@
+export {default as ApiObjectInitializer} from './classes/ApiObjectInitializer';
+export {default as EngineInitializer} from './classes/EngineInitializer';
+

package/tsconfig.json

@@ -0,0 +1,35 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Node",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "lib": [
+      "dom",
+      "es2017"
+    ],
+    "jsx": "react",
+    "declaration": true,
+    "declarationDir": "./types",
+    "sourceMap": true,
+    "strictNullChecks": false,
+    "removeComments": false,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "baseUrl": "./",
+    "outDir": "./dist/",
+    "noImplicitAny": true,
+    "experimentalDecorators": true,
+    "typeRoots": [
+      "./types/"
+    ],
+    "allowJs": true,
+    "allowSyntheticDefaultImports": true
+  },
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}

package/tsup.config.ts

@@ -0,0 +1,46 @@
+import {defineConfig, Options} from 'tsup';
+import fs from 'fs';
+
+
+const LIB_NAME = 'd5-api-initializer';
+
+const outputDir = 'publish';
+
+
+//@ts-ignore
+export default defineConfig(options => {
+  const commonOptions: Partial<Options> = {
+    entry: {
+      [LIB_NAME]: 'src/lib-index.ts',
+    },
+    esbuildPlugins: [],
+    outDir: outputDir,
+    target: 'es2020',
+
+    skipNodeModulesBundle: true,
+    sourcemap: false,
+    ...options
+  };
+
+  return [
+    // Standard ESM, embedded `process.env.NODE_ENV` checks
+    {
+      ...commonOptions,
+      format: ['esm'],
+      splitting: false,
+      outExtension: () => ({js: '.mjs'}),
+      dts: true,
+      clean: true,
+      onSuccess() {
+        // Support Webpack 4 by pointing `"module"` to a file with a `.js` extension
+        fs.copyFileSync(`${outputDir}/${LIB_NAME}.mjs`, `${outputDir}/${LIB_NAME}.legacy-esm.js`);
+      }
+    },
+    {
+      ...commonOptions,
+      format: 'cjs',
+      outDir: `./${outputDir}/cjs/`,
+      outExtension: () => ({js: '.cjs'})
+    }
+  ];
+});