Merge branch 'main' into poc/onboarding-setup

# Conflicts:
#	app/api/agent/[agentId]/status/helpers.ts

CITATION.cff

@@ -33,5 +33,5 @@ keywords:
   - web-ui
   - agent
 license: Apache-2.0
-version: 1.20.1
+version: 1.20.2
 date-released: '2026-03-02'

app/api/agent/[agentId]/status/helpers.ts

@@ -1,36 +1,24 @@
-import { NextResponse } from "next/server";
+import {NextResponse} from "next/server";
-import { Body } from "./route";
+import {Body} from "./route";
-import { Agent } from "@/db/schema/08_agent";
+import {isUuidv4} from "@/utils/verify-uuid";
-import { DatabaseWith } from "@/db/schema/07_database";
+import {Agent} from "@/db/schema/08_agent";
+import {DatabaseWith} from "@/db/schema/07_database";
 import * as drizzleDb from "@/db";
-import { db, db as dbClient } from "@/db";
+import {db, db as dbClient} from "@/db";
-import { and, eq, inArray } from "drizzle-orm";
+import {and, eq, inArray} from "drizzle-orm";
-import { dbmsEnumSchema, EDbmsSchema } from "@/db/schema/types";
+import {dbmsEnumSchema, EDbmsSchema} from "@/db/schema/types";
-import { withUpdatedAt } from "@/db/utils";
+import {withUpdatedAt} from "@/db/utils";
-import type { StorageInput } from "@/features/storages/types";
+import type {StorageInput} from "@/features/storages/storages.types";
-import { dispatchStorage } from "@/features/storages/utils/storages.dispatch";
+import {dispatchStorage} from "@/features/storages/storages.dispatch";
-import { Setting } from "@/db/schema/01_setting";
+import {Setting} from "@/db/schema/01_setting";
-import { logger } from "@/lib/logger";
+import {logger} from "@/lib/logger";
-import { isUUID } from "@/utils/text";
 
-const log = logger.child({ module: "api/agent/status/helpers" });
+const log = logger.child({module: "api/agent/status/helpers"});
 
-export async function handleDatabases(
+export async function handleDatabases(body: Body, agent: Agent, lastContact: Date, settings: Setting) {
-  body: Body,
-  agent: Agent,
-  lastContact: Date,
-  settings: Setting,
-) {
     const databasesResponse = [];
 
-  const formatDatabase = (
+    const formatDatabase = (database: DatabaseWith, backupAction: boolean, restoreAction: boolean, UrlBackup: string | null, storages: PingDatabaseStorageChannels[], urlMeta: string | null, backupSize: number | null) => ({
-    database: DatabaseWith,
-    backupAction: boolean,
-    restoreAction: boolean,
-    UrlBackup: string | null,
-    storages: PingDatabaseStorageChannels[],
-    urlMeta: string | null,
-  ) => ({
         generatedId: database.agentDatabaseId,
         dbms: database.dbms,
         storages: storages,
@@ -44,36 +32,36 @@ export async function handleDatabases(
                 action: restoreAction,
                 file: UrlBackup,
                 metaFile: urlMeta,
+                size: backupSize
             },
         },
     });
 
     for (const db of body.databases) {
+
         const existingDatabase = await dbClient.query.database.findFirst({
             where: eq(drizzleDb.schemas.database.agentDatabaseId, db.generatedId),
             with: {
-        project: true,
+                project: true
-      },
+            }
         });
 
-    let backupAction: boolean = false;
+        let backupAction: boolean = false
-    let restoreAction: boolean = false;
+        let restoreAction: boolean = false
         let urlBackup: string | null = null;
-    let urlMeta: string | null = null;
+        let urlMeta: string | null = null
+        let backupSize: number | null = null
 
         if (!existingDatabase) {
-      if (!isUUID(db.generatedId)) {
+            if (!isUuidv4(db.generatedId)) {
                 return NextResponse.json(
-          { error: "generatedId is not a valid uuid" },
+                    {error: "generatedId is not a valid uuid"},
-          { status: 500 },
+                    {status: 500}
                 );
             }
 
             if (!dbmsEnumSchema.safeParse(db.dbms).success) {
-        log.error(
+                log.error({name: "handleDatabases"},`Database type not available: ${db.dbms}`);
-          { name: "handleDatabases" },
-          `Database type not available: ${db.dbms}`,
-        );
                 continue;
             }
 
@@ -85,92 +73,80 @@ export async function handleDatabases(
                     dbms: db.dbms as EDbmsSchema,
                     agentDatabaseId: db.generatedId,
                     lastContact: db.pingStatus ? lastContact : null,
-          healthErrorCount: null,
+                    healthErrorCount: null
                 })
                 .returning();
 
+
             if (databaseCreated) {
-        await dbClient.insert(drizzleDb.schemas.healthcheckLog).values({
+
+
+                await dbClient
+                    .insert(drizzleDb.schemas.healthcheckLog)
+                    .values({
                         kind: "database",
                         status: db.pingStatus ? "success" : "failed",
                         objectId: databaseCreated.id,
-          date: lastContact,
+                        date: lastContact
-        });
+                    })
 
-        const storages = await getDatabaseStorageChannels(databaseCreated.id);
+                const storages = await getDatabaseStorageChannels(databaseCreated.id)
 
-        databasesResponse.push(
+                databasesResponse.push(formatDatabase(databaseCreated, backupAction, restoreAction, urlBackup, storages, null, null));
-          formatDatabase(
-            databaseCreated,
-            backupAction,
-            restoreAction,
-            urlBackup,
-            storages,
-            null,
-          ),
-        );
             }
         } else {
+
             const [databaseUpdated] = await dbClient
                 .update(drizzleDb.schemas.database)
-        .set(
+                .set(withUpdatedAt({
-          withUpdatedAt({
                     name: db.name,
                     agentId: agent.id,
                     dbms: db.dbms as EDbmsSchema,
-            lastContact: db.pingStatus
+                    lastContact: db.pingStatus ? lastContact : existingDatabase.lastContact,
-              ? lastContact
+                    healthErrorCount: db.pingStatus ? null : existingDatabase.healthErrorCount,
-              : existingDatabase.lastContact,
+                }))
-            healthErrorCount: db.pingStatus
-              ? null
-              : existingDatabase.healthErrorCount,
-          }),
-        )
                 .where(eq(drizzleDb.schemas.database.id, existingDatabase.id))
                 .returning();
 
-      await dbClient.insert(drizzleDb.schemas.healthcheckLog).values({
+
+            await dbClient
+                .insert(drizzleDb.schemas.healthcheckLog)
+                .values({
                     kind: "database",
                     status: db.pingStatus ? "success" : "failed",
                     objectId: databaseUpdated.id,
-        date: lastContact,
+                    date: lastContact
-      });
+                })
+
 
             const activeBackup = await dbClient.query.backup.findFirst({
                 where: and(
                     eq(drizzleDb.schemas.backup.databaseId, databaseUpdated.id),
-          inArray(drizzleDb.schemas.backup.status, ["waiting", "ongoing"]),
+                    inArray(drizzleDb.schemas.backup.status, ["waiting", "ongoing"])
-        ),
+                )
-      });
+            })
 
             const restoration = await dbClient.query.restoration.findFirst({
-        where: and(
+                where: and(eq(drizzleDb.schemas.restoration.databaseId, databaseUpdated.id), eq(drizzleDb.schemas.restoration.status, "waiting")),
-          eq(drizzleDb.schemas.restoration.databaseId, databaseUpdated.id),
-          eq(drizzleDb.schemas.restoration.status, "waiting"),
-        ),
                 with: {
-          backupStorage: true,
+                    backupStorage: true
-        },
+                }
-      });
+            })
 
             if (activeBackup && activeBackup.status == "waiting") {
-        backupAction = true;
+                backupAction = true
 
                 await dbClient
                     .update(drizzleDb.schemas.backup)
-          .set(withUpdatedAt({ status: "ongoing" }))
+                    .set(withUpdatedAt({status: "ongoing"}))
                     .where(eq(drizzleDb.schemas.backup.id, activeBackup.id));
             }
 
             if (restoration) {
-        restoreAction = true;
+                restoreAction = true
 
-        if (
+                if (!restoration.backupStorage || restoration.backupStorage.status != "success" || !restoration.backupStorage.path) {
-          !restoration.backupStorage ||
+                    restoreAction = false
-          restoration.backupStorage.status != "success" ||
-          !restoration.backupStorage.path
-        ) {
-          restoreAction = false;
                     continue;
                 }
 
@@ -182,8 +158,8 @@ export async function handleDatabases(
                     },
                     metadata: {
                         storageId: restoration.backupStorage.storageChannelId,
-            fileKind: "backups",
+                        fileKind: "backups"
-          },
+                    }
                 };
 
                 const inputMeta: StorageInput = {
@@ -194,119 +170,93 @@ export async function handleDatabases(
                     },
                     metadata: {
                         storageId: restoration.backupStorage.storageChannelId,
-            fileKind: "backups",
+                        fileKind: "backups"
-          },
+                    }
                 };
 
+
                 try {
-          const result = await dispatchStorage(
+                    const result = await dispatchStorage(input, undefined, restoration.backupStorage.storageChannelId);
-            input,
+                    const resultMeta = await dispatchStorage(inputMeta, undefined, restoration.backupStorage.storageChannelId);
-            undefined,
-            restoration.backupStorage.storageChannelId,
-          );
-          const resultMeta = await dispatchStorage(
-            inputMeta,
-            undefined,
-            restoration.backupStorage.storageChannelId,
-          );
 
                     if (result.success) {
                         urlBackup = result.url ?? null;
-            urlMeta = resultMeta.url ?? null;
+                        urlMeta = resultMeta.url ?? null
+                        backupSize = restoration.backupStorage.size
                     } else {
                         await dbClient
                             .update(drizzleDb.schemas.restoration)
-              .set(withUpdatedAt({ status: "failed" }))
+                            .set(withUpdatedAt({status: "failed"}))
                             .where(eq(drizzleDb.schemas.restoration.id, restoration.id));
 
                         const errorMessage = "Failed to get backup URL";
-            log.error(
+                        log.error({error: errorMessage, name: "handleDatabases"}, "Restoration failed");
-              { error: errorMessage, name: "handleDatabases" },
-              "Restoration failed",
-            );
                         continue;
                     }
                 } catch (err) {
-          log.error(
+                    log.error({error: err, name: "handleDatabases"}, "Restoration crashed unexpectedly");
-            { error: err, name: "handleDatabases" },
-            "Restoration crashed unexpectedly",
-          );
                     await dbClient
                         .update(drizzleDb.schemas.restoration)
-            .set(withUpdatedAt({ status: "failed" }))
+                        .set(withUpdatedAt({status: "failed"}))
                         .where(eq(drizzleDb.schemas.restoration.id, restoration.id));
                     continue;
                 }
 
                 await dbClient
                     .update(drizzleDb.schemas.restoration)
-          .set(withUpdatedAt({ status: "ongoing" }))
+                    .set(withUpdatedAt({status: "ongoing"}))
                     .where(eq(drizzleDb.schemas.restoration.id, restoration.id));
             }
-      const storages = await getDatabaseStorageChannels(databaseUpdated.id);
+            const storages = await getDatabaseStorageChannels(databaseUpdated.id)
-      databasesResponse.push(
+            databasesResponse.push(formatDatabase(databaseUpdated, backupAction, restoreAction, urlBackup, storages, urlMeta, backupSize));
-        formatDatabase(
-          databaseUpdated,
-          backupAction,
-          restoreAction,
-          urlBackup,
-          storages,
-          urlMeta,
-        ),
-      );
         }
     }
     return databasesResponse;
 }
 
+
 type PingDatabaseStorageChannels = {
     id: string;
-  config: any;
+    config: any
-  provider: string;
+    provider: string
-};
+}
+
+async function getDatabaseStorageChannels(databaseId: string): Promise<PingDatabaseStorageChannels[]> {
 
-async function getDatabaseStorageChannels(
-  databaseId: string,
-): Promise<PingDatabaseStorageChannels[]> {
     const database = await db.query.database.findFirst({
         where: eq(drizzleDb.schemas.database.id, databaseId),
         with: {
             project: true,
             retentionPolicy: true,
             alertPolicies: true,
-      storagePolicies: true,
+            storagePolicies: true
-    },
+        }
     });
 
     if (!database) {
-    return [];
+        return []
     }
 
     const settings = await db.query.setting.findFirst({
         where: eq(drizzleDb.schemas.setting.name, "system"),
-    with: { storageChannel: true },
+        with: {storageChannel: true},
     });
 
-  const defaultStorageChannel: PingDatabaseStorageChannels[] =
+    const defaultStorageChannel: PingDatabaseStorageChannels[] = settings?.storageChannel
-    settings?.storageChannel
+        ? [{
-      ? [
-          {
             id: settings.storageChannel.id,
             provider: settings.storageChannel.provider,
             config: settings.storageChannel.config,
-          },
+        }]
-        ]
         : [];
 
+
     const enabledDatabaseStorageChannels = await Promise.all(
         (database.storagePolicies ?? [])
-      .filter((p) => p.enabled)
+            .filter(p => p.enabled)
-      .map(async (policy) => {
+            .map(async policy => {
                 const storageChannel = await db.query.storageChannel.findFirst({
-          where: eq(
+                    where: eq(drizzleDb.schemas.storageChannel.id, policy.storageChannelId),
-            drizzleDb.schemas.storageChannel.id,
-            policy.storageChannelId,
-          ),
                 });
 
                 if (!storageChannel) return null;
@@ -316,13 +266,13 @@ async function getDatabaseStorageChannels(
                     config: storageChannel.config,
                     provider: storageChannel.provider,
                 } as PingDatabaseStorageChannels;
-      }),
+            })
     );
 
-  const filteredChannels: PingDatabaseStorageChannels[] =
+    const filteredChannels: PingDatabaseStorageChannels[] = enabledDatabaseStorageChannels.filter(
-    enabledDatabaseStorageChannels.filter(
+        (c): c is PingDatabaseStorageChannels => c !== null
-      (c): c is PingDatabaseStorageChannels => c !== null,
     );
 
     return filteredChannels.length > 0 ? filteredChannels : defaultStorageChannel;
 }
+

package.json

@@ -1,6 +1,6 @@
 {
   "name": "portabase",
-  "version": "1.20.1",
+  "version": "1.20.2",
   "private": true,
   "scripts": {
     "dev": "next dev --turbopack -p 8887",