@ollie-shop/cli 1.6.0 → 1.7.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @ollie-shop/cli@1.6.0 build /home/runner/work/ollie-shop/ollie-shop/packages/cli
+> @ollie-shop/cli@1.7.0 build /home/runner/work/ollie-shop/ollie-shop/packages/cli
 > tsup
 
 CLI Building entry: src/index.tsx
@@ -9,5 +9,5 @@
 CLI Target: node22
 CLI Cleaning output folder
 ESM Build start
-ESM dist/index.js 112.10 KB
-ESM ⚡️ Build success in 291ms
+ESM dist/index.js 115.94 KB
+ESM ⚡️ Build success in 278ms

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @ollie-shop/cli
 
+## 1.7.0
+
+### Minor Changes
+
+- 3d5d259: Add a `component update` command so custom component props (and name, slot, active, version) can be changed after creation directly from the CLI. Previously the CLI could only `create` and `list` components, forcing prop edits through the Studio UI. Supports partial updates via flags (`--id`, `--name`, `--slot`, `--active`, `--props`, `--version-id`) or a full `--data` JSON payload, mirroring the existing `business-rule update` command.
+
+### Patch Changes
+
+- 616e0ea: Fix `deploy --function-id` looking for the function source under `components/`. The deploy bundler was hardcoded to `components/<name>` and always emitted a component-style `index.tsx` (`export { default }`), so function deploys failed with `Component "<name>" not found in components/` — or bundled the wrong entry point. It now resolves function sources from `functions/<name>` and emits a function-style `index.ts` (`export { handler }`) that the builder's `build_function` step expects.
+
 ## 1.6.0
 
 ### Minor Changes

package/dist/index.js

@@ -47,8 +47,8 @@ function HelpCommand() {
         /* @__PURE__ */ jsx(Text, { children: "Create or list versions" })
       ] }),
       /* @__PURE__ */ jsxs(Box, { children: [
-        /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "component create|list" }) }),
-        /* @__PURE__ */ jsx(Text, { children: "Create or list components" })
+        /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "component create|update|list" }) }),
+        /* @__PURE__ */ jsx(Text, { children: "Create, update or list components" })
       ] }),
       /* @__PURE__ */ jsxs(Box, { children: [
         /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "function create|list" }) }),
@@ -520,12 +520,19 @@ import path3 from "path";
 import { PassThrough } from "stream";
 import archiver from "archiver";
 async function createComponentBundle(options) {
-  const { cwd = process.cwd(), componentName } = options;
-  const componentDir = path3.join(cwd, "components", componentName);
+  const {
+    cwd = process.cwd(),
+    componentName,
+    resourceType = "component"
+  } = options;
+  const sourceDir = resourceType === "function" ? "functions" : "components";
+  const componentDir = path3.join(cwd, sourceDir, componentName);
   try {
     await fs3.access(componentDir);
   } catch {
-    throw new Error(`Component "${componentName}" not found in components/`);
+    throw new Error(
+      `${resourceType === "function" ? "Function" : "Component"} "${componentName}" not found in ${sourceDir}/`
+    );
   }
   const packageJsonPath = path3.join(cwd, "package.json");
   try {
@@ -541,9 +548,15 @@ async function createComponentBundle(options) {
   archive.on("error", (err) => {
     output.destroy(err);
   });
-  const entryPoint = `export { default } from './components/${componentName}';
+  if (resourceType === "function") {
+    const entryPoint = `export { handler } from './functions/${componentName}';
+`;
+    archive.append(entryPoint, { name: "index.ts" });
+  } else {
+    const entryPoint = `export { default } from './components/${componentName}';
 `;
-  archive.append(entryPoint, { name: "index.tsx" });
+    archive.append(entryPoint, { name: "index.tsx" });
+  }
   archive.file(packageJsonPath, { name: "package.json" });
   const entries = await fs3.readdir(cwd, { withFileTypes: true });
   for (const entry of entries) {
@@ -1737,7 +1750,7 @@ function App({ command, args }) {
   }
 }
 function VersionCommand() {
-  const version = "1.6.0" ? "1.6.0" : "unknown";
+  const version = "1.7.0" ? "1.7.0" : "unknown";
   return /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsxs4(Text4, { children: [
     "ollieshop v",
     version
@@ -2263,6 +2276,14 @@ var componentCreateSchema = z2.object({
   active: z2.boolean().default(true).describe("Whether component is active"),
   props: z2.record(z2.unknown()).nullable().default(null).describe("Default component props as JSON object")
 });
+var componentUpdateSchema = z2.object({
+  id: z2.string().uuid().describe("Component UUID to update"),
+  versionId: z2.string().uuid().optional().describe("Move component to a different version UUID"),
+  name: z2.string().min(1).optional().describe("Component name"),
+  slot: z2.string().min(1).optional().describe("Target slot"),
+  active: z2.boolean().optional().describe("Whether component is active"),
+  props: z2.record(z2.unknown()).nullable().optional().describe("Component props as JSON object (null clears them)")
+});
 var componentListSchema = z2.object({
   storeId: z2.string().uuid().describe("Store UUID"),
   versionId: z2.string().uuid().optional().describe("Optional version UUID to filter by")
@@ -2294,6 +2315,7 @@ var schemas = {
   },
   component: {
     create: componentCreateSchema,
+    update: componentUpdateSchema,
     list: componentListSchema
   },
   function: {
@@ -2350,6 +2372,32 @@ async function createComponent(client, input) {
   }
   return { data: { id: data.id } };
 }
+async function updateComponent(client, id, input) {
+  const parsed2 = componentUpdateSchema.safeParse({ id, ...input });
+  if (!parsed2.success) {
+    return {
+      error: { message: parsed2.error.issues.map((i) => i.message).join("; ") }
+    };
+  }
+  const updatePayload = {};
+  if (input.name !== void 0) updatePayload.name = input.name;
+  if (input.slot !== void 0) updatePayload.slot = input.slot;
+  if (input.active !== void 0) updatePayload.active = input.active;
+  if (input.versionId !== void 0) updatePayload.version_id = input.versionId;
+  if (input.props !== void 0) updatePayload.props = input.props;
+  if (Object.keys(updatePayload).length === 0) {
+    return {
+      error: {
+        message: "No fields to update. Provide at least one of: --name, --slot, --active, --props, --version-id."
+      }
+    };
+  }
+  const { data, error } = await client.from("components").update(updatePayload).eq("id", id).select("id").single();
+  if (error) {
+    return { error: { message: error.message } };
+  }
+  return { data: { id: data.id } };
+}
 async function listComponents(client, storeId, versionId) {
   let query = client.from("components").select(
     "id, name, slot, active, version_id, props, created_at, versions!inner(id, name)"
@@ -2368,9 +2416,10 @@ async function listComponents(client, storeId, versionId) {
 async function componentCommand(parsed2) {
   const sub = parsed2.subcommand;
   if (sub === "create") return componentCreateCommand(parsed2);
+  if (sub === "update") return componentUpdateCommand(parsed2);
   if (sub === "list" || sub === "ls") return componentListCommand(parsed2);
   console.error(
-    `Unknown component subcommand: ${sub}. Use: component create | component list`
+    `Unknown component subcommand: ${sub}. Use: component create | component update | component list`
   );
   process.exit(1);
 }
@@ -2421,6 +2470,66 @@ async function componentCreateCommand(parsed2) {
     process.exit(1);
   }
 }
+async function componentUpdateCommand(parsed2) {
+  const format = detectOutputFormat(parsed2.global.output);
+  try {
+    let id;
+    let input;
+    if (parsed2.global.data) {
+      const raw = JSON.parse(parsed2.global.data);
+      id = validateUuid(validateRequired(raw.id, "id"), "id");
+      input = {
+        versionId: raw.versionId !== void 0 ? validateUuid(raw.versionId, "versionId") : void 0,
+        name: raw.name,
+        slot: raw.slot,
+        active: typeof raw.active === "boolean" ? raw.active : void 0,
+        props: raw.props
+      };
+    } else {
+      id = validateUuid(
+        validateRequired(getFlag(parsed2.flags, "id"), "id"),
+        "id"
+      );
+      const versionId = getFlag(parsed2.flags, "version-id");
+      if (versionId) validateUuid(versionId, "version-id");
+      const activeRaw = parsed2.flags.active;
+      let active;
+      if (activeRaw === "true" || activeRaw === true) {
+        active = true;
+      } else if (activeRaw === "false") {
+        active = false;
+      }
+      const propsRaw = getFlag(parsed2.flags, "props");
+      input = {
+        versionId,
+        name: getFlag(parsed2.flags, "name", "n"),
+        slot: getFlag(parsed2.flags, "slot", "s"),
+        active,
+        props: propsRaw ? JSON.parse(propsRaw) : void 0
+      };
+    }
+    if (parsed2.global.dryRun) {
+      outputDryRun(
+        "component.update",
+        { id, ...input },
+        format
+      );
+      return;
+    }
+    const client = await getAuthenticatedClient();
+    const result = await updateComponent(client, id, input);
+    outputResult(result, format, parsed2.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(parsed2) {
   const format = detectOutputFormat(parsed2.global.output);
   try {
@@ -2588,7 +2697,8 @@ async function deployCommand(parsed2) {
     }
     const stream = await createComponentBundle({
       componentName,
-      cwd: process.cwd()
+      cwd: process.cwd(),
+      resourceType
     });
     const chunks = [];
     for await (const chunk of stream) {

package/package.json

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

package/src/commands/component-cmd.ts

@@ -1,4 +1,8 @@
-import { createComponent, listComponents } from "../core/component.js";
+import {
+  createComponent,
+  listComponents,
+  updateComponent,
+} from "../core/component.js";
 import {
   detectOutputFormat,
   outputDryRun,
@@ -11,10 +15,11 @@ 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 === "update") return componentUpdateCommand(parsed);
   if (sub === "list" || sub === "ls") return componentListCommand(parsed);
 
   console.error(
-    `Unknown component subcommand: ${sub}. Use: component create | component list`,
+    `Unknown component subcommand: ${sub}. Use: component create | component update | component list`,
   );
   process.exit(1);
 }
@@ -79,6 +84,87 @@ async function componentCreateCommand(parsed: ParsedArgs): Promise<void> {
   }
 }
 
+async function componentUpdateCommand(parsed: ParsedArgs): Promise<void> {
+  const format = detectOutputFormat(parsed.global.output);
+
+  try {
+    let id: string;
+    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);
+      id = validateUuid(validateRequired(raw.id, "id"), "id");
+      input = {
+        versionId:
+          raw.versionId !== undefined
+            ? validateUuid(raw.versionId, "versionId")
+            : undefined,
+        name: raw.name,
+        slot: raw.slot,
+        active: typeof raw.active === "boolean" ? raw.active : undefined,
+        props: raw.props,
+      };
+    } else {
+      id = validateUuid(
+        validateRequired(getFlag(parsed.flags, "id"), "id"),
+        "id",
+      );
+
+      const versionId = getFlag(parsed.flags, "version-id");
+      if (versionId) validateUuid(versionId, "version-id");
+
+      const activeRaw = parsed.flags.active;
+      let active: boolean | undefined;
+      if (activeRaw === "true" || activeRaw === true) {
+        active = true;
+      } else if (activeRaw === "false") {
+        active = false;
+      }
+
+      const propsRaw = getFlag(parsed.flags, "props");
+
+      input = {
+        versionId,
+        name: getFlag(parsed.flags, "name", "n"),
+        slot: getFlag(parsed.flags, "slot", "s"),
+        active,
+        props: propsRaw
+          ? (JSON.parse(propsRaw) as Record<string, unknown> | null)
+          : undefined,
+      };
+    }
+
+    if (parsed.global.dryRun) {
+      outputDryRun(
+        "component.update",
+        { id, ...input } as Record<string, unknown>,
+        format,
+      );
+      return;
+    }
+
+    const client = await getAuthenticatedClient();
+    const result = await updateComponent(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);
+  }
+}
+
 async function componentListCommand(parsed: ParsedArgs): Promise<void> {
   const format = detectOutputFormat(parsed.global.output);
 

package/src/commands/deploy-cmd.ts

@@ -61,10 +61,11 @@ export async function deployCommand(parsed: ParsedArgs): Promise<void> {
       timeout = Number(getFlag(parsed.flags, "timeout") ?? "300");
     }
 
-    // Bundle the component
+    // Bundle the resource
     const stream = await createComponentBundle({
       componentName,
       cwd: process.cwd(),
+      resourceType,
     });
 
     // Collect the zip buffer

package/src/commands/help.tsx

@@ -57,9 +57,9 @@ export function HelpCommand() {
         </Box>
         <Box>
           <Box width={24}>
-            <Text color="green">component create|list</Text>
+            <Text color="green">component create|update|list</Text>
           </Box>
-          <Text>Create or list components</Text>
+          <Text>Create, update or list components</Text>
         </Box>
         <Box>
           <Box width={24}>

package/src/core/component.ts

@@ -1,5 +1,5 @@
 import type { SupabaseClient } from "@supabase/supabase-js";
-import { componentCreateSchema } from "./schema.js";
+import { componentCreateSchema, componentUpdateSchema } from "./schema.js";
 
 export interface CreateComponentInput {
   versionId: string;
@@ -9,6 +9,14 @@ export interface CreateComponentInput {
   props?: Record<string, unknown> | null;
 }
 
+export interface UpdateComponentInput {
+  versionId?: string;
+  name?: string;
+  slot?: string;
+  active?: boolean;
+  props?: Record<string, unknown> | null;
+}
+
 export interface ComponentRecord {
   id: string;
   name: string;
@@ -50,6 +58,48 @@ export async function createComponent(
   return { data: { id: data.id } };
 }
 
+export async function updateComponent(
+  client: SupabaseClient,
+  id: string,
+  input: UpdateComponentInput,
+): Promise<{ data?: { id: string }; error?: { message: string } }> {
+  const parsed = componentUpdateSchema.safeParse({ id, ...input });
+  if (!parsed.success) {
+    return {
+      error: { message: parsed.error.issues.map((i) => i.message).join("; ") },
+    };
+  }
+
+  const updatePayload: Record<string, unknown> = {};
+  if (input.name !== undefined) updatePayload.name = input.name;
+  if (input.slot !== undefined) updatePayload.slot = input.slot;
+  if (input.active !== undefined) updatePayload.active = input.active;
+  if (input.versionId !== undefined) updatePayload.version_id = input.versionId;
+  if (input.props !== undefined) updatePayload.props = input.props;
+
+  if (Object.keys(updatePayload).length === 0) {
+    return {
+      error: {
+        message:
+          "No fields to update. Provide at least one of: --name, --slot, --active, --props, --version-id.",
+      },
+    };
+  }
+
+  const { data, error } = await client
+    .from("components")
+    .update(updatePayload)
+    .eq("id", id)
+    .select("id")
+    .single();
+
+  if (error) {
+    return { error: { message: error.message } };
+  }
+
+  return { data: { id: data.id } };
+}
+
 export async function listComponents(
   client: SupabaseClient,
   storeId: string,

package/src/core/schema.ts

@@ -52,6 +52,23 @@ export const componentCreateSchema = z.object({
     .describe("Default component props as JSON object"),
 });
 
+export const componentUpdateSchema = z.object({
+  id: z.string().uuid().describe("Component UUID to update"),
+  versionId: z
+    .string()
+    .uuid()
+    .optional()
+    .describe("Move component to a different version UUID"),
+  name: z.string().min(1).optional().describe("Component name"),
+  slot: z.string().min(1).optional().describe("Target slot"),
+  active: z.boolean().optional().describe("Whether component is active"),
+  props: z
+    .record(z.unknown())
+    .nullable()
+    .optional()
+    .describe("Component props as JSON object (null clears them)"),
+});
+
 export const componentListSchema = z.object({
   storeId: z.string().uuid().describe("Store UUID"),
   versionId: z
@@ -109,6 +126,7 @@ const schemas: Record<string, SchemaMap> = {
   },
   component: {
     create: componentCreateSchema,
+    update: componentUpdateSchema,
     list: componentListSchema,
   },
   function: {

package/src/utils/bundle.ts

@@ -5,11 +5,15 @@ import archiver from "archiver";
 
 // TODO: Implement .ollieignore file support for custom exclusions
 
+export type BundleResourceType = "component" | "function";
+
 export interface BundleOptions {
   /** Project root directory */
   cwd?: string;
   /** Component name (folder name in components/) */
   componentName: string;
+  /** Resource type — decides the source folder and entry point shape */
+  resourceType?: BundleResourceType;
 }
 
 export interface BundleResult {
@@ -33,14 +37,21 @@ export interface BundleResult {
 export async function createComponentBundle(
   options: BundleOptions,
 ): Promise<PassThrough> {
-  const { cwd = process.cwd(), componentName } = options;
+  const {
+    cwd = process.cwd(),
+    componentName,
+    resourceType = "component",
+  } = options;
+
+  const sourceDir = resourceType === "function" ? "functions" : "components";
 
-  // Verify component exists
-  const componentDir = path.join(cwd, "components", componentName);
+  const componentDir = path.join(cwd, sourceDir, componentName);
   try {
     await fs.access(componentDir);
   } catch {
-    throw new Error(`Component "${componentName}" not found in components/`);
+    throw new Error(
+      `${resourceType === "function" ? "Function" : "Component"} "${componentName}" not found in ${sourceDir}/`,
+    );
   }
 
   // Verify package.json exists
@@ -67,8 +78,13 @@ export async function createComponentBundle(
   });
 
   // Add synthetic entry point
-  const entryPoint = `export { default } from './components/${componentName}';\n`;
-  archive.append(entryPoint, { name: "index.tsx" });
+  if (resourceType === "function") {
+    const entryPoint = `export { handler } from './functions/${componentName}';\n`;
+    archive.append(entryPoint, { name: "index.ts" });
+  } else {
+    const entryPoint = `export { default } from './components/${componentName}';\n`;
+    archive.append(entryPoint, { name: "index.tsx" });
+  }
 
   // Add package.json
   archive.file(packageJsonPath, { name: "package.json" });