@swell/cli 1.0.2 → 2.0.1-alpha.2

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

@@ -0,0 +1,167 @@
+/* eslint-disable camelcase */
+import isEmpty from 'lodash/isEmpty.js';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { bundleFunction } from '../bundle.js';
+import { ConfigType } from './index.js';
+class IgnoringFileError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'IgnoringFileError';
+    }
+}
+class FunctionProcessingError extends Error {
+    originalError;
+    constructor(message, error) {
+        super(message);
+        this.name = 'FunctionProcessingError';
+        this.originalError = error;
+    }
+}
+/**
+ * An app configuration as defined by the Swell API. This implies that the
+ * app & the configuration are saved to the API.
+ */
+class AppConfig {
+    date_created;
+    file;
+    fileData;
+    id;
+    /** The local path of a remote AppConfig */
+    localPath;
+    name;
+    parent_id;
+    slug;
+    values = {};
+    constructor(attrs = {}) {
+        Object.assign(this, attrs);
+        const { localPath } = attrs;
+        if (localPath) {
+            this.fileData = fs.readFileSync(localPath, 'utf8');
+        }
+    }
+    static create(attrs = {}) {
+        switch (attrs.type) {
+            case ConfigType.ASSET: {
+                return new AppConfigAsset(attrs);
+            }
+            case ConfigType.FUNCTION: {
+                return new AppConfigFunction(attrs);
+            }
+            case ConfigType.MODEL: {
+                return new AppConfigModel(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);
+            }
+            default: {
+                // the default type is content so we want to make sure
+                // that we set the expected type
+                const defaultConfig = new AppConfigDefault(attrs);
+                defaultConfig.type = attrs.type;
+                return defaultConfig;
+            }
+        }
+    }
+    async postData() {
+        if (!this.localPath || !this.fileData) {
+            throw new Error('Missing local config path');
+        }
+        if (this.localPath.endsWith('.json')) {
+            try {
+                this.values = JSON.parse(this.fileData);
+            }
+            catch {
+                throw new IgnoringFileError('invalid JSON');
+            }
+            if (isEmpty(this.values)) {
+                throw new IgnoringFileError('empty JSON');
+            }
+        }
+        const postData = {
+            name: this.values?.name || this.name,
+            type: this.type,
+            values: this.values,
+        };
+        return this.preparePostData(postData);
+    }
+}
+class AppConfigDefault extends AppConfig {
+    type = ConfigType.CONTENT;
+    preparePostData(postData) {
+        return postData;
+    }
+}
+class AppConfigModel extends AppConfig {
+    type = ConfigType.MODEL;
+    preparePostData(postData) {
+        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');
+    }
+    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'),
+                },
+            };
+        }
+        return postData;
+    }
+}
+class AppConfigFunction extends AppConfig {
+    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 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 {
+    type = ConfigType.ASSET;
+    preparePostData(_postData) {
+        throw new Error('Assets not yet supported');
+    }
+}
+export { AppConfig, FunctionProcessingError, IgnoringFileError };

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

@@ -0,0 +1,67 @@
+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 = {
+    client?: any;
+    client_id?: string;
+    configs?: AppConfig[];
+    date_created?: string;
+    date_updated?: string;
+    description?: string;
+    id?: string;
+    installed?: boolean;
+    name?: string;
+    private_id?: string;
+    public_id?: string;
+    published?: boolean;
+    version?: string;
+};
+type AppVersion = {
+    date_created: string;
+    id: string;
+    name: string;
+    notes: string;
+    version: string;
+};
+declare enum ConfigType {
+    ASSET = "asset",
+    CONTENT = "content",
+    FUNCTION = "function",
+    MODEL = "model",
+    NOTIFICATION = "notification",
+    SETTING = "setting",
+    WEBHOOK = "webhook"
+}
+type ConfigPathsType = {
+    [key in ConfigType]: string;
+};
+declare const ConfigPaths: ConfigPathsType;
+declare enum ConfigInputFields {
+    FILE = "file",
+    NAME = "name",
+    TYPE = "type",
+    VALUES = "values",
+    VERSION = "version"
+}
+declare function hasAllowedFileExtension(file: string, configType?: ConfigType): boolean;
+declare function getConfigTypeFromPath(path: string): ConfigType | undefined;
+declare function getConfigTypeKeyFromValue(value: string): string | undefined;
+declare function fileExists(filePath: string): boolean;
+declare function writeFile(file: string, data: 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;
+/**
+ * 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, };
+export { AppConfig, FunctionProcessingError, IgnoringFileError, } from './app-config.js';
+export { allConfigDirsPaths, allConfigFilesPaths, allConfigFilesPathsByType, getAllConfigPaths, configFilePath, } from './paths.js';

package/dist/lib/apps/index.js

@@ -0,0 +1,167 @@
+import { pluralize, titleize } from 'inflection';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { appConfigFileExists } from '../app-config.js';
+import { AppConfig } from './app-config.js';
+var ConfigType;
+(function (ConfigType) {
+    ConfigType["ASSET"] = "asset";
+    ConfigType["CONTENT"] = "content";
+    ConfigType["FUNCTION"] = "function";
+    ConfigType["MODEL"] = "model";
+    ConfigType["NOTIFICATION"] = "notification";
+    ConfigType["SETTING"] = "setting";
+    ConfigType["WEBHOOK"] = "webhook";
+})(ConfigType || (ConfigType = {}));
+// Models and content should come first in order
+const ConfigTypeBatchOrder = [
+    ConfigType.MODEL,
+    ConfigType.CONTENT,
+    ConfigType.ASSET,
+    ConfigType.FUNCTION,
+    ConfigType.NOTIFICATION,
+    ConfigType.SETTING,
+    ConfigType.WEBHOOK,
+];
+const ConfigPaths = {
+    ...Object.fromEntries(Object.keys(ConfigType).map((type) => [
+        type,
+        // a bit of a hack to make the path singular for content configs
+        // need to refactor this to a function if we add more exceptions
+        type === 'CONTENT' ? 'content' : pluralize(type.toLowerCase()),
+    ])),
+};
+var ConfigInputFields;
+(function (ConfigInputFields) {
+    ConfigInputFields["FILE"] = "file";
+    ConfigInputFields["NAME"] = "name";
+    ConfigInputFields["TYPE"] = "type";
+    ConfigInputFields["VALUES"] = "values";
+    ConfigInputFields["VERSION"] = "version";
+})(ConfigInputFields || (ConfigInputFields = {}));
+function hasAllowedFileExtension(file, configType) {
+    let allowedFileExtensions = new Set([
+        '.js',
+        '.json',
+        '.tpl',
+        '.ts',
+    ]);
+    if (configType === ConfigType.NOTIFICATION) {
+        allowedFileExtensions = new Set(['.json']);
+    }
+    return allowedFileExtensions.has(path.parse(file).ext);
+}
+function getConfigTypeFromPath(path) {
+    for (const type in ConfigPaths) {
+        if (ConfigPaths[type] === path) {
+            const configType = ConfigType[type];
+            return configType;
+        }
+    }
+    return undefined;
+}
+function getConfigTypeKeyFromValue(value) {
+    return Object.keys(ConfigType).find((key) => ConfigType[key] === value);
+}
+function fileExists(filePath) {
+    try {
+        // eslint-disable-next-line no-bitwise
+        fs.accessSync(filePath, fs.constants.R_OK | fs.constants.W_OK);
+        return true;
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+        return false;
+    }
+}
+function writeFile(file, data) {
+    return new Promise((resolve, _reject) => {
+        fs.mkdir(path.dirname(file), { recursive: true }, (error) => {
+            if (error) {
+                throw error;
+            }
+            fs.writeFile(file, data, (error) => {
+                if (error) {
+                    throw error;
+                }
+                resolve();
+            });
+        });
+    });
+}
+async function writeJsonFile(file, data = {}) {
+    return writeFile(file, `${JSON.stringify(data, null, 2)}\n`);
+}
+function appLogoIcon(appPath) {
+    const assetsDirPath = path.join(appPath, ConfigPaths['ASSET']);
+    if (!appConfigFileExists(assetsDirPath)) {
+        return;
+    }
+    for (const configFile of fs.readdirSync(assetsDirPath)) {
+        if (isAppLogoIcon(configFile)) {
+            return path.join(assetsDirPath, configFile);
+        }
+    }
+}
+function isAppLogoIcon(file) {
+    return path.parse(file).name === 'icon';
+}
+function appConfigFromFile(configFile, configType) {
+    const { name } = path.parse(configFile);
+    const appConfig = AppConfig.create({
+        localPath: configFile,
+        name,
+        type: configType,
+        values: {},
+    });
+    return appConfig;
+}
+function findAppConfig(app, file, configType) {
+    const { name } = path.parse(file);
+    const config = app?.configs?.find((c) => c && c.type === configType && c.name === name);
+    return config;
+}
+/**
+ * Get files to push in batches prioritized by dependencies
+ *
+ * @param appConfigs - List of app configs
+ * @returns {Array} Batches of files to push
+ */
+function batchAppConfigsByType(appConfigs) {
+    const modelsWithExtends = appConfigs.filter((item) => item.type === 'model' && item.values.extends);
+    const modelsWithoutExtends = appConfigs.filter((item) => item.type === 'model' && !item.values.extends);
+    const contentTypesWithCollection = appConfigs.filter((item) => item.type === 'content' && item.values.collection);
+    const contentTypesWithoutCollection = appConfigs.filter((item) => item.type === 'content' && !item.values.collection);
+    const prioritized = [
+        ...modelsWithExtends,
+        ...modelsWithoutExtends,
+        ...contentTypesWithCollection,
+        ...contentTypesWithoutCollection,
+    ];
+    const sorted = [
+        ...prioritized,
+        ...appConfigs.filter((item) => !prioritized.includes(item)),
+    ];
+    const batches = [];
+    // eslint-disable-next-line guard-for-in
+    for (const key in ConfigTypeBatchOrder) {
+        const configType = ConfigTypeBatchOrder[key];
+        const configsByType = sorted.filter((item) => item.type === configType);
+        if (configsByType.length === 0) {
+            continue;
+        }
+        batches.push({
+            configs: configsByType,
+            label: titleize(configType),
+            type: configType,
+        });
+    }
+    return batches;
+}
+export { ConfigInputFields, ConfigPaths, ConfigType, 
+// functions
+appConfigFromFile, appLogoIcon, batchAppConfigsByType, fileExists, findAppConfig, getConfigTypeFromPath, getConfigTypeKeyFromValue, hasAllowedFileExtension, isAppLogoIcon, writeFile, writeJsonFile, };
+export { AppConfig, FunctionProcessingError, IgnoringFileError, } from './app-config.js';
+export { allConfigDirsPaths, allConfigFilesPaths, allConfigFilesPathsByType, getAllConfigPaths, configFilePath, } from './paths.js';

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

@@ -0,0 +1,18 @@
+import { AppConfig, ConfigType } from './index.js';
+declare function allConfigDirsPaths(appPath: string): Generator<{
+    configDirPath: string;
+    configType: ConfigType;
+}>;
+declare function allConfigFilesPaths(appPath: string): Generator<{
+    configDirPath: string;
+    configFile: string;
+    configType: ConfigType;
+}, void, unknown>;
+declare function allConfigFilesPathsByType(appPath: string, configTypeKey: string): Generator<{
+    configDirPath: string;
+    configFile: string;
+    configType: ConfigType;
+}, void, unknown>;
+declare function configFilePath(appPath: string, config: AppConfig): string;
+declare function getAllConfigPaths(): Array<string>;
+export { allConfigDirsPaths, allConfigFilesPaths, allConfigFilesPathsByType, getAllConfigPaths, configFilePath, };

package/dist/lib/apps/paths.js

@@ -0,0 +1,54 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { appConfigFileExists } from '../app-config.js';
+import { ConfigPaths, ConfigType, hasAllowedFileExtension, } from './index.js';
+function* allConfigDirsPaths(appPath) {
+    for (const type in ConfigType) {
+        if (Object.prototype.hasOwnProperty.call(ConfigType, type)) {
+            const configType = ConfigType[type];
+            const configPath = ConfigPaths[type];
+            const configDirPath = path.join(appPath, configPath);
+            if (appConfigFileExists(configDirPath)) {
+                yield { configDirPath, configType };
+            }
+        }
+    }
+}
+function* allConfigFilesPaths(appPath) {
+    for (const { configDirPath, configType } of allConfigDirsPaths(appPath)) {
+        yield* allConfigFilesInDir(configDirPath, configType);
+    }
+}
+function* allConfigFilesPathsByType(appPath, configTypeKey) {
+    const configPath = ConfigPaths[configTypeKey];
+    const configDirPath = path.join(appPath, configPath);
+    yield* allConfigFilesInDir(configDirPath, ConfigType[configTypeKey]);
+}
+function* allConfigFilesInDir(configDirPath, configType) {
+    for (const file of fs.readdirSync(configDirPath)) {
+        const configFile = path.join(configDirPath, file);
+        // ignore sub-directories, e.g. functions/lib
+        // ignore files that don't have the allowed extensions
+        if (fs.lstatSync(configFile).isDirectory() ||
+            !hasAllowedFileExtension(configFile, configType)) {
+            continue;
+        }
+        yield { configDirPath, configFile, configType };
+    }
+}
+function configFilePath(appPath, config) {
+    const configPath = ConfigPaths[config.type.toLocaleUpperCase()];
+    const fileExt = config.file?.ext || '.json';
+    return path.join(appPath, configPath, [config.name, fileExt].join(''));
+}
+function getAllConfigPaths() {
+    const configPaths = [];
+    for (const type in ConfigPaths) {
+        if (Object.prototype.hasOwnProperty.call(ConfigPaths, type)) {
+            const configPath = ConfigPaths[type];
+            configPaths.push(configPath);
+        }
+    }
+    return configPaths;
+}
+export { allConfigDirsPaths, allConfigFilesPaths, allConfigFilesPathsByType, getAllConfigPaths, configFilePath, };

package/dist/lib/bundle.d.ts

@@ -0,0 +1 @@
+export declare function bundleFunction(filePath: string): Promise<any>;

package/dist/lib/bundle.js

@@ -0,0 +1,40 @@
+import * as esbuild from 'esbuild';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+export async function bundleFunction(filePath) {
+    try {
+        const buildResult = await esbuild.build({
+            bundle: true,
+            entryPoints: [filePath],
+            format: 'cjs',
+            metafile: true,
+            platform: 'node',
+            target: ['chrome58'],
+            write: false, // Do not write the output to a file
+        });
+        const { metafile: { inputs }, outputFiles: [{ text: origCode }], } = buildResult;
+        // TODO: make a separate method to get dependencies for watch command
+        const dependencies = Object.keys(inputs).filter((input) => !input.startsWith('node_modules/'));
+        let code = origCode
+            .split('\n')
+            .map((line) => line.trim().startsWith('module.exports')
+            ? line.replace('module.exports', 'var moduleExports')
+            : line)
+            .join('\n');
+        // eslint-disable-next-line no-new-func
+        const evalFn = new Function(`${code}\nreturn { ...moduleExports }`);
+        const { config, ...moduleExports } = evalFn();
+        code += getSwellFunctionWrapper();
+        return { code, config, dependencies, moduleExports };
+    }
+    catch (error) {
+        console.log(error);
+        throw new Error(`Unable to compile function ${filePath}: ${error.message}`);
+    }
+}
+function getSwellFunctionWrapper() {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    return fs.readFileSync(path.join(__dirname, './swell-function-wrapper.js'), 'utf8');
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,37 @@
+declare const env: any;
+declare function ensureLoggedIn(storeId: string): Promise<any>;
+declare function get(key: string): any;
+declare function getAll(): any;
+declare function getDefaultStore(): any;
+declare function setDefaultStore(storeId: string): void;
+declare function getSessionId(storeId: string): any;
+/**
+ * Set store data for later access.
+ *
+ * It replaces the previous store value if it exists and only stores the
+ * following attributes:
+ *
+ *  - sessionId
+ *  - storeId
+ *  - name
+ *
+ * @param store - The store to set
+ * @returns {void}
+ */
+declare function setStore(store: Store): void;
+declare function getUser(): any;
+declare function setUser(user: User): void;
+declare function clear(): void;
+declare const config: {
+    clear: typeof clear;
+    ensureLoggedIn: typeof ensureLoggedIn;
+    get: typeof get;
+    getAll: typeof getAll;
+    getDefaultStore: typeof getDefaultStore;
+    getSessionId: typeof getSessionId;
+    getUser: typeof getUser;
+    setDefaultStore: typeof setDefaultStore;
+    setStore: typeof setStore;
+    setUser: typeof setUser;
+};
+export { config as default, env };

package/dist/lib/config.js

@@ -0,0 +1,131 @@
+import Conf from 'conf';
+import Configstore from 'configstore';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import style from './style.js';
+const configPath = process.env.NODE_ENV === 'test'
+    ? path.resolve(process.cwd(), 'test', '.swell', 'config.json')
+    : path.resolve(homedir(), '.swell', 'config.json');
+const configDir = process.env.NODE_ENV === 'test'
+    ? path.resolve(process.cwd(), 'test', 'fixtures')
+    : homedir();
+const configStore = new Configstore('swell', {
+// user: {...},
+// defaultStore: '<store_id>',
+// stores: [
+//   {
+//     storeId: '<store_id>',
+//     sessionId: '<session_id>',
+//     name: '<store_name>',
+//   }
+// ]
+}, {
+    configPath,
+});
+const env = new Conf({
+    configName: 'env',
+    cwd: path.join(configDir, '.swell'),
+    projectName: 'swell',
+    projectSuffix: '',
+});
+/**
+ * Get specified attributes for given object.
+ *
+ * @param object - The object to get attributes from
+ * @param attributes - The attributes to get from the
+ *
+ * @returns An array of the values of the specified attributes
+ */
+function selectAttributes(object, attributes) {
+    // eslint-disable-next-line unicorn/no-array-reduce
+    return attributes.reduce((acc, key) => {
+        acc[key] = object[key];
+        return acc;
+    }, {});
+}
+async function ensureLoggedIn(storeId) {
+    const currentStore = storeId || getDefaultStore();
+    const sessionId = getSessionId(currentStore);
+    // still not logged in
+    if (!sessionId) {
+        const message = [
+            `You are not logged in to store ${style.storeId(currentStore)}.`,
+            `Use ${style.command('swell login')} to authenticate.`,
+        ].join(' ');
+        throw new Error(message);
+    }
+    return sessionId;
+}
+function get(key) {
+    return configStore.get(key);
+}
+function getAll() {
+    return configStore.all;
+}
+function getDefaultStore() {
+    return configStore.get('defaultStore');
+}
+function setDefaultStore(storeId) {
+    return configStore.set('defaultStore', storeId);
+}
+function getSessionId(storeId) {
+    if (!configStore.has('stores'))
+        return;
+    const store = configStore
+        .get('stores')
+        .find((store) => store.storeId === storeId);
+    return store?.sessionId;
+}
+/**
+ * Set store data for later access.
+ *
+ * It replaces the previous store value if it exists and only stores the
+ * following attributes:
+ *
+ *  - sessionId
+ *  - storeId
+ *  - name
+ *
+ * @param store - The store to set
+ * @returns {void}
+ */
+function setStore(store) {
+    const stores = configStore.get('stores') || [];
+    const storeIndex = stores.findIndex((s) => s.storeId === store.storeId);
+    const storeConfig = selectAttributes(store, [
+        'storeId',
+        'sessionId',
+        'name',
+        'email',
+    ]);
+    if (storeIndex === -1) {
+        stores.push(storeConfig);
+    }
+    else {
+        stores[storeIndex] = storeConfig;
+    }
+    return configStore.set('stores', stores);
+}
+function getUser() {
+    return configStore.get('user');
+}
+function setUser(user) {
+    const userConfig = selectAttributes(user, ['name', 'email']);
+    return configStore.set('user', userConfig);
+}
+function clear() {
+    return configStore.clear();
+}
+const config = {
+    clear,
+    ensureLoggedIn,
+    get,
+    getAll,
+    getDefaultStore,
+    getSessionId,
+    getUser,
+    setDefaultStore,
+    setStore,
+    setUser,
+};
+export { config as default, env };

package/dist/lib/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const API_BASE_URL: any;
+export declare const ADMIN_API_BASE_URL: any;
+export declare const LOGIN_HOST: any;
+export declare function getAdminApiBaseUrl(storeId: string): any;
+export declare function getLoginHost(storeId?: string): any;