alchemy 2.0.0-beta.43 → 2.0.0-beta.45

package/src/Sidecar/RpcServices.ts

@@ -1,48 +0,0 @@
-import * as ConfigProvider from "effect/ConfigProvider";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as AlchemyContext from "../AlchemyContext.ts";
-import { withProfileOverride } from "../Auth/Profile.ts";
-import type { ExecStackOptionsEncoded } from "../Cli/commands/deploy.ts";
-import { loadConfigProvider } from "../Util/ConfigProvider.ts";
-import * as Lock from "./Lock.ts";
-import * as RpcPaths from "./RpcPaths.ts";
-
-export const layer = (main: string) =>
-  Layer.provideMerge(
-    Lock.LockLive,
-    Layer.provideMerge(
-      RpcPaths.layer(main),
-      Layer.mergeAll(
-        AlchemyContext.AlchemyContextLive,
-        makeConfigProvider(),
-        Layer.unwrap(
-          Effect.promise(() => {
-            if ("Bun" in globalThis) {
-              return import("./RpcServerBun.ts").then((m) => m.RpcServerBun);
-            } else {
-              return import("./RpcServerNode.js").then((m) => m.RpcServerNode);
-            }
-          }),
-        ),
-      ),
-    ),
-  );
-
-const makeConfigProvider = () => {
-  let options: Partial<ExecStackOptionsEncoded>;
-  try {
-    options = JSON.parse(
-      process.env.ALCHEMY_EXEC_OPTIONS!,
-    ) as ExecStackOptionsEncoded;
-  } catch {
-    options = {};
-  }
-  const envFile = Option.fromUndefinedOr(options.envFile);
-  return ConfigProvider.layer(
-    loadConfigProvider(envFile).pipe(
-      Effect.map((base) => withProfileOverride(base, options.profile)),
-    ),
-  );
-};

package/src/Trait.ts

@@ -1,105 +0,0 @@
-import type { ClassTuple } from ".//Util/class.ts";
-import * as S from "./Schema.ts";
-
-export declare function defineTrait<F extends TraitFn>(
-  tag: NoInfer<ReturnType<F>["tag"]>,
-  fn: F,
-): TraitDef<F>;
-
-export declare function defineTrait<T extends Trait>(
-  tag: T["tag"],
-  props: {
-    [k in keyof TraitProps<T>]: TraitProps<T>[k];
-  },
-): TraitDef<<Target>(target: Target) => ApplyTrait<Target, T>>;
-
-export const applyTrait = <T extends Trait<any, any, any>>(
-  tag: T["tag"],
-  props: {
-    [k in keyof TraitProps<T>]: TraitProps<T>[k];
-  },
-): T => undefined!;
-
-export type AnyTrait = Trait<any, any, any>;
-
-export type TraitFn<
-  T extends AnyTrait = AnyTrait,
-  Args extends any[] = any[],
-> = (...args: Args) => T;
-
-export type TraitDef<Fn extends TraitFn = TraitFn> = Fn & {
-  /** @internal phantom */
-  trait: ReturnType<Fn>;
-};
-
-export interface Trait<
-  Tag extends string = string,
-  Errors extends any[] = never,
-  Provides extends any[] = never,
-> {
-  type?: "trait";
-  tag: Tag;
-  errors?: ClassTuple<Errors>;
-  provides?: ClassTuple<Provides>;
-}
-
-export type TraitError<A extends Trait<any, any, any>> = InstanceType<
-  Exclude<A["errors"], undefined>[number]
->;
-
-export type TraitProps<A extends Trait<any, any, any>> = {
-  [k in keyof _TraitProps<A>]: _TraitProps<A>[k];
-};
-
-type _TraitProps<A extends Trait<any, any, any>> = Omit<
-  A,
-  "type" | "tag" | "provides" | "errors"
-> &
-  (A["errors"] extends never | undefined
-    ? {}
-    : {
-        errors: Exclude<A["errors"], undefined>;
-      }) &
-  (A["provides"] extends never | undefined
-    ? {}
-    : {
-        provides: Exclude<A["provides"], undefined>;
-      });
-
-export type ApplyTrait<Target, T extends Trait<any, any, any>> = ([
-  Target,
-] extends [Annotated<infer s, infer t>]
-  ? Annotated<s, T | t>
-  : [Target] extends [S.Top]
-    ? Annotated<Target, T>
-    : [Target] extends [S.AnyClassSchema]
-      ? Annotated<Target, T | Annotated.Unwrap<Target>>
-      : Target) & {};
-
-export type Annotated<S, T extends Trait<any, any, any>> = S & {
-  /** @internal phantom type */
-  S: S;
-  type: "annotated";
-  /** @internal phatom */
-  traits: T;
-};
-
-export declare namespace Annotated {
-  export type Unwrap<T> = T extends Annotated<infer _, infer t> ? t : never;
-}
-
-// export declare namespace Traits {
-//   export type Of<C, Seen = never> = C extends Seen
-//     ? never
-//     : C extends Annotated<infer S, infer T>
-//       ? T | Of<S, Seen>
-//       : C extends AnyClassSchema
-//         ? OfFields<C["fields"], Seen | C>
-//         : C extends S.Struct<any>
-//           ? OfFields<C["fields"], Seen | C>
-//           : never;
-
-//   type OfFields<F extends S.Struct.Fields, Seen> = {
-//     [prop in keyof F]: Of<F[prop], Seen>;
-//   }[keyof F];
-// }

package/src/Util/LocalhostDns.ts

@@ -1,52 +0,0 @@
-/**
- * Process-level DNS shim that makes `*.localhost` resolve to 127.0.0.1
- * for any HTTP client that goes through undici (Node's global `fetch`,
- * undici-based clients, etc.).
- *
- * Background: macOS's `getaddrinfo` does not honor RFC 6761 for arbitrary
- * `*.localhost` names — only the bare `localhost` is mapped to loopback.
- * The Cloudflare local proxy returns URLs like
- * `http://my-worker.localhost:1337` and dispatches by the URL hostname,
- * so we cannot rewrite the URL client-side to `127.0.0.1` (and `Host` is
- * a forbidden fetch header). The fix is to make the host resolvable at
- * the network layer.
- *
- * On Bun, `globalThis.fetch` is the native (Zig) implementation and does
- * not consult undici's global dispatcher; Bun resolves `*.localhost`
- * itself on Darwin/Linux, so this shim is effectively a no-op there for
- * the global `fetch` and only matters if user code reaches for `undici`
- * directly.
- *
- * Calling `installLocalhostDns()` is idempotent.
- */
-
-import * as dns from "node:dns";
-import * as undici from "undici";
-
-let installed = false;
-
-const isLocalhost = (hostname: string): boolean =>
-  hostname === "localhost" ||
-  hostname === "[::1]" ||
-  hostname.endsWith(".localhost");
-
-export const installLocalhostDns = (): void => {
-  if (installed) return;
-  installed = true;
-
-  undici.setGlobalDispatcher(
-    new undici.Agent({
-      connect: {
-        lookup: (hostname, options, cb) => {
-          if (isLocalhost(hostname)) {
-            if (options && (options as { all?: boolean }).all) {
-              return cb(null, [{ address: "127.0.0.1", family: 4 }]);
-            }
-            return cb(null, "127.0.0.1", 4);
-          }
-          return dns.lookup(hostname, options, cb);
-        },
-      },
-    }),
-  );
-};

package/src/Util/assert-never.ts

@@ -1,18 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Data from "effect/Data";
-
-export class UnexpectedValueError extends Data.TaggedError(
-  "UnexpectedValueError",
-)<{
-  message: string;
-  value: never;
-}> {}
-
-export const assertNeverOrDie = (value: never): Effect.Effect<never> => {
-  return Effect.die(
-    new UnexpectedValueError({
-      message: `Unexpected value: ${value}`,
-      value,
-    }),
-  );
-};

package/src/Util/class.ts

@@ -1,7 +0,0 @@
-export type Class<T = any> =
-  | (new (...args: any[]) => T)
-  | (new (_: never) => T);
-
-export type ClassTuple<T extends any[]> = T extends [infer Head, ...infer Tail]
-  ? [Class<Head>, ...ClassTuple<Tail>]
-  : [];