alchemy-effect 0.6.0 → 0.6.2

package/src/policy.ts

@@ -1,128 +0,0 @@
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as S from "effect/Schema";
-import { type AnyBinding, type Bind } from "./binding.ts";
-import type { Capability } from "./capability.ts";
-import type { IRuntime, Runtime } from "./runtime.ts";
-
-/**
- * A Policy binds a set of Capbilities (e.g SQS.SendMessage, SQS.Consume, etc.) to a
- * specific Runtime (e.g. AWS Lambda Function, Cloudflare Worker, etc.).
- *
- * It brings with it a set of upstream Tags containing the required Provider services
- * to deploy the infrastructure, e.g. (BindingTag<AWS.Lambda.Function, SendMessage<Queue>>)
- *
- * A Policy is invariant over the set of Capabilities to ensure least-privilege.
- */
-export interface Policy<
-  F extends IRuntime,
-  in out Capabilities,
-  Tags = unknown,
-> {
-  readonly kind: "alchemy/Policy";
-  readonly runtime: F;
-  readonly tags: Tags[];
-  readonly capabilities: Capabilities[];
-  // phantom property (exists at runtime but not in types)
-  // readonly bindings: AnyBinding[];
-  /** Add more Capabilities to a Policy */
-  and<B extends AnyBinding[]>(
-    ...bindings: B
-  ): Policy<
-    F,
-    B[number]["capability"] | Capabilities,
-    BindingTags<B[number]> | Exclude<Tags, unknown>
-  >;
-}
-
-type BindingTags<B extends AnyBinding> = B extends any
-  ? Bind<B["runtime"], B["capability"], Extract<B["tag"], string>>
-  : never;
-
-export function Policy<F extends Runtime>(): Policy<F, never, never>;
-export function Policy<B extends AnyBinding[]>(
-  ...capabilities: B
-): Policy<
-  B[number]["runtime"],
-  B[number]["capability"],
-  BindingTags<B[number]>
->;
-export function Policy(...bindings: AnyBinding[]): any {
-  return {
-    runtime: bindings[0]?.["runtime"],
-    capabilities: bindings.map((b) => b.capability),
-    tags: bindings.map((b) => Context.Tag(b.tag as any)()),
-    bindings,
-    and: (...b2: AnyBinding[]) => Policy(...bindings, ...b2),
-  } as Policy<any, any, any> & {
-    // add the phantom property
-    bindings: AnyBinding[];
-  };
-}
-
-export namespace Policy {
-  export interface AnyOf<in out T> {
-    readonly anyOf: T[];
-  }
-  type Generalize<T> = T extends S.Schema<infer U> ? U : T;
-
-  export const anyOf = <const T>(...anyOf: T[]): AnyOf<Generalize<T>> => ({
-    anyOf: anyOf as Generalize<T>[],
-  });
-
-  export const join = <
-    const Strings extends readonly string[],
-    const Delimiter extends string,
-  >(
-    strings: Strings,
-    delimiter: Delimiter,
-  ) => strings.join(delimiter) as Join<Strings, Delimiter>;
-
-  type ___ = Join<string[], ",">;
-  type Join<
-    T extends readonly string[],
-    Delimiter extends string,
-  > = T extends readonly [infer First extends string]
-    ? First
-    : T extends readonly [
-          infer First extends string,
-          ...infer Rest extends readonly string[],
-        ]
-      ? `${First}${Delimiter}${Join<Rest, Delimiter>}`
-      : T extends string[]
-        ? string
-        : "";
-
-  export type Constraint<T> = Pick<
-    T,
-    {
-      [k in keyof T]: T[k] extends never
-        ? never
-        : T[k] extends AnyOf<never>
-          ? never
-          : k;
-    }[keyof T]
-  >;
-
-  // TODO(sam): one day we might infer policies using a compiler plugin, this is a placeholder
-  export const infer = <T>(): T => undefined!;
-}
-
-/** declare a Policy requiring Capabilities in some context */
-export const declare = <S extends Capability>() =>
-  Effect.gen(function* () {}) as Effect.Effect<void, never, S>;
-
-export type Instance<T> = T extends { id: string }
-  ? string extends T["id"]
-    ? T
-    : T extends new (...args: any) => infer I
-      ? I
-      : never
-  : never;
-// syntactic sugar for mapping `typeof Messages` -> Messages, e.g. so it's SQS.SendMessage<Messages> instead of SQS.SendMessage<typeof Messages>
-// e.g. <Q extends SQS.Queue>(queue: Q) => SQS.SendMessage<To<Q>>
-export type From<T> = Instance<T>;
-export type To<T> = Instance<T>;
-export type In<T> = Instance<T>;
-export type Into<T> = Instance<T>;
-export type On<T> = Instance<T>;

package/src/provider.ts

@@ -1,113 +0,0 @@
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import type { ScopedPlanStatusSession } from "./cli/service.ts";
-import type { Diff } from "./diff.ts";
-import type { Input } from "./input.ts";
-import type { Resource } from "./resource.ts";
-import type { Runtime } from "./runtime.ts";
-import type { Service } from "./service.ts";
-
-export interface Provider<
-  R extends Resource | Service,
-> extends Context.TagClass<
-  Provider<R>,
-  R["type"],
-  ProviderService<any>
-  // TODO(sam): we are using any here because the R["type"] is enough and gaining access to the sub type (e.g. SQS.Queue)
-  // is currently not possible in the current approach
-
-  // preferred:
-  // ProviderService<R>
-> {}
-
-type BindingData<Res extends Resource> = [Res] extends [Runtime]
-  ? Res["binding"][]
-  : any[];
-
-type Props<Res extends Resource> = Input.ResolveOpaque<Res["props"]>;
-
-export interface ProviderService<
-  Res extends Resource = Resource,
-  ReadReq = never,
-  DiffReq = never,
-  PrecreateReq = never,
-  CreateReq = never,
-  UpdateReq = never,
-  DeleteReq = never,
-> {
-  /**
-   * The version of the provider.
-   *
-   * @default 0
-   */
-  version?: number;
-  // tail();
-  // watch();
-  // replace(): Effect.Effect<void, never, never>;
-  // different interface that is persistent, watching, reloads
-  // run?() {}
-  read?(input: {
-    id: string;
-    instanceId: string;
-    olds: Props<Res>;
-    // what is the ARN?
-    output: Res["attr"] | undefined; // current state -> synced state
-    bindings: BindingData<Res>;
-  }): Effect.Effect<Res["attr"] | undefined, any, ReadReq>;
-  /**
-   * Properties that are always stable across any update.
-   */
-  stables?: Extract<keyof Res["attr"], string>[];
-  diff?(input: {
-    id: string;
-    olds: Props<Res>;
-    instanceId: string;
-    // Note: we do not resolve (Props<Res>) here because diff runs during plan
-    // -> we need a way for the diff handlers to work with Outputs
-    news: Res["props"];
-    output: Res["attr"];
-  }): Effect.Effect<Diff | void, never, DiffReq>;
-  precreate?(input: {
-    id: string;
-    news: Props<Res>;
-    instanceId: string;
-    session: ScopedPlanStatusSession;
-  }): Effect.Effect<Res["attr"], any, PrecreateReq>;
-  create(input: {
-    id: string;
-    instanceId: string;
-    news: Props<Res>;
-    session: ScopedPlanStatusSession;
-    bindings: BindingData<Res>;
-  }): Effect.Effect<Res["attr"], any, CreateReq>;
-  update(input: {
-    id: string;
-    instanceId: string;
-    news: Props<Res>;
-    olds: Props<Res>;
-    output: Res["attr"];
-    session: ScopedPlanStatusSession;
-    bindings: BindingData<Res>;
-  }): Effect.Effect<Res["attr"], any, UpdateReq>;
-  delete(input: {
-    id: string;
-    instanceId: string;
-    olds: Props<Res>;
-    output: Res["attr"];
-    session: ScopedPlanStatusSession;
-    bindings: BindingData<Res>;
-  }): Effect.Effect<void, any, DeleteReq>;
-}
-
-export const getProviderByType = Effect.fnUntraced(function* (
-  resourceType: string,
-) {
-  const context = yield* Effect.context<never>();
-  const provider: ProviderService = context.unsafeMap.get(resourceType);
-  if (!provider) {
-    return yield* Effect.die(
-      new Error(`Provider not found for ${resourceType}`),
-    );
-  }
-  return provider;
-});

package/src/ref.ts

@@ -1,48 +0,0 @@
-import type { Resource, AnyResource } from "./resource.ts";
-import * as Output from "./output.ts";
-
-// special runtime-only symbol for probing the Ref proxy for its metadata
-const RefMetadata = Symbol.for("alchemy/RefMetadata");
-
-export const isRef = (s: any): s is Ref<any> =>
-  s && s[RefMetadata] !== undefined;
-
-export const getRefMetadata = <R extends Resource<string, string, any, any>>(
-  ref: Ref<R>,
-): RefMetadata<R> => (ref as any)[RefMetadata];
-
-export interface Ref<
-  R extends Resource<string, string, any, any> = AnyResource,
-> {
-  /** @internal phantom */
-  Ref: R;
-}
-
-export interface RefMetadata<R extends Resource<string, string, any, any>> {
-  stack?: string;
-  stage?: string;
-  resourceId: R["id"];
-}
-
-export const ref = <R extends Resource<string, string, any, any>>({
-  stack,
-  resourceId,
-  stage,
-}: RefMetadata<R>): Ref<R> => {
-  const ref = new Proxy(
-    {},
-    {
-      get: (_, prop) => {
-        if (prop === RefMetadata) {
-          return {
-            stack,
-            stage,
-            resourceId,
-          };
-        }
-        return (Output.of(ref) as any)[prop];
-      },
-    },
-  ) as Ref<R>;
-  return ref;
-};

package/src/reporter.ts

@@ -1,8 +0,0 @@
-import * as Context from "effect/Context";
-
-export class Reporter extends Context.Tag("Reporter")<
-  Reporter,
-  {
-    report: (event: Event) => void;
-  }
->() {}

package/src/resource.ts

@@ -1,140 +0,0 @@
-import * as Context from "effect/Context";
-import type { Effect } from "effect/Effect";
-import * as Layer from "effect/Layer";
-import type { Provider, ProviderService } from "./provider.ts";
-import type { InstanceId } from "./instance-id.ts";
-
-export const isResource = (r: any): r is Resource => {
-  return (
-    r && typeof r === "function" && "id" in r && "type" in r && "props" in r
-  );
-};
-
-export type AnyResource = Resource<string, string, any, any>;
-
-export interface IResource<
-  Type extends string = string,
-  ID extends string = string,
-  Props = unknown,
-  Attrs = unknown,
-  Base = unknown,
-> {
-  id: ID;
-  type: Type;
-  Props: unknown;
-  props: Props;
-  base: Base;
-  /** @internal phantom */
-  attr: Attrs;
-}
-
-export interface Resource<
-  Type extends string = string,
-  ID extends string = string,
-  Props = unknown,
-  Attrs = unknown,
-  Base = unknown,
-> extends IResource<Type, ID, Props, Attrs, Base> {
-  new (): Resource<Type, ID, Props, Attrs, Base>;
-}
-
-export interface ResourceTags<R extends Resource<string, string, any, any>> {
-  of<S extends ProviderService<R>>(service: S): S;
-  tag: Provider<R>;
-  effect<
-    Err,
-    Req,
-    ReadReq = never,
-    DiffReq = never,
-    PrecreateReq = never,
-    CreateReq = never,
-    UpdateReq = never,
-    DeleteReq = never,
-  >(
-    eff: Effect<
-      ProviderService<
-        R,
-        ReadReq,
-        DiffReq,
-        PrecreateReq,
-        CreateReq,
-        UpdateReq,
-        DeleteReq
-      >,
-      Err,
-      Req
-    >,
-  ): Layer.Layer<
-    Provider<R>,
-    Err,
-    Exclude<
-      | Req
-      | ReadReq
-      | DiffReq
-      | PrecreateReq
-      | CreateReq
-      | UpdateReq
-      | DeleteReq,
-      InstanceId
-    >
-  >;
-  succeed<
-    ReadReq = never,
-    DiffReq = never,
-    PrecreateReq = never,
-    CreateReq = never,
-    UpdateReq = never,
-    DeleteReq = never,
-  >(
-    service: ProviderService<
-      R,
-      ReadReq,
-      DiffReq,
-      PrecreateReq,
-      CreateReq,
-      UpdateReq,
-      DeleteReq
-    >,
-  ): Layer.Layer<
-    Provider<R>,
-    never,
-    Exclude<
-      ReadReq | DiffReq | PrecreateReq | CreateReq | UpdateReq | DeleteReq,
-      InstanceId
-    >
-  >;
-}
-
-export const Resource = <Ctor extends (id: string, props: any) => Resource>(
-  type: ReturnType<Ctor>["type"],
-) => {
-  const Tag = Context.Tag(type)();
-  const provider: ResourceTags<ReturnType<Ctor>> = {
-    tag: Tag as any,
-    effect: (eff) => Layer.effect(Tag, eff),
-    succeed: (service: ProviderService<ReturnType<Ctor>>) =>
-      Layer.succeed(Tag, service),
-    of: (service) => service,
-  } as ResourceTags<ReturnType<Ctor>>;
-  return Object.assign(
-    function (id: string, props: any) {
-      return class Resource {
-        static readonly id = id;
-        static readonly type = type;
-        static readonly props = props;
-        static readonly provider = provider;
-      };
-    } as unknown as Ctor & {
-      type: ReturnType<Ctor>["type"];
-      parent: ReturnType<Ctor>;
-      new (): ReturnType<Ctor> & {
-        parent: ReturnType<Ctor>;
-      };
-      provider: typeof provider;
-    },
-    {
-      type: type,
-      provider,
-    },
-  );
-};

package/src/runtime.ts

@@ -1,152 +0,0 @@
-import type { Types } from "effect";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import type { Capability } from "./capability.ts";
-import type { Policy } from "./policy.ts";
-import type { ProviderService } from "./provider.ts";
-import type { IResource, Resource, ResourceTags } from "./resource.ts";
-import type { IService, Service } from "./service.ts";
-
-export type RuntimeHandler<
-  Inputs extends any[] = any[],
-  Output = any,
-  Err = any,
-  Req = any,
-> = (...inputs: Inputs) => Effect.Effect<Output, Err, Req>;
-
-export declare namespace RuntimeHandler {
-  export type Caps<H extends RuntimeHandler | unknown> = Extract<
-    Effect.Effect.Context<ReturnType<Extract<H, RuntimeHandler>>>,
-    Capability
-  >;
-}
-
-export declare namespace Runtime {
-  export type Binding<F, Cap> = F extends {
-    readonly Binding: unknown;
-  }
-    ? (F & {
-        readonly cap: Cap;
-      })["Binding"]
-    : {
-        readonly F: F;
-        readonly cap: Types.Contravariant<Cap>;
-      };
-}
-
-export type AnyRuntime = Runtime<string>;
-
-export interface RuntimeProps<Run extends IRuntime, Req> {
-  bindings: Policy<Run, Extract<Req, Capability>, unknown>;
-}
-
-export interface IRuntime<
-  Type extends string = string,
-  Handler = unknown,
-  Props = unknown,
-> extends IResource<Type, string, Props> {
-  type: Type;
-  props: Props;
-  handler: Handler;
-  binding: unknown;
-  /** @internal phantom */
-  capability: unknown;
-}
-
-export interface Runtime<
-  Type extends string = string,
-  Handler = unknown,
-  Props = unknown,
->
-  extends IRuntime<Type, Handler, Props>, Resource<Type, string, Props> {
-  provider: ResourceTags<this>;
-  <
-    const ID extends string,
-    Inputs extends any[],
-    Output,
-    Err,
-    Req,
-    Handler extends RuntimeHandler<Inputs, Output, Err, Req>,
-  >(
-    id: ID,
-    { handle }: { handle: Handler },
-  ): <const Props extends this["props"]>(
-    props: Props,
-  ) => Service<
-    ID,
-    this,
-    Handler,
-    // @ts-expect-error
-    Props
-  >;
-}
-
-export const Runtime =
-  <const Type extends string>(type: Type) =>
-  <Self extends Runtime>(): Self => {
-    const Tag = Context.Tag(type)();
-    const provider = {
-      tag: Tag,
-      effect: (eff: Effect.Effect<ProviderService<Self>, any, any>) =>
-        Layer.effect(Tag, eff),
-      succeed: (service: ProviderService<Self>) => Layer.succeed(Tag, service),
-    };
-    const self = Object.assign(
-      (
-        ...args:
-          | [cap: Capability]
-          | [
-              id: string,
-              { handle: (...args: any[]) => Effect.Effect<any, never, any> },
-            ]
-      ) => {
-        if (args.length === 1) {
-          const [cap] = args;
-          const tag = `${type}(${cap})` as const;
-          return class extends Context.Tag(tag)<Self, string>() {
-            Capability = cap;
-          };
-        } else {
-          const [id, { handle }] = args;
-          return <const Props extends RuntimeProps<Self, any>>(props: Props) =>
-            Object.assign(
-              class {
-                constructor() {
-                  throw new Error("Cannot instantiate a Service directly");
-                }
-              },
-              {
-                kind: "Service",
-                type,
-                id,
-                attr: undefined!,
-                impl: handle,
-                handler: Effect.succeed(handle as any),
-                props,
-                runtime: self,
-                // TODO(sam): is this right?
-                parent: self,
-                // @ts-expect-error
-                provider,
-              } satisfies IService<string, Self, any, any, Self>,
-            );
-        }
-      },
-      {
-        kind: "Runtime",
-        type: type,
-        id: undefined! as string,
-        capability: undefined! as Capability[],
-        provider,
-        toString() {
-          return `${this.type}(${this.id}${
-            this.capability?.length
-              ? `, ${this.capability.map((c) => `${c}`).join(", ")}`
-              : ""
-          })`;
-        },
-      },
-    ) as unknown as Self;
-    return self as any;
-  };

package/src/schema.ts

@@ -1,102 +0,0 @@
-import * as S from "effect/Schema";
-import type { AST } from "effect/SchemaAST";
-
-const Description = Symbol.for("effect/annotation/Description");
-
-export const isTag = <T extends S.Schema<any>>(tag: T["ast"]["_tag"]) =>
-  ((schema) =>
-    S.isSchema(schema)
-      ? S.encodedSchema(schema).ast._tag === tag
-      : schema._tag === tag) as {
-    (schema: S.Schema<any>): schema is T;
-    (schema: AST): boolean;
-  };
-
-export const hasGenericAnnotation =
-  (type: string) => (ast: AST | undefined) => {
-    const description: string | undefined = ast?.annotations?.[
-      Description
-    ] as string;
-    return (
-      description &&
-      description?.startsWith(`${type}<`) &&
-      description?.endsWith(">")
-    );
-  };
-
-export const isNullishSchema = (schema: S.Schema<any>) =>
-  isNullSchema(schema) || isUndefinedSchema(schema);
-export const isNullSchema = (schema: S.Schema<any>) =>
-  schema.ast._tag === "Literal" && schema.ast.literal === null;
-export const isUndefinedSchema = isTag("UndefinedKeyword");
-export const isBooleanSchema = isTag<S.Schema<boolean>>("BooleanKeyword");
-export const isStringSchema = isTag<S.Schema<string>>("StringKeyword");
-export const isNumberSchema = isTag<S.Schema<number>>("NumberKeyword");
-
-export const hasMapAnnotation = hasGenericAnnotation("Map");
-
-export const isRecordLikeSchema = (schema: S.Schema<any>) =>
-  isMapSchema(schema) ||
-  isRecordSchema(schema) ||
-  isStructSchema(schema) ||
-  isClassSchema(schema) ||
-  false;
-
-export const isMapSchema = (schema: S.Schema<any>) =>
-  hasMapAnnotation(schema.ast) ||
-  // @ts-expect-error - ast.to?. is not narrowed, we don't care
-  hasMapAnnotation(schema.ast.to) ||
-  false;
-
-export const isClassSchema = (schema: S.Schema<any>) => {
-  const encoded = S.encodedSchema(schema);
-  return (
-    encoded.ast._tag === "TypeLiteral" &&
-    encoded.ast.propertySignatures !== undefined
-  );
-};
-
-export const isStructSchema = (schema: S.Schema<any>) => {
-  return (
-    schema.ast._tag === "TypeLiteral" &&
-    schema.ast.propertySignatures !== undefined
-  );
-};
-
-export const isRecordSchema = (schema: S.Schema<any>) => {
-  const encoded = S.encodedSchema(schema);
-  return (
-    encoded.ast._tag === "TypeLiteral" &&
-    encoded.ast.indexSignatures?.[0] !== undefined
-  );
-};
-
-export const isListSchema = (schema: S.Schema<any>) => {
-  return (
-    hasListAnnotation(schema.ast) ||
-    (S.encodedSchema(schema).ast._tag === "TupleType" && !isMapSchema(schema))
-  );
-};
-export const hasListAnnotation = (ast: AST | undefined) => {
-  const description: string | undefined = ast?.annotations?.[
-    Description
-  ] as string;
-  return (
-    description &&
-    description?.startsWith("List<") &&
-    description?.endsWith(">")
-  );
-};
-
-export const isSetSchema = (schema: S.Schema<any>) => {
-  return (
-    // @ts-expect-error - ast.to?. is not narrowed, we don't care
-    hasSetAnnotation(schema.ast) || hasSetAnnotation(schema.ast.to) || false
-  );
-};
-
-export const hasSetAnnotation = hasGenericAnnotation("Set");
-
-export const getSetValueAST = (schema: S.Schema<any>): AST =>
-  // @ts-expect-error - ast.to?. is not narrowed, we don't care
-  isSetSchema(schema) && schema.ast.to?.typeParameters[0];