@oomol-lab/open-flow 0.1.0-beta.73 → 0.1.0-beta.75

package/src/base/common/json.ts

@@ -0,0 +1,90 @@
+export type JsonValue = null | boolean | number | string | readonly JsonValue[] | JsonObject
+
+export type JsonObject = { readonly [key: string]: JsonValue }
+
+type Frame = {
+  readonly value: object
+  readonly keys: readonly (string | symbol)[]
+  readonly arrayLength: number | undefined
+  index: number
+}
+
+function hasJsonShape(root: unknown): boolean {
+  if (root === null || typeof root == 'boolean' || typeof root == 'string') return true
+  if (typeof root == 'number') return Number.isFinite(root)
+  if (typeof root != 'object') return false
+
+  const ancestors = new Set<object>()
+  const pending: Frame[] = []
+  let value = root
+
+  traversal: while (true) {
+    let keys: readonly (string | symbol)[]
+    let arrayLength: number | undefined
+    if (Array.isArray(value)) {
+      arrayLength = value.length
+      keys = Reflect.ownKeys(value)
+      if (keys.length != arrayLength + 1) return false
+    } else {
+      const prototype = Reflect.getPrototypeOf(value)
+      if (prototype != Object.prototype && prototype != null) return false
+      keys = Reflect.ownKeys(value)
+      arrayLength = undefined
+    }
+    ancestors.add(value)
+
+    let index = 0
+    while (true) {
+      if (index >= keys.length) {
+        ancestors.delete(value)
+        const parent = pending.pop()
+        if (parent === undefined) return true
+        value = parent.value
+        keys = parent.keys
+        arrayLength = parent.arrayLength
+        index = parent.index
+        continue
+      }
+
+      const key = keys[index++]!
+      if (arrayLength !== undefined) {
+        if (key == 'length') continue
+        if (typeof key != 'string') return false
+        const arrayIndex = Number(key)
+        if (!Number.isSafeInteger(arrayIndex) || arrayIndex < 0 || arrayIndex >= arrayLength || String(arrayIndex) != key) return false
+      } else if (typeof key != 'string') {
+        return false
+      }
+
+      const descriptor = Reflect.getOwnPropertyDescriptor(value, key)
+      if (descriptor?.enumerable != true || !Object.hasOwn(descriptor, 'value')) return false
+      const child: unknown = descriptor.value
+      if (child === null || typeof child == 'boolean' || typeof child == 'string') continue
+      if (typeof child == 'number') {
+        if (!Number.isFinite(child)) return false
+        continue
+      }
+      if (typeof child != 'object' || ancestors.has(child)) return false
+
+      pending.push({ value, keys, arrayLength, index })
+      value = child
+      continue traversal
+    }
+  }
+}
+
+export function isJsonValue(value: unknown): value is JsonValue {
+  try {
+    return hasJsonShape(value)
+  } catch {
+    return false
+  }
+}
+
+export function isJsonObject(value: unknown): value is JsonObject {
+  try {
+    return value != null && typeof value == 'object' && !Array.isArray(value) && hasJsonShape(value)
+  } catch {
+    return false
+  }
+}

package/src/canvas/common/commands.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod'
+
+export const canvasMinZoom = 0.1
+export const canvasMaxZoom = 3
+
+/** Transient operations on each connected canvas's own viewport. */
+export const canvasCommandSchema = z.discriminatedUnion('type', [
+  z.strictObject({ type: z.literal('focus'), nodeId: z.string().min(1) }),
+  z.strictObject({ type: z.literal('zoom'), zoom: z.number().min(canvasMinZoom).max(canvasMaxZoom) }),
+  z.strictObject({ type: z.literal('pan'), dx: z.number(), dy: z.number() }),
+  z.strictObject({ type: z.literal('fit') }),
+])
+
+export type CanvasCommand = z.infer<typeof canvasCommandSchema>
+export type CanvasCommandSubscriber = (execute: (command: CanvasCommand) => void) => () => void

package/src/connector/common/actionSchema.ts

@@ -0,0 +1,168 @@
+import { toPlainObject } from '@wopjs/cast'
+
+export interface ConnectorActionPorts {
+  readonly inputs: readonly {
+    readonly description?: string
+    readonly handle: string
+    readonly json_schema: unknown
+    readonly nullable: boolean
+    readonly value?: unknown
+  }[]
+  readonly initialInputs: readonly { readonly handle: string; readonly value: unknown }[]
+  readonly outputs: readonly {
+    readonly description?: string
+    readonly handle: string
+    readonly json_schema: unknown
+    readonly nullable: boolean
+  }[]
+}
+
+export interface ConnectorRuntimeInputPort {
+  readonly handle: string
+  readonly jsonSchema: unknown
+  readonly nullable: boolean
+}
+
+export function connectorActionPorts(inputSchema: unknown, outputSchema: unknown): ConnectorActionPorts {
+  const inputs = inputPorts(inputSchema)
+  return {
+    inputs,
+    initialInputs: inputs.flatMap((input) => (input.value === undefined ? [] : [{ handle: input.handle, value: input.value }])),
+    outputs: outputPorts(outputSchema),
+  }
+}
+
+export function normalizeConnectorRuntimeInputs<Value>(
+  ports: readonly ConnectorRuntimeInputPort[],
+  inputs: Readonly<Record<string, Value>>,
+): Readonly<Record<string, Value>> {
+  const definitions: ReadonlyMap<string, ConnectorRuntimeInputPort> = new Map(ports.map((port) => [port.handle, port]))
+  const result: Record<string, Value> = {}
+  for (const [handle, value] of Object.entries(inputs) as [string, Value][]) {
+    const port = definitions.get(handle)
+    if (value == null && port?.nullable == true && !schemaAllowsNull(port.jsonSchema)) continue
+    result[handle] = value
+  }
+  return result
+}
+
+function inputPorts(schema: unknown): ConnectorActionPorts['inputs'] {
+  const root = toPlainObject(schema)
+  if (root == null || (root.type != 'object' && root.properties == null)) {
+    throw new Error('Connector action inputSchema must be an object schema.')
+  }
+  const properties = toPlainObject(root.properties)
+  if (properties == null) return []
+  const required = stringSet(root.required)
+  return Object.entries(properties).map(([handle, propertySchema]) => {
+    const isRequired = required.has(handle)
+    const nullable = !isRequired || schemaAllowsNull(propertySchema, root)
+    return {
+      description: schemaDescription(root, propertySchema),
+      handle,
+      json_schema: propertySchemaWithDefinitions(root, propertySchema),
+      nullable,
+      value: schemaDefault(root, propertySchema, nullable),
+    }
+  })
+}
+
+export function connectorOutputMode(schema: unknown): 'fields' | 'value' {
+  const root = toPlainObject(schema)
+  const properties = toPlainObject(root?.properties)
+  return (properties != null && Object.keys(properties).length > 0) || (root?.type == 'object' && root.additionalProperties === false) ? 'fields' : 'value'
+}
+
+function outputPorts(schema: unknown): ConnectorActionPorts['outputs'] {
+  const root = toPlainObject(schema)
+  if (connectorOutputMode(schema) == 'value') {
+    return [{ description: schemaDescription(root, schema), handle: 'output', json_schema: schema, nullable: schemaAllowsNull(schema) }]
+  }
+  const properties = toPlainObject(root?.properties) ?? {}
+  const required = stringSet(root?.required)
+  return Object.entries(properties).map(([handle, propertySchema]) => ({
+    description: schemaDescription(root, propertySchema),
+    handle,
+    json_schema: propertySchemaWithDefinitions(root!, propertySchema),
+    nullable: !required.has(handle) || schemaAllowsNull(propertySchema, root),
+  }))
+}
+
+function propertySchemaWithDefinitions(root: Record<string, unknown>, schema: unknown): unknown {
+  const property = toPlainObject(schema)
+  if (property == null) return schema
+  const result: Record<string, unknown> = Object.assign({}, property)
+  if (result.$defs == null && root.$defs != null) result.$defs = root.$defs
+  if (result.definitions == null && root.definitions != null) result.definitions = root.definitions
+  return result
+}
+
+function schemaDescription(root: unknown, schema: unknown): string | undefined {
+  for (const object of referencedSchemas(root, schema)) {
+    if (typeof object.description == 'string') return object.description
+  }
+  return undefined
+}
+
+function schemaDefault(root: unknown, schema: unknown, nullable: boolean): unknown {
+  for (const object of referencedSchemas(root, schema)) {
+    if (Object.hasOwn(object, 'default')) return object.default
+  }
+  return nullable ? null : undefined
+}
+
+function stringSet(value: unknown): ReadonlySet<string> {
+  if (!Array.isArray(value)) return new Set()
+  return new Set(value.filter((item): item is string => typeof item == 'string'))
+}
+
+function schemaAllowsNull(schema: unknown, root: unknown = schema, references: ReadonlySet<string> = new Set()): boolean {
+  const object = toPlainObject(schema)
+  if (object == null) return false
+  if (Object.hasOwn(object, 'type')) {
+    return object.type == 'null' || (Array.isArray(object.type) && object.type.includes('null'))
+  }
+  if (Object.hasOwn(object, 'enum')) return Array.isArray(object.enum) && object.enum.includes(null)
+  for (const key of ['anyOf', 'oneOf'] as const) {
+    if (Object.hasOwn(object, key)) {
+      return Array.isArray(object[key]) && object[key].some((item) => schemaAllowsNull(item, root, references))
+    }
+  }
+  const reference = typeof object.$ref == 'string' ? object.$ref : undefined
+  if (reference == null || references.has(reference)) return false
+  const target = resolveLocalReference(root, reference)
+  if (target === undefined) return false
+  const nextReferences = new Set(references)
+  nextReferences.add(reference)
+  return schemaAllowsNull(target, root, nextReferences)
+}
+
+function referencedSchemas(root: unknown, schema: unknown): readonly Record<string, unknown>[] {
+  const result: Record<string, unknown>[] = []
+  const references = new Set<string>()
+  let current = schema
+  while (true) {
+    const object = toPlainObject(current)
+    if (object == null) return result
+    result.push(object)
+    const reference = typeof object.$ref == 'string' ? object.$ref : undefined
+    if (reference == null || references.has(reference)) return result
+    const target = resolveLocalReference(root, reference)
+    if (target === undefined) return result
+    references.add(reference)
+    current = target
+  }
+}
+
+function resolveLocalReference(root: unknown, reference: string): unknown {
+  if (reference == '#') return root
+  if (!reference.startsWith('#/')) return undefined
+  let current = root
+  for (const encodedToken of reference.slice(2).split('/')) {
+    const object = toPlainObject(current)
+    const token = encodedToken.replaceAll('~1', '/').replaceAll('~0', '~')
+    if (object == null || !Object.hasOwn(object, token)) return undefined
+    current = object[token]
+  }
+  return current
+}

package/src/connector/common/proxy.ts

@@ -0,0 +1,44 @@
+import type { SourceOperation, SourceReferenceOperation } from '../../event-source/common/definition.ts'
+import type { JsonValue } from '../../flow/common/change.ts'
+export type TriggerOperationRequest =
+  | { readonly operation: 'sourceReference'; readonly request: SourceReferenceOperation }
+  | { readonly operation: 'source'; readonly request: SourceOperation }
+  | { readonly operation: 'read'; readonly config: Readonly<Record<string, JsonValue>>; readonly checkpoint: JsonValue }
+  | { readonly operation: 'options'; readonly config: Readonly<Record<string, JsonValue>>; readonly field: string }
+  | {
+      readonly operation: 'reconcile'
+      readonly subscriptionId?: string
+      readonly config: Readonly<Record<string, JsonValue>>
+      readonly requestKey: string
+      readonly endpointUrl: string
+      readonly active: boolean
+    }
+  | {
+      readonly operation: 'receive'
+      readonly subscriptionId: string
+      readonly method: string
+      readonly headers: Readonly<Record<string, string>>
+      readonly query: Readonly<Record<string, string>>
+      readonly rawBody: string
+      readonly admit: boolean
+      readonly current: boolean
+    }
+  | { readonly operation: 'resource'; readonly config: Readonly<Record<string, JsonValue>>; readonly requestKey: string; readonly active: boolean }
+
+export interface ConnectorProxyRequest {
+  readonly body?: unknown
+  readonly endpoint: string
+  readonly headers?: Readonly<Record<string, string>>
+  readonly method: 'DELETE' | 'GET' | 'PATCH' | 'POST' | 'PUT'
+  readonly query?: Readonly<Record<string, boolean | number | string | null>>
+}
+
+export interface ConnectorProxyResult {
+  readonly data: unknown
+  readonly status: number
+}
+
+export interface ConnectorProxy {
+  trigger?(request: TriggerOperationRequest, signal?: AbortSignal): Promise<unknown>
+  execute(request: ConnectorProxyRequest, signal?: AbortSignal): Promise<ConnectorProxyResult>
+}