@useparagon/cli 0.0.1-canary.1

package/src/config/config.utils.ts

@@ -0,0 +1,251 @@
+import * as path from 'node:path';
+import * as fs from 'fs-extra';
+
+import logger from '../logger';
+
+import {
+  DEFAULT_PROFILE,
+  DEFAULT_PROJECT_CONFIG,
+  SYSTEM_CONFIG_DIR_PATH,
+} from './config.constants';
+import {
+  IAuth,
+  IAuthConfig,
+  IProfile,
+  IProfileAuth,
+  IProfileConfig,
+  IProjectConfig,
+  SystemFile,
+  SystemFileToPathMap,
+} from './config.types';
+
+/**
+ * ensures the system directory and files exist
+ */
+export async function initializeSystemFiles(
+  systemDirectoryPath: string = SYSTEM_CONFIG_DIR_PATH,
+): Promise<void> {
+  logger.info('Initializing system files...');
+  await initializeSystemDirectory(systemDirectoryPath);
+  const systemFiles: SystemFile[] = Object.values(SystemFile);
+  await Promise.all(
+    systemFiles.map((file: SystemFile) =>
+      initializeOrUpdateFile(file, systemDirectoryPath),
+    ),
+  );
+}
+
+/**
+ * ensures the system directory exists
+ */
+export async function initializeSystemDirectory(
+  systemDirectoryPath: string,
+): Promise<void> {
+  logger.info('Initializing system directory...', { systemDirectoryPath });
+  const isDir: boolean = await fs.exists(systemDirectoryPath);
+  if (!isDir) {
+    logger.info('Initialized system directory.');
+    await fs.mkdir(systemDirectoryPath);
+  }
+}
+
+/**
+ * ensures a system file exists
+ *
+ * @param file
+ */
+export async function initializeOrUpdateFile(
+  file: SystemFile,
+  systemDirectoryPath: string,
+  fileContents?: string,
+): Promise<void> {
+  logger.info('Initializing or updating file...', {
+    file,
+    systemDirectoryPath,
+  });
+  const filePath: string = path.resolve(
+    systemDirectoryPath,
+    SystemFileToPathMap[file],
+  );
+  const doesExist: boolean = await fs.exists(filePath);
+  if (!doesExist || fileContents) {
+    logger.info('Initialized or updated file.');
+    await fs.writeFile(filePath, fileContents || '{}', { encoding: 'utf-8' });
+  }
+}
+
+/**
+ * reads a system file
+ *
+ * @param file
+ * @param systemDirectoryPath
+ */
+async function readFile(
+  file: SystemFile.CREDENTIALS,
+  systemDirectoryPath: string,
+): Promise<IAuthConfig>;
+async function readFile(
+  file: SystemFile.PROFILES,
+  systemDirectoryPath: string,
+): Promise<IProfileConfig>;
+async function readFile(
+  file: SystemFile,
+  systemDirectoryPath: string,
+): Promise<IAuthConfig | IProfileConfig> {
+  logger.info('Reading file...', { file, systemDirectoryPath });
+  const filePath: string = path.resolve(
+    systemDirectoryPath,
+    SystemFileToPathMap[file],
+  );
+  const fileContents: string = await fs.readFile(filePath, 'utf-8');
+  return JSON.parse(fileContents);
+}
+
+/**
+ * creates a default profile
+ *
+ * @param projectConfig
+ */
+async function createDefaultProfile(
+  projectConfig: IProjectConfig,
+): Promise<IProfile> {
+  const profile: IProfile = {
+    name: DEFAULT_PROFILE,
+    default: true,
+  };
+  const configPath: string =
+    projectConfig.config_path ?? SYSTEM_CONFIG_DIR_PATH;
+  const currentProfileConfig: IProfileConfig = await readFile(
+    SystemFile.PROFILES,
+    configPath,
+  );
+  const updatedProfileConfig: IProfileConfig = {
+    ...currentProfileConfig,
+    [profile.name]: profile,
+  };
+  const stringifiedUpdatedProfileConfig: string = JSON.stringify(
+    updatedProfileConfig,
+    null,
+    2,
+  );
+  await initializeOrUpdateFile(
+    SystemFile.PROFILES,
+    configPath,
+    stringifiedUpdatedProfileConfig,
+  );
+  return profile;
+}
+
+/**
+ * loads the profiles from the file system
+ *
+ * @todo validate config
+ */
+export async function loadProfileConfig(
+  projectConfig: IProjectConfig,
+): Promise<IProfileConfig> {
+  const configPath: string =
+    projectConfig.config_path ?? SYSTEM_CONFIG_DIR_PATH;
+  return readFile(SystemFile.PROFILES, configPath);
+}
+
+/**
+ * loads the profile used in the project
+ *
+ * @param projectConfig
+ */
+export async function loadProfile(
+  projectConfig: IProjectConfig,
+): Promise<IProfile> {
+  const profileConfig: IProfileConfig = await loadProfileConfig(projectConfig);
+  const profileName: string = projectConfig.profile ?? DEFAULT_PROFILE;
+  let profile: IProfile | undefined =
+    profileConfig[profileName] ??
+    Object.values(profileConfig).find((profile: IProfile) => profile.default);
+  if (!profile) {
+    profile = await createDefaultProfile(projectConfig);
+  }
+  return profile;
+}
+
+/**
+ * loads the configuration for the project
+ *
+ * @todo validate config loaded from file system
+ */
+export async function loadProjectConfig(): Promise<IProjectConfig> {
+  const cwd: string = process.cwd();
+  const projectConfigFilePath: string = path.resolve(cwd, 'paragon.json');
+  const doesProjectConfigFileExist: boolean = await fs.exists(
+    projectConfigFilePath,
+  );
+  let projectConfig: IProjectConfig;
+  if (doesProjectConfigFileExist) {
+    const projectConfigString: string = await fs.readFile(
+      projectConfigFilePath,
+      'utf-8',
+    );
+    projectConfig = JSON.parse(projectConfigString);
+    if (projectConfig.config_path) {
+      projectConfig.config_path = path.resolve(
+        process.cwd(),
+        projectConfig.config_path,
+      );
+    }
+  } else {
+    projectConfig = DEFAULT_PROJECT_CONFIG;
+  }
+
+  await initializeSystemFiles(projectConfig.config_path);
+  return projectConfig;
+}
+
+/**
+ * loads the auth params for a project's specified profile
+ *
+ * @param projectConfig
+ * @todo validate auth before returning
+ */
+export async function loadAuthForProfile(
+  projectConfig: IProjectConfig,
+): Promise<IAuth> {
+  const configPath: string =
+    projectConfig.config_path ?? SYSTEM_CONFIG_DIR_PATH;
+  const authConfig: IAuthConfig = await readFile(
+    SystemFile.CREDENTIALS,
+    configPath,
+  );
+  const profileName: string = projectConfig.profile ?? DEFAULT_PROFILE;
+  const auth: IAuth | undefined = authConfig[profileName];
+  if (!auth) {
+    throw new Error('No authentication configured for profile');
+  }
+  // TODO: validate auth
+  return auth;
+}
+
+/**
+ * saving login token to profile
+ *
+ * @param auth
+ * @param projectConfig
+ */
+export async function updateAuthForProfile(
+  auth: IProfileAuth,
+  projectConfig: IProjectConfig,
+): Promise<void> {
+  const configPath: string =
+    projectConfig.config_path ?? SYSTEM_CONFIG_DIR_PATH;
+  const authConfig: IAuthConfig = await readFile(
+    SystemFile.CREDENTIALS,
+    configPath,
+  );
+  const profileName: string = projectConfig.profile ?? DEFAULT_PROFILE;
+  authConfig[profileName] = auth;
+  const serializedAuthConfig: string = JSON.stringify(authConfig, null, 2);
+  await initializeOrUpdateFile(
+    SystemFile.CREDENTIALS,
+    configPath,
+    serializedAuthConfig,
+  );
+}

package/src/config/index.ts

@@ -0,0 +1,2 @@
+export * from './config.types';
+export * from './config.utils';

package/src/helpers/constants.ts

@@ -0,0 +1,9 @@
+/**
+ * language supported by cli
+ */
+export const LANGUAGES_SUPPORTED = <const>['typescript', 'javascript'];
+
+/**
+ * known package managers for node
+ */
+export const KNOWN_PACKAGE_MANAGERS = <const>['npm', 'pnpm', 'yarn', 'bun'];

package/src/helpers/json.ts

@@ -0,0 +1,8 @@
+/**
+ * strigify object with prettier
+ * @param value
+ * @returns
+ */
+export const stringifyObject = (value: object): string => {
+  return JSON.stringify(value, null, 2);
+};

package/src/helpers/spinners.ts

@@ -0,0 +1,3 @@
+import spinnnies from 'spinnies';
+
+export default new spinnnies();

package/src/helpers/strings.ts

@@ -0,0 +1,9 @@
+/**
+ * capitalize first letter of string
+ * example -> "abcd" => "Abcd"
+ * @param value
+ * @returns
+ */
+export const capitalizeFirstLetter = (value: string) => {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+};

package/src/index.ts

@@ -0,0 +1,26 @@
+#! /usr/bin/env node
+
+import * as commander from 'commander';
+
+import { CommandLoader } from './commands/command.loader';
+
+const program: commander.Command = commander.program
+  .version(
+    require('../package.json').version,
+    '-v, --version',
+    'Output the current version.',
+  )
+  .usage('<command> [options]')
+  .helpOption('-h, --help', 'Output usage information.');
+
+//load all commands
+CommandLoader.load(program);
+
+// Only run this file if called directly so functions can be exported + used in other files.
+// If it's being called directly, it's being called from from a github action or yarn script
+// In that case, we have to log the result to the console so it can parse it.
+if (require.main === module) {
+  program.parse(process.argv);
+}
+
+export default program;

package/src/logger/index.ts

@@ -0,0 +1 @@
+export { default } from './logger';

package/src/logger/logger.ts

@@ -0,0 +1,97 @@
+import chalk from 'chalk';
+
+import { Logger } from './logger.type';
+
+// import pino, { DestinationStream, Level, Logger, LoggerOptions } from 'pino';
+// /**
+//  * creates a logger
+//  *
+//  * @todo fix logic for log level when not testing
+//  * @todo disable pretty printing in production environment
+//  */
+// function configureLogger(): Logger<LoggerOptions | DestinationStream> {
+//   const level: Level = process.env.NODE_ENV === 'production' ? 'warn' : 'trace';
+//   const options: LoggerOptions = {
+//     timestamp: false,
+//     level,
+//     transport: {
+//       target: 'pino-pretty',
+//       options: {
+//         colorize: true,
+//       },
+//     },
+
+//     hooks: {
+//       logMethod(args, method) {
+//         // console.log(args);
+//         const newArgs: typeof args =
+//           args.length > 1 &&
+//           typeof args[0] === 'string' &&
+//           typeof args[1] !== 'string'
+//             ? [args[1], args[0], ...args.slice(2)]
+//             : args;
+//         method.apply(this, newArgs);
+//       },
+//     },
+//   };
+//   return pino(options);
+// }
+
+enum LOG_LEVEL {
+  ERROR,
+  // exit process on
+  FATAL,
+  INFO,
+  LOG,
+  SUCCESS,
+  WARNING,
+}
+
+/**
+ * log message with color
+ * @param logLevel
+ * @param args
+ */
+const logWithColor = (logLevel: LOG_LEVEL, ...messages: any[]): void => {
+  let completeMessage: string = '';
+
+  for (const message of messages) {
+    if (typeof message === 'object') {
+      completeMessage += ` ${JSON.stringify(message, null, 2)}`;
+      continue;
+    }
+    completeMessage += ` ${message}`;
+  }
+
+  switch (logLevel) {
+    case LOG_LEVEL.INFO:
+      console.log(chalk.blueBright(completeMessage));
+      break;
+    case LOG_LEVEL.WARNING:
+      console.log('⚠️ ', chalk.yellow(completeMessage));
+      break;
+    case LOG_LEVEL.ERROR:
+      console.log('❌ ', chalk.red(completeMessage));
+      break;
+    case LOG_LEVEL.FATAL:
+      console.log('❌ ', chalk.red(completeMessage));
+      process.exit(1);
+    case LOG_LEVEL.SUCCESS:
+      console.log('✅ ', chalk.green(completeMessage));
+      break;
+  }
+};
+
+/**
+ * pino-prettier not writing synchrounously to terminal so for now using simple console
+ */
+const logger: Logger = {
+  error: (...messages: any[]) => logWithColor(LOG_LEVEL.ERROR, ...messages),
+  fatal: (...messages: any[]) => logWithColor(LOG_LEVEL.FATAL, ...messages),
+  info: (...messages: any[]) => logWithColor(LOG_LEVEL.INFO, ...messages),
+  log: console.log,
+  success: (...messages: any[]) => logWithColor(LOG_LEVEL.SUCCESS, ...messages),
+  warn: (...messages: any[]) => logWithColor(LOG_LEVEL.WARNING, ...messages),
+};
+
+export default logger;

package/src/logger/logger.type.ts

@@ -0,0 +1,8 @@
+export type Logger = {
+  error: (...messages: any[]) => void;
+  fatal: (...messages: any[]) => void;
+  info: (...messages: any[]) => void;
+  log: (...messages: any[]) => void;
+  success: (...messages: any[]) => void;
+  warn: (...messages: any[]) => void;
+};

package/templates/configurations/javascript/.prettierignore

@@ -0,0 +1,2 @@
+node_modules
+dist

package/templates/configurations/javascript/.prettierrc

@@ -0,0 +1,11 @@
+{
+  "singleQuote": true,
+  "trailingComma": "all",
+  "organizeImportsSkipDestructiveCodeActions": true,
+  "importOrder": [
+    "^@useparagon/(.*)$",
+    "^[./]"
+  ],
+  "importOrderSeparation": true,
+  "importOrderCaseInsensitive": true
+}

package/templates/configurations/typescript/.prettierignore

@@ -0,0 +1,2 @@
+node_modules
+dist

package/templates/configurations/typescript/.prettierrc

@@ -0,0 +1,19 @@
+{
+  "singleQuote": true,
+  "trailingComma": "all",
+  "overrides": [
+    {
+      "files": "*.ts",
+      "options": {
+        "parser": "typescript"
+      }
+    }
+  ],
+  "organizeImportsSkipDestructiveCodeActions": true,
+  "importOrder": [
+    "^@useparagon/(.*)$",
+    "^[./]"
+  ],
+  "importOrderSeparation": true,
+  "importOrderCaseInsensitive": true
+}

package/templates/javascript/src/events/hello-world.js

@@ -0,0 +1,13 @@
+module.exports = {
+  /**
+   * name of event
+   */
+  name: 'hello-world',
+
+  /**
+   * schema of event payload
+   */
+  schema: {
+    message: 'Hello,world',
+  },
+};

package/templates/javascript/src/integrations/slack/config.js

@@ -0,0 +1,11 @@
+export default {
+  description: 'Slack Integration',
+  overviewText: `Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
+  
+  Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
+  
+  Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.
+  
+  Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.`,
+  scopes: 'channel:read',
+};

package/templates/javascript/src/integrations/slack/workflows/example-workflow.js

@@ -0,0 +1,30 @@
+import { EventStep, FunctionStep, Workflow } from '@useparagon/core';
+import { IContext } from '@useparagon/core/execution';
+
+import event from '../../../events/hello';
+
+/**
+ * example workflow triggered by an app event
+ */
+export default class ExampleWorkflow extends Workflow {
+  /**
+   * defines the workflow
+   * @param integration
+   * @param context
+   * @param user
+   */
+  define(integration, context) {
+    const trigger = new EventStep(event);
+    const fn = new FunctionStep({
+      code: (parameters) => {
+        return parameters.message;
+      },
+      parameters: {
+        message: context.getOutput(trigger)?.message,
+      },
+    });
+
+    trigger.nextStep(fn);
+    return this.register({ trigger, fn });
+  }
+}

package/templates/typescript/src/events/hello-world.ts

@@ -0,0 +1,21 @@
+import { IEvent } from '@useparagon/core/event';
+
+type EventSchema = {
+  message: string;
+};
+
+const event: IEvent<EventSchema> = {
+  /**
+   * name of event
+   */
+  name: 'hello-world',
+
+  /**
+   * schema of event payload
+   */
+  schema: {
+    message: 'Hello,world',
+  },
+};
+
+export default event;

package/templates/typescript/src/integrations/slack/config.ts

@@ -0,0 +1,18 @@
+import { IIntegrationConfig } from '@useparagon/core';
+
+/**
+ * configuration for a dummy integration
+ */
+const config: IIntegrationConfig = {
+  description: 'A dummy BYO integration.',
+  overviewText: `Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
+  
+  Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
+  
+  Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.
+  
+  Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.`,
+  scopes: 'user:read',
+};
+
+export default config;

package/templates/typescript/src/integrations/slack/workflows/example-workflow.ts

@@ -0,0 +1,30 @@
+import { EventStep, FunctionStep, Workflow } from '@useparagon/core';
+import { IContext } from '@useparagon/core/execution';
+
+import event from '../../../events/hello-world';
+
+/**
+ * example workflow triggered by an app event
+ */
+export default class MyWorkflow extends Workflow<any> {
+  /**
+   * defines the workflow
+   * @param integration
+   * @param context
+   * @param user
+   */
+  define(_integration: any, context: IContext) {
+    const trigger = new EventStep(event);
+    const fn = new FunctionStep({
+      code: (parameters: Record<string, unknown>) => {
+        return parameters.message;
+      },
+      parameters: {
+        message: context.getOutput(trigger)?.message,
+      },
+    });
+
+    trigger.nextStep(fn);
+    return this.register({ trigger, fn });
+  }
+}

package/templates/typescript/tsconfig.json

@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "allowSyntheticDefaultImports": true,
+    "allowUnreachableCode": false,
+    "alwaysStrict": true,
+    "declaration": true,
+    "emitDecoratorMetadata": true,
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "forceConsistentCasingInFileNames": true,
+    "importHelpers": true,
+    "isolatedModules": false,
+    "jsx": "react",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitAny": false,
+    "noImplicitReturns": true,
+    "noImplicitThis": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "removeComments": true,
+    "resolveJsonModule": true,
+    "sourceMap": true,
+    "strict": true,
+    "strictNullChecks": true,
+    "target": "es6",
+  }
+}
+

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["./src", "./templates"],
+  "compilerOptions": {
+    "outDir": "./dist",
+    "baseUrl": "./"
+  },
+  "references": [
+    {
+      "path": "../core"
+    }
+  ]
+}

package/tsconfig.release.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.release.json",
+  "include": ["./src/"],
+  "compilerOptions": {
+    "outDir": "./dist",
+    "baseUrl": "./"
+  },
+  "references": [
+    {
+      "path": "../core"
+    }
+  ]
+}