alchemy-effect 0.6.0 → 0.6.2

package/src/Input.ts

@@ -0,0 +1,91 @@
+import type { Effect } from "effect/Effect";
+import type * as S from "effect/Schema";
+import type { Primitive } from ".//Util/data.ts";
+import type { Output } from "./Output.ts";
+
+export type Function = (...args: any[]) => any;
+export type Constructor = new (...args: any[]) => any;
+type PolicyLike = { kind: "alchemy/Policy" };
+
+export type Input<T> =
+  | T
+  | Output<T>
+  // TODO(sam): extract Requirements in Resource
+  | Effect<T, any, any>
+  | (T extends S.Schema<any>
+      ? never
+      :
+          | Output<T, any>
+          | (T extends Primitive
+              ? never
+              : T extends any[]
+                ? number extends T["length"]
+                  ? Input<T[number]>[]
+                  : Inputs<T>
+                : T extends object
+                  ? { [K in keyof T]: Input<T[K]> }
+                  : never));
+
+export type InputProps<
+  T extends Record<string, any>,
+  Static extends keyof T = never,
+> = {
+  [K in keyof T]: K extends Static ? T[K] : Input<T[K]>;
+};
+
+export declare namespace Input {
+  export type Resolve<T> = T extends {
+    Type: string;
+    Attributes: infer Attributes;
+  }
+    ? {
+        [K in keyof Attributes]: Resolve<Attributes[K]>;
+      }
+    : T extends Output<infer U>
+      ? U
+      : T extends
+            | Primitive
+            | Constructor
+            | Function
+            | S.Schema<any>
+            | PolicyLike
+        ? T
+        : T extends any[]
+          ? ResolveArray<T>
+          : T extends Record<string, any>
+            ? {
+                [k in keyof T]: Input.Resolve<T[k]>;
+              }
+            : never;
+
+  export type ResolveArray<T extends any[]> = number extends T["length"]
+    ? Resolve<T[number]>[]
+    : ResolveTuple<T>;
+
+  export type ResolveTuple<
+    T extends any[],
+    // TODO(sam): I added the accumulator because it resolved infinite type instantiation
+    Accum extends any[] = [],
+  > = T extends [infer H, ...infer Tail]
+    ? ResolveTuple<Tail, [...Accum, Input.Resolve<H>]>
+    : Accum;
+
+  export type ResolveProps<Props extends Record<string, any>> = {
+    [k in keyof Props]: Input.Resolve<Props[k]>;
+  };
+
+  export type ResolveOpaque<T> =
+    // use true extends IsOut to avoid distribution in the case where we have an Out<T>
+    // because T is a clean type, e.g. Input<SubnetProps> should just be SubnetProps (don't bother resolving the recursive input type variants)
+    true extends IsOut<T> ? ResolveOut<T> : Resolve<T>;
+  export type IsOut<T> = T extends Output<infer _U> ? true : never;
+
+  export type ResolveOut<T> = T extends Output<infer U> ? U : never;
+}
+
+export type Inputs<T extends any[], Out extends any[] = []> = T extends [
+  infer H,
+  ...infer T,
+]
+  ? Inputs<T, [...Out, Input<H>]>
+  : Out;

package/src/InstanceId.ts

@@ -0,0 +1,19 @@
+import * as Effect from "effect/Effect";
+import * as ServiceMap from "effect/ServiceMap";
+
+/** A 16-byte (128-bit) random hex-encoded string representing an physical instance of a logical resource */
+export class InstanceId extends ServiceMap.Service<InstanceId, string>()(
+  "instance-id",
+) {}
+
+/**
+ * @returns Hex-encoded instance ID (16 random bytes)
+ */
+export const generateInstanceId = () =>
+  Effect.sync(() => {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    return Array.from(bytes)
+      .map((b) => b.toString(16).padStart(2, "0"))
+      .join("");
+  });

package/src/Kubernetes/ConfigMap.ts

@@ -0,0 +1,59 @@
+import type { Cluster } from "../AWS/EKS/Cluster.ts";
+import { metadataWithNamespace } from "./common.ts";
+import { Object, type ObjectRef } from "./Object.ts";
+
+export interface ConfigMapProps {
+  /**
+   * Target EKS cluster.
+   */
+  cluster: Cluster;
+  /**
+   * Namespace name or namespace helper result.
+   */
+  namespace: string | { name: string } | ObjectRef;
+  /**
+   * Optional explicit config map name. Defaults to the logical id.
+   */
+  name?: string;
+  /**
+   * Config map string data.
+   */
+  data?: Record<string, string>;
+  /**
+   * Config map labels.
+   */
+  labels?: Record<string, string>;
+  /**
+   * Config map annotations.
+   */
+  annotations?: Record<string, string>;
+}
+
+/**
+ * A Kubernetes config map bound to an EKS cluster.
+ *
+ * @example Create a config map
+ * ```typescript
+ * const config = yield* ConfigMap("app-config", {
+ *   cluster,
+ *   namespace: "default",
+ *   data: {
+ *     LOG_LEVEL: "debug",
+ *   },
+ * });
+ * ```
+ */
+export const ConfigMap = (id: string, props: ConfigMapProps) =>
+  Object(id, {
+    cluster: props.cluster,
+    apiVersion: "v1",
+    kind: "ConfigMap",
+    metadata: metadataWithNamespace(props.namespace, {
+      name: props.name,
+      labels: props.labels,
+      annotations: props.annotations,
+    }),
+    body: {
+      data: props.data,
+    },
+  });

package/src/Kubernetes/Deployment.ts

@@ -0,0 +1,123 @@
+import type { Cluster } from "../AWS/EKS/Cluster.ts";
+import { metadataWithNamespace, objectNameOf } from "./common.ts";
+import { Object, type ObjectRef } from "./Object.ts";
+
+export interface ContainerPort {
+  containerPort: number;
+  name?: string;
+}
+
+export interface ContainerEnvVar {
+  name: string;
+  value: string;
+}
+
+export interface ContainerResourceList {
+  cpu?: string;
+  memory?: string;
+}
+
+export interface ContainerResources {
+  requests?: ContainerResourceList;
+  limits?: ContainerResourceList;
+}
+
+export interface ContainerSpec {
+  name: string;
+  image: string;
+  command?: string[];
+  args?: string[];
+  env?: ContainerEnvVar[];
+  ports?: ContainerPort[];
+  resources?: ContainerResources;
+}
+
+export interface DeploymentProps {
+  /**
+   * Target EKS cluster.
+   */
+  cluster: Cluster;
+  /**
+   * Namespace name or namespace helper result.
+   */
+  namespace: string | { name: string } | ObjectRef;
+  /**
+   * Optional explicit deployment name. Defaults to the logical id.
+   */
+  name?: string;
+  /**
+   * Deployment labels.
+   */
+  labels?: Record<string, string>;
+  /**
+   * Pod labels. Defaults to `labels`.
+   */
+  podLabels?: Record<string, string>;
+  /**
+   * Replica count.
+   * @default 1
+   */
+  replicas?: number;
+  /**
+   * Service account name for the pod template.
+   */
+  serviceAccountName?: string | { name: string } | ObjectRef;
+  /**
+   * Container specs for the pod template.
+   */
+  containers: ContainerSpec[];
+}
+
+/**
+ * A Kubernetes deployment bound to an EKS cluster.
+ *
+ * @example Deploy a simple workload
+ * ```typescript
+ * const app = yield* Deployment("api", {
+ *   cluster,
+ *   namespace: "default",
+ *   containers: [
+ *     {
+ *       name: "api",
+ *       image: "nginx:latest",
+ *     },
+ *   ],
+ * });
+ * ```
+ */
+export const Deployment = (id: string, props: DeploymentProps) => {
+  const name = props.name ?? id;
+  const labels = props.labels ?? {
+    "app.kubernetes.io/name": name,
+  };
+  const podLabels = props.podLabels ?? labels;
+
+  return Object(id, {
+    cluster: props.cluster,
+    apiVersion: "apps/v1",
+    kind: "Deployment",
+    metadata: metadataWithNamespace(props.namespace, {
+      name,
+      labels,
+    }),
+    body: {
+      spec: {
+        replicas: props.replicas ?? 1,
+        selector: {
+          matchLabels: podLabels,
+        },
+        template: {
+          metadata: {
+            labels: podLabels,
+          },
+          spec: {
+            serviceAccountName: props.serviceAccountName
+              ? objectNameOf(props.serviceAccountName)
+              : undefined,
+            containers: props.containers,
+          },
+        },
+      },
+    },
+  });
+};

package/src/Kubernetes/Job.ts

@@ -0,0 +1,82 @@
+import type { Cluster } from "../AWS/EKS/Cluster.ts";
+import { metadataWithNamespace, objectNameOf } from "./common.ts";
+import { Object, type ObjectRef } from "./Object.ts";
+import type { ContainerSpec } from "./Deployment.ts";
+
+export interface JobProps {
+  /**
+   * Target EKS cluster.
+   */
+  cluster: Cluster;
+  /**
+   * Namespace name or namespace helper result.
+   */
+  namespace: string | { name: string } | ObjectRef;
+  /**
+   * Optional explicit job name. Defaults to the logical id.
+   */
+  name?: string;
+  /**
+   * Job labels.
+   */
+  labels?: Record<string, string>;
+  /**
+   * Restart policy.
+   * @default "Never"
+   */
+  restartPolicy?: "Never" | "OnFailure";
+  /**
+   * Service account name for the pod template.
+   */
+  serviceAccountName?: string | { name: string } | ObjectRef;
+  /**
+   * Pod containers.
+   */
+  containers: ContainerSpec[];
+}
+
+/**
+ * A Kubernetes job bound to an EKS cluster.
+ *
+ * @example Run a one-shot job
+ * ```typescript
+ * const job = yield* Job("seed", {
+ *   cluster,
+ *   namespace: "default",
+ *   containers: [
+ *     {
+ *       name: "seed",
+ *       image: "busybox:latest",
+ *       command: ["/bin/sh", "-lc"],
+ *       args: ["echo hello"],
+ *     },
+ *   ],
+ * });
+ * ```
+ */
+export const Job = (id: string, props: JobProps) =>
+  Object(id, {
+    cluster: props.cluster,
+    apiVersion: "batch/v1",
+    kind: "Job",
+    metadata: metadataWithNamespace(props.namespace, {
+      name: props.name,
+      labels: props.labels,
+    }),
+    body: {
+      spec: {
+        template: {
+          metadata: {
+            labels: props.labels,
+          },
+          spec: {
+            restartPolicy: props.restartPolicy ?? "Never",
+            serviceAccountName: props.serviceAccountName
+              ? objectNameOf(props.serviceAccountName)
+              : undefined,
+            containers: props.containers,
+          },
+        },
+      },
+    },
+  });

package/src/Kubernetes/Namespace.ts

@@ -0,0 +1,49 @@
+import type { Cluster } from "../AWS/EKS/Cluster.ts";
+import type * as Effect from "effect/Effect";
+import { Object, type ObjectRef } from "./Object.ts";
+
+export interface NamespaceProps {
+  /**
+   * Target EKS cluster.
+   */
+  cluster: Cluster;
+  /**
+   * Optional explicit namespace name. Defaults to the logical id.
+   */
+  name?: string;
+  /**
+   * Namespace labels.
+   */
+  labels?: Record<string, string>;
+  /**
+   * Namespace annotations.
+   */
+  annotations?: Record<string, string>;
+}
+
+export interface Namespace extends ObjectRef {
+  kind: "Namespace";
+  namespace: undefined;
+}
+
+/**
+ * A Kubernetes namespace bound to an EKS cluster.
+ *
+ * @example Create a namespace
+ * ```typescript
+ * const ns = yield* Namespace("demo", {
+ *   cluster,
+ * });
+ * ```
+ */
+export const Namespace = (id: string, props: NamespaceProps) =>
+  Object(id, {
+    cluster: props.cluster,
+    apiVersion: "v1",
+    kind: "Namespace",
+    metadata: {
+      name: props.name,
+      labels: props.labels,
+      annotations: props.annotations,
+    },
+  }) as Effect.Effect<Namespace>;

package/src/Kubernetes/Object.ts

@@ -0,0 +1,99 @@
+import * as Effect from "effect/Effect";
+import type { Cluster } from "../AWS/EKS/Cluster.ts";
+import {
+  kubernetesBindingSid,
+  kubernetesObjectKey,
+  toKubernetesObjectRef,
+  type KubernetesObjectDefinition,
+  type KubernetesObjectMetadata,
+} from "./types.ts";
+
+export interface ObjectProps {
+  /**
+   * Target EKS cluster that will own this Kubernetes object.
+   */
+  cluster: Cluster;
+  /**
+   * Kubernetes API version.
+   */
+  apiVersion: string;
+  /**
+   * Kubernetes kind.
+   */
+  kind: string;
+  /**
+   * Object metadata. `name` defaults to the logical id.
+   */
+  metadata?: Omit<KubernetesObjectMetadata, "name"> & {
+    name?: string;
+  };
+  /**
+   * Extra top-level fields merged into the final Kubernetes object.
+   */
+  body?: Record<string, unknown>;
+}
+
+export interface ObjectRef {
+  cluster: Cluster;
+  apiVersion: string;
+  kind: string;
+  name: string;
+  namespace: string | undefined;
+  key: string;
+  object: KubernetesObjectDefinition;
+}
+
+/**
+ * Binds a Kubernetes object definition onto an `AWS.EKS.Cluster`.
+ *
+ * This is the low-level escape hatch for TypeScript-defined Kubernetes objects.
+ *
+ * @example Bind a raw Kubernetes object
+ * ```typescript
+ * const object = yield* Object("demo", {
+ *   cluster,
+ *   apiVersion: "v1",
+ *   kind: "ConfigMap",
+ *   metadata: {
+ *     namespace: "default",
+ *   },
+ *   body: {
+ *     data: {
+ *       EXAMPLE: "true",
+ *     },
+ *   },
+ * });
+ * ```
+ */
+const KubernetesObject = Effect.fn(function* (id: string, props: ObjectProps) {
+  const object = {
+    apiVersion: props.apiVersion,
+    kind: props.kind,
+    metadata: {
+      name: props.metadata?.name ?? id,
+      namespace: props.metadata?.namespace,
+      labels: props.metadata?.labels,
+      annotations: props.metadata?.annotations,
+    },
+    ...props.body,
+  } satisfies KubernetesObjectDefinition;
+
+  yield* props.cluster.bind(kubernetesBindingSid(object), {
+    type: "kubernetes-object",
+    object,
+  });
+
+  const ref = toKubernetesObjectRef(object);
+
+  return {
+    cluster: props.cluster,
+    apiVersion: ref.apiVersion,
+    kind: ref.kind,
+    name: ref.name,
+    namespace: ref.namespace,
+    key: kubernetesObjectKey(ref),
+    object,
+  } satisfies ObjectRef;
+});
+
+export { KubernetesObject as Object };

package/src/Kubernetes/Service.ts

@@ -0,0 +1,78 @@
+import type { Cluster } from "../AWS/EKS/Cluster.ts";
+import { metadataWithNamespace } from "./common.ts";
+import { Object, type ObjectRef } from "./Object.ts";
+
+export interface ServicePort {
+  port: number;
+  targetPort?: number;
+  protocol?: "TCP" | "UDP";
+  name?: string;
+}
+
+export interface ServiceProps {
+  /**
+   * Target EKS cluster.
+   */
+  cluster: Cluster;
+  /**
+   * Namespace name or namespace helper result.
+   */
+  namespace: string | { name: string } | ObjectRef;
+  /**
+   * Optional explicit service name. Defaults to the logical id.
+   */
+  name?: string;
+  /**
+   * Service type.
+   * @default "ClusterIP"
+   */
+  type?: "ClusterIP" | "NodePort" | "LoadBalancer";
+  /**
+   * Selector labels for backing pods.
+   */
+  selector: Record<string, string>;
+  /**
+   * Service ports.
+   */
+  ports: ServicePort[];
+  /**
+   * Service labels.
+   */
+  labels?: Record<string, string>;
+  /**
+   * Service annotations.
+   */
+  annotations?: Record<string, string>;
+}
+
+/**
+ * A Kubernetes service bound to an EKS cluster.
+ *
+ * @example Expose a deployment on a ClusterIP service
+ * ```typescript
+ * const service = yield* Service("api", {
+ *   cluster,
+ *   namespace: "default",
+ *   selector: { "app.kubernetes.io/name": "api" },
+ *   ports: [{ port: 80, targetPort: 8080 }],
+ * });
+ * ```
+ */
+export const Service = (id: string, props: ServiceProps) =>
+  Object(id, {
+    cluster: props.cluster,
+    apiVersion: "v1",
+    kind: "Service",
+    metadata: metadataWithNamespace(props.namespace, {
+      name: props.name,
+      labels: props.labels,
+      annotations: props.annotations,
+    }),
+    body: {
+      spec: {
+        type: props.type ?? "ClusterIP",
+        selector: props.selector,
+        ports: props.ports,
+      },
+    },
+  });

package/src/Kubernetes/ServiceAccount.ts

@@ -0,0 +1,49 @@
+import type { Cluster } from "../AWS/EKS/Cluster.ts";
+import { metadataWithNamespace } from "./common.ts";
+import { Object, type ObjectRef } from "./Object.ts";
+
+export interface ServiceAccountProps {
+  /**
+   * Target EKS cluster.
+   */
+  cluster: Cluster;
+  /**
+   * Namespace name or namespace helper result.
+   */
+  namespace: string | { name: string } | ObjectRef;
+  /**
+   * Optional explicit service account name. Defaults to the logical id.
+   */
+  name?: string;
+  /**
+   * Service account labels.
+   */
+  labels?: Record<string, string>;
+  /**
+   * Service account annotations.
+   */
+  annotations?: Record<string, string>;
+}
+
+/**
+ * A Kubernetes service account bound to an EKS cluster.
+ *
+ * @example Create a service account
+ * ```typescript
+ * const sa = yield* ServiceAccount("api", {
+ *   cluster,
+ *   namespace: "default",
+ * });
+ * ```
+ */
+export const ServiceAccount = (id: string, props: ServiceAccountProps) =>
+  Object(id, {
+    cluster: props.cluster,
+    apiVersion: "v1",
+    kind: "ServiceAccount",
+    metadata: metadataWithNamespace(props.namespace, {
+      name: props.name,
+      labels: props.labels,
+      annotations: props.annotations,
+    }),
+  });