just-git 1.1.11 → 1.2.3

package/dist/server/index.d.ts

@@ -1,4 +1,4 @@
-import { f as GitRepo, X as Rejection } from '../hooks-OMCbhUGB.js';
+import { f as GitRepo, X as Rejection } from '../hooks-4DvkF2xT.js';
 
 interface GitServerConfig {
     /**
@@ -37,6 +37,14 @@ interface GitServerConfig {
         /** Delta window size (default 10). Smaller = faster, worse compression ratio. */
         deltaWindow?: number;
     };
+    /**
+     * Called when the server catches an unhandled error.
+     *
+     * Defaults to logging `err.message` (no stack trace) to `console.error`.
+     * Override to integrate with your own logging, or set to `false` to
+     * suppress all error output.
+     */
+    onError?: false | ((err: unknown, request: Request) => void);
 }
 interface GitServer {
     /** Standard fetch-API handler: (Request) => Response */
@@ -67,32 +75,43 @@ interface ServerHooks {
      */
     advertiseRefs?: (event: AdvertiseRefsEvent) => RefAdvertisement[] | void | Promise<RefAdvertisement[] | void>;
 }
+/** A single ref update within a push. */
 interface RefUpdate {
+    /** Full ref name, e.g. "refs/heads/main". */
     ref: string;
+    /** Previous hash, or null if creating a new ref. */
     oldHash: string | null;
+    /** New hash being pushed. */
     newHash: string;
+    /** Whether the update is a fast-forward. */
     isFF: boolean;
+    /** Whether this creates a new ref. */
     isCreate: boolean;
+    /** Whether this deletes an existing ref. */
     isDelete: boolean;
 }
+/** Fired after objects are unpacked but before refs are updated. */
 interface PreReceiveEvent {
     repo: GitRepo;
     repoPath: string;
     updates: readonly RefUpdate[];
     request: Request;
 }
+/** Fired per-ref after preReceive passes. */
 interface UpdateEvent {
     repo: GitRepo;
     repoPath: string;
     update: RefUpdate;
     request: Request;
 }
+/** Fired after all ref updates succeed. */
 interface PostReceiveEvent {
     repo: GitRepo;
     repoPath: string;
     updates: readonly RefUpdate[];
     request: Request;
 }
+/** Fired during ref advertisement (info/refs). */
 interface AdvertiseRefsEvent {
     repo: GitRepo;
     repoPath: string;
@@ -100,6 +119,7 @@ interface AdvertiseRefsEvent {
     service: "git-upload-pack" | "git-receive-pack";
     request: Request;
 }
+/** A ref name and hash advertised to clients during fetch/push discovery. */
 interface RefAdvertisement {
     name: string;
     hash: string;
@@ -161,94 +181,33 @@ declare function toNodeHandler(server: GitServer): (req: NodeHttpRequest, res: N
 declare function composeHooks(...hookSets: (ServerHooks | undefined)[]): ServerHooks;
 
 /**
- * High-level server operations for Git Smart HTTP.
- *
- * Each operation accepts a `GitRepo` (ObjectStore + RefStore)
- * and returns protocol-level results. The handler layer is
- * responsible for hook invocation and ref application.
+ * Opinionated hook presets built on top of the minimal ServerHooks interface.
  */
 
-interface PackCacheEntry {
-    packData: Uint8Array;
-    objectCount: number;
-    deltaCount: number;
-}
+type ResolveRepo = GitServerConfig["resolveRepo"];
 /**
- * Bounded LRU-ish cache for generated packfiles.
+ * Wrap a `resolveRepo` function with an authorization check that
+ * gates **all** access (clone, fetch, and push).
  *
- * Keyed on `(repoPath, sorted wants)` — only caches full clones
- * (requests with no `have` lines). Incremental fetches always
- * compute fresh packs.
+ * The `authorize` callback receives the raw `Request` and returns:
+ * - `true` — request is allowed, delegate to the inner `resolveRepo`
+ * - `false` — respond with 403 Forbidden
+ * - `Response` — send as-is (e.g. 401 with `WWW-Authenticate` header)
  *
- * Entries are automatically invalidated when refs change: since the
- * cache key includes the exact want hashes, a ref update changes
- * the want set on the next client request, producing a cache miss.
- */
-declare class PackCache {
-    private entries;
-    private currentBytes;
-    private maxBytes;
-    private hits;
-    private misses;
-    constructor(maxBytes?: number);
-    /** Build a cache key. Returns null for requests with haves (not cacheable). */
-    static key(repoPath: string, wants: string[], haves: string[]): string | null;
-    get(key: string): PackCacheEntry | undefined;
-    set(key: string, entry: PackCacheEntry): void;
-    get stats(): {
-        entries: number;
-        bytes: number;
-        hits: number;
-        misses: number;
-    };
-}
-interface RefsData {
-    refs: RefAdvertisement[];
-    headTarget?: string;
-}
-/**
- * Collect the structured ref list from a repo (no wire encoding).
- * The handler can pass this through an advertiseRefs hook to filter,
- * then call `buildRefAdvertisementBytes` to produce the wire format.
- */
-declare function collectRefs(repo: GitRepo): Promise<RefsData>;
-/**
- * Build the wire-format ref advertisement from a (possibly filtered) ref list.
- */
-declare function buildRefAdvertisementBytes(refs: RefAdvertisement[], service: "git-upload-pack" | "git-receive-pack", headTarget?: string): Uint8Array;
-interface UploadPackOptions {
-    /** Pack cache instance. When provided, full clones (no haves) are cached. */
-    cache?: PackCache;
-    /** Repo path used as part of the cache key. Required when cache is set. */
-    cacheKey?: string;
-    /** Skip delta compression — faster pack generation, larger output. */
-    noDelta?: boolean;
-    /** Delta window size (default 10). Ignored when noDelta is true. */
-    deltaWindow?: number;
-}
-/**
- * Handle a `POST /git-upload-pack` request.
+ * For push-only authorization, use `createStandardHooks({ authorizePush })`.
+ * The two compose naturally:
  *
- * Returns `Uint8Array` for buffered responses (cache hits, deltified packs)
- * or `ReadableStream<Uint8Array>` for streaming no-delta responses.
- */
-declare function handleUploadPack(repo: GitRepo, requestBody: Uint8Array, options?: UploadPackOptions): Promise<Uint8Array | ReadableStream<Uint8Array>>;
-interface ReceivePackResult {
-    updates: RefUpdate[];
-    unpackOk: boolean;
-    capabilities: string[];
-}
-/**
- * Ingest a receive-pack request: parse commands, ingest the packfile,
- * and compute enriched RefUpdate objects. Does NOT apply ref updates —
- * the handler runs hooks first, then applies surviving updates.
- */
-declare function ingestReceivePack(repo: GitRepo, requestBody: Uint8Array): Promise<ReceivePackResult>;
-
-/**
- * Opinionated hook presets built on top of the minimal ServerHooks interface.
+ * ```ts
+ * const server = createGitServer({
+ *   resolveRepo: withAuth(
+ *     (req) => req.headers.get("Authorization") === `Bearer ${token}`,
+ *     (repoPath) => storage.repo(repoPath),
+ *   ),
+ *   hooks: createStandardHooks({ protectedBranches: ["main"] }),
+ * });
+ * ```
  */
-
+declare function withAuth(authorize: (request: Request) => boolean | Response | Promise<boolean | Response>, resolveRepo: ResolveRepo): ResolveRepo;
 interface StandardHooksConfig {
     /** Branches that cannot be force-pushed to or deleted. */
     protectedBranches?: string[];
@@ -275,7 +234,7 @@ declare function createStandardHooks(config: StandardHooksConfig): ServerHooks;
 /**
  * Abstract storage backend for multi-repo git object and ref storage.
  *
- * Implemented by `SqliteStorage` and `PgStorage`.
+ * Implemented by `BunSqliteStorage`, `BetterSqlite3Storage`, and `PgStorage`.
  */
 interface Storage {
     /** Get a `GitRepo` scoped to a specific repo. */
@@ -306,76 +265,79 @@ declare class MemoryStorage implements Storage {
     private getRefs;
 }
 
-interface SqliteStatement {
+/** Minimal prepared statement interface matching `bun:sqlite`. */
+interface BunSqliteStatement {
     run(...params: any[]): void;
     get(...params: any[]): any;
     all(...params: any[]): any[];
 }
-interface SqliteDatabase {
+/** Minimal database interface matching `bun:sqlite`'s `Database` class. */
+interface BunSqliteDatabase {
     run(sql: string): void;
-    prepare(sql: string): SqliteStatement;
+    prepare(sql: string): BunSqliteStatement;
     transaction<F extends (...args: any[]) => any>(fn: F): (...args: Parameters<F>) => ReturnType<F>;
 }
+/**
+ * SQLite-backed git storage using `bun:sqlite`.
+ *
+ * ```ts
+ * import { Database } from "bun:sqlite";
+ * const storage = new BunSqliteStorage(new Database("repos.db"));
+ * ```
+ */
+declare class BunSqliteStorage implements Storage {
+    private db;
+    private stmts;
+    private ingestTx;
+    constructor(db: BunSqliteDatabase);
+    repo(repoId: string): GitRepo;
+    deleteRepo(repoId: string): Promise<void>;
+}
+
+/** Minimal prepared statement interface matching `better-sqlite3`. */
 interface BetterSqlite3Statement {
     run(...params: any[]): any;
     get(...params: any[]): any;
     all(...params: any[]): any[];
 }
+/** Minimal database interface matching the `better-sqlite3` `Database` class. */
 interface BetterSqlite3Database {
     exec(sql: string): any;
     prepare(sql: string): BetterSqlite3Statement;
     transaction<F extends (...args: any[]) => any>(fn: F): (...args: Parameters<F>) => ReturnType<F>;
 }
 /**
- * Wrap a `better-sqlite3` database into a `SqliteDatabase`.
- *
- * Adapts `exec` → `run` and coerces `get` results from `undefined`
- * to `null` to match the `bun:sqlite` convention.
+ * SQLite-backed git storage using `better-sqlite3`.
  *
  * ```ts
  * import Database from "better-sqlite3";
- * const db = wrapBetterSqlite3(new Database("repos.sqlite"));
- * const storage = new SqliteStorage(db);
+ * const storage = new BetterSqlite3Storage(new Database("repos.db"));
  * ```
  */
-declare function wrapBetterSqlite3(raw: BetterSqlite3Database): SqliteDatabase;
-/**
- * SQLite-backed git storage with multi-repo support.
- *
- * Creates and manages `git_objects` and `git_refs` tables in the
- * provided database. Multiple repos are partitioned by `repo_id`.
- *
- * ```ts
- * const db = new Database("repos.sqlite");
- * const storage = new SqliteStorage(db);
- * const server = createGitServer({
- *   resolve: async (repoPath) => storage.repo(repoPath),
- * });
- * ```
- */
-declare class SqliteStorage implements Storage {
+declare class BetterSqlite3Storage implements Storage {
     private db;
     private stmts;
     private ingestTx;
-    constructor(db: SqliteDatabase);
-    /** Get a `GitRepo` scoped to a specific repo. */
+    constructor(db: BetterSqlite3Database);
     repo(repoId: string): GitRepo;
-    /** Delete all objects and refs for a repo. */
     deleteRepo(repoId: string): Promise<void>;
 }
 
+/** Minimal database interface for PostgreSQL. Use {@link wrapPgPool} to adapt a `pg` Pool. */
 interface PgDatabase {
     query<T = any>(text: string, values?: any[]): Promise<{
         rows: T[];
     }>;
     transaction<R>(fn: (tx: PgDatabase) => Promise<R>): Promise<R>;
 }
+/** Minimal pool interface matching the `pg` package's `Pool` class. */
 interface PgPool {
     query(text: string, values?: any[]): Promise<{
         rows: any[];
     }>;
     connect(): Promise<PgPoolClient>;
 }
+/** Minimal pool client interface matching the `pg` package's `PoolClient`. */
 interface PgPoolClient {
     query(text: string, values?: any[]): Promise<{
         rows: any[];
@@ -421,4 +383,4 @@ declare class PgStorage implements Storage {
     deleteRepo(repoId: string): Promise<void>;
 }
 
-export { type AdvertiseRefsEvent, type BetterSqlite3Database, type BetterSqlite3Statement, type GitServer, type GitServerConfig, MemoryStorage, type NodeHttpRequest, type NodeHttpResponse, PackCache, type PgDatabase, type PgPool, type PgPoolClient, PgStorage, type PostReceiveEvent, type PreReceiveEvent, type ReceivePackResult, type RefAdvertisement, type RefUpdate, type RefsData, Rejection, type ServerHooks, type SqliteDatabase, type SqliteStatement, SqliteStorage, type StandardHooksConfig, type Storage, type UpdateEvent, type UploadPackOptions, buildRefAdvertisementBytes, collectRefs, composeHooks, createGitServer, createStandardHooks, handleUploadPack, ingestReceivePack, toNodeHandler, wrapBetterSqlite3, wrapPgPool };
+export { type AdvertiseRefsEvent, type BetterSqlite3Database, type BetterSqlite3Statement, BetterSqlite3Storage, type BunSqliteDatabase, type BunSqliteStatement, BunSqliteStorage, type GitServer, type GitServerConfig, MemoryStorage, type PgDatabase, type PgPool, type PgPoolClient, PgStorage, type PostReceiveEvent, type PreReceiveEvent, type RefAdvertisement, type RefUpdate, Rejection, type ServerHooks, type StandardHooksConfig, type Storage, type UpdateEvent, composeHooks, createGitServer, createStandardHooks, toNodeHandler, withAuth, wrapPgPool };