Add preliminary prisma support

electron/electron-env.d.ts

@@ -2,10 +2,10 @@
 
 declare namespace NodeJS {
   interface ProcessEnv {
-    VSCODE_DEBUG?: 'true'
-    DIST_ELECTRON: string
-    DIST: string
+    DIST: string;
+    DIST_ELECTRON: string;
     /** /dist/ or /public/ */
-    PUBLIC: string
+    PUBLIC: string;
+    VSCODE_DEBUG?: 'true';
   }
 }

electron/main/features/core/api/index.ts

@@ -0,0 +1,126 @@
+import fs from 'fs';
+import path from 'path';
+import { PrismaClient } from '@prisma/client';
+import { app, ipcMain } from 'electron';
+import isDev from 'electron-is-dev';
+import './server';
+
+const dbPath = isDev
+  ? path.join(__dirname, '../../../../prisma/dev.db')
+  : path.join(app.getPath('userData'), 'database.db');
+
+if (!isDev) {
+  try {
+    // database file does not exist, need to create
+    fs.copyFileSync(path.join(process.resourcesPath, 'prisma/dev.db'), dbPath, fs.constants.COPYFILE_EXCL);
+    console.log(`DB does not exist. Create new DB from ${path.join(process.resourcesPath, 'prisma/dev.db')}`);
+  } catch (err) {
+    if (err && 'code' in (err as { code: string }) && (err as { code: string }).code !== 'EEXIST') {
+      console.error(`DB creation faild. Reason:`, err);
+    } else {
+      throw err;
+    }
+  }
+}
+
+function getPlatformName(): string {
+  const isDarwin = process.platform === 'darwin';
+  if (isDarwin && process.arch === 'arm64') {
+    return `${process.platform}Arm64`;
+  }
+
+  return process.platform;
+}
+
+const platformToExecutables: Record<string, any> = {
+  darwin: {
+    migrationEngine: 'node_modules/@prisma/engines/migration-engine-darwin',
+    queryEngine: 'node_modules/@prisma/engines/libquery_engine-darwin.dylib.node',
+  },
+  darwinArm64: {
+    migrationEngine: 'node_modules/@prisma/engines/migration-engine-darwin-arm64',
+    queryEngine: 'node_modules/@prisma/engines/libquery_engine-darwin-arm64.dylib.node',
+  },
+  linux: {
+    migrationEngine: 'node_modules/@prisma/engines/migration-engine-debian-openssl-1.1.x',
+    queryEngine: 'node_modules/@prisma/engines/libquery_engine-debian-openssl-1.1.x.so.node',
+  },
+  win32: {
+    migrationEngine: 'node_modules/@prisma/engines/migration-engine-windows.exe',
+    queryEngine: 'node_modules/@prisma/engines/query_engine-windows.dll.node',
+  },
+};
+
+const extraResourcesPath = app.getAppPath().replace('app.asar', ''); // impacted by extraResources setting in electron-builder.yml
+const platformName = getPlatformName();
+
+const mePath = path.join(extraResourcesPath, platformToExecutables[platformName].migrationEngine);
+const qePath = path.join(extraResourcesPath, platformToExecutables[platformName].queryEngine);
+
+ipcMain.on('config:get-app-path', (event) => {
+  event.returnValue = app.getAppPath();
+});
+
+ipcMain.on('config:get-platform-name', (event) => {
+  const isDarwin = process.platform === 'darwin';
+  event.returnValue =
+    isDarwin && process.arch === 'arm64' ? `${process.platform}Arm64` : (event.returnValue = process.platform);
+});
+
+ipcMain.on('config:get-prisma-db-path', (event) => {
+  event.returnValue = dbPath;
+});
+
+ipcMain.on('config:get-prisma-me-path', (event) => {
+  event.returnValue = mePath;
+});
+
+ipcMain.on('config:get-prisma-qe-path', (event) => {
+  event.returnValue = qePath;
+});
+
+export const prisma = new PrismaClient({
+  datasources: {
+    db: {
+      url: `file:${dbPath}`,
+    },
+  },
+  errorFormat: 'minimal',
+  // see https://github.com/prisma/prisma/discussions/5200
+  // __internal: {
+  //   engine: {
+  //     binaryPath: qePath,
+  //   },
+  // },
+});
+
+prisma.server.findMany({
+  where: {},
+});
+
+export const exclude = <T, Key extends keyof T>(resultSet: T, ...keys: Key[]): Omit<T, Key> => {
+  // eslint-disable-next-line no-restricted-syntax
+  for (const key of keys) {
+    delete resultSet[key];
+  }
+  return resultSet;
+};
+
+function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+prisma.$use(async (params, next) => {
+  const maxRetries = 5;
+  let retries = 0;
+
+  do {
+    try {
+      const result = await next(params);
+      return result;
+    } catch (err) {
+      retries += 1;
+      return sleep(500);
+    }
+  } while (retries < maxRetries);
+});

electron/main/features/core/api/server/index.ts

@@ -0,0 +1,12 @@
+import { ipcMain } from 'electron';
+import { prisma } from '..';
+
+export enum ServerApi {
+  GET_SERVER = 'api:server:get-server',
+  GET_SERVERS = 'api:server:get-servers',
+}
+
+ipcMain.handle(ServerApi.GET_SERVERS, async () => {
+  const result = await prisma.server.findMany();
+  return result;
+});

electron/main/features/core/index.ts

@@ -0,0 +1,2 @@
+import './mpv-player';
+import './api';

electron/main/features/core/mpv-player/index.ts

@@ -0,0 +1,134 @@
+import { ipcMain } from 'electron';
+import MpvAPI from 'node-mpv';
+import { getWindow } from '../../..';
+
+const mpv = new MpvAPI(
+  {
+    audio_only: true,
+    auto_restart: true,
+    binary: 'C:/ProgramData/chocolatey/lib/mpv.install/tools/mpv.exe',
+    time_update: 1,
+  },
+  ['--gapless-audio=yes', '--prefetch-playlist']
+);
+
+mpv.start().catch((error: any) => {
+  console.log('error', error);
+});
+
+mpv.on('status', (status: any) => {
+  if (status.property === 'playlist-pos') {
+    if (status.value !== 0) {
+      getWindow()?.webContents.send('renderer-player-auto-next');
+    }
+  }
+});
+
+// Automatically updates the play button when the player is playing
+mpv.on('started', () => {
+  getWindow()?.webContents.send('renderer-player-play');
+});
+
+// Automatically updates the play button when the player is stopped
+mpv.on('stopped', () => {
+  getWindow()?.webContents.send('renderer-player-stop');
+});
+
+// Automatically updates the play button when the player is paused
+mpv.on('paused', () => {
+  getWindow()?.webContents.send('renderer-player-pause');
+});
+
+mpv.on('quit', () => {
+  console.log('mpv quit');
+});
+
+// Event output every interval set by time_update, used to update the current time
+mpv.on('timeposition', (time: number) => {
+  getWindow()?.webContents.send('renderer-player-current-time', time);
+});
+
+mpv.on('seek', () => {
+  console.log('mpv seek');
+});
+
+// Starts the player
+ipcMain.on('player-play', async () => {
+  await mpv.play();
+});
+
+// Pauses the player
+ipcMain.on('player-pause', async () => {
+  await mpv.pause();
+});
+
+// Stops the player
+ipcMain.on('player-stop', async () => {
+  await mpv.stop();
+});
+
+// Stops the player
+ipcMain.on('player-next', async () => {
+  await mpv.next();
+});
+
+// Stops the player
+ipcMain.on('player-previous', async () => {
+  await mpv.prev();
+});
+
+// Seeks forward or backward by the given amount of seconds
+ipcMain.on('player-seek', async (_event, time: number) => {
+  await mpv.seek(time);
+});
+
+// Seeks to the given time in seconds
+ipcMain.on('player-seek-to', async (_event, time: number) => {
+  await mpv.goToPosition(time);
+});
+
+// Sets the queue in position 0 and 1 to the given data. Used when manually starting a song or using the next/prev buttons
+ipcMain.on('player-set-queue', async (_event, data: any) => {
+  if (data.queue.current) {
+    await mpv.load(data.queue.current.streamUrl, 'replace');
+  }
+
+  if (data.queue.next) {
+    await mpv.load(data.queue.next.streamUrl, 'append');
+  }
+});
+
+// Replaces the queue in position 1 to the given data
+ipcMain.on('player-set-queue-next', async (_event, data: any) => {
+  const size = await mpv.getPlaylistSize();
+
+  if (size > 1) {
+    await mpv.playlistRemove(1);
+  }
+
+  if (data.queue.next) {
+    await mpv.load(data.queue.next.streamUrl, 'append');
+  }
+});
+
+// Sets the next song in the queue when reaching the end of the queue
+ipcMain.on('player-auto-next', async (_event, data: any) => {
+  // Always keep the current song as position 0 in the mpv queue
+  // This allows us to easily set update the next song in the queue without
+  // disturbing the currently playing song
+  await mpv.playlistRemove(0);
+
+  if (data.queue.next) {
+    await mpv.load(data.queue.next.streamUrl, 'append');
+  }
+});
+
+// Sets the volume to the given value (0-100)
+ipcMain.on('player-volume', async (_event, value: number) => {
+  mpv.volume(value);
+});
+
+// Toggles the mute status
+ipcMain.on('player-mute', async () => {
+  mpv.mute();
+});

electron/main/features/index.ts

@@ -0,0 +1,3 @@
+import './core';
+
+require(`./${process.platform}`);

electron/main/index.ts

@@ -8,21 +8,20 @@
 // ├─┬ dist
 // │ └── index.html    > Electron-Renderer
 //
-process.env.DIST_ELECTRON = join(__dirname, "..");
-process.env.DIST = join(process.env.DIST_ELECTRON, "../dist");
-process.env.PUBLIC = app.isPackaged
-  ? process.env.DIST
-  : join(process.env.DIST_ELECTRON, "../public");
+process.env.DIST_ELECTRON = join(__dirname, '..');
+process.env.DIST = join(process.env.DIST_ELECTRON, '../dist');
+process.env.PUBLIC = app.isPackaged ? process.env.DIST : join(process.env.DIST_ELECTRON, '../public');
 
-import { app, BrowserWindow, shell, ipcMain } from "electron";
-import { release } from "os";
-import { join } from "path";
+import { release } from 'os';
+import { join } from 'path';
+import { app, BrowserWindow, shell, ipcMain } from 'electron';
+import './features';
 
 // Disable GPU Acceleration for Windows 7
-if (release().startsWith("6.1")) app.disableHardwareAcceleration();
+if (release().startsWith('6.1')) app.disableHardwareAcceleration();
 
 // Set application name for Windows 10+ notifications
-if (process.platform === "win32") app.setAppUserModelId(app.getName());
+if (process.platform === 'win32') app.setAppUserModelId(app.getName());
 
 if (!app.requestSingleInstanceLock()) {
   app.quit();
@@ -31,18 +30,18 @@ if (!app.requestSingleInstanceLock()) {
 
 let win: BrowserWindow | null = null;
 // Here, you can also use other preload
-const preload = join(__dirname, "../preload/index.js");
+const preload = join(__dirname, '../preload/index.js');
 const url = process.env.VITE_DEV_SERVER_URL;
-const indexHtml = join(process.env.DIST, "index.html");
+const indexHtml = join(process.env.DIST, 'index.html');
 
 async function createWindow() {
   win = new BrowserWindow({
-    title: "Main window",
-    icon: join(process.env.PUBLIC, "favicon.svg"),
+    icon: join(process.env.PUBLIC, 'favicon.svg'),
+    title: 'Main window',
     webPreferences: {
-      preload,
-      nodeIntegration: false,
       contextIsolation: true,
+      nodeIntegration: false,
+      preload,
     },
   });
 
@@ -54,25 +53,25 @@ async function createWindow() {
   }
 
   // Test actively push message to the Electron-Renderer
-  win.webContents.on("did-finish-load", () => {
-    win?.webContents.send("main-process-message", new Date().toLocaleString());
+  win.webContents.on('did-finish-load', () => {
+    win?.webContents.send('main-process-message', new Date().toLocaleString());
   });
 
   // Make all links open with the browser, not with the application
   win.webContents.setWindowOpenHandler(({ url }) => {
-    if (url.startsWith("https:")) shell.openExternal(url);
-    return { action: "deny" };
+    if (url.startsWith('https:')) shell.openExternal(url);
+    return { action: 'deny' };
   });
 }
 
 app.whenReady().then(createWindow);
 
-app.on("window-all-closed", () => {
+app.on('window-all-closed', () => {
   win = null;
-  if (process.platform !== "darwin") app.quit();
+  if (process.platform !== 'darwin') app.quit();
 });
 
-app.on("second-instance", () => {
+app.on('second-instance', () => {
   if (win) {
     // Focus on the main window if the user tried to open another
     if (win.isMinimized()) win.restore();
@@ -80,7 +79,7 @@ app.on("second-instance", () => {
   }
 });
 
-app.on("activate", () => {
+app.on('activate', () => {
   const allWindows = BrowserWindow.getAllWindows();
   if (allWindows.length) {
     allWindows[0].focus();
@@ -90,7 +89,7 @@ app.on("activate", () => {
 });
 
 // new window example arg: new windows url
-ipcMain.handle("open-win", (event, arg) => {
+ipcMain.handle('open-win', (event, arg) => {
   const childWindow = new BrowserWindow({
     webPreferences: {
       preload,
@@ -104,3 +103,7 @@ ipcMain.handle("open-win", (event, arg) => {
     // childWindow.webContents.openDevTools({ mode: "undocked", activate: true })
   }
 });
+
+export const getWindow = () => {
+  return win;
+};

electron/preload/index.ts

@@ -1,31 +1,31 @@
-import { contextBridge } from "electron"
+import { contextBridge, ipcRenderer } from 'electron';
 
 function domReady(condition: DocumentReadyState[] = ['complete', 'interactive']) {
-  return new Promise(resolve => {
+  return new Promise((resolve) => {
     if (condition.includes(document.readyState)) {
-      resolve(true)
+      resolve(true);
     } else {
       document.addEventListener('readystatechange', () => {
         if (condition.includes(document.readyState)) {
-          resolve(true)
+          resolve(true);
         }
-      })
+      });
     }
-  })
+  });
 }
 
 const safeDOM = {
   append(parent: HTMLElement, child: HTMLElement) {
-    if (!Array.from(parent.children).find(e => e === child)) {
-      return parent.appendChild(child)
+    if (!Array.from(parent.children).find((e) => e === child)) {
+      return parent.appendChild(child);
     }
   },
   remove(parent: HTMLElement, child: HTMLElement) {
-    if (Array.from(parent.children).find(e => e === child)) {
-      return parent.removeChild(child)
+    if (Array.from(parent.children).find((e) => e === child)) {
+      return parent.removeChild(child);
     }
   },
-}
+};
 
 /**
  * https://tobiasahlin.com/spinkit
@@ -34,7 +34,7 @@ const safeDOM = {
  * https://matejkustec.github.io/SpinThatShit
  */
 function useLoading() {
-  const className = `loaders-css__square-spin`
+  const className = `loaders-css__square-spin`;
   const styleContent = `
 @keyframes square-spin {
   25% { transform: perspective(100px) rotateX(180deg) rotateY(0); }
@@ -61,39 +61,47 @@ function useLoading() {
   background: #282c34;
   z-index: 9;
 }
-    `
-  const oStyle = document.createElement('style')
-  const oDiv = document.createElement('div')
+    `;
+  const oStyle = document.createElement('style');
+  const oDiv = document.createElement('div');
 
-  oStyle.id = 'app-loading-style'
-  oStyle.innerHTML = styleContent
-  oDiv.className = 'app-loading-wrap'
-  oDiv.innerHTML = `<div class="${className}"><div></div></div>`
+  oStyle.id = 'app-loading-style';
+  oStyle.innerHTML = styleContent;
+  oDiv.className = 'app-loading-wrap';
+  oDiv.innerHTML = `<div class="${className}"><div></div></div>`;
 
   return {
     appendLoading() {
-      safeDOM.append(document.head, oStyle)
-      safeDOM.append(document.body, oDiv)
+      safeDOM.append(document.head, oStyle);
+      safeDOM.append(document.body, oDiv);
     },
     removeLoading() {
-      safeDOM.remove(document.head, oStyle)
-      safeDOM.remove(document.body, oDiv)
+      safeDOM.remove(document.head, oStyle);
+      safeDOM.remove(document.body, oDiv);
     },
-  }
+  };
 }
 
 // ----------------------------------------------------------------------
 
-const { appendLoading, removeLoading } = useLoading()
-domReady().then(appendLoading)
+const { appendLoading, removeLoading } = useLoading();
+domReady().then(appendLoading);
 
-window.onmessage = ev => {
-  ev.data.payload === 'removeLoading' && removeLoading()
-}
+window.onmessage = (ev) => {
+  ev.data.payload === 'removeLoading' && removeLoading();
+};
 
-setTimeout(removeLoading, 4999)
+setTimeout(removeLoading, 4999);
 
+const serverApi = {
+  getServer: () => ipcRenderer.invoke('api:server:get-server'), // ServerApi.GET_SERVER
+  getServers: () => ipcRenderer.invoke('api:server:get-servers'), // ServerApi.GET_SERVERS
+};
 
-contextBridge.exposeInMainWorld('electron', {
-  doThing: () => console.log('hello'),
-});
+const api = {
+  prisma: {
+    server: serverApi,
+  },
+};
+
+contextBridge.exposeInMainWorld('electron', api);