@igstack/app-catalog-backend-core 6.12.0 → 6.12.2

package/src/generated/prisma/models/DbCommunityToolView.ts

@@ -16,7 +16,7 @@ import type * as Prisma from "../internal/prismaNamespace"
 
 /**
  * Model DbCommunityToolView
- * View tracking for community tools (one row per viewer per tool per day).
+ * Superseded by DbCommunityToolOpen and no longer written; kept so the schema stays additive.
  */
 export type DbCommunityToolViewModel = runtime.Types.Result.DefaultSelection<Prisma.$DbCommunityToolViewPayload>
 

package/src/generated/prisma/models.ts

@@ -28,6 +28,7 @@ export type * from './models/DbCommunityToolOwner'
 export type * from './models/DbCommunityToolLike'
 export type * from './models/DbCommunityToolNamedOwner'
 export type * from './models/DbCommunityToolTag'
+export type * from './models/DbCommunityToolOpen'
 export type * from './models/DbCommunityToolView'
 export type * from './models/DbCommunityToolPin'
 export type * from './commonInputTypes'

package/src/modules/communityTools/capture.ts

@@ -10,13 +10,23 @@ export type CaptureResult =
       /** The page's `Last-Modified`: a static host sets it on each deploy. */
       lastModified: Date | null
     }
-  | { ok: false; error: string }
+  | {
+      ok: false
+      error: string
+      /**
+       * No answer at all (a timeout, a refused connection), which may be the
+       * server's own network. Absent for a definitive failure: an HTTP error
+       * status, or a name that does not resolve.
+       */
+      unreachable?: true
+    }
 
 /**
  * Visits a page and photographs it, reaching only `allowedHosts`.
  *
  * Resolves `{ ok: false }` when the page itself failed (no response, an error status, a
- * timeout, a redirect off the list) — that is the tool's health. Throws when the
+ * timeout, a redirect off the list) — that is the tool's health; `unreachable` when
+ * it never answered. Throws when the
  * browser could not be started, which is ours: the health job must not mark every tool
  * broken because Chromium is missing on one pod.
  */
@@ -191,6 +201,7 @@ export async function capturePage(
     return {
       ok: false,
       error: response ? `HTTP ${response.status()}` : 'No response',
+      ...(!response && { unreachable: true as const }),
     }
   }
   // `load` is only the HTML and its assets: a page that fetches its data after
@@ -240,6 +251,19 @@ export async function capturePage(
   }
 }
 
+/**
+ * A capture that threw, from the browser or the network under it. Only a name
+ * that does not resolve is definitive; anything else got no answer at all.
+ */
+export function failureOf(
+  error: unknown,
+): Extract<CaptureResult, { ok: false }> {
+  const message = error instanceof Error ? error.message : String(error)
+  return /ENOTFOUND|ERR_NAME_NOT_RESOLVED/.test(message)
+    ? { ok: false, error: message }
+    : { ok: false, error: message, unreachable: true }
+}
+
 /** An HTTP date header as a Date; null when absent or unreadable. */
 export function httpDate(value: string | undefined): Date | null {
   if (!value) return null
@@ -293,6 +317,9 @@ export function createPlaywrightCapturer(): ScreenshotCapturer | null {
         viewport: VIEWPORT,
         serviceWorkers: 'block',
       })
+      // The fence answers the page itself, so the browser only sees that it
+      // failed; why it failed (no such name, or no answer) is kept here.
+      let navigationError: unknown = null
       // Second layer under the resolver fence: per-request and per-hop checks.
       await context.route('**/*', (route) =>
         fenceRoute(
@@ -300,17 +327,25 @@ export function createPlaywrightCapturer(): ScreenshotCapturer | null {
             url: route.request().url(),
             abort: (code) => route.abort(code),
             continue: () => route.continue(),
-            fetch: (hop, mode) =>
-              mode === 'get'
-                ? context.request.get(hop, {
-                    maxRedirects: 0,
-                    timeout: HOP_TIMEOUT_MS,
-                  })
-                : route.fetch({
-                    url: hop,
-                    maxRedirects: 0,
-                    timeout: HOP_TIMEOUT_MS,
-                  }),
+            fetch: async (hop, mode) => {
+              try {
+                return await (mode === 'get'
+                  ? context.request.get(hop, {
+                      maxRedirects: 0,
+                      timeout: HOP_TIMEOUT_MS,
+                    })
+                  : route.fetch({
+                      url: hop,
+                      maxRedirects: 0,
+                      timeout: HOP_TIMEOUT_MS,
+                    }))
+              } catch (error) {
+                if (route.request().isNavigationRequest()) {
+                  navigationError ??= error
+                }
+                throw error
+              }
+            },
             fulfill: (response) => route.fulfill({ response }),
           },
           allowedHosts,
@@ -319,12 +354,13 @@ export function createPlaywrightCapturer(): ScreenshotCapturer | null {
       // A screenshot needs no live socket, and `route` does not see them.
       await context.routeWebSocket(/.*/, (ws) => ws.close())
       const page = await context.newPage()
-      return await capturePage(page, url, allowedHosts)
-    } catch (error) {
-      return {
-        ok: false,
-        error: error instanceof Error ? error.message : String(error),
+      try {
+        return await capturePage(page, url, allowedHosts)
+      } catch (error) {
+        return failureOf(navigationError ?? error)
       }
+    } catch (error) {
+      return failureOf(error)
     } finally {
       await browser.close()
     }

package/src/modules/communityTools/healthJob.ts

@@ -28,6 +28,7 @@ interface CheckableTool {
   failingSince: Date | null
   archivedAt: Date | null
   archivedBy: string | null
+  unreachableSince: Date | null
 }
 
 /** Stores the screenshot and, when it decodes, the favicon as assets. */
@@ -97,7 +98,11 @@ export async function checkTool(
     where: { id: tool.id },
     data: {
       lastCheckAt: now,
-      ...nextLifecycle(tool, result.ok, now),
+      ...nextLifecycle(
+        tool,
+        result.ok ? 'ok' : result.unreachable ? 'unreachable' : 'failed',
+        now,
+      ),
       ...(result.ok && (await storeCapture(tool.slug, result, now))),
       // A visit without the header leaves the date it last had.
       ...(result.ok &&
@@ -143,6 +148,7 @@ export async function runHealthCheckOnce(
           failingSince: true,
           archivedAt: true,
           archivedBy: true,
+          unreachableSince: true,
         },
       })
       const due = tools.filter(

package/src/modules/communityTools/router.ts

@@ -89,11 +89,36 @@ export function createCommunityToolsRouter(options?: CommunityToolsOptions) {
         return tool
       }),
 
+    /** The card opened. */
     recordView: publicProcedure
       .input(z.object({ slug: z.string() }))
       .mutation(({ input, ctx }) => {
         const actor = requireActor(ctx.actor)
-        return service.recordView(input.slug, actor, ctx.user, new Date())
+        return service.recordOpen(
+          input.slug,
+          'card',
+          actor,
+          ctx.user,
+          new Date(),
+        )
+      }),
+
+    /**
+     * A click through to the site. The page leaves as it is sent, so the
+     * client posts it with `keepalive` rather than through the tRPC client.
+     */
+    recordSiteOpen: publicProcedure
+      .input(z.object({ slug: z.string() }))
+      .mutation(async ({ input, ctx }) => {
+        const actor = requireActor(ctx.actor)
+        await service.recordOpen(
+          input.slug,
+          'site',
+          actor,
+          ctx.user,
+          new Date(),
+        )
+        return { ok: true }
       }),
 
     pins: protectedProcedure.query(({ ctx }) => {

package/src/modules/communityTools/service.ts

@@ -34,28 +34,10 @@ export async function listTools(
   })
   const personMap = new Map(persons.map((p) => [p.slug, p]))
 
-  // Get view counts for all tools
-  const today = new Date(now)
-  today.setUTCHours(0, 0, 0, 0)
-  const thirtyDaysAgo = new Date(today)
-  thirtyDaysAgo.setUTCDate(thirtyDaysAgo.getUTCDate() - 29)
-
-  const viewCounts = await Promise.all(
-    toolIds.map(async (toolId) => {
-      const [views30d, viewsAll] = await Promise.all([
-        db.dbCommunityToolView.count({
-          where: { toolId, day: { gte: thirtyDaysAgo } },
-        }),
-        db.dbCommunityToolView.count({ where: { toolId } }),
-      ])
-      return { toolId, views30d, viewsAll }
-    }),
-  )
   const viewCountMap = new Map(
-    viewCounts.map((v) => [
-      v.toolId,
-      { views30d: v.views30d, viewsAll: v.viewsAll },
-    ]),
+    await Promise.all(
+      toolIds.map(async (id) => [id, await openCounts(id, now)] as const),
+    ),
   )
 
   return Promise.all(
@@ -111,22 +93,10 @@ export async function getTool(
   })
   const personMap = new Map(persons.map((p) => [p.slug, p]))
 
-  const today = new Date(now)
-  today.setUTCHours(0, 0, 0, 0)
-  const thirtyDaysAgo = new Date(today)
-  thirtyDaysAgo.setUTCDate(thirtyDaysAgo.getUTCDate() - 29)
-
-  const [views30d, viewsAll] = await Promise.all([
-    db.dbCommunityToolView.count({
-      where: { toolId: tool.id, day: { gte: thirtyDaysAgo } },
-    }),
-    db.dbCommunityToolView.count({ where: { toolId: tool.id } }),
-  ])
-
   return toView(
     tool,
     personMap,
-    { views30d, viewsAll },
+    await openCounts(tool.id, now),
     user,
     isAdmin,
     now,
@@ -134,54 +104,58 @@ export async function getTool(
   )
 }
 
-export async function recordView(
+/** Opens since the first of the last 30 UTC days, and ever. */
+async function openCounts(
+  toolId: string,
+  now: Date,
+): Promise<{ views30d: number; viewsAll: number }> {
+  const db = getDbClient()
+  const since = new Date(now)
+  since.setUTCHours(0, 0, 0, 0)
+  since.setUTCDate(since.getUTCDate() - 29)
+  const [views30d, viewsAll] = await Promise.all([
+    db.dbCommunityToolOpen.count({ where: { toolId, at: { gte: since } } }),
+    db.dbCommunityToolOpen.count({ where: { toolId } }),
+  ])
+  return { views30d, viewsAll }
+}
+
+/** More opens than this by one visitor of one tool in a minute are ignored. */
+const OPENS_PER_MINUTE = 30
+
+/**
+ * Counts one card open or click through to the site: every one counts, short
+ * of a visitor opening the same tool more than OPENS_PER_MINUTE times a minute.
+ */
+export async function recordOpen(
   slug: string,
+  kind: 'card' | 'site',
   actor: Actor,
   user: User | null,
   now: Date,
 ): Promise<{ views30d: number; viewsAll: number }> {
   const db = getDbClient()
+  const toolId = await requireToolId(slug)
 
-  const tool = await db.dbCommunityTool.findUnique({ where: { slug } })
-  if (!tool) {
-    throw new Error('Tool not found')
-  }
-
-  const day = new Date(now)
-  day.setUTCHours(0, 0, 0, 0)
-
-  await db.dbCommunityToolView.upsert({
+  const recent = await db.dbCommunityToolOpen.count({
     where: {
-      toolId_actorHash_day: {
-        toolId: tool.id,
-        actorHash: actor.hash,
-        day,
-      },
-    },
-    create: {
-      toolId: tool.id,
+      toolId,
       actorHash: actor.hash,
-      userId: user?.id ?? null,
-      day,
-      at: now,
-    },
-    update: {
-      at: now,
-      userId: user?.id ?? null,
+      at: { gt: new Date(now.getTime() - 60_000) },
     },
   })
-
-  const thirtyDaysAgo = new Date(day)
-  thirtyDaysAgo.setUTCDate(thirtyDaysAgo.getUTCDate() - 29)
-
-  const [views30d, viewsAll] = await Promise.all([
-    db.dbCommunityToolView.count({
-      where: { toolId: tool.id, day: { gte: thirtyDaysAgo } },
-    }),
-    db.dbCommunityToolView.count({ where: { toolId: tool.id } }),
-  ])
-
-  return { views30d, viewsAll }
+  if (recent < OPENS_PER_MINUTE) {
+    await db.dbCommunityToolOpen.create({
+      data: {
+        toolId,
+        kind,
+        actorHash: actor.hash,
+        userId: user?.id ?? null,
+        at: now,
+      },
+    })
+  }
+  return openCounts(toolId, now)
 }
 
 export async function listPins(
@@ -218,27 +192,10 @@ export async function listPins(
   })
   const personMap = new Map(persons.map((p) => [p.slug, p]))
 
-  const today = new Date(now)
-  today.setUTCHours(0, 0, 0, 0)
-  const thirtyDaysAgo = new Date(today)
-  thirtyDaysAgo.setUTCDate(thirtyDaysAgo.getUTCDate() - 29)
-
-  const viewCounts = await Promise.all(
-    toolIds.map(async (toolId) => {
-      const [views30d, viewsAll] = await Promise.all([
-        db.dbCommunityToolView.count({
-          where: { toolId, day: { gte: thirtyDaysAgo } },
-        }),
-        db.dbCommunityToolView.count({ where: { toolId } }),
-      ])
-      return { toolId, views30d, viewsAll }
-    }),
-  )
   const viewCountMap = new Map(
-    viewCounts.map((v) => [
-      v.toolId,
-      { views30d: v.views30d, viewsAll: v.viewsAll },
-    ]),
+    await Promise.all(
+      toolIds.map(async (id) => [id, await openCounts(id, now)] as const),
+    ),
   )
 
   return Promise.all(

package/src/modules/communityTools/toView.ts

@@ -64,6 +64,7 @@ export async function toView(
       archivedAt: tool.archivedAt,
       archivedBy: tool.archivedBy,
       archivedReason: tool.archivedReason,
+      unreachableSince: tool.unreachableSince,
     },
     now,
   )
@@ -114,6 +115,7 @@ export async function toView(
     faviconId: tool.faviconAssetId ?? null,
     capturedAt: tool.capturedAt?.toISOString() ?? null,
     capturePending,
+    serverUnreachable: tool.unreachableSince !== null,
     canEdit,
   }
 }

package/src/modules/communityTools/writeService.ts

@@ -319,6 +319,7 @@ export async function editTool(
     // automatic archive says nothing about the new one.
     const newSite = host !== tool.host && {
       failingSince: null,
+      unreachableSince: null,
       lastCheckAt: null,
       ...(tool.archivedBy === 'auto' && {
         archivedAt: null,