import { SourceControlProviderKind } from "@t3tools/contracts";
import * as Cache from "effect/Cache";
import * as Context from "effect/Context";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as Equal from "effect/Equal";
import * as Exit from "effect/Exit";
import * as Hash from "effect/Hash";
import * as Layer from "effect/Layer";
import * as Stream from "effect/Stream";
import {
SourceControlProviderError,
type SourceControlProviderDiscoveryItem,
} from "@t3tools/contracts";
import * as BuiltInDrivers from "./builtInDrivers.ts";
import { sourceControlDefinitions } from "./sourceControlDefinitions.ts";
import * as SourceControlProvider from "@t3tools/source-control-core/server/SourceControlProvider";
import {
probeSourceControlProvider,
refineUnknownRemoteProvider,
type SourceControlProviderDiscoverySpec,
type UnknownRemoteVerdict,
} from "@t3tools/source-control-core/server/discovery";
import * as SourceControlHost from "@t3tools/source-control-core/server/SourceControlHost";
import * as ServerConfig from "../config.ts";
import * as ServerSettings from "../serverSettings.ts";
import * as VcsDriverRegistry from "../vcs/VcsDriverRegistry.ts";
const PROVIDER_DETECTION_CACHE_CAPACITY = 2_048;
const PROVIDER_DETECTION_CACHE_TTL = Duration.seconds(5);
const UNKNOWN_REMOTE_CACHE_CAPACITY = 512;
const UNKNOWN_REMOTE_CACHE_TTL = Duration.minutes(5);
export interface SourceControlProviderRegistration {
readonly kind: SourceControlProviderKind;
readonly provider: SourceControlProvider.SourceControlProvider["Service"];
readonly discovery: SourceControlProviderDiscoverySpec;
}
export interface SourceControlProviderHandle {
readonly provider: SourceControlProvider.SourceControlProvider["Service"];
readonly context: SourceControlProvider.SourceControlProviderContext | null;
}
export class SourceControlProviderRegistry extends Context.Service<
SourceControlProviderRegistry,
{
readonly resolveLink: SourceControlProvider.ResolveSourceControlLink;
readonly get: (
kind: SourceControlProviderKind,
) => Effect.Effect<
SourceControlProvider.SourceControlProvider["Service"],
SourceControlProviderError
>;
readonly resolveHandle: (input: {
readonly cwd: string;
readonly context?: SourceControlProvider.SourceControlProviderContext;
}) => Effect.Effect<SourceControlProviderHandle, SourceControlProviderError>;
readonly resolve: (input: {
readonly cwd: string;
}) => Effect.Effect<
SourceControlProvider.SourceControlProvider["Service"],
SourceControlProviderError
>;
readonly discover: Effect.Effect<ReadonlyArray<SourceControlProviderDiscoveryItem>>;
}
>()("t3/sourceControl/SourceControlProviderRegistry") {}
function unsupportedProvider(
kind: SourceControlProviderKind,
): SourceControlProvider.SourceControlProvider["Service"] {
// Binding context does not create a second provider-operation span.
return SourceControlProvider.SourceControlProvider.of({
kind,
// Unknown hosts have no readable change requests; return none to avoid poll warnings on every refresh.
listChangeRequests: (input) =>
kind === "unknown"
? Effect.succeed([])
: new SourceControlProviderError({
provider: kind,
operation: "listChangeRequests",
cwd: input.cwd,
detail: `No ${kind} source control provider is registered.`,
}),
getChangeRequest: (input) =>
new SourceControlProviderError({
provider: kind,
operation: "getChangeRequest",
cwd: input.cwd,
reference: SourceControlProvider.transportSafeSourceControlErrorValue(input.reference),
detail: `No ${kind} source control provider is registered.`,
}),
createChangeRequest: (input) =>
new SourceControlProviderError({
provider: kind,
operation: "createChangeRequest",
cwd: input.cwd,
reference: SourceControlProvider.transportSafeSourceControlErrorValue(input.headSelector),
detail: `No ${kind} source control provider is registered.`,
}),
getRepositoryCloneUrls: (input) =>
new SourceControlProviderError({
provider: kind,
operation: "getRepositoryCloneUrls",
cwd: input.cwd,
repository: SourceControlProvider.transportSafeSourceControlErrorValue(input.repository),
detail: `No ${kind} source control provider is registered.`,
}),
createRepository: (input) =>
new SourceControlProviderError({
provider: kind,
operation: "createRepository",
cwd: input.cwd,
repository: SourceControlProvider.transportSafeSourceControlErrorValue(input.repository),
detail: `No ${kind} source control provider is registered.`,
}),
getDefaultBranch: (input) =>
new SourceControlProviderError({
provider: kind,
operation: "getDefaultBranch",
cwd: input.cwd,
detail: `No ${kind} source control provider is registered.`,
}),
checkoutChangeRequest: (input) =>
new SourceControlProviderError({
provider: kind,
operation: "checkoutChangeRequest",
cwd: input.cwd,
reference: SourceControlProvider.transportSafeSourceControlErrorValue(input.reference),
detail: `No ${kind} source control provider is registered.`,
}),
});
}
function selectProviderContext(
remotes: ReadonlyArray<{
readonly name: string;
readonly url: string;
}>,
): SourceControlProvider.SourceControlProviderContext | null {
const candidates: Array<SourceControlProvider.SourceControlProviderContext> = [];
for (const remote of remotes) {
const provider = sourceControlDefinitions.recognizeRemote(remote.url);
if (provider) {
candidates.push({
provider,
remoteName: remote.name,
remoteUrl: remote.url,
});
}
}
return (
candidates.find((candidate) => candidate.remoteName === "origin") ??
candidates.find((candidate) => candidate.provider.kind !== "unknown") ??
candidates[0] ??
null
);
}
// Failed probes are not cached, so cwd is irrelevant; equality ignores lookup, unlike Data.Class.
class UnknownRemoteLookup {
readonly key: string;
readonly lookup: Effect.Effect<UnknownRemoteVerdict>;
constructor(
context: SourceControlProvider.SourceControlProviderContext,
lookup: Effect.Effect<UnknownRemoteVerdict>,
) {
this.lookup = lookup;
this.key = [
context.provider.name,
context.provider.baseUrl,
context.remoteUrl.trim().replace(/(?<!\/\/[^/]*)[^/:]+\/[^/:]+\/?$/u, ""),
context.requestedHost ?? "",
].join("\n");
}
[Equal.symbol](that: unknown): boolean {
return that instanceof UnknownRemoteLookup && that.key === this.key;
}
[Hash.symbol](): number {
return Hash.string(this.key);
}
}
function bindProviderContext(
provider: SourceControlProvider.SourceControlProvider["Service"],
context: SourceControlProvider.SourceControlProviderContext | null,
): SourceControlProvider.SourceControlProvider["Service"] {
if (context === null) {
return provider;
}
return SourceControlProvider.SourceControlProvider.of({
...provider,
listChangeRequests: Effect.fnUntraced(function* (input) {
return yield* provider.listChangeRequests({
...input,
context: input.context ?? context,
});
}),
getChangeRequest: Effect.fnUntraced(function* (input) {
return yield* provider.getChangeRequest({
...input,
context: input.context ?? context,
});
}),
createChangeRequest: Effect.fnUntraced(function* (input) {
return yield* provider.createChangeRequest({
...input,
context: input.context ?? context,
});
}),
getRepositoryCloneUrls: Effect.fnUntraced(function* (input) {
return yield* provider.getRepositoryCloneUrls({
...input,
context: input.context ?? context,
});
}),
createRepository: Effect.fnUntraced(function* (input) {
return yield* provider.createRepository(input);
}),
getDefaultBranch: Effect.fnUntraced(function* (input) {
return yield* provider.getDefaultBranch({
...input,
context: input.context ?? context,
});
}),
checkoutChangeRequest: Effect.fnUntraced(function* (input) {
return yield* provider.checkoutChangeRequest({
...input,
context: input.context ?? context,
});
}),
});
}
/** @public */
export const makeWithProviders = Effect.fn("makeSourceControlProviderRegistryWithProviders")(
function* (registrations: ReadonlyArray<SourceControlProviderRegistration>) {
const config = yield* ServerConfig.ServerConfig;
const serverSettings = yield* ServerSettings.ServerSettingsService;
const { process } = yield* SourceControlHost.SourceControlHost;
const vcsRegistry = yield* VcsDriverRegistry.VcsDriverRegistry;
const providers = new Map<
SourceControlProviderKind,
SourceControlProvider.SourceControlProvider["Service"]
>(registrations.map((registration) => [registration.kind, registration.provider]));
const discoverySpecs = registrations.map((registration) => registration.discovery);
const get: SourceControlProviderRegistry["Service"]["get"] = (kind) =>
Effect.succeed(providers.get(kind) ?? unsupportedProvider(kind));
const unknownRemoteCache = yield* Cache.makeWith(
(request: UnknownRemoteLookup) => request.lookup,
{
capacity: UNKNOWN_REMOTE_CACHE_CAPACITY,
timeToLive: (exit) =>
Exit.isSuccess(exit) && exit.value.settled ? UNKNOWN_REMOTE_CACHE_TTL : Duration.zero,
},
);
const settingsChanges = yield* serverSettings.subscribeChanges;
yield* Stream.runForEach(settingsChanges, () => Cache.invalidateAll(unknownRemoteCache)).pipe(
Effect.forkScoped,
);
const refineContext = (
cwd: string,
context: SourceControlProvider.SourceControlProviderContext | null,
): Effect.Effect<SourceControlProvider.SourceControlProviderContext | null> =>
context === null || context.provider.kind !== "unknown"
? Effect.succeed(context)
: Cache.get(
unknownRemoteCache,
new UnknownRemoteLookup(
context,
refineUnknownRemoteProvider({ specs: discoverySpecs, process, cwd, context }),
),
).pipe(Effect.map(({ provider }) => (provider ? { ...context, provider } : context)));
const detectProviderContext = Effect.fn("SourceControlProviderRegistry.detectProviderContext")(
function* (cwd: string) {
const handle = yield* vcsRegistry.resolve({ cwd }).pipe(
Effect.mapError(
(error) =>
new SourceControlProviderError({
provider: SourceControlProviderKind.make("unknown"),
operation: "detectProvider",
cwd,
detail: "Failed to detect source control provider.",
cause: error,
}),
),
);
const remotes = yield* handle.driver.listRemotes(cwd).pipe(
Effect.mapError(
(error) =>
new SourceControlProviderError({
provider: SourceControlProviderKind.make("unknown"),
operation: "detectProvider",
cwd,
detail: "Failed to detect source control provider.",
cause: error,
}),
),
);
return yield* refineContext(cwd, selectProviderContext(remotes.remotes));
},
);
const providerContextCache = yield* Cache.makeWith<
string,
SourceControlProvider.SourceControlProviderContext | null,
SourceControlProviderError
>(detectProviderContext, {
capacity: PROVIDER_DETECTION_CACHE_CAPACITY,
timeToLive: (exit) => (Exit.isSuccess(exit) ? PROVIDER_DETECTION_CACHE_TTL : Duration.zero),
});
const resolveHandle: SourceControlProviderRegistry["Service"]["resolveHandle"] = (input) =>
(input.context === undefined
? Cache.get(providerContextCache, input.cwd)
: refineContext(input.cwd, input.context)
).pipe(
Effect.map((context) => {
const kind = context?.provider.kind ?? SourceControlProviderKind.make("unknown");
const provider = providers.get(kind) ?? unsupportedProvider(kind);
return {
provider: bindProviderContext(provider, context),
context,
} satisfies SourceControlProviderHandle;
}),
);
return SourceControlProviderRegistry.of({
resolveLink: (input) => {
if (input.url.protocol !== "https:" || input.url.username || input.url.password) {
return undefined;
}
const kind = sourceControlDefinitions.recognizeRemote(input.url.href)?.kind;
return kind ? providers.get(kind)?.resolveLink?.(input) : undefined;
},
get,
resolveHandle,
resolve: Effect.fn("SourceControlProviderRegistry.resolve")(function (input) {
return resolveHandle(input).pipe(Effect.map((handle) => handle.provider));
}),
discover: Effect.forEach(
discoverySpecs,
(spec) =>
probeSourceControlProvider({
spec,
process,
cwd: config.cwd,
}),
{ concurrency: "unbounded" },
),
});
},
);
const make = Effect.gen(function* () {
const drivers = yield* BuiltInDrivers.SourceControlDrivers;
return yield* makeWithProviders(
drivers.map(({ driver, instance }): SourceControlProviderRegistration => ({
kind: driver.kind,
provider: instance.sourceControl,
discovery: instance.discovery,
})),
);
});
export const layer = Layer.effect(SourceControlProviderRegistry, make);