Update internal impl, use name Module

Author: liamgriffiths

examples/package.ts renamed to examples/module.ts

@@ -39,23 +39,20 @@ async function main() {
   // });
 
   // using the module from JSON
-  const mod = new Module(
-    {
-      json: substrate.module.serialize({
-        nodes: [a, b],
-        inputs: { x, y, z },
-      }),
-      inputs: {
-        // when commented will use "hello" because it is defined as the default above
-        // x: "xxx",
-        y: "yyy",
-        z: {
-          arr: ["123"],
-        },
+  const mod = new Module({
+    module_json: substrate.module.serialize({
+      nodes: [a, b],
+      inputs: { x, y, z },
+    }),
+    inputs: {
+      // when commented will use "hello" because it is defined as the default above
+      // x: 123,
+      y: "yyy",
+      z: {
+        arr: ["123"],
       },
     },
-    { id: "Module" },
-  );
+  });
 
   // using the module from publication/module id
   // const mod = new Module({

package-lock.json

@@ -43,6 +43,7 @@
     "vitest": "^1.0.4"
   },
   "dependencies": {
+    "@types/json-schema": "^7.0.15",
     "@types/node-fetch": "^2.6.11",
     "node-fetch": "2.7.0",
     "pako": "^2.1.0"

package.json

@@ -1,5 +1,6 @@
 import { idGenerator } from "substrate/idGenerator";
 import { Node } from "substrate/Node";
+import { type JSONSchema7 } from "json-schema";
 
 type Accessor = "item" | "attr";
 type TraceOperation = {
@@ -123,7 +124,7 @@ export class JQ extends Directive {
     rawValue: (val: JQCompatible) => ({ future_id: null, val }),
   };
 
-  override next(...items: TraceProp[]) {
+  override next(..._items: TraceProp[]) {
     return new JQ(this.query, this.target);
   }
 
@@ -318,7 +319,7 @@ export class FutureAnyObject extends Future<Object> {
 }
 
 export class Input extends Directive {
-  items: any[];
+  items: any[]; // NOTE: unused field (will remove this from direcitve in a later refactor)
   name: string | null;
 
   constructor(items: any[]) {
@@ -342,13 +343,11 @@ export class Input extends Directive {
   }
 }
 
-type JSONSchema = any;
-
 export class FutureInput extends Future<any> {
   declare _directive: Input;
-  schema: JSONSchema;
+  schema: JSONSchema7;
 
-  constructor(schema?: JSONSchema, id: string = newInputId()) {
+  constructor(schema?: JSONSchema7, id: string = newInputId()) {
     super(new Input([]), id);
     this.schema = schema ?? {};
   }

src/Future.ts

@@ -0,0 +1,25 @@
+import { Node, Options } from "substrate/Node";
+import { FutureInput } from "substrate/Future";
+
+export type ModuleInputs = Record<string, FutureInput>;
+
+type ModuleIn =
+  | {
+      module_json: any;
+      inputs: Record<string, any>;
+    }
+  | {
+      module_id: any;
+      inputs: Record<string, any>;
+    }
+  | {
+      module_uri: any;
+      inputs: Record<string, any>;
+    };
+
+export class Module extends Node {
+  constructor(args: ModuleIn, options?: Options) {
+    super(args, options);
+    this.node = "Module";
+  }
+}

src/Module.ts

@@ -8,7 +8,7 @@ import { Future } from "substrate/Future";
 import { getPlatformProperties } from "substrate/Platform";
 import { deflate } from "pako";
 import { randomString } from "substrate/idGenerator";
-import { packager } from "./Package";
+import { ModuleInputs } from "./Module";
 
 type Configuration = {
   /**
@@ -179,8 +179,6 @@ export class Substrate {
     }
   }
 
-  createPackageable = packager(this);
-
   /**
    *  Return a set of all nodes and their dependent nodes.
    */
@@ -296,14 +294,48 @@ export class Substrate {
   }
 
   module = {
-    serialize: ({ nodes, inputs }: { nodes: Node[], inputs: any }) => {
-      let p = packager(this);
-      return p(nodes, inputs).toJSON();
+    /**
+     * Returns an object that represents a publishable "module" or code that can be used to construct 
+     * a `Module` node.
+     */
+    serialize: ({ nodes, inputs }: { nodes: Node[]; inputs: ModuleInputs }) => {
+      const inputIdToName = {};
+      const inputNameToSchema = {};
+
+      for (let name in inputs) {
+        let input = inputs[name];
+        // @ts-ignore
+        inputIdToName[input._id] = name;
+        // @ts-ignore
+        inputNameToSchema[name] = input.schema;
+      }
+
+      const dag = Substrate.serialize(...nodes);
+
+      // update variable name bindings in dag using inputs
+      dag.futures = dag.futures.map((future: any) => {
+        if (future.directive.type === "input" && !future.directive.name) {
+          // @ts-ignore
+          future.directive.name = inputIdToName[future.id];
+        }
+        return future;
+      });
+
+      return {
+        dag,
+        inputs: inputNameToSchema,
+        api_version: this.apiVersion,
+      };
     },
 
-    publish: async (publishable: any) => {
+    /**
+     * Publishes a module on substrate.run
+     * A successful response will contain the module id and web uri
+     */
+    publish: async (_publishable: any) => {
       console.log("not implemented yet");
-      return publishable;
-    }
-  }
+      let publication;
+      return publication;
+    },
+  };
 }

src/Package.ts

@@ -51,7 +51,7 @@ export {
   DeleteVectors,
 } from "substrate/Nodes";
 
-export { Package, Package as Module } from "substrate/Package";
+export { Module } from "substrate/Module";
 
 export { sb } from "substrate/sb";
 export { Substrate };