One definition.Thirteen platforms.

1const { POST } = createEndpoint({
2  scopedTranslation,
3  method: Methods.POST,
4  path: ["explain", "to-my-boss"],
5  title: "post.title" as const,
6  description: "post.description" as const,
7  icon: "sparkles",
8  category: "endpointCategories.ai",
9  allowedRoles: [UserRole.CUSTOMER, UserRole.ADMIN] as const,
10  fields: customWidgetObject({
11    render: ExplainContainer,
12    usage: { request: "data", response: true } as const,
13    children: {
14      decision: requestField(scopedTranslation, {
15        type: WidgetType.FORM_FIELD,
16        fieldType: FieldDataType.TEXTAREA,
17        label: "post.decision.label" as const,
18        columns: 12,
19        schema: z.string().min(10),
20      }),
21      justification: responseField(scopedTranslation, {
22        type: WidgetType.TEXT,
23        content: "post.justification.content" as const,
24        schema: z.string(),
25      }),
26    },
27  }),
28  errorTypes: {
29    [EndpointErrorTypes.UNAUTHORIZED]:      { title: "post.errors.unauthorized.title" as const,      description: "post.errors.unauthorized.description" as const },
30    [EndpointErrorTypes.SERVER_ERROR]:      { title: "post.errors.serverError.title" as const,       description: "post.errors.serverError.description" as const },
31    // ... other error types
32  },
33  successTypes: { title: "post.success.title" as const, description: "post.success.description" as const },
34  examples: { requests: { default: { decision: "Rewrite everything in TypeScript" } }, responses: { default: { justification: "..." } } },
35});
36
37export type ExplainResponseOutput = typeof POST.types.ResponseOutput;
38const definitions = { POST } as const;
39export default definitions;

1import "server-only";
2
3export class ExplainRepository {
4  static async explainToMyBoss(
5    data: ExplainRequestOutput,
6    user: JwtPayloadType,
7    logger: EndpointLogger,
8    t: ExplainT,
9  ): Promise<ResponseType<ExplainResponseOutput>> {
10    if (!user.id) {
11      return fail({ message: t("post.errors.unauthorized.title"), errorType: ErrorResponseTypes.UNAUTHORIZED });
12    }
13    try {
14      const [saved] = await db
15        .insert(explainResults)
16        .values({ userId: user.id, decision: data.decision })
17        .returning();
18      logger.info("Saved decision", { userId: user.id, id: saved.id });
19      return success({ justification: saved.justification ?? "" });
20    } catch (error) {
21      logger.error("Failed to save decision", parseError(error));
22      return fail({ message: t("post.errors.serverError.title"), errorType: ErrorResponseTypes.INTERNAL_ERROR });
23    }
24  }
25}

1"use client";
2
3interface CustomWidgetProps {
4  field: {
5    value: ExplainResponseOutput | null | undefined;
6  } & (typeof definition.POST)["fields"];
7}
8
9export function ExplainContainer({ field }: CustomWidgetProps): JSX.Element {
10  const children = field.children;
11  const emptyField = useMemo(() => ({}), []);
12
13  return (
14    <Div className="flex flex-col gap-4 p-4">
15      <TextareaFieldWidget fieldName="decision" field={children.decision} />
16      <SubmitButtonWidget<typeof definition.POST>
17        field={{
18          text: "Explain to my boss",
19          loadingText: "Explaining...",
20          icon: "sparkles",
21          variant: "primary",
22        }}
23      />
24      <FormAlertWidget field={emptyField} />
25      <AlertWidget
26        fieldName="justification"
27        field={withValue(children.justification, field.value?.justification, null)}
28      />
29    </Div>
30  );
31}