@goast/core 0.4.0-beta3 → 0.4.0

package/src/src/transform/transform-endpoint.ts

@@ -0,0 +1,331 @@
+import type { OpenApiCollectorEndpointInfo } from '../collect/types.js';
+import { isOpenApiObjectProperty } from '../internal-utils.js';
+import type {
+  OpenApiHeader,
+  OpenApiMediaType,
+  OpenApiParameter,
+  OpenApiPathItem,
+  OpenApiRequestBody,
+  OpenApiResponse,
+  OpenApiSchema,
+} from '../parse/openapi-types.js';
+import type { Deref } from '../parse/types.js';
+import type {
+  ApiContent,
+  ApiEndpoint,
+  ApiHeader,
+  ApiParameter,
+  ApiParameterTarget,
+  ApiPath,
+  ApiRequestBody,
+  ApiResponse,
+} from './api-types.js';
+import { determineEndpointName, getCustomFields, getOpenApiObjectIdentifier } from './helpers.js';
+import { transformSchema } from './transform-schema.js';
+import type { OpenApiTransformerContext } from './types.js';
+
+export function transformEndpoint(context: OpenApiTransformerContext, endpointInfo: OpenApiCollectorEndpointInfo) {
+  const apiPath = transformApiPath(context, endpointInfo.path, endpointInfo.pathItem);
+  const endpoint: ApiEndpoint = {
+    $src: {
+      ...endpointInfo.operation.$src,
+      component: endpointInfo.operation,
+    },
+    $ref: undefined,
+    id: context.idGenerator.generateId('endpoint'),
+    name: determineEndpointName(endpointInfo),
+    path: endpointInfo.path,
+    pathInfo: apiPath,
+    method: endpointInfo.method,
+    summary: endpointInfo.operation.summary,
+    description: endpointInfo.operation.description,
+    parameters: combineParameters(
+      apiPath.parameters,
+      endpointInfo.operation.parameters?.map((p) => transformParameter(context, p)) ?? [],
+    ),
+    deprecated: endpointInfo.operation.deprecated ?? false,
+    requestBody: endpointInfo.operation.requestBody
+      ? transformRequestBody(context, endpointInfo.operation.requestBody)
+      : undefined,
+    responses: transformResponses(context, endpointInfo.operation.responses),
+    tags: endpointInfo.operation.tags ?? [],
+    custom: getCustomFields(endpointInfo.operation),
+  };
+
+  const tags = endpoint.tags.length === 0 ? [''] : endpoint.tags;
+  for (const tag of tags) {
+    let service = context.services.get(tag);
+    if (!service) {
+      const id = context.idGenerator.generateId('service');
+      service = {
+        $ref: undefined,
+        id,
+        name: tag || id,
+        description: undefined,
+        endpoints: [],
+      };
+      context.services.set(tag, service);
+    }
+
+    service.endpoints.push(endpoint);
+  }
+
+  apiPath[endpointInfo.method] = endpoint;
+  context.endpoints.set(`${endpointInfo.method}:${endpointInfo.path}`, endpoint);
+  return endpoint;
+}
+
+function transformApiPath(
+  context: OpenApiTransformerContext,
+  path: string,
+  pathItem: Deref<OpenApiPathItem>,
+  isReference = false,
+): ApiPath {
+  const existingPath = context.paths.get(path);
+  if (existingPath) return existingPath;
+
+  const openApiObjectId = getOpenApiObjectIdentifier(pathItem);
+  const existing = context.transformed.paths.get(openApiObjectId);
+  if (existing) return existing;
+
+  const ref = pathItem.$ref ? transformApiPath(context, path, pathItem.$ref, true) : undefined;
+  const apiPath: ApiPath = {
+    $src: {
+      ...pathItem.$src,
+      component: pathItem,
+    },
+    $ref: ref,
+    id: context.idGenerator.generateId('path'),
+    summary: pathItem.summary,
+    description: pathItem.description,
+    path: path,
+    parameters: pathItem.parameters?.map((p) => transformParameter(context, p)) ?? [],
+
+    // HTTP methods are added later (see transformEndpoint)
+    get: undefined,
+    put: undefined,
+    post: undefined,
+    delete: undefined,
+    options: undefined,
+    head: undefined,
+    patch: undefined,
+    trace: undefined,
+  };
+
+  context.transformed.paths.set(openApiObjectId, apiPath);
+  if (!isReference) context.paths.set(path, apiPath);
+  return apiPath;
+}
+
+function transformParameter(context: OpenApiTransformerContext, parameter: Deref<OpenApiParameter>): ApiParameter {
+  const openApiObjectId = getOpenApiObjectIdentifier(parameter);
+  const existing = context.transformed.parameters.get(openApiObjectId);
+  if (existing) return existing;
+
+  const ref = parameter.$ref ? transformParameter(context, parameter.$ref) : undefined;
+  const id = context.idGenerator.generateId('parameter');
+  const p: ApiParameter = {
+    $src: {
+      ...parameter.$src,
+      component: parameter,
+    },
+    $ref: ref,
+    id: id,
+    name: parameter.name ?? id,
+    target: parameter.in as ApiParameterTarget,
+    description: parameter.description,
+    required: parameter.required ?? false,
+    deprecated: parameter.deprecated ?? false,
+    allowEmptyValue: parameter.allowEmptyValue,
+    style: parameter.style,
+    explode: parameter.explode,
+    allowReserved: parameter.allowReserved,
+    schema: parameter.schema ? transformSchema(context, parameter.schema) : undefined,
+  };
+
+  context.transformed.parameters.set(openApiObjectId, p);
+  return p;
+}
+
+function transformRequestBody(
+  context: OpenApiTransformerContext,
+  requestBody: Deref<OpenApiRequestBody>,
+): ApiRequestBody {
+  const openApiObjectId = getOpenApiObjectIdentifier(requestBody);
+  const existing = context.transformed.requestBodies.get(openApiObjectId);
+  if (existing) return existing;
+
+  const ref = requestBody.$ref ? transformRequestBody(context, requestBody.$ref) : undefined;
+  const rb: ApiRequestBody = {
+    $src: {
+      ...requestBody.$src,
+      component: requestBody,
+    },
+    $ref: ref,
+    id: context.idGenerator.generateId('requestBody'),
+    description: requestBody.description,
+    required: requestBody.required ?? false,
+    content: transformContent(context, requestBody.content),
+  };
+
+  context.transformed.requestBodies.set(openApiObjectId, rb);
+  return rb;
+}
+
+function transformResponses(
+  context: OpenApiTransformerContext,
+  responses?: Record<string, Deref<OpenApiResponse>>,
+): ApiResponse[] {
+  if (!responses) return [];
+  const result: ApiResponse[] = [];
+  for (const status of Object.keys(responses)) {
+    if (!isOpenApiObjectProperty(status)) continue;
+    result.push(transformResponse(context, responses[status], status));
+  }
+  return result;
+}
+
+function transformResponse(
+  context: OpenApiTransformerContext,
+  response: Deref<OpenApiResponse>,
+  status: string,
+): ApiResponse {
+  const openApiObjectId = getOpenApiObjectIdentifier(response);
+  const existing = context.transformed.responses.get(openApiObjectId);
+  if (existing) return existing;
+
+  const ref = response.$ref ? transformResponse(context, response.$ref, status) : undefined;
+  const r: ApiResponse = {
+    $src: {
+      ...response.$src,
+      component: response,
+    },
+    $ref: ref,
+    id: context.idGenerator.generateId('response'),
+    statusCode: Number(status) || undefined,
+    description: response.description,
+    headers: transformHeaders(context, response.headers),
+    contentOptions: transformContent(context, response.content),
+  };
+
+  context.transformed.responses.set(openApiObjectId, r);
+  return r;
+}
+
+function transformContent(
+  context: OpenApiTransformerContext,
+  content?: Record<string, Deref<OpenApiMediaType>>,
+): ApiContent[] {
+  if (!content) return [];
+  const result: ApiContent[] = [];
+  for (const media of Object.keys(content)) {
+    if (!isOpenApiObjectProperty(media)) continue;
+    result.push(transformMediaType(context, content[media], media));
+  }
+  return result;
+}
+
+function transformMediaType(
+  context: OpenApiTransformerContext,
+  mediaType: Deref<OpenApiMediaType>,
+  media: string,
+): ApiContent {
+  const openApiObjectId = getOpenApiObjectIdentifier(mediaType);
+  const existing = context.transformed.content.get(openApiObjectId);
+  if (existing) return existing;
+
+  const ref = mediaType.$ref ? transformMediaType(context, mediaType.$ref, media) : undefined;
+  const mt: ApiContent = {
+    $src: {
+      ...mediaType.$src,
+      component: mediaType,
+    },
+    $ref: ref,
+    id: context.idGenerator.generateId('content'),
+    type: media,
+    schema: mediaType.schema ? transformSchema(context, mediaType.schema) : undefined,
+  };
+
+  context.transformed.content.set(openApiObjectId, mt);
+  return mt;
+}
+
+function combineParameters(pathParams: ApiParameter[], operationParams: ApiParameter[]): ApiParameter[] {
+  const result = [...pathParams];
+  for (const opParam of operationParams) {
+    const existingParam = result.findIndex((p) => p.name === opParam.name);
+    if (existingParam >= 0) {
+      result[existingParam] = opParam;
+    } else {
+      result.push(opParam);
+    }
+  }
+  return result;
+}
+
+function isSchema(obj: Record<string, unknown>): obj is Deref<OpenApiSchema> {
+  return obj && typeof obj === 'object' && obj['type'] !== undefined;
+}
+
+function transformHeaders(
+  context: OpenApiTransformerContext,
+  headers?: Record<string, Deref<OpenApiHeader> | Deref<OpenApiSchema>>,
+): ApiHeader[] {
+  if (!headers) return [];
+  const result: ApiHeader[] = [];
+  for (const name of Object.keys(headers)) {
+    if (!isOpenApiObjectProperty(name)) continue;
+    result.push(transformHeader(context, headers[name], name));
+  }
+  return result;
+}
+
+function transformHeader(
+  context: OpenApiTransformerContext,
+  header: Deref<OpenApiHeader> | Deref<OpenApiSchema>,
+  name: string,
+): ApiHeader {
+  const openApiObjectId = getOpenApiObjectIdentifier(header);
+  const existing = context.transformed.headers.get(openApiObjectId);
+  if (existing) return existing;
+
+  let h: ApiHeader;
+  const ref = header.$ref ? transformHeader(context, header.$ref, name) : undefined;
+  const id = context.idGenerator.generateId('header');
+  if (isSchema(header)) {
+    h = {
+      // deno-lint-ignore no-explicit-any
+      $src: Object.assign({}, header.$src, { component: header }) as any,
+      $ref: ref as ApiHeader['$ref'],
+      id,
+      name,
+      description: header.description,
+      required: false,
+      deprecated: false,
+      allowEmptyValue: undefined,
+      style: undefined,
+      explode: undefined,
+      allowReserved: undefined,
+      schema: transformSchema(context, header),
+    };
+  } else {
+    h = {
+      // deno-lint-ignore no-explicit-any
+      $src: Object.assign({}, header.$src, { component: header }) as any,
+      $ref: ref as ApiHeader['$ref'],
+      id,
+      name,
+      description: header.description,
+      required: header.required ?? false,
+      deprecated: header.deprecated ?? false,
+      allowEmptyValue: header.allowEmptyValue,
+      style: header.style,
+      explode: header.explode,
+      allowReserved: header.allowReserved,
+      schema: header.schema ? transformSchema(context, header.schema) : undefined,
+    };
+  }
+
+  context.transformed.headers.set(openApiObjectId, h);
+  return h;
+}

package/src/src/transform/transform-schema.ts

@@ -0,0 +1,217 @@
+import type { OpenApiSchema } from '../parse/openapi-types.js';
+import type { Deref } from '../parse/types.js';
+import { createOverwriteProxy } from '../utils/object.utils.js';
+import type { ApiSchema, ApiSchemaExtensions, ApiSchemaKind } from './api-types.js';
+import {
+  determineSchemaAccessibility,
+  determineSchemaKind,
+  determineSchemaName,
+  getCustomFields,
+  getOpenApiObjectIdentifier,
+  transformAdditionalProperties,
+  transformSchemaProperties,
+} from './helpers.js';
+import type { IncompleteApiSchema, OpenApiTransformerContext } from './types.js';
+
+export function transformSchema<T extends Deref<OpenApiSchema>>(ctx: OpenApiTransformerContext, schema: T): ApiSchema {
+  if (!schema) {
+    throw new Error('Schema is required.');
+  }
+  const schemaSource = `${schema.$src.file}:${schema.$src.path}`;
+  const existingSchema = ctx.schemas.get(schemaSource) ?? ctx.incompleteSchemas.get(schemaSource);
+  if (existingSchema) return existingSchema as ApiSchema;
+
+  const openApiObjectId = getOpenApiObjectIdentifier(schema);
+  const existing = ctx.transformed.schemas.get(openApiObjectId);
+  if (existing) return existing;
+
+  let kind = determineSchemaKind(ctx, schema);
+  let nullable = kind === 'null';
+  if (kind === 'multi-type') {
+    const types = schema.type as string[];
+    let isSingleType = types.length === 1;
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    if (types.includes('null') || types.includes(null!)) {
+      nullable = true;
+      isSingleType = types.length === 2;
+    }
+
+    if (isSingleType) {
+      const newType = types.filter((t) => t !== 'null' && t !== null)[0];
+      schema = createOverwriteProxy(schema);
+      schema.type = newType;
+      kind = determineSchemaKind(ctx, schema);
+    } else {
+      schema.type = types.filter((t) => t !== 'null' && t !== null);
+    }
+  }
+
+  const id = ctx.idGenerator.generateId('schema');
+  const nameInfo = determineSchemaName(schema, id);
+  const incompleteSchema: IncompleteApiSchema = {
+    $src: {
+      ...schema.$src,
+      component: schema,
+    },
+    $ref: undefined,
+    id,
+    name: nameInfo.name,
+    isNameGenerated: nameInfo.isGenerated,
+    description: schema.description,
+    deprecated: schema.deprecated ?? false,
+    accessibility: determineSchemaAccessibility(schema),
+    kind,
+    enum: schema.enum,
+    default: schema.default,
+    example: schema.example,
+    nullable: nullable || schema.nullable === true,
+    required: new Set(schema.required),
+    custom: getCustomFields(schema),
+    not: schema.not ? transformSchema(ctx, schema.not) : undefined,
+    const: schema.const,
+    discriminator: schema.discriminator
+      ? {
+        propertyName: typeof schema.discriminator === 'string'
+          ? schema.discriminator
+          : schema.discriminator.propertyName,
+        mapping: {},
+      }
+      : undefined,
+    inheritedSchemas: [],
+  };
+  ctx.incompleteSchemas.set(schemaSource, incompleteSchema);
+
+  if (schema.$ref) {
+    incompleteSchema.$ref = transformSchema(ctx, schema.$ref);
+  }
+  const extensions = schemaTransformers[kind](schema, ctx);
+  const completeSchema = Object.assign(incompleteSchema, extensions) as
+    & IncompleteApiSchema
+    & ApiSchemaExtensions<ApiSchemaKind>;
+  resolveDescriminatorMapping(ctx, completeSchema);
+
+  ctx.incompleteSchemas.delete(schemaSource);
+  ctx.transformed.schemas.set(openApiObjectId, completeSchema);
+  ctx.schemas.set(schemaSource, completeSchema);
+  return completeSchema;
+}
+
+function allExtensionsTransformer(schema: Deref<OpenApiSchema>, context: OpenApiTransformerContext) {
+  return {
+    oneOf: schema.oneOf?.map((s) => transformSchema(context, s)) ?? [],
+    format: schema.format,
+    pattern: schema.pattern,
+    minLength: schema.minLength,
+    maxLength: schema.maxLength,
+    minimum: schema.minimum,
+    maximum: schema.maximum,
+    properties: transformSchemaProperties<Deref<OpenApiSchema>>(context, schema, transformSchema),
+    additionalProperties: transformAdditionalProperties(context, schema, transformSchema),
+    allOf: schema.allOf?.map((s) => transformSchema(context, s)) ?? [],
+    anyOf: schema.anyOf?.map((s) => transformSchema(context, s)) ?? [],
+    items: schema.items ? transformSchema(context, schema.items) : undefined,
+    minItems: schema.minItems,
+    maxItems: schema.maxItems,
+  };
+}
+
+const schemaTransformers: {
+  [K in ApiSchemaKind]: (
+    schema: Deref<OpenApiSchema>,
+    context: OpenApiTransformerContext,
+  ) => Omit<ApiSchemaExtensions<K>, 'kind'>;
+} = {
+  oneOf: (schema, context) => ({
+    ...allExtensionsTransformer(schema, context),
+  }),
+  string: (schema, context) => ({
+    type: 'string',
+    ...allExtensionsTransformer(schema, context),
+  }),
+  number: (schema, context) => ({
+    type: 'number',
+    ...allExtensionsTransformer(schema, context),
+  }),
+  boolean: (schema, context) => ({ type: 'boolean', ...allExtensionsTransformer(schema, context) }),
+  object: (schema, context) => ({
+    type: 'object',
+    ...allExtensionsTransformer(schema, context),
+  }),
+  integer: (schema, context) => ({
+    type: 'integer',
+    ...allExtensionsTransformer(schema, context),
+  }),
+  array: (schema, context) => ({
+    type: 'array',
+    ...allExtensionsTransformer(schema, context),
+  }),
+  combined: (schema, context) => ({
+    ...allExtensionsTransformer(schema, context),
+  }),
+  'multi-type': (schema, context) => ({
+    type: schema.type as string[],
+    ...allExtensionsTransformer(schema, context),
+  }),
+  null: () => ({ type: 'null' }),
+  unknown: () => ({}),
+};
+
+function resolveDescriminatorMapping(context: OpenApiTransformerContext, schema: ApiSchema) {
+  const discriminator = schema.$src.component.discriminator;
+  if (discriminator && typeof discriminator === 'object' && discriminator.mapping) {
+    for (const key of Object.keys(discriminator.mapping)) {
+      const mappedSchemaRef = discriminator.mapping[key];
+      const mappedSchema = transformSchema(context, mappedSchemaRef);
+      if (schema.discriminator) {
+        schema.discriminator.mapping[key] = mappedSchema;
+        const hasInheritedSchema = mappedSchema.inheritedSchemas.some((x) => x.id === schema.id);
+        if (!hasInheritedSchema) {
+          mappedSchema.inheritedSchemas.push(
+            schema as ApiSchema & { discriminator: NonNullable<ApiSchema['discriminator']> },
+          );
+        }
+      }
+    }
+  }
+
+  if (schema.kind === 'combined' && schema.allOf) {
+    for (const s of schema.allOf) {
+      const base = findDiscriminatedSchema(s);
+      if (!base) continue;
+      if (base.discriminator && base.discriminator.propertyName) {
+        const origDiscriminator = base.$src.component.discriminator;
+        if (
+          origDiscriminator &&
+          typeof origDiscriminator === 'object' &&
+          origDiscriminator.mapping &&
+          Object.values(origDiscriminator.mapping).some(
+            (x) => x.$src.file === schema.$src.file && x.$src.path === schema.$src.path,
+          )
+        ) {
+          continue;
+        }
+
+        const mappingKey = schema.isNameGenerated ? null : schema.name;
+        if (!mappingKey) {
+          continue;
+        }
+
+        base.discriminator.mapping[mappingKey] = schema;
+        const hasInheritedSchema = schema.inheritedSchemas.some((x) => x.id === base.id);
+        if (!hasInheritedSchema) {
+          schema.inheritedSchemas.push(base as ApiSchema & { discriminator: NonNullable<ApiSchema['discriminator']> });
+        }
+      }
+    }
+  }
+}
+
+function findDiscriminatedSchema(
+  schema: ApiSchema,
+): (ApiSchema & { discriminator: NonNullable<ApiSchema['discriminator']> }) | null {
+  const origDiscriminator = schema.$src.originalComponent.discriminator;
+  if (origDiscriminator && (typeof origDiscriminator === 'string' || origDiscriminator.propertyName)) {
+    return schema as ApiSchema & { discriminator: NonNullable<ApiSchema['discriminator']> };
+  }
+  return schema.$ref ? findDiscriminatedSchema(schema.$ref) : null;
+}

package/src/src/transform/transformer.ts

@@ -0,0 +1,52 @@
+import type { OpenApiCollectorData } from '../collect/types.js';
+import type { ApiData } from './api-types.js';
+import { IdGenerator } from './helpers.js';
+import { transformDocument } from './transform-document.js';
+import { transformEndpoint } from './transform-endpoint.js';
+import { transformSchema } from './transform-schema.js';
+import {
+  defaultOpenApiTransformerOptions,
+  type OpenApiTransformerContext,
+  type OpenApiTransformerOptions,
+} from './types.js';
+
+export function transformOpenApi(data: OpenApiCollectorData, options?: Partial<OpenApiTransformerOptions>): ApiData {
+  const context: OpenApiTransformerContext = {
+    config: { ...defaultOpenApiTransformerOptions, ...options },
+
+    idGenerator: new IdGenerator(),
+    input: data,
+    incompleteSchemas: new Map(),
+    paths: new Map(),
+    services: new Map(),
+    endpoints: new Map(),
+    schemas: new Map(),
+
+    transformed: {
+      services: new Map(),
+      paths: new Map(),
+      parameters: new Map(),
+      requestBodies: new Map(),
+      responses: new Map(),
+      content: new Map(),
+      headers: new Map(),
+      schemas: new Map(),
+    },
+  };
+
+  for (const document of data.documents) {
+    transformDocument(context, document);
+  }
+  for (const schema of context.input.schemas.values()) {
+    transformSchema(context, schema);
+  }
+  for (const endpoint of context.input.endpoints.values()) {
+    transformEndpoint(context, endpoint);
+  }
+
+  return {
+    services: Array.from(context.services.values()),
+    endpoints: Array.from(context.endpoints.values()),
+    schemas: Array.from(context.schemas.values()),
+  };
+}

package/src/src/transform/types.ts

@@ -0,0 +1,52 @@
+import type {
+  ApiContent,
+  ApiData,
+  ApiHeader,
+  ApiParameter,
+  ApiPath,
+  ApiRequestBody,
+  ApiResponse,
+  ApiSchema,
+  ApiSchemaExtensions,
+  ApiSchemaKind,
+  ApiService,
+} from './api-types.js';
+import type { IdGenerator } from './helpers.js';
+import type { OpenApiCollectorData } from '../collect/types.js';
+import type { ArrayItem } from '../utils/type.utils.js';
+
+export type OpenApiTransformerOptions = {
+  /**
+   * Determines how schemas without a `type` property should be treated.
+   * - `keep-unknown`: Keep the schema as-is.
+   * - `object-if-properties`: Treat the schema as an object schema only if it has properties.
+   * - `always-object`: Treat the schema as an object schema.
+   * @default 'object-if-properties'
+   */
+  unknownTypeBehavior: 'keep-unknown' | 'object-if-properties' | 'always-object';
+};
+
+export const defaultOpenApiTransformerOptions: OpenApiTransformerOptions = {
+  unknownTypeBehavior: 'object-if-properties',
+};
+
+export type IncompleteApiSchema = Omit<ApiSchema, Exclude<keyof ApiSchemaExtensions<ApiSchemaKind>, 'kind'>>;
+export type OpenApiTransformerContext = {
+  config: OpenApiTransformerOptions;
+
+  idGenerator: IdGenerator;
+  input: OpenApiCollectorData;
+  incompleteSchemas: Map<string, IncompleteApiSchema>;
+  paths: Map<string, ApiPath>;
+
+  transformed: {
+    services: Map<string, ApiService>;
+    paths: Map<string, ApiPath>;
+    parameters: Map<string, ApiParameter>;
+    requestBodies: Map<string, ApiRequestBody>;
+    responses: Map<string, ApiResponse>;
+    content: Map<string, ApiContent>;
+    headers: Map<string, ApiHeader>;
+    schemas: Map<string, ApiSchema>;
+  };
+} & { [K in keyof ApiData]: Map<string, ArrayItem<ApiData[K]>> };

package/src/src/utils/action-provider.test.ts

@@ -0,0 +1,32 @@
+import "../../_dnt.test_polyfills.js";
+import { expect } from '../../deps/jsr.io/@std/expect/1.0.5/mod.js';
+import { describe, it } from '../../deps/jsr.io/@std/testing/1.0.3/bdd.js';
+
+import { ActionProvider } from './action-provider.js';
+
+describe('ActionProvider', () => {
+  describe('run', () => {
+    it('should create an instance using a constructor and call the specified function', () => {
+      class Foo {
+        public bar(value: string): string {
+          return `Hello, ${value}!`;
+        }
+      }
+      const provider = ActionProvider.fromType(Foo, 'bar');
+      const result = provider.run('world');
+      expect(result).toBe('Hello, world!');
+    });
+
+    it('should call a function and return the result', () => {
+      const provider = ActionProvider.fromFn((value: string) => `Hello, ${value}!`);
+      const result = provider.run('world');
+      expect(result).toBe('Hello, world!');
+    });
+
+    it('should call a function on a value and return the result', () => {
+      const provider = ActionProvider.fromValue({ bar: (value: string) => `Hello, ${value}!` }, 'bar');
+      const result = provider.run('world');
+      expect(result).toBe('Hello, world!');
+    });
+  });
+});