sebastjan/videofolxtv
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Restored to '551aaee106c3dc6c34e10193d8683fa67e7f9bea'

Browse Source 
Replit-Restored-To: 551aaee106
This commit is contained in:
sebastjanartic
2025-08-04 20:10:59 +00:00
parent bb26fd3cdc
commit 9b192c6e1b
27 changed files with 107 additions and 2599 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/storage.ts
+4 -551
View File
@@ -1,69 +1,23 @@
import {
type Video,
type InsertVideo,
type User,
type InsertUser,
type Playlist,
type InsertPlaylist,
type PlaylistVideo,
type InsertPlaylistVideo,
type UserFavorite,
type InsertUserFavorite
} from "@shared/schema";
import { type Video, type InsertVideo } from "@shared/schema";
import { randomUUID } from "crypto";
import { BunnyService } from "./bunny";
export interface IStorage {
// Video operations
getVideos(limit?: number, offset?: number, search?: string, category?: string): Promise<Video[]>;
getVideo(id: string): Promise<Video | undefined>;
createVideo(video: InsertVideo): Promise<Video>;
updateVideoViews(id: string): Promise<void>;
getVideoCount(search?: string, category?: string): Promise<number>;
// User operations
getUser(id: string): Promise<User | undefined>;
getUserByEmail(email: string): Promise<User | undefined>;
getUserByUsername(username: string): Promise<User | undefined>;
createUser(user: InsertUser): Promise<User>;
updateUser(id: string, user: Partial<InsertUser>): Promise<User | undefined>;
// Playlist operations
getPlaylists(userId: string, limit?: number, offset?: number): Promise<Playlist[]>;
getPlaylist(id: string, userId?: string): Promise<Playlist | undefined>;
createPlaylist(playlist: InsertPlaylist): Promise<Playlist>;
updatePlaylist(id: string, playlist: Partial<InsertPlaylist>, userId: string): Promise<Playlist | undefined>;
deletePlaylist(id: string, userId: string): Promise<boolean>;
// Playlist video operations
getPlaylistVideos(playlistId: string): Promise<(PlaylistVideo & { video: Video })[]>;
addVideoToPlaylist(playlistVideo: InsertPlaylistVideo): Promise<PlaylistVideo>;
removeVideoFromPlaylist(playlistId: string, videoId: string): Promise<boolean>;
// Favorites operations
getUserFavorites(userId: string, limit?: number, offset?: number): Promise<(UserFavorite & { video: Video })[]>;
addToFavorites(favorite: InsertUserFavorite): Promise<UserFavorite>;
removeFromFavorites(userId: string, videoId: string): Promise<boolean>;
isVideoFavorited(userId: string, videoId: string): Promise<boolean>;
}
export class MemStorage implements IStorage {
private videos: Map<string, Video>;
private users: Map<string, User>;
private playlists: Map<string, Playlist>;
private playlistVideos: Map<string, PlaylistVideo[]>;
private userFavorites: Map<string, UserFavorite[]>;
constructor() {
this.videos = new Map();
this.users = new Map();
this.playlists = new Map();
this.playlistVideos = new Map();
this.userFavorites = new Map();
// Initialize with some sample videos for demonstration
// In production, these would be fetched from bunny.net API
this.initializeSampleVideos();
this.initializeSampleUsers();
}
private initializeSampleVideos() {
@@ -191,222 +145,6 @@ export class MemStorage implements IStorage {
const videos = await this.getVideos(1000, 0, search, category);
return videos.length;
}
private initializeSampleUsers() {
// Sample user for testing
const sampleUser: User = {
id: "test-user-123",
username: "testuser",
email: "test@example.com",
passwordHash: "hashed_password",
firstName: "Test",
lastName: "User",
avatar: null,
isActive: true,
createdAt: new Date(),
updatedAt: new Date(),
};
this.users.set(sampleUser.id, sampleUser);
}
// User operations
async getUser(id: string): Promise<User | undefined> {
return this.users.get(id);
}
async getUserByEmail(email: string): Promise<User | undefined> {
for (const user of this.users.values()) {
if (user.email === email) {
return user;
}
}
return undefined;
}
async getUserByUsername(username: string): Promise<User | undefined> {
for (const user of this.users.values()) {
if (user.username === username) {
return user;
}
}
return undefined;
}
async createUser(userData: InsertUser): Promise<User> {
const user: User = {
id: randomUUID(),
...userData,
createdAt: new Date(),
updatedAt: new Date(),
};
this.users.set(user.id, user);
return user;
}
async updateUser(id: string, userData: Partial<InsertUser>): Promise<User | undefined> {
const user = this.users.get(id);
if (!user) return undefined;
const updatedUser: User = {
...user,
...userData,
updatedAt: new Date(),
};
this.users.set(id, updatedUser);
return updatedUser;
}
// Playlist operations
async getPlaylists(userId: string, limit = 20, offset = 0): Promise<Playlist[]> {
const userPlaylists = Array.from(this.playlists.values())
.filter(playlist => playlist.userId === userId)
.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime())
.slice(offset, offset + limit);
return userPlaylists;
}
async getPlaylist(id: string, userId?: string): Promise<Playlist | undefined> {
const playlist = this.playlists.get(id);
if (!playlist) return undefined;
// If userId is provided, check ownership or public status
if (userId && playlist.userId !== userId && !playlist.isPublic) {
return undefined;
}
return playlist;
}
async createPlaylist(playlistData: InsertPlaylist): Promise<Playlist> {
const playlist: Playlist = {
id: randomUUID(),
...playlistData,
createdAt: new Date(),
updatedAt: new Date(),
};
this.playlists.set(playlist.id, playlist);
this.playlistVideos.set(playlist.id, []);
return playlist;
}
async updatePlaylist(id: string, playlistData: Partial<InsertPlaylist>, userId: string): Promise<Playlist | undefined> {
const playlist = this.playlists.get(id);
if (!playlist || playlist.userId !== userId) return undefined;
const updatedPlaylist: Playlist = {
...playlist,
...playlistData,
updatedAt: new Date(),
};
this.playlists.set(id, updatedPlaylist);
return updatedPlaylist;
}
async deletePlaylist(id: string, userId: string): Promise<boolean> {
const playlist = this.playlists.get(id);
if (!playlist || playlist.userId !== userId) return false;
this.playlists.delete(id);
this.playlistVideos.delete(id);
return true;
}
// Playlist video operations
async getPlaylistVideos(playlistId: string): Promise<(PlaylistVideo & { video: Video })[]> {
const videos = this.playlistVideos.get(playlistId) || [];
const result = [];
for (const playlistVideo of videos) {
const video = this.videos.get(playlistVideo.videoId);
if (video) {
result.push({ ...playlistVideo, video });
}
}
return result.sort((a, b) => a.position - b.position);
}
async addVideoToPlaylist(playlistVideoData: InsertPlaylistVideo): Promise<PlaylistVideo> {
const videos = this.playlistVideos.get(playlistVideoData.playlistId) || [];
// Check if video is already in playlist
const existingIndex = videos.findIndex(v => v.videoId === playlistVideoData.videoId);
if (existingIndex !== -1) {
throw new Error("Video is already in playlist");
}
const playlistVideo: PlaylistVideo = {
...playlistVideoData,
addedAt: new Date(),
};
videos.push(playlistVideo);
this.playlistVideos.set(playlistVideoData.playlistId, videos);
return playlistVideo;
}
async removeVideoFromPlaylist(playlistId: string, videoId: string): Promise<boolean> {
const videos = this.playlistVideos.get(playlistId) || [];
const filteredVideos = videos.filter(v => v.videoId !== videoId);
if (filteredVideos.length === videos.length) {
return false; // Video not found
}
this.playlistVideos.set(playlistId, filteredVideos);
return true;
}
// Favorites operations
async getUserFavorites(userId: string, limit = 20, offset = 0): Promise<(UserFavorite & { video: Video })[]> {
const favorites = this.userFavorites.get(userId) || [];
const result = [];
for (const favorite of favorites.slice(offset, offset + limit)) {
const video = this.videos.get(favorite.videoId);
if (video) {
result.push({ ...favorite, video });
}
}
return result.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
}
async addToFavorites(favoriteData: InsertUserFavorite): Promise<UserFavorite> {
const favorites = this.userFavorites.get(favoriteData.userId) || [];
// Check if already favorited
const existing = favorites.find(f => f.videoId === favoriteData.videoId);
if (existing) {
throw new Error("Video is already in favorites");
}
const favorite: UserFavorite = {
...favoriteData,
createdAt: new Date(),
};
favorites.push(favorite);
this.userFavorites.set(favoriteData.userId, favorites);
return favorite;
}
async removeFromFavorites(userId: string, videoId: string): Promise<boolean> {
const favorites = this.userFavorites.get(userId) || [];
const filteredFavorites = favorites.filter(f => f.videoId !== videoId);
if (filteredFavorites.length === favorites.length) {
return false; // Favorite not found
}
this.userFavorites.set(userId, filteredFavorites);
return true;
}
async isVideoFavorited(userId: string, videoId: string): Promise<boolean> {
const favorites = this.userFavorites.get(userId) || [];
return favorites.some(f => f.videoId === videoId);
}
}
// Use Bunny.net storage if API keys are available, otherwise fallback to memory storage
@@ -482,291 +220,6 @@ class BunnyStorage implements IStorage {
return 0;
}
}
// User operations - Not implemented for BunnyStorage (video-only service)
async getUser(id: string): Promise<User | undefined> {
throw new Error("User operations are not supported with Bunny.net storage");
}
async getUserByEmail(email: string): Promise<User | undefined> {
throw new Error("User operations are not supported with Bunny.net storage");
}
async getUserByUsername(username: string): Promise<User | undefined> {
throw new Error("User operations are not supported with Bunny.net storage");
}
async createUser(user: InsertUser): Promise<User> {
throw new Error("User operations are not supported with Bunny.net storage");
}
async updateUser(id: string, user: Partial<InsertUser>): Promise<User | undefined> {
throw new Error("User operations are not supported with Bunny.net storage");
}
// Playlist operations - Not implemented for BunnyStorage (video-only service)
async getPlaylists(userId: string, limit?: number, offset?: number): Promise<Playlist[]> {
throw new Error("Playlist operations are not supported with Bunny.net storage");
}
async getPlaylist(id: string, userId?: string): Promise<Playlist | undefined> {
throw new Error("Playlist operations are not supported with Bunny.net storage");
}
async createPlaylist(playlist: InsertPlaylist): Promise<Playlist> {
throw new Error("Playlist operations are not supported with Bunny.net storage");
}
async updatePlaylist(id: string, playlist: Partial<InsertPlaylist>, userId: string): Promise<Playlist | undefined> {
throw new Error("Playlist operations are not supported with Bunny.net storage");
}
async deletePlaylist(id: string, userId: string): Promise<boolean> {
throw new Error("Playlist operations are not supported with Bunny.net storage");
}
async getPlaylistVideos(playlistId: string): Promise<(PlaylistVideo & { video: Video })[]> {
throw new Error("Playlist operations are not supported with Bunny.net storage");
}
async addVideoToPlaylist(playlistVideo: InsertPlaylistVideo): Promise<PlaylistVideo> {
throw new Error("Playlist operations are not supported with Bunny.net storage");
}
async removeVideoFromPlaylist(playlistId: string, videoId: string): Promise<boolean> {
throw new Error("Playlist operations are not supported with Bunny.net storage");
}
// Favorites operations - Not implemented for BunnyStorage (video-only service)
async getUserFavorites(userId: string, limit?: number, offset?: number): Promise<(UserFavorite & { video: Video })[]> {
throw new Error("Favorites operations are not supported with Bunny.net storage");
}
async addToFavorites(favorite: InsertUserFavorite): Promise<UserFavorite> {
throw new Error("Favorites operations are not supported with Bunny.net storage");
}
async removeFromFavorites(userId: string, videoId: string): Promise<boolean> {
throw new Error("Favorites operations are not supported with Bunny.net storage");
}
async isVideoFavorited(userId: string, videoId: string): Promise<boolean> {
throw new Error("Favorites operations are not supported with Bunny.net storage");
}
}
// Create a hybrid storage that combines Bunny.net videos with database user features
import { db } from "./db";
import { eq, and, desc, asc } from "drizzle-orm";
import { users, playlists, playlistVideos, userFavorites } from "@shared/schema";
class HybridStorage implements IStorage {
private bunnyStorage: BunnyStorage;
constructor() {
this.bunnyStorage = new BunnyStorage();
}
// Video operations - delegate to Bunny.net
async getVideos(limit = 20, offset = 0, search?: string, category?: string): Promise<Video[]> {
return this.bunnyStorage.getVideos(limit, offset, search, category);
}
async getVideo(id: string): Promise<Video | undefined> {
return this.bunnyStorage.getVideo(id);
}
async createVideo(video: InsertVideo): Promise<Video> {
return this.bunnyStorage.createVideo(video);
}
async updateVideoViews(id: string): Promise<void> {
return this.bunnyStorage.updateVideoViews(id);
}
async getVideoCount(search?: string, category?: string): Promise<number> {
return this.bunnyStorage.getVideoCount(search, category);
}
// User operations - use database
async getUser(id: string): Promise<User | undefined> {
const [user] = await db.select().from(users).where(eq(users.id, id));
return user;
}
async getUserByEmail(email: string): Promise<User | undefined> {
const [user] = await db.select().from(users).where(eq(users.email, email));
return user;
}
async getUserByUsername(username: string): Promise<User | undefined> {
const [user] = await db.select().from(users).where(eq(users.username, username));
return user;
}
async createUser(userData: InsertUser): Promise<User> {
const [user] = await db.insert(users).values({
...userData,
createdAt: new Date(),
updatedAt: new Date()
}).returning();
return user;
}
async updateUser(id: string, userData: Partial<InsertUser>): Promise<User | undefined> {
const [user] = await db.update(users)
.set({ ...userData, updatedAt: new Date() })
.where(eq(users.id, id))
.returning();
return user;
}
// Playlist operations - use database
async getPlaylists(userId: string, limit = 20, offset = 0): Promise<Playlist[]> {
const userPlaylists = await db.select()
.from(playlists)
.where(eq(playlists.userId, userId))
.orderBy(desc(playlists.createdAt))
.limit(limit)
.offset(offset);
return userPlaylists;
}
async getPlaylist(id: string, userId?: string): Promise<Playlist | undefined> {
let query = db.select().from(playlists).where(eq(playlists.id, id));
if (userId) {
query = query.where(eq(playlists.userId, userId));
}
const [playlist] = await query;
return playlist;
}
async createPlaylist(playlistData: InsertPlaylist): Promise<Playlist> {
const [playlist] = await db.insert(playlists).values({
...playlistData,
createdAt: new Date(),
updatedAt: new Date()
}).returning();
return playlist;
}
async updatePlaylist(id: string, updates: Partial<InsertPlaylist>, userId: string): Promise<Playlist | undefined> {
const [playlist] = await db.update(playlists)
.set({ ...updates, updatedAt: new Date() })
.where(and(eq(playlists.id, id), eq(playlists.userId, userId)))
.returning();
return playlist;
}
async deletePlaylist(id: string, userId: string): Promise<boolean> {
const result = await db.delete(playlists)
.where(and(eq(playlists.id, id), eq(playlists.userId, userId)));
return result.rowCount > 0;
}
// Playlist video operations - use database
async getPlaylistVideos(playlistId: string): Promise<(PlaylistVideo & { video: Video })[]> {
const playlistVideoRecords = await db.select()
.from(playlistVideos)
.where(eq(playlistVideos.playlistId, playlistId))
.orderBy(asc(playlistVideos.position));
const results = [];
for (const record of playlistVideoRecords) {
const video = await this.getVideo(record.videoId);
if (video) {
results.push({ ...record, video });
}
}
return results;
}
async addVideoToPlaylist(data: InsertPlaylistVideo): Promise<PlaylistVideo> {
// Check if video already exists in playlist
const existing = await db.select()
.from(playlistVideos)
.where(and(
eq(playlistVideos.playlistId, data.playlistId),
eq(playlistVideos.videoId, data.videoId)
));
if (existing.length > 0) {
throw new Error("Video is already in playlist");
}
const [playlistVideo] = await db.insert(playlistVideos).values({
...data,
addedAt: new Date()
}).returning();
return playlistVideo;
}
async removeVideoFromPlaylist(playlistId: string, videoId: string): Promise<boolean> {
const result = await db.delete(playlistVideos)
.where(and(
eq(playlistVideos.playlistId, playlistId),
eq(playlistVideos.videoId, videoId)
));
return result.rowCount > 0;
}
// Favorites operations - use database
async getUserFavorites(userId: string, limit = 20, offset = 0): Promise<(UserFavorite & { video: Video })[]> {
const favoriteRecords = await db.select()
.from(userFavorites)
.where(eq(userFavorites.userId, userId))
.orderBy(desc(userFavorites.createdAt))
.limit(limit)
.offset(offset);
const results = [];
for (const record of favoriteRecords) {
const video = await this.getVideo(record.videoId);
if (video) {
results.push({ ...record, video });
}
}
return results;
}
async addToFavorites(data: InsertUserFavorite): Promise<UserFavorite> {
// Check if video already favorited
const existing = await db.select()
.from(userFavorites)
.where(and(
eq(userFavorites.userId, data.userId),
eq(userFavorites.videoId, data.videoId)
));
if (existing.length > 0) {
throw new Error("Video is already in favorites");
}
const [favorite] = await db.insert(userFavorites).values({
...data,
createdAt: new Date()
}).returning();
return favorite;
}
async removeFromFavorites(userId: string, videoId: string): Promise<boolean> {
const result = await db.delete(userFavorites)
.where(and(
eq(userFavorites.userId, userId),
eq(userFavorites.videoId, videoId)
));
return result.rowCount > 0;
}
async isVideoFavorited(userId: string, videoId: string): Promise<boolean> {
const [favorite] = await db.select()
.from(userFavorites)
.where(and(
eq(userFavorites.userId, userId),
eq(userFavorites.videoId, videoId)
));
return !!favorite;
}
}
// Try to use Bunny.net storage, fallback to memory storage if not configured
@@ -777,10 +230,10 @@ const hasBunnyConfig = process.env.BUNNY_API_KEY && process.env.BUNNY_LIBRARY_ID
if (hasBunnyConfig) {
try {
storage = new HybridStorage();
console.log('✅ Using Hybrid storage (Bunny.net + Database) with library ID:', process.env.BUNNY_LIBRARY_ID);
storage = new BunnyStorage();
console.log('✅ Using Bunny.net storage with library ID:', process.env.BUNNY_LIBRARY_ID);
} catch (error) {
console.error('❌ Failed to initialize Hybrid storage:', error);
console.error('❌ Failed to initialize Bunny.net storage:', error);
console.log('📁 Falling back to memory storage');
storage = new MemStorage();
}