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

package/dist/lib/api.js

@@ -1,5 +1,5 @@
 import fetch from 'node-fetch';
-import qs from 'qs';
+import { stringify } from 'qs';
 import config from './config.js';
 import { API_BASE_URL, getAdminApiBaseUrl } from './constants.js';
 const defaultHeaders = (opts) => ({
@@ -51,10 +51,9 @@ export default class Api {
             ? `${getAdminApiBaseUrl(storeId)}/${this.truncatePath(pathOpts.adminPath)}`
             : `${API_BASE_URL}/${this.truncatePath(pathOpts.backendPath)}`;
         if (options.query) {
-            path += `?${qs.stringify(options.query)}`;
+            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)
@@ -85,29 +84,15 @@ export default class Api {
             return null;
         }
     }
-    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,
+    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,
         });
-        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);
+        return this.waitForAsyncResponse(response, pathOpts, options);
     }
     async get(pathOpts, options = {}) {
         return this.api(pathOpts, {
@@ -115,6 +100,9 @@ export default class Api {
             ...options,
         });
     }
+    isAdmin() {
+        return !this.secretKey;
+    }
     async post(pathOpts, options = {}) {
         // ensure post body is stringified
         if (options.body)
@@ -135,16 +123,6 @@ export default class Api {
         });
         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;
@@ -152,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

@@ -30,8 +30,8 @@ declare function newConfig(path?: string): any;
 /**
  * Returns a new configuration instance at the specified path.
  *
- * @param path Path of the current working directory
+ * @param appPath Path of the current working directory
  * @returns Conf
  */
 declare function newConfigAtPath(appPath?: string): any;
-export { swellConfigFileExists, config as default, newConfig, newConfigAtPath, readRcFile, writeRcFile, };
+export { config as default, newConfig, newConfigAtPath, readRcFile, swellConfigFileExists, writeRcFile, };

package/dist/lib/app-config.js

@@ -5,15 +5,16 @@ import Conf from 'conf';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 const schema = {
+    compatibilities: { type: 'object' },
+    description: { type: 'string' },
     id: { type: 'string' },
+    integrations: { type: 'array' },
     name: { type: 'string' },
-    type: { type: 'string' },
-    version: { type: 'string' },
-    description: { type: 'string' },
+    permissions: { type: 'array' },
     storefront: { type: 'object' },
     theme: { type: 'object' },
-    compatibilities: { type: 'object' },
-    permissions: { type: 'array' },
+    type: { type: 'string' },
+    version: { type: 'string' },
 };
 const APP_FILE_NAME = 'swell';
 const APP_FILE_EXT = 'json';
@@ -114,14 +115,14 @@ function config(configDir = '') {
     let config;
     try {
         config = new Conf({
+            clearInvalidConfig: true,
             configName: APP_FILE_NAME,
             cwd: dirPath,
             schema,
-            clearInvalidConfig: true,
         });
     }
-    catch (err) {
-        throw new Error(`Error parsing swell.json: ${err.toString()}`);
+    catch (error) {
+        throw new Error(`Error parsing swell.json: ${error.toString()}`);
     }
     // for convenience, we add custom properties to the Conf object
     // we prefix them with "sw" to avoid conflicts with Conf's properties
@@ -136,17 +137,17 @@ function config(configDir = '') {
  */
 function newConfig(path) {
     return new Conf({
+        clearInvalidConfig: true,
         configName: APP_FILE_NAME,
         cwd: `${process.cwd()}${path ? `/${path}` : ''}`,
         schema,
         serialize,
-        clearInvalidConfig: true,
     });
 }
 /**
  * Returns a new configuration instance at the specified path.
  *
- * @param path Path of the current working directory
+ * @param appPath Path of the current working directory
  * @returns Conf
  */
 function newConfigAtPath(appPath) {
@@ -161,4 +162,4 @@ function newConfigAtPath(appPath) {
 function serialize(value) {
     return JSON.stringify(value, null, 2);
 }
-export { swellConfigFileExists, config as default, newConfig, newConfigAtPath, readRcFile, writeRcFile, };
+export { config as default, newConfig, newConfigAtPath, readRcFile, swellConfigFileExists, writeRcFile, };

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

@@ -8,6 +8,7 @@ declare class FunctionProcessingError extends Error {
     constructor(message: string, error: Error);
 }
 type AppConfigFile = {
+    content_type?: string;
     data?: string;
     date_uploaded?: string;
     ext?: string;
@@ -15,42 +16,41 @@ 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 {
-    id?: string;
-    version?: string;
-    hash?: string;
-    fileHash?: string;
+    appConfigId?: string;
+    appPath: string;
+    byteSize?: number;
+    date_created?: string;
+    date_updated?: string;
     file?: AppConfigFile;
     file_path?: string;
+    fileContent?: string;
+    fileData?: Buffer;
+    fileHash?: string;
+    filePath: string;
+    hash?: string;
+    id?: string;
+    mbSize?: number;
     name?: string;
     parent_id?: string;
     slug?: string;
     values: {
         [key: string]: 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;
+    version?: string;
     constructor(attrs?: Partial<AppConfig>);
     static create(attrs?: Partial<AppConfig>): AppConfig;
+    isRootConfig(configDir: string): boolean;
     postData(): Promise<any>;
     prepareFileData(): any;
-    isRootConfig(configDir: string): boolean;
+    abstract hasValues: boolean;
+    /** build the JSON used when making requests (usually push) to the API */
+    protected abstract preparePostData(postData: any): Promise<any>;
+    abstract type: ConfigType;
 }
 export { AppConfig, FunctionProcessingError, IgnoringFileError };

package/dist/lib/apps/app-config.js

@@ -1,11 +1,10 @@
-/* eslint-disable camelcase */
+import { getEncoding } from 'istextorbinary';
 import isEmpty from 'lodash/isEmpty.js';
+import { detectFilenameMime } from 'mime-detect';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { detectFilenameMime } from 'mime-detect';
-import { getEncoding } from 'istextorbinary';
 import { bundleFunction } from '../bundle.js';
-import { ConfigType, ConfigPaths, hashFile, filePathExists } from './index.js';
+import { ConfigPaths, ConfigType, filePathExists, hashFile } from './index.js';
 class IgnoringFileError extends Error {
     constructor(message) {
         super(message);
@@ -25,38 +24,38 @@ class FunctionProcessingError extends Error {
  * app & the configuration are saved to the API.
  */
 class AppConfig {
-    // Server-side props
-    id;
-    version;
-    hash;
-    fileHash;
-    file;
-    file_path;
-    name;
-    parent_id;
-    slug;
-    values = {};
-    date_created;
-    date_updated;
     // Used when pushing a theme and the app config is considered
     appConfigId;
-    // Relative path of remote AppConfig, same as file_path if defined
-    filePath;
     // Full local path of remote AppConfig
     appPath;
-    // Buffer of local file data
-    fileData;
-    // UTF8 content of local file
-    fileContent;
     // Size of local file in bytes and mb
     byteSize;
+    date_created;
+    date_updated;
+    file;
+    file_path;
+    // UTF8 content of local file
+    fileContent;
+    // Buffer of local file data
+    fileData;
+    fileHash;
+    // Relative path of remote AppConfig, same as file_path if defined
+    filePath;
+    hash;
+    // Server-side props
+    id;
     mbSize;
+    name;
+    parent_id;
+    slug;
+    values = {};
+    version;
     constructor(attrs = {}) {
         Object.assign(this, attrs);
-        let { filePath, appPath } = attrs;
-        this.filePath = filePath || '';
+        let { appPath, file_path, filePath, name, type } = attrs;
         this.appPath = appPath || '';
-        if (!attrs.type || !attrs.name) {
+        this.filePath = filePath || '';
+        if (!type || !name) {
             throw new Error('Missing app config type or name.');
         }
         if (!appPath) {
@@ -64,15 +63,15 @@ class AppConfig {
         }
         // Make sure file path is set from server prop or type/name
         if (!filePath) {
-            if (attrs.file_path) {
-                filePath = attrs.file_path;
+            if (file_path) {
+                filePath = file_path;
             }
             else {
                 // Note this shouldn't be necessary unless the config was created before file_path was added
-                const typePath = ConfigPaths[String(attrs.type).toUpperCase()];
-                filePath = `${typePath}/${attrs.name}`;
+                const typePath = ConfigPaths[String(type).toUpperCase()];
+                filePath = `${typePath}/${name}`;
                 if (!typePath) {
-                    throw new Error(`Missing path for app config type: ${attrs.type}`);
+                    throw new Error(`Missing path for app config type: ${type}`);
                 }
             }
             this.filePath = filePath;
@@ -126,6 +125,11 @@ class AppConfig {
             }
         }
     }
+    isRootConfig(configDir) {
+        return !this.filePath
+            ?.replace(new RegExp(`^${configDir}/`), '')
+            .includes('/');
+    }
     async postData() {
         if (this.fileContent === undefined) {
             return;
@@ -142,24 +146,19 @@ class AppConfig {
             }
         }
         // Detect file content type
-        let contentType = detectFilenameMime(this.filePath);
-        if (this.filePath.endsWith('.liquid') ||
-            this.filePath.endsWith('.liquidx')) {
-            contentType = 'application/liquid';
-        }
-        else {
-            contentType = detectFilenameMime(this.filePath);
-        }
+        const contentType = this.filePath.endsWith('.liquid') || this.filePath.endsWith('.liquidx')
+            ? 'application/liquid'
+            : detectFilenameMime(this.filePath);
         const postData = {
-            // Name is either configured or the last part of the path without extension
-            name: this.values?.name || this.name,
-            type: this.type,
-            hash: this.hash,
-            file_path: this.filePath,
             file: {
-                data: this.prepareFileData(),
                 content_type: contentType,
+                data: this.prepareFileData(),
             },
+            file_path: this.filePath,
+            hash: this.hash,
+            // Name is either configured or the last part of the path without extension
+            name: this.values?.name || this.name,
+            type: this.type,
         };
         if (this.hasValues) {
             postData.values = this.values || {};
@@ -174,22 +173,17 @@ class AppConfig {
             ? { $base64: this.fileData.toString('base64') }
             : this.fileData?.toString('utf8');
     }
-    isRootConfig(configDir) {
-        return !this.filePath
-            ?.replace(new RegExp(`^${configDir}/`), '')
-            .includes('/');
-    }
 }
 class AppConfigDefault extends AppConfig {
-    type = ConfigType.FILE;
     hasValues = false;
+    type = ConfigType.FILE;
     preparePostData(postData) {
         return postData;
     }
 }
 class AppConfigModel extends AppConfig {
-    type = ConfigType.MODEL;
     hasValues = true;
+    type = ConfigType.MODEL;
     preparePostData(postData) {
         postData.values.collection =
             postData.values.collection || postData.values.model || this.name;
@@ -197,16 +191,16 @@ class AppConfigModel extends AppConfig {
     }
 }
 class AppConfigContent extends AppConfig {
-    type = ConfigType.CONTENT;
     hasValues = true;
+    type = ConfigType.CONTENT;
     preparePostData(postData) {
         postData.values.collection = postData.values.collection || this.name;
         return postData;
     }
 }
 class AppConfigNotification extends AppConfig {
-    type = ConfigType.NOTIFICATION;
     hasValues = true;
+    type = ConfigType.NOTIFICATION;
     preparePostData(postData) {
         const isTemplate = this.isRootConfig('notifications') &&
             (this.filePath.endsWith('.tpl') || this.filePath.endsWith('.liquid'));
@@ -220,34 +214,34 @@ class AppConfigNotification extends AppConfig {
                 jsonData = JSON.parse(fs.readFileSync(jsonPath, 'utf8'));
                 postData.values.collection = jsonData?.collection || jsonData?.model;
             }
-            catch (err) {
+            catch {
                 // noop
             }
             postData.file = {
-                data: this.fileContent?.replaceAll('\r\n', '\n'),
                 content_type: 'text/plain',
+                data: this.fileContent?.replaceAll('\r\n', '\n'),
             };
         }
         return postData;
     }
 }
 class AppConfigSetting extends AppConfig {
-    type = ConfigType.SETTING;
     hasValues = true;
+    type = ConfigType.SETTING;
     preparePostData(postData) {
         return postData;
     }
 }
 class AppConfigWebhook extends AppConfig {
-    type = ConfigType.WEBHOOK;
     hasValues = true;
+    type = ConfigType.WEBHOOK;
     preparePostData(postData) {
         return postData;
     }
 }
 class AppConfigFunction extends AppConfig {
-    type = ConfigType.FUNCTION;
     hasValues = true;
+    type = ConfigType.FUNCTION;
     async preparePostData(postData) {
         const isFunction = this.isRootConfig('functions') &&
             (this.filePath.endsWith('.js') || this.filePath.endsWith('.ts'));
@@ -262,8 +256,8 @@ class AppConfigFunction extends AppConfig {
                     data: this.prepareFileData(),
                 };
                 postData.build_file = {
-                    data: code,
                     content_type: 'text/javascript',
+                    data: code,
                 };
                 postData.values = config;
             }
@@ -276,25 +270,25 @@ class AppConfigFunction extends AppConfig {
 }
 // Assets do not get installed but saved as plain files
 class AppConfigAsset extends AppConfigDefault {
-    type = ConfigType.ASSET;
     hasValues = false;
+    type = ConfigType.ASSET;
 }
 class AppConfigFrontend extends AppConfigDefault {
-    type = ConfigType.FRONTEND;
     hasValues = false;
+    type = ConfigType.FRONTEND;
 }
 class AppConfigTheme extends AppConfigDefault {
-    type = ConfigType.THEME;
     hasValues = false;
+    type = ConfigType.THEME;
     preparePostData(postData) {
-        const isConfigJson = this.filePath?.match(/^theme\/config\/[^\.\/]+\.json$/);
+        const isConfigJson = this.filePath?.match(/^theme\/config\/[^./]+\.json$/);
         // Files in theme/config/*.json are treated as settings with values
         if (isConfigJson) {
             try {
                 const jsonData = JSON.parse(fs.readFileSync(this.filePath, 'utf8'));
                 postData.values = jsonData;
             }
-            catch (err) {
+            catch {
                 // noop
             }
         }