sharetribe-flex-build-sdk 1.15.0

package/src/events.ts

@@ -0,0 +1,203 @@
+/**
+ * Events query functions
+ *
+ * Programmatic API for querying marketplace events
+ */
+
+import { apiGet } from './api/client.js';
+
+export interface EventData {
+  sequenceId: number;
+  resourceId: string;
+  eventType: string;
+  createdAt: string;
+  resourceType?: string;
+  source?: string;
+  id?: string;
+  resource?: unknown;
+  auditData?: {
+    userId?: string | null;
+    adminId?: string | null;
+    clientId?: string | null;
+    requestId?: string | null;
+  };
+  auditEmails?: {
+    userEmail?: string | null;
+    adminEmail?: string | null;
+  };
+  previousValues?: unknown;
+  marketplaceId?: string;
+}
+
+export interface QueryEventsOptions {
+  resourceId?: string;
+  relatedResourceId?: string;
+  eventTypes?: string;
+  sequenceId?: number;
+  afterSeqId?: number;
+  beforeSeqId?: number;
+  afterTs?: string;
+  beforeTs?: string;
+  limit?: number;
+}
+
+/**
+ * Validates query parameters
+ */
+function validateParams(opts: QueryEventsOptions): void {
+  const exclusiveParams = [
+    opts.sequenceId !== undefined,
+    opts.afterSeqId !== undefined,
+    opts.beforeSeqId !== undefined,
+    opts.afterTs !== undefined,
+    opts.beforeTs !== undefined,
+  ];
+
+  if (exclusiveParams.filter(Boolean).length > 1) {
+    throw new Error(
+      'Only one of sequenceId, afterSeqId, beforeSeqId, afterTs, or beforeTs can be specified'
+    );
+  }
+
+  if (opts.resourceId && opts.relatedResourceId) {
+    throw new Error('Only one of resourceId or relatedResourceId can be specified');
+  }
+}
+
+/**
+ * Builds query parameters for API
+ */
+function buildQueryParams(
+  marketplace: string,
+  opts: QueryEventsOptions
+): Record<string, string> {
+  const params: Record<string, string> = {
+    marketplace,
+    latest: 'true'
+  };
+
+  if (opts.resourceId) params['resource-id'] = opts.resourceId;
+  if (opts.relatedResourceId) params['related-resource-id'] = opts.relatedResourceId;
+  if (opts.eventTypes) params['event-types'] = opts.eventTypes;
+  if (opts.sequenceId !== undefined) params['sequence-id'] = opts.sequenceId.toString();
+  if (opts.afterSeqId !== undefined) {
+    params['start-after-sequence-id'] = opts.afterSeqId.toString();
+    params.latest = 'false';
+  }
+  if (opts.beforeSeqId !== undefined) params['sequence-id-end'] = opts.beforeSeqId.toString();
+  if (opts.afterTs) {
+    params['start-after-created-at'] = opts.afterTs;
+    params.latest = 'false';
+  }
+  if (opts.beforeTs) params['created-at-end'] = opts.beforeTs;
+  if (opts.limit !== undefined) params.perPage = opts.limit.toString();
+
+  return params;
+}
+
+/**
+ * Transforms event from API format to standard format
+ */
+function transformEvent(event: any): EventData {
+  const eventData = event['event/data'];
+  const eventAudit = event['event/audit'];
+
+  return {
+    eventType: eventData.eventType,
+    createdAt: eventData.createdAt,
+    resourceType: eventData.resourceType,
+    source: eventData.source,
+    resourceId: eventData.resourceId,
+    id: eventData.id,
+    resource: eventData.resource || null,
+    auditData: eventData.auditData || {
+      userId: null,
+      adminId: null,
+      clientId: null,
+      requestId: null,
+    },
+    auditEmails: eventAudit ? {
+      userEmail: eventAudit['user/email'] || null,
+      adminEmail: eventAudit['admin/email'] || null,
+    } : undefined,
+    sequenceId: eventData.sequenceId,
+    previousValues: eventData.previousValues || null,
+    marketplaceId: eventData.marketplaceId,
+  };
+}
+
+/**
+ * Queries marketplace events
+ *
+ * @param apiKey - Sharetribe API key (optional, reads from auth file if not provided)
+ * @param marketplace - Marketplace ID
+ * @param options - Query options
+ * @returns Array of events
+ */
+export async function queryEvents(
+  apiKey: string | undefined,
+  marketplace: string,
+  options: QueryEventsOptions = {}
+): Promise<EventData[]> {
+  validateParams(options);
+
+  const queryParams = buildQueryParams(marketplace, options);
+  const response = await apiGet<{ data: any[] }>(apiKey, '/events/query', queryParams);
+
+  return response.data.map(transformEvent);
+}
+
+/**
+ * Polls for new events and calls callback when new events are found
+ *
+ * @param apiKey - Sharetribe API key (optional, reads from auth file if not provided)
+ * @param marketplace - Marketplace ID
+ * @param options - Query options
+ * @param callback - Function called with new events
+ * @param pollInterval - Interval in milliseconds between polls (default: 5000)
+ * @returns Function to stop polling
+ */
+export function pollEvents(
+  apiKey: string | undefined,
+  marketplace: string,
+  options: QueryEventsOptions,
+  callback: (events: EventData[]) => void,
+  pollInterval: number = 5000
+): () => void {
+  let lastSeqId: number | undefined;
+  let intervalId: NodeJS.Timeout;
+  let isStopped = false;
+
+  const poll = async () => {
+    if (isStopped) return;
+
+    try {
+      const queryOpts = { ...options };
+      if (lastSeqId !== undefined) {
+        queryOpts.afterSeqId = lastSeqId;
+      }
+
+      const events = await queryEvents(apiKey, marketplace, queryOpts);
+
+      if (events.length > 0) {
+        callback(events);
+        lastSeqId = Math.max(...events.map(e => e.sequenceId));
+      }
+    } catch (error) {
+      // Silently continue polling on errors
+      // Caller can handle errors in their callback if needed
+    }
+  };
+
+  // Initial poll
+  poll();
+
+  // Set up interval
+  intervalId = setInterval(poll, pollInterval);
+
+  // Return stop function
+  return () => {
+    isStopped = true;
+    clearInterval(intervalId);
+  };
+}

package/src/index.ts

@@ -0,0 +1,101 @@
+/**
+ * Sharetribe Flex Build SDK
+ *
+ * Programmatic API matching all CLI capabilities
+ */
+
+// Export process management functions
+export {
+  listProcesses,
+  listProcessVersions,
+  getProcess,
+  createProcess,
+  pushProcess,
+  createAlias,
+  updateAlias,
+  deleteAlias,
+  type ProcessListItem,
+  type ProcessVersion,
+  type ProcessDetails,
+  type CreateProcessResult,
+  type PushProcessResult,
+  type AliasResult,
+} from './processes.js';
+
+// Export process deployment functions
+export {
+  deployProcess,
+  type DeployProcessOptions,
+  type DeployProcessResult,
+} from './deploy.js';
+
+// Export search schema management functions
+export {
+  listSearchSchemas,
+  setSearchSchema,
+  unsetSearchSchema,
+  type SearchSchema,
+  type SetSearchSchemaOptions,
+  type UnsetSearchSchemaOptions,
+} from './search.js';
+
+// Export events query functions
+export {
+  queryEvents,
+  pollEvents,
+  type EventData,
+  type QueryEventsOptions,
+} from './events.js';
+
+// Export types
+export type {
+  ProcessState,
+  ProcessTransition,
+  ProcessNotification,
+  ProcessAction,
+  ProcessDefinition,
+} from './types.js';
+
+// Export EDN process utilities
+export {
+  parseProcessFile,
+  serializeProcess,
+} from './edn-process.js';
+
+// Export authentication functions
+export {
+  writeAuth,
+  clearAuth,
+  type AuthData,
+} from './auth-storage.js';
+
+// Export asset management functions
+export {
+  pullAssets,
+  pushAssets,
+  type Asset,
+  type PullAssetsResult,
+  type PushAssetsResult,
+} from './assets.js';
+
+// Export notification management functions
+export {
+  sendNotification,
+  previewNotification,
+  type EmailTemplate,
+  type NotificationOptions,
+} from './notifications.js';
+
+// Export listing approval functions
+export {
+  getListingApprovalStatus,
+  enableListingApproval,
+  disableListingApproval,
+} from './listing-approval.js';
+
+// Export Stripe integration functions
+export {
+  updateStripeVersion,
+  SUPPORTED_STRIPE_VERSIONS,
+  type StripeApiVersion,
+} from './stripe.js';

package/src/listing-approval.ts

@@ -0,0 +1,59 @@
+/**
+ * Listing approval management functions
+ *
+ * Programmatic API for managing listing approvals
+ */
+
+import { apiGet, apiPostTransit } from './api/client.js';
+
+/**
+ * Gets current listing approval status
+ *
+ * @param apiKey - Sharetribe API key (optional, reads from auth file if not provided)
+ * @param marketplace - Marketplace ID
+ * @returns Whether listing approvals are enabled
+ */
+export async function getListingApprovalStatus(
+  apiKey: string | undefined,
+  marketplace: string
+): Promise<{ enabled: boolean }> {
+  const response = await apiGet<{ data: { 'listing-approval-enabled': boolean } }>(
+    apiKey,
+    '/marketplace/show',
+    { marketplace }
+  );
+
+  return {
+    enabled: response.data['listing-approval-enabled'],
+  };
+}
+
+/**
+ * Enables listing approvals
+ *
+ * @param apiKey - Sharetribe API key (optional, reads from auth file if not provided)
+ * @param marketplace - Marketplace ID
+ * @returns Success confirmation
+ */
+export async function enableListingApproval(
+  apiKey: string | undefined,
+  marketplace: string
+): Promise<{ success: true }> {
+  await apiPostTransit(apiKey, '/listing-approval/enable', { marketplace }, {});
+  return { success: true };
+}
+
+/**
+ * Disables listing approvals
+ *
+ * @param apiKey - Sharetribe API key (optional, reads from auth file if not provided)
+ * @param marketplace - Marketplace ID
+ * @returns Success confirmation
+ */
+export async function disableListingApproval(
+  apiKey: string | undefined,
+  marketplace: string
+): Promise<{ success: true }> {
+  await apiPostTransit(apiKey, '/listing-approval/disable', { marketplace }, {});
+  return { success: true };
+}

package/src/notifications.ts

@@ -0,0 +1,89 @@
+/**
+ * Notification management functions
+ *
+ * Programmatic API for managing email notifications
+ */
+
+import { apiPost } from './api/client.js';
+
+export interface EmailTemplate {
+  html: string;
+  subject: string;
+}
+
+export interface NotificationOptions {
+  template: EmailTemplate;
+  context?: unknown;
+}
+
+/**
+ * Sends a preview email to the marketplace admin
+ *
+ * @param apiKey - Sharetribe API key (optional, reads from auth file if not provided)
+ * @param marketplace - Marketplace ID
+ * @param options - Email template and context
+ * @returns Admin email that received the preview
+ */
+export async function sendNotification(
+  apiKey: string | undefined,
+  marketplace: string,
+  options: NotificationOptions
+): Promise<{ adminEmail: string }> {
+  const body: Record<string, unknown> = {
+    template: {
+      'template-html': options.template.html,
+      'template-subject': options.template.subject,
+    },
+  };
+
+  if (options.context !== undefined) {
+    body['template-context'] = options.context;
+  }
+
+  const response = await apiPost<{ data: { 'admin-email': string } }>(
+    apiKey,
+    '/notifications/send',
+    { marketplace },
+    body
+  );
+
+  return {
+    adminEmail: response.data['admin-email'],
+  };
+}
+
+/**
+ * Previews a notification (renders HTML)
+ *
+ * @param apiKey - Sharetribe API key (optional, reads from auth file if not provided)
+ * @param marketplace - Marketplace ID
+ * @param options - Email template and context
+ * @returns Rendered HTML
+ */
+export async function previewNotification(
+  apiKey: string | undefined,
+  marketplace: string,
+  options: NotificationOptions
+): Promise<{ html: string }> {
+  const body: Record<string, unknown> = {
+    template: {
+      'template-html': options.template.html,
+      'template-subject': options.template.subject,
+    },
+  };
+
+  if (options.context !== undefined) {
+    body['template-context'] = options.context;
+  }
+
+  const response = await apiPost<{ data: { html: string } }>(
+    apiKey,
+    '/notifications/preview',
+    { marketplace },
+    body
+  );
+
+  return {
+    html: response.data.html,
+  };
+}