@bjorntech/alchemy-azure 0.2.0-beta.57

package/src/Providers.ts

@@ -0,0 +1,125 @@
+import * as Layer from "effect/Layer";
+import { CredentialsStoreLive } from "alchemy/Auth/Credentials";
+import { ProfileLive } from "alchemy/Auth/Profile";
+import * as Provider from "alchemy/Provider";
+import { AzureAuth } from "./AuthProvider.ts";
+import { AzureClientsLive } from "./Clients.ts";
+import { BlobContainer, BlobContainerProvider } from "./BlobContainer.ts";
+import * as Credentials from "./Credentials.ts";
+import { ContainerApp, ContainerAppProvider } from "./ContainerApp.ts";
+import {
+  ContainerAppEnvironment,
+  ContainerAppEnvironmentProvider,
+} from "./ContainerAppEnvironment.ts";
+import { ContainerImage, ContainerImageProvider } from "./ContainerImage.ts";
+import { ContainerRegistry, ContainerRegistryProvider } from "./ContainerRegistry.ts";
+import {
+  AppService,
+  AppServicePlan,
+  AppServicePlanProvider,
+  AppServiceProvider,
+  CognitiveServices,
+  CognitiveServicesProvider,
+  ContainerInstance,
+  ContainerInstanceProvider,
+  CosmosDBAccount,
+  CosmosDBAccountProvider,
+  FunctionApp,
+  FunctionAppProvider,
+  KeyVault,
+  KeyVaultProvider,
+  NetworkSecurityGroup,
+  NetworkSecurityGroupProvider,
+  PublicIPAddress,
+  PublicIPAddressProvider,
+  ServiceBus,
+  ServiceBusProvider,
+  SqlDatabase,
+  SqlDatabaseProvider,
+  SqlServer,
+  SqlServerProvider,
+  StaticWebApp,
+  StaticWebAppProvider,
+  UserAssignedIdentity,
+  UserAssignedIdentityProvider,
+  VirtualMachine,
+  VirtualMachineProvider,
+  VirtualNetwork,
+  VirtualNetworkProvider,
+} from "./MoreResources.ts";
+import { ResourceGroup, ResourceGroupProvider } from "./ResourceGroup.ts";
+import {
+  ResourceProviderRegistration,
+  ResourceProviderRegistrationProvider,
+} from "./ResourceProviderRegistration.ts";
+import { StorageAccount, StorageAccountProvider } from "./StorageAccount.ts";
+
+export class Providers extends Provider.ProviderCollection<Providers>()("Azure") {}
+
+export type ProviderRequirements = Layer.Services<ReturnType<typeof providers>>;
+
+export const providers = () =>
+  Layer.effect(
+    Providers,
+    Provider.collection([
+      ResourceGroup,
+      ResourceProviderRegistration,
+      StorageAccount,
+      BlobContainer,
+      UserAssignedIdentity,
+      VirtualNetwork,
+      NetworkSecurityGroup,
+      PublicIPAddress,
+      CognitiveServices,
+      ServiceBus,
+      CosmosDBAccount,
+      SqlServer,
+      SqlDatabase,
+      KeyVault,
+      AppServicePlan,
+      AppService,
+      FunctionApp,
+      StaticWebApp,
+      ContainerInstance,
+      ContainerAppEnvironment,
+      ContainerRegistry,
+      ContainerImage,
+      ContainerApp,
+      VirtualMachine,
+    ]),
+  ).pipe(
+    Layer.provide(
+      Layer.mergeAll(
+        ResourceGroupProvider(),
+        ResourceProviderRegistrationProvider(),
+        StorageAccountProvider(),
+        BlobContainerProvider(),
+        UserAssignedIdentityProvider(),
+        VirtualNetworkProvider(),
+        NetworkSecurityGroupProvider(),
+        PublicIPAddressProvider(),
+        CognitiveServicesProvider(),
+        ServiceBusProvider(),
+        CosmosDBAccountProvider(),
+        SqlServerProvider(),
+        SqlDatabaseProvider(),
+        KeyVaultProvider(),
+        AppServicePlanProvider(),
+        AppServiceProvider(),
+        FunctionAppProvider(),
+        StaticWebAppProvider(),
+        ContainerInstanceProvider(),
+        ContainerAppEnvironmentProvider(),
+        ContainerRegistryProvider(),
+        ContainerImageProvider(),
+        ContainerAppProvider(),
+        VirtualMachineProvider(),
+      ),
+    ),
+    Layer.provide(AzureClientsLive),
+    Layer.provideMerge(Credentials.fromAuthProvider()),
+    Layer.provideMerge(AzureAuth),
+    Layer.provideMerge(ProfileLive),
+    Layer.provideMerge(CredentialsStoreLive),
+    Layer.orDie,
+  );

package/src/ResourceGroup.ts

@@ -0,0 +1,171 @@
+import type { ResourceGroup as AzureResourceGroup } from "@azure/arm-resources";
+import * as Effect from "effect/Effect";
+import { Unowned } from "alchemy/AdoptPolicy";
+import { isResolved } from "alchemy/Diff";
+import { Resource } from "alchemy";
+import * as Provider from "alchemy/Provider";
+import { makeAzureClients } from "./Clients.ts";
+import { azureError, isNotFound } from "./Errors.ts";
+import { collectAzurePages, diffValueEqual, makePhysicalNames } from "./Internal.ts";
+import type { Providers } from "./Providers.ts";
+
+export interface ResourceGroupProps {
+  /**
+   * Resource group name. Defaults to a deterministic physical name.
+   */
+  name?: string;
+  /**
+   * Azure region, for example `eastus`, `westus2`, or `westeurope`.
+   */
+  location: string;
+  /**
+   * Tags to apply to the resource group.
+   */
+  tags?: Record<string, string>;
+  /**
+   * Whether to delete the resource group when removed from Alchemy.
+   *
+   * @default true
+   */
+  delete?: boolean;
+}
+
+export type ResourceGroup = Resource<
+  "Azure.ResourceGroup",
+  ResourceGroupProps,
+  {
+    name: string;
+    location: string;
+    resourceGroupId: string;
+    provisioningState?: string;
+    tags?: Record<string, string>;
+  },
+  never,
+  Providers
+>;
+
+/**
+ * Azure Resource Group — a logical container for Azure resources.
+ *
+ * @example Basic resource group
+ * ```ts
+ * const group = yield* Azure.ResourceGroup("Group", {
+ *   location: "westeurope",
+ *   tags: { app: "demo" },
+ * });
+ * ```
+ */
+export const ResourceGroup = Resource<ResourceGroup>("Azure.ResourceGroup");
+
+export const ResourceGroupProvider = () =>
+  Provider.effect(
+    ResourceGroup,
+    Effect.gen(function* () {
+      const clients = yield* makeAzureClients;
+      const names = yield* makePhysicalNames;
+
+      const resourceGroupName = (id: string, instanceId: string, name?: string) =>
+        names.physicalName(id, instanceId, name, { maxLength: 90 });
+
+      const toAttributes = (group: AzureResourceGroup) => {
+        if (!group.name || !group.id || !group.location) {
+          throw new Error("Azure returned an incomplete resource group response");
+        }
+        return {
+          name: group.name,
+          location: group.location,
+          resourceGroupId: group.id,
+          provisioningState: group.properties?.provisioningState,
+          tags: group.tags,
+        } satisfies ResourceGroup["Attributes"];
+      };
+
+      return ResourceGroup.Provider.of({
+        stables: ["name", "resourceGroupId"],
+        list: () =>
+          Effect.tryPromise({
+            try: () => collectAzurePages(clients.resources.resourceGroups.list()),
+            catch: (cause) => azureError({ operation: "list resource groups", cause }),
+          }).pipe(
+            Effect.map((groups) =>
+              groups
+                .filter((group) => group.tags?.["alchemy:logical-id"])
+                .map((group) => toAttributes(group)),
+            ),
+          ),
+        diff: Effect.fnUntraced(function* ({ id, instanceId, olds, news, output }) {
+          if (!isResolved(news)) return undefined;
+          if (!output) return undefined;
+          const name = resourceGroupName(id, instanceId, news.name);
+          const oldName = output.name;
+          if (name !== oldName || news.location !== output.location) {
+            return { action: "replace" } as const;
+          }
+          if (!diffValueEqual(olds.tags ?? {}, news.tags ?? {})) {
+            return { action: "update" } as const;
+          }
+          return undefined;
+        }),
+        read: Effect.fnUntraced(function* ({ id, instanceId, olds, output }) {
+          const name = output?.name ?? resourceGroupName(id, instanceId, olds?.name);
+          const group = yield* Effect.tryPromise({
+            try: () => clients.resources.resourceGroups.get(name),
+            catch: (cause) => azureError({ operation: "read resource group", resource: name, cause }),
+          }).pipe(Effect.catchIf(isNotFound, () => Effect.succeed(undefined)));
+          if (!group) return undefined;
+          const attrs = toAttributes(group);
+          return hasAlchemyTags(id, group.tags) ? attrs : Unowned(attrs);
+        }),
+        reconcile: Effect.fnUntraced(function* ({ id, instanceId, news }) {
+          const name = resourceGroupName(id, instanceId, news.name);
+          validateResourceGroupName(name);
+          const tags = withAlchemyTags(id, news.tags);
+          const group = yield* Effect.tryPromise({
+            try: () =>
+              clients.resources.resourceGroups.createOrUpdate(name, {
+                location: news.location,
+                tags,
+              }),
+            catch: (cause) =>
+              azureError({ operation: "reconcile resource group", resource: name, cause }),
+          });
+          return toAttributes(group);
+        }),
+        delete: Effect.fnUntraced(function* ({ olds, output, session }) {
+          if (olds.delete === false) return;
+          yield* session.note(`Deleting Azure resource group: ${output.name}`);
+          const poller = yield* Effect.tryPromise({
+            try: () => clients.resources.resourceGroups.beginDelete(output.name),
+            catch: (cause) => azureError({ operation: "delete resource group", resource: output.name, cause }),
+          }).pipe(Effect.catchIf(isNotFound, () => Effect.succeed(undefined)));
+          if (poller) {
+            yield* Effect.tryPromise({
+              try: () => poller.pollUntilDone(),
+              catch: (cause) => azureError({ operation: "wait for resource group deletion", resource: output.name, cause }),
+            }).pipe(
+              Effect.catchIf(isNotFound, () => Effect.void),
+            );
+          }
+        }),
+      });
+    }),
+  );
+
+function validateResourceGroupName(name: string) {
+  if (!/^[\w\-.()]{1,90}$/.test(name)) {
+    throw new Error(
+      `Azure resource group name "${name}" is invalid. It must be 1-90 characters and contain only letters, numbers, underscores, hyphens, periods, and parentheses.`,
+    );
+  }
+}
+
+export function withAlchemyTags(id: string, tags?: Record<string, string>) {
+  return {
+    ...tags,
+    "alchemy:logical-id": id,
+  };
+}
+
+export function hasAlchemyTags(id: string, tags: Record<string, string> | undefined) {
+  return tags?.["alchemy:logical-id"] === id;
+}

package/src/ResourceProviderRegistration.ts

@@ -0,0 +1,177 @@
+import type { Provider as AzureResourceProvider } from "@azure/arm-resources";
+import * as Effect from "effect/Effect";
+import { isResolved } from "alchemy/Diff";
+import { Resource } from "alchemy";
+import * as Provider from "alchemy/Provider";
+import { makeAzureClients } from "./Clients.ts";
+import { azureError, isNotFound } from "./Errors.ts";
+import { collectAzurePages } from "./Internal.ts";
+import type { Providers } from "./Providers.ts";
+
+export interface ResourceProviderRegistrationProps {
+  /** Azure resource provider namespace, for example `Microsoft.App`. */
+  namespace: string;
+  /** Seconds to wait for Azure to report `Registered`. @default 600 */
+  timeoutSeconds?: number;
+  /** Seconds between registration-state polls. @default 5 */
+  pollIntervalSeconds?: number;
+  /**
+   * Whether destroy should unregister the provider namespace.
+   *
+   * Defaults to false because provider registrations are subscription-scoped
+   * prerequisites and unregistering can break unrelated workloads.
+   */
+  unregisterOnDelete?: boolean;
+}
+
+export type ResourceProviderRegistration = Resource<
+  "Azure.ResourceProviderRegistration",
+  ResourceProviderRegistrationProps,
+  {
+    namespace: string;
+    registrationState?: string;
+    providerId?: string;
+    unregisterOnDelete: boolean;
+  },
+  never,
+  Providers
+>;
+
+export const ResourceProviderRegistration = Resource<ResourceProviderRegistration>(
+  "Azure.ResourceProviderRegistration",
+);
+
+export const ResourceProviderRegistrationProvider = () =>
+  Provider.effect(
+    ResourceProviderRegistration,
+    Effect.gen(function* () {
+      const clients = yield* makeAzureClients;
+
+      return ResourceProviderRegistration.Provider.of({
+        stables: ["namespace"],
+        list: () =>
+          Effect.tryPromise({
+            try: () => collectAzurePages(clients.resources.providers.list()),
+            catch: (cause) =>
+              azureError({ operation: "list Azure resource provider registrations", cause }),
+          }).pipe(
+            Effect.map((providers) => providers.map((provider) => toAttributes(provider, false))),
+          ),
+        diff: Effect.fnUntraced(function* ({ news, output }) {
+          if (!isResolved(news)) return undefined;
+          if (!output) return undefined;
+          if (normalizeNamespace(news.namespace) !== output.namespace) {
+            return { action: "replace" } as const;
+          }
+          return undefined;
+        }),
+        read: Effect.fnUntraced(function* ({ olds, output }) {
+          const namespace = output?.namespace ?? (olds ? normalizeNamespace(olds.namespace) : undefined);
+          if (!namespace) return undefined;
+          const provider = yield* getProvider(namespace);
+          return toAttributes(provider, output?.unregisterOnDelete ?? olds?.unregisterOnDelete ?? false);
+        }),
+        reconcile: Effect.fnUntraced(function* ({ news }) {
+          const namespace = normalizeNamespace(news.namespace);
+          validateNamespace(namespace);
+
+          const current = yield* getProvider(namespace);
+          if (current.registrationState === "Registered") {
+            return toAttributes(current, news.unregisterOnDelete ?? false);
+          }
+
+          yield* Effect.tryPromise({
+            try: () => clients.resources.providers.register(namespace),
+            catch: (cause) =>
+              azureError({
+                operation: "register Azure resource provider",
+                resource: namespace,
+                cause,
+              }),
+          });
+
+          const registered = yield* Effect.tryPromise({
+            try: () =>
+              waitForRegistered(
+                () => clients.resources.providers.get(namespace),
+                news.timeoutSeconds ?? 600,
+                news.pollIntervalSeconds ?? 5,
+              ),
+            catch: (cause) =>
+              azureError({
+                operation: "wait for Azure resource provider registration",
+                resource: namespace,
+                cause,
+              }),
+          });
+          return toAttributes(registered, news.unregisterOnDelete ?? false);
+        }),
+        delete: Effect.fnUntraced(function* ({ olds, output, session }) {
+          if (!olds.unregisterOnDelete && !output.unregisterOnDelete) return;
+          yield* session.note(`Unregistering Azure resource provider: ${output.namespace}`);
+          yield* Effect.tryPromise({
+            try: () => clients.resources.providers.unregister(output.namespace),
+            catch: (cause) =>
+              azureError({
+                operation: "unregister Azure resource provider",
+                resource: output.namespace,
+                cause,
+              }),
+          }).pipe(
+            Effect.catchIf(isNotFound, () => Effect.void),
+          );
+        }),
+      });
+
+      function getProvider(namespace: string) {
+        return Effect.tryPromise({
+          try: () => clients.resources.providers.get(namespace),
+          catch: (cause) =>
+            azureError({
+              operation: "read Azure resource provider registration",
+              resource: namespace,
+              cause,
+            }),
+        });
+      }
+    }),
+  );
+
+function toAttributes(provider: AzureResourceProvider, unregisterOnDelete: boolean) {
+  const namespace = normalizeNamespace(provider.namespace ?? provider.id?.split("/").pop() ?? "");
+  return {
+    namespace,
+    registrationState: provider.registrationState,
+    providerId: provider.id,
+    unregisterOnDelete,
+  } satisfies ResourceProviderRegistration["Attributes"];
+}
+
+function normalizeNamespace(namespace: string) {
+  return namespace.trim();
+}
+
+function validateNamespace(namespace: string) {
+  if (!/^[A-Za-z][A-Za-z0-9]*(\.[A-Za-z][A-Za-z0-9]*)+$/.test(namespace)) {
+    throw new Error(`Azure resource provider namespace "${namespace}" is invalid.`);
+  }
+}
+
+async function waitForRegistered(
+  getProvider: () => Promise<AzureResourceProvider>,
+  timeoutSeconds: number,
+  pollIntervalSeconds: number,
+) {
+  const deadline = Date.now() + timeoutSeconds * 1000;
+  let latest = await getProvider();
+  while (latest.registrationState !== "Registered") {
+    if (Date.now() >= deadline) {
+      throw new Error(
+        `Timed out waiting for ${latest.namespace ?? "provider"} to register; latest state: ${latest.registrationState ?? "unknown"}`,
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalSeconds * 1000));
+    latest = await getProvider();
+  }
+  return latest;
+}