@ollie-shop/cli 0.1.3 → 0.3.0

package/src/commands/function.ts

@@ -0,0 +1,252 @@
+import type { Command } from "@commander-js/extra-typings";
+import * as functionActions from "../actions/function.actions";
+import {
+  type FunctionCreateOptions,
+  FunctionCreateOptionsSchema,
+  type FunctionDeployOptions,
+  FunctionDeployOptionsSchema,
+  FunctionTestOptionsSchema,
+  FunctionValidateOptionsSchema,
+} from "../schemas/command.schema";
+import { buildCommand, buildCommandGroup } from "../utils/command-builder";
+import { COMMON_OPTIONS } from "../utils/command-parser";
+
+export function registerFunctionCommands(program: Command): void {
+  const cmd = buildCommandGroup(
+    program,
+    "function",
+    "Manage Ollie Shop functions",
+    ["func"],
+  );
+
+  // Create function command
+  buildCommand(cmd, {
+    name: "create",
+    description: "Create a new function",
+    options: [
+      COMMON_OPTIONS.functionName,
+      COMMON_OPTIONS.functionInvocation,
+      COMMON_OPTIONS.priority,
+      {
+        flags: "--on-error <strategy>",
+        description: "Error handling strategy (throw|skip)",
+        defaultValue: "throw",
+      },
+      {
+        flags: "-d, --description <description>",
+        description: "Function description",
+      },
+      {
+        flags: "--template <template>",
+        description: "Function template to use",
+      },
+      COMMON_OPTIONS.tests,
+      COMMON_OPTIONS.noTests,
+    ],
+    schema: FunctionCreateOptionsSchema,
+    examples: [
+      {
+        description: "Create a function to validate orders",
+        command:
+          "ollieshop function create --name validate-order --event order --timing before",
+      },
+      {
+        description: "Create a discount function for cart",
+        command:
+          "ollieshop function create --name apply-discount --event cart --description 'Apply bulk discounts'",
+      },
+      {
+        description: "Create a JavaScript function without tests",
+        command:
+          "ollieshop function create --name check-inventory --language javascript --no-tests",
+      },
+    ],
+    handler: async (options, console) => {
+      await functionActions.createFunction(
+        options as FunctionCreateOptions,
+        console,
+      );
+    },
+  });
+
+  // Validate function command
+  buildCommand(cmd, {
+    name: "validate",
+    description: "Validate a function",
+    options: [COMMON_OPTIONS.path],
+    schema: FunctionValidateOptionsSchema,
+    examples: [
+      {
+        description: "Validate current directory",
+        command: "ollieshop function validate",
+      },
+      {
+        description: "Validate specific function",
+        command:
+          "ollieshop function validate --path ./functions/validate-order",
+      },
+    ],
+    handler: async (options, console) => {
+      await functionActions.validateFunction(
+        {
+          path: options.path || process.cwd(),
+          strict: options.strict ?? false,
+          fix: options.fix ?? false,
+        },
+        console,
+      );
+    },
+  });
+
+  // Test function command
+  buildCommand(cmd, {
+    name: "test",
+    description: "Test a function locally",
+    options: [
+      COMMON_OPTIONS.path,
+      {
+        flags: "-w, --watch",
+        description: "Watch for changes",
+        defaultValue: false,
+      },
+      {
+        flags: "--payload <json>",
+        description: "Test payload (JSON string)",
+      },
+      {
+        flags: "--timeout <ms>",
+        description: "Timeout in milliseconds",
+      },
+    ],
+    schema: FunctionTestOptionsSchema,
+    examples: [
+      {
+        description: "Test function in current directory",
+        command: "ollieshop function test",
+      },
+      {
+        description: "Test with custom payload",
+        command: `ollieshop function test --payload '{"items": [{"id": "123", "quantity": 2}]}'`,
+      },
+      {
+        description: "Test in watch mode",
+        command: "ollieshop function test --watch",
+      },
+    ],
+    handler: async (options, console) => {
+      await functionActions.testFunction(
+        {
+          path: options.path || process.cwd(),
+          payload: options.payload,
+          timeout: options.timeout,
+          watch: options.watch ?? false,
+          coverage: options.coverage ?? false,
+        },
+        console,
+      );
+    },
+  });
+
+  // Deploy function command
+  buildCommand(cmd, {
+    name: "deploy",
+    description: "Build and deploy a function to cloud",
+    options: [
+      COMMON_OPTIONS.path,
+      {
+        flags: "--id <id>",
+        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",
+      },
+      {
+        description: "Deploy with function ID",
+        command: "ollieshop function deploy --id func_123abc",
+      },
+    ],
+    handler: async (options: FunctionDeployOptions, console) => {
+      // Map id to functionId if provided
+      const deployOptions = {
+        path: options.path || process.cwd(),
+        functionId: options.id || options.functionId,
+        wait: options.wait,
+      };
+      await functionActions.deployFunction(deployOptions, console);
+    },
+  });
+
+  // List functions command
+  buildCommand(cmd, {
+    name: "list",
+    description: "List all functions",
+    aliases: ["ls"],
+    examples: [
+      {
+        description: "List all functions",
+        command: "ollieshop function list",
+      },
+    ],
+    handler: async (_, console) => {
+      await functionActions.listFunctions(console);
+    },
+  });
+
+  // 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);
+      }
+    });
+}

package/src/commands/help.ts

@@ -0,0 +1,18 @@
+import type { Command } from "@commander-js/extra-typings";
+import { console as cliConsole } from "../utils/console";
+
+export function configureHelpCommand(program: Command): void {
+  program
+    .command("help [command]")
+    .description("Display help for a specific command or list all commands")
+    .action((cmdName: string | undefined) => {
+      if (cmdName) {
+        // For specific command help, show the program help with the command
+        cliConsole.info(`\nHelp for command: ${cmdName}`);
+        cliConsole.info("Use 'ollieshop <command> --help' for detailed help\n");
+      } else {
+        // Show general help
+        program.help();
+      }
+    });
+}

package/src/commands/index.ts

@@ -1,13 +1,27 @@
-import type { Command } from "commander";
+import type { Command } from "@commander-js/extra-typings";
+import { registerComponentCommands } from "./component";
+import { configureDocsCommand } from "./docs";
+import { registerFunctionCommands } from "./function";
+import { configureHelpCommand } from "./help";
 import { configureLoginCommand } from "./login";
+import { registerProjectCommands } from "./project";
+import { registerStoreVersionCommands } from "./store-version";
+import { configureVersionCommand } from "./version";
+import { configureWhoamiCommand } from "./whoami";
 
-/**
- * Register all CLI commands with the program
- * @param program The commander program instance
- */
 export function registerCommands(program: Command): void {
-  // Register individual commands
+  // Register simple commands that don't need heavy services
+  configureDocsCommand(program);
+  configureHelpCommand(program);
   configureLoginCommand(program);
+  configureWhoamiCommand(program);
 
-  // Add more commands here as they are implemented
+  // Register new commands
+  registerStoreVersionCommands(program);
+  configureVersionCommand(program);
+
+  // Register complex commands with lazy service loading
+  registerComponentCommands(program);
+  registerFunctionCommands(program);
+  registerProjectCommands(program);
 }

package/src/commands/login.ts

@@ -4,23 +4,13 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import { createServer } from "node:http";
 import { homedir } from "node:os";
 import path from "node:path";
-import type { Command } from "commander";
+import type { Command } from "@commander-js/extra-typings";
+import { isNodeError } from "../types";
+import { console as cliConsole } from "../utils/console";
 
-/**
- * Default port for the local callback server
- */
 const DEFAULT_CALLBACK_PORT = 7777;
-
-/**
- * Default Ollie Shop authorization endpoint
- */
 const AUTH_ENDPOINT = "https://admin.ollie.shop/auth/login";
 
-/**
- * Configure the login command
- * @param program The commander program instance
- * @returns The configured command
- */
 export function configureLoginCommand(program: Command): Command {
   return program
     .command("login")
@@ -31,24 +21,22 @@ export function configureLoginCommand(program: Command): Command {
       DEFAULT_CALLBACK_PORT.toString(),
     )
     .option("--auth-url <url>", "Custom authorization URL", AUTH_ENDPOINT)
-    .action(async (options) => {
-      console.log("🔐 Initiating Ollie Shop login flow...");
+    .action(async (options: { port: string; authUrl: string }) => {
+      cliConsole.info("🔐 Initiating Ollie Shop login flow...");
 
       try {
         const token = await startWebAuthFlow(options);
 
         if (token) {
           await saveCredentials(token);
-
-          console.log("✅ Successfully logged in!");
-          // Process continues normally after login
+          cliConsole.success("✅ Successfully logged in!");
           return;
         }
 
-        console.error("❌ Authentication failed. Please try again.");
+        cliConsole.error("❌ Authentication failed. Please try again.");
         process.exit(1);
       } catch (error) {
-        console.error(
+        cliConsole.error(
           `❌ Login failed: ${error instanceof Error ? error.message : "Unknown error"}`,
         );
         process.exit(1);
@@ -56,20 +44,12 @@ export function configureLoginCommand(program: Command): Command {
     });
 }
 
-/**
- * Authentication response type
- */
 type AuthToken = {
   accessToken: string;
   refreshToken: string;
   expiresAt: string;
 };
 
-/**
- * Handle the callback endpoint for web authentication flow
- *
- * This now expects to receive tokens directly from the Next.js app with Supabase auth
- */
 async function handleAuthCallback(
   req: IncomingMessage,
   res: ServerResponse,
@@ -77,7 +57,6 @@ async function handleAuthCallback(
   resolve: (token: AuthToken | null) => void,
   reject: (err: Error) => void,
 ): Promise<void> {
-  // TypeScript doesn't know the socket will always have localPort, so we cast
   const socket = req.socket as { localPort?: number };
   const url = new URL(
     req.url || "/",
@@ -85,7 +64,6 @@ async function handleAuthCallback(
   );
   const params = url.searchParams;
 
-  // Verify state from query parameters to prevent CSRF attacks
   const returnedState = params.get("state");
   if (returnedState !== state) {
     sendErrorResponse(
@@ -98,7 +76,6 @@ async function handleAuthCallback(
     return;
   }
 
-  // Parse the request body to get the access_token from form data
   let formData = "";
   req.on("data", (chunk) => {
     formData += chunk.toString();
@@ -110,7 +87,6 @@ async function handleAuthCallback(
     });
   });
 
-  // Parse form data
   const formParams = new URLSearchParams(formData);
   const accessToken = formParams.get("access_token");
   const refreshToken = formParams.get("refresh_token") || "";
@@ -130,17 +106,13 @@ async function handleAuthCallback(
   }
 
   try {
-    // Create token object
     const token: AuthToken = {
       accessToken,
       refreshToken,
       expiresAt,
     };
 
-    // Send success response to browser
     sendSuccessResponse(res);
-
-    // Resolve the promise with the token
     resolve(token);
   } catch (error) {
     const errorMessage =
@@ -155,9 +127,6 @@ async function handleAuthCallback(
   }
 }
 
-/**
- * Send HTML error response
- */
 function sendErrorResponse(
   res: ServerResponse,
   statusCode: number,
@@ -168,9 +137,6 @@ function sendErrorResponse(
   res.end(`<h1>${title}</h1><p>${message}</p>`);
 }
 
-/**
- * Send HTML success response
- */
 function sendSuccessResponse(res: ServerResponse): void {
   res.writeHead(200, { "Content-Type": "text/html" });
   res.end(
@@ -178,9 +144,6 @@ function sendSuccessResponse(res: ServerResponse): void {
   );
 }
 
-/**
- * Send HTML waiting page response
- */
 function sendWaitingResponse(res: ServerResponse): void {
   res.writeHead(200, { "Content-Type": "text/html" });
   res.end(
@@ -188,9 +151,6 @@ function sendWaitingResponse(res: ServerResponse): void {
   );
 }
 
-/**
- * Start the web-based authentication flow
- */
 async function startWebAuthFlow(options: {
   port: string;
   authUrl: string;
@@ -200,35 +160,29 @@ async function startWebAuthFlow(options: {
   const baseUrl = options.authUrl;
 
   return new Promise<AuthToken | null>((resolve, reject) => {
-    // Create a local server to receive the callback
     const server = createServer(async (req, res) => {
       try {
-        // Parse the URL and query parameters
         const url = new URL(req.url || "/", `http://localhost:${port}`);
 
-        // Check if this is a callback from the Next.js app
         if (url.pathname === "/callback") {
           await handleAuthCallback(
             req,
             res,
             state,
             (token) => {
-              // Wrap the resolve to ensure server is closed
               server.close(() => {
-                console.log("🔐 Local authentication server closed");
+                cliConsole.debug("🔐 Local authentication server closed");
                 resolve(token);
               });
             },
             (error) => {
-              // Wrap the reject to ensure server is closed
               server.close(() => {
-                console.log("🔐 Local authentication server closed");
+                cliConsole.debug("🔐 Local authentication server closed");
                 reject(error);
               });
             },
           );
         } else {
-          // Serve a simple page for any other path
           sendWaitingResponse(res);
         }
       } catch (error) {
@@ -236,35 +190,29 @@ async function startWebAuthFlow(options: {
           error instanceof Error ? error.message : "Unknown error";
         sendErrorResponse(res, 500, "Server Error", errorMessage);
         server.close(() => {
-          console.log("🔐 Local authentication server closed");
+          cliConsole.debug("🔐 Local authentication server closed");
           reject(new Error(errorMessage));
         });
       }
     });
 
-    // Start the server
     server.listen(port, async () => {
-      // Build the URL to your Next.js app with necessary parameters
       const redirectUrl = `http://localhost:${port}/callback`;
-
       const authUrl = new URL(baseUrl);
 
       authUrl.searchParams.set("flow", "cli");
       authUrl.searchParams.set("state", state);
       authUrl.searchParams.set("redirect_to", redirectUrl);
 
-      console.log("\n🔒 Please authenticate in your browser...\n");
-      console.log(`Opening: ${authUrl}\n`);
+      cliConsole.info("\n🔒 Please authenticate in your browser...\n");
+      cliConsole.info(`Opening: ${authUrl}\n`);
 
       const open = (await import("open")).default;
-
-      // Open the browser with the authorization URL
       open(authUrl.toString());
     });
 
-    // Handle server errors
     server.on("error", (err: Error) => {
-      if ((err as NodeJS.ErrnoException).code === "EADDRINUSE") {
+      if (isNodeError(err) && err.code === "EADDRINUSE") {
         reject(
           new Error(
             `Port ${port} is already in use. Please specify a different port using the --port option.`,
@@ -276,44 +224,37 @@ async function startWebAuthFlow(options: {
       server.close();
     });
 
-    // Set a timeout to prevent hanging indefinitely
     const timeoutId = setTimeout(
       () => {
         server.close(() => {
-          console.log("🔐 Local authentication server closed due to timeout");
+          cliConsole.debug(
+            "🔐 Local authentication server closed due to timeout",
+          );
           reject(new Error("Authentication timed out. Please try again."));
         });
       },
       5 * 60 * 1000,
-    ); // 5 minutes timeout
+    );
 
-    // Clean up the timeout if the server closes for other reasons
     server.on("close", () => {
       clearTimeout(timeoutId);
     });
   });
 }
 
-/**
- * Save authentication credentials locally
- *
- * @todo Use a more secure storage method like OS keychain
- */
 async function saveCredentials(token: {
   accessToken: string;
   refreshToken: string;
   expiresAt: string;
 }) {
-  console.log("Saving credentials...");
+  cliConsole.debug("Saving credentials...");
 
   const configDir = path.join(homedir(), ".ollie-shop");
   const credentialsPath = path.join(configDir, "credentials.json");
 
-  // Create the .ollie-shop directory if it doesn't exist
   try {
     await fs.mkdir(configDir, { recursive: true });
   } catch (error) {
-    // Ignore error if directory already exists
     if (
       !(error instanceof Error && "code" in error && error.code === "EEXIST")
     ) {
@@ -322,6 +263,5 @@ async function saveCredentials(token: {
   }
 
   await fs.writeFile(credentialsPath, JSON.stringify(token, null, 2));
-
   return true;
 }