Bot player for projects

Author: stever

apps/gif-service/src/hasura.ts

@@ -37,21 +37,31 @@ export interface ProjectRecord {
 }
 
 /**
- * Look up a public project by id. Returns null when the project is missing or
- * private: the `public` role's select permission filters to is_public, so a
- * private project is simply absent from the result rather than an error.
+ * Look up a public project from its canonical /u/<userSlug>/<projectSlug> URL.
+ *
+ * Project slug is unique only per owner (user slug is globally unique), so the
+ * lookup is scoped by the owner relationship rather than projectSlug alone.
+ * Returns null when the project is missing or private: the `public` role's
+ * select permission filters to is_public, so a private project is simply absent
+ * rather than an error.
  */
-export async function fetchProject(projectId: string): Promise<ProjectRecord | null> {
+export async function fetchProject(
+    userSlug: string,
+    projectSlug: string,
+): Promise<ProjectRecord | null> {
     const query = `
-        query ($id: uuid!) {
-            project(where: { project_id: { _eq: $id } }, limit: 1) {
+        query ($userSlug: String!, $projectSlug: String!) {
+            project(
+                where: { slug: { _eq: $projectSlug }, owner: { slug: { _eq: $userSlug } } }
+                limit: 1
+            ) {
                 lang
                 code
                 title
             }
         }
     `;
-    const data = await gql<{ project: ProjectRecord[] }>(query, { id: projectId });
+    const data = await gql<{ project: ProjectRecord[] }>(query, { userSlug, projectSlug });
     return data.project[0] ?? null;
 }
 

apps/gif-service/src/routes/project.ts

@@ -8,11 +8,25 @@ const router = Router();
 
 type Format = 'gif' | 'mp4';
 
-const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const SLUG = /^[a-z0-9-]+$/i;
 
-function readProjectId(req: Request): string | null {
-    const id: unknown = typeof req.body === 'object' && req.body ? req.body.projectId : undefined;
-    return typeof id === 'string' && UUID.test(id) ? id.toLowerCase() : null;
+interface ProjectRef {
+    userSlug: string;
+    projectSlug: string;
+}
+
+function readProjectRef(req: Request): ProjectRef | null {
+    const body = typeof req.body === 'object' && req.body ? req.body : {};
+    const { userSlug, projectSlug } = body;
+    if (
+        typeof userSlug === 'string' &&
+        typeof projectSlug === 'string' &&
+        SLUG.test(userSlug) &&
+        SLUG.test(projectSlug)
+    ) {
+        return { userSlug: userSlug.toLowerCase(), projectSlug: projectSlug.toLowerCase() };
+    }
+    return null;
 }
 
 /**
@@ -23,13 +37,13 @@ function readProjectId(req: Request): string | null {
  */
 async function handle(format: Format, req: Request, res: Response): Promise<void> {
     try {
-        const projectId = readProjectId(req);
-        if (!projectId) {
-            res.status(400).json({ error: 'No valid projectId provided' });
+        const ref = readProjectRef(req);
+        if (!ref) {
+            res.status(400).json({ error: 'No valid project reference provided' });
             return;
         }
 
-        const project = await fetchProject(projectId);
+        const project = await fetchProject(ref.userSlug, ref.projectSlug);
         if (!project) {
             res.status(404).json({ error: 'Project not found or not public' });
             return;
@@ -59,7 +73,7 @@ async function handle(format: Format, req: Request, res: Response): Promise<void
         await generator.initialize();
 
         console.log(
-            `Generating ${format.toUpperCase()} from project ${projectId} (lang=${project.lang})...`,
+            `Generating ${format.toUpperCase()} from project ${ref.userSlug}/${ref.projectSlug} (lang=${project.lang})...`,
         );
         if (format === 'mp4') {
             const mp4 = await generator.generateMp4FromTAP(tap, machineType);

apps/mastodon-bot/src/index.ts

@@ -1,6 +1,6 @@
 import { config, assertRuntimeConfig } from './config.js';
 import { htmlToBasic } from './basic.js';
-import { extractProjectId } from './project.js';
+import { extractProjectRef } from './project.js';
 import { basicToMedia, projectToMedia } from './media.js';
 import { loadState, saveState } from './state.js';
 import {
@@ -33,26 +33,27 @@ async function handleMention(self: MastodonAccount, n: MastodonNotification): Pr
 
     // A project link takes precedence over inline BASIC: the source already
     // lives on the site, so render it directly rather than parsing the toot.
-    const projectId = extractProjectId(status.content, config.projectHost);
-    const code = projectId ? null : htmlToBasic(status.content);
-    if (!projectId && !code) {
+    const projectRef = extractProjectRef(status.content, config.projectHost);
+    const code = projectRef ? null : htmlToBasic(status.content);
+    if (!projectRef && !code) {
         console.log(`Mention ${n.id} from @${status.account.acct}: no project link or BASIC found, skipping`);
         return;
     }
+    const projectPath = projectRef ? `${projectRef.userSlug}/${projectRef.projectSlug}` : '';
     console.log(
-        projectId
-            ? `Mention ${n.id} from @${status.account.acct}: project ${projectId}`
+        projectRef
+            ? `Mention ${n.id} from @${status.account.acct}: project ${projectPath}`
             : `Mention ${n.id} from @${status.account.acct}: ${code!.split('\n').length} line(s)`,
     );
 
     const visibility = replyVisibility(status.visibility);
 
     if (config.dryRun) {
-        console.log(projectId ? `[dry-run] would render project ${projectId}` : `[dry-run] would run:\n${code}`);
+        console.log(projectRef ? `[dry-run] would render project ${projectPath}` : `[dry-run] would run:\n${code}`);
         return;
     }
 
-    const result = projectId ? await projectToMedia(projectId) : await basicToMedia(code!);
+    const result = projectRef ? await projectToMedia(projectRef) : await basicToMedia(code!);
 
     if (!result.ok) {
         await postReply({

apps/mastodon-bot/src/media.ts

@@ -1,4 +1,5 @@
 import { config } from './config.js';
+import { ProjectRef } from './project.js';
 
 export type MediaResult =
     | { ok: true; data: Buffer; contentType: string; filename: string; altText: string }
@@ -39,10 +40,10 @@ export function basicToMedia(code: string): Promise<MediaResult> {
 }
 
 /** Render a public code.zxplay.org project via gif-service, returning an MP4 or an error. */
-export function projectToMedia(projectId: string): Promise<MediaResult> {
+export function projectToMedia(ref: ProjectRef): Promise<MediaResult> {
     return requestMedia(
         '/api/project-to-mp4',
-        { projectId },
-        `${config.projectHost}/projects/${projectId}`,
+        ref,
+        `${config.projectHost}/u/${ref.userSlug}/${ref.projectSlug}`,
     );
 }

apps/mastodon-bot/src/project.ts

@@ -1,16 +1,21 @@
-const UUID = '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}';
+export interface ProjectRef {
+    userSlug: string;
+    projectSlug: string;
+}
+
+const SLUG = '[a-z0-9-]+';
 
 /**
  * Find a code.zxplay.org project link in a status's HTML content and return its
- * id. Matches the canonical project URL, https://<host>/projects/<uuid>, whether
- * it appears as an <a href> or as plain text. Returns null when there is none.
- *
- * The prettier /u/<user>/<slug> URLs are not handled yet: they need a slug
- * lookup, so for now a sharer links the /projects/<id> form.
+ * user/project slugs. Matches the canonical URL, https://<host>/u/<user>/<project>,
+ * whether it appears as an <a href> or as plain text. Returns null when there
+ * is no such link.
  */
-export function extractProjectId(content: string, host: string): string | null {
+export function extractProjectRef(content: string, host: string): ProjectRef | null {
     const escapedHost = host.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const re = new RegExp(`https?://${escapedHost}/projects/(${UUID})`, 'i');
+    const re = new RegExp(`https?://${escapedHost}/u/(${SLUG})/(${SLUG})`, 'i');
     const match = content.match(re);
-    return match ? match[1].toLowerCase() : null;
+    return match
+        ? { userSlug: match[1].toLowerCase(), projectSlug: match[2].toLowerCase() }
+        : null;
 }