545 lines
16 KiB
JavaScript
545 lines
16 KiB
JavaScript
const fs = require('fs/promises');
|
|
const path = require('path');
|
|
const { existsSync, mkdirSync } = require('fs');
|
|
|
|
// Ensure data directory exists (sync is fine for startup)
|
|
const dataDir = process.env.NODECAST_DATA_DIR
|
|
? path.resolve(process.env.NODECAST_DATA_DIR)
|
|
: path.join(__dirname, '..', 'data');
|
|
if (!existsSync(dataDir)) {
|
|
mkdirSync(dataDir, { recursive: true });
|
|
}
|
|
|
|
const dbPath = path.join(dataDir, 'db.json');
|
|
|
|
function getEmptyDb() {
|
|
return {
|
|
sources: [],
|
|
hiddenItems: [],
|
|
favorites: [],
|
|
settings: getDefaultSettings(),
|
|
users: [],
|
|
nextId: 1
|
|
};
|
|
}
|
|
|
|
// Writes use this strict reader so a damaged or temporarily unreadable file
|
|
// cannot be replaced with an empty database after an apparently successful edit.
|
|
async function readDbForMutation() {
|
|
try {
|
|
const fileContent = await fs.readFile(dbPath, 'utf-8');
|
|
const data = JSON.parse(fileContent);
|
|
if (!data || typeof data !== 'object' || Array.isArray(data)) {
|
|
throw new Error('Invalid database document');
|
|
}
|
|
let nextId = Number.isSafeInteger(data.nextId) && data.nextId > 0 ? data.nextId : 1;
|
|
for (const records of [data.sources, data.hiddenItems, data.favorites, data.users]) {
|
|
if (!records) continue;
|
|
if (!Array.isArray(records)) throw new Error('Invalid database collection');
|
|
for (const record of records) {
|
|
const id = Number(record.id);
|
|
if (Number.isSafeInteger(id) && id >= nextId) nextId = id + 1;
|
|
}
|
|
}
|
|
return {
|
|
...data,
|
|
sources: data.sources || [],
|
|
hiddenItems: data.hiddenItems || [],
|
|
favorites: data.favorites || [],
|
|
settings: data.settings || getDefaultSettings(),
|
|
users: data.users || [],
|
|
nextId
|
|
};
|
|
} catch (error) {
|
|
if (error.code === 'ENOENT') return getEmptyDb();
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
// Preserve the existing read-only fallback behavior. Mutations never use it.
|
|
async function loadDb() {
|
|
try {
|
|
return await readDbForMutation();
|
|
} catch (err) {
|
|
console.error('Error loading database:', err);
|
|
return getEmptyDb();
|
|
}
|
|
}
|
|
|
|
// Default settings
|
|
function getDefaultSettings() {
|
|
return {
|
|
arrowKeysChangeChannel: true,
|
|
overlayDuration: 5,
|
|
defaultVolume: 80,
|
|
rememberVolume: true,
|
|
lastVolume: 80,
|
|
autoPlayNextEpisode: false,
|
|
forceProxy: false,
|
|
forceTranscode: false, // Force Audio Transcode
|
|
forceVideoTranscode: false, // Force Video Transcode
|
|
forceRemux: false,
|
|
autoTranscode: true,
|
|
streamFormat: 'm3u8',
|
|
epgRefreshInterval: '24',
|
|
// User-Agent settings
|
|
userAgentPreset: 'chrome', // chrome | vlc | tivimate | custom
|
|
userAgentCustom: '', // Custom UA string when preset is 'custom'
|
|
// Transcoding settings
|
|
hwEncoder: 'auto', // auto | nvenc | amf | qsv | vaapi | software
|
|
maxResolution: '1080p', // 4k | 1080p | 720p | 480p
|
|
quality: 'medium', // high | medium | low
|
|
audioMixPreset: 'auto', // auto | itu | night | cinematic | passthrough
|
|
// Probe cache settings
|
|
probeCacheTTL: 300, // 5 minutes for URL probe cache
|
|
seriesProbeCacheDays: 7, // 7 days for series episode probe cache
|
|
// Upscaling settings
|
|
upscaleEnabled: false,
|
|
upscaleMethod: 'hardware', // hardware | software
|
|
upscaleTarget: '1080p' // 1080p | 4k | 720p
|
|
};
|
|
}
|
|
|
|
// User-Agent presets
|
|
const USER_AGENT_PRESETS = {
|
|
chrome: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36',
|
|
vlc: 'VLC/3.0.20 LibVLC/3.0.20',
|
|
tivimate: 'TiviMate/4.7.0',
|
|
};
|
|
|
|
function getUserAgent(settings) {
|
|
if (settings.userAgentPreset === 'custom' && settings.userAgentCustom) {
|
|
return settings.userAgentCustom;
|
|
}
|
|
return USER_AGENT_PRESETS[settings.userAgentPreset] || USER_AGENT_PRESETS.chrome;
|
|
}
|
|
|
|
// Queue the entire read-modify-write transaction, not only the file write.
|
|
let mutationQueue = Promise.resolve();
|
|
const tmpPath = dbPath + '.tmp';
|
|
|
|
async function writeDb(data) {
|
|
try {
|
|
const jsonString = JSON.stringify(data, null, 2);
|
|
// Rename keeps readers from observing a partially written JSON file.
|
|
await fs.writeFile(tmpPath, jsonString);
|
|
// Windows can briefly lock the destination while another request reads it.
|
|
// Retry only transient rename errors; persistent failures still reach the caller.
|
|
for (let attempt = 0; ; attempt++) {
|
|
try {
|
|
await fs.rename(tmpPath, dbPath);
|
|
break;
|
|
} catch (error) {
|
|
if (attempt >= 4 || !['EPERM', 'EACCES', 'EBUSY'].includes(error.code)) throw error;
|
|
await new Promise(resolve => setTimeout(resolve, 10 * (2 ** attempt)));
|
|
}
|
|
}
|
|
} catch (err) {
|
|
console.error('Error writing database:', err);
|
|
try { await fs.unlink(tmpPath); } catch { /* ignore */ }
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
function queueMutation(operation) {
|
|
const result = mutationQueue.then(operation);
|
|
// A rejected operation must not poison later writes, but its own caller
|
|
// must receive the error instead of an incorrect success response.
|
|
mutationQueue = result.catch(() => {});
|
|
return result;
|
|
}
|
|
|
|
async function mutateDb(mutator) {
|
|
return queueMutation(async () => {
|
|
const data = await readDbForMutation();
|
|
let changed = false;
|
|
const result = await mutator(data, () => { changed = true; });
|
|
if (changed) await writeDb(data);
|
|
return result;
|
|
});
|
|
}
|
|
|
|
// Full-document saves remain serialized for compatibility with external callers.
|
|
function saveDb(data) {
|
|
return queueMutation(() => writeDb(data));
|
|
}
|
|
|
|
// Source CRUD operations
|
|
const sources = {
|
|
async getAll() {
|
|
const db = await loadDb();
|
|
return db.sources;
|
|
},
|
|
|
|
async getById(id) {
|
|
const db = await loadDb();
|
|
return db.sources.find(s => s.id === parseInt(id));
|
|
},
|
|
|
|
async getByType(type) {
|
|
const db = await loadDb();
|
|
return db.sources.filter(s => s.type === type && s.enabled);
|
|
},
|
|
|
|
async create(source) {
|
|
return mutateDb((db, markChanged) => {
|
|
const newSource = {
|
|
id: db.nextId++,
|
|
...source,
|
|
enabled: true,
|
|
created_at: new Date().toISOString(),
|
|
updated_at: new Date().toISOString()
|
|
};
|
|
db.sources.push(newSource);
|
|
markChanged();
|
|
return newSource;
|
|
});
|
|
},
|
|
|
|
async update(id, updates) {
|
|
return mutateDb((db, markChanged) => {
|
|
const index = db.sources.findIndex(s => s.id === parseInt(id));
|
|
if (index === -1) return null;
|
|
|
|
db.sources[index] = {
|
|
...db.sources[index],
|
|
...updates,
|
|
updated_at: new Date().toISOString()
|
|
};
|
|
markChanged();
|
|
return db.sources[index];
|
|
});
|
|
},
|
|
|
|
async delete(id) {
|
|
return mutateDb((db, markChanged) => {
|
|
db.sources = db.sources.filter(s => s.id !== parseInt(id));
|
|
// Also delete related hidden items and favorites
|
|
db.hiddenItems = db.hiddenItems.filter(h => h.source_id !== parseInt(id));
|
|
db.favorites = db.favorites.filter(f => f.source_id !== parseInt(id));
|
|
markChanged();
|
|
});
|
|
},
|
|
|
|
async toggleEnabled(id) {
|
|
return mutateDb((db, markChanged) => {
|
|
const source = db.sources.find(s => s.id === parseInt(id));
|
|
if (source) {
|
|
source.enabled = !source.enabled;
|
|
source.updated_at = new Date().toISOString();
|
|
markChanged();
|
|
}
|
|
return source;
|
|
});
|
|
}
|
|
};
|
|
|
|
// Hidden items operations
|
|
const hiddenItems = {
|
|
async getAll(sourceId = null) {
|
|
const db = await loadDb();
|
|
if (sourceId) {
|
|
return db.hiddenItems.filter(h => h.source_id === parseInt(sourceId));
|
|
}
|
|
return db.hiddenItems;
|
|
},
|
|
|
|
async hide(sourceId, itemType, itemId) {
|
|
return mutateDb((db, markChanged) => {
|
|
// Check if already hidden
|
|
const exists = db.hiddenItems.find(
|
|
h => h.source_id === parseInt(sourceId) && h.item_type === itemType && h.item_id === itemId
|
|
);
|
|
if (!exists) {
|
|
db.hiddenItems.push({
|
|
id: db.nextId++,
|
|
source_id: parseInt(sourceId),
|
|
item_type: itemType,
|
|
item_id: itemId
|
|
});
|
|
markChanged();
|
|
}
|
|
});
|
|
},
|
|
|
|
async show(sourceId, itemType, itemId) {
|
|
return mutateDb((db, markChanged) => {
|
|
db.hiddenItems = db.hiddenItems.filter(
|
|
h => !(h.source_id === parseInt(sourceId) && h.item_type === itemType && h.item_id === itemId)
|
|
);
|
|
markChanged();
|
|
});
|
|
},
|
|
|
|
async isHidden(sourceId, itemType, itemId) {
|
|
const db = await loadDb();
|
|
return db.hiddenItems.some(
|
|
h => h.source_id === parseInt(sourceId) && h.item_type === itemType && h.item_id === itemId
|
|
);
|
|
},
|
|
|
|
async bulkHide(items) {
|
|
return mutateDb((db, markChanged) => {
|
|
let modified = false;
|
|
|
|
items.forEach(item => {
|
|
const { sourceId, itemType, itemId } = item;
|
|
const exists = db.hiddenItems.find(
|
|
h => h.source_id === parseInt(sourceId) && h.item_type === itemType && h.item_id === itemId
|
|
);
|
|
|
|
if (!exists) {
|
|
db.hiddenItems.push({
|
|
id: db.nextId++,
|
|
source_id: parseInt(sourceId),
|
|
item_type: itemType,
|
|
item_id: itemId
|
|
});
|
|
modified = true;
|
|
}
|
|
});
|
|
|
|
if (modified) {
|
|
markChanged();
|
|
}
|
|
return true;
|
|
});
|
|
},
|
|
|
|
async bulkShow(items) {
|
|
return mutateDb((db, markChanged) => {
|
|
const initialLength = db.hiddenItems.length;
|
|
|
|
// Create a set of "signatures" for O(1) lookup of items to remove
|
|
const toRemove = new Set(items.map(i => `${i.sourceId}:${i.itemType}:${i.itemId}`));
|
|
|
|
db.hiddenItems = db.hiddenItems.filter(h =>
|
|
!toRemove.has(`${h.source_id}:${h.item_type}:${h.item_id}`)
|
|
);
|
|
|
|
if (db.hiddenItems.length !== initialLength) {
|
|
markChanged();
|
|
}
|
|
return true;
|
|
});
|
|
}
|
|
};
|
|
|
|
// Favorites operations
|
|
const favorites = {
|
|
async getAll(sourceId = null, itemType = null) {
|
|
const db = await loadDb();
|
|
let results = db.favorites;
|
|
if (sourceId) {
|
|
results = results.filter(f => f.source_id === parseInt(sourceId));
|
|
}
|
|
if (itemType) {
|
|
results = results.filter(f => f.item_type === itemType);
|
|
}
|
|
return results;
|
|
},
|
|
|
|
async add(sourceId, itemId, itemType = 'channel') {
|
|
return mutateDb((db, markChanged) => {
|
|
// Check if already favorited
|
|
const exists = db.favorites.find(
|
|
f => f.source_id === parseInt(sourceId) && f.item_id === String(itemId) && f.item_type === itemType
|
|
);
|
|
if (!exists) {
|
|
db.favorites.push({
|
|
id: db.nextId++,
|
|
source_id: parseInt(sourceId),
|
|
item_id: String(itemId),
|
|
item_type: itemType, // 'channel', 'movie', 'series'
|
|
created_at: new Date().toISOString()
|
|
});
|
|
markChanged();
|
|
}
|
|
return true;
|
|
});
|
|
},
|
|
|
|
async remove(sourceId, itemId, itemType = 'channel') {
|
|
return mutateDb((db, markChanged) => {
|
|
db.favorites = db.favorites.filter(
|
|
f => !(f.source_id === parseInt(sourceId) && f.item_id === String(itemId) && f.item_type === itemType)
|
|
);
|
|
markChanged();
|
|
return true;
|
|
});
|
|
},
|
|
|
|
async isFavorite(sourceId, itemId, itemType = 'channel') {
|
|
const db = await loadDb();
|
|
return db.favorites.some(
|
|
f => f.source_id === parseInt(sourceId) && f.item_id === String(itemId) && f.item_type === itemType
|
|
);
|
|
}
|
|
};
|
|
|
|
// Settings operations
|
|
const settings = {
|
|
async get() {
|
|
const db = await loadDb();
|
|
return { ...getDefaultSettings(), ...db.settings };
|
|
},
|
|
|
|
async update(newSettings) {
|
|
return mutateDb((db, markChanged) => {
|
|
db.settings = { ...db.settings, ...newSettings };
|
|
markChanged();
|
|
return db.settings;
|
|
});
|
|
},
|
|
|
|
async reset() {
|
|
return mutateDb((db, markChanged) => {
|
|
db.settings = getDefaultSettings();
|
|
markChanged();
|
|
return db.settings;
|
|
});
|
|
}
|
|
};
|
|
|
|
// Preserve display spelling and IDs while preventing new case-only account collisions.
|
|
function usernameKey(username) { return typeof username === 'string' ? username.toLowerCase() : null; }
|
|
function validateUsername(username) {
|
|
if (typeof username !== 'string' || !username.trim() || username.length > 64 || /[\x00-\x1f\x7f]/.test(username)) {
|
|
throw new Error('Username must be a non-empty string of at most 64 characters');
|
|
}
|
|
}
|
|
|
|
// User operations
|
|
const users = {
|
|
async getAll() {
|
|
const db = await loadDb();
|
|
return db.users || [];
|
|
},
|
|
|
|
async getById(id) {
|
|
const db = await loadDb();
|
|
return db.users?.find(u => u.id === parseInt(id));
|
|
},
|
|
|
|
async getByUsername(username) {
|
|
const db = await loadDb();
|
|
const key = usernameKey(username);
|
|
if (key === null) return undefined;
|
|
const matches = (db.users || []).filter(user => usernameKey(user.username) === key);
|
|
if (matches.length === 1) return matches[0];
|
|
// Legacy case-only duplicates keep their exact-spelling login. Never guess between accounts.
|
|
const exact = matches.filter(user => user.username === username);
|
|
return exact.length === 1 ? exact[0] : undefined;
|
|
},
|
|
|
|
async getByOidcId(oidcId) {
|
|
const db = await loadDb();
|
|
return db.users?.find(u => u.oidcId === oidcId);
|
|
},
|
|
|
|
async getByEmail(email) {
|
|
const db = await loadDb();
|
|
return db.users?.find(u => u.email === email);
|
|
},
|
|
|
|
async create(userData, { initialSetup = false } = {}) {
|
|
return mutateDb((db, markChanged) => {
|
|
if (!db.users) {
|
|
db.users = [];
|
|
}
|
|
|
|
// Check if username already exists
|
|
if (initialSetup && db.users.length) throw new Error('Setup already completed');
|
|
validateUsername(userData.username);
|
|
if (db.users.some(u => usernameKey(u.username) === usernameKey(userData.username))) {
|
|
throw new Error('Username already exists');
|
|
}
|
|
|
|
const newUser = {
|
|
id: db.nextId++,
|
|
username: userData.username,
|
|
// For OIDC users, passwordHash is optional
|
|
passwordHash: userData.passwordHash || null,
|
|
role: userData.role || 'viewer',
|
|
oidcId: userData.oidcId || null,
|
|
email: userData.email || null,
|
|
createdAt: new Date().toISOString()
|
|
};
|
|
|
|
db.users.push(newUser);
|
|
markChanged();
|
|
|
|
// Return user without password hash
|
|
const { passwordHash, ...userWithoutPassword } = newUser;
|
|
return userWithoutPassword;
|
|
});
|
|
},
|
|
|
|
async update(id, updates) {
|
|
return mutateDb((db, markChanged) => {
|
|
const userIndex = db.users?.findIndex(u => u.id === parseInt(id));
|
|
|
|
if (userIndex === -1 || userIndex === undefined) {
|
|
throw new Error('User not found');
|
|
}
|
|
|
|
// Existing case-only duplicates can still change passwords/roles without a rename.
|
|
if (Object.hasOwn(updates, 'username')) validateUsername(updates.username);
|
|
if (updates.username && updates.username !== db.users[userIndex].username) {
|
|
if (db.users.some((u, index) => index !== userIndex && usernameKey(u.username) === usernameKey(updates.username))) {
|
|
throw new Error('Username already exists');
|
|
}
|
|
}
|
|
|
|
if (db.users[userIndex].role === 'admin' && updates.role && updates.role !== 'admin') {
|
|
if (db.users.filter(user => user.role === 'admin').length <= 1) {
|
|
throw new Error('Cannot remove admin role from the last admin user');
|
|
}
|
|
}
|
|
|
|
db.users[userIndex] = {
|
|
...db.users[userIndex],
|
|
...updates,
|
|
authVersion: updates.passwordHash ? (db.users[userIndex].authVersion || 0) + 1 : (db.users[userIndex].authVersion || 0),
|
|
updatedAt: new Date().toISOString()
|
|
};
|
|
|
|
markChanged();
|
|
|
|
// Return user without password hash
|
|
const { passwordHash, ...userWithoutPassword } = db.users[userIndex];
|
|
return userWithoutPassword;
|
|
});
|
|
},
|
|
|
|
async delete(id) {
|
|
return mutateDb((db, markChanged) => {
|
|
const userIndex = db.users?.findIndex(u => u.id === parseInt(id));
|
|
|
|
if (userIndex === -1 || userIndex === undefined) {
|
|
throw new Error('User not found');
|
|
}
|
|
|
|
// Prevent deleting the last admin
|
|
const user = db.users[userIndex];
|
|
if (user.role === 'admin') {
|
|
const adminCount = db.users.filter(u => u.role === 'admin').length;
|
|
if (adminCount <= 1) {
|
|
throw new Error('Cannot delete the last admin user');
|
|
}
|
|
}
|
|
|
|
db.users.splice(userIndex, 1);
|
|
markChanged();
|
|
return true;
|
|
});
|
|
},
|
|
|
|
async count() {
|
|
const db = await loadDb();
|
|
return db.users?.length || 0;
|
|
}
|
|
};
|
|
|
|
module.exports = { loadDb, saveDb, checkHealth: readDbForMutation, sources, hiddenItems, favorites, settings, users, getDefaultSettings, getUserAgent, USER_AGENT_PRESETS };
|