feat: Psg 5154 introduce new method names

CHANGELOG.md

@@ -2,6 +2,32 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.11.3] - 2024-11-30
+
+### Added
+- deprecated methods
+    - Passage.GetUser(userId: string): User
+    - Passage.GetUserByIdentifier(identifier: string): User
+    - Passage.ActivateUser(userId: string): User
+    - Passage.DeactivateUser(userId: string): User
+    - Passage.UpdateUser(userId: string, options: UpdateUserArgs): User
+    - Passage.CreateUser(args: CreateUserArgs): User
+    - Passage.DeleteUser(userId: string): boolean
+    - Passage.ListUserDevices(userId: string): WebAuthnDevice[]
+    - Passage.RevokeUserDevice(userId: string, deviceId: string): boolean
+    - Passage.ValidateAuthToken(authToken: string): string, bool
+- added new methods
+    - Passage.User.Get(userId: string): User
+    - Passage.User.GetByIdentifier(identifier: string): User
+    - Passage.User.Activate(userId: string): User
+    - Passage.User.Deactivate(userId: string): User
+    - Passage.User.Update(userId: string, options: UpdateUserArgs): User
+    - Passage.User.Create(args: CreateUserArgs): User
+    - Passage.User.Delete(userId: string): boolean
+    - Passage.User.ListDevices(userId: string): WebAuthnDevice[]
+    - Passage.User.RevokeDevice(userId: string, deviceId: string): boolean
+    - Passage.ValidateJwt(authToken: string): string, bool
+
 ## [1.11.2] - 2024-10-24
 
 ### Added

app.go

@@ -14,13 +14,16 @@ type Config struct {
 	HeaderAuth bool
 }
 
+// Deprecated: will be replace with a different object in v2
 type App struct {
 	ID           string
 	Config       *Config
+	User         *AppUser
 	client       *ClientWithResponses
 	jwksCacheSet jwk.Set
 }
 
+// Deprecated: Will be replaced with a different signature in v2
 func New(appID string, config *Config) (*App, error) {
 	if config == nil {
 		config = &Config{}
@@ -53,9 +56,12 @@ func New(appID string, config *Config) (*App, error) {
 
 	app.jwksCacheSet = jwk.NewCachedSet(cache, url)
 
+	app.User = newAppUser(appID, app)
+
 	return &app, nil
 }
 
+// Deprecated: GetApp
 // GetApp gets information about an app
 // returns App on success, error on failure
 func (a *App) GetApp() (*AppInfo, error) {

app_user.go

@@ -0,0 +1,81 @@
+package passage
+
+type PassageUser = User
+type AppUser struct {
+	appID string
+	app   App
+}
+
+const (
+	UserIDDoesNotExist     string = "passage User with ID \"%v\" does not exist"
+	IdentifierDoesNotExist string = "passage User with Identifier \"%v\" does not exist"
+)
+
+func newAppUser(appID string, app App) *AppUser {
+	appUser := AppUser{
+		appID: appID,
+		app:   app,
+	}
+
+	return &appUser
+}
+
+// Get gets a user using their userID
+// returns user on success, error on failure
+func (a *AppUser) Get(userID string) (*PassageUser, error) {
+	return a.app.GetUser(userID)
+}
+
+// GetByIdentifier gets a user using their identifier
+// returns user on success, error on failure
+func (a *AppUser) GetByIdentifier(identifier string) (*PassageUser, error) {
+	return a.app.GetUserByIdentifier(identifier)
+}
+
+// Activate activates a user using their userID
+// returns user on success, error on failure
+func (a *AppUser) Activate(userID string) (*PassageUser, error) {
+	return a.app.ActivateUser(userID)
+}
+
+// Deactivate deactivates a user using their userID
+// returns user on success, error on failure
+func (a *AppUser) Deactivate(userID string) (*PassageUser, error) {
+	return a.app.DeactivateUser(userID)
+}
+
+// Update receives an UpdateBody struct, updating the corresponding user's attribute(s)
+// returns user on success, error on failure
+func (a *AppUser) Update(userID string, updateBody UpdateBody) (*PassageUser, error) {
+	return a.app.UpdateUser(userID, updateBody)
+}
+
+// Delete deletes a user by their user string
+// returns true on success, false and error on failure (bool, err)
+func (a *AppUser) Delete(userID string) (bool, error) {
+	return a.app.DeleteUser(userID)
+}
+
+// Create receives a CreateUserBody struct, creating a user with provided values
+// returns user on success, error on failure
+func (a *AppUser) Create(createUserBody CreateUserBody) (*PassageUser, error) {
+	return a.app.CreateUser(createUserBody)
+}
+
+// ListDevices lists a user's devices
+// returns a list of devices on success, error on failure
+func (a *AppUser) ListDevices(userID string) ([]WebAuthnDevices, error) {
+	return a.app.ListUserDevices(userID)
+}
+
+// RevokeDevice gets a user using their userID
+// returns a true success, error on failure
+func (a *AppUser) RevokeDevice(userID, deviceID string) (bool, error) {
+	return a.app.RevokeUserDevice(userID, deviceID)
+}
+
+// Signout revokes a users refresh tokens
+// returns true on success, error on failure
+func (a *AppUser) SignOut(userID string) (bool, error) {
+	return a.app.SignOut(userID)
+}

app_user_test.go

@@ -0,0 +1,235 @@
+package passage_test
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/passageidentity/passage-go"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestGetInfo(t *testing.T) {
+	psg, err := passage.New(PassageAppID, &passage.Config{
+		APIKey: PassageApiKey,
+	})
+	require.Nil(t, err)
+
+	user, err := psg.User.Get(PassageUserID)
+	require.Nil(t, err)
+	assert.Equal(t, PassageUserID, user.ID)
+}
+
+func TestGetInfoByIdentifier(t *testing.T) {
+	psg, err := passage.New(PassageAppID, &passage.Config{
+		APIKey: PassageApiKey,
+	})
+	require.Nil(t, err)
+
+	createUserBody := passage.CreateUserBody{
+		Email: RandomEmail,
+	}
+
+	user, err := psg.User.Create(createUserBody)
+	require.Nil(t, err)
+	assert.Equal(t, RandomEmail, user.Email)
+
+	userByIdentifier, err := psg.User.GetByIdentifier(RandomEmail)
+	require.Nil(t, err)
+
+	userById, err := psg.User.Get(user.ID)
+	require.Nil(t, err)
+
+	assert.Equal(t, user.ID, userById.ID)
+
+	assert.Equal(t, userById, userByIdentifier)
+}
+
+func TestGetInfoByIdentifierEmailUpperCase(t *testing.T) {
+	psg, err := passage.New(PassageAppID, &passage.Config{
+		APIKey: PassageApiKey,
+	})
+	require.Nil(t, err)
+
+	createUserBody := passage.CreateUserBody{
+		Email: RandomEmail,
+	}
+
+	user, err := psg.User.Create(createUserBody)
+	require.Nil(t, err)
+	assert.Equal(t, RandomEmail, user.Email)
+
+	userByIdentifier, err := psg.User.GetByIdentifier(strings.ToUpper(RandomEmail))
+	require.Nil(t, err)
+
+	assert.Equal(t, user.ID, userByIdentifier.ID)
+}
+
+func TestGetInfoByIdentifierPhone(t *testing.T) {
+	psg, err := passage.New(PassageAppID, &passage.Config{
+		APIKey: PassageApiKey,
+	})
+	require.Nil(t, err)
+
+	phone := "+15005550007"
+	createUserBody := passage.CreateUserBody{
+		Phone: phone,
+	}
+
+	user, err := psg.User.Create(createUserBody)
+	require.Nil(t, err)
+	assert.Equal(t, phone, user.Phone)
+
+	userByIdentifier, err := psg.User.GetByIdentifier(phone)
+	require.Nil(t, err)
+
+	userById, err := psg.User.Get(user.ID)
+	require.Nil(t, err)
+
+	assert.Equal(t, user.ID, userById.ID)
+
+	assert.Equal(t, userById, userByIdentifier)
+}
+
+func TestGetInfoByIdentifierError(t *testing.T) {
+	psg, err := passage.New(PassageAppID, &passage.Config{
+		APIKey: PassageApiKey,
+	})
+	require.Nil(t, err)
+
+	_, err = psg.User.GetByIdentifier("error@passage.id")
+	require.NotNil(t, err)
+
+	expectedMessage := "passage User with Identifier \"error@passage.id\" does not exist"
+	assert.Contains(t, err.Error(), expectedMessage)
+}
+
+func TestActivate(t *testing.T) {
+	psg, err := passage.New(PassageAppID, &passage.Config{
+		APIKey: PassageApiKey, // An API_KEY environment variable is required for testing.
+	})
+	require.Nil(t, err)
+
+	user, err := psg.User.Activate(PassageUserID)
+	require.Nil(t, err)
+	assert.Equal(t, PassageUserID, user.ID)
+	assert.Equal(t, passage.StatusActive, user.Status)
+}
+func TestDeactivate(t *testing.T) {
+	psg, err := passage.New(PassageAppID, &passage.Config{
+		APIKey: PassageApiKey, // An API_KEY environment variable is required for testing.
+	})
+	require.Nil(t, err)
+
+	user, err := psg.User.Deactivate(PassageUserID)
+	require.Nil(t, err)
+	assert.Equal(t, PassageUserID, user.ID)
+	assert.Equal(t, passage.StatusInactive, user.Status)
+}
+
+func TestUpdate(t *testing.T) {
+	psg, err := passage.New(PassageAppID, &passage.Config{
+		APIKey: PassageApiKey, // An API_KEY environment variable is required for testing.
+	})
+	require.Nil(t, err)
+
+	updateBody := passage.UpdateBody{
+		Email: "updatedemail-gosdk@passage.id",
+		Phone: "+15005550012",
+		UserMetadata: map[string]interface{}{
+			"example1": "123",
+		},
+	}
+	user, err := psg.User.Update(PassageUserID, updateBody)
+	require.Nil(t, err)
+	assert.Equal(t, "updatedemail-gosdk@passage.id", user.Email)
+	assert.Equal(t, "+15005550012", user.Phone)
+	assert.Equal(t, "123", user.UserMetadata["example1"])
+
+	secondUpdateBody := passage.UpdateBody{
+		Email: "updatedemail-gosdk@passage.id",
+		Phone: "+15005550012",
+		UserMetadata: map[string]interface{}{
+			"example1": "456",
+		},
+	}
+	user, err = psg.User.Update(PassageUserID, secondUpdateBody)
+	require.Nil(t, err)
+	assert.Equal(t, "updatedemail-gosdk@passage.id", user.Email)
+	assert.Equal(t, "+15005550012", user.Phone)
+	assert.Equal(t, "456", user.UserMetadata["example1"])
+}
+
+func TestCreate(t *testing.T) {
+	psg, err := passage.New(PassageAppID, &passage.Config{
+		APIKey: PassageApiKey, // An API_KEY environment variable is required for testing.
+	})
+	require.Nil(t, err)
+
+	createUserBody := passage.CreateUserBody{
+		Email: RandomEmail,
+	}
+
+	user, err := psg.User.Create(createUserBody)
+	require.Nil(t, err)
+	assert.Equal(t, RandomEmail, user.Email)
+
+	CreatedUser = *user
+}
+
+func TestCreateWithMetadata(t *testing.T) {
+	psg, err := passage.New(PassageAppID, &passage.Config{
+		APIKey: PassageApiKey, // An API_KEY environment variable is required for testing.
+	})
+	require.Nil(t, err)
+
+	createUserBody := passage.CreateUserBody{
+		Email: fmt.Sprintf("1%v", RandomEmail),
+		UserMetadata: map[string]interface{}{
+			"example1": "test",
+		},
+	}
+
+	user, err := psg.User.Create(createUserBody)
+	require.Nil(t, err)
+	assert.Equal(t, "1"+RandomEmail, user.Email)
+	assert.Equal(t, "test", user.UserMetadata["example1"].(string))
+
+	CreatedUser = *user
+}
+
+func TestDelete(t *testing.T) {
+	psg, err := passage.New(PassageAppID, &passage.Config{
+		APIKey: PassageApiKey, // An API_KEY environment variable is required for testing.
+	})
+	require.Nil(t, err)
+
+	result, err := psg.User.Delete(CreatedUser.ID)
+	require.Nil(t, err)
+	assert.Equal(t, result, true)
+}
+
+func TestListDevices(t *testing.T) {
+	psg, err := passage.New(PassageAppID, &passage.Config{
+		APIKey: PassageApiKey,
+	})
+	require.Nil(t, err)
+
+	devices, err := psg.User.ListDevices(PassageUserID)
+	require.Nil(t, err)
+	assert.Equal(t, 2, len(devices))
+}
+
+// NOTE RevokeUserDevice is not tested because it is impossible to spoof webauthn to create a device to then revoke
+
+func TestSignOut(t *testing.T) {
+	psg, err := passage.New(PassageAppID, &passage.Config{
+		APIKey: PassageApiKey, // An API_KEY environment variable is required for testing.
+	})
+	require.Nil(t, err)
+
+	result, err := psg.User.SignOut(PassageUserID)
+	require.Nil(t, err)
+	assert.Equal(t, result, true)
+}