@ciridae/ui 0.17.0 → 1.0.1

package/dist/feedback/generated/zod.gen.js

@@ -0,0 +1,293 @@
+// This file is auto-generated by @hey-api/openapi-ts
+import * as z from 'zod';
+/**
+ * Body_create_feedback_v1_projects__project_id__environments__environment__feedback__post
+ */
+export const zBodyCreateFeedbackV1ProjectsProjectIdEnvironmentsEnvironmentFeedbackPost = z.object({
+    feedback: z.string().nullish(),
+    files: z.array(z.string()).max(4).nullish()
+});
+/**
+ * FeedbackCreateRequest
+ *
+ * Reporter-authored fields for a new feedback item.
+ */
+export const zFeedbackCreateRequest = z.object({
+    subject: z.string().min(1).max(120),
+    description: z.string().min(1).max(10000),
+    type: z.enum([
+        'bug',
+        'feature',
+        'general'
+    ]),
+    urgency: z.enum(['normal', 'emergency']).optional().default('normal'),
+    affectedScope: z.enum([
+        'everyone',
+        'just_me',
+        'my_team',
+        'unknown'
+    ]).optional().default('unknown')
+}).strict();
+/**
+ * FeedbackUpdateRequest
+ *
+ * Editable reporter fields while feedback awaits triage.
+ */
+export const zFeedbackUpdateRequest = z.object({
+    subject: z.string().min(1).max(120).nullish(),
+    description: z.string().min(1).max(10000).nullish()
+}).strict();
+/**
+ * FeedbackMessageCreateRequest
+ *
+ * Body of a reporter reply.
+ */
+export const zFeedbackMessageCreateRequest = z.object({
+    body: z.string().min(1).max(10000)
+}).strict();
+/**
+ * HTTPErrorResponse
+ *
+ * FastAPI-compatible error envelope with caller-safe detail.
+ */
+export const zHttpErrorResponse = z.object({
+    detail: z.string()
+});
+/**
+ * FeedbackStatusEvent
+ *
+ * One status transition with its epoch-millisecond time.
+ */
+export const zFeedbackStatusEvent = z.object({
+    id: z.string(),
+    status: z.enum([
+        'received',
+        'in_progress',
+        'discussion_required',
+        'completed',
+        'no_action',
+        'withdrawn'
+    ]),
+    createdAt: z.iso.datetime(),
+    createdAt_epoch_milliseconds: z.int().min(-9223372036854775808, { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(9223372036854775807, { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' })
+});
+/**
+ * FeedbackAttachment
+ *
+ * A file attached to one feedback item.
+ */
+export const zFeedbackAttachment = z.object({
+    id: z.string(),
+    name: z.string().min(1).max(255).regex(/^[^\/\\\x00-\x1f\x7f]+$/),
+    size: z.int().gte(1).lte(10485760),
+    url: z.url().min(1).max(2083).nullish()
+});
+/**
+ * FeedbackErrorDetail
+ *
+ * Stable machine and human classification of an expected failure.
+ */
+export const zFeedbackErrorDetail = z.object({
+    code: z.enum([
+        'feedback_access_denied',
+        'feedback_auth_unavailable',
+        'feedback_invalid_token',
+        'feedback_not_editable',
+        'feedback_not_found',
+        'feedback_not_replyable',
+        'feedback_scope_not_found',
+        'feedback_unavailable'
+    ]),
+    detail: z.string()
+});
+/**
+ * FeedbackErrorResponse
+ *
+ * FastAPI error envelope returned by the reporter API.
+ */
+export const zFeedbackErrorResponse = z.object({
+    detail: zFeedbackErrorDetail
+});
+/**
+ * ValidationError
+ */
+export const zValidationError = z.object({
+    loc: z.array(z.union([z.string(), z.int()])),
+    msg: z.string(),
+    type: z.string(),
+    input: z.unknown().optional(),
+    ctx: z.record(z.string(), z.unknown()).optional()
+});
+/**
+ * HTTPValidationError
+ */
+export const zHttpValidationError = z.object({
+    detail: z.array(zValidationError).optional()
+});
+/**
+ * FeedbackSummary
+ *
+ * One reporter-visible summary with epoch-millisecond times.
+ */
+export const zFeedbackSummary = z.object({
+    id: z.uuid(),
+    subject: z.string(),
+    description: z.string(),
+    type: z.enum([
+        'bug',
+        'feature',
+        'general'
+    ]),
+    urgency: z.enum(['normal', 'emergency']),
+    affectedScope: z.enum([
+        'everyone',
+        'just_me',
+        'my_team',
+        'unknown'
+    ]),
+    status: z.enum([
+        'received',
+        'in_progress',
+        'discussion_required',
+        'completed',
+        'no_action',
+        'withdrawn'
+    ]),
+    createdAt: z.iso.datetime(),
+    updatedAt: z.iso.datetime(),
+    canEdit: z.boolean(),
+    canWithdraw: z.boolean(),
+    canReply: z.boolean(),
+    createdAt_epoch_milliseconds: z.int().min(-9223372036854775808, { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(9223372036854775807, { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }),
+    updatedAt_epoch_milliseconds: z.int().min(-9223372036854775808, { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(9223372036854775807, { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' })
+});
+/**
+ * FeedbackListResponse
+ *
+ * The authenticated reporter's feedback items.
+ */
+export const zFeedbackListResponse = z.object({
+    items: z.array(zFeedbackSummary)
+});
+/**
+ * FeedbackMessageAuthor
+ *
+ * Provider-neutral author projection.
+ */
+export const zFeedbackMessageAuthor = z.object({
+    role: z.enum(['reporter', 'operator']),
+    name: z.string()
+});
+/**
+ * FeedbackMessage
+ *
+ * One public conversation message with epoch-millisecond times.
+ */
+export const zFeedbackMessage = z.object({
+    id: z.string(),
+    author: zFeedbackMessageAuthor,
+    body: z.string(),
+    createdAt: z.iso.datetime(),
+    editedAt: z.iso.datetime().nullable(),
+    createdAt_epoch_milliseconds: z.int().min(-9223372036854775808, { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(9223372036854775807, { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }),
+    editedAt_epoch_milliseconds: z.int().min(-9223372036854775808, { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(9223372036854775807, { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }).nullable()
+});
+/**
+ * FeedbackItem
+ *
+ * Reporter detail with its status history and public conversation.
+ */
+export const zFeedbackItem = z.object({
+    id: z.uuid(),
+    subject: z.string(),
+    description: z.string(),
+    type: z.enum([
+        'bug',
+        'feature',
+        'general'
+    ]),
+    urgency: z.enum(['normal', 'emergency']),
+    affectedScope: z.enum([
+        'everyone',
+        'just_me',
+        'my_team',
+        'unknown'
+    ]),
+    status: z.enum([
+        'received',
+        'in_progress',
+        'discussion_required',
+        'completed',
+        'no_action',
+        'withdrawn'
+    ]),
+    createdAt: z.iso.datetime(),
+    updatedAt: z.iso.datetime(),
+    canEdit: z.boolean(),
+    canWithdraw: z.boolean(),
+    canReply: z.boolean(),
+    createdAt_epoch_milliseconds: z.int().min(-9223372036854775808, { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(9223372036854775807, { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }),
+    updatedAt_epoch_milliseconds: z.int().min(-9223372036854775808, { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(9223372036854775807, { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }),
+    statusTimeline: z.array(zFeedbackStatusEvent),
+    messages: z.array(zFeedbackMessage),
+    attachments: z.array(zFeedbackAttachment).optional().default([])
+});
+export const zListFeedbackV1ProjectsProjectIdEnvironmentsEnvironmentFeedbackGetPath = z.object({
+    project_id: z.string().min(1).max(64),
+    environment: z.string()
+});
+/**
+ * Successful Response
+ */
+export const zListFeedbackV1ProjectsProjectIdEnvironmentsEnvironmentFeedbackGetResponse = zFeedbackListResponse;
+export const zCreateFeedbackV1ProjectsProjectIdEnvironmentsEnvironmentFeedbackPostBody = zFeedbackCreateRequest;
+export const zCreateFeedbackV1ProjectsProjectIdEnvironmentsEnvironmentFeedbackPostHeaders = z.object({
+    'Idempotency-Key': z.uuid(),
+    'X-POSTHOG-SESSION-ID': z.string().nullish()
+});
+export const zCreateFeedbackV1ProjectsProjectIdEnvironmentsEnvironmentFeedbackPostPath = z.object({
+    project_id: z.string().min(1).max(64),
+    environment: z.string()
+});
+/**
+ * Successful Response
+ */
+export const zCreateFeedbackV1ProjectsProjectIdEnvironmentsEnvironmentFeedbackPostResponse = zFeedbackItem;
+export const zGetFeedbackV1ProjectsProjectIdEnvironmentsEnvironmentFeedbackFeedbackIdGetPath = z.object({
+    feedback_id: z.uuid(),
+    project_id: z.string().min(1).max(64),
+    environment: z.string()
+});
+/**
+ * Successful Response
+ */
+export const zGetFeedbackV1ProjectsProjectIdEnvironmentsEnvironmentFeedbackFeedbackIdGetResponse = zFeedbackItem;
+export const zUpdateFeedbackV1ProjectsProjectIdEnvironmentsEnvironmentFeedbackFeedbackIdPatchBody = zFeedbackUpdateRequest;
+export const zUpdateFeedbackV1ProjectsProjectIdEnvironmentsEnvironmentFeedbackFeedbackIdPatchPath = z.object({
+    feedback_id: z.uuid(),
+    project_id: z.string().min(1).max(64),
+    environment: z.string()
+});
+/**
+ * Successful Response
+ */
+export const zUpdateFeedbackV1ProjectsProjectIdEnvironmentsEnvironmentFeedbackFeedbackIdPatchResponse = zFeedbackItem;
+export const zWithdrawFeedbackV1ProjectsProjectIdEnvironmentsEnvironmentFeedbackFeedbackIdWithdrawPostPath = z.object({
+    feedback_id: z.uuid(),
+    project_id: z.string().min(1).max(64),
+    environment: z.string()
+});
+/**
+ * Successful Response
+ */
+export const zWithdrawFeedbackV1ProjectsProjectIdEnvironmentsEnvironmentFeedbackFeedbackIdWithdrawPostResponse = zFeedbackItem;
+export const zCreateFeedbackMessageV1ProjectsProjectIdEnvironmentsEnvironmentFeedbackFeedbackIdMessagesPostBody = zFeedbackMessageCreateRequest;
+export const zCreateFeedbackMessageV1ProjectsProjectIdEnvironmentsEnvironmentFeedbackFeedbackIdMessagesPostPath = z.object({
+    feedback_id: z.uuid(),
+    project_id: z.string().min(1).max(64),
+    environment: z.string()
+});
+/**
+ * Successful Response
+ */
+export const zCreateFeedbackMessageV1ProjectsProjectIdEnvironmentsEnvironmentFeedbackFeedbackIdMessagesPostResponse = zFeedbackMessage;

package/dist/feedback/get-response-error-id.d.ts

@@ -0,0 +1 @@
+export declare function getResponseErrorId(response: Response): string | null;

package/dist/feedback/get-response-error-id.js

@@ -0,0 +1,7 @@
+export function getResponseErrorId(response) {
+    const serverTraceId = response.headers.get("X-Trace-ID");
+    if (serverTraceId)
+        return serverTraceId;
+    return (/^([0-9a-f]{32})(?:\/|$)/i.exec(response.headers.get("X-Cloud-Trace-Context") ?? "")?.[1] ??
+        null);
+}

package/dist/feedback/operator-client.d.ts

@@ -0,0 +1,21 @@
+import { type FeedbackMessage } from "./contract.js";
+import { type FeedbackTriageStatus, type OperatorFeedbackItem, type OperatorFeedbackSummary } from "./operator-contract.js";
+type FeedbackOperatorClientConfig = {
+    baseUrl: string;
+    getBearerToken: () => Promise<string>;
+};
+type FeedbackOperatorReadOptions = {
+    signal?: AbortSignal;
+};
+declare class FeedbackOperatorClient {
+    #private;
+    readonly baseUrl: string;
+    constructor(config: FeedbackOperatorClientConfig);
+    list(options?: FeedbackOperatorReadOptions): Promise<OperatorFeedbackSummary[]>;
+    get(feedbackId: string, options?: FeedbackOperatorReadOptions): Promise<OperatorFeedbackItem>;
+    getAttachmentUrl(feedbackId: string, attachmentId: string): Promise<string>;
+    updateStatus(feedbackId: string, status: FeedbackTriageStatus): Promise<OperatorFeedbackItem>;
+    createMessage(feedbackId: string, body: string): Promise<FeedbackMessage>;
+}
+declare function createFeedbackOperatorClient(config: FeedbackOperatorClientConfig): FeedbackOperatorClient;
+export { createFeedbackOperatorClient, FeedbackOperatorClient, type FeedbackOperatorClientConfig };

package/dist/feedback/operator-client.js

@@ -0,0 +1,96 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _FeedbackOperatorClient_instances, _FeedbackOperatorClient_basePath, _FeedbackOperatorClient_getBearerToken, _FeedbackOperatorClient_request;
+import { FeedbackApiError } from "./client.js";
+import { feedbackErrorResponseSchema, feedbackMessageSchema, } from "./contract.js";
+import { getResponseErrorId } from "./get-response-error-id.js";
+import { operatorFeedbackItemSchema, operatorFeedbackListResponseSchema, } from "./operator-contract.js";
+import { requireConfig } from "./require-config.js";
+class FeedbackOperatorClient {
+    constructor(config) {
+        _FeedbackOperatorClient_instances.add(this);
+        _FeedbackOperatorClient_basePath.set(this, void 0);
+        _FeedbackOperatorClient_getBearerToken.set(this, void 0);
+        this.baseUrl = requireConfig(config.baseUrl, "baseUrl").replace(/\/$/, "");
+        __classPrivateFieldSet(this, _FeedbackOperatorClient_basePath, `${this.baseUrl}/feedback/admin`, "f");
+        __classPrivateFieldSet(this, _FeedbackOperatorClient_getBearerToken, config.getBearerToken, "f");
+    }
+    async list(options) {
+        const response = await __classPrivateFieldGet(this, _FeedbackOperatorClient_instances, "m", _FeedbackOperatorClient_request).call(this, "", operatorFeedbackListResponseSchema, options);
+        return response.items;
+    }
+    async get(feedbackId, options) {
+        return __classPrivateFieldGet(this, _FeedbackOperatorClient_instances, "m", _FeedbackOperatorClient_request).call(this, `/${encodeURIComponent(feedbackId)}`, operatorFeedbackItemSchema, options);
+    }
+    async getAttachmentUrl(feedbackId, attachmentId) {
+        const item = await this.get(feedbackId);
+        const url = item.attachments?.find((file) => file.id === attachmentId)?.url;
+        if (!url)
+            throw new Error("File download is unavailable.");
+        return url;
+    }
+    async updateStatus(feedbackId, status) {
+        return __classPrivateFieldGet(this, _FeedbackOperatorClient_instances, "m", _FeedbackOperatorClient_request).call(this, `/${encodeURIComponent(feedbackId)}`, operatorFeedbackItemSchema, {
+            body: { status },
+            method: "PATCH",
+        });
+    }
+    async createMessage(feedbackId, body) {
+        return __classPrivateFieldGet(this, _FeedbackOperatorClient_instances, "m", _FeedbackOperatorClient_request).call(this, `/${encodeURIComponent(feedbackId)}/messages`, feedbackMessageSchema, {
+            body: { body },
+            method: "POST",
+        });
+    }
+}
+_FeedbackOperatorClient_basePath = new WeakMap(), _FeedbackOperatorClient_getBearerToken = new WeakMap(), _FeedbackOperatorClient_instances = new WeakSet(), _FeedbackOperatorClient_request = async function _FeedbackOperatorClient_request(path, schema, options) {
+    const bearer = await __classPrivateFieldGet(this, _FeedbackOperatorClient_getBearerToken, "f").call(this);
+    const response = await fetch(`${__classPrivateFieldGet(this, _FeedbackOperatorClient_basePath, "f")}${path}`, {
+        body: options?.body ? JSON.stringify(options.body) : undefined,
+        headers: {
+            Authorization: `Bearer ${bearer}`,
+            ...(options?.body ? { "Content-Type": "application/json" } : {}),
+        },
+        method: options?.method ?? "GET",
+        signal: options?.signal,
+    });
+    const payload = await response.json().catch(() => undefined);
+    if (!response.ok)
+        throw parseFeedbackOperatorApiError(response, payload);
+    const parsed = schema.safeParse(payload);
+    if (!parsed.success) {
+        throw new FeedbackApiError("Feedback returned an invalid response.", {
+            code: "feedback_invalid_response",
+            status: response.status,
+            errorId: getResponseErrorId(response),
+        });
+    }
+    return parsed.data;
+};
+function createFeedbackOperatorClient(config) {
+    return new FeedbackOperatorClient(config);
+}
+function parseFeedbackOperatorApiError(response, payload) {
+    const parsed = feedbackErrorResponseSchema.safeParse(payload);
+    if (parsed.success) {
+        return new FeedbackApiError(parsed.data.detail.detail, {
+            code: parsed.data.detail.code,
+            status: response.status,
+            errorId: getResponseErrorId(response),
+        });
+    }
+    return new FeedbackApiError("Feedback request failed.", {
+        code: "feedback_request_failed",
+        status: response.status,
+        errorId: getResponseErrorId(response),
+    });
+}
+export { createFeedbackOperatorClient, FeedbackOperatorClient };

package/dist/feedback/operator-contract.d.ts

@@ -0,0 +1,111 @@
+import { z } from "zod";
+declare const feedbackTriageStatusSchema: z.ZodEnum<{
+    in_progress: "in_progress";
+    completed: "completed";
+    received: "received";
+    discussion_required: "discussion_required";
+    no_action: "no_action";
+}>;
+declare const operatorFeedbackSummarySchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        in_progress: "in_progress";
+        completed: "completed";
+        received: "received";
+        discussion_required: "discussion_required";
+        no_action: "no_action";
+        withdrawn: "withdrawn";
+    }>;
+    type: z.ZodEnum<{
+        general: "general";
+        bug: "bug";
+        feature: "feature";
+    }>;
+    description: z.ZodString;
+    id: z.ZodUUID;
+    createdAt: z.ZodISODateTime;
+    subject: z.ZodString;
+    urgency: z.ZodEnum<{
+        normal: "normal";
+        emergency: "emergency";
+    }>;
+    updatedAt: z.ZodISODateTime;
+    reporterEmail: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+declare const operatorFeedbackItemSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        in_progress: "in_progress";
+        completed: "completed";
+        received: "received";
+        discussion_required: "discussion_required";
+        no_action: "no_action";
+        withdrawn: "withdrawn";
+    }>;
+    type: z.ZodEnum<{
+        general: "general";
+        bug: "bug";
+        feature: "feature";
+    }>;
+    description: z.ZodString;
+    id: z.ZodUUID;
+    createdAt: z.ZodISODateTime;
+    subject: z.ZodString;
+    urgency: z.ZodEnum<{
+        normal: "normal";
+        emergency: "emergency";
+    }>;
+    updatedAt: z.ZodISODateTime;
+    reporterEmail: z.ZodNullable<z.ZodString>;
+    canReply: z.ZodBoolean;
+    attachments: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        size: z.ZodInt;
+        url: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
+    }, z.core.$strip>>>;
+    messages: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        author: z.ZodObject<{
+            role: z.ZodEnum<{
+                operator: "operator";
+                reporter: "reporter";
+            }>;
+            name: z.ZodString;
+        }, z.core.$strip>;
+        body: z.ZodString;
+        createdAt: z.ZodISODateTime;
+        editedAt: z.ZodNullable<z.ZodISODateTime>;
+        createdAt_epoch_milliseconds: z.ZodInt;
+        editedAt_epoch_milliseconds: z.ZodNullable<z.ZodInt>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const operatorFeedbackListResponseSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        status: z.ZodEnum<{
+            in_progress: "in_progress";
+            completed: "completed";
+            received: "received";
+            discussion_required: "discussion_required";
+            no_action: "no_action";
+            withdrawn: "withdrawn";
+        }>;
+        type: z.ZodEnum<{
+            general: "general";
+            bug: "bug";
+            feature: "feature";
+        }>;
+        description: z.ZodString;
+        id: z.ZodUUID;
+        createdAt: z.ZodISODateTime;
+        subject: z.ZodString;
+        urgency: z.ZodEnum<{
+            normal: "normal";
+            emergency: "emergency";
+        }>;
+        updatedAt: z.ZodISODateTime;
+        reporterEmail: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type FeedbackTriageStatus = z.infer<typeof feedbackTriageStatusSchema>;
+type OperatorFeedbackItem = z.infer<typeof operatorFeedbackItemSchema>;
+type OperatorFeedbackSummary = z.infer<typeof operatorFeedbackSummarySchema>;
+export { feedbackTriageStatusSchema, operatorFeedbackItemSchema, operatorFeedbackListResponseSchema, type FeedbackTriageStatus, type OperatorFeedbackItem, type OperatorFeedbackSummary, };

package/dist/feedback/operator-contract.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { feedbackAttachmentSchema, feedbackMessageSchema, feedbackStatusSchema, feedbackSummarySchema, } from "./contract.js";
+const feedbackTriageStatusSchema = feedbackStatusSchema.exclude(["withdrawn"]);
+const operatorFeedbackSummarySchema = feedbackSummarySchema
+    .omit({
+    affectedScope: true,
+    canEdit: true,
+    canReply: true,
+    canWithdraw: true,
+    createdAt_epoch_milliseconds: true,
+    updatedAt_epoch_milliseconds: true,
+})
+    .extend({ reporterEmail: z.string().nullable() });
+const operatorFeedbackItemSchema = operatorFeedbackSummarySchema.extend({
+    canReply: z.boolean(),
+    attachments: z.array(feedbackAttachmentSchema).default([]),
+    messages: z.array(feedbackMessageSchema),
+});
+const operatorFeedbackListResponseSchema = z.object({
+    items: z.array(operatorFeedbackSummarySchema),
+});
+export { feedbackTriageStatusSchema, operatorFeedbackItemSchema, operatorFeedbackListResponseSchema, };

package/dist/feedback/operator-controller.d.ts

@@ -0,0 +1,80 @@
+import { type FeedbackOperatorClientConfig } from "./operator-client.js";
+type FeedbackOperatorControllerConfig = FeedbackOperatorClientConfig & {
+    cacheScope: string;
+};
+declare function useFeedbackOperatorController(config: FeedbackOperatorControllerConfig, selectedFeedbackId: string | undefined): {
+    getAttachmentUrl: (feedbackId: string, attachmentId: string) => Promise<string>;
+    itemQuery: import("@tanstack/react-query/build/legacy").UseQueryResult<NoInfer<{
+        status: "in_progress" | "completed" | "received" | "discussion_required" | "no_action" | "withdrawn";
+        type: "general" | "bug" | "feature";
+        description: string;
+        id: string;
+        createdAt: string;
+        subject: string;
+        urgency: "normal" | "emergency";
+        updatedAt: string;
+        reporterEmail: string | null;
+        canReply: boolean;
+        attachments: {
+            id: string;
+            name: string;
+            size: number;
+            url?: string | null | undefined;
+        }[];
+        messages: {
+            id: string;
+            author: {
+                role: "operator" | "reporter";
+                name: string;
+            };
+            body: string;
+            createdAt: string;
+            editedAt: string | null;
+            createdAt_epoch_milliseconds: number;
+            editedAt_epoch_milliseconds: number | null;
+        }[];
+    }>, Error>;
+    itemsQuery: import("@tanstack/react-query/build/legacy").UseQueryResult<NoInfer<{
+        status: "in_progress" | "completed" | "received" | "discussion_required" | "no_action" | "withdrawn";
+        type: "general" | "bug" | "feature";
+        description: string;
+        id: string;
+        createdAt: string;
+        subject: string;
+        urgency: "normal" | "emergency";
+        updatedAt: string;
+        reporterEmail: string | null;
+    }[]>, Error>;
+    messageMutation: import("@tanstack/react-query/build/legacy").UseMutationResult<import("./contract.js").FeedbackMessage, Error, string, unknown>;
+    statusMutation: import("@tanstack/react-query/build/legacy").UseMutationResult<{
+        status: "in_progress" | "completed" | "received" | "discussion_required" | "no_action" | "withdrawn";
+        type: "general" | "bug" | "feature";
+        description: string;
+        id: string;
+        createdAt: string;
+        subject: string;
+        urgency: "normal" | "emergency";
+        updatedAt: string;
+        reporterEmail: string | null;
+        canReply: boolean;
+        attachments: {
+            id: string;
+            name: string;
+            size: number;
+            url?: string | null | undefined;
+        }[];
+        messages: {
+            id: string;
+            author: {
+                role: "operator" | "reporter";
+                name: string;
+            };
+            body: string;
+            createdAt: string;
+            editedAt: string | null;
+            createdAt_epoch_milliseconds: number;
+            editedAt_epoch_milliseconds: number | null;
+        }[];
+    }, Error, "in_progress" | "completed" | "received" | "discussion_required" | "no_action", unknown>;
+};
+export { type FeedbackOperatorControllerConfig, useFeedbackOperatorController };

package/dist/feedback/operator-controller.js

@@ -0,0 +1,43 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import * as React from "react";
+import { createFeedbackOperatorClient } from "./operator-client.js";
+import { requireConfig } from "./require-config.js";
+function useFeedbackOperatorController(config, selectedFeedbackId) {
+    const { baseUrl, cacheScope: configuredCacheScope, getBearerToken } = config;
+    const client = React.useMemo(() => createFeedbackOperatorClient({ baseUrl, getBearerToken }), [baseUrl, getBearerToken]);
+    const cacheScope = requireConfig(configuredCacheScope, "cacheScope");
+    const queryClient = useQueryClient();
+    const queryRoot = React.useMemo(() => ["feedback-operator", client.baseUrl, cacheScope], [cacheScope, client.baseUrl]);
+    const itemsQuery = useQuery({
+        queryKey: [...queryRoot, "items"],
+        queryFn: ({ signal }) => client.list({ signal }),
+        retry: false,
+    });
+    const itemQuery = useQuery({
+        queryKey: [...queryRoot, "item", selectedFeedbackId],
+        queryFn: ({ signal }) => client.get(requireSelectedFeedbackId(selectedFeedbackId), { signal }),
+        enabled: selectedFeedbackId !== undefined,
+        retry: false,
+    });
+    const statusMutation = useMutation({
+        mutationFn: (status) => client.updateStatus(requireSelectedFeedbackId(selectedFeedbackId), status),
+        onSuccess: async () => queryClient.invalidateQueries({ queryKey: queryRoot }),
+    });
+    const messageMutation = useMutation({
+        mutationFn: (body) => client.createMessage(requireSelectedFeedbackId(selectedFeedbackId), body),
+        onSuccess: async () => queryClient.invalidateQueries({ queryKey: queryRoot }),
+    });
+    return {
+        getAttachmentUrl: (feedbackId, attachmentId) => client.getAttachmentUrl(feedbackId, attachmentId),
+        itemQuery,
+        itemsQuery,
+        messageMutation,
+        statusMutation,
+    };
+}
+function requireSelectedFeedbackId(feedbackId) {
+    if (feedbackId === undefined)
+        throw new Error("Select feedback before changing it.");
+    return feedbackId;
+}
+export { useFeedbackOperatorController };