fix(releases-widget): error display, decouple database repository object from responses and batch widget queries

packages/api/src/router/widgets/releases.ts

@@ -5,7 +5,7 @@ import { releasesRequestHandler } from "@homarr/request-handler/releases";
 
 import { createTRPCRouter, publicProcedure } from "../../trpc";
 
-const formatVersionFilterRegex = (versionFilter: z.infer<typeof _releaseVersionFilterSchema> | undefined) => {
+const formatVersionFilterRegex = (versionFilter: z.infer<typeof releaseVersionFilterSchema> | undefined) => {
   if (!versionFilter) return undefined;
 
   const escapedPrefix = versionFilter.prefix ? escapeForRegEx(versionFilter.prefix) : "";
@@ -15,7 +15,7 @@ const formatVersionFilterRegex = (versionFilter: z.infer<typeof _releaseVersionF
   return `^${escapedPrefix}${precision}${escapedSuffix}$`;
 };
 
-const _releaseVersionFilterSchema = z.object({
+const releaseVersionFilterSchema = z.object({
   prefix: z.string().optional(),
   precision: z.number(),
   suffix: z.string().optional(),
@@ -29,7 +29,7 @@ export const releasesRouter = createTRPCRouter({
           z.object({
             providerKey: z.string(),
             identifier: z.string(),
-            versionFilter: _releaseVersionFilterSchema.optional(),
+            versionFilter: releaseVersionFilterSchema.optional(),
           }),
         ),
       }),

packages/common/src/array.ts

@@ -5,3 +5,11 @@ export const splitToNChunks = <T>(array: T[], chunks: number): T[][] => {
   }
   return result;
 };
+
+export const splitToChunksWithNItems = <T>(array: T[], itemCount: number): T[][] => {
+  const result: T[][] = [];
+  for (let i = 0; i < array.length; i += itemCount) {
+    result.push(array.slice(i, i + itemCount));
+  }
+  return result;
+};

packages/common/src/date.ts

@@ -0,0 +1,26 @@
+import dayjs from "dayjs";
+import type { UnitTypeShort } from "dayjs";
+import isBetween from "dayjs/plugin/isBetween";
+
+dayjs.extend(isBetween);
+
+const validUnits = ["h", "d", "w", "M", "y"] as UnitTypeShort[];
+
+export const isDateWithin = (date: Date, relativeDate: string): boolean => {
+  if (relativeDate.length < 2) {
+    throw new Error("Relative date must be at least 2 characters long");
+  }
+
+  const amount = parseInt(relativeDate.slice(0, -1), 10);
+  if (isNaN(amount) || amount <= 0) {
+    throw new Error("Relative date must be a number greater than 0");
+  }
+
+  const unit = relativeDate.slice(-1) as dayjs.UnitTypeShort;
+  if (!validUnits.includes(unit)) {
+    throw new Error("Invalid relative time unit");
+  }
+
+  const startDate = dayjs().subtract(amount, unit);
+  return dayjs(date).isBetween(startDate, dayjs(), null, "[]");
+};

packages/common/src/index.ts

@@ -2,6 +2,7 @@ export * from "./object";
 export * from "./string";
 export * from "./cookie";
 export * from "./array";
+export * from "./date";
 export * from "./stopwatch";
 export * from "./hooks";
 export * from "./url";

packages/common/src/test/array.spec.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from "vitest";
+
+import { splitToChunksWithNItems, splitToNChunks } from "../array";
+
+describe("splitToNChunks", () => {
+  it("should split an array into the specified number of chunks", () => {
+    const array = [1, 2, 3, 4, 5];
+    const chunks = 3;
+    const result = splitToNChunks(array, chunks);
+    expect(result).toEqual([[1, 2], [3, 4], [5]]);
+  });
+
+  it("should handle an empty array", () => {
+    const array: number[] = [];
+    const chunks = 3;
+    const result = splitToNChunks(array, chunks);
+    expect(result).toEqual([[], [], []]);
+  });
+
+  it("should handle more chunks than elements", () => {
+    const array = [1, 2];
+    const chunks = 5;
+    const result = splitToNChunks(array, chunks);
+    expect(result).toEqual([[1], [2], [], [], []]);
+  });
+});
+
+describe("splitToChunksWithNItems", () => {
+  it("should split an array into chunks with the specified number of items", () => {
+    const array = [1, 2, 3, 4, 5];
+    const items = 2;
+    const result = splitToChunksWithNItems(array, items);
+    expect(result).toEqual([[1, 2], [3, 4], [5]]);
+  });
+
+  it("should handle an empty array", () => {
+    const array: number[] = [];
+    const items = 2;
+    const result = splitToChunksWithNItems(array, items);
+    expect(result).toEqual([]);
+  });
+
+  it("should handle more items per chunk than elements", () => {
+    const array = [1, 2];
+    const items = 5;
+    const result = splitToChunksWithNItems(array, items);
+    expect(result).toEqual([[1, 2]]);
+  });
+});

packages/common/src/test/date.spec.ts

@@ -0,0 +1,91 @@
+import { describe, expect, it } from "vitest";
+
+import { isDateWithin } from "../date";
+
+describe("isDateWithin", () => {
+  it("should return true for a date within the specified hours", () => {
+    const date = new Date();
+    date.setHours(date.getHours() - 20);
+    expect(isDateWithin(date, "100h")).toBe(true);
+  });
+
+  it("should return false for a date outside the specified hours", () => {
+    const date = new Date();
+    date.setHours(date.getHours() - 101);
+    expect(isDateWithin(date, "100h")).toBe(false);
+  });
+
+  it("should return true for a date within the specified days", () => {
+    const date = new Date();
+    date.setDate(date.getDate() - 5);
+    expect(isDateWithin(date, "10d")).toBe(true);
+  });
+
+  it("should return false for a date outside the specified days", () => {
+    const date = new Date();
+    date.setDate(date.getDate() - 11);
+    expect(isDateWithin(date, "10d")).toBe(false);
+  });
+
+  it("should return true for a date within the specified weeks", () => {
+    const date = new Date();
+    date.setDate(date.getDate() - 10);
+    expect(isDateWithin(date, "7w")).toBe(true);
+  });
+
+  it("should return false for a date outside the specified weeks", () => {
+    const date = new Date();
+    date.setDate(date.getDate() - 50);
+    expect(isDateWithin(date, "7w")).toBe(false);
+  });
+
+  it("should return true for a date within the specified months", () => {
+    const date = new Date();
+    date.setMonth(date.getMonth() - 1);
+    expect(isDateWithin(date, "2M")).toBe(true);
+  });
+
+  it("should return false for a date outside the specified months", () => {
+    const date = new Date();
+    date.setMonth(date.getMonth() - 3);
+    expect(isDateWithin(date, "2M")).toBe(false);
+  });
+
+  it("should return true for a date within the specified years", () => {
+    const date = new Date();
+    date.setFullYear(date.getFullYear() - 1);
+    expect(isDateWithin(date, "2y")).toBe(true);
+  });
+
+  it("should return false for a date outside the specified years", () => {
+    const date = new Date();
+    date.setFullYear(date.getFullYear() - 3);
+    expect(isDateWithin(date, "2y")).toBe(false);
+  });
+
+  it("should return false for a date after the specified relative time", () => {
+    const date = new Date();
+    date.setDate(date.getDate() + 2);
+    expect(isDateWithin(date, "1d")).toBe(false);
+  });
+
+  it("should throw an error for an invalid unit", () => {
+    const date = new Date();
+    expect(() => isDateWithin(date, "2x")).toThrow("Invalid relative time unit");
+  });
+
+  it("should throw an error if relativeDate is less than 2 characters long", () => {
+    const date = new Date();
+    expect(() => isDateWithin(date, "h")).toThrow("Relative date must be at least 2 characters long");
+  });
+
+  it("should throw an error if relativeDate has an invalid number", () => {
+    const date = new Date();
+    expect(() => isDateWithin(date, "hh")).toThrow("Relative date must be a number greater than 0");
+  });
+
+  it("should throw an error if relativeDate is set to 0", () => {
+    const date = new Date();
+    expect(() => isDateWithin(date, "0y")).toThrow("Relative date must be a number greater than 0");
+  });
+});

packages/request-handler/src/releases-providers.ts

@@ -41,12 +41,8 @@ export const Providers: ProvidersProps = {
         .transform((resp) => ({
           projectUrl: `https://hub.docker.com/r/${resp.namespace === "library" ? "_" : resp.namespace}/${resp.name}`,
           projectDescription: resp.description,
-          isFork: false,
-          isArchived: false,
           createdAt: resp.date_registered,
           starsCount: resp.star_count,
-          openIssues: 0,
-          forksCount: 0,
         }))
         .safeParse(response);
     },
@@ -67,12 +63,7 @@ export const Providers: ProvidersProps = {
           ),
         })
         .transform((resp) => {
-          return resp.results.map((release) => ({
-            ...release,
-            releaseUrl: "",
-            releaseDescription: "",
-            isPreRelease: false,
-          }));
+          return resp.results;
         })
         .safeParse(response);
     },
@@ -217,7 +208,6 @@ export const Providers: ProvidersProps = {
             ...release,
             releaseUrl: `https://www.npmjs.com/package/${resp.name}/v/${release.latestRelease}`,
             releaseDescription: resp.versions[release.latestRelease]?.description ?? "",
-            isPreRelease: false,
           }));
         })
         .safeParse(response);
@@ -282,23 +272,31 @@ export const Providers: ProvidersProps = {
   },
 };
 
-const _detailsSchema = z.object({
-  projectUrl: z.string(),
-  projectDescription: z.string(),
-  isFork: z.boolean(),
-  isArchived: z.boolean(),
-  createdAt: z.date(),
-  starsCount: z.number(),
-  openIssues: z.number(),
-  forksCount: z.number(),
-});
+const _detailsSchema = z
+  .object({
+    projectUrl: z.string().optional(),
+    projectDescription: z.string().optional(),
+    isFork: z.boolean().optional(),
+    isArchived: z.boolean().optional(),
+    createdAt: z.date().optional(),
+    starsCount: z.number().optional(),
+    openIssues: z.number().optional(),
+    forksCount: z.number().optional(),
+  })
+  .optional();
 
 const _releasesSchema = z.object({
   latestRelease: z.string(),
   latestReleaseAt: z.date(),
-  releaseUrl: z.string(),
-  releaseDescription: z.string(),
-  isPreRelease: z.boolean(),
+  releaseUrl: z.string().optional(),
+  releaseDescription: z.string().optional(),
+  isPreRelease: z.boolean().optional(),
+  error: z
+    .object({
+      code: z.string().optional(),
+      message: z.string().optional(),
+    })
+    .optional(),
 });
 
 export type DetailsResponse = z.infer<typeof _detailsSchema>;