@clioplaylists/clio 0.1.7 → 0.1.9

package/dist/dataplane/server/db/tables/artist-list-item.js

@@ -1 +1,4 @@
-export const tableName = 'artist_list_item';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'artist_list_item';

package/dist/dataplane/server/db/tables/artist.js

@@ -1 +1,4 @@
-export const tableName = 'artist';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'artist';

package/dist/dataplane/server/db/tables/oauth-session.d.ts

@@ -0,0 +1,9 @@
+export declare const tableName = "oauth_session";
+export interface OAuthSessionTable {
+    key: string;
+    value: unknown;
+    updated_at: number;
+}
+export type PartialDB = {
+    [tableName]: OAuthSessionTable;
+};

package/dist/dataplane/server/db/tables/oauth-session.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'oauth_session';

package/dist/dataplane/server/db/tables/oauth-state.d.ts

@@ -0,0 +1,10 @@
+export declare const tableName = "oauth_state";
+export interface OAuthStateTable {
+    key: string;
+    value: unknown;
+    created_at: number;
+    expires_at: number;
+}
+export type PartialDB = {
+    [tableName]: OAuthStateTable;
+};

package/dist/dataplane/server/db/tables/oauth-state.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'oauth_state';

package/dist/dataplane/server/db/tables/playlist-idea.d.ts

@@ -1,12 +1,12 @@
+import { Generated } from 'kysely';
 export declare const tableName = "playlist_idea";
 export interface PlaylistIdeaTable {
+    id: Generated<number>;
     uri: string;
     title: string;
-    description?: string;
+    description: string | null;
     creator_did: string;
     owner_did: string;
-    master_playlist_id?: number;
-    recommended_playlist_id?: number;
     created_at: string;
 }
 export type PartialDB = {

package/dist/dataplane/server/db/tables/playlist-idea.js

@@ -1 +1,4 @@
-export const tableName = 'playlist_idea';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'playlist_idea';

package/dist/dataplane/server/db/tables/playlist-item.js

@@ -1 +1,4 @@
-export const tableName = 'playlist_item';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'playlist_item';

package/dist/dataplane/server/db/tables/playlist.d.ts

@@ -4,6 +4,7 @@ export interface PlaylistTable {
     id: Generated<number>;
     playlist_idea_uri: string;
     type: string;
+    name: string;
 }
 export type PartialDB = {
     [tableName]: PlaylistTable;

package/dist/dataplane/server/db/tables/playlist.js

@@ -1 +1,4 @@
-export const tableName = 'playlist';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'playlist';

package/dist/dataplane/server/db/tables/profile.d.ts

@@ -2,11 +2,11 @@ export declare const tableName = "profile";
 export interface ProfileTable {
     uri: string;
     cid: string;
-    creator: string;
-    display_name?: string;
-    description?: string;
-    avatar_cid?: string;
-    banner_cid?: string;
+    creator_did: string;
+    display_name: string | null;
+    description: string | null;
+    avatar_cid: string | null;
+    banner_cid: string | null;
     created_at: string;
     indexed_at: string;
 }

package/dist/dataplane/server/db/tables/profile.js

@@ -1 +1,4 @@
-export const tableName = 'profile';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'profile';

package/dist/dataplane/server/db/tables/record.d.ts

@@ -5,7 +5,7 @@ export interface RecordTable {
     did: string;
     json: string;
     indexed_at: string;
-    takedown_ref?: string;
+    takedown_ref: string | null;
 }
 export type PartialDB = {
     [tableName]: RecordTable;

package/dist/dataplane/server/db/tables/record.js

@@ -1 +1,4 @@
-export const tableName = 'record';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'record';

package/dist/dataplane/server/db/tables/song-recommendation.d.ts

@@ -0,0 +1,17 @@
+import { Generated } from 'kysely';
+export declare const tableName = "song_recommendation";
+export interface SongRecommendationTable {
+    id: Generated<number>;
+    uri: string;
+    cid: string;
+    recommender_did: string;
+    playlist_idea_uri: string;
+    playlist_idea_cid: string;
+    song_id: number;
+    note: string | null;
+    created_at: string;
+    indexed_at: string;
+}
+export type PartialDB = {
+    [tableName]: SongRecommendationTable;
+};

package/dist/dataplane/server/db/tables/song-recommendation.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'song_recommendation';

package/dist/dataplane/server/db/tables/song.d.ts

@@ -4,8 +4,8 @@ export interface SongTable {
     id: Generated<number>;
     track_name: string;
     track_mb_id: string;
-    album_artwork_ref?: string;
-    created_at?: string;
+    album_artwork_ref: string | null;
+    indexed_at: string;
 }
 export type PartialDB = {
     [tableName]: SongTable;

package/dist/dataplane/server/db/tables/song.js

@@ -1 +1,4 @@
-export const tableName = 'song';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'song';

package/dist/dataplane/server/db/tables/subscription-cursor.d.ts

@@ -0,0 +1,9 @@
+export declare const tableName = "subscription_cursor";
+export interface SubscriptionCursorTable {
+    service: string;
+    cursor: number;
+    updated_at: number;
+}
+export type PartialDB = {
+    [tableName]: SubscriptionCursorTable;
+};

package/dist/dataplane/server/db/tables/subscription-cursor.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'subscription_cursor';

package/dist/dataplane/server/db/types.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/dataplane/server/db/util.d.ts

@@ -1,4 +1,4 @@
-import { DummyDriver, DynamicModule, ExpressionBuilder, RawBuilder, SelectQueryBuilder, SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler } from 'kysely';
+import { DummyDriver, ExpressionBuilder, RawBuilder, SelectQueryBuilder, SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler } from 'kysely';
 import { DatabaseSchema, DatabaseSchemaType } from './database-schema';
 export declare const actorWhereClause: (actor: string) => RawBuilder<0 | 1>;
 export declare const notSoftDeletedClause: (alias: DbRef) => RawBuilder<unknown>;
@@ -6,7 +6,7 @@ export declare const softDeleted: (actorOrRecord: {
     takedownRef: string | null;
 }) => boolean;
 export declare const countAll: RawBuilder<number>;
-export declare const excluded: <T>(db: DatabaseSchema, col: any) => RawBuilder<T>;
+export declare const excluded: <T>(db: DatabaseSchema, col: string) => RawBuilder<T>;
 export declare const noMatch: RawBuilder<unknown>;
 export declare const valuesList: (vals: unknown[]) => RawBuilder<unknown>;
 export declare const dummyDialect: {
@@ -15,6 +15,10 @@ export declare const dummyDialect: {
     createIntrospector(db: any): SqliteIntrospector;
     createQueryCompiler(): SqliteQueryCompiler;
 };
-export type DbRef = RawBuilder | ReturnType<DynamicModule['ref']>;
+type DynamicRefReturn = DatabaseSchema['dynamic'] extends {
+    ref: (...args: unknown[]) => infer R;
+} ? R : never;
+export type DbRef = RawBuilder<unknown> | DynamicRefReturn;
 export type Subquery = ExpressionBuilder<DatabaseSchemaType, any>;
 export type AnyQb = SelectQueryBuilder<any, any, any>;
+export {};

package/dist/dataplane/server/db/util.js

@@ -1,40 +1,48 @@
-import { DummyDriver, SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler, sql, } from 'kysely';
-export const actorWhereClause = (actor) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dummyDialect = exports.valuesList = exports.noMatch = exports.excluded = exports.countAll = exports.softDeleted = exports.notSoftDeletedClause = exports.actorWhereClause = void 0;
+const kysely_1 = require("kysely");
+const actorWhereClause = (actor) => {
     if (actor.startsWith('did:')) {
-        return sql `"actor"."did" = ${actor}`;
+        return (0, kysely_1.sql) `"actor"."did" = ${actor}`;
     }
     else {
-        return sql `"actor"."handle" = ${actor}`;
+        return (0, kysely_1.sql) `"actor"."handle" = ${actor}`;
     }
 };
+exports.actorWhereClause = actorWhereClause;
 // Applies to actor or record table
-export const notSoftDeletedClause = (alias) => {
-    return sql `${alias}."takedownRef" is null`;
+const notSoftDeletedClause = (alias) => {
+    return (0, kysely_1.sql) `${alias}."takedownRef" is null`;
 };
-export const softDeleted = (actorOrRecord) => {
+exports.notSoftDeletedClause = notSoftDeletedClause;
+const softDeleted = (actorOrRecord) => {
     return actorOrRecord.takedownRef !== null;
 };
-export const countAll = sql `count(*)`;
+exports.softDeleted = softDeleted;
+exports.countAll = (0, kysely_1.sql) `count(*)`;
 // For use with doUpdateSet()
-export const excluded = (db, col) => {
-    return sql `${db.dynamic.ref(`excluded.${col}`)}`;
+const excluded = (db, col) => {
+    return (0, kysely_1.sql) `${db.dynamic.ref(`excluded.${col}`)}`;
 };
-export const noMatch = sql `1 = 0`;
+exports.excluded = excluded;
+exports.noMatch = (0, kysely_1.sql) `1 = 0`;
 // Can be useful for large where-in clauses, to get the db to use a hash lookup on the list
-export const valuesList = (vals) => {
-    return sql `(values (${sql.join(vals, sql `), (`)}))`;
+const valuesList = (vals) => {
+    return (0, kysely_1.sql) `(values (${kysely_1.sql.join(vals, (0, kysely_1.sql) `), (`)}))`;
 };
-export const dummyDialect = {
+exports.valuesList = valuesList;
+exports.dummyDialect = {
     createAdapter() {
-        return new SqliteAdapter();
+        return new kysely_1.SqliteAdapter();
     },
     createDriver() {
-        return new DummyDriver();
+        return new kysely_1.DummyDriver();
     },
     createIntrospector(db) {
-        return new SqliteIntrospector(db);
+        return new kysely_1.SqliteIntrospector(db);
     },
     createQueryCompiler() {
-        return new SqliteQueryCompiler();
+        return new kysely_1.SqliteQueryCompiler();
     },
 };

package/dist/dataplane/server/index.js

@@ -1,10 +1,17 @@
-import { IdResolver, MemoryCache } from '@atproto/identity';
-import { expressConnectMiddleware } from '@connectrpc/connect-express';
-import express from 'express';
-import events from 'node:events';
-import createRoutes from './routes';
-export { RepoSubscription } from './subscription';
-export class DataPlaneServer {
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataPlaneServer = exports.RepoSubscription = void 0;
+const identity_1 = require("@atproto/identity");
+const connect_express_1 = require("@connectrpc/connect-express");
+const express_1 = __importDefault(require("express"));
+const node_events_1 = __importDefault(require("node:events"));
+const routes_1 = __importDefault(require("./routes"));
+var subscription_1 = require("./subscription");
+Object.defineProperty(exports, "RepoSubscription", { enumerable: true, get: function () { return subscription_1.RepoSubscription; } });
+class DataPlaneServer {
     server;
     idResolver;
     constructor(server, idResolver) {
@@ -12,13 +19,13 @@ export class DataPlaneServer {
         this.idResolver = idResolver;
     }
     static async create(db, port, plcUrl) {
-        const app = express();
-        const didCache = new MemoryCache();
-        const idResolver = new IdResolver({ plcUrl, didCache });
-        const routes = createRoutes(db, idResolver);
-        app.use(expressConnectMiddleware({ routes }));
+        const app = (0, express_1.default)();
+        const didCache = new identity_1.MemoryCache();
+        const idResolver = new identity_1.IdResolver({ plcUrl, didCache });
+        const routes = (0, routes_1.default)(db, idResolver);
+        app.use((0, connect_express_1.expressConnectMiddleware)({ routes }));
         const server = app.listen(port);
-        await events.once(server, 'listening');
+        await node_events_1.default.once(server, 'listening');
         return new DataPlaneServer(server, idResolver);
     }
     async destroy() {
@@ -34,3 +41,4 @@ export class DataPlaneServer {
         });
     }
 }
+exports.DataPlaneServer = DataPlaneServer;

package/dist/dataplane/server/indexing/index.d.ts

@@ -5,6 +5,7 @@ import { CID } from 'multiformats/cid';
 import { Database } from '../db';
 import * as PlaylistIdea from './plugins/playlist-idea';
 import * as Profile from './plugins/profile';
+import * as SongRecommendation from './plugins/song-recommendation';
 import { RecordProcessor } from './processor';
 export declare class IndexingService {
     db: Database;
@@ -12,6 +13,7 @@ export declare class IndexingService {
     records: {
         playlistIdea: PlaylistIdea.PluginType;
         profile: Profile.PluginType;
+        songRecommendation: SongRecommendation.PluginType;
     };
     constructor(db: Database, idResolver: IdResolver);
     transact(txn: Database): IndexingService;

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

@@ -1,16 +1,53 @@
-import { Agent, ComAtprotoSyncGetLatestCommit } from '@atproto/api';
-import { DAY, HOUR } from '@atproto/common';
-import { getPds } from '@atproto/identity';
-import { ValidationError } from '@atproto/lexicon';
-import { WriteOpAction, getAndParseRecord, readCarWithRoot, verifyRepo, } from '@atproto/repo';
-import { AtUri } from '@atproto/syntax';
-import { sql } from 'kysely';
-import { CID } from 'multiformats/cid';
-import { httpLogger } from '../../../logger';
-import { retryXrpc } from '../../../util/retry';
-import * as PlaylistIdea from './plugins/playlist-idea';
-import * as Profile from './plugins/profile';
-export class IndexingService {
+"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.IndexingService = void 0;
+const api_1 = require("@atproto/api");
+const common_1 = require("@atproto/common");
+const identity_1 = require("@atproto/identity");
+const lexicon_1 = require("@atproto/lexicon");
+const repo_1 = require("@atproto/repo");
+const syntax_1 = require("@atproto/syntax");
+const kysely_1 = require("kysely");
+const cid_1 = require("multiformats/cid");
+const logger_1 = require("../../../logger");
+const retry_1 = require("../../../util/retry");
+const PlaylistIdea = __importStar(require("./plugins/playlist-idea"));
+const Profile = __importStar(require("./plugins/profile"));
+const SongRecommendation = __importStar(require("./plugins/song-recommendation"));
+class IndexingService {
     db;
     idResolver;
     records;
@@ -20,6 +57,7 @@ export class IndexingService {
         this.records = {
             playlistIdea: PlaylistIdea.makePlugin(this.db),
             profile: Profile.makePlugin(this.db),
+            songRecommendation: SongRecommendation.makePlugin(this.db),
         };
     }
     transact(txn) {
@@ -33,7 +71,7 @@ export class IndexingService {
             const indexer = indexingTx.findIndexerForCollection(uri.collection);
             if (!indexer)
                 return;
-            if (action === WriteOpAction.Create) {
+            if (action === repo_1.WriteOpAction.Create) {
                 await indexer.insertRecord(uri, cid, obj, timestamp);
             }
             else {
@@ -53,11 +91,7 @@ export class IndexingService {
     }
     async indexHandle(did, timestamp, force = false) {
         this.db.assertNotTransaction();
-        const actor = await this.db.db
-            .selectFrom('actor')
-            .where('did', '=', did)
-            .selectAll()
-            .executeTakeFirst();
+        const actor = await this.db.db.selectFrom('actor').where('did', '=', did).selectAll().executeTakeFirst();
         if (!force && !needsHandleReindex(actor, timestamp)) {
             return;
         }
@@ -65,19 +99,11 @@ export class IndexingService {
         const handleToDid = await this.idResolver.handle.resolve(atpData.handle);
         const handle = did === handleToDid ? atpData.handle.toLowerCase() : null;
         const actorWithHandle = handle !== null
-            ? await this.db.db
-                .selectFrom('actor')
-                .where('handle', '=', handle)
-                .selectAll()
-                .executeTakeFirst()
+            ? await this.db.db.selectFrom('actor').where('handle', '=', handle).selectAll().executeTakeFirst()
             : null;
         // handle contention
         if (handle && actorWithHandle && did !== actorWithHandle.did) {
-            await this.db.db
-                .updateTable('actor')
-                .where('actor.did', '=', actorWithHandle.did)
-                .set({ handle: null })
-                .execute();
+            await this.db.db.updateTable('actor').where('actor.did', '=', actorWithHandle.did).set({ handle: null }).execute();
         }
         const actorInfo = { handle, indexed_at: timestamp };
         await this.db.db
@@ -91,10 +117,10 @@ export class IndexingService {
         this.db.assertNotTransaction();
         const now = new Date().toISOString();
         const { pds, signingKey } = await this.idResolver.did.resolveAtprotoData(did, true);
-        const agent = new Agent(pds);
-        const { data: car } = await retryXrpc(() => agent.com.atproto.sync.getRepo({ did }));
-        const { root, blocks } = await readCarWithRoot(car);
-        const verifiedRepo = await verifyRepo(blocks, root, did, signingKey);
+        const agent = new api_1.Agent(pds);
+        const { data: car } = await (0, retry_1.retryXrpc)(() => agent.com.atproto.sync.getRepo({ did }));
+        const { root, blocks } = await (0, repo_1.readCarWithRoot)(car);
+        const verifiedRepo = await (0, repo_1.verifyRepo)(blocks, root, did, signingKey);
         const currRecords = await this.getCurrentRecords(did);
         const repoRecords = formatCheckout(did, verifiedRepo);
         const diff = findDiffFromCheckout(currRecords, repoRecords);
@@ -105,16 +131,16 @@ export class IndexingService {
                     await this.deleteRecord(uri);
                 }
                 else {
-                    const parsed = await getAndParseRecord(blocks, cid);
-                    await this.indexRecord(uri, cid, parsed.record, op.op === 'create' ? WriteOpAction.Create : WriteOpAction.Update, now);
+                    const parsed = await (0, repo_1.getAndParseRecord)(blocks, cid);
+                    await this.indexRecord(uri, cid, parsed.record, op.op === 'create' ? repo_1.WriteOpAction.Create : repo_1.WriteOpAction.Update, now);
                 }
             }
             catch (err) {
-                if (err instanceof ValidationError) {
-                    httpLogger.warn({ did, commit, uri: uri.toString(), cid: cid.toString() }, 'skipping indexing of invalid record');
+                if (err instanceof lexicon_1.ValidationError) {
+                    logger_1.httpLogger.warn({ did, commit, uri: uri.toString(), cid: cid.toString() }, 'skipping indexing of invalid record');
                 }
                 else {
-                    httpLogger.error({ err, did, commit, uri: uri.toString(), cid: cid.toString() }, 'skipping indexing due to error processing record');
+                    logger_1.httpLogger.error({ err, did, commit, uri: uri.toString(), cid: cid.toString() }, 'skipping indexing due to error processing record');
                 }
             }
         }));
@@ -130,11 +156,7 @@ export class IndexingService {
         else {
             throw new Error(`Unrecognized account status: ${status}`);
         }
-        await this.db.db
-            .updateTable('actor')
-            .set({ upstreamStatus })
-            .where('did', '=', did)
-            .execute();
+        await this.db.db.updateTable('actor').set({ upstream_status: upstreamStatus }).where('did', '=', did).execute();
     }
     async setCommitLastSeen(did, commit, rev) {
         const { ref } = this.db.db.dynamic;
@@ -142,28 +164,24 @@ export class IndexingService {
             .insertInto('actor_sync')
             .values({
             did,
-            commitCid: commit.toString(),
-            repoRev: rev ?? null,
+            commit_cid: commit.toString(),
+            repo_rev: rev,
         })
             .onConflict((oc) => {
             const excluded = (col) => ref(`excluded.${col}`);
             return oc.column('did').doUpdateSet({
-                commitCid: sql `${excluded('commitCid')}`,
-                repoRev: sql `${excluded('repoRev')}`,
+                commit_cid: (0, kysely_1.sql) `${excluded('commit_cid')}`,
+                repo_rev: (0, kysely_1.sql) `${excluded('repo_rev')}`,
             });
         })
             .execute();
     }
     async getCurrentRecords(did) {
-        const res = await this.db.db
-            .selectFrom('record')
-            .where('did', '=', did)
-            .select(['uri', 'cid'])
-            .execute();
+        const res = await this.db.db.selectFrom('record').where('did', '=', did).select(['uri', 'cid']).execute();
         return res.reduce((acc, cur) => {
             acc[cur.uri] = {
-                uri: new AtUri(cur.uri),
-                cid: CID.parse(cur.cid),
+                uri: new syntax_1.AtUri(cur.uri),
+                cid: cid_1.CID.parse(cur.cid),
             };
             return acc;
         }, {});
@@ -182,16 +200,16 @@ export class IndexingService {
     }
     async getActorIsHosted(did) {
         const doc = await this.idResolver.did.resolve(did, true);
-        const pds = doc && getPds(doc);
+        const pds = doc && (0, identity_1.getPds)(doc);
         if (!pds)
             return false;
-        const agent = new Agent(pds);
+        const agent = new api_1.Agent(pds);
         try {
-            await retryXrpc(() => agent.com.atproto.sync.getLatestCommit({ did }));
+            await (0, retry_1.retryXrpc)(() => agent.com.atproto.sync.getLatestCommit({ did }));
             return true;
         }
         catch (err) {
-            if (err instanceof ComAtprotoSyncGetLatestCommit.RepoNotFoundError) {
+            if (err instanceof api_1.ComAtprotoSyncGetLatestCommit.RepoNotFoundError) {
                 return false;
             }
             return null;
@@ -199,7 +217,7 @@ export class IndexingService {
     }
     async unindexActor(did) {
         this.db.assertNotTransaction();
-        await this.db.db.deleteFrom('profile').where('creator', '=', did).execute();
+        await this.db.db.deleteFrom('profile').where('creator_did', '=', did).execute();
         await this.db.db.deleteFrom('record').where('did', '=', did).execute();
         const deletedPlaylistIdeas = await this.db.db
             .deleteFrom('playlist_idea')
@@ -217,12 +235,10 @@ export class IndexingService {
         const deletedPlaylistIds = deletedPlaylists.map((deletedPlaylist) => {
             return deletedPlaylist.id;
         });
-        await this.db.db
-            .deleteFrom('playlist_item')
-            .where('playlist_id', 'in', deletedPlaylistIds)
-            .execute();
+        await this.db.db.deleteFrom('playlist_item').where('playlist_id', 'in', deletedPlaylistIds).execute();
     }
 }
+exports.IndexingService = IndexingService;
 const findDiffFromCheckout = (curr, checkout) => {
     const ops = [];
     for (const uri of Object.keys(checkout)) {
@@ -249,7 +265,7 @@ const findDiffFromCheckout = (curr, checkout) => {
 const formatCheckout = (did, verifiedRepo) => {
     const records = {};
     for (const create of verifiedRepo.creates) {
-        const uri = AtUri.make(did, create.collection, create.rkey);
+        const uri = syntax_1.AtUri.make(did, create.collection, create.rkey);
         records[uri.toString()] = {
             uri,
             cid: create.cid,
@@ -262,10 +278,10 @@ const needsHandleReindex = (actor, timestamp) => {
         return true;
     const timeDiff = new Date(timestamp).getTime() - new Date(actor.indexed_at).getTime();
     // revalidate daily
-    if (timeDiff > DAY)
+    if (timeDiff > common_1.DAY)
         return true;
     // revalidate more aggressively for invalidated handles
-    if (actor.handle === null && timeDiff > HOUR)
+    if (actor.handle === null && timeDiff > common_1.HOUR)
         return true;
     return false;
 };