@useparagon/cli 0.0.1-canary.1

package/src/commands/login/login.utils.ts

@@ -0,0 +1,68 @@
+import axios, { AxiosError, AxiosResponse } from 'axios';
+
+import { IAuth, IProfile, IProfileAuth } from '../../config';
+import logger from '../../logger';
+
+import { ILoginResponse } from './login.types';
+
+type FormattedAxiosError = {
+  message: string;
+  code?: string;
+  status?: number;
+  statusText?: string;
+};
+
+/**
+ * logs into a profile
+ *
+ * @param auth
+ * @param profile
+ */
+export async function login(
+  auth: IAuth,
+  profile: IProfile,
+): Promise<IProfileAuth> {
+  const baseURL: string | undefined = profile.services?.zeus;
+  if (!baseURL) {
+    throw new Error('No url defined for Zeus!');
+  }
+
+  try {
+    const { username, password } = auth;
+    if (!username) {
+      throw new Error('No username configured for profile.');
+    } else if (!password) {
+      throw new Error('No password configured for profile.');
+    }
+
+    const response: AxiosResponse<ILoginResponse> = await axios.post(
+      '/auth/login/email',
+      {
+        username,
+        password,
+      },
+      {
+        baseURL,
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      },
+    );
+
+    return {
+      ...auth,
+      profile: profile.name,
+      token: response.data.accessToken,
+    };
+  } catch (e) {
+    const typedError: AxiosError = e as AxiosError;
+    const formattedError: FormattedAxiosError = {
+      code: typedError.code,
+      message: typedError.message,
+      status: typedError.response?.status,
+      statusText: typedError.response?.statusText,
+    };
+    logger.warn('Failed to login.', formattedError);
+    throw new Error(formattedError.message);
+  }
+}

package/src/compilers/compiler.interface.ts

@@ -0,0 +1,9 @@
+/**
+ * interface for compilation of file
+ */
+export interface ICompiler<Options, Output> {
+  /**
+   * compile the file
+   */
+  compile(fileName: string, options: Options): Promise<Output>;
+}

package/src/compilers/compiler.types.ts

@@ -0,0 +1,52 @@
+import { IIntegrationConfig, StateMachine } from '@useparagon/core';
+import { IEvent } from '@useparagon/core/event';
+
+/**
+ * workflow build output
+ */
+export type WorkflowOutput = {
+  id: string;
+  name: string;
+  stateMachine: StateMachine;
+};
+
+/**
+ * integration output
+ */
+export type IntegrationOutput = {
+  // can be skip for default integration
+  config?: IIntegrationConfig;
+
+  /**
+   * map of workflowId->workflowoutput
+   */
+  workflows: Record<string, WorkflowOutput>;
+};
+
+/**
+ * project build output
+ */
+export type BuildOutput = {
+  /**
+   * map of eventId->event entity
+   */
+  events: Record<string, IEvent>;
+
+  /**
+   * map of integrationName->integration output
+   */
+  integrations: Record<string, IntegrationOutput>;
+};
+
+/**
+ * integration depdencies
+ */
+export type ProjectDependencies = {
+  events: Record<string, IEvent>;
+};
+
+export type WorkflowDependencies = ProjectDependencies & {
+  integration: {
+    name: string;
+  };
+};

package/src/compilers/compiler.utils.ts

@@ -0,0 +1,32 @@
+import logger from '../logger';
+
+/**
+ * it will extract key {integration , workflow ,event} name from file path
+ * @param filePath
+ * @returns
+ */
+export const extractKeyFromPath = (filePath: string): string => {
+  const names: string[] = filePath.split('/');
+  const fileName: string = names[names.length - 1];
+
+  //as .js is file extension
+  if (fileName.endsWith('.js')) {
+    return fileName.slice(0, -3);
+  }
+
+  return fileName;
+};
+
+/**
+ * require module + exit process
+ * @param filePath
+ * @returns
+ */
+export const requireSafe = <T>(filePath: string): T => {
+  try {
+    return require(filePath).default as T;
+  } catch {
+    logger.error(`Could not found ${filePath}.`);
+    process.exit(1);
+  }
+};

package/src/compilers/event.compiler.ts

@@ -0,0 +1,33 @@
+import path from 'path';
+
+import { IEvent } from '@useparagon/core/event';
+
+import spinners from '../helpers/spinners';
+import { requireSafe } from './compiler.utils';
+
+export class EventCompiler {
+  /**
+   * get event's payload
+   * @param options
+   * @returns
+   */
+  async compile(options: {
+    projectRoot: string;
+    event: string;
+  }): Promise<IEvent> {
+    spinners.add(`compile-event:${options.event}`, {
+      text: `building event ${options.event}`,
+      indent: 2,
+    });
+
+    const event: IEvent = requireSafe(
+      path.join(options.projectRoot, 'events', `${options.event}.js`),
+    );
+
+    spinners.succeed(`compile-event:${options.event}`, {
+      text: `built event ${options.event}`,
+      indent: 2,
+    });
+    return event;
+  }
+}

package/src/compilers/integration.compiler.ts

@@ -0,0 +1,84 @@
+import { glob } from 'glob';
+import path from 'path';
+
+import { IIntegrationConfig } from '@useparagon/core';
+
+import spinners from '../helpers/spinners';
+import logger from '../logger';
+import { IntegrationOutput, WorkflowOutput } from './compiler.types';
+import { extractKeyFromPath } from './compiler.utils';
+import { WorkflowCompiler } from './workflow.compiler';
+
+export class IntegrationCompiler {
+  private workflowCompiler: WorkflowCompiler;
+
+  constructor() {
+    this.workflowCompiler = new WorkflowCompiler();
+  }
+
+  /**
+   * get integration's build output
+   * @param options
+   * @returns
+   */
+  async compile(options: {
+    integration: string;
+    projectRoot: string;
+  }): Promise<IntegrationOutput> {
+    const { integration, projectRoot } = options;
+
+    spinners.add(`compile-integration:${integration}`, {
+      text: `building integration ${integration}`,
+      indent: 2,
+    });
+
+    const workflowKeys: string[] = (
+      await glob(
+        path.join(projectRoot, 'integrations', integration, `workflows/*.js`),
+        {
+          nodir: true,
+        },
+      )
+    ).map(extractKeyFromPath);
+
+    const isCustomIntegration: boolean = integration.startsWith('custom.');
+    let config: IIntegrationConfig | undefined;
+
+    try {
+      config = require(path.join(
+        projectRoot,
+        'integrations',
+        integration,
+        'config.js',
+      ));
+    } catch {
+      if (isCustomIntegration) {
+        logger.fatal(`Config file not found for ${integration}.`);
+      }
+    }
+
+    const compiledWorkflowEntries: Array<[string, WorkflowOutput]> =
+      await Promise.all(
+        workflowKeys.map(
+          async (workflowName: string): Promise<[string, WorkflowOutput]> => {
+            const result: WorkflowOutput = await this.workflowCompiler.compile({
+              projectRoot,
+              workflow: workflowName,
+              integration,
+            });
+            return [result.id, result];
+          },
+        ),
+      );
+
+    spinners.succeed(`compile-integration:${integration}`, {
+      text: `built integration ${integration}`,
+      indent: 2,
+    });
+
+    return {
+      config,
+      workflows: Object.fromEntries(compiledWorkflowEntries),
+    };
+  }
+}

package/src/compilers/project.compiler.ts

@@ -0,0 +1,86 @@
+import { glob } from 'glob';
+import path from 'path';
+
+import { IEvent } from '@useparagon/core/event';
+
+import logger from '../logger';
+import { EventCompiler } from './event.compiler';
+import { IntegrationCompiler } from './integration.compiler';
+import { BuildOutput, IntegrationOutput } from './compiler.types';
+import { extractKeyFromPath } from './compiler.utils';
+
+export class ProjectCompiler {
+  private eventCompiler: EventCompiler;
+  private integrationCompiler: IntegrationCompiler;
+  constructor() {
+    this.eventCompiler = new EventCompiler();
+    this.integrationCompiler = new IntegrationCompiler();
+  }
+
+  /**
+   * compile project
+   * @param options
+   * @returns
+   */
+  async compile(options: {
+    projectRoot: string;
+    integrations: string[];
+  }): Promise<BuildOutput> {
+    const { integrations, projectRoot } = options;
+
+    const userIntegrations: string[] = (
+      await glob(path.join(projectRoot, 'integrations/*/'))
+    ).map(extractKeyFromPath);
+
+    //filter integrations that are not presnent in project
+    const notPresentIntegrations: string[] = userIntegrations.filter(
+      (integration: string): boolean => integrations.includes(integration),
+    );
+
+    if (integrations.length && !notPresentIntegrations.length) {
+      logger.error(
+        `Could not found Integration with key "${notPresentIntegrations.join(
+          ',',
+        )}`,
+      );
+      process.exit(1);
+    }
+
+    const userEvents: string[] = (
+      await glob(path.join(projectRoot, 'events/*.js'))
+    ).map(extractKeyFromPath);
+
+    const eventEntries: Array<[string, IEvent]> = await Promise.all(
+      userEvents.map(async (event: string): Promise<[string, IEvent]> => {
+        const result = await this.eventCompiler.compile({ projectRoot, event });
+        return [result.id!, result];
+      }),
+    );
+
+    const events: Record<string, IEvent> = Object.fromEntries(eventEntries);
+
+    const integrationEntries: Array<[string, IntegrationOutput]> =
+      await Promise.all(
+        userIntegrations
+          .filter((integration: string): boolean =>
+            integrations.length ? integrations.includes(integration) : true,
+          )
+          .map(
+            async (
+              integration: string,
+            ): Promise<[string, IntegrationOutput]> => [
+              integration,
+              await this.integrationCompiler.compile({
+                integration,
+                projectRoot,
+              }),
+            ],
+          ),
+      );
+
+    return {
+      events,
+      integrations: Object.fromEntries(integrationEntries),
+    };
+  }
+}

package/src/compilers/ts.compiler.ts

@@ -0,0 +1,116 @@
+import { join } from 'path';
+import fs from 'fs-extra';
+import * as ts from 'typescript';
+
+import logger from '../logger';
+
+//https://github.com/microsoft/TypeScript-wiki/blob/main/Using-the-Compiler-API.md#a-minimal-compiler
+export class TsCompiler {
+  private tsBinary: typeof ts | undefined;
+
+  /**
+   * run typescript compiler
+   * @param tsConfigPath
+   */
+  public run({ configPath }: { configPath?: string }) {
+    const tsBinary: typeof ts = this.getTsBinary();
+
+    const tsConfigPath: string = configPath ?? this.getDefaultTsconfigPath();
+
+    const formatHost: ts.FormatDiagnosticsHost = {
+      getCanonicalFileName: (path: string) => path,
+      getCurrentDirectory: tsBinary.sys.getCurrentDirectory,
+      getNewLine: () => tsBinary.sys.newLine,
+    };
+
+    const parsedCmd: ts.ParsedCommandLine | undefined =
+      tsBinary.getParsedCommandLineOfConfigFile(
+        tsConfigPath,
+        undefined,
+        tsBinary.sys as unknown as ts.ParseConfigFileHost,
+      );
+
+    const { options, fileNames, projectReferences } = parsedCmd!;
+
+    const createProgram =
+      tsBinary.createIncrementalProgram || tsBinary.createProgram;
+    const program = createProgram.call(ts, {
+      rootNames: fileNames,
+      projectReferences,
+      options,
+    });
+
+    const emitResult = program.emit();
+
+    const diagnostics = tsBinary
+      .getPreEmitDiagnostics(program as unknown as ts.Program)
+      .concat(emitResult.diagnostics);
+
+    if (diagnostics.length > 0) {
+      console.error(
+        tsBinary.formatDiagnosticsWithColorAndContext(diagnostics, formatHost),
+      );
+      console.info(
+        `Found ${diagnostics.length} error(s).` + tsBinary.sys.newLine,
+      );
+    }
+
+    if (diagnostics.length) {
+      process.exit(1);
+    }
+  }
+
+  /**
+   * return tsconfig path
+   */
+  private getDefaultTsconfigPath(): string {
+    const tsConfigFileName: string = fs.existsSync(
+      join(process.cwd(), 'tsconfig.build.json'),
+    )
+      ? 'tsconfig.build.json'
+      : 'tsconfig.json';
+
+    return join(process.cwd(), tsConfigFileName);
+  }
+
+  /**
+   * get host project's typescript binary
+   * @returns
+   */
+  private getTsBinary(): typeof ts {
+    if (this.tsBinary) {
+      return this.tsBinary;
+    }
+
+    try {
+      const tsBinaryPath = require.resolve('typescript', {
+        paths: [process.cwd()],
+      });
+      this.tsBinary = require(tsBinaryPath) as typeof ts;
+
+      return this.tsBinary!;
+    } catch {
+      logger.error(
+        'TypeScript could not be found! Please, install "typescript" package.',
+      );
+      process.exit(1);
+    }
+  }
+
+  /**
+   * convert typescript code to js
+   * @param code
+   * @returns
+   */
+  public transpileToJSCode(code: string): string {
+    const result = ts.transpileModule(code, {
+      compilerOptions: { module: ts.ModuleKind.ES2015 },
+    });
+
+    return result.outputText;
+  }
+}
+
+const tsCompiler = new TsCompiler();
+
+export default tsCompiler;

package/src/compilers/workflow.compiler.ts

@@ -0,0 +1,69 @@
+import path from 'path';
+
+import {
+  IExecutableWorkflow,
+  IIntegrationConfig,
+  StateMachine,
+} from '@useparagon/core';
+import { Context } from '@useparagon/core/execution';
+
+import spinners from '../helpers/spinners';
+import { WorkflowOutput } from './compiler.types';
+import { requireSafe } from './compiler.utils';
+
+interface Constructable<T> {
+  new (...args: any): T;
+}
+
+export class WorkflowCompiler {
+  private context: Context;
+
+  constructor() {
+    this.context = new Context();
+  }
+
+  /**
+   * build workflow
+   * @param options
+   * @returns
+   */
+  async compile(options: {
+    integration: string;
+    workflow: string;
+    projectRoot: string;
+  }): Promise<WorkflowOutput> {
+    spinners.add(`compile-workflow:${options.workflow}`, {
+      text: `building workflow ${options.workflow}`,
+      indent: 4,
+    });
+
+    const workflowPath: string = path.join(
+      options.projectRoot,
+      'integrations',
+      options.integration,
+      'workflows',
+      `${options.workflow}.js`,
+    );
+    const Workflow: Constructable<IExecutableWorkflow<IIntegrationConfig>> =
+      requireSafe(workflowPath);
+    const workflowInstance: IExecutableWorkflow<IIntegrationConfig> =
+      new Workflow();
+
+    const stateMachine: StateMachine = await workflowInstance.define(
+      {} as IIntegrationConfig,
+      this.context,
+      {},
+    );
+
+    spinners.succeed(`compile-workflow:${options.workflow}`, {
+      text: `built workflow ${options.workflow}`,
+      indent: 4,
+    });
+
+    return {
+      id: workflowInstance.id,
+      stateMachine,
+      name: options.workflow,
+    };
+  }
+}

package/src/config/config.constants.ts

@@ -0,0 +1,27 @@
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+import { IProjectConfig } from './config.types';
+
+/**
+ * the location of the system-wide config directory
+ */
+export const SYSTEM_CONFIG_DIR_PATH: string = path.resolve(
+  os.homedir(),
+  '.paragon',
+);
+
+/**
+ * default configuration for a project
+ */
+export const DEFAULT_PROJECT_CONFIG: IProjectConfig = {
+  /**
+   * used to configure a different location for storing credential info
+   */
+  config_path: SYSTEM_CONFIG_DIR_PATH,
+};
+
+/**
+ * the name of the default profile
+ */
+export const DEFAULT_PROFILE: string = 'default';

package/src/config/config.types.ts

@@ -0,0 +1,112 @@
+/**
+ * special files stored at the system level
+ */
+export enum SystemFile {
+  /**
+   * stores credentials for interacting with Paragon
+   */
+  CREDENTIALS = 'CREDENTIALS',
+
+  /**
+   * stores information on different environments that can be interacted with
+   */
+  PROFILES = 'PROFILES',
+}
+
+/**
+ * stores the path to each system file
+ */
+export const SystemFileToPathMap: Record<SystemFile, string> = {
+  [SystemFile.CREDENTIALS]: 'credentials.json',
+  [SystemFile.PROFILES]: 'profiles.json',
+};
+
+/**
+ * credentials for logging into an environment
+ */
+export interface IAuth {
+  /**
+   * the username for logging in
+   */
+  username: string;
+
+  /**
+   * the password for logging in
+   */
+  password: string;
+}
+
+/**
+ * credentials for logging into an environment with the token and associated profile
+ */
+export interface IProfileAuth extends IAuth {
+  /**
+   * the profile in which the authorization information is for
+   */
+  profile: string;
+
+  /**
+   * the auth token for authenticating requests to a profile
+   * saved by the cli after a successful login
+   */
+  token: string;
+}
+
+/**
+ * configuration for authentication to all the profiles on the machine
+ */
+export interface IAuthConfig extends Record<string, IAuth> {}
+
+/**
+ * APIs
+ */
+export enum Service {
+  HERMES = 'hermes',
+  ZEUS = 'zeus',
+}
+
+/**
+ * configuration for an environment
+ */
+export interface IProfile {
+  /**
+   * specifies that this profile is the default profile
+   */
+  default?: boolean;
+
+  /**
+   * the name of the profile
+   */
+  name: string;
+
+  /**
+   * environment variables
+   */
+  environment?: Record<string, string>;
+
+  /**
+   * urls to access services
+   */
+  services?: Record<Service, string>;
+}
+
+/**
+ * configuration for all the profiles configured on the machine
+ */
+export interface IProfileConfig extends Record<string, IProfile> {}
+
+/**
+ * configuration for the current project
+ */
+export interface IProjectConfig {
+  /**
+   * used to configure a different location for storing credential info
+   * defaults to `<HOME_DIRECTORY>/.paragon`, e.g. `~/.paragon`
+   */
+  config_path?: string;
+
+  /**
+   * the profile to use
+   */
+  profile?: string;
+}