@clioplaylists/clio 0.1.8 → 0.1.9

package/dist/api/com/clioplaylists/alpha/feed/getRecommendedPlaylistsByUser.d.ts

@@ -0,0 +1,3 @@
+import AppContext from '../../../../../context';
+import { Server } from '../../../../../lexicons';
+export default function (server: Server, ctx: AppContext): void;

package/dist/api/com/clioplaylists/alpha/feed/getRecommendedPlaylistsByUser.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const util_1 = require("../../../../../util");
+const util_2 = require("../../../../util");
+function default_1(server, ctx) {
+    server.com.clioplaylists.alpha.feed.getRecommendedPlaylistsByUser({
+        handler: async ({ params, auth, req }) => {
+            void auth;
+            void req;
+            const userAtIdentifier = params.userAtIdentifier;
+            const did = userAtIdentifier.startsWith('did:')
+                ? userAtIdentifier
+                : (await ctx.dataplane.getDidsByHandles({
+                    handles: [userAtIdentifier.toLowerCase()],
+                })).dids[0];
+            if (!did) {
+                const output = { recommendedPlaylists: [] };
+                return { encoding: 'application/json', body: output, headers: (0, util_2.resHeaders)({}) };
+            }
+            const [identity, recRes] = await Promise.all([
+                ctx.dataplane.getIdentityByDid({ did }).catch(() => undefined),
+                ctx.dataplane.getSongRecommendationRecordsByUser({ userDid: did }),
+            ]);
+            const ownerHandle = identity?.handle ?? userAtIdentifier;
+            const byPlaylistIdea = new Map();
+            for (const recordWrapper of recRes.records) {
+                const rec = (0, util_1.parseRecord)(recordWrapper, false);
+                if (!rec)
+                    continue;
+                const playlistIdeaUri = rec.record.playlistIdea.uri;
+                const playlistIdeaCid = rec.record.playlistIdea.cid;
+                const song = rec.record.song;
+                const entry = byPlaylistIdea.get(playlistIdeaUri) ??
+                    (() => {
+                        const created = {
+                            playlistIdeaUri,
+                            playlistIdeaCid,
+                            songsByMbId: new Map(),
+                        };
+                        byPlaylistIdea.set(playlistIdeaUri, created);
+                        return created;
+                    })();
+                if (!entry.songsByMbId.has(song.trackMbId)) {
+                    entry.songsByMbId.set(song.trackMbId, {
+                        trackName: song.trackName,
+                        artistNames: song.artistNames,
+                        trackMbId: song.trackMbId,
+                        artistMbIds: song.artistMbIds,
+                        albumArtwork: song.albumArtworkRef,
+                    });
+                }
+            }
+            const output = {
+                recommendedPlaylists: Array.from(byPlaylistIdea.values()).map((pl) => ({
+                    uri: pl.playlistIdeaUri,
+                    cid: pl.playlistIdeaCid,
+                    playlistIdeaUri: pl.playlistIdeaUri,
+                    ownerHandle,
+                    songs: Array.from(pl.songsByMbId.values()),
+                })),
+            };
+            return {
+                encoding: 'application/json',
+                body: output,
+                headers: (0, util_2.resHeaders)({}),
+            };
+        },
+    });
+}

package/dist/api/health.js

@@ -1,6 +1,12 @@
-import express from 'express';
-export const createRouter = (ctx) => {
-    const router = express.Router();
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRouter = void 0;
+const express_1 = __importDefault(require("express"));
+const createRouter = (ctx) => {
+    const router = express_1.default.Router();
     router.get('/', function (req, res) {
         res.type('text/plain');
         res.send(`
@@ -23,3 +29,4 @@ Most API routes are under /xrpc/
     });
     return router;
 };
+exports.createRouter = createRouter;

package/dist/api/index.d.ts

@@ -1,4 +1,5 @@
 import AppContext from '../context';
 import { Server } from '../lexicons';
 export * as health from './health';
+export * as wellKnown from './well-known';
 export default function (server: Server, ctx: AppContext): Server;

package/dist/api/index.js

@@ -1,6 +1,44 @@
+"use strict";
+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.wellKnown = exports.health = void 0;
+exports.default = default_1;
 // import getSongs from './com/clioplaylists/alpha/feed/getSongs'
-export * as health from './health';
-export default function (server, ctx) {
+exports.health = __importStar(require("./health"));
+exports.wellKnown = __importStar(require("./well-known"));
+function default_1(server, ctx) {
     // getSongs(server, ctx)
     return server;
 }

package/dist/api/oauth.d.ts

@@ -0,0 +1,3 @@
+import { Router } from 'express';
+import AppContext from '../context';
+export declare const createRouter: (ctx: AppContext) => Router;

package/dist/api/oauth.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRouter = void 0;
+const express_1 = require("express");
+const client_1 = require("../oauth/client");
+const createRouter = (ctx) => {
+    const router = (0, express_1.Router)();
+    router.get('/.well-known/atproto-oauth-client.json', (_req, res) => {
+        res.json((0, client_1.getOauthClientMetadata)(ctx));
+    });
+    router.get('/oauth/login', async (req, res, next) => {
+        try {
+            const identifierRaw = typeof req.query['identifier'] === 'string' ? req.query['identifier'] : undefined;
+            const handleRaw = typeof req.query['handle'] === 'string' ? req.query['handle'] : undefined;
+            const identifier = identifierRaw ?? handleRaw;
+            if (!identifier) {
+                res.status(400).json({ error: 'Missing query param: identifier' });
+                return;
+            }
+            const oauth = (0, client_1.getOauthClient)(ctx);
+            const url = await oauth.authorize(identifier, {
+                scope: ctx.cfg.oauthScope,
+                redirect_uri: (0, client_1.getOauthRedirectUri)(ctx),
+            });
+            res.redirect(url.toString());
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    router.get('/oauth/callback', async (req, res, next) => {
+        try {
+            const qs = req.originalUrl.split('?', 2)[1] ?? '';
+            const params = new URLSearchParams(qs);
+            const oauth = (0, client_1.getOauthClient)(ctx);
+            const { session } = await oauth.callback(params, {
+                redirect_uri: (0, client_1.getOauthRedirectUri)(ctx),
+            });
+            res.json({ did: session.did });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    router.get('/oauth/session', async (req, res, next) => {
+        try {
+            const did = typeof req.query['did'] === 'string' ? req.query['did'] : undefined;
+            if (!did) {
+                res.status(400).json({ error: 'Missing query param: did' });
+                return;
+            }
+            const oauth = (0, client_1.getOauthClient)(ctx);
+            const session = await oauth.restore(did, 'auto');
+            const info = await session.getTokenInfo('auto');
+            res.json({ did: session.did, token: info });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    return router;
+};
+exports.createRouter = createRouter;

package/dist/api/util.d.ts

@@ -1,6 +1,7 @@
 import { ParsedLabelers } from '../util';
 export declare const ATPROTO_CONTENT_LABELERS = "Atproto-Content-Labelers";
 export declare const ATPROTO_REPO_REV = "Atproto-Repo-Rev";
+export declare const BSKY_USER_AGENT = "clio-appview";
 type ResHeaderOpts = {
     labelers: ParsedLabelers;
     repoRev: string | null;

package/dist/api/util.js

@@ -1,13 +1,18 @@
-import { formatLabelerHeader } from '../util';
-export const ATPROTO_CONTENT_LABELERS = 'Atproto-Content-Labelers';
-export const ATPROTO_REPO_REV = 'Atproto-Repo-Rev';
-export const resHeaders = (opts) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resHeaders = exports.BSKY_USER_AGENT = exports.ATPROTO_REPO_REV = exports.ATPROTO_CONTENT_LABELERS = void 0;
+const util_1 = require("../util");
+exports.ATPROTO_CONTENT_LABELERS = 'Atproto-Content-Labelers';
+exports.ATPROTO_REPO_REV = 'Atproto-Repo-Rev';
+exports.BSKY_USER_AGENT = 'clio-appview';
+const resHeaders = (opts) => {
     const headers = {};
     if (opts.labelers) {
-        headers[ATPROTO_CONTENT_LABELERS] = formatLabelerHeader(opts.labelers);
+        headers[exports.ATPROTO_CONTENT_LABELERS] = (0, util_1.formatLabelerHeader)(opts.labelers);
     }
     if (opts.repoRev) {
-        headers[ATPROTO_REPO_REV] = opts.repoRev;
+        headers[exports.ATPROTO_REPO_REV] = opts.repoRev;
     }
     return headers;
 };
+exports.resHeaders = resHeaders;

package/dist/api/well-known.js

@@ -1,6 +1,9 @@
-import { Router } from 'express';
-export const createRouter = (ctx) => {
-    const router = Router();
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRouter = void 0;
+const express_1 = require("express");
+const createRouter = (ctx) => {
+    const router = (0, express_1.Router)();
     const did = ctx.cfg.serverDid;
     if (did.startsWith('did:web:')) {
         const hostname = did.slice('did:web:'.length);
@@ -22,10 +25,11 @@ export const createRouter = (ctx) => {
                         id: '#clio_appview',
                         type: 'ClioAppView',
                         serviceEndpoint,
-                    }
+                    },
                 ],
             });
         });
     }
     return router;
 };
+exports.createRouter = createRouter;

package/dist/auth-verifier.d.ts

@@ -1,9 +1,12 @@
 import { VerifySignatureWithKeyFn } from '@atproto/xrpc-server';
-import express from 'express';
+import type { Request } from 'express';
 import { KeyObject } from 'node:crypto';
-import { DataPlaneClient } from './client';
+import { DataPlaneClient } from './dataplane';
 type ReqCtx = {
-    req: express.Request;
+    req: HeaderedRequest;
+};
+type HeaderedRequest = Request & {
+    headers: Record<string, string | string[] | undefined>;
 };
 type StandardAuthOpts = {
     skipAudCheck?: boolean;
@@ -62,7 +65,9 @@ export declare class AuthVerifier {
     standardOrRole: (ctx: ReqCtx) => Promise<StandardOutput | RoleOutput>;
     optionalStandardOrRole: (ctx: ReqCtx) => Promise<StandardOutput | RoleOutput | NullOutput>;
     entrywaySession: (reqCtx: ReqCtx) => Promise<StandardOutput>;
-    parseRoleCreds(req: express.Request): {
+    modService: (reqCtx: ReqCtx) => Promise<ModServiceOutput>;
+    roleOrModService: (reqCtx: ReqCtx) => Promise<RoleOutput | ModServiceOutput>;
+    parseRoleCreds(req: HeaderedRequest): {
         status: RoleStatus;
         admin: boolean;
         moderator: boolean;
@@ -73,6 +78,14 @@ export declare class AuthVerifier {
         moderator?: undefined;
         triage?: undefined;
     };
+    verifyServiceJwt(reqCtx: ReqCtx, opts: {
+        iss: string[] | null;
+        aud: string | null;
+        lxmCheck?: (method?: string) => boolean;
+    }): Promise<{
+        iss: string;
+        aud: string;
+    }>;
     isModService(iss: string): boolean;
     nullCreds(): NullOutput;
     parseCreds(creds: StandardOutput | RoleOutput | ModServiceOutput | NullOutput): {