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

package/dist/actions/blueprinit/workspace.js

@@ -0,0 +1,146 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, posix } from 'node:path';
+import { renderBlueprint, STARTER_FUNCTION_NAME } from './manifest.js';
+import { FUNCTION_SET_SLUG, functionPackageJson, renderStudioCliConfig, renderStudioConfig, STUDIO_POST_TYPE, STUDIO_SCHEMA_TYPES, STUDIO_TSCONFIG, studioPackageJson, } from './templates.js';
+const GITIGNORE_ENTRY = '# Sanity Blueprints\n.sanity/';
+const DEFAULT_GITIGNORE = `node_modules
+.env
+
+${GITIGNORE_ENTRY}
+`;
+export function scaffoldWorkspace(options) {
+    const { dir, studioName, studioVersions } = options;
+    assertTargetsAvailable(dir, [
+        posix.join('studios', studioName),
+        posix.join('functions', STARTER_FUNCTION_NAME),
+    ]);
+    const packageJson = preparePackageJson(options, ['studios/*', 'functions/*']);
+    const files = [];
+    const write = createWriter(dir, files);
+    const blueprintFilePath = write('sanity.blueprint.ts', renderBlueprint({
+        ...manifestOptions(options),
+        studioSrc: `./studios/${studioName}`,
+        withFunction: true,
+    }));
+    write(posix.join('studios', studioName, 'package.json'), formatJson(studioPackageJson(studioName, studioVersions)));
+    write(posix.join('studios', studioName, 'tsconfig.json'), formatJson(STUDIO_TSCONFIG));
+    write(posix.join('studios', studioName, 'sanity.config.ts'), renderStudioConfig(options));
+    write(posix.join('studios', studioName, 'sanity.cli.ts'), renderStudioCliConfig(options));
+    write(posix.join('studios', studioName, 'schemaTypes', 'index.ts'), STUDIO_SCHEMA_TYPES);
+    write(posix.join('studios', studioName, 'schemaTypes', 'post.ts'), STUDIO_POST_TYPE);
+    write(posix.join('studios', studioName, 'static', '.gitkeep'), '');
+    write(posix.join('functions', STARTER_FUNCTION_NAME, 'package.json'), formatJson(functionPackageJson(STARTER_FUNCTION_NAME)));
+    write(posix.join('functions', STARTER_FUNCTION_NAME, 'index.ts'), FUNCTION_SET_SLUG);
+    writePreparedRootFiles(dir, packageJson, files);
+    return { blueprintFilePath, files };
+}
+export function adoptWorkspace(options) {
+    const { dir } = options;
+    const packageJson = preparePackageJson(options, []);
+    const files = [];
+    const write = createWriter(dir, files);
+    const blueprintFilePath = write('sanity.blueprint.ts', renderBlueprint({ ...manifestOptions(options), studioSrc: '.', withFunction: false }));
+    writePreparedRootFiles(dir, packageJson, files);
+    return { blueprintFilePath, files };
+}
+function manifestOptions(options) {
+    return {
+        projectName: options.projectName,
+        displayName: options.displayName,
+        projectId: options.projectId,
+        datasetName: options.datasetName,
+        studioName: options.studioName,
+        studioSlug: options.studioSlug,
+        studioOrigin: options.studioOrigin,
+    };
+}
+function assertTargetsAvailable(dir, paths) {
+    const conflicts = paths.filter((path) => existsSync(join(dir, path)));
+    if (conflicts.length > 0) {
+        throw new Error(`Refusing to overwrite existing paths: ${conflicts.join(', ')}`);
+    }
+}
+function createWriter(dir, files) {
+    return (relativePath, content) => {
+        const filePath = join(dir, relativePath);
+        mkdirSync(dirname(filePath), { recursive: true });
+        writeFileSync(filePath, content);
+        files.push(relativePath);
+        return filePath;
+    };
+}
+function writePreparedRootFiles(dir, packageJson, files) {
+    if (writeGitignore(dir))
+        files.push('.gitignore');
+    writeFileSync(join(dir, 'package.json'), formatJson(packageJson));
+    files.push('package.json');
+}
+function writeGitignore(dir) {
+    const filePath = join(dir, '.gitignore');
+    if (!existsSync(filePath)) {
+        writeFileSync(filePath, DEFAULT_GITIGNORE);
+        return true;
+    }
+    const existing = readFileSync(filePath, 'utf8');
+    if (existing.split(/\r?\n/).some((line) => line.trim() === '.sanity/'))
+        return false;
+    writeFileSync(filePath, `${existing.trimEnd()}\n\n${GITIGNORE_ENTRY}\n`);
+    return true;
+}
+function preparePackageJson(options, requiredWorkspaces) {
+    const filePath = join(options.dir, 'package.json');
+    const parsed = existsSync(filePath)
+        ? JSON.parse(readFileSync(filePath, 'utf8'))
+        : {
+            name: options.stackName,
+            version: '0.1.0',
+            private: true,
+            type: 'module',
+        };
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('The existing package.json must contain a JSON object.');
+    }
+    const packageJson = parsed;
+    addWorkspaces(packageJson, requiredWorkspaces);
+    addBlueprintsDependency(packageJson, options.blueprintsVersion);
+    return packageJson;
+}
+function addWorkspaces(packageJson, required) {
+    if (required.length === 0)
+        return;
+    if (!packageJson.workspaces) {
+        packageJson.workspaces = required;
+        return;
+    }
+    if (Array.isArray(packageJson.workspaces)) {
+        packageJson.workspaces = [...new Set([...packageJson.workspaces, ...required])];
+        return;
+    }
+    if (!packageJson.workspaces || typeof packageJson.workspaces !== 'object') {
+        throw new Error('Cannot add generated packages to the existing package.json workspaces.');
+    }
+    const workspaces = packageJson.workspaces;
+    if (Array.isArray(workspaces.packages)) {
+        workspaces.packages = [...new Set([...workspaces.packages, ...required])];
+        return;
+    }
+    throw new Error('Cannot add generated packages to the existing package.json workspaces.');
+}
+function addBlueprintsDependency(packageJson, blueprintsVersion) {
+    const dependencies = recordOrEmpty(packageJson.dependencies);
+    const devDependencies = recordOrEmpty(packageJson.devDependencies);
+    if (dependencies['@sanity/blueprints'] || devDependencies['@sanity/blueprints'])
+        return;
+    packageJson.devDependencies = {
+        ...devDependencies,
+        '@sanity/blueprints': blueprintsVersion,
+    };
+}
+function recordOrEmpty(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+function formatJson(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}

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

@@ -6,10 +6,12 @@ type ListStacksResponse = {
     ok: true;
     error: null;
     stacks: StackSummary[];
+    response?: Response;
 } | {
     ok: false;
     error: string;
     stacks?: unknown;
+    response?: Response;
 };
 export declare function listStacks(auth: AuthParams, logger: Logger): Promise<ListStacksResponse>;
 type GetStackResponse = {

package/dist/actions/blueprints/stacks.js

@@ -14,6 +14,7 @@ export async function listStacks(auth, logger) {
             ok: response.ok,
             error: response.ok ? null : data.message,
             stacks: data,
+            response,
         };
     }
     catch (error) {

package/dist/actions/sanity/datasets.d.ts

@@ -0,0 +1,15 @@
+import type { Logger } from '../../utils/logger.js';
+import type { ActionResponse } from '../../utils/types.js';
+export interface Dataset {
+    name: string;
+    aclMode: string;
+}
+interface ListDatasetsResponse extends ActionResponse {
+    datasets: Dataset[];
+}
+export declare function listDatasets({ token, projectId, logger, }: {
+    token: string;
+    projectId: string;
+    logger: Logger;
+}): Promise<ListDatasetsResponse>;
+export {};

package/dist/actions/sanity/datasets.js

@@ -0,0 +1,26 @@
+import { createTracedFetch } from '../../utils/traced-fetch.js';
+import { projectsApiPath } from './projects.js';
+export async function listDatasets({ token, projectId, logger, }) {
+    const fetchFn = createTracedFetch(logger);
+    const url = `${projectsApiPath}/${encodeURIComponent(projectId)}/datasets`;
+    const response = await fetchFn(url, {
+        method: 'GET',
+        headers: {
+            Authorization: `Bearer ${token}`,
+            'Content-Type': 'application/json',
+        },
+    });
+    const body = await response.json();
+    if (!response.ok) {
+        return {
+            ok: false,
+            error: body.error?.message ?? response.statusText,
+            datasets: [],
+        };
+    }
+    return {
+        ok: true,
+        error: null,
+        datasets: body,
+    };
+}

package/dist/actions/sanity/projects.d.ts

@@ -22,6 +22,17 @@ export declare function listProjects({ token, organizationId, logger, }: {
     organizationId?: string;
     logger: Logger;
 }): Promise<ListProjectsResponse>;
+export interface Organization {
+    id: string;
+    name: string;
+}
+interface ListOrganizationsResponse extends ActionResponse {
+    organizations: Organization[];
+}
+export declare function listOrganizations({ token, logger, }: {
+    token: string;
+    logger: Logger;
+}): Promise<ListOrganizationsResponse>;
 interface GroupedProjectsByOrganizationResponse extends ActionResponse {
     organizations: GroupedProjects[];
 }

package/dist/actions/sanity/projects.js

@@ -8,22 +8,52 @@ export async function listProjects({ token, organizationId, logger, }) {
     const url = organizationId
         ? `${projectsApiPath}?organizationId=${encodeURIComponent(organizationId)}`
         : projectsApiPath;
-    const projectsFetch = await fetchFn(url, {
-        method: 'GET',
-        headers: {
-            Authorization: `Bearer ${token}`,
-            'Content-Type': 'application/json',
-        },
-    });
-    const projects = await projectsFetch.json();
-    return {
-        ok: projectsFetch.ok,
-        error: projectsFetch.ok ? null : projects.error?.message,
-        projects,
-    };
+    try {
+        const projectsFetch = await fetchFn(url, {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        const projects = await projectsFetch.json();
+        return {
+            ok: projectsFetch.ok,
+            error: projectsFetch.ok ? null : projects.error?.message,
+            projects,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+            projects: [],
+        };
+    }
 }
-export async function groupProjectsByOrganization({ token, logger, }) {
+export async function listOrganizations({ token, logger, }) {
     const fetchFn = createTracedFetch(logger);
+    try {
+        const response = await fetchFn(orgsApiPath, {
+            method: 'GET',
+            headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+        });
+        const organizations = await response.json();
+        return {
+            ok: response.ok,
+            error: response.ok ? null : organizations.error?.message,
+            organizations,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+            organizations: [],
+        };
+    }
+}
+export async function groupProjectsByOrganization({ token, logger, }) {
     const projectsResponse = await listProjects({ token, logger });
     if (!projectsResponse.ok) {
         return {
@@ -32,19 +62,15 @@ export async function groupProjectsByOrganization({ token, logger, }) {
             organizations: [],
         };
     }
-    const orgsFetch = await fetchFn(orgsApiPath, {
-        method: 'GET',
-        headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
-    });
-    if (!orgsFetch.ok) {
+    const orgsResponse = await listOrganizations({ token, logger });
+    if (!orgsResponse.ok) {
         return {
             ok: false,
-            error: orgsFetch.statusText,
+            error: orgsResponse.error,
             organizations: [],
         };
     }
-    const organizations = await orgsFetch.json();
-    const orgsWithProjects = organizations.map(({ name, id }) => {
+    const orgsWithProjects = orgsResponse.organizations.map(({ name, id }) => {
         const projects = projectsResponse.projects.filter((project) => project.organizationId === id);
         return { organization: { name, id }, projects };
     });

package/dist/baseCommands.d.ts

@@ -131,6 +131,12 @@ export declare abstract class ResolvedCommand<T extends typeof Command> extends
      * populated regardless of `needs` and is never required
      */
     protected resolvedStackId?: string;
+    /**
+     * locally-resolved scope (flags > env > module > config)
+     * populated regardless of `needs` and is never required
+     */
+    protected resolvedScopeType?: ScopeType;
+    protected resolvedScopeId?: string;
     /**
      * the located `.sanity/blueprint.config.json` (if any), populated regardless of
      * `needs`. Lets commands read/update local config without requiring a manifest.

package/dist/baseCommands.js

@@ -213,6 +213,12 @@ export class ResolvedCommand extends RuntimeCommand {
      * populated regardless of `needs` and is never required
      */
     resolvedStackId;
+    /**
+     * locally-resolved scope (flags > env > module > config)
+     * populated regardless of `needs` and is never required
+     */
+    resolvedScopeType;
+    resolvedScopeId;
     /**
      * the located `.sanity/blueprint.config.json` (if any), populated regardless of
      * `needs`. Lets commands read/update local config without requiring a manifest.
@@ -308,8 +314,10 @@ export class ResolvedCommand extends RuntimeCommand {
                 // assumption was wrong; leave stackId undefined
             }
         }
-        // Expose the resolved Stack ID regardless of `needs` (optional, for listings/highlighting)
+        // Expose the resolved Stack ID and scope regardless of `needs` (optional, for listings/highlighting)
         this.resolvedStackId = resolved.stackId;
+        this.resolvedScopeType = resolved.scopeType;
+        this.resolvedScopeId = resolved.scopeId;
         // Backfill resolved IDs onto the blueprint result if it was loaded
         if (this.blueprint) {
             Object.assign(this.blueprint, {

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

@@ -1,6 +1,6 @@
 import { ResolvedCommand } from '../../baseCommands.js';
 export default class StacksCommand extends ResolvedCommand<typeof StacksCommand> {
-    static needs: readonly ['scope'];
+    static needs: readonly ['token'];
     static summary: string;
     static description: string;
     static examples: string[];
@@ -8,6 +8,7 @@ export default class StacksCommand extends ResolvedCommand<typeof StacksCommand>
         'project-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'organization-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'include-projects': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<Record<string, unknown> | undefined>;
 }

package/dist/commands/blueprints/stacks.js

@@ -3,15 +3,16 @@ import { organizationIdFlagConfig, projectIdFlagConfig, ResolvedCommand } from '
 import { blueprintStacksCore } from '../../cores/blueprints/stacks.js';
 import { Logger } from '../../utils/logger.js';
 export default class StacksCommand extends ResolvedCommand {
-    static needs = ['scope'];
+    static needs = ['token'];
     static summary = 'List remote Stack deployments for your project or organization';
     static description = `Shows all Stacks associated with a project or organization. By default, lists Stacks scoped to the local Blueprint.
 
 Use this to discover existing Stacks you can scope a local Blueprint to (using 'blueprints config --edit'), or to audit what's deployed across your project.
 
-Use --include-projects with --organization-id to also list Stacks from all projects within the organization.`;
+Without a scope, prompts for an organization or project. Use --all to list Stacks across every organization and project you can access, or --include-projects with --organization-id for one organization and its projects.`;
     static examples = [
         '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --all',
         '<%= config.bin %> <%= command.id %> --project-id <projectId>',
         '<%= config.bin %> <%= command.id %> --organization-id <organizationId>',
         '<%= config.bin %> <%= command.id %> --organization-id <organizationId> --include-projects',
@@ -19,21 +20,28 @@ Use --include-projects with --organization-id to also list Stacks from all proje
     static flags = {
         'project-id': Flags.string({
             ...projectIdFlagConfig,
-            exclusive: ['organization-id', 'include-projects'],
+            exclusive: ['organization-id', 'include-projects', 'all'],
+        }),
+        'organization-id': Flags.string({
+            ...organizationIdFlagConfig,
+            exclusive: ['project-id', 'all'],
         }),
-        'organization-id': Flags.string({ ...organizationIdFlagConfig }),
         'include-projects': Flags.boolean({
             description: 'Include Stacks from all projects within the organization. Requires --organization-id.',
             dependsOn: ['organization-id'],
         }),
+        all: Flags.boolean({
+            description: 'List Stacks from every organization and project you have access to',
+            exclusive: ['project-id', 'organization-id', 'include-projects'],
+        }),
     };
     async run() {
         const result = await blueprintStacksCore({
             bin: this.config.bin,
             log: Logger(this.log.bind(this), this.flags),
             token: this.sanityToken,
-            scopeType: this.scopeType,
-            scopeId: this.scopeId,
+            scopeType: this.resolvedScopeType,
+            scopeId: this.resolvedScopeId,
             localStackId: this.resolvedStackId,
             flags: this.flags,
         });

package/dist/commands/init.d.ts

@@ -0,0 +1,20 @@
+import { RuntimeCommand } from '../baseCommands.js';
+export default class InitCommand extends RuntimeCommand<typeof InitCommand> {
+    static hidden: boolean;
+    static summary: string;
+    static description: string;
+    static examples: string[];
+    static args: {
+        directory: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        llms: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'organization-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'project-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        dataset: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'stack-name': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'studio-name': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<Record<string, unknown> | undefined>;
+}

package/dist/commands/init.js

@@ -0,0 +1,72 @@
+import { resolve } from 'node:path';
+import { Args, Flags } from '@oclif/core';
+import { llmsFlagConfig } from '@sanity-labs/oclif-plugin-skills-flag';
+import { RuntimeCommand } from '../baseCommands.js';
+import { blueprinitCore } from '../cores/blueprinit.js';
+import { playIntro } from '../utils/display/intro.js';
+import { Logger } from '../utils/logger.js';
+export default class InitCommand extends RuntimeCommand {
+    static hidden = true;
+    static summary = 'Experimental blueprints-first project init';
+    static description = `Scaffolds a Blueprint, Studio, and starter function around an existing Sanity project.
+
+Pass a directory to scaffold into it. Without one, an interactive run asks where the files go.
+
+This hidden command is an experiment; its interface and generated files are not stable.`;
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> ./my-workspace',
+        '<%= config.bin %> <%= command.id %> --yes',
+        '<%= config.bin %> <%= command.id %> --project-id <id> --dataset <name> --yes',
+    ];
+    static args = {
+        directory: Args.string({
+            description: 'Directory to initialize. Interactive runs are asked for one instead.',
+            required: false,
+        }),
+    };
+    static flags = {
+        llms: Flags.boolean(llmsFlagConfig),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Skip confirmation prompts',
+            default: false,
+        }),
+        'organization-id': Flags.string({
+            description: 'Organization to use when the account has several',
+            aliases: ['organization', 'organizationId', 'org'],
+        }),
+        'project-id': Flags.string({
+            description: 'Project to use when the organization has several',
+            aliases: ['project', 'projectId'],
+        }),
+        dataset: Flags.string({
+            description: 'Dataset to attach',
+        }),
+        'stack-name': Flags.string({
+            description: 'Name for the new organization-scoped Stack, and the hosted Studio slug',
+        }),
+        'studio-name': Flags.string({
+            description: 'Blueprint-local name for the Studio resource and its directory',
+        }),
+    };
+    async run() {
+        await playIntro({ json: this.jsonEnabled() });
+        const result = await blueprinitCore({
+            bin: this.config.bin,
+            dir: this.args.directory ? resolve(this.args.directory) : undefined,
+            log: Logger(this.log.bind(this), this.flags),
+            flags: {
+                yes: this.flags.yes,
+                organizationId: this.flags['organization-id'],
+                projectId: this.flags['project-id'],
+                datasetName: this.flags.dataset,
+                stackName: this.flags['stack-name'],
+                studioName: this.flags['studio-name'],
+            },
+        });
+        if (!result.success)
+            this.coreError(result);
+        return result.json;
+    }
+}

package/dist/constants.d.ts

@@ -1,3 +1,4 @@
+import type { DurableStepPhase } from './utils/types.js';
 export declare const SANITY_ACCESS_ROLE = "sanity.access.role";
 export declare const SANITY_ACCESS_ROBOT = "sanity.access.robot";
 export declare const SANITY_FUNCTION_PREFIX = "sanity.function.";
@@ -50,3 +51,4 @@ export declare const LABEL_PUBSUB = "PubSub";
 export declare const LABEL_SCHEDULED = "Scheduled";
 export declare const LABEL_SYNC_TAG_INVALIDATE = "Sync Tag Invalidate";
 export declare const CI_SETUP_DOCS_URL = "https://www.sanity.io/docs/blueprints/deploy-blueprints-from-ci";
+export declare const STEP_PHASE_GLYPH: Record<DurableStepPhase, string>;

package/dist/constants.js

@@ -56,3 +56,8 @@ export const LABEL_PUBSUB = 'PubSub';
 export const LABEL_SCHEDULED = 'Scheduled';
 export const LABEL_SYNC_TAG_INVALIDATE = 'Sync Tag Invalidate';
 export const CI_SETUP_DOCS_URL = 'https://www.sanity.io/docs/blueprints/deploy-blueprints-from-ci';
+export const STEP_PHASE_GLYPH = {
+    start: '▶',
+    complete: '✔',
+    error: '✖',
+};

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

@@ -0,0 +1,6 @@
+import type { DetectedStudio } from '../../actions/blueprinit/studio.js';
+import type { CoreResult } from '../index.js';
+import type { BlueprinitFlowOptions } from './types.js';
+export declare function adoptFlow(options: BlueprinitFlowOptions & {
+    studio: DetectedStudio;
+}): Promise<CoreResult>;