ObjectStateMutations.ts

import encode from './encode';
import CoreManager from './CoreManager';
import ParseFile from './ParseFile';
import ParseRelation from './ParseRelation';
import TaskQueue from './TaskQueue';
import { RelationOp } from './ParseOp';
import type { Op } from './ParseOp';
import type ParseObject from './ParseObject';
import { isDangerousKey } from "./isDangerousKey";

export type AttributeMap = Record<string, any>;
export type OpsMap = Record<string, Op>;
export type ObjectCache = Record<string, string>;

export interface State {
  serverData: AttributeMap;
  pendingOps: OpsMap[];
  objectCache: ObjectCache;
  tasks: TaskQueue;
  existed: boolean;
}

export function defaultState(): State {
  return {
    serverData: Object.create(null),
    pendingOps: [Object.create(null)],
    objectCache: Object.create(null),
    tasks: new TaskQueue(),
    existed: false,
  };
}

export function setServerData(serverData: AttributeMap, attributes: AttributeMap) {
  for (const attr in attributes) {
    // Skip properties from prototype chain
    if (!Object.prototype.hasOwnProperty.call(attributes, attr)) {
      continue;
    }
    // Skip dangerous keys that could pollute prototypes
    if (isDangerousKey(attr)) {
      continue;
    }
    if (typeof attributes[attr] !== "undefined") {
      serverData[attr] = attributes[attr];
    } else {
      delete serverData[attr];
    }
  }
}

export function setPendingOp(pendingOps: OpsMap[], attr: string, op?: Op) {
  // Skip dangerous keys that could pollute prototypes
  if (isDangerousKey(attr)) {
    return;
  }
  const last = pendingOps.length - 1;
  if (op) {
    pendingOps[last][attr] = op;
  } else {
    delete pendingOps[last][attr];
  }
}

export function pushPendingState(pendingOps: OpsMap[]) {
  pendingOps.push(Object.create(null));
}

export function popPendingState(pendingOps: OpsMap[]): OpsMap {
  const first = pendingOps.shift();
  if (!pendingOps.length) {
    pendingOps[0] = Object.create(null);
  }
  return first;
}

export function mergeFirstPendingState(pendingOps: OpsMap[]) {
  const first = popPendingState(pendingOps);
  const next = pendingOps[0];
  for (const attr in first) {
    // Skip properties from prototype chain
    if (!Object.prototype.hasOwnProperty.call(first, attr)) {
      continue;
    }
    // Skip dangerous keys that could pollute prototypes
    if (isDangerousKey(attr)) {
      continue;
    }
    if (next[attr] && first[attr]) {
      const merged = next[attr].mergeWith(first[attr]);
      if (merged) {
        next[attr] = merged;
      }
    } else {
      next[attr] = first[attr];
    }
  }
}

export function estimateAttribute(
  serverData: AttributeMap,
  pendingOps: OpsMap[],
  object: ParseObject,
  attr: string
): any {
  // Skip dangerous keys that could pollute prototypes
  if (isDangerousKey(attr)) {
    return undefined;
  }
  let value = serverData[attr];
  for (let i = 0; i < pendingOps.length; i++) {
    if (pendingOps[i][attr]) {
      if (pendingOps[i][attr] instanceof RelationOp) {
        if (object.id) {
          value = (pendingOps[i][attr] as RelationOp).applyTo(value, object, attr);
        }
      } else {
        value = pendingOps[i][attr].applyTo(value);
      }
    }
  }
  return value;
}

export function estimateAttributes(
  serverData: AttributeMap,
  pendingOps: OpsMap[],
  object: ParseObject
): AttributeMap {
  const data = Object.create(null);
  let attr;
  for (attr in serverData) {
    data[attr] = serverData[attr];
  }
  for (let i = 0; i < pendingOps.length; i++) {
    for (attr in pendingOps[i]) {
      // Skip properties from prototype chain
      if (!Object.prototype.hasOwnProperty.call(pendingOps[i], attr)) {
        continue;
      }
      // Skip dangerous keys that could pollute prototypes
      if (isDangerousKey(attr)) {
        continue;
      }
      if (pendingOps[i][attr] instanceof RelationOp) {
        if (object.id) {
          data[attr] = (pendingOps[i][attr] as RelationOp).applyTo(data[attr], object, attr);
        }
      } else {
        if (attr.includes('.')) {
          // similar to nestedSet function
          const fields = attr.split('.');
          const last = fields[fields.length - 1];
          let object = data;
          for (let i = 0; i < fields.length - 1; i++) {
            const key = fields[i];
            if (!(key in object)) {
              const nextKey = fields[i + 1];
              if (!isNaN(nextKey)) {
                object[key] = [];
              } else {
                object[key] = Object.create(null);
              }
            } else {
              if (Array.isArray(object[key])) {
                object[key] = [...object[key]];
              } else {
                object[key] = { ...object[key] };
              }
            }
            object = object[key];
          }
          object[last] = pendingOps[i][attr].applyTo(object[last]);
        } else {
          data[attr] = pendingOps[i][attr].applyTo(data[attr]);
        }
      }
    }
  }
  return data;
}

/**
 * Allows setting properties/variables deep in an object.
 * Converts a.b into { a: { b: value } } for dot notation on Objects
 * Converts a.0.b into { a: [{ b: value }] } for dot notation on Arrays
 *
 * @param obj The object to assign the value to
 * @param key The key to assign. If it's in a deeper path, then use dot notation (`prop1.prop2.prop3`)
 * Note that intermediate object(s) in the nested path are automatically created if they don't exist.
 * @param value The value to assign. If it's an `undefined` then the key is deleted.
 */
function nestedSet(obj, key, value) {
  const paths = key.split('.');
  for (let i = 0; i < paths.length - 1; i++) {
    const path = paths[i];
    if (!(path in obj)) {
      const nextPath = paths[i + 1];
      if (!isNaN(nextPath)) {
        obj[path] = [];
      } else {
        obj[path] = Object.create(null);
      }
    }
    obj = obj[path];
  }
  if (typeof value === 'undefined') {
    delete obj[paths[paths.length - 1]];
  } else {
    obj[paths[paths.length - 1]] = value;
  }
}

export function commitServerChanges(
  serverData: AttributeMap,
  objectCache: ObjectCache,
  changes: AttributeMap
) {
  const ParseObject = CoreManager.getParseObject();
  for (const attr in changes) {
    // Skip properties from prototype chain
    if (!Object.prototype.hasOwnProperty.call(changes, attr)) {
      continue;
    }
    // Skip dangerous keys that could pollute prototypes
    if (isDangerousKey(attr)) {
      continue;
    }
    const val = changes[attr];
    // Set the change value to server data using nested path
    nestedSet(serverData, attr, val);
    
    // Initialize cache value and cache key
    let cacheVal = val,
        cacheKey = attr
    
    // Handle nested attributes (dot notation)
    if (attr.indexOf('.') >= 0) {
      // Split attribute path and use first key for caching
      const [firstKey, ..._rest] = attr.split('.')
      cacheKey = firstKey
      // Get the actual value from server data using first key
      cacheVal = serverData[firstKey]
    }
    
    // Check if cache value should be serialized and stored
    // Only serialize plain objects, not Parse instances
    if (
      cacheVal && // Value exists
      typeof cacheVal === 'object' && // Is an object
      !(cacheVal instanceof ParseObject) &&
      !(cacheVal instanceof ParseFile) &&
      !(cacheVal instanceof ParseRelation)
    ) {
      const json = encode(cacheVal, false, true)
      // Store serialized JSON string in object cache
      objectCache[cacheKey] = JSON.stringify(json)
    }
  }
}