Closes https://github.com/functionless/nodejs-closure-serializer/issues/13 Closes https://github.com/functionless/nodejs-closure-serializer/issues/15

• [x] Allows a list of TS AST transformers to be passed in to serializeFunction that will be applied to a closure before serialization.
• [x] Updates all tests cases to actually run the closures and ensure the returned value is correct.
• [x] Replace use of with with closured constants for enhanced performance

BREAKING CHANGE: with statement replaced with const statements in the closure. Potentially unintended breaking behavior not covered by the unit tests. Should be adopted purposefully.

Strange bug where vs code (and other test tools) set a global["$jsDebugIsRegistered"] with a getter that, when called, throws an exception. This change is a quick hack to ignore serializing that property - it should never impact prod.

• [x] adds a shouldCaptureProp hook for excluding properties from serialization.

serializeFunction({
  shouldCaptureProp: (obj, prop) => typeof obh === "function" && prop === "bad name"
});

• [x] when transforming closures, unwrap a ExpressionStatement(ParenthesizedExpression(FunctionExpression)) to a single FunctionExpression

It should be possible to transform the AST syntax prior to serialization rather than relying purely on value-level serialization customization.

This would be useful for removing syntax added by Functionless's TS transformers.

The way the closure serializer wraps closures in a with degrades performance by approximately 4-5x. See below for an example.

function foo() {
  with({
    a: "hello"
  }) {
    return (function() {
      return function() {
        return arguments * 10 ;
      }
    }).apply(undefined, undefined).apply(this, arguments);
  }
}


function foo2() {
  return (function() {
    return function() {
      return arguments * 10;
    }
  }).apply(undefined, undefined).apply(this, arguments)
}

for (let j = 0; j < 10; j++) {
  const start = new Date();
  for (let i = 0; i < 10*1000*1000; i++) {
    foo2(i);
  }
  
  console.log(new Date().getTime() - start.getTime());
}

Allows for the serialize function to accept Function expr or Arrow Expr and return values.

previously serialize would throw an error when a function was returned.

class C {
   static S = "x"
   constructor() {}
}

() => {
   // does not need the whole class
   C.S
}

() => {
   // needs the whole class
   new C()
}

() => {
   // needs the whole class
   C.S
   new C();
}

() => {
   // needs the whole class
   const doSomething = (d: any) => {}
   doSomething(C);
}

Total re-write of the closure serializer as a single recursive pass.

For visual context, refer to this diagram of Prototypical Inheritance:

Outstanding tasks:

• [ ] support recursive references in properties
• [ ] serialize classes as Functions (not classes)
• [ ] detect augmented globals
• [ ] detect references to modules or a module's exports and emit as an import/require
• [ ] run esbuild on the serialized closure + imports to create a tree-shaken bundle with minimal usage of the closure serializer and maximal usage of esbuild

Closure serialization should maintain references to closured let and var and all modifications of that value should reflect everywhere it is referenced.

Below is a test case that should pass, with expectResult: 2, but the result is 0 - because the closured let is re-declared in each closure and copied by-value, not by-ref. This is true even when using the previous with technique.

let i = 0;
function a() {
  i += 1;
}
function b() {
  i += 1;
}

cases.push({
  title: "two functions modifying a single let have changes reflected",
  func: () => {
    a();
    b();
    return i;
  },
  snapshot: true,
  expectResult: 2,
});

From https://github.com/functionless/functionless/pull/273

It would be nice to remove the deploymentOnlyModule from the bottom of all of the files. By passing in a pattern to the serialize function, we could avoiding missing files and polluting the modules.

For https://github.com/functionless/functionless/issues/274

• [ ] Output import and export instead of require and exports.
• [ ] support top level async
• [ ] Generated imports should support tree shaking

The repo is a fork of @pulumi/pulumi's closure serializer.

One of the changes to the original repo was to support replacement of objects to be serialized using the serialize callback.

The current implementation supports the contract (o: any) => boolean | any where:

• true - serialize o as is - original contract
• false - do not serialize o (replace with undefined) - original contract
• anything else - replace o with the value

This contract isn't great, but it was a quick update from the original contract.

We should update this to support the edge case where a boolean value should replace the original value.

Proposal:

/**
 * return the value to serialize, return `undefined` to skip serialization. `undefined` may also be used to avoid circular references.
 **/
serialize: (o: any) => any | undefined

In the updated contract, the user just returns the new value or current value.