sharetribe-flex-build-sdk 1.15.0 → 1.15.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sharetribe-flex-build-sdk",
-  "version": "1.15.0",
+  "version": "1.15.2",
   "description": "SDK for building and managing Sharetribe Flex transaction processes",
   "type": "module",
   "main": "./dist/index.js",

package/src/api/client.ts

@@ -8,13 +8,11 @@ import { get, post, del, request, postTransit, HttpResponse } from './http-clien
 import { createMultipartBody, MultipartField } from './multipart.js';
 import { encodeTransit, decodeTransit } from './transit.js';
 import { readAuth } from '../auth-storage.js';
+import { getApiBaseUrl } from '../config.js';
 
 // Re-export MultipartField for use in commands
 export type { MultipartField };
 
-// API base URL - must match flex-cli exactly
-const API_BASE_URL = 'https://flex-build-api.sharetribe.com/v1/build-api';
-
 export interface ApiError {
   code: string;
   message: string;
@@ -81,7 +79,7 @@ function handleResponse<T>(response: HttpResponse): T {
  * @returns API response
  */
 export async function apiGet<T>(apiKey: string | undefined, endpoint: string, queryParams?: Record<string, string>): Promise<T> {
-  const url = new URL(API_BASE_URL + endpoint);
+  const url = new URL(getApiBaseUrl() + endpoint);
   if (queryParams) {
     Object.entries(queryParams).forEach(([key, value]) => {
       url.searchParams.append(key, value);
@@ -107,7 +105,7 @@ export async function apiPost<T>(
   queryParams?: Record<string, string>,
   body?: unknown
 ): Promise<T> {
-  const url = new URL(API_BASE_URL + endpoint);
+  const url = new URL(getApiBaseUrl() + endpoint);
   if (queryParams) {
     Object.entries(queryParams).forEach(([key, value]) => {
       url.searchParams.append(key, value);
@@ -131,7 +129,7 @@ export async function apiDelete<T>(
   endpoint: string,
   queryParams?: Record<string, string>
 ): Promise<T> {
-  const url = new URL(API_BASE_URL + endpoint);
+  const url = new URL(getApiBaseUrl() + endpoint);
   if (queryParams) {
     Object.entries(queryParams).forEach(([key, value]) => {
       url.searchParams.append(key, value);
@@ -157,7 +155,7 @@ export async function apiPostMultipart<T>(
   queryParams: Record<string, string>,
   fields: MultipartField[]
 ): Promise<T> {
-  const url = new URL(API_BASE_URL + endpoint);
+  const url = new URL(getApiBaseUrl() + endpoint);
   Object.entries(queryParams).forEach(([key, value]) => {
     url.searchParams.append(key, value);
   });
@@ -194,7 +192,7 @@ export async function apiPostTransit<T>(
   queryParams: Record<string, string>,
   body: unknown
 ): Promise<T> {
-  const url = new URL(API_BASE_URL + endpoint);
+  const url = new URL(getApiBaseUrl() + endpoint);
   Object.entries(queryParams).forEach(([key, value]) => {
     url.searchParams.append(key, value);
   });

package/src/assets.ts

@@ -22,6 +22,10 @@ export interface PushAssetsResult {
   assets: Array<{ path: string; contentHash: string }>;
 }
 
+export interface StageAssetResult {
+  stagingId: string;
+}
+
 /**
  * Pulls assets from remote
  *
@@ -67,6 +71,34 @@ export async function pullAssets(
   };
 }
 
+/**
+ * Stages an asset for upload
+ *
+ * @param apiKey - Sharetribe API key (optional, reads from auth file if not provided)
+ * @param marketplace - Marketplace ID
+ * @param fileData - File data as Buffer
+ * @param filename - Filename
+ * @returns Staging ID
+ */
+export async function stageAsset(
+  apiKey: string | undefined,
+  marketplace: string,
+  fileData: Buffer,
+  filename: string
+): Promise<StageAssetResult> {
+  const fields: MultipartField[] = [
+    { name: 'file', value: fileData, filename },
+  ];
+
+  const response = await apiPostMultipart<{
+    data: { 'staging-id': string };
+  }>(apiKey, '/assets/stage', { marketplace }, fields);
+
+  return {
+    stagingId: response.data['staging-id'],
+  };
+}
+
 /**
  * Pushes assets to remote
  *
@@ -84,6 +116,8 @@ export async function pushAssets(
     path: string;
     op: 'upsert' | 'delete';
     data?: Buffer;
+    stagingId?: string;
+    filename?: string;
   }>
 ): Promise<PushAssetsResult> {
   const fields: MultipartField[] = [
@@ -94,8 +128,13 @@ export async function pushAssets(
     const op = operations[i];
     fields.push({ name: `path-${i}`, value: op.path });
     fields.push({ name: `op-${i}`, value: op.op });
-    if (op.op === 'upsert' && op.data) {
-      fields.push({ name: `data-raw-${i}`, value: op.data });
+    if (op.op === 'upsert') {
+      if (op.stagingId) {
+        fields.push({ name: `staging-id-${i}`, value: String(op.stagingId) });
+      } else if (op.data) {
+        const fname = op.filename || op.path;
+        fields.push({ name: `data-raw-${i}`, value: op.data, filename: fname });
+      }
     }
   }
 

package/src/config.ts

@@ -0,0 +1,58 @@
+/**
+ * Configuration helpers matching flex-cli behavior.
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import edn from 'jsedn';
+
+const ENV_FILE = '.env.edn';
+const DEFAULT_API_BASE_URL = 'https://flex-build-api.sharetribe.com/v1/build-api';
+
+let envFileContent: any | null | undefined;
+
+function readEnvFile(): any | null {
+  const envPath = join(process.cwd(), ENV_FILE);
+  if (!existsSync(envPath)) {
+    return null;
+  }
+
+  try {
+    const content = readFileSync(envPath, 'utf-8');
+    return edn.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+function getEnvValue(name: string): string | undefined {
+  const envValue = process.env[name];
+  if (envValue) {
+    return envValue;
+  }
+
+  if (envFileContent === undefined) {
+    envFileContent = readEnvFile();
+  }
+
+  if (envFileContent && typeof envFileContent.at === 'function') {
+    const value = envFileContent.at(name);
+    if (typeof value === 'string') {
+      return value;
+    }
+  }
+
+  return undefined;
+}
+
+export function getApiBaseUrl(): string {
+  return getEnvValue('FLEX_API_BASE_URL') || DEFAULT_API_BASE_URL;
+}
+
+export function getConfigMap(): Record<string, string> {
+  return {
+    'api-base-url': getApiBaseUrl(),
+  };
+}
+
+export { DEFAULT_API_BASE_URL };

package/src/index.ts

@@ -64,6 +64,7 @@ export {
 
 // Export authentication functions
 export {
+  readAuth,
   writeAuth,
   clearAuth,
   type AuthData,
@@ -73,9 +74,11 @@ export {
 export {
   pullAssets,
   pushAssets,
+  stageAsset,
   type Asset,
   type PullAssetsResult,
   type PushAssetsResult,
+  type StageAssetResult,
 } from './assets.js';
 
 // Export notification management functions
@@ -99,3 +102,10 @@ export {
   SUPPORTED_STRIPE_VERSIONS,
   type StripeApiVersion,
 } from './stripe.js';
+
+// Export configuration helpers
+export {
+  getApiBaseUrl,
+  getConfigMap,
+  DEFAULT_API_BASE_URL,
+} from './config.js';

package/test/assets.test.ts

@@ -0,0 +1,308 @@
+/**
+ * Tests for asset management SDK functions
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { stageAsset, pushAssets } from '../src/assets.js';
+import * as client from '../src/api/client.js';
+
+// Mock the API client
+vi.mock('../src/api/client.js', () => ({
+  apiPostMultipart: vi.fn(),
+}));
+
+describe('stageAsset', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should stage an asset and return staging ID', async () => {
+    const mockApiPostMultipart = vi.mocked(client.apiPostMultipart);
+    mockApiPostMultipart.mockResolvedValue({
+      data: {
+        'staging-id': 'staging-12345',
+      },
+    });
+
+    const result = await stageAsset(
+      'test-api-key',
+      'test-marketplace',
+      Buffer.from('image data'),
+      'test.png'
+    );
+
+    expect(mockApiPostMultipart).toHaveBeenCalledWith(
+      'test-api-key',
+      '/assets/stage',
+      { marketplace: 'test-marketplace' },
+      [
+        {
+          name: 'file',
+          value: Buffer.from('image data'),
+          filename: 'test.png',
+        },
+      ]
+    );
+
+    expect(result.stagingId).toBe('staging-12345');
+  });
+
+  it('should work without API key (reads from auth file)', async () => {
+    const mockApiPostMultipart = vi.mocked(client.apiPostMultipart);
+    mockApiPostMultipart.mockResolvedValue({
+      data: {
+        'staging-id': 'staging-67890',
+      },
+    });
+
+    const result = await stageAsset(
+      undefined,
+      'test-marketplace',
+      Buffer.from('file data'),
+      'document.pdf'
+    );
+
+    expect(mockApiPostMultipart).toHaveBeenCalledWith(
+      undefined,
+      '/assets/stage',
+      { marketplace: 'test-marketplace' },
+      expect.arrayContaining([
+        expect.objectContaining({
+          name: 'file',
+          filename: 'document.pdf',
+        }),
+      ])
+    );
+
+    expect(result.stagingId).toBe('staging-67890');
+  });
+});
+
+describe('pushAssets', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should push assets with staging-id when provided', async () => {
+    const mockApiPostMultipart = vi.mocked(client.apiPostMultipart);
+    mockApiPostMultipart.mockResolvedValue({
+      data: {
+        version: 'v2',
+        'asset-meta': {
+          assets: [
+            { path: 'test.png', 'content-hash': 'hash123' },
+          ],
+        },
+      },
+    });
+
+    const result = await pushAssets(
+      'test-api-key',
+      'test-marketplace',
+      'v1',
+      [
+        {
+          path: 'test.png',
+          op: 'upsert',
+          stagingId: 'staging-123',
+        },
+      ]
+    );
+
+    expect(mockApiPostMultipart).toHaveBeenCalledWith(
+      'test-api-key',
+      '/assets/push',
+      { marketplace: 'test-marketplace' },
+      expect.arrayContaining([
+        { name: 'current-version', value: 'v1' },
+        { name: 'path-0', value: 'test.png' },
+        { name: 'op-0', value: 'upsert' },
+        { name: 'staging-id-0', value: 'staging-123' },
+      ])
+    );
+
+    expect(result.version).toBe('v2');
+    expect(result.assets).toHaveLength(1);
+    expect(result.assets[0].path).toBe('test.png');
+    expect(result.assets[0].contentHash).toBe('hash123');
+  });
+
+  it('should push assets with data-raw when staging-id is not provided', async () => {
+    const mockApiPostMultipart = vi.mocked(client.apiPostMultipart);
+    mockApiPostMultipart.mockResolvedValue({
+      data: {
+        version: 'v2',
+        'asset-meta': {
+          assets: [
+            { path: 'config.json', 'content-hash': 'hash456' },
+          ],
+        },
+      },
+    });
+
+    const fileData = Buffer.from('{"test": "data"}');
+
+    const result = await pushAssets(
+      'test-api-key',
+      'test-marketplace',
+      'v1',
+      [
+        {
+          path: 'config.json',
+          op: 'upsert',
+          data: fileData,
+          filename: 'config.json',
+        },
+      ]
+    );
+
+    expect(mockApiPostMultipart).toHaveBeenCalledWith(
+      'test-api-key',
+      '/assets/push',
+      { marketplace: 'test-marketplace' },
+      expect.arrayContaining([
+        { name: 'current-version', value: 'v1' },
+        { name: 'path-0', value: 'config.json' },
+        { name: 'op-0', value: 'upsert' },
+        expect.objectContaining({
+          name: 'data-raw-0',
+          value: fileData,
+          filename: 'config.json',
+        }),
+      ])
+    );
+
+    expect(result.version).toBe('v2');
+  });
+
+  it('should handle delete operations', async () => {
+    const mockApiPostMultipart = vi.mocked(client.apiPostMultipart);
+    mockApiPostMultipart.mockResolvedValue({
+      data: {
+        version: 'v2',
+        'asset-meta': {
+          assets: [],
+        },
+      },
+    });
+
+    const result = await pushAssets(
+      'test-api-key',
+      'test-marketplace',
+      'v1',
+      [
+        {
+          path: 'old-file.txt',
+          op: 'delete',
+        },
+      ]
+    );
+
+    expect(mockApiPostMultipart).toHaveBeenCalledWith(
+      'test-api-key',
+      '/assets/push',
+      { marketplace: 'test-marketplace' },
+      expect.arrayContaining([
+        { name: 'current-version', value: 'v1' },
+        { name: 'path-0', value: 'old-file.txt' },
+        { name: 'op-0', value: 'delete' },
+      ])
+    );
+
+    // Should not include data-raw or staging-id for delete operations
+    const callArgs = mockApiPostMultipart.mock.calls[0];
+    const fields = callArgs[3] as Array<{ name: string }>;
+    const fieldNames = fields.map(f => f.name);
+    expect(fieldNames).not.toContain('data-raw-0');
+    expect(fieldNames).not.toContain('staging-id-0');
+
+    expect(result.version).toBe('v2');
+  });
+
+  it('should handle multiple operations', async () => {
+    const mockApiPostMultipart = vi.mocked(client.apiPostMultipart);
+    mockApiPostMultipart.mockResolvedValue({
+      data: {
+        version: 'v3',
+        'asset-meta': {
+          assets: [
+            { path: 'new.png', 'content-hash': 'hash1' },
+            { path: 'config.json', 'content-hash': 'hash2' },
+          ],
+        },
+      },
+    });
+
+    const result = await pushAssets(
+      'test-api-key',
+      'test-marketplace',
+      'v2',
+      [
+        {
+          path: 'new.png',
+          op: 'upsert',
+          stagingId: 'staging-1',
+        },
+        {
+          path: 'config.json',
+          op: 'upsert',
+          data: Buffer.from('{}'),
+          filename: 'config.json',
+        },
+        {
+          path: 'old.txt',
+          op: 'delete',
+        },
+      ]
+    );
+
+    expect(mockApiPostMultipart).toHaveBeenCalledWith(
+      'test-api-key',
+      '/assets/push',
+      { marketplace: 'test-marketplace' },
+      expect.arrayContaining([
+        { name: 'current-version', value: 'v2' },
+        { name: 'path-0', value: 'new.png' },
+        { name: 'op-0', value: 'upsert' },
+        { name: 'staging-id-0', value: 'staging-1' },
+        { name: 'path-1', value: 'config.json' },
+        { name: 'op-1', value: 'upsert' },
+        { name: 'path-2', value: 'old.txt' },
+        { name: 'op-2', value: 'delete' },
+      ])
+    );
+
+    expect(result.version).toBe('v3');
+    expect(result.assets).toHaveLength(2);
+  });
+
+  it('should convert staging-id to string', async () => {
+    const mockApiPostMultipart = vi.mocked(client.apiPostMultipart);
+    mockApiPostMultipart.mockResolvedValue({
+      data: {
+        version: 'v2',
+        'asset-meta': {
+          assets: [],
+        },
+      },
+    });
+
+    await pushAssets(
+      'test-api-key',
+      'test-marketplace',
+      'v1',
+      [
+        {
+          path: 'test.png',
+          op: 'upsert',
+          stagingId: 12345 as any, // Test that it converts to string
+        },
+      ]
+    );
+
+    const callArgs = mockApiPostMultipart.mock.calls[0];
+    const fields = callArgs[3] as Array<{ name: string; value: string }>;
+    const stagingIdField = fields.find(f => f.name === 'staging-id-0');
+    expect(stagingIdField?.value).toBe('12345');
+  });
+});