@prefecthq/prefect-ui-library 2.9.18 → 2.10.0

package/src/mocks/index.ts

@@ -0,0 +1,123 @@
+import { randomAny } from '@/mocks/any'
+import { randomArtifact } from '@/mocks/artifact'
+import { randomBlockDocument } from '@/mocks/blockDocument'
+import { randomBlockDocumentData } from '@/mocks/blockDocumentData'
+import { randomBlockSchema } from '@/mocks/blockSchema'
+import { randomBlockSchemaCapabilities } from '@/mocks/blockSchemaCapabilities'
+import { randomBlockSchemaCapability } from '@/mocks/blockSchemaCapability'
+import { randomBlockType } from '@/mocks/blockType'
+import { randomBlockTypeSnippet } from '@/mocks/blockTypeSnippet'
+import { randomBoolean } from '@/mocks/boolean'
+import { randomCollectionItem } from '@/mocks/collectionItem'
+import { randomConcurrencyLimit } from '@/mocks/concurrencyLimit'
+import { randomConcurrencyV2Limit } from '@/mocks/concurrencyV2Limit'
+import { randomCreatedOrUpdatedBy } from '@/mocks/createdOrUpdatedBy'
+import { randomDate, randomDateString } from '@/mocks/date'
+import { randomDeployment } from '@/mocks/deployment'
+import { randomDeploymentSchedules } from '@/mocks/deploymentSchedule'
+import { randomDeploymentStatus } from '@/mocks/deploymentStatus'
+import { randomEmail } from '@/mocks/email'
+import { randomFlow } from '@/mocks/flow'
+import { randomFlowResponse } from '@/mocks/flowResponse'
+import { randomFlowRun } from '@/mocks/flowRun'
+import { randomFlowRunGraph, randomGraphNode } from '@/mocks/flowRunGraph'
+import { randomFlowRunHistory } from '@/mocks/flowRunHistory'
+import { randomFlowRunStateHistory } from '@/mocks/flowRunStateHistory'
+import { randomId } from '@/mocks/id'
+import { randomImage } from '@/mocks/image'
+import { randomLogLevel, randomLog } from '@/mocks/log'
+import { randomMarkdownString, randomMarkdownCodeBlockString, randomMarkdownCodeSpanString, randomMarkdownContentString, randomMarkdownHeaderString, randomMarkdownQuoteString, randomMarkdownTableString } from '@/mocks/markdown'
+import { randomNotification } from '@/mocks/notification'
+import { randomNotificationCreate } from '@/mocks/notificationCreate'
+import { randomNumber } from '@/mocks/number'
+import { randomParameters } from '@/mocks/parameters'
+import { randomSchedule } from '@/mocks/schedule'
+import { randomSchema, randomSchemaProperties, randomSchemaProperty } from '@/mocks/schemas'
+import { randomState } from '@/mocks/state'
+import { randomStateType } from '@/mocks/stateType'
+import { randomChar, randomString, randomSentence, randomParagraph, randomRunName, randomNoun, randomAdjective } from '@/mocks/string'
+import { randomTable } from '@/mocks/table'
+import { randomTaskRun } from '@/mocks/taskRun'
+import { randomUiFlowRunHistory } from '@/mocks/UiFlowRunHistory'
+import { randomUrl } from '@/mocks/url'
+import { randomWorker } from '@/mocks/worker'
+import { randomWorkerStatus } from '@/mocks/workerStatus'
+import { randomWorkPool } from '@/mocks/workPool'
+import { randomWorkPoolQueue } from '@/mocks/workPoolQueue'
+import { randomWorkPoolStatus } from '@/mocks/workPoolStatus'
+import { randomWorkQueue, randomWorkQueueFilter } from '@/mocks/workQueue'
+import { randomWorkQueueCreate } from '@/mocks/workQueueCreate'
+import { randomWorkQueueHealthPolicy } from '@/mocks/workQueueHealthPolicy'
+import { randomWorkQueueStatus } from '@/mocks/workQueueStatus'
+
+export const mocks = {
+  adjective: randomAdjective,
+  any: randomAny,
+  artifact: randomArtifact,
+  blockDocument: randomBlockDocument,
+  blockDocumentData: randomBlockDocumentData,
+  blockSchema: randomBlockSchema,
+  blockSchemaCapabilities: randomBlockSchemaCapabilities,
+  blockSchemaCapability: randomBlockSchemaCapability,
+  blockType: randomBlockType,
+  blockTypeSnippet: randomBlockTypeSnippet,
+  boolean: randomBoolean,
+  char: randomChar,
+  collectionItem: randomCollectionItem,
+  concurrencyLimit: randomConcurrencyLimit,
+  concurrencyV2Limit: randomConcurrencyV2Limit,
+  createdOrUpdatedBy: randomCreatedOrUpdatedBy,
+  date: randomDate,
+  dateString: randomDateString,
+  deployment: randomDeployment,
+  deploymentSchedules: randomDeploymentSchedules,
+  deploymentStatus: randomDeploymentStatus,
+  email: randomEmail,
+  flow: randomFlow,
+  flowResponse: randomFlowResponse,
+  flowRun: randomFlowRun,
+  flowRunGraph: randomFlowRunGraph,
+  flowRunHistory: randomFlowRunHistory,
+  flowRunStateHistory: randomFlowRunStateHistory,
+  graphNode: randomGraphNode,
+  id: randomId,
+  image: randomImage,
+  log: randomLog,
+  logLevel: randomLogLevel,
+  markdownCodeBlockString: randomMarkdownCodeBlockString,
+  markdownCodeSpanString: randomMarkdownCodeSpanString,
+  markdownContentString: randomMarkdownContentString,
+  markdownHeaderString: randomMarkdownHeaderString,
+  markdownQuoteString: randomMarkdownQuoteString,
+  markdownString: randomMarkdownString,
+  markdownTableString: randomMarkdownTableString,
+  notification: randomNotification,
+  notificationCreate: randomNotificationCreate,
+  noun: randomNoun,
+  number: randomNumber,
+  paragraph: randomParagraph,
+  parameters: randomParameters,
+  runName: randomRunName,
+  schedule: randomSchedule,
+  schema: randomSchema,
+  schemaProperties: randomSchemaProperties,
+  schemaProperty: randomSchemaProperty,
+  sentence: randomSentence,
+  state: randomState,
+  stateType: randomStateType,
+  string: randomString,
+  table: randomTable,
+  taskRun: randomTaskRun,
+  uiFlowRunHistory: randomUiFlowRunHistory,
+  url: randomUrl,
+  worker: randomWorker,
+  workerStatus: randomWorkerStatus,
+  workPool: randomWorkPool,
+  workPoolQueue: randomWorkPoolQueue,
+  workPoolStatus: randomWorkPoolStatus,
+  workQueue: randomWorkQueue,
+  workQueueCreate: randomWorkQueueCreate,
+  workQueueFilter: randomWorkQueueFilter,
+  workQueueHealthPolicy: randomWorkQueueHealthPolicy,
+  workQueueStatus: randomWorkQueueStatus,
+}

package/src/mocks/log.ts

@@ -0,0 +1,22 @@
+import { Log, LogLevel, logLevel } from '@/models/Log'
+import { MockFunction } from '@/services/Mocker'
+import { random, uniform } from '@/utilities/math'
+
+export const randomLogLevel: MockFunction<LogLevel, []> = function() {
+  return logLevel[uniform(0, logLevel.length - 1)]
+}
+
+export const randomLog: MockFunction<Log, [Partial<Log>?]> = function(overrides = {}) {
+  return new Log({
+    id: this.create('id'),
+    created: this.create('date'),
+    updated: this.create('date'),
+    name: `${this.create('adjective')}.${this.create('noun')}`,
+    level: this.create('logLevel'),
+    message: random() > 0.75 ? this.create('paragraph') : this.create('sentence'),
+    timestamp: this.create('date'),
+    flowRunId: this.create('id'),
+    taskRunId: this.create('id'),
+    ...overrides,
+  })
+}

package/src/mocks/markdown.ts

@@ -0,0 +1,158 @@
+import { choice } from '..'
+import { MockFunction } from '@/services/Mocker'
+import { random, uniform } from '@/utilities/math'
+
+export const randomMarkdownHeaderString: MockFunction<string, [{ level?: number }?]> = function({ level = uniform(1, 6) } = {}) {
+  return `${'#'.repeat(level)} ${this.create('noun')}`
+}
+
+export const randomMarkdownQuoteString: MockFunction<string, [{ lines?: number }?]> = function({ lines = uniform(1, 5) } = {}) {
+  const quoteLines: string[] = []
+
+  for (let i = 0; i < lines; i++) {
+    quoteLines.push(`> ${this.create('sentence')}`)
+  }
+
+  return `\n${quoteLines.join('\n')}`
+}
+
+export const randomMarkdownContentString: MockFunction<string, [{ lines?: number }?]> = function({ lines = uniform(1, 5) } = {}) {
+  const contentLines: string[] = []
+
+  for (let i = 0; i < lines; i++) {
+    const hasCodeSpan = random() > 0.95
+    let line = ''
+
+    if (hasCodeSpan) {
+      line = `${this.create('sentence')} ${this.create('markdownCodeSpanString')} ${this.create('sentence')}`
+    } else {
+      line = this.create('sentence')
+    }
+
+    contentLines.push(line)
+  }
+
+  return contentLines.join('\n')
+}
+
+export const randomMarkdownTableString: MockFunction<string, [{ rows?: number, columns?: number }?]> = function({ rows = uniform(4, 10), columns = uniform(3, 8) } = {}) {
+  const tableLines: string[] = []
+
+  const columnHeaders = []
+  const headerAlignments = []
+  for (let i = 0; i < columns; i++) {
+    const alignment = choice([':--', ':--:', '--:'])
+    columnHeaders.push(this.create('noun'))
+    headerAlignments.push(alignment)
+  }
+  tableLines.push(`| ${columnHeaders.join(' | ')} |`)
+  tableLines.push(`| ${headerAlignments.join(' | ')} |`)
+
+
+  for (let i = 0; i < rows; i++) {
+    const rowLines: string[] = []
+
+    for (let i_ = 0; i_ < columns; i_++) {
+      rowLines.push(this.create('noun'))
+    }
+
+    tableLines.push(`| ${rowLines.join(' | ')} |`)
+  }
+
+
+  return `\n${tableLines.join('\n')}\n`
+}
+
+export const randomMarkdownCodeSpanString: MockFunction<string, []> = function() {
+  return `\`${this.create('noun')}\``
+}
+
+export const randomMarkdownCodeBlockString: MockFunction<string, [{ lines?: number }?]> = function({ lines = uniform(1, 5) } = {}) {
+  const codeLines: string[] = []
+
+  for (let i = 0; i < lines; i++) {
+    codeLines.push(this.create('sentence'))
+  }
+
+  return `\`\`\`\n${codeLines.join('\n')}\n\`\`\``
+}
+
+type MarkdownType = 'header' | 'quote' | 'content' | 'code' | 'table'
+const markdownTypes: MarkdownType[] = ['header', 'quote', 'content', 'code', 'table']
+type MarkdownLine = {
+  type: MarkdownType,
+  content: string,
+  level?: number,
+}
+
+export const randomMarkdownString: MockFunction<string, [{ sections?: number }?]> = function({ sections = 5 } = {}) {
+
+  const markdownLines: MarkdownLine[] = []
+
+  markdownLines.push({
+    type: 'header',
+    content: this.create('markdownHeaderString', [{ level: 1 }]),
+    level: 1,
+  })
+
+  for (let i = 0; i < sections; i++) {
+    const lastLine: MarkdownLine | undefined = markdownLines[markdownLines.length - 1]
+    const type = choice(markdownTypes)
+
+    if (type == 'header' && i < sections - 1) {
+      let headerLevel: number = 1
+
+      if (lastLine.type == 'header' && lastLine.level && lastLine.level < 6) {
+        headerLevel = lastLine.level + 1
+      } else {
+        headerLevel = uniform(2, 5)
+      }
+
+      markdownLines.push({
+        type: 'header',
+        content: this.create('markdownHeaderString', [{ level: headerLevel }]),
+        level: headerLevel,
+      })
+
+      continue
+    }
+
+
+    if (type == 'quote') {
+      markdownLines.push({
+        type: 'quote',
+        content: this.create('markdownQuoteString'),
+      })
+
+      continue
+    }
+
+    if (type == 'table') {
+      markdownLines.push({
+        type: 'table',
+        content: this.create('markdownTableString'),
+      })
+
+      continue
+    }
+
+    if (type == 'code') {
+      markdownLines.push({
+        type: 'content',
+        content: this.create('markdownCodeBlockString'),
+      })
+
+      continue
+    }
+
+    // Default to content
+    markdownLines.push({
+      type: 'content',
+      content: this.create('markdownContentString'),
+    })
+
+    continue
+  }
+
+  return markdownLines.map(mdl => mdl.content).join('\n\n')
+}

package/src/mocks/notification.ts

@@ -0,0 +1,15 @@
+import { Notification } from '@/models/Notification'
+import { MockFunction } from '@/services/Mocker'
+
+export const randomNotification: MockFunction<Notification, [Partial<Notification>?]> = function(overrides = {}) {
+  return new Notification({
+    id: this.create('id'),
+    created: this.create('date'),
+    updated: this.create('date'),
+    isActive: this.create('boolean'),
+    stateNames: this.createMany('stateType', this.create('number', [0, 3])),
+    tags: this.createMany('noun', this.create('number', [0, 3])),
+    blockDocumentId: this.create('id'),
+    ...overrides,
+  })
+}

package/src/mocks/notificationCreate.ts

@@ -0,0 +1,14 @@
+import { NotificationCreate } from '@/models'
+import { MockFunction } from '@/services/Mocker'
+
+export const randomNotificationCreate: MockFunction<NotificationCreate, [Partial<NotificationCreate>?]> = function(overrides = {}) {
+  const { isActive, stateNames, tags, blockDocumentId } = this.create('notification')
+
+  return {
+    isActive,
+    stateNames,
+    tags,
+    blockDocumentId,
+    ...overrides,
+  }
+}

package/src/mocks/number.ts

@@ -0,0 +1,7 @@
+/* eslint-disable prefer-arrow-callback */
+import { MockFunction } from '@/services'
+import { uniform } from '@/utilities/math'
+
+export const randomNumber: MockFunction<number, [number?, number?]> = function(min = 0, max = 100) {
+  return uniform(min, max)
+}

package/src/mocks/parameters.ts

@@ -0,0 +1,69 @@
+import { mapper } from '@/services/Mapper'
+import { mocker, MockFunction } from '@/services/Mocker'
+import { SchemaStringFormats, Schema, SchemaValues } from '@/types/schemas'
+import { coinflip, uniform } from '@/utilities/math'
+
+export const randomParameters: MockFunction<Record<string, unknown>, [Record<string, unknown>?, Schema?]> = function(overrides = {}, schema: Schema = mocker.create('schema')) {
+  const parameters: Record<string, unknown> = {}
+
+  if (!schema.properties) {
+    return {}
+  }
+
+  const defaultTypeStringFormatMap: Record<Partial<typeof SchemaStringFormats[number]>, unknown> = {
+    date: this.create('date'),
+    'date-time': this.create('date'),
+    email: this.create('email'),
+    'json-string': '{}',
+    regex: '/w+/gi',
+    'time-delta': 600,
+    password: this.create('string'),
+  }
+
+
+  Object.keys(schema.properties).forEach((key) => {
+    const { type, format, default: defaultValue } = schema.properties![key]!
+
+    if (uniform(0, 10) > 8 && type !== 'object') {
+      return
+    }
+
+    let val: unknown = undefined
+
+    switch (type) {
+      case 'array':
+        val = this.createMany('string', uniform(0, 6))
+        break
+      case 'string':
+        if (coinflip(0.1)) {
+          val = format ? defaultTypeStringFormatMap[format] : this.create('sentence')
+        } else {
+          val = defaultValue
+        }
+        break
+      case 'number':
+      case 'integer':
+        val = this.create('number')
+        break
+      case 'boolean':
+        val = this.create('boolean')
+        break
+      case 'object':
+        val = '{}'
+        break
+      case 'null':
+      case undefined:
+      default:
+        break
+    }
+
+    if (typeof val !== 'undefined') {
+      parameters[key] = val
+    }
+
+  })
+
+  const values: SchemaValues = { ...parameters, ...overrides }
+
+  return mapper.map('SchemaValuesResponse', { values, schema }, 'SchemaValues')
+}

package/src/mocks/schedule.ts

@@ -0,0 +1,46 @@
+import { IntervalSchedule, CronSchedule, RRuleSchedule, Schedule } from '@/models'
+import { MockFunction } from '@/services/Mocker'
+import { choice } from '@/utilities/arrays'
+import { uniform } from '@/utilities/math'
+
+const intervalSchedules = [1, 30, 60, 900, 1800, 3600, 86400]
+
+const cronSchedules = [
+  '* * * * *',
+  '0 0 * * *',
+  '@daily',
+  '@hourly',
+]
+
+const rruleSchedules = [
+  'DTSTART:20120201T023000Z RRULE:FREQ=MONTHLY;COUNT=5',
+  'DTSTART:20120201T023000Z RRULE:FREQ=DAILY;COUNT=30',
+]
+
+type ScheduleType = 'interval' | 'cron' | 'rrule'
+
+export const randomSchedule: MockFunction<Schedule, [{ type?: ScheduleType }?, Partial<Schedule>?]> = function({ type } = {}) {
+  let schedule: Schedule
+
+  const interval = intervalSchedules[uniform(0, intervalSchedules.length - 1)]
+  const cron = cronSchedules[uniform(0, cronSchedules.length - 1)]
+  const rrule = rruleSchedules[uniform(0, rruleSchedules.length - 1)]
+
+  const randomScheduleType = choice<ScheduleType>(['interval', 'cron', 'rrule'])
+
+  switch (type ?? randomScheduleType) {
+    case 'interval':
+      schedule = new IntervalSchedule({ interval, timezone: null, anchorDate: this.create('date') })
+      break
+    case 'cron':
+      schedule = new CronSchedule({ cron, timezone: null, dayOr: false })
+      break
+    case 'rrule':
+      schedule = new RRuleSchedule({ rrule, timezone: null })
+      break
+    default:
+      throw new Error(`randomSchedule missing case for ${type ?? randomScheduleType}`)
+  }
+
+  return schedule
+}

package/src/mocks/schemas.ts

@@ -0,0 +1,68 @@
+import { SchemaResponse } from '@/models'
+import { mapper, MockFunction } from '@/services'
+import { SchemaStringFormats, SchemaTypes, Schema, SchemaProperty, SchemaProperties } from '@/types/schemas'
+import { kebabCase } from '@/utilities'
+import { choice } from '@/utilities/arrays'
+import { uniform } from '@/utilities/math'
+
+export const randomSchemaProperty: MockFunction<SchemaProperty, [SchemaProperty?]> = function(overrides = {}) {
+  // propertyTypeFirstDraw lets us reduce the number of `null` type definitions by half
+  const propertyTypeFirstDraw = choice(SchemaTypes)
+  const propertyType = propertyTypeFirstDraw == 'null' ? choice(SchemaTypes) : propertyTypeFirstDraw
+  const propertyFormat = propertyType == 'string' && uniform(0, 10) > 8 ? choice(SchemaStringFormats) : undefined
+
+  const defaultTypeStringFormatMap: Record<Partial<typeof SchemaStringFormats[number]>, unknown> = {
+    date: this.create('date'),
+    'date-time': this.create('date'),
+    email: this.create('email'),
+    'json-string': '{}',
+    regex: '/w+/gi',
+    'time-delta': 600,
+    password: this.create('string'),
+  }
+
+  const defaultTypeMap: Record<typeof SchemaTypes[number], unknown> = {
+    null: null,
+    array: [],
+    string: propertyFormat ? defaultTypeStringFormatMap[propertyFormat] : undefined,
+    boolean: false,
+    integer: 1,
+    number: 1.6,
+    object: {},
+    block: null,
+  }
+
+  return {
+    title: this.create('noun'),
+    type: propertyType,
+    description: uniform(0, 10) > 7 ? this.create('sentence') : undefined,
+    default: propertyType == 'object' || uniform(0, 10) > 4 ? defaultTypeMap[propertyType] : undefined,
+    properties: propertyType === 'object' ? this.create('schemaProperties') : undefined,
+    ...propertyFormat ? { format: propertyFormat } : {},
+    ...overrides,
+  }
+}
+
+export const randomSchema: MockFunction<Schema, [Schema?]> = function(overrides = {}) {
+  const schema: SchemaResponse = {
+    title: 'Open API Schema',
+    type: 'object',
+    properties: this.create('schemaProperties'),
+    ...overrides,
+  }
+
+  return mapper.map('SchemaResponse', schema, 'Schema')
+}
+
+export const randomSchemaProperties: MockFunction<SchemaProperties, [SchemaProperties?]> = function(overrides = {}) {
+  const properties = this.createMany('schemaProperty', this.create('number', [1, 5])).reduce<Schema['properties']>((properties = {}, property) => {
+    properties[kebabCase(property.title!)] = property
+
+    return properties
+  }, {})
+
+  return {
+    ...properties,
+    ...overrides,
+  }
+}

package/src/mocks/sentences/generateText.ts

@@ -0,0 +1,103 @@
+// adapted from https://github.com/ndaidong/txtgen/blob/main/src/main.js
+
+import {
+  sentenceTemplates,
+  phrases
+} from '@/mocks/sentences/sample'
+
+import {
+  rand,
+  pickLastPunc,
+  generator,
+  GeneratorKey
+} from '@/mocks/sentences/utils'
+import { uniform, random } from '@/utilities/math'
+
+
+export {
+  addNouns,
+  addAdjectives,
+  addTemplates,
+  setNouns,
+  setAdjectives,
+  setTemplates,
+  getNouns,
+  getAdjectives,
+  getTemplates
+} from './sample'
+
+const actions: GeneratorKey[] = [
+  'noun', 'aNoun', 'nouns',
+  'adjective', 'anAdjective',
+]
+
+const trim = (str: string): string => {
+  return str.replace(/^[\s\xa0]+|[\s\xa0]+$/g, '')
+    .replace(/\r?\n|\r/g, ' ')
+    .replace(/\s\s+|\r/g, ' ')
+}
+
+const make = (template: string): string => {
+  let sentence = template
+  const occurrences = template.match(/\{\{(.+?)\}\}/g)
+
+  if (occurrences?.length) {
+    for (const occurrence of occurrences) {
+      const action = trim(occurrence.replace('{{', '').replace('}}', '')) as GeneratorKey
+
+      let result: string = ''
+      if (actions.includes(action)) {
+        result = generator[action]()
+      }
+
+      sentence = sentence.replace(occurrence, result)
+    }
+  }
+  return sentence
+}
+
+const randomStartingPhrase = (): string => {
+  if (random() < 0.33) {
+    return rand(phrases)
+  }
+  return ''
+}
+
+const makeSentenceFromTemplate = (): string => {
+  return make(rand(sentenceTemplates))
+}
+
+export const sentence = (): string => {
+  const phrase = randomStartingPhrase()
+  let str = phrase + makeSentenceFromTemplate()
+  str = str.charAt(0).toUpperCase() + str.slice(1)
+  str += pickLastPunc()
+  return str
+}
+
+export const paragraph = (len = 0): string => {
+  if (!len) {
+    len = uniform(3, 10)
+  }
+  const minLength = Math.min(len, 15)
+  const sentences = []
+
+  while (sentences.length < minLength) {
+    const str = sentence()
+    sentences.push(str)
+  }
+  return sentences.join(' ')
+}
+
+export const article = (len = 0): string => {
+  if (!len) {
+    len = uniform(3, 10)
+  }
+  const minLength = Math.min(len, 15)
+  const sentences = []
+  while (sentences.length < minLength) {
+    const str = paragraph()
+    sentences.push(str)
+  }
+  return sentences.join('\n\n')
+}