@sanity/runtime-cli 17.7.1 → 17.8.0-blueprinit.g0993fa5

package/dist/cores/blueprinit/selection.js

@@ -0,0 +1,90 @@
+import { select } from '@inquirer/prompts';
+export async function chooseOrganization(groups, organizationId, interactive) {
+    if (groups.length === 0) {
+        return failure('No organizations found for this account.');
+    }
+    if (organizationId) {
+        const organization = groups.find((group) => group.organization.id === organizationId);
+        return organization
+            ? { ok: true, value: organization }
+            : failure(`No organization "${organizationId}" found for this account.`);
+    }
+    if (groups.length === 1)
+        return { ok: true, value: groups[0] };
+    if (!interactive) {
+        return failure('Multiple organizations found.', ['Pass --organization-id <id> to choose one.']);
+    }
+    const selectedId = await select({
+        message: 'Choose a Sanity organization:',
+        choices: groups.map(({ organization, projects }) => ({
+            name: organization.name,
+            value: organization.id,
+            description: `${projects?.length ?? 0} projects`,
+        })),
+    });
+    const selected = groups.find(({ organization }) => organization.id === selectedId);
+    return selected ? { ok: true, value: selected } : failure('Organization not found.');
+}
+export async function chooseProject(projects, projectId, organizationName, interactive) {
+    if (projects.length === 0) {
+        return failure(`No projects found in ${organizationName}.`);
+    }
+    if (projectId) {
+        const project = projects.find(({ id }) => id === projectId);
+        return project
+            ? { ok: true, value: project }
+            : failure(`No project "${projectId}" found in ${organizationName}.`);
+    }
+    if (projects.length === 1)
+        return { ok: true, value: projects[0] };
+    if (!interactive) {
+        return failure('Multiple projects found.', ['Pass --project-id <id> to choose one.']);
+    }
+    const selectedId = await select({
+        message: 'Choose a Sanity project:',
+        choices: projects.map((project) => ({ name: project.displayName, value: project.id })),
+    });
+    const selected = projects.find(({ id }) => id === selectedId);
+    return selected ? { ok: true, value: selected } : failure('Project not found.');
+}
+export async function chooseDataset(datasets, datasetName, projectName, interactive) {
+    if (datasets.length === 0) {
+        return failure(`No datasets found in ${projectName}.`);
+    }
+    if (datasetName) {
+        const dataset = datasets.find(({ name }) => name === datasetName);
+        return dataset
+            ? { ok: true, value: dataset }
+            : failure(`No dataset "${datasetName}" found in ${projectName}.`);
+    }
+    if (datasets.length === 1)
+        return { ok: true, value: datasets[0] };
+    if (!interactive) {
+        return failure('Multiple datasets found.', ['Pass --dataset <name> to choose one.']);
+    }
+    const production = datasets.find(({ name }) => name === 'production');
+    const orderedDatasets = production
+        ? [production, ...datasets.filter(({ name }) => name !== 'production')]
+        : datasets;
+    const selectedName = await select({
+        message: 'Choose a Sanity dataset:',
+        choices: orderedDatasets.map((dataset) => ({
+            name: dataset.name,
+            value: dataset.name,
+            description: dataset.aclMode,
+        })),
+    });
+    const selected = datasets.find(({ name }) => name === selectedName);
+    return selected ? { ok: true, value: selected } : failure('Dataset not found.');
+}
+export function findProject(groups, projectId) {
+    for (const { organization, projects = [] } of groups) {
+        const project = projects.find(({ id }) => id === projectId);
+        if (project)
+            return { organization, project };
+    }
+    return undefined;
+}
+function failure(message, suggestions) {
+    return { ok: false, error: { message, suggestions } };
+}

package/dist/cores/blueprinit/stack-name.d.ts

@@ -0,0 +1,39 @@
+import type { Logger } from '../../utils/logger.js';
+import type { BlueprinitFlags } from './types.js';
+interface TakenNamesOptions {
+    token: string;
+    organizationId: string;
+    log: Logger;
+}
+/**
+ * Stack names already used in the organization.
+ *
+ * Returns nothing when the listing fails. A token that cannot read Stacks is not a reason
+ * to stop, because the create call reports the same conflict a moment later.
+ */
+export declare function takenStackNames(options: TakenNamesOptions): Promise<Set<string>>;
+interface ChooseStackNameOptions {
+    flags: BlueprinitFlags;
+    interactive: boolean;
+    defaultName: string;
+    taken: Set<string>;
+    log: Logger;
+}
+type ChooseStackNameResult = {
+    ok: true;
+    value: string;
+} | {
+    ok: false;
+    error: string;
+    suggestions: string[];
+};
+/**
+ * A Stack name the organization does not already hold.
+ *
+ * Asks again rather than failing, because the conflict is only visible after `init` has
+ * written every local file.
+ */
+export declare function chooseStackName(options: ChooseStackNameOptions): Promise<ChooseStackNameResult>;
+/** `field-notes-production`, then `field-notes-production-2`, until one is free. */
+export declare function nextFreeName(name: string, taken: Set<string>): string;
+export {};

package/dist/cores/blueprinit/stack-name.js

@@ -0,0 +1,56 @@
+import { listStacks } from '../../actions/blueprints/stacks.js';
+import { warn } from '../../utils/display/presenters.js';
+import { promptForStackName } from './prompts.js';
+/**
+ * Stack names already used in the organization.
+ *
+ * Returns nothing when the listing fails. A token that cannot read Stacks is not a reason
+ * to stop, because the create call reports the same conflict a moment later.
+ */
+export async function takenStackNames(options) {
+    const { token, organizationId, log } = options;
+    const result = await listStacks({ token, scopeType: 'organization', scopeId: organizationId }, log);
+    if (!result.ok) {
+        log.verbose(`Could not list Stacks to check the name: ${result.error}`);
+        return new Set();
+    }
+    return new Set(result.stacks.map(({ name }) => name));
+}
+/**
+ * A Stack name the organization does not already hold.
+ *
+ * Asks again rather than failing, because the conflict is only visible after `init` has
+ * written every local file.
+ */
+export async function chooseStackName(options) {
+    const { flags, interactive, defaultName, taken, log } = options;
+    const suggested = nextFreeName(defaultName, taken);
+    if (suggested !== defaultName) {
+        log(warn(`A Stack named "${defaultName}" already exists. Suggesting "${suggested}".`));
+    }
+    let name = await promptForStackName(flags, interactive, suggested);
+    while (taken.has(name)) {
+        // Only a --stack-name value can be taken here; every other path starts from a free name.
+        if (!interactive || flags.yes || flags.stackName) {
+            return {
+                ok: false,
+                error: `A Stack named "${name}" already exists in this organization.`,
+                suggestions: [`Pass --stack-name with a different value, such as ${suggested}.`],
+            };
+        }
+        log(warn(`A Stack named "${name}" already exists in this organization.`));
+        name = await promptForStackName({}, interactive, nextFreeName(name, taken));
+    }
+    return { ok: true, value: name };
+}
+/** `field-notes-production`, then `field-notes-production-2`, until one is free. */
+export function nextFreeName(name, taken) {
+    if (!taken.has(name))
+        return name;
+    for (let suffix = 2; suffix < 100; suffix += 1) {
+        const candidate = `${name}-${suffix}`;
+        if (!taken.has(candidate))
+            return candidate;
+    }
+    return name;
+}

package/dist/cores/blueprinit/target.d.ts

@@ -0,0 +1,33 @@
+import type { Result } from '../../utils/types.js';
+interface TargetError {
+    message: string;
+    suggestions?: string[];
+}
+export declare function isEmptyDirectory(dir: string): boolean;
+/**
+ * What the directory prompt offers.
+ *
+ * The current directory when it is free, and a new directory named for the project when it
+ * is not, so accepting the default never writes a scaffold beside unrelated files.
+ */
+export declare function defaultTargetPath(dir: string, baseName: string): string;
+/**
+ * Where to scaffold, asked rather than assumed.
+ *
+ * An unattended run keeps the current directory. Relocating a scaffold with nobody watching
+ * would move files a script expects to find where it started.
+ */
+export declare function promptForTargetDirectory(dir: string, baseName: string, interactive: boolean): Promise<string>;
+/**
+ * Resolve the answer against the starting directory and refuse a target that is already
+ * something else: a file, a Blueprint, or a Studio that adoption should handle instead.
+ */
+export declare function resolveTargetDirectory(dir: string, answer: string, bin: string): Result<string, TargetError>;
+/**
+ * The `cd` the printed next steps need, or nothing when the files landed here.
+ *
+ * Measured from the process working directory, not from the flow's starting directory,
+ * because a directory argument moves the target without moving the reader.
+ */
+export declare function relativeTargetPath(target: string, from?: string): string | undefined;
+export {};

package/dist/cores/blueprinit/target.js

@@ -0,0 +1,80 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { isAbsolute, relative, resolve } from 'node:path';
+import { cwd } from 'node:process';
+import { input } from '@inquirer/prompts';
+import { detectStudio } from '../../actions/blueprinit/studio.js';
+import { findBlueprintFile } from '../../actions/blueprints/blueprint.js';
+/** Entries that say nothing about whether a directory is in use. */
+const IGNORED_ENTRIES = new Set(['.git', '.DS_Store']);
+export function isEmptyDirectory(dir) {
+    try {
+        return readdirSync(dir).every((entry) => IGNORED_ENTRIES.has(entry));
+    }
+    catch {
+        // A directory that does not exist yet has nothing to overwrite.
+        return true;
+    }
+}
+/**
+ * What the directory prompt offers.
+ *
+ * The current directory when it is free, and a new directory named for the project when it
+ * is not, so accepting the default never writes a scaffold beside unrelated files.
+ */
+export function defaultTargetPath(dir, baseName) {
+    return isEmptyDirectory(dir) ? '.' : `./${baseName}`;
+}
+/**
+ * Where to scaffold, asked rather than assumed.
+ *
+ * An unattended run keeps the current directory. Relocating a scaffold with nobody watching
+ * would move files a script expects to find where it started.
+ */
+export async function promptForTargetDirectory(dir, baseName, interactive) {
+    if (!interactive)
+        return '.';
+    const fallback = defaultTargetPath(dir, baseName);
+    const answer = await input({ message: 'Where should the files go?', default: fallback });
+    return answer.trim() || fallback;
+}
+/**
+ * Resolve the answer against the starting directory and refuse a target that is already
+ * something else: a file, a Blueprint, or a Studio that adoption should handle instead.
+ */
+export function resolveTargetDirectory(dir, answer, bin) {
+    const target = isAbsolute(answer) ? answer : resolve(dir, answer);
+    if (existsSync(target) && !statSync(target).isDirectory()) {
+        return { ok: false, error: { message: `${answer} is not a directory.` } };
+    }
+    const blueprint = findBlueprintFile(target);
+    if (blueprint) {
+        return {
+            ok: false,
+            error: {
+                message: `A Blueprint already exists in ${answer} (${blueprint.fileName}).`,
+                suggestions: [`Review it with: npx ${bin} blueprints doctor`],
+            },
+        };
+    }
+    const studio = detectStudio(target);
+    if (studio) {
+        return {
+            ok: false,
+            error: {
+                message: `${answer} already holds a Studio (${studio.configFile}).`,
+                suggestions: [`Wrap it in a Blueprint with: npx ${bin} init ${answer}`],
+            },
+        };
+    }
+    return { ok: true, value: target };
+}
+/**
+ * The `cd` the printed next steps need, or nothing when the files landed here.
+ *
+ * Measured from the process working directory, not from the flow's starting directory,
+ * because a directory argument moves the target without moving the reader.
+ */
+export function relativeTargetPath(target, from = cwd()) {
+    const path = relative(from, target);
+    return path === '' ? undefined : path;
+}

package/dist/cores/blueprinit/types.d.ts

@@ -0,0 +1,18 @@
+import type { Logger } from '../../utils/logger.js';
+export interface BlueprinitFlags {
+    yes?: boolean;
+    organizationId?: string;
+    projectId?: string;
+    datasetName?: string;
+    stackName?: string;
+    studioName?: string;
+}
+export interface BlueprinitFlowOptions {
+    bin: string;
+    dir: string;
+    /** True when a directory argument named the target, so the flow must not ask for one. */
+    targetProvided: boolean;
+    flags: BlueprinitFlags;
+    log: Logger;
+    token: string;
+}

package/dist/cores/blueprinit/types.js

@@ -0,0 +1 @@
+export {};

package/dist/cores/blueprinit.d.ts

@@ -0,0 +1,7 @@
+import type { BlueprinitFlags } from './blueprinit/types.js';
+import type { CoreConfig, CoreResult } from './index.js';
+export interface BlueprinitOptions extends CoreConfig {
+    dir?: string;
+    flags?: BlueprinitFlags;
+}
+export declare function blueprinitCore(options: BlueprinitOptions): Promise<CoreResult>;

package/dist/cores/blueprinit.js

@@ -0,0 +1,55 @@
+import { cwd } from 'node:process';
+import { detectStudio } from '../actions/blueprinit/studio.js';
+import { findBlueprintFile } from '../actions/blueprints/blueprint.js';
+import { readConfigFile } from '../actions/blueprints/config.js';
+import { validTokenOrErrorMessage } from '../utils/validated-token.js';
+import { adoptFlow } from './blueprinit/adopt.js';
+import { freshFlow } from './blueprinit/fresh.js';
+export async function blueprinitCore(options) {
+    const { bin, log, flags = {}, dir = cwd() } = options;
+    try {
+        const existingBlueprint = findBlueprintFile(dir);
+        if (existingBlueprint) {
+            const blueprintConfig = readConfigFile(existingBlueprint.blueprintFilePath);
+            if (!blueprintConfig?.stackId) {
+                return {
+                    success: false,
+                    error: `A Blueprint exists here (${existingBlueprint.fileName}), but it is not connected to a Stack.`,
+                    suggestions: [`Finish setup with: npx ${bin} blueprints init`],
+                };
+            }
+            log(`A blueprint already exists here (${existingBlueprint.fileName}).`);
+            log('');
+            log('Use these instead:');
+            log(`  npx ${bin} blueprints config --edit`);
+            log(`  npx ${bin} blueprints doctor`);
+            return {
+                success: true,
+                json: { alreadyInitialized: true, blueprintFile: existingBlueprint.fileName },
+            };
+        }
+        const tokenCheck = await validTokenOrErrorMessage(log);
+        if (!tokenCheck.ok) {
+            return {
+                success: false,
+                error: 'No Sanity session found.',
+                suggestions: ['Sign in first: npx sanity login', 'Then run init again.'],
+            };
+        }
+        log('Setting up your Sanity workspace.');
+        log('');
+        const flowOptions = {
+            bin,
+            dir,
+            targetProvided: Boolean(options.dir),
+            flags,
+            log,
+            token: tokenCheck.value,
+        };
+        const studio = detectStudio(dir);
+        return studio ? await adoptFlow({ ...flowOptions, studio }) : await freshFlow(flowOptions);
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}

package/dist/cores/blueprints/stacks.d.ts

@@ -2,13 +2,18 @@ import type { ScopeType } from '../../utils/types.js';
 import type { CoreConfig, CoreResult } from '../index.js';
 export interface BlueprintStacksOptions extends CoreConfig {
     token: string;
-    /** Scope to list Stacks for, resolved by the base command (flags > env > config). */
-    scopeType: ScopeType;
-    scopeId: string;
+    /**
+     * Scope to list Stacks for, resolved by the base command (flags > env > config).
+     * Prompted for when absent.
+     */
+    scopeType?: ScopeType;
+    scopeId?: string;
     /** Locally-configured Stack ID, used only to highlight the current Stack in listings. */
     localStackId?: string;
     flags: {
+        all?: boolean;
         'include-projects'?: boolean;
+        json?: boolean;
         verbose?: boolean;
     };
 }