@foxtware/mineral 0.1.28 → 0.1.29

package/api/spotify/spotifyArtistGet.js

@@ -0,0 +1,71 @@
+// https://developer.spotify.com/documentation/web-api/reference/get-an-artist
+
+const { ArgsWarden, actionSingleOrMultiple, logDeep } = require('../utils');
+const { credsValidator } = require('../validators');
+const { spotifyClient } = require('../spotify/spotify.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['artistId'],
+]);
+
+const spotifyArtistGetSingle = async (
+  credsPayload,
+  artistId,
+  {
+    fetchClient = spotifyClient,
+  } = {},
+) => {
+  const response = await fetchClient.fetch({
+    context: { credsPayload },
+    requestPayload: {
+      method: 'get',
+      url: `/artists/${ artistId }`,
+    },
+  });
+
+  const { ok, data, error } = response;
+  if (!ok) {
+    logDeep({ error });
+    return { ok: false, error };
+  }
+
+  return { ok: true, data };
+};
+
+const spotifyArtistGet = async (
+  credsPayload,
+  artistId,
+  {
+    queueRunOptions,
+    fetchClient,
+  } = {},
+) => {
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    artistId,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  return actionSingleOrMultiple(
+    artistId,
+    spotifyArtistGetSingle,
+    (artistIdItem) => ({
+      args: [credsPayload, artistIdItem, { fetchClient }],
+    }),
+    {
+      ...(queueRunOptions ? { queueRunOptions } : {}),
+    },
+  );
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  spotifyArtistGet,
+  funcApiConfig,
+};

package/api/spotify/spotifyArtistTopTracksGet.js

@@ -0,0 +1,56 @@
+// https://developer.spotify.com/documentation/web-api/reference/get-an-artists-top-tracks
+
+const { ArgsWarden, logDeep } = require('../utils');
+const { credsValidator } = require('../validators');
+const { spotifyClient } = require('../spotify/spotify.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['artistId'],
+]);
+
+const spotifyArtistTopTracksGet = async (
+  credsPayload,
+  artistId,
+  {
+    market = 'US',
+    fetchClient = spotifyClient,
+  } = {},
+) => {
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    artistId,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const response = await fetchClient.fetch({
+    context: { credsPayload },
+    requestPayload: {
+      method: 'get',
+      url: `/artists/${ artistId }/top-tracks`,
+      params: { market },
+    },
+  });
+
+  const { ok, data, error } = response;
+  if (!ok) {
+    logDeep({ error });
+    return { ok: false, error };
+  }
+
+  return {
+    ok: true,
+    data: data.tracks ?? data,
+  };
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  spotifyArtistTopTracksGet,
+  funcApiConfig,
+};

package/api/spotify/spotifyGet.js

@@ -0,0 +1,171 @@
+// https://developer.spotify.com/documentation/web-api/concepts/api-calls#pagination
+
+const { ArgsWarden, Getter } = require('../utils');
+const { credsValidator } = require('../validators');
+const { spotifyClient } = require('../spotify/spotify.utils');
+const { MAX_PER_PAGE } = require('../spotify/spotify.constants');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['url'],
+]);
+
+const digResults = (data, resultsKey) => {
+  if (resultsKey) {
+    // Nested e.g. tracks.items or playlists.items
+    const value = resultsKey.split('.').reduce(
+      (node, key) => node?.[key],
+      data,
+    );
+    if (Array.isArray(value)) {
+      return value;
+    }
+    return value != null ? [value] : [];
+  }
+
+  if (Array.isArray(data?.items)) {
+    return data.items;
+  }
+
+  if (Array.isArray(data)) {
+    return data;
+  }
+
+  return [];
+};
+
+const spotifyGetPacket = async (
+  credsPayload,
+  url,
+  {
+    params,
+    perPage = MAX_PER_PAGE,
+    fetchClient = spotifyClient,
+  } = {},
+) => {
+  return fetchClient.fetch({
+    requestPayload: {
+      method: 'get',
+      url,
+      params: {
+        limit: Math.min(perPage, MAX_PER_PAGE),
+        offset: 0,
+        ...params,
+      },
+    },
+    context: {
+      credsPayload,
+    },
+  });
+};
+
+const spotifyGetPaginator = async (currentParams, response) => {
+  if (!response?.ok) {
+    return [true];
+  }
+
+  const page = response.data ?? {};
+  // Spotify paging objects expose next (URL) or offset/limit/total.
+  if (page.next == null && page.items) {
+    const { offset = 0, limit = 0, total = 0 } = page;
+    if (offset + limit >= total || page.items.length === 0) {
+      return [true];
+    }
+  } else if (!page.next) {
+    return [true];
+  }
+
+  const { args, options } = currentParams;
+  const { params = {}, perPage = MAX_PER_PAGE } = options;
+  const currentOffset = Number(params.offset ?? 0);
+  const pageLimit = Number(params.limit ?? perPage);
+
+  return [false, {
+    args,
+    options: {
+      ...options,
+      params: {
+        ...params,
+        offset: currentOffset + pageLimit,
+        limit: pageLimit,
+      },
+    },
+  }];
+};
+
+const spotifyGet = async (
+  returnGetter,
+
+  credsPayload,
+  url,
+  {
+    params,
+    perPage = MAX_PER_PAGE,
+    resultsKey = 'items',
+    fetchClient,
+    ...getterOptions
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    url,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const getter = new Getter(
+    {
+      args: [credsPayload, url],
+      options: {
+        params,
+        perPage,
+        fetchClient,
+      },
+    },
+    {
+      func: spotifyGetPacket,
+      digester: (response) => {
+        if (!response?.ok) {
+          return [];
+        }
+
+        return digResults(response.data, resultsKey);
+      },
+      paginator: spotifyGetPaginator,
+      ...getterOptions,
+    },
+  );
+
+  if (returnGetter) {
+    return getter;
+  }
+
+  const data = await getter.run({ returnAll: true });
+
+  return {
+    ok: true,
+    data,
+  };
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  spotifyGet: (...args) => spotifyGet(false, ...args),
+  spotifyGetter: (...args) => spotifyGet(true, ...args),
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/spotifyGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "spotify" },
+    "url": "/me/playlists",
+    "options": { "perPage": 20 }
+  }'
+*/

package/api/spotify/spotifyMeGet.js

@@ -0,0 +1,48 @@
+// https://developer.spotify.com/documentation/web-api/reference/get-current-users-profile
+
+const { ArgsWarden, logDeep } = require('../utils');
+const { credsValidator } = require('../validators');
+const { spotifyClient } = require('../spotify/spotify.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+]);
+
+const spotifyMeGet = async (
+  credsPayload,
+  {
+    fetchClient = spotifyClient,
+  } = {},
+) => {
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const response = await fetchClient.fetch({
+    context: { credsPayload },
+    requestPayload: {
+      method: 'get',
+      url: '/me',
+    },
+  });
+
+  const { ok, data, error } = response;
+  if (!ok) {
+    logDeep({ error });
+    return { ok: false, error };
+  }
+
+  return { ok: true, data };
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  spotifyMeGet,
+  funcApiConfig,
+};

package/api/spotify/spotifyPlayerCurrentlyPlayingGet.js

@@ -0,0 +1,62 @@
+// https://developer.spotify.com/documentation/web-api/reference/get-the-users-currently-playing-track
+
+const { ArgsWarden, logDeep } = require('../utils');
+const { credsValidator } = require('../validators');
+const { spotifyClient } = require('../spotify/spotify.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+]);
+
+const spotifyPlayerCurrentlyPlayingGet = async (
+  credsPayload,
+  {
+    market,
+    additionalTypes,
+    fetchClient = spotifyClient,
+  } = {},
+) => {
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const response = await fetchClient.fetch({
+    context: { credsPayload },
+    requestPayload: {
+      method: 'get',
+      url: '/me/player/currently-playing',
+      params: {
+        ...(market !== undefined && { market }),
+        ...(additionalTypes !== undefined && {
+          additional_types: Array.isArray(additionalTypes)
+            ? additionalTypes.join(',')
+            : additionalTypes,
+        }),
+      },
+    },
+  });
+
+  if (response.ok && (response.data == null || response.data === '')) {
+    return { ok: true, data: null };
+  }
+
+  const { ok, data, error } = response;
+  if (!ok) {
+    logDeep({ error });
+    return { ok: false, error };
+  }
+
+  return { ok: true, data };
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  spotifyPlayerCurrentlyPlayingGet,
+  funcApiConfig,
+};

package/api/spotify/spotifyPlayerDevicesGet.js

@@ -0,0 +1,51 @@
+// https://developer.spotify.com/documentation/web-api/reference/get-a-users-available-devices
+
+const { ArgsWarden, logDeep } = require('../utils');
+const { credsValidator } = require('../validators');
+const { spotifyClient } = require('../spotify/spotify.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+]);
+
+const spotifyPlayerDevicesGet = async (
+  credsPayload,
+  {
+    fetchClient = spotifyClient,
+  } = {},
+) => {
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const response = await fetchClient.fetch({
+    context: { credsPayload },
+    requestPayload: {
+      method: 'get',
+      url: '/me/player/devices',
+    },
+  });
+
+  const { ok, data, error } = response;
+  if (!ok) {
+    logDeep({ error });
+    return { ok: false, error };
+  }
+
+  return {
+    ok: true,
+    data: data.devices ?? data,
+  };
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  spotifyPlayerDevicesGet,
+  funcApiConfig,
+};

package/api/spotify/spotifyPlayerGet.js

@@ -0,0 +1,63 @@
+// https://developer.spotify.com/documentation/web-api/reference/get-information-about-the-users-current-playback
+
+const { ArgsWarden, logDeep } = require('../utils');
+const { credsValidator } = require('../validators');
+const { spotifyClient } = require('../spotify/spotify.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+]);
+
+const spotifyPlayerGet = async (
+  credsPayload,
+  {
+    market,
+    additionalTypes,
+    fetchClient = spotifyClient,
+  } = {},
+) => {
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const response = await fetchClient.fetch({
+    context: { credsPayload },
+    requestPayload: {
+      method: 'get',
+      url: '/me/player',
+      params: {
+        ...(market !== undefined && { market }),
+        ...(additionalTypes !== undefined && {
+          additional_types: Array.isArray(additionalTypes)
+            ? additionalTypes.join(',')
+            : additionalTypes,
+        }),
+      },
+    },
+  });
+
+  // 204 = nothing currently playing / no active device
+  if (response.ok && (response.data == null || response.data === '')) {
+    return { ok: true, data: null };
+  }
+
+  const { ok, data, error } = response;
+  if (!ok) {
+    logDeep({ error });
+    return { ok: false, error };
+  }
+
+  return { ok: true, data };
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  spotifyPlayerGet,
+  funcApiConfig,
+};

package/api/spotify/spotifyPlayerNext.js

@@ -0,0 +1,55 @@
+// https://developer.spotify.com/documentation/web-api/reference/skip-users-playback-to-next-track
+
+const { ArgsWarden, logDeep } = require('../utils');
+const { credsValidator } = require('../validators');
+const { spotifyClient } = require('../spotify/spotify.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+]);
+
+const spotifyPlayerNext = async (
+  credsPayload,
+  {
+    deviceId,
+    fetchClient = spotifyClient,
+  } = {},
+) => {
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const response = await fetchClient.fetch({
+    context: { credsPayload },
+    requestPayload: {
+      method: 'post',
+      url: '/me/player/next',
+      params: {
+        ...(deviceId !== undefined && { device_id: deviceId }),
+      },
+    },
+  });
+
+  const { ok, data, error } = response;
+  if (!ok) {
+    logDeep({ error });
+    return { ok: false, error };
+  }
+
+  return {
+    ok: true,
+    data: data ?? null,
+  };
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  spotifyPlayerNext,
+  funcApiConfig,
+};

package/api/spotify/spotifyPlayerPause.js

@@ -0,0 +1,55 @@
+// https://developer.spotify.com/documentation/web-api/reference/pause-a-users-playback
+
+const { ArgsWarden, logDeep } = require('../utils');
+const { credsValidator } = require('../validators');
+const { spotifyClient } = require('../spotify/spotify.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+]);
+
+const spotifyPlayerPause = async (
+  credsPayload,
+  {
+    deviceId,
+    fetchClient = spotifyClient,
+  } = {},
+) => {
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const response = await fetchClient.fetch({
+    context: { credsPayload },
+    requestPayload: {
+      method: 'put',
+      url: '/me/player/pause',
+      params: {
+        ...(deviceId !== undefined && { device_id: deviceId }),
+      },
+    },
+  });
+
+  const { ok, data, error } = response;
+  if (!ok) {
+    logDeep({ error });
+    return { ok: false, error };
+  }
+
+  return {
+    ok: true,
+    data: data ?? null,
+  };
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  spotifyPlayerPause,
+  funcApiConfig,
+};

package/api/spotify/spotifyPlayerPlay.js

@@ -0,0 +1,70 @@
+// https://developer.spotify.com/documentation/web-api/reference/start-a-users-playback
+
+const { ArgsWarden, logDeep } = require('../utils');
+const { credsValidator } = require('../validators');
+const { spotifyClient } = require('../spotify/spotify.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+]);
+
+const spotifyPlayerPlay = async (
+  credsPayload,
+  {
+    deviceId,
+    contextUri,
+    uris,
+    offset,
+    positionMs,
+    fetchClient = spotifyClient,
+  } = {},
+) => {
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const body = {
+    ...(contextUri !== undefined && { context_uri: contextUri }),
+    ...(uris !== undefined && {
+      uris: Array.isArray(uris) ? uris : [uris],
+    }),
+    ...(offset !== undefined && { offset }),
+    ...(positionMs !== undefined && { position_ms: positionMs }),
+  };
+
+  const response = await fetchClient.fetch({
+    context: { credsPayload },
+    requestPayload: {
+      method: 'put',
+      url: '/me/player/play',
+      params: {
+        ...(deviceId !== undefined && { device_id: deviceId }),
+      },
+      // Spotify accepts empty body to resume.
+      body: Object.keys(body).length ? body : {},
+    },
+  });
+
+  const { ok, data, error } = response;
+  if (!ok) {
+    logDeep({ error });
+    return { ok: false, error };
+  }
+
+  return {
+    ok: true,
+    data: data ?? null,
+  };
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  spotifyPlayerPlay,
+  funcApiConfig,
+};