alchemy-effect 0.6.0 → 0.6.2

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

@@ -1,240 +0,0 @@
-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/dynamodb/client.ts

@@ -1,20 +0,0 @@
-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/index.ts

@@ -1,12 +0,0 @@
-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

@@ -1,159 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,173 +0,0 @@
-import { Effect } from "effect";
-import type { ReturnConsumedCapacity } from "itty-aws/dynamodb";
-import { Binding } from "../../binding.ts";
-import type { Capability } from "../../capability.ts";
-import { toEnvKey } from "../../env.ts";
-import { declare, type From, type Policy } from "../../policy.ts";
-import { Function } from "../lambda/function.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,
-        },
-      ],
-    }),
-  });