@baseplate-dev/sync/dist/generators/generators.d.ts

Library for syncing Baseplate descriptions

import { z } from 'zod';
import type { GeneratorTaskOutputBuilder } from '#src/output/generator-task-output.js';
import type { TaskPhase } from '#src/phases/types.js';
import type { InferProviderDependency, Provider, ProviderDependency, ProviderExport, ProviderExportScope, ProviderType } from '#src/providers/index.js';
/**
 * The base required fields for a generator descriptor
 */
export declare const baseDescriptorSchema: z.ZodObject<{
    /**
     * The name of the generator instance (required if the descriptor is one of an array of children)
     */
    name: z.ZodOptional<z.ZodString>;
    /**
     * The generator to use to generate the descriptor
     */
    generator: z.ZodString;
}, "strip", z.ZodTypeAny, {
    generator: string;
    name?: string | undefined;
}, {
    generator: string;
    name?: string | undefined;
}>;
export type BaseGeneratorDescriptor = z.infer<typeof baseDescriptorSchema>;
/**
 * A map of export names to the provider export type
 */
export type ProviderExportMap<T = Record<string, Provider>> = {
    [key in keyof T]: ProviderExport<T[key]>;
};
/**
 * A map of dependency names to the provider dependency type
 */
export type ProviderDependencyMap<T = Record<string, Provider>> = {
    [key in keyof T]: ProviderType<T[key]> | ProviderDependency<T[key]> | undefined;
};
/**
 * Infer the map of the initialized providers from the provider export map
 */
export type InferExportProviderMap<T> = T extends undefined ? undefined : T extends ProviderExportMap<infer P> ? P : never;
type IsUndefined<T> = undefined extends T ? true : false;
/**
 * Infer the map of the initialized providers from the provider dependency map
 */
export type InferDependencyProviderMap<T> = T extends undefined ? undefined : {
    [key in keyof T]: IsUndefined<T[key]> extends true ? InferProviderDependency<T[key]> | undefined : InferProviderDependency<T[key]>;
};
interface GeneratorTaskResultProviders<ExportMap extends Record<string, Provider> | undefined = Record<string, Provider> | undefined> {
    /**
     * The providers that are exported by this generator task
     */
    providers: ExportMap;
}
interface GeneratorTaskResultBuildersWithOutputs<OutputMap extends Record<string, Provider> | undefined = Record<string, Provider> | undefined> {
    /**
     * The function to build the output for the generator task
     */
    build: (builder: GeneratorTaskOutputBuilder) => Promise<OutputMap> | OutputMap;
}
interface GeneratorTaskResultBuildersWithNoOutputs {
    /**
     * The function to build the output for the generator task
     */
    build?: (builder: GeneratorTaskOutputBuilder) => Promise<void> | void;
}
type IsEmpty<T> = T extends undefined ? true : keyof T extends never ? true : false;
/**
 * The result of a generator task with exported providers
 */
export type GeneratorTaskResult<ExportMap extends Record<string, Provider> | undefined = Record<string, Provider> | undefined, OutputMap extends Record<string, Provider> | undefined = Record<string, Provider> | undefined> = (IsEmpty<ExportMap> extends true ? Record<never, never> : GeneratorTaskResultProviders<ExportMap>) & (OutputMap extends true ? GeneratorTaskResultBuildersWithNoOutputs : IsEmpty<OutputMap> extends true ? GeneratorTaskResultBuildersWithNoOutputs : GeneratorTaskResultBuildersWithOutputs<OutputMap>);
/**
 * The context of the task run
 */
export interface TaskRunContext {
    /**
     * The id of the task
     */
    taskId: string;
}
/**
 * A generator task that has been initialized by the generator config with
 * the descriptor of the generator.
 */
export interface GeneratorTask<ExportMap extends ProviderExportMap | undefined = ProviderExportMap | undefined, DependencyMap extends ProviderDependencyMap = ProviderDependencyMap, OutputMap extends ProviderExportMap | undefined = ProviderExportMap | undefined> {
    /**
     * The providers that are exported by this generator task
     */
    exports?: ExportMap;
    /**
     * The providers that are outputs from this generator task
     */
    outputs?: OutputMap;
    /**
     * The providers that are required by this generator task
     */
    dependencies?: DependencyMap;
    /**
     * The phase of the generator task (otherwise it will be executed before all named phases)
     */
    phase?: TaskPhase | undefined;
    /**
     * Given the resolved dependencies, run the generator task and return
     * the initialized export map and function to build the output for the
     * generator task.
     */
    run: (dependencies: InferDependencyProviderMap<DependencyMap>, context: TaskRunContext) => {
        exports: ExportMap;
        outputs: OutputMap;
    } extends {
        exports: undefined;
        outputs: undefined;
    } ? // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
    void | GeneratorTaskResult<InferExportProviderMap<ExportMap>, InferExportProviderMap<OutputMap>> : GeneratorTaskResult<InferExportProviderMap<ExportMap>, InferExportProviderMap<OutputMap>>;
}
/**
 * A type that can be used to create a generator task with any export, dependency, and output maps
 */
export type AnyGeneratorTask = GeneratorTask<any, any, any>;
export declare function createGeneratorTask<ExportMap extends ProviderExportMap | undefined = undefined, DependencyMap extends ProviderDependencyMap = ProviderDependencyMap, OutputMap extends ProviderExportMap | undefined = undefined>(task: GeneratorTask<ExportMap, DependencyMap, OutputMap>): GeneratorTask<ExportMap, DependencyMap, OutputMap>;
export interface CreateGeneratorContext {
    id: string;
    generatorName: string;
    generatorBaseDirectory: string;
}
/**
 * A generator bundle contains the built generator and its children
 */
export interface GeneratorBundle<TaskConfigs extends Record<string, AnyGeneratorTask | undefined> = Record<string, AnyGeneratorTask | undefined>> {
    /**
     * The name of the generator
     */
    name: string;
    /**
     * The directory of the generator
     */
    directory: string;
    /**
     * The name of the generator instance (must be unique if in a list of children)
     */
    instanceName?: string;
    /**
     * The scopes of the generator
     */
    scopes: ProviderExportScope[];
    /**
     * The children of the generator
     */
    children: Record<string, undefined | GeneratorBundle | GeneratorBundle[]>;
    /**
     * The tasks of the generator
     */
    tasks: TaskConfigs;
    /**
     * The phases of the generator that may only contain
     * dynamic tasks and thus need to be pre-registered
     */
    preRegisteredPhases?: TaskPhase[];
}
export {};
//# sourceMappingURL=generators.d.ts.map