echofi-client
Version:
A comprehensive TypeScript/JavaScript client library for EchoFi services with automatic gRPC-Web code generation, unified service access, and real-time WebSocket communication.
1,273 lines • 80.5 kB
JavaScript
"use strict";
/**
* Auto-Generated Unified gRPC-Web Client for EchoFi
* This client provides access to all backend services with proper TypeScript support
*
* Generated automatically from proto files - do not edit manually
* To regenerate: npm run generate-client
*/
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.EchoFiGrpcWebClient = exports.Messages = void 0;
exports.createEchoFiGrpcWebClient = createEchoFiGrpcWebClient;
// Import service clients
const ServiceServiceClientPb_1 = require("./activity/ServiceServiceClientPb");
const ServiceServiceClientPb_2 = require("./auth/ServiceServiceClientPb");
const ServiceServiceClientPb_3 = require("./music/ServiceServiceClientPb");
const ServiceServiceClientPb_4 = require("./stats/ServiceServiceClientPb");
const ServiceServiceClientPb_5 = require("./user/ServiceServiceClientPb");
const ServiceServiceClientPb_6 = require("./web3auth/ServiceServiceClientPb");
// Import message types
const activityListening_history = __importStar(require("./activity/listening_history_pb"));
const activityListening_session = __importStar(require("./activity/listening_session_pb"));
const activityParam = __importStar(require("./activity/param_pb"));
const activityProcessing_cycles = __importStar(require("./activity/processing_cycles_pb"));
const activityRate_param = __importStar(require("./activity/rate_param_pb"));
const activityReferral = __importStar(require("./activity/referral_pb"));
const activityRewards = __importStar(require("./activity/rewards_pb"));
const activityService = __importStar(require("./activity/service_pb"));
const activityUser_favorite = __importStar(require("./activity/user_favorite_pb"));
const activityUser_points = __importStar(require("./activity/user_points_pb"));
const activityUser_referral_rewards = __importStar(require("./activity/user_referral_rewards_pb"));
const activityUser_rewards = __importStar(require("./activity/user_rewards_pb"));
const authAccount = __importStar(require("./auth/account_pb"));
const authService = __importStar(require("./auth/service_pb"));
const authSession = __importStar(require("./auth/session_pb"));
const authVerification_token = __importStar(require("./auth/verification_token_pb"));
const musicAlbum = __importStar(require("./music/album_pb"));
const musicArtist = __importStar(require("./music/artist_pb"));
const musicGenre = __importStar(require("./music/genre_pb"));
const musicPlaylist = __importStar(require("./music/playlist_pb"));
const musicService = __importStar(require("./music/service_pb"));
const musicTrack = __importStar(require("./music/track_pb"));
const statsPoint_boost = __importStar(require("./stats/point_boost_pb"));
const statsService = __importStar(require("./stats/service_pb"));
const statsUser_statistics = __importStar(require("./stats/user_statistics_pb"));
const userService = __importStar(require("./user/service_pb"));
const userUser = __importStar(require("./user/user_pb"));
const web3authAuth_proof = __importStar(require("./web3auth/auth_proof_pb"));
const web3authService = __importStar(require("./web3auth/service_pb"));
const web3authWallet = __importStar(require("./web3auth/wallet_pb"));
// Import Helpers for JSON-to-request conversion
const helpers_1 = require("./helpers");
// Export all message types for easy access
exports.Messages = {
Activity: {
Listening_history: activityListening_history,
Listening_session: activityListening_session,
Param: activityParam,
Processing_cycles: activityProcessing_cycles,
Rate_param: activityRate_param,
Referral: activityReferral,
Rewards: activityRewards,
Service: activityService,
User_favorite: activityUser_favorite,
User_points: activityUser_points,
User_referral_rewards: activityUser_referral_rewards,
User_rewards: activityUser_rewards,
},
Auth: {
Account: authAccount,
Service: authService,
Session: authSession,
Verification_token: authVerification_token,
},
Music: {
Album: musicAlbum,
Artist: musicArtist,
Genre: musicGenre,
Playlist: musicPlaylist,
Service: musicService,
Track: musicTrack,
},
Stats: {
Point_boost: statsPoint_boost,
Service: statsService,
User_statistics: statsUser_statistics,
},
User: {
Service: userService,
User: userUser,
},
Web3Auth: {
Auth_proof: web3authAuth_proof,
Service: web3authService,
Wallet: web3authWallet,
},
};
/**
* Unified EchoFi gRPC-Web Client
* Provides access to all backend services with proper protobuf serialization
*/
class EchoFiGrpcWebClient {
constructor(config = {}) {
/**
* Enhanced authentication state management
*/
this._authState = {
sessionToken: null,
isAuthenticated: false,
lastValidation: 0
};
// Parse host if it contains protocol
let parsedHost = config.host || 'localhost';
let parsedSecure = config.secure;
// Handle cases where host includes protocol (e.g., "http://example.com" or "https://example.com")
if (parsedHost.startsWith('http://') || parsedHost.startsWith('https://')) {
try {
const url = new URL(parsedHost);
parsedHost = url.hostname;
// Auto-detect secure from protocol if not explicitly set
if (parsedSecure === undefined) {
parsedSecure = url.protocol === 'https:';
}
// Use port from URL if specified and not overridden in config
if (!config.port && url.port) {
config.port = parseInt(url.port, 10);
}
}
catch (error) {
console.warn('⚠️ Invalid URL format in host, using as hostname:', parsedHost);
// Remove protocol manually if URL parsing fails
parsedHost = parsedHost.replace(/^https?:\/\//, '');
}
}
// Set default configuration with smart port defaults
const defaultPort = parsedSecure ? 443 : 8080;
this.config = {
host: parsedHost,
port: config.port || defaultPort,
secure: parsedSecure || false,
credentials: config.credentials || {},
options: config.options || {},
};
// Construct hostname
const protocol = this.config.secure ? 'https' : 'http';
const standardPort = this.config.secure ? 443 : 80;
// Only include port in URL if it's not the standard port for the protocol
if (this.config.port === standardPort) {
this.hostname = `${protocol}://${this.config.host}`;
}
else {
this.hostname = `${protocol}://${this.config.host}:${this.config.port}`;
}
// Set default options for gRPC-Web with proper CORS headers
const grpcOptions = {
format: 'text',
withCredentials: false, // Set to true if you need cookies/auth
...this.config.options,
};
// Initialize service clients
this._activityClient = new ServiceServiceClientPb_1.ActivityServiceClient(this.hostname, this.config.credentials, grpcOptions);
this._authClient = new ServiceServiceClientPb_2.AuthServiceClient(this.hostname, this.config.credentials, grpcOptions);
this._musicClient = new ServiceServiceClientPb_3.MusicServiceClient(this.hostname, this.config.credentials, grpcOptions);
this._statsClient = new ServiceServiceClientPb_4.StatsServiceClient(this.hostname, this.config.credentials, grpcOptions);
this._userClient = new ServiceServiceClientPb_5.UserServiceClient(this.hostname, this.config.credentials, grpcOptions);
this._web3authClient = new ServiceServiceClientPb_6.Web3AuthServiceClient(this.hostname, this.config.credentials, grpcOptions);
console.log(`🌐 EchoFi gRPC-Web Client initialized for ${this.hostname}`);
}
/**
* Initialize the client (for compatibility with existing code)
*/
async initialize() {
console.log('✅ EchoFi gRPC-Web Client ready');
}
/**
* Check if the client is connected (always true for gRPC-Web)
*/
isConnected() {
return true;
}
/**
* Get the hostname being used
*/
getHostname() {
return this.hostname;
}
/**
* Create metadata for authenticated requests
*/
createAuthMetadata(sessionToken) {
const metadata = {};
metadata['authorization'] = `Bearer ${sessionToken}`;
return metadata;
}
/**
* Create metadata with proper CORS headers
*/
createCorsMetadata(additionalHeaders = {}) {
const metadata = {
'content-type': 'application/grpc-web+proto',
...additionalHeaders,
};
return metadata;
}
/**
* Make an authenticated gRPC call with automatic error handling
*/
async makeAuthenticatedCall(sessionToken, callFn) {
if (!sessionToken) {
throw new Error('Authentication required - no session token provided');
}
const metadata = this.createAuthMetadata(sessionToken);
try {
return await callFn(metadata);
}
catch (error) {
const grpcError = error;
// Enhanced error handling for authentication
if (grpcError.code === 16) { // UNAUTHENTICATED
throw new Error('Authentication failed - session token may be expired or invalid');
}
else if (grpcError.code === 7) { // PERMISSION_DENIED
throw new Error('Permission denied - insufficient privileges for this operation');
}
// Re-throw other errors as-is
throw error;
}
}
/**
* Web3 Authentication Helper - Connect and authenticate with wallet
* Note: This method provides a template for wallet authentication.
* Actual wallet signing must be implemented in the frontend application.
*/
async authenticateWithWallet(walletAddress, userInfo) {
// This method serves as a template for the authentication flow
// The actual implementation should be done in the frontend with proper wallet integration
throw new Error('Web3 authentication must be implemented in the frontend with wallet integration. Use the web3-provider.ts for actual implementation.');
}
/**
* Session Token Validation Helper
*/
async validateSessionToken(sessionToken) {
try {
// Try to make a simple authenticated call to validate the token
await this.makeAuthenticatedCall(sessionToken, async (metadata) => {
return this.getUser({}, metadata);
});
return true;
}
catch (error) {
return false;
}
}
/**
* Set session token for automatic authentication
*/
setSessionToken(sessionToken) {
this._authState.sessionToken = sessionToken;
this._authState.isAuthenticated = !!sessionToken;
this._authState.lastValidation = sessionToken ? Date.now() : 0;
}
/**
* Get current session token
*/
getSessionToken() {
return this._authState.sessionToken;
}
/**
* Check if client is authenticated
*/
isAuthenticated() {
return this._authState.isAuthenticated && !!this._authState.sessionToken;
}
/**
* Make authenticated call using stored session token
*/
async callAuthenticated(callFn) {
return this.makeAuthenticatedCall(this._authState.sessionToken, callFn);
}
// Activity Service Enhanced Methods
/**
* GetUserFavorite - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a GetUserFavoriteRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async getUserFavorite(requestOrData, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof activityService.GetUserFavoriteRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Activity.createGetUserFavoriteRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._activityClient.getUserFavorite(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* ListUserFavorites - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a ListUserFavoritesRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async listUserFavorites(requestOrData = {}, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof activityService.ListUserFavoritesRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Activity.createListUserFavoritesRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._activityClient.listUserFavorites(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* AddUserFavorite - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a AddUserFavoriteRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async addUserFavorite(requestOrData, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof activityService.AddUserFavoriteRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Activity.createAddUserFavoriteRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._activityClient.addUserFavorite(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* RemoveUserFavorite - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a RemoveUserFavoriteRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async removeUserFavorite(requestOrData, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof activityService.RemoveUserFavoriteRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Activity.createRemoveUserFavoriteRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._activityClient.removeUserFavorite(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* GetRateParam - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a GetRateParamRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async getRateParam(requestOrData, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof activityService.GetRateParamRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Activity.createGetRateParamRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._activityClient.getRateParam(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* ListRateParams - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a ListRateParamsRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async listRateParams(requestOrData = {}, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof activityService.ListRateParamsRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Activity.createListRateParamsRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._activityClient.listRateParams(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* GetListeningHistory - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a GetListeningHistoryRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async getListeningHistory(requestOrData, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof activityService.GetListeningHistoryRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Activity.createGetListeningHistoryRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._activityClient.getListeningHistory(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* ListListeningHistory - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a ListListeningHistoryRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async listListeningHistory(requestOrData = {}, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof activityService.ListListeningHistoryRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Activity.createListListeningHistoryRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._activityClient.listListeningHistory(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* GetListeningSession - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a GetListeningSessionRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async getListeningSession(requestOrData, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof activityService.GetListeningSessionRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Activity.createGetListeningSessionRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._activityClient.getListeningSession(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* ListListeningSessions - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a ListListeningSessionsRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async listListeningSessions(requestOrData = {}, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof activityService.ListListeningSessionsRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Activity.createListListeningSessionsRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._activityClient.listListeningSessions(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* GetUserPoints - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a GetUserPointsRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async getUserPoints(requestOrData = {}, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof activityService.GetUserPointsRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Activity.createGetUserPointsRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._activityClient.getUserPoints(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* ListUserPoints - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a ListUserPointsRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async listUserPoints(requestOrData = {}, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof activityService.ListUserPointsRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Activity.createListUserPointsRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._activityClient.listUserPoints(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* GetUnprocessedListeningRecords - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a GetUnprocessedListeningRecordsRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async getUnprocessedListeningRecords(requestOrData = {}, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof activityService.GetUnprocessedListeningRecordsRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Activity.createGetUnprocessedListeningRecordsRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._activityClient.getUnprocessedListeningRecords(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* GetUnprocessedListeningDuration - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a GetUnprocessedListeningDurationRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async getUnprocessedListeningDuration(requestOrData = {}, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof activityService.GetUnprocessedListeningDurationRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Activity.createGetUnprocessedListeningDurationRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._activityClient.getUnprocessedListeningDuration(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* SetReferrer - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a SetReferrerRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async setReferrer(requestOrData, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof activityService.SetReferrerRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Activity.createSetReferrerRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._activityClient.setReferrer(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* GetUserReferralRewards - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a GetUserReferralRewardsRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async getUserReferralRewards(requestOrData = {}, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof activityService.GetUserReferralRewardsRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Activity.createGetUserReferralRewardsRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._activityClient.getUserReferralRewards(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* ListUserReferees - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a ListUserRefereesRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async listUserReferees(requestOrData = {}, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof activityService.ListUserRefereesRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Activity.createListUserRefereesRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._activityClient.listUserReferees(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* GetUserRewards - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a GetUserRewardsRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async getUserRewards(requestOrData = {}, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof activityService.GetUserRewardsRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Activity.createGetUserRewardsRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._activityClient.getUserRewards(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* ListRewards - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a ListRewardsRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async listRewards(requestOrData = {}, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof activityService.ListRewardsRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Activity.createListRewardsRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._activityClient.listRewards(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
// Auth Service Enhanced Methods
/**
* GetSession - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a GetSessionRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async getSession(requestOrData, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof authService.GetSessionRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Auth.createGetSessionRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._authClient.getSession(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* CreateSession - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a CreateSessionRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async createSession(requestOrData, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof authService.CreateSessionRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Auth.createCreateSessionRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._authClient.createSession(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* DeleteSession - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a DeleteSessionRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async deleteSession(requestOrData, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof authService.DeleteSessionRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Auth.createDeleteSessionRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._authClient.deleteSession(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
// Music Service Enhanced Methods
/**
* GetArtist - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a GetArtistRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async getArtist(requestOrData, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof musicService.GetArtistRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Music.createGetArtistRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._musicClient.getArtist(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* ListArtists - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a ListArtistsRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async listArtists(requestOrData = {}, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof musicService.ListArtistsRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Music.createListArtistsRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._musicClient.listArtists(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* GetAlbum - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a GetAlbumRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async getAlbum(requestOrData, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof musicService.GetAlbumRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Music.createGetAlbumRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._musicClient.getAlbum(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* ListAlbums - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a ListAlbumsRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async listAlbums(requestOrData = {}, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof musicService.ListAlbumsRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Music.createListAlbumsRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._musicClient.listAlbums(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* GetTrack - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a GetTrackRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async getTrack(requestOrData, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof musicService.GetTrackRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Music.createGetTrackRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._musicClient.getTrack(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* ListTracks - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a ListTracksRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async listTracks(requestOrData = {}, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof musicService.ListTracksRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Music.createListTracksRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._musicClient.listTracks(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* GetGenre - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a GetGenreRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async getGenre(requestOrData, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof musicService.GetGenreRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Music.createGetGenreRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._musicClient.getGenre(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* ListGenres - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a ListGenresRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async listGenres(requestOrData = {}, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof musicService.ListGenresRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Music.createListGenresRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._musicClient.listGenres(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* GetPlaylist - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a GetPlaylistRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async getPlaylist(requestOrData, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof musicService.GetPlaylistRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Music.createGetPlaylistRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._musicClient.getPlaylist(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* ListPlaylists - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a ListPlaylistsRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async listPlaylists(requestOrData = {}, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof musicService.ListPlaylistsRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Music.createListPlaylistsRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._musicClient.listPlaylists(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* GetUserPlaylists - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a GetUserPlaylistsRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async getUserPlaylists(requestOrData = {}, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof musicService.GetUserPlaylistsRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Music.createGetUserPlaylistsRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._musicClient.getUserPlaylists(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* GetPublicPlaylists - Enhanc