create-acmekit-app 2.13.1

package/.turbo/turbo-build.log

@@ -0,0 +1 @@
+

package/CHANGELOG.md

@@ -0,0 +1,3 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.

package/README.md

@@ -0,0 +1,58 @@
+<p align="center">
+  <a href="https://www.acmekit.com">
+    <img alt="AcmeKit" src="https://user-images.githubusercontent.com/7554214/153162406-bf8fd16f-aa98-4604-b87b-e13ab4baf604.png" width="100" />
+  </a>
+</p>
+<h1 align="center">
+  create-acmekit-app
+</h1>
+
+<h4 align="center">
+  <a href="https://docs.acmekit.com">Documentation</a> |
+  <a href="https://www.acmekit.com">Website</a>
+</h4>
+
+<p align="center">
+An open source composable commerce engine built for developers.
+</p>
+<p align="center">
+  <a href="https://github.com/acmekit/acmekit/blob/master/LICENSE">
+    <img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="AcmeKit is released under the MIT license." />
+  </a>
+  <a href="https://circleci.com/gh/acmekit/acmekit">
+    <img src="https://circleci.com/gh/acmekit/acmekit.svg?style=shield" alt="Current CircleCI build status." />
+  </a>
+  <a href="https://github.com/acmekit/acmekit/blob/master/CONTRIBUTING.md">
+    <img src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat" alt="PRs welcome!" />
+  </a>
+    <a href="https://www.producthunt.com/posts/acmekit"><img src="https://img.shields.io/badge/Product%20Hunt-%231%20Product%20of%20the%20Day-%23DA552E" alt="Product Hunt"></a>
+  <a href="https://discord.gg/xpCwq3Kfn8">
+    <img src="https://img.shields.io/badge/chat-on%20discord-7289DA.svg" alt="Discord Chat" />
+  </a>
+  <a href="https://twitter.com/intent/follow?screen_name=acmekit">
+    <img src="https://img.shields.io/twitter/follow/acmekit.svg?label=Follow%20@acmekit" alt="Follow @acmekit" />
+  </a>
+</p>
+
+## Overview
+
+Using this NPX command, you can setup a AcmeKit backend and admin along with a PostgreSQL database in simple steps.
+
+---
+
+## Usage
+
+Run the following command in your terminal:
+
+```bash
+npx create-acmekit-app@latest
+```
+
+Then, answer the prompted questions to setup your PostgreSQL database and AcmeKit project. Once the setup is done, the AcmeKit admin dashboard will open in your default browser.
+
+### Options
+
+| Option             | Description                                           | Default value                                        |
+|--------------------|-------------------------------------------------------|------------------------------------------------------|
+| `--repo-url <url>` | Create AcmeKit project from a different repository URL | `https://github.com/acmekit/acmekit-starter-default` |
+| `--seed`           | Using this option seeds the database with demo data   | false                                                |

package/dist/commands/create.js

@@ -0,0 +1,8 @@
+import { ProjectCreatorFactory, } from "../utils/project-creator/index.js";
+/**
+ * Command handler to create a AcmeKit project or plugin
+ */
+export default async (args, options) => {
+    const projectCreator = await ProjectCreatorFactory.create(args, options);
+    await projectCreator.create();
+};

package/dist/index.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import { Option, program } from "commander";
+import create from "./commands/create.js";
+program
+    .description("Create a new AcmeKit project or plugin")
+    .argument("[project-name]", "Name of the project to create.")
+    .option("--plugin", "Create a plugin instead of a project.")
+    .option("--repo-url <url>", "URL of repository to use to setup project.")
+    .option("--version <version>", "The version of AcmeKit packages to install.")
+    .option("--seed", "Seed the created database with demo data.")
+    .option("--skip-db", "Skips creating the database, running migrations, and seeding, and subsequently skips opening the browser.", false)
+    .option("--db-url <url>", "Skips database creation and sets the database URL to the provided URL. Throws an error if can't connect to the database. Will still run migrations and open the admin after project creation.")
+    .option("--no-migrations", "Skips running migrations, creating admin user, and seeding. If used, it's expected that you pass the --db-url option with a url of a database that has all necessary migrations. Otherwise, unexpected errors will occur.", true)
+    .option("--no-browser", "Disables opening the browser at the end of the project creation and only shows success message.", true)
+    .option("--directory-path <path>", "Specify the directory path to install the project in.")
+    .option("--with-nextjs-starter", "Install the Next.js starter along with the AcmeKit backend", false)
+    .option("--verbose", "Show all logs of underlying commands. Useful for debugging.", false)
+    .addOption(new Option("--use-npm", "Use npm as the package manager").conflicts([
+    "usePnpm",
+    "useYarn",
+]))
+    .addOption(new Option("--use-yarn", "Use yarn as the package manager").conflicts([
+    "useNpm",
+    "usePnpm",
+]))
+    .addOption(new Option("--use-pnpm", "Use pnpm as the package manager").conflicts([
+    "useNpm",
+    "useYarn",
+]))
+    .parse();
+void create(program.args, program.opts());

package/dist/utils/clone-repo.js

@@ -0,0 +1,77 @@
+import fs from "fs";
+import path from "path";
+import { isAbortError } from "./create-abort-controller.js";
+import execute from "./execute.js";
+import logMessage from "./log-message.js";
+import { execFileSync } from "child_process";
+const DEFAULT_REPO = "https://github.com/acmekit/acmekit-starter-default";
+const DEFAULT_PLUGIN_REPO = "https://github.com/acmekit/acmekit-starter-plugin";
+const BRANCH = "master";
+const PLUGIN_BRANCH = "main";
+export default async function cloneRepo({ directoryName = "", repoUrl, abortController, verbose = false, isPlugin = false, }) {
+    const defaultRepo = isPlugin ? DEFAULT_PLUGIN_REPO : DEFAULT_REPO;
+    const branch = isPlugin ? PLUGIN_BRANCH : BRANCH;
+    await execute([
+        `git clone ${repoUrl || defaultRepo} -b ${branch} ${directoryName} --depth 1`,
+        {
+            signal: abortController?.signal,
+        },
+    ], { verbose });
+}
+export async function runCloneRepo({ projectName, repoUrl, abortController, spinner, verbose = false, isPlugin = false, }) {
+    try {
+        await cloneRepo({
+            directoryName: projectName,
+            repoUrl,
+            abortController,
+            verbose,
+            isPlugin,
+        });
+        deleteGitDirectory(projectName);
+    }
+    catch (e) {
+        if (isAbortError(e)) {
+            process.exit();
+        }
+        spinner.stop();
+        logMessage({
+            message: `An error occurred while setting up your project: ${e}`,
+            type: "error",
+        });
+    }
+}
+function deleteGitDirectory(projectDirectory) {
+    try {
+        fs.rmSync(path.join(projectDirectory, ".git"), {
+            recursive: true,
+            force: true,
+        });
+    }
+    catch (error) {
+        deleteWithCommand(projectDirectory, ".git");
+    }
+    try {
+        fs.rmSync(path.join(projectDirectory, ".github"), {
+            recursive: true,
+            force: true,
+        });
+    }
+    catch (error) {
+        deleteWithCommand(projectDirectory, ".github");
+    }
+}
+/**
+ * Useful for deleting directories when fs methods fail (e.g., with Yarn v3)
+ */
+function deleteWithCommand(projectDirectory, dirName) {
+    const dirPath = path.normalize(path.join(projectDirectory, dirName));
+    if (!fs.existsSync(dirPath)) {
+        return;
+    }
+    if (process.platform === "win32") {
+        execFileSync("cmd", ["/c", "rmdir", "/s", "/q", dirPath]);
+    }
+    else {
+        execFileSync("rm", ["-rf", dirPath]);
+    }
+}

package/dist/utils/create-abort-controller.js

@@ -0,0 +1,11 @@
+export default (processManager) => {
+    const abortController = new AbortController();
+    processManager.onTerminated(() => abortController.abort());
+    return abortController;
+};
+export const isAbortError = (e) => e !== null && typeof e === "object" && "code" in e && e.code === "ABORT_ERR";
+export const getAbortError = () => {
+    return {
+        code: "ABORT_ERR",
+    };
+};

package/dist/utils/create-db.js

@@ -0,0 +1,172 @@
+import { EOL } from "os";
+import postgresClient, { DEFAULT_HOST, DEFAULT_PORT, } from "./postgres-client.js";
+import inquirer from "inquirer";
+import logMessage from "./log-message.js";
+import formatConnectionString from "./format-connection-string.js";
+import terminalLink from "terminal-link";
+export default async function createDb({ client, db }) {
+    await client.query(`CREATE DATABASE "${db}"`);
+}
+async function doesDbExist(client, dbName) {
+    const result = await client.query(`SELECT datname FROM pg_catalog.pg_database WHERE datname='${dbName}';`);
+    return !!result.rowCount;
+}
+export async function runCreateDb({ client, dbName, spinner, }) {
+    let newClient = client;
+    try {
+        // create postgres database
+        await createDb({
+            client,
+            db: dbName,
+        });
+        // create a new connection with database selected
+        await client.end();
+        newClient = await postgresClient({
+            user: client.user,
+            password: client.password,
+            database: dbName,
+        });
+    }
+    catch (e) {
+        spinner.stop();
+        logMessage({
+            message: `An error occurred while trying to create your database: ${e}`,
+            type: "error",
+        });
+    }
+    return newClient;
+}
+async function getForDbName({ dbName, verbose = false, }) {
+    let client;
+    let postgresUsername = "postgres";
+    let postgresPassword = "";
+    const defaultConnectionOptions = {
+        host: DEFAULT_HOST,
+        port: DEFAULT_PORT,
+    };
+    try {
+        client = await postgresClient({
+            user: postgresUsername,
+            password: postgresPassword,
+            ...defaultConnectionOptions,
+        });
+    }
+    catch (e) {
+        if (verbose) {
+            logMessage({
+                message: `The following error occured when connecting to the database: ${e}`,
+                type: "verbose",
+            });
+        }
+        // ask for the user's postgres credentials
+        const answers = await inquirer.prompt([
+            {
+                type: "input",
+                name: "postgresUsername",
+                message: "Enter your Postgres username",
+                default: "postgres",
+                validate: (input) => {
+                    return typeof input === "string" && input.length > 0;
+                },
+            },
+            {
+                type: "password",
+                name: "postgresPassword",
+                message: "Enter your Postgres password",
+            },
+        ]);
+        postgresUsername = answers.postgresUsername;
+        postgresPassword = answers.postgresPassword;
+        const { userDbName } = await inquirer.prompt([
+            {
+                type: "database",
+                name: "userDbName",
+                message: "Enter your Postgres user's database name",
+                default: answers.postgresUsername,
+                validate: (input) => {
+                    return typeof input === "string" && input.length > 0;
+                },
+            },
+        ]);
+        try {
+            client = await postgresClient({
+                user: postgresUsername,
+                password: postgresPassword,
+                database: userDbName,
+                ...defaultConnectionOptions,
+            });
+        }
+        catch (e) {
+            logMessage({
+                message: `Couldn't connect to PostgreSQL because of the following error: ${e}.${EOL}${EOL}Make sure you have PostgreSQL installed and the credentials you provided are correct.${EOL}${EOL}If you keep running into this issue despite having PostgreSQL installed, please check out our ${terminalLink("troubleshooting guides", "https://docs.acmekit.com/resources/troubleshooting/database-errors")}.`,
+                type: "error",
+            });
+        }
+    }
+    // check if database exists
+    if (await doesDbExist(client, dbName)) {
+        const { newDbName } = await inquirer.prompt([
+            {
+                type: "input",
+                name: "newDbName",
+                message: `A database already exists with the name ${dbName}, please enter a name for the database:`,
+                default: dbName,
+                validate: (input) => {
+                    return (typeof input === "string" && input.length > 0 && input !== dbName);
+                },
+            },
+        ]);
+        dbName = newDbName;
+    }
+    // format connection string
+    const dbConnectionString = formatConnectionString({
+        user: postgresUsername,
+        password: postgresPassword,
+        host: client.host,
+        db: dbName,
+    });
+    return {
+        client,
+        dbConnectionString,
+        dbName,
+    };
+}
+async function getForDbUrl({ dbUrl, verbose = false, }) {
+    let client;
+    try {
+        client = await postgresClient({
+            connectionString: dbUrl,
+        });
+    }
+    catch (e) {
+        if (verbose) {
+            logMessage({
+                message: `The following error occured when connecting to the database: ${e}`,
+                type: "verbose",
+            });
+        }
+        logMessage({
+            message: `Couldn't connect to PostgreSQL using the database URL you passed. Make sure it's correct and try again.`,
+            type: "error",
+        });
+    }
+    return {
+        client,
+        dbConnectionString: dbUrl,
+    };
+}
+export async function getDbClientAndCredentials({ dbName = "", dbUrl = "", verbose = false, }) {
+    // Check the db-url first, because the dbName is always defined in AcmeKitProjectCreator->create()->initializeProject()->setupDatabase()
+    if (dbUrl) {
+        return await getForDbUrl({
+            dbUrl,
+            verbose,
+        });
+    }
+    else {
+        return await getForDbName({
+            dbName,
+            verbose,
+        });
+    }
+}

package/dist/utils/execute.js

@@ -0,0 +1,51 @@
+import { exec, spawnSync } from "child_process";
+import util from "util";
+import { getAbortError } from "./create-abort-controller.js";
+const promiseExec = util.promisify(exec);
+const execute = async (command, { verbose = false, needOutput = false }) => {
+    if (verbose) {
+        const [commandStr, options] = command;
+        const childProcess = spawnSync(commandStr, {
+            ...options,
+            shell: true,
+            stdio: needOutput
+                ? "pipe"
+                : [process.stdin, process.stdout, process.stderr],
+            env: {
+                ...process.env,
+                ...(options.env || {}),
+            },
+        });
+        if (childProcess.error || childProcess.status !== 0) {
+            throw (childProcess.error ||
+                childProcess.stderr?.toString() ||
+                `${commandStr} failed with status ${childProcess.status}`);
+        }
+        if (childProcess.signal &&
+            ["SIGINT", "SIGTERM"].includes(childProcess.signal)) {
+            throw getAbortError();
+        }
+        if (needOutput) {
+            console.log(childProcess.stdout?.toString() || childProcess.stderr?.toString());
+        }
+        return {
+            stdout: childProcess.stdout?.toString() || "",
+            stderr: childProcess.stderr?.toString() || "",
+        };
+    }
+    else {
+        const [commandStr, options] = command;
+        const childProcess = await promiseExec(commandStr, {
+            ...options,
+            env: {
+                ...process.env,
+                ...(options?.env || {}),
+            },
+        });
+        return {
+            stdout: childProcess.stdout,
+            stderr: childProcess.stderr,
+        };
+    }
+};
+export default execute;

package/dist/utils/facts.js

@@ -0,0 +1,87 @@
+import boxen from "boxen";
+import chalk from "chalk";
+import { emojify } from "node-emoji";
+import terminalLink from "terminal-link";
+const facts = [
+    "Specify a product's availability in one or more sales channels.",
+    "Payment providers can be configured per region.",
+    "Tax-inclusive pricing allows you to set prices for products and shipping options while delegating tax calculations to AcmeKit.",
+    "AcmeKit provides multi-currency and region support, with full control over prices for each currency and region.",
+    "Organize customers by customer groups and set special prices for them.",
+    "Specify the inventory of products per location and sales channel.",
+    "Publishable-API Keys allow you to send scoped requests to the server's store API routes.",
+    "API Routes expose business logic to clients, such as storefronts and admin customizations.",
+    "Subscribers are asynchronous functions that are executed when an event is emitted.",
+    "Data models represent tables in the database. They are created using AcmeKit's Data Modeling Language (DML).",
+    "AcmeKit's store API routes are prefixed by /store. The admin API routes are prefixed by /admin.",
+    "The JS SDK allows you to send requests to the AcmeKit server from your storefront or admin customizations.",
+    "Modules are reusable packages of functionalities related to a single commerce domain or integration.",
+    "Modules have a main service that provides data-management and integration functionalities.",
+    "Modules allow you to replace an entire functionality with your custom logic.",
+    "Infrastructure Modules are interchangeable modules that implement features and integrations related to the AcmeKit server's infrastructure.",
+    "Commerce Modules are built-in modules that provide core commerce logic specific to domains like Product, Cart and Order.",
+    "Workflows are a series of queries and actions, called steps, that complete a task.",
+    "A workflow's steps can be retried or rolled back in case of an error.",
+    `AcmeKit provides ${terminalLink("Claude Code plugins", "https://github.com/acmekit/acmekit-claude-plugins")} to facilitate your development.`,
+    "AcmeKit provides an MCP server at https://docs.acmekit.com/mcp to support your learning and development experience with AI agents",
+    `AcmeKit is optimized to build custom commerce software with AI agents through its MCP server and ${terminalLink("Claude Code plugins", "https://github.com/acmekit/acmekit-claude-plugins")}.`,
+];
+export const getFact = () => {
+    const randIndex = Math.floor(Math.random() * facts.length);
+    return facts[randIndex];
+};
+export const showFact = ({ spinner, title, verbose, }) => {
+    const fact = getFact();
+    if (verbose) {
+        spinner.stopAndPersist({
+            symbol: chalk.cyan("⠋"),
+            text: title,
+        });
+    }
+    else {
+        spinner.text = `${title}\n${boxen(`${fact}`, {
+            title: chalk.cyan(`${emojify(":bulb:")} AcmeKit Tips`),
+            titleAlignment: "center",
+            textAlignment: "center",
+            padding: 1,
+            margin: 1,
+        })}`;
+    }
+};
+export const createFactBox = ({ spinner, title, processManager, verbose, }) => {
+    showFact({ spinner, title, verbose });
+    const interval = setInterval(() => {
+        showFact({ spinner, title, verbose });
+    }, 10000);
+    processManager.addInterval(interval);
+    return interval;
+};
+export const resetFactBox = ({ interval, spinner, successMessage, processManager, newTitle, verbose, }) => {
+    if (interval) {
+        clearInterval(interval);
+    }
+    spinner.succeed(chalk.green(successMessage)).start();
+    let newInterval = null;
+    if (newTitle) {
+        newInterval = createFactBox({
+            spinner,
+            title: newTitle,
+            processManager,
+            verbose,
+        });
+    }
+    return newInterval;
+};
+export function displayFactBox({ interval, spinner, processManager, title = "", message = "", verbose = false, }) {
+    if (!message) {
+        return createFactBox({ spinner, title, processManager, verbose });
+    }
+    return resetFactBox({
+        interval,
+        spinner,
+        successMessage: message,
+        processManager,
+        newTitle: title,
+        verbose,
+    });
+}

package/dist/utils/format-connection-string.js

@@ -0,0 +1,17 @@
+export function encodeDbValue(value) {
+    return encodeURIComponent(value);
+}
+export default ({ user, password, host, db }) => {
+    let connection = `postgres://`;
+    if (user) {
+        connection += encodeDbValue(user);
+    }
+    if (password) {
+        connection += `:${encodeDbValue(password)}`;
+    }
+    if (user || password) {
+        connection += "@";
+    }
+    connection += `${host}/${db}`;
+    return connection;
+};

package/dist/utils/get-config-store.js

@@ -0,0 +1,10 @@
+import Configstore from "configstore";
+let config;
+export const getConfigStore = () => {
+    if (!config) {
+        config = new Configstore(`acmekit`, {}, {
+            globalConfigPath: true,
+        });
+    }
+    return config;
+};

package/dist/utils/get-current-os.js

@@ -0,0 +1,10 @@
+export const getCurrentOs = () => {
+    switch (process.platform) {
+        case "darwin":
+            return "macos";
+        case "linux":
+            return "linux";
+        default:
+            return "windows";
+    }
+};

package/dist/utils/log-message.js

@@ -0,0 +1,21 @@
+import chalk from "chalk";
+import { program } from "commander";
+import { logger } from "./logger.js";
+export default ({ message, type = "info", stack }) => {
+    switch (type) {
+        case "info":
+            logger.info(chalk.white(message));
+            break;
+        case "success":
+            logger.info(chalk.green(message));
+            break;
+        case "warn":
+            logger.warn(chalk.yellow(message));
+            break;
+        case "verbose":
+            logger.info(`${chalk.bgYellowBright("VERBOSE LOG:")} ${message}`);
+            break;
+        case "error":
+            program.error(chalk.bold.red(message.trim() + (stack || "")));
+    }
+};

package/dist/utils/logger.js

@@ -0,0 +1,8 @@
+import winston from "winston";
+const consoleTransport = new winston.transports.Console({
+    format: winston.format.printf((log) => log.message),
+});
+const options = {
+    transports: [consoleTransport],
+};
+export const logger = winston.createLogger(options);

package/dist/utils/nextjs-utils.js

@@ -0,0 +1,85 @@
+import { exec } from "child_process";
+import fs from "fs";
+import inquirer from "inquirer";
+import { customAlphabet } from "nanoid";
+import path from "path";
+import { isAbortError } from "./create-abort-controller.js";
+import execute from "./execute.js";
+import { displayFactBox } from "./facts.js";
+import logMessage from "./log-message.js";
+import { updatePackageVersions } from "./update-package-versions.js";
+const NEXTJS_REPO = "https://github.com/acmekit/nextjs-starter-acmekit";
+const NEXTJS_BRANCH = "main";
+export async function askForNextjsStarter() {
+    const { installNextjs } = await inquirer.prompt([
+        {
+            type: "confirm",
+            name: "installNextjs",
+            message: `Would you like to install the Next.js Starter Storefront? You can also install it later.`,
+            default: false,
+        },
+    ]);
+    return installNextjs;
+}
+export async function installNextjsStarter({ directoryName, abortController, factBoxOptions, verbose = false, packageManager, version, }) {
+    factBoxOptions.interval = displayFactBox({
+        ...factBoxOptions,
+        title: "Installing Next.js Starter Storefront...",
+    });
+    let nextjsDirectory = `${directoryName}-storefront`;
+    if (fs.existsSync(nextjsDirectory) &&
+        fs.lstatSync(nextjsDirectory).isDirectory()) {
+        // append a random number to the directory name
+        nextjsDirectory += `-${customAlphabet(
+        // npm throws an error if the directory name has an uppercase letter
+        "123456789abcdefghijklmnopqrstuvwxyz", 4)()}`;
+    }
+    try {
+        await execute([
+            `git clone ${NEXTJS_REPO} -b ${NEXTJS_BRANCH} ${nextjsDirectory} --depth 1`,
+            {
+                signal: abortController?.signal,
+                env: process.env,
+            },
+        ], { verbose });
+        if (version) {
+            const packageJsonPath = path.join(nextjsDirectory, "package.json");
+            updatePackageVersions(packageJsonPath, version, { applyChanges: true });
+        }
+        const execOptions = {
+            signal: abortController?.signal,
+            cwd: nextjsDirectory,
+        };
+        await packageManager.installDependencies(execOptions);
+    }
+    catch (e) {
+        if (isAbortError(e)) {
+            process.exit();
+        }
+        logMessage({
+            message: `An error occurred while installing Next.js Starter Storefront: ${e}`,
+            type: "error",
+        });
+    }
+    fs.rmSync(path.join(nextjsDirectory, ".git"), {
+        recursive: true,
+        force: true,
+    });
+    fs.renameSync(path.join(nextjsDirectory, ".env.template"), path.join(nextjsDirectory, ".env.local"));
+    displayFactBox({
+        ...factBoxOptions,
+        message: `Installed Next.js Starter Storefront successfully in the ${nextjsDirectory} directory.`,
+    });
+    return nextjsDirectory;
+}
+export function startNextjsStarter({ directory, abortController, verbose = false, packageManager, }) {
+    const command = packageManager.getCommandStr(`dev`);
+    const childProcess = exec(command, {
+        cwd: directory,
+        signal: abortController?.signal,
+    });
+    if (verbose) {
+        childProcess.stdout?.pipe(process.stdout);
+        childProcess.stderr?.pipe(process.stderr);
+    }
+}

package/dist/utils/node-version.js

@@ -0,0 +1,5 @@
+export function getNodeVersion() {
+    const [major] = process.versions.node.split(".").map(Number);
+    return major;
+}
+export const MIN_SUPPORTED_NODE_VERSION = 20;