@botpress/cli 0.0.8 → 0.0.10

package/dist/api-client.js

@@ -0,0 +1,107 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var api_client_exports = {};
+__export(api_client_exports, {
+  ApiClient: () => ApiClient
+});
+module.exports = __toCommonJS(api_client_exports);
+var import_client = require("@botpress/client");
+var import_lodash = __toESM(require("lodash"));
+var import_integration_ref = require("./integration-ref");
+class ApiClient {
+  constructor(props, _logger) {
+    this._logger = _logger;
+    const { host, token, workspaceId } = props;
+    this.client = new import_client.Client({ host, token, workspaceId });
+    this.host = host;
+    this.token = token;
+    this.workspaceId = workspaceId;
+  }
+  client;
+  host;
+  token;
+  workspaceId;
+  static newClient = (props, logger) => new ApiClient(props, logger);
+  async findIntegration(ref) {
+    const formatted = (0, import_integration_ref.formatIntegrationRef)(ref);
+    const privateIntegration = await this.findPrivateIntegration(ref);
+    if (privateIntegration) {
+      this._logger.debug(`Found integration "${formatted}" in workspace`);
+      return privateIntegration;
+    }
+    const publicIntegration = await this.findPublicIntegration(ref);
+    if (publicIntegration) {
+      this._logger.debug(`Found integration "${formatted}" in hub`);
+      return publicIntegration;
+    }
+    return;
+  }
+  async findPrivateIntegration(ref) {
+    if (ref.type === "id") {
+      return this.validateStatus(() => this.client.getIntegration(ref).then((r) => r.integration), [404, 500]);
+    }
+    return this.validateStatus(() => this.client.getIntegrationByName(ref).then((r) => r.integration), [404, 500]);
+  }
+  async findPublicIntegration(ref) {
+    if (ref.type === "id") {
+      return this.validateStatus(() => this.client.getPublicIntegrationById(ref).then((r) => r.integration), [404, 500]);
+    }
+    return this.validateStatus(() => this.client.getPublicIntegration(ref).then((r) => r.integration), [404, 500]);
+  }
+  async testLogin() {
+    await this.client.listBots({});
+  }
+  async listAllPages(lister, mapper) {
+    let nextToken;
+    const all = [];
+    do {
+      const { meta, ...r } = await lister({ nextToken });
+      all.push(r);
+      nextToken = meta.nextToken;
+    } while (nextToken);
+    if (!mapper) {
+      return all;
+    }
+    const mapped = all.flatMap((r) => mapper(r));
+    return mapped;
+  }
+  async validateStatus(fn, allowedStatuses) {
+    try {
+      const v = await fn();
+      return v;
+    } catch (err) {
+      const allowedStatusesArray = import_lodash.default.isArray(allowedStatuses) ? allowedStatuses : [allowedStatuses];
+      const isAllowed = (0, import_client.isApiError)(err) && err.code && allowedStatusesArray.includes(err.code);
+      if (isAllowed) {
+        return;
+      }
+      throw err;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiClient
+});

package/dist/app/api-utils.js

@@ -27,17 +27,23 @@ __export(api_utils_exports, {
   ApiUtils: () => ApiUtils
 });
 module.exports = __toCommonJS(api_utils_exports);
+var import_client = require("@botpress/client");
 var import_lodash = __toESM(require("lodash"));
 var errors = __toESM(require("./errors"));
 var import_integration_ref = require("./integration-ref");
 class ApiUtils {
-  constructor(client, host, token, workspaceId, _logger) {
-    this.client = client;
+  constructor(props, _logger) {
+    this._logger = _logger;
+    const { host, token, workspaceId } = props;
+    this.client = new import_client.Client({ host, token, workspaceId });
     this.host = host;
     this.token = token;
     this.workspaceId = workspaceId;
-    this._logger = _logger;
   }
+  client;
+  host;
+  token;
+  workspaceId;
   async findIntegration(ref) {
     const formatted = (0, import_integration_ref.formatIntegrationRef)(ref);
     const privateIntegration = await this.findPrivateIntegration(ref);

package/dist/app/base.js

@@ -27,7 +27,6 @@ __export(base_exports, {
   BaseCommands: () => BaseCommands
 });
 module.exports = __toCommonJS(base_exports);
-var bpclient = __toESM(require("@botpress/client"));
 var import_prompts = __toESM(require("prompts"));
 var import_api_utils = require("./api-utils");
 var errors = __toESM(require("./errors"));
@@ -47,8 +46,7 @@ class BaseCommands {
     if (!(token && workspaceId && host)) {
       throw new errors.NotLoggedInError();
     }
-    const client = new bpclient.Client({ host, token, workspaceId });
-    return new import_api_utils.ApiUtils(client, host, token, workspaceId, this._logger);
+    return new import_api_utils.ApiUtils({ host, token, workspaceId }, this._logger);
   }
   async _confirm(message) {
     if (this._props.confirm) {

package/dist/app/errors.js

@@ -31,6 +31,7 @@ __export(errors_exports, {
   InvalidIntegrationReferenceError: () => InvalidIntegrationReferenceError,
   NoBotsFoundError: () => NoBotsFoundError,
   NoBundleFoundError: () => NoBundleFoundError,
+  NoWorkspacesFoundError: () => NoWorkspacesFoundError,
   NotLoggedInError: () => NotLoggedInError,
   ParamRequiredError: () => ParamRequiredError
 });
@@ -116,6 +117,12 @@ class NoBotsFoundError extends BotpressCLIError {
     super(message);
   }
 }
+class NoWorkspacesFoundError extends BotpressCLIError {
+  constructor() {
+    const message = "No Workspace found. Please create one first.";
+    super(message);
+  }
+}
 class NotLoggedInError extends BotpressCLIError {
   constructor() {
     const message = "Not logged in. Please run `bp login` first.";
@@ -143,6 +150,7 @@ class InvalidIntegrationReferenceError extends BotpressCLIError {
   InvalidIntegrationReferenceError,
   NoBotsFoundError,
   NoBundleFoundError,
+  NoWorkspacesFoundError,
   NotLoggedInError,
   ParamRequiredError
 });

package/dist/app/file-paths.js

@@ -33,47 +33,44 @@ var consts = __toESM(require("../consts"));
 var pathutils = __toESM(require("../path-utils"));
 class ProjectPaths {
   abs;
-  rel;
-  constructor({ workDir, definition, entryPoint: entrypoint, outDir }) {
-    const absWorkdir = pathutils.absoluteFrom(pathutils.cwd(), workDir);
-    const absDefinition = pathutils.absoluteFrom(absWorkdir, definition);
-    const absEntrypoint = pathutils.absoluteFrom(absWorkdir, entrypoint);
-    const absOutdir = pathutils.absoluteFrom(absWorkdir, outDir);
+  constructor({ workDir, entryPoint, outDir }) {
+    const absWorkDir = pathutils.absoluteFrom(pathutils.cwd(), workDir);
+    const absEntrypoint = pathutils.absoluteFrom(absWorkDir, entryPoint);
+    const absOutDir = pathutils.absoluteFrom(absWorkDir, outDir);
     this.abs = {
-      workDir: absWorkdir,
-      definition: absDefinition,
+      workDir: absWorkDir,
       entryPoint: absEntrypoint,
-      outDir: absOutdir,
-      ...import_lodash.default.mapValues(consts.relativeToOutFolder, (p) => pathutils.absoluteFrom(absOutdir, p))
-    };
-    const relDefinition = pathutils.relativeFrom(this.abs.workDir, this.abs.definition);
-    const relEntrypoint = pathutils.relativeFrom(this.abs.workDir, this.abs.entryPoint);
-    const relOutdir = pathutils.relativeFrom(this.abs.workDir, this.abs.outDir);
-    const relWorkdir = ".";
-    this.rel = {
-      workDir: relWorkdir,
-      definition: relDefinition,
-      entryPoint: relEntrypoint,
-      outDir: relOutdir,
-      ...import_lodash.default.mapValues(consts.relativeToOutFolder, (p) => pathutils.relativeFrom(this.abs.outDir, p))
+      outDir: absOutDir,
+      ...import_lodash.default.mapValues(consts.fromOutDir, (p) => pathutils.absoluteFrom(absOutDir, p)),
+      ...import_lodash.default.mapValues(consts.fromWorkDir, (p) => pathutils.absoluteFrom(absWorkDir, p))
     };
   }
+  get rel() {
+    return this.relFrom("workDir");
+  }
+  relFrom(dir) {
+    const from = this.abs[dir];
+    return import_lodash.default.mapValues(this.abs, (to) => pathutils.relativeFrom(from, to));
+  }
 }
 class UserPaths {
   abs;
-  rel;
-  constructor({ botpressHome }) {
-    const absBotpressHome = pathutils.absoluteFrom(pathutils.cwd(), botpressHome);
+  constructor({ botpressHomeDir, cliRootDir: absCliRootDir }) {
+    const absBotpressHome = pathutils.absoluteFrom(pathutils.cwd(), botpressHomeDir);
     this.abs = {
-      botpressHome: absBotpressHome,
-      ...import_lodash.default.mapValues(consts.relativeToHomeFolder, (p) => pathutils.absoluteFrom(absBotpressHome, p))
-    };
-    const relBotpressHome = ".";
-    this.rel = {
-      botpressHome: relBotpressHome,
-      ...import_lodash.default.mapValues(consts.relativeToHomeFolder, (p) => pathutils.relativeFrom(this.abs.botpressHome, p))
+      cliRootDir: absCliRootDir,
+      botpressHomeDir: absBotpressHome,
+      ...import_lodash.default.mapValues(consts.fromHomeDir, (p) => pathutils.absoluteFrom(absBotpressHome, p)),
+      ...import_lodash.default.mapValues(consts.fromCliRootDir, (p) => pathutils.absoluteFrom(absCliRootDir, p))
     };
   }
+  get rel() {
+    return this.relFrom("botpressHomeDir");
+  }
+  relFrom(dir) {
+    const from = this.abs[dir];
+    return import_lodash.default.mapValues(this.abs, (to) => pathutils.relativeFrom(from, to));
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/app/index.js

@@ -39,33 +39,40 @@ var import_file_paths = require("./file-paths");
 var import_project = require("./project");
 var import_user = require("./user");
 var errors = __toESM(require("./errors"));
-const logBootInfo = async (logger, props) => {
-  const versionText = import_chalk.default.bold(`v${props.version}`);
+const readPackageJson = async (paths) => {
+  const pkgJson = await import_fs.default.promises.readFile(paths.abs.packageJson, "utf-8");
+  return JSON.parse(pkgJson);
+};
+const logBootInfo = async (logger, paths) => {
+  const packageJson = await readPackageJson(paths);
+  const versionText = import_chalk.default.bold(`v${packageJson.version}`);
   logger.log(`Botpress CLI ${versionText}`, { prefix: "\u{1F916}" });
-  await (0, import_update_notif.notifyUpdate)(props, logger);
-  if (props.botpressHome !== consts.defaultBotpressHome) {
-    logger.log(`Using custom botpress home: ${props.botpressHome}`, { prefix: "\u{1F3E0}" });
+  await (0, import_update_notif.notifyUpdate)(packageJson, logger);
+  if (paths.abs.botpressHomeDir !== consts.defaultBotpressHome) {
+    logger.log(`Using custom botpress home: ${paths.abs.botpressHomeDir}`, { prefix: "\u{1F3E0}" });
   }
 };
 const forProject = async (props) => {
   const logger = new import_logger.Logger(props);
-  await logBootInfo(logger, props);
-  const projectPaths = new import_file_paths.ProjectPaths(props);
+  const { workDir, entryPoint, outDir, botpressHome, cliRootPath } = props;
+  const projectPaths = new import_file_paths.ProjectPaths({ workDir, entryPoint, outDir });
   const projectCachePath = projectPaths.abs.projectCacheFile;
   const projectCache = await import_cache.FSConfigCache.loadFrom(projectCachePath);
-  const userPaths = new import_file_paths.UserPaths(props);
+  const userPaths = new import_file_paths.UserPaths({ botpressHomeDir: botpressHome, cliRootDir: cliRootPath });
   const userCacheFile = userPaths.abs.userCacheFile;
   const userCache = await import_cache.FSConfigCache.loadFrom(userCacheFile);
   await import_fs.default.promises.mkdir(projectPaths.abs.distDir, { recursive: true });
+  await logBootInfo(logger, userPaths);
   return new import_project.ProjectCommands(props, projectPaths, projectCache, userCache, logger);
 };
 const forUser = async (props) => {
   const logger = new import_logger.Logger(props);
-  await logBootInfo(logger, props);
-  const userPaths = new import_file_paths.UserPaths(props);
+  const { botpressHome, cliRootPath } = props;
+  const userPaths = new import_file_paths.UserPaths({ botpressHomeDir: botpressHome, cliRootDir: cliRootPath });
   const userCacheFile = userPaths.abs.userCacheFile;
   const userCache = await import_cache.FSConfigCache.loadFrom(userCacheFile);
-  return new import_user.UserCommands(props, userCache, logger);
+  await logBootInfo(logger, userPaths);
+  return new import_user.UserCommands(props, userPaths, userCache, logger);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/app/project.js

@@ -126,9 +126,9 @@ class ProjectCommands extends import_base.BaseCommands {
     line.started(`Generating typings for integration ${import_chalk.default.bold(name)}...`);
     const typingFiles = await generator.generateIntegrationImplementationTypings(
       integrationDef,
-      consts.relativeToOutFolder.implementationDir
+      this._paths.relFrom("outDir").implementationDir
     );
-    const indexFile = await generator.generateIntegrationIndex(consts.relativeToOutFolder.implementationDir);
+    const indexFile = await generator.generateIntegrationIndex(this._paths.relFrom("outDir").implementationDir);
     const generatedFiles = [...typingFiles, indexFile];
     await this._writeFilesToOutFolder(generatedFiles);
     line.success(`Typings available at ${import_chalk.default.grey(this._paths.rel.outDir)}`);
@@ -438,7 +438,7 @@ class ProjectCommands extends import_base.BaseCommands {
     line.started(`Installing ${import_chalk.default.bold(name)} v${version}...`);
     const instanceFiles = await generator.generateIntegrationInstance(
       integration,
-      consts.relativeToOutFolder.installDir
+      this._paths.relFrom("outDir").installDir
     );
     await this._writeFilesToOutFolder(instanceFiles);
     await this._generateBotIndex();
@@ -447,7 +447,7 @@ class ProjectCommands extends import_base.BaseCommands {
   async _generateBotIndex() {
     const allInstances = await this._listIntegrationInstances();
     const indexFile = await generator.generateBotIndex(
-      consts.relativeToOutFolder.installDir,
+      this._paths.relFrom("outDir").installDir,
       allInstances.map((i) => i.dirname)
     );
     await this._writeFilesToOutFolder([indexFile]);

package/dist/app/user.js

@@ -27,17 +27,21 @@ __export(user_exports, {
   UserCommands: () => UserCommands
 });
 module.exports = __toCommonJS(user_exports);
-var bpclient = __toESM(require("@botpress/client"));
 var import_chalk = __toESM(require("chalk"));
+var import_fs = __toESM(require("fs"));
 var import_lodash = __toESM(require("lodash"));
+var import_path = __toESM(require("path"));
 var import_prompts = __toESM(require("prompts"));
+var consts = __toESM(require("../consts"));
+var pathutils = __toESM(require("../path-utils"));
 var import_api_utils = require("./api-utils");
 var import_base = require("./base");
 var errors = __toESM(require("./errors"));
 var import_integration_ref = require("./integration-ref");
 class UserCommands extends import_base.BaseCommands {
-  constructor(props, userCache, logger) {
+  constructor(props, _paths, userCache, logger) {
     super(props, userCache, logger);
+    this._paths = _paths;
   }
   async login(argv) {
     const promptedToken = await this._userCache.sync("token", argv.token, async (previousToken) => {
@@ -52,29 +56,29 @@ class UserCommands extends import_base.BaseCommands {
       }
       return prompted;
     });
-    const promptedWorkspaceId = await this._userCache.sync(
-      "workspaceId",
-      argv.workspaceId,
-      async (previousWorkspace) => {
-        const { prompted } = await (0, import_prompts.default)({
-          type: "text",
-          name: "prompted",
-          message: "Enter your default Workspace Id",
-          initial: previousWorkspace
-        });
-        if (!prompted) {
-          throw new errors.ParamRequiredError("Workspace Id");
-        }
-        return prompted;
+    const promptedWorkspaceId = await this._userCache.sync("workspaceId", argv.workspaceId, async (defaultId) => {
+      const tmpApi = new import_api_utils.ApiUtils({ host: argv.host, token: promptedToken }, this._logger);
+      const userWorkspaces = await tmpApi.listAllPages(tmpApi.client.listWorkspaces, (r) => r.workspaces).catch((thrown) => {
+        throw errors.BotpressCLIError.wrap(thrown, "Could not list workspaces");
+      });
+      if (userWorkspaces.length === 0) {
+        throw new errors.NoWorkspacesFoundError();
       }
-    );
-    await this._userCache.set("host", argv.host);
-    const client = new bpclient.Client({
-      host: argv.host,
-      token: promptedToken,
-      workspaceId: promptedWorkspaceId
+      const initial = userWorkspaces.find((ws) => ws.id === defaultId);
+      const { prompted } = await (0, import_prompts.default)({
+        type: "autocomplete",
+        name: "prompted",
+        message: "Which workspace do you want to login to?",
+        initial: initial?.name,
+        choices: userWorkspaces.map((ws) => ({ title: ws.name, value: ws.id }))
+      });
+      if (!prompted) {
+        throw new errors.ParamRequiredError("Workspace Id");
+      }
+      return prompted;
     });
-    const api = new import_api_utils.ApiUtils(client, argv.host, promptedToken, promptedWorkspaceId, this._logger);
+    await this._userCache.set("host", argv.host);
+    const api = new import_api_utils.ApiUtils({ host: argv.host, token: promptedToken, workspaceId: promptedWorkspaceId }, this._logger);
     await api.testLogin();
     this._logger.success("Logged In");
   }
@@ -180,6 +184,52 @@ class UserCommands extends import_base.BaseCommands {
     this._logger.success(`Integration ${import_chalk.default.bold(integrationRef)} deleted`);
     return;
   }
+  async initProject(argv) {
+    let { type: projectType } = argv;
+    if (!projectType) {
+      const { promptedType } = await (0, import_prompts.default)({
+        type: "autocomplete",
+        name: "promptedType",
+        message: "What type of project do you wish to initialize?",
+        choices: ["bot", "integration"].map((t) => ({ title: t, value: t }))
+      });
+      if (!promptedType) {
+        throw new errors.ParamRequiredError("Project Type");
+      }
+      projectType = promptedType;
+    }
+    const workDir = pathutils.absoluteFrom(pathutils.cwd(), argv.workDir);
+    if (projectType === "bot") {
+      const destination2 = import_path.default.join(workDir, argv.name ?? consts.echoBotName);
+      const exist2 = await this._checkIfDestinationExists(destination2);
+      if (exist2) {
+        return;
+      }
+      await import_fs.default.promises.cp(this._paths.abs.echoBotTemplate, destination2, { recursive: true });
+      this._logger.success(`Bot project initialized in ${import_chalk.default.bold(workDir)}`);
+      return;
+    }
+    const destination = import_path.default.join(workDir, argv.name ?? consts.emptyIntegrationName);
+    const exist = await this._checkIfDestinationExists(destination);
+    if (exist) {
+      return;
+    }
+    await import_fs.default.promises.cp(this._paths.abs.emptyIntegrationTemplate, destination, { recursive: true });
+    this._logger.success(`Integration project initialized in ${import_chalk.default.bold(argv.workDir)}`);
+    return;
+  }
+  _checkIfDestinationExists = async (destination) => {
+    if (import_fs.default.existsSync(destination)) {
+      const override = await this._confirm(
+        `Directory ${import_chalk.default.bold(destination)} already exists. Do you want to overwrite it?`
+      );
+      if (!override) {
+        this._logger.log("Aborting");
+        return true;
+      }
+    }
+    return false;
+  };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/code-generation/action.js

@@ -0,0 +1,70 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var action_exports = {};
+__export(action_exports, {
+  ActionInputModule: () => ActionInputModule,
+  ActionModule: () => ActionModule,
+  ActionOutputModule: () => ActionOutputModule
+});
+module.exports = __toCommonJS(action_exports);
+var import_json_schema_to_typescript = require("json-schema-to-typescript");
+var import_utils = require("../utils");
+var import_module = require("./module");
+class ActionInputModule extends import_module.Module {
+  static async create(input) {
+    const schema = input.schema ?? {};
+    const filename = "input.ts";
+    const def = {
+      path: filename,
+      exportName: "Input",
+      content: await (0, import_json_schema_to_typescript.compile)(schema, filename)
+    };
+    return new ActionInputModule(def);
+  }
+}
+class ActionOutputModule extends import_module.Module {
+  static async create(output) {
+    const schema = output.schema ?? {};
+    const filename = "output.ts";
+    const def = {
+      path: filename,
+      exportName: "Output",
+      content: await (0, import_json_schema_to_typescript.compile)(schema, filename)
+    };
+    return new ActionOutputModule(def);
+  }
+}
+class ActionModule extends import_module.ReExportModule {
+  static async create(actionName, action) {
+    const inputModule = await ActionInputModule.create(action.input ?? {});
+    const outputModule = await ActionOutputModule.create(action.output ?? {});
+    const inst = new ActionModule({
+      exportName: `Action${import_utils.strings.pascalCase(actionName)}`
+    });
+    inst.pushDep(inputModule);
+    inst.pushDep(outputModule);
+    return inst;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActionInputModule,
+  ActionModule,
+  ActionOutputModule
+});

package/dist/code-generation/channel.js

@@ -0,0 +1,51 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var channel_exports = {};
+__export(channel_exports, {
+  ChannelModule: () => ChannelModule
+});
+module.exports = __toCommonJS(channel_exports);
+var import_bluebird = __toESM(require("bluebird"));
+var import_utils = require("../utils");
+var import_message = require("./message");
+var import_module = require("./module");
+class ChannelModule extends import_module.ReExportModule {
+  static async create(channelName, channel) {
+    const messages = channel.messages ?? {};
+    const messageModules = await import_bluebird.default.map(
+      Object.entries(messages),
+      ([messageName, message]) => import_message.MessageModule.create(messageName, message)
+    );
+    const inst = new ChannelModule({
+      exportName: `Channel${import_utils.strings.pascalCase(channelName)}`
+    });
+    inst.pushDep(...messageModules);
+    return inst;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChannelModule
+});

package/dist/code-generation/configuration.js

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var configuration_exports = {};
+__export(configuration_exports, {
+  ConfigurationModule: () => ConfigurationModule
+});
+module.exports = __toCommonJS(configuration_exports);
+var import_json_schema_to_typescript = require("json-schema-to-typescript");
+var import_module = require("./module");
+class ConfigurationModule extends import_module.Module {
+  static async create(configuration) {
+    const schema = configuration.schema ?? {};
+    const filename = "configuration";
+    return new ConfigurationModule({
+      path: `${filename}.ts`,
+      exportName: "Configuration",
+      content: await (0, import_json_schema_to_typescript.compile)(schema, filename)
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigurationModule
+});

package/dist/code-generation/const.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var const_exports = {};
+__export(const_exports, {
+  GENERATED_HEADER: () => GENERATED_HEADER,
+  INDEX_FILE: () => INDEX_FILE
+});
+module.exports = __toCommonJS(const_exports);
+const GENERATED_HEADER = "/* tslint:disable */\n// This file is generated\n// Do not edit this file\n\n";
+const INDEX_FILE = "index.ts";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GENERATED_HEADER,
+  INDEX_FILE
+});