neutrinos-cli 1.0.0

package/utils/inquirer-utils.js

@@ -0,0 +1,49 @@
+//@ts-check
+import inquirer from 'inquirer';
+export const inquiry = async (queries) => {
+    try {
+        const answers = await inquirer.prompt(queries);
+        return answers;
+    } catch (error) {
+        console.error(error);
+        return error;
+    }
+};
+
+export const multipleInquiry = async (query, field) => {
+    const result = [];
+    let addMore = true;
+    while (addMore) {
+        const value = await inquiry(query);
+        if (!value) {
+            break;
+        }
+        addMore = (
+            await inquiry({
+                type: 'confirm',
+                name: 'continueAdding',
+                message: 'Do you want to add another ' + field + '?',
+                default: true,
+            })
+        ).continueAdding;
+        result.push(value);
+    }
+
+    return result;
+};
+
+export const DISPLAY_NAME_QUERY = {
+    type: 'input',
+    name: 'name',
+    message: 'Enter the Display Name of the package :',
+};
+export const ICON_FILE_PATH_QUERY = {
+    type: 'input',
+    name: 'value',
+    message: 'Enter the path to the icon of the package :',
+};
+export const IMAGES_FILE_PATH_QUERY = {
+    type: 'input',
+    name: 'value',
+    message: 'Enter the path to images of the package :',
+};

package/utils/logger.js

@@ -0,0 +1,35 @@
+import { greenBright, red, yellow, yellowBright } from 'colorette';
+import { log as _log, error } from 'node:console';
+
+/**
+ * Logs a message with green color to indicate that it is successful.
+ * @param {string} message - The message to be logged.
+ */
+export const log = (message) => _log(yellow(message));
+
+/**
+ * Logs a message with blue color to indicate that it is in progress.
+ *
+ * @param {string} message - The message to be logged.
+ */
+export const inprogress = (message) => _log(yellowBright(message));
+
+/**
+ * Logs a success message with a checkmark symbol.
+ *
+ * @param {string} message - The message to be logged.
+ */
+export const done = (message) => _log(greenBright('✔ ' + message));
+
+/**
+ * Logs a failed message and error.
+ *
+ * @param {string} message - The message to log.
+ * @param {Error} [err] - The error to log.
+ */
+export const failed = (message, err) => {
+    error(red('✖ ' + message));
+    if (err) {
+        error(err);
+    }
+};

package/utils/marketplace-api-utils.js

@@ -0,0 +1,34 @@
+//@ts-check
+import axios from 'axios';
+
+/**
+ *
+ * @param {any} form
+ * @param {string} path
+ * @param {any} session
+ * @param {boolean} isProdPublish
+ * @returns
+ */
+export const publishToMarketplace = async (form, path, session, isProdPublish) => {
+    const url = (isProdPublish ? process.env.MARKETPLACE_URL_PROD : process.env.MARKETPLACE_URL) + path;
+
+    const config = {
+        method: 'post',
+        maxBodyLength: Infinity,
+        url,
+        headers: {
+            Accept: 'application/json',
+            'Content-Type': 'multipart/form-data',
+            Authorization: `${session.token_type} ${session.access_token}`,
+        },
+        data: form,
+    };
+
+    try {
+        const response = await axios.request(config);
+        return response.data;
+    } catch (e) {
+        //@ts-ignore
+        throw new Error(e.response?.data?.message || e.response?.message || e.message);
+    }
+};

package/utils/path-utils.js

@@ -0,0 +1,40 @@
+//@ts-check
+import { kebabCase, pascalCase } from 'change-case';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const __dirname = fileURLToPath(new URL('.', import.meta.url));
+export const templatesPath = () => {
+    return join(__dirname, '../templates');
+};
+export const componentTemplatesPath = () => {
+    return join(templatesPath(), 'component');
+};
+export const pluginJsonPath = (dir) => {
+    return join(dir, 'plugin.json');
+};
+export const modulesTemplatesPath = () => {
+    return join(templatesPath(), 'module');
+};
+export const pluginServerRoot = (wsPath) => {
+    return join(wsPath, 'plugins-server');
+};
+export const pluginServerTemplatesPath = () => {
+    return join(templatesPath(), 'plugins-server');
+};
+export const configDir = () => {
+    return join(homedir(), '.alphaconfigs');
+};
+export const authConfigJson = () => {
+    return join(configDir(), 'auth.json');
+};
+export const getGeneratedComponentName = (packageName) => {
+    return kebabCase(packageName);
+};
+export const getGeneratedComponentClassName = (packageName) => {
+    return pascalCase(packageName);
+};
+export const getDefaultIconPath = () => {
+    return join(templatesPath(), 'assets/default-icon.png');
+};

package/utils/prettify.js

@@ -0,0 +1,36 @@
+import { format } from 'prettier';
+
+/**@type {import('prettier').Options} */
+const formatOptions = {
+    printWidth: 80,
+    singleQuote: true,
+    quoteProps: 'as-needed',
+    trailingComma: 'es5',
+    // useTabs: true,
+    tabWidth: 4,
+    semi: true,
+    bracketSpacing: true,
+    arrowParens: 'avoid',
+    /**
+		 By default, Prettier will wrap markdown text as-is since some services use a linebreak-sensitive renderer,
+		e.g. GitHub comment and BitBucket. In some cases you may want to rely on editor/viewer soft wrapping instead,
+		so this option allows you to opt out with "never".
+   		Valid options:
+   		"always" - Wrap prose if it exceeds the print width.
+   		"never" - Do not wrap prose.
+   		"preserve" - Wrap prose as-is. 
+	 */
+    //  proseWrap: "<always|never|preserve>"
+};
+
+/**
+ * Prettify the given code
+ * @param {string | Object} code
+ * @param {import('prettier').LiteralUnion<import('prettier').BuiltInParserName>} [parser]
+ * @returns {Promise<string>}
+ */
+export const prettify = (code, parser) =>
+    format(typeof code === 'string' ? code : JSON.stringify(code, null, 2), {
+        ...formatOptions,
+        parser: parser || 'typescript',
+    });

package/utils/user-seesion-utils.js

@@ -0,0 +1,43 @@
+//@ts-check
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { exit } from 'process';
+import { createClient } from './create-client.js';
+import { failed, log } from './logger.js';
+import { authConfigJson } from './path-utils.js';
+
+export const validateUserLogin = async () => {
+    try {
+        const tokenSetPath = authConfigJson();
+        if (!existsSync(tokenSetPath)) {
+            log('Please Login');
+            exit(1);
+        }
+        const client = await createClient();
+        const response = await verifyToken(client, tokenSetPath);
+        if (response.active) {
+            return true;
+        } else {
+            await refreshToken(client, tokenSetPath);
+        }
+        return true;
+    } catch (e) {
+        failed('Please login again');
+        exit(1);
+    }
+};
+
+export const getLoggedInUserSession = async () => {
+    await validateUserLogin();
+    return JSON.parse(readFileSync(authConfigJson(), 'utf-8'));
+};
+
+const verifyToken = async (client, tokenSetPath) => {
+    const tokenSet = JSON.parse(readFileSync(tokenSetPath, 'utf-8'));
+    return await client.introspect(tokenSet.access_token);
+};
+
+const refreshToken = async (client, tokenSetPath) => {
+    const tokenSet = JSON.parse(readFileSync(tokenSetPath, 'utf-8'));
+    const updatedTokenSet = await client.refresh(tokenSet.refresh_token);
+    writeFileSync(tokenSetPath, JSON.stringify(updatedTokenSet, null, 2));
+};