@pierre/storage 0.2.1 → 0.2.3

package/README.md

@@ -76,6 +76,26 @@ const readOnlyUrl = await repo.getRemoteURL({
 // - 'repo:write' - Create a repository
 ```
 
+#### Ephemeral Branches
+
+For working with ephemeral branches (temporary branches isolated from the main repository), use
+`getEphemeralRemote()`:
+
+```typescript
+// Get ephemeral namespace remote URL
+const ephemeralUrl = await repo.getEphemeralRemoteURL();
+// Returns: https://t:JWT@your-name.code.storage/repo-id+ephemeral.git
+
+// Configure separate remotes for default and ephemeral branches
+console.log(`Run: git remote add origin ${await repo.getRemoteURL()}`);
+console.log(`Run: git remote add ephemeral ${await repo.getEphemeralRemoteURL()}`);
+
+// Push ephemeral branch
+// git push ephemeral feature-branch
+
+// The ephemeral remote supports all the same options and permission as regular remotes
+```
+
 ### Working with Repository Content
 
 Once you have a repository instance, you can perform various Git operations:
@@ -129,6 +149,15 @@ const commitDiff = await repo.getCommitDiff({
 console.log(commitDiff.stats);
 console.log(commitDiff.files);
 
+// Create a new branch from an existing one
+const branch = await repo.createBranch({
+  baseBranch: 'main',
+  targetBranch: 'feature/demo',
+  // baseIsEphemeral: true,
+  // targetIsEphemeral: true,
+});
+console.log(branch.targetBranch, branch.commitSha);
+
 // Create a commit using the streaming helper
 const fs = await import('node:fs/promises');
 const result = await repo
@@ -281,6 +310,7 @@ interface FindOneOptions {
 interface Repo {
   id: string;
   getRemoteURL(options?: GetRemoteURLOptions): Promise<string>;
+  getEphemeralRemoteURL(options?: GetRemoteURLOptions): Promise<string>;
 
   getFileStream(options: GetFileOptions): Promise<Response>;
   listFiles(options?: ListFilesOptions): Promise<ListFilesResult>;

package/dist/index.cjs

@@ -110,6 +110,12 @@ var commitDiffResponseSchema = zod.z.object({
   files: zod.z.array(diffFileRawSchema),
   filtered_files: zod.z.array(filteredFileRawSchema)
 });
+var createBranchResponseSchema = zod.z.object({
+  message: zod.z.string(),
+  target_branch: zod.z.string(),
+  target_is_ephemeral: zod.z.boolean(),
+  commit_sha: zod.z.string().nullable().optional()
+});
 var refUpdateResultSchema = zod.z.object({
   branch: zod.z.string(),
   old_sha: zod.z.string(),
@@ -1491,6 +1497,14 @@ function transformCommitDiffResult(raw) {
     filteredFiles: raw.filtered_files.map(transformFilteredFile)
   };
 }
+function transformCreateBranchResult(raw) {
+  return {
+    message: raw.message,
+    targetBranch: raw.target_branch,
+    targetIsEphemeral: raw.target_is_ephemeral,
+    commitSha: raw.commit_sha ?? void 0
+  };
+}
 var RepoImpl = class {
   constructor(id, options, generateJWT) {
     this.id = id;
@@ -1509,6 +1523,13 @@ var RepoImpl = class {
     url.password = await this.generateJWT(this.id, urlOptions);
     return url.toString();
   }
+  async getEphemeralRemoteURL(urlOptions) {
+    const storageBaseUrl = this.options.storageBaseUrl ?? STORAGE_BASE_URL;
+    const url = new URL(`https://${this.options.name}.${storageBaseUrl}/${this.id}+ephemeral.git`);
+    url.username = `t`;
+    url.password = await this.generateJWT(this.id, urlOptions);
+    return url.toString();
+  }
   async getFileStream(options) {
     const ttl = resolveInvocationTtlSeconds(options, DEFAULT_TOKEN_TTL_SECONDS);
     const jwt = await this.generateJWT(this.id, {
@@ -1626,7 +1647,7 @@ var RepoImpl = class {
     const raw = commitDiffResponseSchema.parse(await response.json());
     return transformCommitDiffResult(raw);
   }
-  async pullUpstream(options) {
+  async pullUpstream(options = {}) {
     const ttl = resolveInvocationTtlSeconds(options, DEFAULT_TOKEN_TTL_SECONDS);
     const jwt = await this.generateJWT(this.id, {
       permissions: ["git:write"],
@@ -1642,6 +1663,34 @@ var RepoImpl = class {
     }
     return;
   }
+  async createBranch(options) {
+    const baseBranch = options?.baseBranch?.trim();
+    if (!baseBranch) {
+      throw new Error("createBranch baseBranch is required");
+    }
+    const targetBranch = options?.targetBranch?.trim();
+    if (!targetBranch) {
+      throw new Error("createBranch targetBranch is required");
+    }
+    const ttl = resolveInvocationTtlSeconds(options, DEFAULT_TOKEN_TTL_SECONDS);
+    const jwt = await this.generateJWT(this.id, {
+      permissions: ["git:write"],
+      ttl
+    });
+    const body = {
+      base_branch: baseBranch,
+      target_branch: targetBranch
+    };
+    if (options.baseIsEphemeral === true) {
+      body.base_is_ephemeral = true;
+    }
+    if (options.targetIsEphemeral === true) {
+      body.target_is_ephemeral = true;
+    }
+    const response = await this.api.post({ path: "repos/branches/create", body }, jwt);
+    const raw = createBranchResponseSchema.parse(await response.json());
+    return transformCreateBranchResult(raw);
+  }
   async restoreCommit(options) {
     const targetBranch = options?.targetBranch?.trim();
     if (!targetBranch) {