alchemy-effect 0.6.0 → 0.6.3

package/src/Kubernetes/client.ts

@@ -0,0 +1,298 @@
+import { AwsClient } from "aws4fetch";
+import { Credentials } from "@distilled.cloud/aws/Credentials";
+import { Region } from "@distilled.cloud/aws/Region";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Redacted from "effect/Redacted";
+import * as https from "node:https";
+import {
+  buildKubernetesObjectPath,
+  chunkByApplyRank,
+  kubernetesObjectKey,
+  sortRefsForDelete,
+  toKubernetesObjectRef,
+  type KubernetesObjectDefinition,
+  type KubernetesObjectRef,
+} from "./types.ts";
+
+export class KubernetesApiError extends Data.TaggedError("KubernetesApiError")<{
+  method: string;
+  path: string;
+  statusCode: number;
+  body: string;
+}> {}
+
+export interface KubernetesClusterConnection {
+  clusterName: string;
+  endpoint: string;
+  certificateAuthorityData: string;
+}
+
+const fieldManager = "alchemy-effect";
+
+const createBearerToken = Effect.fn(function* (clusterName: string) {
+  const credentials = yield* yield* Credentials;
+  const region = yield* Region;
+
+  const client = new AwsClient({
+    accessKeyId: Redacted.value(credentials.accessKeyId),
+    secretAccessKey: Redacted.value(credentials.secretAccessKey),
+    sessionToken: credentials.sessionToken
+      ? Redacted.value(credentials.sessionToken)
+      : undefined,
+    service: "sts",
+    region,
+  });
+
+  const presigned = yield* Effect.tryPromise(() =>
+    client.sign(
+      new Request(
+        `https://sts.${region}.amazonaws.com/?Action=GetCallerIdentity&Version=2011-06-15&X-Amz-Expires=60`,
+        {
+          headers: {
+            "x-k8s-aws-id": clusterName,
+          },
+        },
+      ),
+      {
+        aws: {
+          signQuery: true,
+          allHeaders: true,
+        },
+      },
+    ),
+  );
+
+  return `k8s-aws-v1.${Buffer.from(presigned.url).toString("base64url")}`;
+});
+
+const requestJson = Effect.fn(function* ({
+  connection,
+  method,
+  path,
+  body,
+}: {
+  connection: KubernetesClusterConnection;
+  method: string;
+  path: string;
+  body?: Record<string, unknown>;
+}) {
+  const token = yield* createBearerToken(connection.clusterName);
+  const url = new URL(path, connection.endpoint);
+  const payload = body ? JSON.stringify(body) : undefined;
+
+  return yield* Effect.tryPromise({
+    try: () =>
+      new Promise<unknown>((resolve, reject) => {
+        const request = https.request(
+          {
+            protocol: url.protocol,
+            hostname: url.hostname,
+            port: url.port || 443,
+            path: `${url.pathname}${url.search}`,
+            method,
+            headers: {
+              Authorization: `Bearer ${token}`,
+              Accept: "application/json",
+              ...(payload
+                ? {
+                    "Content-Type": "application/apply-patch+yaml",
+                    "Content-Length": Buffer.byteLength(payload),
+                  }
+                : {}),
+            },
+            ca: Buffer.from(
+              connection.certificateAuthorityData,
+              "base64",
+            ).toString("utf8"),
+          },
+          (response) => {
+            const chunks: Buffer[] = [];
+            response.on("data", (chunk) => {
+              chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            });
+            response.on("end", () => {
+              const responseBody = Buffer.concat(chunks).toString("utf8");
+              const statusCode = response.statusCode ?? 500;
+
+              if (statusCode < 200 || statusCode >= 300) {
+                reject(
+                  new KubernetesApiError({
+                    method,
+                    path,
+                    statusCode,
+                    body: responseBody,
+                  }),
+                );
+                return;
+              }
+
+              if (!responseBody.trim()) {
+                resolve(undefined);
+                return;
+              }
+
+              try {
+                resolve(JSON.parse(responseBody));
+              } catch {
+                resolve(responseBody);
+              }
+            });
+          },
+        );
+
+        request.on("error", reject);
+        if (payload) {
+          request.write(payload);
+        }
+        request.end();
+      }),
+    catch: (error) =>
+      error instanceof KubernetesApiError
+        ? error
+        : new Error(
+            `Failed Kubernetes ${method} ${path}: ${error instanceof Error ? error.message : String(error)}`,
+          ),
+  });
+});
+
+export const readObject = Effect.fn(function* ({
+  connection,
+  object,
+}: {
+  connection: KubernetesClusterConnection;
+  object: KubernetesObjectRef;
+}) {
+  return yield* requestJson({
+    connection,
+    method: "GET",
+    path: buildKubernetesObjectPath(object),
+  });
+});
+
+export const applyObject = Effect.fn(function* ({
+  connection,
+  object,
+}: {
+  connection: KubernetesClusterConnection;
+  object: KubernetesObjectDefinition;
+}) {
+  const path = `${buildKubernetesObjectPath(toKubernetesObjectRef(object))}?fieldManager=${fieldManager}&force=true`;
+
+  return yield* requestJson({
+    connection,
+    method: "PATCH",
+    path,
+    body: object,
+  });
+});
+
+export const deleteObject = Effect.fn(function* ({
+  connection,
+  object,
+}: {
+  connection: KubernetesClusterConnection;
+  object: KubernetesObjectRef;
+}) {
+  yield* requestJson({
+    connection,
+    method: "DELETE",
+    path: buildKubernetesObjectPath(object),
+  }).pipe(
+    Effect.catchIf(
+      (error): error is KubernetesApiError =>
+        error instanceof KubernetesApiError,
+      (error) => (error.statusCode === 404 ? Effect.void : Effect.fail(error)),
+    ),
+  );
+});
+
+export const reconcileObjects = Effect.fn(function* ({
+  connection,
+  previousObjects,
+  desiredObjects,
+}: {
+  connection: KubernetesClusterConnection;
+  previousObjects: ReadonlyArray<KubernetesObjectRef>;
+  desiredObjects: ReadonlyArray<KubernetesObjectDefinition>;
+}) {
+  const desiredRefs = desiredObjects.map(toKubernetesObjectRef);
+  const desiredKeys = new Set(desiredRefs.map(kubernetesObjectKey));
+
+  const removedObjects = previousObjects.filter(
+    (object) => !desiredKeys.has(kubernetesObjectKey(object)),
+  );
+
+  for (const object of sortRefsForDelete(removedObjects)) {
+    yield* deleteObject({
+      connection,
+      object,
+    });
+  }
+
+  for (const chunk of chunkByApplyRank(desiredObjects)) {
+    yield* Effect.forEach(
+      chunk,
+      (object) =>
+        applyObject({
+          connection,
+          object,
+        }),
+      {
+        concurrency: "unbounded",
+      },
+    );
+  }
+
+  return desiredRefs;
+});
+
+export const deleteObjects = Effect.fn(function* ({
+  connection,
+  objects,
+}: {
+  connection: KubernetesClusterConnection;
+  objects: ReadonlyArray<KubernetesObjectRef>;
+}) {
+  for (const object of sortRefsForDelete(objects)) {
+    yield* deleteObject({
+      connection,
+      object,
+    });
+  }
+});
+
+export const createClient = (connection: KubernetesClusterConnection) => ({
+  readObject: (object: KubernetesObjectRef) =>
+    readObject({
+      connection,
+      object,
+    }),
+  applyObject: (object: KubernetesObjectDefinition) =>
+    applyObject({
+      connection,
+      object,
+    }),
+  deleteObject: (object: KubernetesObjectRef) =>
+    deleteObject({
+      connection,
+      object,
+    }),
+  reconcileObjects: ({
+    previousObjects,
+    desiredObjects,
+  }: {
+    previousObjects: ReadonlyArray<KubernetesObjectRef>;
+    desiredObjects: ReadonlyArray<KubernetesObjectDefinition>;
+  }) =>
+    reconcileObjects({
+      connection,
+      previousObjects,
+      desiredObjects,
+    }),
+  deleteObjects: (objects: ReadonlyArray<KubernetesObjectRef>) =>
+    deleteObjects({
+      connection,
+      objects,
+    }),
+});

package/src/Kubernetes/common.ts

@@ -0,0 +1,23 @@
+import type { ObjectRef } from "./Object.ts";
+
+export const namespaceNameOf = (
+  namespace: string | { name: string } | ObjectRef,
+): string => (typeof namespace === "string" ? namespace : namespace.name);
+
+export const objectNameOf = (
+  object: string | { name: string } | ObjectRef,
+): string => (typeof object === "string" ? object : object.name);
+
+export const metadataWithNamespace = (
+  namespace: string | { name: string } | ObjectRef,
+  metadata?: {
+    name?: string;
+    labels?: Record<string, string>;
+    annotations?: Record<string, string>;
+  },
+) => ({
+  name: metadata?.name,
+  namespace: namespaceNameOf(namespace),
+  labels: metadata?.labels,
+  annotations: metadata?.annotations,
+});

package/src/Kubernetes/index.ts

@@ -0,0 +1,11 @@
+export * from "./Object.ts";
+
+export * from "./client.ts";
+export * from "./common.ts";
+export * from "./ConfigMap.ts";
+export * from "./Deployment.ts";
+export * from "./Job.ts";
+export * from "./Namespace.ts";
+export * from "./Service.ts";
+export * from "./ServiceAccount.ts";
+export * from "./types.ts";

package/src/Kubernetes/types.ts

@@ -0,0 +1,177 @@
+export interface KubernetesObjectMetadata {
+  name: string;
+  namespace?: string;
+  labels?: Record<string, string>;
+  annotations?: Record<string, string>;
+}
+
+export type KubernetesObjectDefinition = {
+  apiVersion: string;
+  kind: string;
+  metadata: KubernetesObjectMetadata;
+} & Record<string, unknown>;
+
+export interface KubernetesObjectRef {
+  apiVersion: string;
+  kind: string;
+  name: string;
+  namespace?: string;
+}
+
+export interface KubernetesObjectBinding {
+  type: "kubernetes-object";
+  object: KubernetesObjectDefinition;
+}
+
+type KubernetesObjectScope = "Cluster" | "Namespaced";
+
+interface KubernetesObjectKindSpec {
+  plural: string;
+  scope: KubernetesObjectScope;
+  applyRank: number;
+}
+
+const supportedKinds: Record<string, KubernetesObjectKindSpec> = {
+  "v1/Namespace": {
+    plural: "namespaces",
+    scope: "Cluster",
+    applyRank: 10,
+  },
+  "v1/ServiceAccount": {
+    plural: "serviceaccounts",
+    scope: "Namespaced",
+    applyRank: 20,
+  },
+  "v1/ConfigMap": {
+    plural: "configmaps",
+    scope: "Namespaced",
+    applyRank: 30,
+  },
+  "v1/Service": {
+    plural: "services",
+    scope: "Namespaced",
+    applyRank: 40,
+  },
+  "apps/v1/Deployment": {
+    plural: "deployments",
+    scope: "Namespaced",
+    applyRank: 50,
+  },
+  "batch/v1/Job": {
+    plural: "jobs",
+    scope: "Namespaced",
+    applyRank: 60,
+  },
+};
+
+const objectTypeKey = (
+  input: Pick<KubernetesObjectRef, "apiVersion" | "kind">,
+) => `${input.apiVersion}/${input.kind}`;
+
+export const getKubernetesKindSpec = (
+  input: Pick<KubernetesObjectRef, "apiVersion" | "kind">,
+) => {
+  const spec = supportedKinds[objectTypeKey(input)];
+  if (!spec) {
+    throw new Error(
+      `Unsupported Kubernetes object ${input.apiVersion}/${input.kind}`,
+    );
+  }
+  return spec;
+};
+
+export const toKubernetesObjectRef = (
+  object: KubernetesObjectDefinition,
+): KubernetesObjectRef => ({
+  apiVersion: object.apiVersion,
+  kind: object.kind,
+  name: object.metadata.name,
+  namespace: object.metadata.namespace,
+});
+
+export const kubernetesObjectKey = (
+  input: Pick<
+    KubernetesObjectRef,
+    "apiVersion" | "kind" | "name" | "namespace"
+  >,
+) =>
+  [
+    input.apiVersion,
+    input.kind,
+    input.namespace ?? "_cluster",
+    input.name,
+  ].join("/");
+
+export const kubernetesBindingSid = (object: KubernetesObjectDefinition) =>
+  `Kubernetes.Object(${kubernetesObjectKey(toKubernetesObjectRef(object))})`;
+
+const compareRefs = (a: KubernetesObjectRef, b: KubernetesObjectRef) =>
+  kubernetesObjectKey(a).localeCompare(kubernetesObjectKey(b));
+
+export const sortObjectsForApply = (
+  objects: ReadonlyArray<KubernetesObjectDefinition>,
+) =>
+  [...objects].sort(
+    (a, b) =>
+      getKubernetesKindSpec(a).applyRank - getKubernetesKindSpec(b).applyRank ||
+      compareRefs(toKubernetesObjectRef(a), toKubernetesObjectRef(b)),
+  );
+
+export const sortRefsForDelete = (
+  objects: ReadonlyArray<KubernetesObjectRef>,
+) =>
+  [...objects].sort(
+    (a, b) =>
+      getKubernetesKindSpec(b).applyRank - getKubernetesKindSpec(a).applyRank ||
+      compareRefs(a, b),
+  );
+
+export const chunkByApplyRank = (
+  objects: ReadonlyArray<KubernetesObjectDefinition>,
+) => {
+  const chunks: KubernetesObjectDefinition[][] = [];
+
+  for (const object of sortObjectsForApply(objects)) {
+    const rank = getKubernetesKindSpec(object).applyRank;
+    const current = chunks[chunks.length - 1];
+    if (!current) {
+      chunks.push([object]);
+      continue;
+    }
+
+    const currentRank = getKubernetesKindSpec(current[0]).applyRank;
+    if (currentRank === rank) {
+      current.push(object);
+    } else {
+      chunks.push([object]);
+    }
+  }
+
+  return chunks;
+};
+
+export const buildKubernetesObjectPath = (
+  input: Pick<
+    KubernetesObjectRef,
+    "apiVersion" | "kind" | "name" | "namespace"
+  >,
+) => {
+  const spec = getKubernetesKindSpec(input);
+  const [group, version] = input.apiVersion.includes("/")
+    ? input.apiVersion.split("/", 2)
+    : [undefined, input.apiVersion];
+
+  const base = group ? `/apis/${group}/${version}` : `/api/${version}`;
+
+  if (spec.scope === "Namespaced") {
+    if (!input.namespace) {
+      throw new Error(
+        `Kubernetes object ${input.apiVersion}/${input.kind}/${input.name} requires a namespace`,
+      );
+    }
+
+    return `${base}/namespaces/${input.namespace}/${spec.plural}/${input.name}`;
+  }
+
+  return `${base}/${spec.plural}/${input.name}`;
+};

package/src/Namespace.ts

@@ -0,0 +1,64 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as ServiceMap from "effect/ServiceMap";
+
+export interface NamespaceNode {
+  Id: string;
+  Parent?: NamespaceNode;
+}
+
+export class Namespace extends ServiceMap.Service<Namespace, NamespaceNode>()(
+  "Alchemy/Namespace",
+) {}
+
+export function push<const Id extends string, A, Err = never, Req = never>(
+  id: Id,
+  eff: Effect.Effect<A, Err, Req>,
+): Effect.Effect<A, Err, Req>;
+
+export function push<const Id extends string>(
+  id: Id,
+): <A, Err = never, Req = never>(
+  eff: Effect.Effect<A, Err, Req>,
+) => Effect.Effect<A, Err, Req>;
+
+export function push(id: string, eff?: Effect.Effect<any, any, any>) {
+  return eff
+    ? Effect.flatMap(CurrentNamespace, (parent) =>
+        Effect.provideService(eff, Namespace, {
+          Id: id,
+          Parent: parent,
+        }),
+      )
+    : (eff: Effect.Effect<any, any, any>) => push(id, eff);
+}
+
+export const set = (namespace: string | NamespaceNode) =>
+  Effect.provideService(
+    Namespace,
+    typeof namespace === "string" ? { Id: namespace } : namespace,
+  );
+
+export const CurrentNamespace = Effect.serviceOption(Namespace)
+  .asEffect()
+  .pipe(Effect.map(Option.getOrUndefined));
+
+export const CurrentChain = CurrentNamespace.asEffect().pipe(
+  Effect.map(function findRoot(ns): string[] {
+    if (ns?.Parent) {
+      return [ns.Id, ...findRoot(ns.Parent)];
+    }
+    return ns ? [ns.Id] : [];
+  }),
+);
+
+export const Parent = Namespace.asEffect().pipe(Effect.map((ns) => ns?.Parent));
+
+export const Root = Namespace.asEffect().pipe(
+  Effect.map(function findRoot(ns) {
+    if (ns.Parent) {
+      return findRoot(ns.Parent);
+    }
+    return ns;
+  }),
+);