wip

Author: OllysCoding

README.md

@@ -50,3 +50,5 @@ Bumpgen offers a number of default templates to use for your channels, as well a
 - Plugins: some kind of versioning + publish types + example repo + language/locale in template
 - Frontend for configuring
 - Allow animations?
+- Unit tests
+- Publishing & output comparison (maybe via some kind of PR & github actions?)

apps/backend/.swcrc

@@ -2,7 +2,13 @@
   "jsc": {
     "parser": {
       "syntax": "typescript",
-      "tsx": false
+      "tsx": false,
+      "decorators": true
+    },
+    "target": "es2016",
+    "transform": {
+      "legacyDecorator": false,
+      "decoratorMetadata": true
     }
   }
 }

apps/backend/package.json

@@ -24,13 +24,17 @@
     "dotenv": "^16.4.7",
     "fabric": "^6.5.4",
     "fastify": "^5.1.0",
+    "fastify-plugin": "^5.0.1",
     "ffmpeg-static": "^4.4.1",
     "ffprobe-static": "^3.1.0",
     "fluent-ffmpeg": "^2.1.3",
     "glob": "^11.0.0",
     "gsap": "^3.12.5",
     "node-schedule": "^2.1.1",
-    "ts-node": "^10.9.2"
+    "reflect-metadata": "^0.2.2",
+    "ts-node": "^10.9.2",
+    "typedi": "^0.10.0",
+    "ws": "^8.18.0"
   },
   "devDependencies": {
     "@swc/cli": "^0.5.2",
@@ -39,6 +43,7 @@
     "@types/ffmpeg-static": "^3.0.3",
     "@types/ffprobe-static": "^2.0.3",
     "@types/fluent-ffmpeg": "^2.1.27",
-    "@types/node-schedule": "^2.1.7"
+    "@types/node-schedule": "^2.1.7",
+    "@types/ws": "^8.5.14"
   }
 }

apps/backend/src/api/index.ts

@@ -0,0 +1,50 @@
+import Fastify from "fastify";
+
+import errorsPlugin from "./plugins/errors.js";
+import isInitiliazedPlugin from "./plugins/isInitiliazed.js";
+
+import settingsRoutes from "./routes/settings.js";
+import cacheRoutes from "./routes/cache.js";
+import initializeRoutes from "./routes/initialize.js";
+import Container from "typedi";
+import { LiveStatsService } from "../services/LiveStatsService.js";
+
+const V1_API_BASE = "/api/v1";
+
+export const initializeApi = async () => {
+  const fastify = Fastify({
+    logger: true,
+  });
+
+  // Register plugins
+  fastify.register(errorsPlugin);
+
+  // Register routers that can be accessed pre-initialization
+  fastify.register(initializeRoutes, { prefix: `${V1_API_BASE}/initialize` });
+
+  fastify.register(isInitiliazedPlugin, (fastifyWithAppInitialized) => {
+    // Register routes
+    fastifyWithAppInitialized.register(settingsRoutes, {
+      prefix: `${V1_API_BASE}/settings`,
+    });
+    fastifyWithAppInitialized.register(cacheRoutes, {
+      prefix: `${V1_API_BASE}/cache`,
+    });
+  });
+
+  fastify.server.on("upgrade", (req, socket, head) => {
+    console.log(req.url);
+    if (req.url === "/ws") {
+      Container.get(LiveStatsService).wss.handleUpgrade(
+        req,
+        socket,
+        head,
+        function done(ws) {
+          Container.get(LiveStatsService).wss.emit("connection", ws, req);
+        },
+      );
+    }
+  });
+
+  await fastify.listen({ port: 4000 });
+};

apps/backend/src/api/plugins/errors.ts

@@ -0,0 +1,71 @@
+import type { FastifyPluginCallback } from "fastify";
+import fp from "fastify-plugin";
+
+export enum ApiErrorType {
+  APP_NOT_INITIALIZED = 100,
+  APP_ALREADY_INITIALIZED = 101,
+  UNABLE_TO_INITIALIZE = 102,
+  UNABLE_TO_ADD_RESOURCE = 200,
+  UNABLE_TO_UPDATE_RESOURCE = 201,
+}
+
+declare module "fastify" {
+  interface FastifyReply {
+    sendError: (errorType: ApiErrorType, errorSpecifics?: unknown) => void;
+  }
+}
+
+const pluginCallback: FastifyPluginCallback = (fastify, options, done) => {
+  fastify.decorateReply(
+    "sendError",
+    function (errorType: ApiErrorType, errorSpecifics: unknown) {
+      const baseError = {
+        error: true,
+        code: errorType,
+        errorSpecifics,
+      };
+
+      switch (errorType) {
+        case ApiErrorType.APP_NOT_INITIALIZED: {
+          this.status(500).send({
+            ...baseError,
+            message: "App is not initialized",
+          });
+          break;
+        }
+        case ApiErrorType.APP_ALREADY_INITIALIZED: {
+          this.status(500).send({
+            ...baseError,
+            message: "App is already initialized",
+          });
+          break;
+        }
+        case ApiErrorType.UNABLE_TO_INITIALIZE: {
+          this.status(500).send({
+            ...baseError,
+            message: "Failed to initialize app",
+          });
+          break;
+        }
+        case ApiErrorType.UNABLE_TO_ADD_RESOURCE: {
+          this.status(500).send({
+            ...baseError,
+            message: "Unable to add resource",
+          });
+          break;
+        }
+        case ApiErrorType.UNABLE_TO_UPDATE_RESOURCE: {
+          this.status(500).send({
+            ...baseError,
+            message: "Unable to update resource",
+          });
+          break;
+        }
+      }
+    },
+  );
+
+  done();
+};
+
+export default fp(pluginCallback);

apps/backend/src/api/plugins/isInitiliazed.ts

@@ -0,0 +1,24 @@
+import type { FastifyPluginCallback } from "fastify";
+import fp from "fastify-plugin";
+import { ApiErrorType } from "./errors.js";
+import { Container } from "typedi";
+import { AppConfigService } from "../../services/AppConfigService.js";
+
+const pluginCallback: FastifyPluginCallback = (fastify, options, done) => {
+  fastify.addHook("onRequest", (request, reply, done) => {
+    if (!Container.get(AppConfigService).isInitialized) {
+      reply.sendError(ApiErrorType.APP_NOT_INITIALIZED);
+    } else {
+      done();
+    }
+  });
+
+  done();
+};
+
+export default fp(pluginCallback, {
+  encapsulate: true,
+  decorators: {
+    reply: ["sendError"],
+  },
+});

apps/backend/src/api/routes/cache.ts

@@ -0,0 +1,68 @@
+import type { FastifyInstance /* FastifyRegisterOptions */ } from "fastify";
+
+import { type Static, Type } from "@sinclair/typebox";
+import { Container } from "typedi";
+import { XmlTvService } from "../../services/XmlTvService.js";
+import { BackgroundContentService } from "../../services/BackgroundContentService.js";
+import { TemplatesService } from "../../services/TemplatesService.js";
+import { unwrap } from "../../result/index.js";
+
+const CacheDataSchema = Type.Object({
+  channels: Type.Array(
+    Type.Object({
+      name: Type.String(),
+      id: Type.String(),
+    }),
+  ),
+  backgroundContent: Type.Array(
+    Type.Object({
+      fullPath: Type.String(),
+      relativePath: Type.String(),
+      length: Type.Number(),
+    }),
+  ),
+  templates: Type.Array(
+    Type.Object({
+      name: Type.String(),
+    }),
+  ),
+});
+
+type CacheData = Static<typeof CacheDataSchema>;
+
+const routes = async (
+  fastify: FastifyInstance,
+  // options: FastifyRegisterOptions<never>,
+) => {
+  fastify.get<{ Reply: CacheData }>(
+    "/",
+    { schema: { response: { 200: CacheDataSchema } } },
+    (request, reply) => {
+      const xmlTvService = Container.get(XmlTvService);
+      const backgroundContentService = Container.get(BackgroundContentService);
+      const templatesService = Container.get(TemplatesService);
+
+      reply.status(200).send({
+        channels: xmlTvService.channels.map((channel) => ({
+          name:
+            unwrap(
+              xmlTvService.getValueForConfiguredLang(channel.displayName),
+            ) || "unknown",
+          id: channel.id,
+        })),
+        backgroundContent: backgroundContentService.files.map(
+          ({ fullPath, relativePath, length }) => ({
+            fullPath,
+            relativePath,
+            length,
+          }),
+        ),
+        templates: Object.keys(templatesService.templates).map((name) => ({
+          name,
+        })),
+      });
+    },
+  );
+};
+
+export default routes;

apps/backend/src/api/routes/initialize.ts

@@ -0,0 +1,56 @@
+import type { FastifyInstance /* FastifyRegisterOptions */ } from "fastify";
+import { type Static, Type } from "@sinclair/typebox";
+import { ApiErrorType } from "../plugins/errors.js";
+import { isFailure } from "../../result/index.js";
+import { Container } from "typedi";
+import { AppConfigService } from "../../services/AppConfigService.js";
+
+const InitializeSchema = Type.Object({
+  xmlTvUrl: Type.String(),
+  language: Type.String(),
+  outputFolder: Type.String(),
+  backgroundContentFolder: Type.String(),
+});
+
+type InitializeSchema = Static<typeof InitializeSchema>;
+
+const routes = async (
+  fastify: FastifyInstance,
+  // options: FastifyRegisterOptions<never>,
+) => {
+  fastify.get("/", () => {
+    const appConfigService = Container.get(AppConfigService);
+    return {
+      isInitialized: appConfigService.isInitialized,
+    };
+  });
+
+  fastify.post<{ Body: InitializeSchema }>(
+    "/",
+    { schema: { body: InitializeSchema } },
+    async (request, reply) => {
+      const appConfigService = Container.get(AppConfigService);
+      if (appConfigService.isInitialized) {
+        reply.sendError(ApiErrorType.APP_ALREADY_INITIALIZED);
+      } else {
+        const result = await appConfigService.initializeFromDefaults(
+          request.body.xmlTvUrl,
+          request.body.language,
+          request.body.outputFolder,
+          request.body.backgroundContentFolder,
+        );
+
+        if (isFailure(result)) {
+          reply.sendError(
+            ApiErrorType.UNABLE_TO_INITIALIZE,
+            result.error.message,
+          );
+        } else {
+          reply.status(200).send(appConfigService.config);
+        }
+      }
+    },
+  );
+};
+
+export default routes;