alchemy-effect 0.1.0 → 0.3.0

package/src/aws/dynamodb/attribute-value.ts

@@ -0,0 +1,240 @@
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+import type { AttributeValue, ScalarAttributeType } from "itty-aws/dynamodb";
+import {
+  getSetValueAST,
+  isClassSchema,
+  isListSchema,
+  isMapSchema,
+  isNumberSchema,
+  isRecordLikeSchema,
+  isRecordSchema,
+  isSetSchema,
+  isStringSchema,
+  isStructSchema,
+} from "../../schema.ts";
+
+// this seems important for handling S.Struct.Fields https://effect.website/docs/schema/classes/#recursive-types-with-different-encoded-and-type
+// interface CategoryEncoded extends Schema.Struct.Encoded<typeof fields> { .. }
+
+export class InvalidAttributeValue extends Data.TaggedError(
+  "InvalidAttributeValue",
+)<{
+  message: string;
+  value: any;
+}> {}
+
+export const toAttributeValue: (
+  value: any,
+) => Effect.Effect<AttributeValue, InvalidAttributeValue, never> = Effect.fn(
+  function* (value: any) {
+    if (value === undefined) {
+      return {
+        NULL: false,
+      };
+    } else if (value === null) {
+      return {
+        NULL: true,
+      };
+    } else if (typeof value === "boolean") {
+      return {
+        BOOL: value,
+      };
+    } else if (typeof value === "string") {
+      return {
+        S: value,
+      };
+    } else if (typeof value === "number") {
+      return {
+        N: value.toString(10),
+      };
+    } else if (Array.isArray(value)) {
+      return {
+        L: yield* Effect.all(value.map(toAttributeValue)),
+      };
+    } else if (value instanceof Set) {
+      const setType = getType(value);
+      if (setType === "EMPTY_SET") {
+        return {
+          SS: [],
+        };
+      } else if (Array.isArray(setType)) {
+        return {
+          L: yield* Effect.all(setType.map(toAttributeValue)),
+        };
+      } else if (setType === "SS") {
+        return {
+          SS: Array.from(value.values()),
+        };
+      } else if (setType === "NS") {
+        return {
+          NS: Array.from(value.values()).map((value) => value.toString(10)),
+        };
+      } else if (setType === "BS") {
+        return {
+          BS: Array.from(value.values()),
+        };
+      } else {
+        return {
+          L: yield* Effect.all(
+            Array.from(value.values()).map(toAttributeValue),
+          ),
+        };
+      }
+    } else if (Buffer.isBuffer(value)) {
+      return {
+        B: new Uint8Array(value),
+      };
+    } else if (value instanceof File) {
+      return {
+        B: new Uint8Array(yield* Effect.promise(() => value.arrayBuffer())),
+      };
+    } else if (value instanceof Uint8Array) {
+      return {
+        B: value,
+      };
+    } else if (value instanceof ArrayBuffer) {
+      return {
+        B: new Uint8Array(value),
+      };
+    } else if (typeof value === "object") {
+      return {
+        M: Object.fromEntries(
+          yield* Effect.all(
+            Object.entries(value).map(([key, value]) =>
+              toAttributeValue(value).pipe(Effect.map((value) => [key, value])),
+            ),
+          ),
+        ),
+      };
+    }
+
+    return yield* Effect.fail(
+      new InvalidAttributeValue({
+        message: `Unknown value type: ${typeof value}`,
+        value,
+      }),
+    );
+  },
+);
+
+export const fromAttributeValue = (value: AttributeValue): any => {
+  if (value.NULL) {
+    return null;
+  } else if (typeof value.BOOL === "boolean") {
+    return value.BOOL;
+  } else if (value.L) {
+    return value.L.map(fromAttributeValue);
+  } else if (value.M) {
+    return Object.fromEntries(
+      Object.entries(value.M).map(([key, value]) => [
+        key,
+        fromAttributeValue(value),
+      ]),
+    );
+  } else if (value.N) {
+    return parseFloat(value.N);
+  } else if (value.S) {
+    // how do we know if this is a date?
+    return value.S;
+  } else if (value.SS) {
+    return new Set(value.SS);
+  } else if (value.NS) {
+    return new Set(value.NS);
+  } else if (value.BS) {
+    return new Set(value.BS);
+  } else {
+    throw new Error(`Unknown attribute value: ${JSON.stringify(value)}`);
+  }
+};
+
+type ValueType =
+  | "L"
+  | "BOOL"
+  | "EMPTY_SET"
+  | "M"
+  | "NULL"
+  | "N"
+  | "M"
+  | "S"
+  | "SS"
+  | "BS"
+  | "NS"
+  | "undefined";
+
+const getType = (value: any): ValueType | ValueType[] => {
+  if (value === undefined) {
+    return "undefined";
+  } else if (value === null) {
+    return "NULL";
+  } else if (typeof value === "boolean") {
+    return "BOOL";
+  } else if (typeof value === "string") {
+    return "S";
+  } else if (typeof value === "number") {
+    return "N";
+  } else if (Array.isArray(value)) {
+    return "L";
+  } else if (value instanceof Set) {
+    return value.size === 0
+      ? "EMPTY_SET"
+      : (() => {
+          const types = Array.from(value.values())
+            .flatMap(getType)
+            .filter((type, i, arr) => arr.indexOf(type) === i);
+
+          return types.length === 1
+            ? types[0] === "S"
+              ? "SS"
+              : types[0] === "N"
+                ? "NS"
+                : types[0] === "BOOL"
+                  ? "BS"
+                  : types[0]
+            : "L";
+        })();
+  } else if (value instanceof Map) {
+    return "M";
+  } else if (typeof value === "object") {
+    return "M";
+  } else {
+    throw new Error(`Unknown value type: ${typeof value}`);
+  }
+};
+
+export const isScalarAttributeType = (
+  type: string,
+): type is ScalarAttributeType => {
+  return type === "S" || type === "N" || type === "B";
+};
+
+export const toAttributeType = (schema: S.Schema<any>) => {
+  if (isStringSchema(schema)) {
+    return "S";
+  } else if (isNumberSchema(schema)) {
+    return "N";
+  } else if (isRecordLikeSchema(schema)) {
+    return "M";
+  } else if (isStringSetSchema(schema)) {
+    return "SS";
+  } else if (isNumberSetSchema(schema)) {
+    return "NS";
+  } else if (isListSchema(schema)) {
+    return "L";
+  }
+  return "S";
+};
+
+export const isMapSchemaType = (schema: S.Schema<any>) =>
+  isMapSchema(schema) ||
+  isRecordSchema(schema) ||
+  isStructSchema(schema) ||
+  isClassSchema(schema) ||
+  false;
+
+export const isStringSetSchema = (schema: S.Schema<any>) =>
+  isSetSchema(schema) && isStringSchema(getSetValueAST(schema));
+
+export const isNumberSetSchema = (schema: S.Schema<any>) =>
+  isSetSchema(schema) && isNumberSchema(getSetValueAST(schema));

package/src/aws/{sqs/queue.client.ts → dynamodb/client.ts}

@@ -1,20 +1,20 @@
-import * as Context from "effect/Context";
 import * as Layer from "effect/Layer";
+import * as Context from "effect/Context";
+import { DynamoDB } from "itty-aws/dynamodb";
 
-import { SQS as SQSClient } from "itty-aws/sqs";
-import { createAWSServiceClientLayer } from "../client.ts";
 import * as Credentials from "../credentials.ts";
 import * as Region from "../region.ts";
+import { createAWSServiceClientLayer } from "../client.ts";
 
-export class QueueClient extends Context.Tag("AWS::SQS::Queue.Client")<
-  QueueClient,
-  SQSClient
+export class DynamoDBClient extends Context.Tag("AWS::DynamoDB::Client")<
+  DynamoDBClient,
+  DynamoDB
 >() {}
 
 export const client = createAWSServiceClientLayer<
-  typeof QueueClient,
-  SQSClient
->(QueueClient, SQSClient);
+  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";
+
+// TODO(sam): figure out a better strategy to workaround non-portable types
+export type * from "../../exports.ts";
+
+import "../config.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;
+};