Migrate api to websocket

.env

@@ -1,7 +1,7 @@
 VITE_CLOUDINARY_CLOUDNAME=dl7hskxab
 VITE_FRONTEND_URL=http://localhost:8004
 VITE_DM_URL=http://localhost:8001
-VITE_DM_API_URL=http://localhost:3000
+VITE_DM_SOCKET_URL=http://localhost:3000
+VITE_DUMILI_SOCKET_URL=http://localhost:3002
 VITE_FLAGS_ROOT=https://ducksmanager.net/images/flags/
 VITE_IMAGES_ROOT=/images/
-VITE_BACKEND_URL=http://localhost:3002

.env.production

@@ -1,5 +1,4 @@
 VITE_FRONTEND_URL=https://dumili.ducksmanager.net
-VITE_DM_URL=https://ducksmanager.net
-VITE_DM_API_URL=https://api-2.ducksmanager.net
+VITE_DM_URL=https://socket.ducksmanager.net
+VITE_DM_SOCKET_URL=https://socket.api.ducksmanager.net
 VITE_FLAGS_ROOT=https://ducksmanager.net/images/flags/
-VITE_BACKEND_URL=https://dumili-api.ducksmanager.net

.eslintrc.js → .eslintrc.json

@@ -1,21 +1,21 @@
-module.exports = {
-  extends: [
+{
+  "extends": [
     // add more generic rulesets here, such as:
     // 'eslint:recommended',
     "plugin:vue/vue3-recommended",
     "plugin:prettier-vue/recommended",
     "prettier",
-    "plugin:@typescript-eslint/recommended",
+    "plugin:@typescript-eslint/recommended"
   ],
-  parser: "vue-eslint-parser",
-  parserOptions: { parser: "@typescript-eslint/parser" },
-  overrides: [
+  "parser": "vue-eslint-parser",
+  "parserOptions": { "parser": "@typescript-eslint/parser" },
+  "overrides": [
     {
-      files: ["*.js", "*.ts", "*.vue"],
-    },
+      "files": ["*.ts", "*.vue"]
+    }
   ],
-  root: true,
-  rules: {
+  "root": true,
+  "rules": {
     "@typescript-eslint/no-non-null-assertion": "off",
     "simple-import-sort/exports": "error",
     "simple-import-sort/imports": "error",
@@ -32,18 +32,16 @@ module.exports = {
       "error",
       "kebab-case",
       {
-        registeredComponentsOnly: true,
-        ignores: [],
-      },
-    ],
+        "registeredComponentsOnly": true,
+        "ignores": []
+      }
+    ]
   },
-  plugins: ["simple-import-sort", "@typescript-eslint", "unused-imports"],
-  ignorePatterns: [
-    "**/node_modules",
+  "plugins": ["simple-import-sort", "@typescript-eslint", "unused-imports"],
+  "ignorePatterns": [
+    "../**",
+    "*.d.ts",
     "**/dist",
-    "shims.d.ts",
-    "vendor",
-    "auto-imports.d.ts",
-    "component.d.ts",
-  ],
-};
+    "**/node_modules"
+  ]
+}

.gitignore

@@ -27,3 +27,4 @@ dist-ssr
 .eslintcache
 auto-imports.d.ts
 components.d.ts
+api/prisma/client_*

.prettierignore

@@ -0,0 +1 @@
+..

Dockerfile

@@ -28,8 +28,6 @@ COPY {package.json,pnpm-*.yaml} /app/
 
 WORKDIR /app/apps/dumili/api
 COPY --from=build /app/apps/dumili/api/dist/api ./
-COPY --from=build /app/packages/axios-helper/package.json ./packages/axios-helper/
-COPY --from=build /app/packages/axios-helper/dist ./packages/axios-helper
 
 COPY apps/dumili/api/package.json ./
 RUN --mount=type=cache,id=pnpm-store-dumili,target=/app/.pnpm-store \

api/.env

@@ -1,6 +1,10 @@
 KUMIKO_HOST=http://localhost:8005
 OCR_HOST=http://localhost:8006
+DM_SOCKET_URL=http://localhost:3000
 
-CLOUDINARY_URL=cloudinary://my_key:my_secret@my_cloud_name
+CLOUDINARY_URL=cloudinary://my_key:my_secret@my_cloud_name?secure=true
+
+DATABASE_URL=mysql://root:changeme@localhost:64097/dumili
+MYSQL_ROOT_PASSWORD=changeme
 
 TOKEN_SECRET=3543c30fe79047b4f73cfb61aa1eb52cb3173de4b3941e0fc4ec1b127bbeed6019695a1a453a81c33c2eea964ccc577e69c7df994124bd2751e262a311ea23a1

api/.eslintrc.json

@@ -0,0 +1,25 @@
+{
+  "extends": [
+    // add more generic rulesets here, such as:
+    "eslint:recommended",
+    "plugin:prettier-vue/recommended",
+    "plugin:@typescript-eslint/recommended",
+    "prettier"
+  ],
+  "parserOptions": { "parser": "@typescript-eslint/parser" },
+  "overrides": [
+    {
+      "files": ["*.ts"]
+    }
+  ],
+  "root": true,
+  "rules": {
+    "@typescript-eslint/no-non-null-assertion": "off",
+    "simple-import-sort/exports": "error",
+    "simple-import-sort/imports": "error",
+    "unused-imports/no-unused-imports": "error"
+  },
+  "plugins": ["simple-import-sort", "@typescript-eslint", "unused-imports"],
+  "ignorePatterns": ["**/node_modules", "**/dist", 
+  "prisma/client_dumili"]
+}

api/.prettierrc.json

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

api/index.ts

@@ -1,11 +1,19 @@
-import * as Sentry from "@sentry/node";
-import busboy from "connect-busboy";
-import cors from "cors";
+import busboy from "busboy";
+import { v2 as cloudinary } from "cloudinary";
 import dotenv from "dotenv";
-import express from "express";
-import { router } from "express-file-routing";
+import fs from "fs";
+import { createServer } from "http";
+import path from "path";
+import { fromBuffer } from "pdf2pic";
+import { Namespace, Server } from "socket.io";
+import { EventsMap } from "socket.io/dist/typed-events";
 
-import { authenticateToken } from "~routes/_auth";
+import { SessionUser } from "~dm-types/SessionUser";
+
+import { PrismaClient } from "./prisma/client_dumili";
+import { authenticateUser } from "./services/_auth";
+import indexations from "./services/indexations";
+import { FullIndexation } from "./services/indexations/types";
 
 dotenv.config({
   path: ".env",
@@ -16,34 +24,166 @@ dotenv.config({
   override: true,
 });
 
-const port = 3002;
+const [, API_KEY, API_SECRET, CLOUD_NAME] =
+  process.env.CLOUDINARY_URL?.match(/cloudinary:\/\/(\d+):(\w+)@(\w+)/) ?? [];
+cloudinary.config({
+  cloud_name: CLOUD_NAME,
+  api_key: API_KEY,
+  api_secret: API_SECRET,
+});
+
+export type SessionDataWithIndexation = {
+  user: SessionUser;
+  indexation: FullIndexation;
+};
+export type SessionData = { user: SessionUser };
+export class ServerWithData<Data extends object> extends Server<
+  Record<string, never>,
+  Record<string, never>,
+  Record<string, never>,
+  Data
+> {}
+
+export type NamespaceWithData<
+  Services extends EventsMap,
+  Data extends object = object,
+> = Namespace<Services, Record<string, never>, Record<string, never>, Data>;
+
+export const prisma = new PrismaClient();
 
-Sentry.init({
-  dsn: process.env.SENTRY_DSN,
+const httpServer = createServer(async (req, res) => {
+  if (req.url === "/upload") {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Request-Method", "*");
+    res.setHeader("Access-Control-Allow-Methods", "OPTIONS, GET, POST");
+    res.setHeader("Access-Control-Allow-Headers", "*");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+    } else {
+      const { headers } = req;
+      const indexationId = headers["x-dumili-indexation-id"] as string;
+      const token = headers["x-token"] as string;
+      authenticateUser(token)
+        .then((user) => {
+          const filename = "";
+          const bb = busboy({ headers });
+          bb.on("file", async (name, file, info) => {
+            let imagesToUpload: string[];
+            switch (info.mimeType) {
+              case "image/jpg":
+              case "image/jpeg":
+              case "image/png": {
+                const saveTo = path.join(__dirname, name);
+                file.pipe(fs.createWriteStream(saveTo));
+                imagesToUpload = [filename];
+                break;
+              }
+              case "application/pdf": {
+                const chunks = [];
+                for await (const chunk of file) {
+                  chunks.push(chunk);
+                }
+                const buffer = Buffer.concat(chunks);
+                imagesToUpload = (
+                  await fromBuffer(buffer, {
+                    saveFilename: info.filename.replace(".pdf", ""),
+                  }).bulk(-1)
+                ).map(({ path }) => path!);
+                break;
+              }
+              default:
+                res.writeHead(400, { "Content-Type": "text/plain" });
+                res.write("Unsupported file type:" + info.mimeType);
+                return;
+            }
+
+            const firstNewPageNumber =
+              (
+                await prisma.page.findFirst({
+                  where: {
+                    indexationId: indexationId,
+                  },
+                  orderBy: {
+                    pageNumber: "desc",
+                  },
+                })
+              )?.pageNumber ?? 0;
+
+            const uploadedImages = (await Promise.all(
+              imagesToUpload.map(async (filename) =>
+                cloudinary.uploader
+                  .upload(filename, {
+                    upload_preset: "p1urov1k",
+                    folder: `dumili/${user.username}/${indexationId}`,
+                  })
+                  .then(({ secure_url }) => secure_url)
+                  .catch((e) => {
+                    console.error(e);
+                    res.writeHead(500, { "Content-Type": "text/plain" });
+                    res.end(e);
+                  })
+                  .finally(() => {
+                    fs.unlinkSync(filename);
+                  }),
+              ),
+            )) as string[];
+            const pagesToCreate = {
+              pages: {
+                create: uploadedImages.map((url, idx) => ({
+                  pageNumber: firstNewPageNumber + idx + 1,
+                  url,
+                })),
+              },
+            };
+
+            prisma.indexation
+              .upsert({
+                where: {
+                  id: indexationId,
+                },
+                update: pagesToCreate,
+                create: {
+                  dmUserId: user.id,
+                  id: indexationId,
+                  ...pagesToCreate,
+                },
+              })
+              .then(() => {
+                res.writeHead(200, { "Content-Type": "text/plain" });
+                res.end(`upload success: ${filename}`);
+              })
+              .catch((e) => {
+                console.error(e);
+                res.writeHead(401, { "Content-Type": "text/plain" });
+                res.end(e);
+              });
+          });
+          bb.on("close", () => {
+            res.writeHead(200, { "Content-Type": "text/plain" });
+            res.end(`upload success: ${filename}`);
+          });
+          req.pipe(bb);
+        })
+        .catch((e) => {
+          console.error(e);
+          res.writeHead(401, { "Content-Type": "text/plain" });
+          res.end(e);
+        });
+    }
+  } else {
+    res.writeHead(404);
+    res.end();
+  }
 });
 
-const app = express();
-app.use(
-  Sentry.Handlers.requestHandler({
-    user: ["id", "username"],
-  }) as express.RequestHandler
-);
-app.use(
-  cors({
-    optionsSuccessStatus: 200, // some legacy browsers (IE11, various SmartTVs) choke on 204
-  })
-);
-app.use(busboy({ immediate: true }));
-
-app.all(/^.+$/, authenticateToken);
-
-app.use(express.json({ limit: "5mb" }));
-
-router().then((r) => {
-  app.use("/", r);
-  app.use(Sentry.Handlers.errorHandler() as express.ErrorRequestHandler);
-
-  app.listen(port, () => {
-    console.log(`API listening on port ${port}`);
-  });
+const io = new Server(httpServer, {
+  cors: {
+    origin: "*",
+  },
 });
+
+indexations(io);
+
+httpServer.listen(3002);
+console.log("Dumuli API open on port 3002");