@pierre/storage 0.0.11 → 0.1.1

package/src/schemas.ts

@@ -0,0 +1,138 @@
+import { z } from 'zod';
+
+export const listFilesResponseSchema = z.object({
+	paths: z.array(z.string()),
+	ref: z.string(),
+});
+
+export const branchInfoSchema = z.object({
+	cursor: z.string(),
+	name: z.string(),
+	head_sha: z.string(),
+	created_at: z.string(),
+});
+
+export const listBranchesResponseSchema = z.object({
+	branches: z.array(branchInfoSchema),
+	next_cursor: z.string().nullable().optional(),
+	has_more: z.boolean(),
+});
+
+export const commitInfoRawSchema = z.object({
+	sha: z.string(),
+	message: z.string(),
+	author_name: z.string(),
+	author_email: z.string(),
+	committer_name: z.string(),
+	committer_email: z.string(),
+	date: z.string(),
+});
+
+export const listCommitsResponseSchema = z.object({
+	commits: z.array(commitInfoRawSchema),
+	next_cursor: z.string().nullable().optional(),
+	has_more: z.boolean(),
+});
+
+export const diffStatsSchema = z.object({
+	files: z.number(),
+	additions: z.number(),
+	deletions: z.number(),
+	changes: z.number(),
+});
+
+export const diffFileRawSchema = z.object({
+	path: z.string(),
+	state: z.string(),
+	old_path: z.string().nullable().optional(),
+	raw: z.string(),
+	bytes: z.number(),
+	is_eof: z.boolean(),
+});
+
+export const filteredFileRawSchema = z.object({
+	path: z.string(),
+	state: z.string(),
+	old_path: z.string().nullable().optional(),
+	bytes: z.number(),
+	is_eof: z.boolean(),
+});
+
+export const branchDiffResponseSchema = z.object({
+	branch: z.string(),
+	base: z.string(),
+	stats: diffStatsSchema,
+	files: z.array(diffFileRawSchema),
+	filtered_files: z.array(filteredFileRawSchema),
+});
+
+export const commitDiffResponseSchema = z.object({
+	sha: z.string(),
+	stats: diffStatsSchema,
+	files: z.array(diffFileRawSchema),
+	filtered_files: z.array(filteredFileRawSchema),
+});
+
+export const refUpdateResultSchema = z.object({
+	branch: z.string(),
+	old_sha: z.string(),
+	new_sha: z.string(),
+	success: z.boolean(),
+	status: z.string(),
+	message: z.string().optional(),
+});
+
+export const commitPackCommitSchema = z.object({
+	commit_sha: z.string(),
+	tree_sha: z.string(),
+	target_branch: z.string(),
+	pack_bytes: z.number(),
+	blob_count: z.number(),
+});
+
+export const restoreCommitCommitSchema = commitPackCommitSchema.omit({ blob_count: true });
+
+export const refUpdateResultWithOptionalsSchema = z.object({
+	branch: z.string().optional(),
+	old_sha: z.string().optional(),
+	new_sha: z.string().optional(),
+	success: z.boolean().optional(),
+	status: z.string(),
+	message: z.string().optional(),
+});
+
+export const commitPackAckSchema = z.object({
+	commit: commitPackCommitSchema,
+	result: refUpdateResultSchema,
+});
+
+export const restoreCommitAckSchema = z.object({
+	commit: restoreCommitCommitSchema,
+	result: refUpdateResultSchema.extend({ success: z.literal(true) }),
+});
+
+export const commitPackResponseSchema = z.object({
+	commit: commitPackCommitSchema.partial().optional().nullable(),
+	result: refUpdateResultWithOptionalsSchema,
+});
+
+export const restoreCommitResponseSchema = z.object({
+	commit: restoreCommitCommitSchema.partial().optional().nullable(),
+	result: refUpdateResultWithOptionalsSchema,
+});
+
+export const errorEnvelopeSchema = z.object({
+	error: z.string(),
+});
+
+export type ListFilesResponseRaw = z.infer<typeof listFilesResponseSchema>;
+export type RawBranchInfo = z.infer<typeof branchInfoSchema>;
+export type ListBranchesResponseRaw = z.infer<typeof listBranchesResponseSchema>;
+export type RawCommitInfo = z.infer<typeof commitInfoRawSchema>;
+export type ListCommitsResponseRaw = z.infer<typeof listCommitsResponseSchema>;
+export type RawFileDiff = z.infer<typeof diffFileRawSchema>;
+export type RawFilteredFile = z.infer<typeof filteredFileRawSchema>;
+export type GetBranchDiffResponseRaw = z.infer<typeof branchDiffResponseSchema>;
+export type GetCommitDiffResponseRaw = z.infer<typeof commitDiffResponseSchema>;
+export type CommitPackAckRaw = z.infer<typeof commitPackAckSchema>;
+export type RestoreCommitAckRaw = z.infer<typeof restoreCommitAckSchema>;

package/src/types.ts

@@ -2,10 +2,23 @@
  * Type definitions for Pierre Git Storage SDK
  */
 
+import type {
+	GetBranchDiffResponseRaw,
+	GetCommitDiffResponseRaw,
+	ListBranchesResponseRaw,
+	ListCommitsResponseRaw,
+	ListFilesResponseRaw,
+	RawBranchInfo as SchemaRawBranchInfo,
+	RawCommitInfo as SchemaRawCommitInfo,
+	RawFileDiff as SchemaRawFileDiff,
+	RawFilteredFile as SchemaRawFilteredFile,
+} from './schemas';
+
 export interface OverrideableGitStorageOptions {
 	apiBaseUrl?: string;
 	storageBaseUrl?: string;
 	apiVersion?: ValidAPIVersion;
+	defaultTTL?: number;
 }
 
 export interface GitStorageOptions extends OverrideableGitStorageOptions {
@@ -26,13 +39,13 @@ export interface Repo {
 	getRemoteURL(options?: GetRemoteURLOptions): Promise<string>;
 
 	getFileStream(options: GetFileOptions): Promise<Response>;
-	listFiles(options?: ListFilesOptions): Promise<ListFilesResponse>;
-	listBranches(options?: ListBranchesOptions): Promise<ListBranchesResponse>;
-	listCommits(options?: ListCommitsOptions): Promise<ListCommitsResponse>;
-	getBranchDiff(options: GetBranchDiffOptions): Promise<GetBranchDiffResponse>;
-	getCommitDiff(options: GetCommitDiffOptions): Promise<GetCommitDiffResponse>;
-	getCommit(options: GetCommitOptions): Promise<GetCommitResponse>;
+	listFiles(options?: ListFilesOptions): Promise<ListFilesResult>;
+	listBranches(options?: ListBranchesOptions): Promise<ListBranchesResult>;
+	listCommits(options?: ListCommitsOptions): Promise<ListCommitsResult>;
+	getBranchDiff(options: GetBranchDiffOptions): Promise<GetBranchDiffResult>;
+	getCommitDiff(options: GetCommitDiffOptions): Promise<GetCommitDiffResult>;
 	pullUpstream(options: PullUpstreamOptions): Promise<void>;
+	restoreCommit(options: RestoreCommitOptions): Promise<RestoreCommitResult>;
 	createCommit(options: CreateCommitOptions): CommitBuilder;
 }
 
@@ -71,11 +84,6 @@ export interface CreateRepoOptions extends GitStorageInvocationOptions {
 	defaultBranch?: string;
 }
 
-export interface CreateRepoResponse {
-	repo_id: string;
-	url: string;
-}
-
 // Get File API types
 export interface GetFileOptions extends GitStorageInvocationOptions {
 	path: string;
@@ -91,7 +99,9 @@ export interface ListFilesOptions extends GitStorageInvocationOptions {
 	ref?: string;
 }
 
-export interface ListFilesResponse {
+export type ListFilesResponse = ListFilesResponseRaw;
+
+export interface ListFilesResult {
 	paths: string[];
 	ref: string;
 }
@@ -102,17 +112,21 @@ export interface ListBranchesOptions extends GitStorageInvocationOptions {
 	limit?: number;
 }
 
+export type RawBranchInfo = SchemaRawBranchInfo;
+
 export interface BranchInfo {
 	cursor: string;
 	name: string;
-	head_sha: string;
-	created_at: string;
+	headSha: string;
+	createdAt: string;
 }
 
-export interface ListBranchesResponse {
+export type ListBranchesResponse = ListBranchesResponseRaw;
+
+export interface ListBranchesResult {
 	branches: BranchInfo[];
-	next_cursor?: string;
-	has_more: boolean;
+	nextCursor?: string;
+	hasMore: boolean;
 }
 
 // List Commits API types
@@ -122,20 +136,25 @@ export interface ListCommitsOptions extends GitStorageInvocationOptions {
 	limit?: number;
 }
 
+export type RawCommitInfo = SchemaRawCommitInfo;
+
 export interface CommitInfo {
 	sha: string;
 	message: string;
-	author_name: string;
-	author_email: string;
-	committer_name: string;
-	committer_email: string;
-	date: string;
+	authorName: string;
+	authorEmail: string;
+	committerName: string;
+	committerEmail: string;
+	date: Date;
+	rawDate: string;
 }
 
-export interface ListCommitsResponse {
+export type ListCommitsResponse = ListCommitsResponseRaw;
+
+export interface ListCommitsResult {
 	commits: CommitInfo[];
-	next_cursor?: string;
-	has_more: boolean;
+	nextCursor?: string;
+	hasMore: boolean;
 }
 
 // Branch Diff API types
@@ -144,12 +163,14 @@ export interface GetBranchDiffOptions extends GitStorageInvocationOptions {
 	base?: string;
 }
 
-export interface GetBranchDiffResponse {
+export type GetBranchDiffResponse = GetBranchDiffResponseRaw;
+
+export interface GetBranchDiffResult {
 	branch: string;
 	base: string;
 	stats: DiffStats;
 	files: FileDiff[];
-	filtered_files: FilteredFile[];
+	filteredFiles: FilteredFile[];
 }
 
 // Commit Diff API types
@@ -157,11 +178,13 @@ export interface GetCommitDiffOptions extends GitStorageInvocationOptions {
 	sha: string;
 }
 
-export interface GetCommitDiffResponse {
+export type GetCommitDiffResponse = GetCommitDiffResponseRaw;
+
+export interface GetCommitDiffResult {
 	sha: string;
 	stats: DiffStats;
 	files: FileDiff[];
-	filtered_files: FilteredFile[];
+	filteredFiles: FilteredFile[];
 }
 
 // Shared diff types
@@ -172,52 +195,40 @@ export interface DiffStats {
 	changes: number;
 }
 
-export interface FileDiff {
-	path: string;
-	state: string;
-	old_path?: string;
-	bytes: number;
-	is_eof: boolean;
-	diff: string;
-}
+export type RawFileDiff = SchemaRawFileDiff;
 
-export interface FilteredFile {
+export type RawFilteredFile = SchemaRawFilteredFile;
+
+export type DiffFileState =
+	| 'added'
+	| 'modified'
+	| 'deleted'
+	| 'renamed'
+	| 'copied'
+	| 'type_changed'
+	| 'unmerged'
+	| 'unknown';
+
+export interface DiffFileBase {
 	path: string;
-	state: string;
-	old_path?: string;
+	state: DiffFileState;
+	rawState: string;
+	oldPath?: string;
 	bytes: number;
-	is_eof: boolean;
+	isEof: boolean;
 }
 
-// Get Commit API types
-export interface GetCommitOptions extends GitStorageInvocationOptions {
-	sha: string;
+export interface FileDiff extends DiffFileBase {
+	raw: string;
 }
 
-export interface GetCommitResponse {
-	sha: string;
-	message: string;
-	author: {
-		name: string;
-		email: string;
-	};
-	committer: {
-		name: string;
-		email: string;
-	};
-	date: string;
-	stats: {
-		additions: number;
-		deletions: number;
-		total: number;
-	};
-}
+export interface FilteredFile extends DiffFileBase {}
 
 export interface CreateCommitOptions extends GitStorageInvocationOptions {
-	targetRef: string;
+	targetBranch: string;
 	commitMessage: string;
-	baseRef?: string;
-	author?: CommitSignature;
+	expectedHeadSha?: string;
+	author: CommitSignature;
 	committer?: CommitSignature;
 	signal?: AbortSignal;
 }
@@ -225,47 +236,110 @@ export interface CreateCommitOptions extends GitStorageInvocationOptions {
 export interface CommitSignature {
 	name: string;
 	email: string;
-	date?: string;
 }
 
+export interface ReadableStreamReaderLike<T> {
+	read(): Promise<{ value?: T; done: boolean }>;
+	releaseLock?(): void;
+}
+
+export interface ReadableStreamLike<T> {
+	getReader(): ReadableStreamReaderLike<T>;
+}
+
+export interface BlobLike {
+	stream(): unknown;
+}
+
+export interface FileLike extends BlobLike {
+	name: string;
+	lastModified?: number;
+}
+
+export type GitFileMode = '100644' | '100755' | '120000' | '160000';
+
+export type TextEncoding =
+	| 'ascii'
+	| 'utf8'
+	| 'utf-8'
+	| 'utf16le'
+	| 'utf-16le'
+	| 'ucs2'
+	| 'ucs-2'
+	| 'base64'
+	| 'base64url'
+	| 'latin1'
+	| 'binary'
+	| 'hex';
+
 export type CommitFileSource =
 	| string
 	| Uint8Array
 	| ArrayBuffer
-	| AsyncIterable<Uint8Array | ArrayBuffer>
-	| Iterable<Uint8Array | ArrayBuffer>;
+	| BlobLike
+	| FileLike
+	| ReadableStreamLike<Uint8Array | ArrayBuffer | ArrayBufferView | string>
+	| AsyncIterable<Uint8Array | ArrayBuffer | ArrayBufferView | string>
+	| Iterable<Uint8Array | ArrayBuffer | ArrayBufferView | string>;
 
 export interface CommitFileOptions {
-	mode?: string;
+	mode?: GitFileMode;
 }
 
 export interface CommitTextFileOptions extends CommitFileOptions {
-	encoding?: 'utf8' | 'utf-8';
+	encoding?: TextEncoding;
 }
 
 export interface CommitBuilder {
 	addFile(path: string, source: CommitFileSource, options?: CommitFileOptions): CommitBuilder;
 	addFileFromString(path: string, contents: string, options?: CommitTextFileOptions): CommitBuilder;
 	deletePath(path: string): CommitBuilder;
-	send(): Promise<CommitResponse>;
+	send(): Promise<CommitResult>;
 }
 
-export interface CommitResponse {
-	commit: {
-		commit_sha: string;
-		tree_sha: string;
-		target_ref: string;
-		pack_bytes: number;
-		blob_count: number;
-	};
-	result: {
-		ref: string;
-		old_sha: string; // 40-hex previous tip; all zeroes when the ref is newly created.
-		new_sha: string;
-		success: boolean;
-		status: string;
-		message?: string;
-	};
+export interface RefUpdate {
+	branch: string;
+	oldSha: string;
+	newSha: string;
+}
+
+export type RefUpdateReason =
+	| 'precondition_failed'
+	| 'conflict'
+	| 'not_found'
+	| 'invalid'
+	| 'timeout'
+	| 'unauthorized'
+	| 'forbidden'
+	| 'unavailable'
+	| 'internal'
+	| 'failed'
+	| 'unknown';
+
+export interface CommitResult {
+	commitSha: string;
+	treeSha: string;
+	targetBranch: string;
+	packBytes: number;
+	blobCount: number;
+	refUpdate: RefUpdate;
+}
+
+export interface RestoreCommitOptions extends GitStorageInvocationOptions {
+	targetBranch: string;
+	targetCommitSha: string;
+	commitMessage?: string;
+	expectedHeadSha?: string;
+	author: CommitSignature;
+	committer?: CommitSignature;
+}
+
+export interface RestoreCommitResult {
+	commitSha: string;
+	treeSha: string;
+	targetBranch: string;
+	packBytes: number;
+	refUpdate: RefUpdate;
 }
 
 // Webhook types
@@ -297,7 +371,7 @@ export interface WebhookValidationResult {
 }
 
 // Webhook event payloads
-export interface WebhookPushEvent {
+export interface RawWebhookPushEvent {
 	repository: {
 		id: string;
 		url: string;
@@ -309,7 +383,26 @@ export interface WebhookPushEvent {
 	pushed_at: string; // RFC3339 timestamp
 }
 
-export type WebhookEventPayload = WebhookPushEvent;
+export interface WebhookPushEvent {
+	type: 'push';
+	repository: {
+		id: string;
+		url: string;
+	};
+	ref: string;
+	before: string;
+	after: string;
+	customerId: string;
+	pushedAt: Date;
+	rawPushedAt: string;
+}
+
+export interface WebhookUnknownEvent {
+	type: string;
+	raw: unknown;
+}
+
+export type WebhookEventPayload = WebhookPushEvent | WebhookUnknownEvent;
 
 export interface ParsedWebhookSignature {
 	timestamp: string;

package/src/util.ts

@@ -42,21 +42,3 @@ export async function createHmac(algorithm: string, secret: string, data: string
 		.map((b) => b.toString(16).padStart(2, '0'))
 		.join('');
 }
-
-// Keep the legacy async function for backward compatibility
-export async function createHmacAsync(secret: string, data: string): Promise<string> {
-	const crypto = await getEnvironmentCrypto();
-	const encoder = new TextEncoder();
-	const key = await crypto.subtle.importKey(
-		'raw',
-		encoder.encode(secret),
-		{ name: 'HMAC', hash: 'SHA-256' },
-		false,
-		['sign'],
-	);
-
-	const signature = await crypto.subtle.sign('HMAC', key, encoder.encode(data));
-	return Array.from(new Uint8Array(signature))
-		.map((b) => b.toString(16).padStart(2, '0'))
-		.join('');
-}

package/src/webhook.ts

@@ -4,7 +4,9 @@
 
 import type {
 	ParsedWebhookSignature,
+	RawWebhookPushEvent,
 	WebhookEventPayload,
+	WebhookPushEvent,
 	WebhookValidationOptions,
 	WebhookValidationResult,
 } from './types';
@@ -231,9 +233,9 @@ export async function validateWebhook(
 
 	// Parse payload
 	const payloadStr = typeof payload === 'string' ? payload : payload.toString('utf8');
-	let parsedPayload: WebhookEventPayload;
+	let parsedJson: unknown;
 	try {
-		parsedPayload = JSON.parse(payloadStr);
+		parsedJson = JSON.parse(payloadStr);
 	} catch {
 		return {
 			valid: false,
@@ -242,10 +244,80 @@ export async function validateWebhook(
 		};
 	}
 
+	const conversion = convertWebhookPayload(String(eventType), parsedJson);
+	if (!conversion.valid) {
+		return {
+			valid: false,
+			error: conversion.error,
+			timestamp: validationResult.timestamp,
+		};
+	}
+
 	return {
 		valid: true,
 		eventType,
 		timestamp: validationResult.timestamp,
-		payload: parsedPayload,
+		payload: conversion.payload,
 	};
 }
+
+function convertWebhookPayload(
+	eventType: string,
+	raw: unknown,
+): { valid: true; payload: WebhookEventPayload } | { valid: false; error: string } {
+	if (eventType === 'push') {
+		if (!isRawWebhookPushEvent(raw)) {
+			return {
+				valid: false,
+				error: 'Invalid push payload',
+			};
+		}
+		return {
+			valid: true,
+			payload: transformPushEvent(raw),
+		};
+	}
+	const fallbackPayload = { type: eventType, raw };
+	return {
+		valid: true,
+		payload: fallbackPayload,
+	};
+}
+
+function transformPushEvent(raw: RawWebhookPushEvent): WebhookPushEvent {
+	return {
+		type: 'push' as const,
+		repository: {
+			id: raw.repository.id,
+			url: raw.repository.url,
+		},
+		ref: raw.ref,
+		before: raw.before,
+		after: raw.after,
+		customerId: raw.customer_id,
+		pushedAt: new Date(raw.pushed_at),
+		rawPushedAt: raw.pushed_at,
+	};
+}
+
+function isRawWebhookPushEvent(value: unknown): value is RawWebhookPushEvent {
+	if (!isRecord(value)) {
+		return false;
+	}
+	if (!isRecord(value.repository)) {
+		return false;
+	}
+	return (
+		typeof value.repository.id === 'string' &&
+		typeof value.repository.url === 'string' &&
+		typeof value.ref === 'string' &&
+		typeof value.before === 'string' &&
+		typeof value.after === 'string' &&
+		typeof value.customer_id === 'string' &&
+		typeof value.pushed_at === 'string'
+	);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === 'object' && value !== null;
+}