@xano/sdk 1.0.0

package/dist/chunk-YHEFQUQB.js

@@ -0,0 +1,186 @@
+import {
+  workspaceEnvPathIn
+} from "./chunk-DAD3ONIS.js";
+import {
+  addGitignoreRule,
+  ensureGitignored,
+  gitSaysIgnored,
+  gitignoreRootFor,
+  insideGitRepo
+} from "./chunk-XW6KISBB.js";
+import {
+  UsageError,
+  detail,
+  displayPath,
+  noteRunWarning,
+  relForwardSlash,
+  warn
+} from "./chunk-PTHVMXZI.js";
+import {
+  shellQuote
+} from "./chunk-5ZSO4T2G.js";
+
+// src/emit/gitignore.ts
+import { execFileSync } from "child_process";
+import { readFileSync, realpathSync } from "fs";
+import { basename, dirname, join, resolve } from "path";
+function ensureGitignoredOrWarn(authFilePath) {
+  if (!insideGitRepo(authFilePath)) return "not-in-repo";
+  try {
+    if (ensureGitignored(authFilePath)) detail("Added the credential file to .gitignore");
+  } catch (err) {
+    warn(
+      `Could not update .gitignore (${err instanceof Error ? err.message : String(err)}). Add ${authFilePath} to your ignore rules manually.`,
+      "gitignore.update-failed"
+    );
+    return false;
+  }
+  if (trackedByGit(authFilePath)) {
+    warn(
+      `${displayPath(authFilePath)} is tracked by git, so its ignore rule cannot keep the token just written out of the next commit. Untrack it (the file stays on disk): \`${untrackCommand(authFilePath)}\`.`,
+      "gitignore.credential-tracked"
+    );
+    return false;
+  }
+  return true;
+}
+function trackedByGit(path) {
+  try {
+    execFileSync("git", ["ls-files", "--error-unmatch", "--", path], {
+      cwd: dirname(path),
+      stdio: ["ignore", "ignore", "ignore"],
+      timeout: GIT_PROBE_TIMEOUT_MS
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function untrackCommand(path) {
+  let real = resolve(path);
+  try {
+    real = realpathSync(real);
+  } catch {
+  }
+  const top = gitToplevel(dirname(real));
+  const here = gitToplevel(process.cwd());
+  if (top !== void 0 && top === here) return `git rm --cached ${shellQuote(secretPathLabel(real))}`;
+  return `git -C ${shellQuote(displayPath(dirname(real)))} rm --cached ${shellQuote(basename(real))}`;
+}
+function gitToplevel(dir) {
+  try {
+    return execFileSync("git", ["rev-parse", "--show-toplevel"], {
+      cwd: dir,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: GIT_PROBE_TIMEOUT_MS
+    }).trim();
+  } catch {
+    return void 0;
+  }
+}
+function ensureExportGitignored(path) {
+  if (gitSaysIgnored(path) !== false) return;
+  const label = relForwardSlash(process.cwd(), path) || path;
+  try {
+    const rule = addGitignoreRule(path, { fileOnly: true });
+    if (rule !== void 0) {
+      const added = `Added ${rule} to ${gitignoreLabel(path)} \u2014 ${label} holds secrets.`;
+      detail(added);
+      noteRunWarning("gitignore.added-export", added);
+    }
+  } catch (err) {
+    warn(
+      `Could not update .gitignore (${err instanceof Error ? err.message : String(err)}). Add ${label} to your ignore rules manually \u2014 it holds secrets.`,
+      "gitignore.update-failed"
+    );
+  }
+}
+function ensureWorkspaceEnvGitignored(dir) {
+  ensureSecretPathIgnored(workspaceEnvPathIn(dir), "warn");
+}
+function ensureSecretPathGitignored(path, place) {
+  ensureSecretPathIgnored(path, "warn", void 0, place);
+}
+function requireSecretPathGitignored(path, helpFor, place) {
+  ensureSecretPathIgnored(path, "refuse", helpFor, place);
+}
+function secretPathLabel(path) {
+  return relForwardSlash(process.cwd(), path) || resolve(path);
+}
+function gitignoreLabel(path, root) {
+  return displayPath(join(gitignoreRootFor(path, root === void 0 ? {} : { root }), ".gitignore"));
+}
+var GIT_PROBE_TIMEOUT_MS = 5e3;
+function refuseIfTracked(path, label, helpFor) {
+  if (!trackedByGit(path)) return;
+  throw new UsageError(
+    `${label} is TRACKED by git, and this command is about to write real secrets into it. Adding an ignore rule does nothing to a file git already tracks.
+Untrack it first: \`git rm --cached ${label}\` \u2014 then re-run.`,
+    { helpFor }
+  );
+}
+function bareRuleCovers(root, path) {
+  const name = basename(path);
+  const top = resolve(root);
+  for (let dir = resolve(dirname(path)); ; dir = dirname(dir)) {
+    let text;
+    try {
+      text = readFileSync(join(dir, ".gitignore"), "utf8");
+    } catch {
+      text = void 0;
+    }
+    if (text !== void 0) {
+      const lines = text.split(/\r?\n/).map((l) => l.trim());
+      if (lines.some((l) => l.startsWith("!") && l.includes(name))) return false;
+      if (lines.some((l) => l === name)) return true;
+      if (dir === resolve(dirname(path)) && lines.some((l) => l === `/${name}`)) return true;
+    }
+    if (dir === top || dirname(dir) === dir || !`${dir}/`.startsWith(`${top}/`)) return false;
+  }
+}
+function ensureSecretPathIgnored(path, posture, helpFor, place) {
+  const projectRootOf = (p) => place?.root ?? dirname(dirname(p));
+  const label = place?.label ?? secretPathLabel(path);
+  if (posture === "refuse") refuseIfTracked(path, label, helpFor);
+  try {
+    const root = projectRootOf(path);
+    if (!bareRuleCovers(root, `${path}.tmp-*`)) ensureGitignored(`${path}.tmp-*`, { fileOnly: true, root });
+    const rule = bareRuleCovers(root, path) ? void 0 : addGitignoreRule(path, { fileOnly: true, root });
+    if (rule !== void 0) detail(`Added ${rule} to ${gitignoreLabel(path, root)}`);
+  } catch (err) {
+    const why = err instanceof Error ? err.message : String(err);
+    if (posture === "refuse") {
+      throw new UsageError(
+        `Refusing to write ${label}: could not add it to .gitignore (${why}).
+That file is about to hold real secrets, and without an ignore rule the next \`git add\` commits them.
+Add \`${label}\` to your ignore rules yourself, then re-run.`,
+        { helpFor }
+      );
+    }
+    warn(
+      `Could not update .gitignore (${why}). Add ${label} to your ignore rules manually \u2014 it holds secrets.`,
+      "gitignore.update-failed"
+    );
+    return;
+  }
+  if (posture === "refuse" && gitSaysIgnored(path) === false) {
+    throw new UsageError(
+      `Refusing to write ${label}: git still does not ignore it after adding the rule.
+Something later in your ignore rules overrides it (a \`!\` negation, or a nested .gitignore), or a directory in the path contains gitignore glob characters.
+Make \`git check-ignore ${label}\` succeed, then re-run.`,
+      { helpFor }
+    );
+  }
+}
+
+export {
+  ensureGitignoredOrWarn,
+  ensureExportGitignored,
+  ensureWorkspaceEnvGitignored,
+  ensureSecretPathGitignored,
+  requireSecretPathGitignored,
+  secretPathLabel,
+  refuseIfTracked
+};
+//# sourceMappingURL=chunk-YHEFQUQB.js.map