podverse-parser 5.0.0-beta.1 → 5.0.0-beta.3

package/dist/lib/rss/item/itemTxt.js

@@ -0,0 +1,21 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleParsedItemTxt = void 0;
+const podverse_orm_1 = require("podverse-orm");
+const item_1 = require("@parser/lib/compat/partytime/item");
+const handleParsedManyData_1 = require("../base/handleParsedManyData");
+const handleParsedItemTxt = (parsedItem, item, transactionalEntityManager) => __awaiter(void 0, void 0, void 0, function* () {
+    const itemTxtService = new podverse_orm_1.ItemTxtService(transactionalEntityManager);
+    const itemTxtDtos = (0, item_1.compatItemTxtDtos)(parsedItem);
+    yield (0, handleParsedManyData_1.handleParsedManyData)(item, itemTxtService, itemTxtDtos);
+});
+exports.handleParsedItemTxt = handleParsedItemTxt;

package/dist/lib/rss/item/itemValue.d.ts

@@ -0,0 +1,4 @@
+import { Episode } from "podcast-partytime";
+import { EntityManager, Item } from "podverse-orm";
+export declare const handleParsedItemValue: (parsedItem: Episode, item: Item, transactionalEntityManager: EntityManager) => Promise<void>;
+//# sourceMappingURL=itemValue.d.ts.map

package/dist/lib/rss/item/itemValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"itemValue.d.ts","sourceRoot":"","sources":["../../../../src/lib/rss/item/itemValue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,IAAI,EAE3B,MAAM,cAAc,CAAC;AAGtB,eAAO,MAAM,qBAAqB,eACpB,OAAO,QACb,IAAI,8BACkB,aAAa,kBAkD1C,CAAC"}

package/dist/lib/rss/item/itemValue.js

@@ -0,0 +1,65 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleParsedItemValue = void 0;
+const podverse_orm_1 = require("podverse-orm");
+const item_1 = require("@parser/lib/compat/partytime/item");
+const handleParsedItemValue = (parsedItem, item, transactionalEntityManager) => __awaiter(void 0, void 0, void 0, function* () {
+    const itemValueService = new podverse_orm_1.ItemValueService(transactionalEntityManager);
+    const itemValueDtos = (0, item_1.compatItemValueDtos)(parsedItem);
+    const itemValueRecipientService = new podverse_orm_1.ItemValueRecipientService(transactionalEntityManager);
+    const itemValueTimeSplitService = new podverse_orm_1.ItemValueTimeSplitService(transactionalEntityManager);
+    const itemValueTimeSplitRecipientService = new podverse_orm_1.ItemValueTimeSplitRecipientService(transactionalEntityManager);
+    const itemValueTimeSplitRemoteItemService = new podverse_orm_1.ItemValueTimeSplitRemoteItemService(transactionalEntityManager);
+    if (itemValueDtos.length > 0) {
+        for (const itemValueDto of itemValueDtos) {
+            const item_value = yield itemValueService.update(item, itemValueDto.item_value);
+            const itemValueRecipientDtos = itemValueDto.item_value_recipients;
+            if (itemValueRecipientDtos.length > 0) {
+                for (const itemValueRecipientDto of itemValueRecipientDtos) {
+                    yield itemValueRecipientService.update(item_value, itemValueRecipientDto);
+                }
+            }
+            else {
+                yield itemValueRecipientService.deleteAll(item_value);
+            }
+            const itemValueTimeSplitDtos = itemValueDto.item_value_time_splits;
+            if (itemValueTimeSplitDtos.length > 0) {
+                for (const itemValueTimeSplitDto of itemValueTimeSplitDtos) {
+                    const item_value_time_split = yield itemValueTimeSplitService.update(item_value, itemValueTimeSplitDto.meta);
+                    const itemValueTimeSplitRecipientDtos = itemValueTimeSplitDto.item_value_time_splits_recipients;
+                    if (itemValueTimeSplitRecipientDtos.length > 0) {
+                        for (const itemValueTimeSplitRecipientDto of itemValueTimeSplitRecipientDtos) {
+                            yield itemValueTimeSplitRecipientService.update(item_value_time_split, itemValueTimeSplitRecipientDto);
+                        }
+                    }
+                    else {
+                        yield itemValueTimeSplitRecipientService.deleteAll(item_value_time_split);
+                    }
+                    const itemValueTimeSplitRemoteItemDto = itemValueTimeSplitDto.item_value_time_splits_remote_item;
+                    if (itemValueTimeSplitRemoteItemDto) {
+                        yield itemValueTimeSplitRemoteItemService.update(item_value_time_split, itemValueTimeSplitRemoteItemDto);
+                    }
+                    else {
+                        yield itemValueTimeSplitRemoteItemService.deleteAll(item_value_time_split);
+                    }
+                }
+            }
+            else {
+                yield itemValueTimeSplitService.deleteAll(item_value);
+            }
+        }
+    }
+    else {
+        yield itemValueService.deleteAll(item);
+    }
+});
+exports.handleParsedItemValue = handleParsedItemValue;

package/dist/lib/rss/liveItem/liveItem.d.ts

@@ -0,0 +1,4 @@
+import { Phase4PodcastLiveItem } from "podcast-partytime/dist/parser/phase/phase-4";
+import { Channel, ChannelSeasonIndex } from "podverse-orm";
+export declare const handleParsedLiveItems: (parsedLiveItems: Phase4PodcastLiveItem[], channel: Channel, channelSeasonIndex: ChannelSeasonIndex) => Promise<void>;
+//# sourceMappingURL=liveItem.d.ts.map

package/dist/lib/rss/liveItem/liveItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"liveItem.d.ts","sourceRoot":"","sources":["../../../../src/lib/rss/liveItem/liveItem.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,MAAM,6CAA6C,CAAC;AACpF,OAAO,EAAiB,OAAO,EAAE,kBAAkB,EAAgC,MAAM,cAAc,CAAC;AAIxG,eAAO,MAAM,qBAAqB,oBAA2B,qBAAqB,EAAE,WAAW,OAAO,sBAAsB,kBAAkB,kBA2B7I,CAAC"}

package/dist/lib/rss/liveItem/liveItem.js

@@ -0,0 +1,41 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleParsedLiveItems = void 0;
+const podverse_helpers_1 = require("podverse-helpers");
+const podverse_orm_1 = require("podverse-orm");
+const liveItem_1 = require("@parser/lib/compat/partytime/liveItem");
+const item_1 = require("../item/item");
+const handleParsedLiveItems = (parsedLiveItems, channel, channelSeasonIndex) => __awaiter(void 0, void 0, void 0, function* () {
+    const itemService = new podverse_orm_1.ItemService();
+    const existingLiveItems = yield itemService.getAllItemsWithLiveItemByChannel(channel, { select: ['id'] });
+    const existingLiveItemIds = existingLiveItems.map(live_item => live_item.id);
+    const updatedLiveItemIds = [];
+    const liveItemObjDtos = (0, liveItem_1.compatLiveItemsDtos)(parsedLiveItems);
+    const liveItemObjDtosBatchs = (0, podverse_helpers_1.chunkArray)(liveItemObjDtos, 100);
+    for (const liveItemObjDtosBatch of liveItemObjDtosBatchs) {
+        yield podverse_orm_1.AppDataSource.manager.transaction((transactionalEntityManager) => __awaiter(void 0, void 0, void 0, function* () {
+            for (const liveItemObjDto of liveItemObjDtosBatch) {
+                // PTDO: how to make any unnecessary?
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const itemDto = liveItemObjDto.item;
+                const item = yield (0, item_1.handleParsedItem)(itemDto, channel, channelSeasonIndex, transactionalEntityManager);
+                updatedLiveItemIds.push(item.id);
+                const liveItemService = new podverse_orm_1.LiveItemService();
+                const liveItemDto = liveItemObjDto.liveItem;
+                yield liveItemService.update(item, liveItemDto);
+            }
+        }));
+    }
+    const itemIdsToDelete = existingLiveItemIds.filter(id => !updatedLiveItemIds.includes(id));
+    yield itemService.deleteMany(itemIdsToDelete);
+});
+exports.handleParsedLiveItems = handleParsedLiveItems;

package/dist/lib/rss/parser.d.ts

@@ -0,0 +1,4 @@
+export declare const parseAllRSSFeeds: () => Promise<any>;
+export declare const getAndParseRSSFeed: (url: string) => Promise<import("podcast-partytime").FeedObject>;
+export declare const parseRSSFeedAndSaveToDatabase: (url: string, podcast_index_id: number) => Promise<any>;
+//# sourceMappingURL=parser.d.ts.map

package/dist/lib/rss/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../src/lib/rss/parser.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,gBAAgB,oBAM5B,CAAC;AAEF,eAAO,MAAM,kBAAkB,QAAe,MAAM,oDASnD,CAAC;AAQF,eAAO,MAAM,6BAA6B,QAAe,MAAM,oBAAoB,MAAM,iBA4CxF,CAAC"}

package/dist/lib/rss/parser.js

@@ -0,0 +1,83 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRSSFeedAndSaveToDatabase = exports.getAndParseRSSFeed = exports.parseAllRSSFeeds = void 0;
+const podcast_partytime_1 = require("podcast-partytime");
+const podverse_helpers_1 = require("podverse-helpers");
+const podverse_orm_1 = require("podverse-orm");
+const channel_1 = require("@parser/lib/rss/channel/channel");
+const item_1 = require("./item/item");
+const channelSeason_1 = require("./channel/channelSeason");
+const liveItem_1 = require("./liveItem/liveItem");
+const feed_1 = require("./feed/feed");
+/*
+  NOTE: All RSS feeds that have a podcast_index_id will be saved to the database.
+  RSS feeds without podcast_index_id (Add By RSS feeds) will NOT be saved to the database.
+*/
+// TEMP: exists for development purposes
+const parseAllRSSFeeds = () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const feedService = new podverse_orm_1.FeedService();
+    const feeds = yield feedService.getAll();
+    for (const feed of feeds) {
+        return yield (0, exports.parseRSSFeedAndSaveToDatabase)(feed.url, (_a = feed === null || feed === void 0 ? void 0 : feed.channel) === null || _a === void 0 ? void 0 : _a.podcast_index_id);
+    }
+});
+exports.parseAllRSSFeeds = parseAllRSSFeeds;
+const getAndParseRSSFeed = (url) => __awaiter(void 0, void 0, void 0, function* () {
+    const xml = yield (0, podverse_helpers_1.request)(url);
+    const parsedFeed = (0, podcast_partytime_1.parseFeed)(xml, { allowMissingGuid: true });
+    if (!parsedFeed) {
+        throw new Error(`getAndParseRSSFeed: parsedFeed not found for ${url}`);
+    }
+    return parsedFeed;
+});
+exports.getAndParseRSSFeed = getAndParseRSSFeed;
+// export const parseRSSAddByRSSFeed = async (url: string) => {
+//   const parsedFeed = await getAndParseRSSFeed(url);
+//   const compatData = convertParsedRSSFeedToCompat(parsedFeed);
+//   return compatData;
+// };
+const parseRSSFeedAndSaveToDatabase = (url, podcast_index_id) => __awaiter(void 0, void 0, void 0, function* () {
+    const feedService = new podverse_orm_1.FeedService();
+    let feed = yield feedService.getBy({ url, podcast_index_id });
+    if (!feed) {
+        throw new Error(`parseRSSFeedAndSaveToDatabase: feed not found for ${url}`);
+    }
+    const parsedFeed = yield (0, feed_1.handleGetRSSFeed)(feed);
+    feed = yield (0, feed_1.handleParsedFeed)(parsedFeed, url, podcast_index_id);
+    try {
+        yield feedService.update(feed.id, { is_parsing: new Date() });
+        const channelService = new podverse_orm_1.ChannelService();
+        const channel = yield channelService.getOrCreateByPodcastIndexId({ feed, podcast_index_id });
+        // ChannelSeason must be parsed before anything else, because the channel season rows
+        // need to be created for other data to have a foreign key to them.
+        yield (0, channelSeason_1.handleParsedChannelSeasons)(parsedFeed, channel);
+        const channelSeasonService = new podverse_orm_1.ChannelSeasonService();
+        const channelSeasonIndex = yield channelSeasonService.getChannelSeasonIndex(channel);
+        yield (0, channel_1.handleParsedChannel)(parsedFeed, channel, channelSeasonIndex);
+        // PTDO: if publisher feed, handle publisher remote item data
+        // else handle parsed items
+        yield (0, item_1.handleParsedItems)(parsedFeed.items, channel, channelSeasonIndex);
+        if (parsedFeed.podcastLiveItems) {
+            yield (0, liveItem_1.handleParsedLiveItems)(parsedFeed.podcastLiveItems, channel, channelSeasonIndex);
+        }
+        // TODO: handle new item notifications
+        // TODO: handle new live_item notifications
+        const feedLogService = new podverse_orm_1.FeedLogService();
+        yield feedLogService.update(feed, { last_finished_parse_time: new Date() });
+    }
+    finally {
+        yield feedService.update(feed.id, { is_parsing: null });
+    }
+    return feed;
+});
+exports.parseRSSFeedAndSaveToDatabase = parseRSSFeedAndSaveToDatabase;

package/dist/module-alias-config.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=module-alias-config.d.ts.map

package/dist/module-alias-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-alias-config.d.ts","sourceRoot":"","sources":["../src/module-alias-config.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,CAAC"}

package/dist/module-alias-config.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const moduleAlias = require('module-alias');
+const path = require('path');
+moduleAlias.addAliases({
+    '@parser': path.join(__dirname, '')
+});

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "podverse-parser",
-  "version": "5.0.0-beta.1",
+  "version": "5.0.0-beta.3",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*"
+  ],
   "scripts": {
     "dev:watch": "nodemon --watch 'src' --watch $(realpath node_modules/podverse-external-services) --watch $(realpath node_modules/podverse-orm) --watch $(realpath node_modules/podverse-shared) -x \"npm run build\"",
     "build": "tsc",

package/.nvmrc

@@ -1 +0,0 @@
-v20.16.0

package/eslint.config.mjs

@@ -1,38 +0,0 @@
-import globals from "globals";
-import pluginJs from "@eslint/js";
-import tseslint from "@typescript-eslint/eslint-plugin";
-import tsParser from "@typescript-eslint/parser";
-
-const pluginJsRecommended = {
-  rules: {
-    ...pluginJs.configs.recommended.rules,
-  },
-};
-
-const tseslintRecommended = {
-  rules: {
-    ...tseslint.configs.recommended.rules,
-  },
-};
-
-export default [
-  {
-    files: ["src/**/*.{js,ts}"],
-    languageOptions: {
-      globals: globals.node,
-      parser: tsParser,
-    },
-    plugins: {
-      "@typescript-eslint": tseslint,
-    },
-    rules: {
-      ...pluginJsRecommended.rules,
-      ...tseslintRecommended.rules,
-      "semi": ["error", "always"],
-      "indent": ["error", 2],
-      "@typescript-eslint/no-require-imports": "off",
-    },
-    ignores: ["**/eslint.config.mjs"],
-  }
-];
-

package/src/lib/chapters/chapters.ts

@@ -1,54 +0,0 @@
-import { request, throwRequestError } from "podverse-helpers";
-import { Item, ItemChaptersFeed, ItemChapterService, ItemChaptersFeedLogService } from "podverse-orm";
-import { compatParsedChapters, PIChapter } from "@parser/lib/compat/chapters/chapters";
-
-const getParsedChapters = async (item_chapters_feed: ItemChaptersFeed) => {
-  const itemChaptersFeedLogService = new ItemChaptersFeedLogService();
-  try {
-    const response: { chapters: PIChapter[] } = await request(item_chapters_feed.url);
-    await itemChaptersFeedLogService.update(item_chapters_feed, {
-      last_http_status: 200,
-      last_good_http_status_time: new Date()
-    });
-    return compatParsedChapters(response.chapters);
-  } catch (error) {
-    // TODO: how to handle errors?
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const statusCode = (error as any).statusCode as number;
-    const item_chapters_feed_log = await itemChaptersFeedLogService.get(item_chapters_feed);
-    if (statusCode) {
-      await itemChaptersFeedLogService.update(item_chapters_feed, {
-        last_http_status: statusCode,
-        parse_errors: (item_chapters_feed_log?.parse_errors || 0) + 1,
-      });
-    }
-    return throwRequestError(error);
-  }
-};
-
-export const parseChapters = async (item: Item): Promise<void> => {
-  const item_chapters_feed = item.item_chapters_feed;
-
-  if (!item_chapters_feed) {
-    return;
-  }
-
-  const parsedChapters = await getParsedChapters(item_chapters_feed);
-  
-  const itemChapterService = new ItemChapterService();
-
-  const existingChapters = await itemChapterService.getAll(item_chapters_feed, { select: ['id'] });
-  const existingChaptersIds = existingChapters.map(item_chapter => item_chapter.id);
-  const updatedChaptersIds: number[] = [];
-
-  for (const parsedChapter of parsedChapters) {
-    await itemChapterService.update(item_chapters_feed, parsedChapter);
-    updatedChaptersIds.push(item_chapters_feed.id);
-  }
-
-  const itemChapterIdsToDelete = existingChaptersIds.filter(id => !updatedChaptersIds.includes(id));
-  await itemChapterService.deleteMany(itemChapterIdsToDelete);
-
-  const itemChaptersFeedLogService = new ItemChaptersFeedLogService();
-  await itemChaptersFeedLogService.update(item_chapters_feed, { last_finished_parse_time: new Date() });
-};

package/src/lib/compat/channel.ts

@@ -1,287 +0,0 @@
-import { FeedObject, Phase4Medium } from "podcast-partytime";
-import { Phase4PodcastImage } from "podcast-partytime/dist/parser/phase/phase-4";
-import { createSortableTitle, getBooleanOrNull } from "podverse-helpers";
-import { getChannelItunesTypeItunesTypeEnumValue, getMediumEnumValue } from "podverse-orm";
-import { compatChannelValue } from "@parser/lib/compat/partytime/value";
-
-export const compatChannelDto = (parsedFeed: FeedObject) => ({
-  podcast_guid: parsedFeed.guid,
-  title: parsedFeed.title,
-  sortable_title: createSortableTitle(parsedFeed.title),
-  medium: getMediumEnumValue(parsedFeed.medium ?? Phase4Medium.Podcast)
-});
-
-export const compatChannelAboutDto = (parsedFeed: FeedObject) => ({
-  author: (Array.isArray(parsedFeed.author) ? parsedFeed.author : parsedFeed.author ? [parsedFeed.author] : [])?.join(', ') || null,
-  explicit: getBooleanOrNull(parsedFeed.explicit),
-  language: parsedFeed.language || null,
-  website_link_url: parsedFeed.link || null,
-  itunes_type: getChannelItunesTypeItunesTypeEnumValue(parsedFeed.itunesType || 'episodic')
-});
-
-export const compatChannelChatDto = (parsedFeed: FeedObject) => {
-  if (!parsedFeed.chat) {
-    return null;
-  }
-  return {
-    server: parsedFeed.chat.server,
-    protocol: parsedFeed.chat.protocol,
-    account_id: parsedFeed.chat.accountId || null,
-    space: parsedFeed.chat.space || null
-  };
-};
-
-export const compatChannelDescriptionDto = (parsedFeed: FeedObject) => {
-  if (!parsedFeed.description) {
-    return null;
-  }
-  return {
-    value: parsedFeed.description
-  };
-};
-
-export const compatChannelFundingDtos = (parsedFeed: FeedObject) => {
-  const dtos = [];
-
-  if (Array.isArray(parsedFeed.podcastFunding)) {
-    for (const f of parsedFeed.podcastFunding) {
-      if (f.url) {
-        dtos.push({
-          url: f.url,
-          title: f.message || null
-        });
-      }
-    }
-  }
-
-  return dtos;
-};
-
-export const compatChannelImageDtos = (parsedFeed: FeedObject) => {
-  const dtos = [];
-  if (parsedFeed.itunesImage) {
-    dtos.push({
-      url: parsedFeed.itunesImage,
-      image_width_size: null
-    });
-  } else if (parsedFeed.image?.url) {
-    dtos.push({
-      url: parsedFeed.image.url,
-      image_width_size: null
-    });
-  }
-
-  function hasWidth(image: Phase4PodcastImage['parsed']): image is { url: string; width: number } {
-    return (image as { width: number }).width !== undefined;
-  }
-
-  if (Array.isArray(parsedFeed.podcastImages)) {
-    for (const image of parsedFeed.podcastImages) {
-      if (image.parsed.url && hasWidth(image.parsed)) {
-        dtos.push({
-          url: image.parsed.url,
-          image_width_size: image.parsed.width
-        });
-      }
-    }
-  }
-
-  return dtos;
-};
-
-export const compatChannelLicenseDto = (parsedFeed: FeedObject) => {
-  if (!parsedFeed?.license?.identifier) {
-    return null;
-  }
-  return {
-    identifier: parsedFeed.license.identifier,
-    url: parsedFeed.license.url || null
-  };
-};
-
-export const compatChannelLocationDto = (parsedFeed: FeedObject) => {
-  if (!parsedFeed?.podcastLocation?.geo && !parsedFeed?.podcastLocation?.osm) {
-    return null;
-  }
-
-  return {
-    geo: parsedFeed.podcastLocation.geo || null,
-    osm: parsedFeed.podcastLocation.osm || null,
-    name: parsedFeed.podcastLocation.name || null
-  };
-};
-
-export const compatChannelPersonDtos = (parsedFeed: FeedObject) => {
-  const dtos = [];
-
-  if (Array.isArray(parsedFeed.podcastPeople)) {
-    for (const p of parsedFeed.podcastPeople) {
-      if (p.name) {
-        dtos.push({
-          name: p.name,
-          role: p.role?.toLowerCase() || null,
-          person_group: p.group?.toLowerCase() || 'cast',
-          img: p.img || null,
-          href: p.href || null
-        });
-      }
-    }
-  }
-
-  return dtos;
-};
-
-export const compatChannelPodrollRemoteItemDtos = (parsedFeed: FeedObject) => {
-  const dtos = [];
-
-  if (Array.isArray(parsedFeed.podroll)) {
-    for (const ri of parsedFeed.podroll) {
-      if (ri.feedGuid) {
-        dtos.push({
-          feed_guid: ri.feedGuid,
-          feed_url: ri.feedUrl || null,
-          item_guid: null,
-          title: /* PTDO: ri.title || */ null
-        });
-      }
-    }
-  }
-
-  return dtos;
-};
-
-export const compatChannelPublisherRemoteItemDtos = (parsedFeed: FeedObject) => {
-  const dtos = [];
-
-  if (Array.isArray(parsedFeed.podroll)) {
-    for (const ri of parsedFeed.podroll) {
-      if (ri.feedGuid) {
-        dtos.push({
-          feed_guid: ri.feedGuid,
-          feed_url: ri.feedUrl || null,
-          item_guid: null,
-          title: /* PTDO: ri.title || */ null
-        });
-      }
-    }
-  }
-
-  return dtos;
-};
-
-export const compatChannelRemoteItemDtos = (parsedFeed: FeedObject) => {
-  const dtos = [];
-
-  if (Array.isArray(parsedFeed.podcastRemoteItems)) {
-    for (const ri of parsedFeed.podcastRemoteItems) {
-      if (ri.feedGuid) {
-        dtos.push({
-          feed_guid: ri.feedGuid,
-          feed_url: ri.feedUrl || null,
-          item_guid: null,
-          title: /* PTDO: ri.title || */ null
-        });
-      }
-    }
-  }
-
-  return dtos;
-};
-
-export const compatChannelSocialInteractDtos = (parsedFeed: FeedObject) => {
-  const dtos = [];
-
-  if (parsedFeed?.podcastSocial?.length) {
-    for (const ps of parsedFeed.podcastSocial) {
-      dtos.push({
-        // PTDO: fix keys mismatch between partytime and podverse
-        protocol: ps.platform,
-        uri: ps.url,
-        account_id: ps.id || null,
-        account_url: ps.name || null,
-        priority: ps.priority || null
-      });
-    }
-  }
-
-  return dtos;
-};
-
-export const compatChannelSeasonDtos = (parsedFeed: FeedObject) => {
-  const dtos = [];
-
-  const parsedItems = parsedFeed?.items || [];
-
-  const seasonsIndex: { [key: number]: { name: string | null } } = {};
-
-  for (const parsedItem of parsedItems) {
-    const seasonNumber = parsedItem?.podcastSeason?.number || parsedItem?.itunesSeason;
-    const seasonName = parsedItem?.podcastSeason?.name || null;
-    if (Number.isInteger(seasonNumber)) {
-      const seasonNumberAsNumber = seasonNumber as number;
-      seasonsIndex[seasonNumberAsNumber] = {
-        name: seasonName
-      };
-    }
-  }
-
-  for (const [number, { name }] of Object.entries(seasonsIndex)) {
-    dtos.push({
-      number: parseInt(number),
-      name: name || null
-    });
-  }
-
-  return dtos;
-};
-
-export const compatChannelTrailerDtos = (parsedFeed: FeedObject) => {
-  const dtos = [];
-  if (parsedFeed?.trailers?.length) {
-    for (const pt of parsedFeed.trailers) {
-      dtos.push({
-        url: pt.url,
-        title: /* PTDO: add pt.title || */ null,
-        pubdate: pt.pubdate,
-        length: pt.length || null,
-        type: pt.type || null,
-        season: pt.season || null
-      });
-    }
-  }
-
-  return dtos;
-};
-
-export const compatChannelTxtDtos = (parsedFeed: FeedObject) => {
-  const dtos = [];
-  if (parsedFeed?.podcastTxt?.length) {
-    for (const pt of parsedFeed.podcastTxt) {
-      dtos.push({
-        purpose: pt.purpose || null,
-        value: pt.value
-      });
-    }
-  }
-
-  return dtos;
-};
-
-export const compatChannelValueDtos = (parsedFeed: FeedObject) => {
-  let dtos = [];
-  if (parsedFeed.value) {
-    const dto = compatChannelValue(parsedFeed.value);
-
-    const formattedDto = {
-      channel_value: {
-        type: dto.type,
-        method: dto.method,
-        suggested: dto.suggested || null
-      },
-      channel_value_recipients: dto.channel_value_recipients
-    };
-
-    dtos.push(formattedDto);
-  }
-  return dtos;
-};