Module Agnostic Schema Binding

packages/cli/src/__tests__/project/web3api.gen.ts

@@ -1,15 +1,16 @@
-import { OutputDirectory } from "@web3api/schema-bind";
-import { TypeInfo } from "@web3api/schema-parse";
+import { GenerateBindingFn, BindOptions, BindOutput } from "@web3api/schema-bind";
+import { OutputDirectory } from "@web3api/os-js";
 import Mustache from "mustache";
 import path from "path";
 import fs from "fs";
 
-export function generateBinding(
-  output: OutputDirectory,
-  typeInfo: TypeInfo,
-  schema: string,
-  config: Record<string, unknown>
-) {
+export const generateBinding: GenerateBindingFn = (
+  options: BindOptions
+): BindOutput => {
+  const schema = options.modules[0].schema;
+  const output: OutputDirectory = {
+    entries: []
+  };
   const schemaTemplate = fs.readFileSync(
     path.join(__dirname, "/templates/schema.mustache"),
     "utf-8"
@@ -38,4 +39,12 @@ export function generateBinding(
     name: "./schema3.ts",
     data: "./templates/schema.mustache",
   });
+
+  return {
+    modules: [{
+      name: "custom",
+      outputDirAbs: __dirname,
+      output,
+    }]
+  };
 };

packages/cli/src/lib/CodeGenerator.ts

@@ -20,21 +20,18 @@ import {
 
 import { TypeInfo } from "@web3api/schema-parse";
 import {
-  OutputDirectory,
-  writeDirectory,
   bindSchema,
   BindLanguage,
   GenerateBindingFn,
 } from "@web3api/schema-bind";
+import { writeDirectorySync } from "@web3api/os-js";
 import path from "path";
 import fs, { readFileSync } from "fs";
 import * as gluegun from "gluegun";
 import { Ora } from "ora";
 import Mustache from "mustache";
 import rimraf from "rimraf";
 
-export { OutputDirectory };
-
 export interface CodeGeneratorConfig {
   outputDir: string;
   project: Project<AnyManifest>;
@@ -106,9 +103,6 @@ export class CodeGenerator {
       }
 
       if (this._config.customScript) {
-        const output: OutputDirectory = {
-          entries: [],
-        };
         const customScript = this._config.customScript;
 
         // Check the generation file if it has the proper run() method
@@ -129,31 +123,44 @@ export class CodeGenerator {
           throw Error(intlMsg.lib_codeGenerator_nogenerateBindingMethod());
         }
 
-        await generateBinding(
-          output,
-          typeInfo,
-          this._schema || "",
-          config || {}
-        );
+        const output = await generateBinding({
+          modules: [
+            {
+              name: "custom",
+              typeInfo,
+              schema: this._schema || "",
+              config: config || {},
+              outputDirAbs: this._config.outputDir,
+            },
+          ],
+          bindLanguage,
+        });
 
-        writeDirectory(this._config.outputDir, output, (templatePath: string) =>
-          this._generateTemplate(templatePath, typeInfo, spinner)
-        );
+        for (const module of output.modules) {
+          writeDirectorySync(
+            this._config.outputDir,
+            module.output,
+            (templatePath: string) =>
+              this._generateTemplate(templatePath, typeInfo, spinner)
+          );
+        }
       } else {
-        const content = bindSchema({
-          combined: {
-            typeInfo: composed.combined?.typeInfo as TypeInfo,
-            schema: composed.combined?.schema as string,
-            config,
-            outputDirAbs: "",
-          },
+        const output = bindSchema({
+          modules: [
+            {
+              name: "combined",
+              typeInfo: composed.combined?.typeInfo as TypeInfo,
+              schema: composed.combined?.schema as string,
+              config,
+              outputDirAbs: this._config.outputDir,
+            },
+          ],
           bindLanguage,
         });
 
-        writeDirectory(
-          this._config.outputDir,
-          content.combined as OutputDirectory
-        );
+        for (const module of output.modules) {
+          writeDirectorySync(this._config.outputDir, module.output);
+        }
       }
     };
 

packages/cli/src/lib/Compiler.ts

@@ -24,10 +24,14 @@ import {
 import { WasmWeb3Api } from "@web3api/client-js";
 import { W3Imports } from "@web3api/client-js/build/wasm/types";
 import { AsyncWasmInstance } from "@web3api/asyncify-js";
-import { bindSchema, writeDirectory } from "@web3api/schema-bind";
+import { bindSchema, BindOptions } from "@web3api/schema-bind";
 import { TypeInfo } from "@web3api/schema-parse";
 import { ComposerOutput } from "@web3api/schema-compose";
-import { writeFileSync } from "@web3api/os-js";
+import {
+  getCommonPath,
+  writeFileSync,
+  writeDirectorySync,
+} from "@web3api/os-js";
 import * as gluegun from "gluegun";
 import fs from "fs";
 import path from "path";
@@ -227,34 +231,52 @@ export class Compiler {
       await project.getManifestLanguage()
     );
 
-    // Generate the bindings
-    const output = bindSchema({
+    const options: BindOptions = {
+      modules: [],
       bindLanguage,
-      query: modulesToBuild.query
-        ? {
-            typeInfo: composerOutput.query?.typeInfo as TypeInfo,
-            schema: composerOutput.combined?.schema as string,
-            outputDirAbs: queryDirectory as string,
-          }
-        : undefined,
-      mutation: modulesToBuild.mutation
-        ? {
-            typeInfo: composerOutput.mutation?.typeInfo as TypeInfo,
-            schema: composerOutput.combined?.schema as string,
-            outputDirAbs: mutationDirectory as string,
-          }
-        : undefined,
-    });
+    };
+
+    if (modulesToBuild.query) {
+      options.modules.push({
+        name: "query",
+        typeInfo: composerOutput.query?.typeInfo as TypeInfo,
+        schema: composerOutput.combined?.schema as string,
+        outputDirAbs: queryDirectory as string,
+      });
+    }
+
+    if (modulesToBuild.mutation) {
+      options.modules.push({
+        name: "mutation",
+        typeInfo: composerOutput.mutation?.typeInfo as TypeInfo,
+        schema: composerOutput.combined?.schema as string,
+        outputDirAbs: mutationDirectory as string,
+      });
+    }
+
+    if (mutationDirectory && queryDirectory) {
+      options.commonDirAbs = path.join(
+        getCommonPath(queryDirectory, mutationDirectory),
+        "w3"
+      );
+    }
+
+    // Generate the bindings
+    const output = bindSchema(options);
 
     // Output the bindings
     const filesWritten: string[] = [];
 
-    if (output.query && queryDirectory) {
-      filesWritten.push(...writeDirectory(queryDirectory, output.query));
+    for (const module of output.modules) {
+      filesWritten.push(
+        ...writeDirectorySync(module.outputDirAbs, module.output)
+      );
     }
 
-    if (output.mutation && mutationDirectory) {
-      filesWritten.push(...writeDirectory(mutationDirectory, output.mutation));
+    if (output.common) {
+      filesWritten.push(
+        ...writeDirectorySync(output.common.outputDirAbs, output.common.output)
+      );
     }
 
     return filesWritten;

packages/cli/src/lib/build-envs/wasm/assemblyscript/Dockerfile.mustache

@@ -31,17 +31,16 @@ COPY {{.}} .
 {{/web3api_manifests}}
 
 # Copy all source files
+{{#web3api_common_dir}}
+COPY {{.}} {{.}}
+{{/web3api_common_dir}}
 {{#include}}
 COPY {{.}} {{.}}
 {{/include}}
 {{#web3api_modules}}
 COPY {{dir}} {{dir}}
 {{/web3api_modules}}
 
-{{#web3api_modules}}
-COPY {{dir}} {{dir}}
-{{/web3api_modules}}
-
 {{#web3api_modules}}
 # Build the module at {{dir}}
 RUN ./node_modules/.bin/asc {{dir}}/w3/entry.ts \

packages/cli/src/lib/project/Web3ApiProject.ts

@@ -15,7 +15,7 @@ import {
 } from "..";
 
 import { Web3ApiManifest, BuildManifest, MetaManifest } from "@web3api/core-js";
-import { normalizePath } from "@web3api/os-js";
+import { getCommonPath, normalizePath } from "@web3api/os-js";
 import regexParser from "regex-parser";
 import path from "path";
 import fs from "fs";
@@ -167,15 +167,21 @@ export class Web3ApiProject extends Project<Web3ApiManifest> {
       const cacheDir = this.getCachePath(cacheLayout.buildLinkedPackagesDir);
 
       // Add default env variables
+      const modules = await this._getWeb3ApiModules();
       const defaultConfig = {
-        web3api_modules: (await this.getWeb3ApiModules()).map(
+        web3api_modules: modules.modules.map(
           (module: { dir: string; name: string }) => {
             return {
               name: module.name,
               dir: normalizePath(module.dir),
             };
           }
         ),
+        web3api_common_dir: () =>
+          modules.commonDir &&
+          fs.existsSync(path.join(this.getManifestDir(), modules.commonDir))
+            ? modules.commonDir
+            : undefined,
         web3api_manifests: (await this.getManifestPaths()).map(
           (path: string) => {
             return normalizePath(path);
@@ -202,38 +208,6 @@ export class Web3ApiProject extends Project<Web3ApiManifest> {
     return this._buildManifest;
   }
 
-  public async getWeb3ApiModules(): Promise<
-    {
-      dir: string;
-      name: string;
-    }[]
-  > {
-    const web3apiManifest = await this.getManifest();
-    const web3apiModules: {
-      dir: string;
-      name: string;
-    }[] = [];
-
-    if (web3apiManifest.modules.mutation?.module) {
-      web3apiModules.push({
-        dir: path
-          .dirname(web3apiManifest.modules.mutation.module)
-          .replace("./", ""),
-        name: "mutation",
-      });
-    }
-    if (web3apiManifest.modules.query?.module) {
-      web3apiModules.push({
-        dir: path
-          .dirname(web3apiManifest.modules.query.module)
-          .replace("./", ""),
-        name: "query",
-      });
-    }
-
-    return web3apiModules;
-  }
-
   public async getBuildUuid(): Promise<string> {
     // Load the cached build UUID
     let uuid = this.readCacheFile(cacheLayout.buildUuidFile);
@@ -402,4 +376,50 @@ export class Web3ApiProject extends Project<Web3ApiManifest> {
 
     return paths;
   }
+
+  /// Private Helpers
+
+  private async _getWeb3ApiModules(): Promise<{
+    modules: {
+      dir: string;
+      name: string;
+    }[];
+    commonDir?: string;
+  }> {
+    const web3apiManifest = await this.getManifest();
+    const web3apiModules: {
+      dir: string;
+      name: string;
+    }[] = [];
+
+    if (web3apiManifest.modules.mutation?.module) {
+      web3apiModules.push({
+        dir: path
+          .dirname(web3apiManifest.modules.mutation.module)
+          .replace("./", ""),
+        name: "mutation",
+      });
+    }
+    if (web3apiManifest.modules.query?.module) {
+      web3apiModules.push({
+        dir: path
+          .dirname(web3apiManifest.modules.query.module)
+          .replace("./", ""),
+        name: "query",
+      });
+    }
+
+    let commonDir: string | undefined;
+
+    if (web3apiModules.length > 1) {
+      const module1 = web3apiModules[0];
+      const module2 = web3apiModules[1];
+      commonDir = getCommonPath(module1.dir, module2.dir) + "w3";
+    }
+
+    return {
+      modules: web3apiModules,
+      commonDir,
+    };
+  }
 }