alchemy-effect 0.5.0 → 0.6.2

package/src/AWS/IdentityCenter/common.ts

@@ -0,0 +1,117 @@
+import * as identitystore from "@distilled.cloud/aws/identitystore";
+import * as ssoAdmin from "@distilled.cloud/aws/sso-admin";
+import * as Effect from "effect/Effect";
+import * as Schedule from "effect/Schedule";
+import * as Stream from "effect/Stream";
+
+export const retryIdentityCenter = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+  effect.pipe(
+    Effect.retry({
+      while: (error: any) =>
+        error?._tag === "ConflictException" ||
+        error?._tag === "ThrottlingException" ||
+        error?._tag === "InternalServerException",
+      schedule: Schedule.exponential(200).pipe(
+        Schedule.both(Schedule.recurs(8)),
+      ),
+    }),
+  );
+
+export const listInstances = Effect.fn(function* () {
+  return yield* ssoAdmin.listInstances
+    .items({
+      MaxResults: 100,
+    })
+    .pipe(
+      Stream.runCollect,
+      Effect.map(
+        (instances) => Array.from(instances) as ssoAdmin.InstanceMetadata[],
+      ),
+    );
+});
+
+export const resolveInstance = Effect.fn(function* (instanceArn?: string) {
+  const instances = yield* listInstances();
+
+  if (instanceArn) {
+    const selected = instances.find(
+      (instance) => instance.InstanceArn === instanceArn,
+    );
+    if (!selected?.InstanceArn || !selected.IdentityStoreId) {
+      return yield* Effect.fail(
+        new Error(`Identity Center instance '${instanceArn}' was not found`),
+      );
+    }
+    return selected;
+  }
+
+  if (instances.length === 1) {
+    return instances[0]!;
+  }
+
+  const active = instances.filter((instance) => instance.Status === "ACTIVE");
+  if (active.length === 1) {
+    return active[0]!;
+  }
+
+  return yield* Effect.fail(
+    new Error(
+      "Unable to resolve a single visible Identity Center instance; pass instanceArn explicitly",
+    ),
+  );
+});
+
+export const resolveIdentityStoreId = Effect.fn(function* ({
+  identityStoreId,
+  instanceArn,
+}: {
+  identityStoreId?: string;
+  instanceArn?: string;
+}) {
+  if (identityStoreId) {
+    return identityStoreId;
+  }
+
+  const instance = yield* resolveInstance(instanceArn);
+  if (!instance.IdentityStoreId) {
+    return yield* Effect.fail(
+      new Error(
+        `Identity Center instance '${instance.InstanceArn}' is missing an identity store ID`,
+      ),
+    );
+  }
+
+  return instance.IdentityStoreId;
+});
+
+export const toInstanceAttributes = (
+  instance: ssoAdmin.InstanceMetadata,
+): {
+  instanceArn: string;
+  identityStoreId: string;
+  ownerAccountId: string | undefined;
+  name: string | undefined;
+  status: string | undefined;
+  statusReason: string | undefined;
+  createdDate: Date | undefined;
+} => ({
+  instanceArn: instance.InstanceArn ?? "",
+  identityStoreId: instance.IdentityStoreId ?? "",
+  ownerAccountId: instance.OwnerAccountId,
+  name: instance.Name,
+  status: instance.Status,
+  statusReason: instance.StatusReason,
+  createdDate: instance.CreatedDate,
+});
+
+export const listGroups = Effect.fn(function* (identityStoreId: string) {
+  return yield* identitystore.listGroups
+    .items({
+      IdentityStoreId: identityStoreId,
+      MaxResults: 100,
+    })
+    .pipe(
+      Stream.runCollect,
+      Effect.map((groups) => Array.from(groups) as identitystore.Group[]),
+    );
+});

package/src/AWS/IdentityCenter/index.ts

@@ -0,0 +1,4 @@
+export * from "./AccountAssignment.ts";
+export * from "./Group.ts";
+export * from "./Instance.ts";
+export * from "./PermissionSet.ts";

package/src/AWS/Kinesis/DescribeAccountSettings.ts

@@ -0,0 +1,63 @@
+import * as Kinesis from "@distilled.cloud/aws/kinesis";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { isFunction } from "../Lambda/Function.ts";
+
+export interface DescribeAccountSettingsRequest
+  extends Kinesis.DescribeAccountSettingsInput {}
+
+export class DescribeAccountSettings extends Binding.Service<
+  DescribeAccountSettings,
+  () => Effect.Effect<
+    (
+      request?: DescribeAccountSettingsRequest,
+    ) => Effect.Effect<
+      Kinesis.DescribeAccountSettingsOutput,
+      Kinesis.DescribeAccountSettingsError
+    >
+  >
+>()("AWS.Kinesis.DescribeAccountSettings") {}
+
+export const DescribeAccountSettingsLive = Layer.effect(
+  DescribeAccountSettings,
+  Effect.gen(function* () {
+    const Policy = yield* DescribeAccountSettingsPolicy;
+    const describeAccountSettings = yield* Kinesis.describeAccountSettings;
+
+    return Effect.fn(function* () {
+      yield* Policy();
+      return Effect.fn(function* (request?: DescribeAccountSettingsRequest) {
+        return yield* describeAccountSettings(request ?? {});
+      });
+    });
+  }),
+);
+
+export class DescribeAccountSettingsPolicy extends Binding.Policy<
+  DescribeAccountSettingsPolicy,
+  () => Effect.Effect<void>
+>()("AWS.Kinesis.DescribeAccountSettings") {}
+
+export const DescribeAccountSettingsPolicyLive =
+  DescribeAccountSettingsPolicy.layer.succeed(
+    Effect.fn(function* (host) {
+      if (isFunction(host)) {
+        yield* host.bind`Allow(${host}, AWS.Kinesis.DescribeAccountSettings())`(
+          {
+            policyStatements: [
+              {
+                Effect: "Allow",
+                Action: ["kinesis:DescribeAccountSettings"],
+                Resource: ["*"],
+              },
+            ],
+          },
+        );
+      } else {
+        return yield* Effect.die(
+          `DescribeAccountSettingsPolicy does not support runtime '${host.Type}'`,
+        );
+      }
+    }),
+  );

package/src/AWS/Kinesis/DescribeLimits.ts

@@ -0,0 +1,59 @@
+import * as Kinesis from "@distilled.cloud/aws/kinesis";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { isFunction } from "../Lambda/Function.ts";
+
+export interface DescribeLimitsRequest extends Kinesis.DescribeLimitsInput {}
+
+export class DescribeLimits extends Binding.Service<
+  DescribeLimits,
+  () => Effect.Effect<
+    (
+      request?: DescribeLimitsRequest,
+    ) => Effect.Effect<
+      Kinesis.DescribeLimitsOutput,
+      Kinesis.DescribeLimitsError
+    >
+  >
+>()("AWS.Kinesis.DescribeLimits") {}
+
+export const DescribeLimitsLive = Layer.effect(
+  DescribeLimits,
+  Effect.gen(function* () {
+    const Policy = yield* DescribeLimitsPolicy;
+    const describeLimits = yield* Kinesis.describeLimits;
+
+    return Effect.fn(function* () {
+      yield* Policy();
+      return Effect.fn(function* (request?: DescribeLimitsRequest) {
+        return yield* describeLimits(request ?? {});
+      });
+    });
+  }),
+);
+
+export class DescribeLimitsPolicy extends Binding.Policy<
+  DescribeLimitsPolicy,
+  () => Effect.Effect<void>
+>()("AWS.Kinesis.DescribeLimits") {}
+
+export const DescribeLimitsPolicyLive = DescribeLimitsPolicy.layer.succeed(
+  Effect.fn(function* (host) {
+    if (isFunction(host)) {
+      yield* host.bind`Allow(${host}, AWS.Kinesis.DescribeLimits())`({
+        policyStatements: [
+          {
+            Effect: "Allow",
+            Action: ["kinesis:DescribeLimits"],
+            Resource: ["*"],
+          },
+        ],
+      });
+    } else {
+      return yield* Effect.die(
+        `DescribeLimitsPolicy does not support runtime '${host.Type}'`,
+      );
+    }
+  }),
+);

package/src/AWS/Kinesis/DescribeStream.ts

@@ -0,0 +1,69 @@
+import * as Kinesis from "@distilled.cloud/aws/kinesis";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { isFunction } from "../Lambda/Function.ts";
+import type { Stream } from "./Stream.ts";
+
+export interface DescribeStreamRequest extends Omit<
+  Kinesis.DescribeStreamInput,
+  "StreamName" | "StreamARN"
+> {}
+
+export class DescribeStream extends Binding.Service<
+  DescribeStream,
+  (
+    stream: Stream,
+  ) => Effect.Effect<
+    (
+      request?: DescribeStreamRequest,
+    ) => Effect.Effect<
+      Kinesis.DescribeStreamOutput,
+      Kinesis.DescribeStreamError
+    >
+  >
+>()("AWS.Kinesis.DescribeStream") {}
+
+export const DescribeStreamLive = Layer.effect(
+  DescribeStream,
+  Effect.gen(function* () {
+    const Policy = yield* DescribeStreamPolicy;
+    const describeStream = yield* Kinesis.describeStream;
+
+    return Effect.fn(function* (stream: Stream) {
+      const StreamARN = yield* stream.streamArn;
+      yield* Policy(stream);
+      return Effect.fn(function* (request?: DescribeStreamRequest) {
+        return yield* describeStream({
+          ...request,
+          StreamARN: yield* StreamARN,
+        });
+      });
+    });
+  }),
+);
+
+export class DescribeStreamPolicy extends Binding.Policy<
+  DescribeStreamPolicy,
+  (stream: Stream) => Effect.Effect<void>
+>()("AWS.Kinesis.DescribeStream") {}
+
+export const DescribeStreamPolicyLive = DescribeStreamPolicy.layer.succeed(
+  Effect.fn(function* (host, stream) {
+    if (isFunction(host)) {
+      yield* host.bind`Allow(${host}, AWS.Kinesis.DescribeStream(${stream}))`({
+        policyStatements: [
+          {
+            Effect: "Allow",
+            Action: ["kinesis:DescribeStream"],
+            Resource: [stream.streamArn],
+          },
+        ],
+      });
+    } else {
+      return yield* Effect.die(
+        `DescribeStreamPolicy does not support runtime '${host.Type}'`,
+      );
+    }
+  }),
+);

package/src/AWS/Kinesis/DescribeStreamConsumer.ts

@@ -0,0 +1,72 @@
+import * as Kinesis from "@distilled.cloud/aws/kinesis";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { isFunction } from "../Lambda/Function.ts";
+import type { StreamConsumer } from "./StreamConsumer.ts";
+
+export interface DescribeStreamConsumerRequest extends Omit<
+  Kinesis.DescribeStreamConsumerInput,
+  "ConsumerARN" | "StreamARN" | "ConsumerName"
+> {}
+
+export class DescribeStreamConsumer extends Binding.Service<
+  DescribeStreamConsumer,
+  (
+    consumer: StreamConsumer,
+  ) => Effect.Effect<
+    (
+      request?: DescribeStreamConsumerRequest,
+    ) => Effect.Effect<
+      Kinesis.DescribeStreamConsumerOutput,
+      Kinesis.DescribeStreamConsumerError
+    >
+  >
+>()("AWS.Kinesis.DescribeStreamConsumer") {}
+
+export const DescribeStreamConsumerLive = Layer.effect(
+  DescribeStreamConsumer,
+  Effect.gen(function* () {
+    const Policy = yield* DescribeStreamConsumerPolicy;
+    const describeStreamConsumer = yield* Kinesis.describeStreamConsumer;
+
+    return Effect.fn(function* (consumer: StreamConsumer) {
+      const ConsumerARN = yield* consumer.consumerArn;
+      yield* Policy(consumer);
+      return Effect.fn(function* (request?: DescribeStreamConsumerRequest) {
+        return yield* describeStreamConsumer({
+          ...request,
+          ConsumerARN: yield* ConsumerARN,
+        });
+      });
+    });
+  }),
+);
+
+export class DescribeStreamConsumerPolicy extends Binding.Policy<
+  DescribeStreamConsumerPolicy,
+  (consumer: StreamConsumer) => Effect.Effect<void>
+>()("AWS.Kinesis.DescribeStreamConsumer") {}
+
+export const DescribeStreamConsumerPolicyLive =
+  DescribeStreamConsumerPolicy.layer.succeed(
+    Effect.fn(function* (host, consumer) {
+      if (isFunction(host)) {
+        yield* host.bind`Allow(${host}, AWS.Kinesis.DescribeStreamConsumer(${consumer}))`(
+          {
+            policyStatements: [
+              {
+                Effect: "Allow",
+                Action: ["kinesis:DescribeStreamConsumer"],
+                Resource: [consumer.consumerArn],
+              },
+            ],
+          },
+        );
+      } else {
+        return yield* Effect.die(
+          `DescribeStreamConsumerPolicy does not support runtime '${host.Type}'`,
+        );
+      }
+    }),
+  );

package/src/AWS/Kinesis/DescribeStreamSummary.ts

@@ -0,0 +1,72 @@
+import * as Kinesis from "@distilled.cloud/aws/kinesis";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { isFunction } from "../Lambda/Function.ts";
+import type { Stream } from "./Stream.ts";
+
+export interface DescribeStreamSummaryRequest extends Omit<
+  Kinesis.DescribeStreamSummaryInput,
+  "StreamName" | "StreamARN"
+> {}
+
+export class DescribeStreamSummary extends Binding.Service<
+  DescribeStreamSummary,
+  (
+    stream: Stream,
+  ) => Effect.Effect<
+    (
+      request?: DescribeStreamSummaryRequest,
+    ) => Effect.Effect<
+      Kinesis.DescribeStreamSummaryOutput,
+      Kinesis.DescribeStreamSummaryError
+    >
+  >
+>()("AWS.Kinesis.DescribeStreamSummary") {}
+
+export const DescribeStreamSummaryLive = Layer.effect(
+  DescribeStreamSummary,
+  Effect.gen(function* () {
+    const Policy = yield* DescribeStreamSummaryPolicy;
+    const describeStreamSummary = yield* Kinesis.describeStreamSummary;
+
+    return Effect.fn(function* (stream: Stream) {
+      const StreamARN = yield* stream.streamArn;
+      yield* Policy(stream);
+      return Effect.fn(function* (request?: DescribeStreamSummaryRequest) {
+        return yield* describeStreamSummary({
+          ...request,
+          StreamARN: yield* StreamARN,
+        });
+      });
+    });
+  }),
+);
+
+export class DescribeStreamSummaryPolicy extends Binding.Policy<
+  DescribeStreamSummaryPolicy,
+  (stream: Stream) => Effect.Effect<void>
+>()("AWS.Kinesis.DescribeStreamSummary") {}
+
+export const DescribeStreamSummaryPolicyLive =
+  DescribeStreamSummaryPolicy.layer.succeed(
+    Effect.fn(function* (host, stream) {
+      if (isFunction(host)) {
+        yield* host.bind`Allow(${host}, AWS.Kinesis.DescribeStreamSummary(${stream}))`(
+          {
+            policyStatements: [
+              {
+                Effect: "Allow",
+                Action: ["kinesis:DescribeStreamSummary"],
+                Resource: [stream.streamArn],
+              },
+            ],
+          },
+        );
+      } else {
+        return yield* Effect.die(
+          `DescribeStreamSummaryPolicy does not support runtime '${host.Type}'`,
+        );
+      }
+    }),
+  );

package/src/AWS/Kinesis/GetRecords.ts

@@ -0,0 +1,59 @@
+import * as Kinesis from "@distilled.cloud/aws/kinesis";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { isFunction } from "../Lambda/Function.ts";
+import type { Stream } from "./Stream.ts";
+
+export interface GetRecordsRequest extends Kinesis.GetRecordsInput {}
+
+export class GetRecords extends Binding.Service<
+  GetRecords,
+  (
+    stream: Stream,
+  ) => Effect.Effect<
+    (
+      request: GetRecordsRequest,
+    ) => Effect.Effect<Kinesis.GetRecordsOutput, Kinesis.GetRecordsError>
+  >
+>()("AWS.Kinesis.GetRecords") {}
+
+export const GetRecordsLive = Layer.effect(
+  GetRecords,
+  Effect.gen(function* () {
+    const Policy = yield* GetRecordsPolicy;
+    const getRecords = yield* Kinesis.getRecords;
+
+    return Effect.fn(function* (stream: Stream) {
+      yield* Policy(stream);
+      return Effect.fn(function* (request: GetRecordsRequest) {
+        return yield* getRecords(request);
+      });
+    });
+  }),
+);
+
+export class GetRecordsPolicy extends Binding.Policy<
+  GetRecordsPolicy,
+  (stream: Stream) => Effect.Effect<void>
+>()("AWS.Kinesis.GetRecords") {}
+
+export const GetRecordsPolicyLive = GetRecordsPolicy.layer.succeed(
+  Effect.fn(function* (host, stream) {
+    if (isFunction(host)) {
+      yield* host.bind`Allow(${host}, AWS.Kinesis.GetRecords(${stream}))`({
+        policyStatements: [
+          {
+            Effect: "Allow",
+            Action: ["kinesis:GetRecords"],
+            Resource: [stream.streamArn],
+          },
+        ],
+      });
+    } else {
+      return yield* Effect.die(
+        `GetRecordsPolicy does not support runtime '${host.Type}'`,
+      );
+    }
+  }),
+);

package/src/AWS/Kinesis/GetResourcePolicy.ts

@@ -0,0 +1,72 @@
+import * as Kinesis from "@distilled.cloud/aws/kinesis";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { isFunction } from "../Lambda/Function.ts";
+import type { Stream } from "./Stream.ts";
+
+export interface GetResourcePolicyRequest extends Omit<
+  Kinesis.GetResourcePolicyInput,
+  "ResourceARN"
+> {}
+
+export class GetResourcePolicy extends Binding.Service<
+  GetResourcePolicy,
+  (
+    stream: Stream,
+  ) => Effect.Effect<
+    (
+      request?: GetResourcePolicyRequest,
+    ) => Effect.Effect<
+      Kinesis.GetResourcePolicyOutput,
+      Kinesis.GetResourcePolicyError
+    >
+  >
+>()("AWS.Kinesis.GetResourcePolicy") {}
+
+export const GetResourcePolicyLive = Layer.effect(
+  GetResourcePolicy,
+  Effect.gen(function* () {
+    const Policy = yield* GetResourcePolicyPolicy;
+    const getResourcePolicy = yield* Kinesis.getResourcePolicy;
+
+    return Effect.fn(function* (stream: Stream) {
+      const ResourceARN = yield* stream.streamArn;
+      yield* Policy(stream);
+      return Effect.fn(function* (request?: GetResourcePolicyRequest) {
+        return yield* getResourcePolicy({
+          ...request,
+          ResourceARN: yield* ResourceARN,
+        });
+      });
+    });
+  }),
+);
+
+export class GetResourcePolicyPolicy extends Binding.Policy<
+  GetResourcePolicyPolicy,
+  (stream: Stream) => Effect.Effect<void>
+>()("AWS.Kinesis.GetResourcePolicy") {}
+
+export const GetResourcePolicyPolicyLive =
+  GetResourcePolicyPolicy.layer.succeed(
+    Effect.fn(function* (host, stream) {
+      if (isFunction(host)) {
+        yield* host.bind`Allow(${host}, AWS.Kinesis.GetResourcePolicy(${stream}))`(
+          {
+            policyStatements: [
+              {
+                Effect: "Allow",
+                Action: ["kinesis:GetResourcePolicy"],
+                Resource: [stream.streamArn],
+              },
+            ],
+          },
+        );
+      } else {
+        return yield* Effect.die(
+          `GetResourcePolicyPolicy does not support runtime '${host.Type}'`,
+        );
+      }
+    }),
+  );

package/src/AWS/Kinesis/GetShardIterator.ts

@@ -0,0 +1,71 @@
+import * as Kinesis from "@distilled.cloud/aws/kinesis";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { isFunction } from "../Lambda/Function.ts";
+import type { Stream } from "./Stream.ts";
+
+export interface GetShardIteratorRequest extends Omit<
+  Kinesis.GetShardIteratorInput,
+  "StreamName" | "StreamARN"
+> {}
+
+export class GetShardIterator extends Binding.Service<
+  GetShardIterator,
+  (
+    stream: Stream,
+  ) => Effect.Effect<
+    (
+      request: GetShardIteratorRequest,
+    ) => Effect.Effect<
+      Kinesis.GetShardIteratorOutput,
+      Kinesis.GetShardIteratorError
+    >
+  >
+>()("AWS.Kinesis.GetShardIterator") {}
+
+export const GetShardIteratorLive = Layer.effect(
+  GetShardIterator,
+  Effect.gen(function* () {
+    const Policy = yield* GetShardIteratorPolicy;
+    const getShardIterator = yield* Kinesis.getShardIterator;
+
+    return Effect.fn(function* (stream: Stream) {
+      const StreamARN = yield* stream.streamArn;
+      yield* Policy(stream);
+      return Effect.fn(function* (request: GetShardIteratorRequest) {
+        return yield* getShardIterator({
+          ...request,
+          StreamARN: yield* StreamARN,
+        });
+      });
+    });
+  }),
+);
+
+export class GetShardIteratorPolicy extends Binding.Policy<
+  GetShardIteratorPolicy,
+  (stream: Stream) => Effect.Effect<void>
+>()("AWS.Kinesis.GetShardIterator") {}
+
+export const GetShardIteratorPolicyLive = GetShardIteratorPolicy.layer.succeed(
+  Effect.fn(function* (host, stream) {
+    if (isFunction(host)) {
+      yield* host.bind`Allow(${host}, AWS.Kinesis.GetShardIterator(${stream}))`(
+        {
+          policyStatements: [
+            {
+              Effect: "Allow",
+              Action: ["kinesis:GetShardIterator"],
+              Resource: [stream.streamArn],
+            },
+          ],
+        },
+      );
+    } else {
+      return yield* Effect.die(
+        `GetShardIteratorPolicy does not support runtime '${host.Type}'`,
+      );
+    }
+  }),
+);