@clioplaylists/clio 0.1.8 → 0.1.9

package/dist/dataplane/server/indexing/plugins/playlist-idea.js

@@ -1,16 +1,50 @@
-import { normalizeDatetimeAlways } from '@atproto/syntax';
-import * as lex from '../../../../lexicons/lexicons';
-import { RecordProcessor } from '../processor';
+"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.makePlugin = void 0;
+const syntax_1 = require("@atproto/syntax");
+const lex = __importStar(require("../../../../lexicons/lexicons"));
+const processor_1 = require("../processor");
 const lexId = lex.ids.ComClioplaylistsAlphaFeedPlaylistIdea;
 const insertFn = async (db, uri, cid, obj, timestamp) => {
     const masterPlaylist = obj.masterPlaylist;
-    const recommendedPlaylist = obj.recommendedPlaylist;
-    let masterPlaylistId;
-    let recommendedPlaylistId;
     if (masterPlaylist) {
         const playlist = {
             playlist_idea_uri: uri.toString(),
             type: 'master',
+            name: `${obj.title} (master)`,
         };
         const insertedPlaylistIdResponse = await db
             .insertInto('playlist')
@@ -22,8 +56,8 @@ const insertFn = async (db, uri, cid, obj, timestamp) => {
             return {
                 track_name: song.trackName,
                 track_mb_id: song.trackMbId,
-                album_artwork_ref: song.albumArtwork?.ref.toString(),
-                created_at: song.createdAt,
+                album_artwork_ref: song.albumArtworkRef?.ref.toString(),
+                indexed_at: timestamp,
             };
         });
         const insertedSongIdsResponse = await db
@@ -43,26 +77,13 @@ const insertFn = async (db, uri, cid, obj, timestamp) => {
             await db.insertInto('playlist_item').values(playlistItems).execute();
         }
     }
-    if (recommendedPlaylist) {
-        const playlist = {
-            playlist_idea_uri: uri.toString(),
-            type: 'recommended',
-        };
-        await db
-            .insertInto('playlist')
-            .values(playlist)
-            .onConflict((oc) => oc.doNothing())
-            .execute();
-    }
     const playlistIdea = {
         uri: uri.toString(),
         title: obj.title,
         description: obj.description,
         creator_did: obj.creatorDid,
         owner_did: obj.ownerDid,
-        master_playlist_id: masterPlaylistId,
-        recommended_playlist_id: recommendedPlaylistId,
-        created_at: normalizeDatetimeAlways(obj.createdAt),
+        created_at: (0, syntax_1.normalizeDatetimeAlways)(obj.createdAt),
     };
     const [insertedPlaylistIdea] = await Promise.all([
         db
@@ -78,7 +99,6 @@ const insertFn = async (db, uri, cid, obj, timestamp) => {
     return {
         playlistIdea: insertedPlaylistIdea,
         masterPlaylist: masterPlaylist,
-        recommendedPlaylist: recommendedPlaylist,
     };
 };
 const findDuplicate = async () => {
@@ -87,40 +107,29 @@ const findDuplicate = async () => {
 const deleteFn = async (db, uri) => {
     const uriStr = uri.toString();
     const [deletedPlaylistIdea, deletedPlaylists] = await Promise.all([
-        db
-            .deleteFrom('playlist_idea')
-            .where('uri', '=', uriStr)
-            .returningAll()
-            .executeTakeFirst(),
-        db
-            .deleteFrom('playlist')
-            .where('playlist_idea_uri', '=', uriStr)
-            .returningAll()
-            .execute(),
+        db.deleteFrom('playlist_idea').where('uri', '=', uriStr).returningAll().executeTakeFirst(),
+        db.deleteFrom('playlist').where('playlist_idea_uri', '=', uriStr).returningAll().execute(),
     ]);
     const deletedPlaylistIds = deletedPlaylists.map((deletedPlaylist) => {
         return deletedPlaylist.id;
     });
     if (deletedPlaylists) {
-        await db
-            .deleteFrom('playlist_item')
-            .where('playlist_id', 'in', deletedPlaylistIds)
-            .execute();
+        await db.deleteFrom('playlist_item').where('playlist_id', 'in', deletedPlaylistIds).execute();
     }
     return deletedPlaylistIdea
         ? {
             playlistIdea: deletedPlaylistIdea,
             masterPlaylist: undefined, // TODO: Figure out if this should be undefined
-            recommendedPlaylist: undefined, // TODO: Figure out if this should be undefined
         }
         : null;
 };
-export const makePlugin = (db) => {
-    return new RecordProcessor(db, {
+const makePlugin = (db) => {
+    return new processor_1.RecordProcessor(db, {
         lexId,
         insertFn,
         findDuplicate,
         deleteFn,
     });
 };
-export default makePlugin;
+exports.makePlugin = makePlugin;
+exports.default = exports.makePlugin;

package/dist/dataplane/server/indexing/plugins/profile.js

@@ -1,5 +1,41 @@
-import * as lex from '../../../../lexicons/lexicons';
-import { RecordProcessor } from '../processor';
+"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.makePlugin = void 0;
+const lex = __importStar(require("../../../../lexicons/lexicons"));
+const processor_1 = require("../processor");
 const lexId = lex.ids.ComClioplaylistsAlphaActorProfile;
 const insertFn = async (db, uri, cid, obj, timestamp) => {
     if (uri.rkey !== 'self')
@@ -9,9 +45,9 @@ const insertFn = async (db, uri, cid, obj, timestamp) => {
         .values({
         uri: uri.toString(),
         cid: cid.toString(),
-        creator: uri.host,
+        creator_did: uri.host,
         display_name: obj.displayName,
-        description: obj.description,
+        description: obj.bio,
         avatar_cid: obj.avatar?.ref.toString(),
         banner_cid: obj.banner?.ref.toString(),
         created_at: obj.createdAt ?? new Date().toISOString(),
@@ -26,19 +62,16 @@ const findDuplicate = async () => {
     return null;
 };
 const deleteFn = async (db, uri) => {
-    const deleted = await db
-        .deleteFrom('profile')
-        .where('uri', '=', uri.toString())
-        .returningAll()
-        .executeTakeFirst();
+    const deleted = await db.deleteFrom('profile').where('uri', '=', uri.toString()).returningAll().executeTakeFirst();
     return deleted || null;
 };
-export const makePlugin = (db) => {
-    return new RecordProcessor(db, {
+const makePlugin = (db) => {
+    return new processor_1.RecordProcessor(db, {
         lexId,
         insertFn,
         findDuplicate,
         deleteFn,
     });
 };
-export default makePlugin;
+exports.makePlugin = makePlugin;
+exports.default = exports.makePlugin;

package/dist/dataplane/server/indexing/plugins/song-recommendation.d.ts

@@ -0,0 +1,9 @@
+import { Selectable } from 'kysely';
+import type { Record as SongRecommendationRecord } from '../../../../lexicons/types/com/clioplaylists/alpha/feed/songRecommendation';
+import { Database } from '../../db';
+import { DatabaseSchemaType } from '../../db/database-schema';
+import { RecordProcessor } from '../processor';
+type IndexedSongRecommendation = Selectable<DatabaseSchemaType['song_recommendation']>;
+export type PluginType = RecordProcessor<SongRecommendationRecord, IndexedSongRecommendation>;
+export declare const makePlugin: (db: Database) => PluginType;
+export default makePlugin;

package/dist/dataplane/server/indexing/plugins/song-recommendation.js

@@ -0,0 +1,101 @@
+"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.makePlugin = void 0;
+const syntax_1 = require("@atproto/syntax");
+const lex = __importStar(require("../../../../lexicons/lexicons"));
+const processor_1 = require("../processor");
+const lexId = lex.ids.ComClioplaylistsAlphaFeedSongRecommendation;
+const insertFn = async (db, uri, cid, obj, timestamp) => {
+    const recommenderDid = uri.host;
+    const playlistIdeaUri = obj.playlistIdea.uri;
+    const playlistIdeaCid = obj.playlistIdea.cid;
+    const insertedSong = await db
+        .insertInto('song')
+        .values({
+        track_name: obj.song.trackName,
+        track_mb_id: obj.song.trackMbId,
+        album_artwork_ref: obj.song.albumArtworkRef?.ref.toString(),
+        indexed_at: timestamp,
+    })
+        .onConflict((oc) => oc.column('track_mb_id').doUpdateSet({
+        track_name: obj.song.trackName,
+        album_artwork_ref: obj.song.albumArtworkRef?.ref.toString(),
+        indexed_at: timestamp,
+    }))
+        .returning('id')
+        .executeTakeFirst();
+    if (!insertedSong?.id) {
+        return null;
+    }
+    const inserted = await db
+        .insertInto('song_recommendation')
+        .values({
+        uri: uri.toString(),
+        cid: cid.toString(),
+        recommender_did: recommenderDid,
+        playlist_idea_uri: playlistIdeaUri,
+        playlist_idea_cid: playlistIdeaCid,
+        song_id: insertedSong.id,
+        note: obj.note ?? null,
+        created_at: (0, syntax_1.normalizeDatetimeAlways)(obj.createdAt),
+        indexed_at: timestamp,
+    })
+        .onConflict((oc) => oc.column('uri').doNothing())
+        .returningAll()
+        .executeTakeFirst();
+    return inserted || null;
+};
+const findDuplicate = async () => {
+    return null;
+};
+const deleteFn = async (db, uri) => {
+    const deleted = await db
+        .deleteFrom('song_recommendation')
+        .where('uri', '=', uri.toString())
+        .returningAll()
+        .executeTakeFirst();
+    return deleted || null;
+};
+const makePlugin = (db) => {
+    return new processor_1.RecordProcessor(db, {
+        lexId,
+        insertFn,
+        findDuplicate,
+        deleteFn,
+    });
+};
+exports.makePlugin = makePlugin;
+exports.default = exports.makePlugin;

package/dist/dataplane/server/indexing/processor.js

@@ -1,6 +1,9 @@
-import { stringifyLex } from '@atproto/lexicon';
-import { lexicons } from '../../../lexicons/lexicons';
-export class RecordProcessor {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordProcessor = void 0;
+const lexicon_1 = require("@atproto/lexicon");
+const lexicons_1 = require("../../../lexicons/lexicons");
+class RecordProcessor {
     params;
     collection;
     db;
@@ -19,7 +22,7 @@ export class RecordProcessor {
         }
     }
     assertValidRecord(obj) {
-        lexicons.assertValidRecord(this.params.lexId, obj);
+        lexicons_1.lexicons.assertValidRecord(this.params.lexId, obj);
     }
     async insertRecord(uri, cid, obj, timestamp) {
         this.assertValidRecord(obj);
@@ -29,7 +32,7 @@ export class RecordProcessor {
             uri: uri.toString(),
             cid: cid.toString(),
             did: uri.host,
-            json: stringifyLex(obj),
+            json: (0, lexicon_1.stringifyLex)(obj),
             indexed_at: timestamp,
         })
             .onConflict((oc) => oc.doNothing())
@@ -47,7 +50,7 @@ export class RecordProcessor {
             .where('uri', '=', uri.toString())
             .set({
             cid: cid.toString(),
-            json: stringifyLex(obj),
+            json: (0, lexicon_1.stringifyLex)(obj),
             indexed_at: timestamp,
         })
             .execute();
@@ -62,11 +65,9 @@ export class RecordProcessor {
         }
     }
     async deleteRecord(uri, cascading = false) {
-        await this.db
-            .deleteFrom('record')
-            .where('uri', '=', uri.toString())
-            .execute();
+        await this.db.deleteFrom('record').where('uri', '=', uri.toString()).execute();
         await this.params.deleteFn(this.db, uri);
     }
 }
-export default RecordProcessor;
+exports.RecordProcessor = RecordProcessor;
+exports.default = RecordProcessor;

package/dist/dataplane/server/routes/identity.d.ts

@@ -1,6 +1,25 @@
 import { IdResolver } from '@atproto/identity';
+import { Timestamp } from '@bufbuild/protobuf';
 import { ServiceImpl } from '@connectrpc/connect';
 import { ClioService } from '../../../rpc/clio_connect';
 import { Database } from '../db';
 declare const _default: (_db: Database, idResolver: IdResolver) => Partial<ServiceImpl<typeof ClioService>>;
 export default _default;
+export declare const getIdentityByDid: (_db: Database, idResolver: IdResolver) => (req: {
+    did: string;
+}) => Promise<{
+    did: string;
+    handle: string | undefined;
+    keys: Buffer<ArrayBuffer>;
+    services: Buffer<ArrayBuffer>;
+    updated: Timestamp;
+}>;
+export declare const getIdentityByHandle: (_db: Database, idResolver: IdResolver) => (req: {
+    handle: string;
+}) => Promise<{
+    did: string;
+    handle: string | undefined;
+    keys: Buffer<ArrayBuffer>;
+    services: Buffer<ArrayBuffer>;
+    updated: Timestamp;
+}>;

package/dist/dataplane/server/routes/identity.js

@@ -1,26 +1,33 @@
-import { getDid, getHandle } from '@atproto/identity';
-import { Timestamp } from '@bufbuild/protobuf';
-import { Code, ConnectError } from '@connectrpc/connect';
-export default (_db, idResolver) => ({
-    async getIdentityByDid(req) {
-        const doc = await idResolver.did.resolve(req.did);
-        if (!doc) {
-            throw new ConnectError('identity not found', Code.NotFound);
-        }
-        return getResultFromDoc(doc);
-    },
-    async getIdentityByHandle(req) {
-        const did = await idResolver.handle.resolve(req.handle);
-        if (!did) {
-            throw new ConnectError('identity not found', Code.NotFound);
-        }
-        const doc = await idResolver.did.resolve(did);
-        if (!doc || did !== getDid(doc)) {
-            throw new ConnectError('identity not found', Code.NotFound);
-        }
-        return getResultFromDoc(doc);
-    },
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIdentityByHandle = exports.getIdentityByDid = void 0;
+const identity_1 = require("@atproto/identity");
+const protobuf_1 = require("@bufbuild/protobuf");
+const connect_1 = require("@connectrpc/connect");
+exports.default = (_db, idResolver) => ({
+    getIdentityByDid: (0, exports.getIdentityByDid)(_db, idResolver),
+    getIdentityByHandle: (0, exports.getIdentityByHandle)(_db, idResolver),
 });
+const getIdentityByDid = (_db, idResolver) => async (req) => {
+    const doc = await idResolver.did.resolve(req.did);
+    if (!doc) {
+        throw new connect_1.ConnectError('identity not found', connect_1.Code.NotFound);
+    }
+    return getResultFromDoc(doc);
+};
+exports.getIdentityByDid = getIdentityByDid;
+const getIdentityByHandle = (_db, idResolver) => async (req) => {
+    const did = await idResolver.handle.resolve(req.handle);
+    if (!did) {
+        throw new connect_1.ConnectError('identity not found', connect_1.Code.NotFound);
+    }
+    const doc = await idResolver.did.resolve(did);
+    if (!doc || did !== (0, identity_1.getDid)(doc)) {
+        throw new connect_1.ConnectError('identity not found', connect_1.Code.NotFound);
+    }
+    return getResultFromDoc(doc);
+};
+exports.getIdentityByHandle = getIdentityByHandle;
 const getResultFromDoc = (doc) => {
     const keys = {};
     doc.verificationMethod?.forEach((method) => {
@@ -45,10 +52,10 @@ const getResultFromDoc = (doc) => {
         };
     });
     return {
-        did: getDid(doc),
-        handle: getHandle(doc),
+        did: (0, identity_1.getDid)(doc),
+        handle: (0, identity_1.getHandle)(doc),
         keys: Buffer.from(JSON.stringify(keys)),
         services: Buffer.from(JSON.stringify(services)),
-        updated: Timestamp.fromDate(new Date()),
+        updated: protobuf_1.Timestamp.fromDate(new Date()),
     };
 };

package/dist/dataplane/server/routes/index.js

@@ -1,13 +1,18 @@
-import { ClioService } from '../../../rpc/clio_connect';
-import identity from './identity';
-import profile from './profile';
-import records from './records';
-import sync from './sync';
-export default (db, idResolver) => (router) => router.service(ClioService, {
-    ...identity(db, idResolver),
-    ...profile(db),
-    ...records(db),
-    ...sync(db),
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const clio_connect_1 = require("../../../rpc/clio_connect");
+const identity_1 = __importDefault(require("./identity"));
+const profile_1 = __importDefault(require("./profile"));
+const records_1 = __importDefault(require("./records"));
+const sync_1 = __importDefault(require("./sync"));
+exports.default = (db, idResolver) => (router) => router.service(clio_connect_1.ClioService, {
+    ...(0, identity_1.default)(db, idResolver),
+    ...(0, profile_1.default)(db),
+    ...(0, records_1.default)(db),
+    ...(0, sync_1.default)(db),
     async healthCheck() {
         return {};
     },

package/dist/dataplane/server/routes/profile.js

@@ -1,7 +1,9 @@
-import { keyBy } from '@atproto/common';
-import { parseRecordBytes } from '../../../util';
-import { getRecords } from './records';
-export default (db) => ({
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@atproto/common");
+const util_1 = require("../../../util");
+const records_1 = require("./records");
+exports.default = (db) => ({
     async getActors(req) {
         const { dids } = req;
         if (dids.length === 0) {
@@ -11,24 +13,22 @@ export default (db) => ({
         const chatDeclarationUris = dids.map((did) => `at://${did}/chat.bsky.actor.declaration/self`);
         const [handlesRes, profiles, chatDeclarations] = await Promise.all([
             db.db.selectFrom('actor').selectAll().execute(),
-            getRecords(db)({ uris: profileUris }),
-            getRecords(db)({ uris: chatDeclarationUris }),
+            (0, records_1.getRecords)(db)({ uris: profileUris }),
+            (0, records_1.getRecords)(db)({ uris: chatDeclarationUris }),
         ]);
-        const byDid = keyBy(handlesRes, 'did');
+        const byDid = (0, common_1.keyBy)(handlesRes, 'did');
         const actors = dids.map((did, i) => {
             const row = byDid.get(did);
-            const chatDeclaration = parseRecordBytes(chatDeclarations.records[i].record);
+            const chatDeclaration = (0, util_1.parseRecordBytes)(chatDeclarations.records[i].record);
             return {
                 exists: !!row,
                 handle: row?.handle ?? undefined,
                 profile: profiles.records[i],
-                takenDown: !!row?.takedownRef,
-                takedownRef: row?.takedownRef || undefined,
+                takenDown: !!row?.takedown_ref,
+                takedownRef: row?.takedown_ref || undefined,
                 tombstonedAt: undefined, // in current implementation, tombstoned actors are deleted
-                allowIncomingChatsFrom: typeof chatDeclaration?.['allowIncoming'] === 'string'
-                    ? chatDeclaration['allowIncoming']
-                    : undefined,
-                upstreamStatus: row?.upstreamStatus ?? '',
+                allowIncomingChatsFrom: typeof chatDeclaration?.['allowIncoming'] === 'string' ? chatDeclaration['allowIncoming'] : undefined,
+                upstreamStatus: row?.upstream_status ?? '',
                 createdAt: profiles.records[i].createdAt, // @NOTE profile creation date not trusted in production
             };
         });
@@ -39,21 +39,13 @@ export default (db) => ({
         if (handles.length === 0) {
             return { dids: [] };
         }
-        const res = await db.db
-            .selectFrom('actor')
-            .where('handle', 'in', handles)
-            .selectAll()
-            .execute();
-        const byHandle = keyBy(res, 'handle');
+        const res = await db.db.selectFrom('actor').where('handle', 'in', handles).selectAll().execute();
+        const byHandle = (0, common_1.keyBy)(res, 'handle');
         const dids = handles.map((handle) => byHandle.get(handle)?.did ?? '');
         return { dids };
     },
     async updateActorUpstreamStatus(req) {
         const { actorDid, upstreamStatus } = req;
-        await db.db
-            .updateTable('actor')
-            .set({ upstreamStatus })
-            .where('did', '=', actorDid)
-            .execute();
+        await db.db.updateTable('actor').set({ upstream_status: upstreamStatus }).where('did', '=', actorDid).execute();
     },
 });

package/dist/dataplane/server/routes/records.d.ts

@@ -4,8 +4,26 @@ import { Record } from '../../../rpc/clio_pb';
 import { Database } from '../db';
 declare const _default: (db: Database) => Partial<ServiceImpl<typeof ClioService>>;
 export default _default;
+export interface Song {
+    id: number;
+    track_name: string;
+    track_mb_id: string;
+    album_artwork_ref: string | null;
+}
+export interface Playlist {
+    id: number;
+    playlistIdeaUri: string;
+    type: 'recommended' | 'master';
+    name: string;
+    songs: Song[];
+}
 export declare const getRecords: (db: Database, collection?: string) => (req: {
     uris: string[];
 }) => Promise<{
     records: Record[];
 }>;
+export declare const getRecommendedPlaylistsForPlaylistIdea: (db: Database) => (req: {
+    playlistIdeaUri: string;
+}) => Promise<{
+    records: Record[];
+}>;