@unifiedcommerce/cli 0.0.1 → 0.2.1

package/dist/commands/init.js

@@ -4,7 +4,7 @@ import { fileURLToPath } from "node:url";
 import { defineCommand } from "citty";
 import consola from "consola";
 import { downloadTemplate } from "giget";
-import { copyDir, readJson, writeJson } from "../utils";
+import { copyDir, readJson, writeJson } from "../utils.js";
 const currentDir = fileURLToPath(new URL(".", import.meta.url));
 export const initCommand = defineCommand({
     meta: {

package/dist/index.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from "citty";
-import { initCommand } from "./commands/init";
-import { devCommand } from "./commands/dev";
-import { generateMigrationCommand } from "./commands/generate-migration";
-import { migrateCommand } from "./commands/migrate";
-import { deployCommand } from "./commands/deploy";
-import { importCommand } from "./commands/import";
+import { initCommand } from "./commands/init.js";
+import { devCommand } from "./commands/dev.js";
+import { generateMigrationCommand } from "./commands/generate-migration.js";
+import { migrateCommand } from "./commands/migrate.js";
+import { deployCommand } from "./commands/deploy.js";
+import { importCommand } from "./commands/import.js";
 const main = defineCommand({
     meta: {
         name: "@unifiedcommerce/cli",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unifiedcommerce/cli",
-  "version": "0.0.1",
+  "version": "0.2.1",
   "type": "module",
   "bin": {
     "unifiedcommerce": "./dist/index.js"
@@ -32,7 +32,6 @@
   },
   "files": [
     "dist",
-    "src",
     "README.md"
   ]
 }

package/src/commands/deploy.ts

@@ -1,49 +0,0 @@
-import { spawn } from "node:child_process";
-import { defineCommand } from "citty";
-import consola from "consola";
-
-export const deployCommand = defineCommand({
-  meta: {
-    name: "deploy",
-    description: "Deploy UnifiedCommerce app to a target environment.",
-  },
-  args: {
-    target: {
-      type: "string",
-      required: true,
-      description: "Deployment target. Supported: vercel",
-    },
-    prod: {
-      type: "boolean",
-      default: false,
-      description: "Deploy production build",
-    },
-  },
-  async run({ args }) {
-    const target = String(args.target).toLowerCase();
-
-    if (target !== "vercel") {
-      throw new Error(`Unsupported deploy target: ${target}. Currently supported: vercel.`);
-    }
-
-    const command = process.platform === "win32" ? "npx.cmd" : "npx";
-    const deployArgs = ["vercel", "deploy"];
-    if (args.prod) deployArgs.push("--prod");
-
-    consola.info(`Running deploy for target=${target} (${deployArgs.join(" ")})`);
-
-    await new Promise<void>((resolvePromise, rejectPromise) => {
-      const proc = spawn(command, deployArgs, {
-        stdio: "inherit",
-        shell: false,
-      });
-
-      proc.on("exit", (code) => {
-        if (code === 0) resolvePromise();
-        else rejectPromise(new Error(`Deploy command failed with code ${code}`));
-      });
-
-      proc.on("error", rejectPromise);
-    });
-  },
-});

package/src/commands/dev.ts

@@ -1,37 +0,0 @@
-import { spawn } from "node:child_process";
-import { defineCommand } from "citty";
-import consola from "consola";
-
-export const devCommand = defineCommand({
-  meta: {
-    name: "dev",
-    description: "Run local dev server with file watching",
-  },
-  args: {
-    port: {
-      type: "string",
-      default: "3000",
-    },
-  },
-  async run({ args }) {
-    const port = String(args.port);
-    consola.info(`Starting dev server on port ${port}`);
-
-    const proc = spawn(
-      process.platform === "win32" ? "npx.cmd" : "npx",
-      ["tsx", "watch", "src/dev-server.ts", "--port", port],
-      {
-        stdio: "inherit",
-        shell: false,
-      },
-    );
-
-    await new Promise<void>((resolvePromise, rejectPromise) => {
-      proc.on("exit", (code) => {
-        if (code === 0) resolvePromise();
-        else rejectPromise(new Error(`dev exited with code ${code}`));
-      });
-      proc.on("error", rejectPromise);
-    });
-  },
-});

package/src/commands/generate-migration.ts

@@ -1,23 +0,0 @@
-import { spawn } from "node:child_process";
-import { defineCommand } from "citty";
-
-export const generateMigrationCommand = defineCommand({
-  meta: {
-    name: "generate migration",
-    description: "Generate Drizzle migration",
-  },
-  async run() {
-    await new Promise<void>((resolvePromise, rejectPromise) => {
-      const proc = spawn(
-        process.platform === "win32" ? "npx.cmd" : "npx",
-        ["drizzle-kit", "generate"],
-        { stdio: "inherit" },
-      );
-      proc.on("exit", (code) => {
-        if (code === 0) resolvePromise();
-        else rejectPromise(new Error(`drizzle-kit generate failed with code ${code}`));
-      });
-      proc.on("error", rejectPromise);
-    });
-  },
-});

package/src/commands/import.ts

@@ -1,324 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { extname, resolve } from "node:path";
-import { defineCommand } from "citty";
-import consola from "consola";
-// @ts-ignore — missing type declarations
-import { importFlat } from "@unifiedcommerce/import-flat";
-// @ts-ignore — missing type declarations
-import { importShopifyCatalog } from "@unifiedcommerce/import-shopify";
-// @ts-ignore — missing type declarations
-import { importWooCommerceCatalog } from "@unifiedcommerce/import-woocommerce";
-
-type JsonRecord = Record<string, unknown>;
-
-function toBaseUrl(raw: string | undefined): string {
-  return (raw ?? "http://localhost:3000").replace(/\/$/, "");
-}
-
-function toHeaders(token?: string): Record<string, string> {
-  if (!token) return {};
-  return { authorization: `Bearer ${token}` };
-}
-
-async function requestJson<T>(
-  baseUrl: string,
-  path: string,
-  method: "GET" | "POST" | "PATCH" | "DELETE",
-  body: unknown,
-  token?: string,
-): Promise<T> {
-  const response = await fetch(`${baseUrl}${path}`, {
-    method,
-    headers: {
-      "content-type": "application/json",
-      ...toHeaders(token),
-    },
-    body: JSON.stringify(body),
-  });
-
-  const payload = (await response.json().catch(() => ({}))) as { data?: T; error?: { message?: string } };
-  if (!response.ok) {
-    const message = payload.error?.message ?? `HTTP ${response.status}`;
-    throw new Error(`Request failed for ${method} ${path}: ${message}`);
-  }
-
-  if (payload.data === undefined) {
-    throw new Error(`Expected data payload for ${method} ${path}.`);
-  }
-
-  return payload.data;
-}
-
-function createRestImportTarget(baseUrl: string, token?: string) {
-  return {
-    async createEntity(input: {
-      type: string;
-      slug: string;
-      attributes: { title: string; description?: string; subtitle?: string; locale?: string };
-      metadata?: Record<string, unknown>;
-      customFields?: Record<string, unknown>;
-    }) {
-      return requestJson<{ id: string }>(baseUrl, "/api/catalog/entities", "POST", input, token);
-    },
-    async createOptionType(input: {
-      entityId: string;
-      name: string;
-      displayName: string;
-      sortOrder?: number;
-    }) {
-      return requestJson<{ id: string }>(
-        baseUrl,
-        `/api/catalog/entities/${input.entityId}/options`,
-        "POST",
-        input,
-        token,
-      );
-    },
-    async createOptionValue(input: {
-      optionTypeId: string;
-      value: string;
-      displayValue: string;
-      sortOrder?: number;
-    }) {
-      return requestJson<{ id: string }>(
-        baseUrl,
-        `/api/catalog/options/${input.optionTypeId}/values`,
-        "POST",
-        input,
-        token,
-      );
-    },
-    async createVariant(input: {
-      entityId: string;
-      optionValueIds: string[];
-      sku?: string;
-      barcode?: string;
-      metadata?: Record<string, unknown>;
-    }) {
-      return requestJson<{ id: string }>(
-        baseUrl,
-        `/api/catalog/entities/${input.entityId}/variants`,
-        "POST",
-        input,
-        token,
-      );
-    },
-    async uploadMedia(input: {
-      filename: string;
-      contentType: string;
-      data: ArrayBuffer;
-      alt?: string;
-      metadata?: Record<string, unknown>;
-    }) {
-      const form = new FormData();
-      form.set(
-        "file",
-        new File([input.data], input.filename, {
-          type: input.contentType,
-        }),
-      );
-      if (input.alt) form.set("alt", input.alt);
-
-      const response = await fetch(`${baseUrl}/api/media/upload`, {
-        method: "POST",
-        headers: {
-          ...toHeaders(token),
-        },
-        body: form,
-      });
-
-      const payload = (await response.json().catch(() => ({}))) as {
-        data?: { id: string; url: string };
-        error?: { message?: string };
-      };
-
-      if (!response.ok || !payload.data) {
-        throw new Error(payload.error?.message ?? `Media upload failed (${response.status}).`);
-      }
-
-      return payload.data;
-    },
-    async attachMedia(input: { entityId: string; mediaAssetId: string; role: "primary" | "gallery" }) {
-      await requestJson<{ attached: boolean }>(baseUrl, "/api/media/attach", "POST", input, token);
-    },
-  };
-}
-
-async function loadJsonInput(path: string): Promise<unknown> {
-  const absolute = resolve(process.cwd(), path);
-  const raw = await readFile(absolute, "utf8");
-  return JSON.parse(raw) as unknown;
-}
-
-export const importCommand = defineCommand({
-  meta: {
-    name: "import",
-    description: "Import catalog data from Shopify, WooCommerce, or flat CSV/JSON into UnifiedCommerce.",
-  },
-  args: {
-    source: {
-      type: "string",
-      required: true,
-      description: "shopify | woocommerce | flat",
-    },
-    input: {
-      type: "string",
-      description: "Path to input JSON/CSV for offline imports",
-    },
-    targetUrl: {
-      type: "string",
-      default: "http://localhost:3000",
-      description: "UnifiedCommerce API base URL",
-    },
-    authToken: {
-      type: "string",
-      description: "Optional bearer token for target API",
-    },
-    apiKey: {
-      type: "string",
-      description: "Shopify admin API key/token",
-    },
-    storeUrl: {
-      type: "string",
-      description: "Shopify or WooCommerce store URL",
-    },
-    consumerKey: {
-      type: "string",
-      description: "WooCommerce consumer key",
-    },
-    consumerSecret: {
-      type: "string",
-      description: "WooCommerce consumer secret",
-    },
-    mapping: {
-      type: "string",
-      description: "Path to flat-import mapping JSON (required for source=flat)",
-    },
-    entityType: {
-      type: "string",
-      default: "product",
-    },
-  },
-  async run({ args }) {
-    const source = String(args.source).toLowerCase();
-    const baseUrl = toBaseUrl(args.targetUrl ? String(args.targetUrl) : undefined);
-    const token = args.authToken ? String(args.authToken) : undefined;
-    const target = createRestImportTarget(baseUrl, token);
-
-    if (source === "shopify") {
-      let products: unknown;
-      let customers: unknown;
-
-      if (args.input) {
-        const parsed = await loadJsonInput(String(args.input));
-        if (Array.isArray(parsed)) {
-          products = parsed;
-        } else if (parsed && typeof parsed === "object") {
-          products = (parsed as JsonRecord).products;
-          customers = (parsed as JsonRecord).customers;
-        }
-      }
-
-      const imported = await importShopifyCatalog({
-        target,
-        ...(args.storeUrl ? { storeUrl: String(args.storeUrl) } : {}),
-        ...(args.apiKey ? { apiKey: String(args.apiKey) } : {}),
-        entityType: String(args.entityType),
-        ...(Array.isArray(products) ? { products: products as any[] } : {}),
-        ...(Array.isArray(customers) ? { customers: customers as any[] } : {}),
-      });
-
-      if (!imported.ok) {
-        throw new Error(imported.error.message);
-      }
-
-      consola.success(`Shopify import completed: ${imported.value.entitiesImported} entities, ${imported.value.variantsImported} variants, ${imported.value.mediaImported} media.`);
-      if (imported.value.customersImported > 0) {
-        consola.info(`Imported customers: ${imported.value.customersImported}`);
-      }
-      if (imported.value.errors.length > 0) {
-        consola.warn(`Import completed with ${imported.value.errors.length} warnings.`);
-      }
-      return;
-    }
-
-    if (source === "woocommerce") {
-      let products: unknown;
-      let customers: unknown;
-
-      if (args.input) {
-        const parsed = await loadJsonInput(String(args.input));
-        if (Array.isArray(parsed)) {
-          products = parsed;
-        } else if (parsed && typeof parsed === "object") {
-          products = (parsed as JsonRecord).products;
-          customers = (parsed as JsonRecord).customers;
-        }
-      }
-
-      const imported = await importWooCommerceCatalog({
-        target,
-        ...(args.storeUrl ? { storeUrl: String(args.storeUrl) } : {}),
-        ...(args.consumerKey ? { consumerKey: String(args.consumerKey) } : {}),
-        ...(args.consumerSecret ? { consumerSecret: String(args.consumerSecret) } : {}),
-        entityType: String(args.entityType),
-        ...(Array.isArray(products) ? { products: products as any[] } : {}),
-        ...(Array.isArray(customers) ? { customers: customers as any[] } : {}),
-      });
-
-      if (!imported.ok) {
-        throw new Error(imported.error.message);
-      }
-
-      consola.success(`WooCommerce import completed: ${imported.value.entitiesImported} entities, ${imported.value.variantsImported} variants, ${imported.value.mediaImported} media.`);
-      if (imported.value.customersImported > 0) {
-        consola.info(`Imported customers: ${imported.value.customersImported}`);
-      }
-      if (imported.value.errors.length > 0) {
-        consola.warn(`Import completed with ${imported.value.errors.length} warnings.`);
-      }
-      return;
-    }
-
-    if (source === "flat") {
-      if (!args.mapping) {
-        throw new Error("--mapping is required for source=flat");
-      }
-
-      const mappingParsed = await loadJsonInput(String(args.mapping));
-      if (!mappingParsed || typeof mappingParsed !== "object") {
-        throw new Error("Flat import mapping file must be a JSON object.");
-      }
-
-      if (!args.input) {
-        throw new Error("--input is required for source=flat");
-      }
-
-      const inputPath = resolve(process.cwd(), String(args.input));
-      const raw = await readFile(inputPath, "utf8");
-      const extension = extname(inputPath).toLowerCase();
-
-      const imported = await importFlat({
-        mapping: mappingParsed as any,
-        target: {
-          async createEntity(input: unknown) {
-            return target.createEntity(input as Parameters<typeof target.createEntity>[0]);
-          },
-        },
-        ...(extension === ".csv" ? { csv: raw } : { json: raw }),
-      });
-
-      if (!imported.ok) {
-        throw new Error(imported.error.message);
-      }
-
-      consola.success(`Flat import completed: ${imported.value.imported} entities imported.`);
-      if (imported.value.failed > 0) {
-        consola.warn(`Failed rows: ${imported.value.failed}`);
-      }
-      return;
-    }
-
-    throw new Error(`Unsupported source: ${source}. Expected shopify, woocommerce, or flat.`);
-  },
-});

package/src/commands/init.ts

@@ -1,63 +0,0 @@
-import { join, resolve } from "node:path";
-import { existsSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { defineCommand } from "citty";
-import consola from "consola";
-import { downloadTemplate } from "giget";
-import { copyDir, readJson, writeJson } from "../utils";
-
-const currentDir = fileURLToPath(new URL(".", import.meta.url));
-
-interface PackageJsonShape {
-  name?: string;
-  [key: string]: unknown;
-}
-
-export const initCommand = defineCommand({
-  meta: {
-    name: "init",
-    description: "Scaffold a UnifiedCommerce project",
-  },
-  args: {
-    projectName: {
-      type: "positional",
-      description: "Project directory name",
-      required: true,
-    },
-    template: {
-      type: "string",
-      default: "starter",
-    },
-  },
-  async run({ args }) {
-    const projectName = String(args.projectName);
-    const destination = resolve(process.cwd(), projectName);
-
-    if (existsSync(destination)) {
-      throw new Error(`Directory ${destination} already exists.`);
-    }
-
-    const localTemplatePath = resolve(currentDir, "../../templates", String(args.template));
-
-    if (existsSync(localTemplatePath)) {
-      await copyDir(localTemplatePath, destination);
-    } else {
-      await downloadTemplate(`gh:unifiedcommerce/templates/${String(args.template)}`, {
-        dir: destination,
-      });
-    }
-
-    const packageJsonPath = join(destination, "package.json");
-    if (existsSync(packageJsonPath)) {
-      const pkg = await readJson<PackageJsonShape>(packageJsonPath);
-      pkg.name = projectName;
-      await writeJson(packageJsonPath, pkg);
-    }
-
-    consola.success(`Project created at ${destination}`);
-    consola.info(`Next steps:`);
-    consola.info(`  cd ${projectName}`);
-    consola.info(`  bun install`);
-    consola.info(`  bun run dev`);
-  },
-});

package/src/commands/migrate.ts

@@ -1,23 +0,0 @@
-import { spawn } from "node:child_process";
-import { defineCommand } from "citty";
-
-export const migrateCommand = defineCommand({
-  meta: {
-    name: "migrate",
-    description: "Apply Drizzle migrations",
-  },
-  async run() {
-    await new Promise<void>((resolvePromise, rejectPromise) => {
-      const proc = spawn(
-        process.platform === "win32" ? "npx.cmd" : "npx",
-        ["drizzle-kit", "migrate"],
-        { stdio: "inherit" },
-      );
-      proc.on("exit", (code) => {
-        if (code === 0) resolvePromise();
-        else rejectPromise(new Error(`drizzle-kit migrate failed with code ${code}`));
-      });
-      proc.on("error", rejectPromise);
-    });
-  },
-});

package/src/index.ts

@@ -1,30 +0,0 @@
-#!/usr/bin/env node
-import { defineCommand, runMain } from "citty";
-import { initCommand } from "./commands/init";
-import { devCommand } from "./commands/dev";
-import { generateMigrationCommand } from "./commands/generate-migration";
-import { migrateCommand } from "./commands/migrate";
-import { deployCommand } from "./commands/deploy";
-import { importCommand } from "./commands/import";
-
-const main = defineCommand({
-  meta: {
-    name: "@unifiedcommerce/cli",
-    version: "0.0.1",
-    description: "UnifiedCommerce Engine CLI",
-  },
-  subCommands: {
-    init: initCommand,
-    dev: devCommand,
-    migrate: migrateCommand,
-    deploy: deployCommand,
-    import: importCommand,
-    generate: defineCommand({
-      subCommands: {
-        migration: generateMigrationCommand,
-      },
-    }),
-  },
-});
-
-await runMain(main);

package/src/utils.ts

@@ -1,21 +0,0 @@
-import { cp, mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
-
-export async function copyDir(src: string, dest: string): Promise<void> {
-  await mkdir(dest, { recursive: true });
-  await cp(src, dest, { recursive: true, force: true });
-}
-
-export async function writeJson(path: string, value: unknown): Promise<void> {
-  await mkdir(dirname(path), { recursive: true });
-  await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, "utf8");
-}
-
-export async function readJson<T>(path: string): Promise<T> {
-  const raw = await readFile(path, "utf8");
-  return JSON.parse(raw) as T;
-}
-
-export function resolveFromCwd(path: string): string {
-  return resolve(process.cwd(), path);
-}