@botpress/cli 0.11.6 → 1.0.0

package/dist/utils/path-utils.js

@@ -27,19 +27,34 @@ __export(path_utils_exports, {
   PathStore: () => PathStore,
   absoluteFrom: () => absoluteFrom,
   cwd: () => cwd,
-  isAbsolute: () => isAbsolute,
+  isAbsolutePath: () => isAbsolutePath,
   isPath: () => isPath,
   join: () => join,
+  posix: () => posix,
   relativeFrom: () => relativeFrom,
   rmExtension: () => rmExtension,
-  toUnix: () => toUnix
+  toUnix: () => toUnix,
+  win32: () => win32
 });
 module.exports = __toCommonJS(path_utils_exports);
 var import_lodash = __toESM(require("lodash"));
+var import_os = __toESM(require("os"));
 var import_path = __toESM(require("path"));
+var posix;
+((posix2) => {
+  posix2.isPath = (path) => posix2.isAbsolutePath(path) || posix2.isRelativePath(path);
+  posix2.isRelativePath = (path) => path.startsWith("./") || path.startsWith("../");
+  posix2.isAbsolutePath = (path) => import_path.default.posix.isAbsolute(path);
+})(posix || (posix = {}));
+var win32;
+((win322) => {
+  win322.isPath = (path) => win322.isAbsolutePath(path) || win322.isRelativePath(path);
+  win322.isRelativePath = (path) => path.startsWith(".\\") || path.startsWith("..\\");
+  win322.isAbsolutePath = (path) => /^[a-zA-Z]:\\/.test(path);
+})(win32 || (win32 = {}));
+const isPath = (path) => import_os.default.platform() === "win32" ? win32.isPath(path) : posix.isPath(path);
+const isAbsolutePath = (path) => import_os.default.platform() === "win32" ? win32.isAbsolutePath(path) : posix.isAbsolutePath(path);
 const cwd = () => process.cwd();
-const isAbsolute = (path) => import_path.default.isAbsolute(path);
-const isPath = (path) => isAbsolute(path) || path.startsWith(".");
 const join = (abs, ...paths) => {
   const joined = import_path.default.join(abs, ...paths);
   return import_path.default.normalize(joined);
@@ -47,14 +62,14 @@ const join = (abs, ...paths) => {
 const rmExtension = (filename) => filename.replace(/\.[^/.]+$/, "");
 const toUnix = (path) => path.split(import_path.default.sep).join(import_path.default.posix.sep);
 const absoluteFrom = (rootdir, target) => {
-  if (isAbsolute(target)) {
+  if (isAbsolutePath(target)) {
     return target;
   }
   return import_path.default.join(rootdir, target);
 };
 const relativeFrom = (rootdir, target) => {
   let absPath;
-  if (isAbsolute(target)) {
+  if (isAbsolutePath(target)) {
     absPath = target;
   } else {
     absPath = import_path.default.resolve(import_path.default.join(rootdir, target));
@@ -74,11 +89,13 @@ class PathStore {
   PathStore,
   absoluteFrom,
   cwd,
-  isAbsolute,
+  isAbsolutePath,
   isPath,
   join,
+  posix,
   relativeFrom,
   rmExtension,
-  toUnix
+  toUnix,
+  win32
 });
 //# sourceMappingURL=path-utils.js.map

package/dist/utils/path-utils.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/utils/path-utils.ts"],
-  "sourcesContent": ["import _ from 'lodash'\nimport pathlib from 'path'\n\nexport type AbsolutePath = `/${string}` | `C:\\\\${string}`\n\nexport const cwd = (): AbsolutePath => process.cwd() as AbsolutePath\nexport const isAbsolute = (path: string): path is AbsolutePath => pathlib.isAbsolute(path)\nexport const isPath = (path: string) => isAbsolute(path) || path.startsWith('.')\nexport const join = (abs: AbsolutePath, ...paths: string[]): AbsolutePath => {\n  const joined = pathlib.join(abs, ...paths)\n  return pathlib.normalize(joined) as AbsolutePath\n}\n\nexport const rmExtension = (filename: string) => filename.replace(/\\.[^/.]+$/, '')\n\nexport const toUnix = (path: string) => path.split(pathlib.sep).join(pathlib.posix.sep)\n\nexport const absoluteFrom = (rootdir: AbsolutePath, target: string): AbsolutePath => {\n  if (isAbsolute(target)) {\n    return target\n  }\n  return pathlib.join(rootdir, target) as AbsolutePath\n}\n\nexport const relativeFrom = (rootdir: AbsolutePath, target: string) => {\n  let absPath: string\n\n  if (isAbsolute(target)) {\n    absPath = target\n  } else {\n    absPath = pathlib.resolve(pathlib.join(rootdir, target))\n  }\n\n  return pathlib.relative(rootdir, absPath)\n}\n\nexport class PathStore<P extends string> {\n  public constructor(public readonly abs: Record<P, AbsolutePath>) {}\n  public rel(from: Extract<P, `${string}Dir`>) {\n    return _.mapValues(this.abs, (to) => relativeFrom(this.abs[from], to))\n  }\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAc;AACd,kBAAoB;AAIb,MAAM,MAAM,MAAoB,QAAQ,IAAI;AAC5C,MAAM,aAAa,CAAC,SAAuC,YAAAA,QAAQ,WAAW,IAAI;AAClF,MAAM,SAAS,CAAC,SAAiB,WAAW,IAAI,KAAK,KAAK,WAAW,GAAG;AACxE,MAAM,OAAO,CAAC,QAAsB,UAAkC;AAC3E,QAAM,SAAS,YAAAA,QAAQ,KAAK,KAAK,GAAG,KAAK;AACzC,SAAO,YAAAA,QAAQ,UAAU,MAAM;AACjC;AAEO,MAAM,cAAc,CAAC,aAAqB,SAAS,QAAQ,aAAa,EAAE;AAE1E,MAAM,SAAS,CAAC,SAAiB,KAAK,MAAM,YAAAA,QAAQ,GAAG,EAAE,KAAK,YAAAA,QAAQ,MAAM,GAAG;AAE/E,MAAM,eAAe,CAAC,SAAuB,WAAiC;AACnF,MAAI,WAAW,MAAM,GAAG;AACtB,WAAO;AAAA,EACT;AACA,SAAO,YAAAA,QAAQ,KAAK,SAAS,MAAM;AACrC;AAEO,MAAM,eAAe,CAAC,SAAuB,WAAmB;AACrE,MAAI;AAEJ,MAAI,WAAW,MAAM,GAAG;AACtB,cAAU;AAAA,EACZ,OAAO;AACL,cAAU,YAAAA,QAAQ,QAAQ,YAAAA,QAAQ,KAAK,SAAS,MAAM,CAAC;AAAA,EACzD;AAEA,SAAO,YAAAA,QAAQ,SAAS,SAAS,OAAO;AAC1C;AAEO,MAAM,UAA4B;AAAA,EAChC,YAA4B,KAA8B;AAA9B;AAAA,EAA+B;AAAA,EAC3D,IAAI,MAAkC;AAC3C,WAAO,cAAAC,QAAE,UAAU,KAAK,KAAK,CAAC,OAAO,aAAa,KAAK,IAAI,OAAO,EAAE,CAAC;AAAA,EACvE;AACF;",
-  "names": ["pathlib", "_"]
+  "sourcesContent": ["import _ from 'lodash'\nimport oslib from 'os'\nimport pathlib from 'path'\n\nexport namespace posix {\n  export type AbsolutePath = `/${string}`\n  export const isPath = (path: string) => isAbsolutePath(path) || isRelativePath(path)\n  export const isRelativePath = (path: string) => path.startsWith('./') || path.startsWith('../')\n  export const isAbsolutePath = (path: string): path is AbsolutePath => pathlib.posix.isAbsolute(path)\n}\n\nexport namespace win32 {\n  export type AbsolutePath = `${string}:\\\\${string}` // C:\\path\n  export const isPath = (path: string) => isAbsolutePath(path) || isRelativePath(path)\n  export const isRelativePath = (path: string) => path.startsWith('.\\\\') || path.startsWith('..\\\\')\n  export const isAbsolutePath = (path: string): path is AbsolutePath => /^[a-zA-Z]:\\\\/.test(path) // bp cli does not allow omitting the drive letter\n}\n\nexport type AbsolutePath = posix.AbsolutePath | win32.AbsolutePath\nexport const isPath = (path: string) => (oslib.platform() === 'win32' ? win32.isPath(path) : posix.isPath(path))\nexport const isAbsolutePath = (path: string): path is AbsolutePath =>\n  oslib.platform() === 'win32' ? win32.isAbsolutePath(path) : posix.isAbsolutePath(path)\n\nexport const cwd = (): AbsolutePath => process.cwd() as AbsolutePath\nexport const join = (abs: AbsolutePath, ...paths: string[]): AbsolutePath => {\n  const joined = pathlib.join(abs, ...paths)\n  return pathlib.normalize(joined) as AbsolutePath\n}\n\nexport const rmExtension = (filename: string) => filename.replace(/\\.[^/.]+$/, '')\n\nexport const toUnix = (path: string) => path.split(pathlib.sep).join(pathlib.posix.sep)\n\nexport const absoluteFrom = (rootdir: AbsolutePath, target: string): AbsolutePath => {\n  if (isAbsolutePath(target)) {\n    return target\n  }\n  return pathlib.join(rootdir, target) as AbsolutePath\n}\n\nexport const relativeFrom = (rootdir: AbsolutePath, target: string) => {\n  let absPath: string\n\n  if (isAbsolutePath(target)) {\n    absPath = target\n  } else {\n    absPath = pathlib.resolve(pathlib.join(rootdir, target))\n  }\n\n  return pathlib.relative(rootdir, absPath)\n}\n\nexport class PathStore<P extends string> {\n  public constructor(public readonly abs: Record<P, AbsolutePath>) {}\n  public rel(from: Extract<P, `${string}Dir`>) {\n    return _.mapValues(this.abs, (to) => relativeFrom(this.abs[from], to))\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAc;AACd,gBAAkB;AAClB,kBAAoB;AAEb,IAAU;AAAA,CAAV,CAAUA,WAAV;AAEE,EAAMA,OAAA,SAAS,CAAC,SAAiBA,OAAA,eAAe,IAAI,KAAKA,OAAA,eAAe,IAAI;AAC5E,EAAMA,OAAA,iBAAiB,CAAC,SAAiB,KAAK,WAAW,IAAI,KAAK,KAAK,WAAW,KAAK;AACvF,EAAMA,OAAA,iBAAiB,CAAC,SAAuC,YAAAC,QAAQ,MAAM,WAAW,IAAI;AAAA,GAJpF;AAOV,IAAU;AAAA,CAAV,CAAUC,WAAV;AAEE,EAAMA,OAAA,SAAS,CAAC,SAAiBA,OAAA,eAAe,IAAI,KAAKA,OAAA,eAAe,IAAI;AAC5E,EAAMA,OAAA,iBAAiB,CAAC,SAAiB,KAAK,WAAW,KAAK,KAAK,KAAK,WAAW,MAAM;AACzF,EAAMA,OAAA,iBAAiB,CAAC,SAAuC,eAAe,KAAK,IAAI;AAAA,GAJ/E;AAQV,MAAM,SAAS,CAAC,SAAkB,UAAAC,QAAM,SAAS,MAAM,UAAU,MAAM,OAAO,IAAI,IAAI,MAAM,OAAO,IAAI;AACvG,MAAM,iBAAiB,CAAC,SAC7B,UAAAA,QAAM,SAAS,MAAM,UAAU,MAAM,eAAe,IAAI,IAAI,MAAM,eAAe,IAAI;AAEhF,MAAM,MAAM,MAAoB,QAAQ,IAAI;AAC5C,MAAM,OAAO,CAAC,QAAsB,UAAkC;AAC3E,QAAM,SAAS,YAAAF,QAAQ,KAAK,KAAK,GAAG,KAAK;AACzC,SAAO,YAAAA,QAAQ,UAAU,MAAM;AACjC;AAEO,MAAM,cAAc,CAAC,aAAqB,SAAS,QAAQ,aAAa,EAAE;AAE1E,MAAM,SAAS,CAAC,SAAiB,KAAK,MAAM,YAAAA,QAAQ,GAAG,EAAE,KAAK,YAAAA,QAAQ,MAAM,GAAG;AAE/E,MAAM,eAAe,CAAC,SAAuB,WAAiC;AACnF,MAAI,eAAe,MAAM,GAAG;AAC1B,WAAO;AAAA,EACT;AACA,SAAO,YAAAA,QAAQ,KAAK,SAAS,MAAM;AACrC;AAEO,MAAM,eAAe,CAAC,SAAuB,WAAmB;AACrE,MAAI;AAEJ,MAAI,eAAe,MAAM,GAAG;AAC1B,cAAU;AAAA,EACZ,OAAO;AACL,cAAU,YAAAA,QAAQ,QAAQ,YAAAA,QAAQ,KAAK,SAAS,MAAM,CAAC;AAAA,EACzD;AAEA,SAAO,YAAAA,QAAQ,SAAS,SAAS,OAAO;AAC1C;AAEO,MAAM,UAA4B;AAAA,EAChC,YAA4B,KAA8B;AAA9B;AAAA,EAA+B;AAAA,EAC3D,IAAI,MAAkC;AAC3C,WAAO,cAAAG,QAAE,UAAU,KAAK,KAAK,CAAC,OAAO,aAAa,KAAK,IAAI,OAAO,EAAE,CAAC;AAAA,EACvE;AACF;",
+  "names": ["posix", "pathlib", "win32", "oslib", "_"]
 }

package/dist/utils/path-utils.test.js

@@ -0,0 +1,69 @@
+"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 __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 import_node_test = require("node:test");
+var import_vitest = require("vitest");
+var pathUtils = __toESM(require("./path-utils"));
+(0, import_node_test.describe)("posix", () => {
+  (0, import_vitest.test)("isPath with valid relative path should return true", () => {
+    (0, import_vitest.expect)(pathUtils.posix.isPath("./src")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.posix.isPath("../src")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.posix.isPath("./src/services")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.posix.isPath("./src/services/index.ts")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.posix.isPath("./.././.././../lol.json")).toBe(true);
+  });
+  (0, import_vitest.test)("isPath with valid absolute path should return true", () => {
+    (0, import_vitest.expect)(pathUtils.posix.isPath("/src")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.posix.isPath("/src")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.posix.isPath("/src/services")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.posix.isPath("/src/services/index.ts")).toBe(true);
+  });
+  (0, import_vitest.test)("isPath with invalid path should return false", () => {
+    (0, import_vitest.expect)(pathUtils.posix.isPath("src")).toBe(false);
+    (0, import_vitest.expect)(pathUtils.posix.isPath(".src")).toBe(false);
+    (0, import_vitest.expect)(pathUtils.posix.isPath("..src")).toBe(false);
+    (0, import_vitest.expect)(pathUtils.posix.isPath("src/services")).toBe(false);
+    (0, import_vitest.expect)(pathUtils.posix.isPath("src/services/index.ts")).toBe(false);
+  });
+});
+(0, import_node_test.describe)("win32", () => {
+  (0, import_vitest.test)("isPath with valid relative path should return true", () => {
+    (0, import_vitest.expect)(pathUtils.win32.isPath(".\\src")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.win32.isPath("..\\src")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.win32.isPath(".\\src\\services")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.win32.isPath(".\\src\\services\\index.ts")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.win32.isPath(".\\..\\.\\..\\.\\..\\lol.json")).toBe(true);
+  });
+  (0, import_vitest.test)("isPath with valid absolute path should return true", () => {
+    (0, import_vitest.expect)(pathUtils.win32.isPath("C:\\src")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.win32.isPath("C:\\src")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.win32.isPath("C:\\src\\services")).toBe(true);
+    (0, import_vitest.expect)(pathUtils.win32.isPath("C:\\src\\services\\index.ts")).toBe(true);
+  });
+  (0, import_vitest.test)("isPath with invalid path should return false", () => {
+    (0, import_vitest.expect)(pathUtils.win32.isPath("src")).toBe(false);
+    (0, import_vitest.expect)(pathUtils.win32.isPath(".src")).toBe(false);
+    (0, import_vitest.expect)(pathUtils.win32.isPath("..src")).toBe(false);
+    (0, import_vitest.expect)(pathUtils.win32.isPath("src\\services")).toBe(false);
+    (0, import_vitest.expect)(pathUtils.win32.isPath("src\\services\\index.ts")).toBe(false);
+    (0, import_vitest.expect)(pathUtils.win32.isPath("\\services")).toBe(false);
+    (0, import_vitest.expect)(pathUtils.win32.isPath("\\services\\index.ts")).toBe(false);
+  });
+});
+//# sourceMappingURL=path-utils.test.js.map

package/dist/utils/path-utils.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/path-utils.test.ts"],
+  "sourcesContent": ["import { describe } from 'node:test'\nimport { test, expect } from 'vitest'\nimport * as pathUtils from './path-utils'\n\ndescribe('posix', () => {\n  test('isPath with valid relative path should return true', () => {\n    expect(pathUtils.posix.isPath('./src')).toBe(true)\n    expect(pathUtils.posix.isPath('../src')).toBe(true)\n    expect(pathUtils.posix.isPath('./src/services')).toBe(true)\n    expect(pathUtils.posix.isPath('./src/services/index.ts')).toBe(true)\n    expect(pathUtils.posix.isPath('./.././.././../lol.json')).toBe(true)\n  })\n\n  test('isPath with valid absolute path should return true', () => {\n    expect(pathUtils.posix.isPath('/src')).toBe(true)\n    expect(pathUtils.posix.isPath('/src')).toBe(true)\n    expect(pathUtils.posix.isPath('/src/services')).toBe(true)\n    expect(pathUtils.posix.isPath('/src/services/index.ts')).toBe(true)\n  })\n\n  test('isPath with invalid path should return false', () => {\n    // these are technically valid posix paths, but not for the bp cli\n    expect(pathUtils.posix.isPath('src')).toBe(false)\n    expect(pathUtils.posix.isPath('.src')).toBe(false)\n    expect(pathUtils.posix.isPath('..src')).toBe(false)\n    expect(pathUtils.posix.isPath('src/services')).toBe(false)\n    expect(pathUtils.posix.isPath('src/services/index.ts')).toBe(false)\n  })\n})\n\ndescribe('win32', () => {\n  test('isPath with valid relative path should return true', () => {\n    expect(pathUtils.win32.isPath('.\\\\src')).toBe(true)\n    expect(pathUtils.win32.isPath('..\\\\src')).toBe(true)\n    expect(pathUtils.win32.isPath('.\\\\src\\\\services')).toBe(true)\n    expect(pathUtils.win32.isPath('.\\\\src\\\\services\\\\index.ts')).toBe(true)\n    expect(pathUtils.win32.isPath('.\\\\..\\\\.\\\\..\\\\.\\\\..\\\\lol.json')).toBe(true)\n  })\n\n  test('isPath with valid absolute path should return true', () => {\n    expect(pathUtils.win32.isPath('C:\\\\src')).toBe(true)\n    expect(pathUtils.win32.isPath('C:\\\\src')).toBe(true)\n    expect(pathUtils.win32.isPath('C:\\\\src\\\\services')).toBe(true)\n    expect(pathUtils.win32.isPath('C:\\\\src\\\\services\\\\index.ts')).toBe(true)\n  })\n\n  test('isPath with invalid path should return false', () => {\n    // these are technically valid win32 paths, but not for the bp cli\n    expect(pathUtils.win32.isPath('src')).toBe(false)\n    expect(pathUtils.win32.isPath('.src')).toBe(false)\n    expect(pathUtils.win32.isPath('..src')).toBe(false)\n    expect(pathUtils.win32.isPath('src\\\\services')).toBe(false)\n    expect(pathUtils.win32.isPath('src\\\\services\\\\index.ts')).toBe(false)\n    expect(pathUtils.win32.isPath('\\\\services')).toBe(false)\n    expect(pathUtils.win32.isPath('\\\\services\\\\index.ts')).toBe(false)\n  })\n})\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;AAAA,uBAAyB;AACzB,oBAA6B;AAC7B,gBAA2B;AAAA,IAE3B,2BAAS,SAAS,MAAM;AACtB,0BAAK,sDAAsD,MAAM;AAC/D,8BAAO,UAAU,MAAM,OAAO,OAAO,CAAC,EAAE,KAAK,IAAI;AACjD,8BAAO,UAAU,MAAM,OAAO,QAAQ,CAAC,EAAE,KAAK,IAAI;AAClD,8BAAO,UAAU,MAAM,OAAO,gBAAgB,CAAC,EAAE,KAAK,IAAI;AAC1D,8BAAO,UAAU,MAAM,OAAO,yBAAyB,CAAC,EAAE,KAAK,IAAI;AACnE,8BAAO,UAAU,MAAM,OAAO,yBAAyB,CAAC,EAAE,KAAK,IAAI;AAAA,EACrE,CAAC;AAED,0BAAK,sDAAsD,MAAM;AAC/D,8BAAO,UAAU,MAAM,OAAO,MAAM,CAAC,EAAE,KAAK,IAAI;AAChD,8BAAO,UAAU,MAAM,OAAO,MAAM,CAAC,EAAE,KAAK,IAAI;AAChD,8BAAO,UAAU,MAAM,OAAO,eAAe,CAAC,EAAE,KAAK,IAAI;AACzD,8BAAO,UAAU,MAAM,OAAO,wBAAwB,CAAC,EAAE,KAAK,IAAI;AAAA,EACpE,CAAC;AAED,0BAAK,gDAAgD,MAAM;AAEzD,8BAAO,UAAU,MAAM,OAAO,KAAK,CAAC,EAAE,KAAK,KAAK;AAChD,8BAAO,UAAU,MAAM,OAAO,MAAM,CAAC,EAAE,KAAK,KAAK;AACjD,8BAAO,UAAU,MAAM,OAAO,OAAO,CAAC,EAAE,KAAK,KAAK;AAClD,8BAAO,UAAU,MAAM,OAAO,cAAc,CAAC,EAAE,KAAK,KAAK;AACzD,8BAAO,UAAU,MAAM,OAAO,uBAAuB,CAAC,EAAE,KAAK,KAAK;AAAA,EACpE,CAAC;AACH,CAAC;AAAA,IAED,2BAAS,SAAS,MAAM;AACtB,0BAAK,sDAAsD,MAAM;AAC/D,8BAAO,UAAU,MAAM,OAAO,QAAQ,CAAC,EAAE,KAAK,IAAI;AAClD,8BAAO,UAAU,MAAM,OAAO,SAAS,CAAC,EAAE,KAAK,IAAI;AACnD,8BAAO,UAAU,MAAM,OAAO,kBAAkB,CAAC,EAAE,KAAK,IAAI;AAC5D,8BAAO,UAAU,MAAM,OAAO,4BAA4B,CAAC,EAAE,KAAK,IAAI;AACtE,8BAAO,UAAU,MAAM,OAAO,+BAA+B,CAAC,EAAE,KAAK,IAAI;AAAA,EAC3E,CAAC;AAED,0BAAK,sDAAsD,MAAM;AAC/D,8BAAO,UAAU,MAAM,OAAO,SAAS,CAAC,EAAE,KAAK,IAAI;AACnD,8BAAO,UAAU,MAAM,OAAO,SAAS,CAAC,EAAE,KAAK,IAAI;AACnD,8BAAO,UAAU,MAAM,OAAO,mBAAmB,CAAC,EAAE,KAAK,IAAI;AAC7D,8BAAO,UAAU,MAAM,OAAO,6BAA6B,CAAC,EAAE,KAAK,IAAI;AAAA,EACzE,CAAC;AAED,0BAAK,gDAAgD,MAAM;AAEzD,8BAAO,UAAU,MAAM,OAAO,KAAK,CAAC,EAAE,KAAK,KAAK;AAChD,8BAAO,UAAU,MAAM,OAAO,MAAM,CAAC,EAAE,KAAK,KAAK;AACjD,8BAAO,UAAU,MAAM,OAAO,OAAO,CAAC,EAAE,KAAK,KAAK;AAClD,8BAAO,UAAU,MAAM,OAAO,eAAe,CAAC,EAAE,KAAK,KAAK;AAC1D,8BAAO,UAAU,MAAM,OAAO,yBAAyB,CAAC,EAAE,KAAK,KAAK;AACpE,8BAAO,UAAU,MAAM,OAAO,YAAY,CAAC,EAAE,KAAK,KAAK;AACvD,8BAAO,UAAU,MAAM,OAAO,sBAAsB,CAAC,EAAE,KAAK,KAAK;AAAA,EACnE,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/utils/record-utils.js

@@ -1,7 +1,9 @@
 "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)
@@ -15,6 +17,10 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 record_utils_exports = {};
 __export(record_utils_exports, {
@@ -22,10 +28,12 @@ __export(record_utils_exports, {
   mapKeys: () => mapKeys,
   mapValues: () => mapValues,
   mapValuesAsync: () => mapValuesAsync,
+  mergeRecords: () => mergeRecords,
   setNullOnMissingValues: () => setNullOnMissingValues,
   zipObjects: () => zipObjects
 });
 module.exports = __toCommonJS(record_utils_exports);
+var import_lodash = __toESM(require("lodash"));
 const setNullOnMissingValues = (record = {}, oldRecord = {}) => {
   const newRecord = {};
   for (const [key, value] of Object.entries(record)) {
@@ -77,12 +85,29 @@ function filterValues(record, fn) {
   }
   return newRecord;
 }
+const mergeRecords = (a, b, merge) => {
+  const keys = import_lodash.default.uniq([...Object.keys(a), ...Object.keys(b)]);
+  const result = {};
+  for (const key of keys) {
+    const aValue = a[key];
+    const bValue = b[key];
+    if (aValue && bValue) {
+      result[key] = merge(aValue, bValue);
+    } else if (aValue) {
+      result[key] = aValue;
+    } else if (bValue) {
+      result[key] = bValue;
+    }
+  }
+  return result;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   filterValues,
   mapKeys,
   mapValues,
   mapValuesAsync,
+  mergeRecords,
   setNullOnMissingValues,
   zipObjects
 });

package/dist/utils/record-utils.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/utils/record-utils.ts"],
-  "sourcesContent": ["export const setNullOnMissingValues = <A, B>(\n  record: Record<string, A> = {},\n  oldRecord: Record<string, B> = {}\n): Record<string, A | null> => {\n  const newRecord: Record<string, A | null> = {}\n\n  for (const [key, value] of Object.entries(record)) {\n    newRecord[key] = value\n  }\n\n  for (const value of Object.keys(oldRecord)) {\n    if (!record[value]) {\n      newRecord[value] = null\n    }\n  }\n\n  return newRecord\n}\n\nexport const zipObjects = <A, B>(\n  recordA: Record<string, A>,\n  recordB: Record<string, B>\n): Record<string, [A | null, B | null]> => {\n  const allKeys = new Set([...Object.keys(recordA), ...Object.keys(recordB)])\n  const newRecord: Record<string, [A | null, B | null]> = {}\n\n  for (const key of allKeys) {\n    newRecord[key] = [recordA[key] ?? null, recordB[key] ?? null]\n  }\n\n  return newRecord\n}\n\nexport const mapValues = <A, B>(record: Record<string, A>, fn: (value: A, key: string) => B): Record<string, B> => {\n  const newRecord: Record<string, B> = {}\n\n  for (const [key, value] of Object.entries(record)) {\n    newRecord[key] = fn(value, key)\n  }\n\n  return newRecord\n}\n\nexport const mapValuesAsync = async <A, B>(\n  record: Record<string, A>,\n  fn: (value: A, key: string) => Promise<B>\n): Promise<Record<string, B>> => {\n  const newRecord: Record<string, B> = {}\n\n  for (const [key, value] of Object.entries(record)) {\n    newRecord[key] = await fn(value, key)\n  }\n\n  return newRecord\n}\n\nexport const mapKeys = <A>(record: Record<string, A>, fn: (value: A, key: string) => string): Record<string, A> => {\n  const newRecord: Record<string, A> = {}\n\n  for (const [key, value] of Object.entries(record)) {\n    const newKey = fn(value, key) as string\n    newRecord[newKey] = value\n  }\n\n  return newRecord\n}\n\nexport function filterValues<A, B extends A>(\n  record: Record<string, A>,\n  fn: (value: A, key: string) => value is B\n): Record<string, B>\nexport function filterValues<A, _B extends A>(\n  record: Record<string, A>,\n  fn: (value: A, key: string) => boolean\n): Record<string, A>\nexport function filterValues<A>(record: Record<string, A>, fn: (value: A, key: string) => boolean) {\n  const newRecord: Record<string, A> = {}\n\n  for (const [key, value] of Object.entries(record)) {\n    if (fn(value, key)) {\n      newRecord[key] = value\n    }\n  }\n\n  return newRecord\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,MAAM,yBAAyB,CACpC,SAA4B,CAAC,GAC7B,YAA+B,CAAC,MACH;AAC7B,QAAM,YAAsC,CAAC;AAE7C,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,MAAM,GAAG;AACjD,cAAU,OAAO;AAAA,EACnB;AAEA,aAAW,SAAS,OAAO,KAAK,SAAS,GAAG;AAC1C,QAAI,CAAC,OAAO,QAAQ;AAClB,gBAAU,SAAS;AAAA,IACrB;AAAA,EACF;AAEA,SAAO;AACT;AAEO,MAAM,aAAa,CACxB,SACA,YACyC;AACzC,QAAM,UAAU,oBAAI,IAAI,CAAC,GAAG,OAAO,KAAK,OAAO,GAAG,GAAG,OAAO,KAAK,OAAO,CAAC,CAAC;AAC1E,QAAM,YAAkD,CAAC;AAEzD,aAAW,OAAO,SAAS;AACzB,cAAU,OAAO,CAAC,QAAQ,QAAQ,MAAM,QAAQ,QAAQ,IAAI;AAAA,EAC9D;AAEA,SAAO;AACT;AAEO,MAAM,YAAY,CAAO,QAA2B,OAAwD;AACjH,QAAM,YAA+B,CAAC;AAEtC,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,MAAM,GAAG;AACjD,cAAU,OAAO,GAAG,OAAO,GAAG;AAAA,EAChC;AAEA,SAAO;AACT;AAEO,MAAM,iBAAiB,OAC5B,QACA,OAC+B;AAC/B,QAAM,YAA+B,CAAC;AAEtC,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,MAAM,GAAG;AACjD,cAAU,OAAO,MAAM,GAAG,OAAO,GAAG;AAAA,EACtC;AAEA,SAAO;AACT;AAEO,MAAM,UAAU,CAAI,QAA2B,OAA6D;AACjH,QAAM,YAA+B,CAAC;AAEtC,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,MAAM,GAAG;AACjD,UAAM,SAAS,GAAG,OAAO,GAAG;AAC5B,cAAU,UAAU;AAAA,EACtB;AAEA,SAAO;AACT;AAUO,SAAS,aAAgB,QAA2B,IAAwC;AACjG,QAAM,YAA+B,CAAC;AAEtC,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,MAAM,GAAG;AACjD,QAAI,GAAG,OAAO,GAAG,GAAG;AAClB,gBAAU,OAAO;AAAA,IACnB;AAAA,EACF;AAEA,SAAO;AACT;",
-  "names": []
+  "sourcesContent": ["import _ from 'lodash'\n\nexport const setNullOnMissingValues = <A, B>(\n  record: Record<string, A> = {},\n  oldRecord: Record<string, B> = {}\n): Record<string, A | null> => {\n  const newRecord: Record<string, A | null> = {}\n\n  for (const [key, value] of Object.entries(record)) {\n    newRecord[key] = value\n  }\n\n  for (const value of Object.keys(oldRecord)) {\n    if (!record[value]) {\n      newRecord[value] = null\n    }\n  }\n\n  return newRecord\n}\n\nexport const zipObjects = <A, B>(\n  recordA: Record<string, A>,\n  recordB: Record<string, B>\n): Record<string, [A | null, B | null]> => {\n  const allKeys = new Set([...Object.keys(recordA), ...Object.keys(recordB)])\n  const newRecord: Record<string, [A | null, B | null]> = {}\n\n  for (const key of allKeys) {\n    newRecord[key] = [recordA[key] ?? null, recordB[key] ?? null]\n  }\n\n  return newRecord\n}\n\nexport const mapValues = <A, B>(record: Record<string, A>, fn: (value: A, key: string) => B): Record<string, B> => {\n  const newRecord: Record<string, B> = {}\n\n  for (const [key, value] of Object.entries(record)) {\n    newRecord[key] = fn(value, key)\n  }\n\n  return newRecord\n}\n\nexport const mapValuesAsync = async <A, B>(\n  record: Record<string, A>,\n  fn: (value: A, key: string) => Promise<B>\n): Promise<Record<string, B>> => {\n  const newRecord: Record<string, B> = {}\n\n  for (const [key, value] of Object.entries(record)) {\n    newRecord[key] = await fn(value, key)\n  }\n\n  return newRecord\n}\n\nexport const mapKeys = <A>(record: Record<string, A>, fn: (value: A, key: string) => string): Record<string, A> => {\n  const newRecord: Record<string, A> = {}\n\n  for (const [key, value] of Object.entries(record)) {\n    const newKey = fn(value, key) as string\n    newRecord[newKey] = value\n  }\n\n  return newRecord\n}\n\nexport function filterValues<A, B extends A>(\n  record: Record<string, A>,\n  fn: (value: A, key: string) => value is B\n): Record<string, B>\nexport function filterValues<A, _B extends A>(\n  record: Record<string, A>,\n  fn: (value: A, key: string) => boolean\n): Record<string, A>\nexport function filterValues<A>(record: Record<string, A>, fn: (value: A, key: string) => boolean) {\n  const newRecord: Record<string, A> = {}\n\n  for (const [key, value] of Object.entries(record)) {\n    if (fn(value, key)) {\n      newRecord[key] = value\n    }\n  }\n\n  return newRecord\n}\n\nexport const mergeRecords = <K extends string, V>(\n  a: Record<K, V>,\n  b: Record<K, V>,\n  merge: (v1: V, v2: V) => V\n): Record<K, V> => {\n  const keys = _.uniq([...Object.keys(a), ...Object.keys(b)]) as K[]\n  const result: Record<K, V> = {} as Record<K, V>\n  for (const key of keys) {\n    const aValue = a[key]\n    const bValue = b[key]\n    if (aValue && bValue) {\n      result[key] = merge(aValue, bValue)\n    } else if (aValue) {\n      result[key] = aValue\n    } else if (bValue) {\n      result[key] = bValue\n    }\n  }\n  return result\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAc;AAEP,MAAM,yBAAyB,CACpC,SAA4B,CAAC,GAC7B,YAA+B,CAAC,MACH;AAC7B,QAAM,YAAsC,CAAC;AAE7C,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,MAAM,GAAG;AACjD,cAAU,OAAO;AAAA,EACnB;AAEA,aAAW,SAAS,OAAO,KAAK,SAAS,GAAG;AAC1C,QAAI,CAAC,OAAO,QAAQ;AAClB,gBAAU,SAAS;AAAA,IACrB;AAAA,EACF;AAEA,SAAO;AACT;AAEO,MAAM,aAAa,CACxB,SACA,YACyC;AACzC,QAAM,UAAU,oBAAI,IAAI,CAAC,GAAG,OAAO,KAAK,OAAO,GAAG,GAAG,OAAO,KAAK,OAAO,CAAC,CAAC;AAC1E,QAAM,YAAkD,CAAC;AAEzD,aAAW,OAAO,SAAS;AACzB,cAAU,OAAO,CAAC,QAAQ,QAAQ,MAAM,QAAQ,QAAQ,IAAI;AAAA,EAC9D;AAEA,SAAO;AACT;AAEO,MAAM,YAAY,CAAO,QAA2B,OAAwD;AACjH,QAAM,YAA+B,CAAC;AAEtC,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,MAAM,GAAG;AACjD,cAAU,OAAO,GAAG,OAAO,GAAG;AAAA,EAChC;AAEA,SAAO;AACT;AAEO,MAAM,iBAAiB,OAC5B,QACA,OAC+B;AAC/B,QAAM,YAA+B,CAAC;AAEtC,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,MAAM,GAAG;AACjD,cAAU,OAAO,MAAM,GAAG,OAAO,GAAG;AAAA,EACtC;AAEA,SAAO;AACT;AAEO,MAAM,UAAU,CAAI,QAA2B,OAA6D;AACjH,QAAM,YAA+B,CAAC;AAEtC,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,MAAM,GAAG;AACjD,UAAM,SAAS,GAAG,OAAO,GAAG;AAC5B,cAAU,UAAU;AAAA,EACtB;AAEA,SAAO;AACT;AAUO,SAAS,aAAgB,QAA2B,IAAwC;AACjG,QAAM,YAA+B,CAAC;AAEtC,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,MAAM,GAAG;AACjD,QAAI,GAAG,OAAO,GAAG,GAAG;AAClB,gBAAU,OAAO;AAAA,IACnB;AAAA,EACF;AAEA,SAAO;AACT;AAEO,MAAM,eAAe,CAC1B,GACA,GACA,UACiB;AACjB,QAAM,OAAO,cAAAA,QAAE,KAAK,CAAC,GAAG,OAAO,KAAK,CAAC,GAAG,GAAG,OAAO,KAAK,CAAC,CAAC,CAAC;AAC1D,QAAM,SAAuB,CAAC;AAC9B,aAAW,OAAO,MAAM;AACtB,UAAM,SAAS,EAAE;AACjB,UAAM,SAAS,EAAE;AACjB,QAAI,UAAU,QAAQ;AACpB,aAAO,OAAO,MAAM,QAAQ,MAAM;AAAA,IACpC,WAAW,QAAQ;AACjB,aAAO,OAAO;AAAA,IAChB,WAAW,QAAQ;AACjB,aAAO,OAAO;AAAA,IAChB;AAAA,EACF;AACA,SAAO;AACT;",
+  "names": ["_"]
 }

package/dist/utils/schema-utils.js

@@ -18,6 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var schema_utils_exports = {};
 __export(schema_utils_exports, {
+  dereferenceSchema: () => dereferenceSchema,
   mapZodToJsonSchema: () => mapZodToJsonSchema
 });
 module.exports = __toCommonJS(schema_utils_exports);
@@ -48,8 +49,18 @@ async function mapZodToJsonSchema(definition, options = {}) {
   }
   return schema;
 }
+const dereferenceSchema = async (schema) => {
+  return (0, import_json_schema_ref_parser.dereference)(schema, {
+    resolve: {
+      external: false,
+      file: false,
+      http: false
+    }
+  });
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  dereferenceSchema,
   mapZodToJsonSchema
 });
 //# sourceMappingURL=schema-utils.js.map

package/dist/utils/schema-utils.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/utils/schema-utils.ts"],
-  "sourcesContent": ["import { dereference } from '@apidevtools/json-schema-ref-parser'\nimport { z, transforms, JSONSchema } from '@botpress/sdk'\n\ntype ZuiToJsonSchema = typeof transforms.zuiToJsonSchema\ntype JsonSchema = ReturnType<ZuiToJsonSchema>\ntype ObjectJsonSchema = Extract<JsonSchema, { type: 'object' }>\n\ntype SchemaOptions = {\n  title?: string\n  examples?: any[]\n}\n\ntype SchemaDefinition = {\n  schema: z.ZodObject<any>\n  ui?: Record<string, SchemaOptions | undefined>\n}\n\nexport type ZodToJsonOptions = {\n  dereference?: boolean\n}\n\nconst isObjectSchema = (schema: JsonSchema): schema is ObjectJsonSchema => schema.type === 'object'\n\nexport async function mapZodToJsonSchema(\n  definition: SchemaDefinition,\n  options: ZodToJsonOptions = {}\n): Promise<ReturnType<typeof transforms.zuiToJsonSchema>> {\n  let schema = transforms.zuiToJsonSchema(definition.schema, { target: 'jsonSchema7' })\n\n  if (options.dereference) {\n    schema = (await dereference(schema)) as JSONSchema satisfies JSONSchema\n  }\n\n  if (!isObjectSchema(schema) || !definition.ui) {\n    return schema\n  }\n\n  for (const [key, value] of Object.entries(definition.ui ?? {})) {\n    const property = schema.properties?.[key]\n\n    if (!property) {\n      continue\n    }\n\n    if (!!value?.title) {\n      ;(property as any).title = value.title\n    }\n\n    if (!!value?.examples) {\n      ;(property as any).examples = value.examples\n    }\n  }\n\n  return schema\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oCAA4B;AAC5B,iBAA0C;AAoB1C,MAAM,iBAAiB,CAAC,WAAmD,OAAO,SAAS;AAE3F,eAAsB,mBACpB,YACA,UAA4B,CAAC,GAC2B;AACxD,MAAI,SAAS,sBAAW,gBAAgB,WAAW,QAAQ,EAAE,QAAQ,cAAc,CAAC;AAEpF,MAAI,QAAQ,aAAa;AACvB,aAAU,UAAM,2CAAY,MAAM;AAAA,EACpC;AAEA,MAAI,CAAC,eAAe,MAAM,KAAK,CAAC,WAAW,IAAI;AAC7C,WAAO;AAAA,EACT;AAEA,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,WAAW,MAAM,CAAC,CAAC,GAAG;AAC9D,UAAM,WAAW,OAAO,aAAa;AAErC,QAAI,CAAC,UAAU;AACb;AAAA,IACF;AAEA,QAAI,CAAC,CAAC,OAAO,OAAO;AAClB;AAAC,MAAC,SAAiB,QAAQ,MAAM;AAAA,IACnC;AAEA,QAAI,CAAC,CAAC,OAAO,UAAU;AACrB;AAAC,MAAC,SAAiB,WAAW,MAAM;AAAA,IACtC;AAAA,EACF;AAEA,SAAO;AACT;",
+  "sourcesContent": ["import { dereference } from '@apidevtools/json-schema-ref-parser'\nimport { z, transforms } from '@botpress/sdk'\nimport { JSONSchema7 } from 'json-schema'\n\ntype ZuiToJsonSchema = typeof transforms.zuiToJsonSchema\ntype JsonSchema = ReturnType<ZuiToJsonSchema>\ntype ObjectJsonSchema = Extract<JsonSchema, { type: 'object' }>\n\ntype SchemaOptions = {\n  title?: string\n  examples?: any[]\n}\n\ntype SchemaDefinition = {\n  schema: z.ZodObject<any>\n  ui?: Record<string, SchemaOptions | undefined>\n}\n\nexport type ZodToJsonOptions = {\n  dereference?: boolean\n}\n\nconst isObjectSchema = (schema: JsonSchema): schema is ObjectJsonSchema => schema.type === 'object'\n\nexport async function mapZodToJsonSchema(\n  definition: SchemaDefinition,\n  options: ZodToJsonOptions = {}\n): Promise<ReturnType<typeof transforms.zuiToJsonSchema>> {\n  let schema = transforms.zuiToJsonSchema(definition.schema, { target: 'jsonSchema7' })\n\n  if (options.dereference) {\n    schema = (await dereference(schema)) as typeof schema\n  }\n\n  if (!isObjectSchema(schema) || !definition.ui) {\n    return schema\n  }\n\n  for (const [key, value] of Object.entries(definition.ui ?? {})) {\n    const property = schema.properties?.[key]\n\n    if (!property) {\n      continue\n    }\n\n    if (!!value?.title) {\n      ;(property as any).title = value.title\n    }\n\n    if (!!value?.examples) {\n      ;(property as any).examples = value.examples\n    }\n  }\n\n  return schema\n}\n\nexport const dereferenceSchema = async (schema: JSONSchema7): Promise<JSONSchema7> => {\n  return dereference(schema, {\n    resolve: {\n      external: false,\n      file: false,\n      http: false,\n    },\n  })\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oCAA4B;AAC5B,iBAA8B;AAqB9B,MAAM,iBAAiB,CAAC,WAAmD,OAAO,SAAS;AAE3F,eAAsB,mBACpB,YACA,UAA4B,CAAC,GAC2B;AACxD,MAAI,SAAS,sBAAW,gBAAgB,WAAW,QAAQ,EAAE,QAAQ,cAAc,CAAC;AAEpF,MAAI,QAAQ,aAAa;AACvB,aAAU,UAAM,2CAAY,MAAM;AAAA,EACpC;AAEA,MAAI,CAAC,eAAe,MAAM,KAAK,CAAC,WAAW,IAAI;AAC7C,WAAO;AAAA,EACT;AAEA,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,WAAW,MAAM,CAAC,CAAC,GAAG;AAC9D,UAAM,WAAW,OAAO,aAAa;AAErC,QAAI,CAAC,UAAU;AACb;AAAA,IACF;AAEA,QAAI,CAAC,CAAC,OAAO,OAAO;AAClB;AAAC,MAAC,SAAiB,QAAQ,MAAM;AAAA,IACnC;AAEA,QAAI,CAAC,CAAC,OAAO,UAAU;AACrB;AAAC,MAAC,SAAiB,WAAW,MAAM;AAAA,IACtC;AAAA,EACF;AAEA,SAAO;AACT;AAEO,MAAM,oBAAoB,OAAO,WAA8C;AACpF,aAAO,2CAAY,QAAQ;AAAA,IACzB,SAAS;AAAA,MACP,UAAU;AAAA,MACV,MAAM;AAAA,MACN,MAAM;AAAA,IACR;AAAA,EACF,CAAC;AACH;",
   "names": []
 }

package/dist/utils/schema-utils.test.js

@@ -0,0 +1,51 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_node_test = require("node:test");
+var import_schema_utils = require("./schema-utils");
+(0, import_node_test.describe)("dereferenceSchema", () => {
+  (0, import_vitest.it)("should do nothing if no $ref", async () => {
+    const schema = { type: "object" };
+    const result = await (0, import_schema_utils.dereferenceSchema)(schema);
+    (0, import_vitest.expect)(result).toEqual(schema);
+  });
+  (0, import_vitest.it)("should dereference local $ref", async () => {
+    const schema = {
+      type: "object",
+      properties: {
+        foo: { $ref: "#/$defs/foo" },
+        bar: { $ref: "#/definitions/bar" }
+      },
+      $defs: {
+        foo: { type: "string" }
+      },
+      definitions: {
+        bar: { type: "number" }
+      }
+    };
+    const result = await (0, import_schema_utils.dereferenceSchema)(schema);
+    (0, import_vitest.expect)(result).toEqual({
+      type: "object",
+      properties: {
+        foo: { type: "string" },
+        bar: { type: "number" }
+      },
+      $defs: {
+        foo: { type: "string" }
+      },
+      definitions: {
+        bar: { type: "number" }
+      }
+    });
+  });
+  (0, import_vitest.it)("should ignore non-local $ref", async () => {
+    const schema = {
+      type: "object",
+      properties: {
+        foo: { $ref: "TItem" }
+      }
+    };
+    const result = await (0, import_schema_utils.dereferenceSchema)(schema);
+    (0, import_vitest.expect)(result).toEqual(schema);
+  });
+});
+//# sourceMappingURL=schema-utils.test.js.map

package/dist/utils/schema-utils.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/schema-utils.test.ts"],
+  "sourcesContent": ["import { it, expect } from 'vitest'\nimport { describe } from 'node:test'\nimport { dereferenceSchema } from './schema-utils'\nimport { JSONSchema7 } from 'json-schema'\n\ndescribe('dereferenceSchema', () => {\n  it('should do nothing if no $ref', async () => {\n    const schema: JSONSchema7 = { type: 'object' }\n    const result = await dereferenceSchema(schema)\n    expect(result).toEqual(schema)\n  })\n\n  it('should dereference local $ref', async () => {\n    const schema: JSONSchema7 = {\n      type: 'object',\n      properties: {\n        foo: { $ref: '#/$defs/foo' },\n        bar: { $ref: '#/definitions/bar' },\n      },\n      $defs: {\n        foo: { type: 'string' },\n      },\n      definitions: {\n        bar: { type: 'number' },\n      },\n    }\n    const result = await dereferenceSchema(schema)\n    expect(result).toEqual({\n      type: 'object',\n      properties: {\n        foo: { type: 'string' },\n        bar: { type: 'number' },\n      },\n      $defs: {\n        foo: { type: 'string' },\n      },\n      definitions: {\n        bar: { type: 'number' },\n      },\n    })\n  })\n\n  it('should ignore non-local $ref', async () => {\n    const schema: JSONSchema7 = {\n      type: 'object',\n      properties: {\n        foo: { $ref: 'TItem' },\n      },\n    }\n    const result = await dereferenceSchema(schema)\n    expect(result).toEqual(schema)\n  })\n})\n"],
+  "mappings": ";AAAA,oBAA2B;AAC3B,uBAAyB;AACzB,0BAAkC;AAAA,IAGlC,2BAAS,qBAAqB,MAAM;AAClC,wBAAG,gCAAgC,YAAY;AAC7C,UAAM,SAAsB,EAAE,MAAM,SAAS;AAC7C,UAAM,SAAS,UAAM,uCAAkB,MAAM;AAC7C,8BAAO,MAAM,EAAE,QAAQ,MAAM;AAAA,EAC/B,CAAC;AAED,wBAAG,iCAAiC,YAAY;AAC9C,UAAM,SAAsB;AAAA,MAC1B,MAAM;AAAA,MACN,YAAY;AAAA,QACV,KAAK,EAAE,MAAM,cAAc;AAAA,QAC3B,KAAK,EAAE,MAAM,oBAAoB;AAAA,MACnC;AAAA,MACA,OAAO;AAAA,QACL,KAAK,EAAE,MAAM,SAAS;AAAA,MACxB;AAAA,MACA,aAAa;AAAA,QACX,KAAK,EAAE,MAAM,SAAS;AAAA,MACxB;AAAA,IACF;AACA,UAAM,SAAS,UAAM,uCAAkB,MAAM;AAC7C,8BAAO,MAAM,EAAE,QAAQ;AAAA,MACrB,MAAM;AAAA,MACN,YAAY;AAAA,QACV,KAAK,EAAE,MAAM,SAAS;AAAA,QACtB,KAAK,EAAE,MAAM,SAAS;AAAA,MACxB;AAAA,MACA,OAAO;AAAA,QACL,KAAK,EAAE,MAAM,SAAS;AAAA,MACxB;AAAA,MACA,aAAa;AAAA,QACX,KAAK,EAAE,MAAM,SAAS;AAAA,MACxB;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AAED,wBAAG,gCAAgC,YAAY;AAC7C,UAAM,SAAsB;AAAA,MAC1B,MAAM;AAAA,MACN,YAAY;AAAA,QACV,KAAK,EAAE,MAAM,QAAQ;AAAA,MACvB;AAAA,IACF;AACA,UAAM,SAAS,UAAM,uCAAkB,MAAM;AAC7C,8BAAO,MAAM,EAAE,QAAQ,MAAM;AAAA,EAC/B,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/utils/template-utils.js

@@ -0,0 +1,47 @@
+"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 template_utils_exports = {};
+__export(template_utils_exports, {
+  formatHandleBars: () => formatHandleBars
+});
+module.exports = __toCommonJS(template_utils_exports);
+var import_handlebars = __toESM(require("handlebars"));
+var casing = __toESM(require("./case-utils"));
+import_handlebars.default.registerHelper("toUpperCase", (s) => s.toUpperCase());
+import_handlebars.default.registerHelper("toLowerCase", (s) => s.toLowerCase());
+import_handlebars.default.registerHelper("pascalCase", casing.to.pascalCase);
+import_handlebars.default.registerHelper("kebabCase", casing.to.kebabCase);
+import_handlebars.default.registerHelper("snakeCase", casing.to.snakeCase);
+import_handlebars.default.registerHelper("screamingSnakeCase", casing.to.screamingSnakeCase);
+import_handlebars.default.registerHelper("camelCase", casing.to.camelCase);
+const formatHandleBars = (templateStr, data) => {
+  const template = import_handlebars.default.compile(templateStr);
+  return template(data);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatHandleBars
+});
+//# sourceMappingURL=template-utils.js.map

package/dist/utils/template-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/template-utils.ts"],
+  "sourcesContent": ["import hb from 'handlebars'\nimport * as casing from './case-utils'\n\nhb.registerHelper('toUpperCase', (s) => s.toUpperCase())\nhb.registerHelper('toLowerCase', (s) => s.toLowerCase())\nhb.registerHelper('pascalCase', casing.to.pascalCase)\nhb.registerHelper('kebabCase', casing.to.kebabCase)\nhb.registerHelper('snakeCase', casing.to.snakeCase)\nhb.registerHelper('screamingSnakeCase', casing.to.screamingSnakeCase)\nhb.registerHelper('camelCase', casing.to.camelCase)\n\nexport const formatHandleBars = (templateStr: string, data: Record<string, string>): string => {\n  const template = hb.compile(templateStr)\n  return template(data)\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,wBAAe;AACf,aAAwB;AAExB,kBAAAA,QAAG,eAAe,eAAe,CAAC,MAAM,EAAE,YAAY,CAAC;AACvD,kBAAAA,QAAG,eAAe,eAAe,CAAC,MAAM,EAAE,YAAY,CAAC;AACvD,kBAAAA,QAAG,eAAe,cAAc,OAAO,GAAG,UAAU;AACpD,kBAAAA,QAAG,eAAe,aAAa,OAAO,GAAG,SAAS;AAClD,kBAAAA,QAAG,eAAe,aAAa,OAAO,GAAG,SAAS;AAClD,kBAAAA,QAAG,eAAe,sBAAsB,OAAO,GAAG,kBAAkB;AACpE,kBAAAA,QAAG,eAAe,aAAa,OAAO,GAAG,SAAS;AAE3C,MAAM,mBAAmB,CAAC,aAAqB,SAAyC;AAC7F,QAAM,WAAW,kBAAAA,QAAG,QAAQ,WAAW;AACvC,SAAO,SAAS,IAAI;AACtB;",
+  "names": ["hb"]
+}

package/dist/utils/type-utils.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/utils/type-utils.ts"],
-  "sourcesContent": ["export type Merge<A extends object, B extends object> = Omit<A, keyof B> & B\n"],
+  "sourcesContent": ["export type Merge<A extends object, B extends object> = Omit<A, keyof B> & B\nexport type SafeOmit<T, K extends keyof T> = Omit<T, K>\nexport type Writable<T> = { -readonly [K in keyof T]: T[K] }\n"],
   "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;",
   "names": []
 }

package/e2e/index.ts

@@ -4,6 +4,7 @@ import * as consts from '../src/consts'
 import { createDeployBot } from './tests/create-deploy-bot'
 import { createDeployIntegration } from './tests/create-deploy-integration'
 import { devBot } from './tests/dev-bot'
+import { addIntegration } from './tests/install-package'
 import { requiredSecrets } from './tests/integration-secrets'
 import { prependWorkspaceHandle, enforceWorkspaceHandle } from './tests/manage-workspace-handle'
 import { Test } from './typings'
@@ -16,6 +17,7 @@ const tests: Test[] = [
   requiredSecrets,
   prependWorkspaceHandle,
   enforceWorkspaceHandle,
+  addIntegration,
 ]
 
 const timeout = (ms: number) =>

package/e2e/tests/install-package.ts

@@ -0,0 +1,163 @@
+import * as client from '@botpress/client'
+import * as sdk from '@botpress/sdk'
+import * as fslib from 'fs'
+import * as pathlib from 'path'
+import * as uuid from 'uuid'
+import * as apiUtils from '../../src/api'
+import impl from '../../src/command-implementations'
+import defaults from '../defaults'
+import { Test, TestProps } from '../typings'
+import * as utils from '../utils'
+
+const issueSchema = sdk.z.object({
+  id: sdk.z.string(),
+  priority: sdk.z.enum(['high', 'medium', 'low']),
+  title: sdk.z.string(),
+  body: sdk.z.string(),
+})
+const INTEGRATION = {
+  version: '0.0.1',
+  title: 'An Integration',
+  description: 'An integration',
+  user: { tags: { id: { title: 'ID', description: 'The user ID' } } },
+  configuration: { schema: sdk.z.object({}), identifier: { required: true, linkTemplateScript: '' } },
+  configurations: {
+    token: {
+      title: 'API Token',
+      description: 'The token to authenticate with',
+      schema: sdk.z.object({ token: sdk.z.string() }),
+    },
+  },
+  actions: {
+    getIssue: {
+      input: { schema: sdk.z.object({ id: sdk.z.string() }) },
+      output: { schema: issueSchema },
+    },
+  },
+  events: {
+    issueCreated: {
+      title: 'Issue Created',
+      description: 'An issue was created',
+      schema: issueSchema,
+    },
+  },
+  channels: {
+    issueComment: {
+      title: 'Issue Comment',
+      description: 'Comment on an issue',
+      messages: { text: sdk.messages.defaults.text },
+      conversation: { tags: { id: { title: 'ID', description: 'The issue ID' } } },
+      message: { tags: { id: { title: 'ID', description: 'The issue comment ID' } } },
+    },
+  },
+  entities: {
+    issue: {
+      title: 'Issue',
+      description: 'An issue',
+      schema: issueSchema,
+    },
+  },
+  states: {
+    lastCreatedIssue: {
+      type: 'integration',
+      schema: issueSchema,
+    },
+  },
+  identifier: {
+    extractScript: '',
+  },
+} satisfies Omit<sdk.IntegrationDefinitionProps, 'name'>
+
+const getHomeDir = (props: { tmpDir: string }) => pathlib.join(props.tmpDir, '.botpresshome')
+const initBot = async (props: TestProps, definitionFile: string) => {
+  const { tmpDir, dependencies, ...creds } = props
+  const argv = {
+    ...defaults,
+    botpressHome: getHomeDir(props),
+    confirm: true,
+    ...creds,
+  }
+  const botName = uuid.v4().replace(/-/g, '')
+  const botDir = pathlib.join(tmpDir, botName)
+  await impl.init({ ...argv, workDir: tmpDir, name: botName, type: 'bot' }).then(utils.handleExitCode)
+  await utils.fixBotpressDependencies({ workDir: botDir, target: dependencies })
+  await utils.npmInstall({ workDir: botDir }).then(utils.handleExitCode)
+  await fslib.promises.writeFile(pathlib.join(botDir, 'bot.definition.ts'), definitionFile)
+  return { botDir }
+}
+
+// TODO: add an equivalent test with an interface once interfaces can be created by any workspace
+
+export const addIntegration: Test = {
+  name: 'cli should allow installing an integration',
+  handler: async (props) => {
+    const { tmpDir, workspaceHandle, logger, ...creds } = props
+    const argv = {
+      ...defaults,
+      botpressHome: getHomeDir({ tmpDir }),
+      confirm: true,
+      ...creds,
+    }
+
+    const bpClient = new client.Client({ apiUrl: creds.apiUrl, token: creds.token, workspaceId: creds.workspaceId })
+
+    const integrationSuffix = uuid.v4().replace(/-/g, '')
+    const name = `myintegration${integrationSuffix}`
+    const integrationName = `${workspaceHandle}/${name}`
+
+    const createIntegrationBody = await apiUtils.prepareCreateIntegrationBody(
+      new sdk.IntegrationDefinition({
+        ...INTEGRATION,
+        name: integrationName,
+      })
+    )
+
+    const { integration } = await bpClient.createIntegration({
+      ...createIntegrationBody,
+      dev: true, // this way we ensure the integration will eventually be janitored if the test fails
+      url: creds.apiUrl,
+    })
+
+    try {
+      logger.info('Initializing bot')
+      const { botDir } = await initBot(
+        props,
+        [
+          'import * as sdk from "@botpress/sdk"',
+          `import anIntegration from "./bp_modules/${workspaceHandle}-${name}"`,
+          'export default new sdk.BotDefinition({}).add(anIntegration, {',
+          '  enabled: true,',
+          '  configurationType: null,',
+          '  configuration: {},',
+          '})',
+        ].join('\n')
+      )
+
+      logger.info('Logging in')
+      await impl.login(argv).then(utils.handleExitCode)
+
+      logger.info('Installing integration')
+      await impl
+        .add({
+          ...argv,
+          packageType: undefined,
+          installPath: botDir,
+          packageRef: integration.id,
+        })
+        .then(utils.handleExitCode)
+
+      logger.info('Building bot')
+      await impl.build({ ...argv, workDir: botDir }).then(utils.handleExitCode)
+      await utils.tscCheck({ workDir: botDir }).then(utils.handleExitCode)
+    } finally {
+      await impl.integrations.subcommands
+        .delete({
+          ...argv,
+          integrationRef: integration.id,
+        })
+        .catch(() => {
+          logger.warn(`Failed to delete integration ${integration.id}`) // this is not the purpose of the test
+        })
+    }
+  },
+}