@ollie-shop/cli 0.3.4 → 1.0.1

package/src/commands/function.ts

@@ -1,201 +0,0 @@
-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,
-      },
-    ],
-    schema: FunctionDeployOptionsSchema,
-    examples: [
-      {
-        description: "Deploy current directory",
-        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) => {
-      // Map id to functionId if provided
-      const deployOptions = {
-        path: options.path || process.cwd(),
-        functionId: options.id || options.functionId,
-      };
-      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 removed - no longer needed since deployments always wait for completion
-}

package/src/commands/help.ts

@@ -1,18 +0,0 @@
-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,27 +0,0 @@
-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";
-
-export function registerCommands(program: Command): void {
-  // Register simple commands that don't need heavy services
-  configureDocsCommand(program);
-  configureHelpCommand(program);
-  configureLoginCommand(program);
-  configureWhoamiCommand(program);
-
-  // 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

@@ -1,267 +0,0 @@
-import { randomBytes } from "node:crypto";
-import fs from "node:fs/promises";
-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-js/extra-typings";
-import { isNodeError } from "../types";
-import { console as cliConsole } from "../utils/console";
-
-const DEFAULT_CALLBACK_PORT = 7777;
-const AUTH_ENDPOINT = "https://admin.ollie.shop/auth/login";
-
-export function configureLoginCommand(program: Command): Command {
-  return program
-    .command("login")
-    .description("Log in to your Ollie Shop account")
-    .option(
-      "-p, --port <port>",
-      "Port to use for the local callback server",
-      DEFAULT_CALLBACK_PORT.toString(),
-    )
-    .option("--auth-url <url>", "Custom authorization URL", AUTH_ENDPOINT)
-    .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);
-          cliConsole.success("✅ Successfully logged in!");
-          return;
-        }
-
-        cliConsole.error("❌ Authentication failed. Please try again.");
-        process.exit(1);
-      } catch (error) {
-        cliConsole.error(
-          `❌ Login failed: ${error instanceof Error ? error.message : "Unknown error"}`,
-        );
-        process.exit(1);
-      }
-    });
-}
-
-type AuthToken = {
-  accessToken: string;
-  refreshToken: string;
-  expiresAt: string;
-};
-
-async function handleAuthCallback(
-  req: IncomingMessage,
-  res: ServerResponse,
-  state: string,
-  resolve: (token: AuthToken | null) => void,
-  reject: (err: Error) => void,
-): Promise<void> {
-  const socket = req.socket as { localPort?: number };
-  const url = new URL(
-    req.url || "/",
-    `http://localhost:${socket.localPort || 3000}`,
-  );
-  const params = url.searchParams;
-
-  const returnedState = params.get("state");
-  if (returnedState !== state) {
-    sendErrorResponse(
-      res,
-      400,
-      "Invalid state parameter",
-      "Authentication failed. Please try again.",
-    );
-    reject(new Error("Invalid state parameter"));
-    return;
-  }
-
-  let formData = "";
-  req.on("data", (chunk) => {
-    formData += chunk.toString();
-  });
-
-  await new Promise<void>((formResolve) => {
-    req.on("end", () => {
-      formResolve();
-    });
-  });
-
-  const formParams = new URLSearchParams(formData);
-  const accessToken = formParams.get("access_token");
-  const refreshToken = formParams.get("refresh_token") || "";
-  const expiresAt =
-    formParams.get("expires_at") ||
-    new Date(Date.now() + 3600000).toISOString();
-
-  if (!accessToken) {
-    sendErrorResponse(
-      res,
-      400,
-      "Missing authentication token",
-      "Authentication failed. Please try again.",
-    );
-    reject(new Error("Missing authentication token"));
-    return;
-  }
-
-  try {
-    const token: AuthToken = {
-      accessToken,
-      refreshToken,
-      expiresAt,
-    };
-
-    sendSuccessResponse(res);
-    resolve(token);
-  } catch (error) {
-    const errorMessage =
-      error instanceof Error ? error.message : "Unknown error";
-    sendErrorResponse(
-      res,
-      500,
-      "Authentication failed",
-      `Error: ${errorMessage}`,
-    );
-    reject(new Error(errorMessage));
-  }
-}
-
-function sendErrorResponse(
-  res: ServerResponse,
-  statusCode: number,
-  title: string,
-  message: string,
-): void {
-  res.writeHead(statusCode, { "Content-Type": "text/html" });
-  res.end(`<h1>${title}</h1><p>${message}</p>`);
-}
-
-function sendSuccessResponse(res: ServerResponse): void {
-  res.writeHead(200, { "Content-Type": "text/html" });
-  res.end(
-    "<h1>Authentication successful!</h1><p>You can now close this window and return to the CLI.</p>",
-  );
-}
-
-function sendWaitingResponse(res: ServerResponse): void {
-  res.writeHead(200, { "Content-Type": "text/html" });
-  res.end(
-    "<h1>Ollie Shop CLI Authentication</h1><p>Waiting for authentication response...</p>",
-  );
-}
-
-async function startWebAuthFlow(options: {
-  port: string;
-  authUrl: string;
-}): Promise<AuthToken | null> {
-  const state = randomBytes(16).toString("hex");
-  const port = Number.parseInt(options.port, 10);
-  const baseUrl = options.authUrl;
-
-  return new Promise<AuthToken | null>((resolve, reject) => {
-    const server = createServer(async (req, res) => {
-      try {
-        const url = new URL(req.url || "/", `http://localhost:${port}`);
-
-        if (url.pathname === "/callback") {
-          await handleAuthCallback(
-            req,
-            res,
-            state,
-            (token) => {
-              server.close(() => {
-                cliConsole.debug("🔐 Local authentication server closed");
-                resolve(token);
-              });
-            },
-            (error) => {
-              server.close(() => {
-                cliConsole.debug("🔐 Local authentication server closed");
-                reject(error);
-              });
-            },
-          );
-        } else {
-          sendWaitingResponse(res);
-        }
-      } catch (error) {
-        const errorMessage =
-          error instanceof Error ? error.message : "Unknown error";
-        sendErrorResponse(res, 500, "Server Error", errorMessage);
-        server.close(() => {
-          cliConsole.debug("🔐 Local authentication server closed");
-          reject(new Error(errorMessage));
-        });
-      }
-    });
-
-    server.listen(port, async () => {
-      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);
-
-      cliConsole.info("\n🔒 Please authenticate in your browser...\n");
-      cliConsole.info(`Opening: ${authUrl}\n`);
-
-      const open = (await import("open")).default;
-      open(authUrl.toString());
-    });
-
-    server.on("error", (err: Error) => {
-      if (isNodeError(err) && err.code === "EADDRINUSE") {
-        reject(
-          new Error(
-            `Port ${port} is already in use. Please specify a different port using the --port option.`,
-          ),
-        );
-      } else {
-        reject(err);
-      }
-      server.close();
-    });
-
-    const timeoutId = setTimeout(
-      () => {
-        server.close(() => {
-          cliConsole.debug(
-            "🔐 Local authentication server closed due to timeout",
-          );
-          reject(new Error("Authentication timed out. Please try again."));
-        });
-      },
-      5 * 60 * 1000,
-    );
-
-    server.on("close", () => {
-      clearTimeout(timeoutId);
-    });
-  });
-}
-
-async function saveCredentials(token: {
-  accessToken: string;
-  refreshToken: string;
-  expiresAt: string;
-}) {
-  cliConsole.debug("Saving credentials...");
-
-  const configDir = path.join(homedir(), ".ollie-shop");
-  const credentialsPath = path.join(configDir, "credentials.json");
-
-  try {
-    await fs.mkdir(configDir, { recursive: true });
-  } catch (error) {
-    if (
-      !(error instanceof Error && "code" in error && error.code === "EEXIST")
-    ) {
-      throw error;
-    }
-  }
-
-  await fs.writeFile(credentialsPath, JSON.stringify(token, null, 2));
-  return true;
-}

package/src/commands/project.ts

@@ -1,107 +0,0 @@
-import type { Command } from "@commander-js/extra-typings";
-import {
-  buildProject,
-  initProject,
-  startDevServer,
-  validateProject,
-} from "../actions/project.actions";
-import { console as cliConsole } from "../utils/console";
-
-export function registerProjectCommands(program: Command): void {
-  const projectCommand = program
-    .command("project")
-    .description("Project management commands");
-
-  projectCommand
-    .command("init")
-    .description("Initialize a new project")
-    .option("-n, --name <name>", "Project name")
-    .option("-t, --template <template>", "Project template")
-    .action(async (options) => {
-      try {
-        await initProject(
-          {
-            name: options.name,
-            template:
-              (options.template as
-                | "default"
-                | "grocery"
-                | "sales"
-                | undefined) || "default",
-            git: true,
-            install: true,
-          },
-          cliConsole,
-        );
-      } catch (error) {
-        cliConsole.error(
-          error instanceof Error ? error.message : "An error occurred",
-        );
-        process.exit(1);
-      }
-    });
-
-  projectCommand
-    .command("build")
-    .description("Build project")
-    .option("-p, --path <path>", "Project path")
-    .option("--watch", "Watch for changes")
-    .action(async (options) => {
-      try {
-        await buildProject(
-          {
-            path: options.path,
-            watch: options.watch ?? false,
-          },
-          cliConsole,
-        );
-      } catch (error) {
-        cliConsole.error(
-          error instanceof Error ? error.message : "An error occurred",
-        );
-        process.exit(1);
-      }
-    });
-
-  projectCommand
-    .command("dev")
-    .description("Start development server")
-    .option("-p, --port <port>", "Port number", Number.parseInt)
-    .option("--open", "Open browser")
-    .action(async (options) => {
-      try {
-        await startDevServer(
-          {
-            port: options.port ?? 3000,
-            open: options.open ?? false,
-          },
-          cliConsole,
-        );
-      } catch (error) {
-        cliConsole.error(
-          error instanceof Error ? error.message : "An error occurred",
-        );
-        process.exit(1);
-      }
-    });
-
-  projectCommand
-    .command("validate")
-    .description("Validate project")
-    .option("-p, --path <path>", "Project path")
-    .action(async (options) => {
-      try {
-        await validateProject(
-          {
-            path: options.path,
-          },
-          cliConsole,
-        );
-      } catch (error) {
-        cliConsole.error(
-          error instanceof Error ? error.message : "An error occurred",
-        );
-        process.exit(1);
-      }
-    });
-}