podverse-parser 1.0.0 → 5.0.0-beta.2

package/src/lib/compat/partytime/item.ts

@@ -0,0 +1,273 @@
+import type { Episode } from 'podcast-partytime';
+import { Phase4PodcastImage } from 'podcast-partytime/dist/parser/phase/phase-4';
+import { getItemItunesEpisodeTypeEnumValue } from 'podverse-orm';
+import { compatItemValue } from './value';
+
+export const compatItemDto = (parsedItem: Episode) => ({
+  guid: parsedItem.guid || null,
+  guid_enclosure_url: parsedItem.enclosure.url,
+  pubdate: parsedItem.pubDate || null,
+  title: parsedItem.title || null
+});
+
+export const compatItemAboutDto = (parsedItem: Episode) => ({
+  duration: parsedItem.duration?.toFixed(2) || null,
+  explicit: parsedItem.explicit || false,
+  website_link_url: parsedItem.link || null,
+  item_itunes_episode_type: getItemItunesEpisodeTypeEnumValue(parsedItem.itunesEpisodeType || 'full')
+});
+
+export const compatItemChaptersFeedDto = (parsedItem: Episode) => {
+  if (!parsedItem.podcastChapters?.url && !parsedItem.podcastChapters?.type) return null;
+  
+  return {
+    url: parsedItem.podcastChapters?.url,
+    type: parsedItem.podcastChapters?.type
+  };
+};
+
+export const compatItemChatDto = (parsedItem: Episode) => {
+  if (!parsedItem.chat) {
+    return null;
+  }
+  return {
+    server: parsedItem.chat.server,
+    protocol: parsedItem.chat.protocol,
+    account_id: parsedItem.chat.accountId || null,
+    space: parsedItem.chat.space || null
+  };
+};
+
+export const compatItemDescriptionDto = (parsedItem: Episode) => {
+  if (!parsedItem.description) {
+    return null;
+  }
+  return {
+    value: parsedItem.description
+  };
+};
+
+export const compatItemEnclosureDtos = (parsedItem: Episode) => {
+  const dtos = [];
+
+  if (parsedItem.alternativeEnclosures && parsedItem.alternativeEnclosures.length > 0) {
+    for (const alternativeEnclosure of parsedItem.alternativeEnclosures) {
+      const item_enclosure = {
+        type: alternativeEnclosure.type,
+        length: alternativeEnclosure.length || null,
+        bitrate: alternativeEnclosure.bitrate || null,
+        height: alternativeEnclosure.height || null,
+        language: alternativeEnclosure.lang || null,
+        title: alternativeEnclosure.title || null,
+        rel: alternativeEnclosure.rel || null,
+        codecs: alternativeEnclosure.codecs || null,
+        item_enclosure_default: false
+      };
+
+      /*
+        PTDO: why am I getting this error when I don't use any?
+        src/lib/compat/partytime/item.ts:50:14 - error TS4023: Exported variable
+        'compatItemEnclosureDtos' has or is using name 'IntegrityType' from external module
+        "/podverse-parser/node_modules/podcast-partytime/dist/parser/phase/phase-3" but cannot be named.
+      */
+      const item_enclosure_integrity = (alternativeEnclosure.integrity as any) || null;
+
+      const item_enclosure_sources = alternativeEnclosure.source.map(source => ({
+        uri: source.uri,
+        content_type: source.contentType
+      }));
+
+      const formattedDto = {
+        item_enclosure,
+        item_enclosure_integrity,
+        item_enclosure_sources
+      };
+
+      dtos.push(formattedDto);
+    }
+  }
+  
+  return dtos;
+};
+
+export const compatItemImageDtos = (parsedItem: Episode) => {
+  const dtos = [];
+  if (parsedItem.itunesImage) {
+    dtos.push({
+      url: parsedItem.itunesImage,
+      image_width_size: null
+    });
+  } else if (parsedItem.image) {
+    dtos.push({
+      url: parsedItem.image,
+      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(parsedItem.podcastImages)) {
+    for (const image of parsedItem.podcastImages) {
+      if (image.parsed.url && hasWidth(image.parsed)) {
+        dtos.push({
+          url: image.parsed.url,
+          image_width_size: image.parsed.width
+        });
+      }
+    }
+  }
+
+  return dtos;
+};
+
+export const compatItemLicenseDto = (parsedItem: Episode) => {
+  if (!parsedItem?.license?.identifier) {
+    return null;
+  }
+  return {
+    identifier: parsedItem.license.identifier,
+    url: parsedItem.license.url || null
+  };
+};
+
+export const compatItemLocationDto = (parsedItem: Episode) => {
+  if (!parsedItem?.podcastLocation?.geo && !parsedItem?.podcastLocation?.osm) {
+    return null;
+  }
+
+  return {
+    geo: parsedItem.podcastLocation.geo || null,
+    osm: parsedItem.podcastLocation.osm || null,
+    name: parsedItem.podcastLocation.name || null
+  };
+};
+
+export const compatItemPersonDtos = (parsedItem: Episode) => {
+  const dtos = [];
+
+  if (Array.isArray(parsedItem.podcastPeople)) {
+    for (const p of parsedItem.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 compatItemSeasonDto = (parsedItem: Episode) => {
+  if (!parsedItem.podcastSeason?.number) {
+    return null;
+  }
+
+  return {
+    number: parsedItem.podcastSeason.number,
+    title: parsedItem.podcastSeason.name || null
+  };
+};
+
+export const compatItemSeasonEpisodeDto = (parsedItem: Episode) => {
+  if (!parsedItem.podcastEpisode) {
+    return null;
+  }
+
+  return {
+    display: parsedItem.podcastEpisode.display || null,
+    number: parsedItem.podcastEpisode.number
+  };
+};
+
+export const compatItemSocialInteractDtos = (parsedItem: Episode) => {
+  const dtos = [];
+
+  if (parsedItem?.podcastSocialInteraction?.length) {
+    for (const ps of parsedItem.podcastSocialInteraction) {
+      dtos.push({
+        // PTDO: fix keys mismatch between partytime and podverse
+        protocol: ps.platform,
+        uri: ps.url,
+        account_id: ps.id || null,
+        account_url: ps.profileUrl || null,
+        priority: ps.priority || null
+      });
+    }
+  }
+
+  return dtos;
+};
+
+export const compatItemSoundbiteDtos = (parsedItem: Episode) => {
+  const dtos = [];
+
+  if (parsedItem?.podcastSoundbites?.length) {
+    for (const s of parsedItem.podcastSoundbites) {
+      dtos.push({
+        start_time: s.startTime.toFixed(2),
+        duration: s.duration.toFixed(2),
+        title: s.title || null
+      });
+    }
+  }
+
+  return dtos;
+};
+
+export const compatItemTranscriptDtos = (parsedItem: Episode) => {
+  const dtos = [];
+
+  if (parsedItem?.podcastTranscripts?.length) {
+    for (const t of parsedItem.podcastTranscripts) {
+      dtos.push({
+        url: t.url,
+        type: t.type,
+        language: t.language || null,
+        rel: t.rel || null
+      });
+    }
+  }
+
+  return dtos;
+};
+
+export const compatItemTxtDtos = (parsedItem: Episode) => {
+  const dtos = [];
+
+  if (parsedItem?.podcastTxt?.length) {
+    for (const txt of parsedItem.podcastTxt) {
+      dtos.push({
+        purpose: txt.purpose || null,
+        value: txt.value
+      });
+    }
+  }
+
+  return dtos;
+};
+
+export const compatItemValueDtos = (parsedItem: Episode) => {
+  let dtos = [];
+  if (parsedItem.value) {
+    const dto = compatItemValue(parsedItem.value);
+    const formattedDto = {
+      item_value: {
+        type: dto.type,
+        method: dto.method,
+        suggested: dto.suggested || null
+      },
+      item_value_recipients: dto.item_value_recipients,
+      item_value_time_splits: dto.item_value_time_splits
+    };
+
+    dtos.push(formattedDto);
+  }
+  return dtos;
+};

package/src/lib/compat/partytime/liveItem.ts

@@ -0,0 +1,18 @@
+import { Phase4PodcastLiveItem } from "podcast-partytime/dist/parser/phase/phase-4";
+import { getLiveItemStatusEnumValue, LiveItemStatusEnum } from "podverse-orm";
+
+export const compatLiveItemsDtos = (parsedLiveItems: Phase4PodcastLiveItem[]) => {
+  const dtos = [];
+  for (const parsedLiveItem of parsedLiveItems) {    
+    dtos.push({
+      liveItem: {
+        live_item_status: getLiveItemStatusEnumValue(parsedLiveItem.status) ?? LiveItemStatusEnum.Pending,
+        start_time: parsedLiveItem.start,
+        end_time: parsedLiveItem.end || null
+      },
+      item: parsedLiveItem
+    });
+  }
+
+  return dtos;
+};

package/src/lib/compat/partytime/value.ts

@@ -0,0 +1,64 @@
+import { Phase4Value, Phase4ValueRecipient } from "podcast-partytime";
+
+export const compatChannelValue = (value: Phase4Value) => {
+  return {
+    type: value.type,
+    method: value.method,
+    suggested: parseFloat(value.suggested ?? '0') || null,
+    channel_value_recipients: compatValueRecipients(value.recipients)
+  };
+};
+
+export const compatItemValue = (value: Phase4Value) => {
+  return {
+    type: value.type,
+    method: value.method,
+    suggested: parseFloat(value.suggested ?? '0') || null,
+    item_value_recipients: compatValueRecipients(value.recipients),
+    item_value_time_splits: value.valueTimeSplits?.map((valueTimeSplit) => {
+      if (valueTimeSplit.type === 'remoteItem') {
+        return {
+          meta: {
+            start_time: valueTimeSplit.startTime.toFixed(2),
+            duration: valueTimeSplit.duration.toFixed(2),
+            remote_start_time: valueTimeSplit.remoteStartTime?.toFixed(2) || (0).toFixed(2),
+            remote_percentage: valueTimeSplit.remotePercentage?.toFixed(2) || (100).toFixed(2),
+          },
+          item_value_time_splits_recipients: [],
+          item_value_time_splits_remote_item: valueTimeSplit.remoteItem ? {
+            feed_guid: valueTimeSplit.remoteItem.feedGuid,
+            feed_url: valueTimeSplit.remoteItem.feedUrl || null,
+            item_guid: valueTimeSplit.remoteItem.itemGuid || null,
+            title: /* PTDO: ri.title || */ null
+          } : null
+        };
+      } else {
+        // else: valueTimeSplit.type === 'recipients'
+        return {
+          meta: {
+            start_time: valueTimeSplit.startTime.toFixed(2),
+            duration: valueTimeSplit.duration.toFixed(2),
+            remote_start_time: (0).toFixed(2),
+            remote_percentage: (100).toFixed(2),
+          },
+          item_value_time_splits_recipients: compatValueRecipients(valueTimeSplit.recipients),
+          item_value_time_splits_remote_item: null
+        };
+      }
+    }) || []
+  };
+};
+
+const compatValueRecipients = (recipients: Phase4ValueRecipient[]) => {
+  return recipients.map((recipient) => {
+    return {
+      type: recipient.type,
+      address: recipient.address,
+      split: recipient.split,
+      name: recipient.name || null,
+      custom_key: recipient.customKey || null,
+      custom_value: recipient.customValue || null,
+      fee: recipient.fee || false
+    };
+  }) || [];
+};

package/src/lib/rss/base/handleParsedManyData.ts

@@ -0,0 +1,16 @@
+interface Service<T, P> {
+  updateMany(parentEntity: P, dtos: Partial<T>[]): Promise<T[]>;
+  deleteAll(parentEntity: P): Promise<void>;
+}
+
+export const handleParsedManyData = async<T, P> (
+  parentEntity: P,
+  service: Service<T, P>,
+  dtos: Partial<T>[]
+) => {
+  if (dtos.length > 0) {
+    await service.updateMany(parentEntity, dtos);
+  } else {
+    await service.deleteAll(parentEntity);
+  }
+};

package/src/lib/rss/base/handleParsedOneData.ts

@@ -0,0 +1,17 @@
+interface Service<T, P> {
+  update(parentEntity: P, dto: Partial<T>): Promise<T>;
+  _delete?(parentEntity: P): Promise<void>;
+}
+
+export const handleParsedOneData = async <T, P>(
+  parentEntity: P,
+  service: Service<T, P>,
+  dto: Partial<T> | null
+) => {
+  if (dto) {
+    await service.update(parentEntity, dto);
+  } else if (service._delete) {
+    await service._delete(parentEntity);
+  }
+};
+

package/src/lib/rss/channel/channel.ts

@@ -0,0 +1,55 @@
+import { FeedObject } from "podcast-partytime";
+import { AppDataSource, Channel, ChannelService, ChannelSeasonIndex } from "podverse-orm";
+import { compatChannelDto } from "@parser/lib/compat/partytime/channel";
+import { handleParsedChannelAbout } from "@parser/lib/rss/channel/channelAbout";
+import { handleParsedChannelChat } from "@parser/lib/rss/channel/channelChat";
+import { handleParsedChannelDescription } from "@parser/lib/rss/channel/channelDescription";
+import { handleParsedChannelFunding } from "@parser/lib/rss/channel/channelFunding";
+import { handleParsedChannelImage } from "@parser/lib/rss/channel/channelImage";
+import { handleParsedChannelLicense } from "@parser/lib/rss/channel/channelLicense";
+import { handleParsedChannelLocation } from "@parser/lib/rss/channel/channelLocation";
+import { handleParsedChannelPerson } from "@parser/lib/rss/channel/channelPerson";
+import { handleParsedChannelPodroll } from "@parser/lib/rss/channel/channelPodroll";
+import { handleParsedChannelRemoteItem } from "@parser/lib/rss/channel/channelRemoteItem";
+import { handleParsedChannelSocialInteract } from "@parser/lib/rss/channel/channelSocialInteract";
+import { handleParsedChannelTrailer } from "@parser/lib/rss/channel/channelTrailer";
+import { handleParsedChannelTxt } from "@parser/lib/rss/channel/channelTxt";
+import { handleParsedChannelValue } from "@parser/lib/rss/channel/channelValue";
+
+export const handleParsedChannel = async (parsedFeed: FeedObject, channel: Channel, channelSeasonIndex: ChannelSeasonIndex) => {
+  const channelService = new ChannelService();
+  const channelDto = compatChannelDto(parsedFeed);
+  await channelService.update(channel.id, channelDto);
+  
+  // TODO: add channelCategory support
+  
+  await AppDataSource.manager.transaction(async transactionalEntityManager => {
+    await handleParsedChannelAbout(parsedFeed, channel, transactionalEntityManager);
+    await handleParsedChannelChat(parsedFeed, channel, transactionalEntityManager);
+    await handleParsedChannelDescription(parsedFeed, channel, transactionalEntityManager);
+    await handleParsedChannelFunding(parsedFeed, channel, transactionalEntityManager);
+    await handleParsedChannelImage(parsedFeed, channel, transactionalEntityManager);
+    await handleParsedChannelLicense(parsedFeed, channel, transactionalEntityManager);
+    await handleParsedChannelLocation(parsedFeed, channel, transactionalEntityManager);
+    await handleParsedChannelPerson(parsedFeed, channel, transactionalEntityManager);
+    await handleParsedChannelPodroll(parsedFeed, channel, transactionalEntityManager);
+  
+    // PTDO: add channelPublisher support
+    // const channelPublisherService = new ChannelPublisherService();
+    // const channelPublisherRemoteItemService = new ChannelPublisherRemoteItemService();
+  
+    // const channelPublisherRemoteItemDtos = compatChannelPublisherRemoteItemDtos(parsedFeed);
+    // if (channelPublisherRemoteItemDtos.length > 0) {
+    //   const channel_publisher = await channelPublisherService.update(channel);
+    //   await channelPublisherRemoteItemService.updateMany(channel_publisher, channelPodrollRemoteItemDtos);
+    // } else {
+    //   await channelPublisherService.delete(channel);
+    // }
+  
+    await handleParsedChannelRemoteItem(parsedFeed, channel, transactionalEntityManager);
+    await handleParsedChannelSocialInteract(parsedFeed, channel, transactionalEntityManager);
+    await handleParsedChannelTrailer(parsedFeed, channel, channelSeasonIndex, transactionalEntityManager);
+    await handleParsedChannelTxt(parsedFeed, channel, transactionalEntityManager);
+    await handleParsedChannelValue(parsedFeed, channel, transactionalEntityManager);
+  });
+};

package/src/lib/rss/channel/channelAbout.ts

@@ -0,0 +1,13 @@
+import { FeedObject } from "podcast-partytime";
+import { ChannelAboutService, Channel, EntityManager } from "podverse-orm";
+import { compatChannelAboutDto } from "@parser/lib/compat/partytime/channel";
+
+export const handleParsedChannelAbout = async (
+  parsedFeed: FeedObject,
+  channel: Channel,
+  transactionalEntityManager: EntityManager
+) => {
+  const channelAboutService = new ChannelAboutService(transactionalEntityManager);
+  const channelAboutDto = compatChannelAboutDto(parsedFeed);
+  await channelAboutService.update(channel, channelAboutDto);
+};

package/src/lib/rss/channel/channelChat.ts

@@ -0,0 +1,14 @@
+import { FeedObject } from "podcast-partytime";
+import { Channel, ChannelChatService, EntityManager } from "podverse-orm";
+import { compatChannelChatDto } from "@parser/lib/compat/partytime/channel";
+import { handleParsedOneData } from "../base/handleParsedOneData";
+
+export const handleParsedChannelChat = async (
+  parsedFeed: FeedObject,
+  channel: Channel,
+  transactionalEntityManager: EntityManager
+) => {
+  const channelChatService = new ChannelChatService(transactionalEntityManager);
+  const channelChatDto = compatChannelChatDto(parsedFeed);
+  await handleParsedOneData(channel, channelChatService, channelChatDto);
+};

package/src/lib/rss/channel/channelDescription.ts

@@ -0,0 +1,14 @@
+import { FeedObject } from "podcast-partytime";
+import { Channel, ChannelDescriptionService, EntityManager } from "podverse-orm";
+import { compatChannelDescriptionDto } from "@parser/lib/compat/partytime/channel";
+import { handleParsedOneData } from "../base/handleParsedOneData";
+
+export const handleParsedChannelDescription = async (
+  parsedFeed: FeedObject,
+  channel: Channel,
+  transactionalEntityManager: EntityManager
+) => {
+  const channelDescriptionService = new ChannelDescriptionService(transactionalEntityManager);
+  const channelDescriptionDto = compatChannelDescriptionDto(parsedFeed);
+  await handleParsedOneData(channel, channelDescriptionService, channelDescriptionDto);
+};

package/src/lib/rss/channel/channelFunding.ts

@@ -0,0 +1,14 @@
+import { FeedObject } from "podcast-partytime";
+import { Channel, ChannelFundingService, EntityManager } from "podverse-orm";
+import { compatChannelFundingDtos } from "@parser/lib/compat/partytime/channel";
+import { handleParsedManyData } from "../base/handleParsedManyData";
+
+export const handleParsedChannelFunding = async (
+  parsedFeed: FeedObject,
+  channel: Channel,
+  transactionalEntityManager: EntityManager
+) => {
+  const channelFundingService = new ChannelFundingService(transactionalEntityManager);
+  const channelFundingDtos = compatChannelFundingDtos(parsedFeed);
+  await handleParsedManyData(channel, channelFundingService, channelFundingDtos);
+};

package/src/lib/rss/channel/channelImage.ts

@@ -0,0 +1,14 @@
+import { FeedObject } from "podcast-partytime";
+import { Channel, ChannelImageService, EntityManager } from "podverse-orm";
+import { compatChannelImageDtos } from "@parser/lib/compat/partytime/channel";
+import { handleParsedManyData } from "../base/handleParsedManyData";
+
+export const handleParsedChannelImage = async (
+  parsedFeed: FeedObject,
+  channel: Channel,
+  transactionalEntityManager: EntityManager
+) => {
+  const channelImageService = new ChannelImageService(transactionalEntityManager);
+  const channelImageDtos = compatChannelImageDtos(parsedFeed);
+  await handleParsedManyData(channel, channelImageService, channelImageDtos);
+};

package/src/lib/rss/channel/channelLicense.ts

@@ -0,0 +1,14 @@
+import { FeedObject } from "podcast-partytime";
+import { Channel, ChannelLicenseService, EntityManager } from "podverse-orm";
+import { compatChannelLicenseDto } from "@parser/lib/compat/partytime/channel";
+import { handleParsedOneData } from "../base/handleParsedOneData";
+
+export const handleParsedChannelLicense = async (
+  parsedFeed: FeedObject,
+  channel: Channel,
+  transactionalEntityManager: EntityManager
+) => {
+  const channelLicenseService = new ChannelLicenseService(transactionalEntityManager);
+  const channelLicenseDtos = compatChannelLicenseDto(parsedFeed);
+  await handleParsedOneData(channel, channelLicenseService, channelLicenseDtos);
+};

package/src/lib/rss/channel/channelLocation.ts

@@ -0,0 +1,14 @@
+import { FeedObject } from "podcast-partytime";
+import { Channel, ChannelLocationService, EntityManager } from "podverse-orm";
+import { compatChannelLocationDto } from "@parser/lib/compat/partytime/channel";
+import { handleParsedOneData } from "../base/handleParsedOneData";
+
+export const handleParsedChannelLocation = async (
+  parsedFeed: FeedObject,
+  channel: Channel,
+  transactionalEntityManager: EntityManager
+) => {
+  const channelLocationService = new ChannelLocationService(transactionalEntityManager);
+  const channelLocationDtos = compatChannelLocationDto(parsedFeed);
+  await handleParsedOneData(channel, channelLocationService, channelLocationDtos);
+};

package/src/lib/rss/channel/channelPerson.ts

@@ -0,0 +1,14 @@
+import { FeedObject } from "podcast-partytime";
+import { Channel, ChannelPersonService, EntityManager } from "podverse-orm";
+import { compatChannelPersonDtos } from "@parser/lib/compat/partytime/channel";
+import { handleParsedManyData } from "../base/handleParsedManyData";
+
+export const handleParsedChannelPerson = async (
+  parsedFeed: FeedObject,
+  channel: Channel,
+  transactionalEntityManager: EntityManager
+) => {
+  const channelPersonService = new ChannelPersonService(transactionalEntityManager);
+  const channelPersonDtos = compatChannelPersonDtos(parsedFeed);
+  await handleParsedManyData(channel, channelPersonService, channelPersonDtos);
+};

package/src/lib/rss/channel/channelPodroll.ts

@@ -0,0 +1,21 @@
+import { FeedObject } from "podcast-partytime";
+import { Channel, ChannelPodrollService, ChannelPodrollRemoteItemService, EntityManager } from "podverse-orm";
+import { compatChannelPodrollRemoteItemDtos } from "@parser/lib/compat/partytime/channel";
+
+export const handleParsedChannelPodroll = async (
+  parsedFeed: FeedObject,
+  channel: Channel,
+  transactionalEntityManager: EntityManager
+) => {
+  const channelPodrollService = new ChannelPodrollService(transactionalEntityManager);
+  const channelPodrollDto = {};
+  const channelPodrollRemoteItemService = new ChannelPodrollRemoteItemService(transactionalEntityManager);
+  const channelPodrollRemoteItemDtos = compatChannelPodrollRemoteItemDtos(parsedFeed);
+  
+  if (channelPodrollRemoteItemDtos.length > 0) {
+    const channel_podroll = await channelPodrollService.update(channel, channelPodrollDto);
+    await channelPodrollRemoteItemService.updateMany(channel_podroll, channelPodrollRemoteItemDtos);
+  } else {
+    await channelPodrollService.delete(channel);
+  }
+};

package/src/lib/rss/channel/channelRemoteItem.ts

@@ -0,0 +1,14 @@
+import { FeedObject } from "podcast-partytime";
+import { Channel, ChannelRemoteItemService, EntityManager } from "podverse-orm";
+import { compatChannelRemoteItemDtos } from "@parser/lib/compat/partytime/channel";
+import { handleParsedManyData } from "../base/handleParsedManyData";
+
+export const handleParsedChannelRemoteItem = async (
+  parsedFeed: FeedObject,
+  channel: Channel,
+  transactionalEntityManager: EntityManager
+) => {
+  const channelRemoteItemService = new ChannelRemoteItemService(transactionalEntityManager);
+  const channelRemoteItemDtos = compatChannelRemoteItemDtos(parsedFeed);
+  await handleParsedManyData(channel, channelRemoteItemService, channelRemoteItemDtos);
+};

package/src/lib/rss/channel/channelSeason.ts

@@ -0,0 +1,14 @@
+import { FeedObject } from "podcast-partytime";
+import { Channel, ChannelSeasonService } from "podverse-orm";
+import { compatChannelSeasonDtos } from "@parser/lib/compat/partytime/channel";
+
+export const handleParsedChannelSeasons = async (parsedFeed: FeedObject, channel: Channel): Promise<void> => {
+  const channelSeasonService = new ChannelSeasonService();
+  const channelSeasonDtos = compatChannelSeasonDtos(parsedFeed);
+  
+  if (channelSeasonDtos.length > 0) {
+    await channelSeasonService.updateMany(channel, channelSeasonDtos);
+  } else {
+    await channelSeasonService.deleteAll(channel);
+  }
+};

package/src/lib/rss/channel/channelSocialInteract.ts

@@ -0,0 +1,14 @@
+import { FeedObject } from "podcast-partytime";
+import { Channel, ChannelSocialInteractService, EntityManager } from "podverse-orm";
+import { compatChannelSocialInteractDtos } from "@parser/lib/compat/partytime/channel";
+import { handleParsedManyData } from "../base/handleParsedManyData";
+
+export const handleParsedChannelSocialInteract = async (
+  parsedFeed: FeedObject,
+  channel: Channel,
+  transactionalEntityManager: EntityManager
+) => {
+  const channelSocialInteractService = new ChannelSocialInteractService(transactionalEntityManager);
+  const channelSocialInteractDtos = compatChannelSocialInteractDtos(parsedFeed);
+  await handleParsedManyData(channel, channelSocialInteractService, channelSocialInteractDtos);
+};

package/src/lib/rss/channel/channelTrailer.ts

@@ -0,0 +1,31 @@
+import { FeedObject } from "podcast-partytime";
+import { Channel, ChannelSeason, ChannelTrailerDto, ChannelTrailerService, EntityManager } from "podverse-orm";
+import { compatChannelTrailerDtos } from "@parser/lib/compat/partytime/channel";
+
+export const handleParsedChannelTrailer = async (
+  parsedFeed: FeedObject,
+  channel: Channel,
+  channelSeasonIndex: Record<number, ChannelSeason>,
+  transactionalEntityManager: EntityManager
+) => {
+  const channelTrailerService = new ChannelTrailerService(transactionalEntityManager);
+  const channelTrailerDtos = compatChannelTrailerDtos(parsedFeed);
+
+  const enrichedChannelTrailerDtos: ChannelTrailerDto[] = channelTrailerDtos.map((channelTrailerDto) => {
+    const channel_season = channelTrailerDto.season ? channelSeasonIndex[channelTrailerDto.season] : null;
+    return {
+      url: channelTrailerDto.url,
+      pubdate: channelTrailerDto.pubdate,
+      title: channelTrailerDto.title,
+      length: channelTrailerDto.length,
+      type: channelTrailerDto.type,
+      channel_season
+    };
+  });
+
+  if (channelTrailerDtos.length > 0) {
+    await channelTrailerService.updateMany(channel, enrichedChannelTrailerDtos);
+  } else {
+    await channelTrailerService.deleteAll(channel);
+  }
+};