Spreading Proxies for JavaScript.

viralProxies.ts

/*
Copyright 2020 Joshua D Scarsbrook

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

// The main interface is ViralProxy.create.
// Call it with an instance of the object to watch and a instance of ViralProxyHost.

// These 4 imports are from my standard library.

// The logger could be replaced by `console`.
import { getLogger } from './logger';

// Expect just always throws an error.
// getRandomId returns a random string.
import { expect, getRandomId } from './common';

// GraphVisGraph is only required by my visualization code.
import { GraphVisGraph } from './graph';

const VIRAL_PROXY_TAG = Symbol('ViralProxy');

const log = getLogger('viralProxies2').disableDebug();

interface StackTraceFrame {
  methodName: string;
  filename: string;
  line: number;
  column: number;
}

function parseStackTrace(stack: string): StackTraceFrame[] {
  const frameRegex = /at (.*) \((.*):([0-9]+):([0-9]+)\)/;
  const frame2Regex = /at (.*):([0-9]+):([0-9]+)/;
  const frame3Regex = /at (.*) \(\<anonymous\>\)/;

  const rawFrames = stack.split('\n').slice(1);

  return rawFrames.map(frame => {
    let matchResult = frame.match(frameRegex);

    let [_, methodName, filename, lineString, columnString] = [] as string[];

    if (matchResult === null) {
      matchResult = frame.match(frame2Regex);

      if (matchResult === null) {
        matchResult = frame.match(frame3Regex);

        if (matchResult === null) {
          throw new Error(`Could not match line in stacktrace [${frame}]`);
        } else {
          filename = '<anonymous>';
          lineString = '0';
          columnString = '0';
          [_, methodName] = matchResult;
        }
      } else {
        methodName = 'unknown';
        [_, filename, lineString, columnString] = matchResult;
      }
    } else {
      [_, methodName, filename, lineString, columnString] = matchResult;
    }

    const line = Number.parseInt(lineString, 10);
    const column = Number.parseInt(columnString, 10);

    return { methodName, filename, line, column };
  });
}
    
export class ViralProxyRoot {
  private hashMap = new Map<string, string>();

  private graph = new GraphVisGraph();

  onStackTrace(stackTrace: StackTraceFrame[]) {
    let lastNode = 'root';

    for (const frame of stackTrace) {
      const frameHash = JSON.stringify(frame);

      let frameId = this.hashMap.get(frameHash);

      if (frameId === undefined) {
        const newId = `id_${getRandomId()}`;

        this.hashMap.set(frameHash, newId);

        this.graph.addNode(
          newId,
          `${frame.methodName}:${frame.line}:${frame.column}`
        );

        frameId = newId;
      }

      this.graph.addEdge(lastNode, frameId);

      lastNode = frameId;
    }
  }

  export() {
    return this.graph.export();
  }
}

export class ViralProxy<T extends object> implements ProxyHandler<T> {
  constructor(readonly root: ViralProxyRoot, readonly name: string) {}

  static create<T extends object>(
    obj: T,
    root: ViralProxyRoot,
    name = '$ROOT'
  ): T {
    const newProxy = new Proxy(obj, new ViralProxy(root, name));
    return newProxy;
  }

  // tslint:disable-next-line: no-any
  get?(target: T, p: PropertyKey, receiver: unknown): any {
    if (p === VIRAL_PROXY_TAG) {
      return true;
    }

    log.trace(this.name, p);

    this.captureStackTrace();

    const internalValue = Reflect.get(target, p);

    return this.proxyOf(p, internalValue);
  }

  set?(target: T, p: PropertyKey, value: unknown, receiver: unknown): boolean {
    log.trace(this.name, p);

    this.captureStackTrace();

    return Reflect.set(target, p, value, receiver);
  }

  // tslint:disable-next-line: no-any
  apply?(target: T, thisArg: any, argArray?: any): any {
    log.trace(this.name);

    this.captureStackTrace();

    const newThis = this.proxyOf(`$THIS`, thisArg);

    if (!Array.isArray(argArray)) {
      throw new Error('Not Implemented');
    }

    const newArgs = argArray.map((arg, index) => {
      return this.proxyOf(`$ARG[${index}]`, arg);
    });

    const result = Reflect.apply(target as Function, newThis, newArgs);

    return this.proxyOf('$RETURN', result);
  }

  // tslint:disable-next-line: no-any
  construct?(target: T, argArray: any, newTarget?: any): object {
    log.trace(this.name);

    this.captureStackTrace();

    return Reflect.construct(target as Function, argArray, newTarget);
  }

  private captureStackTrace() {
    const err = new Error();

    Error.stackTraceLimit = 1000;

    Error.captureStackTrace(err);

    const stack = parseStackTrace(err.stack || expect());

    this.onStackTrace(stack.slice(2).reverse());
  }

  protected onStackTrace(stackTrace: StackTraceFrame[]) {
    this.root.onStackTrace(stackTrace);
  }

  // tslint:disable-next-line: no-any
  private proxyOf(p: PropertyKey, value: any): any {
    if (value instanceof Map || value instanceof Set) {
      /*
      This line has a fun story behind it. Maps don't like being proxyed is the short version.
      The long version is V8 strongly validates the type of the object before it lets
      Map.prototype.get be called (Firefox does the same thing).
      Looking at the standard this technically doesn't need to be the case but it is anyway.
      This is not the case for Array's and other types. All Array methods are pretty abstract
      and don't really care what object they work on so long as they look like Arrays.
      */
      return value;
    } else if (typeof value === 'object') {
      // log.trace('object', this.name, p);

      if (Reflect.get(value, VIRAL_PROXY_TAG) !== undefined) {
        return value;
      }

      return ViralProxy.create(
        value,
        this.root,
        `${this.name}.${p.toString()}`
      );
    } else if (typeof value === 'function') {
      // log.trace('function', this.name, p);

      if (Reflect.get(value, VIRAL_PROXY_TAG) !== undefined) {
        return value;
      }

      const self = this;

      return ViralProxy.create(
        function(this: unknown, ...args: unknown[]) {
          const newThis = self.proxyOf(`${p.toString()}$THIS`, this);

          if (newThis instanceof Map) {
            log.trace("This is a map. This won't work.");
          }

          const viralArguments = args.map((arg, index) => {
            return self.proxyOf(`${p.toString()}$ARG[${index}]`, arg);
          });

          const oldReturn = value.apply(newThis, viralArguments);

          return self.proxyOf(`${p.toString()}$RETURN`, oldReturn);
        },
        this.root || this,
        `${this.name}.${p.toString()}`
      );
    } else {
      return value;
    }
  }
}