@pierre/storage 0.1.4 → 0.2.1

package/package.json

@@ -1,40 +1,39 @@
 {
-	"name": "@pierre/storage",
-	"version": "0.1.4",
-	"description": "Pierre Git Storage SDK",
-	"license": "MIT",
-	"type": "module",
-	"main": "./dist/index.cjs",
-	"module": "./dist/index.js",
-	"types": "./dist/index.d.ts",
-	"exports": {
-		".": {
-			"types": "./dist/index.d.ts",
-			"import": "./dist/index.js",
-			"require": "./dist/index.cjs",
-			"default": "./dist/index.js"
-		}
-	},
-	"files": [
-		"dist",
-		"src"
-	],
-	"scripts": {
-		"build": "tsup",
-		"dev": "tsup --watch",
-		"prepublishOnly": "pnpm build"
-	},
-	"dependencies": {
-		"jose": "^5.10.0",
-		"snakecase-keys": "^9.0.2",
-		"zod": "^3.23.8"
-	},
-	"devDependencies": {
-		"tsup": "8.5.0",
-		"typescript": "5.8.3",
-		"vitest": "3.2.4"
-	},
-	"publishConfig": {
-		"access": "public"
-	}
-}
+  "name": "@pierre/storage",
+  "version": "0.2.1",
+  "description": "Pierre Git Storage SDK",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "jose": "^5.10.0",
+    "snakecase-keys": "^9.0.2",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "tsup": "8.5.0",
+    "typescript": "5.8.3",
+    "vitest": "3.2.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  }
+}

package/src/commit-pack.ts

@@ -0,0 +1,128 @@
+import { inferRefUpdateReason, RefUpdateError } from './errors';
+import type { CommitPackAckRaw } from './schemas';
+import { commitPackResponseSchema, errorEnvelopeSchema } from './schemas';
+import type { CommitResult, RefUpdate } from './types';
+
+export type CommitPackAck = CommitPackAckRaw;
+
+export function buildCommitResult(ack: CommitPackAckRaw): CommitResult {
+	const refUpdate = toRefUpdate(ack.result);
+	if (!ack.result.success) {
+		throw new RefUpdateError(
+			ack.result.message ?? `Commit failed with status ${ack.result.status}`,
+			{
+				status: ack.result.status,
+				message: ack.result.message,
+				refUpdate,
+			},
+		);
+	}
+	return {
+		commitSha: ack.commit.commit_sha,
+		treeSha: ack.commit.tree_sha,
+		targetBranch: ack.commit.target_branch,
+		packBytes: ack.commit.pack_bytes,
+		blobCount: ack.commit.blob_count,
+		refUpdate,
+	};
+}
+
+export function toRefUpdate(result: CommitPackAckRaw['result']): RefUpdate {
+	return {
+		branch: result.branch,
+		oldSha: result.old_sha,
+		newSha: result.new_sha,
+	};
+}
+
+export async function parseCommitPackError(
+	response: Response,
+	fallbackMessage: string,
+): Promise<{
+	statusMessage: string;
+	statusLabel: string;
+	refUpdate?: Partial<RefUpdate>;
+}> {
+	const cloned = response.clone();
+	let jsonBody: unknown;
+	try {
+		jsonBody = await cloned.json();
+	} catch {
+		jsonBody = undefined;
+	}
+
+	let textBody: string | undefined;
+	if (jsonBody === undefined) {
+		try {
+			textBody = await response.text();
+		} catch {
+			textBody = undefined;
+		}
+	}
+
+	const defaultStatus = (() => {
+		const inferred = inferRefUpdateReason(String(response.status));
+		return inferred === 'unknown' ? 'failed' : inferred;
+	})();
+	let statusLabel = defaultStatus;
+	let refUpdate: Partial<RefUpdate> | undefined;
+	let message: string | undefined;
+
+	if (jsonBody !== undefined) {
+		const parsedResponse = commitPackResponseSchema.safeParse(jsonBody);
+		if (parsedResponse.success) {
+			const result = parsedResponse.data.result;
+			if (typeof result.status === 'string' && result.status.trim() !== '') {
+				statusLabel = result.status.trim() as typeof statusLabel;
+			}
+			refUpdate = toPartialRefUpdateFields(result.branch, result.old_sha, result.new_sha);
+			if (typeof result.message === 'string' && result.message.trim() !== '') {
+				message = result.message.trim();
+			}
+		}
+
+		if (!message) {
+			const parsedError = errorEnvelopeSchema.safeParse(jsonBody);
+			if (parsedError.success) {
+				const trimmed = parsedError.data.error.trim();
+				if (trimmed) {
+					message = trimmed;
+				}
+			}
+		}
+	}
+
+	if (!message && typeof jsonBody === 'string' && jsonBody.trim() !== '') {
+		message = jsonBody.trim();
+	}
+
+	if (!message && textBody && textBody.trim() !== '') {
+		message = textBody.trim();
+	}
+
+	return {
+		statusMessage: message ?? fallbackMessage,
+		statusLabel,
+		refUpdate,
+	};
+}
+
+function toPartialRefUpdateFields(
+	branch?: string | null,
+	oldSha?: string | null,
+	newSha?: string | null,
+): Partial<RefUpdate> | undefined {
+	const refUpdate: Partial<RefUpdate> = {};
+
+	if (typeof branch === 'string' && branch.trim() !== '') {
+		refUpdate.branch = branch.trim();
+	}
+	if (typeof oldSha === 'string' && oldSha.trim() !== '') {
+		refUpdate.oldSha = oldSha.trim();
+	}
+	if (typeof newSha === 'string' && newSha.trim() !== '') {
+		refUpdate.newSha = newSha.trim();
+	}
+
+	return Object.keys(refUpdate).length > 0 ? refUpdate : undefined;
+}

package/src/commit.ts

@@ -1,8 +1,16 @@
-import { inferRefUpdateReason, RefUpdateError } from './errors';
+import { buildCommitResult, parseCommitPackError } from './commit-pack';
+import { RefUpdateError } from './errors';
 import type { CommitPackAckRaw } from './schemas';
-import { commitPackAckSchema, commitPackResponseSchema, errorEnvelopeSchema } from './schemas';
+import { commitPackAckSchema } from './schemas';
+import {
+	base64Encode,
+	type ChunkSegment,
+	chunkify,
+	requiresDuplex,
+	toAsyncIterable,
+	toRequestBody,
+} from './stream-utils';
 import type {
-	BlobLike,
 	CommitBuilder,
 	CommitFileOptions,
 	CommitFileSource,
@@ -11,11 +19,8 @@ import type {
 	CommitTextFileOptions,
 	CreateCommitOptions,
 	LegacyCreateCommitOptions,
-	ReadableStreamLike,
-	RefUpdate,
 } from './types';
 
-const MAX_CHUNK_BYTES = 4 * 1024 * 1024;
 const DEFAULT_TTL_SECONDS = 60 * 60;
 const HEADS_REF_PREFIX = 'refs/heads/';
 
@@ -30,16 +35,13 @@ const BufferCtor: NodeBufferConstructor | undefined = (
 	globalThis as { Buffer?: NodeBufferConstructor }
 ).Buffer;
 
-type ChunkSegment = {
-	chunk: Uint8Array;
-	eof: boolean;
-};
-
 interface CommitMetadataPayload {
 	target_branch: string;
 	expected_head_sha?: string;
 	base_branch?: string;
 	commit_message: string;
+	ephemeral?: boolean;
+	ephemeral_base?: boolean;
 	author: {
 		name: string;
 		email: string;
@@ -64,7 +66,7 @@ interface CommitTransportRequest {
 }
 
 interface CommitTransport {
-	send(request: CommitTransportRequest): Promise<CommitPackAck>;
+	send(request: CommitTransportRequest): Promise<CommitPackAckRaw>;
 }
 
 type NormalizedCommitOptions = {
@@ -72,6 +74,8 @@ type NormalizedCommitOptions = {
 	commitMessage: string;
 	expectedHeadSha?: string;
 	baseBranch?: string;
+	ephemeral?: boolean;
+	ephemeralBase?: boolean;
 	author: CommitSignature;
 	committer?: CommitSignature;
 	signal?: AbortSignal;
@@ -92,8 +96,6 @@ type FileOperationState = {
 	streamFactory?: () => AsyncIterable<Uint8Array>;
 };
 
-type CommitPackAck = CommitPackAckRaw;
-
 export class CommitBuilderImpl implements CommitBuilder {
 	private readonly options: NormalizedCommitOptions;
 	private readonly getAuthToken: () => Promise<string>;
@@ -135,6 +137,10 @@ export class CommitBuilderImpl implements CommitBuilder {
 				this.options.baseBranch = trimmedBase;
 			}
 		}
+
+		if (this.options.ephemeralBase && !this.options.baseBranch) {
+			throw new Error('createCommit ephemeralBase requires baseBranch');
+		}
 	}
 
 	addFile(path: string, source: CommitFileSource, options?: CommitFileOptions): CommitBuilder {
@@ -246,6 +252,13 @@ export class CommitBuilderImpl implements CommitBuilder {
 			};
 		}
 
+		if (this.options.ephemeral) {
+			metadata.ephemeral = true;
+		}
+		if (this.options.ephemeralBase) {
+			metadata.ephemeral_base = true;
+		}
+
 		return metadata;
 	}
 
@@ -271,7 +284,7 @@ export class FetchCommitTransport implements CommitTransport {
 		this.url = `${trimmedBase}/api/v${config.version}/repos/commit-pack`;
 	}
 
-	async send(request: CommitTransportRequest): Promise<CommitPackAck> {
+	async send(request: CommitTransportRequest): Promise<CommitPackAckRaw> {
 		const bodyIterable = buildMessageIterable(request.metadata, request.blobs);
 		const body = toRequestBody(bodyIterable);
 
@@ -293,7 +306,11 @@ export class FetchCommitTransport implements CommitTransport {
 		const response = await fetch(this.url, init);
 
 		if (!response.ok) {
-			const { statusMessage, statusLabel, refUpdate } = await parseCommitPackError(response);
+			const fallbackMessage = `createCommit request failed (${response.status} ${response.statusText})`;
+			const { statusMessage, statusLabel, refUpdate } = await parseCommitPackError(
+				response,
+				fallbackMessage,
+			);
 			throw new RefUpdateError(statusMessage, {
 				status: statusLabel,
 				message: statusMessage,
@@ -306,31 +323,6 @@ export class FetchCommitTransport implements CommitTransport {
 	}
 }
 
-function toRequestBody(iterable: AsyncIterable<Uint8Array>): unknown {
-	const readableStreamCtor = (
-		globalThis as { ReadableStream?: new (underlyingSource: unknown) => unknown }
-	).ReadableStream;
-	if (typeof readableStreamCtor === 'function') {
-		const iterator = iterable[Symbol.asyncIterator]();
-		return new readableStreamCtor({
-			async pull(controller: { enqueue(chunk: Uint8Array): void; close(): void }) {
-				const { value, done } = await iterator.next();
-				if (done) {
-					controller.close();
-					return;
-				}
-				controller.enqueue(value!);
-			},
-			async cancel(reason: unknown) {
-				if (typeof iterator.return === 'function') {
-					await iterator.return(reason);
-				}
-			},
-		});
-	}
-	return iterable;
-}
-
 function buildMessageIterable(
 	metadata: CommitMetadataPayload,
 	blobs: Array<{ contentId: string; chunks: AsyncIterable<ChunkSegment> }>,
@@ -355,235 +347,6 @@ function buildMessageIterable(
 	};
 }
 
-function requiresDuplex(body: unknown): boolean {
-	if (!body || typeof body !== 'object') {
-		return false;
-	}
-
-	if (typeof (body as { [Symbol.asyncIterator]?: unknown })[Symbol.asyncIterator] === 'function') {
-		return true;
-	}
-
-	const readableStreamCtor = (globalThis as {
-		ReadableStream?: new (...args: unknown[]) => unknown;
-	}).ReadableStream;
-	if (readableStreamCtor && body instanceof readableStreamCtor) {
-		return true;
-	}
-
-	return false;
-}
-
-function buildCommitResult(ack: CommitPackAck): CommitResult {
-	const refUpdate = toRefUpdate(ack.result);
-	if (!ack.result.success) {
-		throw new RefUpdateError(
-			ack.result.message ?? `Commit failed with status ${ack.result.status}`,
-			{
-				status: ack.result.status,
-				message: ack.result.message,
-				refUpdate,
-			},
-		);
-	}
-	return {
-		commitSha: ack.commit.commit_sha,
-		treeSha: ack.commit.tree_sha,
-		targetBranch: ack.commit.target_branch,
-		packBytes: ack.commit.pack_bytes,
-		blobCount: ack.commit.blob_count,
-		refUpdate,
-	};
-}
-
-function toRefUpdate(result: CommitPackAck['result']): RefUpdate {
-	return {
-		branch: result.branch,
-		oldSha: result.old_sha,
-		newSha: result.new_sha,
-	};
-}
-
-async function* chunkify(source: AsyncIterable<Uint8Array>): AsyncIterable<ChunkSegment> {
-	let pending: Uint8Array | null = null;
-	let produced = false;
-
-	for await (const value of source) {
-		const bytes = value;
-
-		if (pending && pending.byteLength === MAX_CHUNK_BYTES) {
-			yield { chunk: pending, eof: false };
-			produced = true;
-			pending = null;
-		}
-
-		const merged: Uint8Array = pending ? concatChunks(pending, bytes) : bytes;
-		pending = null;
-
-		let cursor: Uint8Array = merged;
-		while (cursor.byteLength > MAX_CHUNK_BYTES) {
-			const chunk: Uint8Array = cursor.slice(0, MAX_CHUNK_BYTES);
-			cursor = cursor.slice(MAX_CHUNK_BYTES);
-			yield { chunk, eof: false };
-			produced = true;
-		}
-
-		pending = cursor;
-	}
-
-	if (pending) {
-		yield { chunk: pending, eof: true };
-		produced = true;
-	}
-
-	if (!produced) {
-		yield { chunk: new Uint8Array(0), eof: true };
-	}
-}
-
-async function* toAsyncIterable(source: CommitFileSource): AsyncIterable<Uint8Array> {
-	if (typeof source === 'string') {
-		yield new TextEncoder().encode(source);
-		return;
-	}
-	if (source instanceof Uint8Array) {
-		yield source;
-		return;
-	}
-	if (source instanceof ArrayBuffer) {
-		yield new Uint8Array(source);
-		return;
-	}
-	if (ArrayBuffer.isView(source)) {
-		yield new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-		return;
-	}
-	if (isBlobLike(source)) {
-		const stream = source.stream();
-		if (isAsyncIterable(stream)) {
-			for await (const chunk of stream as AsyncIterable<unknown>) {
-				yield ensureUint8Array(chunk);
-			}
-			return;
-		}
-		if (isReadableStreamLike(stream)) {
-			yield* readReadableStream(stream);
-			return;
-		}
-	}
-	if (isReadableStreamLike(source)) {
-		yield* readReadableStream(source);
-		return;
-	}
-	if (isAsyncIterable(source)) {
-		for await (const chunk of source as AsyncIterable<unknown>) {
-			yield ensureUint8Array(chunk);
-		}
-		return;
-	}
-	if (isIterable(source)) {
-		for (const chunk of source as Iterable<unknown>) {
-			yield ensureUint8Array(chunk);
-		}
-		return;
-	}
-	throw new Error('Unsupported file source for createCommit');
-}
-
-async function* readReadableStream(stream: ReadableStreamLike<unknown>): AsyncIterable<Uint8Array> {
-	const reader = stream.getReader();
-	try {
-		while (true) {
-			const { value, done } = await reader.read();
-			if (done) {
-				break;
-			}
-			if (value !== undefined) {
-				yield ensureUint8Array(value);
-			}
-		}
-	} finally {
-		reader.releaseLock?.();
-	}
-}
-
-function ensureUint8Array(value: unknown): Uint8Array {
-	if (value instanceof Uint8Array) {
-		return value;
-	}
-	if (value instanceof ArrayBuffer) {
-		return new Uint8Array(value);
-	}
-	if (ArrayBuffer.isView(value)) {
-		return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-	}
-	if (typeof value === 'string') {
-		return new TextEncoder().encode(value);
-	}
-	if (BufferCtor && BufferCtor.isBuffer(value)) {
-		return value as Uint8Array;
-	}
-	throw new Error('Unsupported chunk type; expected binary data');
-}
-
-function isBlobLike(value: unknown): value is BlobLike {
-	return (
-		typeof value === 'object' && value !== null && typeof (value as BlobLike).stream === 'function'
-	);
-}
-
-function isReadableStreamLike<T>(value: unknown): value is ReadableStreamLike<T> {
-	return (
-		typeof value === 'object' &&
-		value !== null &&
-		typeof (value as ReadableStreamLike<T>).getReader === 'function'
-	);
-}
-
-function isAsyncIterable(value: unknown): value is AsyncIterable<unknown> {
-	return (
-		typeof value === 'object' &&
-		value !== null &&
-		Symbol.asyncIterator in (value as Record<string, unknown>)
-	);
-}
-
-function isIterable(value: unknown): value is Iterable<unknown> {
-	return (
-		typeof value === 'object' &&
-		value !== null &&
-		Symbol.iterator in (value as Record<string, unknown>)
-	);
-}
-
-function concatChunks(a: Uint8Array, b: Uint8Array): Uint8Array {
-	if (a.byteLength === 0) {
-		return b;
-	}
-	if (b.byteLength === 0) {
-		return a;
-	}
-	const merged = new Uint8Array(a.byteLength + b.byteLength);
-	merged.set(a, 0);
-	merged.set(b, a.byteLength);
-	return merged;
-}
-
-function base64Encode(bytes: Uint8Array): string {
-	if (BufferCtor) {
-		return BufferCtor.from(bytes).toString('base64');
-	}
-	let binary = '';
-	for (let i = 0; i < bytes.byteLength; i++) {
-		binary += String.fromCharCode(bytes[i]);
-	}
-	const btoaFn = (globalThis as { btoa?: (data: string) => string }).btoa;
-	if (typeof btoaFn === 'function') {
-		return btoaFn(binary);
-	}
-	throw new Error('Base64 encoding is not supported in this environment');
-}
-
 function randomContentId(): string {
 	const cryptoObj = globalThis.crypto;
 	if (cryptoObj && typeof cryptoObj.randomUUID === 'function') {
@@ -599,6 +362,8 @@ function normalizeCommitOptions(options: CreateCommitOptions): NormalizedCommitO
 		commitMessage: options.commitMessage,
 		expectedHeadSha: options.expectedHeadSha,
 		baseBranch: options.baseBranch,
+		ephemeral: options.ephemeral === true,
+		ephemeralBase: options.ephemeralBase === true,
 		author: options.author,
 		committer: options.committer,
 		signal: options.signal,
@@ -665,93 +430,3 @@ export function resolveCommitTtlSeconds(options?: { ttl?: number }): number {
 	}
 	return DEFAULT_TTL_SECONDS;
 }
-
-async function parseCommitPackError(response: Response): Promise<{
-	statusMessage: string;
-	statusLabel: string;
-	refUpdate?: Partial<RefUpdate>;
-}> {
-	const fallbackMessage = `createCommit request failed (${response.status} ${response.statusText})`;
-	const cloned = response.clone();
-	let jsonBody: unknown;
-	try {
-		jsonBody = await cloned.json();
-	} catch {
-		jsonBody = undefined;
-	}
-
-	let textBody: string | undefined;
-	if (jsonBody === undefined) {
-		try {
-			textBody = await response.text();
-		} catch {
-			textBody = undefined;
-		}
-	}
-
-	const defaultStatus = (() => {
-		const inferred = inferRefUpdateReason(String(response.status));
-		return inferred === 'unknown' ? 'failed' : inferred;
-	})();
-	let statusLabel = defaultStatus;
-	let refUpdate: Partial<RefUpdate> | undefined;
-	let message: string | undefined;
-
-	if (jsonBody !== undefined) {
-		const parsedResponse = commitPackResponseSchema.safeParse(jsonBody);
-		if (parsedResponse.success) {
-			const result = parsedResponse.data.result;
-			if (typeof result.status === 'string' && result.status.trim() !== '') {
-				statusLabel = result.status.trim() as typeof statusLabel;
-			}
-			refUpdate = toPartialRefUpdateFields(result.branch, result.old_sha, result.new_sha);
-			if (typeof result.message === 'string' && result.message.trim() !== '') {
-				message = result.message.trim();
-			}
-		}
-
-		if (!message) {
-			const parsedError = errorEnvelopeSchema.safeParse(jsonBody);
-			if (parsedError.success) {
-				const trimmed = parsedError.data.error.trim();
-				if (trimmed) {
-					message = trimmed;
-				}
-			}
-		}
-	}
-
-	if (!message && typeof jsonBody === 'string' && jsonBody.trim() !== '') {
-		message = jsonBody.trim();
-	}
-
-	if (!message && textBody && textBody.trim() !== '') {
-		message = textBody.trim();
-	}
-
-	return {
-		statusMessage: message ?? fallbackMessage,
-		statusLabel,
-		refUpdate,
-	};
-}
-
-function toPartialRefUpdateFields(
-	branch?: string | null,
-	oldSha?: string | null,
-	newSha?: string | null,
-): Partial<RefUpdate> | undefined {
-	const refUpdate: Partial<RefUpdate> = {};
-
-	if (typeof branch === 'string' && branch.trim() !== '') {
-		refUpdate.branch = branch.trim();
-	}
-	if (typeof oldSha === 'string' && oldSha.trim() !== '') {
-		refUpdate.oldSha = oldSha.trim();
-	}
-	if (typeof newSha === 'string' && newSha.trim() !== '') {
-		refUpdate.newSha = newSha.trim();
-	}
-
-	return Object.keys(refUpdate).length > 0 ? refUpdate : undefined;
-}