@commonpub/layer 0.83.1 → 0.84.0

package/utils/contestStages.ts

@@ -109,23 +109,20 @@ export function blankTemplateField(): ContestSubmissionTemplateField {
   return { key: '', label: '', type: 'text', required: false };
 }
 
-function withTemplate(stages: ContestStage[], i: number, template: ContestSubmissionTemplateField[]): ContestStage[] {
-  return stages.map((s, idx) => (idx === i ? { ...s, submissionTemplate: template.length ? template : undefined } : s));
-}
+type FieldType = ContestSubmissionTemplateField['type'];
+type TemplateField = ContestSubmissionTemplateField;
 
-export function withTemplateFieldAdded(stages: ContestStage[], i: number): ContestStage[] {
-  const cur = stages[i]?.submissionTemplate ?? [];
-  return withTemplate(stages, i, [...cur, blankTemplateField()]);
+// ─── Array-level template ops (operate on ONE stage's submissionTemplate) ───
+// The extracted ContestStageTemplateEditor works on a plain field array; the
+// stage-indexed `withTemplate*` wrappers below delegate to these so both surfaces
+// share one implementation (and the existing unit tests still exercise it).
+
+export function templateFieldAdded(t: TemplateField[]): TemplateField[] {
+  return [...t, blankTemplateField()];
 }
 
-export function withTemplateFieldSet(
-  stages: ContestStage[],
-  i: number,
-  fi: number,
-  patch: Partial<ContestSubmissionTemplateField>,
-): ContestStage[] {
-  const cur = (stages[i]?.submissionTemplate ?? []).map((f, idx) => (idx === fi ? { ...f, ...patch } : f));
-  return withTemplate(stages, i, cur);
+export function templateFieldSet(t: TemplateField[], fi: number, patch: Partial<TemplateField>): TemplateField[] {
+  return t.map((f, idx) => (idx === fi ? { ...f, ...patch } : f));
 }
 
 /**
@@ -134,28 +131,17 @@ export function withTemplateFieldSet(
  * organizer edited by hand is left alone — once entrants have submitted, keys
  * are what artifact values hang off, so they must stay stable.
  */
-export function withTemplateFieldLabelChanged(
-  stages: ContestStage[],
-  i: number,
-  fi: number,
-  label: string,
-): ContestStage[] {
-  const field = stages[i]?.submissionTemplate?.[fi];
-  if (!field) return stages;
+export function templateFieldLabelChanged(t: TemplateField[], fi: number, label: string): TemplateField[] {
+  const field = t[fi];
+  if (!field) return t;
   const tracksLabel = !field.key || field.key === fieldKeyFromLabel(field.label);
-  const patch: Partial<ContestSubmissionTemplateField> = tracksLabel
-    ? { label, key: fieldKeyFromLabel(label) }
-    : { label };
-  return withTemplateFieldSet(stages, i, fi, patch);
+  return templateFieldSet(t, fi, tracksLabel ? { label, key: fieldKeyFromLabel(label) } : { label });
 }
 
-export function withTemplateFieldRemoved(stages: ContestStage[], i: number, fi: number): ContestStage[] {
-  const cur = (stages[i]?.submissionTemplate ?? []).filter((_, idx) => idx !== fi);
-  return withTemplate(stages, i, cur);
+export function templateFieldRemoved(t: TemplateField[], fi: number): TemplateField[] {
+  return t.filter((_, idx) => idx !== fi);
 }
 
-type FieldType = ContestSubmissionTemplateField['type'];
-
 /**
  * Change a template field's type AND normalize the type-specific ancillary props
  * so the stored field stays coherent (Phase 4): `address` forces `pii`; leaving
@@ -163,15 +149,10 @@ type FieldType = ContestSubmissionTemplateField['type'];
  * `mustAccept`; entering `select` seeds one blank option; entering `agreement`
  * defaults `mustAccept` true.
  */
-export function withTemplateFieldTypeChanged(
-  stages: ContestStage[],
-  i: number,
-  fi: number,
-  type: FieldType,
-): ContestStage[] {
-  const field = stages[i]?.submissionTemplate?.[fi];
-  if (!field) return stages;
-  const patch: Partial<ContestSubmissionTemplateField> = { type };
+export function templateFieldTypeChanged(t: TemplateField[], fi: number, type: FieldType): TemplateField[] {
+  const field = t[fi];
+  if (!field) return t;
+  const patch: Partial<TemplateField> = { type };
   patch.options = type === 'select' ? (field.options?.length ? field.options : [{ value: '', label: '' }]) : undefined;
   if (type === 'agreement') {
     patch.mustAccept = field.mustAccept ?? true;
@@ -181,13 +162,64 @@ export function withTemplateFieldTypeChanged(
     patch.mustAccept = undefined;
   }
   if (type === 'address') patch.pii = true;
-  return withTemplateFieldSet(stages, i, fi, patch);
+  return templateFieldSet(t, fi, patch);
+}
+
+export function templateOptionAdded(t: TemplateField[], fi: number): TemplateField[] {
+  const field = t[fi];
+  if (!field) return t;
+  return templateFieldSet(t, fi, { options: [...(field.options ?? []), { value: '', label: '' }] });
+}
+
+export function templateOptionSet(
+  t: TemplateField[],
+  fi: number,
+  oi: number,
+  patch: Partial<{ value: string; label: string }>,
+): TemplateField[] {
+  const field = t[fi];
+  if (!field) return t;
+  const options = (field.options ?? []).map((o, idx) => (idx === oi ? { ...o, ...patch } : o));
+  return templateFieldSet(t, fi, { options });
+}
+
+export function templateOptionRemoved(t: TemplateField[], fi: number, oi: number): TemplateField[] {
+  const field = t[fi];
+  if (!field) return t;
+  return templateFieldSet(t, fi, { options: (field.options ?? []).filter((_, idx) => idx !== oi) });
+}
+
+// ─── Stage-indexed wrappers (delegate to the array-level ops above) ───
+
+function withTemplate(stages: ContestStage[], i: number, template: TemplateField[]): ContestStage[] {
+  return stages.map((s, idx) => (idx === i ? { ...s, submissionTemplate: template.length ? template : undefined } : s));
+}
+
+export function withTemplateFieldAdded(stages: ContestStage[], i: number): ContestStage[] {
+  return withTemplate(stages, i, templateFieldAdded(stages[i]?.submissionTemplate ?? []));
+}
+
+export function withTemplateFieldSet(stages: ContestStage[], i: number, fi: number, patch: Partial<TemplateField>): ContestStage[] {
+  return withTemplate(stages, i, templateFieldSet(stages[i]?.submissionTemplate ?? [], fi, patch));
+}
+
+export function withTemplateFieldLabelChanged(stages: ContestStage[], i: number, fi: number, label: string): ContestStage[] {
+  if (!stages[i]?.submissionTemplate?.[fi]) return stages;
+  return withTemplate(stages, i, templateFieldLabelChanged(stages[i]!.submissionTemplate!, fi, label));
+}
+
+export function withTemplateFieldRemoved(stages: ContestStage[], i: number, fi: number): ContestStage[] {
+  return withTemplate(stages, i, templateFieldRemoved(stages[i]?.submissionTemplate ?? [], fi));
+}
+
+export function withTemplateFieldTypeChanged(stages: ContestStage[], i: number, fi: number, type: FieldType): ContestStage[] {
+  if (!stages[i]?.submissionTemplate?.[fi]) return stages;
+  return withTemplate(stages, i, templateFieldTypeChanged(stages[i]!.submissionTemplate!, fi, type));
 }
 
 export function withTemplateOptionAdded(stages: ContestStage[], i: number, fi: number): ContestStage[] {
-  const field = stages[i]?.submissionTemplate?.[fi];
-  if (!field) return stages;
-  return withTemplateFieldSet(stages, i, fi, { options: [...(field.options ?? []), { value: '', label: '' }] });
+  if (!stages[i]?.submissionTemplate?.[fi]) return stages;
+  return withTemplate(stages, i, templateOptionAdded(stages[i]!.submissionTemplate!, fi));
 }
 
 export function withTemplateOptionSet(
@@ -197,16 +229,13 @@ export function withTemplateOptionSet(
   oi: number,
   patch: Partial<{ value: string; label: string }>,
 ): ContestStage[] {
-  const field = stages[i]?.submissionTemplate?.[fi];
-  if (!field) return stages;
-  const options = (field.options ?? []).map((o, idx) => (idx === oi ? { ...o, ...patch } : o));
-  return withTemplateFieldSet(stages, i, fi, { options });
+  if (!stages[i]?.submissionTemplate?.[fi]) return stages;
+  return withTemplate(stages, i, templateOptionSet(stages[i]!.submissionTemplate!, fi, oi, patch));
 }
 
 export function withTemplateOptionRemoved(stages: ContestStage[], i: number, fi: number, oi: number): ContestStage[] {
-  const field = stages[i]?.submissionTemplate?.[fi];
-  if (!field) return stages;
-  return withTemplateFieldSet(stages, i, fi, { options: (field.options ?? []).filter((_, idx) => idx !== oi) });
+  if (!stages[i]?.submissionTemplate?.[fi]) return stages;
+  return withTemplate(stages, i, templateOptionRemoved(stages[i]!.submissionTemplate!, fi, oi));
 }
 
 /** Human label for each template field type (for the editor dropdown). */

package/utils/contestTemplates.ts

@@ -0,0 +1,116 @@
+import type { ContestStage, ContestSubmissionTemplateField } from '@commonpub/schema';
+import { markdownToBlockTuples } from '@commonpub/editor';
+import { newStageId } from './contestStages';
+
+/**
+ * Starter templates for a NEW contest. A blank create page is intimidating and
+ * leaves organisers to discover the (substantial) submission-form / stage / rubric
+ * machinery by hand, so create.vue seeds the `standard` template by default
+ * (ContestEditor, create mode, onMounted). Pure + flag-adaptive so it unit-tests in
+ * isolation and degrades gracefully on instances where the proposal/PII builder
+ * features are OFF.
+ *
+ * A BlockTuple is `[type, attrs]`; bodies are seeded as structured heading/paragraph
+ * blocks via `markdownToBlockTuples` (the same path contestBody.ts uses for legacy
+ * markdown), so the seeded copy renders identically in the editor canvas AND the
+ * public view — a raw `markdown` block would not (its attr key is `source`, not the
+ * `content` an ad-hoc tuple would carry).
+ */
+export type ContestTemplateBlock = [string, Record<string, unknown>];
+
+export interface ContestTemplateSeed {
+  stages: ContestStage[];
+  currentStageId: string | null;
+  judgingCriteria: Array<{ label: string; weight?: number; description?: string }>;
+  descriptionBlocks: ContestTemplateBlock[];
+  rulesBlocks: ContestTemplateBlock[];
+  prizesBlocks: ContestTemplateBlock[];
+}
+
+export interface StandardTemplateOptions {
+  /** `features.contestProposals` — if on, the entry stage collects a proposal form
+   *  (creates a draft project); else it falls back to attaching a published project. */
+  proposals: boolean;
+  /** `features.contestPii` — if on, seed a rules-acceptance `agreement` field (the
+   *  agreement field type is only offered/edited in the builder when this is on). */
+  pii: boolean;
+}
+
+const RULES_AGREEMENT_TERMS =
+  'By entering, I confirm this submission is my own original work and I agree to the contest rules and code of conduct.';
+
+/** The proposal/entry stage's starter submission form (the approved general shape). */
+function standardSubmissionTemplate(opts: StandardTemplateOptions): ContestSubmissionTemplateField[] {
+  const fields: ContestSubmissionTemplateField[] = [
+    { key: 'project_name', label: 'Project name', type: 'text', required: true },
+    { key: 'summary', label: 'One-line summary', type: 'text', required: true, help: 'A single sentence describing your idea.' },
+    { key: 'description', label: 'Description', type: 'textarea', required: true, help: 'What you are building and the problem it solves.' },
+    { key: 'approach', label: 'Approach', type: 'textarea', required: false, help: 'How you plan to build it (optional).' },
+  ];
+  // The agreement field type is only surfaced in the builder when contestPii is on,
+  // so only seed it there — else it would be a hidden, un-editable required field.
+  if (opts.pii) {
+    fields.push({
+      key: 'rules_agreement',
+      label: 'Contest rules',
+      type: 'agreement',
+      required: true,
+      terms: RULES_AGREEMENT_TERMS,
+      mustAccept: true,
+    });
+  }
+  return fields;
+}
+
+/** The default rubric (contest-level; review stages fall back to it). */
+function standardCriteria(): ContestTemplateSeed['judgingCriteria'] {
+  return [
+    { label: 'Innovation', weight: 40, description: 'Originality and creativity of the idea.' },
+    { label: 'Feasibility', weight: 30, description: 'How realistic and well-scoped the plan is.' },
+    { label: 'Impact', weight: 30, description: 'Potential value to the community.' },
+  ];
+}
+
+/**
+ * The standard new-contest template: a Proposals (submission) stage with a starter
+ * form + rules agreement, a Judging (review) stage, and a Results stage, plus a
+ * default rubric and starter Overview/Rules copy. Stage dates are intentionally
+ * unset — the organiser sets the schedule, then can set per-stage dates in the
+ * Stages tab.
+ */
+export function standardContestTemplate(opts: StandardTemplateOptions): ContestTemplateSeed {
+  const stages: ContestStage[] = [
+    {
+      id: newStageId(),
+      name: 'Proposals',
+      kind: 'submission',
+      description: 'Entrants submit a proposal for review.',
+      submissionMode: opts.proposals ? 'proposal' : 'attach',
+      submissionTemplate: standardSubmissionTemplate(opts),
+    },
+    {
+      id: newStageId(),
+      name: 'Judging',
+      kind: 'review',
+      description: 'Judges score entries against the rubric.',
+    },
+    {
+      id: newStageId(),
+      name: 'Results',
+      kind: 'results',
+      description: 'Final standings are published.',
+    },
+  ];
+  return {
+    stages,
+    currentStageId: null,
+    judgingCriteria: standardCriteria(),
+    descriptionBlocks: markdownToBlockTuples(
+      '## About this contest\n\nDescribe who this contest is for, what to build, and why it matters. Replace this overview with your own.',
+    ) as ContestTemplateBlock[],
+    rulesBlocks: markdownToBlockTuples(
+      '## Rules\n\n- Who can enter\n- What counts as a valid entry\n- How judging works\n\nReplace these with your contest rules.',
+    ) as ContestTemplateBlock[],
+    prizesBlocks: [],
+  };
+}

package/server/api/content/[id]/__tests__/versions.get.test.ts

@@ -1,127 +0,0 @@
-/**
- * Auth-gating proving test for `GET /api/content/:id/versions`
- * (audit session 204).
- *
- * Version history (titles, author, timestamps — incl. for unpublished drafts)
- * was world-readable for any content id. The fix requires an authenticated
- * caller AND that they be the content owner OR hold `content.moderate`.
- *
- * This drives the REAL route handler against a REAL (PGlite) DB seeded with a
- * content item + a version row. The Nitro auth auto-imports are stubbed with
- * their REAL semantics (requireAuth throws 401 when anonymous; ownerOrPermission
- * returns true iff the caller is the owner or holds the permission), reading a
- * per-test `currentUser` — so the handler's actual branch on the gate boolean
- * and the DB row's authorId is exercised.
- */
-import { describe, it, expect, beforeAll } from 'vitest';
-import type { H3Event } from 'h3';
-import {
-  createTestDB,
-  createTestUser,
-} from '../../../../../../../packages/server/src/__tests__/helpers/testdb';
-import { contentItems, contentVersions } from '@commonpub/schema';
-import type { DB } from '../../../../../../../packages/server/src/types';
-
-interface HttpError extends Error {
-  statusCode: number;
-}
-interface TestUser {
-  id: string;
-  permissions: Set<string>;
-}
-
-let db: DB;
-let contentId: string;
-let ownerId: string;
-// null => anonymous. permissions => the set the caller holds.
-let currentUser: TestUser | null;
-
-{
-  const g = globalThis as Record<string, unknown>;
-  g.defineEventHandler = (fn: unknown): unknown => fn;
-  g.createError = (opts: { statusCode: number; statusMessage: string }): HttpError => {
-    const e = new Error(opts.statusMessage) as HttpError;
-    e.statusCode = opts.statusCode;
-    return e;
-  };
-  // Real semantics: 401 when there is no authenticated user.
-  g.requireAuth = (_event: H3Event): { id: string } => {
-    if (!currentUser) {
-      const e = new Error('Unauthorized') as HttpError;
-      e.statusCode = 401;
-      throw e;
-    }
-    return { id: currentUser.id };
-  };
-  g.useDB = (): DB => db;
-  // parseParams returns the id under test (route would parse from the path).
-  g.parseParams = (): { id: string } => ({ id: contentId });
-  // Real semantics: owner OR permission-holder.
-  g.ownerOrPermission = (_event: H3Event, resourceOwnerId: string, perm: string): boolean => {
-    if (!currentUser) return false;
-    if (currentUser.id === resourceOwnerId) return true;
-    return currentUser.permissions.has(perm);
-  };
-}
-
-const handlerMod = await import('../versions.get');
-const handler = handlerMod.default as (event: H3Event) => Promise<unknown>;
-const fakeEvent = {} as H3Event;
-
-function statusOf(p: Promise<unknown>): Promise<number | 'no-throw'> {
-  return p.then(
-    () => 'no-throw' as const,
-    (e: HttpError) => e.statusCode,
-  );
-}
-
-beforeAll(async () => {
-  db = await createTestDB();
-  const owner = await createTestUser(db, { username: 'owner' });
-  ownerId = owner.id;
-  const [item] = await db
-    .insert(contentItems)
-    .values({
-      authorId: owner.id,
-      type: 'blog',
-      title: 'Draft',
-      slug: 'draft',
-      status: 'draft',
-      visibility: 'private',
-      content: [],
-    } as never)
-    .returning();
-  contentId = (item as { id: string }).id;
-  await db.insert(contentVersions).values({
-    contentId,
-    version: 1,
-    title: 'Draft v1',
-    createdById: owner.id,
-  } as never);
-}, 30_000); // PGlite pushSchema is heavy; generous setup timeout under parallel load
-
-describe('versions.get — author/moderator-only', () => {
-  it('anonymous caller → 401', async () => {
-    currentUser = null;
-    expect(await statusOf(handler(fakeEvent))).toBe(401);
-  });
-
-  it('authenticated non-owner without content.moderate → 403', async () => {
-    currentUser = { id: 'some-other-user-id', permissions: new Set() };
-    expect(await statusOf(handler(fakeEvent))).toBe(403);
-  });
-
-  it('owner → returns the version list', async () => {
-    currentUser = { id: ownerId, permissions: new Set() };
-    const result = (await handler(fakeEvent)) as Array<{ title: string | null }>;
-    expect(Array.isArray(result)).toBe(true);
-    expect(result.length).toBe(1);
-    expect(result[0]?.title).toBe('Draft v1');
-  });
-
-  it('non-owner WITH content.moderate → returns the version list', async () => {
-    currentUser = { id: 'mod-user-id', permissions: new Set(['content.moderate']) };
-    const result = (await handler(fakeEvent)) as unknown[];
-    expect(result.length).toBe(1);
-  });
-});