podverse-parser 5.0.0-beta.2 → 5.0.1

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

@@ -1,289 +0,0 @@
-import { FeedObject, Phase4Medium } from "podcast-partytime";
-import { createSortableTitle, getBooleanOrNull } from "podverse-helpers";
-import { getMediumEnumValue, getChannelItunesTypeItunesTypeEnumValue } from "podverse-orm";
-import { compatChannelValue } from "@parser/lib/compat/partytime/value";
-import { Phase4PodcastImage } from "podcast-partytime/dist/parser/phase/phase-4";
-
-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,
-  last_pub_date: parsedFeed.pubDate || null,
-  website_link_url: parsedFeed.link || null,
-  itunes_type: getChannelItunesTypeItunesTypeEnumValue(parsedFeed.itunesType || 'episodic'),
-  episode_count: (parsedFeed.items?.length || 0) + (parsedFeed.podcastLiveItems?.length || 0),
-});
-
-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;
-};

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

@@ -1,7 +0,0 @@
-export const convertParsedRSSFeedToCompat = () => {
-  return {
-    channel: {},
-    items: [],
-    liveItems: []
-  };
-};

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

@@ -1,8 +0,0 @@
-import { Phase1Funding } from "podcast-partytime";
-
-export const fundingCompat = (funding: Phase1Funding) => {
-  return {
-    value: funding.message,
-    url: funding.url
-  };
-};

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

@@ -1,273 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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);
-  }
-};
-