@ollie-shop/cli 1.0.2 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ollie-shop/cli",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Ollie Shop CLI - Development tools for custom checkouts",
   "type": "module",
   "main": "dist/index.js",
@@ -9,6 +9,7 @@
     "ollieshop": "dist/index.js"
   },
   "dependencies": {
+    "@supabase/supabase-js": "^2.49.4",
     "archiver": "^7.0.1",
     "esbuild": "^0.24.0",
     "glob": "^11.0.0",
@@ -16,7 +17,8 @@
     "jwt-decode": "^4.0.0",
     "open": "^10.1.0",
     "react": "^18.3.1",
-    "zod": "^3.24.2"
+    "zod": "^3.24.2",
+    "zod-to-json-schema": "^3.24.5"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",

package/src/commands/component-cmd.ts

@@ -0,0 +1,107 @@
+import { createComponent, listComponents } from "../core/component.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 componentCommand(parsed: ParsedArgs): Promise<void> {
+  const sub = parsed.subcommand;
+  if (sub === "create") return componentCreateCommand(parsed);
+  if (sub === "list" || sub === "ls") return componentListCommand(parsed);
+
+  console.error(
+    `Unknown component subcommand: ${sub}. Use: component create | component list`,
+  );
+  process.exit(1);
+}
+
+async function componentCreateCommand(parsed: ParsedArgs): Promise<void> {
+  const format = detectOutputFormat(parsed.global.output);
+
+  try {
+    let input: {
+      versionId: string;
+      name: string;
+      slot: string;
+      active?: boolean;
+      props?: Record<string, unknown> | null;
+    };
+
+    if (parsed.global.data) {
+      const raw = JSON.parse(parsed.global.data);
+      input = {
+        versionId: validateUuid(raw.versionId, "versionId"),
+        name: validateRequired(raw.name, "name"),
+        slot: validateRequired(raw.slot, "slot"),
+        active: raw.active ?? true,
+        props: raw.props ?? null,
+      };
+    } else {
+      input = {
+        versionId: validateUuid(
+          validateRequired(getFlag(parsed.flags, "version-id"), "version-id"),
+          "version-id",
+        ),
+        name: validateRequired(getFlag(parsed.flags, "name", "n"), "name"),
+        slot: validateRequired(getFlag(parsed.flags, "slot", "s"), "slot"),
+        active:
+          getBoolFlag(parsed.flags, "active") || !("active" in parsed.flags),
+        props: null,
+      };
+    }
+
+    if (parsed.global.dryRun) {
+      outputDryRun(
+        "component.create",
+        input as Record<string, unknown>,
+        format,
+      );
+      return;
+    }
+
+    const client = await getAuthenticatedClient();
+    const result = await createComponent(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 componentListCommand(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 listComponents(client, storeId, versionId);
+
+    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/help.tsx

@@ -16,29 +16,71 @@ export function HelpCommand() {
       </Box>
 
       <Box marginTop={1}>
-        <Text bold>Commands:</Text>
+        <Text bold>Interactive Commands:</Text>
       </Box>
       <Box marginLeft={2} flexDirection="column" gap={0}>
         <Box>
-          <Box width={16}>
+          <Box width={24}>
             <Text color="green">login</Text>
           </Box>
           <Text>Authenticate with your Ollie Shop account</Text>
         </Box>
         <Box>
-          <Box width={16}>
+          <Box width={24}>
             <Text color="green">start</Text>
           </Box>
           <Text>Start the development server with hot reload</Text>
         </Box>
+      </Box>
+
+      <Box marginTop={1}>
+        <Text bold>Agent Commands:</Text>
+      </Box>
+      <Box marginLeft={2} flexDirection="column" gap={0}>
+        <Box>
+          <Box width={24}>
+            <Text color="green">whoami</Text>
+          </Box>
+          <Text>Show current user and organization</Text>
+        </Box>
+        <Box>
+          <Box width={24}>
+            <Text color="green">store create|list</Text>
+          </Box>
+          <Text>Create or list stores</Text>
+        </Box>
         <Box>
-          <Box width={16}>
+          <Box width={24}>
+            <Text color="green">version create|list</Text>
+          </Box>
+          <Text>Create or list versions</Text>
+        </Box>
+        <Box>
+          <Box width={24}>
+            <Text color="green">component create|list</Text>
+          </Box>
+          <Text>Create or list components</Text>
+        </Box>
+        <Box>
+          <Box width={24}>
+            <Text color="green">schema</Text>
+          </Box>
+          <Text>Introspect resource schemas (JSON Schema)</Text>
+        </Box>
+        <Box>
+          <Box width={24}>
+            <Text color="green">init</Text>
+          </Box>
+          <Text>Write store/version IDs to ollie.json</Text>
+        </Box>
+        <Box>
+          <Box width={24}>
             <Text color="green">help</Text>
           </Box>
           <Text>Show this help message</Text>
         </Box>
         <Box>
-          <Box width={16}>
+          <Box width={24}>
             <Text color="green">version</Text>
           </Box>
           <Text>Show CLI version</Text>
@@ -46,33 +88,64 @@ export function HelpCommand() {
       </Box>
 
       <Box marginTop={1}>
-        <Text bold>Start Options:</Text>
+        <Text bold>Global Flags:</Text>
       </Box>
       <Box marginLeft={2} flexDirection="column" gap={0}>
         <Box>
-          <Box width={20}>
+          <Box width={24}>
+            <Text color="yellow">--output json, -o json</Text>
+          </Box>
+          <Text>Force JSON output (auto when piped)</Text>
+        </Box>
+        <Box>
+          <Box width={24}>
+            <Text color="yellow">--dry-run</Text>
+          </Box>
+          <Text>Validate without executing mutations</Text>
+        </Box>
+        <Box>
+          <Box width={24}>
+            <Text color="yellow">--fields a,b,c</Text>
+          </Box>
+          <Text>Limit output fields</Text>
+        </Box>
+        <Box>
+          <Box width={24}>
+            <Text color="yellow">--data {`'{...}'`}</Text>
+          </Box>
+          <Text>Raw JSON payload for mutations</Text>
+        </Box>
+        <Box>
+          <Box width={24}>
             <Text color="yellow">--stage, -s</Text>
           </Box>
           <Text>Config stage (loads ollie.{"{stage}"}.json)</Text>
         </Box>
       </Box>
 
-      <Box marginTop={1}>
-        <Text bold>Configuration:</Text>
-      </Box>
-      <Box marginLeft={2} flexDirection="column">
-        <Text dimColor>ollie.json - Default config (prod)</Text>
-        <Text dimColor>ollie.dev.json - Dev stage config</Text>
-        <Text dimColor>ollie.{"{stage}"}.json - Custom stage config</Text>
-      </Box>
-
       <Box marginTop={1}>
         <Text bold>Examples:</Text>
       </Box>
       <Box marginLeft={2} flexDirection="column">
         <Text dimColor>$ ollieshop login</Text>
-        <Text dimColor>$ ollieshop start</Text>
         <Text dimColor>$ ollieshop start --stage dev</Text>
+        <Text dimColor>$ ollieshop whoami -o json</Text>
+        <Text dimColor>$ ollieshop schema store.create</Text>
+        <Text dimColor>
+          $ ollieshop store create --name "My Store" --platform vtex
+          --platform-store-id mystore
+        </Text>
+        <Text dimColor>
+          $ ollieshop store create --data{" "}
+          {
+            '\'{"name":"My Store","platform":"vtex","platformStoreId":"mystore"}\''
+          }{" "}
+          -o json
+        </Text>
+        <Text dimColor>
+          $ ollieshop version create --store-id UUID --name v1 --active
+        </Text>
+        <Text dimColor>$ ollieshop init --store-id UUID --version-id UUID</Text>
       </Box>
     </Box>
   );

package/src/commands/init-cmd.ts

@@ -0,0 +1,53 @@
+import { saveConfig } from "../utils/config.js";
+import { detectOutputFormat, outputResult } from "../utils/output.js";
+import { type ParsedArgs, getFlag } from "../utils/parse-args.js";
+import { validateRequired, validateUuid } from "../utils/validate.js";
+
+export async function initCommand(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 versionIdRaw = getFlag(parsed.flags, "version-id");
+    const versionId = versionIdRaw
+      ? validateUuid(versionIdRaw, "version-id")
+      : undefined;
+
+    const stage = getFlag(parsed.flags, "stage", "s");
+
+    await saveConfig(
+      {
+        storeId,
+        ...(versionId ? { versionId } : {}),
+      },
+      { stage },
+    );
+
+    const fileName =
+      stage && stage !== "prod" ? `ollie.${stage}.json` : "ollie.json";
+
+    outputResult(
+      {
+        data: {
+          file: fileName,
+          storeId,
+          ...(versionId ? { versionId } : {}),
+        },
+      },
+      format,
+      parsed.global.fields,
+    );
+  } catch (err) {
+    outputResult(
+      {
+        error: { message: err instanceof Error ? err.message : String(err) },
+      },
+      format,
+    );
+    process.exit(1);
+  }
+}

package/src/commands/schema-cmd.ts

@@ -0,0 +1,34 @@
+import { getJsonSchema, getSchemaNames } from "../core/schema.js";
+import { detectOutputFormat } from "../utils/output.js";
+import type { ParsedArgs } from "../utils/parse-args.js";
+
+export async function schemaCommand(parsed: ParsedArgs): Promise<void> {
+  const format = detectOutputFormat(parsed.global.output);
+  const resourceName = parsed.subcommand || parsed.positional[0];
+
+  if (!resourceName) {
+    // List all available schemas
+    const names = getSchemaNames();
+    if (format === "json") {
+      process.stdout.write(`${JSON.stringify({ schemas: names })}\n`);
+    } else {
+      console.log("\x1b[1mAvailable schemas:\x1b[0m");
+      for (const name of names) {
+        const indent = name.includes(".") ? "    " : "  ";
+        console.log(`${indent}\x1b[32m${name}\x1b[0m`);
+      }
+      console.log("\nUsage: ollieshop schema <resource[.action]>");
+    }
+    return;
+  }
+
+  const schema = getJsonSchema(resourceName);
+  if (!schema) {
+    console.error(
+      `Unknown schema: ${resourceName}. Run \`ollieshop schema\` to see available schemas.`,
+    );
+    process.exit(1);
+  }
+
+  process.stdout.write(`${JSON.stringify(schema, null, 2)}\n`);
+}

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/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[] };
+}