@ollie-shop/cli 0.3.4 → 1.0.1

package/src/actions/component.actions.ts

@@ -1,278 +0,0 @@
-import {
-  buildAndDeployComponentFromDirectory,
-  buildComponent as buildComponentService,
-  createComponent as createComponentService,
-  validateComponent as validateComponentService,
-} from "@ollie-shop/core";
-import type {
-  ComponentCreateOptions,
-  ComponentDeployOptions,
-  ComponentValidateOptions,
-} 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";
-
-/**
- * Create a new component from a template
- * Generates component files with TypeScript setup and optional tests
- *
- * @async
- * @param {ComponentCreateOptions} options - Component creation options
- * @param {CliConsole} cliConsole - Console instance for output
- * @throws {Error} If component name is not provided or creation fails
- * @example
- * ```typescript
- * await createComponent({
- *   name: "shopping-cart",
- *   slot: "sidebar",
- *   tests: true
- * }, console);
- * ```
- */
-export async function createComponent(
-  options: ComponentCreateOptions,
-  cliConsole: CliConsole,
-): Promise<void> {
-  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");
-    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;
-  }
-}
-
-/**
- * Validate a component's structure and configuration
- * Checks for required files, proper exports, and valid metadata
- *
- * @async
- * @param {ComponentValidateOptions} options - Validation options including path
- * @param {CliConsole} cliConsole - Console instance for output
- * @throws {Error} If validation fails or path is invalid
- * @example
- * ```typescript
- * await validateComponent({
- *   path: "./components/shopping-cart"
- * }, console);
- * ```
- */
-export async function validateComponent(
-  options: ComponentValidateOptions,
-  cliConsole: CliConsole,
-): Promise<void> {
-  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");
-    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;
-  }
-}
-
-/**
- * Build a component for production deployment
- * Bundles the component with optimizations and outputs build metrics
- *
- * @async
- * @param {Object} options - Build options
- * @param {string} [options.path] - Component path (defaults to current directory)
- * @param {boolean} [options.watch] - Enable watch mode for development
- * @param {CliConsole} cliConsole - Console instance for output
- * @throws {Error} If build fails
- * @example
- * ```typescript
- * await buildComponent({
- *   path: "./components/shopping-cart",
- *   watch: false
- * }, console);
- * ```
- */
-export async function buildComponent(
-  options: { path?: string; watch?: boolean },
-  cliConsole: CliConsole,
-): Promise<void> {
-  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;
-  }
-}
-
-/**
- * Deploy a component to the Ollie Shop infrastructure
- * Builds and uploads the component to CloudFront CDN with real-time progress
- *
- * @async
- * @param {ComponentDeployOptions} options - Deployment options
- * @param {CliConsole} cliConsole - Console instance for output
- * @throws {Error} If component ID is not provided or deployment fails
- * @example
- * ```typescript
- * await deployComponent({
- *   componentId: "123e4567-e89b-12d3-a456-426614174000",
- *   path: "./components/shopping-cart"
- * }, console);
- * ```
- */
-export async function deployComponent(
-  options: ComponentDeployOptions,
-  cliConsole: CliConsole,
-): Promise<void> {
-  if (!options.componentId) {
-    throw new Error(ERROR_MESSAGES.COMPONENT_ID_REQUIRED);
-  }
-
-  configureBuilderUrl();
-
-  const spinner = cliConsole.spinner({
-    text: "Preparing component for deployment...",
-  });
-
-  try {
-    const componentPath = options.path || process.cwd();
-    const result = await buildAndDeployComponentFromDirectory(
-      options.componentId,
-      componentPath,
-    );
-
-    handleDeploymentResult(result, "component", cliConsole, spinner);
-    spinner.stop();
-
-    try {
-      const { completedBuild, duration } = await waitForDeploymentWithProgress(
-        result.buildId,
-        "component",
-        cliConsole,
-      );
-
-      showDeploymentSuccess(
-        completedBuild,
-        duration,
-        options.componentId,
-        "component",
-        cliConsole,
-      );
-    } catch (error) {
-      handleDeploymentError(error, result.buildId, "component", cliConsole);
-      throw error;
-    }
-  } catch (error) {
-    if (spinner.isSpinning) {
-      spinner.fail("Deployment failed");
-    }
-    throw error;
-  }
-}
-
-// checkDeployStatus function removed - no longer needed since deployments always wait for completion
-
-/**
- * List all components for the current store
- * Currently displays information about accessing components via admin dashboard
- *
- * @async
- * @param {CliConsole} cliConsole - Console instance for output
- * @example
- * ```typescript
- * await listComponents(console);
- * // Shows suggestions for creating and managing components
- * ```
- */
-export async function listComponents(cliConsole: CliConsole): Promise<void> {
-  cliConsole.info(
-    "Component listing is currently only available through the admin dashboard.",
-  );
-  cliConsole.suggestions([
-    "Create your first component with: ollieshop component create",
-    "Deploy components with: ollieshop component deploy --id <component-id>",
-    "Visit the admin dashboard to view existing components",
-  ]);
-}

package/src/actions/function.actions.ts

@@ -1,220 +0,0 @@
-import {
-  buildAndDeployFunctionFromDirectory,
-  buildFunction as buildFunctionService,
-  createFunction as createFunctionService,
-  testFunction as testFunctionService,
-  validateFunction as validateFunctionService,
-} from "@ollie-shop/core";
-import type {
-  FunctionBuildOptions,
-  FunctionCreateOptions,
-  FunctionDeployOptions,
-  FunctionTestOptions,
-} 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> {
-  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");
-    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 buildFunction(
-  options: FunctionBuildOptions,
-  cliConsole: CliConsole,
-): Promise<void> {
-  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 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");
-    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 validateFunction(
-  options: { path?: string; strict?: boolean; fix?: boolean },
-  cliConsole: CliConsole,
-): Promise<void> {
-  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");
-    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,
-  cliConsole: CliConsole,
-): Promise<void> {
-  if (!options.functionId) {
-    throw new Error(ERROR_MESSAGES.FUNCTION_ID_REQUIRED);
-  }
-
-  configureBuilderUrl();
-
-  const spinner = cliConsole.spinner({
-    text: "Preparing function for deployment...",
-  });
-
-  try {
-    const functionPath = options.path || process.cwd();
-    const result = await buildAndDeployFunctionFromDirectory(
-      options.functionId,
-      functionPath,
-    );
-
-    handleDeploymentResult(result, "function", cliConsole, spinner);
-    spinner.stop();
-
-    try {
-      const { completedBuild, duration } = await waitForDeploymentWithProgress(
-        result.buildId,
-        "function",
-        cliConsole,
-      );
-
-      showDeploymentSuccess(
-        completedBuild,
-        duration,
-        options.functionId,
-        "function",
-        cliConsole,
-      );
-    } catch (error) {
-      handleDeploymentError(error, result.buildId, "function", cliConsole);
-      throw error;
-    }
-  } catch (error) {
-    if (spinner.isSpinning) {
-      spinner.fail("Deployment failed");
-    }
-    throw error;
-  }
-}
-
-export async function listFunctions(cliConsole: CliConsole): Promise<void> {
-  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

@@ -1,131 +0,0 @@
-import type { InitOptions } from "../schemas/command.schema";
-import type { CliConsole } from "../utils/console";
-import { handleValidationResult } from "../utils/validation-helpers";
-
-export async function initProject(
-  options: InitOptions,
-  cliConsole: CliConsole,
-): Promise<void> {
-  // Lazy import - only loaded when this function is called
-  const { initProject: initProjectService } = await import("@ollie-shop/core");
-
-  const spinner = cliConsole.spinner({
-    text: "Initializing project...",
-  });
-
-  try {
-    // Map our template names to core service expected names
-    const templateMap = {
-      default: "default",
-      grocery: "grocery",
-      sales: "sales",
-    } as const;
-
-    const coreTemplate =
-      templateMap[options.template as keyof typeof templateMap] || "default";
-
-    const result = await initProjectService({
-      name: options.name || "my-ollie-shop",
-      template: coreTemplate,
-      typescript: true, // Always use TypeScript
-      git: options.git ?? true,
-      installDeps: options.install ?? true,
-      components: [],
-      platformStoreId: "local",
-      platform: "custom",
-    });
-
-    spinner.succeed("Project initialized successfully!");
-    cliConsole.success(`Project created at: ${result.projectPath}`);
-
-    if (options.git) {
-      cliConsole.info("Git repository initialized");
-    }
-
-    cliConsole.nextSteps("Next steps", [
-      {
-        description: "Navigate to project directory",
-        command: `cd ${result.projectPath}`,
-      },
-      {
-        description: "Install dependencies",
-        command: "npm install",
-      },
-      {
-        description: "Start development server",
-        command: "npm run dev",
-      },
-    ]);
-  } catch (error) {
-    spinner.fail("Failed to initialize project");
-    throw error;
-  }
-}
-
-export async function validateProject(
-  options: { path?: string; strict?: boolean; fix?: boolean },
-  cliConsole: CliConsole,
-): Promise<void> {
-  // Lazy import - only loaded when this function is called
-  const { validateProject: validateProjectService } = await import(
-    "@ollie-shop/core"
-  );
-
-  const targetPath = options.path || process.cwd();
-  const spinner = cliConsole.spinner({ text: "Validating project..." });
-
-  try {
-    const result = await validateProjectService(targetPath);
-    handleValidationResult(result, spinner, cliConsole, "Project");
-  } catch (error) {
-    spinner.fail("Validation failed");
-    throw error;
-  }
-}
-
-export async function buildProject(
-  options: { path?: string; watch?: boolean },
-  cliConsole: CliConsole,
-): Promise<void> {
-  const targetPath = options.path || process.cwd();
-
-  cliConsole.info(
-    "Project building is available through individual component and function builds.",
-  );
-  cliConsole.info(`Target path: ${targetPath}`);
-
-  if (options.watch) {
-    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",
-  ]);
-}
-
-export async function startDevServer(
-  options: { port?: number; open?: boolean },
-  cliConsole: CliConsole,
-): Promise<void> {
-  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(
-      "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",
-  ]);
-}