@by-association-only/cli 3.4.0 → 4.0.0

package/dist/index.cjs

@@ -0,0 +1,340 @@
+var import_node_module = require("node:module");
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+
+// packages/cli/src/commands/create.ts
+var fs = __toESM(require("node:fs"));
+var import_prompts2 = require("@clack/prompts");
+var path = __toESM(require("node:path"));
+var import_octokit = require("octokit");
+
+// packages/cli/src/utils.ts
+var PACKAGE_RUNNER_COMMAND = "bunx";
+var GITHUB_INFO = {
+  organization: "baoagency",
+  templateRepository: "unisian"
+};
+
+// packages/cli/src/wrangler.ts
+var import_prompts = require("@clack/prompts");
+
+// packages/cli/src/constants.ts
+var APP_REFERENCE_NAME = "Unisian";
+
+// packages/cli/src/wrangler.ts
+var import_promises = require("node:fs/promises");
+async function runWranglerCommand(command, cwd) {
+  const child = Bun.spawn([PACKAGE_RUNNER_COMMAND, "wrangler@latest", ...command], {
+    stdin: "pipe",
+    stderr: "pipe",
+    cwd,
+    env: {
+      ...process.env,
+      CLOUDFLARE_ACCOUNT_ID: "824c12820335788e8daf77dba7e7891e"
+    }
+  });
+  const stdout = await new Response(child.stdout).text();
+  const stderr = await new Response(child.stderr).text();
+  const code = await child.exited;
+  return new Promise((resolve, reject) => {
+    if (code === 0) {
+      resolve({
+        code,
+        stdout,
+        stderr
+      });
+    }
+    reject({
+      code,
+      stdout,
+      stderr
+    });
+  });
+}
+async function ensureWranglerAuthenticated() {
+  try {
+    const result = await runWranglerCommand(["whoami"]);
+    return !result.stdout.includes("You are not authenticated");
+  } catch {
+    return false;
+  }
+}
+async function wranglerLogin() {
+  const child = Bun.spawn([PACKAGE_RUNNER_COMMAND, "wrangler", "login"], { stdin: "inherit" });
+  const code = await child.exited;
+  return await new Promise((resolve, reject) => {
+    if (code === 0) {
+      resolve();
+    }
+    reject();
+  });
+}
+async function ensureWranglerSessionExists(s) {
+  s.message("Checking to make sure you have the Wrangler CLI installed and authenticated...");
+  if (!await ensureWranglerAuthenticated()) {
+    s.stop("Hmm. Looks like you're not logged in yet.");
+    const wantsToLogIn = await import_prompts.confirm({
+      message: `You need to be logged into wrangler to setup a ${APP_REFERENCE_NAME} app. Log in now?`
+    });
+    if (import_prompts.isCancel(wantsToLogIn) || !wantsToLogIn) {
+      import_prompts.cancel(`You need to be logged into wrangler to be able to setup a ${APP_REFERENCE_NAME} app.`);
+      process.exit(0);
+    }
+    await wranglerLogin();
+  }
+}
+async function writeWranglerConfig(location, config) {
+  return await import_promises.writeFile(location, JSON.stringify(config, null, 2));
+}
+async function createD1Database(name, cwd) {
+  try {
+    await runWranglerCommand(["d1", "create", name, "--binding=DB", "--update-config=true"], cwd);
+    return {
+      success: true,
+      message: `✅ D1 Database: ${name} created!`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `❌ D1 Database: ${error.stderr || error.stdout || error.message}`
+    };
+  }
+}
+async function createKVNamespace(name, cwd) {
+  try {
+    await runWranglerCommand(["kv", "namespace", "create", name, "--binding=BUCKET", "--update-config=true"], cwd);
+    return {
+      success: true,
+      message: `✅ KV Namespace: ${name} created!`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `❌ KV Namespace: ${error.stderr || error.stdout || error.message}`
+    };
+  }
+}
+async function createR2Bucket(name, cwd) {
+  try {
+    await runWranglerCommand(["r2", "bucket", "create", name, "--binding=BUCKET", "--update-config=true"], cwd);
+    return {
+      success: true,
+      message: `✅ KV Namespace: ${name} created!`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `❌ KV Namespace: ${error.stderr || error.stdout || error.message}`
+    };
+  }
+}
+
+// packages/cli/src/commands/create.ts
+var import_picocolors = __toESM(require("picocolors"));
+async function create() {
+  const initialContext = await initializeContext();
+  const context = await validateEnvironment(initialContext);
+  await createGithubRepository(context);
+  await cloneGithubRepository(context);
+  await provisionCloudflareResources(context);
+  await cleanup(context);
+  import_prompts2.note([
+    `1. cd ${context.localPath}`,
+    "2. shopify app config link",
+    "3. bun run dev"
+  ].join(`
+`), `${import_picocolors.default.bgYellow(import_picocolors.default.black("Next steps."))}`);
+  import_prompts2.outro(`Go and build something ${import_picocolors.default.underline(import_picocolors.default.italic(import_picocolors.default.yellow("stupendous")))}.`);
+}
+async function initializeContext() {
+  import_prompts2.intro(`Setting up a new BAO ${APP_REFERENCE_NAME} project`);
+  const appName = await import_prompts2.text({
+    message: "What is the name of your project?",
+    placeholder: `my-${APP_REFERENCE_NAME.toLowerCase()}-project`,
+    validate: (value) => {
+      if (!value.match(/^[a-z0-9-]+$/)) {
+        return `Invalid app name: ${value}. App names can only contain lowercase letters, numbers, and dashes.`;
+      }
+    }
+  });
+  const repoName = `${String(appName)}-app`;
+  const localPath = `./${repoName}`;
+  if (fs.existsSync(localPath)) {
+    import_prompts2.log.error(`Unable to continue as ${localPath} already exists`);
+    process.exit(0);
+  }
+  const s = import_prompts2.spinner();
+  return {
+    appName: String(appName),
+    repoName,
+    localPath,
+    spinner: s
+  };
+}
+async function validateEnvironment(initialContext) {
+  initialContext.spinner.start("Welcome! Checking to make sure your environment is set up correctly.");
+  const hasEnvironmentAccessToken = typeof process.env.GITHUB_TOKEN !== "undefined" && process.env.GITHUB_TOKEN.trim() !== "";
+  if (!hasEnvironmentAccessToken) {
+    import_prompts2.log.warning(`Unable to find a GITHUB_TOKEN environment variable. Please go to https://github.com/settings/tokens/new and create an access token to be able to use the CLI.`);
+  }
+  const githubAccessToken = process.env.GITHUB_TOKEN || await import_prompts2.text({
+    message: "Access token"
+  });
+  try {
+    await testGithubAccessTokenIsValid(String(githubAccessToken));
+  } catch (error) {
+    import_prompts2.log.error(`Invalid access token: ${error.message}`);
+    process.exit(0);
+  }
+  await ensureWranglerSessionExists(initialContext.spinner);
+  initialContext.spinner.stop("Validated environment");
+  import_prompts2.note(`Before using R2, Queues, and Durable objects,
+` + `make sure you've enabled them in the Cloudflare Dashboard.
+` + `https://dash.cloudflare.com/
+` + "Otherwise, the following commands might fail! \uD83D\uDE2C", "\uD83D\uDC4B Heads-up:");
+  return {
+    ...initialContext,
+    githubPersonalAccessToken: String(githubAccessToken),
+    cloudflare: {}
+  };
+}
+async function testGithubAccessTokenIsValid(accessToken) {
+  const octokit = new import_octokit.Octokit({
+    auth: accessToken
+  });
+  const { data: { login } } = await octokit.rest.users.getAuthenticated();
+  return login;
+}
+async function createGithubRepository(context) {
+  context.spinner.start(`Creating GitHub Repository ${context.repoName}`);
+  const octokit = new import_octokit.Octokit({
+    auth: context.githubPersonalAccessToken
+  });
+  try {
+    const appRepo = await octokit.rest.repos.createUsingTemplate({
+      template_owner: GITHUB_INFO.organization,
+      template_repo: GITHUB_INFO.templateRepository,
+      owner: GITHUB_INFO.organization,
+      name: context.repoName,
+      private: true
+    });
+    context.repoHttpUrl = appRepo.data.html_url;
+    context.repoSshUrl = appRepo.data.ssh_url;
+  } catch (error) {
+    import_prompts2.log.error(`Unable to create Github Repository ${context.repoName}`);
+    import_prompts2.log.error(error);
+    process.exit(0);
+  }
+  context.spinner.stop("Github repository created! ⭐");
+}
+async function cloneGithubRepository(context) {
+  if (typeof context.repoSshUrl === "undefined") {
+    import_prompts2.log.error(`Unable to clone Github repository ${context.repoName} as can't find the .git URL`);
+    process.exit(0);
+  }
+  context.spinner.start(`Cloning ${context.repoName} from GitHub`);
+  await new Promise((resolve) => setTimeout(resolve, 5000));
+  const child = Bun.spawn(["git", "clone", context.repoSshUrl, context.localPath], {
+    stderr: "ignore",
+    stdout: "ignore"
+  });
+  await child.exited;
+  if (fs.existsSync(context.localPath)) {
+    context.spinner.stop(`Successfully cloned repository to ${context.localPath}`);
+    return;
+  }
+  context.spinner.stop();
+  import_prompts2.log.error(`Unable to clone repository`);
+  process.exit(0);
+}
+async function provisionCloudflareResources(context) {
+  import_prompts2.note(["Creating the following Cloudflare resources:", "- KV", "- D1", "- R2 Bucket"].join(`
+`));
+  context.spinner.start(`Creating Cloudflare resources`);
+  const wranglerConfig = {
+    $schema: "node_modules/wrangler/config-schema.json",
+    name: context.appName,
+    compatibility_date: "2025-09-21",
+    compatibility_flags: ["nodejs_compat"],
+    main: "@tanstack/react-start/server-entry",
+    dev: {
+      ip: "0.0.0.0",
+      port: 8647
+    },
+    upload_source_maps: true,
+    placement: {
+      mode: "smart"
+    },
+    observability: {
+      enabled: true
+    }
+  };
+  await writeWranglerConfig(`${context.localPath}/wrangler.json`, wranglerConfig);
+  const results = [];
+  context.spinner.message(`Creating KV namespace`);
+  results.push(await createKVNamespace(context.appName, context.localPath));
+  context.spinner.message(`Creating D1 database`);
+  results.push(await createD1Database(context.appName, context.localPath));
+  context.spinner.message(`Creating R2 bucket`);
+  results.push(await createR2Bucket(context.appName, context.localPath));
+  for (const result of results) {
+    if (!result.success) {
+      import_prompts2.log.error(result.message);
+      process.exit(0);
+    }
+  }
+  context.spinner.stop("Cloudflare resources created and wrangler.json updated");
+  const allResults = results.map((r) => r.message);
+  import_prompts2.note(allResults.join(`
+`), "Here's what we did:");
+}
+async function cleanup(context) {
+  context.spinner.start("Removing unnecessary files from the template");
+  import_prompts2.note("Removing default shopify.app.toml", "\uD83E\uDDF9 Cleaning up");
+  fs.unlinkSync(path.join(context.localPath, "shopify.app.toml"));
+  import_prompts2.note("Removing default shopify.app.production.toml", "\uD83E\uDDF9 Cleaning up");
+  fs.unlinkSync(path.join(context.localPath, "shopify.app.production.toml"));
+  context.spinner.message("Installing packages");
+  const packageInstall = Bun.spawn(["bun", "install"], {
+    stderr: "ignore",
+    stdout: "ignore",
+    cwd: context.localPath
+  });
+  await packageInstall.exited;
+  context.spinner.message("Finalising app setup");
+  const gitAdd = Bun.spawn(["git", "add", "."], {
+    stderr: "ignore",
+    stdout: "ignore",
+    cwd: context.localPath
+  });
+  await gitAdd.exited;
+  const gitCommit = Bun.spawn(["git", "commit", "-m", "App setup"], {
+    stderr: "ignore",
+    stdout: "ignore",
+    cwd: context.localPath
+  });
+  await gitCommit.exited;
+  context.spinner.stop();
+}
+
+// packages/cli/src/index.ts
+(async () => {
+  await create();
+})();
+
+//# debugId=EB8FF545C7B695BE64756E2164756E21
+//# sourceMappingURL=index.js.map