@cimplify/sdk 0.44.21 → 0.44.22

package/dist/cli/commands/domains.mjs

@@ -6,6 +6,7 @@ import readline from 'readline';
 // src/cli/errors.ts
 var CLI_ERROR_CODE = {
   NOT_LOGGED_IN: "NOT_LOGGED_IN",
+  NOT_LINKED: "NOT_LINKED",
   NETWORK_ERROR: "NETWORK_ERROR",
   AUTH_FAILED: "AUTH_FAILED",
   PROJECT_NOT_FOUND: "PROJECT_NOT_FOUND",
@@ -206,6 +207,8 @@ function flagBool(args, name) {
   return args.flags.has(name);
 }
 var AUTH_FILE_NAME = "auth.json";
+var PROJECT_FILE_NAME = "project.json";
+var PROJECT_DIR_NAME = ".cimplify";
 var ENV_XDG_CONFIG_HOME = "XDG_CONFIG_HOME";
 var APP_CONFIG_DIR_NAME = "cimplify";
 var HOME_CONFIG_DIR_NAME = ".config";
@@ -217,6 +220,12 @@ function authConfigDir() {
 function authConfigPath() {
   return path.join(authConfigDir(), AUTH_FILE_NAME);
 }
+function projectConfigDir(cwd = process.cwd()) {
+  return path.join(cwd, PROJECT_DIR_NAME);
+}
+function projectConfigPath(cwd = process.cwd()) {
+  return path.join(projectConfigDir(cwd), PROJECT_FILE_NAME);
+}
 async function readJsonFile(filePath) {
   try {
     const raw = await promises.readFile(filePath, ENCODING_UTF8);
@@ -236,6 +245,16 @@ async function readAuth() {
   }
   return data;
 }
+async function readProjectLink(cwd = process.cwd()) {
+  const data = await readJsonFile(projectConfigPath(cwd));
+  if (!data) {
+    throw new CliError(
+      CLI_ERROR_CODE.NOT_LINKED,
+      "No project linked. Run `cimplify link <project-id>` first."
+    );
+  }
+  return data;
+}
 
 // src/cli/output.ts
 var RESET = "\x1B[0m";
@@ -277,6 +296,14 @@ async function promptYesNo(question, defaultNo = true) {
   if (answer === "") return !defaultNo;
   return answer === "y" || answer === "yes";
 }
+
+// src/cli/types.ts
+var ENV_SCOPE = {
+  DEVELOPMENT: "development",
+  PREVIEW: "preview",
+  STAGING: "staging",
+  PRODUCTION: "production"
+};
 var DOMAIN_TYPE = {
   CUSTOM: "custom",
   CIMPLIFY: "cimplify"
@@ -289,8 +316,34 @@ var SUB_ADD = "add";
 var SUB_VERIFY = "verify";
 var SUB_RM = "rm";
 var SUB_REMOVE = "remove";
+var SUB_ATTACH = "attach";
+var SUB_DETACH = "detach";
+var SUB_PRIMARY = "primary";
 var FLAG_TYPE = "type";
 var FLAG_YES = "yes";
+var FLAG_ENV = "env";
+var FLAG_PRIMARY = "primary";
+var FLAG_ATTACHED = "attached";
+var ENV_SCOPE_VALUES = new Set(Object.values(ENV_SCOPE));
+function resolveEnvScope(value, fallback = ENV_SCOPE.PRODUCTION) {
+  if (value === void 0) return fallback;
+  if (!ENV_SCOPE_VALUES.has(value)) {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      `Invalid env "${value}". Choose: ${[...ENV_SCOPE_VALUES].join(", ")}.`
+    );
+  }
+  return value;
+}
+function projectDomainsEndpoint(businessId, projectId) {
+  return `/v1/businesses/${encodeURIComponent(businessId)}/projects/${encodeURIComponent(projectId)}/domains`;
+}
+function projectDomainItemEndpoint(businessId, projectId, attachmentId) {
+  return `${projectDomainsEndpoint(businessId, projectId)}/${encodeURIComponent(attachmentId)}`;
+}
+function projectDomainPrimaryEndpoint(businessId, projectId, attachmentId) {
+  return `${projectDomainItemEndpoint(businessId, projectId, attachmentId)}/primary`;
+}
 var COL_GAP = "  ";
 var COL_DOMAIN = "DOMAIN";
 var COL_TYPE = "TYPE";
@@ -329,13 +382,17 @@ async function run(argv) {
   if (!sub) {
     throw new CliError(
       CLI_ERROR_CODE.INVALID_INPUT,
-      `Usage: cimplify domains <${SUB_LS}|${SUB_ADD}|${SUB_VERIFY}|${SUB_RM}>`
+      `Usage: cimplify domains <${SUB_LS}|${SUB_ADD}|${SUB_VERIFY}|${SUB_RM}|${SUB_ATTACH}|${SUB_DETACH}|${SUB_PRIMARY}>`
     );
   }
   const auth = await readAuth();
   const client = ApiClient.fromAuth(auth);
   if (sub === SUB_LS || sub === SUB_LIST) {
-    await listDomains(client, auth.businessId);
+    if (flagBool(args, FLAG_ATTACHED)) {
+      await listAttachedForCurrentProject(client, auth.businessId);
+    } else {
+      await listDomains(client, auth.businessId);
+    }
     return;
   }
   if (sub === SUB_ADD) {
@@ -350,6 +407,18 @@ async function run(argv) {
     await removeDomain(client, auth.businessId, args);
     return;
   }
+  if (sub === SUB_ATTACH) {
+    await attachDomain(client, auth.businessId, args);
+    return;
+  }
+  if (sub === SUB_DETACH) {
+    await detachDomain(client, auth.businessId, args);
+    return;
+  }
+  if (sub === SUB_PRIMARY) {
+    await setPrimaryAttachment(client, auth.businessId, args);
+    return;
+  }
   throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `Unknown domains subcommand "${sub}"`);
 }
 async function listDomains(client, businessId) {
@@ -475,5 +544,110 @@ async function findDomain(client, businessId, domain) {
   }
   return match;
 }
+async function attachDomain(client, businessId, args) {
+  const domain = args.positional[1];
+  if (!domain) {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      `Usage: cimplify domains ${SUB_ATTACH} <domain> [--env=preview|production] [--primary]`
+    );
+  }
+  const link = await readProjectLink();
+  const target = await findDomain(client, businessId, domain);
+  if (!target.is_verified) {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      `Domain "${domain}" is not verified. Run: cimplify domains verify ${domain}`
+    );
+  }
+  const envScope = resolveEnvScope(flagString(args, FLAG_ENV));
+  const isPrimary = flagBool(args, FLAG_PRIMARY);
+  const body = {
+    business_domain_id: target.id,
+    env_scope: envScope,
+    is_primary: isPrimary
+  };
+  await client.post(
+    projectDomainsEndpoint(businessId, link.projectId),
+    body
+  );
+  success(`Attached ${domain} to project for ${envScope}${isPrimary ? " (primary)" : ""}`);
+  info(dim("Next deploy will bind this domain. Run: cimplify deploy"));
+}
+async function detachDomain(client, businessId, args) {
+  const domain = args.positional[1];
+  if (!domain) {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      `Usage: cimplify domains ${SUB_DETACH} <domain> [--env=preview|production] [--yes]`
+    );
+  }
+  const link = await readProjectLink();
+  const envScope = resolveEnvScope(flagString(args, FLAG_ENV));
+  const attachment = await findAttachmentForCurrentProject(client, businessId, link.projectId, domain, envScope);
+  if (!flagBool(args, FLAG_YES)) {
+    const confirmed = await promptYesNo(`Detach ${domain} from this project (${envScope})?`, true);
+    if (!confirmed) {
+      throw new CliError(CLI_ERROR_CODE.ABORTED, "Aborted by user.");
+    }
+  }
+  await client.delete(projectDomainItemEndpoint(businessId, link.projectId, attachment.id));
+  success(`Detached ${domain} (${envScope})`);
+  info(dim("Next deploy will not bind this domain. Existing deployments continue serving until redeploy."));
+}
+async function setPrimaryAttachment(client, businessId, args) {
+  const domain = args.positional[1];
+  if (!domain) {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      `Usage: cimplify domains ${SUB_PRIMARY} <domain> [--env=preview|production]`
+    );
+  }
+  const link = await readProjectLink();
+  const envScope = resolveEnvScope(flagString(args, FLAG_ENV));
+  const attachment = await findAttachmentForCurrentProject(client, businessId, link.projectId, domain, envScope);
+  await client.post(
+    projectDomainPrimaryEndpoint(businessId, link.projectId, attachment.id)
+  );
+  success(`Set ${domain} as primary for ${envScope}`);
+}
+async function listAttachedForCurrentProject(client, businessId) {
+  const link = await readProjectLink();
+  const attachments = await client.get(
+    projectDomainsEndpoint(businessId, link.projectId)
+  );
+  if (attachments.length === 0) {
+    info(dim("No domains attached to this project. Attach one: cimplify domains attach <domain>"));
+    return;
+  }
+  const domains = await client.get(domainsEndpoint(businessId));
+  const domainById = new Map(domains.map((d) => [d.id, d]));
+  info(bold(["DOMAIN", "ENV", "PRIMARY", "ATTACHED"].join(COL_GAP)));
+  for (const a of attachments) {
+    const bd = domainById.get(a.business_domain_id);
+    info(
+      [
+        bd?.domain ?? `<unknown:${a.business_domain_id}>`,
+        String(a.env_scope),
+        a.is_primary ? "yes" : "no",
+        a.attached_at
+      ].join(COL_GAP)
+    );
+  }
+}
+async function findAttachmentForCurrentProject(client, businessId, projectId, domain, envScope) {
+  const target = await findDomain(client, businessId, domain);
+  const attachments = await client.get(projectDomainsEndpoint(businessId, projectId));
+  const match = attachments.find(
+    (a) => a.business_domain_id === target.id && a.env_scope === envScope
+  );
+  if (!match) {
+    throw new CliError(
+      CLI_ERROR_CODE.PROJECT_NOT_FOUND,
+      `${domain} is not attached to this project for env "${envScope}". List attached: cimplify domains ls --attached`
+    );
+  }
+  return match;
+}
 
 export { run as default, printDnsRecords };

package/dist/dispatcher.mjs

@@ -31,10 +31,16 @@ Env vars:
   bunx @cimplify/sdk env rm KEY [--yes]      Remove an env var
 
 Domains:
-  bunx @cimplify/sdk domains ls              List business domains
-  bunx @cimplify/sdk domains add <domain>    Add a domain (prints DNS records to set)
-  bunx @cimplify/sdk domains verify <dom>    Trigger verification after DNS is configured
-  bunx @cimplify/sdk domains rm <dom>        Remove a domain
+  bunx @cimplify/sdk domains ls                          List business domains
+  bunx @cimplify/sdk domains ls --attached               List domains attached to the linked project
+  bunx @cimplify/sdk domains add <domain>                Add a domain (prints DNS records to set)
+  bunx @cimplify/sdk domains verify <dom>                Trigger verification after DNS is configured
+  bunx @cimplify/sdk domains rm <dom>                    Remove a domain
+  bunx @cimplify/sdk domains attach <dom> [flags]        Attach a verified domain to the linked project
+                                                         flags: --env=preview|production --primary
+  bunx @cimplify/sdk domains detach <dom> [flags]        Detach a domain from the linked project
+                                                         flags: --env=preview|production --yes
+  bunx @cimplify/sdk domains primary <dom> [--env=...]   Promote an attached domain to primary for its env
 
 Misc:
   bunx @cimplify/sdk --help, -h              Show this help

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cimplify/sdk",
-  "version": "0.44.21",
+  "version": "0.44.22",
   "description": "Cimplify Commerce SDK for storefronts",
   "keywords": [
     "cimplify",