connecting redis to cms, adding ai overview generation, fixing a few post nullables

Author: tomgobich

adonisrc.ts

@@ -17,7 +17,8 @@ export default defineConfig({
     () => import('@adocasts.com/dto/commands'),
     () => import('@adocasts.com/actions/commands'),
     () => import('@tuyau/core/commands'),
-    () => import('@adonisjs/bouncer/commands')
+    () => import('@adonisjs/bouncer/commands'),
+    () => import('@adonisjs/cache/commands')
   ],
 
   /*
@@ -49,7 +50,9 @@ export default defineConfig({
     () => import('@adonisjs/mail/mail_provider'),
     () => import('@tuyau/core/tuyau_provider'),
     () => import('@adonisjs/drive/drive_provider'),
-    () => import('@adonisjs/bouncer/bouncer_provider')
+    () => import('@adonisjs/bouncer/bouncer_provider'),
+    () => import('@adonisjs/cache/cache_provider'),
+    () => import('@adonisjs/redis/redis_provider')
   ],
 
   /*

app/actions/posts/update_post.ts

@@ -43,6 +43,7 @@ export default class UpdatePost {
 
     post.merge(update)
 
+    if (!data.publishAt) post.publishAt = null
     if (!data.videoBunnyId) post.videoBunnyId = null
     if (!data.videoUrl) post.videoUrl = null
     if (!data.videoBunnyId && !data.videoUrl) post.videoSeconds = 0

app/controllers/ai_controller.ts

@@ -0,0 +1,27 @@
+import aiService from '#services/ai/ai_service'
+import r2Service from '#services/r2_service'
+import { aiBodyOverviewValidator } from '#validators/ai'
+import cache from '@adonisjs/cache/services/main'
+import type { HttpContext } from '@adonisjs/core/http'
+
+export default class AiController {
+  async videoChapters({ params }: HttpContext) {
+    const transcript = await r2Service.getTranscript(params.videoId)
+    const chapters = await aiService.generateChapters(transcript)
+    return chapters
+  }
+
+  async bodyOverview({ request, params }: HttpContext) {
+    const { body } = await request.validateUsing(aiBodyOverviewValidator)
+    const force = request.input('force', false)
+    const key = `lesson_${params.lessonId}`
+
+    if (force) {
+      await cache.namespace('AI_BODY_OVERVIEW').delete({ key })
+    }
+
+    const overview = await aiService.getOrGenerateBodyOverview(params.lessonId, body)
+
+    return overview
+  }
+}

app/controllers/ai_videos_controller.ts

@@ -13,6 +13,7 @@ import TaxonomyDto from '#dtos/taxonomy'
 import FrameworkVersion from '#models/framework_version'
 import Post from '#models/post'
 import Taxonomy from '#models/taxonomy'
+import aiService from '#services/ai/ai_service'
 import { postIndexValidator, postSearchValidator, postValidator } from '#validators/post'
 import type { HttpContext } from '@adonisjs/core/http'
 import router from '@adonisjs/core/services/router'
@@ -78,13 +79,15 @@ export default class PostsController {
     const post = await GetPost.byId(params.id)
     const taxonomies = await Taxonomy.query().orderBy('name')
     const frameworkVersions = await FrameworkVersion.query().orderBy('sort')
+    const aiOverview = await aiService.getBodyOverview(post.id)
 
     await bouncer.with('PostPolicy').authorize('update', post)
 
     return inertia.render('posts/form', {
       post: new PostFormDto(post),
       taxonomies: TaxonomyDto.fromArray(taxonomies),
       frameworkVersions: FrameworkVersionDto.fromArray(frameworkVersions),
+      aiOverview,
     })
   }
 

app/controllers/posts_controller.ts

@@ -1,4 +1,5 @@
 import { Chapter } from '#dtos/post_form'
+import cache from '@adonisjs/cache/services/main'
 import { google } from '@ai-sdk/google'
 import { generateText, Output } from 'ai'
 import { z } from 'zod'
@@ -41,6 +42,61 @@ class AiService {
 
     return output.chapters
   }
+
+  async getBodyOverview(lessonId: number) {
+    return cache.namespace('AI_BODY_OVERVIEW').get({ key: `lesson_${lessonId}` })
+  }
+
+  async getOrGenerateBodyOverview(lessonId: number, body: string) {
+    return cache.namespace('AI_BODY_OVERVIEW').getOrSet({
+      key: `lesson_${lessonId}`,
+      ttl: '180d',
+      factory: async () => this.generateBodyOverview(body),
+    })
+  }
+
+  async generateBodyOverview(body: string): Promise<AiBodyOverview> {
+    const { output } = await generateText({
+      model: this.model,
+      output: Output.object({
+        schema: z.object({
+          summary: z
+            .array(z.string())
+            .describe('3 to 5 concise, action-oriented bullet points summarizing the lesson.'),
+          metaDescription: z
+            .string()
+            .max(160)
+            .describe(
+              'A high-click-through SEO description. Must include the primary topic and a call to learning, under 160 characters.'
+            ),
+          socialHooks: z.object({
+            twitter: z
+              .string()
+              .describe(
+                'A punchy, curiosity-gap style tweet to drive clicks. Use 1-2 relevant hashtags.'
+              ),
+            facebook: z
+              .string()
+              .describe(
+                'A conversational, community-focused post. Explain the value of the lesson and encourage comments or shares.'
+              ),
+          }),
+        }),
+      }),
+      prompt: `Analyze the following lesson body and generate metadata: ${body}`,
+    })
+
+    return output
+  }
+}
+
+export interface AiBodyOverview {
+  summary: string[]
+  metaDescription: string
+  socialHooks: {
+    twitter: string
+    facebook: string
+  }
 }
 
 const aiService = new AiService()

app/services/ai/ai_service.ts

@@ -0,0 +1,7 @@
+import vine from '@vinejs/vine'
+
+export const aiBodyOverviewValidator = vine.compile(
+  vine.object({
+    body: vine.string(),
+  })
+)

app/validators/ai.ts

@@ -43,11 +43,11 @@ export const postValidator = vine.compile(
         return !result
       })
       .optional(),
-    pageTitle: vine.string().trim().maxLength(100).optional(),
-    description: vine.string().trim().maxLength(255).optional(),
-    metaDescription: vine.string().trim().maxLength(255).optional(),
-    canonical: vine.string().trim().maxLength(255).url().optional(),
-    body: vine.string().trim().optional(),
+    pageTitle: vine.string().trim().maxLength(100).nullable(),
+    description: vine.string().trim().maxLength(255).nullable(),
+    metaDescription: vine.string().trim().maxLength(255).nullable(),
+    canonical: vine.string().trim().maxLength(255).url().nullable(),
+    body: vine.string().trim().nullable(),
     repositoryUrl: vine.string().trim().maxLength(255).url().optional().nullable(),
     repositoryAccessLevel: vine.number().enum(RepositoryAccessLevels).optional(),
     isFeatured: vine.boolean().optional().nullable(),
@@ -58,8 +58,8 @@ export const postValidator = vine.compile(
     videoBunnyId: vine.string().trim().maxLength(500).optional().nullable(),
     videoSeconds: vine.number().optional(),
     timezone: vine.string().trim().optional(),
-    publishAtDate: vine.date().optional(),
-    publishAtTime: vine.date({ formats: ['HH:mm'] }).optional(),
+    publishAtDate: vine.date().nullable(),
+    publishAtTime: vine.date({ formats: ['HH:mm'] }).nullable(),
     postTypeId: vine.number().enum(PostTypes).optional(),
     stateId: vine.number().enum(States).optional(),
     paywallTypeId: vine.number().enum(PaywallTypes).optional(),
@@ -112,6 +112,7 @@ export const postValidator = vine.compile(
         }
 
         return publishAt.setZone('UTC').set({ second: 0, millisecond: 0 })
-      }),
+      })
+      .nullable(),
   })
 )

app/validators/post.ts

@@ -0,0 +1,36 @@
+import { defineConfig, drivers, errors, store } from '@adonisjs/cache'
+
+const cacheConfig = defineConfig({
+  default: 'default',
+
+  onFactoryError(error) {
+    switch (true) {
+      case error.cause instanceof errors.E_FACTORY_ERROR:
+      case error.cause instanceof errors.E_FACTORY_HARD_TIMEOUT:
+      case error.cause instanceof errors.E_FACTORY_SOFT_TIMEOUT:
+      case error.cause instanceof errors.E_L2_CACHE_ERROR:
+      case error.cause instanceof errors.E_UNDEFINED_VALUE:
+        return // continue with thrown error
+      default:
+        throw error.cause // don't swallow non-cache error, a 404 should remain a 404
+    }
+  },
+
+  stores: {
+    memoryOnly: store().useL1Layer(drivers.memory()),
+
+    default: store()
+      .useL1Layer(drivers.memory({ maxSize: 10_000 }))
+      .useL2Layer(
+        drivers.redis({
+          connectionName: 'main',
+        })
+      ),
+  },
+})
+
+export default cacheConfig
+
+declare module '@adonisjs/cache/types' {
+  interface CacheStores extends InferStores<typeof cacheConfig> {}
+}

config/cache.ts

@@ -0,0 +1,36 @@
+import env from '#start/env'
+import { defineConfig } from '@adonisjs/redis'
+import { InferConnections } from '@adonisjs/redis/types'
+
+const redisConfig = defineConfig({
+  connection: 'main',
+
+  connections: {
+    /*
+    |--------------------------------------------------------------------------
+    | The default connection
+    |--------------------------------------------------------------------------
+    |
+    | The main connection you want to use to execute redis commands. The same
+    | connection will be used by the session provider, if you rely on the
+    | redis driver.
+    |
+    */
+    main: {
+      host: env.get('REDIS_HOST'),
+      port: env.get('REDIS_PORT'),
+      password: env.get('REDIS_PASSWORD', ''),
+      db: 0,
+      keyPrefix: '',
+      retryStrategy(times) {
+        return times > 10 ? null : times * 50
+      },
+    },
+  },
+})
+
+export default redisConfig
+
+declare module '@adonisjs/redis/types' {
+  export interface RedisConnections extends InferConnections<typeof redisConfig> {}
+}