@sanity/cli 6.0.0-alpha.4 → 6.0.0-alpha.6

package/dist/commands/init.js

@@ -1,20 +1,25 @@
 // @Todo will remove by time migration of this command is complete
 /* eslint-disable @typescript-eslint/no-unused-vars */ import { Args, Flags } from '@oclif/core';
+import { CLIError } from '@oclif/core/errors';
 import { getCliToken, SanityCommand, subdebug } from '@sanity/cli-core';
-import { confirm, input, logSymbols, select, spinner } from '@sanity/cli-core/ux';
+import { chalk, confirm, input, logSymbols, select, Separator, spinner } from '@sanity/cli-core/ux';
 import { isHttpError } from '@sanity/client';
 import { frameworks } from '@vercel/frameworks';
 import { detectFrameworkRecord, LocalFileSystemDetector } from '@vercel/fs-detectors';
 import { getProviderName } from '../actions/auth/getProviderName.js';
 import { login } from '../actions/auth/login/login.js';
+import { createDataset } from '../actions/dataset/create.js';
 import { determineAppTemplate } from '../actions/init/determineAppTemplate.js';
 import { checkIsRemoteTemplate, getGitHubRepoInfo } from '../actions/init/remoteTemplate.js';
 import { getOrganizationChoices } from '../actions/organizations/getOrganizationChoices.js';
 import { getOrganizationsWithAttachGrantInfo } from '../actions/organizations/getOrganizationsWithAttachGrantInfo.js';
-import { createDataset } from '../services/datasets.js';
+import { hasProjectAttachGrant } from '../actions/organizations/hasProjectAttachGrant.js';
+import { promptForDatasetName } from '../prompts/promptForDatasetName.js';
+import { createDataset as createDatasetService, listDatasets } from '../services/datasets.js';
+import { getProjectFeatures } from '../services/getProjectFeatures.js';
 import { createOrganization, listOrganizations } from '../services/organizations.js';
 import { getPlanId, getPlanIdFromCoupon } from '../services/plans.js';
-import { createProject } from '../services/projects.js';
+import { createProject, listProjects } from '../services/projects.js';
 import { getCliUser } from '../services/user.js';
 const debug = subdebug('init');
 export class InitCommand extends SanityCommand {
@@ -85,7 +90,7 @@ export class InitCommand extends SanityCommand {
             helpValue: '<filename>',
             parse: async (input)=>{
                 if (!input.startsWith('.env')) {
-                    throw new Error('Env filename (`--env`) must start with `.env`');
+                    throw new CLIError('Env filename (`--env`) must start with `.env`');
                 }
                 return input;
             }
@@ -249,12 +254,14 @@ export class InitCommand extends SanityCommand {
         }
         // Oclif doesn't support custom exclusive error messaging
         if (this.flags.project && this.flags.organization) {
-            throw new Error('You have specified both a project and an organization. To move a project to an organization please visit https://www.sanity.io/manage');
+            this.error('You have specified both a project and an organization. To move a project to an organization please visit https://www.sanity.io/manage', {
+                exit: 1
+            });
         }
         const defaultConfig = this.flags['dataset-default'];
-        let _showDefaultConfigPrompt = !defaultConfig;
+        let showDefaultConfigPrompt = !defaultConfig;
         if (this.flags.dataset || this.flags.visibility || this.flags['dataset-default'] || this.isUnattended()) {
-            _showDefaultConfigPrompt = false;
+            showDefaultConfigPrompt = false;
         }
         const detectedFramework = await detectFrameworkRecord({
             frameworkList: frameworks,
@@ -313,29 +320,52 @@ export class InitCommand extends SanityCommand {
             this.log(`${logSymbols.success} Fetching existing projects`);
             this.log('');
         }
-        const _newProjectId = createProjectName && await this.createProject({
+        const _newProjectId = createProjectName && await this.createProjectFromName({
             createProjectName,
             planId,
             user
         });
+        const { datasetName, projectId } = await this.getProjectDetails({
+            isAppTemplate,
+            planId,
+            showDefaultConfigPrompt,
+            user
+        });
+        // If user doesn't want to output any template code
+        if (this.flags.bare) {
+            this.log(`${logSymbols.success} Below are your project details`);
+            this.log('');
+            this.log(`Project ID: ${chalk.cyan(projectId)}`);
+            this.log(`Dataset: ${chalk.cyan(datasetName)}`);
+            this.log(`\nYou can find your project on Sanity Manage — https://www.sanity.io/manage/project/${projectId}\n`);
+            return;
+        }
     }
     checkFlagsInUnattendedMode({ createProjectName, isNextJs }) {
         debug('Unattended mode, validating required options');
         if (!this.flags['dataset']) {
-            throw new Error(`\`--dataset\` must be specified in unattended mode`);
+            this.error(`\`--dataset\` must be specified in unattended mode`, {
+                exit: 1
+            });
         }
         // output-path is required in unattended mode when not using nextjs
         if (!isNextJs && !this.flags['output-path']) {
-            throw new Error(`\`--output-path\` must be specified in unattended mode`);
+            this.error(`\`--output-path\` must be specified in unattended mode`, {
+                exit: 1
+            });
         }
         if (!this.flags.project && !createProjectName) {
-            throw new Error('`--project <id>` or `--create-project <name>` must be specified in unattended mode');
+            this.error('`--project <id>` or `--create-project <name>` must be specified in unattended mode', {
+                exit: 1
+            });
         }
         if (createProjectName && !this.flags.organization) {
-            throw new Error('--create-project is not supported in unattended mode without an organization, please specify an organization with `--organization <id>`');
+            this.error('--create-project is not supported in unattended mode without an organization, please specify an organization with `--organization <id>`', {
+                exit: 1
+            });
         }
     }
-    async createProject({ createProjectName, planId, user }) {
+    async createProjectFromName({ createProjectName, planId, user }) {
         debug('--create-project specified, creating a new project');
         let orgForCreateProjectFlag = this.flags.organization;
         if (!orgForCreateProjectFlag) {
@@ -361,7 +391,7 @@ export class InitCommand extends SanityCommand {
         if (this.flags.dataset) {
             debug('--dataset specified, creating dataset (%s)', this.flags.dataset);
             const spin = spinner('Creating dataset').start();
-            await createDataset({
+            await createDatasetService({
                 aclMode: this.flags.visibility,
                 datasetName: this.flags.dataset,
                 projectId: createdProject.projectId
@@ -390,7 +420,9 @@ export class InitCommand extends SanityCommand {
         // trace.log({ step: 'login', alreadyLoggedIn: true })
         } else {
             if (this.isUnattended()) {
-                throw new Error('Must be logged in to run this command in unattended mode, run `sanity login`');
+                this.error('Must be logged in to run this command in unattended mode, run `sanity login`', {
+                    exit: 1
+                });
             }
             // @todo telemetry
             //trace.log({step: 'login'})
@@ -405,6 +437,220 @@ export class InitCommand extends SanityCommand {
             user
         };
     }
+    async getOrCreateDataset(opts) {
+        const visibility = this.flags.visibility;
+        const dataset = this.flags.dataset;
+        let defaultConfig = this.flags['dataset-default'];
+        if (dataset && this.isUnattended()) {
+            return {
+                datasetName: dataset,
+                userAction: 'none'
+            };
+        }
+        const [datasets, projectFeatures] = await Promise.all([
+            listDatasets(opts.projectId),
+            getProjectFeatures(opts.projectId)
+        ]);
+        if (dataset) {
+            debug('User has specified dataset through a flag (%s)', dataset);
+            const existing = datasets.find((ds)=>ds.name === dataset);
+            if (!existing) {
+                debug('Specified dataset not found, creating it');
+                await createDataset({
+                    datasetName: dataset,
+                    forcePublic: defaultConfig,
+                    output: this.output,
+                    projectFeatures,
+                    projectId: opts.projectId,
+                    visibility
+                });
+            }
+            return {
+                datasetName: dataset,
+                userAction: 'none'
+            };
+        }
+        const datasetInfo = 'Your content will be stored in a dataset that can be public or private, depending on\nwhether you want to query your content with or without authentication.\nThe default dataset configuration has a public dataset named "production".';
+        if (datasets.length === 0) {
+            debug('No datasets found for project, prompting for name');
+            if (opts.showDefaultConfigPrompt) {
+                this.log(datasetInfo);
+                defaultConfig = await this.promptForDefaultConfig();
+            }
+            const name = defaultConfig ? 'production' : await promptForDatasetName({
+                message: 'Name of your first dataset:'
+            });
+            await createDataset({
+                datasetName: name,
+                forcePublic: defaultConfig,
+                output: this.output,
+                projectFeatures,
+                projectId: opts.projectId,
+                visibility
+            });
+            return {
+                datasetName: name,
+                userAction: 'create'
+            };
+        }
+        debug(`User has ${datasets.length} dataset(s) already, showing list of choices`);
+        const datasetChoices = datasets.map((dataset)=>({
+                value: dataset.name
+            }));
+        const selected = await select({
+            choices: [
+                {
+                    name: 'Create new dataset',
+                    value: 'new'
+                },
+                new Separator(),
+                ...datasetChoices
+            ],
+            message: 'Select dataset to use'
+        });
+        if (selected === 'new') {
+            const existingDatasetNames = datasets.map((ds)=>ds.name);
+            debug('User wants to create a new dataset, prompting for name');
+            if (opts.showDefaultConfigPrompt && !existingDatasetNames.includes('production')) {
+                this.log(datasetInfo);
+                defaultConfig = await this.promptForDefaultConfig();
+            }
+            const newDatasetName = defaultConfig ? 'production' : await promptForDatasetName({
+                message: 'Dataset name:'
+            }, existingDatasetNames);
+            await createDataset({
+                datasetName: newDatasetName,
+                forcePublic: defaultConfig,
+                output: this.output,
+                projectFeatures,
+                projectId: opts.projectId,
+                visibility
+            });
+            return {
+                datasetName: newDatasetName,
+                userAction: 'create'
+            };
+        }
+        debug(`Returning selected dataset (${selected})`);
+        return {
+            datasetName: selected,
+            userAction: 'select'
+        };
+    }
+    async getOrCreateProject({ planId, user }) {
+        const projectId = this.flags.project;
+        const organizationId = this.flags.organization;
+        let projects;
+        let organizations;
+        try {
+            const [allProjects, allOrgs] = await Promise.all([
+                listProjects(),
+                listOrganizations()
+            ]);
+            projects = allProjects.toSorted((a, b)=>b.createdAt.localeCompare(a.createdAt));
+            organizations = allOrgs;
+        } catch (err) {
+            if (this.isUnattended() && projectId) {
+                return {
+                    displayName: 'Unknown project',
+                    isFirstProject: false,
+                    projectId,
+                    userAction: 'select'
+                };
+            }
+            this.error(`Failed to communicate with the Sanity API:\n${err.message}`, {
+                exit: 1
+            });
+        }
+        if (projects.length === 0 && this.isUnattended()) {
+            this.error('No projects found for current user', {
+                exit: 1
+            });
+        }
+        if (projectId) {
+            const project = projects.find((proj)=>proj.id === projectId);
+            if (!project && !this.isUnattended()) {
+                this.error(`Given project ID (${projectId}) not found, or you do not have access to it`, {
+                    exit: 1
+                });
+            }
+            return {
+                displayName: project ? project.displayName : 'Unknown project',
+                isFirstProject: false,
+                projectId,
+                userAction: 'select'
+            };
+        }
+        if (organizationId) {
+            const organization = organizations.find((org)=>org.id === organizationId) || organizations.find((org)=>org.slug === organizationId);
+            if (!organization) {
+                this.error(`Given organization ID (${organizationId}) not found, or you do not have access to it`, {
+                    exit: 1
+                });
+            }
+            if (!await hasProjectAttachGrant(organizationId)) {
+                this.error('You lack the necessary permissions to attach a project to this organization', {
+                    exit: 1
+                });
+            }
+        }
+        // If the user has no projects or is using a coupon (which can only be applied to new projects)
+        // just ask for project details instead of showing a list of projects
+        const isUsersFirstProject = projects.length === 0;
+        if (isUsersFirstProject || this.flags.coupon) {
+            debug(isUsersFirstProject ? 'No projects found for user, prompting for name' : 'Using a coupon - skipping project selection');
+            const newProject = await this.promptForProjectCreation({
+                isUsersFirstProject,
+                organizationId,
+                organizations,
+                planId,
+                user
+            });
+            return {
+                ...newProject,
+                isFirstProject: isUsersFirstProject,
+                userAction: 'create'
+            };
+        }
+        debug(`User has ${projects.length} project(s) already, showing list of choices`);
+        const projectChoices = projects.map((project)=>({
+                name: `${project.displayName} (${project.id})`,
+                value: project.id
+            }));
+        const selected = await select({
+            choices: [
+                {
+                    name: 'Create new project',
+                    value: 'new'
+                },
+                new Separator(),
+                ...projectChoices
+            ],
+            message: 'Create a new project or select an existing one'
+        });
+        if (selected === 'new') {
+            debug('User wants to create a new project, prompting for name');
+            const newProject = await this.promptForProjectCreation({
+                isUsersFirstProject,
+                organizationId,
+                organizations,
+                planId,
+                user
+            });
+            return {
+                ...newProject,
+                isFirstProject: isUsersFirstProject,
+                userAction: 'create'
+            };
+        }
+        debug(`Returning selected project (${selected})`);
+        return {
+            displayName: projects.find((proj)=>proj.id === selected)?.displayName || '',
+            isFirstProject: isUsersFirstProject,
+            projectId: selected,
+            userAction: 'select'
+        };
+    }
     async getPlan() {
         const intendedPlan = this.flags['project-plan'];
         const intendedCoupon = this.flags.coupon;
@@ -416,6 +662,92 @@ export class InitCommand extends SanityCommand {
             return undefined;
         }
     }
+    async getProjectDetails({ isAppTemplate, planId, showDefaultConfigPrompt, user }) {
+        if (isAppTemplate) {
+            const organizations = await listOrganizations({
+                includeImplicitMemberships: 'true',
+                includeMembers: 'true'
+            });
+            const appOrganizationId = await this.promptUserForOrganization({
+                organizations,
+                user
+            });
+            return {
+                datasetName: '',
+                displayName: '',
+                isFirstProject: false,
+                organizationId: appOrganizationId,
+                projectId: ''
+            };
+        }
+        debug('Prompting user to select or create a project');
+        const project = await this.getOrCreateProject({
+            planId,
+            user
+        });
+        debug(`Project with name ${project.displayName} selected`);
+        // Now let's pick or create a dataset
+        debug('Prompting user to select or create a dataset');
+        const dataset = await this.getOrCreateDataset({
+            displayName: project.displayName,
+            projectId: project.projectId,
+            showDefaultConfigPrompt
+        });
+        debug(`Dataset with name ${dataset.datasetName} selected`);
+        // @todo
+        // trace.log({
+        //   step: 'createOrSelectDataset',
+        //   selectedOption: dataset.userAction,
+        //   datasetName: dataset.datasetName,
+        //   visibility: flags.visibility as 'private' | 'public',
+        // })
+        return {
+            datasetName: dataset.datasetName,
+            displayName: project.displayName,
+            isFirstProject: project.isFirstProject,
+            projectId: project.projectId
+        };
+    }
+    async promptForDefaultConfig() {
+        return confirm({
+            default: true,
+            message: 'Use the default dataset configuration?'
+        });
+    }
+    async promptForProjectCreation({ isUsersFirstProject, organizationId, organizations, planId, user }) {
+        const projectName = await input({
+            default: 'My Sanity Project',
+            message: 'Project name:',
+            validate (input) {
+                if (!input || input.trim() === '') {
+                    return 'Project name cannot be empty';
+                }
+                if (input.length > 80) {
+                    return 'Project name cannot be longer than 80 characters';
+                }
+                return true;
+            }
+        });
+        const organization = organizationId || await this.promptUserForOrganization({
+            organizations,
+            user
+        });
+        const newProject = await createProject({
+            displayName: projectName,
+            metadata: {
+                coupon: this.flags.coupon
+            },
+            organizationId: organization,
+            subscription: planId ? {
+                planId
+            } : undefined
+        });
+        return {
+            ...newProject,
+            isFirstProject: isUsersFirstProject,
+            userAction: 'create'
+        };
+    }
     async promptUserForNewOrganization(user) {
         const name = await input({
             default: user ? user.name : undefined,
@@ -472,7 +804,9 @@ export class InitCommand extends SanityCommand {
         } catch (err) {
             if (!isHttpError(err) || err.statusCode !== 404) {
                 const message = err instanceof Error ? err.message : `${err}`;
-                throw new Error(`Unable to validate coupon, please try again later:\n\n${message}`);
+                this.error(`Unable to validate coupon, please try again later:\n\n${message}`, {
+                    exit: 1
+                });
             }
             const useDefaultPlan = this.isUnattended() || await confirm({
                 default: true,
@@ -490,7 +824,9 @@ export class InitCommand extends SanityCommand {
             if (useDefaultPlan) {
                 this.log('Using default plan.');
             } else {
-                throw new Error(`Coupon "${intendedCoupon}" does not exist`);
+                this.error(`Coupon "${intendedCoupon}" does not exist`, {
+                    exit: 1
+                });
             }
         }
     }
@@ -501,8 +837,8 @@ export class InitCommand extends SanityCommand {
         } catch (err) {
             if (!isHttpError(err) || err.statusCode !== 404) {
                 const message = err instanceof Error ? err.message : `${err}`;
-                throw new Error(`Unable to validate plan, please try again later:\n\n${message}`, {
-                    cause: err
+                this.error(`Unable to validate plan, please try again later:\n\n${message}`, {
+                    exit: 1
                 });
             }
             const useDefaultPlan = this.isUnattended() || await confirm({
@@ -521,7 +857,9 @@ export class InitCommand extends SanityCommand {
             if (useDefaultPlan) {
                 this.log('Using default plan.');
             } else {
-                throw new Error(`Plan id "${intendedPlan}" does not exist`);
+                this.error(`Plan id "${intendedPlan}" does not exist`, {
+                    exit: 1
+                });
             }
         }
     }