@swell/cli 2.0.1-alpha.16 → 2.0.1-alpha.18

package/dist/create-app-command.js

@@ -0,0 +1,253 @@
+import { confirm, select } from '@inquirer/prompts';
+import { Flags } from '@oclif/core';
+import { $ } from 'execa';
+import { exec } from 'node:child_process';
+import path from 'node:path';
+import Stream from 'node:stream';
+import { promisify } from 'node:util';
+import ora from 'ora';
+import Api from './lib/api.js';
+import { FrontendProjectTypes, getAllConfigPaths, writeFile, writeJsonFile, } from './lib/apps/index.js';
+import style from './lib/style.js';
+import { SwellCommand } from './swell-command.js';
+const execAsync = promisify(exec);
+export class CreateAppCommand extends SwellCommand {
+    static baseFlags = {
+        frontend: Flags.string({
+            description: `create a starter framework for a hosted frontend`,
+            options: FrontendProjectTypes.map(({ slug }) => slug),
+        }),
+        'storefront-app': Flags.string({
+            description: `id of an installed storefront app to create a theme for, if applicable`,
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: `accept all default values`,
+        }),
+    };
+    devApi;
+    constructor(argv, config) {
+        super(argv, config);
+        this.devApi = new Api(undefined, 'test');
+    }
+    async createAppConfigFolders(swellConfig) {
+        for (const type of getAllConfigPaths(swellConfig.get('type'))) {
+            // Create a config folder
+            // eslint-disable-next-line no-await-in-loop
+            await execAsync(`mkdir -p ${type}`, {
+                cwd: path.dirname(swellConfig.path),
+            });
+        }
+    }
+    async createFrontendApp(swellConfig, flags, directCreate, kind) {
+        const spinner = ora();
+        const configPath = path.dirname(swellConfig.path);
+        const frameworkType = flags.frontend ||
+            (await select({
+                choices: [
+                    ...FrontendProjectTypes.map(({ name, slug }) => ({
+                        name,
+                        value: slug,
+                    })),
+                    ...(directCreate
+                        ? []
+                        : [
+                            {
+                                name: 'Do not install a starter framework',
+                                value: null,
+                            },
+                        ]),
+                ],
+                message: directCreate
+                    ? `Choose a framework for your hosted${kind ? ` ${kind} ` : ' '}app frontend`
+                    : `Install a framework for your hosted${kind ? ` ${kind} ` : ' '}app frontend?`,
+            }));
+        if (frameworkType) {
+            const projectType = FrontendProjectTypes.find((type) => type.slug === frameworkType);
+            if (!projectType) {
+                this.error(`Could not find project type: ${frameworkType}`);
+            }
+            this.log();
+            spinner.start(`Creating ${projectType?.name} frontend app (this may take a while)...`);
+            try {
+                await execAsync(`mkdir -p frontend`, {
+                    cwd: configPath,
+                });
+                await execAsync(projectType.installCommand, {
+                    cwd: configPath,
+                });
+                // Use this command to debug output, i.e.e when command becomes non-responsive
+                /* await this.execWithStdio(
+                  configPath,
+                  projectType.installCommand,
+                ); */
+            }
+            catch (error) {
+                spinner.fail(`Error creating ${projectType?.name} app:\n`);
+                this.log(error.stdout);
+                this.log();
+                return false;
+            }
+            spinner.succeed(`${projectType?.name} initialized app in ${configPath}/frontend/`);
+            if (directCreate) {
+                this.log();
+            }
+            return true;
+        }
+        return false;
+    }
+    async createStorefrontApp(swellConfig, flags, directCreate) {
+        return this.createFrontendApp(swellConfig, flags, directCreate, 'storefront');
+    }
+    async createThemeApp(config, flags, installedStorefrontApp) {
+        const spinner = ora();
+        const configPath = path.dirname(config.path);
+        const defaultThemeConfigs = await this.devApi.get({
+            adminPath: `/client/apps/${installedStorefrontApp.app_id}/theme-template-configs`,
+        });
+        if (defaultThemeConfigs.results?.length > 0) {
+            const { name: appName, version: appVersion } = installedStorefrontApp.app;
+            const shouldCreate = flags.yes ||
+                (await confirm({
+                    message: `Create a theme template for ${style.appConfigValue(appName)} ${appVersion ? `v${appVersion}` : ''}?`,
+                }));
+            if (shouldCreate) {
+                this.log();
+                spinner.start(`Creating theme template...`);
+                try {
+                    await execAsync(`mkdir -p theme`, {
+                        cwd: configPath,
+                    });
+                    for (const themeConfig of defaultThemeConfigs.results) {
+                        const filePath = themeConfig.file_path.replace(/^frontend\/theme-template\//, '');
+                        const fileContent = themeConfig.file_data;
+                        const isJson = filePath.endsWith('.json');
+                        // eslint-disable-next-line no-await-in-loop
+                        await execAsync(`mkdir -p ${path.dirname(filePath)}`, {
+                            cwd: configPath,
+                        });
+                        // eslint-disable-next-line no-await-in-loop
+                        await (isJson
+                            ? writeJsonFile(path.join(configPath, filePath), fileContent)
+                            : writeFile(path.join(configPath, filePath), fileContent));
+                    }
+                }
+                catch (error) {
+                    spinner.fail(`Error creating theme template:\n`);
+                    this.log(error.stdout);
+                    this.log();
+                    return false;
+                }
+                spinner.succeed(`Theme template initialized in ${configPath}/theme/`);
+            }
+        }
+        return true;
+    }
+    async doesPackageManagerExist(packageManager) {
+        try {
+            await execAsync(`${packageManager} --version`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async execWithStdio(cwd, command, onOutput) {
+        const $$ = $({
+            cwd,
+            shell: true,
+            stderr: 'inherit',
+            stdin: 'inherit',
+            stdout: 'pipe',
+        });
+        const outStream = new Stream.Writable();
+        outStream._write = (chunk, _encoding, next) => {
+            const string = chunk.toString();
+            const out = onOutput?.(string);
+            if (out !== false) {
+                console.log(string);
+            }
+            next();
+        };
+        try {
+            await $$ `${command}`.pipeStdout?.(outStream);
+        }
+        catch (error) {
+            console.log(error);
+        }
+    }
+    async findPackageManager(pkg = '') {
+        const packageManager = pkg;
+        // Determine if system has yarn or npm install
+        if (packageManager) {
+            if (await this.doesPackageManagerExist(packageManager)) {
+                return packageManager;
+            }
+        }
+        else {
+            if (await this.doesPackageManagerExist('npm')) {
+                return 'npm';
+            }
+            if (await this.doesPackageManagerExist('yarn')) {
+                return 'yarn';
+            }
+        }
+    }
+    async getInstalledStorefrontApps() {
+        const spinner = ora();
+        spinner.start('Retrieving installed storefront apps...');
+        const installedApps = await this.devApi.get({
+            adminPath: `/client/apps`,
+        });
+        const storefrontInstalledApps = installedApps.results.filter((installedApp) => installedApp.app?.type === 'storefront');
+        if (storefrontInstalledApps.length === 0) {
+            spinner.fail(`You must have at least one storefront app installed in your ${style.appEnv('test')} environment before creating a theme.`);
+            return false;
+        }
+        spinner.stop();
+        return storefrontInstalledApps;
+    }
+    async setupPackage(name, config, pkg) {
+        const execAsync = promisify(exec);
+        const configPath = path.dirname(config.path);
+        const packageJson = {
+            description: config.get('description'),
+            devDependencies: {
+                '@swell/app-types': '^1.0.5',
+            },
+            name,
+            scripts: {},
+            version: config.get('version'),
+        };
+        const tsConfig = {
+            compilerOptions: {
+                lib: ['esnext', 'webworker'],
+                module: 'esnext',
+                target: 'esnext',
+                types: ['@swell/app-types'],
+            },
+            exclude: ['node_modules'],
+            include: ['**/*.ts'],
+        };
+        await writeJsonFile(path.join(configPath, 'package.json'), packageJson);
+        await writeJsonFile(path.join(configPath, 'tsconfig.json'), tsConfig);
+        await writeFile(path.join(configPath, '.gitignore'), `node_modules`);
+        try {
+            const packageManager = await this.findPackageManager(pkg);
+            await execAsync(`${packageManager} install`, {
+                cwd: configPath,
+            });
+        }
+        catch (error) {
+            this.error(error.message);
+        }
+    }
+    async tryPackageSetup(name, config, pkg) {
+        try {
+            await this.setupPackage(name, config, pkg);
+        }
+        catch (error) {
+            this.log(`There was an error setting up the package manager: ${error.message}`);
+        }
+    }
+}

package/dist/create-collection-command.d.ts

@@ -1,12 +1,12 @@
-import { CreateCommand } from './create-command.js';
+import { CreateConfigCommand } from './create-config-command.js';
 /**
  * A base class for Swell CLI Create [content|models] command input.
  *
- * This class extends the `CreateCommand` class and adds:
+ * This class extends the `CreateConfigCommand` class and adds:
  *
  * - promptCollection: Get collection name and description
  */
-export declare abstract class CreateCollectionCommand extends CreateCommand {
+export declare abstract class CreateCollectionCommand extends CreateConfigCommand {
     static args: {
         collection: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
     };

package/dist/create-collection-command.js

@@ -1,15 +1,15 @@
 import { Separator, input, select } from '@inquirer/prompts';
 import { Args, Flags } from '@oclif/core';
-import { CreateCommand } from './create-command.js';
+import { CreateConfigCommand } from './create-config-command.js';
 import { toCollectionLabel, toCollectionName } from './lib/create/index.js';
 /**
  * A base class for Swell CLI Create [content|models] command input.
  *
- * This class extends the `CreateCommand` class and adds:
+ * This class extends the `CreateConfigCommand` class and adds:
  *
  * - promptCollection: Get collection name and description
  */
-export class CreateCollectionCommand extends CreateCommand {
+export class CreateCollectionCommand extends CreateConfigCommand {
     // base flags for all AppCommands
     static args = {
         collection: Args.string({
@@ -20,7 +20,7 @@ export class CreateCollectionCommand extends CreateCommand {
     // needs to be in a ES2021 format: https://github.com/oclif/oclif/issues/1100
     static baseFlags = {
         'app-path': Flags.string({
-            description: 'path to the app directory',
+            description: 'path to your app directory',
         }),
     };
     static flags = {

package/dist/{create-command.d.ts → create-config-command.d.ts}

@@ -9,7 +9,7 @@ import { CreateFileParams } from './lib/create/index.js';
  * - createType: Type of Config to generate file path
  * - createFile: File creation, including general prompts
  */
-export declare abstract class CreateCommand extends AppCommand {
+export declare abstract class CreateConfigCommand extends AppCommand {
     protected createType: '' | ConfigType;
     protected createFile({ extension, fileBody, fileName }: CreateFileParams, overwrite: boolean, shouldConfirm?: boolean): Promise<boolean | undefined>;
     protected getCollectionOptions(): Promise<any>;

package/dist/{create-command.js → create-config-command.js}

@@ -1,7 +1,7 @@
 import { confirm } from '@inquirer/prompts';
 import * as path from 'node:path';
 import { AppCommand } from './app-command.js';
-import { ConfigPaths, fileExists, writeFile, writeJsonFile, } from './lib/apps/index.js';
+import { ConfigPaths, filePathExists, writeFile, writeJsonFile, } from './lib/apps/index.js';
 /**
  * A base class for Swell CLI Create commands for file and input handling.
  *
@@ -10,7 +10,7 @@ import { ConfigPaths, fileExists, writeFile, writeJsonFile, } from './lib/apps/i
  * - createType: Type of Config to generate file path
  * - createFile: File creation, including general prompts
  */
-export class CreateCommand extends AppCommand {
+export class CreateConfigCommand extends AppCommand {
     createType = '';
     async createFile({ extension = 'json', fileBody, fileName }, overwrite, shouldConfirm = true) {
         const isJson = extension === 'json';
@@ -18,7 +18,7 @@ export class CreateCommand extends AppCommand {
         if (shouldConfirm) {
             this.log(`\nCreating app ${this.createType} in ${filePath}`);
             this.log(`\n${isJson ? JSON.stringify(fileBody, null, 4) : fileBody}\n`);
-            if (fileExists(filePath) && !overwrite) {
+            if (filePathExists(filePath) && !overwrite) {
                 const continueWrite = await confirm({
                     message: `This will overwrite an existing ${this.createType} file. Ok to continue?`,
                 });
@@ -45,9 +45,7 @@ export class CreateCommand extends AppCommand {
         const models = await this.api.post({ adminPath: `/data/$get/:models` }, {
             body: {
                 abstract: { $ne: true },
-                // eslint-disable-next-line camelcase
                 app_id: null,
-                // eslint-disable-next-line camelcase
                 client_id: null,
                 deprecated: { $ne: true },
                 fields: 'name, namespace',

package/dist/env/local.d.ts

@@ -0,0 +1,8 @@
+declare namespace _default {
+    let API_BASE_URL: string;
+    let ADMIN_API_BASE_URL: string;
+    let LOGIN_HOST: string;
+    let APP_PAGES_HOST: string;
+    let STOREFRONT_FRONTEND_HOST: string;
+}
+export default _default;

package/dist/env/local.js

@@ -0,0 +1,7 @@
+export default {
+    API_BASE_URL: 'https://localapi.schema.io:4443',
+    ADMIN_API_BASE_URL: 'http://${STORE_ID}.swell.test:4001/admin/api',
+    LOGIN_HOST: 'http://${STORE_ID}.swell.test:3000',
+    APP_PAGES_HOST: 'http://${STORE_ID}--${APP_ID}--${ENV}.swell.test:4001',
+    STOREFRONT_FRONTEND_HOST: 'http://${BRANCH_PREFIX}${STOREFRONT_SLUG}.swell.test:4001',
+};

package/dist/env/production.d.ts

@@ -0,0 +1,8 @@
+declare namespace _default {
+    let API_BASE_URL: string;
+    let ADMIN_API_BASE_URL: string;
+    let LOGIN_HOST: string;
+    let APP_PAGES_HOST: string;
+    let STOREFRONT_FRONTEND_HOST: string;
+}
+export default _default;

package/dist/env/production.js

@@ -0,0 +1,7 @@
+export default {
+    API_BASE_URL: 'https://api.swell.store',
+    ADMIN_API_BASE_URL: 'https://${STORE_ID}.swell.store/admin/api',
+    LOGIN_HOST: 'https://${STORE_ID}.swell.store',
+    APP_PAGES_HOST: 'https://${STORE_ID}--${APP_ID}--${ENV}.swell.store',
+    STOREFRONT_FRONTEND_HOST: 'https://${BRANCH_PREFIX}${STOREFRONT_SLUG}.swell.store',
+};

package/dist/env/review.d.ts

@@ -0,0 +1,8 @@
+declare namespace _default {
+    let API_BASE_URL: string;
+    let ADMIN_API_BASE_URL: string;
+    let LOGIN_HOST: string;
+    let APP_PAGES_HOST: string;
+    let STOREFRONT_FRONTEND_HOST: string;
+}
+export default _default;

package/dist/env/review.js

@@ -0,0 +1,7 @@
+export default {
+    API_BASE_URL: 'https://${REVIEW_DOMAIN}.rav2.swell.store',
+    ADMIN_API_BASE_URL: 'https://${STORE_ID}.${REVIEW_DOMAIN}.rav2.swell.store/admin/api',
+    LOGIN_HOST: 'https://${REVIEW_DOMAIN}.rav2.swell.store',
+    APP_PAGES_HOST: 'https://${STORE_ID}--${APP_ID}--${ENV}.${REVIEW_DOMAIN}.rav2.swell.store',
+    STOREFRONT_FRONTEND_HOST: 'https://${BRANCH_PREFIX}${STOREFRONT_SLUG}.${REVIEW_DOMAIN}.rav2.swell.store',
+};

package/dist/env/staging.d.ts

@@ -0,0 +1,8 @@
+declare namespace _default {
+    let API_BASE_URL: string;
+    let ADMIN_API_BASE_URL: string;
+    let LOGIN_HOST: string;
+    let APP_PAGES_HOST: string;
+    let STOREFRONT_FRONTEND_HOST: string;
+}
+export default _default;

package/dist/env/staging.js

@@ -0,0 +1,7 @@
+export default {
+    API_BASE_URL: 'https://staging.swell.store',
+    ADMIN_API_BASE_URL: 'https://${STORE_ID}.staging.swell.store/admin/api',
+    LOGIN_HOST: 'https://staging.swell.store',
+    APP_PAGES_HOST: 'https://${STORE_ID}--${APP_ID}--${ENV}.staging.swell.store',
+    STOREFRONT_FRONTEND_HOST: 'https://${BRANCH_PREFIX}${STOREFRONT_SLUG}.staging.swell.store',
+};

package/dist/lib/api.d.ts

@@ -11,4 +11,5 @@ export default class Api {
     put(pathOpts: Api.Paths, options?: Api.RequestOptions): Promise<any>;
     setStoreEnv(storeId: string, envId?: string): void;
     truncatePath(path: string | undefined): string | undefined;
+    waitForAsyncResponse(response: any, pathOpts: Api.Paths, options?: Api.RequestOptions): Promise<any>;
 }

package/dist/lib/api.js

@@ -1,4 +1,5 @@
 import fetch from 'node-fetch';
+import { stringify } from 'qs';
 import config from './config.js';
 import { API_BASE_URL, getAdminApiBaseUrl } from './constants.js';
 const defaultHeaders = (opts) => ({
@@ -50,35 +51,35 @@ export default class Api {
             ? `${getAdminApiBaseUrl(storeId)}/${this.truncatePath(pathOpts.adminPath)}`
             : `${API_BASE_URL}/${this.truncatePath(pathOpts.backendPath)}`;
         if (options.query) {
-            const query = new URLSearchParams(options.query);
-            path += `?${query.toString()}`;
+            path += `?${stringify(options.query)}`;
         }
         path = path
-            // eslint-disable-next-line no-template-curly-in-string
             .replace('${STORE_ID}', storeId) // replace store id in template string
             .replaceAll(/([^:]\/)\/+/g, '$1'); // remove duplicate slashes
         if (!path)
             throw new Error('Operation not supported.');
-        const resp = await fetch(path, fetchOptions);
-        const respData = await resp.text();
-        if (!resp.ok) {
+        const res = await fetch(path, fetchOptions);
+        const resData = await res.text();
+        if (!res.ok) {
             // Try to parse error message
             let errorJson;
             try {
-                errorJson = JSON.parse(respData);
+                errorJson = JSON.parse(resData);
             }
             catch {
                 // ignore
             }
-            throw new Error(errorJson?.error?.message || errorJson?.error || respData);
+            const error = new Error(errorJson?.error?.message || errorJson?.error || resData);
+            error.status = res.status;
+            throw error;
         }
         try {
-            return JSON.parse(respData);
+            return JSON.parse(resData);
         }
         catch (error) {
             // respData could be "{}" (length: >=2) but it shouldn't be "{", " " (whitespace - length: 1) or
             // "" (empty response - length: 0) while logging the error.
-            if (respData.length >= 2)
+            if (resData.length >= 2)
                 console.log(error);
             return null;
         }
@@ -87,10 +88,11 @@ export default class Api {
         // ensure post body is stringified
         if (options.body)
             options.body = JSON.stringify(options.body);
-        return this.api(pathOpts, {
+        const response = await this.api(pathOpts, {
             method: 'DELETE',
             ...options,
         });
+        return this.waitForAsyncResponse(response, pathOpts, options);
     }
     async get(pathOpts, options = {}) {
         return this.api(pathOpts, {
@@ -105,19 +107,21 @@ export default class Api {
         // ensure post body is stringified
         if (options.body)
             options.body = JSON.stringify(options.body);
-        return this.api(pathOpts, {
+        const response = await this.api(pathOpts, {
             method: 'POST',
             ...options,
         });
+        return this.waitForAsyncResponse(response, pathOpts, options);
     }
     async put(pathOpts, options = {}) {
         // ensure post body is stringified
         if (options.body)
             options.body = JSON.stringify(options.body);
-        return this.api(pathOpts, {
+        const response = await this.api(pathOpts, {
             method: 'PUT',
             ...options,
         });
+        return this.waitForAsyncResponse(response, pathOpts, options);
     }
     setStoreEnv(storeId, envId) {
         this.storeId = storeId;
@@ -126,4 +130,26 @@ export default class Api {
     truncatePath(path) {
         return path?.startsWith('/') ? path.slice(1) : path;
     }
+    async waitForAsyncResponse(response, pathOpts, options = {}) {
+        const { onAsyncGetPath, spinner } = options;
+        if (!response?.async_progressing || !onAsyncGetPath) {
+            return response;
+        }
+        /* eslint-disable-next-line no-promise-executor-return */
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        const asyncResponse = await this.api(onAsyncGetPath(response), {
+            method: 'GET',
+            onAsyncGetPath,
+        });
+        if (asyncResponse?.async_error) {
+            throw new Error(asyncResponse.async_error);
+        }
+        if (!asyncResponse?.async_progressing && spinner) {
+            spinner.suffixText = '';
+        }
+        else if (asyncResponse?.async_progress > 0 && spinner) {
+            spinner.suffixText = `${asyncResponse.async_progress}%`;
+        }
+        return this.waitForAsyncResponse(asyncResponse, pathOpts, options);
+    }
 }

package/dist/lib/app-config.d.ts

@@ -1,25 +1,25 @@
 import { App } from './apps';
 /**
- * Checks if the app config file exists.
+ * Checks if the swell config file exists at the given path, default to cwd.
  *
  * @param configFilePath - the path to the app config file
  * @returns boolean
  * @throws Error
  */
-declare function appConfigFileExists(configFilePath?: string): boolean;
+declare function swellConfigFileExists(configFilePath?: string): boolean;
 declare function writeRcFile(path: string, data: any): Promise<void>;
 declare function readRcFile(path: string): App;
 /**
  * Returns a new configuration instance in the current working directory or
  * a parent directory.
  *
- * @param configDirPath - the path to the app config directory. If not provided,
+ * @param configDir - the path to the app config directory. If not provided,
  * the config file will be searched for in the current working directory or
  * a parent directory.
  *
  * @returns Conf
  */
-declare function config(configDirPath?: string): LocalApp;
+declare function config(configDir?: string): LocalApp;
 /**
  * Returns a new configuration instance in the current working directory only.
  *
@@ -27,4 +27,11 @@ declare function config(configDirPath?: string): LocalApp;
  * @returns Conf
  */
 declare function newConfig(path?: string): any;
-export { appConfigFileExists, config as default, newConfig, readRcFile, writeRcFile, };
+/**
+ * Returns a new configuration instance at the specified path.
+ *
+ * @param appPath Path of the current working directory
+ * @returns Conf
+ */
+declare function newConfigAtPath(appPath?: string): any;
+export { config as default, newConfig, newConfigAtPath, readRcFile, swellConfigFileExists, writeRcFile, };