jukebox-media-server 0.5.1 → 0.7.0

package/dist/server/schema-1sWMC8cP.js

@@ -0,0 +1,59 @@
+import { n as __exportAll } from "./chunk-CrysgU_F.js";
+import { t as configDirectory } from "./config-CCAveLuN.js";
+import { a as text, i as sqliteTable, o as real, s as integer, t as index } from "./indexes-vPbUiKXP.js";
+import { join } from "path";
+//#region src/telemetry/config.ts
+const telemetryDatabasePath = join(configDirectory, "telemetry.db");
+//#endregion
+//#region src/telemetry/schema.ts
+var schema_exports = /* @__PURE__ */ __exportAll({
+	errors: () => errors,
+	spans: () => spans
+});
+const spans = sqliteTable("spans", {
+	id: integer("id").primaryKey({ autoIncrement: true }),
+	traceId: text("trace_id").notNull(),
+	spanId: text("span_id").notNull(),
+	parentSpanId: text("parent_span_id"),
+	name: text("name").notNull(),
+	kind: text("kind").notNull().default("internal"),
+	source: text("source").notNull(),
+	route: text("route"),
+	startTime: integer("start_time").notNull(),
+	endTime: integer("end_time").notNull(),
+	durationMs: real("duration_ms").notNull(),
+	statusCode: text("status_code").notNull().default("unset"),
+	statusMessage: text("status_message"),
+	attributes: text("attributes").notNull().default("{}"),
+	events: text("events").notNull().default("[]"),
+	resource: text("resource").notNull().default("{}"),
+	sessionId: text("session_id"),
+	createdAt: integer("created_at").notNull()
+}, (table) => [
+	index("spans_trace_id_idx").on(table.traceId),
+	index("spans_trace_start_idx").on(table.traceId, table.startTime),
+	index("spans_status_idx").on(table.statusCode),
+	index("spans_created_idx").on(table.createdAt),
+	index("spans_parent_idx").on(table.parentSpanId),
+	index("spans_route_idx").on(table.route)
+]);
+const errors = sqliteTable("errors", {
+	id: integer("id").primaryKey({ autoIncrement: true }),
+	traceId: text("trace_id"),
+	spanId: text("span_id"),
+	source: text("source").notNull(),
+	kind: text("kind").notNull(),
+	name: text("name").notNull(),
+	message: text("message").notNull(),
+	stack: text("stack"),
+	url: text("url"),
+	attributes: text("attributes").notNull().default("{}"),
+	timestamp: integer("timestamp").notNull(),
+	createdAt: integer("created_at").notNull()
+}, (table) => [
+	index("errors_created_idx").on(table.createdAt),
+	index("errors_trace_idx").on(table.traceId),
+	index("errors_source_idx").on(table.source)
+]);
+//#endregion
+export { telemetryDatabasePath as i, schema_exports as n, spans as r, errors as t };

package/dist/server/schema-B7-kIAVY.js

@@ -0,0 +1,145 @@
+import { n as __exportAll } from "./chunk-CrysgU_F.js";
+import { a as text, i as sqliteTable, n as uniqueIndex, o as real, s as integer } from "./indexes-vPbUiKXP.js";
+//#region src/database/schema.ts
+var schema_exports = /* @__PURE__ */ __exportAll({
+	authConfig: () => authConfig,
+	episodes: () => episodes,
+	favorites: () => favorites,
+	libraries: () => libraries,
+	movies: () => movies,
+	profiles: () => profiles,
+	scanJobs: () => scanJobs,
+	seasons: () => seasons,
+	sessions: () => sessions,
+	settings: () => settings,
+	shows: () => shows,
+	subtitles: () => subtitles,
+	watchProgress: () => watchProgress
+});
+const profiles = sqliteTable("profiles", {
+	id: integer("id").primaryKey({ autoIncrement: true }),
+	name: text("name").notNull().unique(),
+	emoji: text("emoji").notNull(),
+	createdAt: integer("created_at", { mode: "timestamp" }).notNull()
+});
+const libraries = sqliteTable("libraries", {
+	id: integer("id").primaryKey({ autoIncrement: true }),
+	name: text("name").notNull(),
+	path: text("path").notNull().unique(),
+	type: text("type").notNull(),
+	createdAt: integer("created_at", { mode: "timestamp" }).notNull()
+});
+const movies = sqliteTable("movies", {
+	id: integer("id").primaryKey({ autoIncrement: true }),
+	title: text("title").notNull(),
+	filePath: text("file_path").notNull().unique(),
+	fileName: text("file_name").notNull(),
+	fileSize: integer("file_size"),
+	extension: text("extension"),
+	createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+	updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
+	externalId: text("external_id"),
+	year: integer("year"),
+	overview: text("overview"),
+	runtime: integer("runtime"),
+	genres: text("genres"),
+	rating: real("rating"),
+	posterUrl: text("poster_url"),
+	backdropUrl: text("backdrop_url"),
+	trailerUrl: text("trailer_url")
+});
+const shows = sqliteTable("shows", {
+	id: integer("id").primaryKey({ autoIncrement: true }),
+	title: text("title").notNull(),
+	folderPath: text("folder_path").notNull().unique(),
+	externalId: text("external_id"),
+	year: integer("year"),
+	overview: text("overview"),
+	genres: text("genres"),
+	rating: real("rating"),
+	posterUrl: text("poster_url"),
+	backdropUrl: text("backdrop_url"),
+	createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+	updatedAt: integer("updated_at", { mode: "timestamp" }).notNull()
+});
+const seasons = sqliteTable("seasons", {
+	id: integer("id").primaryKey({ autoIncrement: true }),
+	showId: integer("show_id").notNull().references(() => shows.id),
+	seasonNumber: integer("season_number").notNull(),
+	name: text("name"),
+	overview: text("overview"),
+	posterUrl: text("poster_url"),
+	episodeCount: integer("episode_count")
+});
+const episodes = sqliteTable("episodes", {
+	id: integer("id").primaryKey({ autoIncrement: true }),
+	showId: integer("show_id").notNull().references(() => shows.id),
+	seasonId: integer("season_id").notNull().references(() => seasons.id),
+	seasonNumber: integer("season_number").notNull(),
+	episodeNumber: integer("episode_number").notNull(),
+	title: text("title").notNull(),
+	filePath: text("file_path").notNull().unique(),
+	fileName: text("file_name").notNull(),
+	fileSize: integer("file_size"),
+	extension: text("extension"),
+	externalId: text("external_id"),
+	overview: text("overview"),
+	runtime: integer("runtime"),
+	stillUrl: text("still_url"),
+	createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+	updatedAt: integer("updated_at", { mode: "timestamp" }).notNull()
+});
+const watchProgress = sqliteTable("watch_progress", {
+	id: integer("id").primaryKey({ autoIncrement: true }),
+	profileId: integer("profile_id").notNull().references(() => profiles.id, { onDelete: "cascade" }),
+	movieId: integer("movie_id").references(() => movies.id, { onDelete: "cascade" }),
+	episodeId: integer("episode_id").references(() => episodes.id, { onDelete: "cascade" }),
+	currentTime: integer("current_time").notNull(),
+	duration: integer("duration"),
+	updatedAt: integer("updated_at", { mode: "timestamp" }).notNull()
+}, (table) => [uniqueIndex("watch_progress_profile_movie_idx").on(table.profileId, table.movieId), uniqueIndex("watch_progress_profile_episode_idx").on(table.profileId, table.episodeId)]);
+const favorites = sqliteTable("favorites", {
+	id: integer("id").primaryKey({ autoIncrement: true }),
+	profileId: integer("profile_id").notNull().references(() => profiles.id, { onDelete: "cascade" }),
+	movieId: integer("movie_id").references(() => movies.id, { onDelete: "cascade" }),
+	showId: integer("show_id").references(() => shows.id, { onDelete: "cascade" }),
+	createdAt: integer("created_at", { mode: "timestamp" }).notNull()
+}, (table) => [uniqueIndex("favorites_profile_movie_idx").on(table.profileId, table.movieId), uniqueIndex("favorites_profile_show_idx").on(table.profileId, table.showId)]);
+const authConfig = sqliteTable("auth_config", {
+	id: integer("id").primaryKey(),
+	passwordHash: text("password_hash"),
+	updatedAt: integer("updated_at").notNull()
+});
+const sessions = sqliteTable("sessions", {
+	id: text("id").primaryKey(),
+	createdAt: integer("created_at").notNull(),
+	expiresAt: integer("expires_at").notNull(),
+	lastSeenAt: integer("last_seen_at").notNull(),
+	userAgent: text("user_agent")
+});
+const settings = sqliteTable("settings", {
+	key: text("key").primaryKey(),
+	value: text("value").notNull(),
+	updatedAt: integer("updated_at").notNull()
+});
+const scanJobs = sqliteTable("scan_jobs", {
+	id: integer("id").primaryKey({ autoIncrement: true }),
+	startedAt: integer("started_at", { mode: "timestamp" }).notNull(),
+	endedAt: integer("ended_at", { mode: "timestamp" }),
+	status: text("status").notNull(),
+	added: integer("added").notNull().default(0),
+	updated: integer("updated").notNull().default(0),
+	total: integer("total").notNull().default(0),
+	errorMessage: text("error_message"),
+	libraryResults: text("library_results")
+});
+const subtitles = sqliteTable("subtitles", {
+	id: integer("id").primaryKey({ autoIncrement: true }),
+	movieId: integer("movie_id").references(() => movies.id, { onDelete: "cascade" }),
+	episodeId: integer("episode_id").references(() => episodes.id, { onDelete: "cascade" }),
+	filePath: text("file_path").notNull(),
+	language: text("language").notNull(),
+	format: text("format").notNull()
+});
+//#endregion
+export { movies as a, schema_exports as c, settings as d, shows as f, libraries as i, seasons as l, watchProgress as m, episodes as n, profiles as o, subtitles as p, favorites as r, scanJobs as s, authConfig as t, sessions as u };

package/dist/server/select-62doObBa.js

@@ -0,0 +1,101 @@
+import { C as isDriverValueEncoder, D as Table, F as is, N as Column, T as sql, _ as Param, b as StringChunk, v as Placeholder, w as isSQLWrapper, x as View, y as SQL } from "./indexes-vPbUiKXP.js";
+//#region node_modules/drizzle-orm/sql/expressions/conditions.js
+function bindIfParam(value, column) {
+	if (isDriverValueEncoder(column) && !isSQLWrapper(value) && !is(value, Param) && !is(value, Placeholder) && !is(value, Column) && !is(value, Table) && !is(value, View)) return new Param(value, column);
+	return value;
+}
+const eq = (left, right) => {
+	return sql`${left} = ${bindIfParam(right, left)}`;
+};
+const ne = (left, right) => {
+	return sql`${left} <> ${bindIfParam(right, left)}`;
+};
+function and(...unfilteredConditions) {
+	const conditions = unfilteredConditions.filter((c) => c !== void 0);
+	if (conditions.length === 0) return;
+	if (conditions.length === 1) return new SQL(conditions);
+	return new SQL([
+		new StringChunk("("),
+		sql.join(conditions, new StringChunk(" and ")),
+		new StringChunk(")")
+	]);
+}
+function or(...unfilteredConditions) {
+	const conditions = unfilteredConditions.filter((c) => c !== void 0);
+	if (conditions.length === 0) return;
+	if (conditions.length === 1) return new SQL(conditions);
+	return new SQL([
+		new StringChunk("("),
+		sql.join(conditions, new StringChunk(" or ")),
+		new StringChunk(")")
+	]);
+}
+function not(condition) {
+	return sql`not ${condition}`;
+}
+const gt = (left, right) => {
+	return sql`${left} > ${bindIfParam(right, left)}`;
+};
+const gte = (left, right) => {
+	return sql`${left} >= ${bindIfParam(right, left)}`;
+};
+const lt = (left, right) => {
+	return sql`${left} < ${bindIfParam(right, left)}`;
+};
+const lte = (left, right) => {
+	return sql`${left} <= ${bindIfParam(right, left)}`;
+};
+function inArray(column, values) {
+	if (Array.isArray(values)) {
+		if (values.length === 0) return sql`false`;
+		return sql`${column} in ${values.map((v) => bindIfParam(v, column))}`;
+	}
+	return sql`${column} in ${bindIfParam(values, column)}`;
+}
+function notInArray(column, values) {
+	if (Array.isArray(values)) {
+		if (values.length === 0) return sql`true`;
+		return sql`${column} not in ${values.map((v) => bindIfParam(v, column))}`;
+	}
+	return sql`${column} not in ${bindIfParam(values, column)}`;
+}
+function isNull(value) {
+	return sql`${value} is null`;
+}
+function isNotNull(value) {
+	return sql`${value} is not null`;
+}
+function exists(subquery) {
+	return sql`exists ${subquery}`;
+}
+function notExists(subquery) {
+	return sql`not exists ${subquery}`;
+}
+function between(column, min, max) {
+	return sql`${column} between ${bindIfParam(min, column)} and ${bindIfParam(max, column)}`;
+}
+function notBetween(column, min, max) {
+	return sql`${column} not between ${bindIfParam(min, column)} and ${bindIfParam(max, column)}`;
+}
+function like(column, value) {
+	return sql`${column} like ${value}`;
+}
+function notLike(column, value) {
+	return sql`${column} not like ${value}`;
+}
+function ilike(column, value) {
+	return sql`${column} ilike ${value}`;
+}
+function notIlike(column, value) {
+	return sql`${column} not ilike ${value}`;
+}
+//#endregion
+//#region node_modules/drizzle-orm/sql/expressions/select.js
+function asc(column) {
+	return sql`${column} asc`;
+}
+function desc(column) {
+	return sql`${column} desc`;
+}
+//#endregion
+export { or as C, notLike as S, not as _, eq as a, notIlike as b, gte as c, isNotNull as d, isNull as f, ne as g, lte as h, between as i, ilike as l, lt as m, desc as n, exists as o, like as p, and as r, gt as s, asc as t, inArray as u, notBetween as v, notInArray as x, notExists as y };

package/drizzle/0011_loose_eternity.sql

@@ -0,0 +1 @@
+ALTER TABLE `scan_jobs` ADD `library_results` text;