@ollie-shop/cli 1.1.0 → 1.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ollie-shop/cli",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "Ollie Shop CLI - Development tools for custom checkouts",
   "type": "module",
   "main": "dist/index.js",

package/src/commands/business-rule-cmd.ts

@@ -0,0 +1,161 @@
+import {
+  getBusinessRule,
+  listBusinessRules,
+  updateBusinessRule,
+} from "../core/business-rule.js";
+import {
+  detectOutputFormat,
+  outputDryRun,
+  outputResult,
+} from "../utils/output.js";
+import { type ParsedArgs, getFlag } from "../utils/parse-args.js";
+import { getAuthenticatedClient } from "../utils/supabase.js";
+import { validateRequired, validateUuid } from "../utils/validate.js";
+
+export async function businessRuleCommand(parsed: ParsedArgs): Promise<void> {
+  const sub = parsed.subcommand;
+  if (sub === "list" || sub === "ls") return businessRuleListCommand(parsed);
+  if (sub === "get") return businessRuleGetCommand(parsed);
+  if (sub === "update") return businessRuleUpdateCommand(parsed);
+
+  console.error(
+    `Unknown business-rule subcommand: ${sub}. Use: business-rule list | business-rule get | business-rule update`,
+  );
+  process.exit(1);
+}
+
+async function businessRuleListCommand(parsed: ParsedArgs): Promise<void> {
+  const format = detectOutputFormat(parsed.global.output);
+
+  try {
+    const storeId = getFlag(parsed.flags, "store-id");
+    const versionId = getFlag(parsed.flags, "version-id");
+    const codeUpdatedRaw = parsed.flags["code-updated"];
+
+    let codeUpdated: boolean | undefined;
+    if (codeUpdatedRaw === "true" || codeUpdatedRaw === true) {
+      codeUpdated = true;
+    } else if (codeUpdatedRaw === "false") {
+      codeUpdated = false;
+    }
+
+    if (storeId !== undefined) validateUuid(storeId, "store-id");
+    if (versionId !== undefined) validateUuid(versionId, "version-id");
+
+    const client = await getAuthenticatedClient();
+    const result = await listBusinessRules(client, {
+      store_id: storeId,
+      version_id: versionId,
+      code_updated: codeUpdated,
+    });
+
+    outputResult(result, format, parsed.global.fields);
+    if (result.error) process.exit(1);
+  } catch (err) {
+    outputResult(
+      {
+        error: { message: err instanceof Error ? err.message : String(err) },
+      },
+      format,
+    );
+    process.exit(1);
+  }
+}
+
+async function businessRuleGetCommand(parsed: ParsedArgs): Promise<void> {
+  const format = detectOutputFormat(parsed.global.output);
+
+  try {
+    const id = validateUuid(
+      validateRequired(getFlag(parsed.flags, "id"), "id"),
+      "id",
+    );
+
+    const client = await getAuthenticatedClient();
+    const result = await getBusinessRule(client, id);
+
+    outputResult(result, format, parsed.global.fields);
+    if (result.error) process.exit(1);
+  } catch (err) {
+    outputResult(
+      {
+        error: { message: err instanceof Error ? err.message : String(err) },
+      },
+      format,
+    );
+    process.exit(1);
+  }
+}
+
+async function businessRuleUpdateCommand(parsed: ParsedArgs): Promise<void> {
+  const format = detectOutputFormat(parsed.global.output);
+
+  try {
+    let id: string;
+    let input: {
+      content: string;
+      versions_ids?: string[] | null;
+      components_ids?: string[] | null;
+      functions_ids?: string[] | null;
+    };
+
+    if (parsed.global.data) {
+      const raw = JSON.parse(parsed.global.data);
+      id = validateUuid(validateRequired(raw.id, "id"), "id");
+      input = {
+        content: validateRequired(raw.content, "content"),
+        versions_ids: raw.versionsIds ?? undefined,
+        components_ids: raw.componentsIds ?? undefined,
+        functions_ids: raw.functionsIds ?? undefined,
+      };
+    } else {
+      id = validateUuid(
+        validateRequired(getFlag(parsed.flags, "id"), "id"),
+        "id",
+      );
+
+      const versionsIdsRaw = getFlag(parsed.flags, "versions-ids");
+      const componentsIdsRaw = getFlag(parsed.flags, "components-ids");
+      const functionsIdsRaw = getFlag(parsed.flags, "functions-ids");
+
+      input = {
+        content: validateRequired(
+          getFlag(parsed.flags, "content", "c"),
+          "content",
+        ),
+        versions_ids: versionsIdsRaw
+          ? (JSON.parse(versionsIdsRaw) as string[])
+          : undefined,
+        components_ids: componentsIdsRaw
+          ? (JSON.parse(componentsIdsRaw) as string[])
+          : undefined,
+        functions_ids: functionsIdsRaw
+          ? (JSON.parse(functionsIdsRaw) as string[])
+          : undefined,
+      };
+    }
+
+    if (parsed.global.dryRun) {
+      outputDryRun(
+        "business-rule.update",
+        { id, ...input } as Record<string, unknown>,
+        format,
+      );
+      return;
+    }
+
+    const client = await getAuthenticatedClient();
+    const result = await updateBusinessRule(client, id, input);
+
+    outputResult(result, format, parsed.global.fields);
+    if (result.error) process.exit(1);
+  } catch (err) {
+    outputResult(
+      {
+        error: { message: err instanceof Error ? err.message : String(err) },
+      },
+      format,
+    );
+    process.exit(1);
+  }
+}

package/src/commands/deploy-cmd.ts

@@ -0,0 +1,146 @@
+import {
+  type ResourceType,
+  isTerminalStatus,
+  pollBuildStatus,
+  uploadBuild,
+} from "../core/deploy.js";
+import { createComponentBundle } from "../utils/bundle.js";
+import {
+  detectOutputFormat,
+  outputDryRun,
+  outputResult,
+} from "../utils/output.js";
+import { type ParsedArgs, getBoolFlag, getFlag } from "../utils/parse-args.js";
+import { validateRequired, validateUuid } from "../utils/validate.js";
+
+export async function deployCommand(parsed: ParsedArgs): Promise<void> {
+  const format = detectOutputFormat(parsed.global.output);
+
+  try {
+    let resourceId: string;
+    let componentName: string;
+    let resourceType: ResourceType;
+    let wait: boolean;
+    let timeout: number;
+
+    if (parsed.global.data) {
+      const raw = JSON.parse(parsed.global.data);
+      resourceId = validateUuid(
+        raw.componentId || raw.functionId || raw.resourceId,
+        "componentId or functionId",
+      );
+      componentName = validateRequired(raw.name, "name");
+      resourceType = raw.type === "function" ? "function" : "component";
+      wait = raw.wait ?? false;
+      timeout = raw.timeout ?? 300;
+    } else {
+      const compId = getFlag(parsed.flags, "component-id");
+      const funcId = getFlag(parsed.flags, "function-id");
+
+      if (compId && funcId) {
+        throw new Error(
+          "Provide either --component-id or --function-id, not both.",
+        );
+      }
+
+      if (compId) {
+        resourceId = validateUuid(compId, "component-id");
+        resourceType = "component";
+      } else if (funcId) {
+        resourceId = validateUuid(funcId, "function-id");
+        resourceType = "function";
+      } else {
+        throw new Error("Either --component-id or --function-id is required.");
+      }
+
+      componentName = validateRequired(
+        getFlag(parsed.flags, "name", "n"),
+        "name",
+      );
+      wait = getBoolFlag(parsed.flags, "wait");
+      timeout = Number(getFlag(parsed.flags, "timeout") ?? "300");
+    }
+
+    // Bundle the component
+    const stream = await createComponentBundle({
+      componentName,
+      cwd: process.cwd(),
+    });
+
+    // Collect the zip buffer
+    const chunks: Buffer[] = [];
+    for await (const chunk of stream) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const zipBuffer = Buffer.concat(chunks);
+
+    if (parsed.global.dryRun) {
+      outputDryRun(
+        "deploy",
+        {
+          resourceId,
+          resourceType,
+          componentName,
+          bundleSizeBytes: zipBuffer.length,
+          bundleSizeKB: Math.round(zipBuffer.length / 1024),
+          wait,
+          timeout,
+        },
+        format,
+      );
+      return;
+    }
+
+    // Upload to builder
+    const uploadResult = await uploadBuild({
+      resourceId,
+      type: resourceType,
+      zipBuffer,
+    });
+
+    if (!uploadResult.success) {
+      outputResult(uploadResult, format);
+      process.exit(1);
+    }
+
+    // If --wait, poll until terminal
+    if (wait) {
+      const isJson = format === "json";
+      if (!isJson) {
+        process.stderr.write(
+          `Build ${uploadResult.data.id} started. Polling...\n`,
+        );
+      }
+
+      const pollResult = await pollBuildStatus(uploadResult.data.id, {
+        timeoutMs: timeout * 1000,
+        onPoll: (build) => {
+          if (!isJson) {
+            process.stderr.write(`  status: ${build.status}\n`);
+          }
+        },
+      });
+
+      outputResult(pollResult, format, parsed.global.fields);
+      if (!pollResult.success) process.exit(1);
+      if (
+        pollResult.success &&
+        isTerminalStatus(pollResult.data.status) &&
+        pollResult.data.status !== "SUCCEEDED"
+      ) {
+        process.exit(1);
+      }
+    } else {
+      outputResult(uploadResult, format, parsed.global.fields);
+    }
+  } catch (err) {
+    outputResult(
+      {
+        success: false,
+        error: { message: err instanceof Error ? err.message : String(err) },
+      },
+      format,
+    );
+    process.exit(1);
+  }
+}

package/src/commands/help.tsx

@@ -61,6 +61,18 @@ export function HelpCommand() {
           </Box>
           <Text>Create or list components</Text>
         </Box>
+        <Box>
+          <Box width={24}>
+            <Text color="green">deploy</Text>
+          </Box>
+          <Text>Bundle and upload a component/function build</Text>
+        </Box>
+        <Box>
+          <Box width={24}>
+            <Text color="green">status</Text>
+          </Box>
+          <Text>Check or poll a build status</Text>
+        </Box>
         <Box>
           <Box width={24}>
             <Text color="green">schema</Text>
@@ -146,6 +158,12 @@ export function HelpCommand() {
           $ ollieshop version create --store-id UUID --name v1 --active
         </Text>
         <Text dimColor>$ ollieshop init --store-id UUID --version-id UUID</Text>
+        <Text dimColor>
+          $ ollieshop deploy --component-id UUID --name FreeShippingBar --wait
+        </Text>
+        <Text dimColor>
+          $ ollieshop status --build-id BUILD_ID --wait -o json
+        </Text>
       </Box>
     </Box>
   );

package/src/commands/status-cmd.ts

@@ -0,0 +1,68 @@
+import {
+  fetchBuildStatus,
+  isTerminalStatus,
+  pollBuildStatus,
+} from "../core/deploy.js";
+import { detectOutputFormat, outputResult } from "../utils/output.js";
+import { type ParsedArgs, getBoolFlag, getFlag } from "../utils/parse-args.js";
+import { validateRequired } from "../utils/validate.js";
+
+export async function statusCommand(parsed: ParsedArgs): Promise<void> {
+  const format = detectOutputFormat(parsed.global.output);
+
+  try {
+    let buildId: string;
+    let wait: boolean;
+    let timeout: number;
+
+    if (parsed.global.data) {
+      const raw = JSON.parse(parsed.global.data);
+      buildId = validateRequired(raw.buildId, "buildId");
+      wait = raw.wait ?? false;
+      timeout = raw.timeout ?? 300;
+    } else {
+      buildId = validateRequired(getFlag(parsed.flags, "build-id"), "build-id");
+      wait = getBoolFlag(parsed.flags, "wait");
+      timeout = Number(getFlag(parsed.flags, "timeout") ?? "300");
+    }
+
+    if (wait) {
+      const isJson = format === "json";
+      if (!isJson) {
+        process.stderr.write(`Polling build ${buildId}...\n`);
+      }
+
+      const result = await pollBuildStatus(buildId, {
+        timeoutMs: timeout * 1000,
+        onPoll: (build) => {
+          if (!isJson) {
+            process.stderr.write(`  status: ${build.status}\n`);
+          }
+        },
+      });
+
+      outputResult(result, format, parsed.global.fields);
+      if (!result.success) process.exit(1);
+      if (
+        result.success &&
+        isTerminalStatus(result.data.status) &&
+        result.data.status !== "SUCCEEDED"
+      ) {
+        process.exit(1);
+      }
+    } else {
+      const result = await fetchBuildStatus(buildId);
+      outputResult(result, format, parsed.global.fields);
+      if (!result.success) process.exit(1);
+    }
+  } catch (err) {
+    outputResult(
+      {
+        success: false,
+        error: { message: err instanceof Error ? err.message : String(err) },
+      },
+      format,
+    );
+    process.exit(1);
+  }
+}

package/src/core/business-rule.ts

@@ -0,0 +1,128 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+
+export interface BusinessRuleRecord {
+  id: string;
+  store_id: string;
+  title: string;
+  content: string;
+  previous_content: string | null;
+  versions_ids: string[] | null;
+  components_ids: string[] | null;
+  functions_ids: string[] | null;
+  status: "draft" | "active" | "deprecated";
+  code_updated: boolean;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface ListBusinessRulesFilters {
+  store_id?: string;
+  version_id?: string;
+  code_updated?: boolean;
+}
+
+export interface UpdateBusinessRuleInput {
+  content: string;
+  versions_ids?: string[] | null;
+  components_ids?: string[] | null;
+  functions_ids?: string[] | null;
+}
+
+const SELECT_FIELDS =
+  "id, store_id, title, content, previous_content, versions_ids, components_ids, functions_ids, status, code_updated, created_at, updated_at";
+
+export async function listBusinessRules(
+  client: SupabaseClient,
+  filters: ListBusinessRulesFilters = {},
+): Promise<{ data?: BusinessRuleRecord[]; error?: { message: string } }> {
+  let query = client
+    .from("business_rules")
+    .select(SELECT_FIELDS)
+    .order("created_at", { ascending: false });
+
+  if (filters.store_id !== undefined) {
+    query = query.eq("store_id", filters.store_id);
+  }
+  if (filters.version_id !== undefined) {
+    // versions_ids is a JSON array — use "contains" to find rules linked to this version
+    query = query.filter(
+      "versions_ids",
+      "cs",
+      JSON.stringify([filters.version_id]),
+    );
+  }
+  if (filters.code_updated !== undefined) {
+    query = query.eq("code_updated", filters.code_updated);
+  }
+
+  const { data, error } = await query;
+
+  if (error) {
+    return { error: { message: error.message } };
+  }
+
+  return { data: data as BusinessRuleRecord[] };
+}
+
+export async function getBusinessRule(
+  client: SupabaseClient,
+  id: string,
+): Promise<{ data?: BusinessRuleRecord; error?: { message: string } }> {
+  const { data, error } = await client
+    .from("business_rules")
+    .select(SELECT_FIELDS)
+    .eq("id", id)
+    .single();
+
+  if (error) {
+    return { error: { message: error.message } };
+  }
+
+  return { data: data as BusinessRuleRecord };
+}
+
+export async function updateBusinessRule(
+  client: SupabaseClient,
+  id: string,
+  input: UpdateBusinessRuleInput,
+): Promise<{ data?: { id: string }; error?: { message: string } }> {
+  // Fetch current content to preserve it as previous_content
+  const { data: current, error: fetchError } = await client
+    .from("business_rules")
+    .select("content")
+    .eq("id", id)
+    .single();
+
+  if (fetchError) {
+    return { error: { message: fetchError.message } };
+  }
+
+  const updatePayload: Record<string, unknown> = {
+    previous_content: current.content,
+    content: input.content,
+    code_updated: false,
+  };
+
+  if (input.versions_ids !== undefined) {
+    updatePayload.versions_ids = input.versions_ids;
+  }
+  if (input.components_ids !== undefined) {
+    updatePayload.components_ids = input.components_ids;
+  }
+  if (input.functions_ids !== undefined) {
+    updatePayload.functions_ids = input.functions_ids;
+  }
+
+  const { data, error } = await client
+    .from("business_rules")
+    .update(updatePayload)
+    .eq("id", id)
+    .select("id")
+    .single();
+
+  if (error) {
+    return { error: { message: error.message } };
+  }
+
+  return { data: { id: data.id } };
+}

package/src/core/deploy.ts

@@ -0,0 +1,171 @@
+import { getAuthToken, getBuilderUrl } from "../utils/supabase.js";
+
+export type ResourceType = "component" | "function";
+
+export interface BuildResult {
+  id: string;
+  startTime: string;
+  endTime?: string | null;
+  status: string;
+  resource: {
+    id: string;
+    type: ResourceType;
+  };
+}
+
+export interface UploadBuildInput {
+  resourceId: string;
+  type: ResourceType;
+  zipBuffer: Buffer;
+}
+
+interface BuilderResponse {
+  success: boolean;
+  data?: BuildResult;
+  error?: { message?: string; type?: string };
+}
+
+export async function uploadBuild(
+  input: UploadBuildInput,
+): Promise<
+  | { success: true; data: BuildResult }
+  | { success: false; error: { message: string } }
+> {
+  const builderUrl = getBuilderUrl();
+  const token = await getAuthToken();
+
+  const formData = new FormData();
+  formData.append(
+    "code",
+    new Blob([input.zipBuffer], { type: "application/zip" }),
+    "code.zip",
+  );
+  formData.append("type", input.type);
+  formData.append("resource_id", input.resourceId);
+
+  let response: Response;
+  try {
+    response = await fetch(`${builderUrl}/`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+      },
+      body: formData,
+    });
+  } catch (err) {
+    return {
+      success: false,
+      error: {
+        message: `Cannot reach builder at ${builderUrl}: ${err instanceof Error ? err.message : String(err)}`,
+      },
+    };
+  }
+
+  const body = (await response.json()) as BuilderResponse;
+
+  if (!response.ok || !body.success) {
+    const msg =
+      body.error?.message ||
+      body.error?.type ||
+      `Builder returned ${response.status}`;
+    return { success: false, error: { message: msg } };
+  }
+
+  return { success: true, data: body.data as BuildResult };
+}
+
+export async function fetchBuildStatus(
+  buildId: string,
+): Promise<
+  | { success: true; data: BuildResult }
+  | { success: false; error: { message: string } }
+> {
+  const builderUrl = getBuilderUrl();
+  const token = await getAuthToken();
+
+  let response: Response;
+  try {
+    response = await fetch(`${builderUrl}/${encodeURIComponent(buildId)}`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${token}`,
+      },
+    });
+  } catch (err) {
+    return {
+      success: false,
+      error: {
+        message: `Cannot reach builder at ${builderUrl}: ${err instanceof Error ? err.message : String(err)}`,
+      },
+    };
+  }
+
+  const body = (await response.json()) as BuilderResponse;
+
+  if (!response.ok || !body.success) {
+    const msg =
+      body.error?.message ||
+      body.error?.type ||
+      `Builder returned ${response.status}`;
+    return { success: false, error: { message: msg } };
+  }
+
+  return { success: true, data: body.data as BuildResult };
+}
+
+const TERMINAL_STATUSES = new Set([
+  "SUCCEEDED",
+  "FAILED",
+  "STOPPED",
+  "TIMED_OUT",
+  "FAULT",
+]);
+
+export function isTerminalStatus(status: string): boolean {
+  return TERMINAL_STATUSES.has(status);
+}
+
+export interface PollOptions {
+  intervalMs?: number;
+  timeoutMs?: number;
+  onPoll?: (result: BuildResult) => void;
+}
+
+export async function pollBuildStatus(
+  buildId: string,
+  options: PollOptions = {},
+): Promise<
+  | { success: true; data: BuildResult }
+  | { success: false; error: { message: string } }
+> {
+  const { intervalMs = 5000, timeoutMs = 300_000, onPoll } = options;
+  const deadline = Date.now() + timeoutMs;
+
+  while (Date.now() < deadline) {
+    const result = await fetchBuildStatus(buildId);
+
+    if (!result.success) {
+      return result;
+    }
+
+    if (onPoll) {
+      onPoll(result.data);
+    }
+
+    if (isTerminalStatus(result.data.status)) {
+      return result;
+    }
+
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) break;
+
+    await new Promise((resolve) =>
+      setTimeout(resolve, Math.min(intervalMs, remaining)),
+    );
+  }
+
+  return {
+    success: false,
+    error: { message: `Build ${buildId} timed out after ${timeoutMs / 1000}s` },
+  };
+}