@pierre/storage 0.1.2 → 0.1.4

package/src/commit.ts

@@ -7,14 +7,17 @@ import type {
 	CommitFileOptions,
 	CommitFileSource,
 	CommitResult,
+	CommitSignature,
 	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/';
 
 type NodeBuffer = Uint8Array & { toString(encoding?: string): string };
 interface NodeBufferConstructor {
@@ -35,6 +38,7 @@ type ChunkSegment = {
 interface CommitMetadataPayload {
 	target_branch: string;
 	expected_head_sha?: string;
+	base_branch?: string;
 	commit_message: string;
 	author: {
 		name: string;
@@ -63,6 +67,17 @@ interface CommitTransport {
 	send(request: CommitTransportRequest): Promise<CommitPackAck>;
 }
 
+type NormalizedCommitOptions = {
+	targetBranch: string;
+	commitMessage: string;
+	expectedHeadSha?: string;
+	baseBranch?: string;
+	author: CommitSignature;
+	committer?: CommitSignature;
+	signal?: AbortSignal;
+	ttl?: number;
+};
+
 interface CommitBuilderDeps {
 	options: CreateCommitOptions;
 	getAuthToken: () => Promise<string>;
@@ -80,35 +95,27 @@ type FileOperationState = {
 type CommitPackAck = CommitPackAckRaw;
 
 export class CommitBuilderImpl implements CommitBuilder {
-	private readonly options: CreateCommitOptions;
+	private readonly options: NormalizedCommitOptions;
 	private readonly getAuthToken: () => Promise<string>;
 	private readonly transport: CommitTransport;
 	private readonly operations: FileOperationState[] = [];
 	private sent = false;
 
 	constructor(deps: CommitBuilderDeps) {
-		this.options = { ...deps.options };
+		this.options = normalizeCommitOptions(deps.options);
 		this.getAuthToken = deps.getAuthToken;
 		this.transport = deps.transport;
 
-		const trimmedTarget = this.options.targetBranch?.trim();
 		const trimmedMessage = this.options.commitMessage?.trim();
 		const trimmedAuthorName = this.options.author?.name?.trim();
 		const trimmedAuthorEmail = this.options.author?.email?.trim();
 
-		if (!trimmedTarget) {
-			throw new Error('createCommit targetBranch is required');
-		}
-		if (trimmedTarget.startsWith('refs/')) {
-			throw new Error('createCommit targetBranch must not include refs/ prefix');
-		}
 		if (!trimmedMessage) {
 			throw new Error('createCommit commitMessage is required');
 		}
 		if (!trimmedAuthorName || !trimmedAuthorEmail) {
 			throw new Error('createCommit author name and email are required');
 		}
-		this.options.targetBranch = trimmedTarget;
 		this.options.commitMessage = trimmedMessage;
 		this.options.author = {
 			name: trimmedAuthorName,
@@ -117,6 +124,17 @@ export class CommitBuilderImpl implements CommitBuilder {
 		if (typeof this.options.expectedHeadSha === 'string') {
 			this.options.expectedHeadSha = this.options.expectedHeadSha.trim();
 		}
+		if (typeof this.options.baseBranch === 'string') {
+			const trimmedBase = this.options.baseBranch.trim();
+			if (trimmedBase === '') {
+				delete this.options.baseBranch;
+			} else {
+				if (trimmedBase.startsWith('refs/')) {
+					throw new Error('createCommit baseBranch must not include refs/ prefix');
+				}
+				this.options.baseBranch = trimmedBase;
+			}
+		}
 	}
 
 	addFile(path: string, source: CommitFileSource, options?: CommitFileOptions): CommitBuilder {
@@ -218,6 +236,9 @@ export class CommitBuilderImpl implements CommitBuilder {
 		if (this.options.expectedHeadSha) {
 			metadata.expected_head_sha = this.options.expectedHeadSha;
 		}
+		if (this.options.baseBranch) {
+			metadata.base_branch = this.options.baseBranch;
+		}
 		if (this.options.committer) {
 			metadata.committer = {
 				name: this.options.committer.name,
@@ -254,7 +275,7 @@ export class FetchCommitTransport implements CommitTransport {
 		const bodyIterable = buildMessageIterable(request.metadata, request.blobs);
 		const body = toRequestBody(bodyIterable);
 
-		const response = await fetch(this.url, {
+		const init: RequestInit = {
 			method: 'POST',
 			headers: {
 				Authorization: `Bearer ${request.authorization}`,
@@ -263,7 +284,13 @@ export class FetchCommitTransport implements CommitTransport {
 			},
 			body: body as any,
 			signal: request.signal,
-		});
+		};
+
+		if (requiresDuplex(body)) {
+			(init as RequestInit & { duplex: 'half' }).duplex = 'half';
+		}
+
+		const response = await fetch(this.url, init);
 
 		if (!response.ok) {
 			const { statusMessage, statusLabel, refUpdate } = await parseCommitPackError(response);
@@ -328,6 +355,25 @@ 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) {
@@ -547,6 +593,68 @@ function randomContentId(): string {
 	return `cid-${Date.now().toString(36)}-${random}`;
 }
 
+function normalizeCommitOptions(options: CreateCommitOptions): NormalizedCommitOptions {
+	return {
+		targetBranch: resolveTargetBranch(options),
+		commitMessage: options.commitMessage,
+		expectedHeadSha: options.expectedHeadSha,
+		baseBranch: options.baseBranch,
+		author: options.author,
+		committer: options.committer,
+		signal: options.signal,
+		ttl: options.ttl,
+	};
+}
+
+function resolveTargetBranch(options: CreateCommitOptions): string {
+	const branchCandidate =
+		typeof options.targetBranch === 'string' ? options.targetBranch.trim() : '';
+	if (branchCandidate) {
+		return normalizeBranchName(branchCandidate);
+	}
+	if (hasLegacyTargetRef(options)) {
+		return normalizeLegacyTargetRef(options.targetRef);
+	}
+	throw new Error('createCommit targetBranch is required');
+}
+
+function normalizeBranchName(value: string): string {
+	const trimmed = value.trim();
+	if (!trimmed) {
+		throw new Error('createCommit targetBranch is required');
+	}
+	if (trimmed.startsWith(HEADS_REF_PREFIX)) {
+		const branch = trimmed.slice(HEADS_REF_PREFIX.length).trim();
+		if (!branch) {
+			throw new Error('createCommit targetBranch is required');
+		}
+		return branch;
+	}
+	if (trimmed.startsWith('refs/')) {
+		throw new Error('createCommit targetBranch must not include refs/ prefix');
+	}
+	return trimmed;
+}
+
+function normalizeLegacyTargetRef(ref: string): string {
+	const trimmed = ref.trim();
+	if (!trimmed) {
+		throw new Error('createCommit targetRef is required');
+	}
+	if (!trimmed.startsWith(HEADS_REF_PREFIX)) {
+		throw new Error('createCommit targetRef must start with refs/heads/');
+	}
+	const branch = trimmed.slice(HEADS_REF_PREFIX.length).trim();
+	if (!branch) {
+		throw new Error('createCommit targetRef must include a branch name');
+	}
+	return branch;
+}
+
+function hasLegacyTargetRef(options: CreateCommitOptions): options is LegacyCreateCommitOptions {
+	return typeof (options as LegacyCreateCommitOptions).targetRef === 'string';
+}
+
 export function createCommitBuilder(deps: CommitBuilderDeps): CommitBuilder {
 	return new CommitBuilderImpl(deps);
 }

package/src/types.ts

@@ -224,15 +224,30 @@ export interface FileDiff extends DiffFileBase {
 
 export interface FilteredFile extends DiffFileBase {}
 
-export interface CreateCommitOptions extends GitStorageInvocationOptions {
-	targetBranch: string;
+interface CreateCommitBaseOptions extends GitStorageInvocationOptions {
 	commitMessage: string;
 	expectedHeadSha?: string;
+	baseBranch?: string;
 	author: CommitSignature;
 	committer?: CommitSignature;
 	signal?: AbortSignal;
 }
 
+export interface CreateCommitBranchOptions extends CreateCommitBaseOptions {
+	targetBranch: string;
+	targetRef?: never;
+}
+
+/**
+ * @deprecated Use {@link CreateCommitBranchOptions} instead.
+ */
+export interface LegacyCreateCommitOptions extends CreateCommitBaseOptions {
+	targetBranch?: never;
+	targetRef: string;
+}
+
+export type CreateCommitOptions = CreateCommitBranchOptions | LegacyCreateCommitOptions;
+
 export interface CommitSignature {
 	name: string;
 	email: string;