Thoughts on live sessions + messaging for Project Mixtape

live-sessions.swift

// Project Mixtape Live Session Models.

struct SessionTrack: FirestoreModel {

    // MARK: Properties

    let track: Track
    let sessionId: String
    let mixtapeId: String?
    let placement: Int

    let addedBy: RoadtripUser
    let addedAt: Date

    let suggestedBy: RoadtripUser?
    let suggestedAt: Date?

}

enum SessionVisibility: String, Codable {
    case everyone = "EVERYONE"
    case friends = "FRIENDS"
    case secret = "PRIVATE"
}

struct LiveSession: FirestoreModel {

    // MARK: Properties

    let sessionId: String
    let provider: SourceType
    let shortId: String?
    let active: Bool

    let host: RoadtripUser
    let creator: RoadtripUser

    let name: String
    let imageUrl: String?
    let visibility: SessionVisibility

    let currentTrack: SessionTrack?
    let audioState: AudioState?

    let createdAt: Date
    let updatedAt: Date

}

struct SessionInvite: RoadtripUser, FirestoreModel {

    // MARK: Properties

    // These apply to the invited user.
    var uid: String
    var name: String
    var username: String
    var avatarUrl: String?
    var phone: String?

    var sessionId: String
    var sentAt: Date
    var sender: RoadtripUser?

    var accepted: Bool
    var expired: Bool
    var acceptedAt: Date?
  
}

enum MemberVoiceStatus: String, Codable {
    case speaking
    case muted
    case requesting
    case listening
    case disconnected
}

struct SessionMember: RoadtripStatusUser, FirestoreModel {

    // MARK: Properties

    var uid: String
    var name: String
    var username: String
    var avatarUrl: String?
    var phone: String?
    var status: RoomMemberStatus?
    var sessionId: String

    var isHost: Bool
    var present: Bool
    var kicked: Bool
    var voiceStatus: MemberVoiceStatus

    var firstJoinedAt: Date
    var lastJoinedAt: Date
    var lastSeenAt: Date
  
}

TS Types

import { firestore } from 'firebase-admin';
import { UserPreview } from './index';

/**
 * Live Session
 */

export enum SessionVisibility {
  Everyone = 'EVERYONE',
  Friends = 'FRIENDS',
  Private = 'PRIVATE',
}

export enum SessionPlaybackState {
  Playing = 'PLAYING',
  Paused = 'PAUSED',
}

export interface SessionAudioState {
  playerUri: string;
  playerState: SessionPlaybackState;
  playerOffset: number;
  updatedAt: firestore.Timestamp;
  shuffle: boolean;
}

export interface LiveSession {
  id: string;
  provider: 'spotify';
  shortId: string;
  active: boolean;

  host: UserPreview;
  creator: UserPreview;

  name: string;
  imageUrl?: string;
  visibility: SessionVisibility;

  currentTrack: SessionTrack;
  audioState: SessionAudioState;

  createdAt: firestore.Timestamp;
  updatedAt: firestore.Timestamp;

  previewMembers: SessionMember[];
}

export interface LiveSessionPreview extends Omit<LiveSession, 'audioState' | 'currentTrack'> {
  currentTrack: SessionTrackPreview;
}

/**
 * Session Members
 */

export enum MemberVoiceStatus {
  Speaking = 'SPEAKING',
  Muted = 'MUTED',
  Requesting = 'REQUESTING',
  Listening = 'LISTENING',
  Disconnected = 'DISCONNECTED',
}

export interface SessionMember extends UserPreview {
  present: boolean;
  kicked: boolean;
  voiceStatus: MemberVoiceStatus;

  isHost: boolean;

  firstJoinedAt: firestore.Timestamp;
  lastJoinedAt: firestore.Timestamp;
  lastSeenAt: firestore.Timestamp;
}

/**
 * Tracks
 */

export interface SessionTrack {
  id: string;
  mixtapeId?: string;
  trackId: string;
  position: number;
  addedById: string;
  suggestedById: string | null;
  track: Track;
}

export interface SessionTrackPreview extends Omit<SessionTrack, 'track'> {
  track: TrackPreview;
}

export interface Track {
  id: string;
  name: string;
  slug: string;
  durationMs: number;
  releaseDate: Date;
  albumId: string;
  trackNumber: number;
  explicit: boolean;
  type: TrackType;
  source: TrackSource;
}

export type TrackPreview = Omit<Track, 'source'>;

export enum TrackType {
  Music = 'MUSIC',
  Podcast = 'PODCAST',
  Audiobook = 'AUDIOBOOK',
}

export interface TrackSource {
  id: string;
  playbackUri: string;
  trackId: string;
  source: SourceType;
  metadata: any;
}

export enum SourceType {
  Spotify = 'SPOTIFY',
  Apple = 'APPLE',
}

new invite model:

export interface SessionInvite {
  sessionId: string;
  accepted: boolean;
  expired: boolean;
  recipient: UserPreview;
  sender: UserPreview;
  sentAt: firestore.Timestamp;
  acceptedAt: firestore.Timestamp;
}