@proveanything/smartlinks 1.0.5 → 1.0.7

package/examples/react-demo.tsx

@@ -1,25 +1,37 @@
 import React, { useEffect, useState } from 'react';
-import { ApiClient, CollectionResponse, ProductResponse } from '@smartlinks/sdk';
+import { initializeApi } from '../dist/index';
+import { collection } from '../dist/api/collection';
+import { product } from '../dist/api/product';
+import { proof } from '../dist/api/proof';
+import type { CollectionResponse } from '../dist/types/collection';
+import type { ProductResponse } from '../dist/types/product';
+import type { ProofResponse } from '../dist/types/proof';
 
 // You can provide either or both of these values:
-const apiKey = 'YOUR_API_KEY'; // sent as X-API-Key header (optional)
-const bearerToken = 'YOUR_BEARER_TOKEN'; // sent as AUTHORIZATION: Bearer ... (optional)
+const apiKey = 'YOUR_API_KEY'; // optional
+const bearerToken = 'YOUR_BEARER_TOKEN'; // optional
 
-// Example: with both headers
-const client = new ApiClient('https://smartlinks.app/api/v1', apiKey, bearerToken);
+initializeApi({
+  baseURL: 'https://smartlinks.app/api/v1',
+  apiKey,
+  bearerToken,
+});
 
 const ReactDemo: React.FC = () => {
-  const [collection, setCollection] = useState<CollectionResponse | null>(null);
-  const [product, setProduct] = useState<ProductResponse | null>(null);
+  const [collectionData, setCollection] = useState<CollectionResponse | null>(null);
+  const [productData, setProduct] = useState<ProductResponse | null>(null);
+  const [proofData, setProof] = useState<ProofResponse | null>(null);
   const [error, setError] = useState<string | null>(null);
 
   useEffect(() => {
     async function fetchData() {
       try {
-        const col = await client.getCollection('abc123');
-        const prod = await client.getProductItem('abc123', 'prod789');
+        const col = await collection.get('abc123');
+        const prod = await product.get('abc123', 'prod789');
+        const prf = await proof.get('abc123', 'proof456');
         setCollection(col);
         setProduct(prod);
+        setProof(prf);
       } catch (err) {
         setError((err as Error).message);
       }
@@ -28,15 +40,17 @@ const ReactDemo: React.FC = () => {
   }, []);
 
   if (error) return <div>Error: {error}</div>;
-  if (!collection || !product) return <div>Loading...</div>;
+  if (!collectionData || !productData || !proofData) return <div>Loading...</div>;
 
   return (
     <div>
-      <h1>{collection.title}</h1>
-      <img src={collection.logoImage} alt={collection.title} width="100" />
-      <h2>{product.name}</h2>
-      <img src={product.heroImage} alt={product.name} width="100" />
-      <p>{product.description}</p>
+      <h1>{collectionData.title}</h1>
+      <img src={collectionData.logoImage} alt={collectionData.title} width="100" />
+      <h2>{productData.name}</h2>
+      <img src={productData.heroImage} alt={productData.name} width="100" />
+      <p>{productData.description}</p>
+      <h3>Proof</h3>
+      <pre>{JSON.stringify(proofData, null, 2)}</pre>
     </div>
   );
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proveanything/smartlinks",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Official JavaScript/TypeScript SDK for the Smartlinks API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/api/asset.ts

@@ -0,0 +1,133 @@
+import { request, post, getApiHeaders } from "../http"
+import { AssetResponse } from "../types/asset"
+
+export namespace asset {
+  // Collection-level
+  export async function getForCollection(
+    collectionId: string,
+    assetId: string
+  ): Promise<AssetResponse> {
+    const path = `/public/collection/${encodeURIComponent(collectionId)}/asset/${encodeURIComponent(assetId)}`
+    return request<AssetResponse>(path)
+  }
+
+  export async function getAllForCollection(
+    collectionId: string
+  ): Promise<AssetResponse[]> {
+    const path = `/public/collection/${encodeURIComponent(collectionId)}/asset`
+    return request<AssetResponse[]>(path)
+  }
+
+  // Product-level
+  export async function getForProduct(
+    collectionId: string,
+    productId: string,
+    assetId: string
+  ): Promise<AssetResponse> {
+    const path = `/public/collection/${encodeURIComponent(collectionId)}/product/${encodeURIComponent(productId)}/asset/${encodeURIComponent(assetId)}`
+    return request<AssetResponse>(path)
+  }
+
+  export async function getAllForProduct(
+    collectionId: string,
+    productId: string
+  ): Promise<AssetResponse[]> {
+    const path = `/public/collection/${encodeURIComponent(collectionId)}/product/${encodeURIComponent(productId)}/asset`
+    return request<AssetResponse[]>(path)
+  }
+
+  // Proof-level
+  export async function getForProof(
+    collectionId: string,
+    productId: string,
+    proofId: string,
+    assetId: string
+  ): Promise<AssetResponse> {
+    const path = `/public/collection/${encodeURIComponent(collectionId)}/product/${encodeURIComponent(productId)}/proof/${encodeURIComponent(proofId)}/asset/${encodeURIComponent(assetId)}`
+    return request<AssetResponse>(path)
+  }
+
+  export async function getAllForProof(
+    collectionId: string,
+    productId: string,
+    proofId: string,
+    appId?: string
+  ): Promise<AssetResponse[]> {
+    let path = `/public/collection/${encodeURIComponent(collectionId)}/product/${encodeURIComponent(productId)}/proof/${encodeURIComponent(proofId)}/asset`
+    if (appId) {
+      path += `?appId=${encodeURIComponent(appId)}`
+    }
+    return request<AssetResponse[]>(path)
+  }
+
+  /**
+   * Uploads an asset file to a proof, with optional extraData as JSON.
+   * Supports progress reporting via onProgress callback (browser only).
+   * @param collectionId - The collection ID
+   * @param productId - The product ID
+   * @param proofId - The proof ID
+   * @param file - The file to upload
+   * @param extraData - Arbitrary extra data to include (will be stringified as JSON)
+   * @param onProgress - Optional callback for upload progress (0-100)
+   * @returns Promise resolving to an AssetResponse object
+   */
+  export async function uploadAsset(
+    collectionId: string,
+    productId: string,
+    proofId: string,
+    file: File,
+    extraData?: Record<string, any>,
+    onProgress?: (percent: number) => void
+  ): Promise<AssetResponse> {
+    const path = `/public/collection/${encodeURIComponent(collectionId)}/product/${encodeURIComponent(productId)}/proof/${encodeURIComponent(proofId)}/asset`
+    const url = (typeof window !== "undefined" && (window as any).SMARTLINKS_API_BASEURL)
+      ? (window as any).SMARTLINKS_API_BASEURL + path
+      : path // fallback for SSR or Node
+
+    const formData = new FormData()
+    formData.append("file", file)
+    if (extraData) {
+      formData.append("extraData", JSON.stringify(extraData))
+    }
+
+    // Use getApiHeaders from http module
+    const headers = getApiHeaders ? getApiHeaders() : {}
+
+    return new Promise<AssetResponse>((resolve, reject) => {
+      const xhr = new XMLHttpRequest()
+      xhr.open("POST", url)
+
+      // Set headers for API key and bearer token if available
+      for (const [key, value] of Object.entries(headers)) {
+        xhr.setRequestHeader(key, value)
+      }
+
+      xhr.upload.onprogress = (event) => {
+        if (onProgress && event.lengthComputable) {
+          const percent = Math.round((event.loaded / event.total) * 100)
+          onProgress(percent)
+        }
+      }
+
+      xhr.onload = () => {
+        if (xhr.status >= 200 && xhr.status < 300) {
+          try {
+            resolve(JSON.parse(xhr.responseText) as AssetResponse)
+          } catch (e) {
+            reject(new Error("Failed to parse server response"))
+          }
+        } else {
+          try {
+            const errBody = JSON.parse(xhr.responseText)
+            reject(new Error(`Error ${errBody.code}: ${errBody.message}`))
+          } catch {
+            reject(new Error(`Asset upload failed with status ${xhr.status}`))
+          }
+        }
+      }
+
+      xhr.onerror = () => reject(new Error("Network error during asset upload"))
+      xhr.send(formData)
+    })
+  }
+}

package/src/api/index.ts

@@ -4,3 +4,4 @@ export { collection } from "./collection"
 export { product } from "./product"
 export { proof } from "./proof"
 export { appConfiguration } from "./appConfiguration"
+export { asset } from "./asset"

package/src/http.ts

@@ -62,3 +62,57 @@ export async function request<T>(path: string): Promise<T> {
 
   return (await response.json()) as T
 }
+
+/**
+ * Internal helper that performs a POST request to `${baseURL}${path}`,
+ * injecting headers for apiKey or bearerToken if present.
+ * If body is FormData, Content-Type is not set.
+ * Returns the parsed JSON as T, or throws an Error.
+ */
+export async function post<T>(
+  path: string,
+  body: any,
+  extraHeaders?: Record<string, string>
+): Promise<T> {
+  if (!baseURL) {
+    throw new Error("HTTP client is not initialized. Call initializeApi(...) first.")
+  }
+
+  const url = `${baseURL}${path}`
+  const headers: Record<string, string> = extraHeaders ? { ...extraHeaders } : {}
+
+  if (apiKey) headers["X-API-Key"] = apiKey
+  if (bearerToken) headers["AUTHORIZATION"] = `Bearer ${bearerToken}`
+
+  // Only set Content-Type for non-FormData bodies
+  if (!(body instanceof FormData)) {
+    headers["Content-Type"] = "application/json"
+  }
+
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: body instanceof FormData ? body : JSON.stringify(body),
+  })
+
+  if (!response.ok) {
+    try {
+      const errBody = (await response.json()) as import("./types/error").ErrorResponse
+      throw new Error(`Error ${errBody.code}: ${errBody.message}`)
+    } catch {
+      throw new Error(`Request to ${url} failed with status ${response.status}`)
+    }
+  }
+
+  return (await response.json()) as T
+}
+
+/**
+ * Returns the common headers used for API requests, including apiKey and bearerToken if set.
+ */
+export function getApiHeaders(): Record<string, string> {
+  const headers: Record<string, string> = {}
+  if (apiKey) headers["X-API-Key"] = apiKey
+  if (bearerToken) headers["AUTHORIZATION"] = `Bearer ${bearerToken}`
+  return headers
+}

package/src/types/asset.ts

@@ -0,0 +1,9 @@
+/**
+ * Represents an Asset object.
+ */
+export interface AssetResponse {
+  id: string
+  name: string
+  url: string
+  // ...add more fields as needed...
+}

package/src/types/index.ts

@@ -6,3 +6,4 @@ export * from "./product"
 export * from "./proof"
 export * from "./appConfiguration"
 export * from "./error"
+export * from "./asset"