Streaming Typings From CLI -> CLI-JS

packages/cli/src/commands/build.ts

@@ -1,4 +1,4 @@
-import { Command, Program } from "./types";
+import { Command, Program, BaseCommandOptions } from "./types";
 import { createLogger } from "./utils/createLogger";
 import {
   Compiler,
@@ -24,7 +24,7 @@ import {
 
 import path from "path";
 import readline from "readline";
-import { PolywrapClient, PolywrapClientConfig } from "@polywrap/client-js";
+import { PolywrapClient } from "@polywrap/client-js";
 import { PolywrapManifest } from "@polywrap/polywrap-manifest-types-js";
 
 const defaultOutputDir = "./build";
@@ -33,15 +33,13 @@ const strategyStr = intlMsg.commands_build_options_s_strategy();
 const defaultManifestStr = defaultPolywrapManifest.join(" | ");
 const pathStr = intlMsg.commands_build_options_o_path();
 
-export type BuildCommandOptions = {
+export interface BuildCommandOptions extends BaseCommandOptions {
   manifestFile: string;
   outputDir: string;
-  clientConfig: Partial<PolywrapClientConfig>;
+  clientConfig: string;
   skipCodegen?: boolean;
   watch?: boolean;
   strategy: SupportedStrategies;
-  verbose?: boolean;
-  quiet?: boolean;
 };
 
 export const build: Command = {
@@ -82,7 +80,6 @@ export const build: Command = {
             options.manifestFile,
             defaultPolywrapManifest
           ),
-          clientConfig: await parseClientConfigOption(options.clientConfig),
           outputDir: parseDirOption(options.outputDir, defaultOutputDir),
           strategy: options.strategy,
         });
@@ -139,7 +136,8 @@ async function run(options: BuildCommandOptions) {
   const logger = createLogger({ verbose, quiet });
 
   // Get Client
-  const client = new PolywrapClient(clientConfig);
+  const config = await parseClientConfigOption(clientConfig);
+  const client = new PolywrapClient(config);
 
   const project = new PolywrapProject({
     rootDir: path.dirname(manifestFile),

packages/cli/src/commands/codegen.ts

@@ -1,5 +1,5 @@
 /* eslint-disable  @typescript-eslint/no-unused-vars */
-import { Command, Program } from "./types";
+import { Command, Program, BaseCommandOptions } from "./types";
 import { createLogger } from "./utils/createLogger";
 import {
   CodeGenerator,
@@ -17,7 +17,7 @@ import {
 } from "../lib";
 import { ScriptCodegenerator } from "../lib/codegen/ScriptCodeGenerator";
 
-import { PolywrapClient, PolywrapClientConfig } from "@polywrap/client-js";
+import { PolywrapClient } from "@polywrap/client-js";
 import path from "path";
 import fs from "fs";
 
@@ -27,14 +27,12 @@ const defaultPublishDir = "./build";
 const pathStr = intlMsg.commands_codegen_options_o_path();
 const defaultManifestStr = defaultPolywrapManifest.join(" | ");
 
-export type CodegenCommandOptions = {
+export interface CodegenCommandOptions extends BaseCommandOptions {
   manifestFile: string;
   codegenDir: string;
   publishDir: string;
   script?: string;
-  clientConfig: Partial<PolywrapClientConfig>;
-  verbose?: boolean;
-  quiet?: boolean;
+  clientConfig: string;
 };
 
 export const codegen: Command = {
@@ -74,7 +72,6 @@ export const codegen: Command = {
       .action(async (options) => {
         await run({
           ...options,
-          clientConfig: await parseClientConfigOption(options.clientConfig),
           codegenDir: parseDirOption(options.codegenDir, defaultCodegenDir),
           script: parseCodegenScriptOption(options.script),
           manifestFile: parseManifestFileOption(
@@ -100,7 +97,8 @@ async function run(options: CodegenCommandOptions) {
   const logger = createLogger({ verbose, quiet });
 
   // Get Client
-  const client = new PolywrapClient(clientConfig);
+  const config = await parseClientConfigOption(clientConfig);
+  const client = new PolywrapClient(config);
 
   const project = await getProjectFromManifest(manifestFile, logger);
 

packages/cli/src/commands/create.ts

@@ -1,4 +1,4 @@
-import { Command, Program } from "./types";
+import { Command, Program, BaseCommandOptions } from "./types";
 import { createLogger } from "./utils/createLogger";
 import { generateProjectTemplate, intlMsg } from "../lib";
 
@@ -31,12 +31,21 @@ type SupportedLangs =
   | SupportedAppLangs
   | SupportedPluginLangs;
 
-export type CreateCommandOptions = {
+export interface CreateCommandOptions<
+  TLangs extends SupportedLangs
+> extends BaseCommandOptions {
+  language: TLangs;
+  name: string;
   outputDir?: string;
-  verbose?: boolean;
-  quiet?: boolean;
 };
 
+export interface CreateAppCommandOptions
+  extends CreateCommandOptions<SupportedAppLangs> { }
+export interface CreatePluginCommandOptions
+  extends CreateCommandOptions<SupportedPluginLangs> { }
+export interface CreateWasmCommandOptions
+  extends CreateCommandOptions<SupportedWasmLangs> { }
+
 export const create: Command = {
   setup: (program: Program) => {
     const createCommand = program
@@ -61,8 +70,12 @@ export const create: Command = {
       )
       .option("-v, --verbose", intlMsg.commands_common_options_verbose())
       .option("-q, --quiet", intlMsg.commands_common_options_quiet())
-      .action(async (langStr, nameStr, options) => {
-        await run("wasm", langStr, nameStr, options);
+      .action(async (language, name, options) => {
+        await run("wasm", {
+          ...options,
+          language,
+          name,
+        });
       });
 
     createCommand
@@ -82,8 +95,12 @@ export const create: Command = {
       )
       .option("-v, --verbose", intlMsg.commands_common_options_verbose())
       .option("-q, --quiet", intlMsg.commands_common_options_quiet())
-      .action(async (langStr, nameStr, options) => {
-        await run("app", langStr, nameStr, options);
+      .action(async (language, name, options) => {
+        await run("app", {
+          ...options,
+          language,
+          name
+        });
       });
 
     createCommand
@@ -103,19 +120,21 @@ export const create: Command = {
       )
       .option("-v, --verbose", intlMsg.commands_common_options_verbose())
       .option("-q, --quiet", intlMsg.commands_common_options_quiet())
-      .action(async (langStr, nameStr, options) => {
-        await run("plugin", langStr, nameStr, options);
+      .action(async (language, name, options) => {
+        await run("plugin", {
+          ...options,
+          language,
+          name
+        });
       });
   },
 };
 
 async function run(
   command: ProjectType,
-  lang: SupportedLangs,
-  name: string,
-  options: CreateCommandOptions
+  options: CreateCommandOptions<SupportedLangs>
 ) {
-  const { outputDir, verbose, quiet } = options;
+  const { language, name, outputDir, verbose, quiet } = options;
   const logger = createLogger({ verbose, quiet });
 
   const projectDir = path.resolve(outputDir ? `${outputDir}/${name}` : name);
@@ -143,7 +162,7 @@ async function run(
     }
   }
 
-  await generateProjectTemplate(command, lang, projectDir)
+  await generateProjectTemplate(command, language, projectDir)
     .then(() => {
       let readyMessage;
       if (command === "wasm") {

packages/cli/src/commands/deploy.ts

@@ -1,5 +1,5 @@
 /* eslint-disable prefer-const */
-import { Command, Program } from "./types";
+import { Command, Program, BaseCommandOptions } from "./types";
 import { createLogger } from "./utils/createLogger";
 import {
   defaultPolywrapManifest,
@@ -20,11 +20,9 @@ import { validate } from "jsonschema";
 const defaultManifestStr = defaultPolywrapManifest.join(" | ");
 const pathStr = intlMsg.commands_deploy_options_o_path();
 
-export type DeployCommandOptions = {
+export interface DeployCommandOptions extends BaseCommandOptions {
   manifestFile: string;
   outputFile?: string;
-  verbose?: boolean;
-  quiet?: boolean;
 };
 
 type ManifestJob = DeployManifest["jobs"][number];

packages/cli/src/commands/docgen.ts

@@ -9,14 +9,14 @@ import {
   defaultProjectManifestFiles,
   getProjectFromManifest,
 } from "../lib";
-import { Command, Program } from "./types";
+import { Command, Program, BaseCommandOptions } from "./types";
 import { createLogger } from "./utils/createLogger";
 import { scriptPath as docusaurusScriptPath } from "../lib/docgen/docusaurus";
 import { scriptPath as jsdocScriptPath } from "../lib/docgen/jsdoc";
 import { scriptPath as schemaScriptPath } from "../lib/docgen/schema";
 import { ScriptCodegenerator } from "../lib/codegen/ScriptCodeGenerator";
 
-import { PolywrapClient, PolywrapClientConfig } from "@polywrap/client-js";
+import { PolywrapClient } from "@polywrap/client-js";
 import chalk from "chalk";
 import { Argument } from "commander";
 
@@ -29,21 +29,20 @@ const commandToPathMap: Record<string, string> = {
 const defaultDocgenDir = "./docs";
 const pathStr = intlMsg.commands_codegen_options_o_path();
 
-export type DocgenCommandOptions = {
-  manifestFile: string;
-  docgenDir: string;
-  clientConfig: Partial<PolywrapClientConfig>;
-  imports: boolean;
-  verbose?: boolean;
-  quiet?: boolean;
-};
-
 export enum DocgenActions {
   SCHEMA = "schema",
   DOCUSAURUS = "docusaurus",
   JSDOC = "jsdoc",
 }
 
+export interface DocgenCommandOptions extends BaseCommandOptions {
+  action: DocgenActions;
+  manifestFile: string;
+  docgenDir: string;
+  clientConfig: string;
+  imports: boolean;
+};
+
 const argumentsDescription = `
   ${chalk.bold(
     DocgenActions.SCHEMA
@@ -94,21 +93,22 @@ export const docgen: Command = {
       .option("-v, --verbose", intlMsg.commands_common_options_verbose())
       .option("-q, --quiet", intlMsg.commands_common_options_quiet())
       .action(async (action, options) => {
-        await run(action, {
+        await run({
           ...options,
+          action,
           manifestFile: parseManifestFileOption(
             options.manifestFile,
             defaultProjectManifestFiles
           ),
           docgenDir: parseDirOption(options.docgenDir, defaultDocgenDir),
-          clientConfig: await parseClientConfigOption(options.clientConfig),
         });
       });
   },
 };
 
-async function run(command: DocgenActions, options: DocgenCommandOptions) {
+async function run(options: DocgenCommandOptions) {
   const {
+    action,
     manifestFile,
     docgenDir,
     clientConfig,
@@ -133,9 +133,10 @@ async function run(command: DocgenActions, options: DocgenCommandOptions) {
   await project.validate();
 
   // Resolve custom script
-  const customScript = require.resolve(commandToPathMap[command]);
+  const customScript = require.resolve(commandToPathMap[action]);
 
-  const client = new PolywrapClient(clientConfig);
+  const config = await parseClientConfigOption(clientConfig);
+  const client = new PolywrapClient(config);
 
   const schemaComposer = new SchemaComposer({
     project,

packages/cli/src/commands/index.ts

@@ -2,7 +2,42 @@ export * from "./build";
 export * from "./codegen";
 export * from "./create";
 export * from "./deploy";
-export * from "./infra";
-export * from "./run";
 export * from "./docgen";
+export * from "./infra";
 export * from "./manifest";
+export * from "./run";
+export * from "./types";
+
+import { BuildCommandOptions } from "./build";
+import { CodegenCommandOptions } from "./codegen";
+import {
+  CreateAppCommandOptions,
+  CreatePluginCommandOptions,
+  CreateWasmCommandOptions
+} from "./create";
+import { DeployCommandOptions } from "./deploy";
+import { DocgenCommandOptions } from "./docgen";
+import { InfraCommandOptions } from "./infra";
+import {
+  ManifestSchemaCommandOptions,
+  ManifestMigrateCommandOptions
+} from "./manifest";
+import { RunCommandOptions } from "./run";
+
+export interface CommandOptions {
+  "build": BuildCommandOptions;
+  "codegen": CodegenCommandOptions;
+  "create": {
+    "app": CreateAppCommandOptions;
+    "plugin": CreatePluginCommandOptions;
+    "wasm": CreateWasmCommandOptions;
+  };
+  "deploy": DeployCommandOptions;
+  "docgen": DocgenCommandOptions;
+  "infra": InfraCommandOptions;
+  "manifest": {
+    "migrate": ManifestMigrateCommandOptions;
+    "schema": ManifestSchemaCommandOptions;
+  };
+  "run": RunCommandOptions;
+}