@alchemy.run/drizzle 0.0.0 → 2.0.0-beta.85

package/LICENSE

@@ -0,0 +1,201 @@
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,9 +1,87 @@
 # @alchemy.run/drizzle
 
-🐣 This package name has been claimed with [fledgling](https://github.com/dmno-dev/fledgling) for [https://alchemy.run](https://alchemy.run), and a real release will land here soon.
+[Drizzle ORM](https://orm.drizzle.team) for [Alchemy](https://alchemy.run). Generate migrations from your schema at deploy time, and query D1, Postgres, MySQL, or libSQL from a Worker or Lambda with a typed Effect client.
 
-This is a placeholder — there is nothing to install yet.
+```sh
+npm install alchemy @alchemy.run/drizzle @alchemy.run/cloudflare drizzle-orm drizzle-kit effect
+```
 
----
+A schema:
 
-Want to claim a name of your own? Run `npx fledgling add <name> --new --yes` — it reserves the name on npm and can set up token-less (OIDC trusted) publishing for when you are ready.
+```typescript
+// src/schema.ts
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+export const Users = sqliteTable("users", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  email: text("email").notNull().unique(),
+  name: text("name").notNull(),
+});
+```
+
+A D1 database whose migrations are generated from that schema on deploy, and a Worker that queries it:
+
+```typescript
+// src/api.ts
+import * as Cloudflare from "@alchemy.run/cloudflare";
+import * as Drizzle from "@alchemy.run/drizzle";
+import * as Effect from "effect/Effect";
+import * as HttpServerResponse from "effect/http/HttpServerResponse";
+import { Users } from "./schema.ts";
+
+export const Database = Effect.gen(function* () {
+  const schema = yield* Drizzle.Schema("Schema", {
+    schema: "./src/schema.ts",
+    out: "./migrations",
+    dialect: "sqlite",
+  });
+  return yield* Cloudflare.D1.Database("Db", { migrations: schema });
+});
+
+export default class Api extends Cloudflare.Worker<Api>()(
+  "Api",
+  { main: import.meta.url },
+  Effect.gen(function* () {
+    const d1 = yield* Cloudflare.D1.QueryDatabase(yield* Database);
+    const db = yield* Drizzle.D1(d1);
+
+    return {
+      fetch: Effect.gen(function* () {
+        const users = yield* db.select().from(Users);
+        return yield* HttpServerResponse.json({ users });
+      }).pipe(Effect.orDie),
+    };
+  }).pipe(Effect.provide(Cloudflare.D1.QueryDatabaseBinding)),
+) {}
+```
+
+```typescript
+// alchemy.run.ts
+import * as Alchemy from "alchemy";
+import * as Cloudflare from "@alchemy.run/cloudflare";
+import * as Drizzle from "@alchemy.run/drizzle";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import Api from "./src/api.ts";
+
+export default Alchemy.Stack(
+  "MyApp",
+  {
+    providers: Layer.mergeAll(Cloudflare.providers(), Drizzle.providers()),
+    state: Cloudflare.state(),
+  },
+  Effect.gen(function* () {
+    const api = yield* Api;
+    return { url: api.url };
+  }),
+);
+```
+
+`Drizzle.Postgres`, `Drizzle.MySQL`, and `Drizzle.LibSQL` work the same way for the other databases.
+
+## Learn more
+
+- [Drizzle with D1](https://alchemy.run/sql/drizzle/d1)
+- [Drizzle with Postgres](https://alchemy.run/sql/drizzle/postgres)
+- [Drizzle migrations](https://alchemy.run/sql/drizzle/migrations)
+- [SQL on alchemy.run](https://alchemy.run/sql)

package/lib/Cloudflare.d.ts

@@ -0,0 +1,104 @@
+import { DurableObjectState } from "@alchemy.run/cloudflare/Workers/DurableObjectState";
+import type { SqlMigrations } from "@alchemy.run/cloudflare/Workers/SqlMigrations";
+import * as SqliteDoClient from "@effect/sql-sqlite-do/SqliteClient";
+import type { AnyRelations, EmptyRelations } from "drizzle-orm";
+import * as SQLiteDoDrizzle from "drizzle-orm/effect-sqlite-do";
+import * as Effect from "effect/Effect";
+/**
+ * Migrations for {@link DurableObject} — the shape of the `migrations.js`
+ * bundle `drizzle-kit generate` emits for `driver: "durable-sqlite"`
+ * (each migration's `.sql` file imported as a text module).
+ */
+export interface DurableObjectMigrations {
+    readonly migrations: Record<string, string>;
+    readonly migrationsTable?: string | undefined;
+}
+export interface DurableObjectConfig<TRelations extends AnyRelations = EmptyRelations> extends SQLiteDoDrizzle.EffectDrizzleSQLiteDoConfig<TRelations> {
+    /**
+     * Migrations applied before the database is returned. Prefer a snapshot
+     * from `Cloudflare.SqlMigrations(dir)`: SQL is read during construction
+     * and applied with Alchemy's `__alchemy_migrations` bookkeeping.
+     * The generated Drizzle `migrations.js` input remains supported and uses
+     * Drizzle's own migrator; its SQL imports still require loader support.
+     */
+    readonly migrations?: SqlMigrations | DurableObjectMigrations | undefined;
+}
+/**
+ * Open a Drizzle database over the current Durable Object's SQLite
+ * storage using the `drizzle-orm/effect-sqlite-do` integration (driven by
+ * `@effect/sql-sqlite-do`'s `SqliteClient`), applying migrations first
+ * when provided. `Cloudflare.SqlMigrations` captures a SQL directory during
+ * construction without importing `.sql` files. Each instance applies pending
+ * files on activation using Alchemy's shared migration history.
+ *
+ * Every query is an Effect with a typed error channel — drizzle's
+ * `EffectDrizzleQueryError` (query + params + cause, wrapping the
+ * underlying effect-sql `SqlError`) — so failures are handled with
+ * `Effect.catchTag` instead of leaking as defects. Transactions add
+ * `SqlError` to the union. Opening the db itself never fails: a
+ * migration that cannot apply dies, since the instance is unusable
+ * without its schema.
+ *
+ * Yield it in the object's inner (instance) Effect — it runs when the
+ * instance activates, before any request reaches its methods:
+ *
+ * ```typescript
+ * // schema.ts
+ * import { defineRelations } from "drizzle-orm";
+ * import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+ *
+ * export const users = sqliteTable("users", {
+ *   id: integer("id").primaryKey({ autoIncrement: true }),
+ *   name: text("name").notNull(),
+ * });
+ *
+ * export const posts = sqliteTable("posts", {
+ *   id: integer("id").primaryKey({ autoIncrement: true }),
+ *   userId: integer("user_id").notNull().references(() => users.id),
+ *   title: text("title").notNull(),
+ * });
+ *
+ * export const relations = defineRelations({ users, posts }, (t) => ({
+ *   users: { posts: t.many.posts() },
+ *   posts: { author: t.one.users({ from: t.posts.userId, to: t.users.id }) },
+ * }));
+ * ```
+ *
+ * ```typescript
+ * import * as Drizzle from "@alchemy.run/drizzle/Cloudflare";
+ * import { posts, relations, users } from "./schema.ts";
+ *
+ * export class Users extends Cloudflare.DurableObject<Users>()(
+ *   "Users",
+ *   Effect.gen(function* () {
+ *     const migrations = yield* Cloudflare.SqlMigrations("./drizzle");
+ *     return Effect.gen(function* () {
+ *       const db = yield* Drizzle.DurableObject({ migrations, relations });
+ *
+ *       return {
+ *         addUser: (name: string) => db.insert(users).values({ name }),
+ *         listUsers: () => db.select().from(users),
+ *         listUsersWithPosts: () =>
+ *           db.query.users.findMany({ with: { posts: true } }),
+ *         // typed error handling per operation:
+ *         tryAddUser: (name: string) =>
+ *           db
+ *             .insert(users)
+ *             .values({ name })
+ *             .pipe(
+ *               Effect.catchTag("EffectDrizzleQueryError", () =>
+ *                 Effect.succeed(undefined),
+ *               ),
+ *             ),
+ *       };
+ *     });
+ *   }),
+ * ) {}
+ * ```
+ *
+ * @binding
+ */
+export declare const DurableObject: <TRelations extends AnyRelations = EmptyRelations>(config?: DurableObjectConfig<TRelations> | undefined) => Effect.Effect<SQLiteDoDrizzle.EffectSQLiteDoDatabase<TRelations> & {
+    $client: SqliteDoClient.SqliteClient;
+}, never, DurableObjectState | import("alchemy").RuntimeContext | import("effect/Scope").Scope>;
+//# sourceMappingURL=Cloudflare.d.ts.map

package/lib/Cloudflare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cloudflare.d.ts","sourceRoot":"","sources":["../src/Cloudflare.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,oDAAoD,CAAC;AACxF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+CAA+C,CAAC;AACnF,OAAO,KAAK,cAAc,MAAM,oCAAoC,CAAC;AACrE,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAChE,OAAO,KAAK,eAAe,MAAM,8BAA8B,CAAC;AAGhE,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAIxC;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5C,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/C;AAED,MAAM,WAAW,mBAAmB,CAClC,UAAU,SAAS,YAAY,GAAG,cAAc,CAChD,SAAQ,eAAe,CAAC,2BAA2B,CAAC,UAAU,CAAC;IAC/D;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,aAAa,GAAG,uBAAuB,GAAG,SAAS,CAAC;CAC3E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AACH,eAAO,MAAM,aAAa,GACxB,UAAU,SAAS,YAAY;;+FAiC/B,CAAC"}

package/lib/Cloudflare.js

@@ -0,0 +1,115 @@
+import { DurableObjectState } from "@alchemy.run/cloudflare/Workers/DurableObjectState";
+import * as SqliteDoClient from "@effect/sql-sqlite-do/SqliteClient";
+import * as SQLiteDoDrizzle from "drizzle-orm/effect-sqlite-do";
+import { migrate } from "drizzle-orm/effect-sqlite-do/migrator";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Scheduler from "effect/Scheduler";
+/**
+ * Open a Drizzle database over the current Durable Object's SQLite
+ * storage using the `drizzle-orm/effect-sqlite-do` integration (driven by
+ * `@effect/sql-sqlite-do`'s `SqliteClient`), applying migrations first
+ * when provided. `Cloudflare.SqlMigrations` captures a SQL directory during
+ * construction without importing `.sql` files. Each instance applies pending
+ * files on activation using Alchemy's shared migration history.
+ *
+ * Every query is an Effect with a typed error channel — drizzle's
+ * `EffectDrizzleQueryError` (query + params + cause, wrapping the
+ * underlying effect-sql `SqlError`) — so failures are handled with
+ * `Effect.catchTag` instead of leaking as defects. Transactions add
+ * `SqlError` to the union. Opening the db itself never fails: a
+ * migration that cannot apply dies, since the instance is unusable
+ * without its schema.
+ *
+ * Yield it in the object's inner (instance) Effect — it runs when the
+ * instance activates, before any request reaches its methods:
+ *
+ * ```typescript
+ * // schema.ts
+ * import { defineRelations } from "drizzle-orm";
+ * import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+ *
+ * export const users = sqliteTable("users", {
+ *   id: integer("id").primaryKey({ autoIncrement: true }),
+ *   name: text("name").notNull(),
+ * });
+ *
+ * export const posts = sqliteTable("posts", {
+ *   id: integer("id").primaryKey({ autoIncrement: true }),
+ *   userId: integer("user_id").notNull().references(() => users.id),
+ *   title: text("title").notNull(),
+ * });
+ *
+ * export const relations = defineRelations({ users, posts }, (t) => ({
+ *   users: { posts: t.many.posts() },
+ *   posts: { author: t.one.users({ from: t.posts.userId, to: t.users.id }) },
+ * }));
+ * ```
+ *
+ * ```typescript
+ * import * as Drizzle from "@alchemy.run/drizzle/Cloudflare";
+ * import { posts, relations, users } from "./schema.ts";
+ *
+ * export class Users extends Cloudflare.DurableObject<Users>()(
+ *   "Users",
+ *   Effect.gen(function* () {
+ *     const migrations = yield* Cloudflare.SqlMigrations("./drizzle");
+ *     return Effect.gen(function* () {
+ *       const db = yield* Drizzle.DurableObject({ migrations, relations });
+ *
+ *       return {
+ *         addUser: (name: string) => db.insert(users).values({ name }),
+ *         listUsers: () => db.select().from(users),
+ *         listUsersWithPosts: () =>
+ *           db.query.users.findMany({ with: { posts: true } }),
+ *         // typed error handling per operation:
+ *         tryAddUser: (name: string) =>
+ *           db
+ *             .insert(users)
+ *             .values({ name })
+ *             .pipe(
+ *               Effect.catchTag("EffectDrizzleQueryError", () =>
+ *                 Effect.succeed(undefined),
+ *               ),
+ *             ),
+ *       };
+ *     });
+ *   }),
+ * ) {}
+ * ```
+ *
+ * @binding
+ */
+export const DurableObject = Effect.fn("Drizzle.DurableObject")(function* (config) {
+    const state = yield* DurableObjectState;
+    const storage = state.raw.storage;
+    const { migrations, ...drizzleConfig } = config ?? {};
+    // Built on the ambient (instance) Scope — the client wraps the DO's
+    // local SQLite storage, so there is no disposable resource behind it.
+    const services = yield* Layer.build(SqliteDoClient.layer({ storage }));
+    const client = Context.get(services, SqliteDoClient.SqliteClient);
+    const original = client.withTransaction;
+    const scheduler = new Scheduler.MixedScheduler("sync");
+    const withTransaction = (body) => original(body).pipe(Effect.provideService(Scheduler.Scheduler, scheduler));
+    // A parent input-gate timer can block later transaction timers. Yield through
+    // microtasks while retaining the adapter's client, SQL permit, and context.
+    yield* Effect.sync(() => Object.assign(client, { withTransaction }));
+    const db = yield* SQLiteDoDrizzle.makeWithDefaults(drizzleConfig).pipe(Effect.provideContext(services));
+    if (migrations !== undefined && "_tag" in migrations) {
+        yield* migrations.apply().pipe(Effect.orDie);
+    }
+    else if (migrations !== undefined) {
+        // A migration that cannot apply leaves the instance unusable — there
+        // is no meaningful recovery at init, so it dies rather than forcing
+        // every caller to handle (or orDie) an error channel.
+        yield* migrate(db, {
+            migrations: migrations.migrations,
+            ...(migrations.migrationsTable !== undefined
+                ? { migrationsTable: migrations.migrationsTable }
+                : {}),
+        }).pipe(Effect.orDie);
+    }
+    return db;
+});
+//# sourceMappingURL=Cloudflare.js.map

package/lib/Cloudflare.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cloudflare.js","sourceRoot":"","sources":["../src/Cloudflare.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,oDAAoD,CAAC;AAExF,OAAO,KAAK,cAAc,MAAM,oCAAoC,CAAC;AAErE,OAAO,KAAK,eAAe,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,OAAO,EAAE,MAAM,uCAAuC,CAAC;AAChE,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,SAAS,MAAM,kBAAkB,CAAC;AAyB9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CAAC,EAAE,CAAC,uBAAuB,CAAC,CAAC,QAAQ,CAAC,EAEvE,MAAwC;IACxC,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,kBAAkB,CAAC;IACxC,MAAM,OAAO,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC;IAClC,MAAM,EAAE,UAAU,EAAE,GAAG,aAAa,EAAE,GAAG,MAAM,IAAI,EAAE,CAAC;IACtD,oEAAoE;IACpE,sEAAsE;IACtE,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;IACvE,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,cAAc,CAAC,YAAY,CAAC,CAAC;IAClE,MAAM,QAAQ,GAAG,MAAM,CAAC,eAAe,CAAC;IACxC,MAAM,SAAS,GAAG,IAAI,SAAS,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IACvD,MAAM,eAAe,GAAkC,CAAC,IAAI,EAAE,EAAE,CAC9D,QAAQ,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,SAAS,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC;IAC7E,8EAA8E;IAC9E,4EAA4E;IAC5E,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,eAAe,EAAE,CAAC,CAAC,CAAC;IACrE,MAAM,EAAE,GAAG,KAAK,CAAC,CAAC,eAAe,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC,IAAI,CACpE,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,CAChC,CAAC;IACF,IAAI,UAAU,KAAK,SAAS,IAAI,MAAM,IAAI,UAAU,EAAE,CAAC;QACrD,KAAK,CAAC,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC/C,CAAC;SAAM,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;QACpC,qEAAqE;QACrE,oEAAoE;QACpE,sDAAsD;QACtD,KAAK,CAAC,CAAC,OAAO,CAAC,EAAE,EAAE;YACjB,UAAU,EAAE,UAAU,CAAC,UAAU;YACjC,GAAG,CAAC,UAAU,CAAC,eAAe,KAAK,SAAS;gBAC1C,CAAC,CAAC,EAAE,eAAe,EAAE,UAAU,CAAC,eAAe,EAAE;gBACjD,CAAC,CAAC,EAAE,CAAC;SACR,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACxB,CAAC;IACD,OAAO,EAAE,CAAC;AACZ,CAAC,CAAC,CAAC"}

package/lib/D1.d.ts

@@ -0,0 +1,48 @@
+import type { D1DatabaseSource } from "@alchemy.run/cloudflare/D1/SQL";
+import * as D1Client from "@effect/sql-d1/D1Client";
+import type { AnyRelations, EmptyRelations } from "drizzle-orm";
+import type { EffectSQLiteD1Database } from "drizzle-orm/effect-d1";
+import * as SQLiteD1Drizzle from "drizzle-orm/effect-d1";
+import * as Effect from "effect/Effect";
+/**
+ * Open a Drizzle database over a Cloudflare D1 binding using the
+ * `drizzle-orm/effect-d1` integration (which drives queries through
+ * `@effect/sql-d1`'s `D1Client`).
+ *
+ * Accepts the client returned by `Cloudflare.D1.QueryDatabase(db)` — or its
+ * `raw` effect directly — and returns a chainable Proxy over
+ * `EffectSQLiteD1Database` (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 d1 = yield* Cloudflare.D1.QueryDatabase(Db);
+ * const db = yield* Drizzle.D1(d1, { relations });
+ *
+ * fetch: Effect.gen(function* () {
+ *   const rows = yield* db.select().from(users);
+ * });
+ * ```
+ *
+ * The client build is deferred until the first query and memoized on the
+ * current execution's `Scope` (via {@link makeExecutionMemo}), so the
+ * `D1Client` (and its prepared-statement cache) is built at most once per
+ * execution — a Worker `fetch`/`queue`/`scheduled` event, a Durable Object
+ * call, or a Workflow run — and reused across every query in that execution.
+ * Resolving the binding is likewise deferred, so deploy / plan-time
+ * invocations (where `WorkerEnvironment` isn't provided) never touch D1.
+ *
+ * The client is built against that same execution scope, so its 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 client's lifetime to that
+ * block: memo key and finalizer target are always the same scope object, so
+ * they cannot disagree.
+ *
+ * @binding
+ */
+export declare const D1: <TRelations extends AnyRelations = EmptyRelations, E = never, R = never>(database: D1DatabaseSource<E, R>, config?: SQLiteD1Drizzle.EffectDrizzleSQLiteD1Config<TRelations>) => Effect.Effect<EffectSQLiteD1Database<TRelations> & {
+    $client: D1Client.D1Client;
+}, never, never>;
+//# sourceMappingURL=D1.d.ts.map

package/lib/D1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"D1.d.ts","sourceRoot":"","sources":["../src/D1.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,KAAK,QAAQ,MAAM,yBAAyB,CAAC;AAGpD,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAChE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AACpE,OAAO,KAAK,eAAe,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAGxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,EAAE,GAAI,UAAU,SAAS,YAAY,GAAG,cAAc,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,YAC7E,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,WACvB,eAAe,CAAC,2BAA2B,CAAC,UAAU,CAAC;aAe/C,QAAQ,CAAC,QAAQ;gBAWjC,CAAC"}

package/lib/D1.js

@@ -0,0 +1,50 @@
+import * as D1Client from "@effect/sql-d1/D1Client";
+import { makeExecutionMemo } from "alchemy/Runtime/ExecutionMemo";
+import { proxyChain } from "alchemy/Util/proxy-chain";
+import * as SQLiteD1Drizzle from "drizzle-orm/effect-d1";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+/**
+ * Open a Drizzle database over a Cloudflare D1 binding using the
+ * `drizzle-orm/effect-d1` integration (which drives queries through
+ * `@effect/sql-d1`'s `D1Client`).
+ *
+ * Accepts the client returned by `Cloudflare.D1.QueryDatabase(db)` — or its
+ * `raw` effect directly — and returns a chainable Proxy over
+ * `EffectSQLiteD1Database` (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 d1 = yield* Cloudflare.D1.QueryDatabase(Db);
+ * const db = yield* Drizzle.D1(d1, { relations });
+ *
+ * fetch: Effect.gen(function* () {
+ *   const rows = yield* db.select().from(users);
+ * });
+ * ```
+ *
+ * The client build is deferred until the first query and memoized on the
+ * current execution's `Scope` (via {@link makeExecutionMemo}), so the
+ * `D1Client` (and its prepared-statement cache) is built at most once per
+ * execution — a Worker `fetch`/`queue`/`scheduled` event, a Durable Object
+ * call, or a Workflow run — and reused across every query in that execution.
+ * Resolving the binding is likewise deferred, so deploy / plan-time
+ * invocations (where `WorkerEnvironment` isn't provided) never touch D1.
+ *
+ * The client is built against that same execution scope, so its 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 client's lifetime to that
+ * block: memo key and finalizer target are always the same scope object, so
+ * they cannot disagree.
+ *
+ * @binding
+ */
+export const D1 = (database, config) => Effect.map(makeExecutionMemo(Effect.gen(function* () {
+    const db = yield* Effect.isEffect(database) ? database : database.raw;
+    const d1Ctx = yield* Layer.build(D1Client.layer({ db }));
+    return yield* SQLiteD1Drizzle.makeWithDefaults(config ?? {}).pipe(Effect.provideContext(d1Ctx));
+})), (db) => proxyChain(db));
+//# sourceMappingURL=D1.js.map

package/lib/D1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"D1.js","sourceRoot":"","sources":["../src/D1.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAGtD,OAAO,KAAK,eAAe,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,CAAC,MAAM,EAAE,GAAG,CAChB,QAAgC,EAChC,MAAgE,EAChE,EAAE,CACF,MAAM,CAAC,GAAG,CACR,iBAAiB,CACf,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,MAAM,EAAE,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC;IACtE,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;IACzD,OAAO,KAAK,CAAC,CAAC,eAAe,CAAC,gBAAgB,CAC5C,MAAM,IAAK,EAA8D,CAC1E,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"}