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

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

@@ -2,8 +2,10 @@
 import isEmpty from 'lodash/isEmpty.js';
 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 } from './index.js';
+import { ConfigType, ConfigPaths, hashFile, filePathExists } from './index.js';
 class IgnoringFileError extends Error {
     constructor(message) {
         super(message);
@@ -23,21 +25,68 @@ class FunctionProcessingError extends Error {
  * app & the configuration are saved to the API.
  */
 class AppConfig {
-    date_created;
-    file;
-    fileData;
+    // Server-side props
     id;
-    /** The local path of a remote AppConfig */
-    localPath;
+    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;
+    mbSize;
     constructor(attrs = {}) {
         Object.assign(this, attrs);
-        const { localPath } = attrs;
-        if (localPath) {
-            this.fileData = fs.readFileSync(localPath, 'utf8');
+        let { filePath, appPath } = attrs;
+        this.filePath = filePath || '';
+        this.appPath = appPath || '';
+        if (!attrs.type || !attrs.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 (attrs.file_path) {
+                filePath = attrs.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}`;
+                if (!typePath) {
+                    throw new Error(`Missing path for app config type: ${attrs.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,16 +100,26 @@ 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;
@@ -68,103 +127,178 @@ class AppConfig {
         }
     }
     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
+        let contentType = detectFilenameMime(this.filePath);
+        if (this.filePath.endsWith('.liquid') ||
+            this.filePath.endsWith('.liquidx')) {
+            contentType = 'application/liquid';
+        }
+        else {
+            contentType = 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,
-            values: this.values,
+            hash: this.hash,
+            file_path: this.filePath,
+            file: {
+                data: this.prepareFileData(),
+                content_type: contentType,
+            },
         };
+        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');
+    }
+    isRootConfig(configDir) {
+        return !this.filePath
+            ?.replace(new RegExp(`^${configDir}/`), '')
+            .includes('/');
+    }
 }
 class AppConfigDefault extends AppConfig {
-    type = ConfigType.CONTENT;
+    type = ConfigType.FILE;
+    hasValues = false;
     preparePostData(postData) {
         return postData;
     }
 }
 class AppConfigModel extends AppConfig {
     type = ConfigType.MODEL;
+    hasValues = true;
+    preparePostData(postData) {
+        postData.values.collection =
+            postData.values.collection || postData.values.model || this.name;
+        return postData;
+    }
+}
+class AppConfigContent extends AppConfig {
+    type = ConfigType.CONTENT;
+    hasValues = true;
     preparePostData(postData) {
-        postData.values.collection = this.name;
+        postData.values.collection = postData.values.collection || this.name;
         return postData;
     }
 }
 class AppConfigNotification extends AppConfig {
     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');
-    }
+    hasValues = true;
     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 (err) {
+                // noop
+            }
+            postData.file = {
+                data: this.fileContent?.replaceAll('\r\n', '\n'),
+                content_type: 'text/plain',
             };
         }
         return postData;
     }
 }
+class AppConfigSetting extends AppConfig {
+    type = ConfigType.SETTING;
+    hasValues = true;
+    preparePostData(postData) {
+        return postData;
+    }
+}
+class AppConfigWebhook extends AppConfig {
+    type = ConfigType.WEBHOOK;
+    hasValues = true;
+    preparePostData(postData) {
+        return postData;
+    }
+}
 class AppConfigFunction extends AppConfig {
     type = ConfigType.FUNCTION;
+    hasValues = true;
     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 = {
+                    data: code,
+                    content_type: 'text/javascript',
+                };
+                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 {
     type = ConfigType.ASSET;
-    preparePostData(_postData) {
-        throw new Error('Assets not yet supported');
+    hasValues = false;
+}
+class AppConfigFrontend extends AppConfigDefault {
+    type = ConfigType.FRONTEND;
+    hasValues = false;
+}
+class AppConfigTheme extends AppConfigDefault {
+    type = ConfigType.THEME;
+    hasValues = false;
+    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 (err) {
+                // noop
+            }
+        }
+        return postData;
     }
 }
 export { AppConfig, FunctionProcessingError, IgnoringFileError };

package/dist/lib/apps/index.d.ts

@@ -1,29 +1,89 @@
+/// <reference types="node" />
 import { AppConfig } from './app-config.js';
 /**
  * An app as defined by the Swell API. This is different than an app
  * configuration that developers define.
  */
 type App = {
+    id?: string;
     client?: any;
     client_id?: string;
     configs?: AppConfig[];
     date_created?: string;
     date_updated?: string;
     description?: string;
-    id?: string;
-    installed?: boolean;
     name?: string;
+    type?: string;
+    kind?: string;
     private_id?: string;
     public_id?: string;
     published?: boolean;
     version?: string;
+    compatibilities?: {
+        [key: string]: string;
+    };
+    storefront?: {
+        [key: string]: any;
+    };
+    theme?: {
+        [key: string]: any;
+    };
+    logo_icon?: unknown;
+    preview_image?: unknown;
+    preview_mobile_image?: unknown;
+    categories?: Array<string>;
+    use_cases?: Array<string>;
+    purchase_options?: Array<string>;
+    features?: Array<string>;
+    highlights?: Array<{
+        id: string;
+        title: string;
+        image_src?: unknown;
+    }>;
+    styles?: Array<{
+        id: string;
+        label: string;
+        color: string;
+        color_alt?: string;
+        preview_image?: unknown;
+        preview_mobile_image?: unknown;
+    }>;
+    extensions?: Array<any>;
+    frontend?: {
+        url?: string;
+        service?: string;
+        framework?: string;
+        deployment_id?: string;
+        deployment_hash?: string;
+        deployment?: object | null;
+    };
+    installed?: {
+        id: string;
+        date_created: string;
+    };
 };
+declare enum SwellJsonFields {
+    ID = "id",
+    NAME = "name",
+    TYPE = "type",
+    KIND = "kind",
+    VERSION = "version",
+    DESCRIPTION = "description",
+    STOREFRONT = "storefront",
+    THEME = "theme",
+    PERMISSIONS = "permissions",
+    EXTENSIONS = "extensions"
+}
 type AppVersion = {
     date_created: string;
     id: string;
     name: string;
-    notes: string;
     version: string;
+    description?: string;
+    released?: boolean;
+    release_notes?: string;
+    published?: boolean;
+    supported?: boolean;
 };
 declare enum ConfigType {
     ASSET = "asset",
@@ -32,12 +92,19 @@ declare enum ConfigType {
     MODEL = "model",
     NOTIFICATION = "notification",
     SETTING = "setting",
-    WEBHOOK = "webhook"
+    WEBHOOK = "webhook",
+    FRONTEND = "frontend",
+    THEME = "theme",
+    FILE = "file"
 }
+declare const StorefrontConfigTypes: string[];
+declare const ThemeConfigTypes: string[];
 type ConfigPathsType = {
     [key in ConfigType]: string;
 };
 declare const ConfigPaths: ConfigPathsType;
+declare const StorefrontConfigPaths: ConfigPathsType;
+declare const ThemeConfigPaths: ConfigPathsType;
 declare enum ConfigInputFields {
     FILE = "file",
     NAME = "name",
@@ -45,23 +112,36 @@ declare enum ConfigInputFields {
     VALUES = "values",
     VERSION = "version"
 }
-declare function hasAllowedFileExtension(file: string, configType?: ConfigType): boolean;
+type FrontendProjectType = {
+    name: string;
+    slug: string;
+    configFileName: string;
+    deployPath: string;
+    installCommand: string;
+    buildCommand: string;
+    devCommand: string;
+};
+declare const FrontendProjectTypes: Array<FrontendProjectType>;
+declare function getAppSlugId(app: App): string | undefined;
+declare function getFrontendProjectType(appPath: string): FrontendProjectType | undefined;
 declare function getConfigTypeFromPath(path: string): ConfigType | undefined;
 declare function getConfigTypeKeyFromValue(value: string): string | undefined;
-declare function fileExists(filePath: string): boolean;
+declare function filePathExists(filePath: string): boolean;
 declare function writeFile(file: string, data: string): Promise<void>;
+declare function deleteFile(file: string): Promise<void>;
 declare function writeJsonFile(file: string, data?: any): Promise<void>;
-declare function appLogoIcon(appPath: string): string | undefined;
-declare function isAppLogoIcon(file: string): boolean;
-declare function appConfigFromFile(configFile: string, configType: ConfigType): AppConfig;
-declare function findAppConfig(app: App, file: string, configType: ConfigType): AppConfig | undefined;
+declare function hashFile(filePath: string, fileContents?: Buffer): string;
+declare function hashString(contents: string): string;
+declare function appAssetImage(appPath: string, fileName: string): string | undefined;
+declare function appConfigFromFile(filePath: string, configType: ConfigType, appPath: string): AppConfig;
+declare function findAppConfig(app: App, filePath: string, configType: ConfigType): AppConfig | undefined;
 /**
  * Get files to push in batches prioritized by dependencies
  *
  * @param appConfigs - List of app configs
  * @returns {Array} Batches of files to push
  */
-declare function batchAppConfigsByType(appConfigs: AppConfig[]): Array<any>;
-export { App, AppVersion, ConfigInputFields, ConfigPaths, ConfigPathsType, ConfigType, appConfigFromFile, appLogoIcon, batchAppConfigsByType, fileExists, findAppConfig, getConfigTypeFromPath, getConfigTypeKeyFromValue, hasAllowedFileExtension, isAppLogoIcon, writeFile, writeJsonFile, };
+declare function batchAppFilesByType(configs: AppConfig[]): Array<any>;
+export { App, AppVersion, SwellJsonFields, ConfigInputFields, ConfigPaths, ConfigPathsType, StorefrontConfigPaths, StorefrontConfigTypes, ThemeConfigTypes, ThemeConfigPaths, ConfigType, FrontendProjectType, FrontendProjectTypes, getAppSlugId, appConfigFromFile, appAssetImage, batchAppFilesByType, filePathExists, findAppConfig, getConfigTypeFromPath, getConfigTypeKeyFromValue, writeFile, writeJsonFile, deleteFile, hashFile, hashString, getFrontendProjectType, };
 export { AppConfig, FunctionProcessingError, IgnoringFileError, } from './app-config.js';
-export { allConfigDirsPaths, allConfigFilesPaths, allConfigFilesPathsByType, getAllConfigPaths, configFilePath, } from './paths.js';
+export { globAllFilesByPath, allConfigDirsPaths, allConfigFilesPaths, allConfigFilesPathsByType, allConfigFilesInDir, allBaseFilesInDir, isPathDirectory, getAllConfigPaths, } from './paths.js';