@ollie-shop/cli 1.0.2 → 1.2.1

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/commands/store-cmd.ts

@@ -0,0 +1,105 @@
+import { PLATFORM_VENDORS } from "../core/schema.js";
+import { createStore, listStores } from "../core/store.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 { validateEnum, validateRequired } from "../utils/validate.js";
+
+export async function storeCommand(parsed: ParsedArgs): Promise<void> {
+  const sub = parsed.subcommand;
+  if (sub === "create") return storeCreateCommand(parsed);
+  if (sub === "list" || sub === "ls") return storeListCommand(parsed);
+
+  console.error(
+    `Unknown store subcommand: ${sub}. Use: store create | store list`,
+  );
+  process.exit(1);
+}
+
+async function storeCreateCommand(parsed: ParsedArgs): Promise<void> {
+  const format = detectOutputFormat(parsed.global.output);
+
+  try {
+    let input: {
+      name: string;
+      platform: string;
+      platformStoreId: string;
+      logo?: string;
+      settings?: string;
+    };
+
+    if (parsed.global.data) {
+      // Raw JSON mode
+      const raw = JSON.parse(parsed.global.data);
+      input = {
+        name: validateRequired(raw.name, "name"),
+        platform: validateEnum(raw.platform, PLATFORM_VENDORS, "platform"),
+        platformStoreId: validateRequired(
+          raw.platformStoreId,
+          "platformStoreId",
+        ),
+        logo: raw.logo,
+        settings: raw.settings,
+      };
+    } else {
+      // Flag mode
+      input = {
+        name: validateRequired(getFlag(parsed.flags, "name", "n"), "name"),
+        platform: validateEnum(
+          validateRequired(getFlag(parsed.flags, "platform", "p"), "platform"),
+          PLATFORM_VENDORS,
+          "platform",
+        ),
+        platformStoreId: validateRequired(
+          getFlag(parsed.flags, "platform-store-id"),
+          "platform-store-id",
+        ),
+        logo: getFlag(parsed.flags, "logo"),
+        settings: getFlag(parsed.flags, "settings"),
+      };
+    }
+
+    if (parsed.global.dryRun) {
+      outputDryRun("store.create", input, format);
+      return;
+    }
+
+    const client = await getAuthenticatedClient();
+    const result = await createStore(client, 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);
+  }
+}
+
+async function storeListCommand(parsed: ParsedArgs): Promise<void> {
+  const format = detectOutputFormat(parsed.global.output);
+
+  try {
+    const client = await getAuthenticatedClient();
+    const result = await listStores(client);
+
+    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/version-cmd.ts

@@ -0,0 +1,100 @@
+import { createVersion, listVersions } from "../core/version.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 { validateRequired, validateUuid } from "../utils/validate.js";
+
+export async function versionCommand(parsed: ParsedArgs): Promise<void> {
+  const sub = parsed.subcommand;
+  if (sub === "create") return versionCreateCommand(parsed);
+  if (sub === "list" || sub === "ls") return versionListCommand(parsed);
+
+  console.error(
+    `Unknown version subcommand: ${sub}. Use: version create | version list`,
+  );
+  process.exit(1);
+}
+
+async function versionCreateCommand(parsed: ParsedArgs): Promise<void> {
+  const format = detectOutputFormat(parsed.global.output);
+
+  try {
+    let input: {
+      storeId: string;
+      name: string;
+      active?: boolean;
+      default?: boolean;
+      template?: string | null;
+    };
+
+    if (parsed.global.data) {
+      const raw = JSON.parse(parsed.global.data);
+      input = {
+        storeId: validateUuid(raw.storeId, "storeId"),
+        name: validateRequired(raw.name, "name"),
+        active: raw.active ?? false,
+        default: raw.default ?? false,
+        template: raw.template ?? null,
+      };
+    } else {
+      input = {
+        storeId: validateUuid(
+          validateRequired(getFlag(parsed.flags, "store-id"), "store-id"),
+          "store-id",
+        ),
+        name: validateRequired(getFlag(parsed.flags, "name", "n"), "name"),
+        active: getBoolFlag(parsed.flags, "active"),
+        default: getBoolFlag(parsed.flags, "default"),
+        template: getFlag(parsed.flags, "template") ?? null,
+      };
+    }
+
+    if (parsed.global.dryRun) {
+      outputDryRun("version.create", input as Record<string, unknown>, format);
+      return;
+    }
+
+    const client = await getAuthenticatedClient();
+    const result = await createVersion(client, 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);
+  }
+}
+
+async function versionListCommand(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 client = await getAuthenticatedClient();
+    const result = await listVersions(client, storeId);
+
+    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/whoami.ts

@@ -0,0 +1,28 @@
+import { getCurrentUser } from "../utils/auth.js";
+import { detectOutputFormat, outputResult } from "../utils/output.js";
+import type { ParsedArgs } from "../utils/parse-args.js";
+
+export async function whoamiCommand(parsed: ParsedArgs): Promise<void> {
+  const format = detectOutputFormat(parsed.global.output);
+
+  const user = await getCurrentUser();
+  if (!user) {
+    outputResult(
+      {
+        error: { message: "Not logged in. Run `ollieshop login`." },
+      },
+      format,
+    );
+    process.exit(1);
+  }
+
+  outputResult(
+    {
+      data: {
+        email: user.email,
+      },
+    },
+    format,
+    parsed.global.fields,
+  );
+}

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/component.ts

@@ -0,0 +1,76 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+import { componentCreateSchema } from "./schema.js";
+
+export interface CreateComponentInput {
+  versionId: string;
+  name: string;
+  slot: string;
+  active?: boolean;
+  props?: Record<string, unknown> | null;
+}
+
+export interface ComponentRecord {
+  id: string;
+  name: string;
+  slot: string | null;
+  active: boolean;
+  version_id: string;
+  props: Record<string, unknown> | null;
+  created_at: string;
+  versions?: { id: string; name: string };
+}
+
+export async function createComponent(
+  client: SupabaseClient,
+  input: CreateComponentInput,
+): Promise<{ data?: { id: string }; error?: { message: string } }> {
+  const parsed = componentCreateSchema.safeParse(input);
+  if (!parsed.success) {
+    return {
+      error: { message: parsed.error.issues.map((i) => i.message).join("; ") },
+    };
+  }
+
+  const { data, error } = await client
+    .from("components")
+    .insert({
+      name: parsed.data.name,
+      slot: parsed.data.slot,
+      active: parsed.data.active,
+      version_id: parsed.data.versionId,
+      props: parsed.data.props,
+    })
+    .select("id")
+    .single();
+
+  if (error) {
+    return { error: { message: error.message } };
+  }
+
+  return { data: { id: data.id } };
+}
+
+export async function listComponents(
+  client: SupabaseClient,
+  storeId: string,
+  versionId?: string,
+): Promise<{ data?: ComponentRecord[]; error?: { message: string } }> {
+  let query = client
+    .from("components")
+    .select(
+      "id, name, slot, active, version_id, props, created_at, versions!inner(id, name)",
+    )
+    .eq("versions.store_id", storeId);
+
+  if (versionId) {
+    query = query.eq("versions.id", versionId);
+  }
+
+  const { data, error } = await query;
+
+  if (error) {
+    return { error: { message: error.message } };
+  }
+
+  return { data: (data ?? []) as unknown as ComponentRecord[] };
+}

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` },
+  };
+}