import "github.com/gofiber/fiber/v2"

app := fiber.New(fiber.Config{
    Prefork:       false,
    CaseSensitive: true,
    StrictRouting: true,
    ServerHeader:  "MStore-Backend",
})

import (
    "gorm.io/gorm"
    "gorm.io/driver/mysql"
)

dsn := "user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True"
db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})

import "github.com/golang-jwt/jwt/v5"

token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
    "user_id": 123,
    "exp":     time.Now().Add(24 * time.Hour).Unix(),
})

tokenString, err := token.SignedString([]byte(secretKey))

import "github.com/go-resty/resty/v2"

client := resty.New()
resp, err := client.R().
    SetBasicAuth(apiKey, "").
    SetHeader("Content-Type", "application/json").
    SetBody(payload).
    Post("https://api.xendit.co/qr_codes")

import "github.com/nats-io/nats.go"

nc, err := nats.Connect("nats://localhost:4222")
defer nc.Close()

// Publish
nc.Publish("transaction.created", []byte(payload))

// Subscribe
nc.Subscribe("transaction.created", func(m *nats.Msg) {
    // Handle message
})

import "go.uber.org/zap"

logger, _ := zap.NewProduction()
defer logger.Sync()

logger.Info("transaction created",
    zap.String("transaction_code", code),
    zap.Int64("amount", 50000),
)

import (
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/trace"
)

tracer := otel.Tracer("mstore-backend")
ctx, span := tracer.Start(ctx, "CreateTransaction")
defer span.End()

span.SetAttributes(
    attribute.String("transaction.code", code),
    attribute.Int64("transaction.amount", amount),
)

meter := otel.Meter("mstore-backend")
counter, _ := meter.Int64Counter("transactions.created")

counter.Add(ctx, 1, 
    metric.WithAttributes(
        attribute.String("branch", branchCode),
        attribute.String("payment_method", "CASH"),
    ),
)

import "github.com/go-playground/validator/v10"

type CreateTransactionRequest struct {
    BranchCode string  `json:"branch_code" validate:"required"`
    Amount     float64 `json:"amount" validate:"required,gt=0"`
}

validate := validator.New()
err := validate.Struct(req)

Feature: Transaction Creation
  Scenario: Create CASH transaction
    Given I am authenticated as cashier
    When I create a transaction with amount 50000
    Then transaction should be created successfully
    And status should be "draft"

import "github.com/spf13/cobra"

var rootCmd = &cobra.Command{
    Use:   "mstore",
    Short: "MStore Backend CLI",
}

var serverCmd = &cobra.Command{
    Use:   "server",
    Short: "Start HTTP server",
    Run: func(cmd *cobra.Command, args []string) {
        // Start server
    },
}

rootCmd.AddCommand(serverCmd)
rootCmd.Execute()

import "github.com/xuri/excelize/v2"

f := excelize.NewFile()
f.SetCellValue("Sheet1", "A1", "Product Name")
f.SetCellValue("Sheet1", "B1", "Price")
f.SaveAs("products.xlsx")

import "github.com/nicksnyder/go-i18n/v2/i18n"

bundle := i18n.NewBundle(language.English)
bundle.RegisterUnmarshalFunc("json", json.Unmarshal)
bundle.LoadMessageFile("locale/en.json")

localizer := i18n.NewLocalizer(bundle, "id")
msg := localizer.MustLocalize(&i18n.LocalizeConfig{
    MessageID: "transaction.created",
})

type Query {
  transaction(id: ID!): Transaction
  transactions(filter: TransactionFilter): [Transaction!]!
}

type Transaction {
  id: ID!
  transactionCode: String!
  amount: Float!
  status: TransactionStatus!
}

import "github.com/expr-lang/expr"

// Dynamic discount rule
code := `amount > 100000 ? amount * 0.1 : 0`
program, _ := expr.Compile(code)

env := map[string]interface{}{
    "amount": 150000,
}
discount, _ := expr.Run(program, env)