Skip to content

Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.

5.3 KB
Raw Blame
import { DynamicSecretProviders } from "@app/hooks/api/dynamicSecret/types";

import { getDynamicSecretProviderRuntimeMetadata } from "./runtimeMetadata";
import type { TDynamicSecretProviderDefinition } from "./types";

export type TRegisteredDynamicSecretProviderDefinition = TDynamicSecretProviderDefinition<
  DynamicSecretProviders,
  // Provider value types remain available from each concrete definition. The
  // composition root intentionally erases them for heterogeneous lookup.
  any,
  any
>;

export type TDynamicSecretProviderDefinitionModule = {
  id: string;
  definitions: readonly TRegisteredDynamicSecretProviderDefinition[];
};

export const defineDynamicSecretProviderModule = <
  const TDefinitions extends readonly TRegisteredDynamicSecretProviderDefinition[]
>(module: {
  id: string;
  definitions: TDefinitions;
}) => module;

/** Product picker order. The registry exposes only registered entries. */
export const DYNAMIC_SECRET_PROVIDER_PICKER_ORDER = [
  DynamicSecretProviders.SqlDatabase,
  DynamicSecretProviders.Cassandra,
  DynamicSecretProviders.Redis,
  DynamicSecretProviders.AwsElastiCache,
  DynamicSecretProviders.AwsMemoryDb,
  DynamicSecretProviders.AwsIam,
  DynamicSecretProviders.MongoAtlas,
  DynamicSecretProviders.MongoDB,
  DynamicSecretProviders.ElasticSearch,
  DynamicSecretProviders.RabbitMq,
  DynamicSecretProviders.AzureEntraId,
  DynamicSecretProviders.AzureSqlDatabase,
  DynamicSecretProviders.Ldap,
  DynamicSecretProviders.SapHana,
  DynamicSecretProviders.SapAse,
  DynamicSecretProviders.Snowflake,
  DynamicSecretProviders.Totp,
  DynamicSecretProviders.Vertica,
  DynamicSecretProviders.Kubernetes,
  DynamicSecretProviders.GcpIam,
  DynamicSecretProviders.Github,
  DynamicSecretProviders.Couchbase,
  DynamicSecretProviders.Milvus,
  DynamicSecretProviders.Clickhouse,
  DynamicSecretProviders.Ssh,
  DynamicSecretProviders.IbmApiConnect,
  DynamicSecretProviders.Tailscale,
  DynamicSecretProviders.OAuth2,
  DynamicSecretProviders.Kafka
] as const satisfies readonly DynamicSecretProviders[];

type TProvidersMissingFromPickerOrder = Exclude<
  DynamicSecretProviders,
  (typeof DYNAMIC_SECRET_PROVIDER_PICKER_ORDER)[number]
>;
export const isDynamicSecretProviderPickerOrderExhaustive: [
  TProvidersMissingFromPickerOrder
] extends [never]
  ? true
  : TProvidersMissingFromPickerOrder = true;

const DYNAMIC_SECRET_PROVIDER_DOCS_SLUG: Partial<Record<DynamicSecretProviders, string>> = {
  [DynamicSecretProviders.SqlDatabase]: "postgresql",
  [DynamicSecretProviders.MongoAtlas]: "mongo-atlas"
};

export const createDynamicSecretProviderRegistry = (
  ...modules: readonly TDynamicSecretProviderDefinitionModule[]
) => {
  const definitions = new Map<DynamicSecretProviders, TRegisteredDynamicSecretProviderDefinition>();
  const moduleIds = new Set<string>();

  modules.forEach((module) => {
    if (moduleIds.has(module.id)) {
      throw new Error(
        `Dynamic-secret provider module "${module.id}" was registered more than once.`
      );
    }
    moduleIds.add(module.id);

    module.definitions.forEach((definition) => {
      if (definitions.has(definition.provider)) {
        throw new Error(
          `Dynamic-secret provider "${definition.provider}" was registered more than once.`
        );
      }
      definitions.set(definition.provider, definition);
    });
  });

  const providers = Object.freeze(
    DYNAMIC_SECRET_PROVIDER_PICKER_ORDER.filter((provider) => definitions.has(provider))
  );
  const registeredDefinitions = Object.freeze(
    providers.map(
      (provider) => definitions.get(provider) as TRegisteredDynamicSecretProviderDefinition
    )
  );

  return Object.freeze({
    providers,
    definitions: registeredDefinitions,
    hasDefinition: (provider: DynamicSecretProviders) => definitions.has(provider),
    getDefinition: (provider: DynamicSecretProviders) => definitions.get(provider),
    requireDefinition: (provider: DynamicSecretProviders) => {
      const definition = definitions.get(provider);
      if (!definition) {
        throw new Error(`Dynamic-secret provider "${provider}" is not registered.`);
      }
      return definition;
    },
    getLabel: (provider: DynamicSecretProviders) => definitions.get(provider)?.label,
    getPresentation: (provider: DynamicSecretProviders) =>
      definitions.has(provider)
        ? getDynamicSecretProviderRuntimeMetadata(provider).presentation
        : undefined,
    requirePresentation: (provider: DynamicSecretProviders) => {
      if (!definitions.has(provider)) {
        throw new Error(`Dynamic-secret provider "${provider}" is not registered.`);
      }
      return getDynamicSecretProviderRuntimeMetadata(provider).presentation;
    },
    getLeaseCapabilities: (provider: DynamicSecretProviders) =>
      definitions.has(provider)
        ? getDynamicSecretProviderRuntimeMetadata(provider).leaseCapabilities
        : undefined,
    requireLeaseCapabilities: (provider: DynamicSecretProviders) => {
      if (!definitions.has(provider)) {
        throw new Error(`Dynamic-secret provider "${provider}" is not registered.`);
      }
      return getDynamicSecretProviderRuntimeMetadata(provider).leaseCapabilities;
    },
    getDocsSlug: (provider: DynamicSecretProviders) =>
      DYNAMIC_SECRET_PROVIDER_DOCS_SLUG[provider] ?? provider
  });
};

export type TDynamicSecretProviderRegistry = ReturnType<typeof createDynamicSecretProviderRegistry>;