@goast/core 0.5.0-beta.5 → 0.5.0

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,53 @@
+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 {
+    documents: context.input.documents,
+    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 { OpenApiCollectorData } from '../collect/types.js';
+import type { ArrayItem } from '../utils/type.utils.js';
+import type {
+  ApiContent,
+  ApiData,
+  ApiHeader,
+  ApiParameter,
+  ApiPath,
+  ApiRequestBody,
+  ApiResponse,
+  ApiSchema,
+  ApiSchemaExtensions,
+  ApiSchemaKind,
+  ApiService,
+} from './api-types.js';
+import type { IdGenerator } from './helpers.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 Exclude<keyof ApiData, 'documents'>]: Map<string, ArrayItem<ApiData[K]>> };

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

@@ -0,0 +1,58 @@
+// deno-lint-ignore-file
+import type { EmptyConstructor, FunctionNames } from './type.utils.js';
+
+type MatchingFunctionNames<T, TAction> = {
+  [K in keyof T]: T[K] extends TAction ? K : never;
+}[keyof T];
+
+type CtorActionRunner<T, TAction> = {
+  kind: 'ctor';
+  factory: EmptyConstructor<T>;
+  functionName: MatchingFunctionNames<T, TAction>;
+};
+
+type FnActionRunner<TAction> = {
+  kind: 'fn';
+  action: TAction;
+};
+
+type ValueActionRunner<T, TAction> = {
+  kind: 'value';
+  value: T;
+  functionName: MatchingFunctionNames<T, TAction>;
+};
+
+type ActionRunner<TAction> = CtorActionRunner<any, TAction> | FnActionRunner<TAction> | ValueActionRunner<any, TAction>;
+
+export class ActionProvider<TAction extends (...args: any[]) => any> {
+  constructor(private readonly _runner: ActionRunner<TAction>) {}
+
+  public run(...args: Parameters<TAction>): ReturnType<TAction> {
+    switch (this._runner.kind) {
+      case 'ctor':
+        return new this._runner.factory()[this._runner.functionName as any](...args);
+      case 'fn':
+        return this._runner.action(...args);
+      case 'value':
+        return this._runner.value[this._runner.functionName as any](...args);
+    }
+  }
+
+  public static fromType<T, TName extends FunctionNames<T>>(
+    type: EmptyConstructor<T>,
+    functionName: TName,
+  ): ActionProvider<T[TName] extends (...args: any[]) => any ? T[TName] : never> {
+    return new ActionProvider({ kind: 'ctor', factory: type, functionName: functionName as any });
+  }
+
+  public static fromFn<TAction extends (...args: any[]) => any>(fn: TAction): ActionProvider<TAction> {
+    return new ActionProvider({ kind: 'fn', action: fn });
+  }
+
+  public static fromValue<T, TName extends FunctionNames<T>>(
+    value: T,
+    functionName: TName,
+  ): ActionProvider<T[TName] extends (...args: any[]) => any ? T[TName] : never> {
+    return new ActionProvider({ kind: 'value', value, functionName: functionName as any });
+  }
+}

package/src/src/utils/api-data.utils.ts

@@ -0,0 +1,48 @@
+import { dirname, relative } from 'node:path';
+import process from 'node:process';
+import type { ApiComponent, ApiData } from '../transform/api-types.js';
+
+const DOCUMENTS_BASE_PATH = Symbol('documentsBasePath');
+
+type ApiDataWithBasePath = ApiData & {
+  [DOCUMENTS_BASE_PATH]?: string;
+};
+
+export function getSourceDisplayName<T>(data: ApiData, component: ApiComponent<T>): string {
+  let basePath: string | undefined = (data as ApiDataWithBasePath)[DOCUMENTS_BASE_PATH];
+  if (basePath === undefined) {
+    const allPaths = data.documents.map((doc) => doc.$src.file);
+    basePath = getCommonBasePath(allPaths);
+    (data as ApiDataWithBasePath)[DOCUMENTS_BASE_PATH] = basePath;
+  }
+
+  const relativePath = relative(basePath, component.$src.file);
+  return `${relativePath}#${component.$src.path}`;
+}
+
+function getCommonBasePath(paths: string[]): string {
+  if (paths.length === 0) return '';
+  if (paths.length === 1) return dirname(paths[0]);
+
+  const splitPaths = paths.map((p) => normalizePath(p).split('/'));
+  const minLength = Math.min(...splitPaths.map((parts) => parts.length));
+  const commonParts: string[] = [];
+
+  for (let i = 0; i < minLength; i++) {
+    const part = splitPaths[0][i];
+    if (splitPaths.every((parts) => parts[i] === part)) {
+      commonParts.push(part);
+    } else {
+      break;
+    }
+  }
+
+  return commonParts.join('/');
+}
+
+function normalizePath(path: string): string {
+  if (process.platform === 'win32') {
+    return path.replace(/\\/g, '/');
+  }
+  return path;
+}

package/src/src/utils/array.utils.ts

@@ -0,0 +1,7 @@
+export function removeItems<T>(array: T[], predicate: (item: T) => boolean): void {
+  for (let i = array.length - 1; i >= 0; i--) {
+    if (predicate(array[i])) {
+      array.splice(i, 1);
+    }
+  }
+}

package/src/src/utils/asset-manager.ts

@@ -0,0 +1,51 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { basename, resolve } from 'node:path';
+import { fileURLToPath, URL } from 'node:url';
+
+
+import fs from 'fs-extra';
+
+export class AssetManager {
+  private readonly _assetsBaseUrl: URL;
+
+  constructor(assetsBaseUrl: URL) {
+    this._assetsBaseUrl = assetsBaseUrl;
+  }
+
+  public async getAssetFileContent(relativePath: string): Promise<string> {
+    if (this._assetsBaseUrl.protocol === 'file:') {
+      return await fs.readFile(resolve(fileURLToPath(this._assetsBaseUrl), relativePath), 'utf8');
+    } else {
+      return await this.fetchAssetFile(relativePath);
+    }
+  }
+
+  public async copyAssetFile(relativePath: string, destDir: string, logName?: string): Promise<void> {
+    const targetPath = resolve(destDir, basename(relativePath));
+    if (logName !== undefined) {
+      if (logName) {
+        console.log(`Copying ${logName} to "${targetPath}"`);
+      } else {
+        console.log(`Copying asset file "${relativePath}" to "${targetPath}"`);
+      }
+    }
+    if (this._assetsBaseUrl.protocol === 'file:') {
+      const srcPath = resolve(fileURLToPath(this._assetsBaseUrl), relativePath);
+      await fs.copyFile(srcPath, targetPath);
+    } else {
+      const fileContent = await this.fetchAssetFile(relativePath);
+      await fs.outputFile(targetPath, fileContent);
+    }
+  }
+
+  private async fetchAssetFile(relativePath: string): Promise<string> {
+    const url = new URL(relativePath, this._assetsBaseUrl);
+    const response = await dntShim.fetch(url);
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch asset file "${relativePath}" from "${url.href}": ${response.statusText} (${response.status})`,
+      );
+    }
+    return await response.text();
+  }
+}

package/src/src/utils/class.utils.ts

@@ -0,0 +1,40 @@
+// deno-lint-ignore-file no-explicit-any
+export function classifyArray<TItem, TClassification extends Record<string, abstract new (...args: any[]) => any>>(
+  items: Iterable<TItem>,
+  classification: TClassification,
+): { [P in keyof TClassification]: InstanceType<TClassification[P]>[] } & {
+  rest: Exclude<TItem, InstanceType<TClassification[string]>>[];
+} {
+  const result = { rest: [] } as { [P in keyof TClassification]: InstanceType<TClassification[P]>[] } & {
+    rest: Exclude<TItem, InstanceType<TClassification[string]>>[];
+  };
+
+  for (const key in classification) {
+    (result as any)[key] = [];
+  }
+
+  for (const item of items) {
+    let classified = false;
+    for (const key in classification) {
+      const type = classification[key];
+      if (item instanceof type) {
+        result[key].push(item as any);
+        classified = true;
+        break;
+      }
+    }
+    if (!classified) {
+      result.rest.push(item as any);
+    }
+  }
+
+  return result;
+}
+
+export function isInstanceOf<T>(item: unknown, type: abstract new (...args: any[]) => T): item is T {
+  return item instanceof type;
+}
+
+export function getIsInstanceOf<T>(type: abstract new (...args: any[]) => T): (item: unknown) => item is T {
+  return (item): item is T => item instanceof type;
+}

package/src/src/utils/common.utils.ts

@@ -0,0 +1,86 @@
+import type { SingleOrMultiple } from './type.utils.js';
+
+export function isNullish(value: unknown): value is null | undefined {
+  return value === null || value === undefined;
+}
+
+export function notNullish<T>(value: T): value is NonNullable<T> {
+  return !isNullish(value);
+}
+
+export function concatSingleOrMultiple<T>(...values: SingleOrMultiple<T>[]): SingleOrMultiple<T> {
+  if (values.length === 1) {
+    return values[0];
+  }
+  const result: T[] = [];
+  for (const value of values) {
+    if (Array.isArray(value)) {
+      result.push(...value);
+    } else {
+      result.push(value);
+    }
+  }
+  return result;
+}
+
+export function isIterable(value: unknown): value is Iterable<unknown> {
+  return typeof value === 'object' && value !== null && Symbol.iterator in value;
+}
+
+export function toArray<T>(value: T | T[] | Iterable<T>): T[] {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (isIterable(value)) {
+    return Array.from(value);
+  }
+  return [value];
+}
+
+export function modify<T>(value: T, callback: (value: NonNullable<T>) => void): T {
+  if (notNullish(value)) {
+    callback(value);
+  }
+  return value;
+}
+
+export function run<T>(value: T, callback: (value: T) => void): T {
+  callback(value);
+  return value;
+}
+
+export function transform<T, U>(value: T, callback: (value: T) => U): U {
+  return callback(value);
+}
+
+type IterableItem<T> = T extends Iterable<infer U> ? U : never;
+export function modifyEach<T extends Iterable<unknown>>(
+  values: T,
+  callback: (value: NonNullable<IterableItem<T>>) => void,
+): T {
+  for (const value of values) {
+    if (notNullish(value)) {
+      callback(value as NonNullable<IterableItem<T>>);
+    }
+  }
+  return values;
+}
+
+export function runEach<T extends Iterable<unknown>>(values: T, callback: (value: IterableItem<T>) => void): T {
+  for (const value of values) {
+    callback(value as IterableItem<T>);
+  }
+  return values;
+}
+
+export function transformEach<T, U>(values: Iterable<T>, callback: (value: T) => U): U[] {
+  const result: U[] = [];
+  for (const value of values) {
+    result.push(callback(value));
+  }
+  return result;
+}
+
+export function asVoid(_: unknown): void {
+  // Do nothing
+}

package/src/src/utils/condition.ts

@@ -0,0 +1,7 @@
+export type Condition<T = never> = boolean | ([T] extends [never] ? () => boolean : (ctx: T) => boolean);
+export function evalCondition(condition: Condition<never>): boolean;
+export function evalCondition<T>(condition: Condition<T>, ctx: T): boolean;
+export function evalCondition<T>(condition: Condition<T>, ctx?: T): boolean {
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  return typeof condition === 'function' ? condition(ctx!) : condition;
+}

package/src/src/utils/endpoint.utils.ts

@@ -0,0 +1,10 @@
+import type { ApiEndpoint } from '../transform/api-types.js';
+
+export function getEndpointUrlPreview(endpoint: ApiEndpoint): string {
+  let url = endpoint.path;
+  const queryParams = endpoint.parameters.filter((p) => p.target === 'query');
+  if (queryParams.length > 0) {
+    url += '?' + queryParams.map((p) => (p.required ? `${p.name}={${p.name}}` : `[${p.name}={${p.name}}]`)).join('&');
+  }
+  return url;
+}

package/src/src/utils/error.utils.ts

@@ -0,0 +1,3 @@
+export function throwExp(message: string): never {
+  throw new Error(message);
+}

package/src/src/utils/factory.ts

@@ -0,0 +1,42 @@
+import type { Constructor } from './type.utils.js';
+
+type FactoryProvider<T, TArgs extends unknown[]> =
+  | {
+    kind: 'ctor';
+    factory: Constructor<T, TArgs>;
+  }
+  | {
+    kind: 'fn';
+    factory: (...args: TArgs) => T;
+  }
+  | {
+    kind: 'value';
+    factory: T;
+  };
+
+export class Factory<T, TArgs extends unknown[]> {
+  constructor(private readonly _provider: FactoryProvider<T, TArgs>) {}
+
+  public create(...args: TArgs): T {
+    switch (this._provider.kind) {
+      case 'ctor':
+        return new this._provider.factory(...args);
+      case 'fn':
+        return this._provider.factory(...args);
+      case 'value':
+        return this._provider.factory;
+    }
+  }
+
+  public static fromType<T, TArgs extends unknown[]>(type: Constructor<T, TArgs>): Factory<T, TArgs> {
+    return new Factory({ kind: 'ctor', factory: type });
+  }
+
+  public static fromFn<T, TArgs extends unknown[]>(fn: (...args: TArgs) => T): Factory<T, TArgs> {
+    return new Factory({ kind: 'fn', factory: fn });
+  }
+
+  public static fromValue<T>(value: T): Factory<T, []> {
+    return new Factory({ kind: 'value', factory: value });
+  }
+}