@stack0/sdk 0.2.0

package/dist/cdn/index.d.ts

@@ -0,0 +1,322 @@
+import { H as HttpClientConfig } from '../http-client-Wr9lXo9_.js';
+
+/**
+ * Type definitions for Stack0 CDN API
+ */
+type AssetStatus = "pending" | "processing" | "ready" | "failed" | "deleted";
+type AssetType = "image" | "video" | "audio" | "document" | "other";
+interface Asset {
+    id: string;
+    filename: string;
+    originalFilename: string;
+    mimeType: string;
+    size: number;
+    type: AssetType;
+    s3Key: string;
+    cdnUrl: string;
+    width: number | null;
+    height: number | null;
+    duration: number | null;
+    status: AssetStatus;
+    folder: string | null;
+    tags: string[] | null;
+    metadata: Record<string, unknown> | null;
+    alt: string | null;
+    createdAt: Date;
+    updatedAt: Date | null;
+}
+interface UploadUrlRequest {
+    projectSlug: string;
+    filename: string;
+    mimeType: string;
+    size: number;
+    folder?: string;
+    metadata?: Record<string, unknown>;
+}
+interface UploadUrlResponse {
+    uploadUrl: string;
+    assetId: string;
+    cdnUrl: string;
+    expiresAt: Date;
+}
+interface ConfirmUploadRequest {
+    assetId: string;
+}
+interface ConfirmUploadResponse {
+    asset: Asset;
+}
+interface GetAssetRequest {
+    id: string;
+}
+interface UpdateAssetRequest {
+    id: string;
+    filename?: string;
+    folder?: string;
+    tags?: string[];
+    alt?: string;
+    metadata?: Record<string, unknown>;
+}
+interface DeleteAssetRequest {
+    id: string;
+}
+interface DeleteAssetsRequest {
+    ids: string[];
+}
+interface DeleteAssetsResponse {
+    success: boolean;
+    deletedCount: number;
+}
+interface ListAssetsRequest {
+    projectSlug: string;
+    folder?: string | null;
+    type?: AssetType;
+    status?: AssetStatus;
+    search?: string;
+    tags?: string[];
+    sortBy?: "createdAt" | "filename" | "size" | "type";
+    sortOrder?: "asc" | "desc";
+    limit?: number;
+    offset?: number;
+}
+interface ListAssetsResponse {
+    assets: Asset[];
+    total: number;
+    hasMore: boolean;
+}
+interface MoveAssetsRequest {
+    assetIds: string[];
+    folder: string | null;
+}
+interface MoveAssetsResponse {
+    success: boolean;
+    movedCount: number;
+}
+interface TransformOptions {
+    width?: number;
+    height?: number;
+    fit?: "cover" | "contain" | "fill" | "inside" | "outside";
+    format?: "webp" | "jpeg" | "png" | "avif";
+    quality?: number;
+}
+interface GetTransformUrlRequest {
+    assetId: string;
+    options: TransformOptions;
+}
+interface GetTransformUrlResponse {
+    url: string;
+    originalUrl: string;
+    width?: number;
+    height?: number;
+    format?: string;
+}
+interface FolderTreeNode {
+    id: string;
+    name: string;
+    path: string;
+    assetCount: number;
+    children: FolderTreeNode[];
+}
+interface GetFolderTreeRequest {
+    projectSlug: string;
+    maxDepth?: number;
+}
+interface CreateFolderRequest {
+    projectSlug: string;
+    name: string;
+    parentId?: string;
+}
+interface Folder {
+    id: string;
+    name: string;
+    path: string;
+    parentId: string | null;
+    assetCount: number;
+    totalSize: number;
+    createdAt: Date;
+    updatedAt: Date | null;
+}
+
+/**
+ * Stack0 CDN Client
+ * Upload, manage, and transform assets
+ */
+
+declare class CDN {
+    private http;
+    constructor(config: HttpClientConfig);
+    /**
+     * Generate a presigned URL for uploading a file
+     *
+     * @example
+     * ```typescript
+     * const { uploadUrl, assetId } = await cdn.getUploadUrl({
+     *   projectSlug: 'my-project',
+     *   filename: 'image.jpg',
+     *   mimeType: 'image/jpeg',
+     *   size: 1024 * 1024,
+     * });
+     *
+     * // Upload file to the presigned URL
+     * await fetch(uploadUrl, {
+     *   method: 'PUT',
+     *   body: file,
+     *   headers: { 'Content-Type': 'image/jpeg' },
+     * });
+     *
+     * // Confirm the upload
+     * const asset = await cdn.confirmUpload(assetId);
+     * ```
+     */
+    getUploadUrl(request: UploadUrlRequest): Promise<UploadUrlResponse>;
+    /**
+     * Confirm that an upload has completed
+     */
+    confirmUpload(assetId: string): Promise<Asset>;
+    /**
+     * Upload a file directly (handles presigned URL flow automatically)
+     *
+     * @example
+     * ```typescript
+     * const asset = await cdn.upload({
+     *   projectSlug: 'my-project',
+     *   file: fileBuffer,
+     *   filename: 'image.jpg',
+     *   mimeType: 'image/jpeg',
+     * });
+     * ```
+     */
+    upload(options: {
+        projectSlug: string;
+        file: Blob | Buffer | ArrayBuffer;
+        filename: string;
+        mimeType: string;
+        folder?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<Asset>;
+    /**
+     * Get an asset by ID
+     *
+     * @example
+     * ```typescript
+     * const asset = await cdn.get('asset-id');
+     * console.log(asset.cdnUrl);
+     * ```
+     */
+    get(id: string): Promise<Asset>;
+    /**
+     * Update asset metadata
+     *
+     * @example
+     * ```typescript
+     * const asset = await cdn.update({
+     *   id: 'asset-id',
+     *   alt: 'A beautiful sunset',
+     *   tags: ['nature', 'sunset'],
+     * });
+     * ```
+     */
+    update(request: UpdateAssetRequest): Promise<Asset>;
+    /**
+     * Delete an asset
+     *
+     * @example
+     * ```typescript
+     * await cdn.delete('asset-id');
+     * ```
+     */
+    delete(id: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Delete multiple assets
+     *
+     * @example
+     * ```typescript
+     * const result = await cdn.deleteMany(['asset-1', 'asset-2']);
+     * console.log(`Deleted ${result.deletedCount} assets`);
+     * ```
+     */
+    deleteMany(ids: string[]): Promise<DeleteAssetsResponse>;
+    /**
+     * List assets with filters and pagination
+     *
+     * @example
+     * ```typescript
+     * const { assets, total, hasMore } = await cdn.list({
+     *   projectSlug: 'my-project',
+     *   type: 'image',
+     *   limit: 20,
+     * });
+     * ```
+     */
+    list(request: ListAssetsRequest): Promise<ListAssetsResponse>;
+    /**
+     * Move assets to a different folder
+     *
+     * @example
+     * ```typescript
+     * await cdn.move({
+     *   assetIds: ['asset-1', 'asset-2'],
+     *   folder: '/images/archive',
+     * });
+     * ```
+     */
+    move(request: MoveAssetsRequest): Promise<MoveAssetsResponse>;
+    /**
+     * Get a transformed image URL
+     *
+     * @example
+     * ```typescript
+     * const { url } = await cdn.getTransformUrl({
+     *   assetId: 'asset-id',
+     *   options: {
+     *     width: 800,
+     *     height: 600,
+     *     fit: 'cover',
+     *     format: 'webp',
+     *     quality: 80,
+     *   },
+     * });
+     * ```
+     */
+    getTransformUrl(request: GetTransformUrlRequest): Promise<GetTransformUrlResponse>;
+    /**
+     * Get folder tree for navigation
+     *
+     * @example
+     * ```typescript
+     * const tree = await cdn.getFolderTree({
+     *   projectSlug: 'my-project',
+     *   maxDepth: 3,
+     * });
+     * ```
+     */
+    getFolderTree(request: GetFolderTreeRequest): Promise<FolderTreeNode[]>;
+    /**
+     * Create a new folder
+     *
+     * @example
+     * ```typescript
+     * const folder = await cdn.createFolder({
+     *   projectSlug: 'my-project',
+     *   name: 'images',
+     * });
+     * ```
+     */
+    createFolder(request: CreateFolderRequest): Promise<Folder>;
+    /**
+     * Delete a folder
+     *
+     * @example
+     * ```typescript
+     * await cdn.deleteFolder('folder-id');
+     * ```
+     */
+    deleteFolder(id: string, deleteContents?: boolean): Promise<{
+        success: boolean;
+    }>;
+    private convertAssetDates;
+    private convertFolderDates;
+}
+
+export { type Asset, type AssetStatus, type AssetType, CDN, type ConfirmUploadRequest, type ConfirmUploadResponse, type CreateFolderRequest, type DeleteAssetRequest, type DeleteAssetsRequest, type DeleteAssetsResponse, type Folder, type FolderTreeNode, type GetAssetRequest, type GetFolderTreeRequest, type GetTransformUrlRequest, type GetTransformUrlResponse, type ListAssetsRequest, type ListAssetsResponse, type MoveAssetsRequest, type MoveAssetsResponse, type TransformOptions, type UpdateAssetRequest, type UploadUrlRequest, type UploadUrlResponse };

package/dist/cdn/index.js

@@ -0,0 +1,347 @@
+'use strict';
+
+// src/lib/http-client.ts
+var HttpClient = class {
+  apiKey;
+  baseUrl;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl || "https://api.stack0.com/v1";
+  }
+  getHeaders() {
+    return {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`
+    };
+  }
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: this.getHeaders(),
+        body: body ? JSON.stringify(body) : void 0
+      });
+      if (!response.ok) {
+        await this.handleErrorResponse(response);
+      }
+      const data = await response.json();
+      return data;
+    } catch (error) {
+      if (error instanceof Error && "statusCode" in error) {
+        throw error;
+      }
+      throw this.createError("Network error", error);
+    }
+  }
+  async handleErrorResponse(response) {
+    let errorBody;
+    try {
+      errorBody = await response.json();
+    } catch {
+      errorBody = { message: response.statusText };
+    }
+    const error = new Error(errorBody?.message || `HTTP ${response.status}`);
+    error.statusCode = response.status;
+    error.code = errorBody?.code ?? "";
+    error.response = errorBody;
+    throw error;
+  }
+  createError(message, cause) {
+    const error = new Error(message);
+    error.cause = cause;
+    return error;
+  }
+  async get(path) {
+    return this.request("GET", path);
+  }
+  async post(path, body) {
+    return this.request("POST", path, body);
+  }
+  async put(path, body) {
+    return this.request("PUT", path, body);
+  }
+  async delete(path) {
+    return this.request("DELETE", path);
+  }
+};
+
+// src/cdn/client.ts
+var CDN = class {
+  http;
+  constructor(config) {
+    this.http = new HttpClient(config);
+  }
+  /**
+   * Generate a presigned URL for uploading a file
+   *
+   * @example
+   * ```typescript
+   * const { uploadUrl, assetId } = await cdn.getUploadUrl({
+   *   projectSlug: 'my-project',
+   *   filename: 'image.jpg',
+   *   mimeType: 'image/jpeg',
+   *   size: 1024 * 1024,
+   * });
+   *
+   * // Upload file to the presigned URL
+   * await fetch(uploadUrl, {
+   *   method: 'PUT',
+   *   body: file,
+   *   headers: { 'Content-Type': 'image/jpeg' },
+   * });
+   *
+   * // Confirm the upload
+   * const asset = await cdn.confirmUpload(assetId);
+   * ```
+   */
+  async getUploadUrl(request) {
+    const response = await this.http.post("/cdn/assets/upload-url", request);
+    if (typeof response.expiresAt === "string") {
+      response.expiresAt = new Date(response.expiresAt);
+    }
+    return response;
+  }
+  /**
+   * Confirm that an upload has completed
+   */
+  async confirmUpload(assetId) {
+    const response = await this.http.post("/cdn/assets/confirm", { assetId });
+    return this.convertAssetDates(response.asset);
+  }
+  /**
+   * Upload a file directly (handles presigned URL flow automatically)
+   *
+   * @example
+   * ```typescript
+   * const asset = await cdn.upload({
+   *   projectSlug: 'my-project',
+   *   file: fileBuffer,
+   *   filename: 'image.jpg',
+   *   mimeType: 'image/jpeg',
+   * });
+   * ```
+   */
+  async upload(options) {
+    const { projectSlug, file, filename, mimeType, folder, metadata } = options;
+    let size;
+    if (file instanceof Blob) {
+      size = file.size;
+    } else if (file instanceof ArrayBuffer) {
+      size = file.byteLength;
+    } else {
+      size = file.length;
+    }
+    const { uploadUrl, assetId } = await this.getUploadUrl({
+      projectSlug,
+      filename,
+      mimeType,
+      size,
+      folder,
+      metadata
+    });
+    const uploadResponse = await fetch(uploadUrl, {
+      method: "PUT",
+      body: file,
+      headers: {
+        "Content-Type": mimeType
+      }
+    });
+    if (!uploadResponse.ok) {
+      throw new Error(`Upload failed: ${uploadResponse.statusText}`);
+    }
+    return this.confirmUpload(assetId);
+  }
+  /**
+   * Get an asset by ID
+   *
+   * @example
+   * ```typescript
+   * const asset = await cdn.get('asset-id');
+   * console.log(asset.cdnUrl);
+   * ```
+   */
+  async get(id) {
+    const response = await this.http.get(`/cdn/assets/${id}`);
+    return this.convertAssetDates(response);
+  }
+  /**
+   * Update asset metadata
+   *
+   * @example
+   * ```typescript
+   * const asset = await cdn.update({
+   *   id: 'asset-id',
+   *   alt: 'A beautiful sunset',
+   *   tags: ['nature', 'sunset'],
+   * });
+   * ```
+   */
+  async update(request) {
+    const { id, ...data } = request;
+    const response = await this.http.put(`/cdn/assets/${id}`, data);
+    return this.convertAssetDates(response);
+  }
+  /**
+   * Delete an asset
+   *
+   * @example
+   * ```typescript
+   * await cdn.delete('asset-id');
+   * ```
+   */
+  async delete(id) {
+    return this.http.delete(`/cdn/assets/${id}`);
+  }
+  /**
+   * Delete multiple assets
+   *
+   * @example
+   * ```typescript
+   * const result = await cdn.deleteMany(['asset-1', 'asset-2']);
+   * console.log(`Deleted ${result.deletedCount} assets`);
+   * ```
+   */
+  async deleteMany(ids) {
+    return this.http.post("/cdn/assets/delete-many", { ids });
+  }
+  /**
+   * List assets with filters and pagination
+   *
+   * @example
+   * ```typescript
+   * const { assets, total, hasMore } = await cdn.list({
+   *   projectSlug: 'my-project',
+   *   type: 'image',
+   *   limit: 20,
+   * });
+   * ```
+   */
+  async list(request) {
+    const params = new URLSearchParams();
+    params.set("projectSlug", request.projectSlug);
+    if (request.folder !== void 0) params.set("folder", request.folder ?? "");
+    if (request.type) params.set("type", request.type);
+    if (request.status) params.set("status", request.status);
+    if (request.search) params.set("search", request.search);
+    if (request.tags) params.set("tags", request.tags.join(","));
+    if (request.sortBy) params.set("sortBy", request.sortBy);
+    if (request.sortOrder) params.set("sortOrder", request.sortOrder);
+    if (request.limit) params.set("limit", request.limit.toString());
+    if (request.offset) params.set("offset", request.offset.toString());
+    const response = await this.http.get(`/cdn/assets?${params.toString()}`);
+    return {
+      ...response,
+      assets: response.assets.map((asset) => this.convertAssetDates(asset))
+    };
+  }
+  /**
+   * Move assets to a different folder
+   *
+   * @example
+   * ```typescript
+   * await cdn.move({
+   *   assetIds: ['asset-1', 'asset-2'],
+   *   folder: '/images/archive',
+   * });
+   * ```
+   */
+  async move(request) {
+    return this.http.post("/cdn/assets/move", request);
+  }
+  /**
+   * Get a transformed image URL
+   *
+   * @example
+   * ```typescript
+   * const { url } = await cdn.getTransformUrl({
+   *   assetId: 'asset-id',
+   *   options: {
+   *     width: 800,
+   *     height: 600,
+   *     fit: 'cover',
+   *     format: 'webp',
+   *     quality: 80,
+   *   },
+   * });
+   * ```
+   */
+  async getTransformUrl(request) {
+    const params = new URLSearchParams();
+    params.set("assetId", request.assetId);
+    const { options } = request;
+    if (options.width) params.set("width", options.width.toString());
+    if (options.height) params.set("height", options.height.toString());
+    if (options.fit) params.set("fit", options.fit);
+    if (options.format) params.set("format", options.format);
+    if (options.quality) params.set("quality", options.quality.toString());
+    return this.http.get(`/cdn/assets/transform?${params.toString()}`);
+  }
+  /**
+   * Get folder tree for navigation
+   *
+   * @example
+   * ```typescript
+   * const tree = await cdn.getFolderTree({
+   *   projectSlug: 'my-project',
+   *   maxDepth: 3,
+   * });
+   * ```
+   */
+  async getFolderTree(request) {
+    const params = new URLSearchParams();
+    params.set("projectSlug", request.projectSlug);
+    if (request.maxDepth) params.set("maxDepth", request.maxDepth.toString());
+    return this.http.get(`/cdn/folders/tree?${params.toString()}`);
+  }
+  /**
+   * Create a new folder
+   *
+   * @example
+   * ```typescript
+   * const folder = await cdn.createFolder({
+   *   projectSlug: 'my-project',
+   *   name: 'images',
+   * });
+   * ```
+   */
+  async createFolder(request) {
+    const response = await this.http.post("/cdn/folders", request);
+    return this.convertFolderDates(response);
+  }
+  /**
+   * Delete a folder
+   *
+   * @example
+   * ```typescript
+   * await cdn.deleteFolder('folder-id');
+   * ```
+   */
+  async deleteFolder(id, deleteContents = false) {
+    const params = new URLSearchParams();
+    if (deleteContents) params.set("deleteContents", "true");
+    return this.http.delete(`/cdn/folders/${id}?${params.toString()}`);
+  }
+  convertAssetDates(asset) {
+    if (typeof asset.createdAt === "string") {
+      asset.createdAt = new Date(asset.createdAt);
+    }
+    if (asset.updatedAt && typeof asset.updatedAt === "string") {
+      asset.updatedAt = new Date(asset.updatedAt);
+    }
+    return asset;
+  }
+  convertFolderDates(folder) {
+    if (typeof folder.createdAt === "string") {
+      folder.createdAt = new Date(folder.createdAt);
+    }
+    if (folder.updatedAt && typeof folder.updatedAt === "string") {
+      folder.updatedAt = new Date(folder.updatedAt);
+    }
+    return folder;
+  }
+};
+
+exports.CDN = CDN;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map