@alchemy.run/drizzle 0.0.0-stage → 2.0.0-beta.84

package/lib/LibSQL.d.ts

@@ -0,0 +1,45 @@
+import type { LibSQLConfig, LibSQLSource } from "@alchemy.run/sql/SQLite";
+import type * as LibsqlClient from "@effect/sql-libsql/LibsqlClient";
+import type { AnyRelations, EmptyRelations } from "drizzle-orm";
+import type { EffectLibsqlDatabase } from "drizzle-orm/effect-libsql";
+import type { EffectDrizzleSQLiteConfig } from "drizzle-orm/sqlite-core/effect/utils";
+import * as Effect from "effect/Effect";
+/**
+ * Open a Drizzle database over a libSQL database (e.g. Turso) using the
+ * `drizzle-orm/effect-libsql` integration.
+ *
+ * Accepts the client returned by `Turso.Connect(db)` — or any
+ * `{ url, authToken }` — and returns a chainable Proxy over
+ * `EffectLibsqlDatabase` (via `proxyChain`): every property read records a
+ * step, every call records args, and the chain is replayed against the
+ * resolved drizzle db when it's finally yielded as an Effect. Callers don't
+ * need a separate `yield* conn` step:
+ *
+ * ```typescript
+ * const conn = yield* Turso.Connect(Db);
+ * const db = yield* Drizzle.LibSQL(conn, { relations });
+ *
+ * fetch: Effect.gen(function* () {
+ *   const rows = yield* db.select().from(users);
+ * });
+ * ```
+ *
+ * The client is built lazily on the first query and memoized on the
+ * current execution's `Scope` (via {@link makeExecutionMemo}), so it is
+ * created at most once per execution — a Worker `fetch`/`queue`/`scheduled`
+ * event, a Durable Object call, a Workflow run, or a Lambda invocation —
+ * and closed when that execution settles. Resolving the URL and token is
+ * likewise deferred, so deploy / plan-time invocations never connect.
+ *
+ * `@effect/sql-libsql` client options (e.g. `intMode`) are passed via
+ * `config.client`.
+ *
+ * @binding
+ */
+export declare const LibSQL: <TRelations extends AnyRelations = EmptyRelations, E = never, R = never>(source: LibSQLSource<E, R>, config?: EffectDrizzleSQLiteConfig<TRelations> & {
+    /** Overrides for the underlying `@effect/sql-libsql` client. */
+    readonly client?: LibSQLConfig;
+}) => Effect.Effect<EffectLibsqlDatabase<TRelations> & {
+    $client: LibsqlClient.LibsqlClient;
+}, never, never>;
+//# sourceMappingURL=LibSQL.d.ts.map

package/lib/LibSQL.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LibSQL.d.ts","sourceRoot":"","sources":["../src/LibSQL.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAI1E,OAAO,KAAK,KAAK,YAAY,MAAM,iCAAiC,CAAC;AAGrE,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAChE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACtE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC;AACtF,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAGxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,MAAM,GAAI,UAAU,SAAS,YAAY,GAAG,cAAc,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,UACnF,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,WACjB,yBAAyB,CAAC,UAAU,CAAC,GAAG;IAC/C,gEAAgE;IAChE,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;CAChC;aAsB4D,YAAY,CAAC,YAAY;gBAKrF,CAAC"}

package/lib/LibSQL.js

@@ -0,0 +1,47 @@
+import { makeExecutionMemo } from "alchemy/Runtime/ExecutionMemo";
+import { proxyChain } from "alchemy/Util/proxy-chain";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+/**
+ * Open a Drizzle database over a libSQL database (e.g. Turso) using the
+ * `drizzle-orm/effect-libsql` integration.
+ *
+ * Accepts the client returned by `Turso.Connect(db)` — or any
+ * `{ url, authToken }` — and returns a chainable Proxy over
+ * `EffectLibsqlDatabase` (via `proxyChain`): every property read records a
+ * step, every call records args, and the chain is replayed against the
+ * resolved drizzle db when it's finally yielded as an Effect. Callers don't
+ * need a separate `yield* conn` step:
+ *
+ * ```typescript
+ * const conn = yield* Turso.Connect(Db);
+ * const db = yield* Drizzle.LibSQL(conn, { relations });
+ *
+ * fetch: Effect.gen(function* () {
+ *   const rows = yield* db.select().from(users);
+ * });
+ * ```
+ *
+ * The client is built lazily on the first query and memoized on the
+ * current execution's `Scope` (via {@link makeExecutionMemo}), so it is
+ * created at most once per execution — a Worker `fetch`/`queue`/`scheduled`
+ * event, a Durable Object call, a Workflow run, or a Lambda invocation —
+ * and closed when that execution settles. Resolving the URL and token is
+ * likewise deferred, so deploy / plan-time invocations never connect.
+ *
+ * `@effect/sql-libsql` client options (e.g. `intMode`) are passed via
+ * `config.client`.
+ *
+ * @binding
+ */
+export const LibSQL = (source, config) => Effect.map(makeExecutionMemo(Effect.gen(function* () {
+    const [LibsqlClient, LibsqlDrizzle, { resolveLibSQLConfig }] = yield* Effect.promise(() => Promise.all([
+        import("@effect/sql-libsql/LibsqlClient"),
+        import("drizzle-orm/effect-libsql"),
+        import("@alchemy.run/sql/SQLite"),
+    ]));
+    const { client, ...drizzleConfig } = config ?? {};
+    const ctx = yield* Layer.build(LibsqlClient.layer(yield* resolveLibSQLConfig(source, client)));
+    return yield* LibsqlDrizzle.makeWithDefaults(drizzleConfig).pipe(Effect.provideContext(ctx));
+})), (db) => proxyChain(db));
+//# sourceMappingURL=LibSQL.js.map

package/lib/LibSQL.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LibSQL.js","sourceRoot":"","sources":["../src/LibSQL.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAItD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CACpB,MAA0B,EAC1B,MAGC,EACD,EAAE,CACF,MAAM,CAAC,GAAG,CACR,iBAAiB,CACf,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,MAAM,CAAC,YAAY,EAAE,aAAa,EAAE,EAAE,mBAAmB,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,CACxF,OAAO,CAAC,GAAG,CAAC;QACV,MAAM,CAAC,iCAAiC,CAAC;QACzC,MAAM,CAAC,2BAA2B,CAAC;QACnC,MAAM,CAAC,yBAAyB,CAAC;KAClC,CAAC,CACH,CAAC;IACF,MAAM,EAAE,MAAM,EAAE,GAAG,aAAa,EAAE,GAAG,MAAM,IAAI,EAAE,CAAC;IAClD,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,KAAK,CAC5B,YAAY,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,mBAAmB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAC/D,CAAC;IACF,OAAO,KAAK,CAAC,CAAC,aAAa,CAAC,gBAAgB,CAC1C,aAAsD,CACvD,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC;AACrC,CAAC,CAAC,CACH,EACD,CAAC,EAAE,EAAE,EAAE,CACL,UAAU,CACR,EAEC,CACF,CACJ,CAAC"}

package/lib/MySQL.d.ts

@@ -0,0 +1,45 @@
+import type { MySQLConfig } from "@alchemy.run/sql/MySQL";
+import type * as MysqlClient from "@effect/sql-mysql2/MysqlClient";
+import type { AnyRelations, EmptyRelations } from "drizzle-orm";
+import type { EffectMysql2Database } from "drizzle-orm/effect-mysql2";
+import type { EffectDrizzleMySqlConfig } from "drizzle-orm/mysql-core/effect/utils";
+import * as Effect from "effect/Effect";
+import type * as Redacted from "effect/Redacted";
+/**
+ * Open a Drizzle/MySQL database from a connection URL using the
+ * `drizzle-orm/effect-mysql2` integration.
+ *
+ * ```typescript
+ * const conn = yield* Cloudflare.Hyperdrive.Connect(Hyperdrive);
+ * const db = yield* Drizzle.MySQL(conn.connectionString, { relations });
+ *
+ * fetch: Effect.gen(function* () {
+ *   const rows = yield* db.select().from(users);
+ * });
+ * ```
+ *
+ * The pool opens on the first query of an execution, is reused for every
+ * query in it, and closes when the event settles (see
+ * {@link makeExecutionMemo}); plan/deploy never connect. Workers defaults
+ * ({@link resolveMySQLConfig}) are overridden via `config.client`:
+ *
+ * ```typescript
+ * const db = yield* Drizzle.MySQL(connectionString, {
+ *   relations,
+ *   client: { poolConfig: { ssl: { rejectUnauthorized: true } } },
+ * });
+ * ```
+ *
+ * @binding
+ */
+export declare const MySQL: <TRelations extends AnyRelations = EmptyRelations, E = never, R = never>(connectionString: Effect.Effect<Redacted.Redacted<string>, E, R>, config?: EffectDrizzleMySqlConfig<TRelations> & {
+    /**
+     * Overrides for the underlying `@effect/sql-mysql2` client — pool
+     * options (e.g. `poolConfig.ssl` for a direct TLS connection),
+     * `disablePreparedStatements`, `maxConnections`, and friends.
+     */
+    readonly client?: Omit<MySQLConfig, "url">;
+}) => Effect.Effect<EffectMysql2Database<TRelations> & {
+    $client: MysqlClient.MysqlClient;
+}, never, never>;
+//# sourceMappingURL=MySQL.d.ts.map

package/lib/MySQL.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MySQL.d.ts","sourceRoot":"","sources":["../src/MySQL.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAI1D,OAAO,KAAK,KAAK,WAAW,MAAM,gCAAgC,CAAC;AAGnE,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAChE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACtE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,qCAAqC,CAAC;AACpF,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,KAAK,QAAQ,MAAM,iBAAiB,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,KAAK,GAAI,UAAU,SAAS,YAAY,GAAG,cAAc,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,oBACxE,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,WACvD,wBAAwB,CAAC,UAAU,CAAC,GAAG;IAC9C;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;CAC5C;aAwBgB,WAAW,CAAC,WAAW;gBAWvC,CAAC"}

package/lib/MySQL.js

@@ -0,0 +1,42 @@
+import { makeExecutionMemo } from "alchemy/Runtime/ExecutionMemo";
+import { proxyChain } from "alchemy/Util/proxy-chain";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+/**
+ * Open a Drizzle/MySQL database from a connection URL using the
+ * `drizzle-orm/effect-mysql2` integration.
+ *
+ * ```typescript
+ * const conn = yield* Cloudflare.Hyperdrive.Connect(Hyperdrive);
+ * const db = yield* Drizzle.MySQL(conn.connectionString, { relations });
+ *
+ * fetch: Effect.gen(function* () {
+ *   const rows = yield* db.select().from(users);
+ * });
+ * ```
+ *
+ * The pool opens on the first query of an execution, is reused for every
+ * query in it, and closes when the event settles (see
+ * {@link makeExecutionMemo}); plan/deploy never connect. Workers defaults
+ * ({@link resolveMySQLConfig}) are overridden via `config.client`:
+ *
+ * ```typescript
+ * const db = yield* Drizzle.MySQL(connectionString, {
+ *   relations,
+ *   client: { poolConfig: { ssl: { rejectUnauthorized: true } } },
+ * });
+ * ```
+ *
+ * @binding
+ */
+export const MySQL = (connectionString, config) => Effect.map(makeExecutionMemo(Effect.gen(function* () {
+    const [MysqlClient, MySqlDrizzle, { resolveMySQLConfig }] = yield* Effect.promise(() => Promise.all([
+        import("@effect/sql-mysql2/MysqlClient"),
+        import("drizzle-orm/effect-mysql2"),
+        import("@alchemy.run/sql/MySQL"),
+    ]));
+    const { client, ...drizzleConfig } = config ?? {};
+    const mysqlCtx = yield* Layer.build(MysqlClient.layer(yield* resolveMySQLConfig({ ...client, url: connectionString })));
+    return yield* MySqlDrizzle.makeWithDefaults(drizzleConfig).pipe(Effect.provideContext(mysqlCtx));
+})), (db) => proxyChain(db));
+//# sourceMappingURL=MySQL.js.map

package/lib/MySQL.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MySQL.js","sourceRoot":"","sources":["../src/MySQL.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAItD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAGtC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CACnB,gBAAgE,EAChE,MAOC,EACD,EAAE,CACF,MAAM,CAAC,GAAG,CACR,iBAAiB,CACf,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,MAAM,CAAC,WAAW,EAAE,YAAY,EAAE,EAAE,kBAAkB,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,CACrF,OAAO,CAAC,GAAG,CAAC;QACV,MAAM,CAAC,gCAAgC,CAAC;QACxC,MAAM,CAAC,2BAA2B,CAAC;QACnC,MAAM,CAAC,wBAAwB,CAAC;KACjC,CAAC,CACH,CAAC;IACF,MAAM,EAAE,MAAM,EAAE,GAAG,aAAa,EAAE,GAAG,MAAM,IAAI,EAAE,CAAC;IAClD,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,KAAK,CACjC,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,kBAAkB,CAAC,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE,gBAAgB,EAAE,CAAC,CAAC,CACnF,CAAC;IACF,OAAO,KAAK,CAAC,CAAC,YAAY,CAAC,gBAAgB,CACzC,aAAqD,CACtD,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC;AAC1C,CAAC,CAAC,CACH,EACD,CAAC,EAAE,EAAE,EAAE,CACL,UAAU,CAKR,EAMC,CACF,CACJ,CAAC"}

package/lib/Postgres.d.ts

@@ -0,0 +1,62 @@
+import type * as PgClient from "@effect/sql-pg/PgClient";
+import type { AnyRelations, EmptyRelations } from "drizzle-orm";
+import type { EffectPgDatabase } from "drizzle-orm/effect-postgres";
+import type { EffectDrizzlePgConfig } from "drizzle-orm/pg-core/effect/utils";
+import * as Effect from "effect/Effect";
+import type * as Redacted from "effect/Redacted";
+/**
+ * Open a Drizzle/Postgres database from a connection URL using the
+ * `drizzle-orm/effect-postgres` integration.
+ *
+ * Returns a chainable Proxy over `EffectPgDatabase` (via `proxyChain`) —
+ * every property read records a step, every call records args, and the
+ * chain is replayed against the resolved drizzle db when it's finally
+ * yielded as an Effect. Callers don't need a separate `yield* conn` step:
+ *
+ * ```typescript
+ * const db = yield* Drizzle.Postgres(hd.connectionString);
+ *
+ * fetch: Effect.gen(function* () {
+ *   const rows = yield* db.select().from(users);
+ * });
+ * ```
+ *
+ * The connect work is deferred until the first query and memoized on the
+ * current execution's `Scope` (via {@link makeExecutionMemo}), so the pool
+ * is built at most once per execution — a Worker `fetch`/`queue`/`scheduled`
+ * event, a Durable Object call, a Workflow run, or a Lambda invocation — and
+ * reused across every query and `task` step in that execution. Yielding the
+ * connection string is likewise deferred, so deploy / plan-time invocations
+ * (where `WorkerEnvironment` isn't provided) never trigger a real connection
+ * attempt.
+ *
+ * The pool is built against that same execution scope, so its `end`
+ * finalizer fires when the scope closes — when the request / run settles,
+ * not when the Worker's isolate-lifetime init completes. Wrapping queries in
+ * a nested `Effect.scoped` narrows both the memo and the pool's lifetime to
+ * that block: memo key and finalizer target are always the same scope
+ * object, so they cannot disagree.
+ *
+ * `@effect/sql-pg` client options are passed via `config.client`. Behind a
+ * transaction-mode pooler such as Hyperdrive, turn off named prepared
+ * statements, since a later query can reach a backend session that never
+ * prepared them:
+ *
+ * ```typescript
+ * const db = yield* Drizzle.Postgres(hd.connectionString, {
+ *   client: { prepare: false },
+ * });
+ * ```
+ *
+ * @binding
+ */
+export declare const Postgres: <TRelations extends AnyRelations = EmptyRelations, E = never, R = never>(connectionString: Effect.Effect<Redacted.Redacted<string>, E, R>, config?: EffectDrizzlePgConfig<TRelations> & {
+    /**
+     * Overrides for the underlying `@effect/sql-pg` client — `prepare`,
+     * `ssl`, pool limits, and friends. The URL comes from `connectionString`.
+     */
+    readonly client?: Omit<PgClient.PgPoolConfig, "url">;
+}) => Effect.Effect<EffectPgDatabase<TRelations> & {
+    $client: PgClient.PgClient;
+}, never, never>;
+//# sourceMappingURL=Postgres.d.ts.map

package/lib/Postgres.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Postgres.d.ts","sourceRoot":"","sources":["../src/Postgres.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,QAAQ,MAAM,yBAAyB,CAAC;AAGzD,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AAC9E,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,KAAK,QAAQ,MAAM,iBAAiB,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,eAAO,MAAM,QAAQ,GAAI,UAAU,SAAS,YAAY,GAAG,cAAc,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,oBAC3E,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,WACvD,qBAAqB,CAAC,UAAU,CAAC,GAAG;IAC3C;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;CACtD;aAmBgB,QAAQ,CAAC,QAAQ;gBAWjC,CAAC"}

package/lib/Postgres.js

@@ -0,0 +1,59 @@
+import { resolvePoolConfig } from "@alchemy.run/sql/PostgresTls";
+import { makeExecutionMemo } from "alchemy/Runtime/ExecutionMemo";
+import { proxyChain } from "alchemy/Util/proxy-chain";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+/**
+ * Open a Drizzle/Postgres database from a connection URL using the
+ * `drizzle-orm/effect-postgres` integration.
+ *
+ * Returns a chainable Proxy over `EffectPgDatabase` (via `proxyChain`) —
+ * every property read records a step, every call records args, and the
+ * chain is replayed against the resolved drizzle db when it's finally
+ * yielded as an Effect. Callers don't need a separate `yield* conn` step:
+ *
+ * ```typescript
+ * const db = yield* Drizzle.Postgres(hd.connectionString);
+ *
+ * fetch: Effect.gen(function* () {
+ *   const rows = yield* db.select().from(users);
+ * });
+ * ```
+ *
+ * The connect work is deferred until the first query and memoized on the
+ * current execution's `Scope` (via {@link makeExecutionMemo}), so the pool
+ * is built at most once per execution — a Worker `fetch`/`queue`/`scheduled`
+ * event, a Durable Object call, a Workflow run, or a Lambda invocation — and
+ * reused across every query and `task` step in that execution. Yielding the
+ * connection string is likewise deferred, so deploy / plan-time invocations
+ * (where `WorkerEnvironment` isn't provided) never trigger a real connection
+ * attempt.
+ *
+ * The pool is built against that same execution scope, so its `end`
+ * finalizer fires when the scope closes — when the request / run settles,
+ * not when the Worker's isolate-lifetime init completes. Wrapping queries in
+ * a nested `Effect.scoped` narrows both the memo and the pool's lifetime to
+ * that block: memo key and finalizer target are always the same scope
+ * object, so they cannot disagree.
+ *
+ * `@effect/sql-pg` client options are passed via `config.client`. Behind a
+ * transaction-mode pooler such as Hyperdrive, turn off named prepared
+ * statements, since a later query can reach a backend session that never
+ * prepared them:
+ *
+ * ```typescript
+ * const db = yield* Drizzle.Postgres(hd.connectionString, {
+ *   client: { prepare: false },
+ * });
+ * ```
+ *
+ * @binding
+ */
+export const Postgres = (connectionString, config) => Effect.map(makeExecutionMemo(Effect.gen(function* () {
+    const [PgClient, PgDrizzle] = yield* Effect.promise(() => Promise.all([import("@effect/sql-pg/PgClient"), import("drizzle-orm/effect-postgres")]));
+    const url = yield* connectionString;
+    const { client, ...drizzleConfig } = config ?? {};
+    const pgCtx = yield* Layer.build(PgClient.layer(resolvePoolConfig(url, client)));
+    return yield* PgDrizzle.makeWithDefaults(drizzleConfig).pipe(Effect.provideContext(pgCtx));
+})), (db) => proxyChain(db));
+//# sourceMappingURL=Postgres.js.map

package/lib/Postgres.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Postgres.js","sourceRoot":"","sources":["../src/Postgres.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAKjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAItD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAGtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,MAAM,CAAC,MAAM,QAAQ,GAAG,CACtB,gBAAgE,EAChE,MAMC,EACD,EAAE,CACF,MAAM,CAAC,GAAG,CACR,iBAAiB,CACf,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,MAAM,CAAC,QAAQ,EAAE,SAAS,CAAC,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,CACvD,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,yBAAyB,CAAC,EAAE,MAAM,CAAC,6BAA6B,CAAC,CAAC,CAAC,CACxF,CAAC;IACF,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,gBAAgB,CAAC;IACpC,MAAM,EAAE,MAAM,EAAE,GAAG,aAAa,EAAE,GAAG,MAAM,IAAI,EAAE,CAAC;IAClD,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;IACjF,OAAO,KAAK,CAAC,CAAC,SAAS,CAAC,gBAAgB,CACtC,aAAkD,CACnD,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC;AACvC,CAAC,CAAC,CACH,EACD,CAAC,EAAE,EAAE,EAAE,CACL,UAAU,CAKR,EAMC,CACF,CACJ,CAAC"}

package/lib/Providers.d.ts

@@ -0,0 +1,47 @@
+import * as Provider from "alchemy/Provider";
+import * as Layer from "effect/Layer";
+declare const Providers_base: Provider.ProviderCollection<Providers, "Drizzle">;
+export declare class Providers extends Providers_base {
+}
+export type ProviderRequirements = Layer.Services<ReturnType<typeof providers>>;
+/**
+ * Build-time providers for managing Drizzle schemas as Alchemy resources.
+ * Drizzle.Schema regenerates migration SQL via drizzle-kit's programmatic
+ * API on every deploy when the source schema changes.
+ *
+ * @example
+ * ```typescript
+ * import * as Alchemy from "alchemy";
+ * import * as Cloudflare from "@alchemy.run/cloudflare";
+ * import * as Drizzle from "@alchemy.run/drizzle";
+ * import * as Neon from "@alchemy.run/neon";
+ * import * as Effect from "effect/Effect";
+ * import * as Layer from "effect/Layer";
+ *
+ * export default Alchemy.Stack(
+ *   "MyStack",
+ *   {
+ *     providers: Layer.mergeAll(
+ *       Cloudflare.providers(),
+ *       Drizzle.providers(),
+ *       Neon.providers(),
+ *     ),
+ *     state: Alchemy.localState(),
+ *   },
+ *   Effect.gen(function* () {
+ *     const schema = yield* Drizzle.Schema("app-schema", {
+ *       schema: "./src/schema.ts",
+ *     });
+ *     const project = yield* Neon.Project("app-db");
+ *     const branch = yield* Neon.Branch("app-branch", {
+ *       project,
+ *       migrationsDir: schema.out,
+ *     });
+ *     return { branchId: branch.branchId };
+ *   }),
+ * );
+ * ```
+ */
+export declare const providers: () => Layer.Layer<Providers, never, import("effect/process/ChildProcessSpawner").ChildProcessSpawner | import("effect/FileSystem").FileSystem | import("effect/Path").Path | import("effect/Scope").Scope>;
+export {};
+//# sourceMappingURL=Providers.d.ts.map

package/lib/Providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Providers.d.ts","sourceRoot":"","sources":["../src/Providers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;;AAGtC,qBAAa,SAAU,SAAQ,cAAmD;CAAG;AAErF,MAAM,MAAM,oBAAoB,GAAG,KAAK,CAAC,QAAQ,CAAC,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC,CAAC;AAEhF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,SAAS,4MAInB,CAAC"}

package/lib/Providers.js

@@ -0,0 +1,45 @@
+import * as Provider from "alchemy/Provider";
+import * as Layer from "effect/Layer";
+import { Schema, SchemaProvider } from "./Schema.js";
+export class Providers extends Provider.ProviderCollection()("Drizzle") {
+}
+/**
+ * Build-time providers for managing Drizzle schemas as Alchemy resources.
+ * Drizzle.Schema regenerates migration SQL via drizzle-kit's programmatic
+ * API on every deploy when the source schema changes.
+ *
+ * @example
+ * ```typescript
+ * import * as Alchemy from "alchemy";
+ * import * as Cloudflare from "@alchemy.run/cloudflare";
+ * import * as Drizzle from "@alchemy.run/drizzle";
+ * import * as Neon from "@alchemy.run/neon";
+ * import * as Effect from "effect/Effect";
+ * import * as Layer from "effect/Layer";
+ *
+ * export default Alchemy.Stack(
+ *   "MyStack",
+ *   {
+ *     providers: Layer.mergeAll(
+ *       Cloudflare.providers(),
+ *       Drizzle.providers(),
+ *       Neon.providers(),
+ *     ),
+ *     state: Alchemy.localState(),
+ *   },
+ *   Effect.gen(function* () {
+ *     const schema = yield* Drizzle.Schema("app-schema", {
+ *       schema: "./src/schema.ts",
+ *     });
+ *     const project = yield* Neon.Project("app-db");
+ *     const branch = yield* Neon.Branch("app-branch", {
+ *       project,
+ *       migrationsDir: schema.out,
+ *     });
+ *     return { branchId: branch.branchId };
+ *   }),
+ * );
+ * ```
+ */
+export const providers = () => Layer.effect(Providers, Provider.collection([Schema])).pipe(Layer.provide(SchemaProvider()), Layer.orDie);
+//# sourceMappingURL=Providers.js.map

package/lib/Providers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Providers.js","sourceRoot":"","sources":["../src/Providers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAErD,MAAM,OAAO,SAAU,SAAQ,QAAQ,CAAC,kBAAkB,EAAa,CAAC,SAAS,CAAC;CAAG;AAIrF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,GAAG,EAAE,CAC5B,KAAK,CAAC,MAAM,CAAC,SAAS,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CACzD,KAAK,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC,EAC/B,KAAK,CAAC,KAAK,CACZ,CAAC"}

package/lib/Schema.d.ts

@@ -0,0 +1,85 @@
+import * as Provider from "alchemy/Provider";
+import { Resource } from "alchemy/Resource";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import type { Providers } from "./Providers.ts";
+export type Dialect = "postgres" | "mysql" | "sqlite";
+export type SchemaProps = {
+    /**
+     * Path to the schema module, relative to the current working directory.
+     * The module is loaded via dynamic `import()` so drizzle-kit can introspect
+     * the table definitions, then diffed against the latest snapshot under
+     * `out` to detect changes.
+     *
+     * @example "./src/schema.ts"
+     */
+    schema: string;
+    /**
+     * Output directory for generated migrations. Each migration is written as
+     * `{out}/{timestamp}_migration/{migration.sql, snapshot.json}`. Pass this
+     * through as a database resource's `migrations` prop (`Neon.Branch`,
+     * `Fly.Postgres`, `Cloudflare.D1.Database`, …) to apply pending
+     * migrations on deploy.
+     *
+     * @default "./migrations"
+     */
+    out?: string;
+    /**
+     * SQL dialect to generate migrations for. Selects which `drizzle-kit/api-*`
+     * module is loaded.
+     *
+     * @default "postgres"
+     */
+    dialect?: Dialect;
+};
+export type Schema = Resource<"Drizzle.Schema", SchemaProps, {
+    /** Path to the migrations directory, relative to the current working directory. */
+    out: string;
+    /**
+     * sha256 of the latest snapshot.json. Stable across deploys when the
+     * schema is unchanged; bumps trigger an update which regenerates pending
+     * migration SQL. Downstream `migrationsDir` consumers read this to
+     * detect drift and reapply.
+     */
+    snapshotHash: string;
+    /** Names of all migration directories under `out`, in order. */
+    migrations: string[];
+}, never, Providers>;
+/**
+ * A Drizzle schema managed as an Alchemy resource.
+ *
+ * Wraps drizzle-kit's programmatic API (`generateDrizzleJson` /
+ * `generateMigration`) so migration SQL is regenerated as part of `alchemy
+ * deploy` whenever the source schema changes. The output directory is
+ * intended to be passed straight to a database resource's `migrations`
+ * prop, giving you a single deploy-driven flow:
+ *
+ * ```typescript
+ * const schema = yield* Drizzle.Schema("app-schema", {
+ *   schema: "./src/schema.ts",
+ * });
+ *
+ * const branch = yield* Neon.Branch("app-branch", {
+ *   project,
+ *   migrations: schema,
+ * });
+ *
+ * const db = yield* Fly.Postgres("Db", {
+ *   region: "iad",
+ *   migrations: schema,
+ * });
+ * ```
+ *
+ * `Drizzle.Schema` runs first (because the database resource depends
+ * on its `out` output), regenerates pending migration files, and the
+ * database resource then applies them.
+ *
+ * The resource is delete-safe: removing it from the stack does **not** wipe
+ * the migrations directory, since migration files are typically checked in
+ * and shared with other environments.
+ *
+ * @resource
+ */
+export declare const Schema: import("alchemy/Resource").ResourceClass<Schema>;
+export declare const SchemaProvider: () => import("effect/Layer").Layer<Provider.Provider<Schema>, never, import("effect/process/ChildProcessSpawner").ChildProcessSpawner | FileSystem.FileSystem | Path.Path | import("effect/Scope").Scope>;
+//# sourceMappingURL=Schema.d.ts.map

package/lib/Schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Schema.d.ts","sourceRoot":"","sources":["../src/Schema.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,QAAQ,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAI5C,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,IAAI,MAAM,aAAa,CAAC;AAGpC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,MAAM,MAAM,OAAO,GAAG,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAC;AAgBtD,MAAM,MAAM,WAAW,GAAG;IACxB;;;;;;;OAOG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;;;OAQG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG,QAAQ,CAC3B,gBAAgB,EAChB,WAAW,EACX;IACE,mFAAmF;IACnF,GAAG,EAAE,MAAM,CAAC;IACZ;;;;;OAKG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB,gEAAgE;IAChE,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,EACD,KAAK,EACL,SAAS,CACV,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,eAAO,MAAM,MAAM,kDAAqC,CAAC;AAiBzD,eAAO,MAAM,cAAc,2MA4VxB,CAAC"}