@seliseblocks/cli-os 0.2.11 → 0.2.12

package/dist/commands/projects/create.js

@@ -1,42 +1,136 @@
+import { randomBytes } from "node:crypto";
 import { booleanFlag, stringFlag } from "../../lib/args.js";
 import { blocksRequest } from "../../lib/api.js";
 import { confirmMutation } from "../../lib/confirm.js";
+import { CliActionableError } from "../../lib/errors.js";
+import { isRecord } from "../../lib/data-response.js";
 import { writeOutput } from "../../lib/output.js";
-import { parseCommand } from "../../lib/workspace.js";
+import { listProjectGroups } from "../../lib/project-info.js";
 import { requestContext } from "../../lib/request-context.js";
+import { parseCommand } from "../../lib/workspace.js";
+const CREATE_ENDPOINT = "/os/v4/Project/Create";
+// This command creates exactly one application, always in 'dev'. More
+// environments are added later from the portal (or by a future command that
+// passes tenantGroupId); nothing here may widen that.
+const ENVIRONMENT = "dev";
+// Project/Gets builds each tenantId as the environment letter prefixed onto
+// the tenant group id -- 'd' for dev, uppercased.
+const ENVIRONMENT_LETTER = "d";
+const ENVIRONMENT_TENANT_PREFIX = ENVIRONMENT_LETTER.toUpperCase();
+// Only ever a placeholder: the server validates that the domain parses as an
+// absolute http(s) URL and then discards it, assigning its own domain during
+// provisioning (environment letter + tenant slug, e.g.
+// https://dboafe.slsblx.com). Mirror that shape so a dry-run payload looks
+// like what the platform actually hands back.
+const PLACEHOLDER_BASE_DOMAIN = "slsblx.com";
+const PLACEHOLDER_COOKIE_DOMAIN = "slsblx.com";
+const NAME_MIN_LENGTH = 3;
+const NAME_MAX_LENGTH = 100;
+const VERIFY_ATTEMPTS = 5;
+const VERIFY_INTERVAL_MS = 2000;
 export async function createProject(argv) {
     const { args, flags } = parseCommand(argv);
-    const name = args[0] || stringFlag(flags, "name", { required: true });
-    const env = stringFlag(flags, "env", { defaultValue: "dev" });
-    const domain = stringFlag(flags, "domain", { defaultValue: `https://${slug(name)}-${env}.seliseblocks.com` });
-    const cookieDomain = stringFlag(flags, "cookie-domain", { defaultValue: "seliseblocks.com" });
-    const production = booleanFlag(flags, "production");
+    const name = (args[0] || stringFlag(flags, "name")).trim();
+    if (!name) {
+        throw new CliActionableError("Missing project name.", "missing_project_name", 'blocks projects create "<name>"');
+    }
+    if (name.length < NAME_MIN_LENGTH || name.length > NAME_MAX_LENGTH) {
+        throw new CliActionableError(`Project name must be between ${NAME_MIN_LENGTH} and ${NAME_MAX_LENGTH} characters.`, "invalid_project_name", `blocks projects create "<${NAME_MIN_LENGTH}-${NAME_MAX_LENGTH} character name>"`);
+    }
     const body = {
         name,
         isAcceptBlocksTerms: true,
         isUseBlocksExclusively: true,
-        isProduction: production,
+        isProduction: false,
         resources: [],
         applicationContexts: [
             {
-                cookieDomain,
-                domain,
-                environment: env
+                cookieDomain: PLACEHOLDER_COOKIE_DOMAIN,
+                domain: placeholderDomain(),
+                environment: ENVIRONMENT
             }
         ]
     };
     if (booleanFlag(flags, "dry-run")) {
-        writeOutput({ dryRun: true, request: body }, flags);
+        writeOutput({ dryRun: true, endpoint: CREATE_ENDPOINT, request: body }, flags);
         return;
     }
-    await confirmMutation(flags, `Create Blocks project '${name}' with '${env}' environment.`);
-    const result = await blocksRequest("/os/v4/Project/Create", {
+    if (!booleanFlag(flags, "allow-duplicate-name")) {
+        await assertNameIsFree(name, flags);
+    }
+    await confirmMutation(flags, `Create Blocks project '${name}' with a single '${ENVIRONMENT}' environment. This accepts the Blocks terms (isAcceptBlocksTerms, isUseBlocksExclusively) on your behalf.`);
+    // No tenantGroupId in the body: omitting it is what makes this a new
+    // project. Sending one would instead add an environment to an existing
+    // project, which this command deliberately cannot do.
+    const result = await blocksRequest(CREATE_ENDPOINT, {
         accountAuth: true,
         ...requestContext(flags),
         body
     });
-    writeOutput(result, flags);
+    // Project/Create answers validation failures with HTTP 200 and
+    // { isSuccess: false, errors: { property: message } }, so the status code
+    // alone never proves the project was created.
+    if (!result?.isSuccess || !result.tenantGroupId) {
+        throw new CliActionableError(`Project/Create rejected '${name}': ${formatErrors(result?.errors)}`, "project_create_failed", "blocks projects list --json");
+    }
+    const tenantGroupId = result.tenantGroupId;
+    const created = await findCreatedProject(tenantGroupId, flags);
+    const tenantId = created?.tenantId ?? `${ENVIRONMENT_TENANT_PREFIX}${tenantGroupId}`;
+    writeOutput({
+        domain: created?.applications?.[0]?.domain ?? "",
+        environment: created?.environment ?? ENVIRONMENT,
+        name: created?.name ?? name,
+        tenantGroupId,
+        tenantId,
+        verified: Boolean(created)
+    }, flags);
+    if (!flags.json) {
+        if (!created) {
+            console.log(`Project/Gets has not listed '${tenantId}' yet. Re-run 'blocks projects list' to confirm before using it.`);
+        }
+        console.log(`Next: blocks use ${tenantId}`);
+    }
+}
+async function assertNameIsFree(name, flags) {
+    const groups = await listProjectGroups(flags);
+    const target = name.toLowerCase();
+    const clash = groups.some((group) => (group.name ?? "").trim().toLowerCase() === target ||
+        (group.projects ?? []).some((project) => (project.name ?? "").trim().toLowerCase() === target));
+    if (!clash)
+        return;
+    // A retried create makes a second tenant group with the same name rather
+    // than failing, so an accidental duplicate is only preventable here.
+    throw new CliActionableError(`A project named '${name}' already exists on this account.`, "project_name_taken", "blocks projects list --json, or re-run with --allow-duplicate-name to create a second project with this name");
+}
+// Provisioning is asynchronous (Project/Create hands the tenant to a
+// consumer queue) but fast, so poll Project/Gets briefly instead of
+// reporting a tenantId the platform has not published yet.
+async function findCreatedProject(tenantGroupId, flags) {
+    const expectedTenantId = `${ENVIRONMENT_TENANT_PREFIX}${tenantGroupId}`;
+    for (let attempt = 0; attempt < VERIFY_ATTEMPTS; attempt += 1) {
+        if (attempt > 0)
+            await delay(VERIFY_INTERVAL_MS);
+        const groups = await listProjectGroups(flags).catch(() => []);
+        const group = groups.find((item) => item.tenantGroupId === tenantGroupId);
+        const project = (group?.projects ?? []).find((item) => item.tenantId === expectedTenantId || item.environment === ENVIRONMENT);
+        if (project)
+            return project;
+    }
+    return undefined;
+}
+function placeholderDomain() {
+    return `https://${ENVIRONMENT_LETTER}${randomSlug(5)}.${PLACEHOLDER_BASE_DOMAIN}`;
+}
+function randomSlug(length) {
+    const letters = "abcdefghijklmnopqrstuvwxyz";
+    return Array.from(randomBytes(length), (byte) => letters[byte % letters.length]).join("");
+}
+function formatErrors(errors) {
+    if (!isRecord(errors))
+        return "no error detail returned.";
+    const entries = Object.entries(errors).map(([key, value]) => `${key}: ${String(value)}`);
+    return entries.length > 0 ? entries.join("; ") : "no error detail returned.";
 }
-function slug(value) {
-    return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "blocks-app";
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
 }