sailfork / t3code-github / apps/ mobile/ src/ features/ sharing/ incoming-share-storage.ts

import * as Schema from "effect/Schema";
import type { File } from "expo-file-system";

import { decodeIncomingShareDraft, type IncomingShareDraft } from "./incoming-share-model";

const INCOMING_SHARE_DIRECTORY = "incoming-shares";

export class IncomingShareStorageError extends Schema.TaggedError<IncomingShareStorageError>()(
  "IncomingShareStorageError",
  {
    operation: Schema.Literals(["load", "write", "remove"]),
    shareId: Schema.NullOr(Schema.String),
    cause: Schema.Defect(),
  },
) {
  override get message(): string {
    return `Incoming share storage operation ${this.operation} failed for ${this.shareId ?? "unknown"}.`;
  }
}

const isIncomingShareStorageError = Schema.is(IncomingShareStorageError);

function fileName(shareId: string): string {
  return `${encodeURIComponent(shareId)}.json`;
}

async function getDirectory() {
  const { Directory, Paths } = await import("expo-file-system");
  const directory = new Directory(Paths.document, INCOMING_SHARE_DIRECTORY);
  directory.create({ idempotent: true, intermediates: true });
  return directory;
}

async function getFile(shareId: string, suffix = "") {
  const { File } = await import("expo-file-system");
  return new File(await getDirectory(), `${fileName(shareId)}${suffix}`);
}

async function readSavedDraft(file: File) {
  try {
    return { file, draft: decodeIncomingShareDraft(JSON.parse(await file.text()) as unknown) };
  } catch (cause) {
    const { File } = await import("expo-file-system");
    const backup = new File(file.parentDirectory, `${file.name}.bak`);
    if (!backup.exists) throw cause;
    return {
      file: backup,
      draft: decodeIncomingShareDraft(JSON.parse(await backup.text()) as unknown),
    };
  }
}

export async function loadIncomingShareDrafts(options?: {
  readonly strict?: boolean;
}): Promise<ReadonlyArray<IncomingShareDraft>> {
  try {
    const { File } = await import("expo-file-system");
    const drafts: IncomingShareDraft[] = [];
    for (const entry of (await getDirectory()).list()) {
      if (!(entry instanceof File)) continue;
      if (entry.name.endsWith(".json.bak")) {
        if (new File(entry.parentDirectory, entry.name.slice(0, -4)).exists) continue;
      } else if (!entry.name.endsWith(".json")) {
        continue;
      }
      try {
        drafts.push((await readSavedDraft(entry)).draft);
      } catch (cause) {
        const error = new IncomingShareStorageError({ operation: "load", shareId: null, cause });
        if (options?.strict) {
          throw error;
        }
        console.warn("[incoming-share] ignored invalid persisted share", error);
      }
    }
    return drafts.sort((left, right) => right.createdAt.localeCompare(left.createdAt));
  } catch (cause) {
    if (isIncomingShareStorageError(cause)) {
      throw cause;
    }
    throw new IncomingShareStorageError({ operation: "load", shareId: null, cause });
  }
}

export async function writeIncomingShareDraft(draft: IncomingShareDraft): Promise<void> {
  try {
    const file = await getFile(draft.id);
    const backup = await getFile(draft.id, ".bak");
    const temp = await getFile(draft.id, ".tmp");
    // Inbox mutations are serialized, so each share can reuse its staging path.
    temp.create({ intermediates: true, overwrite: true });
    await temp.write(JSON.stringify(draft));
    // Expo can remove or partially copy the destination before a move fails.
    if (file.exists) {
      const saved = await readSavedDraft(file).catch(() => undefined);
      if (!saved || saved.file === file) file.copySync(backup, { overwrite: true });
    }
    temp.moveSync(file, { overwrite: true });
    try {
      if (backup.exists) backup.delete();
    } catch {
      // The installed JSON is authoritative even if backup cleanup fails.
    }
  } catch (cause) {
    throw new IncomingShareStorageError({ operation: "write", shareId: draft.id, cause });
  }
}

export async function removeIncomingShareDraft(shareId: string): Promise<void> {
  try {
    // Delete the backup first so a failed removal cannot resurrect a consumed share.
    for (const suffix of [".tmp", ".bak", ""]) {
      const file = await getFile(shareId, suffix);
      if (file.exists) file.delete();
    }
  } catch (cause) {
    throw new IncomingShareStorageError({ operation: "remove", shareId, cause });
  }
}