@useparagon/core 0.0.1-canary.1

package/src/resolvers/resolvers.interface.ts

@@ -0,0 +1,369 @@
+/**
+ * supported data types
+ */
+export enum DataType {
+  STRING = 'STRING',
+  NUMBER = 'NUMBER',
+  DATE = 'DATE',
+  BOOLEAN = 'BOOLEAN',
+  EMAIL = 'EMAIL',
+  OBJECT = 'OBJECT',
+  ARRAY = 'ARRAY',
+  ANY = 'ANY',
+  FILE = 'FILE',
+  NON_DECIMAL = 'NON_DECIMAL',
+}
+
+/**
+ * data type for files
+ */
+type FileDataType = Buffer;
+
+/**
+ * portable data type for files with associated metadata
+ */
+export type FileValue = {
+  data: FileDataType;
+  dataType: DataType.FILE;
+  encoding?: string;
+  id?: string;
+  mimeType?: string;
+  name?: string;
+  size?: string;
+};
+
+/**
+ * supported data type mappings
+ */
+export type DataTypeValues = {
+  [DataType.STRING]: string;
+  [DataType.NUMBER]: number;
+  [DataType.DATE]: Date;
+  [DataType.BOOLEAN]: boolean;
+  [DataType.EMAIL]: string;
+  [DataType.OBJECT]: object;
+  [DataType.ARRAY]: any[];
+  [DataType.ANY]: any;
+  [DataType.FILE]: FileValue;
+  [DataType.NON_DECIMAL]: number;
+};
+
+/**
+ * a static value
+ */
+export type ValueSource<T extends DataType = DataType> = {
+  dataType?: T;
+  type: 'VALUE';
+  value: DataTypeValues[T];
+};
+
+/**
+ * different strategies for fanning in variables within an execution
+ */
+export enum FanInStrategy {
+  SINGLE = 'SINGLE',
+  SINGLE_BY_FANOUT = 'SINGLE_BY_FANOUT',
+  MULTI = 'MULTI',
+  MULTI_BY_FANOUT = 'MULTI_BY_FANOUT',
+}
+
+/**
+ * a dynamic value determined at runtime
+ */
+export type VariableSource<T extends DataType = DataType> = {
+  dataType?: T;
+  type: 'VARIABLE';
+  stepId: string;
+  path: string[];
+};
+
+/**
+ * a reference to an environment secret
+ */
+export type SecretSource = {
+  type: 'ENVIRONMENT_SECRET';
+  environmentSecretId: string;
+};
+
+/**
+ * a reference to a value generated during an execution
+ *
+ * @deprecated
+ * @todo remove deprecated execution source
+ */
+export type DeprecatedExecutionSource = {
+  type: 'CACHED_EXECUTION';
+  cachedEntryId: string;
+};
+
+/**
+ * a value composed of 0 or more static or dynamic values used to build a string
+ */
+export type TokenizedValue<T extends DataType = DataType> =
+  | ValueSource<T>
+  | VariableSource<T>
+  | SecretSource;
+//   | ConnectCredentialSource
+//   | PersonaMetadataSource;
+
+/**
+ * a reference to 0 or more static or dynamic values
+ */
+export type TokenizedSource<T extends DataType = DataType> = {
+  dataType?: T;
+  type: 'TOKENIZED';
+  parts: TokenizedValue[];
+};
+
+/**
+ * a reference to a condition
+ */
+export type ConditionSource = {
+  type: 'CONDITION';
+  condition: ConditionWrapper;
+};
+
+/**
+ * a reference to a user's credential
+ *
+ * @todo uncomment
+ */
+// export type UserSuppliedCredentialSource = {
+//   type: 'USER_SUPPLIED_CREDENTIAL';
+//   tokenType: TokenType;
+//   providerType: ProviderType;
+//   credential: TokenizedSource<DataType.STRING>;
+// };
+
+export type Source<T extends DataType = DataType> =
+  | ValueSource<T>
+  | VariableSource<T>
+  | TokenizedSource<T>
+  | ConditionSource
+  | SecretSource
+  | DeprecatedExecutionSource;
+//   | ExecutionSource
+//   | FanoutExecutionSource
+//   | UserSuppliedCredentialSource
+//   | ConnectCredentialSource
+//   | PersonaMetadataSource;
+
+export type KeyedSource<T extends DataType = DataType> = {
+  key: string;
+  source: Source<T>;
+};
+
+export enum Operator {
+  'None' = '$none',
+  'StringContains' = '$stringContains',
+  'StringDoesNotContain' = '$stringDoesNotContain',
+  'StringExactlyMatches' = '$stringExactlyMatches',
+  'StringDoesNotExactlyMatch' = '$stringDoesNotExactlyMatch',
+  'StringIsIn' = '$stringIsIn',
+  'StringIsNotIn' = '$stringIsNotIn',
+  'StringStartsWith' = '$stringStartsWith',
+  'StringDoesNotStartWith' = '$stringDoesNotStartWith',
+  'StringEndsWith' = '$stringEndsWith',
+  'StringDoesNotEndWith' = '$stringDoesNotEndWith',
+  'NumberGreaterThan' = '$numberGreaterThan',
+  'NumberLessThan' = '$numberLessThan',
+  'NumberEquals' = '$numberEquals',
+  'NumberDoesNotEqual' = '$numberDoesNotEqual',
+  'NumberLessThanOrEqualTo' = '$numberLessThanOrEqualTo',
+  'NumberGreaterThanOrEqualTo' = '$numberGreaterThanOrEqualTo',
+  'DateTimeAfter' = '$dateTimeAfter',
+  'DateTimeBefore' = '$dateTimeBefore',
+  'DateTimeEquals' = '$dateTimeEquals',
+  'BooleanTrue' = '$booleanTrue',
+  'BooleanFalse' = '$booleanFalse',
+  /** (PARA-5551) previously operators for Does Exist / Does Not Exist do a strict check for equality to null, resulting in a bug where value is undefined
+   * to handle this situation, we are adding 2 new operators IsNotNull and IsNull and changing functionality of
+   * Exist and DoesNotExist operators to handle undefined values
+   */
+  'IsNotNull' = '$exists',
+  'IsNull' = '$doesNotExist',
+  'Exists' = '$isNotUndefinedOrNull',
+  'DoesNotExist' = '$isUndefinedOrNull',
+  'ArrayIsIn' = '$arrayIsIn',
+  'ArrayIsNotIn' = '$arrayIsNotIn',
+  'ArrayIsEmpty' = '$arrayIsEmpty',
+  'ArrayIsNotEmpty' = '$arrayIsNotEmpty',
+  'StringGreaterThan' = '$stringGreaterThan',
+  'StringLessThan' = '$stringLessThan',
+}
+
+/**
+ * used to determine boolean logic
+ */
+export type Condition =
+  | {
+      operator: Operator.None;
+      variable: Source<DataType.ANY>;
+    }
+  | {
+      operator: Operator.StringContains;
+      variable: Source<DataType.STRING>;
+      argument: Source<DataType.STRING>;
+    }
+  | {
+      operator: Operator.StringDoesNotContain;
+      variable: Source<DataType.STRING>;
+      argument: Source<DataType.STRING>;
+    }
+  | {
+      operator: Operator.StringExactlyMatches;
+      variable: Source<DataType.STRING>;
+      argument: Source<DataType.STRING>;
+    }
+  | {
+      operator: Operator.StringDoesNotExactlyMatch;
+      variable: Source<DataType.STRING>;
+      argument: Source<DataType.STRING>;
+    }
+  | {
+      operator: Operator.StringIsIn;
+      variable: Source<DataType.STRING>;
+      argument: Source<DataType.STRING>;
+    }
+  | {
+      operator: Operator.StringIsNotIn;
+      variable: Source<DataType.STRING>;
+      argument: Source<DataType.STRING>;
+    }
+  | {
+      operator: Operator.StringStartsWith;
+      variable: Source<DataType.STRING>;
+      argument: Source<DataType.STRING>;
+    }
+  | {
+      operator: Operator.StringDoesNotStartWith;
+      variable: Source<DataType.STRING>;
+      argument: Source<DataType.STRING>;
+    }
+  | {
+      operator: Operator.StringEndsWith;
+      variable: Source<DataType.STRING>;
+      argument: Source<DataType.STRING>;
+    }
+  | {
+      operator: Operator.StringDoesNotEndWith;
+      variable: Source<DataType.STRING>;
+      argument: Source<DataType.STRING>;
+    }
+  | {
+      operator: Operator.NumberGreaterThan;
+      variable: Source<DataType.NUMBER>;
+      argument: Source<DataType.NUMBER>;
+    }
+  | {
+      operator: Operator.NumberLessThan;
+      variable: Source<DataType.NUMBER>;
+      argument: Source<DataType.NUMBER>;
+    }
+  | {
+      operator: Operator.NumberGreaterThanOrEqualTo;
+      variable: Source<DataType.NUMBER>;
+      argument: Source<DataType.NUMBER>;
+    }
+  | {
+      operator: Operator.NumberLessThanOrEqualTo;
+      variable: Source<DataType.NUMBER>;
+      argument: Source<DataType.NUMBER>;
+    }
+  | {
+      operator: Operator.NumberEquals;
+      variable: Source<DataType.NUMBER>;
+      argument: Source<DataType.NUMBER>;
+    }
+  | {
+      operator: Operator.NumberDoesNotEqual;
+      variable: Source<DataType.NUMBER>;
+      argument: Source<DataType.NUMBER>;
+    }
+  | {
+      operator: Operator.DateTimeAfter;
+      variable: Source<DataType.DATE>;
+      argument: Source<DataType.DATE>;
+    }
+  | {
+      operator: Operator.DateTimeBefore;
+      variable: Source<DataType.DATE>;
+      argument: Source<DataType.DATE>;
+    }
+  | {
+      operator: Operator.DateTimeEquals;
+      variable: Source<DataType.DATE>;
+      argument: Source<DataType.DATE>;
+    }
+  | {
+      operator: Operator.BooleanTrue;
+      variable: Source<DataType.BOOLEAN>;
+    }
+  | {
+      operator: Operator.BooleanFalse;
+      variable: Source<DataType.BOOLEAN>;
+    }
+  | { operator: Operator.IsNull; variable: Source }
+  | {
+      operator: Operator.IsNotNull;
+      variable: Source;
+    }
+  | { operator: Operator.Exists; variable: Source }
+  | {
+      operator: Operator.DoesNotExist;
+      variable: Source;
+    }
+  | {
+      operator: Operator.ArrayIsEmpty;
+      variable: Source<DataType.ARRAY>;
+    }
+  | {
+      operator: Operator.ArrayIsNotEmpty;
+      variable: Source<DataType.ARRAY>;
+    }
+  | {
+      operator: Operator.StringGreaterThan;
+      variable: Source<DataType.STRING>;
+      argument: Source<DataType.STRING>;
+    }
+  | {
+      operator: Operator.StringLessThan;
+      variable: Source<DataType.STRING>;
+      argument: Source<DataType.STRING>;
+    };
+
+/**
+ * a condition composed of multiple conditions where all have to evaluate true
+ */
+export type AndConditions = {
+  type: 'JOIN';
+  join: 'AND';
+  conditions: ConditionWrapper[];
+};
+
+/**
+ * a condition composed of multiple conditions where only one has to evaluate true
+ */
+export type OrConditions = {
+  type: 'JOIN';
+  join: 'OR';
+  conditions: ConditionWrapper[];
+};
+
+/**
+ * a condition composed of multiple compound conditions
+ */
+export type JoinedConditions = AndConditions | OrConditions;
+
+/**
+ * an operator for a condition
+ */
+export type OperatorCondition = {
+  type: 'OPERATOR';
+  condition: Condition;
+};
+
+/**
+ * a higher order type representing combinations of complex types
+ */
+export type ConditionWrapper = JoinedConditions | OperatorCondition;

package/src/secret/index.ts

@@ -0,0 +1 @@
+export * from './secret.interface';

package/src/secret/secret.interface.ts

@@ -0,0 +1,4 @@
+/**
+ * the output of a secret
+ */
+export interface ISecretOutput {}

package/src/stateMachine/index.ts

@@ -0,0 +1,2 @@
+export * from './stateMachine.constants';
+export * from './stateMachine.interface';

package/src/stateMachine/stateMachine.constants.ts

@@ -0,0 +1,12 @@
+import { StateMachine } from './stateMachine.interface';
+
+/**
+ * an empty state machine
+ */
+export const EMPTY_STATE_MACHINE: StateMachine = {
+  stepMap: {},
+  sequenceMap: {},
+  start: '',
+  activeStepId: undefined,
+  unusedSteps: [],
+};

package/src/stateMachine/stateMachine.interface.ts

@@ -0,0 +1,145 @@
+import { StepMap } from '../steps/step.interface';
+
+/**
+ * used to describe a group of steps
+ */
+export enum SequenceType {
+  TRIGGER = 'TRIGGER',
+  MAIN = 'MAIN',
+  BRANCH = 'BRANCH',
+  FANOUT = 'FANOUT',
+}
+
+/**
+ * represents a transition between sequences
+ */
+export type SequenceEdge = {
+  /**
+   * describes the transition between sequences
+   */
+  type: SequenceEdgeType;
+
+  /**
+   * the id of the sequence being transitioned from
+   */
+  from: string;
+
+  /**
+   * the id of the sequence being transitioned to
+   */
+  to: string;
+};
+
+/**
+ * used to describe the type of a sequence edge
+ */
+export enum SequenceEdgeType {
+  NEXT = 'NEXT',
+  BRANCH = 'BRANCH',
+  FANOUT = 'FANOUT',
+}
+
+/**
+ * represents a transition between steps
+ */
+export type StepEdge = {
+  /**
+   * human-readable label; used within UIs
+   */
+  label?: string;
+
+  /**
+   * the step id being transitioned from
+   */
+  from: string;
+
+  /**
+   * the step id being transitioned to
+   */
+  to: string | null | undefined;
+};
+
+/**
+ * a sub group of steps to be executed
+ */
+export type Sequence = {
+  /**
+   * id of the sequence
+   */
+  id: string;
+
+  /**
+   * starting step id of the sequence
+   */
+  start?: string; // step ids
+
+  /**
+   * the ids of the steps within the sequence
+   */
+  stepIds: string[];
+
+  /**
+   * the step edges to / from the sequence
+   */
+  stepEdges: StepEdge[];
+
+  /**
+   * the sequence edges bordering the sequence
+   */
+  sequenceEdges: SequenceEdge[];
+
+  /**
+   * the type of sequence
+   */
+  type: SequenceType;
+
+  /**
+   * width of a branch of steps within a condition; used for rendering UIs
+   */
+  conditionalBranchWidth?: number;
+};
+
+/**
+ * key / value map of sequences where the keys are the sequence ids
+ */
+export type SequenceMap = Record<string, Sequence>;
+
+/**
+ * a JSON representation of a workflow
+ */
+export type StateMachine = {
+  /**
+   * a key / value map of all the steps in the state machine
+   */
+  stepMap: StepMap;
+
+  /**
+   * a key / value map of all the sequences in the state machine
+   */
+  sequenceMap: SequenceMap;
+
+  /**
+   * the id of the starting sequence
+   */
+  start: string;
+
+  /**
+   * the active step that's executing
+   * should be set to the trigger id for full workflow executions
+   * @since PARA-1484: epic/fan-in
+   */
+  activeStepId?: string;
+
+  /**
+   * if provided, a workflow should stop executing after reaching this step
+   * used for single step tests where `activeStepId` & `finalStepId` should be the same value
+   * @since PARA-1484: epic/fan-in
+   */
+  finalStepId?: string;
+
+  /**
+   * steps that aren't used in the state machine
+   * @todo rename to `unusedStepIds` to be explicit about objs vs strings
+   */
+  unusedSteps: string[];
+};