@sanity/runtime-cli 17.2.0 → 17.3.0-blueprinit.g6a63623

package/dist/cores/blueprinit/finish.js

@@ -0,0 +1,64 @@
+import { writeConfigFile } from '../../actions/blueprints/config.js';
+import { createEmptyStack } from '../../actions/blueprints/stacks.js';
+import { check } from '../../utils/display/presenters.js';
+export async function createStackAndFinish(options) {
+    let stack;
+    try {
+        stack = await createEmptyStack({
+            token: options.token,
+            scopeType: 'organization',
+            scopeId: options.organizationId,
+            name: options.stackName,
+            logger: options.log,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            success: false,
+            error: `Local files were written, but Stack creation failed: ${message}`,
+            suggestions: [
+                'Resolve the Stack error, then finish setup with:',
+                `npx ${options.bin} blueprints init --organization-id ${options.organizationId} --stack-name ${options.stackName}`,
+            ],
+        };
+    }
+    try {
+        writeConfigFile(options.blueprintFilePath, {
+            organizationId: options.organizationId,
+            stackId: stack.id,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            success: false,
+            error: `Stack ${stack.id} was created, but the local Blueprint config could not be written: ${message}`,
+            suggestions: [
+                'Finish setup with:',
+                `npx ${options.bin} blueprints init --organization-id ${options.organizationId} --stack-id ${stack.id}`,
+            ],
+        };
+    }
+    options.log(check(`Stack ${stack.name} created (org scope)`));
+    options.log('The Stack is empty; Blueprint resources have not been deployed.');
+    options.log('');
+    options.log('Next steps:');
+    for (const step of options.nextSteps)
+        options.log(step);
+    return {
+        success: true,
+        json: {
+            organizationId: options.organizationId,
+            projectId: options.projectId,
+            dataset: options.datasetName,
+            stackId: stack.id,
+            stackName: stack.name,
+            files: [...options.files, '.sanity/blueprint.config.json'],
+        },
+    };
+}
+export function alignSteps(steps) {
+    const width = Math.max(...steps.map(([command]) => command.length));
+    return steps.map(([command, description]) => description ? `  ${command.padEnd(width + 2)}${description}` : `  ${command}`);
+}

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

@@ -0,0 +1,3 @@
+import type { CoreResult } from '../index.js';
+import type { BlueprinitFlowOptions } from './types.js';
+export declare function freshFlow(options: BlueprinitFlowOptions): Promise<CoreResult>;

package/dist/cores/blueprinit/fresh.js

@@ -0,0 +1,108 @@
+import { STARTER_FUNCTION_NAME, slugify } from '../../actions/blueprinit/manifest.js';
+import { scaffoldWorkspace } from '../../actions/blueprinit/workspace.js';
+import { listDatasets } from '../../actions/sanity/datasets.js';
+import { groupProjectsByOrganization } from '../../actions/sanity/projects.js';
+import { check } from '../../utils/display/presenters.js';
+import { getLatestNpmVersion } from '../../utils/external/npmjs.js';
+import { isInteractive } from '../../utils/interactive.js';
+import { alignSteps, createStackAndFinish } from './finish.js';
+import { printBlueprintPreview } from './preview.js';
+import { confirmUnlessSkipped, promptForStudioName } from './prompts.js';
+import { chooseDataset, chooseOrganization, chooseProject } from './selection.js';
+export async function freshFlow(options) {
+    const { bin, dir, flags, log, token } = options;
+    const grouped = await groupProjectsByOrganization({ token, logger: log });
+    if (!grouped.ok) {
+        return { success: false, error: `Could not list organizations: ${grouped.error}` };
+    }
+    const organizationResult = await chooseOrganization(grouped.organizations, flags.organizationId, isInteractive);
+    if (!organizationResult.ok) {
+        return {
+            success: false,
+            error: organizationResult.error.message,
+            suggestions: organizationResult.error.suggestions,
+        };
+    }
+    const { organization, projects = [] } = organizationResult.value;
+    const projectResult = await chooseProject(projects, flags.projectId, organization.name, isInteractive);
+    if (!projectResult.ok) {
+        return {
+            success: false,
+            error: projectResult.error.message,
+            suggestions: projectResult.error.suggestions,
+        };
+    }
+    const project = projectResult.value;
+    const datasets = await listDatasets({ token, projectId: project.id, logger: log });
+    if (!datasets.ok) {
+        return { success: false, error: `Could not list datasets: ${datasets.error}` };
+    }
+    const datasetResult = await chooseDataset(datasets.datasets, flags.datasetName, project.displayName, isInteractive);
+    if (!datasetResult.ok) {
+        return {
+            success: false,
+            error: datasetResult.error.message,
+            suggestions: datasetResult.error.suggestions,
+        };
+    }
+    const dataset = datasetResult.value;
+    log(check(`Org: ${organization.name} (${organization.id})`));
+    log(check(`Project: ${project.displayName} (${project.id}), dataset: ${dataset.name}`));
+    log('');
+    const stackName = flags.stackName
+        ? slugify(flags.stackName) || project.id
+        : slugify(project.displayName) || project.id;
+    const studioName = await promptForStudioName(flags, isInteractive);
+    printBlueprintPreview({
+        log,
+        organizationName: organization.name,
+        projectId: project.id,
+        projectName: project.displayName,
+        datasetName: dataset.name,
+        studioName,
+        studioSource: `studios/${studioName}`,
+        stackName,
+        functionName: STARTER_FUNCTION_NAME,
+    });
+    log('Files to write:');
+    log('  + sanity.blueprint.ts             project + dataset (attached), studio, function');
+    log(`  + ${`studios/${studioName}/`.padEnd(32)}Studio with a "post" type`);
+    log(`  + ${`functions/${STARTER_FUNCTION_NAME}/`.padEnd(32)}sets a post slug from its title`);
+    log(`  + .sanity/blueprint.config.json   org scope, stack ${stackName}`);
+    log('  + .gitignore');
+    log('  + package.json');
+    log('');
+    const confirmed = await confirmUnlessSkipped(flags, isInteractive, `Create this Blueprint workspace for "${project.displayName}"?`);
+    if (!confirmed)
+        return { success: false, error: 'Initialization cancelled.' };
+    const scaffold = scaffoldWorkspace({
+        dir,
+        projectId: project.id,
+        displayName: project.displayName,
+        datasetName: dataset.name,
+        stackName,
+        studioName,
+        blueprintsVersion: await getLatestNpmVersion('@sanity/blueprints', log),
+    });
+    return await createStackAndFinish({
+        ...options,
+        organizationId: organization.id,
+        projectId: project.id,
+        datasetName: dataset.name,
+        stackName,
+        blueprintFilePath: scaffold.blueprintFilePath,
+        files: scaffold.files,
+        nextSteps: [
+            ...alignSteps([
+                ['npm install'],
+                [`npm run dev -w studios/${studioName}`, 'open the Studio and add a post'],
+                [`npx ${bin} blueprints plan`, 'preview the deployment'],
+                [`npx ${bin} blueprints deploy`, 'deploy the resources'],
+            ]),
+            '',
+            'Test the function on that post:',
+            `  npx ${bin} functions test ${STARTER_FUNCTION_NAME} --document-id <id>` +
+                ` --project-id ${project.id} --dataset ${dataset.name} --with-user-token`,
+        ],
+    });
+}

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

@@ -0,0 +1,14 @@
+import type { Logger } from '../../utils/logger.js';
+interface BlueprintPreviewOptions {
+    log: Logger;
+    organizationName: string;
+    projectId: string;
+    projectName: string;
+    datasetName: string;
+    studioName: string;
+    studioSource: string;
+    stackName: string;
+    functionName?: string;
+}
+export declare function printBlueprintPreview(options: BlueprintPreviewOptions): void;
+export {};

package/dist/cores/blueprinit/preview.js

@@ -0,0 +1,13 @@
+export function printBlueprintPreview(options) {
+    options.log('Blueprint plan:');
+    options.log(`  attach  Project ${options.projectName} (${options.projectId}) on deploy; retain on Stack removal`);
+    options.log(`  attach  Dataset ${options.datasetName} on deploy; retain on Stack removal`);
+    options.log(`  create  Studio ${options.studioName} from ${options.studioSource} on deploy`);
+    if (options.functionName) {
+        options.log(`  create  Function ${options.functionName} on deploy`);
+    }
+    options.log('');
+    options.log('Remote action now:');
+    options.log(`  create  Stack ${options.stackName} in ${options.organizationName} (empty, organization scope)`);
+    options.log('');
+}

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

@@ -0,0 +1,4 @@
+import type { BlueprinitFlags } from './types.js';
+export declare const DEFAULT_STUDIO_NAME = "studio";
+export declare function confirmUnlessSkipped(flags: BlueprinitFlags, interactive: boolean, message: string): Promise<boolean>;
+export declare function promptForStudioName(flags: BlueprinitFlags, interactive: boolean): Promise<string>;

package/dist/cores/blueprinit/prompts.js

@@ -0,0 +1,16 @@
+import { confirm, input } from '@inquirer/prompts';
+import { slugify } from '../../actions/blueprinit/manifest.js';
+export const DEFAULT_STUDIO_NAME = 'studio';
+export async function confirmUnlessSkipped(flags, interactive, message) {
+    if (flags.yes || !interactive)
+        return true;
+    return await confirm({ message, default: true });
+}
+export async function promptForStudioName(flags, interactive) {
+    if (flags.studioName)
+        return slugify(flags.studioName) || DEFAULT_STUDIO_NAME;
+    if (flags.yes || !interactive)
+        return DEFAULT_STUDIO_NAME;
+    const answer = await input({ message: 'Name your studio?', default: DEFAULT_STUDIO_NAME });
+    return slugify(answer) || DEFAULT_STUDIO_NAME;
+}

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

@@ -0,0 +1,15 @@
+import type { Dataset } from '../../actions/sanity/datasets.js';
+import type { GroupedProjects, Project } from '../../actions/sanity/projects.js';
+import type { Result } from '../../utils/types.js';
+interface SelectionError {
+    message: string;
+    suggestions?: string[];
+}
+export declare function chooseOrganization(groups: GroupedProjects[], organizationId: string | undefined, interactive: boolean): Promise<Result<GroupedProjects, SelectionError>>;
+export declare function chooseProject(projects: Project[], projectId: string | undefined, organizationName: string, interactive: boolean): Promise<Result<Project, SelectionError>>;
+export declare function chooseDataset(datasets: Dataset[], datasetName: string | undefined, projectName: string, interactive: boolean): Promise<Result<Dataset, SelectionError>>;
+export declare function findProject(groups: GroupedProjects[], projectId: string): {
+    organization: GroupedProjects['organization'];
+    project: Project;
+} | undefined;
+export {};

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/types.d.ts

@@ -0,0 +1,16 @@
+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;
+    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,48 @@
+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 blueprinit again.'],
+            };
+        }
+        log('Setting up your Sanity workspace.');
+        log('');
+        const flowOptions = { bin, 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/deploy.js

@@ -1,5 +1,5 @@
 import { dirname } from 'node:path';
-import { stashAsset } from '../../actions/blueprints/assets.js';
+import { preDeploy } from '../../actions/blueprints/pre-deploy.js';
 import { getStack, updateStack } from '../../actions/blueprints/stacks.js';
 import { waitForOperation } from '../../actions/blueprints/wait-for-operation.js';
 import { checkUserPermission } from '../../actions/sanity/access.js';
@@ -7,12 +7,7 @@ import { createHintCollector } from '../../utils/blueprints/hints.js';
 import { niceId } from '../../utils/display/presenters.js';
 import { CODE_OPERATION_UNCONFIRMED, EXIT_OPERATION_UNCONFIRMED } from '../../utils/exit-codes.js';
 import { styleText } from '../../utils/style-text.js';
-import { isAssetResource } from '../../utils/types.js';
 import { getWarnings } from '../../utils/warnings.js';
-const DEFAULT_ASSET_TIMEOUT = 60;
-const assetTimeoutS = Number(process.env.SANITY_ASSET_TIMEOUT) || DEFAULT_ASSET_TIMEOUT;
-const assetTimeoutMs = assetTimeoutS * 1000;
-const warnTimeoutMs = assetTimeoutMs / 2;
 export async function blueprintDeployCore(options) {
     const { bin = 'sanity', log, auth, stackId, scopeType, scopeId, deployedStack, blueprint, flags, } = options;
     const { verbose } = flags;
@@ -39,17 +34,21 @@ export async function blueprintDeployCore(options) {
             };
         }
         const resources = [...blueprint.resources];
-        const assetResources = resources.filter(isAssetResource);
-        if (assetResources.length > 0) {
-            log('Processing assets...');
-            for (const resource of assetResources) {
-                const preDeployResult = await preDeploy(resource, { auth, blueprintFileDir, installer, log });
-                if (!preDeployResult.success)
-                    return preDeployResult;
-                const idx = resources.indexOf(resource);
-                if (idx !== -1)
-                    resources[idx] = preDeployResult.resource;
-            }
+        const preDeployResult = await preDeploy({
+            scopeType,
+            scopeId,
+            resources,
+            stackId,
+            stackName,
+            auth,
+            blueprintFileDir,
+            installer,
+            log,
+            bin,
+            verbose,
+        });
+        if (!preDeployResult?.success) {
+            return preDeployResult;
         }
         const spinner = log.ora('Deploying...').start();
         const { ok: deployOk, stack, error: deployError, } = await updateStack({
@@ -152,53 +151,6 @@ export async function blueprintDeployCore(options) {
         return { success: false, error: errorMessage };
     }
 }
-async function preDeploy(resource, options) {
-    const { auth, blueprintFileDir, installer, log } = options;
-    const fnSpinner = log.ora({ text: `Processing ${resource.name}...`, prefixText: ' ' }).start();
-    const warnTimer = setTimeout(() => {
-        fnSpinner.text = `Still processing ${resource.name}, this can take a moment...`;
-    }, warnTimeoutMs);
-    let assetTimeoutTimer;
-    let result;
-    try {
-        result = await Promise.race([
-            stashAsset({ resource, blueprintFileDir, auth, logger: log, installer }),
-            new Promise((_, reject) => {
-                assetTimeoutTimer = setTimeout(() => {
-                    reject(new Error(`Processing ${resource.name} timed out after ${assetTimeoutS}s`));
-                }, assetTimeoutMs);
-            }),
-        ]);
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        fnSpinner.fail(msg);
-        return { success: false, error: msg };
-    }
-    finally {
-        clearTimeout(warnTimer);
-        clearTimeout(assetTimeoutTimer);
-    }
-    if (result.success && result.assetId) {
-        const updatedResource = { ...resource, src: result.assetId };
-        fnSpinner.succeed(`${updatedResource.name} ${niceId(result.assetId)}`);
-        log(`   Source: ${updatedResource.src}`);
-        if (result.hash) {
-            if (result.hash.length > 24) {
-                log.verbose(`   Hash: ${result.hash.slice(0, 8)}...${result.hash.slice(-12)}`);
-            }
-            else {
-                log.verbose(`   Hash: ${result.hash}`);
-            }
-        }
-        if (result.exists)
-            log.verbose('   Asset unchanged');
-        return { success: true, resource: updatedResource };
-    }
-    const errorMsg = `Failed uploading ${resource.name} asset, deploy has stopped`;
-    fnSpinner.fail(errorMsg);
-    return { success: false, error: result.error || 'Failed to process asset' };
-}
 const CHECK_LEGACY_DEPLOY_PERMISSION = false;
 const BLUEPRINTS_PERMISSION_ENFORCEMENT_DATE = 'July 1, 2026';
 async function checkLegacyDeployPermission({ auth, scopeType, scopeId, log, }) {

package/dist/server/static/vendor/vendor.bundle.js

@@ -27598,25 +27598,21 @@ function prettyBytes(number, options) {
 	}
 
 	const localeOptions = buildLocaleOptions(options);
-	let result;
 
-	if (number < 1) {
-		const numberString = toLocaleString(number, options.locale, localeOptions);
-		result = prefix + numberString + separator + UNITS[0];
-	} else {
-		const exponent = Math.min(Math.floor(options.binary ? log(number) / Math.log(1024) : log10(number) / 3), UNITS.length - 1);
-		number = divide(number, (options.binary ? 1024 : 1000) ** exponent);
+	let exponent = 0;
+	if (number >= 1) {
+		exponent = Math.min(Math.floor(options.binary ? log(number) / Math.log(1024) : log10(number) / 3), UNITS.length - 1);
+	}
 
-		if (!localeOptions) {
-			const minPrecision = Math.max(3, Math.floor(number).toString().length);
-			number = number.toPrecision(minPrecision);
-		}
+	number = divide(number, (options.binary ? 1024 : 1000) ** exponent);
 
-		const numberString = toLocaleString(Number(number), options.locale, localeOptions);
-		const unit = UNITS[exponent];
-		result = prefix + numberString + separator + unit;
+	if (!localeOptions) {
+		const minPrecision = Math.max(3, Math.floor(number).toString().length);
+		number = Number(number.toPrecision(minPrecision));
 	}
 
+	const numberString = toLocaleString(number, options.locale, localeOptions);
+	const result = prefix + numberString + separator + UNITS[exponent];
 	return applyFixedWidth(result, options.fixedWidth);
 }