alchemy-effect 0.6.3 → 0.7.0

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>>
@@ -337,17 +339,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),
+        ),
       );
     });
 }

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;