orizu 0.0.9 → 0.1.1

package/src/jsonl-stream.ts

@@ -0,0 +1,131 @@
+import { createReadStream } from 'fs'
+import { createInterface } from 'readline'
+
+export const JSONL_UPLOAD_CHUNK_MAX_BYTES = 2 * 1024 * 1024
+
+interface JsonlChunkOptions {
+  maxPayloadBytes?: number
+}
+
+interface PendingRow {
+  row: Record<string, unknown>
+  jsonByteLength: number
+}
+
+function isObjectRow(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function rowsPayloadByteLength(rowCount: number, rowsByteLength: number): number {
+  return Buffer.byteLength('{"rows":[]}', 'utf8') +
+    rowsByteLength +
+    Math.max(0, rowCount - 1)
+}
+
+function formatMb(byteLength: number): string {
+  return (byteLength / (1024 * 1024)).toFixed(1)
+}
+
+function mapReadError(filePath: string, error: unknown): Error {
+  const maybeError = error as NodeJS.ErrnoException
+
+  if (!maybeError.code && error instanceof Error) {
+    return error
+  }
+
+  if (maybeError.code === 'ENOENT') {
+    return new Error(
+      `File not found: ${filePath}. Check the path and filename, then retry.`
+    )
+  }
+
+  if (maybeError.code === 'EPERM' || maybeError.code === 'EACCES') {
+    return new Error(
+      `Cannot read file: ${filePath}. macOS may be blocking access to this folder (for example Downloads). Grant folder permission to your terminal app and retry.`
+    )
+  }
+
+  return new Error(`Failed to read file ${filePath}: ${maybeError.message}`)
+}
+
+export function estimateRowsPayloadByteLength(rows: Array<Record<string, unknown>>): number {
+  const rowsByteLength = rows.reduce((total, row) => {
+    return total + Buffer.byteLength(JSON.stringify(row), 'utf8')
+  }, 0)
+
+  return rowsPayloadByteLength(rows.length, rowsByteLength)
+}
+
+export async function* streamJsonlRowChunks(
+  filePath: string,
+  options: JsonlChunkOptions = {}
+): AsyncGenerator<Array<Record<string, unknown>>> {
+  const maxPayloadBytes = options.maxPayloadBytes ?? JSONL_UPLOAD_CHUNK_MAX_BYTES
+  let chunk: PendingRow[] = []
+  let chunkRowsByteLength = 0
+  let parsedRowCount = 0
+  let lineNumber = 0
+
+  const stream = createReadStream(filePath, { encoding: 'utf8' })
+  const lines = createInterface({
+    input: stream,
+    crlfDelay: Infinity,
+  })
+
+  try {
+    for await (const line of lines) {
+      lineNumber += 1
+      const trimmed = line.trim()
+      if (!trimmed) {
+        continue
+      }
+
+      let parsed: unknown
+      try {
+        parsed = JSON.parse(trimmed)
+      } catch {
+        throw new Error(`Invalid JSONL at line ${lineNumber}`)
+      }
+
+      if (!isObjectRow(parsed)) {
+        throw new Error(`Row ${lineNumber} must be a JSON object`)
+      }
+
+      const jsonByteLength = Buffer.byteLength(JSON.stringify(parsed), 'utf8')
+      const singleRowPayloadBytes = rowsPayloadByteLength(1, jsonByteLength)
+      if (singleRowPayloadBytes > maxPayloadBytes) {
+        throw new Error(
+          `Row ${lineNumber} is ${formatMb(singleRowPayloadBytes)} MB after JSON encoding, which exceeds the ${formatMb(maxPayloadBytes)} MB upload chunk limit`
+        )
+      }
+
+      const nextPayloadBytes = rowsPayloadByteLength(
+        chunk.length + 1,
+        chunkRowsByteLength + jsonByteLength
+      )
+
+      if (chunk.length > 0 && nextPayloadBytes > maxPayloadBytes) {
+        yield chunk.map(item => item.row)
+        chunk = []
+        chunkRowsByteLength = 0
+      }
+
+      chunk.push({ row: parsed, jsonByteLength })
+      chunkRowsByteLength += jsonByteLength
+      parsedRowCount += 1
+    }
+  } catch (error) {
+    throw mapReadError(filePath, error)
+  } finally {
+    lines.close()
+    stream.destroy()
+  }
+
+  if (chunk.length > 0) {
+    yield chunk.map(item => item.row)
+  }
+
+  if (parsedRowCount === 0) {
+    throw new Error('Dataset file contains no rows')
+  }
+}

package/src/task-create-error.ts

@@ -0,0 +1,115 @@
+export interface TaskCreateErrorPayload {
+  error?: string
+  invalidAssigneeErrors?: Array<{
+    assignee?: string
+    reason?: string
+  }>
+  missingRequiredFields?: string[]
+  incompatibleRowCount?: number
+  missingRequiredFieldCounts?: Record<string, number>
+  versionId?: string
+  versionNum?: number
+}
+
+export interface CliErrorWithStatus extends Error {
+  httpStatus?: number
+  structuredPayload?: Record<string, unknown>
+}
+
+function createCliError(
+  message: string,
+  httpStatus?: number,
+  structuredPayload?: Record<string, unknown>
+): CliErrorWithStatus {
+  const error = new Error(message) as CliErrorWithStatus
+  error.httpStatus = httpStatus
+  error.structuredPayload = structuredPayload
+  return error
+}
+
+export async function formatTaskCreateError(response: Response): Promise<CliErrorWithStatus> {
+  const contentType = response.headers.get('content-type') || ''
+  const rawBody = await response.text()
+  const httpStatus = response.status
+  let parsedPayload: Record<string, unknown> | undefined
+
+  if (!contentType.includes('application/json')) {
+    return createCliError(`Failed to create task: ${rawBody}`, httpStatus)
+  }
+
+  try {
+    const payload = JSON.parse(rawBody) as TaskCreateErrorPayload
+    parsedPayload = payload as unknown as Record<string, unknown>
+
+    if (
+      Array.isArray(payload.invalidAssigneeErrors) &&
+      payload.invalidAssigneeErrors.length > 0
+    ) {
+      const details = payload.invalidAssigneeErrors
+        .filter(
+          item =>
+            typeof item.assignee === 'string' &&
+            item.assignee.length > 0 &&
+            typeof item.reason === 'string' &&
+            item.reason.length > 0
+        )
+        .map(item => `  - ${item.assignee}: ${item.reason}`)
+        .join('\n')
+
+      if (details) {
+        return createCliError(
+          `Failed to create task: ${payload.error || 'Invalid assignees'}\n${details}`,
+          httpStatus,
+          parsedPayload
+        )
+      }
+    }
+
+    if (
+      Array.isArray(payload.missingRequiredFields) &&
+      payload.missingRequiredFields.length > 0
+    ) {
+      const lines: string[] = [
+        `Failed to create task: ${payload.error || 'Dataset incompatible'}`,
+      ]
+
+      if (payload.versionNum !== undefined) {
+        lines.push(`  Version: v${payload.versionNum} (${payload.versionId || 'unknown'})`)
+      }
+
+      lines.push(`  Missing required fields: ${payload.missingRequiredFields.join(', ')}`)
+
+      if (typeof payload.incompatibleRowCount === 'number') {
+        lines.push(`  Incompatible rows: ${payload.incompatibleRowCount}`)
+      }
+
+      if (
+        payload.missingRequiredFieldCounts &&
+        Object.keys(payload.missingRequiredFieldCounts).length > 0
+      ) {
+        const fieldCounts = Object.entries(payload.missingRequiredFieldCounts)
+          .map(([field, count]) => `    ${field}: ${count} rows`)
+          .join('\n')
+        lines.push(`  Missing field counts:\n${fieldCounts}`)
+      }
+
+      return createCliError(
+        lines.join('\n'),
+        httpStatus,
+        parsedPayload
+      )
+    }
+
+    if (typeof payload.error === 'string' && payload.error.length > 0) {
+      return createCliError(
+        `Failed to create task: ${payload.error}`,
+        httpStatus,
+        parsedPayload
+      )
+    }
+  } catch {
+    return createCliError(`Failed to create task: ${rawBody}`, httpStatus)
+  }
+
+  return createCliError(`Failed to create task: ${rawBody}`, httpStatus, parsedPayload)
+}