@axium/kino 0.0.1

package/dist/common.js

@@ -0,0 +1,212 @@
+import { serverConfigs } from '@axium/core';
+import { $API } from '@axium/core/api';
+import { zKeys } from '@axium/core/locales';
+import { UploadConfig, UploadInit, UploadName, UploadSize } from '@axium/core/uploads';
+import * as z from 'zod';
+import * as kt from 'kinotool/tmdb';
+const base62 = /^[0-9A-Za-z]+$/;
+export const ImageExt = z.literal(['jpg', 'png']);
+export const ImageID = z.string().length(27).regex(base62);
+export const ImageFile = z.templateLiteral([ImageID, '.', ImageExt]);
+export const imagesSizes = {
+    backdrop: ['w300', 'w780', 'w1280', 'original'],
+    logo: ['w45', 'w92', 'w154', 'w185', 'w300', 'w500', 'original'],
+    poster: ['w92', 'w154', 'w185', 'w342', 'w500', 'w780', 'original'],
+    profile: ['w45', 'w185', 'h632', 'original'],
+    still: ['w92', 'w185', 'w300', 'original'],
+    all: ['w45', 'w92', 'w154', 'w185', 'w300', 'w342', 'w500', 'w780', 'w1280', 'h632', 'original'],
+};
+export const ImageType = z.literal(Object.keys(imagesSizes));
+export const ImageSize = z.literal(imagesSizes.all).register(zKeys, { key: 'kino.config.image_size', prefix: 'kino.image_size' });
+export function imageWidth(size) {
+    if (size[0] === 'w')
+        return parseInt(size.slice(1));
+    return size == 'original' ? 1e10 : 421;
+}
+/** All the image sizes share one set of translations, since they are the same vocabulary of TMDB buckets */
+const sizeLocale = { prefix: 'kino.image_size' };
+export const PosterImageSize = z.literal(imagesSizes.poster).register(zKeys, { key: 'kino.config.poster_size', ...sizeLocale }), BackdropImageSize = z.literal(imagesSizes.backdrop).register(zKeys, { key: 'kino.config.backdrop_size', ...sizeLocale }), LogoImageSize = z.literal(imagesSizes.logo).register(zKeys, { key: 'kino.config.logo_size', ...sizeLocale }), ProfileImageSize = z.literal(imagesSizes.profile).register(zKeys, { key: 'kino.config.profile_size', ...sizeLocale }), StillImageSize = z.literal(imagesSizes.still).register(zKeys, { key: 'kino.config.still_size', ...sizeLocale });
+export const ImageSelection = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('poster'), size: PosterImageSize.optional() }),
+    z.object({ type: z.literal('backdrop'), size: BackdropImageSize.optional() }),
+    z.object({ type: z.literal('logo'), size: LogoImageSize.optional() }),
+    z.object({ type: z.literal('profile'), size: ProfileImageSize.optional() }),
+    z.object({ type: z.literal('still'), size: StillImageSize.optional() }),
+    z.object({ type: z.union([z.undefined(), z.null()]), size: ImageSize.optional() }),
+]);
+/**
+ * How uploads are prepared for playback:
+ * original: serve the uploaded file as-is
+ * both: keep the original for download and serve a remuxed copy to browsers
+ * replace: remux on upload and discard the original
+ */
+export const RemuxMode = z.literal(['original', 'both', 'replace']).register(zKeys, { key: 'kino.config.remux', prefix: 'kino.remux' });
+export const ImageCacheMode = z
+    .literal(['disabled', 'fallback', 'exact-size', 'quality', 'prefer'])
+    .register(zKeys, { key: 'kino.config.cache_mode', prefix: 'kino.cache_mode' });
+export const KinoConfig = z.object({
+    allow_user_uploads: z.boolean(),
+    data_dir: z.string().nonempty(),
+    tmdb_api_key: z.string(),
+    remux: RemuxMode,
+    images: z.object({
+        cache: z.object({
+            /**
+             * disabled: images will not be cached
+             * fallback: only use cached images if TMDB is unavailable. `largest_only` should be used with this option.
+             * exact-size: use cached images when their size is the same as the requested sized
+             * quality: use cached images when their size is at least the requested sized
+             * prefer: always used cached images
+             */
+            mode: ImageCacheMode,
+            /** Max cache size in MiB, 0=unlimited */
+            max_size: z.number().nonnegative(),
+            /** The directory to store cached images */
+            directory: z.string().nonempty(),
+            /**
+             * If set, only the largest size of an image will be cached.
+             * This will decrease cache size but increase network bandwidth
+             */
+            largest_only: z.boolean(),
+            max_image_sizes: z.object({
+                poster: PosterImageSize,
+                backdrop: BackdropImageSize,
+                logo: LogoImageSize,
+                profile: ProfileImageSize,
+                still: StillImageSize,
+            }),
+        }),
+        base_url: z.url(),
+    }),
+    upload: UploadConfig,
+});
+serverConfigs.set('@axium/kino', KinoConfig);
+export const KinoMovieUploadInit = z.object({
+    ...UploadInit.shape,
+    id: z.int().positive().nullish(),
+});
+export const KinoMovieUploadResult = z.object({
+    /** Maximum size in MiB per transfer/request */
+    max_transfer_size: z.int().positive(),
+    movie: kt.Movie,
+    token: z.base64url(),
+});
+export const KinoTvUploadInit = z.object({
+    ...UploadInit.shape,
+    season: z.int().nonnegative(),
+    episode: z.int().positive(),
+});
+export const KinoTvUploadResult = z.object({
+    /** Maximum size in MiB per transfer/request */
+    max_transfer_size: z.int().positive(),
+    episode: kt.Episode,
+    token: z.base64url(),
+});
+export const KinoSearchQuery = z.object({
+    query: z.string().min(1),
+    type: z.literal(['movie', 'tv']).optional(),
+});
+export const KinoSearchResults = z.union([kt.Movie.extend({ type: z.literal('movie') }), kt.Tv.extend({ type: z.literal('tv') })]).array();
+/** How far through a movie or episode a user is, in seconds */
+export const KinoProgress = z.object({
+    position: z.number().nonnegative().default(0),
+    /** Total runtime, so progress can be shown without loading the file */
+    duration: z.number().positive().nullish(),
+});
+/** Fraction of the way through an item, or null when the runtime isn't known yet */
+export function viewProgress(view) {
+    if (!view?.duration || !view.position)
+        return null;
+    return Math.min(Math.max(view.position / view.duration, 0), 1);
+}
+/** Information about the file backing a movie or episode. `null` when nothing has been uploaded yet. */
+export const KinoUpload = z.object({
+    uploadedAt: z.coerce.date(),
+    name: UploadName.nullish(),
+    size: UploadSize,
+    type: z.string(),
+});
+export const KinoMovie = kt.Movie.extend({ upload: KinoUpload.nullish() });
+export const KinoEpisode = kt.Episode.extend({
+    upload: KinoUpload.nullish(),
+    /** How far the requesting user got through this episode, if they have watched it */
+    progress: KinoProgress.nullish(),
+});
+export const KinoSeason = kt.Season.extend({ episodes: KinoEpisode.array().optional() });
+/** The containers kino accepts, and the MIME type each is served as */
+export const mediaTypes = {
+    '.mkv': 'video/x-matroska',
+    '.mp4': 'video/mp4',
+};
+export const mediaExtensions = Object.keys(mediaTypes);
+/** The extension an upload of `type` should be stored with, or null when the type isn't supported */
+export function extensionForType(type) {
+    return mediaExtensions.find(ext => mediaTypes[ext] == type) ?? null;
+}
+/** `accept` for a media file picker, listing both MIME types and extensions */
+export const mediaAccept = Object.entries(mediaTypes)
+    .flatMap(([ext, type]) => [type, ext])
+    .join(',');
+/** Which movie or episode was watched, and how far through it the user is */
+export const KinoViewInit = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('movie'), id: z.int().positive(), ...KinoProgress.shape }),
+    z.object({
+        type: z.literal('tv'),
+        id: z.int().positive(),
+        season: z.int().nonnegative(),
+        episode: z.int().positive(),
+        ...KinoProgress.shape,
+    }),
+]);
+/**
+ * A recently watched item, built from already-cached metadata so the list never has to hit TMDB.
+ * TV entries carry both the show (for artwork) and the episode that was watched.
+ */
+export const KinoView = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('movie'), viewedAt: z.coerce.date(), ...KinoProgress.shape, movie: KinoMovie }),
+    z.object({
+        type: z.literal('tv'),
+        viewedAt: z.coerce.date(),
+        ...KinoProgress.shape,
+        show: kt.Tv,
+        episode: KinoEpisode,
+    }),
+]);
+const KinoAPI = {
+    'kino/movies': {
+        GET: KinoMovie.array(),
+    },
+    'kino/movies/upload': {
+        PUT: [KinoMovieUploadInit, KinoMovieUploadResult],
+    },
+    'kino/movies/:id': {
+        GET: KinoMovie,
+        /** Removes the upload and its files. Administrators only. */
+        DELETE: KinoUpload,
+    },
+    'kino/views': {
+        GET: KinoView.array(),
+        PUT: [KinoViewInit, KinoView],
+    },
+    'kino/tv': {
+        GET: kt.Tv.array(),
+    },
+    'kino/tv/:id': {
+        GET: kt.Tv,
+    },
+    'kino/tv/:id/season/:season': {
+        GET: KinoSeason,
+    },
+    'kino/tv/:id/season/:season/episode/:episode': {
+        GET: KinoEpisode,
+        /** Removes the upload and its files. Administrators only. */
+        DELETE: KinoUpload,
+    },
+    'kino/tv/:id/upload': {
+        PUT: [KinoTvUploadInit, KinoTvUploadResult],
+    },
+    'kino/search': {
+        POST: [KinoSearchQuery, KinoSearchResults],
+    },
+};
+Object.assign($API, KinoAPI);

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './common.js';

package/dist/index.js

@@ -0,0 +1 @@
+export * from './common.js';

package/dist/server/api/delete.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/api/delete.js

@@ -0,0 +1,57 @@
+import { requireSession } from '@axium/server/auth';
+import { database } from '@axium/server/database';
+import { error } from '@axium/server/requests';
+import { addRoute } from '@axium/server/routes';
+import * as io from 'ioium/node';
+import { episodePath, moviePath, removeMedia } from '../media.js';
+import { ID, SeasonNumber } from './metadata.js';
+/**
+ * Deleting an upload throws away data for everyone, so it is restricted to administrators
+ * regardless of `allow_user_uploads`.
+ */
+async function requireAdmin(req) {
+    const session = await requireSession(req);
+    if (!session.user.isAdmin)
+        error(403, 'Only administrators can delete uploads');
+}
+addRoute({
+    path: '/api/kino/movies/:id/upload',
+    params: { id: ID },
+    async DELETE(req, { id }) {
+        await requireAdmin(req);
+        const upload = await database
+            .deleteFrom('kino_movie_uploads')
+            .where('id', '=', id)
+            .returning(['uploadedAt', 'name', 'size', 'type'])
+            .executeTakeFirst();
+        if (!upload)
+            error(404, 'This movie has not been uploaded');
+        // The row is gone either way; a file we can't remove would only waste space
+        const removed = removeMedia(moviePath(id));
+        io.info(`Kino: deleted movie ${id} (${removed.length} file(s))`);
+        // Progress against a movie nobody can watch anymore is meaningless
+        await database.deleteFrom('kino_movie_views').where('id', '=', id).execute();
+        return upload;
+    },
+});
+addRoute({
+    path: '/api/kino/tv/:id/season/:season/episode/:episode/upload',
+    params: { id: ID, season: SeasonNumber, episode: ID },
+    async DELETE(req, { id, season, episode }) {
+        await requireAdmin(req);
+        const upload = await database
+            .deleteFrom('kino_tv_uploads')
+            .where(eb => eb.and({ id, season_number: season, episode_number: episode }))
+            .returning(['uploadedAt', 'name', 'size', 'type'])
+            .executeTakeFirst();
+        if (!upload)
+            error(404, 'This episode has not been uploaded');
+        const removed = removeMedia(episodePath(id, season, episode));
+        io.info(`Kino: deleted episode ${id} S${season}E${episode} (${removed.length} file(s))`);
+        await database
+            .deleteFrom('kino_tv_views')
+            .where(eb => eb.and({ id, season_number: season, episode_number: episode }))
+            .execute();
+        return upload;
+    },
+});

package/dist/server/api/metadata.d.ts

@@ -0,0 +1,4 @@
+import * as z from 'zod';
+export declare const ID: z.ZodCoercedNumber<unknown>;
+/** Specials are season 0, so season numbers may be zero */
+export declare const SeasonNumber: z.ZodCoercedNumber<unknown>;

package/dist/server/api/metadata.js

@@ -0,0 +1,153 @@
+import { requireSession } from '@axium/server/auth';
+import { database } from '@axium/server/database';
+import { error } from '@axium/server/requests';
+import { addRoute } from '@axium/server/routes';
+import * as io from 'ioium/node';
+import * as z from 'zod';
+import { getEpisode, getMovie, getSeason, getTv } from '../db.js';
+import { episodePath, moviePath, removeMedia } from '../media.js';
+/**
+ * Deleting an upload throws away data for everyone, so it is restricted to administrators
+ * regardless of `allow_user_uploads`.
+ */
+async function requireAdmin(req) {
+    const session = await requireSession(req);
+    if (!session.user.isAdmin)
+        error(403, 'Only administrators can delete uploads');
+}
+export const ID = z.coerce.number().int().positive();
+/** Specials are season 0, so season numbers may be zero */
+export const SeasonNumber = z.coerce.number().int().nonnegative();
+const params = { id: ID };
+/** The columns of `kino_*_uploads` that are exposed to clients */
+const uploadColumns = ['uploadedAt', 'name', 'size', 'type'];
+addRoute({
+    path: '/api/kino/movies',
+    async GET(req) {
+        await requireSession(req);
+        const rows = await database
+            .selectFrom('kino_movies')
+            .innerJoin('kino_movie_uploads', 'kino_movie_uploads.id', 'kino_movies.id')
+            .selectAll('kino_movies')
+            .select(uploadColumns.map(column => `kino_movie_uploads.${column}`))
+            .orderBy('kino_movies.title')
+            .execute();
+        return rows.map(({ uploadedAt, name, size, type, ...movie }) => ({ ...movie, upload: { uploadedAt, name, size, type } }));
+    },
+});
+addRoute({
+    path: '/api/kino/movies/:id',
+    params,
+    async GET(req, { id }) {
+        await requireSession(req);
+        const [movie, upload] = await Promise.all([
+            getMovie(id),
+            database.selectFrom('kino_movie_uploads').select(uploadColumns).where('id', '=', id).executeTakeFirst(),
+        ]);
+        return { ...movie, upload };
+    },
+    async DELETE(req, { id }) {
+        await requireAdmin(req);
+        const upload = await database.deleteFrom('kino_movie_uploads').where('id', '=', id).returning(uploadColumns).executeTakeFirst();
+        if (!upload)
+            error(404, 'This movie has not been uploaded');
+        // The row is gone either way; a file we can't remove would only waste space
+        const removed = removeMedia(moviePath(id));
+        io.info(`Kino: deleted movie ${id} (${removed.length} file(s))`);
+        // Progress against something nobody can watch anymore is meaningless
+        await database.deleteFrom('kino_movie_views').where('id', '=', id).execute();
+        return upload;
+    },
+});
+addRoute({
+    path: '/api/kino/tv',
+    async GET(req) {
+        await requireSession(req);
+        // Only shows with at least one uploaded episode
+        return await database
+            .selectFrom('kino_tv')
+            .selectAll()
+            .where(eb => eb.exists(eb.selectFrom('kino_tv_uploads').select('kino_tv_uploads.id').whereRef('kino_tv_uploads.id', '=', 'kino_tv.id')))
+            .orderBy('name')
+            .execute();
+    },
+});
+addRoute({
+    path: '/api/kino/tv/:id',
+    params,
+    async GET(req, { id }) {
+        await requireSession(req);
+        return await getTv(id);
+    },
+});
+addRoute({
+    path: '/api/kino/tv/:id/season/:season',
+    params: { id: ID, season: SeasonNumber },
+    async GET(req, { id, season }) {
+        const { userId } = await requireSession(req);
+        const data = await getSeason(id, season);
+        if (!data.episodes?.length)
+            return data;
+        const [uploads, views] = await Promise.all([
+            database
+                .selectFrom('kino_tv_uploads')
+                .select(['episode_number', ...uploadColumns])
+                .where(eb => eb.and({ id, season_number: season }))
+                .execute(),
+            // Progress is per-user, so the episode list shows the requester's own position
+            database
+                .selectFrom('kino_tv_views')
+                .select(['episode_number', 'position', 'duration'])
+                .where(eb => eb.and({ userId, id, season_number: season }))
+                .execute(),
+        ]);
+        const uploadFor = new Map(uploads.map(({ episode_number, ...upload }) => [episode_number, upload]));
+        const progressFor = new Map(views.map(({ episode_number, ...progress }) => [episode_number, progress]));
+        return {
+            ...data,
+            episodes: data.episodes.map(episode => ({
+                ...episode,
+                upload: uploadFor.get(episode.episode_number),
+                progress: progressFor.get(episode.episode_number),
+            })),
+        };
+    },
+});
+addRoute({
+    path: '/api/kino/tv/:id/season/:season/episode/:episode',
+    params: { id: ID, season: SeasonNumber, episode: ID },
+    async GET(req, { id, season, episode }) {
+        const { userId } = await requireSession(req);
+        const [data, upload, progress] = await Promise.all([
+            getEpisode(id, season, episode),
+            database
+                .selectFrom('kino_tv_uploads')
+                .select(uploadColumns)
+                .where(eb => eb.and({ id, season_number: season, episode_number: episode }))
+                .executeTakeFirst(),
+            database
+                .selectFrom('kino_tv_views')
+                .select(['position', 'duration'])
+                .where(eb => eb.and({ userId, id, season_number: season, episode_number: episode }))
+                .executeTakeFirst(),
+        ]);
+        return { ...data, upload, progress };
+    },
+    async DELETE(req, { id, season, episode }) {
+        await requireAdmin(req);
+        const upload = await database
+            .deleteFrom('kino_tv_uploads')
+            .where(eb => eb.and({ id, season_number: season, episode_number: episode }))
+            .returning(uploadColumns)
+            .executeTakeFirst();
+        if (!upload)
+            error(404, 'This episode has not been uploaded');
+        const removed = removeMedia(episodePath(id, season, episode));
+        io.info(`Kino: deleted episode ${id} S${season}E${episode} (${removed.length} file(s))`);
+        await database
+            .deleteFrom('kino_tv_views')
+            .where(eb => eb.and({ id, season_number: season, episode_number: episode }))
+            .execute();
+        return upload;
+    },
+});

package/dist/server/api/raw.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/api/raw.js

@@ -0,0 +1,86 @@
+import { requireSession } from '@axium/server/auth';
+import { database } from '@axium/server/database';
+import { contentDispositionFor, error, parseRequestRange } from '@axium/server/requests';
+import { addRoute } from '@axium/server/routes';
+import { createReadStream, statSync } from 'node:fs';
+import { Readable } from 'node:stream';
+import { getEpisode, getMovie } from '../db.js';
+import { episodePath, moviePath, resolveMedia } from '../media.js';
+import { ID, SeasonNumber } from './metadata.js';
+/** `?download` is a bare flag, so it can't go through `parseSearch`, which JSON-parses every value */
+function isDownload(req) {
+    return new URL(req.url).searchParams.has('download');
+}
+/**
+ * Serve a media file, honoring range requests so the browser can seek without pulling the whole file.
+ *
+ * `base` is the path without an extension; which file is actually sent depends on what is on disk
+ * and on whether this is a download or playback.
+ */
+function serveMedia(req, base, name) {
+    const download = isDownload(req);
+    const media = resolveMedia(base, download);
+    if (!media)
+        error(404, 'The file for this media is missing');
+    // The file on disk is the source of truth; the recorded upload size can be for a different container
+    let size;
+    try {
+        ({ size } = statSync(media.path, { bigint: true }));
+    }
+    catch {
+        error(404, 'The file for this media is missing');
+    }
+    const range = req.headers.get('range');
+    const parsed = parseRequestRange(size, range);
+    const { start } = parsed;
+    /**
+     * RFC 9110 requires a last-byte-pos at or past the end to mean "the rest of the representation",
+     * so clamp instead of rejecting. Firefox and Safari both send such ranges while probing.
+     */
+    const end = Math.min(parsed.end, Number(size) - 1);
+    if (start < 0 || start > end || start >= size) {
+        return new Response(null, { status: 416, headers: { 'Content-Range': `bytes */${size}`, 'Accept-Ranges': 'bytes' } });
+    }
+    const headers = {
+        'Accept-Ranges': 'bytes',
+        'Content-Length': String(end - start + 1),
+        'Content-Type': media.type,
+        'Content-Disposition': contentDispositionFor(name, media.ext, download ? 'attachment' : 'inline'),
+        'Cache-Control': 'private, max-age=3600',
+    };
+    // Content-Range is only meaningful on a 206
+    if (range)
+        headers['Content-Range'] = `bytes ${start}-${end}/${size}`;
+    const stream = createReadStream(media.path, { start, end });
+    // Without this an ENOENT/EACCES after the headers are sent becomes an unhandled 'error' event
+    stream.on('error', () => stream.destroy());
+    return new Response(Readable.toWeb(stream), { status: range ? 206 : 200, headers });
+}
+addRoute({
+    path: '/raw/kino/movies/:id',
+    params: { id: ID },
+    async GET(req, { id }) {
+        await requireSession(req);
+        const upload = await database.selectFrom('kino_movie_uploads').select('id').where('id', '=', id).executeTakeFirst();
+        if (!upload)
+            error(404, 'This movie has not been uploaded');
+        const movie = await getMovie(id);
+        return serveMedia(req, moviePath(id), movie.title.replaceAll(/[ :/]/g, '_'));
+    },
+});
+addRoute({
+    path: '/raw/kino/tv/:id/:season/:episode_number',
+    params: { id: ID, season: SeasonNumber, episode_number: ID },
+    async GET(req, { id, season, episode_number }) {
+        await requireSession(req);
+        const upload = await database
+            .selectFrom('kino_tv_uploads')
+            .select('id')
+            .where(eb => eb.and({ id, season_number: season, episode_number }))
+            .executeTakeFirst();
+        if (!upload)
+            error(404, 'This episode has not been uploaded');
+        const episode = await getEpisode(id, season, episode_number);
+        return serveMedia(req, episodePath(id, season, episode_number), episode.name.replaceAll(/[ :/]/g, '_'));
+    },
+});

package/dist/server/api/search.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/api/search.js

@@ -0,0 +1,108 @@
+import { requireSession } from '@axium/server/auth';
+import { database } from '@axium/server/database';
+import { parseBody } from '@axium/server/requests';
+import { addRoute } from '@axium/server/routes';
+import * as io from 'ioium/node';
+import * as kt from 'kinotool';
+import { KinoSearchQuery } from '../../common.js';
+import { tmdb } from '../tmdb.js';
+/**
+ * Whether TMDB search results are persisted.
+ * @todo Replace with the config option
+ */
+const __cache_aggressive__ = true;
+/** Maximum number of results to pull from the database */
+const localLimit = 20;
+/** Escape a user-provided string for use as an `ILIKE` pattern */
+function escapeLike(text) {
+    return text.replaceAll(/[\\%_]/g, char => '\\' + char);
+}
+addRoute({
+    path: '/api/kino/search',
+    async POST(req) {
+        await requireSession(req);
+        const { query, type } = await parseBody(req, KinoSearchQuery);
+        const pattern = `%${escapeLike(query)}%`;
+        const [movies, shows, multi] = await Promise.all([
+            type == 'tv'
+                ? []
+                : database
+                    .selectFrom('kino_movies')
+                    .selectAll()
+                    .where('title', 'ilike', pattern)
+                    .orderBy('title')
+                    .limit(localLimit)
+                    .execute(),
+            type == 'movie'
+                ? []
+                : database.selectFrom('kino_tv').selectAll().where('name', 'ilike', pattern).orderBy('name').limit(localLimit).execute(),
+            tmdb()
+                .search.multi({ query, language: 'en-US', page: 1, include_adult: true })
+                .then(({ results }) => results)
+                .catch(e => {
+                io.warn('Kino: TMDB search failed: ' + io.errorText(e));
+                return [];
+            }),
+        ]);
+        const results = [];
+        const seen = new Set();
+        // Local results come first since media that has actually been uploaded is the most likely target
+        for (const movie of movies) {
+            seen.add('movie:' + movie.id);
+            results.push({ ...movie, type: 'movie' });
+        }
+        for (const show of shows) {
+            seen.add('tv:' + show.id);
+            results.push({ ...show, type: 'tv' });
+        }
+        const newMovies = [], newShows = [];
+        for (const result of multi) {
+            if (result.media_type == 'person')
+                continue;
+            if (type && result.media_type != type)
+                continue;
+            const key = `${result.media_type}:${result.id}`;
+            if (seen.has(key))
+                continue;
+            /**
+             * TMDB returns incomplete entries, e.g. an empty `release_date` for unannounced titles.
+             * Skip those instead of failing the entire search.
+             */
+            if (result.media_type == 'movie') {
+                const parsed = kt.Movie.safeParse(result);
+                if (!parsed.success)
+                    continue;
+                newMovies.push(parsed.data);
+                results.push({ ...parsed.data, type: 'movie' });
+            }
+            else {
+                const parsed = kt.Tv.safeParse(result);
+                if (!parsed.success)
+                    continue;
+                newShows.push(parsed.data);
+                results.push({ ...parsed.data, type: 'tv' });
+            }
+            seen.add(key);
+        }
+        if (__cache_aggressive__) {
+            try {
+                if (newMovies.length)
+                    await database
+                        .insertInto('kino_movies')
+                        .values(newMovies)
+                        .onConflict(oc => oc.doNothing())
+                        .execute();
+                if (newShows.length)
+                    await database
+                        .insertInto('kino_tv')
+                        .values(newShows)
+                        .onConflict(oc => oc.doNothing())
+                        .execute();
+            }
+            catch (e) {
+                io.warn('Kino: failed to cache search results: ' + io.errorText(e));
+            }
+        }
+        return results;
+    },
+});

package/dist/server/api/upload.d.ts

@@ -0,0 +1 @@
+export {};