Implement OneToManyDyadCensus and Anonymisation Interfaces

.eslintrc.cjs

@@ -1,5 +1,3 @@
-const path = require('path');
-
 /** @type {import("eslint").Linter.Config} */
 const config = {
   overrides: [
@@ -10,13 +8,13 @@ const config = {
       ],
       files: ['*.ts', '*.tsx'],
       parserOptions: {
-        project: path.join(__dirname, 'tsconfig.json'),
+        project: true,
       },
     },
   ],
   parser: '@typescript-eslint/parser',
   parserOptions: {
-    project: path.join(__dirname, 'tsconfig.json'),
+    project: true,
   },
   plugins: ['@typescript-eslint'],
   extends: [
@@ -35,6 +33,7 @@ const config = {
   ],
   rules: {
     '@next/next/no-img-element': 'off',
+    'import/no-cycle': 'error',
     'import/no-anonymous-default-export': 'off',
     '@typescript-eslint/consistent-type-definitions': ['error', 'type'],
     'no-process-env': 'error',

actions/activityFeed.ts

@@ -1,7 +1,7 @@
 'use server';
 
+import type { Activity, ActivityType } from '~/components/DataTable/types';
 import { safeRevalidateTag } from '~/lib/cache';
-import type { Activity, ActivityType } from '~/lib/data-table/types';
 import { prisma } from '~/utils/db';
 
 export async function addEvent(

actions/interviews.ts

@@ -1,11 +1,12 @@
 'use server';
 
+import { type NcNetwork } from '@codaco/shared-consts';
 import { createId } from '@paralleldrive/cuid2';
-import { Prisma, type Interview, type Protocol } from '@prisma/client';
+import { type Interview } from '@prisma/client';
 import { cookies } from 'next/headers';
 import trackEvent from '~/lib/analytics';
 import { safeRevalidateTag } from '~/lib/cache';
-import type { InstalledProtocols } from '~/lib/interviewer/store';
+import { initialNetwork } from '~/lib/interviewer/ducks/modules/session';
 import { formatExportableSessions } from '~/lib/network-exporters/formatters/formatExportableSessions';
 import archive from '~/lib/network-exporters/formatters/session/archive';
 import { generateOutputFiles } from '~/lib/network-exporters/formatters/session/generateOutputFiles';
@@ -18,13 +19,11 @@ import type {
   FormattedSession,
 } from '~/lib/network-exporters/utils/types';
 import { getAppSetting } from '~/queries/appSettings';
-import { getInterviewsForExport } from '~/queries/interviews';
-import type {
-  CreateInterview,
-  DeleteInterviews,
-  SyncInterview,
-} from '~/schemas/interviews';
-import { type NcNetwork } from '~/schemas/network-canvas';
+import {
+  getInterviewsForExport,
+  type GetInterviewsForExportReturnType,
+} from '~/queries/interviews';
+import type { CreateInterview, DeleteInterviews } from '~/schemas/interviews';
 import { requireApiAuth } from '~/utils/auth';
 import { prisma } from '~/utils/db';
 import { ensureError } from '~/utils/ensureError';
@@ -86,26 +85,29 @@ export const updateExportTime = async (interviewIds: Interview['id'][]) => {
   }
 };
 
+export type ExportedProtocol =
+  Awaited<GetInterviewsForExportReturnType>[number]['protocol'];
+
 export const prepareExportData = async (interviewIds: Interview['id'][]) => {
   await requireApiAuth();
 
   const interviewsSessions = await getInterviewsForExport(interviewIds);
 
-  const protocolsMap = new Map<string, Protocol>();
+  const protocolsMap = new Map<string, ExportedProtocol>();
   interviewsSessions.forEach((session) => {
     protocolsMap.set(session.protocol.hash, session.protocol);
   });
 
-  const formattedProtocols: InstalledProtocols =
-    Object.fromEntries(protocolsMap);
+  const formattedProtocols = Object.fromEntries(protocolsMap);
+
   const formattedSessions = formatExportableSessions(interviewsSessions);
 
   return { formattedSessions, formattedProtocols };
 };
 
 export const exportSessions = async (
   formattedSessions: FormattedSession[],
-  formattedProtocols: InstalledProtocols,
+  formattedProtocols: Record<string, ExportedProtocol>,
   interviewIds: Interview['id'][],
   exportOptions: ExportOptions,
 ): Promise<ExportReturn> => {
@@ -200,7 +202,7 @@ export async function createInterview(data: CreateInterview) {
         id: true,
       },
       data: {
-        network: Prisma.JsonNull,
+        network: initialNetwork,
         participant: participantStatement,
         protocol: {
           connect: {
@@ -248,35 +250,6 @@ export async function createInterview(data: CreateInterview) {
   }
 }
 
-export async function syncInterview(data: SyncInterview) {
-  const { id, network, currentStep, stageMetadata } = data;
-
-  try {
-    await prisma.interview.update({
-      where: {
-        id,
-      },
-      data: {
-        network,
-        currentStep,
-        stageMetadata,
-        lastUpdated: new Date(),
-      },
-    });
-
-    safeRevalidateTag(`getInterviewById-${id}`);
-
-    // eslint-disable-next-line no-console
-    console.log(`🚀 Interview synced with server! (${id})`);
-    return { success: true };
-  } catch (error) {
-    const message = ensureError(error).message;
-    return { success: false, error: message };
-  }
-}
-
-export type SyncInterviewType = typeof syncInterview;
-
 export async function finishInterview(interviewId: Interview['id']) {
   try {
     const updatedInterview = await prisma.interview.update({

actions/protocols.ts

@@ -1,6 +1,5 @@
 'use server';
 
-import { type Protocol } from '@codaco/shared-consts';
 import { Prisma } from '@prisma/client';
 import { safeRevalidateTag } from 'lib/cache';
 import { hash } from 'ohash';
@@ -125,31 +124,26 @@ export async function insertProtocol(
 ) {
   await requireApiAuth();
 
-  const {
-    protocol: inputProtocol,
-    protocolName,
-    newAssets,
-    existingAssetIds,
-  } = protocolInsertSchema.parse(input);
-
-  const protocol = inputProtocol as Protocol;
+  const { protocol, protocolName, newAssets, existingAssetIds } =
+    protocolInsertSchema.parse(input);
 
   try {
     const protocolHash = hash(protocol);
 
     await prisma.protocol.create({
       data: {
         hash: protocolHash,
-        lastModified: protocol.lastModified,
+        lastModified: protocol.lastModified ?? new Date(),
         name: protocolName,
         schemaVersion: protocol.schemaVersion,
-        stages: protocol.stages as unknown as Prisma.JsonArray, // The Stage interface needs to be changed to be a type: https://www.totaltypescript.com/type-vs-interface-which-should-you-use#index-signatures-in-types-vs-interfaces
+        stages: protocol.stages,
         codebook: protocol.codebook,
         description: protocol.description,
         assets: {
           create: newAssets,
           connect: existingAssetIds.map((assetId) => ({ assetId })),
         },
+        experiments: protocol.experiments ?? Prisma.JsonNull,
       },
     });
 

app/(interview)/interview/[interviewId]/page.tsx

@@ -1,12 +1,17 @@
 import { cookies } from 'next/headers';
 import { notFound, redirect } from 'next/navigation';
-import { syncInterview } from '~/actions/interviews';
+import SuperJSON from 'superjson';
 import FeedbackBanner from '~/components/Feedback/FeedbackBanner';
 import { getAppSetting } from '~/queries/appSettings';
-import { getInterviewById } from '~/queries/interviews';
+import {
+  getInterviewById,
+  type GetInterviewByIdQuery,
+} from '~/queries/interviews';
 import { getServerSession } from '~/utils/auth';
 import InterviewShell from '../_components/InterviewShell';
 
+export const dynamic = 'force-dynamic';
+
 export default async function Page({
   params,
 }: {
@@ -18,32 +23,36 @@ export default async function Page({
     return 'No interview id found';
   }
 
-  const interview = await getInterviewById(interviewId);
-  const session = await getServerSession();
+  const rawInterview = await getInterviewById(interviewId);
 
   // If the interview is not found, redirect to the 404 page
-  if (!interview) {
+  if (!rawInterview) {
     notFound();
   }
 
+  const interview =
+    SuperJSON.parse<NonNullable<GetInterviewByIdQuery>>(rawInterview);
+  const session = await getServerSession();
+
   // if limitInterviews is enabled
   // Check cookies for interview already completed for this user for this protocol
   // and redirect to finished page
   const limitInterviews = await getAppSetting('limitInterviews');
 
-  if (limitInterviews && cookies().get(interview?.protocol?.id ?? '')) {
+  if (limitInterviews && cookies().get(interview.protocol.id)) {
     redirect('/interview/finished');
   }
 
-  // If the interview is finished, redirect to the finish page
-  if (interview?.finishTime) {
+  // If the interview is finished, redirect to the finish page, unless we are
+  // logged in as an admin
+  if (!session && interview?.finishTime) {
     redirect('/interview/finished');
   }
 
   return (
     <>
       {session && <FeedbackBanner />}
-      <InterviewShell interview={interview} syncInterview={syncInterview} />
+      <InterviewShell rawPayload={rawInterview} />
     </>
   );
 }

app/(interview)/interview/[interviewId]/sync/route.ts

@@ -0,0 +1,71 @@
+import { NcNetworkSchema } from '@codaco/shared-consts';
+import { NextResponse, type NextRequest } from 'next/server';
+import { z } from 'zod';
+import { safeRevalidateTag } from '~/lib/cache';
+import { StageMetadataSchema } from '~/lib/interviewer/ducks/modules/session';
+import { prisma } from '~/utils/db';
+import { ensureError } from '~/utils/ensureError';
+
+/**
+ * Handle post requests from the client to store the current interview state.
+ */
+const routeHandler = async (
+  request: NextRequest,
+  { params }: { params: { interviewId: string } },
+) => {
+  const interviewId = params.interviewId;
+
+  const rawRequest = await request.json();
+
+  const Schema = z.object({
+    id: z.string(),
+    network: NcNetworkSchema,
+    currentStep: z.number(),
+    stageMetadata: StageMetadataSchema.optional(),
+    lastUpdated: z.string(),
+  });
+
+  const validatedRequest = Schema.safeParse(rawRequest);
+
+  if (!validatedRequest.success) {
+    return NextResponse.json(
+      {
+        error: validatedRequest.error,
+      },
+      { status: 400 },
+    );
+  }
+
+  const { network, currentStep, stageMetadata, lastUpdated } =
+    validatedRequest.data;
+
+  try {
+    await prisma.interview.update({
+      where: {
+        id: interviewId,
+      },
+      data: {
+        network,
+        currentStep,
+        stageMetadata: stageMetadata ?? undefined,
+        lastUpdated: new Date(lastUpdated),
+      },
+    });
+
+    safeRevalidateTag(`getInterviewById-${interviewId}`);
+
+    // eslint-disable-next-line no-console
+    console.log(`🚀 Interview synced with server! (${interviewId})`);
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    const message = ensureError(error).message;
+    return NextResponse.json(
+      {
+        error: message,
+      },
+      { status: 500 },
+    );
+  }
+};
+
+export { routeHandler as POST };