typeid

ExampleAnyInt64_switchToTypedInt64 narrows AnyInt64 to Int64 after a prefix switch.

const payload = `{"id":"org_01hf7yat00c1s"}`
type Request struct {
	ID typeid.AnyInt64 `json:"id"`
}
var req Request
if err := json.Unmarshal([]byte(payload), &req); err != nil {
	fmt.Println("unmarshal:", err)
	return
}

var orgID OrgID
var err error
switch req.ID.Prefix() {
case "org":
	orgID, err = typeid.Int64From[orgPrefix](req.ID.Int64())
default:
	fmt.Println("unknown prefix")
	return
}
if err != nil {
	fmt.Println("narrow:", err)
	return
}
fmt.Println(orgID.String())

Output:
org_01hf7yat00c1s

package main

import (
	"encoding/json"
	"fmt"

	"github.com/go-chi/typeid"
)

type Mode string

const (
	ModeLive    Mode = "key"
	ModeSandbox Mode = "key_sandbox"
)

type ApiKeyID struct {
	typeid.AnyUUID
}

func NewApiKeyID(mode Mode) ApiKeyID {
	u, err := typeid.NewAnyUUID(string(mode))
	if err != nil {
		panic(err) // can't happen unless crypto/rand is not available
	}
	return ApiKeyID{AnyUUID: u}
}

func (id *ApiKeyID) UnmarshalText(data []byte) error {
	if err := id.AnyUUID.UnmarshalText(data); err != nil {
		return err
	}
	switch id.AnyUUID.Prefix() {
	case string(ModeLive), string(ModeSandbox):
		return nil
	default:
		return fmt.Errorf("invalid api key prefix: %q", id.AnyUUID.Prefix())
	}
}

type Request struct {
	ID          ApiKeyID `json:"id"`
	Description string   `json:"description"`
}

func main() {
	// Sandbox
	data, _ := json.Marshal(Request{ID: NewApiKeyID(ModeSandbox), Description: "Sandbox API Key"})
	var sandboxRequest Request
	_ = json.Unmarshal(data, &sandboxRequest)

	// Live
	data, _ = json.Marshal(Request{ID: NewApiKeyID(ModeLive), Description: "Live API Key"})
	var liveRequest Request
	_ = json.Unmarshal(data, &liveRequest)

	// Invalid prefix, expect error
	data = []byte(`{"id":"key_invalid_prefix_01jcp1ss00edg828t5cy4tqkff", "description":"Invalid API Key"}`)
	var unknownRequest Request
	err := json.Unmarshal(data, &unknownRequest)

	fmt.Println(sandboxRequest.ID.Prefix())
	fmt.Println(liveRequest.ID.Prefix())
	fmt.Println(unknownRequest.ID.Prefix(), err)

}

Output:
key_sandbox
key
key_invalid_prefix invalid api key prefix: "key_invalid_prefix"

ExampleAnyUUID_switchToTypedUUID shows narrowing AnyUUID to UUID after inspecting AnyUUID.Prefix. Use UUIDFrom when the prefix matches; it keeps the same UUID bytes under the typed wrapper.

const payload = `{"id":"user_01jcp1ss00edg828t5cy4tqkff"}`
type Request struct {
	ID typeid.AnyUUID `json:"id"`
}
var req Request
if err := json.Unmarshal([]byte(payload), &req); err != nil {
	fmt.Println("unmarshal:", err)
	return
}

var userID UserID
var err error
switch req.ID.Prefix() {
case "user":
	userID, err = typeid.UUIDFrom[userPrefix](req.ID.UUID())
default:
	fmt.Println("unknown prefix")
	return
}
if err != nil {
	fmt.Println("narrow:", err)
	return
}
fmt.Println(userID.String())

Output:
user_01jcp1ss00edg828t5cy4tqkff

type Org struct {
	ID   OrgID  `json:"id"`
	Name string `json:"name"`
}

id, _ := typeid.NewInt64[orgPrefix]()
original := Org{ID: id, Name: "Polygon"}
data, _ := json.Marshal(original)

var decoded Org
_ = json.Unmarshal(data, &decoded)
fmt.Println(original.ID == decoded.ID)
fmt.Println(strings.Contains(string(data), `"id":"org_`))

Output:
true
true

type User struct {
	ID   UserID `json:"id"`
	Name string `json:"name"`
}

id, _ := typeid.NewUUID[userPrefix]()
original := User{ID: id, Name: "Alice"}
data, _ := json.Marshal(original)

var decoded User
_ = json.Unmarshal(data, &decoded)
fmt.Println(original.ID == decoded.ID)
fmt.Println(strings.Contains(string(data), `"id":"user_`))

Output:
true
true