@renderinc/sdk 0.2.0 → 0.2.1

package/src/experimental/{blob → object}/client.ts

@@ -2,39 +2,39 @@ import type { Client } from "openapi-fetch";
 import { RenderError } from "../../errors.js";
 import type { paths } from "../../generated/schema.js";
 import type {
-  BlobData,
-  BlobScope,
-  DeleteBlobInput,
-  GetBlobInput,
-  PutBlobInput,
-  PutBlobResult,
+  DeleteObjectInput,
+  GetObjectInput,
+  ObjectData,
+  ObjectScope,
+  PutObjectInput,
+  PutObjectResult,
   Region,
-  ScopedDeleteBlobInput,
-  ScopedGetBlobInput,
-  ScopedPutBlobInput,
+  ScopedDeleteObjectInput,
+  ScopedGetObjectInput,
+  ScopedPutObjectInput,
 } from "./types.js";
 
 /**
- * Layer 3: High-Level Blob Client
+ * Layer 3: High-Level Object Client
  *
  * User-facing API that abstracts presigned URLs completely.
  * Provides simple put/get/delete operations that handle the
  * two-step presigned URL flow internally.
  */
-export class BlobClient {
+export class ObjectClient {
   constructor(private readonly apiClient: Client<paths>) {}
 
   /**
-   * Upload a blob to storage
+   * Upload an object to storage
    *
-   * @param input - Upload parameters including blob identifier and data
+   * @param input - Upload parameters including object identifier and data
    * @returns Result with optional ETag
    *
    * @example
    * ```typescript
    * // Upload a Buffer
    * const data = Buffer.from("binary content");
-   * await blobClient.put({
+   * await objectClient.put({
    *   ownerId: "tea-xxxxx",
    *   region: "oregon",
    *   key: "path/to/file.png",
@@ -45,7 +45,7 @@ export class BlobClient {
    * // Upload from stream
    * const stream = createReadStream("/path/to/file.zip");
    * const stats = statSync("/path/to/file.zip");
-   * await blobClient.put({
+   * await objectClient.put({
    *   ownerId: "tea-xxxxx",
    *   region: "oregon",
    *   key: "file.zip",
@@ -54,7 +54,7 @@ export class BlobClient {
    * });
    * ```
    */
-  async put(input: PutBlobInput): Promise<PutBlobResult> {
+  async put(input: PutObjectInput): Promise<PutObjectResult> {
     // Resolve and validate size
     const size = this.resolveSize(input);
 
@@ -100,25 +100,25 @@ export class BlobClient {
   }
 
   /**
-   * Download a blob from storage
+   * Download an object from storage
    *
-   * @param input - Download parameters including blob identifier
-   * @returns Blob data with content
+   * @param input - Download parameters including object identifier
+   * @returns Object data with content
    *
    * @example
    * ```typescript
-   * const blob = await blobClient.get({
+   * const obj = await objectClient.get({
    *   ownerId: "tea-xxxxx",
    *   region: "oregon",
    *   key: "path/to/file.png"
    * });
    *
-   * console.log(blob.size);           // Size in bytes
-   * console.log(blob.contentType);    // MIME type if available
-   * // blob.data is a Buffer
+   * console.log(obj.size);           // Size in bytes
+   * console.log(obj.contentType);    // MIME type if available
+   * // obj.data is a Buffer
    * ```
    */
-  async get(input: GetBlobInput): Promise<BlobData> {
+  async get(input: GetObjectInput): Promise<ObjectData> {
     // Step 1: Get presigned download URL from Render API
     const { data, error } = await this.apiClient.GET("/blobs/{ownerId}/{region}/{key}", {
       params: {
@@ -152,20 +152,20 @@ export class BlobClient {
   }
 
   /**
-   * Delete a blob from storage
+   * Delete an object from storage
    *
-   * @param input - Delete parameters including blob identifier
+   * @param input - Delete parameters including object identifier
    *
    * @example
    * ```typescript
-   * await blobClient.delete({
+   * await objectClient.delete({
    *   ownerId: "tea-xxxxx",
    *   region: "oregon",
    *   key: "path/to/file.png"
    * });
    * ```
    */
-  async delete(input: DeleteBlobInput): Promise<void> {
+  async delete(input: DeleteObjectInput): Promise<void> {
     // DELETE goes directly to Render API (no presigned URL)
     const { error } = await this.apiClient.DELETE("/blobs/{ownerId}/{region}/{key}", {
       params: {
@@ -178,19 +178,19 @@ export class BlobClient {
     });
 
     if (error) {
-      throw new RenderError(`Failed to delete blob: ${error.message || "Unknown error"}`);
+      throw new RenderError(`Failed to delete object: ${error.message || "Unknown error"}`);
     }
   }
 
   /**
-   * Create a scoped blob client for a specific owner and region
+   * Create a scoped object client for a specific owner and region
    *
    * @param scope - Owner ID and region to scope operations to
-   * @returns Scoped blob client that doesn't require ownerId/region on each call
+   * @returns Scoped object client that doesn't require ownerId/region on each call
    *
    * @example
    * ```typescript
-   * const scoped = blobClient.scoped({
+   * const scoped = objectClient.scoped({
    *   ownerId: "tea-xxxxx",
    *   region: "oregon"
    * });
@@ -201,8 +201,8 @@ export class BlobClient {
    * await scoped.delete({ key: "file.png" });
    * ```
    */
-  scoped(scope: BlobScope): ScopedBlobClient {
-    return new ScopedBlobClient(this.apiClient, scope);
+  scoped(scope: ObjectScope): ScopedObjectClient {
+    return new ScopedObjectClient(this.apiClient, scope);
   }
 
   /**
@@ -211,7 +211,7 @@ export class BlobClient {
    * - For Buffer/Uint8Array: auto-calculate size, validate if provided
    * - For streams/strings: require explicit size
    */
-  private resolveSize(input: PutBlobInput): number {
+  private resolveSize(input: PutObjectInput): number {
     if (Buffer.isBuffer(input.data) || input.data instanceof Uint8Array) {
       const actualSize = input.data.byteLength;
 
@@ -240,30 +240,30 @@ export class BlobClient {
 }
 
 /**
- * Scoped Blob Client
+ * Scoped Object Client
  *
  * Pre-configured client for a specific owner and region.
  * Eliminates the need to specify ownerId and region on every operation.
  */
-export class ScopedBlobClient {
-  private readonly blobClient: BlobClient;
+export class ScopedObjectClient {
+  private readonly objectClient: ObjectClient;
 
   constructor(
     apiClient: Client<paths>,
-    private readonly scope: BlobScope,
+    private readonly scope: ObjectScope,
   ) {
-    this.blobClient = new BlobClient(apiClient);
+    this.objectClient = new ObjectClient(apiClient);
   }
 
   /**
-   * Upload a blob to storage using scoped owner and region
+   * Upload an object to storage using scoped owner and region
    *
    * @param input - Upload parameters (key and data only)
    * @returns Result with optional ETag
    *
    * @example
    * ```typescript
-   * const scoped = blobClient.scoped({ ownerId: "tea-xxxxx", region: "oregon" });
+   * const scoped = objectClient.scoped({ ownerId: "tea-xxxxx", region: "oregon" });
    * await scoped.put({
    *   key: "file.png",
    *   data: Buffer.from("content"),
@@ -271,47 +271,47 @@ export class ScopedBlobClient {
    * });
    * ```
    */
-  async put(input: ScopedPutBlobInput): Promise<PutBlobResult> {
-    return this.blobClient.put({
+  async put(input: ScopedPutObjectInput): Promise<PutObjectResult> {
+    return this.objectClient.put({
       ...this.scope,
       ...input,
-    } as PutBlobInput);
+    } as PutObjectInput);
   }
 
   /**
-   * Download a blob from storage using scoped owner and region
+   * Download an object from storage using scoped owner and region
    *
    * @param input - Download parameters (key only)
-   * @returns Blob data with content
+   * @returns Object data with content
    *
    * @example
    * ```typescript
-   * const scoped = blobClient.scoped({ ownerId: "tea-xxxxx", region: "oregon" });
-   * const blob = await scoped.get({ key: "file.png" });
+   * const scoped = objectClient.scoped({ ownerId: "tea-xxxxx", region: "oregon" });
+   * const obj = await scoped.get({ key: "file.png" });
    * ```
    */
-  async get(input: ScopedGetBlobInput): Promise<BlobData> {
-    return this.blobClient.get({
+  async get(input: ScopedGetObjectInput): Promise<ObjectData> {
+    return this.objectClient.get({
       ...this.scope,
       ...input,
-    } as GetBlobInput);
+    } as GetObjectInput);
   }
 
   /**
-   * Delete a blob from storage using scoped owner and region
+   * Delete an object from storage using scoped owner and region
    *
    * @param input - Delete parameters (key only)
    *
    * @example
    * ```typescript
-   * const scoped = blobClient.scoped({ ownerId: "tea-xxxxx", region: "oregon" });
+   * const scoped = objectClient.scoped({ ownerId: "tea-xxxxx", region: "oregon" });
    * await scoped.delete({ key: "file.png" });
    * ```
    */
-  async delete(input: ScopedDeleteBlobInput): Promise<void> {
-    return this.blobClient.delete({
+  async delete(input: ScopedDeleteObjectInput): Promise<void> {
+    return this.objectClient.delete({
       ...this.scope,
       ...input,
-    } as DeleteBlobInput);
+    } as DeleteObjectInput);
   }
 }

package/src/experimental/object/index.ts

@@ -0,0 +1,22 @@
+// Object storage client exports
+export { ObjectApi } from "./api.js";
+export { ObjectClient, ScopedObjectClient } from "./client.js";
+// Type exports
+export type {
+  DeleteObjectInput,
+  GetObjectInput,
+  ObjectData,
+  ObjectIdentifier,
+  ObjectScope,
+  PresignedDownloadUrl,
+  PresignedUploadUrl,
+  PutObjectInput,
+  PutObjectInputBuffer,
+  PutObjectInputStream,
+  PutObjectResult,
+  ScopedDeleteObjectInput,
+  ScopedGetObjectInput,
+  ScopedPutObjectInput,
+} from "./types.js";
+// Re-export the Region enum (both type and value)
+export { Region } from "./types.js";

package/src/experimental/object/types.test.ts

@@ -0,0 +1,87 @@
+import type { Readable } from "node:stream";
+import type {
+  DeleteObjectInput,
+  GetObjectInput,
+  ObjectIdentifier,
+  ObjectScope,
+  PutObjectInput,
+  PutObjectInputBuffer,
+  PutObjectInputStream,
+  ScopedDeleteObjectInput,
+  ScopedGetObjectInput,
+  ScopedPutObjectInput,
+} from "./types.js";
+
+describe("PutObjectInput discriminated union", () => {
+  it("accepts buffer variant", () => {
+    const input: PutObjectInput = {
+      ownerId: "tea-123",
+      region: "frankfurt",
+      key: "test.txt",
+      data: Buffer.from("hello"),
+    };
+    expectTypeOf(input).toMatchTypeOf<PutObjectInput>();
+  });
+
+  it("accepts stream variant with required size", () => {
+    const input: PutObjectInput = {
+      ownerId: "tea-123",
+      region: "frankfurt",
+      key: "test.txt",
+      data: {} as Readable,
+      size: 100,
+    };
+    expectTypeOf(input).toMatchTypeOf<PutObjectInput>();
+  });
+
+  it("union includes both variants", () => {
+    expectTypeOf<PutObjectInput>().toMatchTypeOf<PutObjectInputBuffer | PutObjectInputStream>();
+  });
+});
+
+describe("ObjectIdentifier type", () => {
+  it("requires tea- prefix on ownerId", () => {
+    expectTypeOf<ObjectIdentifier["ownerId"]>().toEqualTypeOf<`tea-${string}`>();
+  });
+
+  it("has required key property", () => {
+    expectTypeOf<ObjectIdentifier>().toHaveProperty("key");
+    expectTypeOf<ObjectIdentifier["key"]>().toEqualTypeOf<string>();
+  });
+});
+
+describe("Scoped types omit ObjectScope fields", () => {
+  it("ScopedPutObjectInput omits ownerId and region", () => {
+    expectTypeOf<ScopedPutObjectInput>().not.toHaveProperty("ownerId");
+    expectTypeOf<ScopedPutObjectInput>().not.toHaveProperty("region");
+    expectTypeOf<ScopedPutObjectInput>().toHaveProperty("key");
+    expectTypeOf<ScopedPutObjectInput>().toHaveProperty("data");
+  });
+
+  it("ScopedGetObjectInput omits ownerId and region", () => {
+    expectTypeOf<ScopedGetObjectInput>().not.toHaveProperty("ownerId");
+    expectTypeOf<ScopedGetObjectInput>().not.toHaveProperty("region");
+    expectTypeOf<ScopedGetObjectInput>().toHaveProperty("key");
+  });
+
+  it("ScopedDeleteObjectInput omits ownerId and region", () => {
+    expectTypeOf<ScopedDeleteObjectInput>().not.toHaveProperty("ownerId");
+    expectTypeOf<ScopedDeleteObjectInput>().not.toHaveProperty("region");
+    expectTypeOf<ScopedDeleteObjectInput>().toHaveProperty("key");
+  });
+
+  it("ObjectScope has ownerId and region", () => {
+    expectTypeOf<ObjectScope>().toHaveProperty("ownerId");
+    expectTypeOf<ObjectScope>().toHaveProperty("region");
+  });
+});
+
+describe("GetObjectInput and DeleteObjectInput extend ObjectIdentifier", () => {
+  it("GetObjectInput matches ObjectIdentifier", () => {
+    expectTypeOf<GetObjectInput>().toMatchTypeOf<ObjectIdentifier>();
+  });
+
+  it("DeleteObjectInput matches ObjectIdentifier", () => {
+    expectTypeOf<DeleteObjectInput>().toMatchTypeOf<ObjectIdentifier>();
+  });
+});

package/src/experimental/{blob → object}/types.ts

@@ -1,35 +1,35 @@
 import type { Readable } from "node:stream";
 
 /**
- * Supported regions for blob storage
+ * Supported regions for object storage
  */
 export type Region = "frankfurt" | "oregon" | "ohio" | "singapore" | "virginia";
 
 /**
- * Base identifier for a blob object
+ * Base identifier for a storage object
  */
-export interface BlobIdentifier {
+export interface ObjectIdentifier {
   /** Owner ID (workspace team ID) in format tea-xxxxx */
   ownerId: `tea-${string}`;
-  /** Region where the blob is stored */
+  /** Region where the object is stored */
   region: Region | string;
-  /** Object key (path) for the blob */
+  /** Object key (path) for the object */
   key: string;
 }
 
 /**
- * Base options for putting a blob
+ * Base options for putting an object
  */
-interface PutBlobInputBase extends BlobIdentifier {
+interface PutObjectInputBase extends ObjectIdentifier {
   /** MIME type of the content (optional, will be auto-detected if not provided) */
   contentType?: string;
 }
 
 /**
- * Put blob input for Buffer, Uint8Array, or string data
+ * Put object input for Buffer, Uint8Array, or string data
  * Size is optional and will be auto-calculated
  */
-export interface PutBlobInputBuffer extends PutBlobInputBase {
+export interface PutObjectInputBuffer extends PutObjectInputBase {
   /** Binary data as Buffer, Uint8Array, or string */
   data: Buffer | Uint8Array | string;
   /** Size in bytes (optional, auto-calculated for Buffer/Uint8Array) */
@@ -37,10 +37,10 @@ export interface PutBlobInputBuffer extends PutBlobInputBase {
 }
 
 /**
- * Put blob input for readable streams
+ * Put object input for readable streams
  * Size is required for streams
  */
-export interface PutBlobInputStream extends PutBlobInputBase {
+export interface PutObjectInputStream extends PutObjectInputBase {
   /** Readable stream */
   data: Readable;
   /** Size in bytes (required for streams) */
@@ -48,20 +48,20 @@ export interface PutBlobInputStream extends PutBlobInputBase {
 }
 
 /**
- * Input for uploading a blob
+ * Input for uploading an object
  * Discriminated union: size is optional for Buffer/Uint8Array, required for streams
  */
-export type PutBlobInput = PutBlobInputBuffer | PutBlobInputStream;
+export type PutObjectInput = PutObjectInputBuffer | PutObjectInputStream;
 
 /**
- * Input for downloading a blob
+ * Input for downloading an object
  */
-export interface GetBlobInput extends BlobIdentifier {}
+export interface GetObjectInput extends ObjectIdentifier {}
 
 /**
- * Input for deleting a blob
+ * Input for deleting an object
  */
-export interface DeleteBlobInput extends BlobIdentifier {}
+export interface DeleteObjectInput extends ObjectIdentifier {}
 
 /**
  * Presigned URL for uploading
@@ -86,9 +86,9 @@ export interface PresignedDownloadUrl {
 }
 
 /**
- * Downloaded blob data
+ * Downloaded object data
  */
-export interface BlobData {
+export interface ObjectData {
   /** Binary content */
   data: Buffer;
   /** MIME type if available */
@@ -98,34 +98,34 @@ export interface BlobData {
 }
 
 /**
- * Result from uploading a blob
+ * Result from uploading an object
  */
-export interface PutBlobResult {
+export interface PutObjectResult {
   /** ETag from storage provider */
   etag?: string;
 }
 
 /**
- * Scope configuration for scoped blob client
+ * Scope configuration for scoped object client
  */
-export interface BlobScope {
+export interface ObjectScope {
   /** Owner ID (workspace team ID) in format tea-xxxxx */
   ownerId: `tea-${string}`;
-  /** Region where the blob is stored */
+  /** Region where the object is stored */
   region: Region | string;
 }
 
 /**
- * Scoped input for uploading a blob (without ownerId/region)
+ * Scoped input for uploading an object (without ownerId/region)
  */
-export type ScopedPutBlobInput = Omit<PutBlobInput, keyof BlobScope>;
+export type ScopedPutObjectInput = Omit<PutObjectInput, keyof ObjectScope>;
 
 /**
- * Scoped input for downloading a blob (without ownerId/region)
+ * Scoped input for downloading an object (without ownerId/region)
  */
-export type ScopedGetBlobInput = Omit<GetBlobInput, keyof BlobScope>;
+export type ScopedGetObjectInput = Omit<GetObjectInput, keyof ObjectScope>;
 
 /**
- * Scoped input for deleting a blob (without ownerId/region)
+ * Scoped input for deleting an object (without ownerId/region)
  */
-export type ScopedDeleteBlobInput = Omit<DeleteBlobInput, keyof BlobScope>;
+export type ScopedDeleteObjectInput = Omit<DeleteObjectInput, keyof ObjectScope>;