sea-dev 1.0.0

package/apps/api/src/routes/v2/forms/index.ts

@@ -0,0 +1,382 @@
+import { type FastifyInstance } from "fastify";
+import { type ZodTypeProvider } from "fastify-type-provider-zod";
+import * as z from "zod/v4";
+import {
+  createFormDerivedHandler,
+  createFormFieldHandler,
+  createFormGroupHandler,
+  createFormHandler,
+  deleteFormDerivedHandler,
+  deleteFormFieldHandler,
+  deleteFormGroupHandler,
+  deleteFormHandler,
+  generateHintsHandler,
+  getFormCorrectionsHandler,
+  getFormHandler,
+  getFormsHandler,
+  patchFormFieldHandler,
+  updateFormDerivedHandler,
+  updateFormFieldHintHandler,
+  updateFormGroupHandler,
+  updateFormHandler,
+} from "./handlers";
+import {
+  createFormDerivedSchema,
+  createFormFieldSchema,
+  createFormFromJsonSchema,
+  createFormGroupSchema,
+  formCorrectionsGroupedResponseSchema,
+  formDerivedResponseSchema,
+  formFieldResponseSchema,
+  formGroupResponseSchema,
+  formResponseSchema,
+  formsListResponseSchema,
+  generateHintsRequestSchema,
+  generateHintsResponseSchema,
+  patchFormFieldSchema,
+  updateFieldHintSchema,
+  updateFormDerivedSchema,
+  updateFormGroupSchema,
+  updateFormSchema,
+} from "./schemas";
+
+export async function v2FormsRouter(app: FastifyInstance) {
+  app
+    .withTypeProvider<ZodTypeProvider>()
+    .route({
+      method: "GET",
+      url: "/",
+      schema: {
+        tags: ["Forms"],
+        description:
+          "Retrieve all forms for the authenticated user's organization. Returns an array of form objects containing basic form metadata (id, workflowId, organizationId, conversationId, name, hint, timestamps) without nested groups and fields. Forms are automatically filtered by the user's organization membership. Use GET /forms/{formId} to retrieve a specific form with its complete structure.",
+        response: {
+          200: formsListResponseSchema,
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ member }, reply) => getFormsHandler(member, reply),
+    })
+    .route({
+      method: "POST",
+      url: "/create",
+      schema: {
+        tags: ["Forms"],
+        description:
+          "Create a complete form with groups and fields from. This endpoint allows creating a full form structure in one API call. The JSON must include workflowId, name, and at least one group with at least one field. Groups will be created with the specified order, and fields within each group will be ordered sequentially. Field types default to 'string' if not specified. Returns the complete form object with all nested groups and fields.",
+        body: createFormFromJsonSchema,
+        response: {
+          200: formResponseSchema,
+          400: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ body, member }, reply) => createFormHandler(body, member, reply),
+    })
+    .route({
+      method: "GET",
+      url: "/:formId",
+      schema: {
+        tags: ["Forms"],
+        description:
+          "Retrieve a specific form by ID with its complete structure including all groups and fields. Returns the full form object with nested groups array, where each group contains its fields array. Each field includes type information (string, string-long, number, boolean, date, email, money, url), ordering, and metadata. Will return 404 if the form doesn't exist or the user doesn't have permission to access it.",
+        params: z.object({ formId: z.string().min(1) }),
+        response: {
+          200: formResponseSchema,
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ params, member }, reply) => getFormHandler(params, member, reply),
+    })
+    .route({
+      method: "PATCH",
+      url: "/:formId",
+      schema: {
+        tags: ["Forms"],
+        description:
+          "Update a form's basic properties (name and/or hint). Both fields are optional - provide only the ones you want to update. The name must be at least 1 character if provided. This endpoint only modifies the form metadata, not its groups or fields structure. Returns the updated form object with complete structure. Will return 404 if the form doesn't exist or the user doesn't have permission to modify it.",
+        params: z.object({ formId: z.string().min(1) }),
+        body: updateFormSchema,
+        response: {
+          200: formResponseSchema,
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ params, body, member }, reply) =>
+        updateFormHandler({ formId: params.formId, ...body }, member, reply),
+    })
+    .route({
+      method: "DELETE",
+      url: "/:formId",
+      schema: {
+        tags: ["Forms"],
+        description:
+          "Soft delete a form by setting its deletedAt timestamp. The form and its associated data are not permanently removed but are hidden from normal queries. This operation cannot be undone via the API. Returns success status on completion. Will return 404 if the form doesn't exist or the user doesn't have permission to delete it. All associated submissions and data remain intact but may become inaccessible.",
+        params: z.object({ formId: z.string().min(1) }),
+        response: {
+          200: z.object({ success: z.boolean() }),
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ params, member }, reply) => deleteFormHandler(params, member, reply),
+    })
+    .route({
+      method: "POST",
+      url: "/:formId/groups",
+      schema: {
+        tags: ["Forms"],
+        description:
+          "Create a new group in a form. Groups organize form fields into logical sections. The multi field indicates whether this group can have multiple instances (default: false). The order field is optional and will append the group at the end if not specified. Returns the created group with its ID and metadata. Will return 404 if the form doesn't exist or the user doesn't have access to it.",
+        params: z.object({ formId: z.string().min(1) }),
+        body: createFormGroupSchema,
+        response: {
+          200: formGroupResponseSchema,
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ params, body, member }, reply) =>
+        createFormGroupHandler({ formId: params.formId, ...body }, member, reply),
+    })
+    .route({
+      method: "PATCH",
+      url: "/:formId/groups/:groupId",
+      schema: {
+        tags: ["Forms"],
+        description:
+          "Partially update an existing form group with only the properties you want to change. All fields (name, multi, hint, order) are optional - provide only the ones you want to update. The group must belong to the specified form. Returns success status on completion. Will return 404 if the form or group doesn't exist, or if the group doesn't belong to the specified form.",
+        params: z.object({ formId: z.string().min(1), groupId: z.string().min(1) }),
+        body: updateFormGroupSchema,
+        response: {
+          200: formGroupResponseSchema,
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ params, body, member }, reply) =>
+        updateFormGroupHandler(
+          { formId: params.formId, formGroupId: params.groupId, ...body },
+          member,
+          reply,
+        ),
+    })
+    .route({
+      method: "DELETE",
+      url: "/:formId/groups/:groupId",
+      schema: {
+        tags: ["Forms"],
+        description:
+          "Delete a form group. This operation will cascade delete all fields within the group. Returns success status on completion. Will return 404 if the form or group doesn't exist, or if the group doesn't belong to the specified form. WARNING: This permanently removes the group and all its fields from the database.",
+        params: z.object({ formId: z.string().min(1), groupId: z.string().min(1) }),
+        response: {
+          200: z.object({ success: z.boolean() }),
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ params, member }, reply) =>
+        deleteFormGroupHandler(
+          { formId: params.formId, formGroupId: params.groupId },
+          member,
+          reply,
+        ),
+    })
+    .route({
+      method: "POST",
+      url: "/:formId/groups/:groupId/fields",
+      schema: {
+        tags: ["Forms"],
+        description:
+          "Create a new field within a form group. Fields define the data structure for form submissions. Available field types: string, string-long, number, boolean, date, email, money, url (default: string). The order field is optional and will append the field at the end if not specified. Returns the created field with its ID and metadata. Will return 404 if the form or group doesn't exist or the user doesn't have access to them.",
+        params: z.object({ formId: z.string().min(1), groupId: z.string().min(1) }),
+        body: createFormFieldSchema,
+        response: {
+          200: formFieldResponseSchema,
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ params, body, member }, reply) =>
+        createFormFieldHandler(
+          { formId: params.formId, groupId: params.groupId, ...body },
+          member,
+          reply,
+        ),
+    })
+    .route({
+      method: "PATCH",
+      url: "/:formId/fields/:fieldId",
+      schema: {
+        tags: ["Forms"],
+        description:
+          "Partially update an existing form field with only the properties you want to change. All fields (name, hint, type, order) are optional - provide only the ones you want to update. The field must belong to the specified form. Available field types: string, string-long, number, boolean, date, email, money, url. The order must be a non-negative integer if provided. Returns success status on completion. Will return 404 if the form or field doesn't exist, or if the field doesn't belong to the specified form.",
+        params: z.object({ formId: z.string().min(1), fieldId: z.string().min(1) }),
+        body: patchFormFieldSchema,
+        response: {
+          200: formFieldResponseSchema,
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ params, body, member }, reply) =>
+        patchFormFieldHandler(
+          { formId: params.formId, formFieldId: params.fieldId, ...body },
+          member,
+          reply,
+        ),
+    })
+    .route({
+      method: "DELETE",
+      url: "/:formId/fields/:fieldId",
+      schema: {
+        tags: ["Forms"],
+        description:
+          "Delete a form field. Returns success status on completion. Will return 404 if the form or field doesn't exist, or if the field doesn't belong to the specified form. WARNING: This permanently removes the field from the database.",
+        params: z.object({ formId: z.string().min(1), fieldId: z.string().min(1) }),
+        response: {
+          200: z.object({ success: z.boolean() }),
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ params, member }, reply) =>
+        deleteFormFieldHandler(
+          { formId: params.formId, formFieldId: params.fieldId },
+          member,
+          reply,
+        ),
+    })
+    .route({
+      method: "POST",
+      url: "/:formId/groups/:groupId/derived",
+      schema: {
+        tags: ["Forms"],
+        description:
+          "Create a new derived field within a form group. Derived fields are computed fields that are automatically generated based on a prompt. The prompt field is optional and defaults to empty string. Returns the created derived field with its ID and metadata. Will return 404 if the form or group doesn't exist or the user doesn't have access to them.",
+        params: z.object({ formId: z.string().min(1), groupId: z.string().min(1) }),
+        body: createFormDerivedSchema,
+        response: {
+          200: formDerivedResponseSchema,
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ params, body, member }, reply) =>
+        createFormDerivedHandler(
+          { formId: params.formId, groupId: params.groupId, ...body },
+          member,
+          reply,
+        ),
+    })
+    .route({
+      method: "PATCH",
+      url: "/:formId/derived/:derivedId",
+      schema: {
+        tags: ["Forms"],
+        description:
+          "Partially update an existing derived field with only the properties you want to change. All fields (name, prompt) are optional - provide only the ones you want to update. The derived field must belong to the specified form. Returns success status on completion. Will return 404 if the form or derived field doesn't exist, or if the derived field doesn't belong to the specified form.",
+        params: z.object({ formId: z.string().min(1), derivedId: z.string().min(1) }),
+        body: updateFormDerivedSchema,
+        response: {
+          200: formDerivedResponseSchema,
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ params, body, member }, reply) =>
+        updateFormDerivedHandler(
+          { formId: params.formId, derivedId: params.derivedId, ...body },
+          member,
+          reply,
+        ),
+    })
+    .route({
+      method: "DELETE",
+      url: "/:formId/derived/:derivedId",
+      schema: {
+        tags: ["Forms"],
+        description:
+          "Delete a derived field. Returns success status on completion. Will return 404 if the form or derived field doesn't exist, or if the derived field doesn't belong to the specified form. WARNING: This permanently removes the derived field from the database.",
+        params: z.object({ formId: z.string().min(1), derivedId: z.string().min(1) }),
+        response: {
+          200: z.object({ success: z.boolean() }),
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ params, member }, reply) => deleteFormDerivedHandler(params, member, reply),
+    })
+
+    // Feedback / corrections routes
+    .route({
+      method: "GET",
+      url: "/:formId/feedback/corrections",
+      schema: {
+        tags: ["Forms"],
+        description:
+          "Retrieve all corrections and feedback for a form, grouped by field. Returns a map where keys are form field IDs and values are arrays of corrections. Each correction includes the extracted value, corrected value, feedback text, and status (pending or addressed). Use this to understand which fields need improvement and review user-submitted corrections.",
+        params: z.object({ formId: z.string().min(1) }),
+        response: {
+          200: formCorrectionsGroupedResponseSchema,
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ params: { formId }, member }, reply) =>
+        getFormCorrectionsHandler({ formId }, member, reply),
+    })
+    .route({
+      method: "POST",
+      url: "/:formId/feedback/hints",
+      schema: {
+        tags: ["Forms"],
+        description:
+          "Generate improved extraction hints based on user corrections and feedback. Analyzes all corrections for a specific field and suggests an improved hint to enhance future extraction accuracy. Returns the current hint, suggested improved hint, and analysis of the changes. Note: This endpoint currently returns a placeholder response and will be enhanced with AI-powered hint generation.",
+        params: z.object({ formId: z.string().min(1) }),
+        body: generateHintsRequestSchema,
+        response: {
+          200: generateHintsResponseSchema,
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ params: { formId }, body, member }, reply) =>
+        generateHintsHandler({ formId, ...body }, member, reply),
+    })
+    .route({
+      method: "PATCH",
+      url: "/:formId/fields/:fieldId/hint",
+      schema: {
+        tags: ["Forms"],
+        description:
+          "Update a form field's extraction hint. This endpoint allows you to apply improved hints (e.g., those generated from the feedback/hints endpoint) to enhance extraction accuracy for future submissions. The hint guides the AI extraction model on what to look for and how to interpret the data. Returns success status on completion.",
+        params: z.object({ formId: z.string().min(1), fieldId: z.string().min(1) }),
+        body: updateFieldHintSchema,
+        response: {
+          200: z.object({ success: z.boolean() }),
+          400: z.object({ description: z.string() }),
+          404: z.object({ description: z.string() }),
+          500: z.object({ description: z.string() }),
+        },
+      },
+      handler: async ({ params: { formId, fieldId }, body, member }, reply) =>
+        updateFormFieldHintHandler({ formId, formFieldId: fieldId, ...body }, member, reply),
+    });
+}

package/apps/api/src/routes/v2/forms/schemas.ts

@@ -0,0 +1,243 @@
+import * as z from "zod/v4";
+
+export const jsonSchema = z.json();
+export type Json = z.infer<typeof jsonSchema>;
+
+// Form schemas
+export const createFormSchema = z.object({
+  workflowId: z.string(),
+  name: z.string().min(1, "Form name is required"),
+  hint: z.string().optional().default(""),
+});
+export type CreateFormRequest = z.infer<typeof createFormSchema>;
+
+export const updateFormSchema = z.object({
+  name: z.string().min(1).optional(),
+  hint: z.string().optional(),
+});
+export type UpdateFormRequest = z.infer<typeof updateFormSchema>;
+
+export const formResponseSchema = z.object({
+  id: z.string(),
+  workflowId: z.string(),
+  organizationId: z.string(),
+  conversationId: z.string(),
+  name: z.string(),
+  hint: z.string(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+  deletedAt: z.date().nullable(),
+});
+export type FormResponse = z.infer<typeof formResponseSchema>;
+
+export const formsListResponseSchema = z.array(
+  z.object({
+    id: z.string(),
+    workflowId: z.string(),
+    organizationId: z.string(),
+    conversationId: z.string(),
+    name: z.string(),
+    hint: z.string(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+  }),
+);
+export type FormsListResponse = z.infer<typeof formsListResponseSchema>;
+
+export const patchFormFieldSchema = z
+  .object({
+    name: z.string().min(1, "Field name is required").optional(),
+    hint: z.string().optional(),
+    type: z
+      .enum(["string", "string-long", "number", "boolean", "date", "email", "money", "url", "enum"])
+      .optional(),
+    options: z.array(z.string()).nullable().optional(),
+    order: z.number().int().min(0).optional(),
+  })
+  .refine((v) => Object.keys(v).length > 0, {
+    message: "At least one field must be supplied",
+  });
+export type PatchFormFieldRequest = z.infer<typeof patchFormFieldSchema>;
+
+// JSON-based form creation schema
+export const createFormFromJsonSchema = z.object({
+  workflowId: z.string(),
+  name: z.string().min(1, "Form name is required"),
+  hint: z.string().optional().default(""),
+  groups: z
+    .array(
+      z.object({
+        name: z.string().min(1, "Group name is required"),
+        multi: z.boolean().optional().default(false),
+        hint: z.string().optional().default(""),
+        fields: z
+          .array(
+            z.object({
+              name: z.string().min(1, "Field name is required"),
+              type: z
+                .enum([
+                  "string",
+                  "string-long",
+                  "number",
+                  "boolean",
+                  "date",
+                  "email",
+                  "money",
+                  "url",
+                  "enum",
+                ])
+                .optional()
+                .default("string"),
+              hint: z.string().optional().default(""),
+              options: z.array(z.string()).nullable().optional(),
+            }),
+          )
+          .min(1, "Each group must have at least one field"),
+      }),
+    )
+    .min(1, "Form must have at least one group"),
+});
+export type CreateFormFromJsonRequest = z.infer<typeof createFormFromJsonSchema>;
+
+// Form group schemas
+export const createFormGroupSchema = z.object({
+  name: z.string().min(1, "Group name is required"),
+  multi: z.boolean().optional().default(false),
+  hint: z.string().optional().default(""),
+  order: z.number().int().min(0).optional(),
+});
+export type CreateFormGroupRequest = z.infer<typeof createFormGroupSchema>;
+
+export const updateFormGroupSchema = z
+  .object({
+    name: z.string().min(1, "Group name is required").optional(),
+    multi: z.boolean().optional(),
+    hint: z.string().optional(),
+    order: z.number().int().min(0).optional(),
+  })
+  .refine((v) => Object.keys(v).length > 0, {
+    message: "At least one field must be supplied",
+  });
+export type UpdateFormGroupRequest = z.infer<typeof updateFormGroupSchema>;
+
+export const formGroupResponseSchema = z.object({
+  id: z.string(),
+  formId: z.string(),
+  name: z.string(),
+  multi: z.boolean(),
+  type: z.enum(["custom", "bank_statement"]),
+  order: z.number(),
+  hint: z.string(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});
+export type FormGroupResponse = z.infer<typeof formGroupResponseSchema>;
+
+// Form field schemas
+export const createFormFieldSchema = z.object({
+  name: z.string().min(1, "Field name is required"),
+  type: z
+    .enum(["string", "string-long", "number", "boolean", "date", "email", "money", "url", "enum"])
+    .optional()
+    .default("string"),
+  hint: z.string().optional().default(""),
+  options: z.array(z.string()).nullable().optional(),
+  order: z.number().int().min(0).optional(),
+});
+export type CreateFormFieldRequest = z.infer<typeof createFormFieldSchema>;
+
+export const formFieldResponseSchema = z.object({
+  id: z.string(),
+  formGroupId: z.string(),
+  name: z.string(),
+  type: z.enum([
+    "string",
+    "string-long",
+    "number",
+    "boolean",
+    "date",
+    "email",
+    "money",
+    "url",
+    "enum",
+  ]),
+  hint: z.string(),
+  options: z.array(z.string()).nullable(),
+  order: z.number(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});
+export type FormFieldResponse = z.infer<typeof formFieldResponseSchema>;
+
+// Form derived field schemas
+export const createFormDerivedSchema = z.object({
+  name: z.string().min(1, "Derived field name is required"),
+  prompt: z.string().optional().default(""),
+});
+export type CreateFormDerivedRequest = z.infer<typeof createFormDerivedSchema>;
+
+export const updateFormDerivedSchema = z
+  .object({
+    name: z.string().min(1, "Derived field name is required").optional(),
+    prompt: z.string().optional(),
+  })
+  .refine((v) => Object.keys(v).length > 0, {
+    message: "At least one field must be supplied",
+  });
+export type UpdateFormDerivedRequest = z.infer<typeof updateFormDerivedSchema>;
+
+export const formDerivedResponseSchema = z.object({
+  id: z.string(),
+  formGroupId: z.string(),
+  name: z.string(),
+  prompt: z.string(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});
+export type FormDerivedResponse = z.infer<typeof formDerivedResponseSchema>;
+
+// ***********************
+// FEEDBACK / CORRECTIONS
+// ***********************
+export const formCorrectionsGroupedResponseSchema = z.record(
+  z.string(),
+  z.array(
+    z.object({
+      id: z.string(),
+      submissionItemId: z.string(),
+      extractedValue: z.union([z.string(), z.number()]).nullable(),
+      correctedValue: z.union([z.string(), z.number()]).nullable(),
+      feedback: z.string().nullable(),
+      status: z.enum(["pending", "addressed"]),
+      createdAt: z.date(),
+      updatedAt: z.date(),
+      submissionItem: z.object({
+        formFieldId: z.string(),
+        formField: z.object({
+          id: z.string(),
+          name: z.string(),
+          hint: z.string(),
+        }),
+      }),
+    }),
+  ),
+);
+export type FormCorrectionsGroupedResponse = z.infer<typeof formCorrectionsGroupedResponseSchema>;
+
+export const generateHintsRequestSchema = z.object({
+  formFieldId: z.string().min(1),
+});
+export type GenerateHintsRequest = z.infer<typeof generateHintsRequestSchema>;
+
+export const generateHintsResponseSchema = z.object({
+  fieldName: z.string(),
+  currentHint: z.string(),
+  improvedHint: z.string(),
+  analysis: z.string(),
+});
+export type GenerateHintsResponse = z.infer<typeof generateHintsResponseSchema>;
+
+export const updateFieldHintSchema = z.object({
+  hint: z.string(),
+});
+export type UpdateFieldHintRequest = z.infer<typeof updateFieldHintSchema>;

package/apps/api/src/routes/v2/index.ts

@@ -0,0 +1,19 @@
+import { type FastifyInstance } from "fastify";
+import { type ZodTypeProvider } from "fastify-type-provider-zod";
+import { v2ChatRouter } from "./chat";
+import { v2DealsRouter } from "./deals";
+import { v2FormsRouter } from "./forms";
+import { v2PipelinesRouter } from "./pipelines";
+import { v2SubmissionsRouter } from "./submissions";
+import { v2WorkflowsRouter } from "./workflows";
+
+export async function v2Router(app: FastifyInstance) {
+  app
+    .withTypeProvider<ZodTypeProvider>()
+    .register(v2ChatRouter, { prefix: "/chat" })
+    .register(v2DealsRouter, { prefix: "/deals" })
+    .register(v2FormsRouter, { prefix: "/forms" })
+    .register(v2PipelinesRouter, { prefix: "/pipelines" })
+    .register(v2SubmissionsRouter, { prefix: "/submissions" })
+    .register(v2WorkflowsRouter, { prefix: "/workflows" });
+}