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

package/dist/lib/app-config.js

@@ -5,11 +5,14 @@ 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' },
     permissions: { type: 'array' },
+    storefront: { type: 'object' },
+    theme: { type: 'object' },
     type: { type: 'string' },
     version: { type: 'string' },
 };
@@ -22,23 +25,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
@@ -60,9 +63,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
@@ -70,10 +73,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`;
     }
@@ -84,9 +87,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;
@@ -95,19 +104,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({
+            clearInvalidConfig: true,
+            configName: APP_FILE_NAME,
+            cwd: dirPath,
+            schema,
+        });
+    }
+    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
     config.swDirPath = dirPath;
@@ -121,9 +137,29 @@ function config(configDirPath = '') {
  */
 function newConfig(path) {
     return new Conf({
+        clearInvalidConfig: true,
         configName: APP_FILE_NAME,
         cwd: `${process.cwd()}${path ? `/${path}` : ''}`,
         schema,
+        serialize,
+    });
+}
+/**
+ * Returns a new configuration instance at the specified path.
+ *
+ * @param appPath 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,
     });
 }
-export { appConfigFileExists, config as default, newConfig, readRcFile, writeRcFile, };
+function serialize(value) {
+    return JSON.stringify(value, null, 2);
+}
+export { config as default, newConfig, newConfigAtPath, readRcFile, swellConfigFileExists, 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);
@@ -7,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;
@@ -20,21 +22,33 @@ type AppConfigFile = {
  * app & the configuration are saved to the API.
  */
 declare abstract class AppConfig {
+    appConfigId?: string;
+    appPath: string;
+    byteSize?: number;
     date_created?: string;
+    date_updated?: string;
     file?: AppConfigFile;
-    fileData?: string;
+    file_path?: string;
+    fileContent?: string;
+    fileData?: Buffer;
+    fileHash?: string;
+    filePath: string;
+    hash?: string;
     id?: string;
-    /** The local path of a remote AppConfig */
-    localPath?: string;
+    mbSize?: number;
     name?: string;
     parent_id?: string;
     slug?: string;
     values: {
         [key: string]: any;
     };
+    version?: string;
     constructor(attrs?: Partial<AppConfig>);
     static create(attrs?: Partial<AppConfig>): AppConfig;
+    isRootConfig(configDir: string): boolean;
     postData(): Promise<any>;
+    prepareFileData(): any;
+    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;

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

@@ -1,9 +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 { bundleFunction } from '../bundle.js';
-import { ConfigType } from './index.js';
+import { ConfigPaths, ConfigType, filePathExists, hashFile } from './index.js';
 class IgnoringFileError extends Error {
     constructor(message) {
         super(message);
@@ -23,21 +24,68 @@ class FunctionProcessingError extends Error {
  * app & the configuration are saved to the API.
  */
 class AppConfig {
+    // Used when pushing a theme and the app config is considered
+    appConfigId;
+    // Full local path of remote AppConfig
+    appPath;
+    // 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;
-    /** The local path of a remote AppConfig */
-    localPath;
+    mbSize;
     name;
     parent_id;
     slug;
     values = {};
+    version;
     constructor(attrs = {}) {
         Object.assign(this, attrs);
-        const { localPath } = attrs;
-        if (localPath) {
-            this.fileData = fs.readFileSync(localPath, 'utf8');
+        let { appPath, file_path, filePath, name, type } = attrs;
+        this.appPath = appPath || '';
+        this.filePath = filePath || '';
+        if (!type || !name) {
+            throw new Error('Missing app config type or name.');
+        }
+        if (!appPath) {
+            throw new Error('Missing app path to initialize config.');
+        }
+        // Make sure file path is set from server prop or type/name
+        if (!filePath) {
+            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(type).toUpperCase()];
+                filePath = `${typePath}/${name}`;
+                if (!typePath) {
+                    throw new Error(`Missing path for app config type: ${type}`);
+                }
+            }
+            this.filePath = filePath;
+        }
+        if (!appPath.endsWith(filePath)) {
+            this.appPath = path.join(appPath, filePath);
+        }
+        if (filePathExists(this.appPath)) {
+            this.fileHash = hashFile(this.appPath);
+            this.hash = this.hash || this.fileHash;
+            this.fileData = fs.readFileSync(this.appPath);
+            this.fileContent = this.fileData.toString('utf8');
+            this.byteSize = Buffer.byteLength(this.fileContent);
+            this.mbSize = this.byteSize / 1024 / 1024;
         }
     }
     static create(attrs = {}) {
@@ -51,120 +99,200 @@ class AppConfig {
             case ConfigType.MODEL: {
                 return new AppConfigModel(attrs);
             }
+            case ConfigType.CONTENT: {
+                return new AppConfigContent(attrs);
+            }
             case ConfigType.NOTIFICATION: {
-                // the path can be a tpl file or a json file as we can use the `create`
-                // function when watching for changes. We need to make sure that we
-                // always use the json file for AppConfig.
-                attrs.localPath = AppConfigNotification.actualConfigPath(attrs.localPath);
                 return new AppConfigNotification(attrs);
             }
+            case ConfigType.SETTING: {
+                return new AppConfigSetting(attrs);
+            }
+            case ConfigType.WEBHOOK: {
+                return new AppConfigWebhook(attrs);
+            }
+            case ConfigType.FRONTEND: {
+                return new AppConfigFrontend(attrs);
+            }
+            case ConfigType.THEME: {
+                return new AppConfigTheme(attrs);
+            }
             default: {
-                // the default type is content so we want to make sure
-                // that we set the expected type
+                // the default type is file
                 const defaultConfig = new AppConfigDefault(attrs);
                 defaultConfig.type = attrs.type;
                 return defaultConfig;
             }
         }
     }
+    isRootConfig(configDir) {
+        return !this.filePath
+            ?.replace(new RegExp(`^${configDir}/`), '')
+            .includes('/');
+    }
     async postData() {
-        if (!this.localPath) {
-            throw new Error('Missing local config path');
-        }
-        if (!this.fileData) {
+        if (this.fileContent === undefined) {
             return;
         }
-        if (this.localPath.endsWith('.json')) {
+        if (this.hasValues && this.filePath.endsWith('.json')) {
             try {
-                this.values = JSON.parse(this.fileData);
+                this.values = JSON.parse(this.fileContent);
             }
             catch {
-                throw new IgnoringFileError('invalid JSON');
+                throw new IgnoringFileError('Invalid JSON');
             }
             if (isEmpty(this.values)) {
-                throw new IgnoringFileError('empty JSON');
+                throw new IgnoringFileError('Empty JSON');
             }
         }
+        // Detect file content type
+        const contentType = this.filePath.endsWith('.liquid') || this.filePath.endsWith('.liquidx')
+            ? 'application/liquid'
+            : detectFilenameMime(this.filePath);
         const postData = {
+            file: {
+                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,
-            values: this.values,
         };
+        if (this.hasValues) {
+            postData.values = this.values || {};
+        }
         return this.preparePostData(postData);
     }
+    prepareFileData() {
+        if (!this.fileData) {
+            return null;
+        }
+        return getEncoding(this.fileData) === 'binary'
+            ? { $base64: this.fileData.toString('base64') }
+            : this.fileData?.toString('utf8');
+    }
 }
 class AppConfigDefault extends AppConfig {
-    type = ConfigType.CONTENT;
+    hasValues = false;
+    type = ConfigType.FILE;
     preparePostData(postData) {
         return postData;
     }
 }
 class AppConfigModel extends AppConfig {
+    hasValues = true;
     type = ConfigType.MODEL;
     preparePostData(postData) {
-        postData.values.collection = this.name;
+        postData.values.collection =
+            postData.values.collection || postData.values.model || this.name;
+        return postData;
+    }
+}
+class AppConfigContent extends AppConfig {
+    hasValues = true;
+    type = ConfigType.CONTENT;
+    preparePostData(postData) {
+        postData.values.collection = postData.values.collection || this.name;
         return postData;
     }
 }
 class AppConfigNotification extends AppConfig {
+    hasValues = true;
     type = ConfigType.NOTIFICATION;
-    /**
-     * The actual config path is the path to the JSON file that is used to
-     * configure the notification. This function ensures that the path is
-     * correct.
-     *
-     * @param localPath - json or tpl file path
-     * @returns - json file path
-     */
-    static actualConfigPath(localPath) {
-        return localPath?.replace('.tpl', '.json');
-    }
     preparePostData(postData) {
-        if (!this.localPath) {
-            throw new Error('Missing local config path');
-        }
-        const templateFile = this.localPath.replace('.json', '.tpl');
-        this.fileData = fs.readFileSync(templateFile, 'utf8');
-        if (this.fileData) {
-            postData.values.content = {
-                html: {
-                    data: this.fileData.replaceAll('\r\n', '\n'),
-                },
+        const isTemplate = this.isRootConfig('notifications') &&
+            (this.filePath.endsWith('.tpl') || this.filePath.endsWith('.liquid'));
+        if (isTemplate) {
+            // Get json config to match collection/model name
+            let jsonData;
+            try {
+                const jsonPath = this.filePath
+                    .replace('.tpl', '.json')
+                    .replace('.liquid', '.json');
+                jsonData = JSON.parse(fs.readFileSync(jsonPath, 'utf8'));
+                postData.values.collection = jsonData?.collection || jsonData?.model;
+            }
+            catch {
+                // noop
+            }
+            postData.file = {
+                content_type: 'text/plain',
+                data: this.fileContent?.replaceAll('\r\n', '\n'),
             };
         }
         return postData;
     }
 }
+class AppConfigSetting extends AppConfig {
+    hasValues = true;
+    type = ConfigType.SETTING;
+    preparePostData(postData) {
+        return postData;
+    }
+}
+class AppConfigWebhook extends AppConfig {
+    hasValues = true;
+    type = ConfigType.WEBHOOK;
+    preparePostData(postData) {
+        return postData;
+    }
+}
 class AppConfigFunction extends AppConfig {
+    hasValues = true;
     type = ConfigType.FUNCTION;
     async preparePostData(postData) {
-        if (!this.localPath) {
-            throw new Error('Missing local config path');
-        }
-        try {
-            const { code, config } = await bundleFunction(this.localPath);
-            if (!config) {
-                throw new IgnoringFileError('Function must export a `config` object.');
+        const isFunction = this.isRootConfig('functions') &&
+            (this.filePath.endsWith('.js') || this.filePath.endsWith('.ts'));
+        if (isFunction) {
+            try {
+                const { code, config } = await bundleFunction(this.filePath);
+                if (!config) {
+                    throw new IgnoringFileError('Function must export a `config` object.');
+                }
+                // Save the original file and the bundled version
+                postData.file = {
+                    data: this.prepareFileData(),
+                };
+                postData.build_file = {
+                    content_type: 'text/javascript',
+                    data: code,
+                };
+                postData.values = config;
+            }
+            catch (error) {
+                throw new FunctionProcessingError(`Unable to compile function ${this.name}`, error);
             }
-            const fileName = path.basename(this.localPath);
-            postData.file = {
-                data: code,
-                // we keep the file extension so we can easily identify the file path
-                // when we need to delete the function
-                ext: fileName.replace(this.name, ''),
-            };
-            postData.values = config;
-        }
-        catch (error) {
-            throw new FunctionProcessingError(`Unable to compile function ${this.name}`, error);
         }
         return postData;
     }
 }
-class AppConfigAsset extends AppConfig {
+// Assets do not get installed but saved as plain files
+class AppConfigAsset extends AppConfigDefault {
+    hasValues = false;
     type = ConfigType.ASSET;
-    preparePostData(_postData) {
-        throw new Error('Assets not yet supported');
+}
+class AppConfigFrontend extends AppConfigDefault {
+    hasValues = false;
+    type = ConfigType.FRONTEND;
+}
+class AppConfigTheme extends AppConfigDefault {
+    hasValues = false;
+    type = ConfigType.THEME;
+    preparePostData(postData) {
+        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 {
+                // noop
+            }
+        }
+        return postData;
     }
 }
 export { AppConfig, FunctionProcessingError, IgnoringFileError };