@ollie-shop/cli 0.3.0 → 0.3.3

package/src/actions/function.actions.ts

@@ -1,23 +1,32 @@
+import {
+  buildAndDeployFunctionFromDirectory,
+  buildFunction as buildFunctionService,
+  createFunction as createFunctionService,
+  testFunction as testFunctionService,
+  validateFunction as validateFunctionService,
+} from "@ollie-shop/core";
 import type {
   FunctionBuildOptions,
   FunctionCreateOptions,
   FunctionDeployOptions,
-  FunctionListItem,
   FunctionTestOptions,
 } from "../schemas/command.schema";
-import { FunctionListItemSchema } from "../schemas/command.schema";
 import type { CliConsole } from "../utils/console";
+import { ERROR_MESSAGES } from "../utils/constants";
+import { getContextualPath } from "../utils/context-detector.js";
+import {
+  configureBuilderUrl,
+  handleDeploymentError,
+  handleDeploymentResult,
+  showDeploymentSuccess,
+  waitForDeploymentWithProgress,
+} from "../utils/deploy-helpers";
 import { handleValidationResult } from "../utils/validation-helpers";
 
 export async function createFunction(
   options: FunctionCreateOptions,
   cliConsole: CliConsole,
 ): Promise<void> {
-  // Lazy import - only loaded when this function is called
-  const { createFunction: createFunctionService } = await import(
-    "@ollie-shop/core"
-  );
-
   const spinner = cliConsole.spinner({
     text: "Creating function...",
   });
@@ -55,6 +64,14 @@ export async function createFunction(
     ]);
   } catch (error) {
     spinner.fail("Failed to create function");
+    const { message, stack } =
+      error instanceof Error
+        ? error
+        : { message: "Unexpected error", stack: undefined };
+    cliConsole.error(`Error details: ${message}`);
+    if (stack) {
+      cliConsole.debug(`Stack trace: ${stack}`);
+    }
     throw error;
   }
 }
@@ -63,12 +80,6 @@ export async function buildFunction(
   options: FunctionBuildOptions,
   cliConsole: CliConsole,
 ): Promise<void> {
-  // Lazy import - only loaded when this function is called
-  const { buildFunction: buildFunctionService } = await import(
-    "@ollie-shop/core"
-  );
-  const { getContextualPath } = await import("../utils/context-detector.js");
-
   const targetPath = getContextualPath(options.path, "function");
   const spinner = cliConsole.spinner({ text: "Building function..." });
 
@@ -93,11 +104,6 @@ export async function testFunction(
   options: FunctionTestOptions,
   cliConsole: CliConsole,
 ): Promise<void> {
-  const { testFunction: testFunctionService } = await import(
-    "@ollie-shop/core"
-  );
-  const { getContextualPath } = await import("../utils/context-detector.js");
-
   const targetPath = getContextualPath(options.path, "function");
   const spinner = cliConsole.spinner({ text: "Testing function..." });
 
@@ -116,6 +122,14 @@ export async function testFunction(
     }
   } catch (error) {
     spinner.fail("Tests failed");
+    const { message, stack } =
+      error instanceof Error
+        ? error
+        : { message: "Unexpected error", stack: undefined };
+    cliConsole.error(`Error details: ${message}`);
+    if (stack) {
+      cliConsole.debug(`Stack trace: ${stack}`);
+    }
     throw error;
   }
 }
@@ -124,12 +138,6 @@ export async function validateFunction(
   options: { path?: string; strict?: boolean; fix?: boolean },
   cliConsole: CliConsole,
 ): Promise<void> {
-  // Lazy import - only loaded when this function is called
-  const { validateFunction: validateFunctionService } = await import(
-    "@ollie-shop/core"
-  );
-  const { getContextualPath } = await import("../utils/context-detector.js");
-
   const targetPath = getContextualPath(options.path, "function");
   const spinner = cliConsole.spinner({ text: "Validating function..." });
 
@@ -138,176 +146,75 @@ export async function validateFunction(
     handleValidationResult(result, spinner, cliConsole, "Function");
   } catch (error) {
     spinner.fail("Validation failed");
+    const { message, stack } =
+      error instanceof Error
+        ? error
+        : { message: "Unexpected error", stack: undefined };
+    cliConsole.error(`Error details: ${message}`);
+    if (stack) {
+      cliConsole.debug(`Stack trace: ${stack}`);
+    }
     throw error;
   }
 }
 
 export async function deployFunction(
-  options: FunctionDeployOptions & { wait?: boolean },
+  options: FunctionDeployOptions,
   cliConsole: CliConsole,
 ): Promise<void> {
   if (!options.functionId) {
-    throw new Error("Function ID is required for deployment");
+    throw new Error(ERROR_MESSAGES.FUNCTION_ID_REQUIRED);
   }
 
+  configureBuilderUrl();
+
   const spinner = cliConsole.spinner({
-    text: "Building and deploying function...",
+    text: "Preparing function for deployment...",
   });
 
   try {
-    // For CLI demo purposes, simulate deployment without Supabase
-    // In production, this would use the builder API directly
-    const buildId = `build-${Date.now()}`;
-    const result = {
-      buildId,
-      status: "IN_PROGRESS" as const,
-      startTime: new Date().toISOString(),
-    };
-
-    spinner.succeed("Function deployment initiated!");
-    cliConsole.success(`Build ID: ${result.buildId}`);
-    cliConsole.info(`Initial Status: ${result.status}`);
+    const functionPath = options.path || process.cwd();
+    const result = await buildAndDeployFunctionFromDirectory(
+      options.functionId,
+      functionPath,
+    );
 
-    // If wait flag is set, simulate deployment progress
-    if (options.wait) {
-      // Stop spinner and use rich progress reporter
-      spinner.stop();
+    handleDeploymentResult(result, "function", cliConsole, spinner);
+    spinner.stop();
 
-      const { RichProgressReporter } = await import(
-        "../utils/rich-progress.js"
+    try {
+      const { completedBuild, duration } = await waitForDeploymentWithProgress(
+        result.buildId,
+        "function",
+        cliConsole,
       );
-      const progressReporter = new RichProgressReporter();
-      progressReporter.start();
-
-      try {
-        // Simulate deployment progress for demo
-        const phases = [
-          {
-            phase: "validate",
-            message: "Validating function...",
-            progress: 0.1,
-          },
-          { phase: "build", message: "Building function...", progress: 0.3 },
-          {
-            phase: "bundle",
-            message: "Creating deployment package...",
-            progress: 0.5,
-            metadata: { bundleSize: 85000, gzippedSize: 28000 },
-          },
-          { phase: "upload", message: "Uploading to Lambda...", progress: 0.7 },
-          {
-            phase: "deploy",
-            message: "Configuring function...",
-            progress: 0.9,
-          },
-          { phase: "complete", message: "Deployment complete!", progress: 1.0 },
-        ];
 
-        // Simulate progress updates
-        for (const update of phases) {
-          await new Promise((resolve) => setTimeout(resolve, 800));
-          progressReporter.updateProgress(update);
-        }
-
-        const functionUrl = `https://api.ollie.shop/functions/${options.functionId}`;
-        const duration = 4.8; // simulated duration
-
-        progressReporter.stop(true);
-
-        cliConsole.success(`\nFunction URL: ${functionUrl}`);
-        cliConsole.info(`Duration: ${duration}s`);
-      } catch (error) {
-        progressReporter.stop(false);
-        throw error;
-      }
-    } else {
-      // Async mode - just show next steps
-      cliConsole.nextSteps("Monitor deployment", [
-        {
-          description: "Check deployment status",
-          command: `ollieshop function deploy-status ${result.buildId}`,
-        },
-        {
-          description: "Or deploy with --wait flag to wait for completion",
-          command: `ollieshop function deploy --id ${options.functionId} --wait`,
-        },
-      ]);
+      showDeploymentSuccess(
+        completedBuild,
+        duration,
+        options.functionId,
+        "function",
+        cliConsole,
+      );
+    } catch (error) {
+      handleDeploymentError(error, result.buildId, "function", cliConsole);
+      throw error;
     }
   } catch (error) {
-    spinner.fail("Deployment failed");
+    if (spinner.isSpinning) {
+      spinner.fail("Deployment failed");
+    }
     throw error;
   }
 }
 
 export async function listFunctions(cliConsole: CliConsole): Promise<void> {
-  const spinner = cliConsole.spinner({ text: "Loading functions..." });
-
-  try {
-    // For CLI demo purposes, return mock functions
-    // In production, this would use the API directly
-    const rawFunctions = [
-      {
-        id: "func-1",
-        name: "validate-cart",
-        active: true,
-        createdAt: new Date().toISOString(),
-        invocation: "request",
-      },
-      {
-        id: "func-2",
-        name: "apply-discount",
-        active: true,
-        createdAt: new Date(Date.now() - 86400000).toISOString(),
-        invocation: "response",
-      },
-    ];
-
-    // Map core function types to CLI display format
-    const functions: FunctionListItem[] = rawFunctions.map((func) =>
-      FunctionListItemSchema.parse({
-        id: func.id,
-        name: func.name,
-        runtime: "nodejs18.x", // TODO: Get from function metadata
-        version: "1.0.0", // TODO: Get version from function metadata
-        enabled: func.active,
-        createdAt: func.createdAt,
-        invocation: "request",
-        priority: 0,
-        onError: "throw",
-        description: "Function description", // TODO: Get from metadata
-      }),
-    );
-
-    spinner.succeed();
-
-    if (functions.length === 0) {
-      cliConsole.warn("No functions found");
-      cliConsole.suggestions([
-        "Create your first function with: ollieshop function create",
-        "Check our documentation at: https://docs.ollie.shop/functions",
-      ]);
-      return;
-    }
-
-    cliConsole.info(
-      `Found ${functions.length} function${functions.length === 1 ? "" : "s"}:\n`,
-    );
-
-    cliConsole.table(
-      functions.map((f) => ({
-        ID: f.id,
-        Name: f.name,
-        Runtime: f.runtime || "nodejs18.x",
-        Version: f.version || "N/A",
-        Enabled: f.enabled ? "✓" : "✗",
-        Created: new Date(f.createdAt).toLocaleDateString(),
-        Invocation: f.invocation || "N/A",
-        Priority: f.priority || "N/A",
-        "On Error": f.onError || "N/A",
-      })),
-    );
-  } catch (error) {
-    spinner.fail("Failed to list functions");
-    throw error;
-  }
+  cliConsole.info(
+    "Function listing is currently only available through the admin dashboard.",
+  );
+  cliConsole.suggestions([
+    "Create your first function with: ollieshop function create",
+    "Deploy functions with: ollieshop function deploy --id <function-id>",
+    "Visit the admin dashboard to view existing functions",
+  ]);
 }

package/src/actions/project.actions.ts

@@ -87,21 +87,23 @@ export async function buildProject(
   options: { path?: string; watch?: boolean },
   cliConsole: CliConsole,
 ): Promise<void> {
-  // TODO: Implement project building functionality
-  // This function needs to be implemented in the core package
-
   const targetPath = options.path || process.cwd();
 
-  cliConsole.warn("Project building is not yet implemented");
+  cliConsole.info(
+    "Project building is available through individual component and function builds.",
+  );
   cliConsole.info(`Target path: ${targetPath}`);
 
   if (options.watch) {
-    cliConsole.info("Watch mode would be enabled when implemented");
+    cliConsole.info(
+      "Use watch mode on individual components and functions for development.",
+    );
   }
 
   cliConsole.suggestions([
     "Build components individually with: ollieshop component build",
     "Build functions individually with: ollieshop function build",
+    "Use watch mode: ollieshop component build --watch",
   ]);
 }
 
@@ -109,18 +111,21 @@ export async function startDevServer(
   options: { port?: number; open?: boolean },
   cliConsole: CliConsole,
 ): Promise<void> {
-  // TODO: Implement development server functionality
-  // This function needs to be implemented in the core package
-
-  cliConsole.warn("Development server is not yet implemented");
-  cliConsole.info(`Would start server on port ${options.port || 3000}`);
+  cliConsole.info(
+    "Development server functionality is available through individual component and function development.",
+  );
+  cliConsole.info(`Target port: ${options.port || 3000}`);
 
   if (options.open) {
-    cliConsole.info("Would open browser when implemented");
+    cliConsole.info(
+      "Use --open flag with individual component development servers.",
+    );
   }
 
   cliConsole.suggestions([
     "Start component development with: cd components/[name] && npm run dev",
     "Start function development with: cd functions/[name] && npm run dev",
+    "Create components with: ollieshop component create",
+    "Create functions with: ollieshop function create",
   ]);
 }

package/src/commands/__tests__/component.test.ts

@@ -14,7 +14,6 @@ vi.mock("../../actions/component.actions", () => ({
   listComponents: vi.fn(),
   deployComponent: vi.fn(),
   validateComponent: vi.fn(),
-  checkDeployStatus: vi.fn(),
 }));
 
 // Import mocked actions
@@ -223,7 +222,7 @@ describe("Component Command", () => {
         "--path",
         "./my-component",
         "--id",
-        "comp-123",
+        "123e4567-e89b-12d3-a456-426614174000",
       ]);
 
       // Assert
@@ -231,7 +230,7 @@ describe("Component Command", () => {
       expect(componentActions.deployComponent).toHaveBeenCalledWith(
         expect.objectContaining({
           path: "./my-component",
-          wait: false,
+          componentId: "123e4567-e89b-12d3-a456-426614174000",
         }),
         expect.any(Object),
       );
@@ -246,16 +245,14 @@ describe("Component Command", () => {
         "component",
         "deploy",
         "--id",
-        "comp-123",
-        "--wait",
+        "123e4567-e89b-12d3-a456-426614174000",
       ]);
 
       // Assert
       expect(result.exitCode).toBe(0);
       expect(componentActions.deployComponent).toHaveBeenCalledWith(
         expect.objectContaining({
-          componentId: "comp-123",
-          wait: true,
+          componentId: "123e4567-e89b-12d3-a456-426614174000",
         }),
         expect.any(Object),
       );

package/src/commands/__tests__/function.test.ts

@@ -237,7 +237,7 @@ describe("Function Command", () => {
         "--path",
         "./my-function",
         "--id",
-        "func-123",
+        "123e4567-e89b-12d3-a456-426614174000",
       ]);
 
       // Assert

package/src/commands/__tests__/store-version.test.ts

@@ -1,8 +1,5 @@
 import type { Command } from "@commander-js/extra-typings";
-import {
-  storeFactory,
-  versionFactory,
-} from "@ollie-shop/core/__tests__/factories";
+import { storeFactory, versionFactory } from "@ollie-shop/core/testing";
 import {
   createTestProgram,
   executeCLI,

package/src/commands/component.ts

@@ -140,11 +140,6 @@ export function registerComponentCommands(program: Command): void {
         required: true,
       },
       COMMON_OPTIONS.path,
-      {
-        flags: "--wait",
-        description: "Wait for deployment to complete",
-        defaultValue: false,
-      },
     ],
     schema: ComponentDeployOptionsSchema,
     examples: [
@@ -152,17 +147,12 @@ export function registerComponentCommands(program: Command): void {
         description: "Deploy a component",
         command: "ollieshop component deploy --id comp-123",
       },
-      {
-        description: "Deploy and wait for completion",
-        command: "ollieshop component deploy --id comp-123 --wait",
-      },
     ],
     handler: async (options: ComponentDeployOptions, console) => {
       // Map id to componentId if provided
       const deployOptions = {
         path: options.path,
         componentId: options.id || options.componentId,
-        wait: options.wait,
       };
       await componentActions.deployComponent(deployOptions, console);
     },

package/src/commands/function.ts

@@ -158,21 +158,17 @@ export function registerFunctionCommands(program: Command): void {
         description: "Function ID for deployment",
         required: true,
       },
-      COMMON_OPTIONS.wait,
     ],
     schema: FunctionDeployOptionsSchema,
     examples: [
       {
         description: "Deploy current directory",
-        command: "ollieshop function deploy",
-      },
-      {
-        description: "Deploy specific function and wait",
-        command: "ollieshop function deploy --path ./my-function --wait",
+        command: "ollieshop function deploy --id func_123abc",
       },
       {
-        description: "Deploy with function ID",
-        command: "ollieshop function deploy --id func_123abc",
+        description: "Deploy specific function",
+        command:
+          "ollieshop function deploy --path ./my-function --id func_123abc",
       },
     ],
     handler: async (options: FunctionDeployOptions, console) => {
@@ -180,7 +176,6 @@ export function registerFunctionCommands(program: Command): void {
       const deployOptions = {
         path: options.path || process.cwd(),
         functionId: options.id || options.functionId,
-        wait: options.wait,
       };
       await functionActions.deployFunction(deployOptions, console);
     },
@@ -202,51 +197,5 @@ export function registerFunctionCommands(program: Command): void {
     },
   });
 
-  // Deploy status command
-  cmd
-    .command("deploy-status <buildId>")
-    .description("Check the status of a function deployment")
-    .action(async (buildId) => {
-      try {
-        const { getBuildStatus } = await import("@ollie-shop/core");
-        const { console: cliConsole } = await import("../utils/console.js");
-        const spinner = cliConsole.spinner("Checking deployment status...");
-
-        const build = await getBuildStatus(buildId);
-
-        if (!build) {
-          spinner.fail("Build not found");
-          return;
-        }
-
-        spinner.succeed();
-
-        cliConsole.info("Deployment Status:");
-        cliConsole.log(`  Build ID: ${build.id}`);
-        cliConsole.log(`  Status: ${build.status}`);
-        cliConsole.log(
-          `  Started: ${new Date(build.startTime).toLocaleString()}`,
-        );
-
-        if (build.endTime) {
-          cliConsole.log(
-            `  Completed: ${new Date(build.endTime).toLocaleString()}`,
-          );
-        }
-
-        if (build.deploymentUrl) {
-          cliConsole.success(`\nFunction URL: ${build.deploymentUrl}`);
-        }
-
-        if (build.error) {
-          cliConsole.error(`\nError: ${build.error}`);
-        }
-      } catch (error) {
-        const { console: cliConsole } = await import("../utils/console.js");
-        cliConsole.error(
-          `Error: ${error instanceof Error ? error.message : String(error)}`,
-        );
-        process.exit(1);
-      }
-    });
+  // deploy-status command removed - no longer needed since deployments always wait for completion
 }