@ollie-shop/cli 1.1.0 → 1.2.2

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

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?: 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

@@ -67,8 +67,24 @@ export const functionCreateSchema = z.object({
   trigger: z
     .string()
     .min(1)
-    .describe("Function trigger (e.g. beforePayment, afterShipping)"),
-  active: z.boolean().default(true).describe("Whether function is active"),
+    .optional()
+    .describe(
+      "Function trigger URL — absolute http(s) URL or relative path starting with /",
+    ),
+  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/index.tsx

@@ -1,8 +1,12 @@
 import { render } from "ink";
 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";
 import { storeCommand } from "./commands/store-cmd.js";
 import { versionCommand } from "./commands/version-cmd.js";
 import { whoamiCommand } from "./commands/whoami.js";
@@ -17,8 +21,12 @@ const AGENT_COMMANDS: Record<
   store: storeCommand,
   version: versionCommand,
   component: componentCommand,
+  "business-rule": businessRuleCommand,
+  function: functionCommand,
   schema: schemaCommand,
   init: initCommand,
+  deploy: deployCommand,
+  status: statusCommand,
 };
 
 const parsed = parseArgs(process.argv);

package/src/utils/supabase.ts

@@ -1,15 +1,10 @@
 import { type SupabaseClient, createClient } from "@supabase/supabase-js";
 import { getCredentials } from "./auth.js";
 
-function requireEnv(name: string): string {
-  const value = process.env[name];
-  if (!value) {
-    throw new Error(
-      `Missing required environment variable: ${name}. Set it in your .env file or shell.`,
-    );
-  }
-  return value;
-}
+// tsup inlines these from CI env vars at build time (see tsup.config.ts).
+declare const __OLLIE_SUPABASE_URL__: string;
+declare const __OLLIE_SUPABASE_ANON_KEY__: string;
+declare const __OLLIE_BUILDER_URL__: string;
 
 export async function getAuthenticatedClient(): Promise<SupabaseClient> {
   const credentials = await getCredentials();
@@ -17,8 +12,9 @@ export async function getAuthenticatedClient(): Promise<SupabaseClient> {
     throw new Error("Not authenticated. Run `ollieshop login` first.");
   }
 
-  const supabaseUrl = requireEnv("OLLIE_SUPABASE_URL");
-  const supabaseAnonKey = requireEnv("OLLIE_SUPABASE_ANON_KEY");
+  const supabaseUrl = process.env.OLLIE_SUPABASE_URL || __OLLIE_SUPABASE_URL__;
+  const supabaseAnonKey =
+    process.env.OLLIE_SUPABASE_ANON_KEY || __OLLIE_SUPABASE_ANON_KEY__;
 
   const client = createClient(supabaseUrl, supabaseAnonKey, {
     auth: {
@@ -35,6 +31,18 @@ export async function getAuthenticatedClient(): Promise<SupabaseClient> {
   return client;
 }
 
+export function getBuilderUrl(): string {
+  return process.env.OLLIE_BUILDER_URL || __OLLIE_BUILDER_URL__;
+}
+
+export async function getAuthToken(): Promise<string> {
+  const credentials = await getCredentials();
+  if (!credentials) {
+    throw new Error("Not authenticated. Run `ollieshop login` first.");
+  }
+  return credentials.accessToken;
+}
+
 export async function getOrganizationId(
   client: SupabaseClient,
 ): Promise<string> {

package/src/utils/validate.ts

@@ -56,3 +56,47 @@ export function validateRequired(
   }
   return rejectControlChars(value.trim(), name);
 }
+
+export function validateInteger(
+  value: unknown,
+  name: string,
+  opts?: { min?: number },
+): number {
+  const n =
+    typeof value === "number"
+      ? value
+      : typeof value === "string" && value.trim() !== ""
+        ? Number(value)
+        : Number.NaN;
+  if (!Number.isFinite(n) || !Number.isInteger(n)) {
+    throw new Error(`Invalid ${name}: "${String(value)}". Must be an integer.`);
+  }
+  if (opts?.min !== undefined && n < opts.min) {
+    throw new Error(`Invalid ${name}: ${n}. Must be >= ${opts.min}.`);
+  }
+  return n;
+}
+
+export function validateTriggerUrl(value: string, name: string): string {
+  rejectControlChars(value, name);
+  const trimmed = value.trim();
+  if (trimmed === "") {
+    throw new Error(
+      `Invalid ${name}: must be a non-empty absolute http(s) URL or a relative path starting with "/".`,
+    );
+  }
+  if (trimmed.startsWith("/")) {
+    return trimmed;
+  }
+  try {
+    const parsed = new URL(trimmed);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      throw new Error("unsupported protocol");
+    }
+    return trimmed;
+  } catch {
+    throw new Error(
+      `Invalid ${name}: "${value}". Must be an absolute http(s) URL or a relative path starting with "/".`,
+    );
+  }
+}

package/tsup.config.ts

@@ -1,5 +1,9 @@
 import { defineConfig } from "tsup";
 
+// CI injects SUPABASE_URL/SUPABASE_ANON_KEY/BUILDER_URL from GH Actions vars;
+// locally they're empty and the CLI falls back to runtime process.env.
+const env = (k: string) => JSON.stringify(process.env[k] ?? "");
+
 export default defineConfig({
   entry: ["src/index.tsx"],
   format: ["esm"],
@@ -7,7 +11,10 @@ export default defineConfig({
   dts: false,
   clean: true,
   sourcemap: false,
-  banner: {
-    js: "#!/usr/bin/env node",
+  banner: { js: "#!/usr/bin/env node" },
+  define: {
+    __OLLIE_SUPABASE_URL__: env("SUPABASE_URL"),
+    __OLLIE_SUPABASE_ANON_KEY__: env("SUPABASE_ANON_KEY"),
+    __OLLIE_BUILDER_URL__: env("BUILDER_URL"),
   },
 });