@executor-js/emulate 0.6.0

package/dist/dist-DK26ESP2.js

@@ -0,0 +1,595 @@
+// ../@emulators/spotify/dist/index.js
+import { timingSafeEqual } from "crypto";
+function getSpotifyStore(store) {
+  return {
+    clients: store.collection("spotify.clients", ["client_id"]),
+    artists: store.collection("spotify.artists", ["spotify_id", "name"]),
+    albums: store.collection("spotify.albums", ["spotify_id", "artist_id"]),
+    tracks: store.collection("spotify.tracks", ["spotify_id", "album_id", "artist_id"])
+  };
+}
+var B62 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+function spotifyId() {
+  const b = new Uint8Array(22);
+  crypto.getRandomValues(b);
+  return Array.from(b, (x) => B62[x % 62]).join("");
+}
+var KEY = "spotify.tokens";
+function issueToken(store, token, rec) {
+  const m = store.getData(KEY) ?? {};
+  m[token] = rec;
+  store.setData(KEY, m);
+}
+function lookupToken(store, token) {
+  return (store.getData(KEY) ?? {})[token];
+}
+function createErrorHandler(documentationUrl) {
+  return async (c, next) => {
+    if (documentationUrl) {
+      c.set("docsUrl", documentationUrl);
+    }
+    await next();
+  };
+}
+var errorHandler = createErrorHandler();
+var isDebug = typeof process !== "undefined" && (process.env.DEBUG === "1" || process.env.DEBUG === "true" || process.env.EMULATE_DEBUG === "1");
+function constantTimeSecretEqual(a, b) {
+  const bufA = Buffer.from(a, "utf-8");
+  const bufB = Buffer.from(b, "utf-8");
+  if (bufA.length !== bufB.length) return false;
+  return timingSafeEqual(bufA, bufB);
+}
+function bodyStr(v) {
+  if (typeof v === "string") return v;
+  if (Array.isArray(v) && typeof v[0] === "string") return v[0];
+  return "";
+}
+function appsRoutes({ app, store, baseUrl }) {
+  const ss = getSpotifyStore(store);
+  app.get(
+    "/_emulator/apps",
+    (c) => c.json({
+      apps: ss.clients.all().map((cl) => ({ client_id: cl.client_id, client_secret: cl.client_secret, name: cl.name })),
+      token_url: `${baseUrl}/api/token`
+    })
+  );
+  app.post("/_emulator/apps", async (c) => {
+    const body = await c.req.parseBody().catch(() => ({}));
+    const client_id = bodyStr(body.client_id) || `app_${spotifyId().slice(0, 18)}`;
+    const client_secret = bodyStr(body.client_secret) || spotifyId();
+    if (!ss.clients.findOneBy("client_id", client_id)) {
+      ss.clients.insert({ client_id, client_secret, name: bodyStr(body.name) || "App" });
+    }
+    return c.json({ client_id, client_secret, token_url: `${baseUrl}/api/token`, grant_type: "client_credentials" });
+  });
+}
+function tokenRoutes({ app, store }) {
+  const ss = getSpotifyStore(store);
+  app.post("/api/token", async (c) => {
+    const body = await c.req.parseBody();
+    let clientId = bodyStr(body.client_id);
+    let clientSecret = bodyStr(body.client_secret);
+    const basic = /^Basic\s+(.+)$/i.exec(c.req.header("Authorization") ?? "");
+    if (basic) {
+      try {
+        const decoded = atob(basic[1].trim());
+        const sep = decoded.indexOf(":");
+        clientId = decoded.slice(0, sep);
+        clientSecret = decoded.slice(sep + 1);
+      } catch {
+      }
+    }
+    if (bodyStr(body.grant_type) !== "client_credentials") {
+      return c.json(
+        { error: "unsupported_grant_type", error_description: "grant_type must be client_credentials" },
+        400
+      );
+    }
+    const client = ss.clients.findOneBy("client_id", clientId);
+    if (!client || !constantTimeSecretEqual(clientSecret, client.client_secret)) {
+      return c.json({ error: "invalid_client", error_description: "Invalid client" }, 401);
+    }
+    const token = `BQ${spotifyId()}${spotifyId()}`;
+    issueToken(store, token, { clientId, scopes: bodyStr(body.scope).split(" ").filter(Boolean) });
+    return c.json({ access_token: token, token_type: "Bearer", expires_in: 3600 });
+  });
+}
+function catalogRoutes({ app, store, baseUrl }) {
+  const ss = getSpotifyStore(store);
+  const authed = (c) => {
+    const m = /^Bearer\s+(.+)$/i.exec(c.req.header("Authorization") ?? "");
+    return !!m && !!lookupToken(store, m[1].trim());
+  };
+  const unauthorized = (c) => c.json({ error: { status: 401, message: "Invalid access token" } }, 401);
+  const notFound = (c) => c.json({ error: { status: 404, message: "Non existing id" } }, 404);
+  const artistObj = (a) => ({
+    id: a.spotify_id,
+    name: a.name,
+    type: "artist",
+    genres: a.genres,
+    popularity: a.popularity,
+    followers: { href: null, total: a.followers },
+    uri: `spotify:artist:${a.spotify_id}`,
+    href: `${baseUrl}/v1/artists/${a.spotify_id}`,
+    external_urls: { spotify: `https://open.spotify.com/artist/${a.spotify_id}` }
+  });
+  const albumObj = (al) => {
+    const ar = ss.artists.findOneBy("spotify_id", al.artist_id);
+    return {
+      id: al.spotify_id,
+      name: al.name,
+      type: "album",
+      album_type: al.album_type,
+      release_date: al.release_date,
+      total_tracks: al.total_tracks,
+      artists: ar ? [{ id: ar.spotify_id, name: ar.name, type: "artist", uri: `spotify:artist:${ar.spotify_id}` }] : [],
+      uri: `spotify:album:${al.spotify_id}`,
+      href: `${baseUrl}/v1/albums/${al.spotify_id}`,
+      external_urls: { spotify: `https://open.spotify.com/album/${al.spotify_id}` }
+    };
+  };
+  const trackObj = (t) => {
+    const al = ss.albums.findOneBy("spotify_id", t.album_id);
+    const ar = ss.artists.findOneBy("spotify_id", t.artist_id);
+    return {
+      id: t.spotify_id,
+      name: t.name,
+      type: "track",
+      duration_ms: t.duration_ms,
+      popularity: t.popularity,
+      track_number: t.track_number,
+      explicit: false,
+      album: al ? { id: al.spotify_id, name: al.name, uri: `spotify:album:${al.spotify_id}` } : null,
+      artists: ar ? [{ id: ar.spotify_id, name: ar.name, type: "artist" }] : [],
+      uri: `spotify:track:${t.spotify_id}`,
+      external_urls: { spotify: `https://open.spotify.com/track/${t.spotify_id}` }
+    };
+  };
+  app.get("/v1/search", (c) => {
+    if (!authed(c)) return unauthorized(c);
+    const q = (c.req.query("q") ?? "").toLowerCase();
+    const types = (c.req.query("type") ?? "artist,album,track").split(",").map((s) => s.trim());
+    const m = (name) => q ? name.toLowerCase().includes(q) : true;
+    const out = {};
+    if (types.includes("artist"))
+      out.artists = {
+        items: ss.artists.all().filter((a) => m(a.name)).map(artistObj)
+      };
+    if (types.includes("album"))
+      out.albums = {
+        items: ss.albums.all().filter((a) => m(a.name)).map(albumObj)
+      };
+    if (types.includes("track"))
+      out.tracks = {
+        items: ss.tracks.all().filter((t) => m(t.name)).map(trackObj)
+      };
+    return c.json(out);
+  });
+  app.get("/v1/artists/:id", (c) => {
+    if (!authed(c)) return unauthorized(c);
+    const a = ss.artists.findOneBy("spotify_id", c.req.param("id"));
+    return a ? c.json(artistObj(a)) : notFound(c);
+  });
+  app.get("/v1/artists/:id/albums", (c) => {
+    if (!authed(c)) return unauthorized(c);
+    const items = ss.albums.findBy("artist_id", c.req.param("id")).map(albumObj);
+    return c.json({ href: `${baseUrl}/v1/artists/${c.req.param("id")}/albums`, items, total: items.length });
+  });
+  app.get("/v1/albums/:id", (c) => {
+    if (!authed(c)) return unauthorized(c);
+    const al = ss.albums.findOneBy("spotify_id", c.req.param("id"));
+    if (!al) return notFound(c);
+    const items = ss.tracks.findBy("album_id", al.spotify_id).map(trackObj);
+    return c.json({ ...albumObj(al), tracks: { items, total: items.length } });
+  });
+  app.get("/v1/tracks/:id", (c) => {
+    if (!authed(c)) return unauthorized(c);
+    const t = ss.tracks.findOneBy("spotify_id", c.req.param("id"));
+    return t ? c.json(trackObj(t)) : notFound(c);
+  });
+  app.get("/v1/me", (c) => {
+    if (!authed(c)) return unauthorized(c);
+    return c.json(
+      {
+        error: {
+          status: 403,
+          message: "This endpoint requires a user-authorized token; a client-credentials token has no user."
+        }
+      },
+      403
+    );
+  });
+}
+function openapiRoutes({ app, baseUrl }) {
+  app.get("/openapi.json", (c) => c.json(buildSpec(baseUrl)));
+}
+var ok = (description) => ({
+  description,
+  content: { "application/json": { schema: { type: "object" } } }
+});
+function buildSpec(baseUrl) {
+  return {
+    openapi: "3.1.0",
+    info: {
+      title: "Spotify Web API (Emulated)",
+      version: "1.0.0",
+      description: "Emulated subset of the Spotify Web API. OAuth 2.0 Client Credentials (app token, no user). Mint credentials via POST /_emulator/apps, then exchange them at the token endpoint."
+    },
+    servers: [{ url: baseUrl }],
+    components: {
+      securitySchemes: {
+        spotifyOAuth: {
+          type: "oauth2",
+          description: "Client Credentials \u2014 app-only token, no user context.",
+          flows: {
+            clientCredentials: {
+              tokenUrl: `${baseUrl}/api/token`,
+              scopes: {}
+            }
+          }
+        }
+      }
+    },
+    security: [{ spotifyOAuth: [] }],
+    paths: {
+      "/v1/search": {
+        get: {
+          operationId: "search",
+          summary: "Search the catalog",
+          parameters: [
+            { name: "q", in: "query", required: true, schema: { type: "string" }, description: "Search query." },
+            {
+              name: "type",
+              in: "query",
+              required: true,
+              schema: { type: "string" },
+              description: "Comma-separated item types: artist, album, track."
+            },
+            { name: "limit", in: "query", required: false, schema: { type: "integer" } }
+          ],
+          responses: { "200": ok("Search results grouped by type.") }
+        }
+      },
+      "/v1/artists/{id}": {
+        get: {
+          operationId: "getArtist",
+          summary: "Get an artist",
+          parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+          responses: { "200": ok("Artist object.") }
+        }
+      },
+      "/v1/artists/{id}/albums": {
+        get: {
+          operationId: "getArtistAlbums",
+          summary: "Get an artist's albums",
+          parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+          responses: { "200": ok("Paged album list.") }
+        }
+      },
+      "/v1/albums/{id}": {
+        get: {
+          operationId: "getAlbum",
+          summary: "Get an album (with tracks)",
+          parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+          responses: { "200": ok("Album object.") }
+        }
+      },
+      "/v1/tracks/{id}": {
+        get: {
+          operationId: "getTrack",
+          summary: "Get a track",
+          parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+          responses: { "200": ok("Track object.") }
+        }
+      },
+      "/v1/me": {
+        get: {
+          operationId: "getCurrentUser",
+          summary: "Get the current user (403 for app tokens \u2014 there is no user)",
+          responses: { "403": ok("Client-credentials tokens have no user, faithfully to Spotify.") }
+        }
+      }
+    }
+  };
+}
+var manifest = {
+  id: "spotify",
+  name: "Spotify",
+  description: "Stateful Spotify Web API emulator focused on client credentials OAuth and catalog APIs.",
+  docsUrl: "https://docs.emulators.dev/spotify",
+  surfaces: [
+    {
+      id: "token",
+      kind: "oauth",
+      title: "Client credentials token endpoint",
+      status: "supported",
+      basePath: "/api/token"
+    },
+    { id: "rest", kind: "rest", title: "REST API", status: "partial", basePath: "/" }
+  ],
+  auth: [
+    {
+      id: "client-credentials",
+      title: "OAuth client credentials",
+      type: "oauth-client-credentials",
+      status: "supported"
+    }
+  ],
+  specs: [
+    {
+      kind: "openapi",
+      title: "Spotify Web API subset",
+      coverage: "hand-authored",
+      url: "/openapi.json",
+      operations: [
+        {
+          operationId: "token",
+          method: "POST",
+          path: "/api/token",
+          status: "hand-authored",
+          summary: "Client credentials grant \u2014 mint an app-only access token."
+        },
+        {
+          operationId: "search",
+          method: "GET",
+          path: "/v1/search",
+          status: "hand-authored",
+          summary: "Search the catalog for artists, albums, and tracks."
+        },
+        {
+          operationId: "getArtist",
+          method: "GET",
+          path: "/v1/artists/:id",
+          status: "hand-authored"
+        },
+        {
+          operationId: "getArtistAlbums",
+          method: "GET",
+          path: "/v1/artists/:id/albums",
+          status: "hand-authored"
+        },
+        {
+          operationId: "getAlbum",
+          method: "GET",
+          path: "/v1/albums/:id",
+          status: "hand-authored",
+          summary: "Get an album with its tracks."
+        },
+        {
+          operationId: "getTrack",
+          method: "GET",
+          path: "/v1/tracks/:id",
+          status: "hand-authored"
+        },
+        {
+          operationId: "getCurrentUserProfile",
+          method: "GET",
+          path: "/v1/me",
+          status: "partial",
+          summary: "Modelled to return 403 \u2014 a client-credentials token has no user, faithful to Spotify."
+        },
+        {
+          operationId: "getSeveralArtists",
+          method: "GET",
+          path: "/v1/artists",
+          status: "unsupported"
+        },
+        {
+          operationId: "getArtistTopTracks",
+          method: "GET",
+          path: "/v1/artists/:id/top-tracks",
+          status: "unsupported"
+        },
+        {
+          operationId: "getAlbumTracks",
+          method: "GET",
+          path: "/v1/albums/:id/tracks",
+          status: "unsupported"
+        },
+        {
+          operationId: "getRecommendations",
+          method: "GET",
+          path: "/v1/recommendations",
+          status: "unsupported"
+        },
+        {
+          operationId: "getPlaylist",
+          method: "GET",
+          path: "/v1/playlists/:id",
+          status: "unsupported",
+          summary: "Playlists are not seeded or served by the emulator."
+        }
+      ]
+    }
+  ],
+  seedSchema: {
+    description: "Seed OAuth apps (clients) and a catalog of artists, albums, and tracks.",
+    fields: [
+      {
+        key: "clients",
+        title: "OAuth apps",
+        description: "Client credentials addressable at the token endpoint.",
+        example: [{ client_id: "demo-client-id", client_secret: "demo-client-secret", name: "Demo App" }]
+      },
+      {
+        key: "artists",
+        title: "Artists",
+        description: "Catalog artists, each with optional nested albums and tracks.",
+        example: [
+          {
+            name: "Daft Punk",
+            genres: ["electronic", "french house"],
+            popularity: 88,
+            followers: 9e6,
+            albums: [
+              {
+                name: "Discovery",
+                release_date: "2001-03-12",
+                tracks: [{ name: "One More Time", duration_ms: 320357 }, { name: "Digital Love" }]
+              }
+            ]
+          }
+        ]
+      }
+    ],
+    example: {
+      clients: [{ client_id: "demo-client-id", client_secret: "demo-client-secret", name: "Demo App" }],
+      artists: [
+        {
+          name: "Tame Impala",
+          genres: ["psychedelic rock"],
+          popularity: 85,
+          followers: 6e6,
+          albums: [
+            {
+              name: "Currents",
+              release_date: "2015-07-17",
+              tracks: [{ name: "Let It Happen" }, { name: "The Less I Know the Better" }]
+            }
+          ]
+        }
+      ]
+    }
+  },
+  stateModel: {
+    description: "Entities seeded and read by Spotify provider calls.",
+    collections: [
+      { name: "spotify.clients", title: "OAuth apps" },
+      { name: "spotify.artists", title: "Artists" },
+      { name: "spotify.albums", title: "Albums" },
+      { name: "spotify.tracks", title: "Tracks" }
+    ]
+  },
+  connections: [
+    {
+      id: "spotify-web-api-node",
+      title: "spotify-web-api-node (TypeScript)",
+      kind: "sdk",
+      language: "typescript",
+      description: "Point the Spotify SDK's account and API base hosts at the emulator instance.",
+      template: 'import SpotifyWebApi from "spotify-web-api-node";\n\nconst spotify = new SpotifyWebApi({\n  clientId: "{{clientId}}",\n  clientSecret: "{{clientSecret}}",\n});\n\n// Route both the accounts (token) and API hosts at the emulator.\nconst base = "{{baseUrl}}";\n\n// Client credentials grant against the emulator token endpoint.\nconst auth = Buffer.from("{{clientId}}:{{clientSecret}}").toString("base64");\nconst res = await fetch(`${base}/api/token`, {\n  method: "POST",\n  headers: {\n    authorization: `Basic ${auth}`,\n    "content-type": "application/x-www-form-urlencoded",\n  },\n  body: new URLSearchParams({ grant_type: "client_credentials" }),\n});\nconst { access_token } = await res.json();\nspotify.setAccessToken(access_token);\n\nconst results = await fetch(`${base}/v1/search?q=daft&type=artist`, {\n  headers: { authorization: `Bearer ${access_token}` },\n}).then((r) => r.json());'
+    },
+    {
+      id: "spotify-env",
+      title: "Spotify base URL (env)",
+      kind: "env",
+      language: "bash",
+      description: "Point your app at the emulator instead of the real Spotify accounts and API hosts.",
+      template: "SPOTIFY_BASE_URL={{baseUrl}}\nSPOTIFY_TOKEN_URL={{baseUrl}}/api/token\nSPOTIFY_CLIENT_ID={{clientId}}\nSPOTIFY_CLIENT_SECRET={{clientSecret}}"
+    },
+    {
+      id: "curl-token",
+      title: "curl (client credentials)",
+      kind: "curl",
+      language: "bash",
+      description: "Exchange client credentials for an app token, then call the catalog.",
+      template: 'curl -s -X POST {{baseUrl}}/api/token \\\n  -u "{{clientId}}:{{clientSecret}}" \\\n  -d grant_type=client_credentials'
+    },
+    {
+      id: "curl-search",
+      title: "curl (search)",
+      kind: "curl",
+      language: "bash",
+      description: "Call the catalog directly with an app token.",
+      template: 'curl -s "{{baseUrl}}/v1/search?q=daft&type=artist" -H "authorization: Bearer {{token}}"'
+    }
+  ]
+};
+function seedFromConfig(store, _baseUrl, config) {
+  const ss = getSpotifyStore(store);
+  for (const c of config.clients ?? []) {
+    if (!ss.clients.findOneBy("client_id", c.client_id)) {
+      ss.clients.insert({ client_id: c.client_id, client_secret: c.client_secret, name: c.name ?? c.client_id });
+    }
+  }
+  for (const a of config.artists ?? []) {
+    let artist = ss.artists.findOneBy("name", a.name);
+    if (!artist) {
+      artist = ss.artists.insert({
+        spotify_id: spotifyId(),
+        name: a.name,
+        genres: a.genres ?? [],
+        popularity: a.popularity ?? 50,
+        followers: a.followers ?? 1e3
+      });
+    }
+    for (const al of a.albums ?? []) {
+      const album = ss.albums.insert({
+        spotify_id: spotifyId(),
+        name: al.name,
+        artist_id: artist.spotify_id,
+        album_type: "album",
+        release_date: al.release_date ?? "2020-01-01",
+        total_tracks: (al.tracks ?? []).length
+      });
+      let n = 1;
+      for (const t of al.tracks ?? []) {
+        ss.tracks.insert({
+          spotify_id: spotifyId(),
+          name: t.name,
+          album_id: album.spotify_id,
+          artist_id: artist.spotify_id,
+          duration_ms: t.duration_ms ?? 2e5,
+          popularity: 50,
+          track_number: n++
+        });
+      }
+    }
+  }
+}
+var spotifyPlugin = {
+  name: "spotify",
+  register(app, store, webhooks, baseUrl, tokenMap) {
+    const ctx = { app, store, webhooks, baseUrl, tokenMap };
+    appsRoutes(ctx);
+    tokenRoutes(ctx);
+    catalogRoutes(ctx);
+    openapiRoutes(ctx);
+  },
+  seed(store, baseUrl) {
+    seedFromConfig(store, baseUrl, {
+      clients: [{ client_id: "demo-client-id", client_secret: "demo-client-secret", name: "Demo App" }],
+      artists: [
+        {
+          name: "Daft Punk",
+          genres: ["electronic", "french house"],
+          popularity: 88,
+          followers: 9e6,
+          albums: [
+            {
+              name: "Discovery",
+              release_date: "2001-03-12",
+              tracks: [
+                { name: "One More Time" },
+                { name: "Harder, Better, Faster, Stronger" },
+                { name: "Digital Love" }
+              ]
+            }
+          ]
+        },
+        {
+          name: "Tame Impala",
+          genres: ["psychedelic rock"],
+          popularity: 85,
+          followers: 6e6,
+          albums: [
+            {
+              name: "Currents",
+              release_date: "2015-07-17",
+              tracks: [{ name: "Let It Happen" }, { name: "The Less I Know the Better" }]
+            }
+          ]
+        }
+      ]
+    });
+  }
+};
+var index_default = spotifyPlugin;
+export {
+  index_default as default,
+  getSpotifyStore,
+  manifest,
+  seedFromConfig,
+  spotifyPlugin
+};
+//# sourceMappingURL=dist-DK26ESP2.js.map