@lenne.tech/ng-base 0.0.9 → 0.2.1

package/fesm2015/lenne.tech-ng-base.js

@@ -4,8 +4,10 @@ import { HttpLink } from 'apollo-angular/http';
 import * as i0 from '@angular/core';
 import { InjectionToken, Injectable, Inject, Directive, ElementRef, Input, Output, HostBinding, HostListener, Pipe, NgModule } from '@angular/core';
 import { BehaviorSubject, Observable, of, throwError } from 'rxjs';
-import { ApolloLink } from '@apollo/client/core';
+import { ApolloLink, split, concat } from '@apollo/client/core';
 import { InMemoryCache } from '@apollo/client/cache';
+import { WebSocketLink } from '@apollo/client/link/ws';
+import { getMainDefinition } from '@apollo/client/utilities';
 import * as i1$2 from '@angular/platform-browser';
 import { DomSanitizer, Title, Meta } from '@angular/platform-browser';
 import * as i1$1 from '@angular/router';
@@ -208,7 +210,8 @@ AuthService.ctorParameters = () => [
  * Factory for apollo-angular options
  */
 function apolloOptionsFactory(baseModuleConfig, httpLink, authService) {
-    const link = httpLink.create({
+    const links = [];
+    const http = httpLink.create({
         uri: baseModuleConfig.apiUrl,
     });
     const authMiddleware = new ApolloLink((operation, forward) => {
@@ -222,8 +225,44 @@ function apolloOptionsFactory(baseModuleConfig, httpLink, authService) {
         }
         return forward(operation);
     });
+    if (baseModuleConfig.wsUrl) {
+        let wsClient;
+        if (localStorage) {
+            const token = authService.token || null;
+            wsClient = new WebSocketLink({
+                uri: baseModuleConfig.wsUrl,
+                options: {
+                    reconnect: true,
+                    connectionParams: {
+                        authToken: token,
+                    },
+                },
+            });
+        }
+        else {
+            wsClient = new WebSocketLink({
+                uri: baseModuleConfig.wsUrl,
+                options: {
+                    reconnect: true,
+                },
+            });
+        }
+        // using the ability to split links, you can send data to each link
+        // depending on what kind of operation is being sent
+        links.push(split(
+        // split based on operation type
+        ({ query }) => {
+            // @ts-ignore
+            const { kind, operation } = getMainDefinition(query);
+            return kind === 'OperationDefinition' && operation === 'subscription';
+        }, wsClient, concat(authMiddleware, http)));
+    }
+    else {
+        links.push(http);
+        links.push(authMiddleware);
+    }
     return {
-        link: ApolloLink.from([authMiddleware, link]),
+        link: ApolloLink.from(links),
         cache: new InMemoryCache(),
         defaultOptions: {
             query: {
@@ -566,7 +605,7 @@ const elements = [
     ResizableDirective,
     // Pipes
     EllipsesPipe,
-    SafeHtmlPipe
+    SafeHtmlPipe,
 ];
 /**
  * Base module
@@ -577,27 +616,36 @@ class BaseModule {
      */
     static forRoot(baseModuleConfig = {}) {
         // Default config
-        const config = Object.assign({ apiUrl: 'localhost:300', authGuardRedirectUrl: '/auth', version: null, prefix: null, scrollDetectionOffset: 200, scrollOffset: 100, storageType: 'local' }, baseModuleConfig);
+        const config = Object.assign({ apiUrl: 'localhost:3000', authGuardRedirectUrl: '/auth', logging: false, version: null, prefix: null, scrollDetectionOffset: 200, scrollOffset: 100, storageType: 'local' }, baseModuleConfig);
+        // Prepare providers
+        const providers = [
+            {
+                provide: BASE_MODULE_CONFIG,
+                useValue: baseModuleConfig,
+            },
+        ];
+        // Add apollo features if API URL is set
+        if (baseModuleConfig.apiUrl) {
+            providers.push({
+                provide: APOLLO_OPTIONS,
+                useFactory: apolloOptionsFactory,
+                deps: [BASE_MODULE_CONFIG, HttpLink, AuthService],
+            });
+        }
+        else if (config.logging) {
+            console.log('apiUrl is missing, ApolloLink is not initialized');
+        }
+        // Return root module
         return {
             ngModule: BaseModule,
-            providers: [
-                {
-                    provide: BASE_MODULE_CONFIG,
-                    useValue: baseModuleConfig
-                },
-                {
-                    provide: APOLLO_OPTIONS,
-                    useFactory: apolloOptionsFactory,
-                    deps: [BASE_MODULE_CONFIG, HttpLink, AuthService],
-                }
-            ]
+            providers,
         };
     }
 }
 BaseModule.decorators = [
     { type: NgModule, args: [{
                 declarations: elements,
-                exports: elements
+                exports: elements,
             },] }
 ];
 
@@ -1527,13 +1575,29 @@ class GraphQLService {
                 const documentNode = fields
                     ? gql(config.type + '{\n' + graphql + args + fields + '\n}')
                     : gql(config.type + '{\n' + graphql + args + '\n}');
+                // Log
+                if (config.log) {
+                    console.log({ documentNode });
+                }
                 const request = {};
                 request[config.type] = documentNode;
                 // Log
                 if (config.log) {
                     console.log({ request });
                 }
-                const func = config.type === GraphQLRequestType.MUTATION ? 'mutate' : config.type;
+                let func;
+                if (config.type === GraphQLRequestType.MUTATION) {
+                    func = 'mutate';
+                    request[config.type] = documentNode;
+                }
+                else if (config.type === GraphQLRequestType.SUBSCRIPTION) {
+                    func = 'subscribe';
+                    request.query = documentNode;
+                }
+                else {
+                    func = config.type;
+                    request[config.type] = documentNode;
+                }
                 this.apollo[func](request).subscribe((result) => {
                     var _a;
                     const data = ((_a = result === null || result === void 0 ? void 0 : result.data) === null || _a === void 0 ? void 0 : _a[graphql]) !== undefined ? result.data[graphql] : result;
@@ -1551,8 +1615,10 @@ class GraphQLService {
                     else {
                         subscriber.next(config.model.map(data));
                     }
-                    // Done
-                    subscriber.complete();
+                    if (config.type !== GraphQLRequestType.SUBSCRIPTION) {
+                        // Done
+                        subscriber.complete();
+                    }
                 }, (error) => {
                     subscriber.error(error);
                     subscriber.complete();
@@ -1563,14 +1629,23 @@ class GraphQLService {
     /**
      * Get fields / args from IGraphQLTypeCollection
      */
-    graphQLTypeCollectionToStringArray(collection, current = '', result = []) {
+    graphQLTypeCollectionToStringArray(collection, current = '', result = [], cacheNode = []) {
         if (collection) {
             if (collection instanceof GraphQLType) {
                 result.push(current);
             }
             else {
+                if (current === null || current === void 0 ? void 0 : current.includes('.')) {
+                    cacheNode.push(current.split('.')[1]);
+                }
+                else if (current) {
+                    cacheNode.push(current);
+                }
                 for (const key of Object.keys(collection)) {
-                    this.graphQLTypeCollectionToStringArray(collection[key], current ? current + '.' + key : key, result);
+                    if (current === key || cacheNode.includes(key)) {
+                        continue;
+                    }
+                    this.graphQLTypeCollectionToStringArray(collection[key], current ? current + '.' + key : key, result, cacheNode);
                 }
             }
         }
@@ -1580,13 +1655,13 @@ class GraphQLService {
      * Prepare arguments for GraphQL request
      */
     prepareArguments(args, options = {}) {
-        // Config
+        // Init config variables
         const { allowed, level, parent, schemaArgs, usedArgs } = Object.assign({ allowed: null, level: 1, parent: '', schemaArgs: [], usedArgs: [] }, options);
         // Check args
-        if (!args) {
+        if (args === undefined || args === null) {
             return { argsString: '', schemaArgs, usedArgs };
         }
-        // Process args
+        // Init args
         const result = [];
         // Process array
         if (Array.isArray(args)) {
@@ -1599,6 +1674,7 @@ class GraphQLService {
                     }
                     key = allowedKeys === null || allowedKeys === void 0 ? void 0 : allowedKeys.shift();
                 }
+                // Process value
                 result.push(this.prepareArguments(item, {
                     allowed: key ? allowed[key] : null,
                     level: level + 1,
@@ -1607,10 +1683,13 @@ class GraphQLService {
                     usedArgs,
                 }).argsString);
             }
+            // Encapsulation of the array result
             if (result.length) {
+                // Complete result, encapsulated via round brackets
                 if (level === 1) {
                     return { argsString: '(' + result.join(', ') + ')', schemaArgs, usedArgs };
                 }
+                // Deeper result part, encapsulated via square brackets
                 else {
                     return { argsString: '[' + result.join(', ') + ']', schemaArgs, usedArgs };
                 }
@@ -1618,62 +1697,92 @@ class GraphQLService {
         }
         // Process object
         else if (typeof args === 'object') {
+            // Check object is empty
+            if (args && Object.keys(args).length === 0 && Object.getPrototypeOf(args) === Object.prototype) {
+                return { argsString: '{}', schemaArgs, usedArgs };
+            }
+            // Process all object entries
             for (const [key, value] of Object.entries(args)) {
+                // Init data for current entry
                 const currentKey = parent + key;
                 schemaArgs.push(currentKey);
+                // If the allowed key handling is enabled and the current key is not included in the list of allowed keys,
+                // the current key will be skipped
                 if (allowed && !allowed[key]) {
                     continue;
                 }
-                if (value !== undefined && value !== null) {
-                    usedArgs.push(currentKey);
-                    if (value instanceof GraphQLEnum) {
-                        result.push(key + ':' + value.value);
-                        continue;
+                // Skip value if not exists
+                if (value === undefined && value === null) {
+                    continue;
+                }
+                // Add current key to metadata
+                usedArgs.push(currentKey);
+                // Process GraphQLEnum
+                if (value instanceof GraphQLEnum) {
+                    result.push(key + ':' + value.value);
+                    continue;
+                }
+                // Process array
+                else if (Array.isArray(value)) {
+                    result.push(key +
+                        ': [' +
+                        value.map((item) => this.prepareArguments(item, {
+                            allowed: allowed[key],
+                            level: level + 1,
+                            parent: currentKey + '.',
+                            schemaArgs,
+                            usedArgs,
+                        }).argsString) +
+                        ']');
+                    continue;
+                }
+                // Prepare additional result string
+                let additionalResult = key + ': ';
+                // Value is a date object
+                if (typeof value === 'object' && Object.prototype.toString.call(value) === '[object Date]') {
+                    additionalResult += `"""${value.toString()}"""`;
+                }
+                // Value is a string
+                else if (typeof value === 'string') {
+                    // Enum (doesn't need quotation marks)
+                    if (allowed[key].isEnum) {
+                        additionalResult += value;
                     }
-                    if (Array.isArray(value)) {
-                        result.push(key +
-                            ': [' +
-                            value.map((item) => this.prepareArguments(item, {
-                                allowed: allowed[key],
-                                level: level + 1,
-                                parent: currentKey + '.',
-                                schemaArgs,
-                                usedArgs,
-                            }).argsString) +
-                            ']');
-                        continue;
+                    // String
+                    else {
+                        additionalResult += `"""${value.replace(/"/g, '\\"')}"""`;
                     }
-                    result.push(key +
-                        ': ' +
-                        (typeof value === 'string' ||
-                            typeof value === 'boolean' ||
-                            Object.prototype.toString.call(value) === '[object Date]'
-                            ? allowed[key].isEnum
-                                ? value
-                                : typeof value === 'string'
-                                    ? `"""${value.replace(/"/g, '\\"')}"""`
-                                    : Object.prototype.toString.call(value) === '[object Date]'
-                                        ? `"""${value.toString()}"""`
-                                        : value
-                            : this.prepareArguments(value, {
-                                allowed: allowed[key],
-                                level: level + 1,
-                                parent: currentKey + '.',
-                                schemaArgs,
-                                usedArgs,
-                            }).argsString));
                 }
+                // Value is a simple boolean or a number
+                else if (typeof value === 'boolean' || typeof value === 'number') {
+                    additionalResult += value;
+                }
+                // Others
+                else {
+                    additionalResult += this.prepareArguments(value, {
+                        allowed: allowed[key],
+                        level: level + 1,
+                        parent: currentKey + '.',
+                        schemaArgs,
+                        usedArgs,
+                    }).argsString;
+                }
+                // Push deeper part into result array
+                result.push(additionalResult);
             }
+            // Encapsulation of the object result
             if (result.length) {
+                // Complete result, encapsulated via round brackets
                 if (level === 1) {
                     return { argsString: '(' + result.join(', ') + ')', schemaArgs, usedArgs };
                 }
+                // Deeper result part, encapsulated via curly brackets
                 else {
                     return { argsString: '{' + result.join(', ') + '}', schemaArgs, usedArgs };
                 }
             }
         }
-        // Others
+        // Prepare and process other / unknown values as JSON
         else {
             return { argsString: JSON.stringify(args), schemaArgs, usedArgs };
         }
@@ -1830,7 +1939,9 @@ class GraphQLPlusService extends GraphQLService {
                 }
                 subscriber.next(response);
                 this.handleLoader('stop', options);
-                subscriber.complete();
+                if (options.type !== GraphQLRequestType.SUBSCRIPTION) {
+                    subscriber.complete();
+                }
             }, (error) => {
                 if (!options.ignoreErrors) {
                     this.handleError(error, options.excludedErrors);