Storage Utilities ❌ Internal API

/**
 * Returns a new IChannelStorageService that resolves the given path as root
 */
class ObjectStoragePartition {
  /**
   * @param storage - The underlying storage service
   * @param path - The path to treat as the root for this partition
   */
  constructor(storage: IChannelStorageService, path: string);
  
  /**
   * Read blob contents from the partition
   * @param path - Path relative to the partition root
   * @returns Promise resolving to the blob contents
   */
  readBlob(path: string): Promise<ArrayBufferLike>;
  
  /**
   * Check if a blob exists at the given path in the partition
   * @param path - Path relative to the partition root
   * @returns Promise resolving to true if the blob exists
   */
  contains(path: string): Promise<boolean>;
  
  /**
   * List all blobs at the given path in the partition
   * @param path - Path relative to the partition root
   * @returns Promise resolving to array of blob names
   */
  list(path: string): Promise<string[]>;
}

/**
 * Normalizes a storage path by removing leading and trailing slashes and splitting into parts
 * @param path - The storage path to normalize (e.g. "/foo/bar/")
 * @returns Array of path segments (e.g. ["foo", "bar"])
 */
function getNormalizedObjectStoragePathParts(path: string): string[];

/**
 * Lists all blobs at the specified path in the given tree
 * @param inputTree - The tree to search within
 * @param path - The path to search at (e.g. "foo/bar")
 * @returns Promise that resolves to an array of blob names at that path
 * @throws Error if the path does not exist in the tree
 */
function listBlobsAtTreePath(
  inputTree: ITree | undefined,
  path: string
): Promise<string[]>;

/**
 * Utility function to check if any blobs under a snapshot tree are missing
 * @param snapshotTree - Snapshot tree to be evaluated for missing blobs
 * @param blobContents - Blob contents of the snapshot
 * @returns True if snapshot fetch is required, false otherwise
 */
function isSnapshotFetchRequiredForLoadingGroupId(
  snapshotTree: ISnapshotTree,
  blobContents: Map<string, ArrayBuffer>
): boolean;

// ❌ These imports will NOT work - APIs are internal
// import { 
//   ObjectStoragePartition,
//   getNormalizedObjectStoragePathParts,
//   listBlobsAtTreePath,
//   isSnapshotFetchRequiredForLoadingGroupId
// } from "@fluidframework/runtime-utils";

// Storage partitioning
const rootStorage = getContainerStorage();
const dataStorePartition = new ObjectStoragePartition(
  rootStorage, 
  "datastores/my-component"
);

// All operations now work relative to "datastores/my-component"
const configBlob = await dataStorePartition.readBlob("config.json");
const hasCache = await dataStorePartition.contains("cache/data.bin");
const allFiles = await dataStorePartition.list("");

// Path normalization
const pathParts = getNormalizedObjectStoragePathParts("/foo/bar/baz/");
console.log(pathParts); // ["foo", "bar", "baz"]

const emptyParts = getNormalizedObjectStoragePathParts("///");
console.log(emptyParts); // []

// Tree navigation
const tree = await getSnapshotTree();
try {
  const blobsInPath = await listBlobsAtTreePath(tree, "settings");
  console.log("Configuration blobs:", blobsInPath);
} catch (error) {
  console.log("Settings path does not exist");
}

// Snapshot loading check
const snapshotTree = await getLatestSnapshot();
const blobContents = new Map<string, ArrayBuffer>();
await loadBlobContents(blobContents);

if (isSnapshotFetchRequiredForLoadingGroupId(snapshotTree, blobContents)) {
  console.log("Need to fetch additional snapshot data");
  await fetchMissingBlobs(snapshotTree, blobContents);
}

// Hierarchical storage access
class ComponentStorage {
  private partition: ObjectStoragePartition;
  
  constructor(rootStorage: IChannelStorageService, componentId: string) {
    this.partition = new ObjectStoragePartition(
      rootStorage, 
      `components/${componentId}`
    );
  }
  
  async loadConfiguration(): Promise<any> {
    if (await this.partition.contains("config.json")) {
      const configData = await this.partition.readBlob("config.json");
      return JSON.parse(new TextDecoder().decode(configData));
    }
    return {};
  }
  
  async saveData(key: string, data: any): Promise<void> {
    const jsonData = JSON.stringify(data);
    const blob = new TextEncoder().encode(jsonData);
    // Note: This example assumes a writable storage interface
    // The actual ObjectStoragePartition is read-only
  }
  
  async listAllData(): Promise<string[]> {
    return this.partition.list("data");
  }
}

// Path manipulation utilities
function joinStoragePaths(...parts: string[]): string {
  return parts
    .flatMap(part => getNormalizedObjectStoragePathParts(part))
    .join("/");
}

function getParentPath(path: string): string {
  const parts = getNormalizedObjectStoragePathParts(path);
  return parts.slice(0, -1).join("/");
}

// Tree traversal example
async function findAllBlobsInTree(
  tree: ITree | undefined, 
  basePath: string = ""
): Promise<string[]> {
  if (!tree) return [];
  
  const allBlobs: string[] = [];
  
  try {
    const blobsAtPath = await listBlobsAtTreePath(tree, basePath);
    allBlobs.push(...blobsAtPath.map(name => 
      basePath ? `${basePath}/${name}` : name
    ));
  } catch {
    // Path doesn't exist, continue
  }
  
  // Recursively search subdirectories
  // Note: This would require additional tree navigation utilities
  // that aren't part of the current API
  
  return allBlobs;
}