@ollie-shop/cli 1.2.1 → 1.3.3

package/package.json

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

package/src/cli.tsx

@@ -3,6 +3,9 @@ import { HelpCommand } from "./commands/help.js";
 import { LoginCommand } from "./commands/login.js";
 import { StartCommand } from "./commands/start.js";
 
+// Inlined by tsup at build time from package.json (see tsup.config.ts).
+declare const __OLLIE_CLI_VERSION__: string;
+
 interface AppProps {
   command: string;
   args: string[];
@@ -28,9 +31,13 @@ export function App({ command, args }: AppProps) {
 }
 
 function VersionCommand() {
+  const version =
+    typeof __OLLIE_CLI_VERSION__ === "string" && __OLLIE_CLI_VERSION__
+      ? __OLLIE_CLI_VERSION__
+      : "unknown";
   return (
     <Box>
-      <Text>ollie v0.1.0</Text>
+      <Text>ollieshop v{version}</Text>
     </Box>
   );
 }

package/src/commands/function-cmd.ts

@@ -0,0 +1,178 @@
+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;
+
+function parseTriggerFromFlags(
+  urlFlag: string | undefined,
+  expressionFlag: string | undefined,
+): { url: string; expression: string } | undefined {
+  if (urlFlag === undefined && expressionFlag === undefined) return undefined;
+  if (urlFlag === undefined || expressionFlag === undefined) {
+    throw new Error(
+      "Both --trigger-url and --trigger-expression are required when configuring a trigger.",
+    );
+  }
+  return {
+    url: validateTriggerUrl(urlFlag, "trigger-url"),
+    expression: validateRequired(expressionFlag, "trigger-expression"),
+  };
+}
+
+function parseTriggerFromData(
+  raw: unknown,
+): { url: string; expression: string } | undefined {
+  if (raw === undefined || raw === null) return undefined;
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error(
+      'Invalid trigger: must be an object with "url" and "expression" string properties.',
+    );
+  }
+  const obj = raw as Record<string, unknown>;
+  if (typeof obj.url !== "string" || typeof obj.expression !== "string") {
+    throw new Error(
+      'Invalid trigger: both "url" and "expression" must be non-empty strings.',
+    );
+  }
+  return {
+    url: validateTriggerUrl(obj.url, "trigger.url"),
+    expression: validateRequired(obj.expression, "trigger.expression"),
+  };
+}
+
+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?: { url: string; expression: 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: parseTriggerFromData(raw.trigger),
+        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 triggerUrlFlag = getFlag(parsed.flags, "trigger-url");
+      const triggerExpressionFlag = getFlag(parsed.flags, "trigger-expression");
+      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: parseTriggerFromFlags(triggerUrlFlag, triggerExpressionFlag),
+        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

@@ -41,7 +41,7 @@ export function HelpCommand() {
           <Box width={24}>
             <Text color="green">whoami</Text>
           </Box>
-          <Text>Show current user and organization</Text>
+          <Text>Show current user (and linked store/org from ollie.json)</Text>
         </Box>
         <Box>
           <Box width={24}>
@@ -61,6 +61,12 @@ 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>
@@ -147,6 +153,10 @@ export function HelpCommand() {
           $ ollieshop store create --name "My Store" --platform vtex
           --platform-store-id mystore
         </Text>
+        <Text dimColor>
+          $ ollieshop store create --org UUID --name "My Store" --platform vtex
+          --platform-store-id mystore
+        </Text>
         <Text dimColor>
           $ ollieshop store create --data{" "}
           {
@@ -158,6 +168,9 @@ 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>

package/src/commands/start.tsx

@@ -1,11 +1,10 @@
-import type { BuildContext, ServeOnRequestArgs } from "esbuild";
+import type { ServeOnRequestArgs } from "esbuild";
 import { Box, Text, useApp, useInput } from "ink";
 import open from "open";
 import { useCallback, useEffect, useRef, useState } from "react";
 import { loadConfig, resolveStage } from "../utils/config.js";
 import {
   type ComponentInfo,
-  createBuildContext,
   discoverComponents,
   startDevServer,
 } from "../utils/esbuild.js";
@@ -55,7 +54,7 @@ export function StartCommand({ args }: StartCommandProps) {
   const [buildCount, setBuildCount] = useState(0);
   const [lastBuildTime, setLastBuildTime] = useState<Date | null>(null);
   const logIdRef = useRef(0);
-  const ctxRef = useRef<BuildContext | null>(null);
+  const rebuildRef = useRef<(() => Promise<void>) | null>(null);
   const stopRef = useRef<(() => Promise<void>) | null>(null);
 
   // Parse args
@@ -121,28 +120,19 @@ export function StartCommand({ args }: StartCommandProps) {
         setComponents(found);
         setState({ status: "building" });
 
-        // Create build context with discovered components
-        const ctx = await createBuildContext(found, {
+        // Start dev server
+        const server = await startDevServer({
+          port: PORT,
           stage,
+          onRequest: handleRequest,
           onBuildEnd: (updatedComponents) => {
             setComponents(updatedComponents);
             setBuildCount((c) => c + 1);
             setLastBuildTime(new Date());
           },
         });
-        ctxRef.current = ctx;
-
-        // Do initial build (manifest is written by the plugin)
-        await ctx.rebuild();
-
-        if (!mounted) return;
-
-        // Start dev server
-        const server = await startDevServer(ctx, {
-          port: PORT,
-          onRequest: handleRequest,
-        });
 
+        rebuildRef.current = server.rebuild;
         stopRef.current = server.stop;
 
         if (!mounted) {
@@ -190,7 +180,7 @@ export function StartCommand({ args }: StartCommandProps) {
 
     // Manual rebuild with 'r' (manifest is updated by the plugin)
     if (input === "r" && state.status === "running") {
-      ctxRef.current?.rebuild();
+      rebuildRef.current?.();
     }
 
     // Open Studio in browser with 'o'

package/src/commands/store-cmd.ts

@@ -7,7 +7,11 @@ import {
 } 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";
+import {
+  validateEnum,
+  validateRequired,
+  validateUuid,
+} from "../utils/validate.js";
 
 export async function storeCommand(parsed: ParsedArgs): Promise<void> {
   const sub = parsed.subcommand;
@@ -63,13 +67,16 @@ async function storeCreateCommand(parsed: ParsedArgs): Promise<void> {
       };
     }
 
+    const orgFlag = getFlag(parsed.flags, "org");
+    const orgId = orgFlag ? validateUuid(orgFlag, "org") : undefined;
+
     if (parsed.global.dryRun) {
-      outputDryRun("store.create", input, format);
+      outputDryRun("store.create", { ...input, orgId }, format);
       return;
     }
 
     const client = await getAuthenticatedClient();
-    const result = await createStore(client, input);
+    const result = await createStore(client, input, orgId);
 
     outputResult(result, format, parsed.global.fields);
     if (result.error) process.exit(1);
@@ -88,8 +95,11 @@ async function storeListCommand(parsed: ParsedArgs): Promise<void> {
   const format = detectOutputFormat(parsed.global.output);
 
   try {
+    const orgFlag = getFlag(parsed.flags, "org");
+    const orgId = orgFlag ? validateUuid(orgFlag, "org") : undefined;
+
     const client = await getAuthenticatedClient();
-    const result = await listStores(client);
+    const result = await listStores(client, orgId);
 
     outputResult(result, format, parsed.global.fields);
     if (result.error) process.exit(1);

package/src/commands/whoami.ts

@@ -1,6 +1,9 @@
+import { getStoreById } from "../core/store.js";
 import { getCurrentUser } from "../utils/auth.js";
+import { loadConfig, resolveStage } from "../utils/config.js";
 import { detectOutputFormat, outputResult } from "../utils/output.js";
 import type { ParsedArgs } from "../utils/parse-args.js";
+import { getAuthenticatedClient } from "../utils/supabase.js";
 
 export async function whoamiCommand(parsed: ParsedArgs): Promise<void> {
   const format = detectOutputFormat(parsed.global.output);
@@ -9,20 +12,78 @@ export async function whoamiCommand(parsed: ParsedArgs): Promise<void> {
   if (!user) {
     outputResult(
       {
-        error: { message: "Not logged in. Run `ollieshop login`." },
+        error: {
+          message: "Not logged in or session expired. Run `ollieshop login`.",
+        },
       },
       format,
     );
     process.exit(1);
   }
 
-  outputResult(
-    {
-      data: {
-        email: user.email,
+  try {
+    const stage = resolveStage(parsed.global.stage);
+    const config = await loadConfig({ stage });
+
+    // No project config: just report the authenticated user.
+    if (!config?.storeId) {
+      outputResult(
+        {
+          data: {
+            email: user.email,
+            hint: "No ollie.json found. Run `ollieshop init` to link a store.",
+          },
+        },
+        format,
+        parsed.global.fields,
+      );
+      return;
+    }
+
+    // Config present: resolve the store/org it points at, gated by access.
+    const client = await getAuthenticatedClient();
+    const result = await getStoreById(client, config.storeId);
+
+    if (result.error || !result.data) {
+      outputResult(
+        {
+          data: {
+            email: user.email,
+            storeId: config.storeId,
+            store: null,
+            note:
+              result.error?.message ??
+              "Store not found. Run `ollieshop login` or check the storeId in ollie.json.",
+          },
+        },
+        format,
+        parsed.global.fields,
+      );
+      return;
+    }
+
+    const store = result.data;
+    outputResult(
+      {
+        data: {
+          email: user.email,
+          orgId: store.organizationId,
+          org: store.organizationName,
+          storeId: store.id,
+          store: store.name,
+          ...(config.versionId ? { versionId: config.versionId } : {}),
+        },
       },
-    },
-    format,
-    parsed.global.fields,
-  );
+      format,
+      parsed.global.fields,
+    );
+  } catch (err) {
+    outputResult(
+      {
+        error: { message: err instanceof Error ? err.message : String(err) },
+      },
+      format,
+    );
+    process.exit(1);
+  }
 }

package/src/core/function.ts

@@ -0,0 +1,92 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+import { functionCreateSchema } from "./schema.js";
+
+export interface CreateFunctionInput {
+  versionId: string;
+  name: string;
+  trigger?: { url: string; expression: string };
+  active?: boolean;
+  onError?: "throw" | "skip";
+  priority?: number;
+}
+
+export interface FunctionRecord {
+  id: string;
+  name: string;
+  active: boolean;
+  urn: string | null;
+  on_error: string;
+  priority: number;
+  trigger: { url: string; expression: string } | null;
+  invocation: string | null;
+  version_id: string;
+  created_at: string;
+  versions?: { id: string; name: string };
+}
+
+export async function createFunction(
+  client: SupabaseClient,
+  input: CreateFunctionInput,
+): Promise<
+  | { success: true; data: { id: string } }
+  | { success: false; error: { message: string } }
+> {
+  const parsed = functionCreateSchema.safeParse(input);
+  if (!parsed.success) {
+    return {
+      success: false,
+      error: {
+        message: parsed.error.issues
+          .map((i: { message: string }) => i.message)
+          .join("; "),
+      },
+    };
+  }
+
+  const { data, error } = await client
+    .from("functions")
+    .insert({
+      name: parsed.data.name,
+      active: parsed.data.active,
+      version_id: parsed.data.versionId,
+      trigger: parsed.data.trigger ?? null,
+      on_error: parsed.data.onError ?? "throw",
+      priority: parsed.data.priority ?? 0,
+    })
+    .select("id")
+    .single();
+
+  if (error) {
+    return { success: false, error: { message: error.message } };
+  }
+
+  return { success: true, data: { id: data.id } };
+}
+
+export async function listFunctions(
+  client: SupabaseClient,
+  storeId: string,
+  versionId?: string,
+): Promise<
+  | { success: true; data: FunctionRecord[] }
+  | { success: false; error: { message: string } }
+> {
+  let query = client
+    .from("functions")
+    .select(
+      "id, name, active, urn, on_error, priority, trigger, invocation, version_id, 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 { success: false, error: { message: error.message } };
+  }
+
+  return { success: true, data: (data ?? []) as unknown as FunctionRecord[] };
+}

package/src/core/schema.ts

@@ -65,10 +65,31 @@ export const functionCreateSchema = z.object({
   versionId: z.string().uuid().describe("Parent version UUID"),
   name: z.string().min(1).describe("Function name"),
   trigger: z
-    .string()
-    .min(1)
-    .describe("Function trigger (e.g. beforePayment, afterShipping)"),
-  active: z.boolean().default(true).describe("Whether function is active"),
+    .object({
+      url: z.string().min(1).describe("Trigger URL — absolute http(s) URL"),
+      expression: z
+        .string()
+        .min(1)
+        .describe("JSONata-like match expression (e.g. 'method in [\"GET\"]')"),
+    })
+    .optional()
+    .describe(
+      "Function trigger — both url and expression are required together",
+    ),
+  active: z
+    .boolean()
+    .default(false)
+    .describe("Whether function is active (default: false)"),
+  onError: z
+    .enum(["throw", "skip"])
+    .optional()
+    .describe("Error handling: throw (default) or skip"),
+  priority: z
+    .number()
+    .int()
+    .min(0)
+    .optional()
+    .describe("Execution order priority (default: 0)"),
 });
 
 export const functionListSchema = z.object({

package/src/core/store.ts

@@ -1,5 +1,5 @@
 import type { SupabaseClient } from "@supabase/supabase-js";
-import { getOrganizationId } from "../utils/supabase.js";
+import { getOrganizationId, unwrapToOne } from "../utils/supabase.js";
 import { storeCreateSchema } from "./schema.js";
 
 export interface CreateStoreInput {
@@ -24,6 +24,7 @@ export interface StoreRecord {
 export async function createStore(
   client: SupabaseClient,
   input: CreateStoreInput,
+  orgId?: string,
 ): Promise<{ data?: { id: string }; error?: { message: string } }> {
   // Validate input against schema
   const parsed = storeCreateSchema.safeParse(input);
@@ -33,7 +34,7 @@ export async function createStore(
     };
   }
 
-  const organizationId = await getOrganizationId(client);
+  const organizationId = await getOrganizationId(client, orgId);
 
   const { data, error } = await client
     .from("stores")
@@ -55,10 +56,56 @@ export async function createStore(
   return { data: { id: data.id } };
 }
 
+export interface StoreWithOrg {
+  id: string;
+  name: string;
+  organizationId: string;
+  organizationName: string | null;
+}
+
+// Resolves a store + org by id; RLS returns no row when the user lacks access.
+export async function getStoreById(
+  client: SupabaseClient,
+  storeId: string,
+): Promise<{ data?: StoreWithOrg; error?: { message: string } }> {
+  const { data, error } = await client
+    .from("stores")
+    .select("id, name, organization_id, organizations(id, name)")
+    .eq("id", storeId)
+    .maybeSingle();
+
+  if (error) {
+    return { error: { message: error.message } };
+  }
+
+  if (!data) {
+    return {
+      error: {
+        message: `Store ${storeId} not found or you don't have access to it.`,
+      },
+    };
+  }
+
+  const org = unwrapToOne<{ name?: string }>(
+    (data as { organizations?: unknown }).organizations,
+  );
+  const orgName = org?.name ?? null;
+
+  return {
+    data: {
+      id: data.id as string,
+      name: data.name as string,
+      organizationId: data.organization_id as string,
+      organizationName: orgName,
+    },
+  };
+}
+
 export async function listStores(
   client: SupabaseClient,
+  orgId?: string,
 ): Promise<{ data?: StoreRecord[]; error?: { message: string } }> {
-  const organizationId = await getOrganizationId(client);
+  const organizationId = await getOrganizationId(client, orgId);
 
   const { data, error } = await client
     .from("stores")

package/src/index.tsx

@@ -3,6 +3,7 @@ import { App } from "./cli.js";
 import { businessRuleCommand } from "./commands/business-rule-cmd.js";
 import { componentCommand } from "./commands/component-cmd.js";
 import { deployCommand } from "./commands/deploy-cmd.js";
+import { functionCommand } from "./commands/function-cmd.js";
 import { initCommand } from "./commands/init-cmd.js";
 import { schemaCommand } from "./commands/schema-cmd.js";
 import { statusCommand } from "./commands/status-cmd.js";
@@ -21,6 +22,7 @@ const AGENT_COMMANDS: Record<
   version: versionCommand,
   component: componentCommand,
   "business-rule": businessRuleCommand,
+  function: functionCommand,
   schema: schemaCommand,
   init: initCommand,
   deploy: deployCommand,