@oxy.so/services 13.6.0 → 13.8.0

package/src/ui/utils/__tests__/nativeAssetFiles.test.ts

@@ -0,0 +1,270 @@
+import type { AssetFileAdapter, OxyServices } from '@oxy.so/core';
+import { installNativeAssetFiles } from '../nativeAssetFiles.native';
+
+const originalUri = 'file:///capture.mp4';
+const mockFiles = new Map<string, { size: number; written: number }>();
+const mockReads: number[] = [];
+const mockDeleted: string[] = [];
+let mockNativeHasher: unknown = null;
+jest.mock('expo-modules-core', () => ({ requireOptionalNativeModule: () => mockNativeHasher }));
+let mockUpload: jest.Mock;
+let mockCancel: jest.Mock;
+let mockRequest: { url: string; uri: string; options: unknown } | undefined;
+
+jest.mock('expo-file-system', () => {
+  const uriOf = (value: string | { uri: string }) =>
+    typeof value === 'string' ? value : value.uri;
+  class Directory {
+    uri: string;
+    constructor(base: string, name: string) {
+      this.uri = `${base}/${name}`;
+    }
+    get exists() {
+      return false;
+    }
+    create() {}
+    delete() {}
+  }
+  class File {
+    uri: string;
+    constructor(base: string | { uri: string }, name?: string) {
+      this.uri = name ? `${uriOf(base)}/${name}` : uriOf(base);
+    }
+    get exists() {
+      return mockFiles.has(this.uri);
+    }
+    get size() {
+      return mockFiles.get(this.uri)?.size ?? 0;
+    }
+    create() {
+      mockFiles.set(this.uri, { size: 0, written: 0 });
+    }
+    delete() {
+      mockDeleted.push(this.uri);
+      mockFiles.delete(this.uri);
+    }
+    open() {
+      const uri = this.uri;
+      let offset = 0;
+      let closed = false;
+      return {
+        get offset() {
+          return offset;
+        },
+        set offset(next: number) {
+          offset = next;
+        },
+        readBytes(length: number) {
+          if (closed) throw new Error('Closed');
+          mockReads.push(length);
+          const size = mockFiles.get(uri)?.size ?? 0;
+          const bytes = new Uint8Array(Math.max(0, Math.min(length, size - offset))).fill(7);
+          offset += bytes.length;
+          return bytes;
+        },
+        writeBytes(bytes: Uint8Array) {
+          if (closed) throw new Error('Closed');
+          const file = mockFiles.get(uri);
+          if (!file) throw new Error('Missing target');
+          file.written += bytes.length;
+          file.size += bytes.length;
+        },
+        close() {
+          closed = true;
+        },
+      };
+    }
+  }
+  return { File, Directory, Paths: { cache: 'file:///cache' } };
+});
+jest.mock('expo-file-system/legacy', () => ({
+  FileSystemUploadType: { BINARY_CONTENT: 0 },
+  FileSystemSessionType: { FOREGROUND: 0 },
+  createUploadTask: (
+    url: string,
+    uri: string,
+    options: unknown,
+    progress: (event: { totalBytesSent: number }) => void,
+  ) => {
+    mockRequest = { url, uri, options };
+    return { uploadAsync: () => mockUpload(uri, progress), cancelAsync: () => mockCancel() };
+  },
+}));
+
+function adapter(): AssetFileAdapter {
+  let installed: AssetFileAdapter | undefined;
+  const oxy = {
+    assets: {
+      installFileAdapter: (value: AssetFileAdapter) => {
+        installed = value;
+        return () => {};
+      },
+    },
+  } as unknown as OxyServices;
+  installNativeAssetFiles(oxy);
+  if (!installed) throw new Error('Adapter was not installed');
+  return installed;
+}
+
+beforeEach(() => {
+  mockNativeHasher = null;
+  mockFiles.clear();
+  mockFiles.set(originalUri, { size: 370 * 1024 * 1024, written: 0 });
+  mockReads.length = 0;
+  mockDeleted.length = 0;
+  mockRequest = undefined;
+  mockCancel = jest.fn(async () => undefined);
+  mockUpload = jest.fn(
+    async (uri: string, progress: (event: { totalBytesSent: number }) => void) => {
+      progress({ totalBytesSent: mockFiles.get(uri)?.size ?? 0 });
+      return { status: 200 };
+    },
+  );
+});
+
+test('reads bounded ranges and streams only a temporary part of a larger-than-heap file', async () => {
+  const source = await adapter()(originalUri);
+  expect(source.size).toBe(370 * 1024 * 1024);
+  const bytes = await source.readRange(16 * 1024 * 1024, 24 * 1024 * 1024);
+  expect(bytes.length).toBe(8 * 1024 * 1024);
+  expect(bytes[bytes.length - 1]).toBe(7);
+  const onProgress = jest.fn();
+  await expect(
+    source.putPart({
+      url: 'https://storage.example/part?signed=1',
+      start: 32 * 1024 * 1024,
+      end: 40 * 1024 * 1024,
+      timeoutMs: 1000,
+      onProgress,
+    }),
+  ).resolves.toEqual({ ok: true });
+  expect(Math.max(...mockReads)).toBe(1024 * 1024);
+  expect(mockReads.reduce((sum, size) => sum + size, 0)).toBe(16 * 1024 * 1024);
+  expect(mockRequest).toMatchObject({
+    url: 'https://storage.example/part?signed=1',
+    options: { httpMethod: 'PUT', uploadType: 0, sessionType: 0, headers: {} },
+  });
+  expect(onProgress).toHaveBeenCalledWith(8 * 1024 * 1024);
+  expect(mockFiles.has(originalUri)).toBe(true);
+  expect(mockFiles.size).toBe(1);
+  expect(mockDeleted).toHaveLength(1);
+});
+
+test('abort cancels the native transfer and deletes its part while preserving the capture', async () => {
+  const source = await adapter()(originalUri);
+  const controller = new AbortController();
+  mockUpload.mockImplementation(() => new Promise(() => {}));
+  const pending = source.putPart({
+    url: 'https://storage.example/part',
+    start: 0,
+    end: 2 * 1024 * 1024,
+    timeoutMs: 1000,
+    signal: controller.signal,
+    onProgress: jest.fn(),
+  });
+  while (!mockRequest) await new Promise((resolve) => setTimeout(resolve, 0));
+  controller.abort();
+  await expect(pending).rejects.toMatchObject({ name: 'AbortError' });
+  expect(mockCancel).toHaveBeenCalledTimes(1);
+  expect(mockFiles.size).toBe(1);
+  expect(mockFiles.has(originalUri)).toBe(true);
+});
+
+test('a stalled native PUT times out and cleans its temporary part', async () => {
+  const source = await adapter()(originalUri);
+  mockUpload.mockImplementation(() => new Promise(() => {}));
+  await expect(
+    source.putPart({
+      url: 'https://storage.example/part',
+      start: 0,
+      end: 1024,
+      timeoutMs: 5,
+      onProgress: jest.fn(),
+    }),
+  ).resolves.toEqual({ ok: false, status: 0 });
+  expect(mockCancel).toHaveBeenCalledTimes(1);
+  expect(mockFiles.size).toBe(1);
+});
+
+test('hash reads let scheduled UI work run before the complete range is read', async () => {
+  const source = await adapter()(originalUri);
+  let readsAtTick = -1;
+  const tick = new Promise<void>((resolve) =>
+    setTimeout(() => {
+      readsAtTick = mockReads.length;
+      resolve();
+    }, 0),
+  );
+  await source.readRange(0, 8 * 1024 * 1024);
+  await tick;
+  expect(readsAtTick).toBeGreaterThan(0);
+  expect(readsAtTick).toBeLessThan(8);
+});
+
+test('an abort timer interrupts part preparation before copying the complete range', async () => {
+  const source = await adapter()(originalUri);
+  const controller = new AbortController();
+  setTimeout(() => controller.abort(), 0);
+  await expect(
+    source.putPart({
+      url: 'https://storage.example/part',
+      start: 0,
+      end: 8 * 1024 * 1024,
+      timeoutMs: 1000,
+      signal: controller.signal,
+      onProgress: jest.fn(),
+    }),
+  ).rejects.toMatchObject({ name: 'AbortError' });
+  expect(mockReads.length).toBeLessThan(8);
+  expect(mockUpload).not.toHaveBeenCalled();
+  expect(mockFiles.size).toBe(1);
+  expect(mockFiles.has(originalUri)).toBe(true);
+});
+
+test('uses the native streaming hash without reading bytes into JavaScript', async () => {
+  let progress: (event: { id: string; loaded: number }) => void;
+  const remove = jest.fn();
+  const digest = 'ab'.repeat(32);
+  mockNativeHasher = {
+    createHash: jest.fn(),
+    cancelHash: jest.fn(),
+    addListener: jest.fn((_event, callback) => {
+      progress = callback;
+      return { remove };
+    }),
+    hashAsync: jest.fn(async (id, _uri, size) => {
+      progress({ id: 'another-upload', loaded: 1 });
+      progress({ id, loaded: size });
+      return digest;
+    }),
+  };
+  const source = await adapter()(originalUri);
+  const onProgress = jest.fn();
+  await expect(source.hash?.(onProgress)).resolves.toBe(digest);
+  expect(mockReads).toHaveLength(0);
+  expect(onProgress).toHaveBeenCalledTimes(1);
+  expect(onProgress).toHaveBeenCalledWith(source.size);
+  expect(remove).toHaveBeenCalledTimes(1);
+});
+
+test('native hash cancellation waits for worker cleanup and removes its listener', async () => {
+  const controller = new AbortController();
+  const remove = jest.fn();
+  let finish: (value: string) => void;
+  const cancelHash = jest.fn(() => finish('ab'.repeat(32)));
+  mockNativeHasher = {
+    createHash: jest.fn(),
+    cancelHash,
+    addListener: () => ({ remove }),
+    hashAsync: () =>
+      new Promise<string>((resolve) => {
+        finish = resolve;
+      }),
+  };
+  const source = await adapter()(originalUri);
+  const pending = source.hash?.(undefined, controller.signal);
+  controller.abort();
+  await expect(pending).rejects.toMatchObject({ name: 'AbortError' });
+  expect(cancelHash).toHaveBeenCalledTimes(1);
+  expect(remove).toHaveBeenCalledTimes(1);
+});

package/src/ui/utils/entryLink.ts

@@ -0,0 +1,61 @@
+import { SUPPORTED_LANGUAGES, normalizeLocale } from '@oxy.so/core';
+import {
+  CAMPAIGN_LABEL_MAX_LENGTH,
+  isLanguageTag,
+  hasCampaignControlCharacters,
+  CAMPAIGN_CLICK_ID_MAX_LENGTH,
+  type CampaignAttribution,
+} from '@oxy.so/contracts/client';
+
+const CAMPAIGN_PARAMETERS = {
+  utmSource: 'utm_source',
+  utmMedium: 'utm_medium',
+  utmCampaign: 'utm_campaign',
+  utmContent: 'utm_content',
+  utmTerm: 'utm_term',
+  fbclid: 'fbclid',
+} as const;
+
+export function readCampaignAttribution(value: unknown): CampaignAttribution | undefined {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined;
+  const result: CampaignAttribution = {};
+  for (const field of Object.keys(CAMPAIGN_PARAMETERS) as (keyof CampaignAttribution)[]) {
+    const raw = Reflect.get(value, field);
+    if (typeof raw !== 'string') continue;
+    const normalized = raw.trim();
+    const limit = field === 'fbclid' ? CAMPAIGN_CLICK_ID_MAX_LENGTH : CAMPAIGN_LABEL_MAX_LENGTH;
+    if (!normalized || normalized.length > limit || hasCampaignControlCharacters(normalized))
+      continue;
+    result[field] = normalized;
+  }
+  return Object.keys(result).length ? result : undefined;
+}
+
+/** Consumes only explicit locale/campaign parameters, never the URL or referrer itself. */
+export function readEntryLink(url: string | null): {
+  language?: string;
+  campaignAttribution?: CampaignAttribution;
+} {
+  if (!url) return {};
+  let parsed: URL;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return {};
+  }
+  const languages = parsed.searchParams.getAll('lang');
+  const requestedLanguage = languages.length === 1 ? languages[0] : undefined;
+  const language =
+    requestedLanguage && isLanguageTag(requestedLanguage)
+      ? (normalizeLocale(requestedLanguage) ??
+        SUPPORTED_LANGUAGES.find(
+          (candidate) => candidate.language === requestedLanguage.split('-')[0]?.toLowerCase(),
+        )?.code)
+      : undefined;
+  const fields: Record<string, string> = {};
+  for (const [field, query] of Object.entries(CAMPAIGN_PARAMETERS)) {
+    const values = parsed.searchParams.getAll(query);
+    if (values.length === 1) fields[field] = values[0];
+  }
+  return { language, campaignAttribution: readCampaignAttribution(fields) };
+}

package/src/ui/utils/nativeAssetFiles.macos.ts

@@ -0,0 +1,6 @@
+import type { OxyServices } from '@oxy.so/core';
+
+/** Web/Node use their existing Blob transport. Metro selects the native adapter. */
+export function installNativeAssetFiles(_oxy: OxyServices): undefined {
+  return undefined;
+}

package/src/ui/utils/nativeAssetFiles.native.ts

@@ -0,0 +1,212 @@
+import type { AssetFilePartRequest, AssetFileSource, OxyServices } from '@oxy.so/core';
+import type { Directory, File } from 'expo-file-system';
+
+// File.slice() reads the WHOLE file on Expo; RN Blob does the same on Java's
+// heap. FileHandle reads and native file uploads keep both heaps bounded.
+const COPY_CHUNK_BYTES = 1024 * 1024;
+let partsDirectory: Promise<Directory> | undefined;
+let nextPart = 0;
+let nextHash = 0;
+interface NativeFileHasher {
+  createHash(id: string): void;
+  cancelHash(id: string): void;
+  hashAsync(id: string, uri: string, expectedSize: number): Promise<string>;
+  addListener(
+    event: 'hashProgress',
+    listener: (event: { id: string; loaded: number }) => void,
+  ): { remove(): void };
+}
+
+// FileHandle methods are synchronous: awaiting them alone only yields a
+// microtask. Let rendering, native events and abort timers run between chunks.
+function yieldToEventLoop(): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+function abortError(): Error {
+  const error = new Error('Upload aborted');
+  error.name = 'AbortError';
+  return error;
+}
+
+function checkAbort(signal?: AbortSignal): void {
+  if (signal?.aborted) throw abortError();
+}
+
+async function temporaryParts(): Promise<Directory> {
+  partsDirectory ??= import('expo-file-system')
+    .then(({ Directory, Paths }) => {
+      const directory = new Directory(Paths.cache, 'oxy-upload-parts');
+      // These are foreground transfers. A new JS runtime owns no previous parts;
+      // remove leftovers from a killed process before creating any new part.
+      if (directory.exists) directory.delete();
+      directory.create({ intermediates: true });
+      return directory;
+    })
+    .catch((error) => {
+      partsDirectory = undefined;
+      throw error;
+    });
+  return partsDirectory;
+}
+
+async function copyRange(
+  file: File,
+  target: File,
+  start: number,
+  end: number,
+  signal?: AbortSignal,
+): Promise<void> {
+  const reader = file.open();
+  try {
+    reader.offset = start;
+    const writer = target.open();
+    try {
+      for (let offset = start; offset < end; ) {
+        checkAbort(signal);
+        const bytes = await reader.readBytes(Math.min(COPY_CHUNK_BYTES, end - offset));
+        if (!bytes.length) throw new Error('File changed while preparing upload');
+        await writer.writeBytes(bytes);
+        offset += bytes.length;
+        await yieldToEventLoop();
+      }
+    } finally {
+      writer.close();
+    }
+  } finally {
+    reader.close();
+  }
+}
+
+async function putRange(
+  file: File,
+  request: AssetFilePartRequest,
+): ReturnType<AssetFileSource['putPart']> {
+  const [{ File }, legacy, directory] = await Promise.all([
+    import('expo-file-system'),
+    import('expo-file-system/legacy'),
+    temporaryParts(),
+  ]);
+  checkAbort(request.signal);
+  const part = new File(directory, `part-${++nextPart}`);
+  part.create();
+  try {
+    await copyRange(file, part, request.start, request.end, request.signal);
+    checkAbort(request.signal);
+    const task = legacy.createUploadTask(
+      request.url,
+      part.uri,
+      {
+        httpMethod: 'PUT',
+        uploadType: legacy.FileSystemUploadType.BINARY_CONTENT,
+        sessionType: legacy.FileSystemSessionType.FOREGROUND,
+        headers: {},
+      },
+      ({ totalBytesSent }) => request.onProgress(totalBytesSent),
+    );
+    let cancel: Promise<void> | undefined;
+    let stop = () => {};
+    const interrupted = new Promise<never>((_resolve, reject) => {
+      stop = () => {
+        cancel ??= task.cancelAsync();
+        void cancel.catch(() => undefined);
+        reject(abortError());
+      };
+    });
+    const timer = setTimeout(() => {
+      stop();
+    }, request.timeoutMs);
+    request.signal?.addEventListener('abort', stop, { once: true });
+    try {
+      checkAbort(request.signal);
+      const result = await Promise.race([task.uploadAsync(), interrupted]);
+      if (!result) throw abortError();
+      return result.status >= 200 && result.status < 300
+        ? { ok: true }
+        : { ok: false, status: result.status };
+    } catch {
+      if (request.signal?.aborted) throw abortError();
+      // The core session owner applies its bounded retry/backoff policy.
+      return { ok: false, status: 0 };
+    } finally {
+      clearTimeout(timer);
+      request.signal?.removeEventListener('abort', stop);
+      if (cancel) await cancel.catch(() => undefined);
+    }
+  } finally {
+    if (part.exists) part.delete();
+  }
+}
+
+async function openNativeFile(uri: string): Promise<AssetFileSource> {
+  const { File } = await import('expo-file-system');
+  let nativeHasher: NativeFileHasher | null = null;
+  try {
+    const { requireOptionalNativeModule } = await import('expo-modules-core');
+    nativeHasher = requireOptionalNativeModule<NativeFileHasher>('OxyAssetFiles');
+  } catch {
+    // Hosts without the optional Expo module bridge retain bounded file access.
+  }
+  const file = new File(uri);
+  if (!file.exists) throw new Error('Native upload file is unavailable');
+  const size = file.size;
+  return {
+    size,
+    // Older native binaries can still use bounded JS reads after an OTA. New
+    // binaries hash entirely on a native worker, without sending bytes to JS.
+    hash: nativeHasher
+      ? async (onProgress, signal) => {
+          checkAbort(signal);
+          if (file.size !== size) throw new Error('File changed while hashing');
+          const id = `upload-hash-${++nextHash}`;
+          const listener = nativeHasher.addListener('hashProgress', (event) => {
+            if (event.id === id && !signal?.aborted) onProgress?.(event.loaded);
+          });
+          const stop = () => nativeHasher.cancelHash(id);
+          try {
+            nativeHasher.createHash(id);
+            signal?.addEventListener('abort', stop, { once: true });
+            if (signal?.aborted) stop();
+            const digest = await nativeHasher.hashAsync(id, uri, size);
+            checkAbort(signal);
+            return digest;
+          } catch (error) {
+            checkAbort(signal);
+            throw error;
+          } finally {
+            signal?.removeEventListener('abort', stop);
+            listener.remove();
+          }
+        }
+      : undefined,
+    async readRange(start, end) {
+      if (file.size !== size) throw new Error('File changed while uploading');
+      if (start < 0 || end > size || end < start) throw new Error('Invalid upload file range');
+      const reader = file.open();
+      try {
+        reader.offset = start;
+        const output = new Uint8Array(end - start);
+        let read = 0;
+        while (read < output.length) {
+          const bytes = await reader.readBytes(Math.min(COPY_CHUNK_BYTES, output.length - read));
+          if (!bytes.length) throw new Error('File changed while hashing');
+          output.set(bytes, read);
+          read += bytes.length;
+          await yieldToEventLoop();
+        }
+        return output;
+      } finally {
+        reader.close();
+      }
+    },
+    putPart: (request) => {
+      if (file.size !== size) throw new Error('File changed while uploading');
+      return putRange(file, request);
+    },
+  };
+}
+
+/** One provider-owned adapter; no native filesystem module loads before an upload. */
+export function installNativeAssetFiles(oxy: OxyServices): () => void {
+  return oxy.assets.installFileAdapter(openNativeFile);
+}

package/src/ui/utils/nativeAssetFiles.ts

@@ -0,0 +1,6 @@
+import type { OxyServices } from '@oxy.so/core';
+
+/** Web/Node use their existing Blob transport. Metro selects the native adapter. */
+export function installNativeAssetFiles(_oxy: OxyServices): undefined {
+  return undefined;
+}