ListDynamicFields - Query Object Dynamic Fields

message ListDynamicFieldsResponse {
  repeated DynamicField fields = 1;
  string next_page_token = 2;
}

message DynamicField {
  string name = 1;
  string type = 2;
  string object_type = 3;
  string object_id = 4;
  uint64 version = 5;
  string digest = 6;
}

async function fetchAllDynamicFields(objectId: string): Promise<any[]> {
  const allFields: any[] = [];
  let pageToken: string | undefined = undefined;

  do {
    const response = await listDynamicFields(objectId, 50, pageToken);

    allFields.push(...response.fields);
    pageToken = response.next_page_token;

    console.log(`Fetched ${response.fields.length} fields, total: ${allFields.length}`);

  } while (pageToken);

  return allFields;
}

// Usage
const allFields = await fetchAllDynamicFields(objectId);
console.log(`Total fields: ${allFields.length}`);

interface DynamicFieldInfo {
  name: string;
  type: string;
  valueObjectId: string;
  valueType: string;
}

async function exploreCollection(objectId: string): Promise<DynamicFieldInfo[]> {
  const fields = await fetchAllDynamicFields(objectId);

  return fields.map(field => ({
    name: field.name,
    type: field.type,
    valueObjectId: field.object_id,
    valueType: field.object_type
  }));
}

// Usage for exploring a Map or Table
const collectionFields = await exploreCollection(tableObjectId);

console.log('Collection contains:');
collectionFields.forEach(field => {
  console.log(`  ${field.name}: ${field.valueType}`);
});

async function getDynamicFieldValue(
  parentObjectId: string,
  fieldName: string
): Promise<any | null> {
  const fields = await fetchAllDynamicFields(parentObjectId);

  const field = fields.find(f => f.name === fieldName);

  if (!field) {
    console.warn(`Field "${fieldName}" not found`);
    return null;
  }

  // Fetch the value object
  const valueObject = await getObject(field.object_id);

  return valueObject;
}

// Usage
const userProfile = await getDynamicFieldValue(
  registryObjectId,
  'user_123'
);

console.log('User profile:', userProfile);

class DynamicFieldMonitor {
  private previousFields = new Map<string, Set<string>>();

  async checkForChanges(objectId: string): Promise<{
    added: string[];
    removed: string[];
    modified: string[];
  }> {
    const currentFields = await fetchAllDynamicFields(objectId);
    const currentSet = new Set(
      currentFields.map(f => `${f.name}:${f.version}`)
    );

    const previousSet = this.previousFields.get(objectId) || new Set();

    const added: string[] = [];
    const removed: string[] = [];
    const modified: string[] = [];

    // Check for added and modified fields
    for (const field of currentFields) {
      const key = `${field.name}:${field.version}`;
      const prevKey = Array.from(previousSet).find(k => k.startsWith(`${field.name}:`));

      if (!prevKey) {
        added.push(field.name);
      } else if (prevKey !== key) {
        modified.push(field.name);
      }
    }

    // Check for removed fields
    const currentNames = new Set(currentFields.map(f => f.name));
    for (const prev of previousSet) {
      const name = prev.split(':')[0];
      if (!currentNames.has(name)) {
        removed.push(name);
      }
    }

    this.previousFields.set(objectId, currentSet);

    return { added, removed, modified };
  }
}

// Usage
const monitor = new DynamicFieldMonitor();

setInterval(async () => {
  const changes = await monitor.checkForChanges(objectId);

  if (changes.added.length > 0) {
    console.log('Fields added:', changes.added);
  }
  if (changes.removed.length > 0) {
    console.log('Fields removed:', changes.removed);
  }
  if (changes.modified.length > 0) {
    console.log('Fields modified:', changes.modified);
  }
}, 10000);

interface FieldIndex {
  [fieldName: string]: {
    objectId: string;
    type: string;
    version: number;
  };
}

async function buildFieldIndex(objectId: string): Promise<FieldIndex> {
  const fields = await fetchAllDynamicFields(objectId);

  const index: FieldIndex = {};

  for (const field of fields) {
    index[field.name] = {
      objectId: field.object_id,
      type: field.object_type,
      version: parseInt(field.version)
    };
  }

  return index;
}

// Usage
const index = await buildFieldIndex(objectId);

// Quick lookups
const userField = index['user_123'];
if (userField) {
  console.log(`User object: ${userField.objectId}`);
}

async function searchFields(
  objectId: string,
  pattern: RegExp
): Promise<any[]> {
  const allFields = await fetchAllDynamicFields(objectId);

  return allFields.filter(field => pattern.test(field.name));
}

// Usage
const userFields = await searchFields(
  registryObjectId,
  /^user_\d+$/
);

console.log(`Found ${userFields.length} user fields`);

async function fetchFieldsPage(
  objectId: string,
  pageSize: number = 50
): Promise<AsyncGenerator<any[], void, unknown>> {
  return async function* () {
    let pageToken: string | undefined = undefined;

    do {
      const response = await listDynamicFields(objectId, pageSize, pageToken);

      yield response.fields;

      pageToken = response.next_page_token;
    } while (pageToken);
  }();
}

// Usage with async iteration
const pages = await fetchFieldsPage(objectId);

for await (const page of pages) {
  console.log(`Processing ${page.length} fields`);
  // Process each page
}

class DynamicFieldCache {
  private cache = new Map<string, { data: any[]; timestamp: number }>();
  private ttl = 30000; // 30 seconds

  async getFields(objectId: string): Promise<any[]> {
    const cached = this.cache.get(objectId);

    if (cached && Date.now() - cached.timestamp < this.ttl) {
      return cached.data;
    }

    const fields = await fetchAllDynamicFields(objectId);

    this.cache.set(objectId, {
      data: fields,
      timestamp: Date.now()
    });

    return fields;
  }

  invalidate(objectId: string): void {
    this.cache.delete(objectId);
  }
}

async function getDynamicFieldsSafe(objectId: string): Promise<any[]> {
  try {
    const fields = await fetchAllDynamicFields(objectId);

    if (fields.length === 0) {
      console.log(`Object ${objectId} has no dynamic fields`);
    }

    return fields;
  } catch (error: any) {
    if (error.code === grpc.status.NOT_FOUND) {
      console.warn(`Object ${objectId} not found`);
      return [];
    }

    throw error;
  }
}