@gaganref/confect-alchemy 0.0.0-stage → 10.3.1-fork.2

package/src/internal/CommandRunner.ts

@@ -0,0 +1,251 @@
+import * as Config from "effect/Config";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+import * as Redacted from "effect/Redacted";
+import * as Schema from "effect/Schema";
+import { ChildProcess, ChildProcessSpawner } from "effect/process";
+
+export interface PrepareCommand {
+  readonly command: string;
+  readonly args: ReadonlyArray<string>;
+}
+
+/**
+ * Where a push goes: a cloud deployment through its deploy key, or a local
+ * backend through the CLI's self-hosted target and its admin key.
+ */
+export type PushTarget =
+  | {
+      readonly _tag: "Cloud";
+      readonly deploymentName: string;
+      readonly deployKey: Redacted.Redacted<string>;
+    }
+  | {
+      readonly _tag: "SelfHosted";
+      readonly deploymentName: string;
+      readonly url: string;
+      readonly adminKey: Redacted.Redacted<string>;
+    };
+
+const selection = (target: PushTarget) =>
+  target._tag === "Cloud"
+    ? `CONVEX_DEPLOY_KEY=${Redacted.value(target.deployKey)}\n`
+    : `CONVEX_SELF_HOSTED_URL=${target.url}\nCONVEX_SELF_HOSTED_ADMIN_KEY=${Redacted.value(target.adminKey)}\n`;
+
+export class CommandError extends Schema.TaggedError<CommandError>()(
+  "CommandError",
+  {
+    operation: Schema.Literals(["prepare", "deploy"]),
+    reason: Schema.Literals(["configuration", "spawn", "exit"]),
+    exitCode: Schema.optionalKey(Schema.Finite),
+  },
+) {}
+
+export class CommandRunner extends Context.Service<
+  CommandRunner,
+  {
+    readonly prepare: (
+      command: PrepareCommand,
+      cwd?: string,
+    ) => Effect.Effect<void, CommandError>;
+    readonly deploy: (
+      target: PushTarget,
+      cwd?: string,
+    ) => Effect.Effect<void, CommandError>;
+  }
+>()("@confect/alchemy/internal/CommandRunner") {}
+
+/**
+ * The ambient variables a child process needs to run on every platform; the
+ * rest of the parent environment, credentials included, is withheld.
+ */
+export const processEnvironment = Config.all({
+  PATH: Config.String("PATH").pipe(
+    Config.orElse(() => Config.String("Path")),
+    Config.withDefault(""),
+  ),
+  HOME: Config.String("HOME").pipe(Config.withDefault("")),
+  USERPROFILE: Config.String("USERPROFILE").pipe(Config.withDefault("")),
+  SystemRoot: Config.String("SystemRoot").pipe(
+    Config.orElse(() => Config.String("SYSTEMROOT")),
+    Config.withDefault(""),
+  ),
+  TMPDIR: Config.String("TMPDIR").pipe(Config.withDefault("")),
+  TEMP: Config.String("TEMP").pipe(Config.withDefault("")),
+});
+
+const packageBin = Effect.fn("CommandRunner.packageBin")(function* (
+  fs: FileSystem.FileSystem,
+  path: Path.Path,
+  cwd: string,
+  packageName: string,
+  binName: string,
+) {
+  const invalid = () =>
+    new CommandError({
+      operation: packageName === "convex" ? "deploy" : "prepare",
+      reason: "configuration",
+    });
+  let directory = cwd;
+  while (true) {
+    const manifestPath = path.join(
+      directory,
+      "node_modules",
+      packageName,
+      "package.json",
+    );
+    if (yield* fs.exists(manifestPath).pipe(Effect.mapError(invalid))) {
+      const manifest = yield* fs.readFileString(manifestPath).pipe(
+        Effect.flatMap(
+          Schema.decodeEffect(
+            Schema.fromJsonString(
+              Schema.Struct({
+                bin: Schema.Union([
+                  Schema.String,
+                  Schema.Record(Schema.String, Schema.String),
+                ]),
+              }),
+            ),
+          ),
+        ),
+        Effect.mapError(invalid),
+      );
+      const relative =
+        typeof manifest.bin === "string" ? manifest.bin : manifest.bin[binName];
+      if (!relative) return yield* invalid();
+      return path.resolve(path.dirname(manifestPath), relative);
+    }
+    const parent = path.dirname(directory);
+    if (parent === directory) return yield* invalid();
+    directory = parent;
+  }
+});
+
+export const layer = Layer.effect(
+  CommandRunner,
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+    const run = Effect.fn("CommandRunner.run")(function* (
+      operation: "prepare" | "deploy",
+      command: string,
+      args: ReadonlyArray<string>,
+      cwd: string,
+      env: Record<string, string | undefined>,
+    ) {
+      const code = yield* spawner
+        .exitCode(
+          ChildProcess.make(command, args, {
+            cwd,
+            env,
+            extendEnv: false,
+            stdin: "ignore",
+            stdout: "ignore",
+            stderr: "ignore",
+          }),
+        )
+        .pipe(
+          Effect.mapError(
+            () => new CommandError({ operation, reason: "spawn" }),
+          ),
+        );
+      if (code !== 0)
+        return yield* new CommandError({
+          operation,
+          reason: "exit",
+          exitCode: Number(code),
+        });
+    });
+    const environment = processEnvironment.pipe(
+      Effect.map((env) => ({ ...env, CI: "true", DO_NOT_TRACK: "1" })),
+    );
+    return CommandRunner.of({
+      prepare: Effect.fn("CommandRunner.prepare")(function* (
+        command,
+        cwd = process.cwd(),
+      ) {
+        const directory = path.resolve(cwd);
+        const env = yield* environment.pipe(
+          Effect.mapError(
+            () =>
+              new CommandError({
+                operation: "prepare",
+                reason: "configuration",
+              }),
+          ),
+        );
+        if (command.command === "confect") {
+          const bin = yield* packageBin(
+            fs,
+            path,
+            directory,
+            "@confect/cli",
+            "confect",
+          );
+          yield* run(
+            "prepare",
+            process.execPath,
+            [bin, ...command.args],
+            directory,
+            env,
+          );
+        } else {
+          yield* run("prepare", command.command, command.args, directory, env);
+        }
+      }),
+      deploy: Effect.fn("CommandRunner.deploy")(function* (
+        target,
+        cwd = process.cwd(),
+      ) {
+        const directory = path.resolve(cwd);
+        const bin = yield* packageBin(fs, path, directory, "convex", "convex");
+        const env = yield* environment.pipe(
+          Effect.mapError(
+            () =>
+              new CommandError({
+                operation: "deploy",
+                reason: "configuration",
+              }),
+          ),
+        );
+        yield* Effect.scoped(
+          Effect.gen(function* () {
+            const temp = yield* fs.makeTempDirectoryScoped({
+              prefix: "confect-deploy-",
+            });
+            const envFile = path.join(temp, "deployment.env");
+            yield* fs.writeFileString(envFile, selection(target), {
+              mode: 0o600,
+            });
+            yield* run(
+              "deploy",
+              process.execPath,
+              [bin, "deploy", "--yes", "--env-file", envFile],
+              directory,
+              {
+                ...env,
+                HOME: temp,
+                USERPROFILE: temp,
+                LOCALAPPDATA: temp,
+                XDG_CONFIG_HOME: temp,
+              },
+            );
+          }).pipe(
+            Effect.mapError((error) =>
+              Schema.is(CommandError)(error)
+                ? error
+                : new CommandError({
+                    operation: "deploy",
+                    reason: "configuration",
+                  }),
+            ),
+          ),
+        );
+      }),
+    });
+  }),
+);

package/src/internal/FileLock.ts

@@ -0,0 +1,136 @@
+import * as Crypto from "effect/Crypto";
+import type * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import * as Predicate from "effect/Predicate";
+import * as Schedule from "effect/Schedule";
+import * as Schema from "effect/Schema";
+
+export class FileLockError extends Schema.TaggedError<FileLockError>()(
+  "FileLockError",
+  { reason: Schema.Literals(["held", "timeout", "filesystem"]) },
+) {}
+
+const Holder = Schema.fromJsonString(
+  Schema.Struct({ pid: Schema.Finite, token: Schema.String }),
+);
+const decodeHolder = Schema.decodeUnknownOption(Holder);
+
+const isAlive = (pid: number) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return Predicate.hasProperty(error, "code") && error.code === "EPERM";
+  }
+};
+
+/**
+ * Hold an exclusive lock file for the ambient scope, waiting up to `wait` for
+ * another holder or failing with `held` at once when `wait` is omitted.
+ *
+ * The holder, `{ pid, token }`, is written to a private claim file and
+ * published with a hard link, which fails when the lock exists, so a visible
+ * lock always names its holder. A lock whose holder has exited is removed only
+ * under `<file>.recovery`, after re-reading that the same dead holder still
+ * owns it, so a successor's lock is never removed in its place. Publishing and
+ * recovering are uninterruptible: Node cannot cancel a link or unlink it has
+ * started, so stopping early would let one land after `.recovery` is released.
+ * The recovery lock is never reclaimed: a crash inside its few file operations
+ * leaves waiters timing out rather than overlapping. A timeout that lands while
+ * an attempt succeeds still fails, and the published lock is removed only when
+ * the ambient scope closes.
+ */
+export const acquire = Effect.fn("FileLock.acquire")(function* (
+  file: string,
+  wait?: Duration.Input,
+) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const crypto = yield* Crypto.Crypto;
+  const failed = () => new FileLockError({ reason: "filesystem" });
+  const token = Buffer.from(
+    yield* crypto.randomBytes(16).pipe(Effect.mapError(failed)),
+  ).toString("hex");
+  const holder = yield* Schema.encodeEffect(Holder)({
+    pid: process.pid,
+    token,
+  }).pipe(Effect.mapError(failed));
+  const claim = `${file}.${token}`;
+  const recovery = `${file}.recovery`;
+  const removeIfOwned = (target: string) =>
+    fs.readFileString(target).pipe(
+      Effect.flatMap((content) =>
+        content === holder ? fs.remove(target) : Effect.void,
+      ),
+      Effect.ignore,
+    );
+  yield* Effect.addFinalizer(() =>
+    Effect.all([
+      removeIfOwned(file),
+      fs.remove(claim, { force: true }).pipe(Effect.ignore),
+    ]),
+  );
+  yield* fs
+    .makeDirectory(path.dirname(file), { recursive: true })
+    .pipe(Effect.mapError(failed));
+  yield* fs
+    .writeFileString(claim, holder, { mode: 0o600 })
+    .pipe(Effect.mapError(failed));
+
+  const read = (target: string) =>
+    fs.readFileString(target).pipe(
+      Effect.map(decodeHolder),
+      Effect.orElseSucceed(() => Option.none()),
+    );
+  const publish = (target: string) =>
+    fs.link(claim, target).pipe(
+      Effect.as(true),
+      Effect.catchReason("PlatformError", "AlreadyExists", () =>
+        Effect.succeed(false),
+      ),
+    );
+  // Whether a dead holder's lock was removed.
+  const reclaim = Effect.gen(function* () {
+    const stale = yield* read(file);
+    if (Option.isNone(stale) || isAlive(stale.value.pid)) return false;
+    if (!(yield* publish(recovery))) return false;
+    return yield* read(file).pipe(
+      Effect.flatMap((current) =>
+        Option.isSome(current) && current.value.token === stale.value.token
+          ? fs.remove(file).pipe(Effect.as(true))
+          : Effect.succeed(false),
+      ),
+      Effect.ensuring(removeIfOwned(recovery)),
+    );
+  });
+  const attempt = publish(file).pipe(
+    Effect.flatMap((acquired) =>
+      acquired
+        ? Effect.succeed(true)
+        : Effect.flatMap(reclaim, (removed) =>
+            removed ? publish(file) : Effect.succeed(false),
+          ),
+    ),
+    Effect.uninterruptible,
+    Effect.mapError(failed),
+  );
+
+  if (wait === undefined) {
+    if (!(yield* attempt)) return yield* new FileLockError({ reason: "held" });
+  } else {
+    yield* attempt.pipe(
+      Effect.repeat({
+        until: (acquired) => acquired,
+        schedule: Schedule.spaced("100 millis"),
+      }),
+      Effect.timeoutOrElse({
+        duration: wait,
+        orElse: () => Effect.fail(new FileLockError({ reason: "timeout" })),
+      }),
+    );
+  }
+  yield* fs.remove(claim, { force: true }).pipe(Effect.ignore);
+});

package/src/internal/Lifecycle.ts

@@ -0,0 +1,49 @@
+import { AdoptPolicy } from "alchemy/AdoptPolicy";
+import { AlchemyContext } from "alchemy/AlchemyContext";
+import { Stack } from "alchemy/Stack";
+import { State } from "alchemy/State/State";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+
+export class LifecycleStateError extends Schema.TaggedError<LifecycleStateError>()(
+  "LifecycleStateError",
+  { fqn: Schema.String },
+) {}
+
+export const checkpointCreate = Effect.fn("Lifecycle.checkpointCreate")(
+  function* (fqn: string, instanceId: string, props: object, output?: object) {
+    const stack = yield* Effect.serviceOption(Stack);
+    if (Option.isNone(stack)) return;
+    const state = yield* Effect.serviceOption(State);
+    if (Option.isNone(state)) return yield* new LifecycleStateError({ fqn });
+    const store = yield* state.value;
+    const key = { stack: stack.value.name, stage: stack.value.stage, fqn };
+    const row = yield* store.get(key);
+    if (!row || row.kind === "action" || row.instanceId !== instanceId)
+      return yield* new LifecycleStateError({ fqn });
+    if (row.status !== "creating") return;
+    yield* store.set({
+      ...key,
+      value: {
+        ...row,
+        props,
+        ...(output === undefined ? {} : { attr: output }),
+      },
+    });
+  },
+);
+
+export const shouldAdopt = Effect.fn("Lifecycle.shouldAdopt")(function* (
+  fqn: string,
+) {
+  const stack = yield* Effect.serviceOption(Stack);
+  const resourcePolicy = Option.isSome(stack)
+    ? stack.value.resources[fqn]?.Adopt
+    : undefined;
+  if (resourcePolicy !== undefined) return resourcePolicy;
+  const policy = yield* Effect.serviceOption(AdoptPolicy);
+  if (Option.isSome(policy)) return policy.value;
+  const context = yield* Effect.serviceOption(AlchemyContext);
+  return Option.isSome(context) && context.value.adopt;
+});