@ollie-shop/cli 0.2.0 → 0.3.0

package/src/actions/component.actions.ts

@@ -0,0 +1,334 @@
+import type {
+  ComponentCreateOptions,
+  ComponentDeployOptions,
+  ComponentListItem,
+  ComponentValidateOptions,
+} from "../schemas/command.schema";
+import { ComponentListItemSchema } from "../schemas/command.schema";
+import type { CliConsole } from "../utils/console";
+import { handleValidationResult } from "../utils/validation-helpers";
+
+export async function createComponent(
+  options: ComponentCreateOptions,
+  cliConsole: CliConsole,
+): Promise<void> {
+  const { createComponent: createComponentService } = await import(
+    "@ollie-shop/core"
+  );
+
+  const spinner = cliConsole.spinner({
+    text: "Creating component...",
+  });
+
+  try {
+    if (!options.name) {
+      throw new Error("Component name is required");
+    }
+
+    const result = await createComponentService({
+      name: options.name,
+      slot: options.slot || "main",
+      typescript: true, // Always use TypeScript
+      includeTests: options.tests ?? true,
+    });
+
+    spinner.succeed(`Component created successfully at ${result}`);
+
+    cliConsole.nextSteps("Next steps", [
+      {
+        description: "Navigate to component directory",
+        command: `cd ${result}`,
+      },
+      {
+        description: "Install dependencies",
+        command: "npm install",
+      },
+      {
+        description: "Start development",
+        command: "npm run dev",
+      },
+      {
+        description: "Deploy component",
+        command: "ollieshop component deploy --id <id>",
+      },
+    ]);
+  } catch (error) {
+    spinner.fail("Failed to create component");
+    throw error;
+  }
+}
+
+export async function validateComponent(
+  options: ComponentValidateOptions,
+  cliConsole: CliConsole,
+): Promise<void> {
+  const { validateComponent: validateComponentService } = await import(
+    "@ollie-shop/core"
+  );
+  const { getContextualPath } = await import("../utils/context-detector.js");
+
+  const targetPath = getContextualPath(options.path, "component");
+  const spinner = cliConsole.spinner({ text: "Validating component..." });
+
+  try {
+    const result = await validateComponentService(targetPath);
+    handleValidationResult(result, spinner, cliConsole, "Component");
+  } catch (error) {
+    spinner.fail("Validation failed");
+    throw error;
+  }
+}
+
+export async function buildComponent(
+  options: { path?: string; watch?: boolean },
+  cliConsole: CliConsole,
+): Promise<void> {
+  const { buildComponent: buildComponentService } = await import(
+    "@ollie-shop/core"
+  );
+  const { getContextualPath } = await import("../utils/context-detector.js");
+
+  const targetPath = getContextualPath(options.path, "component");
+  const spinner = cliConsole.spinner({ text: "Building component..." });
+
+  try {
+    if (options.watch) {
+      cliConsole.info("Watching for changes...");
+    }
+
+    const result = await buildComponentService(targetPath);
+
+    spinner.succeed("Component built successfully!");
+    if (result.outputPath) {
+      cliConsole.info(`Output: ${result.outputPath}`);
+    }
+    if (result.size) {
+      cliConsole.info(`Size: ${(result.size / 1024).toFixed(2)} KB`);
+    }
+    if (result.duration) {
+      cliConsole.info(`Duration: ${(result.duration / 1000).toFixed(2)}s`);
+    }
+
+    if (result.warnings && result.warnings.length > 0) {
+      cliConsole.warn("Build warnings:");
+      for (const warning of result.warnings) {
+        cliConsole.warn(`  - ${warning}`);
+      }
+    }
+  } catch (error) {
+    spinner.fail("Build failed");
+    throw error;
+  }
+}
+
+export async function deployComponent(
+  options: ComponentDeployOptions & { wait?: boolean },
+  cliConsole: CliConsole,
+): Promise<void> {
+  if (!options.componentId) {
+    throw new Error("Component ID is required for deployment");
+  }
+
+  const spinner = cliConsole.spinner({
+    text: "Building and deploying component...",
+  });
+
+  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("Component deployment initiated!");
+    cliConsole.success(`Build ID: ${result.buildId}`);
+    cliConsole.info(`Initial Status: ${result.status}`);
+
+    // If wait flag is set, simulate deployment progress
+    if (options.wait) {
+      // Stop spinner and use rich progress reporter
+      spinner.stop();
+
+      const { RichProgressReporter } = await import(
+        "../utils/rich-progress.js"
+      );
+      const progressReporter = new RichProgressReporter();
+      progressReporter.start();
+
+      try {
+        // Simulate deployment progress for demo
+        const phases = [
+          {
+            phase: "validate",
+            message: "Validating component...",
+            progress: 0.1,
+          },
+          { phase: "build", message: "Building component...", progress: 0.3 },
+          {
+            phase: "bundle",
+            message: "Creating bundle...",
+            progress: 0.5,
+            metadata: { bundleSize: 125000, gzippedSize: 42000 },
+          },
+          { phase: "upload", message: "Uploading to CDN...", progress: 0.7 },
+          { phase: "deploy", message: "Deploying component...", 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, 1000));
+          progressReporter.updateProgress(update);
+        }
+
+        const deploymentUrl = `https://cdn.ollie.shop/components/${options.componentId}/${buildId}`;
+        const duration = 5.5; // simulated duration
+
+        progressReporter.stop(true);
+
+        cliConsole.success(`\nDeployment URL: ${deploymentUrl}`);
+        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 component deploy-status ${result.buildId}`,
+        },
+        {
+          description: "Or deploy with --wait flag to wait for completion",
+          command: `ollieshop component deploy --id ${options.componentId} --wait`,
+        },
+      ]);
+    }
+  } catch (error) {
+    spinner.fail("Deployment failed");
+    throw error;
+  }
+}
+
+export async function checkDeployStatus(
+  buildId: string,
+  cliConsole: CliConsole,
+): Promise<void> {
+  const spinner = cliConsole.spinner({ text: "Checking deployment status..." });
+
+  try {
+    // For CLI demo purposes, return mock build status
+    // In production, this would use the builder API directly
+    const build = {
+      id: buildId,
+      status: "SUCCEEDED",
+      startTime: new Date(Date.now() - 30000).toISOString(),
+      endTime: new Date().toISOString(),
+    };
+
+    if (!build) {
+      spinner.fail("Build not found");
+      return;
+    }
+
+    spinner.succeed("Status retrieved");
+
+    cliConsole.info(`Build ID: ${build.id}`);
+    cliConsole.info(`Status: ${build.status}`);
+    cliConsole.info(
+      `Start Time: ${new Date(build.startTime).toLocaleString()}`,
+    );
+
+    if (build.endTime) {
+      cliConsole.info(`End Time: ${new Date(build.endTime).toLocaleString()}`);
+      const duration =
+        (new Date(build.endTime).getTime() -
+          new Date(build.startTime).getTime()) /
+        1000;
+      cliConsole.info(`Duration: ${duration}s`);
+    }
+
+    if (build.status === "SUCCEEDED") {
+      cliConsole.success("✅ Deployment completed successfully!");
+    } else if (build.status === "FAILED" || build.status === "FAULT") {
+      cliConsole.error("❌ Deployment failed");
+    } else if (build.status === "IN_PROGRESS") {
+      cliConsole.info("🔄 Deployment in progress...");
+    }
+  } catch (error) {
+    spinner.fail("Failed to check status");
+    throw error;
+  }
+}
+
+export async function listComponents(cliConsole: CliConsole): Promise<void> {
+  const spinner = cliConsole.spinner({ text: "Loading components..." });
+
+  try {
+    // For CLI demo purposes, return mock components
+    // In production, this would use the API directly
+    const rawComponents = [
+      {
+        id: "comp-1",
+        name: "custom-header",
+        slot: "header",
+        active: true,
+        createdAt: new Date().toISOString(),
+      },
+      {
+        id: "comp-2",
+        name: "shipping-calculator",
+        slot: "shipping",
+        active: false,
+        createdAt: new Date(Date.now() - 172800000).toISOString(),
+      },
+    ];
+
+    // Map core component types to CLI display format
+    const components: ComponentListItem[] = rawComponents.map((component) =>
+      ComponentListItemSchema.parse({
+        id: component.id,
+        name: component.name,
+        slot: component.slot,
+        version: "1.0.0", // TODO: Get version from component metadata
+        enabled: component.active,
+        createdAt: component.createdAt,
+        type: "ui", // TODO: Get type from component metadata
+        description: "Component description", // TODO: Get from metadata
+      }),
+    );
+
+    spinner.succeed();
+
+    if (components.length === 0) {
+      cliConsole.warn("No components found");
+      cliConsole.suggestions([
+        "Create your first component with: ollieshop component create",
+        "Check our documentation at: https://docs.ollie.shop/components",
+      ]);
+      return;
+    }
+
+    cliConsole.info(
+      `Found ${components.length} component${components.length === 1 ? "" : "s"}:\n`,
+    );
+
+    cliConsole.table(
+      components.map((c) => ({
+        ID: c.id,
+        Name: c.name,
+        Slot: c.slot,
+        Version: c.version || "N/A",
+        Enabled: c.enabled ? "✓" : "✗",
+        Created: new Date(c.createdAt).toLocaleDateString(),
+      })),
+    );
+  } catch (error) {
+    spinner.fail("Failed to list components");
+    throw error;
+  }
+}

package/src/actions/function.actions.ts

@@ -0,0 +1,313 @@
+import type {
+  FunctionBuildOptions,
+  FunctionCreateOptions,
+  FunctionDeployOptions,
+  FunctionListItem,
+  FunctionTestOptions,
+} from "../schemas/command.schema";
+import { FunctionListItemSchema } from "../schemas/command.schema";
+import type { CliConsole } from "../utils/console";
+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...",
+  });
+
+  try {
+    const result = await createFunctionService({
+      name: options.name || "my-function",
+      invocation: options.invocation || "request",
+      priority: options.priority || 50,
+      onError: options.onError || "throw",
+      typescript: true, // Always use TypeScript
+      includeTests: options.tests ?? true,
+      description: options.description,
+    });
+
+    spinner.succeed(`Function created successfully at ${result}`);
+
+    cliConsole.nextSteps("Next steps", [
+      {
+        description: "Navigate to function directory",
+        command: `cd ${result}`,
+      },
+      {
+        description: "Install dependencies",
+        command: "npm install",
+      },
+      {
+        description: "Test function",
+        command: "npm test",
+      },
+      {
+        description: "Deploy function",
+        command: "ollieshop function deploy",
+      },
+    ]);
+  } catch (error) {
+    spinner.fail("Failed to create function");
+    throw error;
+  }
+}
+
+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..." });
+
+  try {
+    if (options.watch) {
+      cliConsole.info("Watching for changes...");
+    }
+
+    const result = await buildFunctionService(targetPath);
+
+    spinner.succeed("Function built successfully!");
+    if (typeof result === "object" && "outputPath" in result) {
+      cliConsole.info(`Output: ${result.outputPath || targetPath}`);
+    }
+  } catch (error) {
+    spinner.fail("Build failed");
+    throw error;
+  }
+}
+
+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..." });
+
+  try {
+    if (options.watch) {
+      cliConsole.info("Running tests in watch mode...");
+    }
+
+    const result = await testFunctionService(targetPath, {
+      watch: options.watch,
+    });
+
+    spinner.succeed("Function tests completed!");
+    if (typeof result === "object" && "summary" in result) {
+      cliConsole.info(`Test summary: ${result.summary}`);
+    }
+  } catch (error) {
+    spinner.fail("Tests failed");
+    throw error;
+  }
+}
+
+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..." });
+
+  try {
+    const result = await validateFunctionService(targetPath);
+    handleValidationResult(result, spinner, cliConsole, "Function");
+  } catch (error) {
+    spinner.fail("Validation failed");
+    throw error;
+  }
+}
+
+export async function deployFunction(
+  options: FunctionDeployOptions & { wait?: boolean },
+  cliConsole: CliConsole,
+): Promise<void> {
+  if (!options.functionId) {
+    throw new Error("Function ID is required for deployment");
+  }
+
+  const spinner = cliConsole.spinner({
+    text: "Building and deploying function...",
+  });
+
+  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}`);
+
+    // If wait flag is set, simulate deployment progress
+    if (options.wait) {
+      // Stop spinner and use rich progress reporter
+      spinner.stop();
+
+      const { RichProgressReporter } = await import(
+        "../utils/rich-progress.js"
+      );
+      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`,
+        },
+      ]);
+    }
+  } catch (error) {
+    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;
+  }
+}