update scopes + DBOSExecutor singleton (#36)

Builder pattern for the DBOS singleton:
- Split building the object and launching
- Stop exposing internal variables
- Make app name & db url mandatory to init DBOS. This means using a
config struct rather than functional options.


**Manipulating the singleton object**

```golang
package main

import (
	"context"
	"fmt"
	"os"

	"github.com/dbos-inc/dbos-transact-go/dbos"
)

var (
	wf = dbos.WithWorkflow(workflow)
)

func workflow(ctx context.Context, input string) (string, error) {
	return input, nil
}

func main() {
	err := dbos.Initialize(dbos.Config{
		AppName:     "dbos-hello",
		DatabaseURL: os.Getenv("DBOS_SYSTEM_DATABASE_URL"),
	})
	if err != nil {
		panic(err)
	}

	err = dbos.Launch()
	if err != nil {
		panic(err)
	}

	r, err := wf(context.Background(), "Hello, DBOS!")
	if err != nil {
		panic(err)
	}
	fmt.Println(r)

	dbos.Shutdown()
}
```

If a user needs to pass the DBOS singleton around and mock it, they can
create a mock interface and write mocks manually or generate them with
something like [mockery](https://github.com/vektra/mockery).


**What is public**
- Config
- WorkflowStatus, Workflow Status types (e.g.,
dbos.WorkflowStatusPending)
- The WorkflowHandle interface (concrete internal types: workflowHandle
and workflowPollingHandle)
- WithWorkflow wrapper, its functional options, and the returned
WorkflowWrapperFunc (not sure whether the latter is actually useful to a
user)
- WorkflowFunc and StepFunc so users know what they can wrap
- Single methods (Send, Recv, RetrieveWorkflow)
- Input types for single methods like Send (WorkflowSendInput)
- Error types
- Queues: WorkflowQueue, NewWorkflowQueue, function options
- SystemDatabase: I think it'll be useful to eventually allow users to
inject a non-pg implementation (e.g., a mock) for testing.
- StepInfo

Author: maxdml

dbos/admin-server.go renamed to dbos/admin_server.go

@@ -9,34 +9,34 @@ import (
 )
 
 const (
-	HealthCheckPath           = "/dbos-healthz"
-	WorkflowRecoveryPath      = "/dbos-workflow-recovery"
-	WorkflowQueuesMetadataPath = "/dbos-workflow-queues-metadata"
+	healthCheckPath            = "/dbos-healthz"
+	workflowRecoveryPath       = "/dbos-workflow-recovery"
+	workflowQueuesMetadataPath = "/dbos-workflow-queues-metadata"
 )
 
-type AdminServer struct {
+type adminServer struct {
 	server *http.Server
 }
 
-type QueueMetadata struct {
+type queueMetadata struct {
 	Name              string       `json:"name"`
 	Concurrency       *int         `json:"concurrency,omitempty"`
 	WorkerConcurrency *int         `json:"workerConcurrency,omitempty"`
 	RateLimit         *RateLimiter `json:"rateLimit,omitempty"`
 }
 
-func NewAdminServer(port int) *AdminServer {
+func newAdminServer(port int) *adminServer {
 	mux := http.NewServeMux()
 
 	// Health endpoint
-	mux.HandleFunc(HealthCheckPath, func(w http.ResponseWriter, r *http.Request) {
+	mux.HandleFunc(healthCheckPath, func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
 		w.Write([]byte(`{"status":"healthy"}`))
 	})
 
 	// Recovery endpoint
-	mux.HandleFunc(WorkflowRecoveryPath, func(w http.ResponseWriter, r *http.Request) {
+	mux.HandleFunc(workflowRecoveryPath, func(w http.ResponseWriter, r *http.Request) {
 		if r.Method != http.MethodPost {
 			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
 			return
@@ -71,21 +71,21 @@ func NewAdminServer(port int) *AdminServer {
 	})
 
 	// Queue metadata endpoint
-	mux.HandleFunc(WorkflowQueuesMetadataPath, func(w http.ResponseWriter, r *http.Request) {
+	mux.HandleFunc(workflowQueuesMetadataPath, func(w http.ResponseWriter, r *http.Request) {
 		if r.Method != http.MethodGet {
 			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
 			return
 		}
 
-		var queueMetadataArray []QueueMetadata
+		var queueMetadataArray []queueMetadata
 
 		// Iterate through all queues in the registry
 		for _, queue := range workflowQueueRegistry {
-			queueMetadata := QueueMetadata{
-				Name:              queue.Name,
-				WorkerConcurrency: queue.WorkerConcurrency,
-				Concurrency:       queue.GlobalConcurrency,
-				RateLimit:         queue.Limiter,
+			queueMetadata := queueMetadata{
+				Name:              queue.name,
+				WorkerConcurrency: queue.workerConcurrency,
+				Concurrency:       queue.globalConcurrency,
+				RateLimit:         queue.limiter,
 			}
 
 			queueMetadataArray = append(queueMetadataArray, queueMetadata)
@@ -103,12 +103,12 @@ func NewAdminServer(port int) *AdminServer {
 		Handler: mux,
 	}
 
-	return &AdminServer{
+	return &adminServer{
 		server: server,
 	}
 }
 
-func (as *AdminServer) Start() error {
+func (as *adminServer) Start() error {
 	getLogger().Info("Starting admin server", "port", 3001)
 
 	go func() {
@@ -120,7 +120,7 @@ func (as *AdminServer) Start() error {
 	return nil
 }
 
-func (as *AdminServer) Shutdown() error {
+func (as *adminServer) Shutdown() error {
 	getLogger().Info("Shutting down admin server")
 
 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)

dbos/admin-server_test.go renamed to dbos/admin_server_test.go

@@ -5,40 +5,41 @@ import (
 	"encoding/json"
 	"io"
 	"net/http"
-	"os"
 	"strings"
 	"testing"
 	"time"
 )
 
 func TestAdminServer(t *testing.T) {
-	// Skip if database is not available
-	databaseURL := os.Getenv("DBOS_SYSTEM_DATABASE_URL")
-	if databaseURL == "" && os.Getenv("PGPASSWORD") == "" {
-		t.Skip("Database not available (DBOS_SYSTEM_DATABASE_URL and PGPASSWORD not set), skipping DBOS integration tests")
-	}
+	databaseURL := getDatabaseURL(t)
 
-	t.Run("Admin server is not started without WithAdminServer option", func(t *testing.T) {
+	t.Run("Admin server is not started by default", func(t *testing.T) {
 		// Ensure clean state
-		if dbos != nil {
-			Shutdown()
-		}
+		Shutdown()
 
-		// Launch DBOS without admin server option
-		err := Launch()
+		err := Initialize(Config{
+			DatabaseURL: databaseURL,
+			AppName:     "test-app",
+		})
 		if err != nil {
-			t.Skipf("Failed to launch DBOS (database likely not available): %v", err)
+			t.Skipf("Failed to initialize DBOS: %v", err)
+		}
+		err = Launch()
+		if err != nil {
+			t.Skipf("Failed to initialize DBOS: %v", err)
 		}
 
 		// Ensure cleanup
-		defer Shutdown()
+		defer func() {
+			Shutdown()
+		}()
 
 		// Give time for any startup processes
 		time.Sleep(100 * time.Millisecond)
 
 		// Verify admin server is not running
 		client := &http.Client{Timeout: 1 * time.Second}
-		_, err = client.Get("http://localhost:3001" + HealthCheckPath)
+		_, err = client.Get("http://localhost:3001" + healthCheckPath)
 		if err == nil {
 			t.Error("Expected request to fail when admin server is not started, but it succeeded")
 		}
@@ -54,19 +55,26 @@ func TestAdminServer(t *testing.T) {
 	})
 
 	t.Run("Admin server endpoints", func(t *testing.T) {
-		// Ensure clean state
-		if dbos != nil {
-			Shutdown()
-		}
+		Shutdown()
 
 		// Launch DBOS with admin server once for all endpoint tests
-		err := Launch(WithAdminServer())
+		err := Initialize(Config{
+			DatabaseURL: databaseURL,
+			AppName:     "test-app",
+			AdminServer: true,
+		})
 		if err != nil {
-			t.Skipf("Failed to launch DBOS with admin server (database likely not available): %v", err)
+			t.Skipf("Failed to initialize DBOS with admin server: %v", err)
+		}
+		err = Launch()
+		if err != nil {
+			t.Skipf("Failed to initialize DBOS with admin server: %v", err)
 		}
 
 		// Ensure cleanup
-		defer Shutdown()
+		defer func() {
+			Shutdown()
+		}()
 
 		// Give the server a moment to start
 		time.Sleep(100 * time.Millisecond)
@@ -94,13 +102,13 @@ func TestAdminServer(t *testing.T) {
 			{
 				name:           "Health endpoint responds correctly",
 				method:         "GET",
-				endpoint:       "http://localhost:3001" + HealthCheckPath,
+				endpoint:       "http://localhost:3001" + healthCheckPath,
 				expectedStatus: http.StatusOK,
 			},
 			{
 				name:           "Recovery endpoint responds correctly with valid JSON",
 				method:         "POST",
-				endpoint:       "http://localhost:3001" + WorkflowRecoveryPath,
+				endpoint:       "http://localhost:3001" + workflowRecoveryPath,
 				body:           bytes.NewBuffer(mustMarshal([]string{"executor1", "executor2"})),
 				contentType:    "application/json",
 				expectedStatus: http.StatusOK,
@@ -117,24 +125,24 @@ func TestAdminServer(t *testing.T) {
 			{
 				name:           "Recovery endpoint rejects invalid methods",
 				method:         "GET",
-				endpoint:       "http://localhost:3001" + WorkflowRecoveryPath,
+				endpoint:       "http://localhost:3001" + workflowRecoveryPath,
 				expectedStatus: http.StatusMethodNotAllowed,
 			},
 			{
 				name:           "Recovery endpoint rejects invalid JSON",
 				method:         "POST",
-				endpoint:       "http://localhost:3001" + WorkflowRecoveryPath,
+				endpoint:       "http://localhost:3001" + workflowRecoveryPath,
 				body:           strings.NewReader(`{"invalid": json}`),
 				contentType:    "application/json",
 				expectedStatus: http.StatusBadRequest,
 			},
 			{
 				name:           "Queue metadata endpoint responds correctly",
 				method:         "GET",
-				endpoint:       "http://localhost:3001" + WorkflowQueuesMetadataPath,
+				endpoint:       "http://localhost:3001" + workflowQueuesMetadataPath,
 				expectedStatus: http.StatusOK,
 				validateResp: func(t *testing.T, resp *http.Response) {
-					var queueMetadata []QueueMetadata
+					var queueMetadata []queueMetadata
 					if err := json.NewDecoder(resp.Body).Decode(&queueMetadata); err != nil {
 						t.Errorf("Failed to decode response as QueueMetadata array: %v", err)
 					}
@@ -170,7 +178,7 @@ func TestAdminServer(t *testing.T) {
 			{
 				name:           "Queue metadata endpoint rejects invalid methods",
 				method:         "POST",
-				endpoint:       "http://localhost:3001" + WorkflowQueuesMetadataPath,
+				endpoint:       "http://localhost:3001" + workflowQueuesMetadataPath,
 				expectedStatus: http.StatusMethodNotAllowed,
 			},
 		}