Add feed generators lexicon and API types

- Add feedGeneratorsView and feedGeneratorView defs (JSON and pkl)
- Add app.rocksky.feed.getFeedGenerators lexicon and generated TS types
- Export new types from lexicon index
- Swap/fix album getAlbums/getAlbumTracks handlers and update schemas
- Misc: small formatting, type-only imports, and script fixes

apps/api/lexicons/feed/defs.json

···
           }
         }
       }
+    },
+    "feedGeneratorsView": {
+      "type": "object",
+      "properties": {
+        "feeds": {
+          "type": "array",
+          "items": {
+            "type": "ref",
+            "ref": "app.rocksky.feed.defs#feedGeneratorView"
+          }
+        }
+      }
+    },
+    "feedGeneratorView": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string"
+        },
+        "name": {
+          "type": "string"
+        },
+        "description": {
+          "type": "string"
+        },
+        "uri": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "avatar": {
+          "type": "string",
+          "format": "uri"
+        },
+        "creator": {
+          "type": "ref",
+          "ref": "app.rocksky.actor.defs#profileViewBasic"
+        }
+      }
     }
   }
 }

apps/api/lexicons/feed/getFeedGenerators.json

···
+{
+  "lexicon": 1,
+  "id": "app.rocksky.feed.getFeedGenerators",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get all feed generators",
+      "parameters": {
+        "type": "params",
+        "properties": {
+          "size": {
+            "type": "integer",
+            "description": "The maximum number of feed generators to return.",
+            "minimum": 1
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "app.rocksky.feed.defs#feedGeneratorsView"
+        }
+      }
+    }
+  }
+}

apps/api/pkl/defs/feed/defs.pkl

···
       }
     }
   }
+  ["feedGeneratorsView"] = new ObjectType {
+    type = "object"
+    properties  {
+      ["feeds"] = new Array {
+        type = "array"
+        items = new Ref {
+          type = "ref"
+          ref = "app.rocksky.feed.defs#feedGeneratorView"
+        }
+      }
+    }
+  }
+  ["feedGeneratorView"] = new ObjectType {
+    type = "object"
+    properties {
+      ["id"] = new StringType {
+        type = "string"
+      }
+      ["name"] = new StringType {
+        type = "string"
+      }
+      ["description"] = new StringType {
+        type = "string"
+      }
+      ["uri"] = new StringType {
+        type = "string"
+        format = "at-uri"
+      }
+      ["avatar"] = new StringType {
+        type = "string"
+        format = "uri"
+      }
+      ["creator"] = new Ref {
+        type = "ref"
+        ref = "app.rocksky.actor.defs#profileViewBasic"
+      }
+    }
+  }
 }

apps/api/pkl/defs/feed/getFeedGenerators.pkl

···
+amends  "../../schema/lexicon.pkl"
+
+lexicon = 1
+id = "app.rocksky.feed.getFeedGenerators"
+defs = new Mapping<String, Query> {
+  ["main"] {
+    type = "query"
+    description = "Get all feed generators"
+    parameters {
+      type = "params"
+      properties {
+        ["size"] = new IntegerType {
+          type = "integer"
+          description = "The maximum number of feed generators to return."
+          minimum = 1
+        }
+      }
+    }
+    output {
+      encoding = "application/json"
+      schema = new Ref {
+        type = "ref"
+        ref = "app.rocksky.feed.defs#feedGeneratorsView"
+      }
+    }
+  }
+}

apps/api/src/lexicon/index.ts

···
 import type * as AppRockskyActorGetActorSongs from "./types/app/rocksky/actor/getActorSongs";
 import type * as AppRockskyActorGetProfile from "./types/app/rocksky/actor/getProfile";
 import type * as AppRockskyAlbumGetAlbum from "./types/app/rocksky/album/getAlbum";
-import type * as AppRockskyAlbumGetAlbumTracks from "./types/app/rocksky/album/getAlbumTracks";
 import type * as AppRockskyAlbumGetAlbums from "./types/app/rocksky/album/getAlbums";
+import type * as AppRockskyAlbumGetAlbumTracks from "./types/app/rocksky/album/getAlbumTracks";
 import type * as AppRockskyApikeyCreateApikey from "./types/app/rocksky/apikey/createApikey";
 import type * as AppRockskyApikeyGetApikeys from "./types/app/rocksky/apikey/getApikeys";
 import type * as AppRockskyApikeyRemoveApikey from "./types/app/rocksky/apikey/removeApikey";
···
 import type * as AppRockskyArtistGetArtist from "./types/app/rocksky/artist/getArtist";
 import type * as AppRockskyArtistGetArtistAlbums from "./types/app/rocksky/artist/getArtistAlbums";
 import type * as AppRockskyArtistGetArtistListeners from "./types/app/rocksky/artist/getArtistListeners";
+import type * as AppRockskyArtistGetArtists from "./types/app/rocksky/artist/getArtists";
 import type * as AppRockskyArtistGetArtistTracks from "./types/app/rocksky/artist/getArtistTracks";
-import type * as AppRockskyArtistGetArtists from "./types/app/rocksky/artist/getArtists";
 import type * as AppRockskyChartsGetScrobblesChart from "./types/app/rocksky/charts/getScrobblesChart";
 import type * as AppRockskyDropboxDownloadFile from "./types/app/rocksky/dropbox/downloadFile";
 import type * as AppRockskyDropboxGetFiles from "./types/app/rocksky/dropbox/getFiles";
 import type * as AppRockskyDropboxGetMetadata from "./types/app/rocksky/dropbox/getMetadata";
 import type * as AppRockskyDropboxGetTemporaryLink from "./types/app/rocksky/dropbox/getTemporaryLink";
+import type * as AppRockskyFeedGetFeedGenerators from "./types/app/rocksky/feed/getFeedGenerators";
 import type * as AppRockskyFeedGetNowPlayings from "./types/app/rocksky/feed/getNowPlayings";
 import type * as AppRockskyFeedSearch from "./types/app/rocksky/feed/search";
 import type * as AppRockskyGoogledriveDownloadFile from "./types/app/rocksky/googledrive/downloadFile";
···
     return this._server.xrpc.method(nsid, cfg);
   }
 
-  getAlbumTracks<AV extends AuthVerifier>(
+  getAlbums<AV extends AuthVerifier>(
     cfg: ConfigOf<
       AV,
-      AppRockskyAlbumGetAlbumTracks.Handler<ExtractAuth<AV>>,
-      AppRockskyAlbumGetAlbumTracks.HandlerReqCtx<ExtractAuth<AV>>
+      AppRockskyAlbumGetAlbums.Handler<ExtractAuth<AV>>,
+      AppRockskyAlbumGetAlbums.HandlerReqCtx<ExtractAuth<AV>>
     >,
   ) {
-    const nsid = "app.rocksky.album.getAlbumTracks"; // @ts-ignore
+    const nsid = "app.rocksky.album.getAlbums"; // @ts-ignore
     return this._server.xrpc.method(nsid, cfg);
   }
 
-  getAlbums<AV extends AuthVerifier>(
+  getAlbumTracks<AV extends AuthVerifier>(
     cfg: ConfigOf<
       AV,
-      AppRockskyAlbumGetAlbums.Handler<ExtractAuth<AV>>,
-      AppRockskyAlbumGetAlbums.HandlerReqCtx<ExtractAuth<AV>>
+      AppRockskyAlbumGetAlbumTracks.Handler<ExtractAuth<AV>>,
+      AppRockskyAlbumGetAlbumTracks.HandlerReqCtx<ExtractAuth<AV>>
     >,
   ) {
-    const nsid = "app.rocksky.album.getAlbums"; // @ts-ignore
+    const nsid = "app.rocksky.album.getAlbumTracks"; // @ts-ignore
     return this._server.xrpc.method(nsid, cfg);
   }
 }
···
     return this._server.xrpc.method(nsid, cfg);
   }
 
-  getArtistTracks<AV extends AuthVerifier>(
+  getArtists<AV extends AuthVerifier>(
     cfg: ConfigOf<
       AV,
-      AppRockskyArtistGetArtistTracks.Handler<ExtractAuth<AV>>,
-      AppRockskyArtistGetArtistTracks.HandlerReqCtx<ExtractAuth<AV>>
+      AppRockskyArtistGetArtists.Handler<ExtractAuth<AV>>,
+      AppRockskyArtistGetArtists.HandlerReqCtx<ExtractAuth<AV>>
     >,
   ) {
-    const nsid = "app.rocksky.artist.getArtistTracks"; // @ts-ignore
+    const nsid = "app.rocksky.artist.getArtists"; // @ts-ignore
     return this._server.xrpc.method(nsid, cfg);
   }
 
-  getArtists<AV extends AuthVerifier>(
+  getArtistTracks<AV extends AuthVerifier>(
     cfg: ConfigOf<
       AV,
-      AppRockskyArtistGetArtists.Handler<ExtractAuth<AV>>,
-      AppRockskyArtistGetArtists.HandlerReqCtx<ExtractAuth<AV>>
+      AppRockskyArtistGetArtistTracks.Handler<ExtractAuth<AV>>,
+      AppRockskyArtistGetArtistTracks.HandlerReqCtx<ExtractAuth<AV>>
     >,
   ) {
-    const nsid = "app.rocksky.artist.getArtists"; // @ts-ignore
+    const nsid = "app.rocksky.artist.getArtistTracks"; // @ts-ignore
     return this._server.xrpc.method(nsid, cfg);
   }
 }
···
 
   constructor(server: Server) {
     this._server = server;
+  }
+
+  getFeedGenerators<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyFeedGetFeedGenerators.Handler<ExtractAuth<AV>>,
+      AppRockskyFeedGetFeedGenerators.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = "app.rocksky.feed.getFeedGenerators"; // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg);
   }
 
   getNowPlayings<AV extends AuthVerifier>(

apps/api/src/lexicon/lexicons.ts

···
       },
     },
   },
-  AppRockskyAlbumGetAlbumTracks: {
+  AppRockskyAlbumGetAlbums: {
     lexicon: 1,
-    id: "app.rocksky.album.getAlbumTracks",
+    id: "app.rocksky.album.getAlbums",
     defs: {
       main: {
         type: "query",
-        description: "Get tracks for an album",
+        description: "Get albums",
         parameters: {
           type: "params",
-          required: ["uri"],
           properties: {
-            uri: {
-              type: "string",
-              description: "The URI of the album to retrieve tracks from",
-              format: "at-uri",
+            limit: {
+              type: "integer",
+              description: "The maximum number of albums to return",
+              minimum: 1,
+            },
+            offset: {
+              type: "integer",
+              description: "The offset for pagination",
+              minimum: 0,
             },
           },
         },
···
           schema: {
             type: "object",
             properties: {
-              tracks: {
+              albums: {
                 type: "array",
                 items: {
                   type: "ref",
-                  ref: "lex:app.rocksky.song.defs#songViewBasic",
+                  ref: "lex:app.rocksky.album.defs#albumViewBasic",
                 },
               },
             },
···
       },
     },
   },
-  AppRockskyAlbumGetAlbums: {
+  AppRockskyAlbumGetAlbumTracks: {
     lexicon: 1,
-    id: "app.rocksky.album.getAlbums",
+    id: "app.rocksky.album.getAlbumTracks",
     defs: {
       main: {
         type: "query",
-        description: "Get albums",
+        description: "Get tracks for an album",
         parameters: {
           type: "params",
+          required: ["uri"],
           properties: {
-            limit: {
-              type: "integer",
-              description: "The maximum number of albums to return",
-              minimum: 1,
-            },
-            offset: {
-              type: "integer",
-              description: "The offset for pagination",
-              minimum: 0,
+            uri: {
+              type: "string",
+              description: "The URI of the album to retrieve tracks from",
+              format: "at-uri",
             },
           },
         },
···
           schema: {
             type: "object",
             properties: {
-              albums: {
+              tracks: {
                 type: "array",
                 items: {
                   type: "ref",
-                  ref: "lex:app.rocksky.album.defs#albumViewBasic",
+                  ref: "lex:app.rocksky.song.defs#songViewBasic",
                 },
               },
             },
···
       },
     },
   },
-  AppRockskyArtistGetArtistTracks: {
+  AppRockskyArtistGetArtists: {
     lexicon: 1,
-    id: "app.rocksky.artist.getArtistTracks",
+    id: "app.rocksky.artist.getArtists",
     defs: {
       main: {
         type: "query",
-        description: "Get artist's tracks",
+        description: "Get artists",
         parameters: {
           type: "params",
           properties: {
-            uri: {
-              type: "string",
-              description: "The URI of the artist to retrieve albums from",
-              format: "at-uri",
-            },
             limit: {
               type: "integer",
-              description: "The maximum number of tracks to return",
+              description: "The maximum number of artists to return",
               minimum: 1,
             },
             offset: {
···
               description: "The offset for pagination",
               minimum: 0,
             },
+            names: {
+              type: "string",
+              description: "The names of the artists to return",
+            },
           },
         },
         output: {
···
           schema: {
             type: "object",
             properties: {
-              tracks: {
+              artists: {
                 type: "array",
                 items: {
                   type: "ref",
-                  ref: "lex:app.rocksky.song.defs#songViewBasic",
+                  ref: "lex:app.rocksky.artist.defs#artistViewBasic",
                 },
               },
             },
···
       },
     },
   },
-  AppRockskyArtistGetArtists: {
+  AppRockskyArtistGetArtistTracks: {
     lexicon: 1,
-    id: "app.rocksky.artist.getArtists",
+    id: "app.rocksky.artist.getArtistTracks",
     defs: {
       main: {
         type: "query",
-        description: "Get artists",
+        description: "Get artist's tracks",
         parameters: {
           type: "params",
           properties: {
+            uri: {
+              type: "string",
+              description: "The URI of the artist to retrieve albums from",
+              format: "at-uri",
+            },
             limit: {
               type: "integer",
-              description: "The maximum number of artists to return",
+              description: "The maximum number of tracks to return",
               minimum: 1,
             },
             offset: {
···
               description: "The offset for pagination",
               minimum: 0,
             },
-            names: {
-              type: "string",
-              description: "The names of the artists to return",
-            },
           },
         },
         output: {
···
           schema: {
             type: "object",
             properties: {
-              artists: {
+              tracks: {
                 type: "array",
                 items: {
                   type: "ref",
-                  ref: "lex:app.rocksky.artist.defs#artistViewBasic",
+                  ref: "lex:app.rocksky.song.defs#songViewBasic",
                 },
               },
             },
···
           },
         },
       },
+      feedGeneratorsView: {
+        type: "object",
+        properties: {
+          feeds: {
+            type: "array",
+            items: {
+              type: "ref",
+              ref: "lex:app.rocksky.feed.defs#feedGeneratorView",
+            },
+          },
+        },
+      },
+      feedGeneratorView: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+          },
+          name: {
+            type: "string",
+          },
+          description: {
+            type: "string",
+          },
+          uri: {
+            type: "string",
+            format: "at-uri",
+          },
+          avatar: {
+            type: "string",
+            format: "uri",
+          },
+          creator: {
+            type: "ref",
+            ref: "lex:app.rocksky.actor.defs#profileViewBasic",
+          },
+        },
+      },
     },
   },
   AppRockskyFeedGenerator: {
···
               type: "string",
               format: "datetime",
             },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyFeedGetFeedGenerators: {
+    lexicon: 1,
+    id: "app.rocksky.feed.getFeedGenerators",
+    defs: {
+      main: {
+        type: "query",
+        description: "Get all feed generators",
+        parameters: {
+          type: "params",
+          properties: {
+            size: {
+              type: "integer",
+              description: "The maximum number of feed generators to return.",
+              minimum: 1,
+            },
+          },
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "ref",
+            ref: "lex:app.rocksky.feed.defs#feedGeneratorsView",
           },
         },
       },
···
   AppRockskyAlbum: "app.rocksky.album",
   AppRockskyAlbumDefs: "app.rocksky.album.defs",
   AppRockskyAlbumGetAlbum: "app.rocksky.album.getAlbum",
-  AppRockskyAlbumGetAlbumTracks: "app.rocksky.album.getAlbumTracks",
   AppRockskyAlbumGetAlbums: "app.rocksky.album.getAlbums",
+  AppRockskyAlbumGetAlbumTracks: "app.rocksky.album.getAlbumTracks",
   AppRockskyApikeyCreateApikey: "app.rocksky.apikey.createApikey",
   AppRockskyApikeyDefs: "app.rocksky.apikey.defs",
   AppRockskyApikeysDefs: "app.rocksky.apikeys.defs",
···
   AppRockskyArtistGetArtist: "app.rocksky.artist.getArtist",
   AppRockskyArtistGetArtistAlbums: "app.rocksky.artist.getArtistAlbums",
   AppRockskyArtistGetArtistListeners: "app.rocksky.artist.getArtistListeners",
+  AppRockskyArtistGetArtists: "app.rocksky.artist.getArtists",
   AppRockskyArtistGetArtistTracks: "app.rocksky.artist.getArtistTracks",
-  AppRockskyArtistGetArtists: "app.rocksky.artist.getArtists",
   AppRockskyChartsDefs: "app.rocksky.charts.defs",
   AppRockskyChartsGetScrobblesChart: "app.rocksky.charts.getScrobblesChart",
   AppRockskyDropboxDefs: "app.rocksky.dropbox.defs",
···
   AppRockskyDropboxGetTemporaryLink: "app.rocksky.dropbox.getTemporaryLink",
   AppRockskyFeedDefs: "app.rocksky.feed.defs",
   AppRockskyFeedGenerator: "app.rocksky.feed.generator",
+  AppRockskyFeedGetFeedGenerators: "app.rocksky.feed.getFeedGenerators",
   AppRockskyFeedGetNowPlayings: "app.rocksky.feed.getNowPlayings",
   AppRockskyFeedSearch: "app.rocksky.feed.search",
   AppRockskyGoogledriveDefs: "app.rocksky.googledrive.defs",

apps/api/src/lexicon/types/app/rocksky/feed/defs.ts

···
 export function validateNowPlayingsView(v: unknown): ValidationResult {
   return lexicons.validate("app.rocksky.feed.defs#nowPlayingsView", v);
 }
+
+export interface FeedGeneratorsView {
+  feeds?: FeedGeneratorView[];
+  [k: string]: unknown;
+}
+
+export function isFeedGeneratorsView(v: unknown): v is FeedGeneratorsView {
+  return (
+    isObj(v) &&
+    hasProp(v, "$type") &&
+    v.$type === "app.rocksky.feed.defs#feedGeneratorsView"
+  );
+}
+
+export function validateFeedGeneratorsView(v: unknown): ValidationResult {
+  return lexicons.validate("app.rocksky.feed.defs#feedGeneratorsView", v);
+}
+
+export interface FeedGeneratorView {
+  id?: string;
+  name?: string;
+  description?: string;
+  uri?: string;
+  avatar?: string;
+  creator?: AppRockskyActorDefs.ProfileViewBasic;
+  [k: string]: unknown;
+}
+
+export function isFeedGeneratorView(v: unknown): v is FeedGeneratorView {
+  return (
+    isObj(v) &&
+    hasProp(v, "$type") &&
+    v.$type === "app.rocksky.feed.defs#feedGeneratorView"
+  );
+}
+
+export function validateFeedGeneratorView(v: unknown): ValidationResult {
+  return lexicons.validate("app.rocksky.feed.defs#feedGeneratorView", v);
+}

apps/api/src/lexicon/types/app/rocksky/feed/getFeedGenerators.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import type express from "express";
+import { ValidationResult, BlobRef } from "@atproto/lexicon";
+import { lexicons } from "../../../../lexicons";
+import { isObj, hasProp } from "../../../../util";
+import { CID } from "multiformats/cid";
+import type { HandlerAuth, HandlerPipeThrough } from "@atproto/xrpc-server";
+import type * as AppRockskyFeedDefs from "./defs";
+
+export interface QueryParams {
+  /** The maximum number of feed generators to return. */
+  size?: number;
+}
+
+export type InputSchema = undefined;
+export type OutputSchema = AppRockskyFeedDefs.FeedGeneratorsView;
+export type HandlerInput = undefined;
+
+export interface HandlerSuccess {
+  encoding: "application/json";
+  body: OutputSchema;
+  headers?: { [key: string]: string };
+}
+
+export interface HandlerError {
+  status: number;
+  message?: string;
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA;
+  params: QueryParams;
+  input: HandlerInput;
+  req: express.Request;
+  res: express.Response;
+  resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput;

apps/api/src/schema/feeds.ts

···
 import users from "./users";
 
 const feeds = pgTable("feeds", {
-  id: text("xata_id")
-    .primaryKey()
-    .default(sql`xata_id()`),
+  id: text("xata_id").primaryKey().default(sql`xata_id()`),
   displayName: text("display_name").notNull(),
   description: text("description"),
   did: text("did").notNull(),

apps/api/src/scripts/avatar.ts

···
 async function processUser(user: SelectUser) {
   if (!process.env.SKIP_AVATAR_UPDATE) {
     const plc = await fetch(`https://plc.directory/${user.did}`).then((res) =>
-      res.json()
+      res.json(),
     );
 
     const serviceEndpoint = _.get(plc, "service.0.serviceEndpoint");
···
     }
 
     const profile = await fetch(
-      `${serviceEndpoint}/xrpc/com.atproto.repo.getRecord?repo=${user.did}&collection=app.bsky.actor.profile&rkey=self`
+      `${serviceEndpoint}/xrpc/com.atproto.repo.getRecord?repo=${user.did}&collection=app.bsky.actor.profile&rkey=self`,
     ).then((res) => res.json());
     const ref = _.get(profile, "value.avatar.ref.$link");
     const type = _.get(profile, "value.avatar.mimeType", "").split("/")[1];
···
   console.log(userPayload);
   await ctx.nc.publish(
     "rocksky.user",
-    Buffer.from(JSON.stringify(userPayload))
+    Buffer.from(JSON.stringify(userPayload)),
   );
 }
 
···
     }
 
     console.log(
-      `Processing batch ${Math.floor(offset / BATCH_SIZE) + 1}, users ${offset + 1}-${offset + batch.length}`
+      `Processing batch ${Math.floor(offset / BATCH_SIZE) + 1}, users ${offset + 1}-${offset + batch.length}`,
     );
 
     for (const user of batch) {

apps/api/src/scripts/feed.ts

···
 import chalk from "chalk";
 import { ctx } from "context";
-import * as FeedGenerator from "lexicon/types/app/rocksky/feed/generator";
+import type * as FeedGenerator from "lexicon/types/app/rocksky/feed/generator";
 import { createAgent } from "lib/agent";
 import prompts from "prompts";
 
···
 
 if (!/^did:web:[a-zA-Z0-9_.-]{3,30}$/.test(did.value)) {
   console.error(
-    "Invalid DID format. It should start with 'did:web:' followed by 3 to 30 alphanumeric characters, underscores, hyphens, or periods."
+    "Invalid DID format. It should start with 'did:web:' followed by 3 to 30 alphanumeric characters, underscores, hyphens, or periods.",
   );
   process.exit(1);
 }
···
 
 if (!/^[a-zA-Z0-9_-]{3,30}$/.test(rkey.value)) {
   console.error(
-    "Invalid record key. Only alphanumeric characters, underscores, and hyphens are allowed. Length must be between 3 and 30 characters."
+    "Invalid record key. Only alphanumeric characters, underscores, and hyphens are allowed. Length must be between 3 and 30 characters.",
   );
   process.exit(1);
 }
···
 console.log("DID:", did.value);
 console.log("Record key (rkey):", rkey.value);
 
-let confirm = await prompts({
+const confirm = await prompts({
   type: "confirm",
   name: "value",
   message: "Do you want to proceed?",
···
 const agent = await createAgent(ctx.oauthClient, userDid);
 
 console.log(
-  `Writing ${chalk.greenBright("app.rocksky.feed.generator")} record...`
+  `Writing ${chalk.greenBright("app.rocksky.feed.generator")} record...`,
 );
 
 const record: FeedGenerator.Record = {

apps/api/src/scripts/seed-feed.ts

···
 import { createAgent } from "lib/agent";
 import * as FeedGenerator from "lexicon/types/app/rocksky/feed/generator";
 import tables from "schema";
-import { InsertFeed } from "schema/feeds";
+import type { InsertFeed } from "schema/feeds";
 import { eq } from "drizzle-orm";
 
 const args = process.argv.slice(2);

apps/api/src/sqliteKv.ts

···
             oc.column("id").doUpdateSet({
               value,
               updated_at: now,
-            })
+            }),
           )
           .execute();
       },
···
                     oc.column("id").doUpdateSet({
                       value,
                       updated_at: now,
-                    })
+                    }),
                   )
                   .execute();
-              })
+              }),
             );
           });
       },
···
         await getDb().destroy();
       },
     };
-  }
+  },
 );