Got Proxy.js injection working

package.json

@@ -13,6 +13,7 @@
 	"devDependencies": {
 		"@babel/cli": "^7.4.4",
 		"@babel/core": "^7.4.5",
+		"@babel/parser": "^7.9.6",
 		"@babel/traverse": "^7.9.6"
 	},
 	"dependencies": {

plugin/__test__/proxy_demo.js

@@ -0,0 +1,24 @@
+(() => {
+	const poop = proxify(
+		Object.assign(
+			Object.create({
+				protoTest: 'old',
+			}),
+			{
+				test: 'old',
+				poop: {
+					test: 'old',
+				},
+			}
+		),
+		{
+			deep: true,
+			prototype: true,
+		}
+	);
+
+	// poop.test = "new"; // Errors
+	// poop.poop.test = "new"; // Errors when `deep`
+	// Object.getPrototypeOf(poop).test = "poop"; // Errors when `prototype`
+	// Object.setPrototypeOf(poop, {}); // Errors
+})();

plugin/index.js

@@ -1,6 +1,12 @@
 const looksLike = require('./looks-like');
 const t = require('@babel/types');
 const { default: traverse } = require('@babel/traverse');
+const parser = require('@babel/parser');
+const fs = require('fs');
+const proxyCode = fs.readFileSync(`${__dirname}/proxy.js`, 'utf8');
+
+const proxyAST = parser.parse(proxyCode);
+console.log(proxyAST.program.body);
 
 /**
  * The "Map" of if the "./proxy.js" code should be injected to the top of the Program
@@ -48,7 +54,7 @@ module.exports = () => {
 									noScope: true,
 									enter(path) {
 										if (path.node.type === 'BlockStatement') {
-											console.log('HELLO 2');
+											console.log('WELCOME TO THE FUNCTION BODY OF THE $shouldNotMutate "Decorator');
 											// debugger;
 										}
 									},
@@ -58,8 +64,14 @@ module.exports = () => {
 					});
 				},
 				exit(programPath) {
-					const val = Programs.get(programPath.node);
-					console.log('PLEASE ONLY RUN ONCE', val);
+          const val = Programs.get(programPath.node);
+          /**
+           * If the Program has any utilization of the $shouldNotMutate, then we'll inject the code from the
+           * proxy.js file to then be able to use that function in the AST
+           */
+          if (val) {
+            programPath.node.body = [...proxyAST.program.body, ...programPath.node.body];
+          }
 				},
 			},
 		},

plugin/proxy.js

@@ -1,19 +1,30 @@
-export const proxify = (object, {deep = false} = {}) => {
+const proxify = (object, options = {}) => {
+	const {
+		deep = false, prototype = false
+	} = options;
 	if (!(object instanceof Object)) return object;
-	
+
 	const triggeredByFunction = true; // TODO: this is for stack trace shit
 
 	return new Proxy(object, {
+		// Other proxy traps have other edgecases
+
 		/*
 			Get - Deep *lennyface*
 		*/
+		// TODO: This has a BUNCH of edgecases involving getting/setting from the result of the desc.
+		// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor
 		getOwnPropertyDescriptor() {
 			const realDescriptor = Reflect.getOwnPropertyDescriptor(...arguments);
-			return deep ? proxify(realDescriptor) : realDescriptor;
+			return deep ? proxify(realDescriptor, options) : realDescriptor;
+		},
+		getPrototypeOf() {
+			const realPrototypeOf = Reflect.getPrototypeOf(...arguments);
+			return prototype ? proxify(realPrototypeOf, options) : realPrototypeOf;
 		},
 		get() {
 			const realGet = Reflect.get(...arguments);
-			return deep ? proxify(realGet) : realGet;
+			return deep ? proxify(realGet, options) : realGet;
 		},
 
 
@@ -27,20 +38,10 @@ export const proxify = (object, {deep = false} = {}) => {
 		setPrototypeOf() {
 			if (triggeredByFunction) throw new Error('Poop!');
 			return Reflect.setPrototypeOf(...arguments);
+		},
+		deleteProperty() {
+			if (triggeredByFunction) throw new Error('Poop!');
+			return Reflect.deleteProperty(...arguments);
 		}
 	});
 };
-
-/*
-Needs to be be able to detect:
-
-defineProperty()
-getOwnPropertyDescriptor()
-construct (new Class)
-deletion
-symbol mutation
-Prototype changes
-Mutations to it (with an option likely)
-setPrototypeOf()
-
-*/