@swiftpatch/react-native 2.0.0

package/src/utils/api.ts

@@ -0,0 +1,244 @@
+import type { ReleaseInfo, SwiftPatchEvent } from '../types';
+
+interface CheckUpdateParams {
+  serverUrl: string;
+  deploymentKey: string;
+  appVersion: string;
+  currentBundleHash: string | null;
+  platform: 'ios' | 'android';
+  deviceId: string;
+  customHeaders?: Record<string, string>;
+  unverifiedHashes?: string[];
+}
+
+interface CheckUpdateResponse {
+  updateAvailable: boolean;
+  release?: ReleaseInfo;
+  appliedRelease?: {
+    isRolledBack: boolean;
+    targetAppVersion: string;
+  };
+}
+
+/**
+ * Check for available updates from the SwiftPatch server
+ */
+export async function checkForUpdateAPI(
+  params: CheckUpdateParams
+): Promise<CheckUpdateResponse> {
+  const {
+    serverUrl,
+    deploymentKey,
+    appVersion,
+    currentBundleHash,
+    platform,
+    deviceId,
+    customHeaders = {},
+    unverifiedHashes,
+  } = params;
+
+  const response = await fetch(`${serverUrl}/sdk/check-update`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      ...customHeaders,
+    },
+    body: JSON.stringify({
+      deploymentKey,
+      appVersion,
+      currentBundleHash,
+      platform,
+      deviceId,
+      unverifiedHashes,
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(
+      `Update check failed: ${response.status} ${response.statusText}`
+    );
+  }
+
+  return response.json();
+}
+
+interface ReportStatusParams {
+  serverUrl: string;
+  deploymentKey: string;
+  releaseId: string;
+  status: 'downloaded' | 'installed' | 'crashed' | 'rolledBack';
+  error?: string;
+}
+
+/**
+ * Report install status to the SwiftPatch server
+ */
+export async function reportInstallStatus(
+  params: ReportStatusParams
+): Promise<void> {
+  const { serverUrl, deploymentKey, releaseId, status, error } = params;
+
+  try {
+    await fetch(`${serverUrl}/sdk/report-status`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        deploymentKey,
+        releaseId,
+        status,
+        error,
+        timestamp: new Date().toISOString(),
+      }),
+    });
+  } catch (_e) {
+    console.warn('[SwiftPatch] Failed to report install status');
+  }
+}
+
+interface LogBulkEventsParams {
+  serverUrl: string;
+  deploymentKey: string;
+  deviceId: string;
+  events: SwiftPatchEvent[];
+  customHeaders?: Record<string, string>;
+}
+
+/**
+ * Send bulk analytics events to the server
+ */
+export async function logBulkEvents(
+  params: LogBulkEventsParams
+): Promise<{ acknowledged: string[] }> {
+  const { serverUrl, deploymentKey, deviceId, events, customHeaders = {} } = params;
+
+  try {
+    const response = await fetch(`${serverUrl}/sdk/log-bulk-events`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...customHeaders,
+      },
+      body: JSON.stringify({
+        deploymentKey,
+        deviceId,
+        events,
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to log events: ${response.status}`);
+    }
+
+    return response.json();
+  } catch (_e) {
+    console.warn('[SwiftPatch] Failed to log bulk events');
+    return { acknowledged: [] };
+  }
+}
+
+interface VerifyPinParams {
+  serverUrl: string;
+  deploymentKey: string;
+  pin: string;
+  customHeaders?: Record<string, string>;
+}
+
+/**
+ * Verify SDK PIN for dashboard access
+ */
+export async function verifySDKPin(
+  params: VerifyPinParams
+): Promise<{ sdkToken: string } | null> {
+  const { serverUrl, deploymentKey, pin, customHeaders = {} } = params;
+
+  try {
+    const response = await fetch(`${serverUrl}/sdk/auth/verify-pin`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-deployment-key': deploymentKey,
+        ...customHeaders,
+      },
+      body: JSON.stringify({ pin }),
+    });
+
+    if (!response.ok) return null;
+    return response.json();
+  } catch (_e) {
+    return null;
+  }
+}
+
+interface ListBucketsParams {
+  serverUrl: string;
+  sdkToken: string;
+  deploymentKey: string;
+  customHeaders?: Record<string, string>;
+}
+
+/**
+ * List available channels/buckets
+ */
+export async function listBuckets(
+  params: ListBucketsParams
+): Promise<any[]> {
+  const { serverUrl, sdkToken, deploymentKey, customHeaders = {} } = params;
+
+  try {
+    const response = await fetch(`${serverUrl}/sdk/list-buckets`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-sdk-token': sdkToken,
+        'x-deployment-key': deploymentKey,
+        ...customHeaders,
+      },
+      body: JSON.stringify({}),
+    });
+
+    if (!response.ok) return [];
+    const data = await response.json();
+    return data.buckets || [];
+  } catch (_e) {
+    return [];
+  }
+}
+
+interface ListBundlesParams {
+  serverUrl: string;
+  sdkToken: string;
+  deploymentKey: string;
+  channelId?: string;
+  platform?: string;
+  pageOffset?: number;
+  customHeaders?: Record<string, string>;
+}
+
+/**
+ * List bundles with pagination
+ */
+export async function listBundles(
+  params: ListBundlesParams
+): Promise<{ bundles: any[]; hasMore: boolean }> {
+  const { serverUrl, sdkToken, deploymentKey, channelId, platform, pageOffset = 0, customHeaders = {} } = params;
+
+  try {
+    const response = await fetch(`${serverUrl}/sdk/list-bundles`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-sdk-token': sdkToken,
+        'x-deployment-key': deploymentKey,
+        ...customHeaders,
+      },
+      body: JSON.stringify({ channelId, platform, pageOffset }),
+    });
+
+    if (!response.ok) return { bundles: [], hasMore: false };
+    return response.json();
+  } catch (_e) {
+    return { bundles: [], hasMore: false };
+  }
+}

package/src/utils/device.ts

@@ -0,0 +1,15 @@
+import NativeSwiftPatch from '../native/NativeSwiftPatch';
+
+/**
+ * Get a unique device identifier for rollout bucketing
+ */
+export async function getDeviceId(): Promise<string> {
+  return NativeSwiftPatch.getDeviceId();
+}
+
+/**
+ * Get the current binary app version
+ */
+export async function getAppVersion(): Promise<string> {
+  return NativeSwiftPatch.getAppVersion();
+}

package/src/utils/logger.ts

@@ -0,0 +1,29 @@
+const TAG = '[SwiftPatch]';
+
+let debugEnabled = false;
+
+export const logger = {
+  setDebug(enabled: boolean): void {
+    debugEnabled = enabled;
+  },
+
+  debug(...args: unknown[]): void {
+    if (debugEnabled) {
+      console.debug(TAG, ...args);
+    }
+  },
+
+  info(...args: unknown[]): void {
+    if (debugEnabled) {
+      console.info(TAG, ...args);
+    }
+  },
+
+  warn(...args: unknown[]): void {
+    console.warn(TAG, ...args);
+  },
+
+  error(...args: unknown[]): void {
+    console.error(TAG, ...args);
+  },
+};

package/src/utils/storage.ts

@@ -0,0 +1,23 @@
+import NativeSwiftPatch from '../native/NativeSwiftPatch';
+import type { BundleInfo } from '../types';
+
+/**
+ * Get current bundle info from native storage
+ */
+export async function getCurrentBundleInfo(): Promise<BundleInfo | null> {
+  return NativeSwiftPatch.getCurrentBundle();
+}
+
+/**
+ * Check if an install is pending confirmation
+ */
+export async function hasPendingInstall(): Promise<boolean> {
+  return NativeSwiftPatch.hasPendingInstall();
+}
+
+/**
+ * Confirm the current install is stable
+ */
+export async function confirmInstall(): Promise<void> {
+  return NativeSwiftPatch.confirmInstall();
+}

package/src/withSwiftPatch.tsx

@@ -0,0 +1,41 @@
+import React, { useState, type ComponentType } from 'react';
+import { SwiftPatchProvider } from './SwiftPatchProvider';
+import { SwiftPatchModal } from './modal/SwiftPatchModal';
+import type { SwiftPatchConfig } from './types';
+import { DEFAULT_CONFIG } from './constants';
+
+/**
+ * Higher-order component to wrap your root component with SwiftPatchProvider.
+ * Also includes the built-in dashboard modal (accessible via useSwiftPatchModal).
+ */
+export function withSwiftPatch<P extends object>(
+  WrappedComponent: ComponentType<P>,
+  config: SwiftPatchConfig
+) {
+  const mergedConfig = { ...DEFAULT_CONFIG, ...config };
+
+  function WithSwiftPatch(props: P) {
+    const [modalVisible, setModalVisible] = useState(false);
+
+    return (
+      <SwiftPatchProvider config={config}>
+        <WrappedComponent {...props} />
+        <SwiftPatchModal
+          visible={modalVisible}
+          onClose={() => setModalVisible(false)}
+          serverUrl={mergedConfig.serverUrl!}
+          deploymentKey={config.deploymentKey}
+          customHeaders={mergedConfig.customHeaders}
+        />
+      </SwiftPatchProvider>
+    );
+  }
+
+  WithSwiftPatch.displayName = `withSwiftPatch(${
+    WrappedComponent.displayName || WrappedComponent.name || 'Component'
+  })`;
+
+  return WithSwiftPatch;
+}
+
+export default withSwiftPatch;