@hubspot/cli 7.8.12-experimental.1 → 7.9.0-beta.0

package/commands/cms/upload.js

@@ -0,0 +1,212 @@
+import fs from 'fs';
+import path from 'path';
+import { uploadFolder, hasUploadErrors, } from '@hubspot/local-dev-lib/cms/uploadFolder';
+import { getFileMapperQueryValues } from '@hubspot/local-dev-lib/fileMapper';
+import { upload, deleteFile } from '@hubspot/local-dev-lib/api/fileMapper';
+import { getCwd, convertToUnixPath, isAllowedExtension, } from '@hubspot/local-dev-lib/path';
+import { validateSrcAndDestPaths } from '@hubspot/local-dev-lib/cms/modules';
+import { shouldIgnoreFile } from '@hubspot/local-dev-lib/ignoreRules';
+import { getThemePreviewUrl, getThemeJSONPath, } from '@hubspot/local-dev-lib/cms/themes';
+import { FieldsJs, isConvertableFieldJs, cleanupTmpDirSync, } from '@hubspot/local-dev-lib/cms/handleFieldsJS';
+import { ApiErrorContext, logError } from '../../lib/errorHandlers/index.js';
+import { getCmsPublishMode } from '../../lib/commonOpts.js';
+import { uploadPrompt } from '../../lib/prompts/uploadPrompt.js';
+import { confirmPrompt } from '../../lib/prompts/promptUtils.js';
+import { validateCmsPublishMode } from '../../lib/validation.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { getUploadableFileList } from '../../lib/upload.js';
+import { commands } from '../../lang/en.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+const command = 'upload [src] [dest]';
+const describe = commands.cms.subcommands.upload.describe;
+function logThemePreview(filePath, accountId) {
+    const previewUrl = getThemePreviewUrl(filePath, accountId);
+    // Only log if we are actually in a theme
+    if (previewUrl) {
+        uiLogger.log(commands.cms.subcommands.upload.previewUrl(previewUrl));
+    }
+}
+async function handler(args) {
+    if (!validateCmsPublishMode(args)) {
+        process.exit(EXIT_CODES.WARNING);
+    }
+    const { derivedAccountId } = args;
+    const cmsPublishMode = getCmsPublishMode(args);
+    const uploadPromptAnswers = await uploadPrompt(args);
+    const src = args.src || uploadPromptAnswers.src;
+    const saveOutput = args.saveOutput;
+    let dest = args.dest || uploadPromptAnswers.dest;
+    let absoluteSrcPath = path.resolve(getCwd(), src);
+    if (!dest) {
+        uiLogger.error(commands.cms.subcommands.upload.errors.destinationRequired);
+        return;
+    }
+    // Check for theme.json file and determine the root path for the project based on it if it exists
+    const themeJsonPath = getThemeJSONPath(absoluteSrcPath);
+    const projectRoot = themeJsonPath
+        ? path.dirname(themeJsonPath)
+        : path.dirname(getCwd());
+    const convertFields = projectRoot &&
+        isConvertableFieldJs(projectRoot, absoluteSrcPath, args.convertFields);
+    let fieldsJs;
+    if (convertFields) {
+        fieldsJs = await new FieldsJs(projectRoot, absoluteSrcPath, undefined, args.fieldOptions).init();
+        if (fieldsJs.rejected)
+            return;
+        // Ensures that the dest path is a .json. The user might pass '.js' accidentally - this ensures it just works.
+        if (fieldsJs.outputPath) {
+            absoluteSrcPath = fieldsJs.outputPath;
+        }
+        dest = path.join(path.dirname(dest), 'fields.json');
+    }
+    let stats;
+    try {
+        stats = fs.statSync(absoluteSrcPath);
+        if (!stats.isFile() && !stats.isDirectory()) {
+            uiLogger.error(commands.cms.subcommands.upload.errors.invalidPath(src));
+            return;
+        }
+    }
+    catch (e) {
+        uiLogger.error(commands.cms.subcommands.upload.errors.invalidPath(src));
+        return;
+    }
+    const normalizedDest = convertToUnixPath(dest);
+    trackCommandUsage('upload', { mode: cmsPublishMode, type: stats.isFile() ? 'file' : 'folder' }, derivedAccountId);
+    const srcDestIssues = await validateSrcAndDestPaths({ isLocal: true, path: src }, { isHubSpot: true, path: dest });
+    if (srcDestIssues.length) {
+        srcDestIssues.forEach(({ message }) => uiLogger.error(message));
+        process.exit(EXIT_CODES.WARNING);
+    }
+    if (stats.isFile()) {
+        if (!isAllowedExtension(src) && !convertFields) {
+            uiLogger.error(commands.cms.subcommands.upload.errors.invalidPath(src));
+            return;
+        }
+        if (shouldIgnoreFile(absoluteSrcPath)) {
+            uiLogger.error(commands.cms.subcommands.upload.errors.fileIgnored(src));
+            return;
+        }
+        upload(derivedAccountId, absoluteSrcPath, normalizedDest, getFileMapperQueryValues(cmsPublishMode))
+            .then(() => {
+            uiLogger.success(commands.cms.subcommands.upload.success.fileUploaded(src, normalizedDest, derivedAccountId));
+            logThemePreview(src, derivedAccountId);
+        })
+            .catch(error => {
+            uiLogger.error(commands.cms.subcommands.upload.errors.uploadFailed(src, normalizedDest));
+            logError(error, new ApiErrorContext({
+                accountId: derivedAccountId,
+                request: normalizedDest,
+                payload: src,
+            }));
+            process.exit(EXIT_CODES.WARNING);
+        })
+            .finally(() => {
+            if (!convertFields)
+                return;
+            if (saveOutput && fieldsJs) {
+                fieldsJs.saveOutput();
+            }
+            if (fieldsJs) {
+                cleanupTmpDirSync(fieldsJs.rootWriteDir);
+            }
+        });
+    }
+    else {
+        uiLogger.log(commands.cms.subcommands.upload.uploading(src, dest, derivedAccountId));
+        // Generate the first-pass file list in here, and pass to uploadFolder.
+        const filePaths = await getUploadableFileList(absoluteSrcPath, args.convertFields ?? false);
+        if (args.clean) {
+            //  If clean is true, will first delete the dest folder and then upload src. Cleans up files that only exist on HS.
+            let cleanUpload = args.force;
+            if (!args.force) {
+                cleanUpload = await confirmPrompt(commands.cms.subcommands.upload.confirmCleanUpload(dest, derivedAccountId), { defaultAnswer: false });
+            }
+            if (cleanUpload) {
+                try {
+                    await deleteFile(derivedAccountId, dest);
+                    uiLogger.log(commands.cms.subcommands.upload.cleaning(dest, derivedAccountId));
+                }
+                catch (error) {
+                    uiLogger.error(commands.cms.subcommands.upload.errors.deleteFailed(dest, derivedAccountId));
+                }
+            }
+        }
+        uploadFolder(derivedAccountId, absoluteSrcPath, dest, {}, {
+            convertFields: args.convertFields,
+            // @ts-expect-error - fieldOptions is a string or string[]
+            fieldOptions: args.fieldOptions ?? undefined,
+            saveOutput: args.saveOutput,
+        }, filePaths)
+            .then(results => {
+            if (!hasUploadErrors(results)) {
+                uiLogger.success(commands.cms.subcommands.upload.success.uploadComplete(dest));
+                logThemePreview(src, derivedAccountId);
+            }
+            else {
+                uiLogger.error(commands.cms.subcommands.upload.errors.someFilesFailed(dest));
+                process.exit(EXIT_CODES.WARNING);
+            }
+        })
+            .catch(error => {
+            uiLogger.error(commands.cms.subcommands.upload.errors.uploadFailed(src, dest));
+            logError(error, {
+                accountId: derivedAccountId,
+            });
+            process.exit(EXIT_CODES.WARNING);
+        });
+    }
+}
+function uploadBuilder(yargs) {
+    yargs.positional('src', {
+        describe: commands.cms.subcommands.upload.positionals.src,
+        type: 'string',
+    });
+    yargs.positional('dest', {
+        describe: commands.cms.subcommands.upload.positionals.dest,
+        type: 'string',
+    });
+    yargs.option('fieldOptions', {
+        describe: commands.cms.subcommands.upload.options.options,
+        type: 'array',
+        default: [''],
+        hidden: true,
+    });
+    yargs.option('saveOutput', {
+        describe: commands.cms.subcommands.upload.options.saveOutput,
+        type: 'boolean',
+        default: false,
+    });
+    yargs.option('convertFields', {
+        describe: commands.cms.subcommands.upload.options.convertFields,
+        type: 'boolean',
+        default: false,
+    });
+    yargs.option('clean', {
+        describe: commands.cms.subcommands.upload.options.clean,
+        type: 'boolean',
+        default: false,
+    });
+    yargs.option('force', {
+        describe: commands.cms.subcommands.upload.options.force,
+        type: 'boolean',
+        default: false,
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(uploadBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useEnvironmentOptions: true,
+    useCmsPublishModeOptions: true,
+});
+const uploadCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default uploadCommand;

package/commands/cms/watch.d.ts

@@ -0,0 +1,14 @@
+import { AccountArgs, CmsPublishModeArgs, CommonArgs, ConfigArgs, EnvironmentArgs, YargsCommandModule } from '../../types/Yargs.js';
+export type WatchCommandArgs = ConfigArgs & AccountArgs & EnvironmentArgs & CommonArgs & CmsPublishModeArgs & {
+    src?: string;
+    dest?: string;
+    fieldOptions?: string[];
+    remove?: boolean;
+    initialUpload?: boolean;
+    disableInitial?: boolean;
+    notify?: string;
+    convertFields?: boolean;
+    saveOutput?: boolean;
+};
+declare const watchCommand: YargsCommandModule<unknown, WatchCommandArgs>;
+export default watchCommand;

package/commands/cms/watch.js

@@ -0,0 +1,138 @@
+import fs from 'fs';
+import path from 'path';
+import { watch } from '@hubspot/local-dev-lib/cms/watch';
+import { getCwd } from '@hubspot/local-dev-lib/path';
+import { getCmsPublishMode } from '../../lib/commonOpts.js';
+import { uploadPrompt } from '../../lib/prompts/uploadPrompt.js';
+import { validateCmsPublishMode } from '../../lib/validation.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { commands } from '../../lang/en.js';
+import { getUploadableFileList } from '../../lib/upload.js';
+import { logError, ApiErrorContext } from '../../lib/errorHandlers/index.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+const command = 'watch [src] [dest]';
+const describe = commands.cms.subcommands.watch.describe;
+const handler = async (args) => {
+    const { remove, initialUpload, disableInitial, notify, derivedAccountId } = args;
+    if (!validateCmsPublishMode(args)) {
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const cmsPublishMode = getCmsPublishMode(args);
+    const uploadPromptAnswers = await uploadPrompt(args);
+    const src = args.src || uploadPromptAnswers.src;
+    const dest = args.dest || uploadPromptAnswers.dest;
+    const absoluteSrcPath = path.resolve(getCwd(), src);
+    try {
+        const stats = fs.statSync(absoluteSrcPath);
+        if (!stats.isDirectory()) {
+            uiLogger.log(commands.cms.subcommands.watch.errors.invalidPath(src));
+            return;
+        }
+    }
+    catch (e) {
+        uiLogger.log(commands.cms.subcommands.watch.errors.invalidPath(src));
+        return;
+    }
+    if (!dest) {
+        uiLogger.log(commands.cms.subcommands.watch.errors.destinationRequired);
+        return;
+    }
+    let filesToUpload = [];
+    if (disableInitial) {
+        uiLogger.info(commands.cms.subcommands.watch.warnings.disableInitial);
+    }
+    else if (!initialUpload) {
+        uiLogger.info(commands.cms.subcommands.watch.warnings.notUploaded(src));
+        uiLogger.info(commands.cms.subcommands.watch.warnings.initialUpload);
+    }
+    if (initialUpload) {
+        filesToUpload = await getUploadableFileList(absoluteSrcPath, args.convertFields);
+    }
+    trackCommandUsage('watch', { mode: cmsPublishMode }, derivedAccountId);
+    const onUploadFolderError = (error) => {
+        uiLogger.error(commands.cms.subcommands.watch.errors.folderFailed(src, dest, derivedAccountId));
+        logError(error, {
+            accountId: derivedAccountId,
+        });
+    };
+    const onUploadFileError = (file, destPath, accountId) => (error) => {
+        uiLogger.error(commands.cms.subcommands.watch.errors.fileFailed(file, destPath, accountId));
+        logError(error, new ApiErrorContext({
+            accountId,
+            request: destPath,
+            payload: file,
+        }));
+    };
+    watch(derivedAccountId, absoluteSrcPath, dest, {
+        cmsPublishMode,
+        remove,
+        disableInitial: !initialUpload,
+        notify,
+        commandOptions: args,
+        filePaths: filesToUpload,
+    }, null, onUploadFolderError, undefined, onUploadFileError);
+};
+function watchBuilder(yargs) {
+    yargs.positional('src', {
+        describe: commands.cms.subcommands.watch.positionals.src,
+        type: 'string',
+    });
+    yargs.positional('dest', {
+        describe: commands.cms.subcommands.watch.positionals.dest,
+        type: 'string',
+    });
+    yargs.option('fieldOptions', {
+        describe: commands.cms.subcommands.watch.options.options,
+        type: 'array',
+        default: [''],
+        hidden: true,
+    });
+    yargs.option('remove', {
+        alias: 'r',
+        describe: commands.cms.subcommands.watch.options.remove,
+        type: 'boolean',
+    });
+    yargs.option('initial-upload', {
+        alias: 'i',
+        describe: commands.cms.subcommands.watch.options.initialUpload,
+        type: 'boolean',
+    });
+    yargs.option('disable-initial', {
+        describe: commands.cms.subcommands.watch.options.disableInitial,
+        type: 'boolean',
+        hidden: true,
+    });
+    yargs.option('notify', {
+        alias: 'n',
+        describe: commands.cms.subcommands.watch.options.notify,
+        type: 'string',
+        requiresArg: true,
+    });
+    yargs.option('convertFields', {
+        describe: commands.cms.subcommands.watch.options.convertFields,
+        type: 'boolean',
+        default: false,
+    });
+    yargs.option('saveOutput', {
+        describe: commands.cms.subcommands.watch.options.saveOutput,
+        type: 'boolean',
+        default: false,
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(watchBuilder, command, describe, {
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useGlobalOptions: true,
+    useEnvironmentOptions: true,
+    useCmsPublishModeOptions: { write: true },
+});
+const watchCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default watchCommand;

package/commands/cms/webpack/create.d.ts

@@ -0,0 +1,6 @@
+import { CommonArgs, ConfigArgs, YargsCommandModule } from '../../../types/Yargs.js';
+type WebpackCreateArgs = CommonArgs & ConfigArgs & {
+    dest?: string;
+};
+declare const webpackCreateCommand: YargsCommandModule<unknown, WebpackCreateArgs>;
+export default webpackCreateCommand;

package/commands/cms/webpack/create.js

@@ -0,0 +1,58 @@
+import fs from 'fs-extra';
+import { logError } from '../../../lib/errorHandlers/index.js';
+import { resolveLocalPath } from '../../../lib/filesystem.js';
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+import { commands } from '../../../lang/en.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { makeYargsBuilder } from '../../../lib/yargsUtils.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import assets from '../../../lib/cmsAssets/index.js';
+const command = 'create [dest]';
+const describe = commands.cms.subcommands.webpack.subcommands.create.describe;
+async function handler(args) {
+    const { dest, derivedAccountId } = args;
+    const assetType = 'webpack-serverless';
+    trackCommandUsage('create', { assetType }, derivedAccountId);
+    const asset = assets[assetType];
+    const argsToPass = {
+        commandArgs: args,
+        assetType,
+        dest,
+    };
+    if (!argsToPass.dest) {
+        argsToPass.dest = resolveLocalPath(asset.dest(argsToPass));
+    }
+    try {
+        await fs.ensureDir(argsToPass.dest);
+    }
+    catch (e) {
+        uiLogger.error(commands.cms.subcommands.webpack.subcommands.create.errors.unusablePath(argsToPass.dest));
+        logError(e);
+        return;
+    }
+    try {
+        await asset.execute(argsToPass);
+    }
+    catch (e) {
+        logError(e);
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
+function webpackCreateBuilder(yargs) {
+    yargs.positional('dest', {
+        describe: commands.cms.subcommands.webpack.subcommands.create.positionals.dest,
+        type: 'string',
+    });
+    return yargs;
+}
+const builder = makeYargsBuilder(webpackCreateBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+});
+const webpackCreateCommand = {
+    command,
+    describe,
+    builder,
+    handler,
+};
+export default webpackCreateCommand;

package/commands/cms/webpack.d.ts

@@ -0,0 +1,3 @@
+import { YargsCommandModuleBucket } from '../../types/Yargs.js';
+declare const webpackCommand: YargsCommandModuleBucket;
+export default webpackCommand;

package/commands/cms/webpack.js

@@ -0,0 +1,17 @@
+import createCommand from './webpack/create.js';
+import { commands } from '../../lang/en.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+const command = 'webpack';
+const describe = commands.cms.subcommands.webpack.describe;
+function webpackBuilder(yargs) {
+    yargs.command(createCommand).demandCommand(1, '');
+    return yargs;
+}
+const builder = makeYargsBuilder(webpackBuilder, command, describe);
+const webpackCommand = {
+    command,
+    describe,
+    builder,
+    handler: () => { },
+};
+export default webpackCommand;

package/commands/cms.js

@@ -3,6 +3,19 @@ import { makeYargsBuilder } from '../lib/yargsUtils.js';
 import lighthouseScore from './cms/lighthouseScore.js';
 import convertFields from './cms/convertFields.js';
 import getReactModule from './cms/getReactModule.js';
+import watchCommand from './cms/watch.js';
+import listCommand from './cms/list.js';
+import uploadCommand from './cms/upload.js';
+import fetchCommand from './cms/fetch.js';
+import deleteCommand from './cms/delete.js';
+import mvCommand from './cms/mv.js';
+import functionCommand from './cms/function.js';
+import lintCommand from './cms/lint.js';
+import themeCommand from './cms/theme.js';
+import moduleCommand from './cms/module.js';
+import webpackCommand from './cms/webpack.js';
+import appCommand from './cms/app.js';
+import templateCommand from './cms/template.js';
 const command = 'cms';
 const describe = commands.cms.describe;
 function cmsBuilder(yargs) {
@@ -10,6 +23,19 @@ function cmsBuilder(yargs) {
         .command(lighthouseScore)
         .command(convertFields)
         .command(getReactModule)
+        .command(watchCommand)
+        .command(listCommand)
+        .command(uploadCommand)
+        .command(fetchCommand)
+        .command(deleteCommand)
+        .command(mvCommand)
+        .command(functionCommand)
+        .command(lintCommand)
+        .command(themeCommand)
+        .command(moduleCommand)
+        .command(webpackCommand)
+        .command(appCommand)
+        .command(templateCommand)
         .demandCommand(1, '');
     return yargs;
 }

package/commands/create.js

@@ -3,17 +3,19 @@ import { logError } from '../lib/errorHandlers/index.js';
 import { setCLILogLevel } from '../lib/commonOpts.js';
 import { resolveLocalPath } from '../lib/filesystem.js';
 import { trackCommandUsage } from '../lib/usageTracking.js';
-import assets from './create/index.js';
+import assets from '../lib/cmsAssets/index.js';
 import { commands } from '../lang/en.js';
 import { uiLogger } from '../lib/ui/logger.js';
 import { makeYargsBuilder } from '../lib/yargsUtils.js';
 import { EXIT_CODES } from '../lib/enums/exitCodes.js';
 import { TEMPLATE_TYPES, HTTP_METHODS, CONTENT_TYPES } from '../types/Cms.js';
+import { uiDeprecatedTag } from '../lib/ui/index.js';
 const SUPPORTED_ASSET_TYPES = Object.keys(assets)
     .filter(t => !assets[t].hidden)
     .join(', ');
 const command = 'create <type> [name] [dest]';
-const describe = commands.create.describe(SUPPORTED_ASSET_TYPES);
+const describe = uiDeprecatedTag(commands.create.describe(SUPPORTED_ASSET_TYPES) +
+    ' Please use the create commands in `hs cms` instead.', false);
 async function handler(args) {
     const { name, internal: getInternalVersion, type } = args;
     let { dest } = args;

package/commands/customObject/{schema/__tests__/create.test.js → __tests__/createSchema.test.js}

@@ -1,12 +1,12 @@
 import yargs from 'yargs';
-import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } from '../../../../lib/commonOpts.js';
-import schemaCreateCommand from '../create.js';
-vi.mock('../../../../lib/commonOpts');
-describe('commands/customObject/schema/create', () => {
+import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } from '../../../lib/commonOpts.js';
+import schemaCreateCommand from '../createSchema.js';
+vi.mock('../../../lib/commonOpts');
+describe('commands/customObject/createSchema', () => {
     const yargsMock = yargs;
     describe('command', () => {
         it('should have the correct command structure', () => {
-            expect(schemaCreateCommand.command).toEqual('create');
+            expect(schemaCreateCommand.command).toEqual('create-schema');
         });
     });
     describe('describe', () => {

package/commands/customObject/{schema/__tests__/delete.test.js → __tests__/deleteSchema.test.js}

@@ -1,9 +1,9 @@
 import yargs from 'yargs';
-import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } from '../../../../lib/commonOpts.js';
-import schemaDeleteCommand from '../delete.js';
+import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } from '../../../lib/commonOpts.js';
+import schemaDeleteCommand from '../deleteSchema.js';
 vi.mock('yargs');
-vi.mock('../../../../lib/commonOpts');
-describe('commands/customObject/schema/delete', () => {
+vi.mock('../../../lib/commonOpts');
+describe('commands/customObject/deleteSchema', () => {
     let yargsMock = yargs;
     beforeEach(() => {
         yargsMock = {
@@ -14,7 +14,7 @@ describe('commands/customObject/schema/delete', () => {
     });
     describe('command', () => {
         it('should have the correct command structure', () => {
-            expect(schemaDeleteCommand.command).toEqual('delete [name]');
+            expect(schemaDeleteCommand.command).toEqual('delete-schema [name]');
         });
     });
     describe('describe', () => {

package/commands/customObject/{schema/__tests__/fetch-all.test.js → __tests__/fetch-all-schemas.test.js}

@@ -1,9 +1,9 @@
 import yargs from 'yargs';
-import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } from '../../../../lib/commonOpts.js';
-import schemaFetchAllCommand from '../fetch-all.js';
+import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } from '../../../lib/commonOpts.js';
+import schemaFetchAllCommand from '../fetchAllSchemas.js';
 vi.mock('yargs');
-vi.mock('../../../../lib/commonOpts');
-describe('commands/customObject/schema/fetch-all', () => {
+vi.mock('../../../lib/commonOpts');
+describe('commands/customObject/fetchAllSchemas', () => {
     let yargsMock = yargs;
     beforeEach(() => {
         yargsMock = {
@@ -13,7 +13,7 @@ describe('commands/customObject/schema/fetch-all', () => {
     });
     describe('command', () => {
         it('should have the correct command structure', () => {
-            expect(schemaFetchAllCommand.command).toEqual('fetch-all [dest]');
+            expect(schemaFetchAllCommand.command).toEqual('fetch-all-schemas [dest]');
         });
     });
     describe('describe', () => {

package/commands/customObject/{schema/__tests__/fetch.test.js → __tests__/fetchSchema.test.js}

@@ -1,9 +1,9 @@
 import yargs from 'yargs';
-import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } from '../../../../lib/commonOpts.js';
-import schemaFetchCommand from '../fetch.js';
+import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } from '../../../lib/commonOpts.js';
+import schemaFetchCommand from '../fetchSchema.js';
 vi.mock('yargs');
-vi.mock('../../../../lib/commonOpts');
-describe('commands/customObject/schema/fetch', () => {
+vi.mock('../../../lib/commonOpts');
+describe('commands/customObject/fetchSchema', () => {
     let yargsMock = yargs;
     beforeEach(() => {
         yargsMock = {
@@ -13,7 +13,7 @@ describe('commands/customObject/schema/fetch', () => {
     });
     describe('command', () => {
         it('should have the correct command structure', () => {
-            expect(schemaFetchCommand.command).toEqual('fetch [name] [dest]');
+            expect(schemaFetchCommand.command).toEqual('fetch-schema [name] [dest]');
         });
     });
     describe('describe', () => {

package/commands/customObject/{schema/__tests__/list.test.js → __tests__/listSchemas.test.js}

@@ -1,13 +1,13 @@
 import yargs from 'yargs';
-import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } from '../../../../lib/commonOpts.js';
-import schemaListCommand from '../list.js';
+import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } from '../../../lib/commonOpts.js';
+import schemaListCommand from '../listSchemas.js';
 vi.mock('yargs');
-vi.mock('../../../../lib/commonOpts');
-describe('commands/customObject/schema/list', () => {
+vi.mock('../../../lib/commonOpts');
+describe('commands/customObject/listSchemas', () => {
     const yargsMock = yargs;
     describe('command', () => {
         it('should have the correct command structure', () => {
-            expect(schemaListCommand.command).toEqual('list');
+            expect(schemaListCommand.command).toEqual('list-schemas');
         });
     });
     describe('describe', () => {

package/commands/customObject/{schema/__tests__/update.test.js → __tests__/updateSchema.test.js}

@@ -1,9 +1,9 @@
 import yargs from 'yargs';
-import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } from '../../../../lib/commonOpts.js';
-import schemaUpdateCommand from '../update.js';
+import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } from '../../../lib/commonOpts.js';
+import schemaUpdateCommand from '../updateSchema.js';
 vi.mock('yargs');
-vi.mock('../../../../lib/commonOpts');
-describe('commands/customObject/schema/update', () => {
+vi.mock('../../../lib/commonOpts');
+describe('commands/customObject/updateSchema', () => {
     let yargsMock = yargs;
     beforeEach(() => {
         yargsMock = {
@@ -13,7 +13,7 @@ describe('commands/customObject/schema/update', () => {
     });
     describe('command', () => {
         it('should have the correct command structure', () => {
-            expect(schemaUpdateCommand.command).toEqual('update [name]');
+            expect(schemaUpdateCommand.command).toEqual('update-schema [name]');
         });
     });
     describe('describe', () => {

package/commands/customObject/createSchema.d.ts

@@ -0,0 +1,6 @@
+import { CommonArgs, ConfigArgs, AccountArgs, EnvironmentArgs, TestingArgs, YargsCommandModule } from '../../types/Yargs.js';
+export type SchemaCreateArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & TestingArgs & {
+    path: string;
+};
+declare const createSchemaCommand: YargsCommandModule<unknown, SchemaCreateArgs>;
+export default createSchemaCommand;