alchemy-effect 0.6.4 → 0.7.1

package/src/Stack.ts

@@ -7,6 +7,7 @@ import type { Scope } from "effect/Scope";
 import * as ServiceMap from "effect/ServiceMap";
 import type { HttpClient } from "effect/unstable/http/HttpClient";
 import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import type { Artifacts } from "./Artifacts.ts";
 import { DotAlchemy } from "./Config.ts";
 import type { ResourceBinding, ResourceLike } from "./Resource.ts";
 import { Stage } from "./Stage.ts";
@@ -19,7 +20,8 @@ export type StackServices =
   | Path
   | DotAlchemy
   | HttpClient
-  | ChildProcessSpawner;
+  | ChildProcessSpawner
+  | Artifacts;
 
 export class Stack extends ServiceMap.Service<
   Stack,
@@ -39,6 +41,10 @@ export interface StackSpec<Output = any> {
   output: Output;
 }
 
+export interface CompiledStack<Output, Services> extends StackSpec<Output> {
+  services: ServiceMap.ServiceMap<Services>;
+}
+
 export const StackName = Stack.use((stack) => Effect.succeed(stack.name));
 
 export const make =
@@ -56,11 +62,17 @@ export const make =
       Stack.asEffect(),
       Effect.services<ROut | StackServices>(),
     ]).pipe(
-      Effect.map(([output, stack, services]) => ({
-        output,
-        services,
-        ...stack,
-      })),
+      Effect.map(
+        ([output, stack, services]) =>
+          ({
+            output,
+            services,
+            ...stack,
+          }) satisfies CompiledStack<A, ROut | StackServices> as CompiledStack<
+            A,
+            ROut | StackServices
+          >,
+      ),
       Effect.provide(providers),
       Effect.provideServiceEffect(
         Stack,

package/src/Test/Vitest.ts

@@ -23,6 +23,7 @@ import * as Cloudflare from "../Cloudflare/index.ts";
 
 import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
 import { apply } from "../Apply.ts";
+import { Artifacts, provideFreshArtifactStore } from "../Artifacts.ts";
 import * as Credentials from "../AWS/Credentials.ts";
 import * as Region from "../AWS/Region.ts";
 import type { Command } from "../Build/Command.ts";
@@ -78,6 +79,7 @@ type Provided =
   | Server.ServerHost
   | Serverless.FunctionContext
   | AWS.StageConfig
+  | Artifacts
   | Provider<Command>
   | Layer.Success<ReturnType<typeof AWS.providers>>
   | Layer.Success<ReturnType<typeof Cloudflare.providers>>
@@ -146,7 +148,10 @@ const deriveStackName = (testPath: string, suffix: string) => {
 const runWithContext = <A, Err>(
   stackName: string,
   effect: Effect.Effect<A, Err, Provided>,
-  options: { state?: Layer.Layer<State.State, never, Stack.Stack> } = {},
+  options: {
+    state?: Layer.Layer<State.State, never, Stack.Stack>;
+    providers?: boolean;
+  } = {},
 ): Effect.Effect<
   A,
   aws.Credentials.CredentialsError | Config.ConfigError | Err,
@@ -192,7 +197,9 @@ const runWithContext = <A, Err>(
   }).pipe(
     Effect.provide(
       Layer.provideMerge(
-        Layer.mergeAll(awsProviders, cfProviders),
+        options.providers === false
+          ? Layer.empty
+          : Layer.mergeAll(awsProviders, cfProviders),
         Layer.provideMerge(alchemy, platform),
       ),
     ),
@@ -214,6 +221,7 @@ export function test(
   options: {
     timeout?: number;
     state?: Layer.Layer<State.State, never, Stack.Stack>;
+    providers?: boolean;
   },
   testCase: Effect.Effect<void, any, Provided>,
 ): void;
@@ -230,6 +238,7 @@ export function test(
         {
           timeout?: number;
           state?: Layer.Layer<State.State, never, Stack.Stack>;
+          providers?: boolean;
         },
         Effect.Effect<void, any, Provided>,
       ]
@@ -251,6 +260,7 @@ export namespace test {
     options: {
       timeout?: number;
       state?: Layer.Layer<State.State, never, Stack.Stack>;
+      providers?: boolean;
     },
     testCase: Effect.Effect<void, any, Provided>,
   ): void;
@@ -267,6 +277,7 @@ export namespace test {
           {
             timeout?: number;
             state?: Layer.Layer<State.State, never, Stack.Stack>;
+            providers?: boolean;
           },
           Effect.Effect<void, any, Provided>,
         ]
@@ -285,6 +296,7 @@ export namespace test {
             {
               timeout?: number;
               state?: Layer.Layer<State.State, never, Stack.Stack>;
+              providers?: boolean;
             },
             Effect.Effect<void, any, Provided>,
           ]
@@ -337,17 +349,24 @@ export namespace test {
     effect: Effect.Effect<A, Err, Req>,
   ): Effect.Effect<Input.Resolve<A>, Err, Req | Stack.Stack> =>
     Stack.Stack.use((stack) => {
-      return effect.pipe(
-        // Effect.tap(Effect.logInfo),
-        // @ts-expect-error
-        Stack.make(stack.name, Layer.effectServices(Effect.services<never>()), {
-          ...stack,
-          resources: {},
-          bindings: {},
-        }),
-        Effect.flatMap(Plan.make),
-        Effect.tap((plan) => Effect.logInfo(formatPlan(plan))),
-        Effect.flatMap(apply),
+      return provideFreshArtifactStore(
+        effect.pipe(
+          // Effect.tap(Effect.logInfo),
+          // @ts-expect-error
+          Stack.make(
+            stack.name,
+            Layer.effectServices(Effect.services<never>()),
+            {
+              ...stack,
+              resources: {},
+              bindings: {},
+              output: {},
+            },
+          ),
+          Effect.flatMap(Plan.make),
+          Effect.tap((plan) => Effect.logInfo(formatPlan(plan))),
+          Effect.flatMap(apply),
+        ),
       );
     });
 }
@@ -427,6 +446,7 @@ export function skip(
   options: {
     timeout?: number;
     state?: Layer.Layer<State.State, never, Stack.Stack>;
+    providers?: boolean;
   },
   testCase: Effect.Effect<void, any, Provided>,
 ): void;
@@ -443,6 +463,7 @@ export function skip(
         {
           timeout?: number;
           state?: Layer.Layer<State.State, never, Stack.Stack>;
+          providers?: boolean;
         },
         Effect.Effect<void, any, Provided>,
       ]
@@ -461,6 +482,7 @@ export function skipIf(condition: boolean) {
           {
             timeout?: number;
             state?: Layer.Layer<State.State, never, Stack.Stack>;
+            providers?: boolean;
           },
           Effect.Effect<void, any, Provided>,
         ]

package/src/Util/gitignore-rules-to-globs.ts

@@ -0,0 +1,80 @@
+/**
+ * Converts gitignore-style rules into glob patterns for tools like fast-glob's {@link https://github.com/mrmlnc/fast-glob#ignore `ignore`} option.
+ *
+ * Gitignore and glob differ (ordering, negation, escapes). This maps the common cases:
+ *
+ * - Rules with no `/` match at any depth → \`**\/name\`, \`**\/name\/\*\/`
+ * - A leading `/` anchors to the ignore file's directory (use the same `cwd` in fast-glob) → `name`, `name/**`
+ * - A `/` in the pattern (not only leading) uses path-aware matching → `a/b`, `a/b/**`
+ * - A trailing `/` restricts to directories → adds `/**` as needed
+ * - Lines starting with `!` (negation) are returned with a `!` prefix for use in **positive** glob
+ *   lists; they are not valid in fast-glob's `ignore` array (filter them out if you only pass `ignore`)
+ *
+ * Does not implement full gitignore escaping (e.g. `\\ ` for trailing space) or `**` edge cases
+ * identical to git; escape handling can be added later if needed.
+ */
+export function gitignoreRulesToGlobs(rules: ReadonlyArray<string>): string[] {
+  const out: string[] = [];
+  for (const raw of rules) {
+    const line = raw.trim();
+    if (line.length === 0 || line.startsWith("#")) {
+      continue;
+    }
+    let negated = false;
+    let rest = line;
+    if (rest.startsWith("!")) {
+      negated = true;
+      rest = rest.slice(1).trim();
+      if (rest.length === 0 || rest.startsWith("#")) {
+        continue;
+      }
+    }
+    let dirOnly = rest.endsWith("/");
+    if (dirOnly) {
+      rest = rest.slice(0, -1);
+    }
+    rest = rest.replace(/\\/g, "/");
+    if (rest.length === 0) {
+      continue;
+    }
+    const anchored = rest.startsWith("/");
+    if (anchored) {
+      rest = rest.slice(1);
+    }
+    if (rest.length === 0) {
+      continue;
+    }
+    const hasSlash = rest.includes("/");
+    const globs = ruleBodyToGlobs(rest, { anchored, hasSlash, dirOnly });
+    for (const g of globs) {
+      out.push(negated ? `!${g}` : g);
+    }
+  }
+  return out;
+}
+
+function ruleBodyToGlobs(
+  body: string,
+  opts: { anchored: boolean; hasSlash: boolean; dirOnly: boolean },
+): string[] {
+  const { anchored, hasSlash, dirOnly } = opts;
+  if (dirOnly) {
+    if (anchored) {
+      return [`${body}/**`];
+    }
+    if (hasSlash) {
+      return [`${body}/**`];
+    }
+    return [`**/${body}/**`];
+  }
+  if (anchored) {
+    if (hasSlash) {
+      return [body, `${body}/**`];
+    }
+    return [body, `${body}/**`];
+  }
+  if (hasSlash) {
+    return [body, `${body}/**`];
+  }
+  return [`**/${body}`, `**/${body}/**`];
+}

package/src/Cloudflare/Website/TanstackStart.ts

@@ -1,14 +0,0 @@
-import * as Effect from "effect/Effect";
-import { Worker } from "../Workers/Worker.ts";
-
-export const TanstackStart: typeof Worker = ((...args: any[]) =>
-  args.length === 0
-    ? (...args: [string, Effect.Effect<any>]) => TanstackStart(...args)
-    : Worker(
-        args[0],
-        {
-          // TODO(sam): main entrypoint should be the Tanstack Start entrypoint (that is assumed to import and run this)
-          main: import.meta.filename,
-        },
-        args[1],
-      )) as any;