529 lines
18 KiB
Bash
Executable File
529 lines
18 KiB
Bash
Executable File
#!/bin/bash
|
|
|
|
# gRPC Layer Generator from Existing Context
|
|
# Usage: ./scripts/grpc.sh [OPTIONS]
|
|
# Options:
|
|
# -d, --dir PATH Custom directory structure of the existing context (e.g., master/reference/province) (required)
|
|
# -e, --entity-file PATH Optional path to the entity file if not named 'entity.go'
|
|
# -v, --verbose Verbose output
|
|
# -h, --help Show help
|
|
|
|
set -uo pipefail
|
|
|
|
# Colors for output
|
|
readonly RED='\033[0;31m'
|
|
readonly GREEN='\033[0;32m'
|
|
readonly YELLOW='\033[1;33m'
|
|
readonly BLUE='\033[0;34m'
|
|
readonly PURPLE='\033[0;35m'
|
|
readonly CYAN='\033[0;36m'
|
|
readonly WHITE='\033[1;37m'
|
|
readonly NC='\033[0m' # No Color
|
|
|
|
# Configuration
|
|
readonly SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
|
|
readonly PROJECT_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
|
|
readonly INTERNAL_DIR="${PROJECT_ROOT}/internal"
|
|
|
|
# Global variables
|
|
VERBOSE=false
|
|
CUSTOM_DIR=""
|
|
ENTITY_FILE_NAME="entity.go"
|
|
|
|
# --- Helper Functions ---
|
|
|
|
# Logging functions
|
|
log_info() { echo -e "${BLUE}[INFO]${NC} $1"; }
|
|
log_success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; }
|
|
log_warning() { echo -e "${YELLOW}[WARNING]${NC} $1"; }
|
|
log_error() { echo -e "${RED}[ERROR]${NC} $1"; }
|
|
log_verbose() { [[ "$VERBOSE" == true ]] && echo -e "${CYAN}[VERBOSE]${NC} $1"; }
|
|
log_header() { echo -e "\n${PURPLE}==== $1 ====${NC}\n"; }
|
|
|
|
# Help function
|
|
show_help() {
|
|
cat << EOF
|
|
${WHITE}gRPC Layer Generator from Existing Context${NC}
|
|
|
|
This script generates the gRPC layer (.proto, handler, mapper)
|
|
by parsing an existing Go entity file.
|
|
|
|
${YELLOW}Usage:${NC}
|
|
$(basename "$0") -d CONTEXT_DIR [OPTIONS]
|
|
|
|
${YELLOW}Required Options:${NC}
|
|
-d, --dir PATH Path to the existing context directory relative to 'internal/'
|
|
(e.g., master/reference/province)
|
|
|
|
${YELLOW}Optional Options:${NC}
|
|
-e, --entity-file NAME File name of the source entity (default: entity.go)
|
|
-v, --verbose Verbose output
|
|
-h, --help Show this help message
|
|
|
|
${YELLOW}Example:${NC}
|
|
# Generate gRPC layer for an existing 'province' context
|
|
$(basename "$0") -d master/reference/province
|
|
EOF
|
|
}
|
|
|
|
# PascalCase from snake_case or kebab-case
|
|
to_pascal_case() {
|
|
echo "$1" | sed -E 's/(^|[-_.])([a-zA-Z])/\U\2/g'
|
|
}
|
|
|
|
# snake_case from PascalCase
|
|
to_snake_case() {
|
|
echo "$1" | sed -E 's/([A-Z])/_\L\1/g' | sed 's/^_//'
|
|
}
|
|
|
|
# camelCase from snake_case or kebab-case
|
|
to_camel_case() {
|
|
local pascal
|
|
pascal=$(to_pascal_case "$1")
|
|
echo "$(echo "${pascal:0:1}" | tr '[:upper:]' '[:lower:]')${pascal:1}"
|
|
}
|
|
|
|
# Extract package name from custom directory structure
|
|
# For path master/reference/province, returns "province"
|
|
extract_package_name() {
|
|
basename "$1"
|
|
}
|
|
|
|
# Convert Go type to Protobuf type
|
|
go_to_proto_type() {
|
|
local go_type="$1"
|
|
local is_pointer="${2:-false}"
|
|
|
|
local proto_type="string" # Default
|
|
case "$go_type" in
|
|
"int"|"int32"|"int64") proto_type="int64" ;;
|
|
"string") proto_type="string" ;;
|
|
"bool") proto_type="bool" ;;
|
|
"time.Time") proto_type="google.protobuf.Timestamp" ;;
|
|
"float32"|"float64") proto_type="double" ;;
|
|
"uuid.UUID") proto_type="string" ;;
|
|
esac
|
|
|
|
# Use optional for pointer fields (nullable) in proto3
|
|
if [[ "$is_pointer" == "true" ]]; then
|
|
echo "optional $proto_type"
|
|
else
|
|
echo "$proto_type"
|
|
fi
|
|
}
|
|
|
|
# --- Core Logic ---
|
|
|
|
# Parse command line arguments
|
|
parse_args() {
|
|
if [[ "$#" -eq 0 ]]; then
|
|
show_help
|
|
exit 1
|
|
fi
|
|
|
|
while [[ $# -gt 0 ]]; do
|
|
case $1 in
|
|
-d|--dir)
|
|
CUSTOM_DIR="$2"
|
|
shift 2
|
|
;;
|
|
-e|--entity-file)
|
|
ENTITY_FILE_NAME="$2"
|
|
shift 2
|
|
;;
|
|
-v|--verbose)
|
|
VERBOSE=true
|
|
shift
|
|
;;
|
|
-h|--help)
|
|
show_help
|
|
exit 0
|
|
;;
|
|
*)
|
|
log_error "Unknown option: $1"
|
|
show_help
|
|
exit 1
|
|
;;
|
|
esac
|
|
done
|
|
|
|
# Validate required arguments
|
|
if [[ -z "$CUSTOM_DIR" ]]; then
|
|
log_error "Context directory is required. Use -d or --dir."
|
|
exit 1
|
|
fi
|
|
}
|
|
|
|
# Extract struct info from Go entity file
|
|
parse_go_context() {
|
|
local context_path="$1"
|
|
local entity_filename="$2"
|
|
local entity_file_path="${INTERNAL_DIR}/${context_path}/${entity_filename}"
|
|
|
|
log_info "Parsing Go context from: $entity_file_path"
|
|
|
|
if [[ ! -f "$entity_file_path" ]]; then
|
|
log_error "Entity file not found: $entity_file_path"
|
|
return 1
|
|
fi
|
|
|
|
# Extract struct name (e.g., Province)
|
|
local struct_name
|
|
struct_name=$(grep -m 1 -E "type .* struct" "$entity_file_path" | awk '{print $2}')
|
|
if [[ -z "$struct_name" ]]; then
|
|
log_error "Could not find a struct definition in $entity_file_path"
|
|
return 1
|
|
fi
|
|
log_verbose "Found struct: $struct_name"
|
|
|
|
# Reset arrays
|
|
PARSED_FIELDS=()
|
|
PARSED_PRIMARY_KEY_GO_NAME=""
|
|
PARSED_PRIMARY_KEY_GO_TYPE=""
|
|
|
|
# Use awk to isolate the struct definition block
|
|
local fields_block
|
|
fields_block=$(awk -v struct_name="$struct_name" '$0 ~ "type " struct_name " struct \\{" {p=1; next} p && /}/ {p=0} p' "$entity_file_path")
|
|
|
|
while IFS= read -r line; do
|
|
# Trim leading/trailing whitespace
|
|
local trimmed_line
|
|
trimmed_line=$(echo "$line" | sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//')
|
|
|
|
# Skip empty, comment, or closing brace lines
|
|
if [[ -z "$trimmed_line" || "$trimmed_line" =~ ^// || "$trimmed_line" == "}" ]]; then
|
|
continue
|
|
fi
|
|
|
|
local go_field_name go_type is_pointer db_name
|
|
go_field_name=$(echo "$trimmed_line" | awk '{print $1}')
|
|
go_type=$(echo "$trimmed_line" | awk '{print $2}')
|
|
is_pointer="false"
|
|
|
|
if [[ "$go_type" == "*"* ]]; then
|
|
is_pointer="true"
|
|
go_type=${go_type#\*} # Remove the leading '*'
|
|
fi
|
|
|
|
# Extract db tag for snake_case name, fallback to json tag, then to converting field name
|
|
db_name=$(echo "$trimmed_line" | grep -o 'db:"[^"]*"' | cut -d'"' -f2)
|
|
if [[ -z "$db_name" ]]; then
|
|
db_name=$(echo "$trimmed_line" | grep -o 'json:"[^"]*"' | cut -d'"' -f2)
|
|
fi
|
|
if [[ -z "$db_name" ]]; then
|
|
db_name=$(to_snake_case "$go_field_name")
|
|
fi
|
|
|
|
PARSED_FIELDS+=("${go_field_name}|${go_type}|${is_pointer}|${db_name}")
|
|
log_verbose "Found field: $go_field_name ($go_type, pointer: $is_pointer, db_name: $db_name)"
|
|
|
|
# Heuristic to find the Primary Key
|
|
if [[ -z "$PARSED_PRIMARY_KEY_GO_NAME" && ("$go_field_name" == "Id" || "$db_name" == "id") ]]; then
|
|
PARSED_PRIMARY_KEY_GO_NAME="$go_field_name"
|
|
PARSED_PRIMARY_KEY_GO_TYPE="$go_type"
|
|
fi
|
|
|
|
done <<< "$fields_block"
|
|
|
|
# If no PK found by heuristic, assume the first field is the PK
|
|
if [[ -z "$PARSED_PRIMARY_KEY_GO_NAME" && ${#PARSED_FIELDS[@]} -gt 0 ]]; then
|
|
IFS='|' read -r go_field_name go_type _ _ <<< "${PARSED_FIELDS[0]}"
|
|
PARSED_PRIMARY_KEY_GO_NAME="$go_field_name"
|
|
PARSED_PRIMARY_KEY_GO_TYPE="$go_type"
|
|
log_warning "Could not determine primary key, assuming first field '${go_field_name}' is the PK."
|
|
fi
|
|
|
|
# Store in global variables for later use
|
|
export CLEAN_NAME="$struct_name"
|
|
export GO_PK_NAME="$PARSED_PRIMARY_KEY_GO_NAME"
|
|
export GO_PK_TYPE="$PARSED_PRIMARY_KEY_GO_TYPE"
|
|
export PROTO_PK_TYPE=$(go_to_proto_type "$PARSED_PRIMARY_KEY_GO_TYPE" "false")
|
|
|
|
log_success "Successfully parsed context for: $struct_name"
|
|
}
|
|
|
|
# Generate gRPC proto file
|
|
generate_proto_file() {
|
|
local package_name
|
|
package_name=$(extract_package_name "$CUSTOM_DIR")
|
|
|
|
local proto_dir="${INTERNAL_DIR}/infrastructure/transport/grpc/proto/${CUSTOM_DIR}/v1"
|
|
log_info "Generating proto file in: $proto_dir"
|
|
mkdir -p "$proto_dir"
|
|
|
|
local proto_file="${proto_dir}/${package_name}.proto"
|
|
|
|
if [ -f "$proto_file" ]; then
|
|
log_warning "File already exists, skipping: $proto_file"
|
|
return
|
|
fi
|
|
|
|
log_info "Generating file: $proto_file"
|
|
cat > "$proto_file" << EOF
|
|
syntax = "proto3";
|
|
|
|
package ${package_name}.v1;
|
|
|
|
option go_package = "service/internal/infrastructure/transport/grpc/gen/${CUSTOM_DIR}/v1;${package_name}v1";
|
|
|
|
import "google/protobuf/timestamp.proto";
|
|
import "google/protobuf/empty.proto";
|
|
|
|
// Service definition for ${CLEAN_NAME}.
|
|
service ${CLEAN_NAME}Service {
|
|
rpc Get${CLEAN_NAME}(Get${CLEAN_NAME}Request) returns (${CLEAN_NAME}Response);
|
|
rpc List${CLEAN_NAME}s(List${CLEAN_NAME}sRequest) returns (List${CLEAN_NAME}sResponse);
|
|
rpc Create${CLEAN_NAME}(Create${CLEAN_NAME}Request) returns (${CLEAN_NAME}Response);
|
|
rpc Update${CLEAN_NAME}(Update${CLEAN_NAME}Request) returns (${CLEAN_NAME}Response);
|
|
rpc Delete${CLEAN_NAME}(Delete${CLEAN_NAME}Request) returns (google.protobuf.Empty);
|
|
}
|
|
|
|
// The main message representing a ${CLEAN_NAME}.
|
|
message ${CLEAN_NAME} {
|
|
EOF
|
|
|
|
local field_index=1
|
|
for field in "${PARSED_FIELDS[@]}"; do
|
|
IFS='|' read -r go_field_name go_type is_pointer db_name <<< "$field"
|
|
local proto_field_name="$db_name"
|
|
local proto_type
|
|
proto_type=$(go_to_proto_type "$go_type" "$is_pointer")
|
|
|
|
echo " ${proto_type} ${proto_field_name} = ${field_index};" >> "$proto_file"
|
|
((field_index++))
|
|
done
|
|
|
|
cat >> "$proto_file" << EOF
|
|
}
|
|
|
|
// --- Request/Response Messages ---
|
|
|
|
message Get${CLEAN_NAME}Request {
|
|
${PROTO_PK_TYPE} id = 1;
|
|
}
|
|
|
|
message ${CLEAN_NAME}Response {
|
|
${CLEAN_NAME} data = 1;
|
|
}
|
|
|
|
message List${CLEAN_NAME}sRequest {
|
|
int32 page = 1;
|
|
int32 page_size = 2;
|
|
// TODO: Add filter fields here if needed
|
|
}
|
|
|
|
message List${CLEAN_NAME}sResponse {
|
|
repeated ${CLEAN_NAME} data = 1;
|
|
int64 total = 2;
|
|
}
|
|
|
|
message Create${CLEAN_NAME}Request {
|
|
EOF
|
|
|
|
local create_field_index=1
|
|
for field in "${PARSED_FIELDS[@]}"; do
|
|
IFS='|' read -r go_field_name go_type is_pointer db_name <<< "$field"
|
|
# Skip PK, created_at, updated_at, deleted_at for create requests
|
|
if [[ "$db_name" == "id" || "$db_name" == "created_at" || "$db_name" == "updated_at" || "$db_name" == "deleted_at" ]]; then
|
|
continue
|
|
fi
|
|
local proto_field_name="$db_name"
|
|
local proto_type
|
|
proto_type=$(go_to_proto_type "$go_type" "false") # All fields are required for create
|
|
|
|
echo " ${proto_type} ${proto_field_name} = ${create_field_index};" >> "$proto_file"
|
|
((create_field_index++))
|
|
done
|
|
|
|
cat >> "$proto_file" << EOF
|
|
}
|
|
|
|
message Update${CLEAN_NAME}Request {
|
|
${PROTO_PK_TYPE} id = 1;
|
|
EOF
|
|
|
|
local update_field_index=2
|
|
for field in "${PARSED_FIELDS[@]}"; do
|
|
IFS='|' read -r go_field_name go_type is_pointer db_name <<< "$field"
|
|
if [[ "$db_name" == "id" || "$db_name" == "created_at" || "$db_name" == "updated_at" || "$db_name" == "deleted_at" ]]; then
|
|
continue
|
|
fi
|
|
local proto_field_name="$db_name"
|
|
# For update, all fields are optional
|
|
local proto_type
|
|
proto_type=$(go_to_proto_type "$go_type" "true")
|
|
|
|
echo " ${proto_type} ${proto_field_name} = ${update_field_index};" >> "$proto_file"
|
|
((update_field_index++))
|
|
done
|
|
|
|
cat >> "$proto_file" << EOF
|
|
}
|
|
|
|
message Delete${CLEAN_NAME}Request {
|
|
${PROTO_PK_TYPE} id = 1;
|
|
}
|
|
EOF
|
|
|
|
log_success "Generated proto file: ${package_name}.proto"
|
|
|
|
log_info "Running proto compiler to generate Go code from this new .proto file..."
|
|
# Assuming you have a script to compile protos, or you can do it directly.
|
|
# This is an example command.
|
|
if command -v protoc &> /dev/null; then
|
|
protoc --go_out=. --go_opt=paths=source_relative \
|
|
--go-grpc_out=. --go-grpc_opt=paths=source_relative \
|
|
"${proto_dir}/${package_name}.proto"
|
|
log_success "protoc compilation successful."
|
|
else
|
|
log_warning "protoc command not found. Please compile the .proto file manually."
|
|
fi
|
|
}
|
|
|
|
# Generate gRPC handler and mapper file
|
|
generate_grpc_handler() {
|
|
local package_name
|
|
package_name=$(extract_package_name "$CUSTOM_DIR")
|
|
|
|
local target_dir="${INTERNAL_DIR}/infrastructure/transport/grpc/handlers/${CUSTOM_DIR}"
|
|
log_info "Generating gRPC handler and mapper in: $target_dir"
|
|
mkdir -p "$target_dir"
|
|
|
|
local handler_file_name="${target_dir}/${package_name}_grpc_handler.go"
|
|
local mapper_file_name="${target_dir}/${package_name}_grpc_mapper.go"
|
|
|
|
if [ -f "$handler_file_name" ]; then
|
|
log_warning "File already exists, skipping: $handler_file_name"
|
|
else
|
|
log_info "Generating file: $handler_file_name"
|
|
cat > "$handler_file_name" << EOF
|
|
package handlers
|
|
|
|
import (
|
|
"context"
|
|
|
|
"service/internal/infrastructure/transport/grpc/gen/${CUSTOM_DIR}/v1"
|
|
${package_name}Service "service/internal/${CUSTOM_DIR}"
|
|
"service/pkg/errors"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
"google.golang.org/protobuf/types/known/emptypb"
|
|
)
|
|
|
|
type ${CLEAN_NAME}GrpcHandler struct {
|
|
${package_name}v1.Unimplemented${CLEAN_NAME}ServiceServer
|
|
service ${package_name}Service.Service
|
|
}
|
|
|
|
func New${CLEAN_NAME}GrpcHandler(service ${package_name}Service.Service) *${CLEAN_NAME}GrpcHandler {
|
|
return &${CLEAN_NAME}GrpcHandler{service: service}
|
|
}
|
|
|
|
func (h *${CLEAN_NAME}GrpcHandler) Get${CLEAN_NAME}(ctx context.Context, req *${package_name}v1.Get${CLEAN_NAME}Request) (*${package_name}v1.${CLEAN_NAME}Response, error) {
|
|
res, err := h.service.GetDetail(ctx, req.GetId())
|
|
if err != nil {
|
|
appErr := errors.FromError(err)
|
|
return nil, status.Error(appErr.GRPCStatus(), appErr.Error())
|
|
}
|
|
return &${package_name}v1.${CLEAN_NAME}Response{Data: mapResponseToProto(res)}, nil
|
|
}
|
|
|
|
// Add other handler methods (List, Create, Update, Delete) here...
|
|
|
|
EOF
|
|
log_success "Generated gRPC handler file: ${package_name}_grpc_handler.go"
|
|
fi
|
|
|
|
if [ -f "$mapper_file_name" ]; then
|
|
log_warning "File already exists, skipping: $mapper_file_name"
|
|
else
|
|
log_info "Generating file: $mapper_file_name"
|
|
cat > "$mapper_file_name" << EOF
|
|
package handlers
|
|
|
|
import (
|
|
"service/internal/infrastructure/transport/grpc/gen/${CUSTOM_DIR}/v1"
|
|
${package_name}Service "service/internal/${CUSTOM_DIR}"
|
|
"google.golang.org/protobuf/types/known/timestamppb"
|
|
)
|
|
|
|
// mapResponseToProto converts the service DTO to a Protobuf message.
|
|
func mapResponseToProto(dto *${package_name}Service.${CLEAN_NAME}Response) *${package_name}v1.${CLEAN_NAME} {
|
|
if dto == nil {
|
|
return nil
|
|
}
|
|
return &${package_name}v1.${CLEAN_NAME}{
|
|
EOF
|
|
for field in "${PARSED_FIELDS[@]}"; do
|
|
IFS='|' read -r go_field_name go_type is_pointer db_name <<< "$field"
|
|
local proto_field_name="$db_name"
|
|
local go_pascal_field
|
|
go_pascal_field=$(to_pascal_case "$go_field_name")
|
|
|
|
# Handle time.Time and *time.Time specifically
|
|
if [[ "$go_type" == "time.Time" ]]; then
|
|
if [[ "$is_pointer" == "true" ]]; then
|
|
echo " ${proto_field_name}: timestamppb.New(*dto.${go_pascal_field})," >> "$mapper_file_name"
|
|
else
|
|
echo " ${proto_field_name}: timestamppb.New(dto.${go_pascal_field})," >> "$mapper_file_name"
|
|
fi
|
|
else
|
|
echo " ${proto_field_name}: dto.${go_pascal_field}," >> "$mapper_file_name"
|
|
fi
|
|
done
|
|
cat >> "$mapper_file_name" << EOF
|
|
}
|
|
}
|
|
|
|
// Add other mappers (e.g., mapCreateProtoToRequest) here...
|
|
EOF
|
|
log_success "Generated gRPC mapper file: ${package_name}_grpc_mapper.go"
|
|
fi
|
|
}
|
|
|
|
# --- Main Execution ---
|
|
|
|
main() {
|
|
log_header "gRPC Layer Generator"
|
|
parse_args "$@"
|
|
|
|
if ! parse_go_context "$CUSTOM_DIR" "$ENTITY_FILE_NAME"; then
|
|
exit 1
|
|
fi
|
|
|
|
generate_proto_file
|
|
generate_grpc_handler
|
|
|
|
local package_name
|
|
package_name=$(extract_package_name "$CUSTOM_DIR")
|
|
|
|
echo -e "\n${PURPLE}================================================================${NC}"
|
|
echo -e "${GREEN}✨ gRPC LAYER FOR [${CLEAN_NAME}] GENERATED SUCCESSFULLY! ✨${NC}"
|
|
echo -e "${PURPLE}================================================================${NC}\n"
|
|
|
|
echo -e "${YELLOW}🚀 NEXT STEPS TO ACTIVATE YOUR gRPC MODULE:${NC}\n"
|
|
|
|
echo -e "${CYAN}1. Review Generated Files:${NC}"
|
|
echo -e " - ${WHITE}internal/infrastructure/transport/grpc/proto/${CUSTOM_DIR}/v1/${package_name}.proto${NC}"
|
|
echo -e " - ${WHITE}internal/infrastructure/transport/grpc/handlers/${CUSTOM_DIR}/${package_name}_grpc_handler.go${NC}"
|
|
echo -e " - ${WHITE}internal/infrastructure/transport/grpc/handlers/${CUSTOM_DIR}/${package_name}_grpc_mapper.go${NC}"
|
|
echo -e " Lengkapi implementasi untuk method List, Create, Update, Delete di handler dan mapper.\n"
|
|
|
|
echo -e "${CYAN}2. Registrasi gRPC Handler (misal di cmd/grpc/server.go):${NC}"
|
|
echo -e " Import packages:"
|
|
echo -e " ${WHITE}gen${CLEAN_NAME} \"service/internal/infrastructure/transport/grpc/gen/${CUSTOM_DIR}/v1\"${NC}"
|
|
echo -e " ${WHITE}grpc${CLEAN_NAME}Handler \"service/internal/infrastructure/transport/grpc/handlers/${CUSTOM_DIR}\"${NC}\n"
|
|
echo -e " Inisialisasi dan registrasi handler:"
|
|
echo -e " ${WHITE}// (Asumsikan ${package_name}Svc sudah diinisialisasi)${NC}"
|
|
echo -e " ${WHITE}${package_name}GrpcHandler := grpc${CLEAN_NAME}Handler.New${CLEAN_NAME}GrpcHandler(${package_name}Svc)${NC}"
|
|
echo -e " ${WHITE}gen${CLEAN_NAME}.Register${CLEAN_NAME}ServiceServer(grpcServer, ${package_name}GrpcHandler)${NC}\n"
|
|
|
|
echo -e "${CYAN}3. Rapihkan Dependencies:${NC}"
|
|
echo -e " ${WHITE}go mod tidy${NC}\n"
|
|
}
|
|
|
|
# Run main function with all arguments
|
|
main "$@"
|
|
|
|
|