@rivascva/dt-idl 1.1.43 → 1.1.45

package/.githooks/pre-commit-config.yaml

@@ -6,6 +6,13 @@ repos:
         name: check newlines
       - id: check-yaml
         name: check yaml
+  - repo: https://github.com/dnephin/pre-commit-golang
+    rev: v0.5.1
+    hooks:
+      - id: golangci-lint
+        name: golangci-lint
+      - id: go-mod-tidy
+        name: go mod tidy
   - repo: local
     hooks:
       - id: gen-services

package/.github/workflows/publish.yaml

@@ -2,7 +2,7 @@ name: Publish
 
 on:
   push:
-    paths: ['ts/**/*']
+    paths: ['ts/**/*', 'go/**/*']
     branches: [main]
   workflow_dispatch:
     # allows manual runs

package/.golangci.yaml

@@ -0,0 +1,8 @@
+version: '2'
+formatters:
+  enable:
+    - gofmt
+    - goimports
+linters:
+  enable:
+    - exhaustruct

package/Makefile

@@ -1,3 +1,9 @@
 pre-commit-install:
 	pre-commit install --hook-type pre-commit --config .githooks/pre-commit-config.yaml
 	pre-commit install --hook-type pre-push --config .githooks/pre-push-config.yaml
+
+lint:
+	golangci-lint run ./...
+
+format:
+	golangci-lint run ./... --fix

package/README.md

@@ -44,7 +44,15 @@ mise install
 make pre-commit-install
 ```
 
-### 4. Install `node` modules
+### 4. Install `go` modules
+
+- Use `go` to install codebase modules
+
+```bash
+go mod tidy
+```
+
+### 5. Install `node` modules
 
 - Install all `node` modules
 
@@ -60,4 +68,21 @@ npm install
 
 ### Deployments
 
-Any merge to `main` with changes to the `ts/*` directory will trigger an automatic deployment to `npm`
+Any merge to `main` with changes to the `ts/*` and `go/*` directory will trigger an automatic deployment to `npm`
+
+### Go Package
+
+To import the Go packages in other repositories, you must follow the steps below to allow importing from a private repository.
+
+#### 1. Add an ssh override in your `~/.gitconfig`
+
+```bash
+[url "git@github.com:"]
+  insteadOf = https://github.com/
+```
+
+#### 2. Add the following export within your `~/.zshrc`
+
+```bash
+export GOPRIVATE=github.com/RivasCVA/*
+```

package/go/utils/fetch/fetch.go

@@ -0,0 +1,47 @@
+package fetch
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+)
+
+type response struct {
+	StatusCode int
+}
+
+// Makes a GET request to the given url.
+//
+// Parses the JSON-encoded response and stores the result into v.
+func Get(url string, v any) (*response, error) {
+	// make the GET request
+	resp, err := http.Get(url)
+	if err != nil {
+		return nil, err
+	}
+
+	// read the body from the response
+	content, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	// unmarshal the body content
+	err = json.Unmarshal(content, v)
+	if err != nil {
+		return nil, err
+	}
+
+	// build the custom fetch response
+	response := response{
+		StatusCode: resp.StatusCode,
+	}
+
+	// close the body content
+	err = resp.Body.Close()
+	if err != nil {
+		return nil, err
+	}
+
+	return &response, nil
+}

package/go/utils/logger/logger.go

@@ -0,0 +1,59 @@
+package logger
+
+import (
+	"fmt"
+	"log"
+	"os"
+)
+
+type LoggerInterface interface {
+	// Prints an info log message.
+	Info(v ...any)
+	// Prints a warning log message.
+	Warn(v ...any)
+	// Prints an error log message.
+	Error(v ...any)
+	// Prints an error log message and exits the program.
+	Fatal(v ...any)
+}
+
+type Logger struct {
+	prefix string
+	info   *log.Logger
+	warn   *log.Logger
+	error  *log.Logger
+}
+
+// A shared singleton log.
+var Log = New()
+
+// Creates a new logger.
+func New() LoggerInterface {
+	return NewWithPrefix("")
+}
+
+// Creates a new logger with a custom prefix.
+func NewWithPrefix(prefix string) LoggerInterface {
+	return &Logger{
+		prefix: prefix,
+		info:   log.New(os.Stdout, "[INFO] ", log.LstdFlags),
+		warn:   log.New(os.Stdout, "[WARN] ", log.LstdFlags),
+		error:  log.New(os.Stdout, "[ERROR] ", log.LstdFlags),
+	}
+}
+
+func (l *Logger) Info(v ...any) {
+	l.info.Println(l.prefix, fmt.Sprint(v...))
+}
+
+func (l *Logger) Warn(v ...any) {
+	l.warn.Println(l.prefix, fmt.Sprint(v...))
+}
+
+func (l *Logger) Error(v ...any) {
+	l.error.Println(l.prefix, fmt.Sprint(v...))
+}
+
+func (l *Logger) Fatal(v ...any) {
+	l.error.Fatal(l.prefix, fmt.Sprint(v...))
+}

package/go/utils/response/models.go

@@ -0,0 +1,10 @@
+package response
+
+// Base error struct.
+//
+// The struct should match the base "Error" schema in all services.
+type Error[T any] struct {
+	Status  int64  `json:"status"`
+	Code    T      `json:"code"`
+	Message string `json:"message"`
+}

package/go/utils/response/response.go

@@ -0,0 +1,78 @@
+package response
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"github.com/RivasCVA/dt-idl/go/utils/logger"
+)
+
+type ResponseInterface[T any] interface {
+	Write(w http.ResponseWriter, status int, data any)
+	WriteError(w http.ResponseWriter, status int, message string)
+	WriteErrorWithCode(w http.ResponseWriter, status int, code T, message string)
+}
+
+type Response[T any] struct {
+	log           logger.LoggerInterface
+	baseErrorCode T
+}
+
+func New[T any](log logger.LoggerInterface, baseErrorCode T) ResponseInterface[T] {
+	return &Response[T]{
+		log:           log,
+		baseErrorCode: baseErrorCode,
+	}
+}
+
+// Writes a JSON response to the given response writer.
+//
+// The given data is converted to JSON. An error response is written if the marshal fails.
+func (r *Response[T]) Write(w http.ResponseWriter, status int, data any) {
+	// encode the given data object
+	out, err := json.Marshal(data)
+	if err != nil {
+		r.log.Error(fmt.Errorf("Write: failed to marshal the data: %w", err))
+		r.WriteError(w, http.StatusInternalServerError, "error encoding the data")
+		return
+	}
+
+	// write the data to the given writer
+	w.WriteHeader(status)
+	_, err = w.Write(out)
+	if err != nil {
+		r.log.Fatal(fmt.Errorf("Write: failed to write a response: %w", err))
+	}
+}
+
+// Writes a JSON error response to the given response writer.
+//
+// The response is based on the generated "api.Error" schema.
+func (r *Response[T]) WriteError(w http.ResponseWriter, status int, message string) {
+	r.WriteErrorWithCode(w, status, r.baseErrorCode, message)
+}
+
+// Writes a JSON error response with a specific code to the given response writer.
+//
+// The code is based on the generated "api.ErrorCode" enum.
+//
+// The response is based on the generated "api.Error" schema.
+func (r *Response[T]) WriteErrorWithCode(w http.ResponseWriter, status int, code T, message string) {
+	// encode an error object with the given message
+	out, err := json.Marshal(Error[T]{
+		Status:  int64(status),
+		Code:    code,
+		Message: message,
+	})
+	if err != nil {
+		r.log.Fatal(fmt.Errorf("WriteErrorWithCode: failed to marshal the error: %w", err))
+	}
+
+	// write the data to the given writer
+	w.WriteHeader(status)
+	_, err = w.Write(out)
+	if err != nil {
+		r.log.Fatal(fmt.Errorf("WriteErrorWithCode: failed to write a response: %w", err))
+	}
+}

package/go/utils/url/url.go

@@ -0,0 +1,26 @@
+package url
+
+import (
+	"fmt"
+	"net/url"
+)
+
+// Builds a url string from the given base and path.
+//
+// Encodes any given query parameters into the url.
+func Build(base string, path string, params map[string]any) (string, error) {
+	// parse the combined base and path
+	url, err := url.Parse(base + path)
+	if err != nil {
+		return "", fmt.Errorf("unable to parse the url: %w", err)
+	}
+
+	// add the query parameters
+	query := url.Query()
+	for key, value := range params {
+		query.Add(key, fmt.Sprintf("%v", value))
+	}
+	url.RawQuery = query.Encode()
+
+	return url.String(), nil
+}

package/go.mod

@@ -0,0 +1,3 @@
+module github.com/RivasCVA/dt-idl
+
+go 1.22

package/mise.toml

@@ -1,3 +1,5 @@
 [tools]
+go = "1.22"
 node = "22"
 pre-commit = "4.0"
+golangci-lint = "2.1"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rivascva/dt-idl",
-  "version": "1.1.43",
+  "version": "1.1.45",
   "description": "Dream Trade - Interface Definition Language",
   "main": "dist/index.cjs.js",
   "module": "dist/index.esm.js",