@ollie-shop/cli 1.1.0 → 1.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ollie-shop/cli",
-  "version": "1.1.0",
+  "version": "1.2.2",
   "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/function-cmd.ts

@@ -0,0 +1,146 @@
+import { createFunction, listFunctions } from "../core/function.js";
+import { functionCreateSchema } from "../core/schema.js";
+import {
+  detectOutputFormat,
+  outputDryRun,
+  outputResult,
+} from "../utils/output.js";
+import { type ParsedArgs, getBoolFlag, getFlag } from "../utils/parse-args.js";
+import { getAuthenticatedClient } from "../utils/supabase.js";
+import {
+  validateEnum,
+  validateInteger,
+  validateRequired,
+  validateTriggerUrl,
+  validateUuid,
+} from "../utils/validate.js";
+
+const ON_ERROR_VALUES = ["throw", "skip"] as const;
+
+export async function functionCommand(parsed: ParsedArgs): Promise<void> {
+  const sub = parsed.subcommand;
+  if (sub === "create") return functionCreateCommand(parsed);
+  if (sub === "list" || sub === "ls") return functionListCommand(parsed);
+
+  console.error(
+    `Unknown function subcommand: ${sub}. Use: function create | function list`,
+  );
+  process.exit(1);
+}
+
+async function functionCreateCommand(parsed: ParsedArgs): Promise<void> {
+  const format = detectOutputFormat(parsed.global.output);
+
+  try {
+    let input: {
+      versionId: string;
+      name: string;
+      trigger?: string;
+      active?: boolean;
+      onError?: "throw" | "skip";
+      priority?: number;
+    };
+
+    if (parsed.global.data) {
+      const raw = JSON.parse(parsed.global.data);
+      input = {
+        versionId: validateUuid(raw.versionId, "versionId"),
+        name: validateRequired(raw.name, "name"),
+        trigger:
+          raw.trigger !== undefined && raw.trigger !== null
+            ? validateTriggerUrl(String(raw.trigger), "trigger")
+            : undefined,
+        active: raw.active === true,
+        onError:
+          raw.onError !== undefined && raw.onError !== null
+            ? validateEnum(String(raw.onError), ON_ERROR_VALUES, "on-error")
+            : "throw",
+        priority:
+          raw.priority !== undefined && raw.priority !== null
+            ? validateInteger(raw.priority, "priority", { min: 0 })
+            : 0,
+      };
+    } else {
+      const triggerFlag = getFlag(parsed.flags, "trigger");
+      const onErrorFlag = getFlag(parsed.flags, "on-error");
+      const priorityFlag = getFlag(parsed.flags, "priority");
+      input = {
+        versionId: validateUuid(
+          validateRequired(getFlag(parsed.flags, "version-id"), "version-id"),
+          "version-id",
+        ),
+        name: validateRequired(getFlag(parsed.flags, "name", "n"), "name"),
+        trigger:
+          triggerFlag !== undefined
+            ? validateTriggerUrl(triggerFlag, "trigger")
+            : undefined,
+        active: getBoolFlag(parsed.flags, "active"),
+        onError:
+          onErrorFlag !== undefined
+            ? validateEnum(onErrorFlag, ON_ERROR_VALUES, "on-error")
+            : "throw",
+        priority:
+          priorityFlag !== undefined
+            ? validateInteger(priorityFlag, "priority", { min: 0 })
+            : 0,
+      };
+    }
+
+    const validated = functionCreateSchema.safeParse(input);
+    if (!validated.success) {
+      throw new Error(validated.error.issues.map((i) => i.message).join("; "));
+    }
+
+    if (parsed.global.dryRun) {
+      outputDryRun(
+        "function.create",
+        validated.data as Record<string, unknown>,
+        format,
+      );
+      return;
+    }
+
+    const client = await getAuthenticatedClient();
+    const result = await createFunction(client, validated.data);
+
+    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);
+  }
+}
+
+async function functionListCommand(parsed: ParsedArgs): Promise<void> {
+  const format = detectOutputFormat(parsed.global.output);
+
+  try {
+    const storeId = validateUuid(
+      validateRequired(getFlag(parsed.flags, "store-id"), "store-id"),
+      "store-id",
+    );
+    const versionId = getFlag(parsed.flags, "version-id");
+    if (versionId) validateUuid(versionId, "version-id");
+
+    const client = await getAuthenticatedClient();
+    const result = await listFunctions(client, storeId, versionId);
+
+    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/commands/help.tsx

@@ -61,6 +61,24 @@ export function HelpCommand() {
           </Box>
           <Text>Create or list components</Text>
         </Box>
+        <Box>
+          <Box width={24}>
+            <Text color="green">function create|list</Text>
+          </Box>
+          <Text>Create or list functions</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 +164,15 @@ 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 function create --version-id UUID --name myHook
+        </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 } };
+}