@keystrokehq/spotify 0.0.1

package/dist/follow.d.mts

@@ -0,0 +1,83 @@
+import { z } from "zod";
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+
+//#region src/follow.d.ts
+declare const getFollowedArtists: _keystrokehq_core0.Operation<z.ZodObject<{
+  after: z.ZodOptional<z.ZodString>;
+  limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+  href: z.ZodOptional<z.ZodURL>;
+  items: z.ZodArray<z.ZodObject<{
+    externalUrls: z.ZodOptional<z.ZodObject<{
+      spotify: z.ZodOptional<z.ZodURL>;
+    }, z.core.$strip>>;
+    href: z.ZodOptional<z.ZodURL>;
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodLiteral<"artist">;
+    uri: z.ZodOptional<z.ZodString>;
+    followers: z.ZodOptional<z.ZodObject<{
+      href: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
+      total: z.ZodNumber;
+    }, z.core.$strip>>;
+    genres: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    images: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      url: z.ZodURL;
+      height: z.ZodNullable<z.ZodNumber>;
+      width: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    popularity: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>;
+  limit: z.ZodNumber;
+  nextPageToken: z.ZodOptional<z.ZodString>;
+  previousPageToken: z.ZodOptional<z.ZodString>;
+  total: z.ZodOptional<z.ZodNumber>;
+  cursors: z.ZodOptional<z.ZodObject<{
+    after: z.ZodOptional<z.ZodString>;
+    before: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"spotify", z.ZodObject<{
+  SPOTIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SPOTIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const followArtistsOrUsers: _keystrokehq_core0.Operation<z.ZodObject<{
+  type: z.ZodEnum<{
+    artist: "artist";
+    user: "user";
+  }>;
+  ids: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  success: z.ZodLiteral<true>;
+}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"spotify", z.ZodObject<{
+  SPOTIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SPOTIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const unfollowArtistsOrUsers: _keystrokehq_core0.Operation<z.ZodObject<{
+  type: z.ZodEnum<{
+    artist: "artist";
+    user: "user";
+  }>;
+  ids: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  success: z.ZodLiteral<true>;
+}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"spotify", z.ZodObject<{
+  SPOTIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SPOTIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const checkFollowingArtistsOrUsers: _keystrokehq_core0.Operation<z.ZodObject<{
+  type: z.ZodEnum<{
+    artist: "artist";
+    user: "user";
+  }>;
+  ids: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodArray<z.ZodBoolean>, readonly [_keystrokehq_core0.CredentialSet<"spotify", z.ZodObject<{
+  SPOTIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SPOTIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+//#endregion
+export { checkFollowingArtistsOrUsers, followArtistsOrUsers, getFollowedArtists, unfollowArtistsOrUsers };

package/dist/follow.mjs

@@ -0,0 +1,65 @@
+import { createSpotifyCursorPageSchema, spotifyArtistSchema, spotifyBooleanListSchema, spotifyIdSchema, spotifyMutationSuccessSchema } from "./schemas.mjs";
+import { createSpotifyClient } from "./client.mjs";
+import { t as spotifyOperation } from "./factory-tZba6Hij.mjs";
+import { z } from "zod";
+
+//#region src/follow.ts
+const followTypeSchema = z.enum(["artist", "user"]);
+const followIdsSchema = z.array(spotifyIdSchema).min(1).max(50);
+const followedArtistsPageSchema = createSpotifyCursorPageSchema(spotifyArtistSchema);
+const followedArtistsInputSchema = z.object({
+	after: z.string().min(1).optional(),
+	limit: z.number().int().min(1).max(50).optional()
+});
+const followMutationInputSchema = z.object({
+	type: followTypeSchema,
+	ids: followIdsSchema
+});
+const getFollowedArtists = spotifyOperation({
+	id: "get_spotify_followed_artists",
+	name: "Get Followed Spotify Artists",
+	description: "List the artists followed by the current Spotify user.",
+	input: followedArtistsInputSchema,
+	output: followedArtistsPageSchema,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).follow.getFollowedArtists({
+			after: input.after,
+			limit: input.limit
+		});
+	}
+});
+const followArtistsOrUsers = spotifyOperation({
+	id: "follow_spotify_artists_or_users",
+	name: "Follow Spotify Artists Or Users",
+	description: "Follow Spotify artists or users for the current account.",
+	needsApproval: true,
+	input: followMutationInputSchema,
+	output: spotifyMutationSuccessSchema,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).follow.followArtistsOrUsers(input.type, input.ids);
+	}
+});
+const unfollowArtistsOrUsers = spotifyOperation({
+	id: "unfollow_spotify_artists_or_users",
+	name: "Unfollow Spotify Artists Or Users",
+	description: "Unfollow Spotify artists or users for the current account.",
+	needsApproval: true,
+	input: followMutationInputSchema,
+	output: spotifyMutationSuccessSchema,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).follow.unfollowArtistsOrUsers(input.type, input.ids);
+	}
+});
+const checkFollowingArtistsOrUsers = spotifyOperation({
+	id: "check_spotify_following_artists_or_users",
+	name: "Check Following Spotify Artists Or Users",
+	description: "Check whether the current Spotify user follows the given artists or users.",
+	input: followMutationInputSchema,
+	output: spotifyBooleanListSchema,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).follow.checkFollowingArtistsOrUsers(input.type, input.ids);
+	}
+});
+
+//#endregion
+export { checkFollowingArtistsOrUsers, followArtistsOrUsers, getFollowedArtists, unfollowArtistsOrUsers };

package/dist/genres.d.mts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+
+//#region src/genres.d.ts
+declare const getAvailableGenreSeeds: _keystrokehq_core0.Operation<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+  genres: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"spotify", z.ZodObject<{
+  SPOTIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SPOTIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+//#endregion
+export { getAvailableGenreSeeds };

package/dist/genres.mjs

@@ -0,0 +1,19 @@
+import { createSpotifyClient } from "./client.mjs";
+import { t as spotifyOperation } from "./factory-tZba6Hij.mjs";
+import { z } from "zod";
+
+//#region src/genres.ts
+const availableGenreSeedsResponseSchema = z.object({ genres: z.array(z.string().min(1)) });
+const getAvailableGenreSeeds = spotifyOperation({
+	id: "get_spotify_available_genre_seeds",
+	name: "Get Spotify Available Genre Seeds",
+	description: "List Spotify recommendation genre seeds. This endpoint is deprecated upstream by Spotify.",
+	input: z.object({}),
+	output: availableGenreSeedsResponseSchema,
+	run: async (_input, credentials) => {
+		return createSpotifyClient(credentials).discovery.getAvailableGenreSeeds();
+	}
+});
+
+//#endregion
+export { getAvailableGenreSeeds };

package/dist/index.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/index.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/integration-DQ5Egd4f.d.mts

@@ -0,0 +1,41 @@
+import * as _keystrokehq_integration_authoring_official0 from "@keystrokehq/integration-authoring/official";
+import { z } from "zod";
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+import { InferCredentialSetAuth } from "@keystrokehq/core/credential-set";
+
+//#region src/integration.d.ts
+declare const spotifyOfficialIntegration: {
+  id: "spotify";
+  name: string;
+  description: string;
+  proxy: {
+    hosts: string[];
+  };
+  auth: z.ZodObject<{
+    SPOTIFY_ACCESS_TOKEN: z.ZodString;
+  }, z.core.$strip>;
+  connections: {
+    id: string;
+    kind: "oauth";
+    tokenType: "refreshable";
+    authUrl: string;
+    tokenUrl: string;
+    revokeUrl: null;
+    scopes: ("user-read-private" | "user-read-email" | "user-read-recently-played" | "user-top-read" | "user-library-read" | "user-library-modify" | "playlist-read-private" | "playlist-read-collaborative" | "playlist-modify-private" | "playlist-modify-public" | "user-read-currently-playing" | "user-modify-playback-state" | "user-read-playback-state" | "user-follow-read" | "user-follow-modify" | "user-read-playback-position" | "ugc-image-upload")[];
+    vault: {
+      accessToken: "SPOTIFY_ACCESS_TOKEN";
+    };
+  }[];
+};
+declare const spotifyBundle: _keystrokehq_integration_authoring_official0.OfficialIntegrationBundle<"spotify", z.ZodObject<{
+  SPOTIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>;
+declare const spotify: _keystrokehq_core0.CredentialSet<"spotify", z.ZodObject<{
+  SPOTIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SPOTIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>;
+type SpotifyCredentials = InferCredentialSetAuth<typeof spotify>;
+//#endregion
+export { spotifyOfficialIntegration as i, spotify as n, spotifyBundle as r, SpotifyCredentials as t };

package/dist/integration-ykoImsCq.mjs

@@ -0,0 +1,78 @@
+import { defineOfficialIntegration } from "@keystrokehq/integration-authoring/official";
+import { z } from "zod";
+import { CredentialSet } from "@keystrokehq/core";
+
+//#region src/_official/provider-app.ts
+const spotifyAppCredentialSet = new CredentialSet({
+	id: "spotify-app",
+	exposure: "platform-only",
+	name: "Spotify App",
+	auth: z.object({
+		clientId: z.string().min(1),
+		clientSecret: z.string().min(1)
+	})
+});
+const spotifyPlatformProviderSeed = {
+	provider: "spotify",
+	appRef: "spotify-platform",
+	displayName: "Spotify Platform",
+	credentialSetName: "Keystroke Spotify Platform App",
+	envShape: {
+		KEYSTROKE_PLATFORM_SPOTIFY_CLIENT_ID: z.string().optional(),
+		KEYSTROKE_PLATFORM_SPOTIFY_CLIENT_SECRET: z.string().optional()
+	},
+	requiredEnvKeys: ["KEYSTROKE_PLATFORM_SPOTIFY_CLIENT_ID", "KEYSTROKE_PLATFORM_SPOTIFY_CLIENT_SECRET"],
+	externalAppIdEnvKey: "KEYSTROKE_PLATFORM_SPOTIFY_CLIENT_ID",
+	buildCredentials: (env) => ({
+		clientId: env.KEYSTROKE_PLATFORM_SPOTIFY_CLIENT_ID,
+		clientSecret: env.KEYSTROKE_PLATFORM_SPOTIFY_CLIENT_SECRET
+	})
+};
+
+//#endregion
+//#region src/integration.ts
+const spotifyAuthSchema = z.object({ SPOTIFY_ACCESS_TOKEN: z.string().min(1) });
+const spotifyScopes = [
+	"user-read-private",
+	"user-read-email",
+	"user-read-recently-played",
+	"user-top-read",
+	"user-library-read",
+	"user-library-modify",
+	"playlist-read-private",
+	"playlist-read-collaborative",
+	"playlist-modify-private",
+	"playlist-modify-public",
+	"user-read-currently-playing",
+	"user-modify-playback-state",
+	"user-read-playback-state",
+	"user-follow-read",
+	"user-follow-modify",
+	"user-read-playback-position",
+	"ugc-image-upload"
+];
+const spotifyOfficialIntegration = {
+	id: "spotify",
+	name: "Spotify",
+	description: "Spotify playback, catalog, playlists, library, and polling triggers for Keystroke workflows",
+	proxy: { hosts: ["api.spotify.com", "accounts.spotify.com"] },
+	auth: spotifyAuthSchema,
+	connections: [{
+		id: "oauth",
+		kind: "oauth",
+		tokenType: "refreshable",
+		authUrl: "https://accounts.spotify.com/authorize",
+		tokenUrl: "https://accounts.spotify.com/api/token",
+		revokeUrl: null,
+		scopes: [...spotifyScopes],
+		vault: { accessToken: "SPOTIFY_ACCESS_TOKEN" }
+	}]
+};
+const spotifyBundle = defineOfficialIntegration({
+	...spotifyOfficialIntegration,
+	internal: { providerApp: spotifyAppCredentialSet }
+});
+const spotify = spotifyBundle.credentialSet;
+
+//#endregion
+export { spotifyPlatformProviderSeed as a, spotifyAppCredentialSet as i, spotifyBundle as n, spotifyOfficialIntegration as r, spotify as t };