alchemy-effect 0.0.0 → 0.2.0

package/src/provider.ts

@@ -44,8 +44,8 @@ export interface ProviderService<Res extends Resource = Resource> {
     olds: Res["props"];
     news: Res["props"];
     output: Res["attr"];
-  }): Effect.Effect<Diff, never, never>;
-  stub?(input: {
+  }): Effect.Effect<Diff | void, never, never>;
+  precreate?(input: {
     id: string;
     news: Res["props"];
     session: ScopedPlanStatusSession;

package/src/resource.ts

@@ -37,13 +37,14 @@ export const Resource = <Ctor extends (id: string, props: any) => Resource>(
   type: ReturnType<Ctor>["type"],
 ) => {
   const Tag = Context.Tag(type)();
-  const provider = {
-    tag: Tag,
+  const provider: ResourceTags<ReturnType<Ctor>> = {
+    tag: Tag as any,
     effect: <Err, Req>(
       eff: Effect<ProviderService<ReturnType<Ctor>>, Err, Req>,
     ) => Layer.effect(Tag, eff),
     succeed: (service: ProviderService<ReturnType<Ctor>>) =>
       Layer.succeed(Tag, service),
+    of: (service) => service,
   };
   return Object.assign(
     function (id: string, props: any) {

package/src/runtime.ts

@@ -38,7 +38,7 @@ export declare namespace Runtime {
 export type AnyRuntime = Runtime<string>;
 
 export interface RuntimeProps<Run extends Runtime, Req> {
-  bindings: Policy<Run, Extract<Req, Capability>>;
+  bindings: Policy<Run, Extract<Req, Capability>, unknown>;
 }
 
 export interface Runtime<

package/src/schema.ts

@@ -0,0 +1,102 @@
+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];

package/src/sha256.ts

@@ -0,0 +1,23 @@
+import * as Effect from "effect/Effect";
+
+type Input = ArrayBuffer | Uint8Array | string;
+
+export const sha256 = (input: Input) =>
+  Effect.promise(async () => {
+    const digest = await crypto.subtle.digest("SHA-256", toArrayBuffer(input));
+    const hashArray = Array.from(new Uint8Array(digest));
+    return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  });
+
+const toArrayBuffer = (input: Input) => {
+  if (input instanceof ArrayBuffer) {
+    return input;
+  }
+  if (typeof input === "string") {
+    return new TextEncoder().encode(input);
+  }
+  return input.buffer.slice(
+    input.byteOffset,
+    input.byteOffset + input.byteLength,
+  ) as ArrayBuffer;
+};

package/src/state.ts

@@ -1,10 +1,10 @@
-import { FileSystem } from "@effect/platform";
 import type { PlatformError } from "@effect/platform/Error";
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Path from "@effect/platform/Path";
 import * as Context from "effect/Context";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import path from "node:path";
 import { App } from "./app.ts";
 import type { BindNode } from "./plan.ts";
 import { isResource } from "./resource.ts";
@@ -100,6 +100,7 @@ export const localFs = Layer.effect(
   Effect.gen(function* () {
     const app = yield* App;
     const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
     const dotAlchemy = path.join(process.cwd(), ".alchemy");
     const stateDir = path.join(dotAlchemy, "state");
     const appDir = path.join(stateDir, app.name);

package/src/tags.ts

@@ -0,0 +1,38 @@
+import * as Effect from "effect/Effect";
+import { App } from "./app.ts";
+
+export type Tags =
+  | Record<string, string>
+  | [string, string][]
+  | { Key: string; Value: string }[];
+
+const normalizeTags = (tags: Tags) =>
+  Array.isArray(tags)
+    ? Object.fromEntries(
+        tags.map((tag) =>
+          Array.isArray(tag) ? [tag[0], tag[1]] : [tag.Key, tag.Value],
+        ),
+      )
+    : tags;
+
+export const hasTags = (expectedTags: Tags, tags: Tags | undefined) => {
+  const actualTags = normalizeTags(tags ?? []);
+  return Object.entries(normalizeTags(expectedTags)).every(
+    ([key, value]) => actualTags[key] === value,
+  );
+};
+
+export const createTagsList = (tags: Tags) =>
+  Object.entries(normalizeTags(tags)).map(([Key, Value]) => ({
+    Key,
+    Value,
+  }));
+
+export const createTagger = Effect.fn(function* () {
+  const app = yield* App;
+  return (id: string) => ({
+    "alchemy::app": app.name,
+    "alchemy::stage": app.stage,
+    "alchemy::id": id,
+  });
+});

package/src/test.ts

@@ -0,0 +1,71 @@
+import { FetchHttpClient, FileSystem, HttpClient } from "@effect/platform";
+import { NodeContext } from "@effect/platform-node";
+import type * as Path from "@effect/platform/Path";
+import { it } from "@effect/vitest";
+import { LogLevel } from "effect";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Logger from "effect/Logger";
+import * as Scope from "effect/Scope";
+import * as App from "./app.ts";
+import { PlanStatusReporter } from "./apply.ts";
+import { DotAlchemy, dotAlchemy } from "./dot-alchemy.ts";
+import * as State from "./state.ts";
+
+type Provided =
+  | Scope.Scope
+  | App.App
+  | State.State
+  | DotAlchemy
+  | HttpClient.HttpClient
+  | FileSystem.FileSystem
+  | Path.Path;
+
+export function test(
+  name: string,
+  testCase: Effect.Effect<void, any, Provided>,
+  timeout: number = 120_000,
+) {
+  const platform = Layer.mergeAll(
+    NodeContext.layer,
+    FetchHttpClient.layer,
+    Logger.pretty,
+  );
+
+  const alchemy = Layer.provideMerge(
+    Layer.mergeAll(State.localFs, report),
+    Layer.mergeAll(
+      App.make({ name: name.replaceAll(/[^a-zA-Z0-9_]/g, "-"), stage: "test" }),
+      dotAlchemy,
+    ),
+  );
+
+  return it.scopedLive(
+    name,
+    () =>
+      testCase.pipe(
+        Effect.provide(Layer.provideMerge(alchemy, platform)),
+        Logger.withMinimumLogLevel(
+          process.env.DEBUG ? LogLevel.Debug : LogLevel.Info,
+        ),
+      ),
+    timeout,
+  );
+}
+
+export const report = Layer.succeed(
+  PlanStatusReporter,
+  PlanStatusReporter.of({
+    start: Effect.fn(function* (plan) {
+      return {
+        done: () => Effect.void,
+        emit: (event) =>
+          Effect.log(
+            event.kind === "status-change"
+              ? `${event.status} ${event.id}(${event.type})`
+              : event.message,
+          ),
+      };
+    }),
+  }),
+);

package/src/type.ts

@@ -0,0 +1,2 @@
+export type type<T> = new () => T;
+export const type = class {} as new <T>() => T;