bx-rest 0.0.1 → 0.0.3

package/package.json

@@ -1,36 +1,57 @@
 {
   "name": "bx-rest",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "bitrix rest api",
-  "main": "index.ts",
+  "typings": "./index.d.ts",
+  "type": "module",
   "dependencies": {
+    "@angular/common": "^16.1.8",
+    "@angular/core": "^16.1.8",
+    "@angular/material": "^16.1.7",
+    "@angular/router": "^16.1.8",
+    "@ngrx/store": "^16.2.0",
     "entities": "^4.5.0",
-    "luxon": "^3.3.0",
-    "parse5": "^7.1.2",
     "just-clone": "^6.2.0",
-    "safevalues": "^0.3.4",
     "just-compare": "^2.3.0",
+    "luxon": "^3.3.0",
+    "parse5": "^7.1.2",
     "rxjs": "^7.8.1",
-    "zone.js": "^0.13.1",
-    "tslib": "^2.6.1"
+    "safevalues": "^0.3.4",
+    "tslib": "^2.6.1",
+    "zone.js": "^0.13.1"
   },
-  "devDependencies": {},
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+  "devDependencies": {
+    "just-flatten-it": "^5.2.0"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Aricatofuka/bx-rest.git"
   },
+  "scripts": {
+    "compile": "tsc -b ./src/tsconfig.cjs.json ./src/tsconfig.cjs.spec.json ./src/tsconfig.esm.json ./src/tsconfig.esm5.json ./src/tsconfig.esm5.rollup.json ./src/tsconfig.types.json ./src/tsconfig.types.spec.json ./spec/tsconfig.json",
+    "build:clean": "shx rm -rf ./dist"
+  },
   "keywords": [
     "bitrxi",
     "rest",
     "api"
   ],
   "author": "Aricatofuka",
-  "license": "ISC",
+  "license": "MIT",
   "bugs": {
     "url": "https://github.com/Aricatofuka/bx-rest/issues"
   },
-  "homepage": "https://github.com/Aricatofuka/bx-rest#readme"
+  "homepage": "https://github.com/Aricatofuka/bx-rest#readme",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "node": "./dist/cjs/index.js",
+      "require": "./dist/cjs/index.js",
+      "es2015": "./dist/esm/index.js",
+      "default": "./dist/esm5/index.js"
+    }
+  }
 }

package/src/index.d.ts

@@ -0,0 +1,19 @@
+import { iHttpParamSettings } from 'bx-rest/src/typification/rest/settings'
+import { Observable, of } from 'rxjs'
+
+export declare class BaseHttp {
+    httpGet<T>(
+        url: string,
+        params: any,
+        textError: string,
+        settings: iHttpParamSettings
+    ): Observable<T | undefined>
+
+    httpPost<T>(url: string,
+                         params: any ,
+                         textError: string,
+                         settings: iHttpParamSettings
+    ): Observable<T | undefined>
+
+    handleError<T>(result?: T, textError?: string): Observable<T>
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+import { BaseHttp } from './services/http/base/base'
+
+export { BaseHttp }

package/src/services/http/http.ts

@@ -2,16 +2,16 @@ import { Observable, throwError, take, mergeMap, forkJoin } from 'rxjs'
 import { catchError, map } from 'rxjs/operators'
 import { Injectable } from '@angular/core'
 import { HttpClient } from '@angular/common/http'
-import SnackBarService from '@/lib/services/snack-bar/snack-bar.service'
-import SessionKeyServices from '@/lib/services/api/bitrix/http/sessionKey'
+import SnackBarService from '@/services/snack-bar/snack-bar.service'
+import SessionKeyServices from '@/services/http/sessionKey'
 import clone from 'just-clone'
-import { iHttpParamSettings } from '@/lib/typification/bitrix/api/rest/settings'
-import BaseHttpServices from '@/lib/services/http/http'
+import { iHttpParamSettings } from '@/typification/rest/settings'
+import BaseHttpServices from '@/services/http/http'
 import {
     iBatchRequestAnswer, iBatchRequestParam,
     iBatchRequestParamArr,
     iBatchRequestParamHttp, keyBatch
-} from '@/lib/typification/bitrix/api/rest/batch/batchRequestParam'
+} from '@/typification/rest/batch/batchRequestParam'
 import flatten from 'just-flatten-it'
 
 @Injectable({

package/src/services/http/sessionKey.ts

@@ -0,0 +1,214 @@
+import { Injectable } from '@angular/core'
+import Cookies from '@/services/vanilla/сookies'
+import { Store } from '@ngrx/store'
+import saveApplicationAuth from '@/typification/auth/save'
+import { environment as env } from '@/environments/environment'
+import { filter, Observable, of, Subscription, take } from 'rxjs'
+import { ActivatedRoute, ParamMap } from '@angular/router'
+import { saveAccessToken, saveApplicationAuthPath } from '@/store/auth'
+import { map } from 'rxjs/operators'
+import { BaseServices } from '@/services/base'
+import { BxApiLibServices } from '@/services/bx-api-lib'
+import { LocalStorageServices as LocalStorage } from '@/lib/services/vanilla/localStorage'
+
+type IKeyAuth = 'sessid' | 'auth' | string
+
+@Injectable({
+    providedIn: 'root'
+})
+
+export default class SessionKeyServices extends BaseServices {
+
+    authHave = false
+    authData$: Observable<saveApplicationAuth>
+    authData: saveApplicationAuth | undefined
+    subscribe = {
+        authData: new Subscription()
+    }
+
+    constructor(
+        public store: Store<{ auth: saveApplicationAuth }>,
+        private route: ActivatedRoute,
+        public BxApiLib: BxApiLibServices,
+    ) {
+        super()
+        this.authData$ = this.store.select('auth')
+        this.authData$.subscribe(authData => {
+            if ((authData && !authData.access_token.length && !env.component) || !authData) {
+                // получаем токен по собственным каналом (в битриксе приложение trace:apps.trace)
+                window.addEventListener('message', (event: MessageEvent) => {
+                    if (event.origin !== window.origin) { // проверяем что это не наше сообщение (с текущего приложения)
+                        if (event.data && event.data.param) {
+                            if (typeof event.data.param === 'string') {
+                                event.data.param = JSON.parse(event.data.param)
+                            }
+
+                            let save: saveApplicationAuthPath = {}
+
+                            if (event.data.param.access_token) {
+                                let param = event.data.param;
+                                save.access_token = event.data.param.access_token
+                                save = {
+                                    access_token: (param.access_token) ? param.access_token : undefined,
+                                    client_endpoint: (param.client_endpoint) ? param.client_endpoint : undefined,
+                                    domain: (param.domain) ? param.domain : undefined,
+                                    expires: (param.expires) ? param.expires : undefined,
+                                    expires_in: (param.expires_in) ? param.expires_in : undefined,
+                                    member_id: (param.member_id) ? param.member_id : undefined,
+                                    refresh_token: (param.refresh_token) ? param.refresh_token : undefined,
+                                    scope: (param.scope) ? param.scope : undefined,
+                                    server_endpoint: (param.server_endpoint) ? param.server_endpoint : undefined,
+                                    status: (param.status) ? param.status : undefined,
+                                    user_id: (param.user_id) ? param.user_id : undefined,
+                                    type: (param.type) ? param.type : undefined,
+                                }
+                            }
+
+                            if (Object.keys(save).length && save.access_token) {
+                                this.store.dispatch(saveAccessToken(save))
+                                this.subscribeAll()
+                            }
+                        }
+                    }
+                })
+
+                this.subscribe.authData = this.route.queryParamMap
+                    .pipe(
+                        filter(param =>
+                            param.has('AUTH_ID')
+                            || param.has('access_token')
+                            || param.has('REFRESH_ID')
+                            || param.has('DOMAIN')
+                        )
+                    )
+                    .subscribe((param: ParamMap) => {
+                        let save: saveApplicationAuthPath = {}
+                        if (param.has('AUTH_ID') && !authData.access_token.length) {
+                            const get = param.get('AUTH_ID')
+                            if (get) {
+                                Cookies.set('auth', get) // потом убрать
+                                save.access_token = get
+                            }
+                        }
+
+                        if (param.has('access_token') && !authData.access_token.length) {
+                            const get = param.get('access_token')
+                            if (get) {
+                                Cookies.set('auth', get) // потом убрать
+                                save.access_token = get
+                            }
+                        }
+
+                        if (param.has('REFRESH_ID') && !authData.refresh_token.length) {
+                            const get = param.get('REFRESH_ID')
+                            if (get) {
+                                save.refresh_token = get
+                            }
+                        }
+
+                        if (param.has('DOMAIN') && !authData.domain.length) {
+                            const get = param.get('DOMAIN')
+                            if (get) {
+                                save.domain = get
+                            }
+                        }
+                        if (Object.keys(save).length && save.access_token) {
+                            this.store.dispatch(saveAccessToken(save))
+                            this.subscribeAll()
+                        } else {
+                            // если битрикс не шлёт нужные мне параметры на прямую
+                            // просим их мне отдать так как описано это в документации
+                            let f = () => {
+                                if (this.BxApiLib.BX24) {
+                                    const initDate = this.BxApiLib.BX24.getAuth()
+                                    this.store.dispatch(saveAccessToken(initDate))
+                                }
+                            }
+
+                            this.BxApiLib.init(f)
+                        }
+
+                    })
+            } else if (env.component && this.getAuth().length) {
+                this.authHave = true
+            }
+
+            this.authData = authData
+        })
+
+        if (!env.production) {
+            this.authHave = true
+        }
+    }
+
+    subscribeAll() {
+        this.subscribe.authData.unsubscribe()
+    }
+
+    getAuth(): string {
+        if ((<any>window).BX && (<any>window).BX.bitrix_sessid()) {
+            return (<any>window).BX.bitrix_sessid()
+        } else if (this.getSessid().length) {
+            let str = this.getSessid()
+            return (str) ? str : ''
+        } else {
+            return Cookies.get('auth')
+        }
+    }
+
+    getKeyAuth(): IKeyAuth {
+        if ((<any>window).BX && (<any>window).BX.bitrix_sessid()
+            || this.getSessid().length) {
+            return 'sessid'
+        } else {
+            return 'auth'
+        }
+    }
+
+    getSessid() {
+        const check = new URLSearchParams(document.location.search).get('sessid')
+        if (check) {
+            LocalStorage.set('sessid', check)
+            return check
+        } else if (LocalStorage.get('sessid')) {
+            return LocalStorage.get('sessid')
+        }
+        return ''
+    }
+
+    setAuthParams<T>(params: any): boolean {
+        const keyAuth = this.getKeyAuth()
+        if (params[keyAuth]) {
+            return true
+        } else if (keyAuth) {
+            params[keyAuth] = this.getAuth()
+            return true
+        }
+        return false
+    }
+
+    getAuthParams(): Observable<string | undefined> {
+        if (env.production && !env.component) {
+            return this.authData$.pipe(
+                take(1),
+                map(v => (v) ? v.access_token : undefined)
+            )
+        } else {
+            return of(this.getAuth())
+        }
+    }
+
+    getBaseUrl(): Observable<string | undefined> {
+        if (env.public) {
+            return this.authData$.pipe(
+                map(v => (v && v.domain) ? this.prepareBaseAddress(v.domain, env.urls.api.bitrix) : undefined)
+            )
+        } else {
+            return of(env.urls.api.bitrix)
+        }
+    }
+
+    getHomeUrl(): string {
+        return env.urls.home
+    }
+}

package/src/services/vanilla/JSON.ts

@@ -0,0 +1,15 @@
+import { Injectable } from '@angular/core'
+import serialize from '@/lib/functions/serializeJavascript'
+
+@Injectable({
+  providedIn: 'root'
+})
+export default class JSONServices {
+  static deserialize(data: any) {
+    return eval('(' + data + ')')
+  }
+
+  static serialize(data: any ) {
+    return serialize(data)
+  }
+}

package/src/services/vanilla/iframe.ts

@@ -0,0 +1,57 @@
+import { Injectable } from '@angular/core'
+import SessionKeyServices from '@/lib/services/api/bitrix/http/sessionKey'
+import { map, mergeMap, of } from 'rxjs'
+import SnackBarService from '@/lib/services/snack-bar/snack-bar.service'
+
+@Injectable({
+  providedIn: 'root'
+})
+export default class IFrameVanillaJS {
+  parent = window.parent
+
+  constructor(
+    private session: SessionKeyServices,
+    private snackBar: SnackBarService
+  ) {
+  }
+
+  sendMessage(message: any, targetOrigin = '') {
+    return this.session.authData$.pipe(
+      mergeMap(
+        v => {
+          if(v){
+            if (message && !message.id){
+              message.id = v.access_token
+            }
+            if (this.parent && this.parent['postMessage']) {
+              if (targetOrigin.length) {
+                this.parent.postMessage(message, targetOrigin)
+                return of(true)
+              } else {
+                return this.session.getBaseUrl().pipe(
+                  map(v => {
+                    if (v) {
+                      this.parent.postMessage(message, v)
+                      return true
+                    }
+                    this.snackBar.error('Не удалось получить адрес родителя для фрейма')
+                    return false
+                  })
+                )
+              }
+            }
+            this.snackBar.error('Не удалось получить адрес родителя для фрейма')
+            return of(false)
+          }
+          this.snackBar.error('Не удалось получить авторизационные данные')
+          return of(false)
+        }
+      )
+    )
+
+  }
+
+  getMassage(func: Function){
+    window.addEventListener('message', func())
+  }
+}

package/src/services/vanilla/localStorage.ts

@@ -0,0 +1,42 @@
+import { Injectable } from '@angular/core'
+import JSON from '@/lib/services/vanilla/JSON'
+
+@Injectable({
+  providedIn: 'root'
+})
+export class LocalStorageServices {
+
+  static get(name: string): any {
+    return localStorage.getItem(name)
+  }
+
+  static getObj<T>(name: string): T | null {
+    return JSON.deserialize(localStorage.getItem(name))
+  }
+
+  static set(name: string, value: string): void {
+    localStorage.setItem(name, value)
+  }
+
+  static setObj(name: string, value: any): void {
+    let get = this.get(name)
+    if(get && typeof get === 'object'){
+      localStorage.setItem(
+        name,
+        JSON.serialize(
+          Object.assign(
+            get,
+            value
+          )
+        )
+      )
+    } else {
+      localStorage.setItem(name, JSON.serialize(value))
+    }
+  }
+
+  static del(name: string): void {
+    localStorage.removeItem(name)
+  }
+
+}

package/src/services/vanilla//321/201ookies.ts

@@ -0,0 +1,43 @@
+import { Injectable } from '@angular/core'
+import JSON from '@/lib/services/vanilla/JSON'
+
+@Injectable({
+  providedIn: 'root'
+})
+export default class CookiesServices {
+
+  static get(name: string): string {
+    const results = document.cookie.match('(^|;) ?' + name + '=([^;]*)(;|$)');
+    if (results)
+      return results[2]
+    else
+      return ''
+  }
+
+  static set(name: string, value: string, age: number = 0) {
+    let string = name + '=' + value + ';'
+    if(age) {
+      string += ' max-age=' + age
+    }
+    string += '; SameSite=None; Secure'
+    document.cookie = string
+  }
+
+  static setObj(name: string, value: any, age: number = 0) {
+    let string = name + '=' + JSON.serialize(value) + ';'
+    if(age) {
+      string += ' max-age=' + age
+    }
+    string += '; SameSite=None; Secure'
+    document.cookie = string
+  }
+
+  static getObj<T>(name: string): T | false {
+    const results = document.cookie.match('(^|;) ?' + name + '=([^;]*)(;|$)');
+    if (results) {
+      return JSON.deserialize(results[2])
+    }
+
+    return false
+  }
+}

package/src/store/auth.ts

@@ -0,0 +1,46 @@
+import { Action, createReducer, on, props } from '@ngrx/store'
+import { createAction } from '@ngrx/store'
+import saveApplicationAuth from '@/typification/auth/save'
+import clone from 'just-clone'
+export interface saveApplicationAuthPath {
+  access_token?: string, // основной авторизационный токен, требуемый для доступа к REST API
+  client_endpoint?: string, // адрес REST-интерфейса портала
+  domain?: string,
+  expires?: number,
+  expires_in?: number,
+  member_id?: string,
+  refresh_token?: string, // дополнительный авторизационный токен, служащий для продления сохраненной авторизации
+  scope?: string,
+  server_endpoint?: string, // адрес REST-интерфейса сервера
+  status?: string, // статус приложения на портале
+  user_id?: number
+  type?: string
+}
+export const save = createAction('[Auth Component] Save', props<saveApplicationAuth | saveApplicationAuthPath>())
+export const saveAccessToken = createAction('[Auth Component] SaveAccessToken', props<saveApplicationAuthPath>())
+
+export const initialState: saveApplicationAuth = {
+  access_token: '',
+  client_endpoint: '',
+  domain: '',
+  expires: 0,
+  expires_in: 0,
+  member_id: '',
+  refresh_token: '',
+  scope: '',
+  server_endpoint: '',
+  status: '',
+  user_id: 0
+}
+
+const _authReducer = createReducer(
+  initialState,
+  on(saveAccessToken, (s, data) => {
+    let copy = clone(s)
+    return Object.assign(copy, data)
+  }),
+);
+
+export function authReducer(state = initialState, action: Action) {
+  return _authReducer(state, action);
+}

package/src/tsconfig.base.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    // "noEmit": false,
+    "baseUrl": "@",
+    "paths": {
+      "bx-rest": ["./"],
+      "bx-rest/*": ["./*"]
+    }
+  },
+  "include": ["./**/*.ts"]
+}

package/src/tsconfig.cjs.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es5",
+    "downlevelIteration": true,
+    "outDir": "../dist/cjs"
+  },
+  "exclude": ["./internal/umd.ts"]
+}

package/src/tsconfig.cjs.spec.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.cjs.json",
+  /**
+   * this is pseudo config for test case's relative path resolution to `../src`, runs
+   * cjs config once more instead of manual copying to utilize incremental build.
+   */
+  "compilerOptions": {
+    "outDir": "../dist/src"
+  }
+}

package/src/tsconfig.esm.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "module": "esnext",
+    "importHelpers": true,
+    "target": "es2015",
+    "outDir": "../dist/esm"
+  }
+}

package/src/tsconfig.esm5.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "module": "esnext",
+    "importHelpers": true,
+    "target": "es5",
+    "downlevelIteration": true,
+    "outDir": "../dist/esm5"
+  },
+  "exclude": ["./internal/umd.ts"]
+}

package/src/tsconfig.esm5.rollup.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.esm5.json",
+  "compilerOptions": {
+    "outDir": "../dist/esm5_for_rollup",
+    "noEmitHelpers": true
+  },
+  "exclude": []
+}

package/src/tsconfig.types.json

@@ -0,0 +1,14 @@
+{
+  "extends": "./tsconfig.esm.json",
+  "compilerOptions": {
+    "composite": true,
+    "module": "es2015",
+    "target": "esnext",
+    "removeComments": false,
+    "declaration": true,
+    "declarationMap": true,
+    "declarationDir": "../dist/types",
+    "emitDeclarationOnly": true
+  },
+  "exclude": ["./internal/umd.ts"]
+}

package/src/tsconfig.types.spec.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.types.json",
+  "compilerOptions": {
+    "declarationDir": "../dist/types_spec",
+    "stripInternal": false
+  }
+}

package/src/typification/auth/OAuthBXParam.ts

@@ -0,0 +1,6 @@
+export default interface OAuthBXParam {
+  code: string,
+  domain: string,
+  member_id: string,
+  scope: string
+}

package/src/typification/auth/application.ts

@@ -0,0 +1,8 @@
+export default interface ApplicationAuth {
+  code?: string,
+  state?: string,
+  domain?: string,
+  member_id?: string,
+  scope?: string,
+  server_domain?: string
+}

package/src/typification/auth/save.ts

@@ -0,0 +1,14 @@
+export default interface saveApplicationAuth {
+  access_token: string, // основной авторизационный токен, требуемый для доступа к REST API
+  client_endpoint: string, // адрес REST-интерфейса портала
+  domain: string,
+  expires: number,
+  expires_in: number,
+  member_id: string,
+  refresh_token: string, // дополнительный авторизационный токен, служащий для продления сохраненной авторизации
+  scope: string,
+  server_endpoint: string, // адрес REST-интерфейса сервера
+  status: string, // статус приложения на портале
+  user_id: number,
+  state?: any
+}

package/src/typification/auth/urlData.ts

@@ -0,0 +1,4 @@
+export default interface UrlData {
+  REFRESH_ID?: string,
+  AUTH_ID?: string
+}

package/src/typification/rest/api-lib.ts

@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core'
+import { iRestLib } from '@/typification/rest/lib'
+
+@Injectable({
+    providedIn: 'root'
+})
+export class ApiLibServices {
+    BX24: iRestLib | false = false
+
+    constructor() {
+        // @ts-ignore
+        this.BX24 = (window.BX24) ? window.BX24 : false
+    }
+
+    init(callBack: Function) {
+        return (this.BX24) ? this.BX24.init(callBack) : false
+    }
+}

package/src/typification/rest/batch/batchRequestParam.ts

@@ -0,0 +1,14 @@
+import iHttpAnswerBX from '@/lib/typification/bitrix/api/rest/base/httpAnswerBX'
+
+export type keyBatch = string | number
+
+export interface iBatchRequestParam <T>{
+    name: string,
+    param: T
+}
+
+export type iBatchRequestParamHttp = {[key:keyBatch]: string}
+
+export type iBatchRequestParamArr<T> = {[key:keyBatch]: iBatchRequestParam <T>}
+
+export interface iBatchRequestAnswer<T> extends iHttpAnswerBX<iHttpAnswerBX<{[key:keyBatch]: T}>>{}

package/src/typification/rest/lib.ts

@@ -0,0 +1,19 @@
+export interface iRestLib {
+    init: Function
+    getAuth: () => iRestLibGetAuth
+    placement: {
+        info: () => {
+            options: any,
+            placement: string
+        }
+    }
+    fitWindow: (func?: () => void) => void
+}
+
+export interface iRestLibGetAuth {
+    access_token: string,
+    domain: string,
+    expires_in: number
+    member_id: string
+    refresh_token: string
+}

package/tsconfig.json

@@ -1,5 +1,7 @@
 {
     "compilerOptions": {
+        "target": "es5",
+        "lib": ["esnext", "dom"],
         "paths": {
             "@/*": [
                 "src/*"