neutrinos-cli 1.0.0

package/commands/alpha-publish.js

@@ -0,0 +1,219 @@
+//@ts-check
+import FormData from 'form-data';
+import { execSync } from 'node:child_process';
+import { writeFileSync } from 'node:fs';
+import { join, sep } from 'node:path';
+import { getAlphaComponentDecorator } from '../utils/attribute-utils.js';
+import { getPackageAssetsDirPath, getPackageIcon, getPackageImages } from '../utils/copy-utils.js';
+import { createZipArchive, getFileReadableStream, getIconStream, getPackageJson } from '../utils/file-utils.js';
+import {
+    DISPLAY_NAME_QUERY,
+    ICON_FILE_PATH_QUERY,
+    IMAGES_FILE_PATH_QUERY,
+    inquiry,
+    multipleInquiry,
+} from '../utils/inquirer-utils.js';
+import { done } from '../utils/logger.js';
+import { publishToMarketplace } from '../utils/marketplace-api-utils.js';
+import { getDefaultIconPath } from '../utils/path-utils.js';
+import { getLoggedInUserSession } from '../utils/user-seesion-utils.js';
+import { selectPackages } from './select-packages.mjs';
+
+export async function publish(name, wsPath, options) {
+    const session = await getLoggedInUserSession();
+    const packages = (await selectPackages(wsPath, options.all ?? false, name)) || [];
+
+    await Promise.all(
+        packages.map(async (pkgDir) => {
+            const packageName = pkgDir.split(sep).pop();
+            await processPackagePublish(pkgDir, packageName, wsPath, options || {}, session);
+            done(`${packageName} Published Successfully`);
+        }),
+    );
+}
+
+function validateAlphaPackage(pkgJsonPath, pkgJson, isModule) {
+    if (!pkgJson.alpha) throw new Error('It is not an alpha package');
+    if (isModule && pkgJson.alpha.metadata?.exposedName) {
+        throw new Error(
+            'This package need the exposedName key in metadata with the name of the function or class exported',
+        );
+    }
+    if (pkgJson.alpha.deprecated) {
+        pkgJson.version = '1.0.0';
+        delete pkgJson.alpha.packageId;
+        delete pkgJson.alpha.versionId;
+        delete pkgJson.alpha.deprecated;
+        writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+    }
+}
+
+function getPackageInfo(pkgJson, componentDirPath) {
+    if (!pkgJson.alpha.component) return { name: pkgJson.name, icon: null };
+
+    const metadata = getAlphaComponentDecorator(componentDirPath);
+    return {
+        name: metadata?.label,
+        icon: metadata?.icon ? join(getPackageAssetsDirPath(componentDirPath), metadata?.icon) : null,
+    };
+}
+
+function updatePackageJson(packageJsonPath, packageJson, packageId, versionId) {
+    packageJson.alpha.packageId = packageId;
+    packageJson.alpha.versionId = versionId;
+    writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+}
+
+async function processPackagePublish(componentDirPath, packageName, wsPath, options, session) {
+    const pkgJsonPath = join(componentDirPath, 'package.json');
+    const pkgJson = getPackageJson(pkgJsonPath);
+    const isModule = pkgJson.alpha.module || pkgJson.alpha.plugin;
+    validateAlphaPackage(pkgJsonPath, pkgJson);
+
+    const zipStream = await createZipArchive(join(componentDirPath, 'dist'), packageName, wsPath, isModule);
+
+    if (pkgJson.alpha.packageId) {
+        return publishVersionedPackage(
+            pkgJson,
+            pkgJsonPath,
+            componentDirPath,
+            structuredClone(options),
+            zipStream,
+            session,
+        );
+    }
+    return publishNewPackage(
+        pkgJson,
+        pkgJsonPath,
+        componentDirPath,
+        structuredClone(options),
+        zipStream,
+        packageName,
+        session,
+    );
+}
+const isProdPublish = (mode) => {
+    return mode ? mode.trim().toLowerCase() === 'prod' : false;
+};
+
+async function publishVersionedPackage(pkgJson, pkgJsonPath, componentDirPath, options, zipStream, session) {
+    await incrementPackageVersion(componentDirPath, options);
+    pkgJson = getPackageJson(pkgJsonPath);
+    const iconStream = options.icon ? getFileReadableStream(options.icon) : null;
+    const imagesStream = (options.images || []).map(getFileReadableStream).filter(Boolean);
+    const formData = prepareVersionFormData(pkgJson, zipStream, iconStream, imagesStream);
+    const response =
+        (await publishToMarketplace(formData, pkgJson.alpha.packageId, session, isProdPublish(options.publish))) || {};
+
+    if (response?.version?.version_id) {
+        updatePackageJson(pkgJsonPath, pkgJson, pkgJson.alpha.packageId, response?.version?.version_id);
+    }
+    return response;
+}
+
+async function publishNewPackage(pkgJson, pkgJsonPath, componentDirPath, options, zipStream, packageName, session) {
+    const pkgInfo = getPackageInfo(pkgJson, componentDirPath);
+    options.icon = options.icon ?? pkgInfo.icon;
+    options.images = options.images ?? [pkgInfo.icon];
+    options.displayName = options.displayName ?? pkgInfo.name;
+
+    const iconPath =
+        options.icon ||
+        (options.acceptDefaults ? getDefaultIconPath() : (await getIconPath(componentDirPath)) || getDefaultIconPath());
+    const iconStream = getIconStream(iconPath, componentDirPath);
+
+    const imagesForPkg = options.images?.length
+        ? options.images
+        : options.acceptDefaults
+          ? []
+          : await getImagesPath(componentDirPath);
+
+    const imagesStream = imagesForPkg.map((imagePath) => getIconStream(imagePath, componentDirPath)).filter(Boolean);
+
+    const displayName = options.displayName || (await inquiry(DISPLAY_NAME_QUERY)).name;
+
+    const formData = prepareFormData(displayName, pkgJson, zipStream, iconStream, imagesStream, packageName);
+    const response = (await publishToMarketplace(formData, '', session, isProdPublish(options.publish))) || {};
+
+    if (response.package) {
+        updatePackageJson(
+            pkgJsonPath,
+            pkgJson,
+            response.package.package_id,
+            response.package.latest_version.version_id,
+        );
+    }
+    return response;
+}
+
+async function incrementPackageVersion(componentDirPath, options) {
+    const versionType =
+        options.versionType ||
+        (
+            await inquiry({
+                type: 'list',
+                name: 'type',
+                choices: ['patch', 'minor', 'major'],
+                message: 'Choose the Version type:',
+            })
+        ).type;
+
+    execSync(`npm version ${versionType}`, {
+        cwd: componentDirPath,
+        stdio: 'inherit',
+    });
+}
+
+function prepareVersionFormData(packageJson, zipStream, iconStream, imagesStream) {
+    const formData = new FormData();
+    const packageMetadata = JSON.stringify({
+        platform: 'alpha',
+        type: packageJson.alpha.component ? 'component' : 'module',
+        hasAlphaOwnership: true,
+        metadata: packageJson.alpha.metadata || {},
+    });
+
+    formData.append('version_number', packageJson.version);
+    formData.append('zip_file', zipStream);
+    formData.append('metadata', packageMetadata);
+    if (iconStream) {
+        formData.append('icon', iconStream);
+    }
+    (imagesStream || []).forEach((is) => formData.append('images', is));
+
+    return formData;
+}
+
+function prepareFormData(name, packageJson, zipStream, iconStream, imagesStream, packageName) {
+    const formData = new FormData();
+    const packageMetadata = JSON.stringify({
+        platform: 'alpha',
+        type: packageJson.alpha.component ? 'component' : 'module',
+        hasAlphaOwnership: true,
+        metadata: packageJson.alpha.metadata || {},
+    });
+
+    formData.append('display_name', name);
+    formData.append('package_metadata', packageMetadata);
+    formData.append('name', packageName);
+    formData.append('version_number', packageJson.version);
+    formData.append('package_type', 'zip');
+    formData.append('version_metadata', packageMetadata);
+    formData.append('description', packageJson.description || 'An alpha component');
+    formData.append('zip_file', zipStream);
+    if (iconStream) {
+        formData.append('icon', iconStream);
+    }
+    imagesStream.forEach((is) => formData.append('images', is));
+
+    return formData;
+}
+
+async function getIconPath(componentDirPath) {
+    return getPackageIcon(componentDirPath) || (await inquiry(ICON_FILE_PATH_QUERY)).value;
+}
+
+async function getImagesPath(componentDirPath) {
+    const images = getPackageImages(componentDirPath) || [];
+    return images.length ? images : (await multipleInquiry(IMAGES_FILE_PATH_QUERY)).map((img) => img.value);
+}

package/commands/attribute.js

@@ -0,0 +1,155 @@
+//@ts-check
+import { pascalCase } from 'change-case';
+import { updateComponentSource } from '../utils/attribute-utils.js';
+import { getPackageMetadata } from '../utils/get-package-info.js';
+import { inquiry, multipleInquiry } from '../utils/inquirer-utils.js';
+
+const UI_TYPES = {
+    input: 'UI_TYPE.INPUT',
+    toggle: 'UI_TYPE.TOGGLE',
+    dropdown: 'UI_TYPE.DROPDOWN',
+    'multi-select': 'UI_TYPE.MULTISELECT',
+    'typed-input': 'UI_TYPE.TYPED_INPUT',
+    range: 'UI_TYPE.RANGE',
+    'color-picker': 'UI_TYPE.COLOR_PICKER',
+    'data-source': 'UI_TYPE.DATASOURCE',
+    'data-set': 'UI_TYPE.DATASET',
+    'table-actions': 'UI_TYPE.TABLE_ACTIONS',
+    'data-mapping': 'UI_TYPE.DATA_MAPPING',
+};
+
+const ATTR_TYPES = {
+    property: 'ATTRIBUTE_TYPE.PROPERTY',
+    event: 'ATTRIBUTE_TYPE.EVENT',
+    validation: 'ATTRIBUTE_TYPE.VALIDATION',
+};
+
+const LABEL_QUERY = {
+    type: 'input',
+    name: 'label',
+    message: 'Label of an attribute : ',
+};
+const PLACEHOLDER_QUERY = {
+    type: 'input',
+    name: 'placeholder',
+    message: 'Placeholder for an attribute : ',
+};
+const CATEGORY_QUERY = {
+    type: 'input',
+    name: 'category',
+    message: 'Category of an attribute : ',
+};
+const DEFAULT_VALUE_QUERY = {
+    type: 'input',
+    name: 'defaultValue',
+    message: 'Default Value : ',
+};
+const EVENT_QUERY = { type: 'input', name: 'event', message: 'Event name : ' };
+const UI_TYPE_QUERY = {
+    type: 'list',
+    name: 'uiType',
+    message: 'UI type of an attribute : ',
+    choices: Object.keys(UI_TYPES),
+};
+
+const FIELD_MAPPING_QUERY = {
+    'UI_TYPE.DATA_MAPPING': ['response', 'actions', 'columns', 'actionColumn', 'pagination', 'paginationData'],
+    'UI_TYPE.DATASET': ['value'],
+    'UI_TYPE.DATASOURCE': ['response', 'label', 'value'],
+    'UI_TYPE.TYPED_INPUT': ['type', 'value'],
+};
+
+const OPTIONS_QUERY = {
+    'UI_TYPE.DROPDOWN': ['displayText', 'value'],
+    'UI_TYPE.DATA_MAPPING': ['displayText', 'value'],
+    'UI_TYPE.TYPED_INPUT': ['name', 'value'],
+};
+
+const getAttributeMetadata = async (options) => {
+    const attrMetadata = { ...(options || {}), type: ATTR_TYPES[options.type] };
+    if (!attrMetadata.type) {
+        const { attrType } = await inquiry({
+            type: 'list',
+            name: 'attrType',
+            message: 'Type of an attribute : ',
+            choices: Object.keys(ATTR_TYPES),
+        });
+        attrMetadata.type = ATTR_TYPES[attrType];
+    }
+
+    if (attrMetadata.type === 'ATTRIBUTE_TYPE.EVENT') {
+        const eventMetadata = {
+            label: attrMetadata.label || (await inquiry(LABEL_QUERY)).label,
+            event: attrMetadata.event || (await inquiry(EVENT_QUERY)).event,
+        };
+        Object.assign(attrMetadata, eventMetadata);
+    } else {
+        const { uiType } = attrMetadata.uiType ? attrMetadata : await inquiry(UI_TYPE_QUERY);
+
+        if (!UI_TYPES[uiType]) {
+            const message = `${uiType} is not valid ui-type, should be one of === ${Object.keys(UI_TYPES).join(', ')}`;
+            throw new Error(message);
+        }
+        const data = {
+            uiType: UI_TYPES[uiType],
+            label: attrMetadata.label ?? (await inquiry(LABEL_QUERY)).label,
+            placeholder: attrMetadata.placeholder ?? (await inquiry(PLACEHOLDER_QUERY)).placeholder,
+            category: attrMetadata.category ?? (await inquiry(CATEGORY_QUERY)).category,
+            defaultValue: attrMetadata.defaultValue ?? (await inquiry(DEFAULT_VALUE_QUERY)).defaultValue,
+        };
+        Object.assign(attrMetadata, data);
+
+        const fieldMappings = FIELD_MAPPING_QUERY[attrMetadata.uiType];
+        if (fieldMappings) {
+            attrMetadata.fieldMappings =
+                options.fieldMappings ||
+                (await inquiry(
+                    fieldMappings.map((f) => ({
+                        type: 'input',
+                        name: f,
+                        message: `Field mapping for ${f} field : `,
+                    })),
+                ));
+        } else {
+            attrMetadata.fieldMappings =
+                options.fieldMappings ||
+                (
+                    await inquiry({
+                        type: 'input',
+                        name: 'value',
+                        message: `Field mapping  : `,
+                    })
+                ).value;
+        }
+
+        const attrOptions = OPTIONS_QUERY[attrMetadata.uiType];
+        if (attrOptions && !attrMetadata.options) {
+            const addOptions = (
+                await inquiry({
+                    type: 'confirm',
+                    name: 'value',
+                    message: 'Do you want to add options?',
+                    default: true,
+                })
+            ).value;
+            if (addOptions) {
+                const query = attrOptions.map((o) => ({
+                    type: 'input',
+                    name: o,
+                    message: `Enter the ${pascalCase(o)} : `,
+                }));
+                attrMetadata.options = await multipleInquiry(query, 'option');
+            }
+        }
+    }
+
+    return attrMetadata;
+};
+
+export const addAttribute = async (name, wsPath, options) => {
+    const { componentDirPath, packageName } = await getPackageMetadata(wsPath, name, 'component');
+    const attrMetadata = await getAttributeMetadata(options);
+
+    console.log(attrMetadata);
+    updateComponentSource(attrMetadata, wsPath, componentDirPath, packageName);
+};

package/commands/build.js

@@ -0,0 +1,83 @@
+// @ts-check
+import { execSync } from 'node:child_process';
+import { cpSync } from 'node:fs';
+import { join, sep } from 'node:path';
+import { build as _build } from 'vite';
+import { getPackageJson } from '../utils/file-utils.js';
+import { done, inprogress } from '../utils/logger.js';
+import { getGeneratedComponentName } from '../utils/path-utils.js';
+import { selectPackages } from './select-packages.mjs';
+/**
+ * Builds the plugin and copies the assets to the static server
+ * @param {string} wsPath - The workspace directory
+ */
+export const build = {
+    plugins: async (wsPath, pluginName = '', option) => {
+        const packagesPaths = await selectPackages(wsPath, option.all ?? false, pluginName);
+        await buildComponents(packagesPaths, wsPath, option.module ?? false);
+        inprogress('Copying the assets to static server');
+        for (const path of packagesPaths) {
+            cpSync(join(path, 'dist'), join(wsPath, 'plugins-server', 'plugins'), {
+                recursive: true,
+            });
+        }
+        done('Plugin built');
+    },
+    docker: async (wsPath, pluginName = '') => {
+        await build.plugins(wsPath, pluginName);
+        inprogress('Building the docker image');
+        execSync('docker build -t plugins-server:latest .', {
+            cwd: wsPath,
+            stdio: 'inherit',
+        });
+        done('Docker image built');
+    },
+};
+
+/**
+ * Builds the components in the workspace
+ * @param {string[]} packages - The paths of the packages in the workspace
+ * @param {string} wsPath - The workspace directory
+ */
+const buildComponents = async (packages, wsPath, isModule) => {
+    inprogress('Building the plugins');
+    if (!isModule) {
+        execSync('npx tsc -p ./tsconfig.json', {
+            cwd: wsPath,
+            stdio: 'inherit',
+        });
+    }
+
+    for (const packagePath of packages) {
+        const packageName = packagePath.split(sep).pop() || '';
+        const packageJson = getPackageJson(join(packagePath, 'package.json'));
+        const entryFile = join(
+            packagePath,
+            packageJson.alpha?.component
+                ? getGeneratedComponentName(packageName) + '.ts'
+                : packageJson.alpha?.module || packageJson.alpha?.plugin
+                  ? packageJson.entryFile || 'index.js'
+                  : '',
+        );
+        const outputDir = join(packagePath, 'dist');
+        await _build({
+            build: {
+                lib: {
+                    entry: entryFile,
+                    name: packagePath,
+                    fileName: () => `${packageName}.js`,
+                    formats: ['es'],
+                },
+                outDir: join(outputDir),
+                minify: true,
+                emptyOutDir: true,
+                rollupOptions: {
+                    output: {
+                        inlineDynamicImports: true,
+                    },
+                },
+            },
+        });
+    }
+    done('Plugins built');
+};

package/commands/deprecate.js

@@ -0,0 +1,88 @@
+//@ts-check
+import axios from 'axios';
+import { red } from 'colorette';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join, sep } from 'node:path';
+import { inquiry } from '../utils/inquirer-utils.js';
+import { done, inprogress } from '../utils/logger.js';
+import { getLoggedInUserSession } from '../utils/user-seesion-utils.js';
+import { selectPackages } from './select-packages.mjs';
+
+/**
+ *
+ * @param {string} packageName
+ * @returns
+ */
+const CONFIRM_INQUIRY = (packageName) => {
+    return {
+        type: 'Confirm',
+        name: 'deletePackage',
+        message: `Are you sure you want to deprecate ${red(packageName)} package?`,
+        default: false,
+    };
+};
+
+/**
+ *
+ * @param {string} pkgName
+ * @param {string} wsPath
+ * @param {any} options
+ */
+export const deprecate = async (pkgName, wsPath, options) => {
+    const session = await getLoggedInUserSession();
+    const packages = await selectPackages(wsPath, options.all ?? false, pkgName);
+    await Promise.all(
+        packages.map(async (componentDirPath) => {
+            try {
+                const packageName = componentDirPath.split(sep).pop();
+                if (!options.yes) {
+                    //@ts-ignore
+                    const { deletePackage } = await inquiry(CONFIRM_INQUIRY(packageName));
+                    if (!deletePackage) return;
+                }
+                const pkgJsonPath = join(componentDirPath, 'package.json');
+                const pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+                const { packageId, deprecated } = pkgJson.alpha || {};
+                if (!packageId) {
+                    throw new Error(`${packageName} is not published to deprecate`);
+                }
+                if (deprecated) {
+                    throw new Error(`${packageName} is already deprecated`);
+                }
+                inprogress(`Deprecating ${packageName}`);
+                await deprecatePackage(packageId, session);
+                done(`${packageName} Deprecated successfully`);
+                pkgJson.alpha.deprecated = true;
+                writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+            } catch (err) {
+                //@ts-ignore
+                console.error(err.message);
+            }
+        }),
+    );
+};
+
+/**
+ *
+ * @param {string} packageId
+ * @param {any} session
+ * @returns
+ */
+const deprecatePackage = async (packageId, session) => {
+    const url = process.env.MARKETPLACE_URL + packageId;
+    const config = {
+        method: 'delete',
+        url,
+        headers: {
+            Authorization: `${session.token_type} ${session.access_token}`,
+        },
+    };
+
+    try {
+        const response = await axios.request(config);
+        return response.data;
+    } catch (e) {
+        //@ts-ignore
+        throw new Error(e);
+    }
+};

package/commands/dev.js

@@ -0,0 +1,21 @@
+import { createServer } from 'vite';
+
+/**
+ * Serve the plugin.
+ * @param {string} wsPath - The path to the workspace.
+ * @param {number} port - The port to serve the plugin.
+ */
+export const servePlugin = async (wsPath, port) => {
+    const server = await createServer({
+        configFile: false,
+        root: wsPath,
+        server: {
+            port,
+        },
+    });
+    await server.listen();
+
+    server.printUrls();
+
+    server.bindCLIShortcuts({ print: true });
+};

package/commands/generate.js

@@ -0,0 +1,19 @@
+import { generateComponentPackageInWorkspace } from '../utils/generate-component.js';
+import { generateModulePackageInWorkspace } from '../utils/generate-module.js';
+import { log } from '../utils/logger.js';
+
+export const generate = {
+    component: async ({ name, dir, description }) => {
+        return generateComponentPackageInWorkspace(dir, name, description);
+    },
+    module: async ({ name, dir, description }) => {
+        return generateModulePackageInWorkspace(dir, name, description);
+    },
+    /**
+     * This may look weird, but it's a way to handle unknown plugin type generation
+     */
+    undefined: async () => {
+        log('Please provide a valid command');
+        process.exit(1);
+    },
+};