@goast/core 0.4.1 → 0.5.0-beta.1

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

@@ -1,331 +0,0 @@
-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

@@ -1,217 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,32 +0,0 @@
-import "../../_dnt.test_polyfills.js";
-import { expect } from '../../deps/jsr.io/@std/expect/1.0.12/mod.js';
-import { describe, it } from '../../deps/jsr.io/@std/testing/1.0.9/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!');
-    });
-  });
-});