@ollie-shop/cli 0.3.3 → 1.0.0

package/src/utils/bundle.ts

@@ -0,0 +1,177 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { PassThrough } from "node:stream";
+import archiver from "archiver";
+
+// TODO: Implement .ollieignore file support for custom exclusions
+
+export interface BundleOptions {
+  /** Project root directory */
+  cwd?: string;
+  /** Component name (folder name in components/) */
+  componentName: string;
+}
+
+export interface BundleResult {
+  /** Readable stream of the zip file */
+  stream: PassThrough;
+  /** Size of the zip in bytes (available after stream ends) */
+  size: number;
+}
+
+/**
+ * Creates a zip bundle for a component with a synthetic entry point.
+ *
+ * The bundle includes:
+ * - index.tsx: synthetic entry point that re-exports the component
+ * - package.json: project dependencies
+ * - components/: all component source files
+ * - Any other user directories (utils/, hooks/, etc.)
+ *
+ * Excludes: node_modules, .git, .next, dist, build, etc.
+ */
+export async function createComponentBundle(
+  options: BundleOptions,
+): Promise<PassThrough> {
+  const { cwd = process.cwd(), componentName } = options;
+
+  // Verify component exists
+  const componentDir = path.join(cwd, "components", componentName);
+  try {
+    await fs.access(componentDir);
+  } catch {
+    throw new Error(`Component "${componentName}" not found in components/`);
+  }
+
+  // Verify package.json exists
+  const packageJsonPath = path.join(cwd, "package.json");
+  try {
+    await fs.access(packageJsonPath);
+  } catch {
+    throw new Error("package.json not found in project root");
+  }
+
+  // Create archive with max compression
+  const archive = archiver("zip", {
+    zlib: { level: 9 },
+  });
+
+  // Create output stream
+  const output = new PassThrough();
+
+  archive.pipe(output);
+
+  // Handle archive errors
+  archive.on("error", (err) => {
+    output.destroy(err);
+  });
+
+  // Add synthetic entry point
+  const entryPoint = `export { default } from './components/${componentName}';\n`;
+  archive.append(entryPoint, { name: "index.tsx" });
+
+  // Add package.json
+  archive.file(packageJsonPath, { name: "package.json" });
+
+  // Add all directories from project root (excluding defaults)
+  const entries = await fs.readdir(cwd, { withFileTypes: true });
+
+  for (const entry of entries) {
+    // Skip excluded patterns
+    if (shouldExclude(entry.name)) {
+      continue;
+    }
+
+    const entryPath = path.join(cwd, entry.name);
+
+    if (entry.isDirectory()) {
+      // Add directory recursively
+      archive.directory(entryPath, entry.name, (data) => {
+        // Filter out excluded patterns within directories
+        const relativePath = path.relative(cwd, data.name || "");
+        if (shouldExcludeFile(relativePath)) {
+          return false;
+        }
+        return data;
+      });
+    } else if (entry.isFile() && isSourceFile(entry.name)) {
+      // Add root-level source files (but not package.json, already added)
+      if (entry.name !== "package.json") {
+        archive.file(entryPath, { name: entry.name });
+      }
+    }
+  }
+
+  // Finalize the archive
+  archive.finalize();
+
+  return output;
+}
+
+/**
+ * Check if a file/directory should be excluded at the root level
+ */
+function shouldExclude(name: string): boolean {
+  const excludeRoots = [
+    "node_modules",
+    ".git",
+    ".next",
+    "dist",
+    "build",
+    ".turbo",
+    ".cache",
+    "coverage",
+  ];
+  return excludeRoots.includes(name) || name.startsWith(".");
+}
+
+/**
+ * Check if a file path should be excluded
+ */
+function shouldExcludeFile(relativePath: string): boolean {
+  // Exclude node_modules anywhere in the tree
+  if (relativePath.includes("node_modules")) {
+    return true;
+  }
+
+  // Exclude common build artifacts
+  const excludePatterns = [
+    /\.tsbuildinfo$/,
+    /\.d\.ts$/,
+    /\.js\.map$/,
+    /\.next\//,
+    /dist\//,
+    /build\//,
+  ];
+
+  return excludePatterns.some((pattern) => pattern.test(relativePath));
+}
+
+/**
+ * Check if a file is a source file we want to include
+ */
+function isSourceFile(name: string): boolean {
+  const sourceExtensions = [
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".json",
+    ".css",
+    ".scss",
+    ".less",
+    ".svg",
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".webp",
+    ".ico",
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".eot",
+  ];
+
+  return sourceExtensions.some((ext) => name.endsWith(ext));
+}

package/src/utils/config.ts

@@ -0,0 +1,123 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+
+const OllieConfigSchema = z
+  .object({
+    storeId: z.string().uuid(),
+    versionId: z.string().uuid().optional(),
+  })
+  .passthrough(); // Allow any other fields without validation
+
+export type OllieConfig = z.infer<typeof OllieConfigSchema>;
+
+const CONFIG_FILE = "ollie.json";
+
+/**
+ * Gets the config file name for a given stage.
+ * - No stage or "prod" → ollie.json
+ * - Other stages → ollie.{stage}.json
+ */
+function getConfigFileName(stage?: string): string {
+  if (!stage || stage === "prod") {
+    return CONFIG_FILE;
+  }
+  return `ollie.${stage}.json`;
+}
+
+/**
+ * Loads a single config file (without stage resolution).
+ */
+async function loadConfigFile(
+  filePath: string,
+): Promise<Record<string, unknown> | null> {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+
+export interface LoadConfigOptions {
+  cwd?: string;
+  stage?: string;
+}
+
+/**
+ * Loads the config for a given stage.
+ * - Loads ollie.json as base config
+ * - If stage is provided (and not "prod"), merges ollie.{stage}.json on top
+ */
+export async function loadConfig(
+  options: LoadConfigOptions = {},
+): Promise<OllieConfig | null> {
+  const { cwd = process.cwd(), stage } = options;
+
+  // Load base config (ollie.json)
+  const basePath = path.join(cwd, CONFIG_FILE);
+  const baseConfig = await loadConfigFile(basePath);
+
+  if (!baseConfig) {
+    return null;
+  }
+
+  // If no stage or stage is "prod", return base config
+  if (!stage || stage === "prod") {
+    return OllieConfigSchema.parse(baseConfig);
+  }
+
+  // Load stage-specific config
+  const stageFileName = getConfigFileName(stage);
+  const stagePath = path.join(cwd, stageFileName);
+  const stageConfig = await loadConfigFile(stagePath);
+
+  if (!stageConfig) {
+    throw new Error(
+      `Stage config not found: ${stageFileName}. Create it or use --stage prod (default).`,
+    );
+  }
+
+  // Merge: stage config overrides base config
+  const merged = {
+    ...baseConfig,
+    ...stageConfig,
+  };
+
+  return OllieConfigSchema.parse(merged);
+}
+
+export interface SaveConfigOptions {
+  cwd?: string;
+  stage?: string;
+}
+
+export async function saveConfig(
+  config: Partial<OllieConfig>,
+  options: SaveConfigOptions = {},
+): Promise<void> {
+  const { cwd = process.cwd(), stage } = options;
+  const fileName = getConfigFileName(stage);
+  const configPath = path.join(cwd, fileName);
+
+  // Load existing config for this specific file
+  const existing = await loadConfigFile(configPath);
+
+  const merged = {
+    ...existing,
+    ...config,
+  };
+
+  await fs.writeFile(configPath, JSON.stringify(merged, null, 2));
+}
+
+/**
+ * Returns the resolved stage from CLI args or environment.
+ * Priority: CLI arg > OLLIE_STAGE env > undefined (defaults to prod behavior)
+ */
+export function resolveStage(cliStage?: string): string | undefined {
+  return cliStage || process.env.OLLIE_STAGE || undefined;
+}