asma-helpers 0.0.2

package/src/helpers/ProcessServerError.ts

@@ -0,0 +1,92 @@
+export function processServerError(error: string | Record<string, any>): string {
+    console['error'](error)
+
+    let errorMessage = getServerErrorMessage(error)
+
+    /* if (i18n[errorMessage]) {
+        ;(errorMessage = (window as any).strings)[errorMessage]
+    } */
+
+    //showErrorMessage(operationName || 'Error', errorMessage)
+    return errorMessage
+}
+
+export function getServerErrorMessage(error: Record<string, any> | string): string {
+    if (typeof error == 'string') {
+        return error
+    } else if (error['data'] && error['data']['Message']) {
+        return error['data']['Message']
+    }
+    if (Array.isArray(error)) {
+        return getArrayErrorsMessage(error)
+    }
+    if (Array.isArray(error?.['errors'])) {
+        return getArrayErrorsMessage(error['errors'])
+    }
+    //graphql
+    else if (error['bodyText']) {
+        return error['bodyText']
+    } else if (error['response'] && error['response'].data) {
+        const data = error['response'].data?.['error'] ?? error['response'].data
+
+        if (typeof data == 'string') {
+            return data
+        } else if (data?.constructor === Object) {
+            const keys = Object.keys(data)
+
+            if (keys[0]) {
+                const objKey = keys[0]
+
+                if (data[objKey]['message']) {
+                    return data[objKey]['message']
+                } else if (data[objKey][0] && data[objKey][0]['message']) {
+                    return data[objKey][0]['message']
+                } else if (typeof data[objKey] == 'string') {
+                    return data[objKey]
+                } else if (data[objKey].constructor === Object) {
+                    const childKeys = Object.keys(data[objKey])
+
+                    if (childKeys[0]) {
+                        const objKey2 = childKeys[0]
+
+                        return `${objKey2}: ${data[objKey][objKey2]}`
+                    } else {
+                        return 'Missing child field: empty keys'
+                    }
+                } else if (data[objKey].constructor === Array) {
+                    if (data[objKey][0] === 'validation.required') {
+                        return `window.strings.field_is_required ${objKey}`
+                    } else {
+                        return `${objKey}: ${data[objKey][0]}`
+                    }
+                } else {
+                    return 'Missing field: Message not available'
+                }
+            } else {
+                return 'Missing field: Response keys are empty'
+            }
+        } else {
+            return 'Missing field: data type not processed'
+        }
+    } else if (error['message']) {
+        return error['message']
+    } else if (error['error']) {
+        return error['error']
+    } else if (error?.['request']?.['response']) {
+        return error['request']['response']
+    } else {
+        return "Missing field: Couldn't process error"
+    }
+}
+
+function getArrayErrorsMessage(error: Record<string, unknown>[]): string {
+    const porcessed_error = error
+        .map((err) => {
+            if ('message' in err) {
+                return err['message'] as string
+            } else return ''
+        })
+        .join()
+
+    return porcessed_error ?? 'No message field found! plase check logs'
+}

package/src/helpers/clearCacheData.ts

@@ -0,0 +1,16 @@
+export const clearCacheData = async (CACHE_VERSION:string) => {
+    const version = localStorage.getItem('version')
+    if (
+        (!version || version !== CACHE_VERSION) &&
+        indexedDB &&
+        typeof indexedDB['databases'] === 'function'
+    ) {
+        const IndexedDBS = await indexedDB.databases()
+
+        IndexedDBS.map((IndexedDB) => {
+            IndexedDB.name && indexedDB.deleteDatabase(IndexedDB.name)
+        })
+
+        localStorage.setItem('version', CACHE_VERSION)
+    }
+}

package/src/helpers/generateGenqlClient.ts

@@ -0,0 +1,75 @@
+import type { AxiosRequestConfig } from 'axios'
+import type { ClientOptions } from '@genql/runtime'
+
+export function generateGenqlClient<T>({
+    accessTokenHasExpired,
+    setReqConfig,
+    createClient,
+    serviceUrl,
+    serviceUrlWs,
+    path = '/v1/graphql',
+}: {
+    accessTokenHasExpired: () => boolean
+    setReqConfig: () => Promise<AxiosRequestConfig<any>>
+    createClient: (options?: ClientOptions | undefined) => T
+    serviceUrl: () => string | undefined
+    serviceUrlWs: () => string | undefined
+    path?: string
+}) {
+    let directoryClient: T | null = null
+
+    async function getGenqlClient() {
+        if (accessTokenHasExpired() || directoryClient === null) {
+            directoryClient = await genqlClient()
+
+            return directoryClient
+        }
+
+        return directoryClient
+    }
+
+    function resetGenqlClient() {
+        directoryClient = null
+    }
+
+    async function genqlClient(
+        anonymous: boolean | undefined = undefined,
+        headers: Record<string, string> = {},
+    ): Promise<T> {
+        let req_headers: Record<string, string> = {}
+        if (!serviceUrl()) {
+            console.warn('requred param srv_url is undefined, please check EnvConfig object!')
+        }
+        if (!anonymous) {
+            req_headers = ((await setReqConfig()).headers ?? {}) as Record<string, string>
+        }
+
+        return createClient({
+            url: `${serviceUrl()}${path}`,
+            headers: {
+                ...req_headers,
+                ...headers,
+            },
+            batch: { batchInterval: 50, maxBatchSize: 100 },
+        })
+    }
+
+    async function genqlClientWs() {
+        const req_headers = ((await setReqConfig()).headers ?? {}) as Record<string, string>
+
+        return createClient({
+            url: `${serviceUrlWs()}${path}`,
+            cache: 'reload',
+            subscription: {
+                timeout: 1,
+                reconnect: true,
+                reconnectionAttempts: 5,
+                headers: {
+                    ...req_headers,
+                },
+            },
+        })
+    }
+
+    return { getGenGqlClient: getGenqlClient, resetGenqlClient, genqlClient, genqlClientWs }
+}

package/src/helpers/generateSrvAuthBindings.ts

@@ -0,0 +1,175 @@
+import axios, { AxiosRequestConfig, AxiosResponse, ResponseType } from 'axios'
+import { EnvironmentEnums, parseJwt } from '..'
+export interface IGenerateSRVAuthBindings {
+    isJwtValid: () => boolean
+    signin(url: string, headers?: Record<string, string>): Promise<{ token: string }>
+    srvAuthGet<R>(url: string, headers?: Record<string, string>): Promise<AxiosResponse<R, any>>
+    signoutAuth(): Promise<void>
+    setReqConfig<T = unknown>(data?: T, responseType?: ResponseType): Promise<AxiosRequestConfig>
+    getJwtTokenAsync(): Promise<string>
+    getNewJwtToken(): Promise<string>
+    getUserId(): string
+    getParsedJwt<R = { user_id: string; exp: number }>(): R | undefined
+    getJwtToken(): string
+    accessTokenHasExpired(): boolean
+}
+export function generateSrvAuthBindings(
+    SRV_AUTH: () => string,
+    DEVELOPMENT: () => boolean,
+    ENVIRONMENT_TO_OPERATE: () => EnvironmentEnums,
+    logout?: () => void,
+): IGenerateSRVAuthBindings {
+    let jwtToken = ''
+    let parsed_jwt: any | undefined = undefined
+
+    let fetchJwtPromise: Promise<{ data: { message: string; token?: string; errors: { message: string }[] } }> | null =
+        null
+
+    const isJwtInvalid = () => (jwtToken && accessTokenHasExpired()) || !jwtToken
+
+    const isJwtValid = () => !isJwtInvalid()
+
+    async function srvAuthGet<R>(url: string, headers?: Record<string, string>) {
+        if (DEVELOPMENT() && ENVIRONMENT_TO_OPERATE()) {
+            url = `${url}&env=${ENVIRONMENT_TO_OPERATE()}`
+
+            url = url.includes('&') && !url.includes('?') ? url.replace('&', '?') : url
+        }
+
+        return axios.get<unknown, AxiosResponse<R>>(`${SRV_AUTH()}${url}`, {
+            headers: {
+                ...headers,
+                'asma-origin': window.location.origin,
+            },
+            withCredentials: true,
+        })
+    }
+
+    function accessTokenHasExpired(): boolean {
+        const tokenObj = getParsedJwt()
+
+        const accessTokenExpDate = tokenObj?.exp || 0
+
+        const nowTime = Math.floor(new Date().getTime() / 1000)
+
+        //set exp time -20sec for token to be refreshed early
+        return accessTokenExpDate - 10 <= nowTime
+    }
+
+    async function signin(url: string, headers?: Record<string, string>) {
+        const { data } = await srvAuthGet<{ token: string }>(url, headers)
+
+        setJwtToken(data.token)
+
+        return data
+    }
+
+    async function signoutAuth() {
+        setJwtToken('')
+        await srvAuthGet('/signout')
+    }
+    function getUserId(): string {
+        return getParsedJwt()?.['user_id'] || '-1'
+    }
+
+    function setJwtToken(token: string) {
+        jwtToken = token
+    }
+    function getJwtToken() {
+        return jwtToken
+    }
+
+    async function getJwtTokenAsync() {
+        if (isJwtInvalid()) {
+            const new_jwt = await getNewJwtToken()
+
+            return new_jwt
+        } else {
+            return jwtToken
+        }
+    }
+
+    async function setReqConfig<T = unknown>(data?: T, responseType?: ResponseType): Promise<AxiosRequestConfig> {
+        const token = await getJwtTokenAsync()
+
+        const res: AxiosRequestConfig = {
+            data: data,
+            responseType: responseType,
+            headers: {},
+        }
+
+        if (token) {
+            if (!res.headers) {
+                res.headers = {}
+            }
+
+            res.headers['Authorization'] = `Bearer ${token}`
+        }
+
+        return res
+    }
+
+    async function getNewJwtToken() {
+        try {
+            if (!fetchJwtPromise) {
+                fetchJwtPromise = srvAuthGet('/token')
+            }
+
+            const { data } = await fetchJwtPromise
+
+            if (!data || data.errors || data.message != 'Success') {
+                logout?.() || signoutAuth()
+            }
+            if (!data.token) {
+                throw new Error('Token is not present in the result')
+            }
+            setJwtToken(data.token ?? '')
+
+            fetchJwtPromise = null
+
+            return jwtToken
+        } catch (error) {
+            logout?.() || signoutAuth()
+            //signoutAuth()
+
+            fetchJwtPromise = null
+
+            console.error(error)
+
+            return jwtToken
+        }
+    }
+
+    function getParsedJwt<R = { user_id: string; exp: number }>(): R | undefined {
+        if (!parsed_jwt) {
+            parsed_jwt = parseJwt<R>(jwtToken)
+        }
+        return parsed_jwt
+    }
+
+    return {
+        isJwtValid,
+        signin,
+        srvAuthGet,
+        signoutAuth,
+        setReqConfig,
+        getJwtTokenAsync,
+        getNewJwtToken,
+        getUserId,
+        getParsedJwt,
+        getJwtToken,
+        accessTokenHasExpired,
+    }
+}
+
+export function generateSrvAuthBindingsMicroApp(
+    SRV_AUTH: () => string,
+    DEVELOPMENT: () => boolean,
+    ENVIRONMENT_TO_OPERATE: () => EnvironmentEnums,
+    logout?: () => void,
+) {
+    return (
+        window.__ASMA__SHELL__?.auth_bindings ||
+        generateSrvAuthBindings(SRV_AUTH, DEVELOPMENT, ENVIRONMENT_TO_OPERATE, logout)
+    )
+}

package/src/helpers/getGqlOperationName.ts

@@ -0,0 +1,21 @@
+export function getGqlOperationName(query: string): string | undefined {
+    const is_query = query.includes('query') ? 'query' : undefined
+
+    const is_mutation = query.includes('mutation') ? 'mutation' : undefined
+
+    const is_subscription = query.includes('subscription') ? 'subscription' : undefined
+
+    const split_word = is_query || is_mutation || is_subscription
+
+    if (!split_word) {
+        return undefined
+    }
+
+    let operationName = query?.split(split_word, 2)?.[1]?.split('{', 1)[0]?.split(' ')?.[1]?.trim()
+
+    if (operationName?.includes('(')) {
+        operationName = operationName.split('(', 1)[0]
+    }
+
+    return operationName
+}

package/src/helpers/getSubdomain.ts

@@ -0,0 +1,41 @@
+function getSubdomain() {
+    const hostname_arr = window.location.hostname.split('.')// fretex-dfsf.advoca.no
+
+    let subdomain = ''
+
+    if (
+        hostname_arr.length === 3 &&
+        hostname_arr[0] &&
+        !['dev', 'test', 'stage', 'intern', 'www'].find((sub) => sub === hostname_arr[0])
+    ) {
+        subdomain = hostname_arr[0]
+
+        const subdomain_arr = subdomain.split('-')
+
+        if (subdomain_arr.length === 2 && subdomain_arr[0]) {
+            subdomain = subdomain_arr[0]
+        }
+    }
+    return subdomain
+}
+
+export const subdomain = getSubdomain()
+
+export function redirectFromSubdomainToDomain() {
+    const domain_hostname = `${createDomainUrlFromSubdomain()}${window.location.pathname}`
+
+    window.location.href = domain_hostname
+
+    return null
+}
+
+export function createDomainUrlFromSubdomain() {
+    let hostname = window.location.hostname.replace(subdomain, '')
+
+    ;(hostname.startsWith('-') && (hostname = hostname.substring(1))) ||
+        (hostname.startsWith('.') && (hostname = 'www' + hostname))
+
+    const { port, protocol } = window.location
+
+    return protocol + '//' + hostname + (port ? `:${port}` : '')
+}

package/src/helpers/parseJwt.ts

@@ -0,0 +1,11 @@
+
+
+export function parseJwt<R>(jwtToken: string): R|undefined {
+    const base64Url = jwtToken?.split('.')[1]
+
+    if (base64Url === undefined) {
+        return {} as any
+    }
+
+    return JSON.parse(decodeURIComponent(escape(window.atob(base64Url))))
+}

package/src/index.ts

@@ -0,0 +1,29 @@
+export { getServerErrorMessage, processServerError } from './helpers/ProcessServerError'
+export { CURENCY_NOK, NORVEGIAN_PHONE_NUMBER, ORDINARY, PERSONAL_NUMBER, YEARS } from './helpers/FormatNumberConstants'
+export { COUNTRIES, POSTAL_CODE } from './helpers/NorwegianPostalCodes'
+export { capitalizeFirstLetter, toLowercaseAndCapitalizeFirstLetter } from './helpers/CapitalizeFistLetter'
+export * from './helpers/IsAdcuris'
+export * from './helpers/IsNotEmpty'
+export * from './helpers/Config'
+export * from './helpers/InitializeIDBListenersOnMstSnapshots'
+export * from './helpers/InitializeIDBListenersOnMstSnapshotsThenCatch'
+
+export * from './helpers/getGqlOperationName'
+export * from './helpers/parseJwt'
+export * from './helpers/EnvironmentsUrls'
+export * from './helpers/EnvironmentToOperateTypes'
+export * from './helpers/generateSrvAuthBindings'
+export * from './helpers/getSubdomain'
+export * from './helpers/clearCacheData'
+export * from './helpers/generateGenqlClient'
+
+export * from './utility/fetch'
+
+export * from './clients/srvAuth'
+
+export type { IUploadedDocument } from './interfaces/api/advoca/IUploadedDocument'
+export type { IFeedBack, ISaveToDataBase } from './interfaces/api/advoca/ISaveToDataBase'
+
+export * from './interfaces/enums'
+
+export * from './global'

package/src/interfaces/api/advoca/ISaveToDataBase.ts

@@ -0,0 +1,18 @@
+export interface ISaveToDataBase {
+    method: string
+    json: string
+    uuid: string | undefined
+    feedback: IFeedBack
+    url: string
+    origin?: {
+        method: string
+        // history: any
+    }
+}
+
+export interface IFeedBack {
+    error?: string
+    type: string
+    message: string
+    show_time: number
+}

package/src/interfaces/api/advoca/IUploadedDocument.ts

@@ -0,0 +1,24 @@
+export interface IUploadedDocument {
+    created_at: string
+    customer: {
+        comm_consents_descr: string
+        contact_email: string
+        contact_message: string
+        contact_tel: string
+
+        id: number
+        logo: string
+        name: string
+        updated_at: string
+    }
+    customer_id: number
+    id: number
+    name: string
+    path: string
+    patientIds: { id: number; soknad_id: string }[]
+    region: number
+    sds_id: number
+    updated_at: string
+    upload_patient_id: number
+    success: string
+}

package/src/interfaces/enums.ts

@@ -0,0 +1,56 @@
+export enum InitiatorTypes {
+    Customer = 'customer',
+    Patient = 'patient',
+    SelfCompletable = 'self-completable',
+}
+
+export enum QnrContextTypes {
+    Advoca = 'advoca',
+    Portal = 'portal',
+    Outlook = 'outlook',
+}
+export enum DocSignicatSignStatusTypes {
+    Complteted = 'completed',
+    Rejected = 'rejected',
+    Waiting = 'waiting',
+}
+
+export enum DocProxyStatusTypes {
+    Signed = 'signed',
+    WaitingForSigning = 'waiting_for_signing',
+    OnlyForView = 'only_for_view',
+    /* download = 'download',
+    uploaded = 'uploaded' */
+}
+export enum QuestionTypes {
+    BooleanQuestion = 'BooleanQuestion',
+    CheckBoxes = 'CheckBoxes',
+    CompositeQuestion = 'CompositeQuestion',
+    DateField = 'DateField',
+    Dropdown = 'Dropdown',
+    FormatNumber = 'FormatNumber',
+    LinearScale = 'LinearScale',
+    Link = 'Link',
+    RadioButtons = 'RadioButtons',
+    TextLong = 'TextLong',
+    TextShort = 'TextShort',
+    Emoticons = 'Emoticons',
+    DocumentUpload = 'DocumentUpload',
+    Readonly = 'Readonly',
+    ExpressionQuestion = 'ExpressionQuestion',
+    Chart = 'Chart',
+}
+
+export enum ActorTypes {
+    Mappable = 'mappable',
+    Custom = 'custom',
+    Complex = 'complex',
+}
+
+export enum EnvironmentEnums {
+    local = 'local',
+    dev = 'dev',
+    test = 'test',
+    stage = 'stage',
+    prod = 'prod',
+}

package/src/utility/fetch.ts

@@ -0,0 +1,10 @@
+export async function http<R>(
+    request: RequestInfo,
+    init?:RequestInit
+  ): Promise<R> {
+    const response = await fetch(request,init);
+
+    const body = await response.json();
+    
+    return body;
+  }

package/tsconfig.json

@@ -0,0 +1,84 @@
+{
+    "compilerOptions": {
+        /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+        /* Basic Options */
+        // "incremental": true,                         /* Enable incremental compilation */
+        "target": "ES2019" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */,
+        "module": "ES2020" /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */,
+        // "lib": [],                                   /* Specify library files to be included in the compilation. */
+        // "allowJs": true,                             /* Allow javascript files to be compiled. */
+        // "checkJs": true,                             /* Report errors in .js files. */
+        "jsx": "react-jsx" /* Specify JSX code generation: 'preserve', 'react-native', 'react', 'react-jsx' or 'react-jsxdev'. */,
+        "declaration": true /* Generates corresponding '.d.ts' file. */,
+        "declarationMap": true /* Generates a sourcemap for each corresponding '.d.ts' file. */,
+        "sourceMap": true /* Generates corresponding '.map' file. */,
+        // "outFile": "./",                             /* Concatenate and emit output to single file. */
+        "outDir": "lib" /* Redirect output structure to the directory. */,
+        "rootDir": "src" /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */,
+        // "composite": true,                           /* Enable project compilation */
+        // "tsBuildInfoFile": "./",                     /* Specify file to store incremental compilation information */
+        // "removeComments": true,                      /* Do not emit comments to output. */
+        // "noEmit": true,                              /* Do not emit outputs. */
+        // "importHelpers": true,                       /* Import emit helpers from 'tslib'. */
+        // "downlevelIteration": true,                  /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
+        "isolatedModules": true /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */,
+
+        /* Strict Type-Checking Options */
+        "strict": true /* Enable all strict type-checking options. */,
+        "noImplicitAny": true /* Raise error on expressions and declarations with an implied 'any' type. */,
+        "strictNullChecks": true /* Enable strict null checks. */,
+        "strictFunctionTypes": true /* Enable strict checking of function types. */,
+        // "strictBindCallApply": true,                 /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
+        // "strictPropertyInitialization": true,        /* Enable strict checking of property initialization in classes. */
+        "noImplicitThis": true /* Raise error on 'this' expressions with an implied 'any' type. */,
+        "alwaysStrict": true /* Parse in strict mode and emit "use strict" for each source file. */,
+        "noUncheckedIndexedAccess": true,
+        /* Additional Checks */
+        "noUnusedLocals": true /* Report errors on unused locals. */,
+        "noUnusedParameters": true /* Report errors on unused parameters. */,
+        "noImplicitReturns": true /* Report error when not all code paths in function return a value. */,
+        "noFallthroughCasesInSwitch": true /* Report errors for fallthrough cases in switch statement. */,
+        //"noUncheckedIndexedAccess": true /* Include 'undefined' in index signature results */,
+        //"noPropertyAccessFromIndexSignature": true /* Require undeclared properties from index signatures to use element accesses. */,
+
+        /* Module Resolution Options */
+        "moduleResolution": "node" /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */,
+        // "baseUrl": "./",                             /* Base directory to resolve non-absolute module names. */
+        // "paths": {},                                 /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
+        // "rootDirs": [],                              /* List of root folders whose combined content represents the structure of the project at runtime. */
+        // "typeRoots": [],                             /* List of folders to include type definitions from. */
+        // "types": [],                                 /* Type declaration files to be included in compilation. */
+        // "allowSyntheticDefaultImports": true,        /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+        "esModuleInterop": false /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */,
+        // "preserveSymlinks": true,                    /* Do not resolve the real path of symlinks. */
+        // "allowUmdGlobalAccess": true,                /* Allow accessing UMD globals from modules. */
+
+        /* Source Map Options */
+        // "sourceRoot": "",                            /* Specify the location where debugger should locate TypeScript files instead of source locations. */
+        // "mapRoot": "",                               /* Specify the location where debugger should locate map files instead of generated locations. */
+        // "inlineSourceMap": true,                     /* Emit a single file with source maps instead of having a separate file. */
+        // "inlineSources": true,                       /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
+
+        /* Experimental Options */
+        // "experimentalDecorators": true,              /* Enables experimental support for ES7 decorators. */
+        // "emitDecoratorMetadata": true,               /* Enables experimental support for emitting type metadata for decorators. */
+
+        /* Advanced Options */
+        "skipLibCheck": true /* Skip type checking of declaration files. */,
+        "forceConsistentCasingInFileNames": true /* Disallow inconsistently-cased references to the same file. */,
+
+        "allowJs": false,
+        "allowSyntheticDefaultImports": true,
+
+        "strictBindCallApply": true,
+
+        "noPropertyAccessFromIndexSignature": true,
+        "resolveJsonModule": true,
+        "experimentalDecorators": false,
+        "importsNotUsedAsValues": "error",
+        "useUnknownInCatchVariables": false
+    },
+    "include": ["src", "lib/interfaces"],
+    "exclude": ["node_modules", "lib"]
+}