jitsu-cli 2.14.0-beta.8 → 2.14.0-beta.85

package/src/commands/config/resources.ts

@@ -0,0 +1,110 @@
+// Single source of truth for the `jitsu config <noun>` command tree.
+// `kind` selects which verb handlers apply; `type` is the segment used in
+// /api/{workspaceId}/config/{type} for standard config objects.
+
+export type ResourceKind = "configObject" | "workspace" | "link" | "profile-builder";
+
+export type Resource = {
+  noun: string;
+  aliases: string[];
+  kind: ResourceKind;
+  type?: string;
+  supportsTest?: boolean;
+  // Description used in `--help`.
+  description: string;
+};
+
+export const resources: Resource[] = [
+  {
+    noun: "workspaces",
+    aliases: ["workspace"],
+    kind: "workspace",
+    description: "Workspaces accessible to the current user",
+  },
+  {
+    noun: "destinations",
+    aliases: ["destination", "dest"],
+    kind: "configObject",
+    type: "destination",
+    supportsTest: true,
+    description: "Destinations (warehouses, databases, services receiving events)",
+  },
+  {
+    noun: "streams",
+    aliases: ["stream"],
+    kind: "configObject",
+    type: "stream",
+    supportsTest: true,
+    description: "Event streams (formerly known as sources)",
+  },
+  {
+    noun: "functions",
+    aliases: ["function", "fn"],
+    kind: "configObject",
+    type: "function",
+    description: "User-defined functions (UDFs). For dev workflow see `jitsu deploy`.",
+  },
+  {
+    noun: "services",
+    aliases: ["service"],
+    kind: "configObject",
+    type: "service",
+    supportsTest: true,
+    description: "External connector services (Airbyte protocol)",
+  },
+  {
+    noun: "domains",
+    aliases: ["domain"],
+    kind: "configObject",
+    type: "domain",
+    description: "Custom ingestion domains",
+  },
+  {
+    noun: "misc",
+    aliases: [],
+    kind: "configObject",
+    type: "misc",
+    description: "Miscellaneous configuration entities (free-form)",
+  },
+  {
+    noun: "notifications",
+    aliases: ["notification"],
+    kind: "configObject",
+    type: "notification",
+    description: "Alert channels (email/Slack)",
+  },
+  {
+    noun: "connections",
+    aliases: ["connection", "link", "links"],
+    kind: "link",
+    description: "Connections between streams/services and destinations",
+  },
+  {
+    noun: "profile-builders",
+    aliases: ["profile-builder"],
+    kind: "profile-builder",
+    description: "Profile builders (identity stitching)",
+  },
+];
+
+export type Verb = "list" | "get" | "create" | "update" | "delete" | "test";
+
+// Which verbs apply to a given resource kind.
+export function verbsFor(kind: ResourceKind): Verb[] {
+  switch (kind) {
+    case "configObject":
+      return ["list", "get", "create", "update", "delete"];
+    case "workspace":
+      return ["list", "get", "create", "update", "delete"];
+    case "link":
+      // link has no per-id GET; list+create(upsert)+update(alias)+delete
+      return ["list", "create", "update", "delete"];
+    case "profile-builder":
+      return ["list", "create", "update", "delete"];
+  }
+}
+
+export function findResource(name: string): Resource | undefined {
+  const lower = name.toLowerCase();
+  return resources.find(r => r.noun === lower || r.aliases.includes(lower));
+}

package/src/commands/default-workspace.ts

@@ -0,0 +1,44 @@
+import { ApiClient, ApiError } from "../lib/api-client";
+import { authFilePath, readAuthFile, resolveAuth, updateAuthFile } from "../lib/auth-file";
+import { red } from "../lib/chalk-code-highlight";
+
+export type DefaultWorkspaceOpts = {
+  host?: string;
+  apikey?: string;
+};
+
+export async function setDefaultWorkspace(idOrSlug: string, opts: DefaultWorkspaceOpts) {
+  try {
+    const auth = resolveAuth(opts);
+    const client = new ApiClient(auth);
+    let workspace: { id: string; slug?: string; name?: string };
+    try {
+      workspace = await client.request({
+        method: "GET",
+        path: `/api/workspace/${encodeURIComponent(idOrSlug)}`,
+      });
+    } catch (e) {
+      if (e instanceof ApiError && e.status === 404) {
+        throw new Error(`Workspace '${idOrSlug}' not found (or you don't have access)`);
+      }
+      throw e;
+    }
+    updateAuthFile({ defaultWorkspace: workspace.id });
+    const label = workspace.slug ? `${workspace.slug} (${workspace.id})` : workspace.id;
+    console.log(`Default workspace set to ${label}.`);
+    console.log(`Saved to ${authFilePath()}.`);
+  } catch (e) {
+    console.error(red(`Error: ${e instanceof Error ? e.message : String(e)}`));
+    process.exit(1);
+  }
+}
+
+export async function unsetDefaultWorkspace() {
+  const file = readAuthFile();
+  if (!file?.defaultWorkspace) {
+    console.log("No default workspace is set.");
+    return;
+  }
+  updateAuthFile({ defaultWorkspace: undefined });
+  console.log("Default workspace unset.");
+}

package/src/commands/deploy.ts

@@ -3,7 +3,6 @@ import { homedir } from "os";
 import inquirer from "inquirer";
 import { existsSync, readdirSync, readFileSync } from "fs";
 import { loadPackageJson } from "./shared";
-import fetch from "node-fetch";
 import cuid from "cuid";
 import { b, green, red } from "../lib/chalk-code-highlight";
 import { getFunctionFromFilePath } from "../lib/compiled-function";
@@ -151,6 +150,7 @@ async function deployFunctions(
       })`
     );
     await deployFunction(
+      projectDir,
       { host, apikey },
       packageJson,
       workspace,
@@ -162,6 +162,7 @@ async function deployFunctions(
 }
 
 async function deployFunction(
+  projectDir: string,
   { host, apikey }: Args,
   packageJson: any,
   workspace: Workspace,
@@ -171,7 +172,7 @@ async function deployFunction(
 ) {
   const code = readFileSync(file, "utf-8");
 
-  const wrapped = await getFunctionFromFilePath(file, kind, profileBuilders);
+  const wrapped = await getFunctionFromFilePath(projectDir, file, kind, profileBuilders);
   const meta = wrapped.meta;
   if (meta) {
     console.log(`  meta: slug=${meta.slug}, name=${meta.name || "not set"}`);

package/src/commands/spec.ts

@@ -0,0 +1,32 @@
+import { Command } from "commander";
+import { red } from "../lib/chalk-code-highlight";
+import { normalizeHost, readAuthFile, resolveAuth } from "../lib/auth-file";
+import { fetchSpec } from "../lib/spec";
+import { DEFAULT_OUTPUT, SUPPORTED_OUTPUTS, print } from "../lib/renderer";
+
+export function buildSpecCommand(): Command {
+  return new Command("spec")
+    .description("Print the live OpenAPI spec served at /api/spec")
+    .option("-o, --output <format>", `Output format: ${SUPPORTED_OUTPUTS.join(", ")}`, DEFAULT_OUTPUT)
+    .option("-h, --host <host>", "Jitsu host (overrides ~/.jitsu/jitsu-cli.json)")
+    .option("-k, --apikey <api-key>", "API key (overrides ~/.jitsu/jitsu-cli.json)")
+    .action(async (opts: { output?: string; host?: string; apikey?: string }) => {
+      try {
+        // Pass a placeholder apikey if missing — /api/spec is public, but resolveAuth
+        // expects an apikey. Fall back to a synthetic one if user has no auth file.
+        const auth = (() => {
+          try {
+            return resolveAuth(opts);
+          } catch {
+            const host = opts.host ?? readAuthFile()?.host ?? "https://use.jitsu.com";
+            return { host: normalizeHost(host), apikey: "anonymous" };
+          }
+        })();
+        const spec = await fetchSpec(auth);
+        print(spec, opts.output);
+      } catch (e) {
+        console.error(red(`Error: ${e instanceof Error ? e.message : String(e)}`));
+        process.exit(1);
+      }
+    });
+}

package/src/index.ts

@@ -8,12 +8,27 @@ import { test } from "./commands/test";
 
 import { jitsuCliVersion, jitsuCliPackageName } from "./lib/version";
 import { whoami } from "./commands/whoami";
+import { buildConfigCommand } from "./commands/config";
+import { buildSpecCommand } from "./commands/spec";
+import { setDefaultWorkspace, unsetDefaultWorkspace } from "./commands/default-workspace";
+import { preprocessArgv } from "./lib/body-fields";
 
-console.log(figlet.textSync("Jitsu CLI", { horizontalLayout: "full" }));
+// Pull ad-hoc body field flags (--name=val, --credentials.password=...) out of argv
+// before Commander parses it. Reserved option names are left in place.
+process.argv = preprocessArgv(process.argv);
+
+// Figlet banner is decorative — write it to stderr so `jitsu config ... -o json | jq`
+// works without filtering. Skip it entirely when stdout is being piped or for spec output
+// (which is also typically piped to other tools).
+const isPipedStdout = !process.stdout.isTTY;
+if (!isPipedStdout) {
+  process.stderr.write(figlet.textSync("Jitsu CLI", { horizontalLayout: "full" }) + "\n");
+}
 
 const p = new Command();
 
-p.name(jitsuCliPackageName).description("CLI command to create, test and deploy extensions for Jitsu Next");
+p.name(jitsuCliPackageName).description("Jitsu CLI — manage workspaces, configuration objects, and extensions");
+
 p.command("init")
   .description("Initialize a new Jitsu extension project")
   .arguments("[dir]")
@@ -31,19 +46,6 @@ p.command("test")
   .option("-d, --dir <dir>", "the directory of project. (Optional). By default, current directory is used")
   .action(test);
 
-// p.command("run")
-//   .description("Check extensions on provided event, config and persistent storage state")
-//   .option("-d, --dir <dir>", "the directory of project. (Optional). By default, current directory is used")
-//   .option(
-//     "-n, --name <name>",
-//     "name of function file to check (optional). Required if multiple functions are defined in project"
-//   )
-//   .option("-t, --type <type>", "entity type to run", "function")
-//   .requiredOption("-e, --event <file_or_json>", "path to file with event json or event json as a string")
-//   .option("-p, --props <file_or_json>", "path to file with config json or config json as a string. (Optional)")
-//   .option("-s, --store <file_or_json>", "path to file with state json or state json as a string. (Optional)")
-//   .action(run);
-
 p.command("whoami")
   .description("Check if current user is logged in. Shows user's info if logged in")
   .option("-h, --host <host>", "Jitsu host or base url", "https://use.jitsu.com")
@@ -56,6 +58,7 @@ p.command("login")
   .option("-h, --host <host>", "Jitsu host or base url", "https://use.jitsu.com")
   .option("-k, --apikey <api-key>", "Jitsu user's Api Key. (Optional). Disables interactive login.")
   .action(login);
+
 p.command("logout").description("Logout").option("-f, --force", "Do not ask for confirmation").action(logout);
 
 p.command("deploy")
@@ -75,9 +78,23 @@ p.command("deploy")
   .option("-n, --name <name...>", "limit deploy to provided entities only. (Optional)")
   .action(deploy);
 
-//version
+p.command("set-default-workspace")
+  .description(
+    "Save a default workspace to ~/.jitsu/jitsu-cli.json. Subsequent `jitsu config` commands use it when -w is omitted."
+  )
+  .argument("<id-or-slug>", "Workspace id or slug")
+  .option("-h, --host <host>", "Jitsu host (overrides ~/.jitsu/jitsu-cli.json)")
+  .option("-k, --apikey <api-key>", "API key in form keyId:secret (overrides ~/.jitsu/jitsu-cli.json)")
+  .action(setDefaultWorkspace);
+
+p.command("unset-default-workspace")
+  .description("Remove the saved default workspace from ~/.jitsu/jitsu-cli.json")
+  .action(unsetDefaultWorkspace);
+
+p.addCommand(buildConfigCommand());
+p.addCommand(buildSpecCommand());
+
 p.version(jitsuCliPackageName + " " + jitsuCliVersion, "-v, --version");
-//help
 p.helpOption("--help", "display help for command");
 
 p.parse();

package/src/lib/api-client.ts

@@ -0,0 +1,64 @@
+import { AuthInfo } from "./auth-file";
+
+export type ApiRequest = {
+  method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+  path: string;
+  query?: Record<string, string | number | boolean | undefined | null>;
+  body?: unknown;
+};
+
+export class ApiError extends Error {
+  status: number;
+  payload: unknown;
+  constructor(status: number, message: string, payload: unknown) {
+    super(message);
+    this.status = status;
+    this.payload = payload;
+  }
+}
+
+export class ApiClient {
+  constructor(private auth: AuthInfo) {}
+
+  url(path: string, query?: ApiRequest["query"]): string {
+    const base = this.auth.host;
+    const p = path.startsWith("/") ? path : `/${path}`;
+    if (!query) return `${base}${p}`;
+    const qs = Object.entries(query)
+      .filter(([, v]) => v !== undefined && v !== null && v !== "")
+      .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`)
+      .join("&");
+    return qs ? `${base}${p}?${qs}` : `${base}${p}`;
+  }
+
+  async request<T = unknown>(req: ApiRequest): Promise<T> {
+    const method = req.method ?? "GET";
+    const headers: Record<string, string> = {
+      Accept: "application/json",
+      Authorization: `Bearer ${this.auth.apikey}`,
+    };
+    let body: string | undefined;
+    if (req.body !== undefined) {
+      headers["Content-Type"] = "application/json";
+      body = JSON.stringify(req.body);
+    }
+    const res = await fetch(this.url(req.path, req.query), { method, headers, body });
+    const text = await res.text();
+    let parsed: unknown = text;
+    if (text && res.headers.get("content-type")?.includes("application/json")) {
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        // fall through with raw text
+      }
+    }
+    if (!res.ok) {
+      const msg =
+        (parsed && typeof parsed === "object" && "message" in (parsed as any)
+          ? String((parsed as any).message)
+          : undefined) ?? `HTTP ${res.status} ${method} ${req.path}`;
+      throw new ApiError(res.status, msg, parsed);
+    }
+    return parsed as T;
+  }
+}

package/src/lib/auth-file.ts

@@ -0,0 +1,83 @@
+import * as fs from "fs";
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+
+export type AuthInfo = { host: string; apikey: string };
+
+export type AuthFile = {
+  host?: string;
+  apikey?: string;
+  defaultWorkspace?: string;
+};
+
+const DEFAULT_HOST = "https://use.jitsu.com";
+
+export function authFilePath(): string {
+  return `${homedir()}/.jitsu/jitsu-cli.json`;
+}
+
+export function readAuthFile(): AuthFile | undefined {
+  const path = authFilePath();
+  if (!fs.existsSync(path)) return undefined;
+  return JSON.parse(readFileSync(path, { encoding: "utf-8" }));
+}
+
+// Merge `patch` into the existing auth file, creating the file (and parent dir)
+// if necessary. Setting a field to `undefined` removes it.
+export function updateAuthFile(patch: Partial<AuthFile>): AuthFile {
+  const path = authFilePath();
+  const existing = readAuthFile() ?? {};
+  const next: AuthFile = { ...existing };
+  for (const [k, v] of Object.entries(patch)) {
+    if (v === undefined) delete (next as any)[k];
+    else (next as any)[k] = v;
+  }
+  mkdirSync(`${homedir()}/.jitsu`, { recursive: true });
+  writeFileSync(path, JSON.stringify(next, null, 2));
+  return next;
+}
+
+export function readDefaultWorkspace(): string | undefined {
+  return readAuthFile()?.defaultWorkspace;
+}
+
+// Resolve host + apikey for an authenticated CLI command. Order of precedence:
+//   1. --host / --apikey flags
+//   2. ~/.jitsu/jitsu-cli.json
+//   3. JITSU_HOST / JITSU_APIKEY env vars
+//   4. https://use.jitsu.com (host only)
+export function resolveAuth(opts: { host?: string; apikey?: string }): AuthInfo {
+  let host = opts.host;
+  let apikey = opts.apikey;
+
+  if (!host || !apikey) {
+    const file = readAuthFile();
+    if (file) {
+      if (!host) host = file.host;
+      if (!apikey) apikey = file.apikey;
+    }
+  }
+
+  if (!host) host = process.env.JITSU_HOST;
+  if (!apikey) apikey = process.env.JITSU_APIKEY;
+  if (!host) host = DEFAULT_HOST;
+
+  if (!apikey) {
+    throw new Error("Not authenticated. Run `jitsu login`, set JITSU_APIKEY, or pass --apikey <key>.");
+  }
+
+  return { host: normalizeHost(host), apikey };
+}
+
+export function normalizeHost(host: string): string {
+  let url = host;
+  if (!url.startsWith("http")) {
+    if (url.startsWith("localhost") || /^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+/.test(url)) {
+      url = "http://" + url;
+    } else {
+      url = "https://" + url;
+    }
+  }
+  if (url.endsWith("/")) url = url.slice(0, -1);
+  return url;
+}

package/src/lib/body-builder.ts

@@ -0,0 +1,68 @@
+import * as fs from "fs";
+import yaml from "js-yaml";
+import { parseScalar, setDottedPath } from "./dotted";
+
+export type BodySources = {
+  // Path to a yaml/json file. `-` means stdin.
+  file?: string;
+  // Inline JSON string (full body or partial).
+  json?: string;
+  // Already-parsed dotted-path fields, e.g. { "credentials.password": "secret" }.
+  fields?: Record<string, string>;
+};
+
+// Builds a single request body by merging (deep) sources in this order:
+//   1. -f / --file
+//   2. --json
+//   3. dotted-path flags
+// Later sources override earlier ones at the leaf level. Arrays are replaced, not concatenated.
+// Returns undefined if no source is provided.
+export function buildBody(sources: BodySources): unknown {
+  const layers: any[] = [];
+  if (sources.file) layers.push(loadFile(sources.file));
+  if (sources.json) layers.push(parseInlineJson(sources.json));
+  if (sources.fields && Object.keys(sources.fields).length > 0) {
+    const obj: any = {};
+    for (const [path, raw] of Object.entries(sources.fields)) {
+      setDottedPath(obj, path, parseScalar(raw));
+    }
+    layers.push(obj);
+  }
+  if (layers.length === 0) return undefined;
+  return layers.reduce((acc, layer) => deepMerge(acc, layer), {});
+}
+
+function loadFile(path: string): unknown {
+  const text = path === "-" ? fs.readFileSync(0, "utf-8") : fs.readFileSync(path, "utf-8");
+  // js-yaml's safeLoad handles JSON too (JSON is valid YAML). But trim first — empty file is null.
+  const parsed = yaml.load(text);
+  if (parsed === null || parsed === undefined) {
+    throw new Error(`File ${path} parsed as empty`);
+  }
+  return parsed;
+}
+
+function parseInlineJson(s: string): unknown {
+  try {
+    return JSON.parse(s);
+  } catch (e) {
+    throw new Error(`--json value is not valid JSON: ${(e as Error).message}`);
+  }
+}
+
+function isPlainObject(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+function deepMerge(target: any, source: any): any {
+  if (!isPlainObject(target) || !isPlainObject(source)) return source;
+  const out: any = { ...target };
+  for (const [k, v] of Object.entries(source)) {
+    if (isPlainObject(v) && isPlainObject(out[k])) {
+      out[k] = deepMerge(out[k], v);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}

package/src/lib/body-fields.ts

@@ -0,0 +1,61 @@
+// Pre-extracts body field flags from process.argv before Commander parses it.
+//
+// Why: we want users to write `--credentials.password=secret` and `--destinationType=postgres`
+// as ad-hoc body fields, but Commander would reject unknown options. The simplest robust
+// solution is to filter argv: anything matching `--<name>=<value>` whose head segment is NOT
+// a reserved Commander option is captured here, and the rest is left for Commander.
+//
+// Single global stash is fine because the CLI runs one command per process.
+
+// Reserved option names — any `--name=value` whose head is in this set is left for Commander.
+// Everything else becomes a body field (top-level for flat names, nested for dotted ones).
+const RESERVED = new Set([
+  "workspace",
+  "output",
+  "host",
+  "apikey",
+  "file",
+  "json",
+  "cascade",
+  "strict",
+  "from",
+  "to",
+  "help",
+  "version",
+]);
+
+const fields: Record<string, string> = {};
+
+// Activate body-field extraction only for the `config` command group. Otherwise the
+// preprocessor would steal flags from `deploy --type=function --name=foo` etc.
+function shouldExtract(argv: string[]): boolean {
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("-")) continue;
+    return a === "config";
+  }
+  return false;
+}
+
+export function preprocessArgv(argv: string[]): string[] {
+  if (!shouldExtract(argv)) return argv;
+  const out: string[] = [];
+  for (const arg of argv) {
+    const m = /^--([a-zA-Z][\w.-]*)=([\s\S]*)$/.exec(arg);
+    if (m) {
+      const head = m[1].split(".")[0];
+      if (!RESERVED.has(head)) {
+        fields[m[1]] = m[2];
+        continue;
+      }
+    }
+    out.push(arg);
+  }
+  return out;
+}
+
+export function consumeBodyFields(): Record<string, string> {
+  const copy = { ...fields };
+  for (const k of Object.keys(fields)) delete fields[k];
+  return copy;
+}

package/src/lib/compiled-function.ts

@@ -1,7 +1,8 @@
 import { JitsuFunction } from "@jitsu/protocols/functions";
 import fs from "fs";
-import { rollup } from "rollup";
+import * as esbuild from "esbuild";
 import { assertDefined, assertTrue } from "juava";
+import path from "path";
 
 export type CompiledFunction = {
   func: JitsuFunction;
@@ -14,10 +15,11 @@ export type CompiledFunction = {
 };
 
 function getSlug(filePath: string) {
-  return filePath.split("/").pop()?.replace(".ts", "");
+  return filePath.split("/").pop()?.replace(".ts", "").replace(".js", "");
 }
 
 export async function getFunctionFromFilePath(
+  projectDir: string,
   filePath: string,
   kind: "function" | "profile",
   profileBuilders: any[] = []
@@ -28,29 +30,34 @@ export async function getFunctionFromFilePath(
     throw new Error(`Cannot load function from file ${filePath}: path is not a file`);
   }
 
-  const bundle = await rollup({
-    input: [filePath],
-    external: ["@jitsu/functions-lib"],
-    logLevel: "silent",
+  // Transform ESM to CJS without bundling - just convert the module format
+  // This avoids resolving dependencies which may be symlinked
+  const result = await esbuild.transform(fs.readFileSync(filePath, "utf-8"), {
+    loader: filePath.endsWith(".ts") ? "ts" : "js",
+    format: "cjs",
+    platform: "node",
   });
 
-  const output = await bundle.generate({
-    file: filePath,
-    format: "commonjs",
-  });
-
-  const exports: Record<string, any> = {} as Record<string, any>;
-  eval(output.output[0].code);
+  const code = result.code;
+  const module: { exports: Record<string, any> } = { exports: {} };
+  const exports = module.exports;
+  // Provide require stub for external imports that we mock out
+  const require = (id: string) => {
+    // External dependencies are not needed for config extraction
+    return {};
+  };
+  eval(code);
+  // After eval, module.exports contains the actual exports
+  const moduleExports = module.exports;
   assertDefined(
-    exports.default,
-    `Function from ${filePath} doesn't have default export. Exported symbols: ${Object.keys(exports)}`
+    moduleExports.default,
+    `Function from ${filePath} doesn't have default export. Exported symbols: ${Object.keys(moduleExports)}`
   );
-  assertTrue(typeof exports.default === "function", `Default export from ${filePath} is not a function`);
-
-  let name = exports.config?.name || exports.config?.slug || getSlug(filePath);
-  let id = exports.config?.id;
+  assertTrue(typeof moduleExports.default === "function", `Default export from ${filePath} is not a function`);
+  let name = moduleExports.config?.name || moduleExports.config?.slug || getSlug(filePath);
+  let id = moduleExports.config?.id;
   if (kind === "profile") {
-    const profileBuilderId = exports.config?.profileBuilderId;
+    const profileBuilderId = moduleExports.config?.profileBuilderId;
     const profileBuilder = profileBuilders.find(pb => pb.id === profileBuilderId);
     if (!profileBuilder) {
       throw new Error(
@@ -67,12 +74,12 @@ export async function getFunctionFromFilePath(
   }
 
   return {
-    func: exports.default,
+    func: moduleExports.default,
     meta: {
-      slug: exports.config?.slug || getSlug(filePath),
+      slug: moduleExports.config?.slug || getSlug(filePath),
       id: id,
       name: name,
-      description: exports.config?.description,
+      description: moduleExports.config?.description,
     },
   };
 }