@linkup-ai/abap-ai 2.0.0

package/dist/knowledge/abap/constructor-expressions.md

@@ -0,0 +1,289 @@
+# Constructor Expressions — VALUE, NEW, CONV, COND, REDUCE, FILTER
+
+## VALUE — Structures and Tables
+
+```abap
+" Structure
+DATA(zs_item) = VALUE zs_order_item( id = 1 name = `Widget` qty = 10 ).
+
+" Clear to initial
+zs_item = VALUE #( ).
+
+" Table with rows
+DATA(zt_items) = VALUE zt_order_items(
+  ( id = 1 name = `Alpha` )
+  ( id = 2 name = `Beta` )
+  ( id = 3 name = `Gamma` ) ).
+
+" BASE — append to existing
+zt_items = VALUE #( BASE zt_items ( id = 4 name = `Delta` ) ).
+
+" LINES OF — merge tables
+zt_items = VALUE #( BASE zt_items ( LINES OF zt_other ) ).
+
+" FOR with counter
+DATA(zt_gen) = VALUE zt_int_tab(
+  FOR i = 1 UNTIL i > 100 ( i ) ).
+
+" FOR from source
+DATA(zt_names) = VALUE string_table(
+  FOR wa IN zt_items ( |{ wa-id }: { wa-name }| ) ).
+
+" FOR with WHERE
+DATA(zt_active) = VALUE zt_order_items(
+  FOR wa IN zt_items WHERE ( status = 'A' ) ( wa ) ).
+
+" FOR with INDEX INTO
+DATA(zt_numbered) = VALUE zt_numbered_tab(
+  FOR wa IN zt_items INDEX INTO idx
+  ( line_no = idx data = wa ) ).
+
+" Nested FOR
+DATA(zt_cross) = VALUE zt_pair_tab(
+  FOR a IN zt_x FOR b IN zt_y
+  ( x = a y = b ) ).
+
+" Deep structure
+DATA(zs_doc) = VALUE zs_document(
+  header = VALUE #( doc_id = '100' title = `Order` )
+  items = VALUE #(
+    ( item_id = 10 desc = `Item A` )
+    ( item_id = 20 desc = `Item B` ) ) ).
+```
+
+## OPTIONAL and DEFAULT
+
+```abap
+" OPTIONAL — returns initial value if not found (no exception)
+DATA(zs_safe) = VALUE #( zt_items[ id = 999 ] OPTIONAL ).
+
+" DEFAULT — returns specified value if not found
+DATA(zs_def) = VALUE #( zt_items[ id = 999 ]
+  DEFAULT VALUE #( id = 0 name = `Not found` ) ).
+```
+
+## NEW — Objects and Data References
+
+```abap
+" Object instantiation
+DATA(zo_proc) = NEW zcl_processor( iv_mode = 'A' ).
+
+" Inline chain
+DATA(lv_valid) = NEW zcl_validator( )->is_valid( lv_input ).
+
+" Data references
+DATA(zr_int) = NEW i( 42 ).
+DATA(zr_str) = NEW string( `Hello` ).
+DATA(zr_struc) = NEW zs_order_item( id = 1 name = `Test` ).
+DATA(zr_tab) = NEW zt_order_items( ( id = 1 ) ( id = 2 ) ).
+```
+
+## CONV — Type Conversion
+
+```abap
+DATA(lv_str) = CONV string( 12345 ).
+DATA(lv_int) = CONV i( '999' ).
+DATA(lv_dec) = CONV decfloat34( 1 / 3 ).
+
+" In method call
+zo_obj->process( CONV string( lv_number ) ).
+```
+
+## CORRESPONDING — Structure/Table Mapping
+
+```abap
+" Basic — map matching component names
+zs_target = CORRESPONDING #( zs_source ).
+
+" BASE — keep existing values, overwrite matches
+zs_target = CORRESPONDING #( BASE ( zs_target ) zs_source ).
+
+" MAPPING — explicit field renaming
+zs_target = CORRESPONDING #( zs_source MAPPING
+  target_field = source_field
+  name = description ).
+
+" EXCEPT — exclude specific fields
+zs_target = CORRESPONDING #( zs_source EXCEPT field1 field2 ).
+
+" DEEP — handle nested structures/tables
+zs_target = CORRESPONDING #( DEEP zs_source ).
+
+" DISCARDING DUPLICATES — for unique key targets
+zt_sorted_target = CORRESPONDING #( zt_source DISCARDING DUPLICATES ).
+
+" RAP entity mapping
+zs_db = CORRESPONDING #( zs_bdef MAPPING FROM ENTITY ).
+zs_bdef = CORRESPONDING #( zs_db MAPPING TO ENTITY ).
+```
+
+## COND — Conditional Expressions
+
+```abap
+" Simple
+DATA(lv_text) = COND string( WHEN lv_flag = abap_true THEN `Yes` ELSE `No` ).
+
+" Multi-branch
+DATA(lv_grade) = COND string(
+  WHEN lv_score >= 90 THEN `A`
+  WHEN lv_score >= 80 THEN `B`
+  WHEN lv_score >= 70 THEN `C`
+  ELSE `F` ).
+
+" With THROW
+DATA(lv_val) = COND #(
+  WHEN lv_valid = abap_true THEN lv_result
+  ELSE THROW zcx_validation_error( ) ).
+
+" With LET
+DATA(lv_size) = COND string(
+  LET len = strlen( lv_text ) IN
+  WHEN len > 100 THEN `Large`
+  WHEN len > 50  THEN `Medium`
+  ELSE `Small` ).
+```
+
+## SWITCH — Value-Based Branching
+
+```abap
+DATA(lv_label) = SWITCH string( lv_code
+  WHEN 'A' THEN `Active`
+  WHEN 'I' THEN `Inactive`
+  WHEN 'D' THEN `Deleted`
+  ELSE `Unknown` ).
+
+" With THROW
+DATA(lv_mapped) = SWITCH #( lv_code
+  WHEN 1 THEN `One`
+  WHEN 2 THEN `Two`
+  ELSE THROW zcx_invalid_code( ) ).
+```
+
+## REDUCE — Aggregation
+
+```abap
+" Sum
+DATA(lv_total) = REDUCE i( INIT s = 0
+  FOR wa IN zt_items
+  NEXT s = s + wa-amount ).
+
+" Concatenation
+DATA(lv_csv) = REDUCE string( INIT str = ``
+  FOR wa IN zt_items
+  NEXT str = str && |{ wa-name },| ).
+
+" Max
+DATA(lv_max) = REDUCE i( INIT m = 0
+  FOR wa IN zt_items
+  NEXT m = COND #( WHEN wa-value > m THEN wa-value ELSE m ) ).
+
+" Conditional count
+DATA(lv_active_count) = REDUCE i( INIT c = 0
+  FOR wa IN zt_items WHERE ( status = 'A' )
+  NEXT c = c + 1 ).
+
+" Multiple accumulators
+DATA(lv_stats) = REDUCE #(
+  INIT sum = 0 cnt = 0
+  FOR wa IN zt_items
+  NEXT sum = sum + wa-amount
+       cnt = cnt + 1 ).
+
+" Build table
+DATA(zt_filtered) = REDUCE string_table(
+  INIT result = VALUE string_table( )
+  FOR wa IN zt_items WHERE ( status = 'A' )
+  NEXT result = VALUE #( BASE result ( wa-name ) ) ).
+```
+
+## FILTER — Table Filtering
+
+```abap
+" Basic (requires sorted/hashed key on filter field)
+DATA(zt_active) = FILTER #( zt_items WHERE status = 'A' ).
+
+" Using secondary key
+DATA(zt_by_cat) = FILTER #( zt_items USING KEY by_category
+  WHERE category = 'X' ).
+
+" EXCEPT — exclude matching
+DATA(zt_rest) = FILTER #( zt_items EXCEPT WHERE status = 'D' ).
+
+" IN with filter table
+DATA zt_vals TYPE SORTED TABLE OF string WITH UNIQUE KEY table_line.
+zt_vals = VALUE #( ( `A` ) ( `B` ) ).
+DATA(zt_matched) = FILTER #( zt_items IN zt_vals WHERE status = table_line ).
+```
+
+## CAST — Type Casting
+
+```abap
+DATA(zo_child) = CAST zcl_child( zo_parent_ref ).
+DATA(zo_intf) = CAST zif_processable( zo_ref ).
+
+" RTTI
+DATA(zo_cls) = CAST cl_abap_classdescr(
+  cl_abap_typedescr=>describe_by_object_ref( zo_ref ) ).
+
+" Safe cast
+TRY.
+    DATA(zo_spec) = CAST zcl_specific( zo_general ).
+  CATCH cx_sy_move_cast_error.
+ENDTRY.
+```
+
+## REF — Data References
+
+```abap
+DATA lv_text TYPE string VALUE `Hello`.
+DATA(zr_ref) = REF #( lv_text ).
+
+" In method call
+zo_obj->process( REF #( zs_structure ) ).
+```
+
+## LET — Local Variables in Expressions
+
+```abap
+DATA(lv_result) = LET a = 10 b = 20 IN a + b.
+
+DATA(zt_offset) = VALUE zt_item_tab(
+  LET base = 1000 IN
+  ( id = base + 1 name = `First` )
+  ( id = base + 2 name = `Second` ) ).
+```
+
+## ALPHA Conversion in String Templates
+
+```abap
+DATA(lv_padded) = |{ '1234' ALPHA = IN WIDTH = 10 }|.   " '0000001234'
+DATA(lv_clean) = |{ '00001234' ALPHA = OUT }|.            " '1234'
+```
+
+---
+
+## Rules
+
+- Use `VALUE #( )` with type inference when target type is clear
+- Use OPTIONAL/DEFAULT for safe table expression access
+- Use CORRESPONDING over manual field-by-field assignment
+- Use REDUCE for functional-style aggregation
+- FILTER requires sorted or hashed key on the filter field
+- Use LET to avoid repeated calculations in expressions
+- NEW for objects, REF for references to existing data
+- COND for if/else chains, SWITCH for value matching
+
+## Anti-Patterns
+
+| Anti-Pattern | Correct Approach |
+|---|---|
+| Manual field-by-field `target-f1 = source-f1` | `CORRESPONDING #( source )` |
+| `IF/ELSEIF` chain to set one variable | `COND #( WHEN ... )` |
+| `CASE` statement to set one variable | `SWITCH #( var WHEN ... )` |
+| `LOOP AT + APPEND` to build derived table | `VALUE #( FOR wa IN source ( ... ) )` |
+| `LOOP AT + sum variable` for aggregation | `REDUCE i( INIT s = 0 FOR ... )` |
+| `LOOP AT + IF + APPEND` for filtering | `FILTER #( itab WHERE ... )` |
+| `CREATE OBJECT oref` | `NEW zcl_class( )` |
+| `MOVE-CORRESPONDING source TO target` | `target = CORRESPONDING #( source )` |
+| Catching table expression exception for existence check | `VALUE #( itab[ ... ] OPTIONAL )` |
+| Nested `IF` for complex conditions | `COND #( LET ... IN WHEN ... )` |

package/dist/knowledge/abap/enhancements.md

@@ -0,0 +1,232 @@
+# Enhancements & Extensibility — BAdI, customer exit, screen exit, modifications, pre-flight checks
+
+## Regra de ouro: verificar ANTES de desenvolver
+
+```
+ANTES de criar qualquer extensão SAP, verificar restrições de slot:
+1. abap_enhancement_spot(name:'SPOT') → single-use? filter? implementações existentes?
+2. Se single-use E já tem implementação ativa → NÃO criar nova, MODIFICAR a existente
+3. Se filter-dependent → verificar se valor de filtro já está ocupado
+4. Se customer exit (SMOD) → verificar se já está em um projeto CMOD
+5. Se transaction code → abap_search para verificar se nome já existe
+6. Se objeto Z com mesmo nome → abap_search antes de abap_create
+```
+
+## Mecanismos de extensão SAP — slots e restrições
+
+| Mecanismo | Restrição de slot | Verificação |
+|-----------|------------------|-------------|
+| BAdI single-use | Apenas 1 implementação ativa | abap_enhancement_spot → ver implementações |
+| BAdI filter-dependent | 1 implementação por valor de filtro | abap_enhancement_spot → ver filtros usados |
+| BAdI multi-use | Sem limite | Pode criar livremente |
+| Customer Exit (SMOD/CMOD) | Function exit só pode estar em 1 projeto CMOD | Verificar em SMOD se já está atribuído |
+| Screen Exit (subscreen) | 1 programa por subscreen area | Verificar se subscreen já está ocupada |
+| Substitution (GGB1) | Limite de steps por evento | Verificar steps existentes na área |
+| Validation (GGB4) | Limite de steps por evento | Verificar steps existentes na área |
+| Modification (SSCR) | 1 correção por include + precisa chave de objeto | Verificar SM04/SSCR, conflito com notas SAP |
+| Transaction code (SE93) | Nome único no sistema | abap_search(query:'TCODE_NAME') |
+| Qualquer objeto Z | Nome único no sistema | abap_search antes de abap_create |
+
+## BAdI — Single-Use vs Multi-Use
+
+```
+Single-Use (apenas 1 implementação ativa):
+- Apenas UMA implementação pode existir e estar ativa
+- Se já existir → MODIFICAR a existente, NÃO criar nova
+- Exemplo: J_1BNF_ADD_DATA (NF-e), BADI_FDCB_SUBBAS01
+
+Multi-Use (múltiplas implementações):
+- Várias implementações podem coexistir
+- Ordem de execução não garantida (exceto com filtro)
+- Exemplo: BADI_MATERIAL_CHECK, BADI_ACC_DOCUMENT
+```
+
+## BAdI — Filter-Dependent
+
+```abap
+" BAdI com filtro: cada implementação responde a um valor de filtro
+" Exemplo: filtro por país (LAND1), tipo de documento (BLART)
+
+" Na definição do BAdI (SE18):
+"   Filter Type: LAND1
+"   Filter Values por implementação: 'BR', 'US', 'DE'
+
+" Na implementação (SE19):
+"   Filter Value = 'BR'  → só executa para Brasil
+
+" RESTRIÇÃO: 2 implementações NÃO podem ter o mesmo valor de filtro
+```
+
+## Customer Exit (SMOD/CMOD)
+
+```
+Tipos de customer exit:
+- Function exit: CALL CUSTOMER-FUNCTION 'NNN' no código standard
+- Screen exit: subscreen area reservada no dynpro standard
+- Menu exit: item de menu adicional
+
+Verificação SMOD:
+1. SMOD → informar nome do exit (ex: SAPMV45A, EXIT_SAPMM06E_001)
+2. Ver se já está atribuído a um projeto CMOD
+3. Se sim → usar o projeto existente ou negociar com o dono
+4. Se não → criar novo projeto CMOD e atribuir
+
+RESTRIÇÃO: um function exit só pode estar em 1 projeto CMOD por vez.
+Se já estiver em outro projeto, precisa remover de lá primeiro.
+```
+
+```abap
+" Exemplo: Customer Exit em SD (USEREXIT)
+" Include: MV45AFZZ (user exits de VA01/VA02)
+
+FORM USEREXIT_SAVE_DOCUMENT_PREPARE.
+  " Validação customizada antes de salvar pedido
+  IF gv_vbak-auart = 'ZOR1'.
+    " lógica customizada
+  ENDIF.
+ENDFORM.
+```
+
+## Screen Exit (Subscreen)
+
+```
+Verificação:
+1. No dynpro standard, identificar a subscreen area (ex: SAPLXM06 0100)
+2. Verificar se já tem programa atribuído
+3. Se sim → modificar o existente
+4. Se não → criar novo e atribuir via CMOD
+
+RESTRIÇÃO: apenas 1 programa pode preencher uma subscreen area.
+```
+
+## Substitution & Validation (OBBH/GGB1/GGB4)
+
+```
+Substitution (GGB1): substitui valor de campo automaticamente
+Validation (GGB4): valida dados e bloqueia gravação se inválido
+
+Verificação:
+1. OBBH (FI) ou GGB1/GGB4 → ver área (ex: Document Header, Line Item)
+2. Ver steps existentes por evento (ex: Document, Before Posting)
+3. Verificar se há limite de steps (normalmente 30-50 por combinação)
+4. Se atingiu limite → consolidar steps existentes
+
+Cada step tem: pré-condição + ação (substitution) ou check (validation)
+```
+
+## Modification (SSCR)
+
+```
+Modificação direta de código SAP standard. ÚLTIMO RECURSO.
+
+Verificação:
+1. Precisa de chave de objeto (Access Key) via SAP Marketplace
+2. Verificar se já existe modificação no mesmo include (SM04, SE95)
+3. Conflita com SAP Notes — a cada nota/SP precisa revalidar
+
+RESTRIÇÃO:
+- 1 correção por include por vez
+- Notas SAP podem sobrescrever a modificação
+- Precisa chave de registro (developer key + object key)
+
+Preferência (do mais seguro ao menos):
+BAdI > Enhancement Point > Customer Exit > Implicit Enhancement > Modification
+```
+
+## Fluxo correto — Implementar BAdI
+
+```
+1. Identificar o BAdI (documentation, debugging, search)
+2. abap_enhancement_spot(name:'BADI_NAME')
+   → Verificar: single-use? filter-dependent? implementações existentes?
+3a. Se single-use COM implementação:
+    → abap_read a implementação existente
+    → abap_write para modificar
+3b. Se single-use SEM implementação:
+    → Criar nova via SE19 ou abap_create
+3c. Se multi-use:
+    → Criar nova implementação
+    → Se filter-dependent: definir valor de filtro
+4. Implementar a interface do BAdI na classe
+5. Ativar
+```
+
+## Implementação BAdI — Estrutura da Classe
+
+```abap
+CLASS zcl_badi_impl DEFINITION PUBLIC FINAL CREATE PUBLIC.
+  PUBLIC SECTION.
+    INTERFACES if_ex_j_1bnf_add_data.
+ENDCLASS.
+
+CLASS zcl_badi_impl IMPLEMENTATION.
+  METHOD if_ex_j_1bnf_add_data~add_data.
+    " Parâmetros vêm da interface do BAdI
+    " Implementação aqui
+  ENDMETHOD.
+ENDCLASS.
+```
+
+## Enhancement Point — Inserir código
+
+```abap
+" Código SAP standard contém:
+ENHANCEMENT-POINT ep_name SPOTS es_name.
+
+" Sua implementação (via SE19 → Enhancement Implementation):
+ENHANCEMENT 1 z_my_enhancement.
+  " Seu código inserido aqui
+  lv_custom_field = 'X'.
+ENDENHANCEMENT.
+```
+
+## Enhancement Section — Substituir bloco
+
+```abap
+" Código SAP standard contém:
+ENHANCEMENT-SECTION es_name SPOTS es_spot.
+  " Código original SAP
+END-ENHANCEMENT-SECTION.
+
+" Sua implementação SUBSTITUI o bloco inteiro:
+ENHANCEMENT 1 z_my_enhancement.
+  " Seu código substituto (documentar original em comentário!)
+END-ENHANCEMENT.
+```
+
+## Encontrar BAdIs de um processo
+
+```abap
+" Método 1: Debugging
+" Breakpoint em CL_EXITHANDLER=>GET_INSTANCE → executar transação
+
+" Método 2: Search
+" abap_search(query:'BADI*MATERIAL*', object_type:'ENHS/ES')
+
+" Método 3: Documentação SAP
+" SE18 → procurar por área funcional
+```
+
+## Regras
+
+- SEMPRE verificar slot antes de desenvolver (single-use, filtro, CMOD, subscreen)
+- Single-use com implementação existente → modificar, NUNCA criar nova
+- Filter-dependent: cada implementação precisa de filtro único
+- Customer exit: verificar se function exit já está em projeto CMOD
+- Enhancement Points/Sections: código SAP muda em upgrades — testar após SP/EHP
+- Preferir BAdI > Enhancement Point > Customer Exit > Modification
+- Documentar qual mecanismo foi usado (comentário no código + transport description)
+- Testar com `abap_unit_test` após implementar — extensões afetam processos críticos
+
+## Anti-Patterns
+
+| Anti-Pattern | Correto |
+|---|---|
+| Criar implementação de BAdI single-use sem verificar se já existe | Sempre abap_enhancement_spot ANTES |
+| Criar customer exit sem verificar SMOD/CMOD | Verificar atribuição antes |
+| Usar Modification quando BAdI existe | BAdI é mais seguro e upgrade-safe |
+| Modificar Enhancement Section sem documentar original | Comentar código original substituído |
+| Ignorar filtro em BAdI filter-dependent | Definir filtro correto ou executa para TUDO |
+| Implementar sem testar processo completo | Testar cenário end-to-end |
+| Deixar implementação inativa sem documentar por quê | Ativar ou deletar |
+| Desenvolver extensão sem verificar versão PRD | abap_object_versions antes de modificar |