@swell/cli 2.0.1-alpha.13 → 2.0.1-alpha.17

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

@@ -1,26 +1,26 @@
-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 {
-    static baseFlags: {
-        'app-path': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-    };
+export declare abstract class CreateCollectionCommand extends CreateConfigCommand {
     static args: {
         collection: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
     };
+    static baseFlags: {
+        'app-path': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
     static flags: {
-        label: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         description: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        label: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         overwrite: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
     };
     promptCollection(): Promise<{
-        label: string;
-        description: string;
         collection: string;
+        description: string;
+        label: string;
     }>;
 }

package/dist/create-collection-command.js

@@ -1,39 +1,39 @@
-import { input, select, Separator } from '@inquirer/prompts';
+import { Separator, input, select } from '@inquirer/prompts';
 import { Args, Flags } from '@oclif/core';
-import { CreateCommand } from './create-command.js';
-import { toCollectionName, toCollectionLabel } from './lib/create/index.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
-    // 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',
-        }),
-    };
     static args = {
         collection: Args.string({
             default: '',
             description: 'collection to create or apply to, i.e. products',
         }),
     };
-    static flags = {
-        label: Flags.string({
-            char: 'l',
-            default: '',
-            description: 'the collection label',
+    // needs to be in a ES2021 format: https://github.com/oclif/oclif/issues/1100
+    static baseFlags = {
+        'app-path': Flags.string({
+            description: 'path to your app directory',
         }),
+    };
+    static flags = {
         description: Flags.string({
             char: 'd',
             default: '',
             description: 'the collection description',
         }),
+        label: Flags.string({
+            char: 'l',
+            default: '',
+            description: 'the collection label',
+        }),
         overwrite: Flags.boolean({
             char: 'o',
             default: false,
@@ -42,14 +42,13 @@ export class CreateCollectionCommand extends CreateCommand {
     };
     async promptCollection() {
         const { args, flags } = await this.parse(CreateCollectionCommand);
-        let { label, description } = flags;
+        let { description, label } = flags;
         let { collection } = args;
         let isStandardCollection = false;
         let collectionInput = collection;
         if (!collection) {
             const collections = await this.getCollectionOptions();
             collectionInput = await select({
-                message: 'Where will content be stored?',
                 choices: [
                     { name: 'Create a new collection', value: '' },
                     new Separator(),
@@ -58,6 +57,7 @@ export class CreateCollectionCommand extends CreateCommand {
                         value: collectionName,
                     })),
                 ],
+                message: 'Where will content be stored?',
                 pageSize: 25,
             });
             if (collectionInput) {
@@ -65,8 +65,8 @@ export class CreateCollectionCommand extends CreateCommand {
             }
             else {
                 collectionInput = await input({
-                    message: 'Collection name',
                     default: 'special-things',
+                    message: 'Collection name',
                 });
             }
             // we replace unwanted characters with underscores to make things easier
@@ -75,23 +75,23 @@ export class CreateCollectionCommand extends CreateCommand {
         }
         if (!label && !isStandardCollection) {
             label = await input({
-                message: 'Collection label',
                 default: toCollectionLabel(collection),
+                message: 'Collection label',
             });
             label = toCollectionLabel(label);
         }
         description =
             description ||
                 (await input({
+                    default: 'Special things for special people',
                     message: isStandardCollection
                         ? `Describe the purpose of fields being added to ${collection}`
                         : 'Describe what this collection is for',
-                    default: 'Special things for special people',
                 }));
         return {
-            label,
-            description,
             collection,
+            description,
+            label,
         };
     }
 }

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?`,
                 });
@@ -44,14 +44,16 @@ export class CreateCommand extends AppCommand {
     async getCollectionOptions() {
         const models = await this.api.post({ adminPath: `/data/$get/:models` }, {
             body: {
-                limit: 1000,
-                client_id: null,
-                app_id: null,
                 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',
+                limit: 1000,
                 name: { $nin: ['events', 'notifications', 'settings'] },
                 sort: 'namespace asc, name asc',
-                fields: 'name, namespace',
             },
         });
         return (models?.results?.map((model) => model.namespace ? `${model.namespace}/${model.name}` : model.name) || []);

package/dist/lib/api.d.ts

@@ -1,13 +1,15 @@
 export default class Api {
+    private envId;
     private secretKey;
     private storeId;
-    private envId;
     constructor(storeId?: string, envId?: string, secretKey?: string);
-    setStoreEnv(storeId: string, envId?: string): void;
     api(pathOpts: Api.Paths, options: Api.RequestOptions): Promise<any>;
-    delete(pathOpts: Api.Paths, options?: Api.RequestOptions): Promise<any>;
-    get(pathOpts: Api.Paths, options?: Api.RequestOptions): Promise<any>;
     isAdmin(): boolean;
+    waitForAsyncResponse(response: any, pathOpts: Api.Paths, options?: Api.RequestOptions): Promise<any>;
+    get(pathOpts: Api.Paths, options?: Api.RequestOptions): Promise<any>;
     post(pathOpts: Api.Paths, options?: Api.RequestOptions): Promise<any>;
     put(pathOpts: Api.Paths, options?: Api.RequestOptions): Promise<any>;
+    delete(pathOpts: Api.Paths, options?: Api.RequestOptions): Promise<any>;
+    setStoreEnv(storeId: string, envId?: string): void;
+    truncatePath(path: string | undefined): string | undefined;
 }

package/dist/lib/api.js

@@ -1,6 +1,7 @@
 import fetch from 'node-fetch';
+import qs from 'qs';
 import config from './config.js';
-import { getAdminApiBaseUrl, API_BASE_URL } from './constants.js';
+import { API_BASE_URL, getAdminApiBaseUrl } from './constants.js';
 const defaultHeaders = (opts) => ({
     'Content-Type': 'application/json',
     ...opts,
@@ -23,18 +24,14 @@ const authenticatedHeaders = (storeId, opts = {}) => {
     return defaultHeaders(moreOpts);
 };
 export default class Api {
+    envId;
     secretKey;
     storeId;
-    envId;
     constructor(storeId, envId, secretKey) {
         this.storeId = storeId;
         this.envId = envId;
         this.secretKey = secretKey;
     }
-    setStoreEnv(storeId, envId) {
-        this.storeId = storeId;
-        this.envId = envId;
-    }
     async api(pathOpts, options) {
         const storeId = this.storeId || config.getDefaultStore();
         let path;
@@ -51,11 +48,10 @@ export default class Api {
             },
         };
         path = this.isAdmin()
-            ? `${getAdminApiBaseUrl(storeId)}/${pathOpts.adminPath}`
-            : `${API_BASE_URL}/${pathOpts.backendPath}`;
+            ? `${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 += `?${qs.stringify(options.query)}`;
         }
         path = path
             // eslint-disable-next-line no-template-curly-in-string
@@ -63,38 +59,55 @@ export default class Api {
             .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;
         }
     }
-    async delete(pathOpts, options = {}) {
-        // ensure post body is stringified
-        if (options.body)
-            options.body = JSON.stringify(options.body);
-        return this.api(pathOpts, {
-            method: 'DELETE',
-            ...options,
+    isAdmin() {
+        return !this.secretKey;
+    }
+    async waitForAsyncResponse(response, pathOpts, options = {}) {
+        const { onAsyncGetPath, spinner } = options;
+        if (!response?.async_progressing || !onAsyncGetPath) {
+            return response;
+        }
+        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);
     }
     async get(pathOpts, options = {}) {
         return this.api(pathOpts, {
@@ -102,25 +115,41 @@ export default class Api {
             ...options,
         });
     }
-    isAdmin() {
-        return !this.secretKey;
-    }
     async post(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: '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);
+    }
+    async delete(pathOpts, options = {}) {
+        // ensure post body is stringified
+        if (options.body)
+            options.body = JSON.stringify(options.body);
+        const response = await this.api(pathOpts, {
+            method: 'DELETE',
+            ...options,
+        });
+        return this.waitForAsyncResponse(response, pathOpts, options);
+    }
+    setStoreEnv(storeId, envId) {
+        this.storeId = storeId;
+        this.envId = envId;
+    }
+    truncatePath(path) {
+        return path?.startsWith('/') ? path.slice(1) : path;
     }
 }

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

@@ -1,29 +1,37 @@
 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.
  *
+ * @param path Path of the current working directory
  * @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 path Path of the current working directory
+ * @returns Conf
+ */
+declare function newConfigAtPath(appPath?: string): any;
+export { swellConfigFileExists, config as default, newConfig, newConfigAtPath, readRcFile, writeRcFile, };

package/dist/lib/app-config.js

@@ -6,10 +6,13 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 const schema = {
     id: { type: 'string' },
-    version: { type: 'string' },
     name: { type: 'string' },
-    description: { type: 'string' },
     type: { type: 'string' },
+    version: { type: 'string' },
+    description: { type: 'string' },
+    storefront: { type: 'object' },
+    theme: { type: 'object' },
+    compatibilities: { type: 'object' },
     permissions: { type: 'array' },
 };
 const APP_FILE_NAME = 'swell';
@@ -21,23 +24,23 @@ const APP_FILE_EXT = 'json';
  * @param dir - the directory to use for the config file path
  * @returns string
  */
-function appConfigFile(dir = '') {
+function swellConfigFile(dir = '') {
     if (!dir) {
         dir = process.cwd();
     }
     return path.join(dir, [APP_FILE_NAME, '.', APP_FILE_EXT].join(''));
 }
 /**
- * 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
  */
-function appConfigFileExists(configFilePath = '') {
+function swellConfigFileExists(configFilePath = '') {
     // if the config file path is not provided, try to find it as the default
     if (!configFilePath) {
-        configFilePath = appConfigFile();
+        configFilePath = swellConfigFile();
     }
     try {
         // eslint-disable-next-line no-bitwise
@@ -59,9 +62,9 @@ function appConfigFileExists(configFilePath = '') {
  * @returns string
  * @throws Error
  */
-function appConfigFilePath(dir = '') {
-    const configFilePath = appConfigFile(dir);
-    if (appConfigFileExists(configFilePath)) {
+function swellConfigFilePath(dir = '') {
+    const configFilePath = swellConfigFile(dir);
+    if (swellConfigFileExists(configFilePath)) {
         return configFilePath;
     }
     // if the file doesn't exist, try to find it in the parent directory
@@ -69,10 +72,10 @@ function appConfigFilePath(dir = '') {
     if (dir && dir === path.parse(dir).root) {
         return '';
     }
-    return appConfigFilePath(path.resolve(dir, '..'));
+    return swellConfigFilePath(path.resolve(dir, '..'));
 }
 async function writeRcFile(path, data) {
-    let dataToWrite = '';
+    let dataToWrite = '# This file is automatically generated by the Swell CLI\n';
     for (const [key, value] of Object.entries(data)) {
         dataToWrite += `${key}=${value}\n`;
     }
@@ -83,9 +86,15 @@ function readRcFile(path) {
     const dataFromFile = fs.readFileSync(path, 'utf8');
     const lines = dataFromFile.split('\n');
     for (const line of lines) {
-        const [key, value] = line.split('=');
-        if (key && value) {
-            data[key] = value;
+        const cleanLine = line.trim();
+        if (cleanLine.startsWith('#')) {
+            // Ignore comments
+            continue;
+        }
+        const [key, value] = cleanLine.trim().split('=');
+        const cleanValue = value && value.trim();
+        if (key && cleanValue) {
+            data[key] = cleanValue;
         }
     }
     return data;
@@ -94,19 +103,26 @@ function readRcFile(path) {
  * 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
  */
-function config(configDirPath = '') {
-    const dirPath = configDirPath || path.dirname(appConfigFilePath());
-    const config = new Conf({
-        configName: APP_FILE_NAME,
-        cwd: dirPath,
-        schema,
-    });
+function config(configDir = '') {
+    const dirPath = configDir || path.dirname(swellConfigFilePath());
+    let config;
+    try {
+        config = new Conf({
+            configName: APP_FILE_NAME,
+            cwd: dirPath,
+            schema,
+            clearInvalidConfig: true,
+        });
+    }
+    catch (err) {
+        throw new Error(`Error parsing swell.json: ${err.toString()}`);
+    }
     // for convenience, we add custom properties to the Conf object
     // we prefix them with "sw" to avoid conflicts with Conf's properties
     config.swDirPath = dirPath;
@@ -115,6 +131,7 @@ function config(configDirPath = '') {
 /**
  * Returns a new configuration instance in the current working directory only.
  *
+ * @param path Path of the current working directory
  * @returns Conf
  */
 function newConfig(path) {
@@ -122,6 +139,26 @@ function newConfig(path) {
         configName: APP_FILE_NAME,
         cwd: `${process.cwd()}${path ? `/${path}` : ''}`,
         schema,
+        serialize,
+        clearInvalidConfig: true,
     });
 }
-export { appConfigFileExists, config as default, newConfig, readRcFile, writeRcFile, };
+/**
+ * Returns a new configuration instance at the specified path.
+ *
+ * @param path Path of the current working directory
+ * @returns Conf
+ */
+function newConfigAtPath(appPath) {
+    const dirPath = appPath || path.dirname(swellConfigFilePath());
+    return new Conf({
+        configName: APP_FILE_NAME,
+        cwd: dirPath,
+        schema,
+        serialize,
+    });
+}
+function serialize(value) {
+    return JSON.stringify(value, null, 2);
+}
+export { swellConfigFileExists, config as default, newConfig, newConfigAtPath, readRcFile, writeRcFile, };

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

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { ConfigType } from './index.js';
 declare class IgnoringFileError extends Error {
     constructor(message: string);
@@ -14,29 +15,42 @@ type AppConfigFile = {
     length?: number;
     md5?: string;
     url?: string;
+    content_type?: string;
 };
 /**
  * An app configuration as defined by the Swell API. This implies that the
  * app & the configuration are saved to the API.
  */
 declare abstract class AppConfig {
-    date_created?: string;
-    file?: AppConfigFile;
-    fileData?: string;
     id?: string;
-    /** The local path of a remote AppConfig */
-    localPath?: string;
+    version?: string;
+    hash?: string;
+    fileHash?: string;
+    file?: AppConfigFile;
+    file_path?: string;
     name?: string;
     parent_id?: string;
     slug?: string;
     values: {
         [key: string]: any;
     };
-    constructor(attrs?: Partial<AppConfig>);
-    static create(attrs?: Partial<AppConfig>): AppConfig;
-    postData(): Promise<any>;
+    date_created?: string;
+    date_updated?: string;
+    appConfigId?: string;
+    filePath: string;
+    appPath: string;
+    fileData?: Buffer;
+    fileContent?: string;
+    byteSize?: number;
+    mbSize?: number;
     /** build the JSON used when making requests (usually push) to the API */
     protected abstract preparePostData(postData: any): Promise<any>;
     abstract type: ConfigType;
+    abstract hasValues: boolean;
+    constructor(attrs?: Partial<AppConfig>);
+    static create(attrs?: Partial<AppConfig>): AppConfig;
+    postData(): Promise<any>;
+    prepareFileData(): any;
+    isRootConfig(configDir: string): boolean;
 }
 export { AppConfig, FunctionProcessingError, IgnoringFileError };