hereya-cli 0.50.0 → 0.52.0

package/dist/commands/flow/up/index.js

@@ -1,7 +1,9 @@
 import { Command, Flags } from '@oclif/core';
+import { getBackend } from '../../../backend/index.js';
 import { getConfigManager } from '../../../lib/config/index.js';
 import { buildFlowWorkspaceName } from '../../../lib/flow-utils.js';
 import { setDebug } from '../../../lib/log.js';
+import { validateFlowCommand } from '../../../lib/workspace-validation.js';
 import Up from '../../up/index.js';
 import WorkspaceCreate from '../../workspace/create/index.js';
 export default class FlowUp extends Command {
@@ -61,8 +63,18 @@ export default class FlowUp extends Command {
             project: loadConfigOutput.config.project,
             projectRootDir,
         });
+        // Validate that if workspace exists, it's not a deployment workspace
+        const backend = await getBackend();
+        const validation = await validateFlowCommand(workspaceName, backend);
+        if (!validation.isValid) {
+            this.error(validation.message);
+        }
+        // Import workspace resolution utility
+        const { resolveWorkspaceName } = await import('../../../lib/workspace-utils.js');
+        // Resolve mirror workspace name with org prefix
+        const mirrorWorkspace = resolveWorkspaceName(loadConfigOutput.config.workspace, loadConfigOutput.config.project);
         // Create workspace with mirror
-        const createArgs = [workspaceName, '--mirror', loadConfigOutput.config.workspace];
+        const createArgs = [workspaceName, '--mirror', mirrorWorkspace];
         if (projectRootDir) {
             createArgs.push('--chdir', projectRootDir);
         }

package/dist/commands/remove/index.js

@@ -8,6 +8,7 @@ import { getLogger, getLogPath, isDebug, setDebug } from '../../lib/log.js';
 import { getParameterManager } from '../../lib/parameter/index.js';
 import { getProfileFromWorkspace } from '../../lib/profile-utils.js';
 import { delay } from '../../lib/shell.js';
+import { validateDevelopmentWorkspace } from '../../lib/workspace-validation.js';
 export default class Remove extends Command {
     static args = {
         package: Args.string({
@@ -60,6 +61,12 @@ export default class Remove extends Command {
                                 ctx.configOutput = loadConfigOutput;
                                 // Use workspace from flag if provided, otherwise use config workspace
                                 ctx.workspace = flags.workspace || loadConfigOutput.config.workspace;
+                                // Validate that the workspace is a development workspace
+                                const backend = await getBackend();
+                                const validation = await validateDevelopmentWorkspace(ctx.workspace, backend, 'remove');
+                                if (!validation.isValid) {
+                                    throw new Error(validation.message);
+                                }
                                 const { config } = loadConfigOutput;
                                 if (!(ctx.package in (config.packages ?? {})) && !(ctx.package in (config.deploy ?? {}))) {
                                     throw new Error(`Package ${ctx.package} not found in the project.`);

package/dist/commands/run/index.js

@@ -4,6 +4,7 @@ import { getConfigManager } from '../../lib/config/index.js';
 import { getEnvManager } from '../../lib/env/index.js';
 import { getProfileFromWorkspace } from '../../lib/profile-utils.js';
 import { runShell } from '../../lib/shell.js';
+import { validateDevelopmentWorkspace } from '../../lib/workspace-validation.js';
 export default class Run extends Command {
     static args = {
         cmd: Args.string({ description: 'command to run', required: true }),
@@ -43,6 +44,11 @@ export default class Run extends Command {
             this.error('you must specify a workspace to run the command in');
         }
         const backend = await getBackend();
+        // Validate that the workspace is a development workspace
+        const validation = await validateDevelopmentWorkspace(workspace, backend, 'run');
+        if (!validation.isValid) {
+            this.error(validation.message);
+        }
         const profile = await getProfileFromWorkspace(backend, workspace, config.project);
         const envManager = getEnvManager();
         const getProjectEnvOutput = await envManager.getProjectEnv({

package/dist/commands/undeploy/index.js

@@ -9,6 +9,7 @@ import { getLogger, getLogPath, isDebug, setDebug } from '../../lib/log.js';
 import { getParameterManager } from '../../lib/parameter/index.js';
 import { getProfileFromWorkspace } from '../../lib/profile-utils.js';
 import { delay } from '../../lib/shell.js';
+import { validateDeploymentWorkspace } from '../../lib/workspace-validation.js';
 export default class Undeploy extends Command {
     static description = 'Undeploy a hereya project by removing all resources.';
     static examples = ['<%= config.bin %> <%= command.id %>'];
@@ -35,6 +36,12 @@ export default class Undeploy extends Command {
         const { flags } = await this.parse(Undeploy);
         setDebug(flags.debug);
         const projectRootDir = path.resolve(flags.chdir || process.env.HEREYA_PROJECT_ROOT_DIR || process.cwd());
+        // Validate that the workspace is a deployment workspace
+        const backend = await getBackend();
+        const validation = await validateDeploymentWorkspace(flags.workspace, backend, 'undeploy');
+        if (!validation.isValid) {
+            this.error(validation.message);
+        }
         const myLogger = new ListrLogger({ useIcons: false });
         const task = new Listr([
             {

package/dist/commands/up/index.js

@@ -8,6 +8,7 @@ import { getLogger, getLogPath, isDebug, setDebug } from '../../lib/log.js';
 import { getParameterManager } from '../../lib/parameter/index.js';
 import { getProfileFromWorkspace } from '../../lib/profile-utils.js';
 import { delay } from '../../lib/shell.js';
+import { validateDevelopmentWorkspace } from '../../lib/workspace-validation.js';
 export default class Up extends Command {
     static description = 'Provision all packages in the project.';
     static examples = ['<%= config.bin %> <%= command.id %>'];
@@ -58,6 +59,12 @@ export default class Up extends Command {
                                 }
                                 ctx.configOutput = loadConfigOutput;
                                 ctx.workspace = flags.workspace || loadConfigOutput.config.workspace;
+                                // Validate that the workspace is a development workspace
+                                const backend = await getBackend();
+                                const validation = await validateDevelopmentWorkspace(ctx.workspace, backend, 'up');
+                                if (!validation.isValid) {
+                                    throw new Error(validation.message);
+                                }
                                 await delay(500);
                             },
                             title: 'Loading project config',

package/dist/commands/workspace/create/index.d.ts

@@ -6,6 +6,7 @@ export default class WorkspaceCreate extends Command {
     static description: string;
     static examples: string[];
     static flags: {
+        deployment: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         mirror: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         profile: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };

package/dist/commands/workspace/create/index.js

@@ -7,6 +7,7 @@ export default class WorkspaceCreate extends Command {
     static description = 'Create a new workspace if it does not exist.';
     static examples = ['<%= config.bin %> <%= command.id %> dev'];
     static flags = {
+        deployment: Flags.boolean({ char: 'd', description: 'mark workspace as a deployment workspace', required: false }),
         mirror: Flags.string({ description: 'workspace to mirror', required: false }),
         profile: Flags.string({ description: 'workspace profile to set (cloud backend only)', required: false }),
     };
@@ -14,6 +15,7 @@ export default class WorkspaceCreate extends Command {
         const { args, flags } = await this.parse(WorkspaceCreate);
         const backend = await getBackend();
         const createWorkspaceOutput = await backend.createWorkspace({
+            isDeploy: flags.deployment,
             mirrorOf: flags.mirror,
             name: args.name,
             profile: flags.profile,

package/dist/commands/workspace/list/index.js

@@ -19,12 +19,14 @@ export default class WorkspaceList extends Command {
                     const result = await backend.getWorkspace(name);
                     if (result.found && !result.hasError) {
                         return {
+                            deployment: result.workspace.isDeploy ? 'Yes' : 'No',
                             mirrorOf: result.workspace.mirrorOf || '-',
                             name,
                             profile: result.workspace.profile || '-',
                         };
                     }
                     return {
+                        deployment: 'No',
                         mirrorOf: '-',
                         name,
                         profile: '-',
@@ -32,6 +34,7 @@ export default class WorkspaceList extends Command {
                 }
                 catch {
                     return {
+                        deployment: 'No',
                         mirrorOf: '-',
                         name,
                         profile: '-',
@@ -41,13 +44,14 @@ export default class WorkspaceList extends Command {
             // Calculate column widths for alignment
             const nameWidth = Math.max(4, ...workspaceDetails.map(w => w.name.length)); // min 4 for "Name"
             const profileWidth = Math.max(7, ...workspaceDetails.map(w => w.profile.length)); // min 7 for "Profile"
+            const deploymentWidth = Math.max(10, ...workspaceDetails.map(w => w.deployment.length)); // min 10 for "Deployment"
             const mirrorWidth = Math.max(9, ...workspaceDetails.map(w => w.mirrorOf.length)); // min 9 for "Mirror Of"
             // Display header
-            this.log(`${'Name'.padEnd(nameWidth)}  ${'Profile'.padEnd(profileWidth)}  ${'Mirror Of'.padEnd(mirrorWidth)}`);
-            this.log('-'.repeat(nameWidth + profileWidth + mirrorWidth + 4));
+            this.log(`${'Name'.padEnd(nameWidth)}  ${'Profile'.padEnd(profileWidth)}  ${'Deployment'.padEnd(deploymentWidth)}  ${'Mirror Of'.padEnd(mirrorWidth)}`);
+            this.log('-'.repeat(nameWidth + profileWidth + deploymentWidth + mirrorWidth + 6));
             // Display rows
             for (const workspace of workspaceDetails) {
-                this.log(`${workspace.name.padEnd(nameWidth)}  ${workspace.profile.padEnd(profileWidth)}  ${workspace.mirrorOf.padEnd(mirrorWidth)}`);
+                this.log(`${workspace.name.padEnd(nameWidth)}  ${workspace.profile.padEnd(profileWidth)}  ${workspace.deployment.padEnd(deploymentWidth)}  ${workspace.mirrorOf.padEnd(mirrorWidth)}`);
             }
         }
         catch (error) {

package/dist/commands/workspace/set-profile/index.d.ts

@@ -6,6 +6,7 @@ export default class WorkspaceSetProfile extends Command {
     static description: string;
     static examples: string[];
     static flags: {
+        deployment: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         workspace: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;

package/dist/commands/workspace/set-profile/index.js

@@ -4,21 +4,38 @@ export default class WorkspaceSetProfile extends Command {
     static args = {
         profile: Args.string({ description: 'AWS profile name to set for the workspace', required: true }),
     };
-    static description = 'Set AWS profile for a workspace (cloud backend only).';
+    static description = 'Set AWS profile and deployment status for a workspace (cloud backend only).';
     static examples = ['<%= config.bin %> <%= command.id %> prod-profile -w production'];
     static flags = {
+        deployment: Flags.boolean({
+            allowNo: true,
+            char: 'd',
+            description: 'mark workspace as a deployment workspace (use --no-deployment to unset)',
+            required: false,
+        }),
         workspace: Flags.string({ char: 'w', description: 'workspace name', required: true }),
     };
     async run() {
         const { args, flags } = await this.parse(WorkspaceSetProfile);
         const backend = await getBackend();
         const updateResult = await backend.updateWorkspace({
+            isDeploy: flags.deployment,
             name: flags.workspace,
             profile: args.profile,
         });
         if (!updateResult.success) {
-            this.error(`Failed to set profile: ${updateResult.reason}`);
+            this.error(`Failed to update workspace: ${updateResult.reason}`);
         }
-        this.log(`Profile '${args.profile}' set for workspace '${flags.workspace}' successfully!`);
+        const messages = [];
+        messages.push(`Profile '${args.profile}' set for workspace '${flags.workspace}'`);
+        if (flags.deployment !== undefined) {
+            if (flags.deployment) {
+                messages.push(`Workspace marked as deployment workspace`);
+            }
+            else {
+                messages.push(`Workspace unmarked as deployment workspace`);
+            }
+        }
+        this.log(messages.join('. ') + '!');
     }
 }

package/dist/lib/flow-utils.js

@@ -1,6 +1,9 @@
 import { gitUtils } from './git-utils.js';
+import { addOrgPrefix, extractOrgPrefix } from './org-utils.js';
 export async function buildFlowWorkspaceName(options) {
     const { pin, profile, project, projectRootDir } = options;
+    // Extract org prefix from project
+    const { name: projectName, org } = extractOrgPrefix(project);
     // Get current git branch
     const gitBranch = await gitUtils.getCurrentGitBranch(projectRootDir);
     // Sanitize branch name
@@ -10,13 +13,15 @@ export async function buildFlowWorkspaceName(options) {
     }
     // Get commit SHA if pin is enabled
     const commitSHA = pin ? await gitUtils.getShortCommitSHA(projectRootDir) : null;
-    // Build workspace name parts
-    const parts = [project, sanitizedBranch];
+    // Build workspace name parts (without org prefix)
+    const parts = [projectName, sanitizedBranch];
     if (profile) {
         parts.push(profile);
     }
     if (commitSHA) {
         parts.push(commitSHA);
     }
-    return parts.join('---');
+    // Join parts and add org prefix if present
+    const workspaceName = parts.join('---');
+    return addOrgPrefix(org, workspaceName);
 }

package/dist/lib/workspace-validation.d.ts

@@ -0,0 +1,17 @@
+import { Backend } from '../backend/common.js';
+export interface WorkspaceValidationResult {
+    isValid: boolean;
+    message?: string;
+}
+/**
+ * Validates that a workspace exists and is marked as a deployment workspace (isDeploy=true)
+ */
+export declare function validateDeploymentWorkspace(workspaceName: string, backend: Backend, commandName: string): Promise<WorkspaceValidationResult>;
+/**
+ * Validates that a workspace exists and is NOT marked as a deployment workspace (isDeploy=false or undefined)
+ */
+export declare function validateDevelopmentWorkspace(workspaceName: string, backend: Backend, commandName: string): Promise<WorkspaceValidationResult>;
+/**
+ * Validates that flow commands are not used with deployment workspaces
+ */
+export declare function validateFlowCommand(workspaceName: string | undefined, backend: Backend): Promise<WorkspaceValidationResult>;

package/dist/lib/workspace-validation.js

@@ -0,0 +1,102 @@
+/**
+ * Validates that a workspace exists and is marked as a deployment workspace (isDeploy=true)
+ */
+export async function validateDeploymentWorkspace(workspaceName, backend, commandName) {
+    const result = await backend.getWorkspace(workspaceName);
+    if (!result.found) {
+        return {
+            isValid: false,
+            message: `Workspace '${workspaceName}' not found. Create a deployment workspace with:\n$ hereya workspace:create ${workspaceName} --deployment`,
+        };
+    }
+    if (result.hasError) {
+        return {
+            isValid: false,
+            message: `Error accessing workspace '${workspaceName}': ${result.error}`,
+        };
+    }
+    const { workspace } = result;
+    if (!workspace.isDeploy) {
+        return {
+            isValid: false,
+            message: `Cannot use '${commandName}' with development workspace '${workspaceName}'.
+
+The '${commandName}' command requires a deployment workspace. You have two options:
+
+1. Create a deployment workspace:
+   $ hereya workspace:create prod-deployment --deployment
+
+2. Convert existing workspace to deployment (if using cloud backend):
+   $ hereya workspace:set-profile ${workspaceName} --deployment
+
+Then run: $ hereya ${commandName} -w prod-deployment`,
+        };
+    }
+    return { isValid: true };
+}
+/**
+ * Validates that a workspace exists and is NOT marked as a deployment workspace (isDeploy=false or undefined)
+ */
+export async function validateDevelopmentWorkspace(workspaceName, backend, commandName) {
+    const result = await backend.getWorkspace(workspaceName);
+    if (!result.found) {
+        return {
+            isValid: false,
+            message: `Workspace '${workspaceName}' not found. Create a workspace with:\n$ hereya workspace:create ${workspaceName}`,
+        };
+    }
+    if (result.hasError) {
+        return {
+            isValid: false,
+            message: `Error accessing workspace '${workspaceName}': ${result.error}`,
+        };
+    }
+    const { workspace } = result;
+    if (workspace.isDeploy === true) {
+        return {
+            isValid: false,
+            message: `Cannot use '${commandName}' with deployment workspace '${workspaceName}'.
+
+The '${commandName}' command is for development workspaces only. Deployment workspaces 
+should only be managed through 'deploy' and 'undeploy' commands.
+
+To work with packages in development:
+1. Use a development workspace: $ hereya ${commandName} <args> -w dev-workspace
+2. Or create a new one: $ hereya workspace:create dev-workspace`,
+        };
+    }
+    return { isValid: true };
+}
+/**
+ * Validates that flow commands are not used with deployment workspaces
+ */
+export async function validateFlowCommand(workspaceName, backend) {
+    if (!workspaceName) {
+        // If no workspace specified, flow commands will create their own
+        return { isValid: true };
+    }
+    const result = await backend.getWorkspace(workspaceName);
+    if (!result.found) {
+        // Workspace doesn't exist, flow command will create it
+        return { isValid: true };
+    }
+    if (result.hasError) {
+        return {
+            isValid: false,
+            message: `Error accessing workspace '${workspaceName}': ${result.error}`,
+        };
+    }
+    const { workspace } = result;
+    if (workspace.isDeploy === true) {
+        return {
+            isValid: false,
+            message: `Flow commands cannot be used with deployment workspaces.
+
+Flow commands are designed for feature branch development workflows.
+For deployment workspaces, use the standard 'deploy' and 'undeploy' commands.
+
+Current workspace '${workspaceName}' is marked as a deployment workspace.`,
+        };
+    }
+    return { isValid: true };
+}