@prefecthq/prefect-ui-library 2.9.18 → 2.10.0

package/src/services/WorkspaceWorkQueuesApi.ts

@@ -0,0 +1,98 @@
+import { FlowRun, FlowRunResponse, WorkQueueCreate, WorkQueueEdit, WorkQueueResponse, WorkQueueStatus, WorkQueueStatusResponse } from '@/models'
+import { WorkQueuesFilter } from '@/models/Filters'
+import { WorkQueue } from '@/models/WorkQueue'
+import { BatchProcessor } from '@/services/BatchProcessor'
+import { mapper } from '@/services/Mapper'
+import { WorkspaceApi } from '@/services/WorkspaceApi'
+import { toMap } from '@/utilities'
+
+export class WorkspaceWorkQueuesApi extends WorkspaceApi {
+
+  protected override routePrefix = '/work_queues'
+
+  private readonly isBatcher = new BatchProcessor<string, WorkQueue>(async ids => {
+    if (ids.length === 1) {
+      const [id] = ids
+      const { data } = await this.get<WorkQueueResponse>(`/${id}`)
+
+      return () => mapper.map('WorkQueueResponse', data, 'WorkQueue')
+    }
+
+    const workQueues = await this.getWorkQueues({
+      workQueues: {
+        id: ids,
+      },
+    })
+
+    return toMap(workQueues, 'id')
+  }, { maxBatchSize: 200 })
+
+  private readonly nameBatcher = new BatchProcessor<string, WorkQueue>(async names => {
+    if (names.length === 1) {
+      const [name] = names
+      const { data } = await this.get<WorkQueueResponse>(`/name/${name}`)
+
+      return () => mapper.map('WorkQueueResponse', data, 'WorkQueue')
+    }
+
+    const workQueues = await this.getWorkQueues({
+      workQueues: {
+        name: names,
+      },
+    })
+
+    return toMap(workQueues, 'id')
+  }, { maxBatchSize: 200 })
+
+  public getWorkQueue(workQueueId: string): Promise<WorkQueue> {
+    return this.isBatcher.batch(workQueueId)
+  }
+
+  public getWorkQueueByName(workQueueName: string): Promise<WorkQueue> {
+    return this.nameBatcher.batch(workQueueName)
+  }
+
+  public async getWorkQueues(filter: WorkQueuesFilter): Promise<WorkQueue[]> {
+    const request = mapper.map('WorkQueuesFilter', filter, 'WorkQueuesFilterRequest')
+    const { data } = await this.post<WorkQueueResponse[]>('/filter', request)
+
+    return mapper.map('WorkQueueResponse', data, 'WorkQueue')
+  }
+
+  public async createWorkQueue(request: WorkQueueCreate): Promise<WorkQueue> {
+    const body = mapper.map('WorkQueueCreate', request, 'WorkQueueCreateRequest')
+    const { data } = await this.post<WorkQueueResponse>('/', body)
+
+    return mapper.map('WorkQueueResponse', data, 'WorkQueue')
+  }
+
+  public pauseWorkQueue(id: string): Promise<void> {
+    return this.patch(`/${id}`, { 'is_paused': true })
+  }
+
+  public resumeWorkQueue(id: string): Promise<void> {
+    return this.patch(`/${id}`, { 'is_paused': false })
+  }
+
+  public updateWorkQueue(id: string, request: WorkQueueEdit): Promise<void> {
+    const body = mapper.map('WorkQueueEdit', request, 'WorkQueueEditRequest')
+
+    return this.patch(`/${id}`, body)
+  }
+
+  public deleteWorkQueue(id: string): Promise<void> {
+    return this.delete(`/${id}`)
+  }
+
+  public async getRuns(id: string): Promise<FlowRun[]> {
+    const { data } = await this.post<FlowRunResponse[]>(`/${id}/get_runs`)
+
+    return mapper.map('FlowRunResponse', data, 'FlowRun')
+  }
+
+  public async getWorkQueueStatus(id: string): Promise<WorkQueueStatus> {
+    const { data } = await this.get<WorkQueueStatusResponse>(`/${id}/status`)
+
+    return mapper.map('WorkQueueStatusResponse', data, 'WorkQueueStatus')
+  }
+}

package/src/services/can.ts

@@ -0,0 +1,110 @@
+import { InjectionKey, ref } from 'vue'
+import { MaybeRef } from '@/types/reactivity'
+
+export const workspaceFeatureFlags = [
+  'access:deploymentStatus',
+  'access:workQueueStatus',
+  'access:flowRunInfraOverrides',
+  'access:deploymentScheduleFlowRunInfraOverrides',
+] as const satisfies Readonly<`access:${string}`[]>
+
+export type WorkspaceFeatureFlag = typeof workspaceFeatureFlags[number]
+
+export const workspacePermissions = [
+  'create:artifact',
+  'create:automation',
+  'create:block',
+  'create:concurrency_limit',
+  'create:deployment',
+  'create:flow_run',
+  'create:flow',
+  'create:log',
+  'create:notification_policy',
+  'create:saved_search',
+  'create:task_run',
+  'create:variable',
+  'create:work_queue',
+  'create:work_pool_queue',
+  'create:work_pool',
+  'create:workspace_bot_access',
+  'create:workspace_user_access',
+  'delete:artifact',
+  'delete:automation',
+  'delete:block',
+  'delete:concurrency_limit',
+  'delete:deployment',
+  'delete:flow_run',
+  'delete:flow',
+  'delete:notification_policy',
+  'delete:saved_search',
+  'delete:task_run',
+  'delete:work_queue',
+  'delete:work_pool_queue',
+  'delete:work_pool',
+  'delete:workspace_bot_access',
+  'delete:workspace_user_access',
+  'delete:variable',
+  'read:artifact',
+  'read:automation',
+  'read:block',
+  'read:concurrency_limit',
+  'read:deployment',
+  'read:flow_run',
+  'read:flow',
+  'read:log',
+  'read:notification_policy',
+  'read:saved_search',
+  'read:task_run',
+  'read:variable',
+  'read:work_queue',
+  'read:work_pool_queue',
+  'read:work_pool',
+  'read:workspace_bot_access',
+  'read:workspace_settings',
+  'read:workspace_user_access',
+  'run:deployment',
+  'update:automation',
+  'update:block',
+  'update:concurrency_limit',
+  'update:deployment',
+  'update:flow_run',
+  'update:flow',
+  'update:notification_policy',
+  'update:task_run',
+  'update:variable',
+  'update:work_queue',
+  'update:work_pool_queue',
+  'update:work_pool',
+  'update:workspace_bot_access',
+  'update:workspace_settings',
+  'update:workspace_user_access',
+  'update:workspace',
+] as const
+export type WorkspacePermission = typeof workspacePermissions[number]
+
+export type PermissionValue = boolean | undefined
+export type PermissionVerb<T extends string> = T extends `${infer Action}:${string}` ? Action : never
+export type Can<T extends string> = {
+  [K in PermissionVerb<T>]:
+  Extract<T, `${K}:${string}`> extends `${string}:${infer Key}`
+    ? Record<Key, PermissionValue>
+    : never
+}
+export type PermissionCheck<T> = (permission: T) => PermissionValue
+
+export function createCan<T extends string>(permissions: MaybeRef<Readonly<T[]>>): Can<T> {
+  const permissionsRef = ref(permissions)
+
+  return new Proxy({} as Can<T>, {
+    get(target, verb) {
+      return new Proxy({}, {
+        get(target, key) {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          return permissionsRef.value.includes(`${verb.toString()}:${key.toString()}` as any)
+        },
+      })
+    },
+  })
+}
+
+export const canKey: InjectionKey<Can<WorkspacePermission | WorkspaceFeatureFlag>> = Symbol('canInjectionKey')

package/src/services/index.ts

@@ -0,0 +1,33 @@
+export * from './Api'
+export * from './BatchProcessor'
+export * from './can'
+export * from './CollectionsApi'
+export * from './HealthApi'
+export * from './Mapper'
+export * from './Mocker'
+export * from './RouteGuardExecutioner'
+export * from './schemas'
+export * from './SimpleIdManager'
+export * from './storage'
+export * from './UiApi'
+export * from './WorkspaceApi'
+export * from './WorkspaceArtifactsApi'
+export * from './WorkspaceAutomationsApi'
+export * from './WorkspaceBlockCapabilitiesApi'
+export * from './WorkspaceBlockDocumentsApi'
+export * from './WorkspaceBlockSchemasApi'
+export * from './WorkspaceBlockTypesApi'
+export * from './WorkspaceConcurrencyLimitsApi'
+export * from './WorkspaceConcurrencyLimitsV2API'
+export * from './WorkspaceDeploymentsApi'
+export * from './WorkspaceFlowRunsApi'
+export * from './WorkspaceFlowsApi'
+export * from './WorkspaceLogsApi'
+export * from './WorkspaceNotificationsApi'
+export * from './WorkspaceSavedSearchesApi'
+export * from './WorkspaceTaskRunsApi'
+export * from './WorkspaceVariablesApi'
+export * from './WorkspaceWorkPoolQueuesApi'
+export * from './WorkspaceWorkPoolsApi'
+export * from './WorkspaceWorkPoolWorkersApi'
+export * from './WorkspaceWorkQueuesApi'

package/src/services/schemas/constants.spec.ts

@@ -0,0 +1,9 @@
+import { describe, expect, it } from 'vitest'
+import { MAX_SCHEMA_PROPERTY_LEVEL } from '@/services/schemas/constants'
+
+
+describe('constants', () => {
+  it('exports MAX_SCHEMA_PROPERTY_LEVEL', () => {
+    expect(MAX_SCHEMA_PROPERTY_LEVEL).toBe(2)
+  })
+})

package/src/services/schemas/constants.ts

@@ -0,0 +1 @@
+export const MAX_SCHEMA_PROPERTY_LEVEL = 2

package/src/services/schemas/index.ts

@@ -0,0 +1,4 @@
+export * from './constants'
+export * from './properties'
+export * from './resolvers'
+export * from './utilities'

package/src/services/schemas/properties/SchemaPropertyAny.ts

@@ -0,0 +1,113 @@
+import { JsonInput } from '@/components'
+import { getSchemaValueDefinition, schemaPropertyServiceFactory } from '@/services/schemas'
+import { SchemaPropertyService } from '@/services/schemas/properties/SchemaPropertyService'
+import { getSchemaPropertyDefaultValue, SchemaPropertyComponentWithProps } from '@/services/schemas/utilities'
+import { SchemaValue } from '@/types/schemas'
+import { isEmptyObject, sameValue } from '@/utilities'
+import { jsonSafeParse } from '@/utilities/jsonSafeParse'
+import { jsonSafeStringify } from '@/utilities/jsonSafeStringify'
+
+export class SchemaPropertyAny extends SchemaPropertyService {
+  protected get default(): unknown {
+    let defaultValue: unknown = null
+
+    if (this.has('default')) {
+      defaultValue = this.property.default
+    } else if (this.has('anyOf') || this.has('allOf')) {
+      defaultValue = this.getDefaultValueForFirstDefinition()
+    }
+
+    if (this.componentIs(JsonInput)) {
+      return jsonSafeStringify(defaultValue).value ?? ''
+    }
+
+    return defaultValue
+  }
+
+  protected get component(): SchemaPropertyComponentWithProps {
+    // if either of these exist let the AnyOf and AllOf components take over
+    if (this.has('anyOf') || this.has('allOf')) {
+      return null
+    }
+
+    return this.withProps(JsonInput)
+  }
+
+  protected request(value: SchemaValue): unknown {
+    if (this.has('anyOf') || this.has('allOf')) {
+      return this.referenceRequest(value)
+    }
+
+    const { value: request } = jsonSafeParse(value)
+
+    return request
+  }
+
+  protected response(value: SchemaValue): unknown {
+    if (this.has('anyOf') || this.has('allOf')) {
+      return this.referenceResponse(value)
+    }
+
+    const { value: response } = jsonSafeStringify(value)
+
+    return response
+  }
+
+  private referenceResponse(value: SchemaValue): SchemaValue {
+    if (value === undefined) {
+      return this.invalid()
+    }
+
+    const definition = getSchemaValueDefinition(this.property, value)
+
+    if (definition === null) {
+      return this.invalid()
+    }
+
+    const service = schemaPropertyServiceFactory(definition, this.level)
+    const mapped = service.mapResponseValue(value)
+
+    return mapped
+
+  }
+
+  private referenceRequest(value: SchemaValue): SchemaValue {
+    if (this.isDefaultValueForReference(value)) {
+      return undefined
+    }
+
+    const definition = getSchemaValueDefinition(this.property, value)
+
+    if (definition === null) {
+      return value
+    }
+
+    const service = schemaPropertyServiceFactory(definition, this.level)
+    const mapped = service.mapRequestValue(value)
+
+    if (isEmptyObject(mapped)) {
+      return undefined
+    }
+
+    return mapped
+
+  }
+
+  private getDefaultValueForFirstDefinition(): SchemaValue {
+    const [firstDefinition] = this.property.anyOf ?? this.property.allOf ?? []
+
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (firstDefinition) {
+      return getSchemaPropertyDefaultValue(firstDefinition)
+    }
+
+    throw new Error('Could not find first definition for schema property')
+  }
+
+  private isDefaultValueForReference(value: SchemaValue): boolean {
+    const definitions = this.property.anyOf ?? this.property.allOf ?? []
+
+    return definitions.some(definition => sameValue(value, getSchemaPropertyDefaultValue(definition)))
+  }
+
+}

package/src/services/schemas/properties/SchemaPropertyArray.ts

@@ -0,0 +1,62 @@
+import { PCombobox } from '@prefecthq/prefect-design'
+import { JsonInput } from '@/components'
+import { SchemaPropertyService } from '@/services/schemas/properties/SchemaPropertyService'
+import { SchemaPropertyComponentWithProps } from '@/services/schemas/utilities'
+import { SchemaValue } from '@/types/schemas'
+import { isNullish } from '@/utilities'
+import { parseUnknownJson } from '@/utilities/parseUnknownJson'
+import { stringifyUnknownJson } from '@/utilities/stringifyUnknownJson'
+import { isEmptyString } from '@/utilities/strings'
+
+export class SchemaPropertyArray extends SchemaPropertyService {
+
+  protected get component(): SchemaPropertyComponentWithProps {
+    const options = this.getSelectOptions()
+
+    if (options.length) {
+      return this.withProps(PCombobox, { options })
+    }
+
+    return this.withProps(JsonInput)
+  }
+
+  protected get default(): unknown {
+    if (this.componentIs(JsonInput)) {
+      return stringifyUnknownJson(this.property.default) ?? null
+    }
+
+    return this.property.default ?? []
+  }
+
+  protected request(value: SchemaValue): unknown {
+    if (this.componentIs(JsonInput)) {
+      if (isEmptyString(value)) {
+        return undefined
+      }
+
+      return parseUnknownJson(value)
+    }
+
+    return value
+  }
+
+  protected response(value: SchemaValue): unknown {
+    if (isNullish(value)) {
+      return this.invalid()
+    }
+
+    if (this.componentIs(JsonInput)) {
+      if (typeof value === 'string') {
+        return value
+      }
+
+      return stringifyUnknownJson(value)
+    }
+
+    if (!Array.isArray(value)) {
+      return this.invalid()
+    }
+
+    return value
+  }
+}

package/src/services/schemas/properties/SchemaPropertyBlock.ts

@@ -0,0 +1,54 @@
+import BlockDocumentInput from '@/components/BlockDocumentInput.vue'
+import { BlockDocumentReferenceValue, BlockDocumentValue, isBlockDocumentReferenceValue, isBlockDocumentValue } from '@/models/api/BlockDocumentCreateRequest'
+import { SchemaPropertyService } from '@/services/schemas/properties/SchemaPropertyService'
+import { SchemaPropertyComponentWithProps } from '@/services/schemas/utilities'
+import { SchemaValue } from '@/types/schemas'
+
+export class SchemaPropertyBlock extends SchemaPropertyService {
+
+  protected readonly default: BlockDocumentValue = {
+    blockTypeSlug: this.property.blockTypeSlug!,
+    blockDocumentId: this.getDefaultBlockDocumentId(),
+  }
+
+  protected override get component(): SchemaPropertyComponentWithProps {
+    return this.withProps(BlockDocumentInput, {
+      blockTypeSlug: this.property.blockTypeSlug!,
+    })
+  }
+
+  protected request(value: SchemaValue): unknown {
+    if (!isBlockDocumentValue(value)) {
+      return value
+    }
+
+    if (!value.blockDocumentId) {
+      return undefined
+    }
+
+    const request: BlockDocumentReferenceValue = {
+      $ref: {
+        'block_document_id': value.blockDocumentId!,
+      },
+    }
+
+    return request
+  }
+
+  protected response(value: SchemaValue): unknown {
+    if (isBlockDocumentValue(value)) {
+      return value
+    }
+
+    this.invalid()
+  }
+
+  private getDefaultBlockDocumentId(): string | null {
+    if (isBlockDocumentReferenceValue(this.property.default)) {
+      return this.property.default.$ref.block_document_id
+    }
+
+    return null
+  }
+
+}

package/src/services/schemas/properties/SchemaPropertyBoolean.ts

@@ -0,0 +1,49 @@
+import { PToggle } from '@prefecthq/prefect-design'
+import { SchemaPropertyService } from '@/services/schemas/properties/SchemaPropertyService'
+import { SchemaPropertyComponentWithProps } from '@/services/schemas/utilities'
+import { SchemaValue } from '@/types/schemas'
+import { isNullish } from '@/utilities'
+
+export class SchemaPropertyBoolean extends SchemaPropertyService {
+
+  protected get default(): unknown {
+    return this.property.default ?? null
+  }
+
+  public mapRequestValue(value: SchemaValue): SchemaValue | undefined {
+    const mappedValue = this.request(value)
+
+    if (isNullish(mappedValue)) {
+      return undefined
+    }
+
+    return mappedValue
+  }
+
+  protected override get component(): SchemaPropertyComponentWithProps {
+    return this.withProps(PToggle)
+  }
+
+  protected override request(value: SchemaValue): unknown {
+    return value
+  }
+
+  protected override response(value: SchemaValue): unknown {
+    if (typeof value === 'string') {
+      if (value.toLowerCase() === 'true') {
+        return true
+      }
+
+      if (value.toLowerCase() === 'false') {
+        return false
+      }
+    }
+
+    if (typeof value !== 'boolean') {
+      return this.invalid()
+    }
+
+    return value
+  }
+
+}

package/src/services/schemas/properties/SchemaPropertyInteger.ts

@@ -0,0 +1,36 @@
+import { PNumberInput, PCombobox } from '@prefecthq/prefect-design'
+import { SchemaPropertyService } from '@/services/schemas/properties/SchemaPropertyService'
+import { SchemaPropertyComponentWithProps } from '@/services/schemas/utilities'
+import { SchemaValue } from '@/types/schemas'
+
+export class SchemaPropertyInteger extends SchemaPropertyService {
+
+  protected get default(): unknown {
+    return this.property.default ?? null
+  }
+
+  protected override get component(): SchemaPropertyComponentWithProps {
+    if (this.has('enum')) {
+      return this.withProps(PCombobox, {
+        options: this.getSelectOptions(),
+      })
+    }
+
+    return this.withProps(PNumberInput)
+  }
+
+  protected request(value: SchemaValue): unknown {
+    return value
+  }
+
+  protected response(value: SchemaValue): unknown {
+    const result = parseInt(value as string)
+
+    if (isNaN(result)) {
+      return this.invalid()
+    }
+
+    return result
+  }
+
+}

package/src/services/schemas/properties/SchemaPropertyNull.ts

@@ -0,0 +1,16 @@
+import { SchemaPropertyService } from '@/services/schemas/properties/SchemaPropertyService'
+import { SchemaValue } from '@/types/schemas'
+
+export class SchemaPropertyNone extends SchemaPropertyService {
+
+  public readonly component = null
+  public readonly default = undefined
+
+  protected request(value: SchemaValue): unknown {
+    return value
+  }
+
+  protected response(value: SchemaPropertyNone): unknown {
+    return value
+  }
+}

package/src/services/schemas/properties/SchemaPropertyNumber.ts

@@ -0,0 +1,42 @@
+import { PNumberInput, PCombobox } from '@prefecthq/prefect-design'
+import { SchemaPropertyService } from '@/services/schemas/properties/SchemaPropertyService'
+import { SchemaPropertyComponentWithProps } from '@/services/schemas/utilities'
+import { SchemaPropertyInputAttrs, SchemaValue } from '@/types/schemas'
+
+export class SchemaPropertyNumber extends SchemaPropertyService {
+
+  protected get default(): unknown {
+    return this.property.default ?? null
+  }
+
+  protected override get component(): SchemaPropertyComponentWithProps {
+    if (this.has('enum')) {
+      return this.withProps(PCombobox, {
+        options: this.getSelectOptions(),
+      })
+    }
+
+    return this.withProps(PNumberInput)
+  }
+
+  protected get attrs(): SchemaPropertyInputAttrs {
+    return {
+      step: 'any',
+    }
+  }
+
+  protected request(value: SchemaValue): unknown {
+    return value
+  }
+
+  protected response(value: SchemaValue): unknown {
+    const result = parseFloat(value as string)
+
+    if (isNaN(result)) {
+      return this.invalid()
+    }
+
+    return result
+  }
+
+}