feat(CCP-4487): implement workflow sharing and unsharing in UI

external-hooks/src/api/routes/ui-api.ts

@@ -2,11 +2,47 @@ import { Router, type Request } from 'express';
 import { createOidcJwtMiddleware } from '../middlewares';
 import { wrapAsyncRoute } from '../utils/errors';
 import type { ApiRouteContext } from '../types/routes';
+import type { OidcTokenDetails } from '../types/oidc';
+import { createRequestSchemaValidator, parseValidatedRequest, parseValidatedResponse } from '../utils/validation';
+import {
+  shareWorkflowResponseSchema,
+  shareWorkflowSchema,
+  unshareWorkflowResponseSchema,
+  unshareWorkflowSchema,
+} from '../schemas/ui';
 
 function getRequestOrigin(req: Request) {
   return req.get('origin') ?? `${req.protocol}://${req.get('host')}`;
 }
 
+function serializeRole(role: { slug: string; displayName: string } | null | undefined) {
+  return role ? { slug: role.slug, displayName: role.displayName } : null;
+}
+
+function serializeN8nUser(
+  user: { id: string; email: string; role: { slug: string; displayName: string } | null } | null,
+) {
+  return user ? { id: user.id, email: user.email, role: serializeRole(user.role) } : null;
+}
+
+function serializeOidcDetails(details: OidcTokenDetails | undefined) {
+  if (!details) return null;
+  return {
+    issuer: details.issuer,
+    subject: details.subject,
+    audience: details.audience,
+    azp: details.azp,
+    email: details.email,
+    preferredUsername: details.preferredUsername,
+    name: details.name,
+    scope: details.scope,
+    expiresAt: details.expiresAt,
+    issuedAt: details.issuedAt,
+    notBefore: details.notBefore,
+    claims: details.claims,
+  };
+}
+
 export function buildUiApiRouter({ services }: ApiRouteContext) {
   const router = Router();
   const oidcJwtMiddleware = createOidcJwtMiddleware({
@@ -42,29 +78,8 @@ export function buildUiApiRouter({ services }: ApiRouteContext) {
         ok: true,
         route: '/ui-api/whoami',
         method: req.method,
-        oidc: details
-          ? {
-              issuer: details.issuer,
-              subject: details.subject,
-              audience: details.audience,
-              azp: details.azp,
-              email: details.email,
-              preferredUsername: details.preferredUsername,
-              name: details.name,
-              scope: details.scope,
-              expiresAt: details.expiresAt,
-              issuedAt: details.issuedAt,
-              notBefore: details.notBefore,
-              claims: details.claims,
-            }
-          : null,
-        n8nUser: n8nUser
-          ? {
-              id: n8nUser.id,
-              email: n8nUser.email,
-              role: n8nUser.role ? { slug: n8nUser.role.slug, displayName: n8nUser.role.displayName } : null,
-            }
-          : null,
+        oidc: serializeOidcDetails(details),
+        n8nUser: serializeN8nUser(n8nUser),
         userAgent: req.get('user-agent') ?? null,
       });
     }),
@@ -81,20 +96,56 @@ export function buildUiApiRouter({ services }: ApiRouteContext) {
         ok: true,
         route: '/ui-api/workflows',
         method: req.method,
-        n8nUser: context.n8nUser
-          ? {
-              id: context.n8nUser.id,
-              email: context.n8nUser.email,
-              role: context.n8nUser.role
-                ? { slug: context.n8nUser.role.slug, displayName: context.n8nUser.role.displayName }
-                : null,
-            }
-          : null,
+        n8nUser: serializeN8nUser(context.n8nUser),
         accessibleProjectIds: context.accessibleProjectIds,
         workflows: context.workflows,
       });
     }),
   );
 
+  router.post(
+    '/workflows/:workflowId/share',
+    oidcJwtMiddleware,
+    createRequestSchemaValidator(shareWorkflowSchema),
+    wrapAsyncRoute(async (req, res) => {
+      const details = res.locals.oidcTokenDetails;
+      const parsed = parseValidatedRequest(shareWorkflowSchema, req);
+      const result = await services.uiApi.shareWorkflow(details.email, parsed.params.workflowId, parsed.body.email);
+
+      const payload = parseValidatedResponse(shareWorkflowResponseSchema, {
+        success: true as const,
+        message: `Workflow '${result.workflowId}' shared with '${result.sharedWithEmail}'.`,
+        workflowId: result.workflowId,
+        sharedWithEmail: result.sharedWithEmail,
+      });
+
+      res.status(201).json(payload);
+    }),
+  );
+
+  router.delete(
+    '/workflows/:workflowId/projects/:projectId',
+    oidcJwtMiddleware,
+    createRequestSchemaValidator(unshareWorkflowSchema),
+    wrapAsyncRoute(async (req, res) => {
+      const details = res.locals.oidcTokenDetails;
+      const parsed = parseValidatedRequest(unshareWorkflowSchema, req);
+      const result = await services.uiApi.unshareWorkflow(
+        details.email,
+        parsed.params.workflowId,
+        parsed.params.projectId,
+      );
+
+      const payload = parseValidatedResponse(unshareWorkflowResponseSchema, {
+        success: true as const,
+        message: `Workflow '${result.workflowId}' unshared from project '${result.projectId}'.`,
+        workflowId: result.workflowId,
+        projectId: result.projectId,
+      });
+
+      res.status(200).json(payload);
+    }),
+  );
+
   return router;
 }

external-hooks/src/api/schemas/ui.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { trimString } from '../utils/string';
+
+export const shareWorkflowSchema = z.object({
+  params: z.object({
+    workflowId: z.string().trim().min(1),
+  }),
+  query: z.record(z.string(), z.unknown()).optional(),
+  body: z
+    .object({
+      email: z.unknown(),
+    })
+    .transform((body) => ({
+      email: trimString(body.email),
+    }))
+    .refine((body) => Boolean(body.email), { message: 'Missing email in request body.' }),
+});
+
+export const shareWorkflowResponseSchema = z.object({
+  success: z.literal(true),
+  message: z.string(),
+  workflowId: z.string(),
+  sharedWithEmail: z.string(),
+});
+
+export const unshareWorkflowSchema = z.object({
+  params: z.object({
+    workflowId: z.string().trim().min(1),
+    projectId: z.string().trim().min(1),
+  }),
+  query: z.record(z.string(), z.unknown()).optional(),
+  body: z.record(z.string(), z.unknown()).optional(),
+});
+
+export const unshareWorkflowResponseSchema = z.object({
+  success: z.literal(true),
+  message: z.string(),
+  workflowId: z.string(),
+  projectId: z.string(),
+});