just-git 1.5.13 → 1.6.0

package/dist/server/index.d.ts

@@ -1,5 +1,5 @@
-import { i as ObjectId, X as RawObject, Y as Ref, g as GitRepo, a0 as Rejection, N as NetworkPolicy } from '../hooks-B50z7ycn.js';
-import { C as CommitOptions, a as CommitResult } from '../writing-BYrXF-yM.js';
+import { i as ObjectId, X as RawObject, Y as Ref, g as GitRepo, a0 as Rejection, N as NetworkPolicy } from '../hooks-pZgz2y6k.js';
+import { C as CommitOptions, a as CommitResult } from '../writing-O7uuLVT_.js';
 
 /** Shallow boundary delta: what to add/remove from `.git/shallow`. */
 interface ShallowUpdate {
@@ -19,7 +19,7 @@ interface ShallowUpdate {
 type MaybeAsync<T> = T | Promise<T>;
 /** Options for creating a new repo via `GitServer.createRepo`. */
 interface CreateRepoOptions {
-    /** Name of the default branch (default: `"main"`). Used for HEAD initialization. */
+    /** Default branch name for the initial `HEAD -> refs/heads/<branch>` symref. */
     defaultBranch?: string;
 }
 /**
@@ -59,6 +59,8 @@ interface RefOps {
  * atomic ref operation primitive. All git-aware logic — object hashing,
  * pack ingestion, symref resolution, compare-and-swap semantics — lives
  * in the internal adapter and does not need to be implemented by backends.
+ * Optional batch helpers (`getObjects`, `hasObjects`) let the adapter reduce
+ * round trips during object walks and pack generation, but are not required.
  *
  * All methods use {@link MaybeAsync} return types: sync backends (SQLite)
  * can return values directly, async backends (PostgreSQL) return promises.
@@ -77,20 +79,48 @@ interface Storage {
      * Returns `null` when the object does not exist.
      */
     getObject(repoId: string, hash: string): MaybeAsync<RawObject | null>;
-    /** Store a single git object. `content` is the uncompressed object body (no git header). */
+    /**
+     * Batch-read raw git objects by hash.
+     * Returns only objects that exist for `repoId`, keyed by full hash.
+     * Missing hashes must simply be omitted from the returned map.
+     * Backends should keep the singleton case cheap as well — callers may
+     * sometimes probe one hash at a time, so avoid batch-only overhead such as
+     * per-call query preparation or heavy intermediate allocation.
+     */
+    getObjects?(repoId: string, hashes: ReadonlyArray<string>): MaybeAsync<Map<string, RawObject>>;
+    /**
+     * Store a single git object.
+     *
+     * `content` is the raw object body (no git header / envelope). Because
+     * git objects are immutable, duplicate writes may be ignored.
+     */
     putObject(repoId: string, hash: string, type: string, content: Uint8Array): MaybeAsync<void>;
     /**
      * Bulk-insert objects. Called during pack ingestion (push, fetch).
      * Implementations should use their optimal batch strategy (e.g. a
      * single transaction for SQL backends).
+     *
+     * Returns the hashes newly inserted for `repoId`. Existing rows must not
+     * be reported, even if the same object appears in the incoming batch.
+     * The adapter uses this return value for rejected-push rollback, so it
+     * must reflect only rows created by this call in this repo partition.
      */
     putObjects(repoId: string, objects: ReadonlyArray<{
         hash: string;
         type: string;
         content: Uint8Array;
-    }>): MaybeAsync<void>;
+    }>): MaybeAsync<string[]>;
     /** Check whether an object exists without reading its content. */
     hasObject(repoId: string, hash: string): MaybeAsync<boolean>;
+    /**
+     * Batch existence check for objects.
+     * Returns the subset of `hashes` that exist for `repoId`.
+     * Missing hashes must simply be omitted from the returned set.
+     * As with `getObjects`, implementations should preserve a fast path for
+     * single-hash probes and prefer reusable query plans / statement caches when
+     * the backend benefits from them.
+     */
+    hasObjects?(repoId: string, hashes: ReadonlyArray<string>): MaybeAsync<Set<string>>;
     /**
      * Find all object hashes starting with `prefix` (for short-hash resolution).
      * `prefix` is at least 4 hex characters.
@@ -100,7 +130,9 @@ interface Storage {
     listObjectHashes(repoId: string): MaybeAsync<string[]>;
     /**
      * Delete specific objects by hash.
-     * Returns the number of objects actually deleted.
+     * Returns the number of objects actually deleted from this repo's own
+     * object partition. Fork-aware backends must not treat this as a request
+     * to delete from a parent/shared object partition.
      */
     deleteObjects(repoId: string, hashes: ReadonlyArray<string>): MaybeAsync<number>;
     /**
@@ -123,21 +155,25 @@ interface Storage {
      *
      * The storage backend wraps the callback in whatever isolation
      * mechanism it supports (SQL transaction, in-memory lock, etc.).
-     * The adapter uses this for compare-and-swap with symref resolution.
+     * The adapter uses this for compare-and-swap with symref resolution and
+     * expects all reads/writes inside `fn` to observe the same transaction or
+     * lock scope.
      */
     atomicRefUpdate<T>(repoId: string, fn: (ops: RefOps) => MaybeAsync<T>): MaybeAsync<T>;
     /**
      * Record a fork relationship. `targetId` becomes a fork of `sourceId`.
-     * The adapter layer handles ref copying and root resolution.
+     * The adapter layer handles ref copying and root resolution; this method
+     * only needs to persist the parent relationship.
      */
     forkRepo?(sourceId: string, targetId: string): MaybeAsync<void>;
     /**
-     * Get the parent (root) repo ID for a fork, or `null` if the repo
-     * is not a fork.
+     * Get the root parent repo ID for a fork, or `null` if the repo is not
+     * a fork.
      */
     getForkParent?(repoId: string): MaybeAsync<string | null>;
     /**
-     * List all direct fork IDs of a repo.
+     * List all direct fork IDs of a repo. Used to block deletion of a root
+     * repo while active forks still exist.
      */
     listForks?(repoId: string): MaybeAsync<string[]>;
 }
@@ -629,9 +665,13 @@ interface ServerHooks<A = Auth> {
      */
     postReceive?: (event: PostReceiveEvent<A>) => void | Promise<void>;
     /**
-     * Called when a client wants to fetch or push (during ref advertisement).
-     * Return a filtered ref list to hide branches, a Rejection to deny
-     * access entirely, or void to advertise all refs.
+     * Called during upload-pack / receive-pack ref advertisement.
+     * Return a filtered ref list to hide refs, a Rejection to deny
+     * access to that service entirely, or void to advertise all refs.
+     *
+     * This hook is primarily for ref visibility and coarse service access.
+     * Use `preReceive` / `update` for push authorization and per-ref write
+     * policy.
      */
     advertiseRefs?: (event: AdvertiseRefsEvent<A>) => RefAdvertisement[] | void | Rejection | Promise<RefAdvertisement[] | void | Rejection>;
 }
@@ -989,7 +1029,10 @@ interface ReceivePackResult {
     capabilities: string[];
     /** Whether the request body contained a valid pkt-line flush packet. */
     sawFlush: boolean;
-    /** Hashes of objects ingested from the pack (for rollback on hook rejection). Only populated when the object store supports deferred ingestion (server-backed stores). Undefined for VFS-backed stores. */
+    /**
+     * Hashes newly inserted for this repo while ingesting the pack.
+     * Used for rollback when the push is rejected before any refs apply.
+     */
     ingestedHashes?: string[];
 }
 /**
@@ -998,8 +1041,8 @@ interface ReceivePackResult {
  * call `applyReceivePack` to run hooks and apply refs.
  *
  * Objects are persisted immediately (needed by `buildRefUpdates` for
- * ancestry checks). If hooks later reject the push, `applyReceivePack`
- * rolls back the ingested objects.
+ * ancestry checks). `applyReceivePack` rolls back newly inserted objects
+ * if the push is rejected before any refs apply.
  */
 declare function ingestReceivePack(repo: GitRepo, requestBody: Uint8Array, limits?: ReceivePackLimitOptions): Promise<ReceivePackResult>;
 /**
@@ -1082,13 +1125,15 @@ declare class MemoryStorage implements Storage {
     insertRepo(repoId: string): void;
     deleteRepo(repoId: string): void;
     getObject(repoId: string, hash: string): RawObject | null;
+    getObjects(repoId: string, hashes: ReadonlyArray<string>): Map<string, RawObject>;
     putObject(repoId: string, hash: string, type: string, content: Uint8Array): void;
     putObjects(repoId: string, objects: ReadonlyArray<{
         hash: string;
         type: string;
         content: Uint8Array;
-    }>): void;
+    }>): string[];
     hasObject(repoId: string, hash: string): boolean;
+    hasObjects(repoId: string, hashes: ReadonlyArray<string>): Set<string>;
     findObjectsByPrefix(repoId: string, prefix: string): string[];
     listObjectHashes(repoId: string): string[];
     deleteObjects(repoId: string, hashes: ReadonlyArray<string>): number;
@@ -1129,6 +1174,8 @@ interface BunSqliteDatabase {
 declare class BunSqliteStorage implements Storage {
     private db;
     private stmts;
+    private objectReadManyStatements;
+    private objectExistsManyStatements;
     private batchInsertTx;
     private batchDeleteTx;
     constructor(db: BunSqliteDatabase);
@@ -1136,16 +1183,21 @@ declare class BunSqliteStorage implements Storage {
     insertRepo(repoId: string): void;
     deleteRepo(repoId: string): void;
     getObject(repoId: string, hash: string): RawObject | null;
+    getObjects(repoId: string, hashes: ReadonlyArray<string>): Map<string, RawObject>;
     putObject(repoId: string, hash: string, type: string, content: Uint8Array): void;
     putObjects(repoId: string, objects: ReadonlyArray<{
         hash: string;
         type: string;
         content: Uint8Array;
-    }>): void;
+    }>): string[];
     hasObject(repoId: string, hash: string): boolean;
+    hasObjects(repoId: string, hashes: ReadonlyArray<string>): Set<string>;
     findObjectsByPrefix(repoId: string, prefix: string): string[];
     listObjectHashes(repoId: string): string[];
     deleteObjects(repoId: string, hashes: ReadonlyArray<string>): number;
+    private getObjectReadManyStatement;
+    private getObjectExistsManyStatement;
+    private getCachedStatement;
     getRef(repoId: string, name: string): Ref | null;
     putRef(repoId: string, name: string, ref: Ref): void;
     removeRef(repoId: string, name: string): void;
@@ -1179,6 +1231,8 @@ interface BetterSqlite3Database {
 declare class BetterSqlite3Storage implements Storage {
     private db;
     private stmts;
+    private objectReadManyStatements;
+    private objectExistsManyStatements;
     private batchInsertTx;
     private batchDeleteTx;
     constructor(db: BetterSqlite3Database);
@@ -1186,16 +1240,21 @@ declare class BetterSqlite3Storage implements Storage {
     insertRepo(repoId: string): void;
     deleteRepo(repoId: string): void;
     getObject(repoId: string, hash: string): RawObject | null;
+    getObjects(repoId: string, hashes: ReadonlyArray<string>): Map<string, RawObject>;
     putObject(repoId: string, hash: string, type: string, content: Uint8Array): void;
     putObjects(repoId: string, objects: ReadonlyArray<{
         hash: string;
         type: string;
         content: Uint8Array;
-    }>): void;
+    }>): string[];
     hasObject(repoId: string, hash: string): boolean;
+    hasObjects(repoId: string, hashes: ReadonlyArray<string>): Set<string>;
     findObjectsByPrefix(repoId: string, prefix: string): string[];
     listObjectHashes(repoId: string): string[];
     deleteObjects(repoId: string, hashes: ReadonlyArray<string>): number;
+    private getObjectReadManyStatement;
+    private getObjectExistsManyStatement;
+    private getCachedStatement;
     getRef(repoId: string, name: string): Ref | null;
     putRef(repoId: string, name: string, ref: Ref): void;
     removeRef(repoId: string, name: string): void;
@@ -1239,13 +1298,15 @@ declare class PgStorage implements Storage {
     insertRepo(repoId: string): Promise<void>;
     deleteRepo(repoId: string): Promise<void>;
     getObject(repoId: string, hash: string): Promise<RawObject | null>;
+    getObjects(repoId: string, hashes: ReadonlyArray<string>): Promise<Map<string, RawObject>>;
     putObject(repoId: string, hash: string, type: string, content: Uint8Array): Promise<void>;
     putObjects(repoId: string, objects: ReadonlyArray<{
         hash: string;
         type: string;
         content: Uint8Array;
-    }>): Promise<void>;
+    }>): Promise<string[]>;
     hasObject(repoId: string, hash: string): Promise<boolean>;
+    hasObjects(repoId: string, hashes: ReadonlyArray<string>): Promise<Set<string>>;
     findObjectsByPrefix(repoId: string, prefix: string): Promise<string[]>;
     listObjectHashes(repoId: string): Promise<string[]>;
     deleteObjects(repoId: string, hashes: ReadonlyArray<string>): Promise<number>;
@@ -1312,13 +1373,15 @@ declare class DurableObjectSqliteStorage implements Storage {
     insertRepo(repoId: string): void;
     deleteRepo(repoId: string): void;
     getObject(repoId: string, hash: string): RawObject | null;
+    getObjects(repoId: string, hashes: ReadonlyArray<string>): Map<string, RawObject>;
     putObject(repoId: string, hash: string, type: string, content: Uint8Array): void;
     putObjects(repoId: string, objects: ReadonlyArray<{
         hash: string;
         type: string;
         content: Uint8Array;
-    }>): void;
+    }>): string[];
     hasObject(repoId: string, hash: string): boolean;
+    hasObjects(repoId: string, hashes: ReadonlyArray<string>): Set<string>;
     findObjectsByPrefix(repoId: string, prefix: string): string[];
     listObjectHashes(repoId: string): string[];
     deleteObjects(repoId: string, hashes: ReadonlyArray<string>): number;