+1 -7

package.json

reviewed

··· 28 28 "type": "git", 29 29 "url": "git@tangled.org:markbennett.ca/tangled-cli" 30 30 }, 31 31 - "keywords": [ 32 32 - "git", 33 33 - "tangled", 34 34 - "pds", 35 35 - "atproto", 36 36 - "cli" 37 37 - ], 31 31 + "keywords": ["git", "tangled", "pds", "atproto", "cli"], 38 32 "author": "Mark Bennett", 39 33 "license": "MIT", 40 34 "dependencies": {

+225 -233

src/lib/issues-api.ts

reviewed

··· 1 1 - import type { TangledApiClient } from './api-client.js'; 1 1 + import type { Record as IssueRecord } from '../lexicon/types/sh/tangled/repo/issue.js'; 2 2 import { parseAtUri } from '../utils/at-uri.js'; 3 3 import { requireAuth } from '../utils/auth-helpers.js'; 4 4 - import type { Record as IssueRecord } from '../lexicon/types/sh/tangled/repo/issue.js'; 4 4 + import type { TangledApiClient } from './api-client.js'; 5 5 6 6 // Re-export the generated issue record type for convenience 7 7 export type { IssueRecord }; ··· 10 10 * Issue record with metadata 11 11 */ 12 12 export interface IssueWithMetadata extends IssueRecord { 13 13 - uri: string; // AT-URI of the issue 14 14 - cid: string; // Content ID 15 15 - author: string; // Creator's DID 13 13 + uri: string; // AT-URI of the issue 14 14 + cid: string; // Content ID 15 15 + author: string; // Creator's DID 16 16 } 17 17 18 18 /** 19 19 * Parameters for creating an issue 20 20 */ 21 21 export interface CreateIssueParams { 22 22 - client: TangledApiClient; 23 23 - repoAtUri: string; 24 24 - title: string; 25 25 - body?: string; 22 22 + client: TangledApiClient; 23 23 + repoAtUri: string; 24 24 + title: string; 25 25 + body?: string; 26 26 } 27 27 28 28 /** 29 29 * Parameters for listing issues 30 30 */ 31 31 export interface ListIssuesParams { 32 32 - client: TangledApiClient; 33 33 - repoAtUri: string; 34 34 - limit?: number; 35 35 - cursor?: string; 32 32 + client: TangledApiClient; 33 33 + repoAtUri: string; 34 34 + limit?: number; 35 35 + cursor?: string; 36 36 } 37 37 38 38 /** 39 39 * Parameters for getting a specific issue 40 40 */ 41 41 export interface GetIssueParams { 42 42 - client: TangledApiClient; 43 43 - issueUri: string; 42 42 + client: TangledApiClient; 43 43 + issueUri: string; 44 44 } 45 45 46 46 /** 47 47 * Parameters for updating an issue 48 48 */ 49 49 export interface UpdateIssueParams { 50 50 - client: TangledApiClient; 51 51 - issueUri: string; 52 52 - title?: string; 53 53 - body?: string; 50 50 + client: TangledApiClient; 51 51 + issueUri: string; 52 52 + title?: string; 53 53 + body?: string; 54 54 } 55 55 56 56 /** 57 57 * Parameters for closing an issue 58 58 */ 59 59 export interface CloseIssueParams { 60 60 - client: TangledApiClient; 61 61 - issueUri: string; 60 60 + client: TangledApiClient; 61 61 + issueUri: string; 62 62 } 63 63 64 64 /** 65 65 * Parameters for deleting an issue 66 66 */ 67 67 export interface DeleteIssueParams { 68 68 - client: TangledApiClient; 69 69 - issueUri: string; 68 68 + client: TangledApiClient; 69 69 + issueUri: string; 70 70 } 71 71 72 72 /** ··· 75 75 * @returns Parsed URI components 76 76 */ 77 77 function parseIssueUri(issueUri: string): { 78 78 - did: string; 79 79 - collection: string; 80 80 - rkey: string; 78 78 + did: string; 79 79 + collection: string; 80 80 + rkey: string; 81 81 } { 82 82 - const parsed = parseAtUri(issueUri); 83 83 - if (!parsed || !parsed.rkey) { 84 84 - throw new Error(`Invalid issue AT-URI: ${issueUri}`); 85 85 - } 82 82 + const parsed = parseAtUri(issueUri); 83 83 + if (!parsed || !parsed.rkey) { 84 84 + throw new Error(`Invalid issue AT-URI: ${issueUri}`); 85 85 + } 86 86 87 87 - return { 88 88 - did: parsed.did, 89 89 - collection: parsed.collection, 90 90 - rkey: parsed.rkey, 91 91 - }; 87 87 + return { 88 88 + did: parsed.did, 89 89 + collection: parsed.collection, 90 90 + rkey: parsed.rkey, 91 91 + }; 92 92 } 93 93 94 94 /** 95 95 * Create a new issue 96 96 */ 97 97 - export async function createIssue( 98 98 - params: CreateIssueParams, 99 99 - ): Promise<IssueWithMetadata> { 100 100 - const { client, repoAtUri, title, body } = params; 97 97 + export async function createIssue(params: CreateIssueParams): Promise<IssueWithMetadata> { 98 98 + const { client, repoAtUri, title, body } = params; 101 99 102 102 - // Validate authentication 103 103 - const session = await requireAuth(client); 100 100 + // Validate authentication 101 101 + const session = await requireAuth(client); 104 102 105 105 - // Build issue record 106 106 - const record: IssueRecord = { 107 107 - $type: 'sh.tangled.repo.issue', 108 108 - repo: repoAtUri, 109 109 - title, 110 110 - body, 111 111 - createdAt: new Date().toISOString(), 112 112 - }; 103 103 + // Build issue record 104 104 + const record: IssueRecord = { 105 105 + $type: 'sh.tangled.repo.issue', 106 106 + repo: repoAtUri, 107 107 + title, 108 108 + body, 109 109 + createdAt: new Date().toISOString(), 110 110 + }; 113 111 114 114 - try { 115 115 - // Create record via AT Protocol 116 116 - const response = await client.getAgent().com.atproto.repo.createRecord({ 117 117 - repo: session.did, 118 118 - collection: 'sh.tangled.repo.issue', 119 119 - record, 120 120 - }); 112 112 + try { 113 113 + // Create record via AT Protocol 114 114 + const response = await client.getAgent().com.atproto.repo.createRecord({ 115 115 + repo: session.did, 116 116 + collection: 'sh.tangled.repo.issue', 117 117 + record, 118 118 + }); 121 119 122 122 - return { 123 123 - ...record, 124 124 - uri: response.data.uri, 125 125 - cid: response.data.cid, 126 126 - author: session.did, 127 127 - }; 128 128 - } catch (error) { 129 129 - if (error instanceof Error) { 130 130 - throw new Error(`Failed to create issue: ${error.message}`); 131 131 - } 132 132 - throw new Error('Failed to create issue: Unknown error'); 133 133 - } 120 120 + return { 121 121 + ...record, 122 122 + uri: response.data.uri, 123 123 + cid: response.data.cid, 124 124 + author: session.did, 125 125 + }; 126 126 + } catch (error) { 127 127 + if (error instanceof Error) { 128 128 + throw new Error(`Failed to create issue: ${error.message}`); 129 129 + } 130 130 + throw new Error('Failed to create issue: Unknown error'); 131 131 + } 134 132 } 135 133 136 134 /** 137 135 * List issues for a repository 138 136 */ 139 139 - export async function listIssues( 140 140 - params: ListIssuesParams, 141 141 - ): Promise<{ 142 142 - issues: IssueWithMetadata[]; 143 143 - cursor?: string; 137 137 + export async function listIssues(params: ListIssuesParams): Promise<{ 138 138 + issues: IssueWithMetadata[]; 139 139 + cursor?: string; 144 140 }> { 145 145 - const { client, repoAtUri, limit = 50, cursor } = params; 141 141 + const { client, repoAtUri, limit = 50, cursor } = params; 146 142 147 147 - // Validate authentication 148 148 - await requireAuth(client); 143 143 + // Validate authentication 144 144 + await requireAuth(client); 149 145 150 150 - // Extract owner DID from repo AT-URI 151 151 - const parsed = parseAtUri(repoAtUri); 152 152 - if (!parsed) { 153 153 - throw new Error(`Invalid repository AT-URI: ${repoAtUri}`); 154 154 - } 146 146 + // Extract owner DID from repo AT-URI 147 147 + const parsed = parseAtUri(repoAtUri); 148 148 + if (!parsed) { 149 149 + throw new Error(`Invalid repository AT-URI: ${repoAtUri}`); 150 150 + } 155 151 156 156 - const ownerDid = parsed.did; 152 152 + const ownerDid = parsed.did; 157 153 158 158 - try { 159 159 - // List all issue records for the owner 160 160 - const response = await client.getAgent().com.atproto.repo.listRecords({ 161 161 - repo: ownerDid, 162 162 - collection: 'sh.tangled.repo.issue', 163 163 - limit, 164 164 - cursor, 165 165 - }); 154 154 + try { 155 155 + // List all issue records for the owner 156 156 + const response = await client.getAgent().com.atproto.repo.listRecords({ 157 157 + repo: ownerDid, 158 158 + collection: 'sh.tangled.repo.issue', 159 159 + limit, 160 160 + cursor, 161 161 + }); 166 162 167 167 - // Filter to only issues for this specific repository 168 168 - const issues: IssueWithMetadata[] = response.data.records 169 169 - .filter((record) => { 170 170 - const issueRecord = record.value as IssueRecord; 171 171 - return issueRecord.repo === repoAtUri; 172 172 - }) 173 173 - .map((record) => ({ 174 174 - ...(record.value as IssueRecord), 175 175 - uri: record.uri, 176 176 - cid: record.cid, 177 177 - author: ownerDid, 178 178 - })); 163 163 + // Filter to only issues for this specific repository 164 164 + const issues: IssueWithMetadata[] = response.data.records 165 165 + .filter((record) => { 166 166 + const issueRecord = record.value as IssueRecord; 167 167 + return issueRecord.repo === repoAtUri; 168 168 + }) 169 169 + .map((record) => ({ 170 170 + ...(record.value as IssueRecord), 171 171 + uri: record.uri, 172 172 + cid: record.cid, 173 173 + author: ownerDid, 174 174 + })); 179 175 180 180 - return { 181 181 - issues, 182 182 - cursor: response.data.cursor, 183 183 - }; 184 184 - } catch (error) { 185 185 - if (error instanceof Error) { 186 186 - throw new Error(`Failed to list issues: ${error.message}`); 187 187 - } 188 188 - throw new Error('Failed to list issues: Unknown error'); 189 189 - } 176 176 + return { 177 177 + issues, 178 178 + cursor: response.data.cursor, 179 179 + }; 180 180 + } catch (error) { 181 181 + if (error instanceof Error) { 182 182 + throw new Error(`Failed to list issues: ${error.message}`); 183 183 + } 184 184 + throw new Error('Failed to list issues: Unknown error'); 185 185 + } 190 186 } 191 187 192 188 /** 193 189 * Get a specific issue 194 190 */ 195 195 - export async function getIssue( 196 196 - params: GetIssueParams, 197 197 - ): Promise<IssueWithMetadata> { 198 198 - const { client, issueUri } = params; 191 191 + export async function getIssue(params: GetIssueParams): Promise<IssueWithMetadata> { 192 192 + const { client, issueUri } = params; 199 193 200 200 - // Validate authentication 201 201 - await requireAuth(client); 194 194 + // Validate authentication 195 195 + await requireAuth(client); 202 196 203 203 - // Parse issue URI 204 204 - const { did, collection, rkey } = parseIssueUri(issueUri); 197 197 + // Parse issue URI 198 198 + const { did, collection, rkey } = parseIssueUri(issueUri); 205 199 206 206 - try { 207 207 - // Get record via AT Protocol 208 208 - const response = await client.getAgent().com.atproto.repo.getRecord({ 209 209 - repo: did, 210 210 - collection, 211 211 - rkey, 212 212 - }); 200 200 + try { 201 201 + // Get record via AT Protocol 202 202 + const response = await client.getAgent().com.atproto.repo.getRecord({ 203 203 + repo: did, 204 204 + collection, 205 205 + rkey, 206 206 + }); 213 207 214 214 - const record = response.data.value as IssueRecord; 208 208 + const record = response.data.value as IssueRecord; 215 209 216 216 - return { 217 217 - ...record, 218 218 - uri: response.data.uri, 219 219 - cid: response.data.cid as string, // CID is always present in AT Protocol responses 220 220 - author: did, 221 221 - }; 222 222 - } catch (error) { 223 223 - if (error instanceof Error) { 224 224 - if (error.message.includes('not found')) { 225 225 - throw new Error(`Issue not found: ${issueUri}`); 226 226 - } 227 227 - throw new Error(`Failed to get issue: ${error.message}`); 228 228 - } 229 229 - throw new Error('Failed to get issue: Unknown error'); 230 230 - } 210 210 + return { 211 211 + ...record, 212 212 + uri: response.data.uri, 213 213 + cid: response.data.cid as string, // CID is always present in AT Protocol responses 214 214 + author: did, 215 215 + }; 216 216 + } catch (error) { 217 217 + if (error instanceof Error) { 218 218 + if (error.message.includes('not found')) { 219 219 + throw new Error(`Issue not found: ${issueUri}`); 220 220 + } 221 221 + throw new Error(`Failed to get issue: ${error.message}`); 222 222 + } 223 223 + throw new Error('Failed to get issue: Unknown error'); 224 224 + } 231 225 } 232 226 233 227 /** 234 228 * Update an issue (title and/or body) 235 229 */ 236 236 - export async function updateIssue( 237 237 - params: UpdateIssueParams, 238 238 - ): Promise<IssueWithMetadata> { 239 239 - const { client, issueUri, title, body } = params; 230 230 + export async function updateIssue(params: UpdateIssueParams): Promise<IssueWithMetadata> { 231 231 + const { client, issueUri, title, body } = params; 240 232 241 241 - // Validate authentication 242 242 - const session = await requireAuth(client); 233 233 + // Validate authentication 234 234 + const session = await requireAuth(client); 243 235 244 244 - // Parse issue URI 245 245 - const { did, collection, rkey } = parseIssueUri(issueUri); 236 236 + // Parse issue URI 237 237 + const { did, collection, rkey } = parseIssueUri(issueUri); 246 238 247 247 - // Verify user owns the issue 248 248 - if (did !== session.did) { 249 249 - throw new Error('Cannot update issue: you are not the author'); 250 250 - } 239 239 + // Verify user owns the issue 240 240 + if (did !== session.did) { 241 241 + throw new Error('Cannot update issue: you are not the author'); 242 242 + } 251 243 252 252 - try { 253 253 - // Get current issue to merge with updates 254 254 - const currentIssue = await getIssue({ client, issueUri }); 244 244 + try { 245 245 + // Get current issue to merge with updates 246 246 + const currentIssue = await getIssue({ client, issueUri }); 255 247 256 256 - // Build updated record (merge existing with new values) 257 257 - const updatedRecord: IssueRecord = { 258 258 - ...currentIssue, 259 259 - ...(title !== undefined && { title }), 260 260 - ...(body !== undefined && { body }), 261 261 - }; 248 248 + // Build updated record (merge existing with new values) 249 249 + const updatedRecord: IssueRecord = { 250 250 + ...currentIssue, 251 251 + ...(title !== undefined && { title }), 252 252 + ...(body !== undefined && { body }), 253 253 + }; 262 254 263 263 - // Update record with CID swap for atomic update 264 264 - const response = await client.getAgent().com.atproto.repo.putRecord({ 265 265 - repo: did, 266 266 - collection, 267 267 - rkey, 268 268 - record: updatedRecord, 269 269 - swapRecord: currentIssue.cid, 270 270 - }); 255 255 + // Update record with CID swap for atomic update 256 256 + const response = await client.getAgent().com.atproto.repo.putRecord({ 257 257 + repo: did, 258 258 + collection, 259 259 + rkey, 260 260 + record: updatedRecord, 261 261 + swapRecord: currentIssue.cid, 262 262 + }); 271 263 272 272 - return { 273 273 - ...updatedRecord, 274 274 - uri: issueUri, 275 275 - cid: response.data.cid, 276 276 - author: did, 277 277 - }; 278 278 - } catch (error) { 279 279 - if (error instanceof Error) { 280 280 - throw new Error(`Failed to update issue: ${error.message}`); 281 281 - } 282 282 - throw new Error('Failed to update issue: Unknown error'); 283 283 - } 264 264 + return { 265 265 + ...updatedRecord, 266 266 + uri: issueUri, 267 267 + cid: response.data.cid, 268 268 + author: did, 269 269 + }; 270 270 + } catch (error) { 271 271 + if (error instanceof Error) { 272 272 + throw new Error(`Failed to update issue: ${error.message}`); 273 273 + } 274 274 + throw new Error('Failed to update issue: Unknown error'); 275 275 + } 284 276 } 285 277 286 278 /** 287 279 * Close an issue by creating/updating a state record 288 280 */ 289 281 export async function closeIssue(params: CloseIssueParams): Promise<void> { 290 290 - const { client, issueUri } = params; 282 282 + const { client, issueUri } = params; 291 283 292 292 - // Validate authentication 293 293 - const session = await requireAuth(client); 284 284 + // Validate authentication 285 285 + const session = await requireAuth(client); 294 286 295 295 - try { 296 296 - // Verify issue exists 297 297 - await getIssue({ client, issueUri }); 287 287 + try { 288 288 + // Verify issue exists 289 289 + await getIssue({ client, issueUri }); 298 290 299 299 - // Create state record 300 300 - const stateRecord = { 301 301 - $type: 'sh.tangled.repo.issue.state', 302 302 - issue: issueUri, 303 303 - state: 'sh.tangled.repo.issue.state.closed', 304 304 - }; 291 291 + // Create state record 292 292 + const stateRecord = { 293 293 + $type: 'sh.tangled.repo.issue.state', 294 294 + issue: issueUri, 295 295 + state: 'sh.tangled.repo.issue.state.closed', 296 296 + }; 305 297 306 306 - // Create state record 307 307 - await client.getAgent().com.atproto.repo.createRecord({ 308 308 - repo: session.did, 309 309 - collection: 'sh.tangled.repo.issue.state', 310 310 - record: stateRecord, 311 311 - }); 312 312 - } catch (error) { 313 313 - if (error instanceof Error) { 314 314 - throw new Error(`Failed to close issue: ${error.message}`); 315 315 - } 316 316 - throw new Error('Failed to close issue: Unknown error'); 317 317 - } 298 298 + // Create state record 299 299 + await client.getAgent().com.atproto.repo.createRecord({ 300 300 + repo: session.did, 301 301 + collection: 'sh.tangled.repo.issue.state', 302 302 + record: stateRecord, 303 303 + }); 304 304 + } catch (error) { 305 305 + if (error instanceof Error) { 306 306 + throw new Error(`Failed to close issue: ${error.message}`); 307 307 + } 308 308 + throw new Error('Failed to close issue: Unknown error'); 309 309 + } 318 310 } 319 311 320 312 /** 321 313 * Delete an issue 322 314 */ 323 315 export async function deleteIssue(params: DeleteIssueParams): Promise<void> { 324 324 - const { client, issueUri } = params; 316 316 + const { client, issueUri } = params; 325 317 326 326 - // Validate authentication 327 327 - const session = await requireAuth(client); 318 318 + // Validate authentication 319 319 + const session = await requireAuth(client); 328 320 329 329 - // Parse issue URI 330 330 - const { did, collection, rkey } = parseIssueUri(issueUri); 321 321 + // Parse issue URI 322 322 + const { did, collection, rkey } = parseIssueUri(issueUri); 331 323 332 332 - // Verify user owns the issue 333 333 - if (did !== session.did) { 334 334 - throw new Error('Cannot delete issue: you are not the author'); 335 335 - } 324 324 + // Verify user owns the issue 325 325 + if (did !== session.did) { 326 326 + throw new Error('Cannot delete issue: you are not the author'); 327 327 + } 336 328 337 337 - try { 338 338 - // Delete record via AT Protocol 339 339 - await client.getAgent().com.atproto.repo.deleteRecord({ 340 340 - repo: did, 341 341 - collection, 342 342 - rkey, 343 343 - }); 344 344 - } catch (error) { 345 345 - if (error instanceof Error) { 346 346 - if (error.message.includes('not found')) { 347 347 - throw new Error(`Issue not found: ${issueUri}`); 348 348 - } 349 349 - throw new Error(`Failed to delete issue: ${error.message}`); 350 350 - } 351 351 - throw new Error('Failed to delete issue: Unknown error'); 352 352 - } 329 329 + try { 330 330 + // Delete record via AT Protocol 331 331 + await client.getAgent().com.atproto.repo.deleteRecord({ 332 332 + repo: did, 333 333 + collection, 334 334 + rkey, 335 335 + }); 336 336 + } catch (error) { 337 337 + if (error instanceof Error) { 338 338 + if (error.message.includes('not found')) { 339 339 + throw new Error(`Issue not found: ${issueUri}`); 340 340 + } 341 341 + throw new Error(`Failed to delete issue: ${error.message}`); 342 342 + } 343 343 + throw new Error('Failed to delete issue: Unknown error'); 344 344 + } 353 345 }

+49 -49

src/utils/at-uri.ts

reviewed

··· 6 6 * @returns Parsed components or null if invalid 7 7 */ 8 8 export function parseAtUri(uri: string): { 9 9 - did: string; 10 10 - collection: string; 11 11 - rkey?: string; 9 9 + did: string; 10 10 + collection: string; 11 11 + rkey?: string; 12 12 } | null { 13 13 - // AT-URI format: at://did:method:identifier/collection[/rkey] 14 14 - const match = uri.match(/^at:\/\/(did:[a-z]+:[a-zA-Z0-9._:%-]+)\/([a-zA-Z0-9._-]+(?:\.[a-zA-Z0-9._-]+)*)(?:\/([a-zA-Z0-9._-]+))?$/); 13 13 + // AT-URI format: at://did:method:identifier/collection[/rkey] 14 14 + const match = uri.match( 15 15 + /^at:\/\/(did:[a-z]+:[a-zA-Z0-9._:%-]+)\/([a-zA-Z0-9._-]+(?:\.[a-zA-Z0-9._-]+)*)(?:\/([a-zA-Z0-9._-]+))?$/ 16 16 + ); 15 17 16 16 - if (!match) { 17 17 - return null; 18 18 - } 18 18 + if (!match) { 19 19 + return null; 20 20 + } 19 21 20 20 - const [, did, collection, rkey] = match; 21 21 - return { 22 22 - did, 23 23 - collection, 24 24 - ...(rkey && { rkey }), 25 25 - }; 22 22 + const [, did, collection, rkey] = match; 23 23 + return { 24 24 + did, 25 25 + collection, 26 26 + ...(rkey && { rkey }), 27 27 + }; 26 28 } 27 29 28 30 /** ··· 33 35 * @throws Error if handle cannot be resolved 34 36 */ 35 37 export async function resolveHandleToDid( 36 36 - handle: string, 37 37 - client: TangledApiClient, 38 38 + handle: string, 39 39 + client: TangledApiClient 38 40 ): Promise<string> { 39 39 - // Strip leading @ if present 40 40 - const cleanHandle = handle.startsWith('@') ? handle.slice(1) : handle; 41 41 + // Strip leading @ if present 42 42 + const cleanHandle = handle.startsWith('@') ? handle.slice(1) : handle; 41 43 42 42 - try { 43 43 - const response = await client.getAgent().com.atproto.identity.resolveHandle({ 44 44 - handle: cleanHandle, 45 45 - }); 44 44 + try { 45 45 + const response = await client.getAgent().com.atproto.identity.resolveHandle({ 46 46 + handle: cleanHandle, 47 47 + }); 46 48 47 47 - if (!response.data.did) { 48 48 - throw new Error(`No DID found for handle: ${cleanHandle}`); 49 49 - } 49 49 + if (!response.data.did) { 50 50 + throw new Error(`No DID found for handle: ${cleanHandle}`); 51 51 + } 50 52 51 51 - return response.data.did; 52 52 - } catch (error) { 53 53 - if (error instanceof Error) { 54 54 - throw new Error( 55 55 - `Failed to resolve handle '${cleanHandle}': ${error.message}`, 56 56 - ); 57 57 - } 58 58 - throw new Error(`Failed to resolve handle '${cleanHandle}': Unknown error`); 59 59 - } 53 53 + return response.data.did; 54 54 + } catch (error) { 55 55 + if (error instanceof Error) { 56 56 + throw new Error(`Failed to resolve handle '${cleanHandle}': ${error.message}`); 57 57 + } 58 58 + throw new Error(`Failed to resolve handle '${cleanHandle}': Unknown error`); 59 59 + } 60 60 } 61 61 62 62 /** ··· 67 67 * @returns AT-URI string (e.g., "at://did:plc:abc/sh.tangled.repo/repoName") 68 68 */ 69 69 export async function buildRepoAtUri( 70 70 - ownerDidOrHandle: string, 71 71 - repoName: string, 72 72 - client: TangledApiClient, 70 70 + ownerDidOrHandle: string, 71 71 + repoName: string, 72 72 + client: TangledApiClient 73 73 ): Promise<string> { 74 74 - // Check if owner is already a DID 75 75 - const isDid = ownerDidOrHandle.startsWith('did:'); 74 74 + // Check if owner is already a DID 75 75 + const isDid = ownerDidOrHandle.startsWith('did:'); 76 76 77 77 - let did: string; 78 78 - if (isDid) { 79 79 - did = ownerDidOrHandle; 80 80 - } else { 81 81 - // Resolve handle to DID 82 82 - did = await resolveHandleToDid(ownerDidOrHandle, client); 83 83 - } 77 77 + let did: string; 78 78 + if (isDid) { 79 79 + did = ownerDidOrHandle; 80 80 + } else { 81 81 + // Resolve handle to DID 82 82 + did = await resolveHandleToDid(ownerDidOrHandle, client); 83 83 + } 84 84 85 85 - // Construct AT-URI for repository 86 86 - // Format: at://{did}/sh.tangled.repo/{repoName} 87 87 - return `at://${did}/sh.tangled.repo/${repoName}`; 85 85 + // Construct AT-URI for repository 86 86 + // Format: at://{did}/sh.tangled.repo/{repoName} 87 87 + return `at://${did}/sh.tangled.repo/${repoName}`; 88 88 }

+10 -10

src/utils/auth-helpers.ts

reviewed

··· 6 6 * @returns The current session with did and handle 7 7 */ 8 8 export async function requireAuth(client: TangledApiClient): Promise<{ 9 9 - did: string; 10 10 - handle: string; 9 9 + did: string; 10 10 + handle: string; 11 11 }> { 12 12 - if (!(await client.isAuthenticated())) { 13 13 - throw new Error('Must be authenticated. Run "tangled auth login" first.'); 14 14 - } 12 12 + if (!(await client.isAuthenticated())) { 13 13 + throw new Error('Must be authenticated. Run "tangled auth login" first.'); 14 14 + } 15 15 16 16 - const session = client.getSession(); 17 17 - if (!session) { 18 18 - throw new Error('No active session found'); 19 19 - } 16 16 + const session = client.getSession(); 17 17 + if (!session) { 18 18 + throw new Error('No active session found'); 19 19 + } 20 20 21 21 - return session; 21 21 + return session; 22 22 }

+60 -64

src/utils/body-input.ts

reviewed

··· 11 11 * @throws Error if file doesn't exist or cannot be read 12 12 */ 13 13 export async function readBodyInput( 14 14 - bodyString?: string, 15 15 - bodyFilePath?: string, 14 14 + bodyString?: string, 15 15 + bodyFilePath?: string 16 16 ): Promise<string | undefined> { 17 17 - // Error if both are provided 18 18 - if (bodyString !== undefined && bodyFilePath !== undefined) { 19 19 - throw new Error( 20 20 - 'Cannot specify both --body and --body-file. Choose one input method.', 21 21 - ); 22 22 - } 17 17 + // Error if both are provided 18 18 + if (bodyString !== undefined && bodyFilePath !== undefined) { 19 19 + throw new Error('Cannot specify both --body and --body-file. Choose one input method.'); 20 20 + } 23 21 24 24 - // Direct string input (including empty string) 25 25 - if (bodyString !== undefined) { 26 26 - return bodyString; 27 27 - } 22 22 + // Direct string input (including empty string) 23 23 + if (bodyString !== undefined) { 24 24 + return bodyString; 25 25 + } 28 26 29 29 - // File or stdin input 30 30 - if (bodyFilePath) { 31 31 - // Read from stdin 32 32 - if (bodyFilePath === '-') { 33 33 - return await readFromStdin(); 34 34 - } 27 27 + // File or stdin input 28 28 + if (bodyFilePath) { 29 29 + // Read from stdin 30 30 + if (bodyFilePath === '-') { 31 31 + return await readFromStdin(); 32 32 + } 35 33 36 36 - // Read from file 37 37 - try { 38 38 - const stats = await fs.stat(bodyFilePath); 34 34 + // Read from file 35 35 + try { 36 36 + const stats = await fs.stat(bodyFilePath); 39 37 40 40 - if (stats.isDirectory()) { 41 41 - throw new Error(`'${bodyFilePath}' is a directory, not a file`); 42 42 - } 38 38 + if (stats.isDirectory()) { 39 39 + throw new Error(`'${bodyFilePath}' is a directory, not a file`); 40 40 + } 43 41 44 44 - const content = await fs.readFile(bodyFilePath, 'utf-8'); 45 45 - return content; 46 46 - } catch (error) { 47 47 - if (error instanceof Error) { 48 48 - // Re-throw our custom directory error 49 49 - if (error.message.includes('is a directory')) { 50 50 - throw error; 51 51 - } 42 42 + const content = await fs.readFile(bodyFilePath, 'utf-8'); 43 43 + return content; 44 44 + } catch (error) { 45 45 + if (error instanceof Error) { 46 46 + // Re-throw our custom directory error 47 47 + if (error.message.includes('is a directory')) { 48 48 + throw error; 49 49 + } 52 50 53 53 - // Handle ENOENT (file not found) 54 54 - if ('code' in error && error.code === 'ENOENT') { 55 55 - throw new Error(`File not found: ${bodyFilePath}`); 56 56 - } 51 51 + // Handle ENOENT (file not found) 52 52 + if ('code' in error && error.code === 'ENOENT') { 53 53 + throw new Error(`File not found: ${bodyFilePath}`); 54 54 + } 57 55 58 58 - // Handle EACCES (permission denied) 59 59 - if ('code' in error && error.code === 'EACCES') { 60 60 - throw new Error(`Permission denied: ${bodyFilePath}`); 61 61 - } 56 56 + // Handle EACCES (permission denied) 57 57 + if ('code' in error && error.code === 'EACCES') { 58 58 + throw new Error(`Permission denied: ${bodyFilePath}`); 59 59 + } 62 60 63 63 - throw new Error( 64 64 - `Failed to read file '${bodyFilePath}': ${error.message}`, 65 65 - ); 66 66 - } 61 61 + throw new Error(`Failed to read file '${bodyFilePath}': ${error.message}`); 62 62 + } 67 63 68 68 - throw new Error(`Failed to read file '${bodyFilePath}': Unknown error`); 69 69 - } 70 70 - } 64 64 + throw new Error(`Failed to read file '${bodyFilePath}': Unknown error`); 65 65 + } 66 66 + } 71 67 72 72 - // No input provided 73 73 - return undefined; 68 68 + // No input provided 69 69 + return undefined; 74 70 } 75 71 76 72 /** ··· 78 74 * @returns Content from stdin as string 79 75 */ 80 76 async function readFromStdin(): Promise<string> { 81 81 - return new Promise((resolve, reject) => { 82 82 - const chunks: Buffer[] = []; 77 77 + return new Promise((resolve, reject) => { 78 78 + const chunks: Buffer[] = []; 83 79 84 84 - process.stdin.on('data', (chunk: Buffer) => { 85 85 - chunks.push(chunk); 86 86 - }); 80 80 + process.stdin.on('data', (chunk: Buffer) => { 81 81 + chunks.push(chunk); 82 82 + }); 87 83 88 88 - process.stdin.on('end', () => { 89 89 - const content = Buffer.concat(chunks).toString('utf-8'); 90 90 - resolve(content); 91 91 - }); 84 84 + process.stdin.on('end', () => { 85 85 + const content = Buffer.concat(chunks).toString('utf-8'); 86 86 + resolve(content); 87 87 + }); 92 88 93 93 - process.stdin.on('error', (error: Error) => { 94 94 - reject(new Error(`Failed to read from stdin: ${error.message}`)); 95 95 - }); 89 89 + process.stdin.on('error', (error: Error) => { 90 90 + reject(new Error(`Failed to read from stdin: ${error.message}`)); 91 91 + }); 96 92 97 97 - // Resume stdin in case it's paused 98 98 - process.stdin.resume(); 99 99 - }); 93 93 + // Resume stdin in case it's paused 94 94 + process.stdin.resume(); 95 95 + }); 100 96 }

+14 -14

src/utils/validation.ts

reviewed

··· 136 136 * Titles must be 1-256 characters 137 137 */ 138 138 export const issueTitleSchema = z 139 139 - .string() 140 140 - .min(1, 'Issue title cannot be empty') 141 141 - .max(256, 'Issue title must be 256 characters or less'); 139 139 + .string() 140 140 + .min(1, 'Issue title cannot be empty') 141 141 + .max(256, 'Issue title must be 256 characters or less'); 142 142 143 143 /** 144 144 * Validation schema for issue body 145 145 * Body is optional but limited to 50,000 characters 146 146 */ 147 147 export const issueBodySchema = z 148 148 - .string() 149 149 - .max(50000, 'Issue body must be 50,000 characters or less') 150 150 - .optional(); 148 148 + .string() 149 149 + .max(50000, 'Issue body must be 50,000 characters or less') 150 150 + .optional(); 151 151 152 152 /** 153 153 * Validation schema for AT-URI 154 154 * Format: at://did:method:identifier/collection[/rkey] 155 155 */ 156 156 export const atUriSchema = z 157 157 - .string() 158 158 - .regex( 159 159 - /^at:\/\/did:[a-z]+:[a-zA-Z0-9._:%-]+\/[a-zA-Z0-9._-]+(?:\.[a-zA-Z0-9._-]+)*(?:\/[a-zA-Z0-9._-]+)?$/, 160 160 - 'Invalid AT-URI format. Expected: at://did:method:id/collection[/rkey]', 161 161 - ); 157 157 + .string() 158 158 + .regex( 159 159 + /^at:\/\/did:[a-z]+:[a-zA-Z0-9._:%-]+\/[a-zA-Z0-9._-]+(?:\.[a-zA-Z0-9._-]+)*(?:\/[a-zA-Z0-9._-]+)?$/, 160 160 + 'Invalid AT-URI format. Expected: at://did:method:id/collection[/rkey]' 161 161 + ); 162 162 163 163 /** 164 164 * Validate an issue title 165 165 * @throws {z.ZodError} if validation fails 166 166 */ 167 167 export function validateIssueTitle(title: string): string { 168 168 - return issueTitleSchema.parse(title); 168 168 + return issueTitleSchema.parse(title); 169 169 } 170 170 171 171 /** ··· 173 173 * @throws {z.ZodError} if validation fails 174 174 */ 175 175 export function validateIssueBody(body: string): string { 176 176 - return issueBodySchema.parse(body) ?? ''; 176 176 + return issueBodySchema.parse(body) ?? ''; 177 177 } 178 178 179 179 /** ··· 181 181 * Returns true/false without throwing 182 182 */ 183 183 export function isValidAtUri(uri: string): boolean { 184 184 - return atUriSchema.safeParse(uri).success; 184 184 + return atUriSchema.safeParse(uri).success; 185 185 }

+560 -568

tests/lib/issues-api.test.ts

reviewed

··· 1 1 import { beforeEach, describe, expect, it, vi } from 'vitest'; 2 2 + import type { TangledApiClient } from '../../src/lib/api-client.js'; 2 3 import { 3 3 - closeIssue, 4 4 - createIssue, 5 5 - deleteIssue, 6 6 - getIssue, 7 7 - listIssues, 8 8 - updateIssue, 4 4 + closeIssue, 5 5 + createIssue, 6 6 + deleteIssue, 7 7 + getIssue, 8 8 + listIssues, 9 9 + updateIssue, 9 10 } from '../../src/lib/issues-api.js'; 10 10 - import type { TangledApiClient } from '../../src/lib/api-client.js'; 11 11 12 12 // Mock API client factory 13 13 const createMockClient = (authenticated = true): TangledApiClient => { 14 14 - const mockAgent = { 15 15 - com: { 16 16 - atproto: { 17 17 - repo: { 18 18 - createRecord: vi.fn(), 19 19 - listRecords: vi.fn(), 20 20 - getRecord: vi.fn(), 21 21 - putRecord: vi.fn(), 22 22 - deleteRecord: vi.fn(), 23 23 - }, 24 24 - }, 25 25 - }, 26 26 - }; 14 14 + const mockAgent = { 15 15 + com: { 16 16 + atproto: { 17 17 + repo: { 18 18 + createRecord: vi.fn(), 19 19 + listRecords: vi.fn(), 20 20 + getRecord: vi.fn(), 21 21 + putRecord: vi.fn(), 22 22 + deleteRecord: vi.fn(), 23 23 + }, 24 24 + }, 25 25 + }, 26 26 + }; 27 27 28 28 - return { 29 29 - isAuthenticated: vi.fn(async () => authenticated), 30 30 - getSession: vi.fn(() => 31 31 - authenticated 32 32 - ? { did: 'did:plc:test123', handle: 'test.bsky.social' } 33 33 - : null, 34 34 - ), 35 35 - getAgent: vi.fn(() => mockAgent), 36 36 - } as unknown as TangledApiClient; 28 28 + return { 29 29 + isAuthenticated: vi.fn(async () => authenticated), 30 30 + getSession: vi.fn(() => 31 31 + authenticated ? { did: 'did:plc:test123', handle: 'test.bsky.social' } : null 32 32 + ), 33 33 + getAgent: vi.fn(() => mockAgent), 34 34 + } as unknown as TangledApiClient; 37 35 }; 38 36 39 37 describe('createIssue', () => { 40 40 - let mockClient: TangledApiClient; 38 38 + let mockClient: TangledApiClient; 41 39 42 42 - beforeEach(() => { 43 43 - mockClient = createMockClient(true); 44 44 - }); 40 40 + beforeEach(() => { 41 41 + mockClient = createMockClient(true); 42 42 + }); 45 43 46 46 - it('should create an issue with all fields', async () => { 47 47 - const mockCreateRecord = vi.fn().mockResolvedValue({ 48 48 - data: { 49 49 - uri: 'at://did:plc:test123/sh.tangled.repo.issue/abc123', 50 50 - cid: 'cid123', 51 51 - }, 52 52 - }); 44 44 + it('should create an issue with all fields', async () => { 45 45 + const mockCreateRecord = vi.fn().mockResolvedValue({ 46 46 + data: { 47 47 + uri: 'at://did:plc:test123/sh.tangled.repo.issue/abc123', 48 48 + cid: 'cid123', 49 49 + }, 50 50 + }); 53 51 54 54 - vi.mocked(mockClient.getAgent).mockReturnValue({ 55 55 - com: { 56 56 - atproto: { 57 57 - repo: { 58 58 - createRecord: mockCreateRecord, 59 59 - }, 60 60 - }, 61 61 - }, 62 62 - } as never); 52 52 + vi.mocked(mockClient.getAgent).mockReturnValue({ 53 53 + com: { 54 54 + atproto: { 55 55 + repo: { 56 56 + createRecord: mockCreateRecord, 57 57 + }, 58 58 + }, 59 59 + }, 60 60 + } as never); 63 61 64 64 - const result = await createIssue({ 65 65 - client: mockClient, 66 66 - repoAtUri: 'at://did:plc:owner/sh.tangled.repo/my-repo', 67 67 - title: 'Bug: Login fails', 68 68 - body: 'Detailed description of the bug', 69 69 - }); 62 62 + const result = await createIssue({ 63 63 + client: mockClient, 64 64 + repoAtUri: 'at://did:plc:owner/sh.tangled.repo/my-repo', 65 65 + title: 'Bug: Login fails', 66 66 + body: 'Detailed description of the bug', 67 67 + }); 70 68 71 71 - expect(result).toMatchObject({ 72 72 - repo: 'at://did:plc:owner/sh.tangled.repo/my-repo', 73 73 - title: 'Bug: Login fails', 74 74 - body: 'Detailed description of the bug', 75 75 - uri: 'at://did:plc:test123/sh.tangled.repo.issue/abc123', 76 76 - cid: 'cid123', 77 77 - author: 'did:plc:test123', 78 78 - }); 69 69 + expect(result).toMatchObject({ 70 70 + repo: 'at://did:plc:owner/sh.tangled.repo/my-repo', 71 71 + title: 'Bug: Login fails', 72 72 + body: 'Detailed description of the bug', 73 73 + uri: 'at://did:plc:test123/sh.tangled.repo.issue/abc123', 74 74 + cid: 'cid123', 75 75 + author: 'did:plc:test123', 76 76 + }); 79 77 80 80 - expect(mockCreateRecord).toHaveBeenCalledWith({ 81 81 - repo: 'did:plc:test123', 82 82 - collection: 'sh.tangled.repo.issue', 83 83 - record: expect.objectContaining({ 84 84 - $type: 'sh.tangled.repo.issue', 85 85 - repo: 'at://did:plc:owner/sh.tangled.repo/my-repo', 86 86 - title: 'Bug: Login fails', 87 87 - body: 'Detailed description of the bug', 88 88 - createdAt: expect.any(String), 89 89 - }), 90 90 - }); 91 91 - }); 78 78 + expect(mockCreateRecord).toHaveBeenCalledWith({ 79 79 + repo: 'did:plc:test123', 80 80 + collection: 'sh.tangled.repo.issue', 81 81 + record: expect.objectContaining({ 82 82 + $type: 'sh.tangled.repo.issue', 83 83 + repo: 'at://did:plc:owner/sh.tangled.repo/my-repo', 84 84 + title: 'Bug: Login fails', 85 85 + body: 'Detailed description of the bug', 86 86 + createdAt: expect.any(String), 87 87 + }), 88 88 + }); 89 89 + }); 92 90 93 93 - it('should create an issue without body', async () => { 94 94 - const mockCreateRecord = vi.fn().mockResolvedValue({ 95 95 - data: { 96 96 - uri: 'at://did:plc:test123/sh.tangled.repo.issue/abc123', 97 97 - cid: 'cid123', 98 98 - }, 99 99 - }); 91 91 + it('should create an issue without body', async () => { 92 92 + const mockCreateRecord = vi.fn().mockResolvedValue({ 93 93 + data: { 94 94 + uri: 'at://did:plc:test123/sh.tangled.repo.issue/abc123', 95 95 + cid: 'cid123', 96 96 + }, 97 97 + }); 100 98 101 101 - vi.mocked(mockClient.getAgent).mockReturnValue({ 102 102 - com: { 103 103 - atproto: { 104 104 - repo: { 105 105 - createRecord: mockCreateRecord, 106 106 - }, 107 107 - }, 108 108 - }, 109 109 - } as never); 99 99 + vi.mocked(mockClient.getAgent).mockReturnValue({ 100 100 + com: { 101 101 + atproto: { 102 102 + repo: { 103 103 + createRecord: mockCreateRecord, 104 104 + }, 105 105 + }, 106 106 + }, 107 107 + } as never); 110 108 111 111 - const result = await createIssue({ 112 112 - client: mockClient, 113 113 - repoAtUri: 'at://did:plc:owner/sh.tangled.repo/my-repo', 114 114 - title: 'Simple issue', 115 115 - }); 109 109 + const result = await createIssue({ 110 110 + client: mockClient, 111 111 + repoAtUri: 'at://did:plc:owner/sh.tangled.repo/my-repo', 112 112 + title: 'Simple issue', 113 113 + }); 116 114 117 117 - expect(result.body).toBeUndefined(); 118 118 - expect(mockCreateRecord).toHaveBeenCalled(); 119 119 - }); 115 115 + expect(result.body).toBeUndefined(); 116 116 + expect(mockCreateRecord).toHaveBeenCalled(); 117 117 + }); 120 118 121 121 - it('should throw error when not authenticated', async () => { 122 122 - mockClient = createMockClient(false); 119 119 + it('should throw error when not authenticated', async () => { 120 120 + mockClient = createMockClient(false); 123 121 124 124 - await expect( 125 125 - createIssue({ 126 126 - client: mockClient, 127 127 - repoAtUri: 'at://did:plc:owner/sh.tangled.repo/my-repo', 128 128 - title: 'Test', 129 129 - }), 130 130 - ).rejects.toThrow('Must be authenticated'); 131 131 - }); 122 122 + await expect( 123 123 + createIssue({ 124 124 + client: mockClient, 125 125 + repoAtUri: 'at://did:plc:owner/sh.tangled.repo/my-repo', 126 126 + title: 'Test', 127 127 + }) 128 128 + ).rejects.toThrow('Must be authenticated'); 129 129 + }); 132 130 133 133 - it('should throw error on API failure', async () => { 134 134 - const mockCreateRecord = vi 135 135 - .fn() 136 136 - .mockRejectedValue(new Error('API error')); 131 131 + it('should throw error on API failure', async () => { 132 132 + const mockCreateRecord = vi.fn().mockRejectedValue(new Error('API error')); 137 133 138 138 - vi.mocked(mockClient.getAgent).mockReturnValue({ 139 139 - com: { 140 140 - atproto: { 141 141 - repo: { 142 142 - createRecord: mockCreateRecord, 143 143 - }, 144 144 - }, 145 145 - }, 146 146 - } as never); 134 134 + vi.mocked(mockClient.getAgent).mockReturnValue({ 135 135 + com: { 136 136 + atproto: { 137 137 + repo: { 138 138 + createRecord: mockCreateRecord, 139 139 + }, 140 140 + }, 141 141 + }, 142 142 + } as never); 147 143 148 148 - await expect( 149 149 - createIssue({ 150 150 - client: mockClient, 151 151 - repoAtUri: 'at://did:plc:owner/sh.tangled.repo/my-repo', 152 152 - title: 'Test', 153 153 - }), 154 154 - ).rejects.toThrow('Failed to create issue: API error'); 155 155 - }); 144 144 + await expect( 145 145 + createIssue({ 146 146 + client: mockClient, 147 147 + repoAtUri: 'at://did:plc:owner/sh.tangled.repo/my-repo', 148 148 + title: 'Test', 149 149 + }) 150 150 + ).rejects.toThrow('Failed to create issue: API error'); 151 151 + }); 156 152 }); 157 153 158 154 describe('listIssues', () => { 159 159 - let mockClient: TangledApiClient; 155 155 + let mockClient: TangledApiClient; 160 156 161 161 - beforeEach(() => { 162 162 - mockClient = createMockClient(true); 163 163 - }); 157 157 + beforeEach(() => { 158 158 + mockClient = createMockClient(true); 159 159 + }); 164 160 165 165 - it('should list issues for a repository', async () => { 166 166 - const mockListRecords = vi.fn().mockResolvedValue({ 167 167 - data: { 168 168 - records: [ 169 169 - { 170 170 - uri: 'at://did:plc:owner/sh.tangled.repo.issue/issue1', 171 171 - cid: 'cid1', 172 172 - value: { 173 173 - $type: 'sh.tangled.repo.issue', 174 174 - repo: 'at://did:plc:owner/sh.tangled.repo/my-repo', 175 175 - title: 'Issue 1', 176 176 - body: 'Description 1', 177 177 - createdAt: '2024-01-01T00:00:00.000Z', 178 178 - }, 179 179 - }, 180 180 - { 181 181 - uri: 'at://did:plc:owner/sh.tangled.repo.issue/issue2', 182 182 - cid: 'cid2', 183 183 - value: { 184 184 - $type: 'sh.tangled.repo.issue', 185 185 - repo: 'at://did:plc:owner/sh.tangled.repo/my-repo', 186 186 - title: 'Issue 2', 187 187 - createdAt: '2024-01-02T00:00:00.000Z', 188 188 - }, 189 189 - }, 190 190 - ], 191 191 - cursor: undefined, 192 192 - }, 193 193 - }); 161 161 + it('should list issues for a repository', async () => { 162 162 + const mockListRecords = vi.fn().mockResolvedValue({ 163 163 + data: { 164 164 + records: [ 165 165 + { 166 166 + uri: 'at://did:plc:owner/sh.tangled.repo.issue/issue1', 167 167 + cid: 'cid1', 168 168 + value: { 169 169 + $type: 'sh.tangled.repo.issue', 170 170 + repo: 'at://did:plc:owner/sh.tangled.repo/my-repo', 171 171 + title: 'Issue 1', 172 172 + body: 'Description 1', 173 173 + createdAt: '2024-01-01T00:00:00.000Z', 174 174 + }, 175 175 + }, 176 176 + { 177 177 + uri: 'at://did:plc:owner/sh.tangled.repo.issue/issue2', 178 178 + cid: 'cid2', 179 179 + value: { 180 180 + $type: 'sh.tangled.repo.issue', 181 181 + repo: 'at://did:plc:owner/sh.tangled.repo/my-repo', 182 182 + title: 'Issue 2', 183 183 + createdAt: '2024-01-02T00:00:00.000Z', 184 184 + }, 185 185 + }, 186 186 + ], 187 187 + cursor: undefined, 188 188 + }, 189 189 + }); 194 190 195 195 - vi.mocked(mockClient.getAgent).mockReturnValue({ 196 196 - com: { 197 197 - atproto: { 198 198 - repo: { 199 199 - listRecords: mockListRecords, 200 200 - }, 201 201 - }, 202 202 - }, 203 203 - } as never); 191 191 + vi.mocked(mockClient.getAgent).mockReturnValue({ 192 192 + com: { 193 193 + atproto: { 194 194 + repo: { 195 195 + listRecords: mockListRecords, 196 196 + }, 197 197 + }, 198 198 + }, 199 199 + } as never); 204 200 205 205 - const result = await listIssues({ 206 206 - client: mockClient, 207 207 - repoAtUri: 'at://did:plc:owner/sh.tangled.repo/my-repo', 208 208 - }); 201 201 + const result = await listIssues({ 202 202 + client: mockClient, 203 203 + repoAtUri: 'at://did:plc:owner/sh.tangled.repo/my-repo', 204 204 + }); 209 205 210 210 - expect(result.issues).toHaveLength(2); 211 211 - expect(result.issues[0]).toMatchObject({ 212 212 - title: 'Issue 1', 213 213 - body: 'Description 1', 214 214 - uri: 'at://did:plc:owner/sh.tangled.repo.issue/issue1', 215 215 - }); 216 216 - }); 206 206 + expect(result.issues).toHaveLength(2); 207 207 + expect(result.issues[0]).toMatchObject({ 208 208 + title: 'Issue 1', 209 209 + body: 'Description 1', 210 210 + uri: 'at://did:plc:owner/sh.tangled.repo.issue/issue1', 211 211 + }); 212 212 + }); 217 213 218 218 - it('should filter issues by repository', async () => { 219 219 - const mockListRecords = vi.fn().mockResolvedValue({ 220 220 - data: { 221 221 - records: [ 222 222 - { 223 223 - uri: 'at://did:plc:owner/sh.tangled.repo.issue/issue1', 224 224 - cid: 'cid1', 225 225 - value: { 226 226 - repo: 'at://did:plc:owner/sh.tangled.repo/my-repo', 227 227 - title: 'Issue 1', 228 228 - createdAt: '2024-01-01T00:00:00.000Z', 229 229 - }, 230 230 - }, 231 231 - { 232 232 - uri: 'at://did:plc:owner/sh.tangled.repo.issue/issue2', 233 233 - cid: 'cid2', 234 234 - value: { 235 235 - repo: 'at://did:plc:owner/sh.tangled.repo/other-repo', 236 236 - title: 'Issue 2', 237 237 - createdAt: '2024-01-02T00:00:00.000Z', 238 238 - }, 239 239 - }, 240 240 - ], 241 241 - cursor: undefined, 242 242 - }, 243 243 - }); 214 214 + it('should filter issues by repository', async () => { 215 215 + const mockListRecords = vi.fn().mockResolvedValue({ 216 216 + data: { 217 217 + records: [ 218 218 + { 219 219 + uri: 'at://did:plc:owner/sh.tangled.repo.issue/issue1', 220 220 + cid: 'cid1', 221 221 + value: { 222 222 + repo: 'at://did:plc:owner/sh.tangled.repo/my-repo', 223 223 + title: 'Issue 1', 224 224 + createdAt: '2024-01-01T00:00:00.000Z', 225 225 + }, 226 226 + }, 227 227 + { 228 228 + uri: 'at://did:plc:owner/sh.tangled.repo.issue/issue2', 229 229 + cid: 'cid2', 230 230 + value: { 231 231 + repo: 'at://did:plc:owner/sh.tangled.repo/other-repo', 232 232 + title: 'Issue 2', 233 233 + createdAt: '2024-01-02T00:00:00.000Z', 234 234 + }, 235 235 + }, 236 236 + ], 237 237 + cursor: undefined, 238 238 + }, 239 239 + }); 244 240 245 245 - vi.mocked(mockClient.getAgent).mockReturnValue({ 246 246 - com: { 247 247 - atproto: { 248 248 - repo: { 249 249 - listRecords: mockListRecords, 250 250 - }, 251 251 - }, 252 252 - }, 253 253 - } as never); 241 241 + vi.mocked(mockClient.getAgent).mockReturnValue({ 242 242 + com: { 243 243 + atproto: { 244 244 + repo: { 245 245 + listRecords: mockListRecords, 246 246 + }, 247 247 + }, 248 248 + }, 249 249 + } as never); 254 250 255 255 - const result = await listIssues({ 256 256 - client: mockClient, 257 257 - repoAtUri: 'at://did:plc:owner/sh.tangled.repo/my-repo', 258 258 - }); 251 251 + const result = await listIssues({ 252 252 + client: mockClient, 253 253 + repoAtUri: 'at://did:plc:owner/sh.tangled.repo/my-repo', 254 254 + }); 259 255 260 260 - // Should only include issue from my-repo, not other-repo 261 261 - expect(result.issues).toHaveLength(1); 262 262 - expect(result.issues[0].title).toBe('Issue 1'); 263 263 - }); 256 256 + // Should only include issue from my-repo, not other-repo 257 257 + expect(result.issues).toHaveLength(1); 258 258 + expect(result.issues[0].title).toBe('Issue 1'); 259 259 + }); 264 260 265 265 - it('should return empty array when no issues found', async () => { 266 266 - const mockListRecords = vi.fn().mockResolvedValue({ 267 267 - data: { 268 268 - records: [], 269 269 - cursor: undefined, 270 270 - }, 271 271 - }); 261 261 + it('should return empty array when no issues found', async () => { 262 262 + const mockListRecords = vi.fn().mockResolvedValue({ 263 263 + data: { 264 264 + records: [], 265 265 + cursor: undefined, 266 266 + }, 267 267 + }); 272 268 273 273 - vi.mocked(mockClient.getAgent).mockReturnValue({ 274 274 - com: { 275 275 - atproto: { 276 276 - repo: { 277 277 - listRecords: mockListRecords, 278 278 - }, 279 279 - }, 280 280 - }, 281 281 - } as never); 269 269 + vi.mocked(mockClient.getAgent).mockReturnValue({ 270 270 + com: { 271 271 + atproto: { 272 272 + repo: { 273 273 + listRecords: mockListRecords, 274 274 + }, 275 275 + }, 276 276 + }, 277 277 + } as never); 282 278 283 283 - const result = await listIssues({ 284 284 - client: mockClient, 285 285 - repoAtUri: 'at://did:plc:owner/sh.tangled.repo/my-repo', 286 286 - }); 279 279 + const result = await listIssues({ 280 280 + client: mockClient, 281 281 + repoAtUri: 'at://did:plc:owner/sh.tangled.repo/my-repo', 282 282 + }); 287 283 288 288 - expect(result.issues).toEqual([]); 289 289 - }); 284 284 + expect(result.issues).toEqual([]); 285 285 + }); 290 286 291 291 - it('should throw error when not authenticated', async () => { 292 292 - mockClient = createMockClient(false); 287 287 + it('should throw error when not authenticated', async () => { 288 288 + mockClient = createMockClient(false); 293 289 294 294 - await expect( 295 295 - listIssues({ 296 296 - client: mockClient, 297 297 - repoAtUri: 'at://did:plc:owner/sh.tangled.repo/my-repo', 298 298 - }), 299 299 - ).rejects.toThrow('Must be authenticated'); 300 300 - }); 290 290 + await expect( 291 291 + listIssues({ 292 292 + client: mockClient, 293 293 + repoAtUri: 'at://did:plc:owner/sh.tangled.repo/my-repo', 294 294 + }) 295 295 + ).rejects.toThrow('Must be authenticated'); 296 296 + }); 301 297 302 302 - it('should throw error for invalid repo URI', async () => { 303 303 - await expect( 304 304 - listIssues({ 305 305 - client: mockClient, 306 306 - repoAtUri: 'invalid-uri', 307 307 - }), 308 308 - ).rejects.toThrow('Invalid repository AT-URI'); 309 309 - }); 298 298 + it('should throw error for invalid repo URI', async () => { 299 299 + await expect( 300 300 + listIssues({ 301 301 + client: mockClient, 302 302 + repoAtUri: 'invalid-uri', 303 303 + }) 304 304 + ).rejects.toThrow('Invalid repository AT-URI'); 305 305 + }); 310 306 }); 311 307 312 308 describe('getIssue', () => { 313 313 - let mockClient: TangledApiClient; 309 309 + let mockClient: TangledApiClient; 314 310 315 315 - beforeEach(() => { 316 316 - mockClient = createMockClient(true); 317 317 - }); 311 311 + beforeEach(() => { 312 312 + mockClient = createMockClient(true); 313 313 + }); 318 314 319 319 - it('should get a specific issue', async () => { 320 320 - const mockGetRecord = vi.fn().mockResolvedValue({ 321 321 - data: { 322 322 - uri: 'at://did:plc:owner/sh.tangled.repo.issue/issue1', 323 323 - cid: 'cid1', 324 324 - value: { 325 325 - $type: 'sh.tangled.repo.issue', 326 326 - repo: 'at://did:plc:owner/sh.tangled.repo/my-repo', 327 327 - title: 'Test Issue', 328 328 - body: 'Test Description', 329 329 - createdAt: '2024-01-01T00:00:00.000Z', 330 330 - }, 331 331 - }, 332 332 - }); 315 315 + it('should get a specific issue', async () => { 316 316 + const mockGetRecord = vi.fn().mockResolvedValue({ 317 317 + data: { 318 318 + uri: 'at://did:plc:owner/sh.tangled.repo.issue/issue1', 319 319 + cid: 'cid1', 320 320 + value: { 321 321 + $type: 'sh.tangled.repo.issue', 322 322 + repo: 'at://did:plc:owner/sh.tangled.repo/my-repo', 323 323 + title: 'Test Issue', 324 324 + body: 'Test Description', 325 325 + createdAt: '2024-01-01T00:00:00.000Z', 326 326 + }, 327 327 + }, 328 328 + }); 333 329 334 334 - vi.mocked(mockClient.getAgent).mockReturnValue({ 335 335 - com: { 336 336 - atproto: { 337 337 - repo: { 338 338 - getRecord: mockGetRecord, 339 339 - }, 340 340 - }, 341 341 - }, 342 342 - } as never); 330 330 + vi.mocked(mockClient.getAgent).mockReturnValue({ 331 331 + com: { 332 332 + atproto: { 333 333 + repo: { 334 334 + getRecord: mockGetRecord, 335 335 + }, 336 336 + }, 337 337 + }, 338 338 + } as never); 343 339 344 344 - const result = await getIssue({ 345 345 - client: mockClient, 346 346 - issueUri: 'at://did:plc:owner/sh.tangled.repo.issue/issue1', 347 347 - }); 340 340 + const result = await getIssue({ 341 341 + client: mockClient, 342 342 + issueUri: 'at://did:plc:owner/sh.tangled.repo.issue/issue1', 343 343 + }); 348 344 349 349 - expect(result).toMatchObject({ 350 350 - title: 'Test Issue', 351 351 - body: 'Test Description', 352 352 - uri: 'at://did:plc:owner/sh.tangled.repo.issue/issue1', 353 353 - cid: 'cid1', 354 354 - }); 345 345 + expect(result).toMatchObject({ 346 346 + title: 'Test Issue', 347 347 + body: 'Test Description', 348 348 + uri: 'at://did:plc:owner/sh.tangled.repo.issue/issue1', 349 349 + cid: 'cid1', 350 350 + }); 355 351 356 356 - expect(mockGetRecord).toHaveBeenCalledWith({ 357 357 - repo: 'did:plc:owner', 358 358 - collection: 'sh.tangled.repo.issue', 359 359 - rkey: 'issue1', 360 360 - }); 361 361 - }); 352 352 + expect(mockGetRecord).toHaveBeenCalledWith({ 353 353 + repo: 'did:plc:owner', 354 354 + collection: 'sh.tangled.repo.issue', 355 355 + rkey: 'issue1', 356 356 + }); 357 357 + }); 362 358 363 363 - it('should throw error when issue not found', async () => { 364 364 - const mockGetRecord = vi 365 365 - .fn() 366 366 - .mockRejectedValue(new Error('Record not found')); 359 359 + it('should throw error when issue not found', async () => { 360 360 + const mockGetRecord = vi.fn().mockRejectedValue(new Error('Record not found')); 367 361 368 368 - vi.mocked(mockClient.getAgent).mockReturnValue({ 369 369 - com: { 370 370 - atproto: { 371 371 - repo: { 372 372 - getRecord: mockGetRecord, 373 373 - }, 374 374 - }, 375 375 - }, 376 376 - } as never); 362 362 + vi.mocked(mockClient.getAgent).mockReturnValue({ 363 363 + com: { 364 364 + atproto: { 365 365 + repo: { 366 366 + getRecord: mockGetRecord, 367 367 + }, 368 368 + }, 369 369 + }, 370 370 + } as never); 377 371 378 378 - await expect( 379 379 - getIssue({ 380 380 - client: mockClient, 381 381 - issueUri: 'at://did:plc:owner/sh.tangled.repo.issue/nonexistent', 382 382 - }), 383 383 - ).rejects.toThrow('Issue not found'); 384 384 - }); 372 372 + await expect( 373 373 + getIssue({ 374 374 + client: mockClient, 375 375 + issueUri: 'at://did:plc:owner/sh.tangled.repo.issue/nonexistent', 376 376 + }) 377 377 + ).rejects.toThrow('Issue not found'); 378 378 + }); 385 379 386 386 - it('should throw error for invalid issue URI', async () => { 387 387 - await expect( 388 388 - getIssue({ 389 389 - client: mockClient, 390 390 - issueUri: 'invalid-uri', 391 391 - }), 392 392 - ).rejects.toThrow('Invalid issue AT-URI'); 393 393 - }); 380 380 + it('should throw error for invalid issue URI', async () => { 381 381 + await expect( 382 382 + getIssue({ 383 383 + client: mockClient, 384 384 + issueUri: 'invalid-uri', 385 385 + }) 386 386 + ).rejects.toThrow('Invalid issue AT-URI'); 387 387 + }); 394 388 395 395 - it('should throw error when not authenticated', async () => { 396 396 - mockClient = createMockClient(false); 389 389 + it('should throw error when not authenticated', async () => { 390 390 + mockClient = createMockClient(false); 397 391 398 398 - await expect( 399 399 - getIssue({ 400 400 - client: mockClient, 401 401 - issueUri: 'at://did:plc:owner/sh.tangled.repo.issue/issue1', 402 402 - }), 403 403 - ).rejects.toThrow('Must be authenticated'); 404 404 - }); 392 392 + await expect( 393 393 + getIssue({ 394 394 + client: mockClient, 395 395 + issueUri: 'at://did:plc:owner/sh.tangled.repo.issue/issue1', 396 396 + }) 397 397 + ).rejects.toThrow('Must be authenticated'); 398 398 + }); 405 399 }); 406 400 407 401 describe('updateIssue', () => { 408 408 - let mockClient: TangledApiClient; 402 402 + let mockClient: TangledApiClient; 409 403 410 410 - beforeEach(() => { 411 411 - mockClient = createMockClient(true); 412 412 - }); 404 404 + beforeEach(() => { 405 405 + mockClient = createMockClient(true); 406 406 + }); 413 407 414 414 - it('should update issue title', async () => { 415 415 - const mockGetRecord = vi.fn().mockResolvedValue({ 416 416 - data: { 417 417 - uri: 'at://did:plc:test123/sh.tangled.repo.issue/issue1', 418 418 - cid: 'old-cid', 419 419 - value: { 420 420 - repo: 'at://did:plc:test123/sh.tangled.repo/my-repo', 421 421 - title: 'Old Title', 422 422 - body: 'Original body', 423 423 - createdAt: '2024-01-01T00:00:00.000Z', 424 424 - }, 425 425 - }, 426 426 - }); 408 408 + it('should update issue title', async () => { 409 409 + const mockGetRecord = vi.fn().mockResolvedValue({ 410 410 + data: { 411 411 + uri: 'at://did:plc:test123/sh.tangled.repo.issue/issue1', 412 412 + cid: 'old-cid', 413 413 + value: { 414 414 + repo: 'at://did:plc:test123/sh.tangled.repo/my-repo', 415 415 + title: 'Old Title', 416 416 + body: 'Original body', 417 417 + createdAt: '2024-01-01T00:00:00.000Z', 418 418 + }, 419 419 + }, 420 420 + }); 427 421 428 428 - const mockPutRecord = vi.fn().mockResolvedValue({ 429 429 - data: { 430 430 - uri: 'at://did:plc:test123/sh.tangled.repo.issue/issue1', 431 431 - cid: 'new-cid', 432 432 - }, 433 433 - }); 422 422 + const mockPutRecord = vi.fn().mockResolvedValue({ 423 423 + data: { 424 424 + uri: 'at://did:plc:test123/sh.tangled.repo.issue/issue1', 425 425 + cid: 'new-cid', 426 426 + }, 427 427 + }); 434 428 435 435 - vi.mocked(mockClient.getAgent).mockReturnValue({ 436 436 - com: { 437 437 - atproto: { 438 438 - repo: { 439 439 - getRecord: mockGetRecord, 440 440 - putRecord: mockPutRecord, 441 441 - }, 442 442 - }, 443 443 - }, 444 444 - } as never); 429 429 + vi.mocked(mockClient.getAgent).mockReturnValue({ 430 430 + com: { 431 431 + atproto: { 432 432 + repo: { 433 433 + getRecord: mockGetRecord, 434 434 + putRecord: mockPutRecord, 435 435 + }, 436 436 + }, 437 437 + }, 438 438 + } as never); 445 439 446 446 - const result = await updateIssue({ 447 447 - client: mockClient, 448 448 - issueUri: 'at://did:plc:test123/sh.tangled.repo.issue/issue1', 449 449 - title: 'New Title', 450 450 - }); 440 440 + const result = await updateIssue({ 441 441 + client: mockClient, 442 442 + issueUri: 'at://did:plc:test123/sh.tangled.repo.issue/issue1', 443 443 + title: 'New Title', 444 444 + }); 451 445 452 452 - expect(result.title).toBe('New Title'); 453 453 - expect(result.body).toBe('Original body'); // Body unchanged 446 446 + expect(result.title).toBe('New Title'); 447 447 + expect(result.body).toBe('Original body'); // Body unchanged 454 448 455 455 - expect(mockPutRecord).toHaveBeenCalledWith({ 456 456 - repo: 'did:plc:test123', 457 457 - collection: 'sh.tangled.repo.issue', 458 458 - rkey: 'issue1', 459 459 - record: expect.objectContaining({ 460 460 - title: 'New Title', 461 461 - body: 'Original body', 462 462 - }), 463 463 - swapRecord: 'old-cid', 464 464 - }); 465 465 - }); 449 449 + expect(mockPutRecord).toHaveBeenCalledWith({ 450 450 + repo: 'did:plc:test123', 451 451 + collection: 'sh.tangled.repo.issue', 452 452 + rkey: 'issue1', 453 453 + record: expect.objectContaining({ 454 454 + title: 'New Title', 455 455 + body: 'Original body', 456 456 + }), 457 457 + swapRecord: 'old-cid', 458 458 + }); 459 459 + }); 466 460 467 467 - it('should update issue body', async () => { 468 468 - const mockGetRecord = vi.fn().mockResolvedValue({ 469 469 - data: { 470 470 - uri: 'at://did:plc:test123/sh.tangled.repo.issue/issue1', 471 471 - cid: 'old-cid', 472 472 - value: { 473 473 - repo: 'at://did:plc:test123/sh.tangled.repo/my-repo', 474 474 - title: 'Title', 475 475 - body: 'Old body', 476 476 - createdAt: '2024-01-01T00:00:00.000Z', 477 477 - }, 478 478 - }, 479 479 - }); 461 461 + it('should update issue body', async () => { 462 462 + const mockGetRecord = vi.fn().mockResolvedValue({ 463 463 + data: { 464 464 + uri: 'at://did:plc:test123/sh.tangled.repo.issue/issue1', 465 465 + cid: 'old-cid', 466 466 + value: { 467 467 + repo: 'at://did:plc:test123/sh.tangled.repo/my-repo', 468 468 + title: 'Title', 469 469 + body: 'Old body', 470 470 + createdAt: '2024-01-01T00:00:00.000Z', 471 471 + }, 472 472 + }, 473 473 + }); 480 474 481 481 - const mockPutRecord = vi.fn().mockResolvedValue({ 482 482 - data: { 483 483 - cid: 'new-cid', 484 484 - }, 485 485 - }); 475 475 + const mockPutRecord = vi.fn().mockResolvedValue({ 476 476 + data: { 477 477 + cid: 'new-cid', 478 478 + }, 479 479 + }); 486 480 487 487 - vi.mocked(mockClient.getAgent).mockReturnValue({ 488 488 - com: { 489 489 - atproto: { 490 490 - repo: { 491 491 - getRecord: mockGetRecord, 492 492 - putRecord: mockPutRecord, 493 493 - }, 494 494 - }, 495 495 - }, 496 496 - } as never); 481 481 + vi.mocked(mockClient.getAgent).mockReturnValue({ 482 482 + com: { 483 483 + atproto: { 484 484 + repo: { 485 485 + getRecord: mockGetRecord, 486 486 + putRecord: mockPutRecord, 487 487 + }, 488 488 + }, 489 489 + }, 490 490 + } as never); 497 491 498 498 - const result = await updateIssue({ 499 499 - client: mockClient, 500 500 - issueUri: 'at://did:plc:test123/sh.tangled.repo.issue/issue1', 501 501 - body: 'New body', 502 502 - }); 492 492 + const result = await updateIssue({ 493 493 + client: mockClient, 494 494 + issueUri: 'at://did:plc:test123/sh.tangled.repo.issue/issue1', 495 495 + body: 'New body', 496 496 + }); 503 497 504 504 - expect(result.title).toBe('Title'); // Title unchanged 505 505 - expect(result.body).toBe('New body'); 506 506 - }); 498 498 + expect(result.title).toBe('Title'); // Title unchanged 499 499 + expect(result.body).toBe('New body'); 500 500 + }); 507 501 508 508 - it('should throw error when updating issue not owned by user', async () => { 509 509 - await expect( 510 510 - updateIssue({ 511 511 - client: mockClient, 512 512 - issueUri: 'at://did:plc:someone-else/sh.tangled.repo.issue/issue1', 513 513 - title: 'New Title', 514 514 - }), 515 515 - ).rejects.toThrow('Cannot update issue: you are not the author'); 516 516 - }); 502 502 + it('should throw error when updating issue not owned by user', async () => { 503 503 + await expect( 504 504 + updateIssue({ 505 505 + client: mockClient, 506 506 + issueUri: 'at://did:plc:someone-else/sh.tangled.repo.issue/issue1', 507 507 + title: 'New Title', 508 508 + }) 509 509 + ).rejects.toThrow('Cannot update issue: you are not the author'); 510 510 + }); 517 511 518 518 - it('should throw error when not authenticated', async () => { 519 519 - mockClient = createMockClient(false); 512 512 + it('should throw error when not authenticated', async () => { 513 513 + mockClient = createMockClient(false); 520 514 521 521 - await expect( 522 522 - updateIssue({ 523 523 - client: mockClient, 524 524 - issueUri: 'at://did:plc:test123/sh.tangled.repo.issue/issue1', 525 525 - title: 'New Title', 526 526 - }), 527 527 - ).rejects.toThrow('Must be authenticated'); 528 528 - }); 515 515 + await expect( 516 516 + updateIssue({ 517 517 + client: mockClient, 518 518 + issueUri: 'at://did:plc:test123/sh.tangled.repo.issue/issue1', 519 519 + title: 'New Title', 520 520 + }) 521 521 + ).rejects.toThrow('Must be authenticated'); 522 522 + }); 529 523 }); 530 524 531 525 describe('closeIssue', () => { 532 532 - let mockClient: TangledApiClient; 526 526 + let mockClient: TangledApiClient; 533 527 534 534 - beforeEach(() => { 535 535 - mockClient = createMockClient(true); 536 536 - }); 528 528 + beforeEach(() => { 529 529 + mockClient = createMockClient(true); 530 530 + }); 537 531 538 538 - it('should close an issue', async () => { 539 539 - const mockGetRecord = vi.fn().mockResolvedValue({ 540 540 - data: { 541 541 - uri: 'at://did:plc:owner/sh.tangled.repo.issue/issue1', 542 542 - cid: 'cid1', 543 543 - value: { 544 544 - repo: 'at://did:plc:owner/sh.tangled.repo/my-repo', 545 545 - title: 'Test Issue', 546 546 - createdAt: '2024-01-01T00:00:00.000Z', 547 547 - }, 548 548 - }, 549 549 - }); 532 532 + it('should close an issue', async () => { 533 533 + const mockGetRecord = vi.fn().mockResolvedValue({ 534 534 + data: { 535 535 + uri: 'at://did:plc:owner/sh.tangled.repo.issue/issue1', 536 536 + cid: 'cid1', 537 537 + value: { 538 538 + repo: 'at://did:plc:owner/sh.tangled.repo/my-repo', 539 539 + title: 'Test Issue', 540 540 + createdAt: '2024-01-01T00:00:00.000Z', 541 541 + }, 542 542 + }, 543 543 + }); 550 544 551 551 - const mockCreateRecord = vi.fn().mockResolvedValue({ 552 552 - data: { 553 553 - uri: 'at://did:plc:test123/sh.tangled.repo.issue.state/state1', 554 554 - cid: 'state-cid', 555 555 - }, 556 556 - }); 545 545 + const mockCreateRecord = vi.fn().mockResolvedValue({ 546 546 + data: { 547 547 + uri: 'at://did:plc:test123/sh.tangled.repo.issue.state/state1', 548 548 + cid: 'state-cid', 549 549 + }, 550 550 + }); 557 551 558 558 - vi.mocked(mockClient.getAgent).mockReturnValue({ 559 559 - com: { 560 560 - atproto: { 561 561 - repo: { 562 562 - getRecord: mockGetRecord, 563 563 - createRecord: mockCreateRecord, 564 564 - }, 565 565 - }, 566 566 - }, 567 567 - } as never); 552 552 + vi.mocked(mockClient.getAgent).mockReturnValue({ 553 553 + com: { 554 554 + atproto: { 555 555 + repo: { 556 556 + getRecord: mockGetRecord, 557 557 + createRecord: mockCreateRecord, 558 558 + }, 559 559 + }, 560 560 + }, 561 561 + } as never); 568 562 569 569 - await closeIssue({ 570 570 - client: mockClient, 571 571 - issueUri: 'at://did:plc:owner/sh.tangled.repo.issue/issue1', 572 572 - }); 563 563 + await closeIssue({ 564 564 + client: mockClient, 565 565 + issueUri: 'at://did:plc:owner/sh.tangled.repo.issue/issue1', 566 566 + }); 573 567 574 574 - expect(mockCreateRecord).toHaveBeenCalledWith({ 575 575 - repo: 'did:plc:test123', 576 576 - collection: 'sh.tangled.repo.issue.state', 577 577 - record: { 578 578 - $type: 'sh.tangled.repo.issue.state', 579 579 - issue: 'at://did:plc:owner/sh.tangled.repo.issue/issue1', 580 580 - state: 'sh.tangled.repo.issue.state.closed', 581 581 - }, 582 582 - }); 583 583 - }); 568 568 + expect(mockCreateRecord).toHaveBeenCalledWith({ 569 569 + repo: 'did:plc:test123', 570 570 + collection: 'sh.tangled.repo.issue.state', 571 571 + record: { 572 572 + $type: 'sh.tangled.repo.issue.state', 573 573 + issue: 'at://did:plc:owner/sh.tangled.repo.issue/issue1', 574 574 + state: 'sh.tangled.repo.issue.state.closed', 575 575 + }, 576 576 + }); 577 577 + }); 584 578 585 585 - it('should throw error when not authenticated', async () => { 586 586 - mockClient = createMockClient(false); 579 579 + it('should throw error when not authenticated', async () => { 580 580 + mockClient = createMockClient(false); 587 581 588 588 - await expect( 589 589 - closeIssue({ 590 590 - client: mockClient, 591 591 - issueUri: 'at://did:plc:owner/sh.tangled.repo.issue/issue1', 592 592 - }), 593 593 - ).rejects.toThrow('Must be authenticated'); 594 594 - }); 582 582 + await expect( 583 583 + closeIssue({ 584 584 + client: mockClient, 585 585 + issueUri: 'at://did:plc:owner/sh.tangled.repo.issue/issue1', 586 586 + }) 587 587 + ).rejects.toThrow('Must be authenticated'); 588 588 + }); 595 589 }); 596 590 597 591 describe('deleteIssue', () => { 598 598 - let mockClient: TangledApiClient; 592 592 + let mockClient: TangledApiClient; 599 593 600 600 - beforeEach(() => { 601 601 - mockClient = createMockClient(true); 602 602 - }); 594 594 + beforeEach(() => { 595 595 + mockClient = createMockClient(true); 596 596 + }); 603 597 604 604 - it('should delete an issue', async () => { 605 605 - const mockDeleteRecord = vi.fn().mockResolvedValue({}); 598 598 + it('should delete an issue', async () => { 599 599 + const mockDeleteRecord = vi.fn().mockResolvedValue({}); 606 600 607 607 - vi.mocked(mockClient.getAgent).mockReturnValue({ 608 608 - com: { 609 609 - atproto: { 610 610 - repo: { 611 611 - deleteRecord: mockDeleteRecord, 612 612 - }, 613 613 - }, 614 614 - }, 615 615 - } as never); 601 601 + vi.mocked(mockClient.getAgent).mockReturnValue({ 602 602 + com: { 603 603 + atproto: { 604 604 + repo: { 605 605 + deleteRecord: mockDeleteRecord, 606 606 + }, 607 607 + }, 608 608 + }, 609 609 + } as never); 616 610 617 617 - await deleteIssue({ 618 618 - client: mockClient, 619 619 - issueUri: 'at://did:plc:test123/sh.tangled.repo.issue/issue1', 620 620 - }); 611 611 + await deleteIssue({ 612 612 + client: mockClient, 613 613 + issueUri: 'at://did:plc:test123/sh.tangled.repo.issue/issue1', 614 614 + }); 621 615 622 622 - expect(mockDeleteRecord).toHaveBeenCalledWith({ 623 623 - repo: 'did:plc:test123', 624 624 - collection: 'sh.tangled.repo.issue', 625 625 - rkey: 'issue1', 626 626 - }); 627 627 - }); 616 616 + expect(mockDeleteRecord).toHaveBeenCalledWith({ 617 617 + repo: 'did:plc:test123', 618 618 + collection: 'sh.tangled.repo.issue', 619 619 + rkey: 'issue1', 620 620 + }); 621 621 + }); 628 622 629 629 - it('should throw error when deleting issue not owned by user', async () => { 630 630 - await expect( 631 631 - deleteIssue({ 632 632 - client: mockClient, 633 633 - issueUri: 'at://did:plc:someone-else/sh.tangled.repo.issue/issue1', 634 634 - }), 635 635 - ).rejects.toThrow('Cannot delete issue: you are not the author'); 636 636 - }); 623 623 + it('should throw error when deleting issue not owned by user', async () => { 624 624 + await expect( 625 625 + deleteIssue({ 626 626 + client: mockClient, 627 627 + issueUri: 'at://did:plc:someone-else/sh.tangled.repo.issue/issue1', 628 628 + }) 629 629 + ).rejects.toThrow('Cannot delete issue: you are not the author'); 630 630 + }); 637 631 638 638 - it('should throw error when issue not found', async () => { 639 639 - const mockDeleteRecord = vi 640 640 - .fn() 641 641 - .mockRejectedValue(new Error('Record not found')); 632 632 + it('should throw error when issue not found', async () => { 633 633 + const mockDeleteRecord = vi.fn().mockRejectedValue(new Error('Record not found')); 642 634 643 643 - vi.mocked(mockClient.getAgent).mockReturnValue({ 644 644 - com: { 645 645 - atproto: { 646 646 - repo: { 647 647 - deleteRecord: mockDeleteRecord, 648 648 - }, 649 649 - }, 650 650 - }, 651 651 - } as never); 635 635 + vi.mocked(mockClient.getAgent).mockReturnValue({ 636 636 + com: { 637 637 + atproto: { 638 638 + repo: { 639 639 + deleteRecord: mockDeleteRecord, 640 640 + }, 641 641 + }, 642 642 + }, 643 643 + } as never); 652 644 653 653 - await expect( 654 654 - deleteIssue({ 655 655 - client: mockClient, 656 656 - issueUri: 'at://did:plc:test123/sh.tangled.repo.issue/nonexistent', 657 657 - }), 658 658 - ).rejects.toThrow('Issue not found'); 659 659 - }); 645 645 + await expect( 646 646 + deleteIssue({ 647 647 + client: mockClient, 648 648 + issueUri: 'at://did:plc:test123/sh.tangled.repo.issue/nonexistent', 649 649 + }) 650 650 + ).rejects.toThrow('Issue not found'); 651 651 + }); 660 652 661 661 - it('should throw error when not authenticated', async () => { 662 662 - mockClient = createMockClient(false); 653 653 + it('should throw error when not authenticated', async () => { 654 654 + mockClient = createMockClient(false); 663 655 664 664 - await expect( 665 665 - deleteIssue({ 666 666 - client: mockClient, 667 667 - issueUri: 'at://did:plc:test123/sh.tangled.repo.issue/issue1', 668 668 - }), 669 669 - ).rejects.toThrow('Must be authenticated'); 670 670 - }); 656 656 + await expect( 657 657 + deleteIssue({ 658 658 + client: mockClient, 659 659 + issueUri: 'at://did:plc:test123/sh.tangled.repo.issue/issue1', 660 660 + }) 661 661 + ).rejects.toThrow('Must be authenticated'); 662 662 + }); 671 663 });

+166 -190

tests/utils/at-uri.test.ts

reviewed

··· 1 1 import { beforeEach, describe, expect, it, vi } from 'vitest'; 2 2 - import { 3 3 - buildRepoAtUri, 4 4 - parseAtUri, 5 5 - resolveHandleToDid, 6 6 - } from '../../src/utils/at-uri.js'; 7 2 import type { TangledApiClient } from '../../src/lib/api-client.js'; 3 3 + import { buildRepoAtUri, parseAtUri, resolveHandleToDid } from '../../src/utils/at-uri.js'; 8 4 9 5 // Mock API client 10 6 const createMockClient = (): TangledApiClient => { 11 11 - return { 12 12 - getAgent: vi.fn(() => ({ 13 13 - com: { 14 14 - atproto: { 15 15 - identity: { 16 16 - resolveHandle: vi.fn(), 17 17 - }, 18 18 - }, 19 19 - }, 20 20 - })), 21 21 - } as unknown as TangledApiClient; 7 7 + return { 8 8 + getAgent: vi.fn(() => ({ 9 9 + com: { 10 10 + atproto: { 11 11 + identity: { 12 12 + resolveHandle: vi.fn(), 13 13 + }, 14 14 + }, 15 15 + }, 16 16 + })), 17 17 + } as unknown as TangledApiClient; 22 18 }; 23 19 24 20 describe('parseAtUri', () => { 25 25 - it('should parse AT-URI with rkey', () => { 26 26 - const uri = 'at://did:plc:abc123/sh.tangled.repo.issue/xyz789'; 27 27 - const result = parseAtUri(uri); 21 21 + it('should parse AT-URI with rkey', () => { 22 22 + const uri = 'at://did:plc:abc123/sh.tangled.repo.issue/xyz789'; 23 23 + const result = parseAtUri(uri); 28 24 29 29 - expect(result).toEqual({ 30 30 - did: 'did:plc:abc123', 31 31 - collection: 'sh.tangled.repo.issue', 32 32 - rkey: 'xyz789', 33 33 - }); 34 34 - }); 25 25 + expect(result).toEqual({ 26 26 + did: 'did:plc:abc123', 27 27 + collection: 'sh.tangled.repo.issue', 28 28 + rkey: 'xyz789', 29 29 + }); 30 30 + }); 35 31 36 36 - it('should parse AT-URI without rkey', () => { 37 37 - const uri = 'at://did:plc:abc123/sh.tangled.repo'; 38 38 - const result = parseAtUri(uri); 32 32 + it('should parse AT-URI without rkey', () => { 33 33 + const uri = 'at://did:plc:abc123/sh.tangled.repo'; 34 34 + const result = parseAtUri(uri); 39 35 40 40 - expect(result).toEqual({ 41 41 - did: 'did:plc:abc123', 42 42 - collection: 'sh.tangled.repo', 43 43 - }); 44 44 - }); 36 36 + expect(result).toEqual({ 37 37 + did: 'did:plc:abc123', 38 38 + collection: 'sh.tangled.repo', 39 39 + }); 40 40 + }); 45 41 46 46 - it('should parse AT-URI with nested collection', () => { 47 47 - const uri = 'at://did:plc:abc123/sh.tangled.repo.issue.state/xyz'; 48 48 - const result = parseAtUri(uri); 42 42 + it('should parse AT-URI with nested collection', () => { 43 43 + const uri = 'at://did:plc:abc123/sh.tangled.repo.issue.state/xyz'; 44 44 + const result = parseAtUri(uri); 49 45 50 50 - expect(result).toEqual({ 51 51 - did: 'did:plc:abc123', 52 52 - collection: 'sh.tangled.repo.issue.state', 53 53 - rkey: 'xyz', 54 54 - }); 55 55 - }); 46 46 + expect(result).toEqual({ 47 47 + did: 'did:plc:abc123', 48 48 + collection: 'sh.tangled.repo.issue.state', 49 49 + rkey: 'xyz', 50 50 + }); 51 51 + }); 56 52 57 57 - it('should return null for invalid URI', () => { 58 58 - expect(parseAtUri('not-a-uri')).toBeNull(); 59 59 - expect(parseAtUri('http://example.com')).toBeNull(); 60 60 - expect(parseAtUri('at://invalid-did/collection')).toBeNull(); 61 61 - expect(parseAtUri('')).toBeNull(); 62 62 - }); 53 53 + it('should return null for invalid URI', () => { 54 54 + expect(parseAtUri('not-a-uri')).toBeNull(); 55 55 + expect(parseAtUri('http://example.com')).toBeNull(); 56 56 + expect(parseAtUri('at://invalid-did/collection')).toBeNull(); 57 57 + expect(parseAtUri('')).toBeNull(); 58 58 + }); 63 59 64 64 - it('should handle DIDs with various characters', () => { 65 65 - const uri = 'at://did:web:example.com/collection/rkey'; 66 66 - const result = parseAtUri(uri); 60 60 + it('should handle DIDs with various characters', () => { 61 61 + const uri = 'at://did:web:example.com/collection/rkey'; 62 62 + const result = parseAtUri(uri); 67 63 68 68 - expect(result).toEqual({ 69 69 - did: 'did:web:example.com', 70 70 - collection: 'collection', 71 71 - rkey: 'rkey', 72 72 - }); 73 73 - }); 64 64 + expect(result).toEqual({ 65 65 + did: 'did:web:example.com', 66 66 + collection: 'collection', 67 67 + rkey: 'rkey', 68 68 + }); 69 69 + }); 74 70 }); 75 71 76 72 describe('resolveHandleToDid', () => { 77 77 - let mockClient: TangledApiClient; 73 73 + let mockClient: TangledApiClient; 78 74 79 79 - beforeEach(() => { 80 80 - mockClient = createMockClient(); 81 81 - }); 75 75 + beforeEach(() => { 76 76 + mockClient = createMockClient(); 77 77 + }); 82 78 83 83 - it('should resolve handle to DID', async () => { 84 84 - const mockResolve = vi.fn().mockResolvedValue({ 85 85 - data: { did: 'did:plc:abc123' }, 86 86 - }); 79 79 + it('should resolve handle to DID', async () => { 80 80 + const mockResolve = vi.fn().mockResolvedValue({ 81 81 + data: { did: 'did:plc:abc123' }, 82 82 + }); 87 83 88 88 - vi.mocked(mockClient.getAgent).mockReturnValue({ 89 89 - com: { 90 90 - atproto: { 91 91 - identity: { 92 92 - resolveHandle: mockResolve, 93 93 - }, 94 94 - }, 95 95 - }, 96 96 - } as never); 84 84 + vi.mocked(mockClient.getAgent).mockReturnValue({ 85 85 + com: { 86 86 + atproto: { 87 87 + identity: { 88 88 + resolveHandle: mockResolve, 89 89 + }, 90 90 + }, 91 91 + }, 92 92 + } as never); 97 93 98 98 - const result = await resolveHandleToDid('mark.bsky.social', mockClient); 94 94 + const result = await resolveHandleToDid('mark.bsky.social', mockClient); 99 95 100 100 - expect(result).toBe('did:plc:abc123'); 101 101 - expect(mockResolve).toHaveBeenCalledWith({ handle: 'mark.bsky.social' }); 102 102 - }); 96 96 + expect(result).toBe('did:plc:abc123'); 97 97 + expect(mockResolve).toHaveBeenCalledWith({ handle: 'mark.bsky.social' }); 98 98 + }); 103 99 104 104 - it('should strip leading @ from handle', async () => { 105 105 - const mockResolve = vi.fn().mockResolvedValue({ 106 106 - data: { did: 'did:plc:abc123' }, 107 107 - }); 100 100 + it('should strip leading @ from handle', async () => { 101 101 + const mockResolve = vi.fn().mockResolvedValue({ 102 102 + data: { did: 'did:plc:abc123' }, 103 103 + }); 108 104 109 109 - vi.mocked(mockClient.getAgent).mockReturnValue({ 110 110 - com: { 111 111 - atproto: { 112 112 - identity: { 113 113 - resolveHandle: mockResolve, 114 114 - }, 115 115 - }, 116 116 - }, 117 117 - } as never); 105 105 + vi.mocked(mockClient.getAgent).mockReturnValue({ 106 106 + com: { 107 107 + atproto: { 108 108 + identity: { 109 109 + resolveHandle: mockResolve, 110 110 + }, 111 111 + }, 112 112 + }, 113 113 + } as never); 118 114 119 119 - await resolveHandleToDid('@mark.bsky.social', mockClient); 115 115 + await resolveHandleToDid('@mark.bsky.social', mockClient); 120 116 121 121 - expect(mockResolve).toHaveBeenCalledWith({ handle: 'mark.bsky.social' }); 122 122 - }); 117 117 + expect(mockResolve).toHaveBeenCalledWith({ handle: 'mark.bsky.social' }); 118 118 + }); 123 119 124 124 - it('should throw error when handle not found', async () => { 125 125 - const mockResolve = vi.fn().mockResolvedValue({ 126 126 - data: { did: null }, 127 127 - }); 120 120 + it('should throw error when handle not found', async () => { 121 121 + const mockResolve = vi.fn().mockResolvedValue({ 122 122 + data: { did: null }, 123 123 + }); 128 124 129 129 - vi.mocked(mockClient.getAgent).mockReturnValue({ 130 130 - com: { 131 131 - atproto: { 132 132 - identity: { 133 133 - resolveHandle: mockResolve, 134 134 - }, 135 135 - }, 136 136 - }, 137 137 - } as never); 125 125 + vi.mocked(mockClient.getAgent).mockReturnValue({ 126 126 + com: { 127 127 + atproto: { 128 128 + identity: { 129 129 + resolveHandle: mockResolve, 130 130 + }, 131 131 + }, 132 132 + }, 133 133 + } as never); 138 134 139 139 - await expect( 140 140 - resolveHandleToDid('nonexistent.bsky.social', mockClient), 141 141 - ).rejects.toThrow('No DID found for handle: nonexistent.bsky.social'); 142 142 - }); 135 135 + await expect(resolveHandleToDid('nonexistent.bsky.social', mockClient)).rejects.toThrow( 136 136 + 'No DID found for handle: nonexistent.bsky.social' 137 137 + ); 138 138 + }); 143 139 144 144 - it('should throw error on network failure', async () => { 145 145 - const mockResolve = vi 146 146 - .fn() 147 147 - .mockRejectedValue(new Error('Network error')); 140 140 + it('should throw error on network failure', async () => { 141 141 + const mockResolve = vi.fn().mockRejectedValue(new Error('Network error')); 148 142 149 149 - vi.mocked(mockClient.getAgent).mockReturnValue({ 150 150 - com: { 151 151 - atproto: { 152 152 - identity: { 153 153 - resolveHandle: mockResolve, 154 154 - }, 155 155 - }, 156 156 - }, 157 157 - } as never); 143 143 + vi.mocked(mockClient.getAgent).mockReturnValue({ 144 144 + com: { 145 145 + atproto: { 146 146 + identity: { 147 147 + resolveHandle: mockResolve, 148 148 + }, 149 149 + }, 150 150 + }, 151 151 + } as never); 158 152 159 159 - await expect( 160 160 - resolveHandleToDid('mark.bsky.social', mockClient), 161 161 - ).rejects.toThrow( 162 162 - "Failed to resolve handle 'mark.bsky.social': Network error", 163 163 - ); 164 164 - }); 153 153 + await expect(resolveHandleToDid('mark.bsky.social', mockClient)).rejects.toThrow( 154 154 + "Failed to resolve handle 'mark.bsky.social': Network error" 155 155 + ); 156 156 + }); 165 157 }); 166 158 167 159 describe('buildRepoAtUri', () => { 168 168 - let mockClient: TangledApiClient; 160 160 + let mockClient: TangledApiClient; 169 161 170 170 - beforeEach(() => { 171 171 - mockClient = createMockClient(); 172 172 - }); 162 162 + beforeEach(() => { 163 163 + mockClient = createMockClient(); 164 164 + }); 173 165 174 174 - it('should build AT-URI from DID', async () => { 175 175 - const result = await buildRepoAtUri( 176 176 - 'did:plc:abc123', 177 177 - 'my-repo', 178 178 - mockClient, 179 179 - ); 166 166 + it('should build AT-URI from DID', async () => { 167 167 + const result = await buildRepoAtUri('did:plc:abc123', 'my-repo', mockClient); 180 168 181 181 - expect(result).toBe('at://did:plc:abc123/sh.tangled.repo/my-repo'); 182 182 - }); 169 169 + expect(result).toBe('at://did:plc:abc123/sh.tangled.repo/my-repo'); 170 170 + }); 183 171 184 184 - it('should build AT-URI from handle', async () => { 185 185 - const mockResolve = vi.fn().mockResolvedValue({ 186 186 - data: { did: 'did:plc:abc123' }, 187 187 - }); 172 172 + it('should build AT-URI from handle', async () => { 173 173 + const mockResolve = vi.fn().mockResolvedValue({ 174 174 + data: { did: 'did:plc:abc123' }, 175 175 + }); 188 176 189 189 - vi.mocked(mockClient.getAgent).mockReturnValue({ 190 190 - com: { 191 191 - atproto: { 192 192 - identity: { 193 193 - resolveHandle: mockResolve, 194 194 - }, 195 195 - }, 196 196 - }, 197 197 - } as never); 177 177 + vi.mocked(mockClient.getAgent).mockReturnValue({ 178 178 + com: { 179 179 + atproto: { 180 180 + identity: { 181 181 + resolveHandle: mockResolve, 182 182 + }, 183 183 + }, 184 184 + }, 185 185 + } as never); 198 186 199 199 - const result = await buildRepoAtUri( 200 200 - 'mark.bsky.social', 201 201 - 'my-repo', 202 202 - mockClient, 203 203 - ); 187 187 + const result = await buildRepoAtUri('mark.bsky.social', 'my-repo', mockClient); 204 188 205 205 - expect(result).toBe('at://did:plc:abc123/sh.tangled.repo/my-repo'); 206 206 - expect(mockResolve).toHaveBeenCalledWith({ handle: 'mark.bsky.social' }); 207 207 - }); 189 189 + expect(result).toBe('at://did:plc:abc123/sh.tangled.repo/my-repo'); 190 190 + expect(mockResolve).toHaveBeenCalledWith({ handle: 'mark.bsky.social' }); 191 191 + }); 208 192 209 209 - it('should handle repository names with special characters', async () => { 210 210 - const result = await buildRepoAtUri( 211 211 - 'did:plc:abc123', 212 212 - 'repo-name_123', 213 213 - mockClient, 214 214 - ); 193 193 + it('should handle repository names with special characters', async () => { 194 194 + const result = await buildRepoAtUri('did:plc:abc123', 'repo-name_123', mockClient); 215 195 216 216 - expect(result).toBe('at://did:plc:abc123/sh.tangled.repo/repo-name_123'); 217 217 - }); 196 196 + expect(result).toBe('at://did:plc:abc123/sh.tangled.repo/repo-name_123'); 197 197 + }); 218 198 219 219 - it('should throw error when handle resolution fails', async () => { 220 220 - const mockResolve = vi 221 221 - .fn() 222 222 - .mockRejectedValue(new Error('Resolution failed')); 199 199 + it('should throw error when handle resolution fails', async () => { 200 200 + const mockResolve = vi.fn().mockRejectedValue(new Error('Resolution failed')); 223 201 224 224 - vi.mocked(mockClient.getAgent).mockReturnValue({ 225 225 - com: { 226 226 - atproto: { 227 227 - identity: { 228 228 - resolveHandle: mockResolve, 229 229 - }, 230 230 - }, 231 231 - }, 232 232 - } as never); 202 202 + vi.mocked(mockClient.getAgent).mockReturnValue({ 203 203 + com: { 204 204 + atproto: { 205 205 + identity: { 206 206 + resolveHandle: mockResolve, 207 207 + }, 208 208 + }, 209 209 + }, 210 210 + } as never); 233 211 234 234 - await expect( 235 235 - buildRepoAtUri('mark.bsky.social', 'my-repo', mockClient), 236 236 - ).rejects.toThrow( 237 237 - "Failed to resolve handle 'mark.bsky.social': Resolution failed", 238 238 - ); 239 239 - }); 212 212 + await expect(buildRepoAtUri('mark.bsky.social', 'my-repo', mockClient)).rejects.toThrow( 213 213 + "Failed to resolve handle 'mark.bsky.social': Resolution failed" 214 214 + ); 215 215 + }); 240 216 });

+25 -24

tests/utils/auth-helpers.test.ts

reviewed

··· 1 1 import { describe, expect, it, vi } from 'vitest'; 2 2 - import { requireAuth } from '../../src/utils/auth-helpers.js'; 3 2 import type { TangledApiClient } from '../../src/lib/api-client.js'; 3 3 + import { requireAuth } from '../../src/utils/auth-helpers.js'; 4 4 5 5 // Mock API client factory 6 6 - const createMockClient = (authenticated: boolean, session: { did: string; handle: string } | null): TangledApiClient => { 7 7 - return { 8 8 - isAuthenticated: vi.fn(async () => authenticated), 9 9 - getSession: vi.fn(() => session), 10 10 - } as unknown as TangledApiClient; 6 6 + const createMockClient = ( 7 7 + authenticated: boolean, 8 8 + session: { did: string; handle: string } | null 9 9 + ): TangledApiClient => { 10 10 + return { 11 11 + isAuthenticated: vi.fn(async () => authenticated), 12 12 + getSession: vi.fn(() => session), 13 13 + } as unknown as TangledApiClient; 11 14 }; 12 15 13 16 describe('requireAuth', () => { 14 14 - it('should return session when authenticated', async () => { 15 15 - const mockSession = { did: 'did:plc:test123', handle: 'test.bsky.social' }; 16 16 - const mockClient = createMockClient(true, mockSession); 17 17 + it('should return session when authenticated', async () => { 18 18 + const mockSession = { did: 'did:plc:test123', handle: 'test.bsky.social' }; 19 19 + const mockClient = createMockClient(true, mockSession); 17 20 18 18 - const result = await requireAuth(mockClient); 21 21 + const result = await requireAuth(mockClient); 19 22 20 20 - expect(result).toEqual(mockSession); 21 21 - }); 23 23 + expect(result).toEqual(mockSession); 24 24 + }); 22 25 23 23 - it('should throw error when not authenticated', async () => { 24 24 - const mockClient = createMockClient(false, null); 26 26 + it('should throw error when not authenticated', async () => { 27 27 + const mockClient = createMockClient(false, null); 25 28 26 26 - await expect(requireAuth(mockClient)).rejects.toThrow( 27 27 - 'Must be authenticated. Run "tangled auth login" first.', 28 28 - ); 29 29 - }); 29 29 + await expect(requireAuth(mockClient)).rejects.toThrow( 30 30 + 'Must be authenticated. Run "tangled auth login" first.' 31 31 + ); 32 32 + }); 30 33 31 31 - it('should throw error when authenticated but no session', async () => { 32 32 - const mockClient = createMockClient(true, null); 34 34 + it('should throw error when authenticated but no session', async () => { 35 35 + const mockClient = createMockClient(true, null); 33 36 34 34 - await expect(requireAuth(mockClient)).rejects.toThrow( 35 35 - 'No active session found', 36 36 - ); 37 37 - }); 37 37 + await expect(requireAuth(mockClient)).rejects.toThrow('No active session found'); 38 38 + }); 38 39 });

+93 -95

tests/utils/body-input.test.ts

reviewed

··· 5 5 import { readBodyInput } from '../../src/utils/body-input.js'; 6 6 7 7 describe('readBodyInput', () => { 8 8 - describe('direct string input', () => { 9 9 - it('should return body string when provided', async () => { 10 10 - const result = await readBodyInput('Test body content'); 11 11 - expect(result).toBe('Test body content'); 12 12 - }); 8 8 + describe('direct string input', () => { 9 9 + it('should return body string when provided', async () => { 10 10 + const result = await readBodyInput('Test body content'); 11 11 + expect(result).toBe('Test body content'); 12 12 + }); 13 13 14 14 - it('should return multiline body string', async () => { 15 15 - const multiline = 'Line 1\nLine 2\nLine 3'; 16 16 - const result = await readBodyInput(multiline); 17 17 - expect(result).toBe(multiline); 18 18 - }); 14 14 + it('should return multiline body string', async () => { 15 15 + const multiline = 'Line 1\nLine 2\nLine 3'; 16 16 + const result = await readBodyInput(multiline); 17 17 + expect(result).toBe(multiline); 18 18 + }); 19 19 20 20 - it('should return empty string', async () => { 21 21 - const result = await readBodyInput(''); 22 22 - expect(result).toBe(''); 23 23 - }); 24 24 - }); 20 20 + it('should return empty string', async () => { 21 21 + const result = await readBodyInput(''); 22 22 + expect(result).toBe(''); 23 23 + }); 24 24 + }); 25 25 26 26 - describe('file input', () => { 27 27 - let tempDir: string; 28 28 - let testFile: string; 26 26 + describe('file input', () => { 27 27 + let tempDir: string; 28 28 + let testFile: string; 29 29 30 30 - beforeEach(async () => { 31 31 - // Create a temporary directory for test files 32 32 - tempDir = path.join(process.cwd(), 'tests', 'fixtures', 'temp'); 33 33 - await fs.mkdir(tempDir, { recursive: true }); 34 34 - testFile = path.join(tempDir, 'test-body.txt'); 35 35 - }); 30 30 + beforeEach(async () => { 31 31 + // Create a temporary directory for test files 32 32 + tempDir = path.join(process.cwd(), 'tests', 'fixtures', 'temp'); 33 33 + await fs.mkdir(tempDir, { recursive: true }); 34 34 + testFile = path.join(tempDir, 'test-body.txt'); 35 35 + }); 36 36 37 37 - afterEach(async () => { 38 38 - // Clean up test files 39 39 - try { 40 40 - await fs.rm(tempDir, { recursive: true, force: true }); 41 41 - } catch { 42 42 - // Ignore cleanup errors 43 43 - } 44 44 - }); 37 37 + afterEach(async () => { 38 38 + // Clean up test files 39 39 + try { 40 40 + await fs.rm(tempDir, { recursive: true, force: true }); 41 41 + } catch { 42 42 + // Ignore cleanup errors 43 43 + } 44 44 + }); 45 45 46 46 - it('should read content from file', async () => { 47 47 - const content = 'File content here'; 48 48 - await fs.writeFile(testFile, content, 'utf-8'); 46 46 + it('should read content from file', async () => { 47 47 + const content = 'File content here'; 48 48 + await fs.writeFile(testFile, content, 'utf-8'); 49 49 50 50 - const result = await readBodyInput(undefined, testFile); 51 51 - expect(result).toBe(content); 52 52 - }); 50 50 + const result = await readBodyInput(undefined, testFile); 51 51 + expect(result).toBe(content); 52 52 + }); 53 53 54 54 - it('should read multiline content from file', async () => { 55 55 - const content = 'Line 1\nLine 2\nLine 3'; 56 56 - await fs.writeFile(testFile, content, 'utf-8'); 54 54 + it('should read multiline content from file', async () => { 55 55 + const content = 'Line 1\nLine 2\nLine 3'; 56 56 + await fs.writeFile(testFile, content, 'utf-8'); 57 57 58 58 - const result = await readBodyInput(undefined, testFile); 59 59 - expect(result).toBe(content); 60 60 - }); 58 58 + const result = await readBodyInput(undefined, testFile); 59 59 + expect(result).toBe(content); 60 60 + }); 61 61 62 62 - it('should read empty file', async () => { 63 63 - await fs.writeFile(testFile, '', 'utf-8'); 62 62 + it('should read empty file', async () => { 63 63 + await fs.writeFile(testFile, '', 'utf-8'); 64 64 65 65 - const result = await readBodyInput(undefined, testFile); 66 66 - expect(result).toBe(''); 67 67 - }); 65 65 + const result = await readBodyInput(undefined, testFile); 66 66 + expect(result).toBe(''); 67 67 + }); 68 68 69 69 - it('should throw error when file does not exist', async () => { 70 70 - const nonExistentFile = path.join(tempDir, 'does-not-exist.txt'); 69 69 + it('should throw error when file does not exist', async () => { 70 70 + const nonExistentFile = path.join(tempDir, 'does-not-exist.txt'); 71 71 72 72 - await expect(readBodyInput(undefined, nonExistentFile)).rejects.toThrow( 73 73 - `File not found: ${nonExistentFile}`, 74 74 - ); 75 75 - }); 72 72 + await expect(readBodyInput(undefined, nonExistentFile)).rejects.toThrow( 73 73 + `File not found: ${nonExistentFile}` 74 74 + ); 75 75 + }); 76 76 77 77 - it('should throw error when path is a directory', async () => { 78 78 - await expect(readBodyInput(undefined, tempDir)).rejects.toThrow( 79 79 - `'${tempDir}' is a directory, not a file`, 80 80 - ); 81 81 - }); 82 82 - }); 77 77 + it('should throw error when path is a directory', async () => { 78 78 + await expect(readBodyInput(undefined, tempDir)).rejects.toThrow( 79 79 + `'${tempDir}' is a directory, not a file` 80 80 + ); 81 81 + }); 82 82 + }); 83 83 84 84 - describe('stdin input', () => { 85 85 - // Note: Stdin reading is tested via integration tests 86 86 - // Mocking process.stdin is complex and unreliable in unit tests 87 87 - // The implementation is straightforward and covered by: 88 88 - // 1. File I/O tests (same event-driven patterns) 89 89 - // 2. Integration tests with real stdin 90 90 - it.skip('stdin reading is tested via integration tests', () => { 91 91 - // Placeholder to document testing approach 92 92 - }); 93 93 - }); 84 84 + describe('stdin input', () => { 85 85 + // Note: Stdin reading is tested via integration tests 86 86 + // Mocking process.stdin is complex and unreliable in unit tests 87 87 + // The implementation is straightforward and covered by: 88 88 + // 1. File I/O tests (same event-driven patterns) 89 89 + // 2. Integration tests with real stdin 90 90 + it.skip('stdin reading is tested via integration tests', () => { 91 91 + // Placeholder to document testing approach 92 92 + }); 93 93 + }); 94 94 95 95 - describe('no input', () => { 96 96 - it('should return undefined when no input provided', async () => { 97 97 - const result = await readBodyInput(); 98 98 - expect(result).toBeUndefined(); 99 99 - }); 95 95 + describe('no input', () => { 96 96 + it('should return undefined when no input provided', async () => { 97 97 + const result = await readBodyInput(); 98 98 + expect(result).toBeUndefined(); 99 99 + }); 100 100 101 101 - it('should return undefined when both params are undefined', async () => { 102 102 - const result = await readBodyInput(undefined, undefined); 103 103 - expect(result).toBeUndefined(); 104 104 - }); 105 105 - }); 101 101 + it('should return undefined when both params are undefined', async () => { 102 102 + const result = await readBodyInput(undefined, undefined); 103 103 + expect(result).toBeUndefined(); 104 104 + }); 105 105 + }); 106 106 107 107 - describe('error cases', () => { 108 108 - it('should throw error when both bodyString and bodyFilePath provided', async () => { 109 109 - await expect( 110 110 - readBodyInput('body text', '/path/to/file'), 111 111 - ).rejects.toThrow( 112 112 - 'Cannot specify both --body and --body-file. Choose one input method.', 113 113 - ); 114 114 - }); 107 107 + describe('error cases', () => { 108 108 + it('should throw error when both bodyString and bodyFilePath provided', async () => { 109 109 + await expect(readBodyInput('body text', '/path/to/file')).rejects.toThrow( 110 110 + 'Cannot specify both --body and --body-file. Choose one input method.' 111 111 + ); 112 112 + }); 115 113 116 116 - it('should throw error when both bodyString and stdin flag provided', async () => { 117 117 - await expect(readBodyInput('body text', '-')).rejects.toThrow( 118 118 - 'Cannot specify both --body and --body-file. Choose one input method.', 119 119 - ); 120 120 - }); 121 121 - }); 114 114 + it('should throw error when both bodyString and stdin flag provided', async () => { 115 115 + await expect(readBodyInput('body text', '-')).rejects.toThrow( 116 116 + 'Cannot specify both --body and --body-file. Choose one input method.' 117 117 + ); 118 118 + }); 119 119 + }); 122 120 });

+6 -2

tests/utils/validation.test.ts

reviewed

··· 194 194 195 195 it('should reject titles over 256 characters', () => { 196 196 const tooLong = 'A'.repeat(257); 197 197 - expect(() => validateIssueTitle(tooLong)).toThrow('Issue title must be 256 characters or less'); 197 197 + expect(() => validateIssueTitle(tooLong)).toThrow( 198 198 + 'Issue title must be 256 characters or less' 199 199 + ); 198 200 }); 199 201 }); 200 202 ··· 215 217 216 218 it('should reject bodies over 50,000 characters', () => { 217 219 const tooLong = 'A'.repeat(50001); 218 218 - expect(() => validateIssueBody(tooLong)).toThrow('Issue body must be 50,000 characters or less'); 220 220 + expect(() => validateIssueBody(tooLong)).toThrow( 221 221 + 'Issue body must be 50,000 characters or less' 222 222 + ); 219 223 }); 220 224 }); 221 225 });