abapgit-agent 1.6.1 → 1.7.0

package/abap/guidelines/02_exceptions.md

@@ -174,3 +174,27 @@ ENDTRY.
 | Multiple callers need to handle exception | Add RAISING to method definition |
 | Exception should be handled internally | Use TRY-CATCH in implementation |
 | Interface method | Add RAISING to interface, or use TRY-CATCH in class |
+
+### RAISING Clause in Method Calls
+
+The `RAISING` clause **cannot be used in method call statements**. It can only be used in method definitions.
+
+```abap
+" WRONG - syntax error
+lo_handler->read( ... ) RAISING cx_dd_ddl_check.
+
+" CORRECT - use TRY-CATCH
+TRY.
+    lo_handler->read( ... ).
+  CATCH cx_dd_ddl_check.
+    " Handle error
+ENDTRY.
+```
+
+**Correct usage in method definitions:**
+```abap
+" Interface/Class method definition
+METHODS read
+  IMPORTING iv_name TYPE string
+  RAISING   cx_static_check.
+``` |

package/abap/guidelines/03_testing.md

@@ -79,6 +79,25 @@ Examples of compliant names:
 - `test_exec_files` (16 chars)
 - `test_interface` (15 chars)
 
+### Test Methods and RAISING Clause
+
+If a test method calls methods that raise exceptions, add `RAISING` to the method definition:
+
+```abap
+" CORRECT - declare that method can raise exceptions
+METHODS test_validate_ddls FOR TESTING RAISING cx_static_check.
+METHODS test_read_data FOR TESTING RAISING cx_dd_ddl_check.
+
+" Then implement with TRY-CATCH if needed
+METHOD test_validate_ddls.
+  TRY.
+      mo_cut->some_method( ).
+    CATCH cx_static_check.
+      " Handle exception
+  ENDTRY.
+ENDMETHOD.
+```
+
 ### Common Assertions
 
 ```abap

package/abap/guidelines/05_classes.md

@@ -7,6 +7,9 @@
 2. Constructor - line 20
 3. Interfaces - line 35
 4. Inline Declaration - line 50
+5. Abstract Methods - line 99
+6. FINAL Class Limitation - line 117
+7. Working with TYPE any - line 135
 
 ## ABAP Class Definition - Must Use PUBLIC
 
@@ -56,3 +59,111 @@ ENDCLASS.
 
 **Wrong**: `METHOD do_something.` - parameter `iv_param` will be unknown
 **Correct**: `METHOD zif_my_interface~do_something.` - parameters recognized
+
+## Use Interface Type for References
+
+When a class implements an interface, use the **interface type** instead of the class type for references:
+
+```abap
+" Interface definition
+INTERFACE zif_my_interface PUBLIC.
+  METHODS do_something RETURNING VALUE(rv_result) TYPE string.
+ENDINTERFACE.
+
+" Class implements interface
+CLASS zcl_my_class DEFINITION PUBLIC.
+  PUBLIC SECTION.
+    INTERFACES zif_my_interface.
+    CLASS-METHODS get_instance RETURNING VALUE(ro_instance) TYPE REF TO zif_my_interface.
+ENDCLASS.
+
+" Caller - use interface type, not class type
+CLASS zcl_consumer DEFINITION PUBLIC.
+  PRIVATE SECTION.
+    DATA mo_instance TYPE REF TO zif_my_interface.  " <- Use interface type
+ENDCLASS.
+
+METHOD zcl_consumer->do_something.
+  mo_instance = zcl_my_class=>get_instance( ).
+
+  " Call without interface prefix - cleaner code
+  DATA(lv_result) = mo_instance->do_something( ).
+ENDMETHOD.
+```
+
+**Benefits:**
+- Cleaner code: `mo_instance->method( )` instead of `mo_instance->zif_my_interface~method( )`
+- Flexibility: Can swap implementation class without changing caller (dependency inversion)
+- Consistency: All callers use the same interface type
+
+**Key rule:** Always use `REF TO zif_xxx` not `REF TO zcl_xxx` for instance variables and parameters.
+
+## Abstract Methods
+
+The ABSTRACT keyword must come immediately after the method name:
+
+```abap
+" ✅ Correct - ABSTRACT right after method name
+METHODS get_name ABSTRACT
+  RETURNING VALUE(rv_name) TYPE string.
+
+" ❌ Wrong - ABSTRACT after parameters (syntax error)
+METHODS get_name
+  RETURNING VALUE(rv_name) TYPE string
+  ABSTRACT.
+```
+
+## FINAL Class Limitation
+
+A FINAL class cannot have abstract methods. Use plain REDEFINITION instead:
+
+```abap
+" ❌ Wrong in FINAL class - syntax error
+CLASS zcl_my_class DEFINITION PUBLIC FINAL.
+  METHODS parse_request ABSTRACT REDEFINITION.
+ENDCLASS.
+
+" ✅ Correct in FINAL class - use REDEFINITION only
+CLASS zcl_my_class DEFINITION PUBLIC FINAL.
+  METHODS parse_request REDEFINITION.
+ENDCLASS.
+```
+
+## Working with TYPE any
+
+TYPE any cannot be used with CREATE DATA. When a base class defines parameters with TYPE any, use a typed local variable in the subclass:
+
+```abap
+" Base class defines:
+CLASS zcl_base DEFINITION PUBLIC ABSTRACT.
+  PROTECTED SECTION.
+    METHODS parse_request
+      IMPORTING iv_json TYPE string
+      EXPORTING es_request TYPE any.
+ENDCLASS.
+
+" Subclass implementation:
+CLASS zcl_subclass DEFINITION PUBLIC FINAL.
+  INHERITING FROM zcl_base.
+  PROTECTED SECTION.
+    METHODS parse_request REDEFINITION.
+ENDCLASS.
+
+CLASS zcl_subclass IMPLEMENTATION.
+  METHOD parse_request.
+    " Use typed local variable
+    DATA: ls_request TYPE ty_my_params.
+
+    /ui2/cl_json=>deserialize(
+      EXPORTING json = iv_json
+      CHANGING data = ls_request ).
+
+    es_request = ls_request.  " Assign typed to generic
+  ENDMETHOD.
+ENDCLASS.
+```
+
+**Key points:**
+- Declare a local variable with the concrete type
+- Deserialize JSON into the typed local variable
+- Assign to the generic TYPE any parameter

package/abap/guidelines/06_objects.md

@@ -1,110 +1,63 @@
-# ABAP Objects
+# ABAP Object Naming Conventions
 
-**Searchable keywords**: naming convention, Z prefix, namespace, object type, CLAS, INTF, PROG, TABL, DDLS, XML metadata, .abapGit.xml
+**Searchable keywords**: naming convention, Z prefix, namespace, object type, CLAS, INTF, PROG, TABL, DDLS
 
 ## TOPICS IN THIS FILE
-1. XML Metadata Required - line 3
-2. Naming Conventions - line 30
-3. Object Types - line 60
+1. Naming Conventions
+2. ABAP Object Types
+3. XML Metadata (see guidelines/08_abapgit.md)
 
-## Creating New ABAP Objects - XML Metadata Required
-
-**CRITICAL CHECKLIST - Never Forget!**
-
-When creating ANY new ABAP object file, you MUST also create its XML metadata file:
+## Naming Conventions
 
-| ABAP File | Required XML File |
-|-----------|------------------|
-| `zcl_my_class.clas.abap` | `zcl_my_class.clas.xml` |
-| `zif_my_intf.intf.abap` | `zif_my_intf.intf.xml` |
+Use `Z_` or `Y_` prefix for custom objects:
+
+| Object Type | Prefix | Example |
+|-------------|--------|---------|
+| Class | ZCL_ | ZCL_MY_CLASS |
+| Interface | ZIF_ | ZIF_MY_INTERFACE |
+| Program | Z | ZMY_PROGRAM |
+| Package | $ | $MY_PACKAGE |
+| Table | Z | ZMY_TABLE |
+| CDS View | ZC | ZC_MY_VIEW |
+| CDS Entity | ZE | ZE_MY_ENTITY |
+| Data Element | Z | ZMY_ELEMENT |
+| Structure | Z | ZMY_STRUCTURE |
+| Table Type | Z | ZMY_TABLE_TYPE |
 
-**Without XML files**, abapGit will NOT recognize the objects during pull, and they won't be activated.
+## ABAP Object Types
 
-### XML Metadata Format for CLAS
+Common object types in this project:
 
-For `zcl_abgagt_util.clas.abap`, create `zcl_abgagt_util.clas.xml`:
+| Type | Description | File Suffix |
+|------|-------------|-------------|
+| CLAS | Classes | .clas.abap |
+| PROG | Programs | .prog.abap |
+| FUGR | Function Groups | .fugr.abap |
+| INTF | Interfaces | .intf.abap |
+| TABL | Tables | .tabl.abap |
+| STRU | Structures | .stru.abap |
+| DTEL | Data Elements | .dtel.abap |
+| TTYP | Table Types | .ttyp.abap |
+| DDLS | CDS Views | .ddls.asddls |
+| DDLX | CDS Entities | .ddlx.asddlx |
 
-```xml
-<?xml version="1.0" encoding="utf-8"?>
-<abapGit version="v1.0.0" serializer="LCL_OBJECT_CLAS" serializer_version="v1.0.0">
- <asx:abap xmlns:asx="http://www.sap.com/abapxml" version="1.0">
-  <asx:values>
-   <VSEOCLASS>
-    <CLSNAME>ZCL_ABGAGT_UTIL</CLSNAME>
-    <LANGU>E</LANGU>
-    <DESCRIPT>Description</DESCRIPT>
-    <EXPOSURE>2</EXPOSURE>
-    <STATE>1</STATE>
-    <UNICODE>X</UNICODE>
-   </VSEOCLASS>
-  </asx:values>
- </asx:abap>
-</abapGit>
-```
+## XML Metadata
 
-### XML Metadata Format for INTF
+**See guidelines/08_abapgit.md for XML templates.**
 
-For `zif_abgagt_util.intf.abap`, create `zif_abgagt_util.intf.xml`:
+Each ABAP object requires an XML metadata file for abapGit. Quick reference:
 
-```xml
-<?xml version="1.0" encoding="utf-8"?>
-<abapGit version="v1.0.0" serializer="LCL_OBJECT_INTF" serializer_version="v1.0.0">
- <asx:abap xmlns:asx="http://www.sap.com/abapxml" version="1.0">
-  <asx:values>
-   <VSEOINTERF>
-    <CLSNAME>ZIF_ABGAGT_UTIL</CLSNAME>
-    <LANGU>E</LANGU>
-    <DESCRIPT>Description</DESCRIPT>
-    <EXPOSURE>2</EXPOSURE>
-    <STATE>1</STATE>
-    <UNICODE>X</UNICODE>
-   </VSEOINTERF>
-  </asx:values>
- </asx:abap>
-</abapGit>
+```
+Class:         zcl_*.clas.xml
+Interface:     zif_*.intf.xml
+Table:         z*.tabl.xml
+CDS View:      zc_*.ddls.xml
 ```
 
-### Important Notes
-
-1. **CRITICAL: Push to git BEFORE pulling into ABAP**
-   - Always commit and push ABAP files to git first
-   - Then run `abapgit-agent pull` to activate in ABAP
-   - Never run `abapgit-agent pull` without pushing changes first
-
-2. **Only pull ABAP files** - The XML metadata stays in git:
-   ```bash
-   abapgit-agent pull --files zcl_my_class.clas.abap
-   ```
-3. abapGit reads the XML from git to deserialize the ABAP code
-4. XML files are NOT activated in ABAP - they are only for abapGit
-
+**Important**: Always push to git BEFORE running pull:
 ```bash
-# After making changes to ABAP files
 git add .
-git commit -m "Describe changes"
-git push    # CRITICAL: Push BEFORE pulling
-
-# Then validate in ABAP system (single file - fast)
+git commit -m "Changes"
+git push           # CRITICAL: Push FIRST
 abapgit-agent pull --files abap/zcl_my_class.clas.abap
-
-# Or validate all files
-abapgit-agent pull
 ```
-
-## Naming Conventions
-
-- Use `Z_` or `Y_` prefix for custom objects
-- Class names: `ZCL_<NAME>`
-- Interface names: `ZIF_<NAME>`
-- Programs: `Z<NAME>`
-- Package: `$<PROJECT_NAME>`
-
-## ABAP Object Types
-
-Common object types in this project:
-- `CLAS` - Classes
-- `PROG` - Programs
-- `FUGR` - Function Groups
-- `INTF` - Interfaces
-- `TABL` - Tables
-- `DDLS` - Data Definitions

package/abap/guidelines/08_abapgit.md

@@ -27,6 +27,7 @@ Key XML Settings:
   Table DELIVERY:   A=Application, C=Customizing
   CDS SOURCE_TYPE:  V=View, C=Consumption
   Test Class XML:   <WITH_UNIT_TESTS>X</WITH_UNIT_TESTS>
+  Local Classes:    <CLSCCINCL>X</CLSCCINCL>
 ```
 
 **Searchable keywords**: class xml, interface xml, table xml, cds xml, test class, exposure, serializer, abapgit
@@ -69,6 +70,16 @@ abapGit needs XML files to:
 - `STATE`: State (1 = Active)
 - `UNICODE`: Unicode encoding (X = Yes)
 
+**Local Classes**: If the class has local classes (e.g., test doubles), add:
+- `<WITH_UNIT_TESTS>X</WITH_UNIT_TESTS>` - for test classes
+- `<CLSCCINCL>X</CLSCCINCL>` - for local class definitions
+
+**Local Class Files**:
+| File | Purpose |
+|------|---------|
+| `zcl_xxx.clas.locals_def.abap` | Local class definitions |
+| `zcl_xxx.clas.locals_imp.abap` | Local class implementations |
+
 ---
 
 ### Interface (INTF)

package/abap/guidelines/09_unit_testable_code.md

@@ -113,6 +113,27 @@ DATA mo_agent TYPE REF TO zcl_abgagt_agent.   " Concrete class!
 
 This allows you to replace the implementation with test doubles.
 
+### Define Types in Interface
+
+Define types needed by the interface directly in the interface to keep it self-contained:
+
+```abap
+INTERFACE zif_my_handler.
+  " Define types needed by the interface
+  TYPES: BEGIN OF ty_response,
+           success TYPE abap_bool,
+           message TYPE string,
+         END OF ty_response.
+
+  " Use the type in method signatures
+  METHODS process
+    IMPORTING iv_data TYPE string
+    RETURNING VALUE(rs_response) TYPE ty_response.
+ENDINTERFACE.
+```
+
+This makes it easier for test doubles to implement the interface without needing separate type definitions.
+
 ### 3. Make Dependencies Injectable via Constructor
 
 **Use constructor injection, not setter injection.**

package/bin/abapgit-agent

@@ -2067,9 +2067,9 @@ Examples:
               console.log(`     ${description}`);
             }
 
-            // Display source code for classes, interfaces, and CDS views
+            // Display source code for classes, interfaces, CDS views, and programs/source includes
             const source = obj.SOURCE || obj.source || '';
-            if (source && (objType === 'INTF' || objType === 'Interface' || objType === 'CLAS' || objType === 'Class' || objType === 'DDLS' || objType === 'CDS View')) {
+            if (source && (objType === 'INTF' || objType === 'Interface' || objType === 'CLAS' || objType === 'Class' || objType === 'DDLS' || objType === 'CDS View' || objType === 'PROG' || objType === 'Program')) {
               console.log('');
               // Replace escaped newlines with actual newlines and display
               const displaySource = source.replace(/\\n/g, '\n');
@@ -2439,6 +2439,105 @@ Examples:
         break;
       }
 
+      case 'where': {
+        const objectsArgIndex = args.indexOf('--objects');
+        if (objectsArgIndex === -1 || objectsArgIndex + 1 >= args.length) {
+          console.error('Error: --objects parameter required');
+          console.error('Usage: abapgit-agent where --objects <obj1>,<obj2>,... [--type <type>] [--limit <n>] [--json]');
+          console.error('Example: abapgit-agent where --objects ZCL_MY_CLASS');
+          console.error('Example: abapgit-agent where --objects ZIF_MY_INTERFACE');
+          console.error('Example: abapgit-agent where --objects CL_SUT_AUNIT_RUNNER --limit 20');
+          process.exit(1);
+        }
+
+        const objects = args[objectsArgIndex + 1].split(',').map(o => o.trim().toUpperCase());
+        const typeArg = args.indexOf('--type');
+        const type = typeArg !== -1 ? args[typeArg + 1].toUpperCase() : null;
+        const limitArg = args.indexOf('--limit');
+        const limit = limitArg !== -1 ? parseInt(args[limitArg + 1], 10) : 100;
+        const jsonOutput = args.includes('--json');
+
+        console.log(`\n  Where-used list for ${objects.length} object(s)`);
+
+        const config = loadConfig();
+        const csrfToken = await fetchCsrfToken(config);
+
+        const data = {
+          objects: objects,
+          limit: Math.min(Math.max(1, limit), 500)
+        };
+
+        if (type) {
+          data.type = type;
+        }
+
+        const result = await request('POST', '/sap/bc/z_abapgit_agent/where', data, { csrfToken });
+
+        // Handle uppercase keys from ABAP
+        const success = result.SUCCESS || result.success;
+        const whereObjects = result.OBJECTS || result.objects || [];
+        const message = result.MESSAGE || result.message || '';
+        const error = result.ERROR || result.error;
+
+        if (!success || error) {
+          console.error(`\n  Error: ${error || 'Failed to get where-used list'}`);
+          break;
+        }
+
+        if (jsonOutput) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(`\n  ${message}`);
+          console.log('');
+
+          for (let i = 0; i < whereObjects.length; i++) {
+            const obj = whereObjects[i];
+            const objName = obj.NAME || obj.name || `Object ${i + 1}`;
+            const objType = obj.TYPE || obj.type || '';
+            const error = obj.ERROR || obj.error || '';
+            const references = obj.REFERENCES || obj.references || [];
+            const count = obj.COUNT || obj.count || 0;
+
+            // Handle object not found error
+            if (error) {
+              console.log(`  ❌ ${objName} (${objType})`);
+              console.log(`     ${error}`);
+              console.log('');
+              continue;
+            }
+
+            if (count === 0) {
+              console.log(`  ❌ ${objName} (${objType})`);
+              console.log(`     No references found`);
+              console.log('');
+              continue;
+            }
+
+            console.log(`  🔍 ${objName} (${objType})`);
+            console.log(`     Found ${count} reference(s):`);
+            console.log('');
+
+            // Display references - one line format: include → method (type) or include (type)
+            for (let j = 0; j < references.length; j++) {
+              const ref = references[j];
+              const includeName = ref.INCLUDE_NAME || ref.include_name || '';
+              const includeType = ref.INCLUDE_TYPE || ref.include_type || '';
+              const methodName = ref.METHOD_NAME || ref.method_name || '';
+
+              let line;
+              if (methodName) {
+                line = `  ${j + 1}. ${includeName} → ${methodName} (${includeType})`;
+              } else {
+                line = `  ${j + 1}. ${includeName} (${includeType})`;
+              }
+              console.log(line);
+            }
+            console.log('');
+          }
+        }
+        break;
+      }
+
       case 'ref': {
         const refSearch = require('../src/ref-search');
         const topicIndex = args.indexOf('--topic');
@@ -2564,6 +2663,9 @@ Commands:
   view --objects <obj1>,<obj2>,... [--type <type>] [--json]
     View ABAP object definitions from the ABAP system
 
+  where --objects <obj1>,<obj2>,... [--type <type>] [--limit <n>] [--json]
+    Find where-used list for ABAP objects (classes, interfaces, programs)
+
   ref <pattern> [--json]
     Search ABAP reference repositories for patterns. Requires referenceFolder in .abapGitAgent.
 
@@ -2610,6 +2712,10 @@ Examples:
   abapgit-agent view --objects ZIF_MY_INTERFACE --type INTF       # View interface
   abapgit-agent view --objects ZMY_TABLE --type TABL               # View table structure
   abapgit-agent view --objects ZCL_CLASS1,ZCL_CLASS2 --json        # Multiple objects
+  abapgit-agent where --objects ZCL_SUT_AUNIT_RUNNER               # Find where class is used
+  abapgit-agent where --objects ZIF_MY_INTERFACE                   # Find interface implementations
+  abapgit-agent where --objects CL_SUT_AUNIT_RUNNER --limit 20    # Limit results
+  abapgit-agent where --objects ZIF_MY_INTERFACE --json            # JSON output
   abapgit-agent ref "CORRESPONDING"                         # Search all reference repos
   abapgit-agent ref "CX_SY_"                                 # Search exceptions
   abapgit-agent ref --topic exceptions                       # View exception topic

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abapgit-agent",
-  "version": "1.6.1",
+  "version": "1.7.0",
   "description": "ABAP Git Agent - Pull and activate ABAP code via abapGit from any git repository",
   "main": "src/index.js",
   "files": [
@@ -16,6 +16,10 @@
     "start": "node src/server.js",
     "dev": "nodemon src/server.js",
     "test": "jest",
+    "test:all": "node scripts/test-all.js",
+    "test:jest": "jest",
+    "test:aunit": "node scripts/test-all.js --jest --cmd",
+    "test:cmd": "node scripts/test-all.js --jest --aunit",
     "pull": "node bin/abapgit-agent",
     "release": "node scripts/release.js",
     "unrelease": "node scripts/unrelease.js"

package/src/abap-client.js

@@ -459,6 +459,52 @@ class ABAPClient {
 
     return await this.request('POST', '/list', data, { csrfToken: this.csrfToken });
   }
+
+  /**
+   * View ABAP object definitions
+   * @param {Array} objects - Array of object names to view
+   * @param {string} type - Object type (optional, e.g., 'CLAS', 'TABL')
+   * @returns {object} View result with object definitions
+   */
+  async view(objects, type = null) {
+    await this.fetchCsrfToken();
+
+    const data = {
+      objects: objects
+    };
+
+    if (type) {
+      data.type = type;
+    }
+
+    logger.info('Viewing objects', { objects, type, service: 'abapgit-agent' });
+
+    return await this.request('POST', '/view', data, { csrfToken: this.csrfToken });
+  }
+
+  /**
+   * Find where-used list for ABAP objects
+   * @param {Array} objects - Array of object names to search
+   * @param {string} type - Object type (optional)
+   * @param {number} limit - Maximum results (default: 100, max: 500)
+   * @returns {object} Where-used result with found objects
+   */
+  async where(objects, type = null, limit = 100) {
+    await this.fetchCsrfToken();
+
+    const data = {
+      objects: objects,
+      limit: Math.min(Math.max(1, limit), 500)
+    };
+
+    if (type) {
+      data.type = type;
+    }
+
+    logger.info('Finding where-used', { objects, type, limit: data.limit, service: 'abapgit-agent' });
+
+    return await this.request('POST', '/where', data, { csrfToken: this.csrfToken });
+  }
 }
 
 // Singleton instance

package/src/agent.js

@@ -264,6 +264,54 @@ class ABAPGitAgent {
       throw new Error(`List command failed: ${error.message}`);
     }
   }
+
+  /**
+   * View ABAP object definitions
+   * @param {Array} objects - Array of object names to view
+   * @param {string} type - Object type (optional, e.g., 'CLAS', 'TABL')
+   * @returns {object} View result with object definitions
+   */
+  async view(objects, type = null) {
+    logger.info('Viewing objects', { objects, type });
+
+    try {
+      const result = await this.abap.view(objects, type);
+      return {
+        success: result.SUCCESS === 'X' || result.success === 'X' || result.success === true,
+        command: result.COMMAND || result.command || 'VIEW',
+        objects: result.OBJECTS || result.objects || [],
+        error: result.ERROR || result.error || null
+      };
+    } catch (error) {
+      logger.error('View command failed', { error: error.message });
+      throw new Error(`View command failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Find where-used list for ABAP objects
+   * @param {Array} objects - Array of object names to search
+   * @param {string} type - Object type (optional)
+   * @param {number} limit - Maximum results (default: 100, max: 500)
+   * @returns {object} Where-used result with found objects
+   */
+  async where(objects, type = null, limit = 100) {
+    logger.info('Finding where-used', { objects, type, limit });
+
+    try {
+      const result = await this.abap.where(objects, type, limit);
+      return {
+        success: result.SUCCESS === 'X' || result.success === 'X' || result.success === true,
+        command: result.COMMAND || result.command || 'WHERE',
+        objects: result.OBJECTS || result.objects || [],
+        message: result.MESSAGE || result.message || '',
+        error: result.ERROR || result.error || null
+      };
+    } catch (error) {
+      logger.error('Where command failed', { error: error.message });
+      throw new Error(`Where command failed: ${error.message}`);
+    }
+  }
 }
 
 module.exports = {