@swell/cli 1.0.2 → 2.0.1-alpha.2

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

@@ -0,0 +1,26 @@
+import { CreateCommand } from './create-command.js';
+/**
+ * A base class for Swell CLI Create [content|models] command input.
+ *
+ * This class extends the `CreateCommand` 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>;
+    };
+    static args: {
+        collection: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    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>;
+        overwrite: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    promptCollection(): Promise<{
+        label: string;
+        description: string;
+        collection: string;
+    }>;
+}

package/dist/create-collection-command.js

@@ -0,0 +1,97 @@
+import { input, select, Separator } from '@inquirer/prompts';
+import { Args, Flags } from '@oclif/core';
+import { CreateCommand } from './create-command.js';
+import { toCollectionName, toCollectionLabel } from './lib/create/index.js';
+/**
+ * A base class for Swell CLI Create [content|models] command input.
+ *
+ * This class extends the `CreateCommand` class and adds:
+ *
+ * - promptCollection: Get collection name and description
+ */
+export class CreateCollectionCommand extends CreateCommand {
+    // 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',
+        }),
+        description: Flags.string({
+            char: 'd',
+            default: '',
+            description: 'the collection description',
+        }),
+        overwrite: Flags.boolean({
+            char: 'o',
+            default: false,
+            description: 'overwrite existing collection configuration file',
+        }),
+    };
+    async promptCollection() {
+        const { args, flags } = await this.parse(CreateCollectionCommand);
+        let { label, description } = 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(),
+                    ...collections.map((collectionName) => ({
+                        name: collectionName,
+                        value: collectionName,
+                    })),
+                ],
+                pageSize: 25,
+            });
+            if (collectionInput) {
+                isStandardCollection = true;
+            }
+            else {
+                collectionInput = await input({
+                    message: 'Collection name',
+                    default: 'special-things',
+                });
+            }
+            // we replace unwanted characters with underscores to make things easier
+            // for the inflection library
+            collection = toCollectionName(collectionInput);
+        }
+        if (!label && !isStandardCollection) {
+            label = await input({
+                message: 'Collection label',
+                default: toCollectionLabel(collection),
+            });
+            label = toCollectionLabel(label);
+        }
+        description =
+            description ||
+                (await input({
+                    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,
+        };
+    }
+}

package/dist/create-command.d.ts

@@ -0,0 +1,16 @@
+import { AppCommand } from './app-command.js';
+import { ConfigType } from './lib/apps/index.js';
+import { CreateFileParams } from './lib/create/index.js';
+/**
+ * A base class for Swell CLI Create commands for file and input handling.
+ *
+ * This class extends the `AppCommand` class and adds:
+ *
+ * - createType: Type of Config to generate file path
+ * - createFile: File creation, including general prompts
+ */
+export declare abstract class CreateCommand 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

@@ -0,0 +1,59 @@
+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';
+/**
+ * A base class for Swell CLI Create commands for file and input handling.
+ *
+ * This class extends the `AppCommand` class and adds:
+ *
+ * - createType: Type of Config to generate file path
+ * - createFile: File creation, including general prompts
+ */
+export class CreateCommand extends AppCommand {
+    createType = '';
+    async createFile({ extension = 'json', fileBody, fileName }, overwrite, shouldConfirm = true) {
+        const isJson = extension === 'json';
+        const filePath = path.join(this.appPath, ConfigPaths[this.createType.toUpperCase()], `${fileName}.${extension}`);
+        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) {
+                const continueWrite = await confirm({
+                    message: `This will overwrite an existing ${this.createType} file. Ok to continue?`,
+                });
+                if (!continueWrite) {
+                    return;
+                }
+            }
+            else {
+                const confirmCreate = await confirm({
+                    message: 'Ok to continue?',
+                });
+                if (!confirmCreate) {
+                    return;
+                }
+            }
+        }
+        typeof fileBody === 'string'
+            ? await writeFile(filePath, fileBody)
+            : await writeJsonFile(filePath, fileBody);
+        this.log(`${filePath} created.`);
+        return true;
+    }
+    async getCollectionOptions() {
+        const models = await this.api.post({ adminPath: `/data/$get/:models` }, {
+            body: {
+                limit: 1000,
+                client_id: null,
+                app_id: null,
+                abstract: { $ne: true },
+                deprecated: { $ne: true },
+                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/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/lib/api.d.ts

@@ -0,0 +1,13 @@
+export default class Api {
+    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;
+    post(pathOpts: Api.Paths, options?: Api.RequestOptions): Promise<any>;
+    put(pathOpts: Api.Paths, options?: Api.RequestOptions): Promise<any>;
+}

package/dist/lib/api.js

@@ -0,0 +1,117 @@
+import fetch from 'node-fetch';
+import config from './config.js';
+import { getAdminApiBaseUrl, API_BASE_URL } from './constants.js';
+const defaultHeaders = (opts) => ({
+    'Content-Type': 'application/json',
+    ...opts,
+});
+const authenticatedHeaders = (storeId, opts = {}) => {
+    let { secretKey, sessionId, ...moreOpts } = opts;
+    sessionId ??= config.getSessionId(storeId);
+    if (secretKey) {
+        return defaultHeaders({
+            Authorization: `Basic ${Buffer.from(`${storeId}:${secretKey}`).toString('base64')}`,
+            ...moreOpts,
+        });
+    }
+    if (sessionId) {
+        return defaultHeaders({
+            'X-Session': sessionId,
+            ...moreOpts,
+        });
+    }
+    return defaultHeaders(moreOpts);
+};
+export default class Api {
+    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;
+        const fetchOptions = {
+            ...options,
+            headers: {
+                'User-Agent': 'swell-cli/2.0',
+                ...options?.headers,
+                ...(this.envId ? { 'Swell-Env': this.envId } : undefined),
+                ...authenticatedHeaders(storeId, {
+                    secretKey: this.secretKey,
+                    sessionId: options.sessionId,
+                }),
+            },
+        };
+        path = this.isAdmin()
+            ? `${getAdminApiBaseUrl(storeId)}/${pathOpts.adminPath}`
+            : `${API_BASE_URL}/${pathOpts.backendPath}`;
+        if (options.query) {
+            const query = new URLSearchParams(options.query);
+            path += `?${query.toString()}`;
+        }
+        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)
+            throw new Error('Operation not supported.');
+        const resp = await fetch(path, fetchOptions);
+        const respData = await resp.text();
+        if (!resp.ok)
+            throw new Error(respData);
+        try {
+            return JSON.parse(respData);
+        }
+        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)
+                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,
+        });
+    }
+    async get(pathOpts, options = {}) {
+        return this.api(pathOpts, {
+            method: 'GET',
+            ...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, {
+            method: 'POST',
+            ...options,
+        });
+    }
+    async put(pathOpts, options = {}) {
+        // ensure post body is stringified
+        if (options.body)
+            options.body = JSON.stringify(options.body);
+        return this.api(pathOpts, {
+            method: 'PUT',
+            ...options,
+        });
+    }
+}

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

@@ -0,0 +1,29 @@
+import { App } from './apps';
+/**
+ * Checks if the app config file exists.
+ *
+ * @param configFilePath - the path to the app config file
+ * @returns boolean
+ * @throws Error
+ */
+declare function appConfigFileExists(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,
+ * the config file will be searched for in the current working directory or
+ * a parent directory.
+ *
+ * @returns Conf
+ */
+declare function config(configDirPath?: string): LocalApp;
+/**
+ * Returns a new configuration instance in the current working directory only.
+ *
+ * @returns Conf
+ */
+declare function newConfig(path?: string): any;
+export { appConfigFileExists, config as default, newConfig, readRcFile, writeRcFile, };

package/dist/lib/app-config.js

@@ -0,0 +1,127 @@
+/**
+ * App configuration for local development of Swell Apps.
+ */
+import Conf from 'conf';
+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' },
+    permissions: { type: 'array' },
+};
+const APP_FILE_NAME = 'swell';
+const APP_FILE_EXT = 'json';
+/**
+ * Builds the path to the app config file. If no directory is provided, the
+ * current working directory is used.
+ *
+ * @param dir - the directory to use for the config file path
+ * @returns string
+ */
+function appConfigFile(dir = '') {
+    if (!dir) {
+        dir = process.cwd();
+    }
+    return path.join(dir, [APP_FILE_NAME, '.', APP_FILE_EXT].join(''));
+}
+/**
+ * Checks if the app config file exists.
+ *
+ * @param configFilePath - the path to the app config file
+ * @returns boolean
+ * @throws Error
+ */
+function appConfigFileExists(configFilePath = '') {
+    // if the config file path is not provided, try to find it as the default
+    if (!configFilePath) {
+        configFilePath = appConfigFile();
+    }
+    try {
+        // eslint-disable-next-line no-bitwise
+        fs.accessSync(configFilePath, fs.constants.R_OK | fs.constants.W_OK);
+        return true;
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+        return false;
+    }
+}
+/**
+ * Finds the app config file in the current directory or a parent directory.
+ * If the file is not found, an error is thrown.
+ *
+ * @param dir - the directory to start searching from
+ * @returns string
+ * @throws Error
+ */
+function appConfigFilePath(dir = '') {
+    const configFilePath = appConfigFile(dir);
+    if (appConfigFileExists(configFilePath)) {
+        return configFilePath;
+    }
+    // if the file doesn't exist, try to find it in the parent directory
+    // until we reach the root directory
+    if (dir && dir === path.parse(dir).root) {
+        return '';
+    }
+    return appConfigFilePath(path.resolve(dir, '..'));
+}
+async function writeRcFile(path, data) {
+    let dataToWrite = '';
+    for (const [key, value] of Object.entries(data)) {
+        dataToWrite += `${key}=${value}\n`;
+    }
+    fs.writeFileSync(path, dataToWrite);
+}
+function readRcFile(path) {
+    const data = {};
+    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;
+        }
+    }
+    return data;
+}
+/**
+ * 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,
+ * 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,
+    });
+    // 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;
+    return config;
+}
+/**
+ * Returns a new configuration instance in the current working directory only.
+ *
+ * @returns Conf
+ */
+function newConfig(path) {
+    return new Conf({
+        configName: APP_FILE_NAME,
+        cwd: `${process.cwd()}${path ? `/${path}` : ''}`,
+        schema,
+    });
+}
+export { appConfigFileExists, config as default, newConfig, readRcFile, writeRcFile, };

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

@@ -0,0 +1,42 @@
+import { ConfigType } from './index.js';
+declare class IgnoringFileError extends Error {
+    constructor(message: string);
+}
+declare class FunctionProcessingError extends Error {
+    originalError: Error;
+    constructor(message: string, error: Error);
+}
+type AppConfigFile = {
+    data?: string;
+    date_uploaded?: string;
+    ext?: string;
+    id?: string;
+    length?: number;
+    md5?: string;
+    url?: 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;
+    name?: string;
+    parent_id?: string;
+    slug?: string;
+    values: {
+        [key: string]: any;
+    };
+    constructor(attrs?: Partial<AppConfig>);
+    static create(attrs?: Partial<AppConfig>): AppConfig;
+    postData(): Promise<any>;
+    /** 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 };