@ollie-shop/cli 0.2.0 → 0.3.0

package/src/prompts/component.prompts.ts

@@ -0,0 +1,94 @@
+import { ComponentSlot, type ComponentSlotType } from "@ollie-shop/core";
+import inquirer from "inquirer";
+import { validateComponentName } from "../utils/validation-helpers";
+
+export interface ComponentCreationAnswers {
+  name: string;
+  slot: ComponentSlotType;
+  includeTests: boolean;
+  description?: string;
+}
+
+export interface ComponentDeploymentAnswers {
+  versionId: string;
+  confirm: boolean;
+}
+
+// Generate component slot choices from core enum
+const componentSlotChoices = ComponentSlot.options.map((slot) => ({
+  name: slot.charAt(0).toUpperCase() + slot.slice(1).replace(/-/g, " "),
+  value: slot,
+}));
+
+export async function promptComponentCreation(
+  name?: string,
+  slot?: string,
+): Promise<ComponentCreationAnswers> {
+  const questions = [];
+
+  if (!name) {
+    questions.push({
+      type: "input",
+      name: "name",
+      message: "What's the name of your component?",
+      validate: (input: string) => {
+        return validateComponentName(input);
+      },
+    });
+  }
+
+  if (!slot) {
+    questions.push({
+      type: "list",
+      name: "slot",
+      message: "Which slot will this component occupy?",
+      choices: componentSlotChoices,
+    });
+  }
+
+  questions.push(
+    {
+      type: "input",
+      name: "description",
+      message: "Enter a description (optional):",
+      default: "",
+    },
+    {
+      type: "confirm",
+      name: "includeTests",
+      message: "Include test files?",
+      default: true,
+    },
+  );
+
+  const answers = await inquirer.prompt(questions);
+
+  return {
+    name: name || answers.name,
+    slot: slot || answers.slot,
+    description: answers.description || undefined,
+    includeTests: answers.includeTests,
+  };
+}
+
+export async function promptComponentDeployment(): Promise<ComponentDeploymentAnswers> {
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "versionId",
+      message: "Enter the version ID to deploy to:",
+      validate: (input: string) => {
+        if (!input.trim()) return "Version ID is required";
+        return true;
+      },
+    },
+    {
+      type: "confirm",
+      name: "confirm",
+      message: "Are you sure you want to deploy this component?",
+      default: false,
+    },
+  ]);
+
+  return answers;
+}

package/src/prompts/function.prompts.ts

@@ -0,0 +1,168 @@
+import {
+  FunctionInvocationType,
+  type FunctionInvocationTypeType,
+  OnErrorBehavior,
+  type OnErrorBehaviorType,
+} from "@ollie-shop/core";
+import inquirer from "inquirer";
+import { validateFunctionName } from "../utils/validation-helpers";
+
+export interface FunctionCreationAnswers {
+  name: string;
+  invocation: FunctionInvocationTypeType;
+  priority: number;
+  onError: OnErrorBehaviorType;
+  includeTests: boolean;
+  description?: string;
+}
+
+export interface FunctionDeploymentAnswers {
+  versionId: string;
+  confirm: boolean;
+}
+
+export interface FunctionTestAnswers {
+  pattern: string;
+}
+
+// Generate function invocation choices from core enum
+const invocationChoices = FunctionInvocationType.options.map((type) => ({
+  name:
+    type === "request"
+      ? "Request (before forwarding to target)"
+      : "Response (after receiving from target)",
+  value: type,
+}));
+
+// Generate error behavior choices from core enum
+const errorBehaviorChoices = OnErrorBehavior.options.map((behavior) => ({
+  name:
+    behavior === "throw"
+      ? "Throw error and stop execution"
+      : "Skip and continue with next function",
+  value: behavior,
+}));
+
+export async function promptFunctionCreation(
+  name?: string,
+  invocation?: string,
+  priority?: number,
+  onError?: string,
+): Promise<FunctionCreationAnswers> {
+  const questions = [];
+
+  if (!name) {
+    questions.push({
+      type: "input",
+      name: "name",
+      message: "What's the name of your function?",
+      validate: (input: string) => {
+        return validateFunctionName(input);
+      },
+    });
+  }
+
+  if (!invocation) {
+    questions.push({
+      type: "list",
+      name: "invocation",
+      message: "When should this function execute?",
+      choices: invocationChoices,
+    });
+  }
+
+  if (priority === undefined) {
+    questions.push({
+      type: "number",
+      name: "priority",
+      message: "Priority (0-100, higher = executes first):",
+      default: 0,
+      validate: (input: number) => {
+        if (input < 0 || input > 100)
+          return "Priority must be between 0 and 100";
+        return true;
+      },
+    });
+  }
+
+  if (!onError) {
+    questions.push({
+      type: "list",
+      name: "onError",
+      message: "What should happen if this function fails?",
+      choices: errorBehaviorChoices,
+    });
+  }
+
+  questions.push(
+    {
+      type: "input",
+      name: "description",
+      message: "Enter a description (optional):",
+      default: "",
+    },
+    {
+      type: "confirm",
+      name: "includeTests",
+      message: "Include test files?",
+      default: true,
+    },
+  );
+
+  const answers = await inquirer.prompt(questions);
+
+  return {
+    name: name || answers.name,
+    invocation: invocation || answers.invocation,
+    priority: priority ?? answers.priority,
+    onError: onError || answers.onError,
+    description: answers.description || undefined,
+    includeTests: answers.includeTests,
+  };
+}
+
+export async function promptFunctionDeployment(): Promise<FunctionDeploymentAnswers> {
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "versionId",
+      message: "Enter the version ID to deploy to:",
+      validate: (input: string) => {
+        if (!input.trim()) return "Version ID is required";
+        return true;
+      },
+    },
+    {
+      type: "confirm",
+      name: "confirm",
+      message: "Are you sure you want to deploy this function?",
+      default: false,
+    },
+  ]);
+
+  return answers;
+}
+
+export async function promptFunctionTest(): Promise<FunctionTestAnswers> {
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "pattern",
+      message: "Enter test file pattern:",
+      default: "**/*.test.{js,ts}",
+    },
+  ]);
+
+  return answers;
+}
+
+export function getInvocationDescription(
+  invocation: FunctionInvocationTypeType,
+): string {
+  const descriptions: Record<FunctionInvocationTypeType, string> = {
+    request: "Executes before forwarding request to target URL",
+    response: "Executes after receiving response from target URL",
+  };
+
+  return descriptions[invocation] || "Custom invocation handler";
+}

package/src/schemas/command.schema.ts

@@ -0,0 +1,354 @@
+// Following TypeScript Discipline: Import schemas from core instead of duplicating
+import {
+  BuildStatus,
+  ComponentNameSchema,
+  ComponentSlot,
+  FunctionInvocationType,
+  FunctionNameSchema,
+  OnErrorBehavior,
+  Template,
+} from "@ollie-shop/core";
+import { z } from "zod";
+
+// Re-export schemas from core for CLI use
+export { ComponentNameSchema, FunctionNameSchema };
+
+/**
+ * CLI-specific schemas (only for CLI-specific concerns)
+ */
+export const PathSchema = z.string().min(1, "Path cannot be empty");
+
+export const StoreIdSchema = z.string().uuid("Invalid store ID format");
+
+export const VersionNameSchema = z
+  .string()
+  .min(1, "Version name is required")
+  .max(100, "Version name is too long (max 100 characters)");
+
+export const PrioritySchema = z
+  .number()
+  .int("Priority must be a whole number")
+  .min(0, "Priority must be between 0 and 100")
+  .max(100, "Priority must be between 0 and 100");
+
+export const UrlSchema = z
+  .string()
+  .min(1, "URL is required")
+  .refine((url) => {
+    // Allow URL patterns like /api/* or /*
+    if (url.startsWith("/")) {
+      return true;
+    }
+    // Validate full URLs
+    try {
+      const parsed = new URL(url);
+      return ["http:", "https:"].includes(parsed.protocol);
+    } catch {
+      return false;
+    }
+  }, "URL must be a valid URL or path pattern");
+
+export const SemverSchema = z
+  .string()
+  .regex(
+    /^\d+\.\d+\.\d+$/,
+    "Version must follow semantic versioning format (e.g., 1.0.0)",
+  );
+
+/**
+ * Component command schemas
+ */
+export const ComponentCreateOptionsSchema = z
+  .object({
+    name: ComponentNameSchema.optional(), // Optional for interactive mode
+    slot: ComponentSlot.optional().default("main"),
+    tests: z.boolean().optional().default(true),
+    template: z.string().optional(),
+    interactive: z.boolean().optional(),
+  })
+  .refine((data) => data.interactive || data.name, {
+    message: "Component name is required when not in interactive mode",
+    path: ["name"],
+  });
+
+export const ComponentBuildOptionsSchema = z.object({
+  path: PathSchema.optional(),
+  watch: z.boolean().optional(),
+  minify: z.boolean().optional(),
+  sourcemap: z.boolean().optional(),
+});
+
+export const ComponentValidateOptionsSchema = z.object({
+  path: PathSchema.optional(),
+  strict: z.boolean().optional(),
+  fix: z.boolean().optional(),
+});
+
+export const ComponentDeployOptionsSchema = z.object({
+  path: PathSchema.optional(),
+  componentId: z.string().optional(),
+  id: z.string().optional(), // CLI uses --id flag
+  wait: z.boolean().optional(),
+});
+
+/**
+ * Function command schemas
+ */
+export const FunctionCreateOptionsSchema = z.object({
+  name: FunctionNameSchema,
+  invocation: FunctionInvocationType.optional().default("request"),
+  priority: PrioritySchema.optional().default(0),
+  onError: OnErrorBehavior.optional().default("throw"),
+  tests: z.boolean().optional().default(true),
+  template: z.string().optional(),
+  description: z.string().optional(),
+});
+
+export const FunctionBuildOptionsSchema = z.object({
+  path: PathSchema.optional(),
+  watch: z.boolean().optional(),
+  minify: z.boolean().optional(),
+  target: z.enum(["node16", "node18", "node20"]).optional(),
+});
+
+export const FunctionValidateOptionsSchema = z.object({
+  path: PathSchema.optional(),
+  strict: z.boolean().optional(),
+  fix: z.boolean().optional(),
+});
+
+export const FunctionTestOptionsSchema = z.object({
+  path: PathSchema.optional(),
+  payload: z.string().optional(),
+  timeout: z.number().optional(),
+  coverage: z.boolean().optional(),
+  watch: z.boolean().optional(),
+});
+
+export const FunctionDeployOptionsSchema = z.object({
+  path: PathSchema.optional(),
+  functionId: z.string().optional(),
+  id: z.string().optional(), // CLI uses --id flag
+  wait: z.boolean().optional(),
+});
+
+/**
+ * Development server schemas
+ */
+export const DevServerOptionsSchema = z.object({
+  port: z.number().min(1000).max(65535).default(3000),
+  host: z.string().default("localhost"),
+  open: z.boolean().default(true),
+  component: PathSchema.optional(),
+  function: PathSchema.optional(),
+  mockData: PathSchema.optional(),
+  hot: z.boolean().default(true),
+  https: z.boolean().default(false),
+});
+
+/**
+ * Global CLI options schemas
+ */
+export const GlobalOptionsSchema = z.object({
+  verbose: z.boolean().default(false),
+  quiet: z.boolean().default(false),
+  color: z.boolean().default(true), // --no-color sets this to false
+  config: PathSchema.optional(),
+  logLevel: z.enum(["error", "warn", "info", "debug"]).default("info"),
+});
+
+/**
+ * Build command schemas
+ */
+export const BuildOptionsSchema = z.object({
+  path: PathSchema.optional(),
+  output: PathSchema.optional(),
+  minify: z.boolean().default(true),
+  sourcemap: z.boolean().default(true),
+  watch: z.boolean().default(false),
+  clean: z.boolean().default(true),
+});
+
+/**
+ * Login/Auth schemas
+ */
+export const LoginOptionsSchema = z.object({
+  token: z.string().optional(),
+  interactive: z.boolean().default(true),
+  save: z.boolean().default(true),
+});
+
+/**
+ * Init project schemas
+ */
+export const InitOptionsSchema = z.object({
+  name: z.string().optional(),
+  template: Template.optional().default("default"),
+  git: z.boolean().default(true),
+  install: z.boolean().default(true),
+  path: PathSchema.optional(),
+});
+
+/**
+ * Store version command schemas
+ */
+export const StoreVersionCreateOptionsSchema = z.object({
+  store: StoreIdSchema,
+  name: VersionNameSchema,
+  template: Template.optional(),
+  active: z.boolean().optional(),
+});
+
+export const StoreVersionListOptionsSchema = z.object({
+  store: StoreIdSchema,
+});
+
+export const StoreVersionCloneOptionsSchema = z.object({
+  store: StoreIdSchema,
+  sourceId: z.string().uuid("Invalid source version ID"),
+  name: VersionNameSchema,
+});
+
+export const StoreVersionActivateOptionsSchema = z.object({
+  store: StoreIdSchema,
+  versionId: z.string().uuid("Invalid version ID"),
+});
+
+export const StoreVersionSetDefaultOptionsSchema = z.object({
+  store: StoreIdSchema,
+  versionId: z.string().uuid("Invalid version ID"),
+});
+
+// Type exports
+export type ComponentCreateOptions = z.infer<
+  typeof ComponentCreateOptionsSchema
+>;
+export type ComponentBuildOptions = z.infer<typeof ComponentBuildOptionsSchema>;
+export type ComponentValidateOptions = z.infer<
+  typeof ComponentValidateOptionsSchema
+>;
+export type ComponentDeployOptions = z.infer<
+  typeof ComponentDeployOptionsSchema
+>;
+
+export type FunctionCreateOptions = z.infer<typeof FunctionCreateOptionsSchema>;
+export type FunctionBuildOptions = z.infer<typeof FunctionBuildOptionsSchema>;
+export type FunctionValidateOptions = z.infer<
+  typeof FunctionValidateOptionsSchema
+>;
+export type FunctionTestOptions = z.infer<typeof FunctionTestOptionsSchema>;
+export type FunctionDeployOptions = z.infer<typeof FunctionDeployOptionsSchema>;
+
+export type DevServerOptions = z.infer<typeof DevServerOptionsSchema>;
+export type GlobalOptions = z.infer<typeof GlobalOptionsSchema>;
+export type BuildOptions = z.infer<typeof BuildOptionsSchema>;
+export type LoginOptions = z.infer<typeof LoginOptionsSchema>;
+export type InitOptions = z.infer<typeof InitOptionsSchema>;
+
+export type StoreVersionCreateOptions = z.infer<
+  typeof StoreVersionCreateOptionsSchema
+>;
+export type StoreVersionListOptions = z.infer<
+  typeof StoreVersionListOptionsSchema
+>;
+export type StoreVersionCloneOptions = z.infer<
+  typeof StoreVersionCloneOptionsSchema
+>;
+export type StoreVersionActivateOptions = z.infer<
+  typeof StoreVersionActivateOptionsSchema
+>;
+export type StoreVersionSetDefaultOptions = z.infer<
+  typeof StoreVersionSetDefaultOptionsSchema
+>;
+
+/**
+ * Validation helper functions
+ */
+// NOTE: For component and function name validation, use validation functions from core:
+// import { validateComponentName, validateFunctionName } from "@ollie-shop/core/schemas"
+
+export function validatePath(path: string): boolean {
+  return PathSchema.safeParse(path).success;
+}
+
+export function validateStoreId(storeId: string): boolean {
+  return StoreIdSchema.safeParse(storeId).success;
+}
+
+export function validateVersionName(name: string): boolean {
+  return VersionNameSchema.safeParse(name).success;
+}
+
+export function validatePriority(priority: number): boolean {
+  return PrioritySchema.safeParse(priority).success;
+}
+
+export function validateUrl(url: string): boolean {
+  return UrlSchema.safeParse(url).success;
+}
+
+export function validateSemver(version: string): boolean {
+  return SemverSchema.safeParse(version).success;
+}
+
+/**
+ * CLI Data Display Schemas
+ * These schemas define the structure for data displayed in CLI commands
+ */
+
+// Function list item schema for CLI display
+export const FunctionListItemSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  runtime: z.string().optional(),
+  version: z.string().optional(),
+  enabled: z.boolean(),
+  createdAt: z.union([z.string(), z.date()]),
+  invocation: FunctionInvocationType.optional(),
+  priority: z.number().optional(),
+  onError: OnErrorBehavior.optional(),
+  description: z.string().optional(),
+});
+
+// Component list item schema for CLI display
+export const ComponentListItemSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  slot: ComponentSlot,
+  version: z.string().optional(),
+  enabled: z.boolean(),
+  createdAt: z.union([z.string(), z.date()]),
+  description: z.string().optional(),
+});
+
+// Build status schema
+export const BuildStatusSchema = z.object({
+  id: z.string(),
+  status: BuildStatus,
+  startTime: z.union([z.string(), z.date()]),
+  endTime: z.union([z.string(), z.date()]).optional(),
+  deploymentUrl: z.string().optional(),
+  artifactLocation: z.string().optional(),
+  logs: z.string().optional(),
+  error: z.string().optional(),
+  resourceId: z.string(),
+  resourceType: z.enum(["component", "function"]),
+});
+
+// Version list item schema for CLI display
+export const VersionListItemSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  template: z.string().nullable().optional(),
+  active: z.boolean(),
+  default: z.boolean(),
+  createdAt: z.union([z.string(), z.date()]),
+  updatedAt: z.union([z.string(), z.date()]),
+  storeId: z.string(),
+});
+
+// Type exports derived from schemas
+export type FunctionListItem = z.infer<typeof FunctionListItemSchema>;
+export type ComponentListItem = z.infer<typeof ComponentListItemSchema>;
+export type BuildStatusItem = z.infer<typeof BuildStatusSchema>;
+export type VersionListItem = z.infer<typeof VersionListItemSchema>;