echofi-client
Version:
A TypeScript/Node.js client library for EchoFi services with Level 3 Ultimate API and gRPC-Web clients for music streaming, user management, activity tracking, and authentication.
1,237 lines • 48.3 kB
JavaScript
;
/**
* 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");
// Import message types
const activityListening_history = __importStar(require("./activity/listening_history_pb"));
const activityListening_session = __importStar(require("./activity/listening_session_pb"));
const activityPlaylist = __importStar(require("./activity/playlist_pb"));
const activityRate_param = __importStar(require("./activity/rate_param_pb"));
const activityService = __importStar(require("./activity/service_pb"));
const activityUser_favorite = __importStar(require("./activity/user_favorite_pb"));
const activityUser_point_rate = __importStar(require("./activity/user_point_rate_pb"));
const activityUser_points = __importStar(require("./activity/user_points_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 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"));
// 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,
Playlist: activityPlaylist,
Rate_param: activityRate_param,
Service: activityService,
User_favorite: activityUser_favorite,
User_point_rate: activityUser_point_rate,
User_points: activityUser_points,
},
Auth: {
Account: authAccount,
Service: authService,
Session: authSession,
Verification_token: authVerification_token,
},
Music: {
Album: musicAlbum,
Artist: musicArtist,
Genre: musicGenre,
Service: musicService,
Track: musicTrack,
},
Stats: {
Point_boost: statsPoint_boost,
Service: statsService,
User_statistics: statsUser_statistics,
},
User: {
Service: userService,
User: userUser,
},
};
/**
* Unified EchoFi gRPC-Web Client
* Provides access to all backend services with proper protobuf serialization
*/
class EchoFiGrpcWebClient {
constructor(config = {}) {
// 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);
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;
}
// Activity Service Enhanced Methods
/**
* 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'));
}
});
});
}
/**
* 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'));
}
});
});
}
/**
* 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 activityService.GetPlaylistRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Activity.createGetPlaylistRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._activityClient.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 activityService.ListPlaylistsRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Activity.createListPlaylistsRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._activityClient.listPlaylists(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* ListPlaylistTracks - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a ListPlaylistTracksRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async listPlaylistTracks(requestOrData, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof activityService.ListPlaylistTracksRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Activity.createListPlaylistTracksRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._activityClient.listPlaylistTracks(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* GetUserPointRate - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a GetUserPointRateRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async getUserPointRate(requestOrData, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof activityService.GetUserPointRateRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Activity.createGetUserPointRateRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._activityClient.getUserPointRate(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* ListUserPointRates - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a ListUserPointRatesRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async listUserPointRates(requestOrData = {}, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof activityService.ListUserPointRatesRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Activity.createListUserPointRatesRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._activityClient.listUserPointRates(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* UpdateUserPointRate - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a UpdateUserPointRateRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async updateUserPointRate(requestOrData, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof activityService.UpdateUserPointRateRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Activity.createUpdateUserPointRateRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._activityClient.updateUserPointRate(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'));
}
});
});
}
/**
* 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'));
}
});
});
}
// 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'));
}
});
});
}
// Stats Service Enhanced Methods
/**
* GetUserStatistics - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a GetUserStatisticsRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async getUserStatistics(requestOrData, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof statsService.GetUserStatisticsRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Stats.createGetUserStatisticsRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._statsClient.getUserStatistics(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* ListUserStatistics - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a ListUserStatisticsRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async listUserStatistics(requestOrData = {}, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof statsService.ListUserStatisticsRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Stats.createListUserStatisticsRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._statsClient.listUserStatistics(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* GetPointBoost - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a GetPointBoostRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async getPointBoost(requestOrData, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof statsService.GetPointBoostRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Stats.createGetPointBoostRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._statsClient.getPointBoost(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* ListPointBoosts - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a ListPointBoostsRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async listPointBoosts(requestOrData = {}, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof statsService.ListPointBoostsRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.Stats.createListPointBoostsRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._statsClient.listPointBoosts(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
// User Service Enhanced Methods
/**
* GetUser - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a GetUserRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async getUser(requestOrData, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof userService.GetUserRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.User.createGetUserRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._userClient.getUser(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
/**
* ListUsers - Enhanced method that accepts both request objects and JSON
* @param requestOrData - Either a ListUsersRequest object or JSON data
* @param metadata - Optional gRPC metadata
*/
async listUsers(requestOrData = {}, metadata) {
let request;
// Check if it's already a request object
if (requestOrData instanceof userService.ListUsersRequest) {
request = requestOrData;
}
else {
// Convert JSON to request object using Helpers
request = helpers_1.Helpers.User.createListUsersRequest(requestOrData);
}
return new Promise((resolve, reject) => {
this._userClient.listUsers(request, metadata || {}, (err, response) => {
if (err) {
reject(err);
}
else if (response) {
resolve(response);
}
else {
reject(new Error('No response received'));
}
});
});
}
}
exports.EchoFiGrpcWebClient = EchoFiGrpcWebClient;
// Export default instance creator
function createEchoFiGrpcWebClient(config) {
return new EchoFiGrpcWebClient(config);
}
// Export for backward compatibility
exports.default = EchoFiGrpcWebClient;
//# sourceMappingURL=unified-client.js.map