alchemy-effect 0.0.0 → 0.2.0

package/src/aws/dynamodb/client.ts

@@ -0,0 +1,20 @@
+import * as Layer from "effect/Layer";
+import * as Context from "effect/Context";
+import { DynamoDB } from "itty-aws/dynamodb";
+
+import * as Credentials from "../credentials.ts";
+import * as Region from "../region.ts";
+import { createAWSServiceClientLayer } from "../client.ts";
+
+export class DynamoDBClient extends Context.Tag("AWS::DynamoDB::Client")<
+  DynamoDBClient,
+  DynamoDB
+>() {}
+
+export const client = createAWSServiceClientLayer<
+  typeof DynamoDBClient,
+  DynamoDB
+>(DynamoDBClient, DynamoDB);
+
+export const clientFromEnv = () =>
+  Layer.provide(client(), Layer.merge(Credentials.fromEnv(), Region.fromEnv()));

package/src/aws/dynamodb/expr.ts

@@ -0,0 +1,90 @@
+export type Expr =
+  | ArrayIndex
+  | Identifier
+  | NumberLiteral
+  | OperatorExpr
+  | NameRef
+  | PropRef
+  | ValueRef;
+//
+
+export interface NameRef<Name extends string = string> {
+  kind: "name-ref";
+  name: Name;
+}
+export interface ValueRef<Name extends string = string> {
+  kind: "value-ref";
+  name: Name;
+}
+export interface Identifier<I extends string = string> {
+  kind: "identifier";
+  name: I;
+}
+
+export interface NumberLiteral<N extends string = string> {
+  kind: "index";
+  number: N;
+}
+export interface PropRef<Ex extends Expr = any, Id extends Identifier = any> {
+  kind: "prop-ref";
+  expr: Ex;
+  name: Id;
+}
+export interface ArrayIndex<
+  List extends Expr = any,
+  Number extends NumberLiteral | ValueRef = NumberLiteral | ValueRef,
+> {
+  kind: "array-index";
+  list: List;
+  number: Number;
+}
+
+export type Operator = "and" | "or" | "=" | "<" | "<=" | ">=" | ">";
+export interface OperatorExpr<
+  Left extends Expr = any,
+  Op extends Operator = Operator,
+  Right extends Expr = any,
+> {
+  kind: "op";
+  left: Left;
+  op: Op;
+  right: Right;
+}
+
+export type LowercaseLetter =
+  | "a"
+  | "b"
+  | "c"
+  | "d"
+  | "e"
+  | "f"
+  | "g"
+  | "h"
+  | "i"
+  | "j"
+  | "k"
+  | "l"
+  | "m"
+  | "n"
+  | "o"
+  | "p"
+  | "q"
+  | "r"
+  | "s"
+  | "t"
+  | "u"
+  | "v"
+  | "w"
+  | "x"
+  | "y"
+  | "z";
+
+export type UppercaseLetter = Uppercase<LowercaseLetter>;
+
+export type Letter = LowercaseLetter | UppercaseLetter;
+
+export type Digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
+
+export type SpecialCharacter = "_";
+
+export type Word = Digit | Letter | SpecialCharacter;

package/src/aws/dynamodb/index.ts

@@ -0,0 +1,12 @@
+export * from "./attribute-value.ts";
+export * from "./client.ts";
+export * from "./expr.ts";
+export * from "./secondary-index.ts";
+export * from "./table.get-item.ts";
+export * from "./table.provider.ts";
+export * from "./table.ts";
+
+export type * as Alchemy from "../../index.ts";
+
+// TODO(sam): figure out a better strategy to workaround non-portable types
+// export type * as _ from "../../index.ts";

package/src/aws/dynamodb/projection.ts

@@ -0,0 +1,159 @@
+import type {
+  ArrayIndex,
+  Expr,
+  Identifier,
+  NameRef,
+  NumberLiteral,
+  PropRef,
+  ValueRef,
+  Word,
+} from "./expr.ts";
+
+export type ParseProjectionExpression<Text extends string> = Parse<
+  Text,
+  [],
+  undefined
+>;
+
+type AsExpr<T> = Extract<T, Expr>;
+
+type Parse<
+  Text extends string,
+  Expressions extends Expr[],
+  Exp extends Expr | undefined,
+> = Text extends `.${infer Rest}`
+  ? Exp extends Expr
+    ? Parse<Rest, Expressions, PropRef<Exp, Identifier<"">>>
+    : never
+  : Text extends `[:${infer Rest}`
+    ? Parse<Rest, Expressions, ArrayIndex<AsExpr<Exp>, ValueRef<"">>>
+    : Text extends `[${infer Rest}`
+      ? Parse<Rest, Expressions, ArrayIndex<AsExpr<Exp>, NumberLiteral<"">>>
+      : Text extends `]${infer Rest}`
+        ? Parse<Rest, Expressions, Exp>
+        : Text extends `]`
+          ? Concat<Expressions, Exp>
+          : Text extends `${"," | " "}${infer Rest}`
+            ? Parse<Rest, Concat<Expressions, Exp>, undefined>
+            : Text extends `#${infer Rest}`
+              ? Parse<Rest, Concat<Expressions, Exp>, NameRef<Rest>>
+              : Text extends `:${infer Rest}`
+                ? Parse<Rest, Concat<Expressions, Exp>, ValueRef<Rest>>
+                : Text extends `${Word}${string}`
+                  ? Text extends `${infer char}${infer Rest}`
+                    ? Parse<Rest, Expressions, Append<Exp, char>>
+                    : never
+                  : Text extends `${Word}${string}`
+                    ? Text extends `${infer char}${infer Rest}`
+                      ? Parse<Rest, Expressions, Append<Exp, char>>
+                      : never
+                    : Concat<Expressions, Exp>;
+
+type Concat<
+  Expressions extends Expr[],
+  CurrentExpr extends Expr | undefined,
+> = undefined extends CurrentExpr
+  ? Expressions
+  : [...Expressions, Extract<CurrentExpr, Expr>];
+
+type Append<
+  Exp extends Expr | undefined,
+  char extends string,
+> = Exp extends undefined
+  ? Identifier<char>
+  : Exp extends Identifier<infer Name>
+    ? Identifier<`${Name}${char}`>
+    : Exp extends NumberLiteral<infer Name>
+      ? NumberLiteral<`${Name}${char}`>
+      : Exp extends NameRef<infer Name>
+        ? NameRef<`${Name}${char}`>
+        : Exp extends ValueRef<infer Name>
+          ? ValueRef<`${Name}${char}`>
+          : Exp extends PropRef<infer expr, infer name>
+            ? PropRef<expr, Extract<Append<name, char>, Identifier>>
+            : Exp extends ArrayIndex<infer expr, infer idx>
+              ? ArrayIndex<expr, Extract<Append<idx, char>, NumberLiteral>>
+              : never;
+
+export type ApplyProjection<T, Expr extends string> = Flatten<
+  UnionToIntersection<
+    ApplyProjectionExpr<T, ParseProjectionExpression<Expr>[number]>
+  >
+>;
+
+type ApplyProjectionExpr<T, Exp extends Expr> = T extends undefined
+  ? never
+  : Exp extends PropRef<infer expr, infer i>
+    ? {
+        [p in keyof ApplyProjectionExpr<T, expr>]: ApplyProjectionExpr<
+          ApplyProjectionExpr<T, expr>[p],
+          i
+        >;
+      }
+    : Exp extends ArrayIndex<infer expr, infer i>
+      ? {
+          [p in keyof ApplyProjectionExpr<T, expr>]: ApplyProjectionExpr<
+            ApplyProjectionExpr<T, expr>[keyof ApplyProjectionExpr<T, expr>],
+            i
+          >;
+        }
+      : Exp extends Identifier<infer I>
+        ? I extends keyof T
+          ? Pick<T, I>
+          : never
+        : Exp extends NumberLiteral<infer I>
+          ? ParseInt<I> extends keyof T
+            ? Pick<T, ParseInt<I>>
+            : never
+          : never;
+
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
+  k: infer I,
+) => void
+  ? I
+  : never;
+
+type Flatten<T> = T extends object
+  ? keyof T extends number
+    ? FlattenArray<Extract<T, Record<number, any>>>
+    : {
+        [k in keyof T]: Flatten<T[k]>;
+      }
+  : T;
+
+type FlattenArray<
+  T extends { [i in number]: any },
+  i extends number = 0,
+> = i extends keyof T
+  ? [T[i], ...FlattenArray<T, Inc<i>>]
+  : number extends i
+    ? []
+    : FlattenArray<T, Inc<i>>;
+
+type BuildTuple<N extends number, T extends any[] = []> = T["length"] extends N
+  ? T
+  : BuildTuple<N, [...T, any]>;
+
+type Inc<N extends number> = Extract<[...BuildTuple<N>, any]["length"], number>;
+
+type ParseInt<N extends string> = N extends "0"
+  ? 0
+  : N extends "1"
+    ? 1
+    : N extends "2"
+      ? 2
+      : N extends "3"
+        ? 3
+        : N extends "4"
+          ? 4
+          : N extends "5"
+            ? 5
+            : N extends "6"
+              ? 6
+              : N extends "7"
+                ? 7
+                : N extends "8"
+                  ? 8
+                  : N extends "9"
+                    ? 9
+                    : number;

package/src/aws/dynamodb/secondary-index.ts

@@ -0,0 +1,45 @@
+import * as S from "effect/Schema";
+import { Resource } from "../../resource.ts";
+import type { Table } from "./table.ts";
+
+export const SecondaryIndex = Resource<{
+  <
+    const ID extends string,
+    const Source extends Table,
+    const Attributes extends S.Struct.Fields,
+    const PartitionKey extends keyof Attributes,
+    const SortKey extends keyof Attributes | undefined = undefined,
+  >(
+    id: ID,
+    props: SecondaryIndexProps<Source, Attributes, PartitionKey, SortKey>,
+  ): SecondaryIndex<
+    ID,
+    SecondaryIndexProps<Source, Attributes, PartitionKey, SortKey>
+  >;
+}>("AWS.DynamoDB.SecondaryIndex");
+
+export interface SecondaryIndex<
+  ID extends string = string,
+  Props extends SecondaryIndexProps = SecondaryIndexProps,
+> extends Resource<
+    "AWS.DynamoDB.SecondaryIndex",
+    ID,
+    Props,
+    SecondaryIndexAttrs<Props>
+  > {}
+
+export interface SecondaryIndexProps<
+  Source extends Table = Table,
+  Attributes extends S.Struct.Fields = S.Struct.Fields,
+  PartitionKey extends keyof Attributes = keyof Attributes,
+  SortKey extends keyof Attributes | undefined = keyof Attributes | undefined,
+> {
+  table: new () => Source;
+  indexName?: string;
+  partitionKey: PartitionKey;
+  sortKey?: SortKey;
+}
+
+export type SecondaryIndexAttrs<Props extends SecondaryIndexProps> = {
+  indexName: Props["indexName"] extends string ? Props["indexName"] : string;
+};

package/src/aws/dynamodb/table.get-item.ts

@@ -0,0 +1,177 @@
+import {
+  Binding,
+  declare,
+  Policy,
+  toEnvKey,
+  type Capability,
+  type From,
+} from "alchemy-effect";
+import { Effect } from "effect";
+import type { ReturnConsumedCapacity } from "itty-aws/dynamodb";
+import { Function } from "../lambda/index.ts";
+import { fromAttributeValue } from "./attribute-value.ts";
+import { DynamoDBClient } from "./client.ts";
+import type { Identifier } from "./expr.ts";
+import type { ParseProjectionExpression } from "./projection.ts";
+import { Table } from "./table.ts";
+
+export interface GetItemConstraint<
+  LeadingKeys extends Policy.AnyOf<any> = Policy.AnyOf<any>,
+  Attributes extends Policy.AnyOf<any> = Policy.AnyOf<any>,
+  ReturnConsumedCapacity extends Policy.AnyOf<any> = Policy.AnyOf<any>,
+> {
+  leadingKeys?: LeadingKeys;
+  attributes?: Attributes;
+  returnConsumedCapacity?: ReturnConsumedCapacity;
+}
+
+export interface GetItem<
+  T = unknown,
+  Constraint extends GetItemConstraint | unknown = unknown,
+> extends Capability<"AWS.DynamoDB.GetItem", T, Constraint> {
+  Constructor: GetItem;
+  Reduce: GetItem<
+    this["resource"],
+    {
+      [k in keyof Capability.Constraint.Simplify<
+        this["constraint"]
+      >]: Capability.Constraint.Simplify<this["constraint"]>[k];
+    }
+  >;
+}
+
+export const GetItem = Binding<
+  <
+    T extends Table,
+    const LeadingKeys extends Policy.AnyOf<any> = Policy.AnyOf<string>,
+    const Attributes extends Policy.AnyOf<any> = never,
+    const ReturnConsumedCapacity extends Policy.AnyOf<any> = never,
+  >(
+    table: T,
+    constraint?: GetItemConstraint<
+      LeadingKeys,
+      Attributes,
+      ReturnConsumedCapacity
+    >,
+  ) => Binding<
+    Function,
+    GetItem<
+      From<T>,
+      Policy.Constraint<{
+        leadingKeys: LeadingKeys;
+        attributes: Attributes;
+        returnConsumedCapacity: ReturnConsumedCapacity;
+      }>
+    >
+  >
+>(Function, "AWS.DynamoDB.GetItem");
+
+// see: https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazondynamodb.html
+export const getItem = <
+  T extends Table<string, any>,
+  const Key extends Table.Key<T>,
+  const ProjectionExpression extends string = never,
+  const Capacity extends ReturnConsumedCapacity = never,
+>({
+  table,
+  key,
+  projectionExpression,
+  returnConsumedCapacity,
+}: {
+  table: T;
+  key: Key;
+  projectionExpression?: ProjectionExpression;
+  returnConsumedCapacity?: Capacity;
+}) =>
+  Effect.gen(function* () {
+    type Parsed = ParseProjectionExpression<ProjectionExpression>;
+    type Attributes = Extract<Parsed[number], Identifier>["name"];
+    type LeadingKeys = Extract<Key[T["props"]["partitionKey"]], string>;
+    type Constraint = Policy.Constraint<{
+      leadingKeys: Policy.AnyOf<LeadingKeys>;
+      attributes: Policy.AnyOf<Attributes>;
+      returnConsumedCapacity: Policy.AnyOf<Capacity>;
+    }>;
+    yield* declare<
+      GetItem<
+        From<T>,
+        {
+          [k in keyof Constraint]: Constraint[k];
+        }
+      >
+    >();
+    const tableNameEnv = toEnvKey(table.id, "TABLE_NAME");
+    const tableName = process.env[tableNameEnv];
+    if (!tableName) {
+      return yield* Effect.die(new Error(`${tableNameEnv} is not set`));
+    }
+    const ddb = yield* DynamoDBClient;
+    const { Item, ...rest } = yield* ddb.getItem({
+      TableName: tableName,
+      Key: {
+        [table.props.partitionKey]: {
+          S: (key as any)[table.props.partitionKey] as string,
+        },
+        ...(table.props.sortKey
+          ? {
+              [table.props.sortKey]: {
+                S: (key as any)[table.props.sortKey] as string,
+              },
+            }
+          : {}),
+      },
+      ProjectionExpression: projectionExpression,
+      ReturnConsumedCapacity: returnConsumedCapacity,
+    });
+
+    return {
+      ...rest,
+      Item: Item
+        ? (Object.fromEntries(
+            yield* Effect.promise(() =>
+              Promise.all(
+                Object.entries(Item!).map(async ([key, value]) => [
+                  key,
+                  await fromAttributeValue(value),
+                ]),
+              ),
+            ),
+          ) as InstanceType<T["props"]["items"]> & Key)
+        : undefined,
+    };
+  });
+
+export const getItemFromLambdaFunction = () =>
+  GetItem.provider.succeed({
+    attach: ({ source: table, props }) => ({
+      env: {
+        [toEnvKey(table.id, "TABLE_NAME")]: table.attr.tableName,
+        [toEnvKey(table.id, "TABLE_ARN")]: table.attr.tableArn,
+      },
+      policyStatements: [
+        {
+          Sid: "GetItem",
+          Effect: "Allow",
+          Action: ["dynamodb:GetItem"],
+          Resource: [table.attr.tableArn],
+          Condition:
+            props?.leadingKeys ||
+            props?.attributes ||
+            props?.returnConsumedCapacity
+              ? {
+                  // https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazondynamodb.html#amazondynamodb-dynamodb_LeadingKeys
+
+                  // TODO(sam): add StringLike for prefixes, templates, etc.
+                  "ForAllValues:StringEquals": {
+                    "dynamodb:LeadingKeys": props.leadingKeys
+                      ?.anyOf as string[],
+                    "dynamodb:Attributes": props.attributes?.anyOf as string[],
+                    "dynamodb:ReturnConsumedCapacity": props
+                      .returnConsumedCapacity?.anyOf as string[],
+                  },
+                }
+              : undefined,
+        },
+      ],
+    }),
+  });