@claudian-collab/protocol 1.0.0

package/dist/CollabRequestTicketRequestCodecs.js

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeCollabRequestTicketOperationRequest = decodeCollabRequestTicketOperationRequest;
+const CollabConstants_1 = require("./CollabConstants");
+const CollabError_1 = require("./CollabError");
+const CollabValidation_1 = require("./CollabValidation");
+function invalid(reason) {
+    return {
+        error: new CollabError_1.CollabError({
+            code: 'protocol-payload-invalid',
+            safeContext: { reason },
+        }),
+        status: 'invalid',
+    };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function hasExactKeys(value, required, optional = []) {
+    const allowed = new Set([...required, ...optional]);
+    return required.every(key => Object.hasOwn(value, key))
+        && Object.keys(value).every(key => allowed.has(key));
+}
+function isRevision(value, minimum = 0) {
+    return typeof value === 'number'
+        && Number.isSafeInteger(value)
+        && value >= minimum;
+}
+function isPageQuery(value, maxLimit = CollabConstants_1.COLLAB_LIMITS.maxCommentPageSize) {
+    return (value.cursor === undefined
+        || (typeof value.cursor === 'string'
+            && value.cursor.length > 0
+            && value.cursor.length <= CollabConstants_1.COLLAB_LIMITS.maxPageCursorUtf16))
+        && (value.limit === undefined
+            || (isRevision(value.limit, 1) && value.limit <= maxLimit));
+}
+function mutationContext(value) {
+    return (0, CollabValidation_1.isCollabProjectId)(value.projectId) && (0, CollabValidation_1.isCollabOpaqueId)(value.idempotencyKey);
+}
+function resolvingTickets(value) {
+    if (!Array.isArray(value) || value.length > CollabConstants_1.COLLAB_LIMITS.maxRequestTicketRelations)
+        return null;
+    const seen = new Set();
+    const result = [];
+    for (const entry of value) {
+        if (!isRecord(entry)
+            || !(0, CollabValidation_1.isCollabOpaqueId)(entry.ticketId)
+            || seen.has(entry.ticketId)
+            || !isRevision(entry.revision, 1))
+            return null;
+        seen.add(entry.ticketId);
+        result.push({ ticketId: entry.ticketId, revision: entry.revision });
+    }
+    return result;
+}
+function decodeRequestTicketRequest(operation, input) {
+    if (!isRecord(input))
+        return null;
+    switch (operation) {
+        case 'getRequest':
+            return (0, CollabValidation_1.isCollabProjectId)(input.projectId) && (0, CollabValidation_1.isCollabOpaqueId)(input.requestId)
+                ? { projectId: input.projectId, requestId: input.requestId }
+                : null;
+        case 'ensureMyRequest':
+            return mutationContext(input)
+                && (0, CollabValidation_1.isCollabGitOid)(input.expectedMainOid)
+                && (0, CollabValidation_1.isCollabGitOid)(input.headOid)
+                && typeof input.description === 'string'
+                && (0, CollabValidation_1.hasUtf8ByteLengthAtMost)(input.description, CollabConstants_1.COLLAB_LIMITS.maxRequestDescriptionBytes)
+                ? {
+                    description: input.description,
+                    expectedMainOid: input.expectedMainOid,
+                    headOid: input.headOid,
+                    idempotencyKey: input.idempotencyKey,
+                    projectId: input.projectId,
+                }
+                : null;
+        case 'createComment':
+            return mutationContext(input)
+                && (0, CollabValidation_1.isCollabOpaqueId)(input.requestId)
+                && typeof input.body === 'string'
+                && (0, CollabValidation_1.hasUtf8ByteLengthAtMost)(input.body, CollabConstants_1.COLLAB_LIMITS.maxCommentBytes)
+                && input.anchor === undefined
+                ? {
+                    body: input.body,
+                    idempotencyKey: input.idempotencyKey,
+                    projectId: input.projectId,
+                    requestId: input.requestId,
+                }
+                : null;
+        case 'updateMyRequestMetadata':
+            return mutationContext(input)
+                && (0, CollabValidation_1.isCollabOpaqueId)(input.requestId)
+                && (0, CollabValidation_1.isCollabGitOid)(input.expectedHeadOid)
+                && isRevision(input.expectedRequestRevision)
+                && typeof input.description === 'string'
+                && (0, CollabValidation_1.hasUtf8ByteLengthAtMost)(input.description, CollabConstants_1.COLLAB_LIMITS.maxRequestDescriptionBytes)
+                ? {
+                    description: input.description,
+                    expectedHeadOid: input.expectedHeadOid,
+                    expectedRequestRevision: input.expectedRequestRevision,
+                    idempotencyKey: input.idempotencyKey,
+                    projectId: input.projectId,
+                    requestId: input.requestId,
+                }
+                : null;
+        case 'acceptRequest': {
+            const expectedResolvingTickets = resolvingTickets(input.expectedResolvingTickets);
+            return mutationContext(input)
+                && (0, CollabValidation_1.isCollabOpaqueId)(input.requestId)
+                && (0, CollabValidation_1.isCollabGitOid)(input.expectedMainOid)
+                && (0, CollabValidation_1.isCollabGitOid)(input.expectedHeadOid)
+                && isRevision(input.expectedRequestRevision)
+                && expectedResolvingTickets !== null
+                ? {
+                    expectedHeadOid: input.expectedHeadOid,
+                    expectedMainOid: input.expectedMainOid,
+                    expectedRequestRevision: input.expectedRequestRevision,
+                    expectedResolvingTickets,
+                    idempotencyKey: input.idempotencyKey,
+                    projectId: input.projectId,
+                    requestId: input.requestId,
+                }
+                : null;
+        }
+        case 'listTickets':
+            return hasExactKeys(input, ['projectId', 'status'], ['cursor', 'limit'])
+                && (0, CollabValidation_1.isCollabProjectId)(input.projectId)
+                && (input.status === 'open' || input.status === 'closed' || input.status === 'all')
+                && isPageQuery(input, CollabConstants_1.COLLAB_LIMITS.maxTicketPageSize)
+                ? {
+                    ...(input.cursor === undefined ? {} : { cursor: input.cursor }),
+                    ...(input.limit === undefined ? {} : { limit: input.limit }),
+                    projectId: input.projectId,
+                    status: input.status,
+                }
+                : null;
+        case 'listRequestComments':
+            return hasExactKeys(input, ['projectId', 'requestId'], ['cursor', 'limit'])
+                && (0, CollabValidation_1.isCollabProjectId)(input.projectId)
+                && (0, CollabValidation_1.isCollabOpaqueId)(input.requestId)
+                && isPageQuery(input)
+                ? {
+                    ...(input.cursor === undefined ? {} : { cursor: input.cursor }),
+                    ...(input.limit === undefined ? {} : { limit: input.limit }),
+                    projectId: input.projectId,
+                    requestId: input.requestId,
+                }
+                : null;
+        case 'listTicketComments':
+            return hasExactKeys(input, ['projectId', 'ticketId'], ['cursor', 'limit'])
+                && (0, CollabValidation_1.isCollabProjectId)(input.projectId)
+                && (0, CollabValidation_1.isCollabOpaqueId)(input.ticketId)
+                && isPageQuery(input)
+                ? {
+                    ...(input.cursor === undefined ? {} : { cursor: input.cursor }),
+                    ...(input.limit === undefined ? {} : { limit: input.limit }),
+                    projectId: input.projectId,
+                    ticketId: input.ticketId,
+                }
+                : null;
+        case 'listTicketAcceptedRelations':
+            return hasExactKeys(input, ['projectId', 'ticketId'], ['cursor', 'limit'])
+                && (0, CollabValidation_1.isCollabProjectId)(input.projectId)
+                && (0, CollabValidation_1.isCollabOpaqueId)(input.ticketId)
+                && isPageQuery(input, CollabConstants_1.COLLAB_LIMITS.maxRelationsPerPage)
+                ? {
+                    ...(input.cursor === undefined ? {} : { cursor: input.cursor }),
+                    ...(input.limit === undefined ? {} : { limit: input.limit }),
+                    projectId: input.projectId,
+                    ticketId: input.ticketId,
+                }
+                : null;
+        case 'getTicket':
+            return hasExactKeys(input, ['projectId', 'ticketId'])
+                && (0, CollabValidation_1.isCollabProjectId)(input.projectId)
+                && (0, CollabValidation_1.isCollabOpaqueId)(input.ticketId)
+                ? { projectId: input.projectId, ticketId: input.ticketId }
+                : null;
+        case 'createTicket':
+            return hasExactKeys(input, ['body', 'idempotencyKey', 'projectId', 'title'])
+                && mutationContext(input)
+                && typeof input.body === 'string'
+                && typeof input.title === 'string'
+                && (0, CollabValidation_1.hasUtf8ByteLengthAtMost)(input.body, CollabConstants_1.COLLAB_LIMITS.maxTicketBodyBytes)
+                && input.title.length <= CollabConstants_1.COLLAB_LIMITS.maxTicketTitleUtf16
+                ? {
+                    body: input.body,
+                    idempotencyKey: input.idempotencyKey,
+                    projectId: input.projectId,
+                    title: input.title,
+                }
+                : null;
+        case 'updateTicketContent':
+            return hasExactKeys(input, [
+                'body', 'expectedRevision', 'idempotencyKey', 'projectId', 'ticketId', 'title',
+            ])
+                && mutationContext(input)
+                && (0, CollabValidation_1.isCollabOpaqueId)(input.ticketId)
+                && isRevision(input.expectedRevision, 1)
+                && typeof input.body === 'string'
+                && typeof input.title === 'string'
+                && (0, CollabValidation_1.hasUtf8ByteLengthAtMost)(input.body, CollabConstants_1.COLLAB_LIMITS.maxTicketBodyBytes)
+                && input.title.length <= CollabConstants_1.COLLAB_LIMITS.maxTicketTitleUtf16
+                ? {
+                    body: input.body,
+                    expectedRevision: input.expectedRevision,
+                    idempotencyKey: input.idempotencyKey,
+                    projectId: input.projectId,
+                    ticketId: input.ticketId,
+                    title: input.title,
+                }
+                : null;
+        case 'createTicketComment':
+            return hasExactKeys(input, ['body', 'idempotencyKey', 'projectId', 'ticketId'])
+                && mutationContext(input)
+                && (0, CollabValidation_1.isCollabOpaqueId)(input.ticketId)
+                && typeof input.body === 'string'
+                && (0, CollabValidation_1.hasUtf8ByteLengthAtMost)(input.body, CollabConstants_1.COLLAB_LIMITS.maxTicketCommentBytes)
+                ? {
+                    body: input.body,
+                    idempotencyKey: input.idempotencyKey,
+                    projectId: input.projectId,
+                    ticketId: input.ticketId,
+                }
+                : null;
+        case 'closeTicket':
+        case 'reopenTicket':
+            return hasExactKeys(input, [
+                'expectedRevision', 'idempotencyKey', 'projectId', 'ticketId',
+            ])
+                && mutationContext(input)
+                && (0, CollabValidation_1.isCollabOpaqueId)(input.ticketId)
+                && isRevision(input.expectedRevision, 1)
+                ? {
+                    expectedRevision: input.expectedRevision,
+                    idempotencyKey: input.idempotencyKey,
+                    projectId: input.projectId,
+                    ticketId: input.ticketId,
+                }
+                : null;
+    }
+}
+const INVALID_REASONS = {
+    acceptRequest: 'request-accept-payload-invalid',
+    closeTicket: 'ticket-mutation-payload-invalid',
+    createComment: 'request-comment-payload-invalid',
+    createTicket: 'ticket-create-payload-invalid',
+    createTicketComment: 'ticket-comment-payload-invalid',
+    ensureMyRequest: 'request-ensure-payload-invalid',
+    getRequest: 'request-read-payload-invalid',
+    getTicket: 'ticket-read-payload-invalid',
+    listRequestComments: 'request-comment-page-query-invalid',
+    listTicketAcceptedRelations: 'ticket-relation-page-query-invalid',
+    listTicketComments: 'ticket-comment-page-query-invalid',
+    listTickets: 'ticket-list-query-invalid',
+    reopenTicket: 'ticket-mutation-payload-invalid',
+    updateMyRequestMetadata: 'request-metadata-payload-invalid',
+    updateTicketContent: 'ticket-content-payload-invalid',
+};
+function decodeCollabRequestTicketOperationRequest(operation, input) {
+    const value = decodeRequestTicketRequest(operation, input);
+    return value
+        ? { status: 'ok', value: value }
+        : invalid(INVALID_REASONS[operation]);
+}

package/dist/CollabRequestTicketResponseCodecs.d.ts

@@ -0,0 +1,15 @@
+import { type AcceptResponse, type CreateCommentResponse, type CreateTicketCommentResponse, type CreateTicketResponse, type EnsureMyRequestResponse, type TicketMutationResponse, type UpdateMyRequestMetadataResponse } from './CollabProtocol';
+import { type CollabCommentPage, type CollabRequestDetail, type CollabTicketAcceptedRelationPage, type CollabTicketCommentPage, type CollabTicketDetail, type CollabTicketPage } from './types';
+export declare function decodeEnsureMyRequestResponse(value: unknown): EnsureMyRequestResponse;
+export declare function decodeRequestDetailResponse(value: unknown): CollabRequestDetail;
+export declare function decodeCommentPageResponse(value: unknown): CollabCommentPage;
+export declare function decodeTicketCommentPageResponse(value: unknown): CollabTicketCommentPage;
+export declare function decodeTicketAcceptedRelationPageResponse(value: unknown): CollabTicketAcceptedRelationPage;
+export declare function decodeCreateCommentResponse(value: unknown): CreateCommentResponse;
+export declare function decodeAcceptResponse(value: unknown): AcceptResponse;
+export declare function decodeTicketPageResponse(value: unknown): CollabTicketPage;
+export declare function decodeTicketDetailResponse(value: unknown): CollabTicketDetail;
+export declare function decodeCreateTicketResponse(value: unknown): CreateTicketResponse;
+export declare function decodeTicketMutationResponse(value: unknown): TicketMutationResponse;
+export declare function decodeTicketCommentResponse(value: unknown): CreateTicketCommentResponse;
+export declare function decodeUpdateRequestMetadataResponse(value: unknown): UpdateMyRequestMetadataResponse;

package/dist/CollabRequestTicketResponseCodecs.js

@@ -0,0 +1,368 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeEnsureMyRequestResponse = decodeEnsureMyRequestResponse;
+exports.decodeRequestDetailResponse = decodeRequestDetailResponse;
+exports.decodeCommentPageResponse = decodeCommentPageResponse;
+exports.decodeTicketCommentPageResponse = decodeTicketCommentPageResponse;
+exports.decodeTicketAcceptedRelationPageResponse = decodeTicketAcceptedRelationPageResponse;
+exports.decodeCreateCommentResponse = decodeCreateCommentResponse;
+exports.decodeAcceptResponse = decodeAcceptResponse;
+exports.decodeTicketPageResponse = decodeTicketPageResponse;
+exports.decodeTicketDetailResponse = decodeTicketDetailResponse;
+exports.decodeCreateTicketResponse = decodeCreateTicketResponse;
+exports.decodeTicketMutationResponse = decodeTicketMutationResponse;
+exports.decodeTicketCommentResponse = decodeTicketCommentResponse;
+exports.decodeUpdateRequestMetadataResponse = decodeUpdateRequestMetadataResponse;
+const CollabConstants_1 = require("./CollabConstants");
+const CollabError_1 = require("./CollabError");
+const CollabValidation_1 = require("./CollabValidation");
+function decodeError(field) {
+    return new CollabError_1.CollabError({
+        code: 'protocol-payload-invalid',
+        recoveryActions: ['retry'],
+        safeContext: { field },
+    });
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function record(value, field) {
+    if (!isRecord(value))
+        throw decodeError(field);
+    return value;
+}
+function assertJsonUtf8ByteLengthAtMost(value, maximum, field) {
+    let serialized;
+    try {
+        serialized = JSON.stringify(value);
+    }
+    catch {
+        throw decodeError(field);
+    }
+    if (serialized === undefined
+        || !(0, CollabValidation_1.hasUtf8ByteLengthAtMost)(serialized, maximum)) {
+        throw decodeError(field);
+    }
+}
+function string(value, field, maxLength, validate, unit = 'utf16') {
+    const candidate = value[field];
+    if (typeof candidate !== 'string'
+        || candidate.length === 0
+        || (unit === 'utf8'
+            ? !(0, CollabValidation_1.hasUtf8ByteLengthAtMost)(candidate, maxLength)
+            : candidate.length > maxLength)
+        || (validate && !validate(candidate))) {
+        throw decodeError(field);
+    }
+    return candidate;
+}
+function text(value, field, maxLength, unit = 'utf16') {
+    const candidate = value[field];
+    if (typeof candidate !== 'string'
+        || (unit === 'utf8'
+            ? !(0, CollabValidation_1.hasUtf8ByteLengthAtMost)(candidate, maxLength)
+            : candidate.length > maxLength))
+        throw decodeError(field);
+    return candidate;
+}
+function timestamp(value, field) {
+    const candidate = string(value, field, 64);
+    if (Number.isNaN(Date.parse(candidate)) || new Date(candidate).toISOString() !== candidate) {
+        throw decodeError(field);
+    }
+    return candidate;
+}
+function optionalTimestamp(value, field) {
+    return value[field] === undefined ? undefined : timestamp(value, field);
+}
+function nonNegativeInteger(value, field) {
+    const candidate = value[field];
+    if (typeof candidate !== 'number'
+        || !Number.isSafeInteger(candidate)
+        || candidate < 0) {
+        throw decodeError(field);
+    }
+    return candidate;
+}
+function boundedNonNegativeInteger(value, field, maximum) {
+    const candidate = nonNegativeInteger(value, field);
+    if (candidate > maximum)
+        throw decodeError(field);
+    return candidate;
+}
+function positiveInteger(value, field) {
+    const candidate = nonNegativeInteger(value, field);
+    if (candidate < 1)
+        throw decodeError(field);
+    return candidate;
+}
+function requestTicketRelation(value) {
+    const source = record(value, 'request.ticketRelations');
+    const kind = source.kind;
+    const state = source.state;
+    if ((kind !== 'references' && kind !== 'resolves')
+        || (state !== 'pending' && state !== 'accepted')) {
+        throw decodeError('request.ticketRelations');
+    }
+    return {
+        commitOid: string(source, 'commitOid', 64, CollabValidation_1.isCollabGitOid),
+        id: string(source, 'id', 128, CollabValidation_1.isCollabOpaqueId),
+        kind,
+        state,
+        ticketId: string(source, 'ticketId', 128, CollabValidation_1.isCollabOpaqueId),
+        ticketNumber: positiveInteger(source, 'ticketNumber'),
+        ticketRevision: positiveInteger(source, 'ticketRevision'),
+        ticketTitle: string(source, 'ticketTitle', CollabConstants_1.COLLAB_LIMITS.maxTicketTitleUtf16),
+    };
+}
+function changeRequest(value) {
+    const source = record(value, 'request');
+    const status = source.status;
+    if ((status !== 'open' && status !== 'merged' && status !== 'discarded')
+        || !Array.isArray(source.ticketRelations)
+        || source.ticketRelations.length > CollabConstants_1.COLLAB_LIMITS.maxRequestTicketRelations) {
+        throw decodeError('request.status');
+    }
+    const mergedOid = source.mergedOid === undefined
+        ? undefined
+        : string(source, 'mergedOid', 64, CollabValidation_1.isCollabGitOid);
+    return {
+        commentCount: boundedNonNegativeInteger(source, 'commentCount', CollabConstants_1.COLLAB_LIMITS.maxRequestComments),
+        createdAt: timestamp(source, 'createdAt'),
+        description: text(source, 'description', CollabConstants_1.COLLAB_LIMITS.maxRequestDescriptionBytes, 'utf8'),
+        firstBaseOid: string(source, 'firstBaseOid', 64, CollabValidation_1.isCollabGitOid),
+        id: string(source, 'id', 128, CollabValidation_1.isCollabOpaqueId),
+        latestHeadOid: string(source, 'latestHeadOid', 64, CollabValidation_1.isCollabGitOid),
+        memberId: string(source, 'memberId', 64, CollabValidation_1.isCollabMemberId),
+        ...(mergedOid ? { mergedOid } : {}),
+        revision: nonNegativeInteger(source, 'revision'),
+        status,
+        ticketRelations: source.ticketRelations.map(requestTicketRelation),
+        updatedAt: timestamp(source, 'updatedAt'),
+    };
+}
+function ticketSummary(value) {
+    const source = record(value, 'ticket');
+    const status = source.status;
+    const closedAt = optionalTimestamp(source, 'closedAt');
+    const closedByMemberId = source.closedByMemberId === undefined
+        ? undefined
+        : string(source, 'closedByMemberId', 64, CollabValidation_1.isCollabMemberId);
+    if ((status !== 'open' && status !== 'closed')
+        || (status === 'open' && (closedAt !== undefined || closedByMemberId !== undefined))
+        || (status === 'closed' && (closedAt === undefined || closedByMemberId === undefined))) {
+        throw decodeError('ticket.status');
+    }
+    return {
+        acceptedRelationCount: boundedNonNegativeInteger(source, 'acceptedRelationCount', CollabConstants_1.COLLAB_LIMITS.maxTicketAcceptedRelations),
+        authorMemberId: string(source, 'authorMemberId', 64, CollabValidation_1.isCollabMemberId),
+        ...(closedAt && closedByMemberId ? { closedAt, closedByMemberId } : {}),
+        commentCount: boundedNonNegativeInteger(source, 'commentCount', CollabConstants_1.COLLAB_LIMITS.maxTicketComments),
+        createdAt: timestamp(source, 'createdAt'),
+        id: string(source, 'id', 128, CollabValidation_1.isCollabOpaqueId),
+        number: positiveInteger(source, 'number'),
+        revision: positiveInteger(source, 'revision'),
+        status,
+        title: string(source, 'title', CollabConstants_1.COLLAB_LIMITS.maxTicketTitleUtf16),
+        updatedAt: timestamp(source, 'updatedAt'),
+    };
+}
+function ticketComment(value) {
+    const source = record(value, 'ticket.comment');
+    return {
+        authorMemberId: string(source, 'authorMemberId', 64, CollabValidation_1.isCollabMemberId),
+        body: string(source, 'body', CollabConstants_1.COLLAB_LIMITS.maxTicketCommentBytes, undefined, 'utf8'),
+        createdAt: timestamp(source, 'createdAt'),
+        id: string(source, 'id', 128, CollabValidation_1.isCollabOpaqueId),
+        ticketId: string(source, 'ticketId', 128, CollabValidation_1.isCollabOpaqueId),
+    };
+}
+function acceptedTicketRelation(value) {
+    const source = record(value, 'ticket.acceptedRelation');
+    const kind = source.kind;
+    if (kind !== 'references' && kind !== 'resolves') {
+        throw decodeError('ticket.acceptedRelation.kind');
+    }
+    return {
+        acceptedAt: timestamp(source, 'acceptedAt'),
+        acceptedMergeOid: string(source, 'acceptedMergeOid', 64, CollabValidation_1.isCollabGitOid),
+        commitOid: string(source, 'commitOid', 64, CollabValidation_1.isCollabGitOid),
+        id: string(source, 'id', 128, CollabValidation_1.isCollabOpaqueId),
+        kind,
+        requestId: string(source, 'requestId', 128, CollabValidation_1.isCollabOpaqueId),
+    };
+}
+function pageCursor(source) {
+    return source.nextCursor === undefined
+        ? undefined
+        : string(source, 'nextCursor', CollabConstants_1.COLLAB_LIMITS.maxPageCursorUtf16);
+}
+function commentPage(value) {
+    const source = record(value, 'commentPage');
+    assertJsonUtf8ByteLengthAtMost(source, CollabConstants_1.COLLAB_LIMITS.commentPageMaxUtf8Bytes, 'commentPage.bytes');
+    if (!Array.isArray(source.comments)
+        || source.comments.length > CollabConstants_1.COLLAB_LIMITS.maxCommentPageSize) {
+        throw decodeError('commentPage');
+    }
+    const nextCursor = pageCursor(source);
+    return {
+        comments: source.comments.map(comment),
+        ...(nextCursor ? { nextCursor } : {}),
+    };
+}
+function ticketCommentPage(value) {
+    const source = record(value, 'ticketCommentPage');
+    assertJsonUtf8ByteLengthAtMost(source, CollabConstants_1.COLLAB_LIMITS.commentPageMaxUtf8Bytes, 'ticketCommentPage.bytes');
+    if (!Array.isArray(source.comments)
+        || source.comments.length > CollabConstants_1.COLLAB_LIMITS.maxCommentPageSize) {
+        throw decodeError('ticketCommentPage');
+    }
+    const nextCursor = pageCursor(source);
+    return {
+        comments: source.comments.map(ticketComment),
+        ...(nextCursor ? { nextCursor } : {}),
+    };
+}
+function acceptedRelationPage(value) {
+    const source = record(value, 'ticketAcceptedRelationPage');
+    assertJsonUtf8ByteLengthAtMost(source, CollabConstants_1.COLLAB_LIMITS.relationPageMaxUtf8Bytes, 'ticketAcceptedRelationPage.bytes');
+    if (!Array.isArray(source.acceptedRelations)
+        || source.acceptedRelations.length > CollabConstants_1.COLLAB_LIMITS.maxRelationsPerPage) {
+        throw decodeError('ticketAcceptedRelationPage');
+    }
+    const nextCursor = pageCursor(source);
+    return {
+        acceptedRelations: source.acceptedRelations.map(acceptedTicketRelation),
+        ...(nextCursor ? { nextCursor } : {}),
+    };
+}
+function ticketDetail(value) {
+    const source = record(value, 'ticketDetail');
+    assertJsonUtf8ByteLengthAtMost(source, CollabConstants_1.COLLAB_LIMITS.detailMaxUtf8Bytes, 'ticketDetail.bytes');
+    if (!isRecord(source.comments)
+        || !isRecord(source.acceptedRelations)) {
+        throw decodeError('ticketDetail');
+    }
+    const decodedTicket = ticketSummary(source.ticket);
+    const comments = ticketCommentPage(source.comments);
+    if (comments.comments.some(commentValue => commentValue.ticketId !== decodedTicket.id)) {
+        throw decodeError('ticketDetail.comments');
+    }
+    const acceptedRelations = acceptedRelationPage(source.acceptedRelations);
+    return {
+        acceptedRelations,
+        body: string(source, 'body', CollabConstants_1.COLLAB_LIMITS.maxTicketBodyBytes, undefined, 'utf8'),
+        comments,
+        ticket: decodedTicket,
+    };
+}
+function comment(value) {
+    const source = record(value, 'comment');
+    return {
+        authorMemberId: string(source, 'authorMemberId', 64, CollabValidation_1.isCollabMemberId),
+        body: string(source, 'body', CollabConstants_1.COLLAB_LIMITS.maxCommentBytes, undefined, 'utf8'),
+        createdAt: timestamp(source, 'createdAt'),
+        id: string(source, 'id', 128, CollabValidation_1.isCollabOpaqueId),
+        requestId: string(source, 'requestId', 128, CollabValidation_1.isCollabOpaqueId),
+    };
+}
+function envelopeData(value) {
+    return value;
+}
+function decodeEnsureMyRequestResponse(value) {
+    const data = record(envelopeData(value), 'data');
+    return {
+        mainOid: string(data, 'mainOid', 64, CollabValidation_1.isCollabGitOid),
+        request: changeRequest(data.request),
+    };
+}
+function decodeRequestDetailResponse(value) {
+    const data = record(envelopeData(value), 'data');
+    assertJsonUtf8ByteLengthAtMost(data, CollabConstants_1.COLLAB_LIMITS.detailMaxUtf8Bytes, 'requestDetail.bytes');
+    if (!isRecord(data.comments)
+        || data.changedFiles !== undefined) {
+        throw decodeError('requestDetail');
+    }
+    const decodedRequest = changeRequest(data.request);
+    const reviewedHeadOid = string(data, 'reviewedHeadOid', 64, CollabValidation_1.isCollabGitOid);
+    const reviewCondition = data.reviewCondition;
+    const comments = commentPage(data.comments);
+    if (reviewedHeadOid !== decodedRequest.latestHeadOid
+        || !['clean', 'conflicting', 'stale'].includes(String(reviewCondition))
+        || comments.comments.some(item => item.requestId !== decodedRequest.id)) {
+        throw decodeError('requestDetail');
+    }
+    return {
+        comments,
+        currentMainOid: string(data, 'currentMainOid', 64, CollabValidation_1.isCollabGitOid),
+        request: decodedRequest,
+        reviewCondition: reviewCondition,
+        reviewedHeadOid,
+    };
+}
+function decodeCommentPageResponse(value) {
+    return commentPage(record(envelopeData(value), 'data'));
+}
+function decodeTicketCommentPageResponse(value) {
+    return ticketCommentPage(record(envelopeData(value), 'data'));
+}
+function decodeTicketAcceptedRelationPageResponse(value) {
+    return acceptedRelationPage(record(envelopeData(value), 'data'));
+}
+function decodeCreateCommentResponse(value) {
+    const data = record(envelopeData(value), 'data');
+    const decodedRequest = changeRequest(data.request);
+    const decodedComment = comment(data.comment);
+    if (decodedComment.requestId !== decodedRequest.id
+        || decodedRequest.commentCount < 1) {
+        throw decodeError('commentResponse');
+    }
+    return { comment: decodedComment, request: decodedRequest };
+}
+function decodeAcceptResponse(value) {
+    const data = record(envelopeData(value), 'data');
+    const mainOid = string(data, 'mainOid', 64, CollabValidation_1.isCollabGitOid);
+    const mergeCommitOid = string(data, 'mergeCommitOid', 64, CollabValidation_1.isCollabGitOid);
+    const decodedRequest = changeRequest(data.request);
+    if (mergeCommitOid !== mainOid
+        || decodedRequest.status !== 'merged'
+        || decodedRequest.mergedOid !== mainOid) {
+        throw decodeError('acceptResponse');
+    }
+    return { mainOid, mergeCommitOid, request: decodedRequest };
+}
+function decodeTicketPageResponse(value) {
+    const data = record(envelopeData(value), 'data');
+    assertJsonUtf8ByteLengthAtMost(data, CollabConstants_1.COLLAB_LIMITS.ticketPageMaxUtf8Bytes, 'ticketPage.bytes');
+    if (!Array.isArray(data.tickets)
+        || data.tickets.length > CollabConstants_1.COLLAB_LIMITS.maxTicketPageSize)
+        throw decodeError('ticketPage');
+    const nextCursor = data.nextCursor === undefined
+        ? undefined
+        : string(data, 'nextCursor', 512);
+    return {
+        ...(nextCursor ? { nextCursor } : {}),
+        tickets: data.tickets.map(ticketSummary),
+    };
+}
+function decodeTicketDetailResponse(value) {
+    return ticketDetail(envelopeData(value));
+}
+function decodeCreateTicketResponse(value) {
+    return { ticket: ticketDetail(record(envelopeData(value), 'data').ticket) };
+}
+function decodeTicketMutationResponse(value) {
+    return { ticket: ticketSummary(record(envelopeData(value), 'data').ticket) };
+}
+function decodeTicketCommentResponse(value) {
+    const data = record(envelopeData(value), 'data');
+    const decodedTicket = ticketSummary(data.ticket);
+    const decodedComment = ticketComment(data.comment);
+    if (decodedComment.ticketId !== decodedTicket.id) {
+        throw decodeError('ticketCommentResponse');
+    }
+    return { comment: decodedComment, ticket: decodedTicket };
+}
+function decodeUpdateRequestMetadataResponse(value) {
+    return { request: changeRequest(record(envelopeData(value), 'data').request) };
+}

package/dist/CollabTicketReferenceParser.d.ts

@@ -0,0 +1,24 @@
+import type { CollabParsedTicketReference, CollabTicketCommitRelationKind } from './types';
+export type CollabTicketReferenceParseFailureReason = 'description-too-large' | 'ticket-number-out-of-range';
+export type CollabTicketReferenceParseResult = {
+    status: 'ok';
+    references: readonly CollabParsedTicketReference[];
+} | {
+    status: 'invalid';
+    reason: CollabTicketReferenceParseFailureReason;
+};
+export interface CollabTicketReferenceToken {
+    readonly from: number;
+    readonly kind: CollabTicketCommitRelationKind;
+    readonly ticketNumber: number;
+    readonly to: number;
+}
+export type CollabTicketReferenceScanResult = {
+    readonly status: 'ok';
+    readonly tokens: readonly CollabTicketReferenceToken[];
+} | {
+    readonly reason: 'ticket-number-out-of-range';
+    readonly status: 'invalid';
+};
+export declare function parseCollabTicketReferences(description: string): CollabTicketReferenceParseResult;
+export declare function scanCollabTicketReferences(description: string): CollabTicketReferenceScanResult;