@yielded/auth-persistence-drizzle 0.1.0-beta.1 → 0.1.0-beta.13

package/src/SqliteDo.ts

@@ -1,7 +1,33 @@
+import { SqliteClient } from "@effect/sql-sqlite-do/SqliteClient";
+import { NativeDatabase, PersistenceConfigurationError } from "@yielded/auth-persistence/Adapter";
 import type { AnyRelations } from "drizzle-orm";
-import type { EffectSQLiteDoDatabase } from "drizzle-orm/effect-sqlite-do";
+import { type EffectSQLiteDoDatabase, makeWithDefaults } from "drizzle-orm/effect-sqlite-do";
 import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
-import { Effect } from "effect";
+import { Context, Effect, Layer } from "effect";
+
+import { nativeDatabase } from "./drizzle/native-database";
+
+/** The application-owned Drizzle database used to construct persistence services. */
+export class Database extends Context.Service<Database, EffectSQLiteDoDatabase<AnyRelations>>()(
+  "effect-auth/persistence-drizzle/SqliteDo/Database",
+) {}
+
+/** The SQL-client Layer must configure storage so Drizzle owns transactionSync. */
+export const databaseLayer = Layer.effect(
+  Database,
+  Effect.gen(function* () {
+    const client = yield* SqliteClient;
+    const storage = client.config.storage;
+
+    if (storage === undefined)
+      return yield* PersistenceConfigurationError.make({
+        reason:
+          "SqliteDo requires a SQL client configured with storage for synchronous transactions",
+      });
+
+    return yield* makeWithDefaults({ storage });
+  }),
+);
 
 import type {
   ExternalIdentityTables,
@@ -18,19 +44,24 @@ import { makeSqlitePasswordTarget, sqlitePasswordConfiguration } from "./drizzle
 import { makeSqliteProofTarget, sqliteProofConfiguration } from "./drizzle/sqlite-proofs";
 import { makeSqliteSessionTarget, sqliteSessionConfiguration } from "./drizzle/sqlite-sessions";
 
-const sessionTarget = makeSqliteSessionTarget<EffectSQLiteDoDatabase<AnyRelations>, true>(
+const sessionTarget = makeSqliteSessionTarget<Database, EffectSQLiteDoDatabase<AnyRelations>, true>(
+  Database,
   sqliteSessionConfiguration("synchronous", Effect.void),
 );
 
-const proofTarget = makeSqliteProofTarget<EffectSQLiteDoDatabase<AnyRelations>, true>(
+const proofTarget = makeSqliteProofTarget<Database, EffectSQLiteDoDatabase<AnyRelations>, true>(
+  Database,
   sqliteProofConfiguration("synchronous", Effect.void),
 );
 
-const passwordTarget = makeSqlitePasswordTarget<EffectSQLiteDoDatabase<AnyRelations>, true>(
-  sqlitePasswordConfiguration("synchronous", Effect.void, Effect.void),
-);
+const passwordTarget = makeSqlitePasswordTarget<
+  Database,
+  EffectSQLiteDoDatabase<AnyRelations>,
+  true
+>(Database, sqlitePasswordConfiguration("synchronous", Effect.void, Effect.void));
 
-const emailTarget = makeSqliteEmailTarget<EffectSQLiteDoDatabase<AnyRelations>, true>(
+const emailTarget = makeSqliteEmailTarget<Database, EffectSQLiteDoDatabase<AnyRelations>, true>(
+  Database,
   sqliteEmailConfiguration("synchronous", Effect.void, Effect.void),
 );
 
@@ -95,9 +126,11 @@ export const makeIdentityServices = <
   Request extends AnySQLiteTable,
   NativeId,
 >(
-  database: EffectSQLiteDoDatabase<AnyRelations>,
   mapping: IdentityTables<Subject, Identifier, External, Request, NativeId>,
-) => makeSqliteIdentityServices(database, mapping, "synchronous");
+) =>
+  makeSqliteIdentityServices(mapping, "synchronous").pipe(
+    Effect.provideServiceEffect(NativeDatabase, nativeDatabase(Database)),
+  );
 
 export const makeSubjectProvisioningServices = <
   Subject extends AnySQLiteTable,
@@ -105,25 +138,30 @@ export const makeSubjectProvisioningServices = <
   Request extends AnySQLiteTable,
   NativeId,
 >(
-  database: EffectSQLiteDoDatabase<AnyRelations>,
   mapping: SubjectProvisioningTables<Subject, Identifier, Request, NativeId>,
-) => makeSqliteSubjectProvisioningServices(database, mapping, "synchronous");
+) =>
+  makeSqliteSubjectProvisioningServices(mapping, "synchronous").pipe(
+    Effect.provideServiceEffect(NativeDatabase, nativeDatabase(Database)),
+  );
 
 export const makeExternalIdentityServices = <
   Subject extends AnySQLiteTable,
   External extends AnySQLiteTable,
   NativeId,
 >(
-  database: EffectSQLiteDoDatabase<AnyRelations>,
   mapping: ExternalIdentityTables<Subject, External, NativeId>,
-) => makeSqliteExternalIdentityServices(database, mapping);
+) =>
+  makeSqliteExternalIdentityServices(mapping).pipe(
+    Effect.provideServiceEffect(NativeDatabase, nativeDatabase(Database)),
+  );
 
 import { makeSqlitePasswordPreparedTarget } from "./drizzle/sqlite-password-prepared";
 
 const passwordPreparedTarget = makeSqlitePasswordPreparedTarget<
+  Database,
   EffectSQLiteDoDatabase<AnyRelations>,
   true
->(sqlitePasswordConfiguration("synchronous", Effect.void, Effect.void));
+>(Database, sqlitePasswordConfiguration("synchronous", Effect.void, Effect.void));
 
 export const { makePasswordPreparedPersistenceServices, coordinatePasswordPreparedPersistence } =
   passwordPreparedTarget;
@@ -133,10 +171,11 @@ export { passwordPreparedPersistenceLayer } from "./drizzle/password-prepared-ta
 import { makeOAuthTarget } from "./drizzle/oauth-drivers";
 
 const oauthTarget = makeOAuthTarget<
+  Database,
   EffectSQLiteDoDatabase<AnyRelations>,
   AnySQLiteTable<{ dialect: "sqlite" }>,
   true
->({
+>(Database, {
   mode: "synchronous",
   dialect: "sqlite",
   locking: false,
@@ -161,11 +200,12 @@ export const {
 import { makePasskeyTarget } from "./drizzle/passkey-drivers";
 
 const passkeyTarget = makePasskeyTarget<
+  Database,
   EffectSQLiteDoDatabase<AnyRelations>,
   AnySQLiteTable<{ dialect: "sqlite" }>,
   unknown,
   true
->({
+>(Database, {
   mode: "synchronous",
   dialect: "sqlite",
   locking: false,
@@ -188,11 +228,12 @@ export const {
 import { makeTotpTarget } from "./drizzle/totp-target";
 
 const totpTarget = makeTotpTarget<
+  Database,
   EffectSQLiteDoDatabase<AnyRelations>,
   AnySQLiteTable<{ dialect: "sqlite" }>,
   unknown,
   true
->({
+>(Database, {
   mode: "synchronous",
   dialect: "sqlite",
   locking: false,
@@ -204,11 +245,12 @@ export const { makeTotpPersistenceServices, coordinateTotpPersistence } = totpTa
 import { makePhoneTarget } from "./drizzle/phone-target";
 
 const phoneTarget = makePhoneTarget<
+  Database,
   EffectSQLiteDoDatabase<AnyRelations>,
   AnySQLiteTable<{ dialect: "sqlite" }>,
   unknown,
   true
->({
+>(Database, {
   mode: "synchronous",
   dialect: "sqlite",
   locking: false,

package/src/SqliteNode.ts

@@ -1,7 +1,18 @@
+import { NativeDatabase } from "@yielded/auth-persistence/Adapter";
 import type { AnyRelations } from "drizzle-orm";
 import { type EffectSQLiteNodeDatabase, makeWithDefaults } from "drizzle-orm/effect-sqlite-node";
 import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
-import { Effect } from "effect";
+import { Context, Effect, Layer } from "effect";
+
+import { nativeDatabase } from "./drizzle/native-database";
+
+/** The application-owned Drizzle database used to construct persistence services. */
+export class Database extends Context.Service<Database, EffectSQLiteNodeDatabase<AnyRelations>>()(
+  "effect-auth/persistence-drizzle/SqliteNode/Database",
+) {}
+
+/** Construct Drizzle from the driver's SQL-client Layer. */
+export const databaseLayer = Layer.effect(Database, makeWithDefaults({}));
 
 import { sqlClientEmailStandaloneGuard } from "./drizzle/email-target";
 import type {
@@ -22,29 +33,34 @@ import { makeSqlitePasswordTarget, sqlitePasswordConfiguration } from "./drizzle
 import { makeSqliteProofTarget, sqliteProofConfiguration } from "./drizzle/sqlite-proofs";
 import { makeSqliteSessionTarget, sqliteSessionConfiguration } from "./drizzle/sqlite-sessions";
 
-const sessionTarget = makeSqliteSessionTarget<EffectSQLiteNodeDatabase<AnyRelations>>((database) =>
-  sqliteSessionConfiguration("interactive", sqlClientSessionStandaloneGuard(database)),
+const sessionTarget = makeSqliteSessionTarget<Database, EffectSQLiteNodeDatabase<AnyRelations>>(
+  Database,
+  (service) => sqliteSessionConfiguration("interactive", sqlClientSessionStandaloneGuard(service)),
 );
 
-const proofTarget = makeSqliteProofTarget<EffectSQLiteNodeDatabase<AnyRelations>>((database) =>
-  sqliteProofConfiguration("interactive", sqlClientProofStandaloneGuard(database)),
+const proofTarget = makeSqliteProofTarget<Database, EffectSQLiteNodeDatabase<AnyRelations>>(
+  Database,
+  (service) => sqliteProofConfiguration("interactive", sqlClientProofStandaloneGuard(service)),
 );
 
-const passwordTarget = makeSqlitePasswordTarget<EffectSQLiteNodeDatabase<AnyRelations>>(
-  (database) =>
+const passwordTarget = makeSqlitePasswordTarget<Database, EffectSQLiteNodeDatabase<AnyRelations>>(
+  Database,
+  (service) =>
     sqlitePasswordConfiguration(
       "interactive",
-      sqlClientPasswordStandaloneGuard(database),
-      sqlClientProofStandaloneGuard(database),
+      sqlClientPasswordStandaloneGuard(service),
+      sqlClientProofStandaloneGuard(service),
     ),
 );
 
-const emailTarget = makeSqliteEmailTarget<EffectSQLiteNodeDatabase<AnyRelations>>((database) =>
-  sqliteEmailConfiguration(
-    "interactive",
-    sqlClientEmailStandaloneGuard(database),
-    sqlClientProofStandaloneGuard(database),
-  ),
+const emailTarget = makeSqliteEmailTarget<Database, EffectSQLiteNodeDatabase<AnyRelations>>(
+  Database,
+  (service) =>
+    sqliteEmailConfiguration(
+      "interactive",
+      sqlClientEmailStandaloneGuard(service),
+      sqlClientProofStandaloneGuard(service),
+    ),
 );
 
 export const {
@@ -86,9 +102,11 @@ export const makeIdentityServices = <
   Request extends AnySQLiteTable,
   NativeId,
 >(
-  database: EffectSQLiteNodeDatabase<AnyRelations>,
   mapping: IdentityTables<Subject, Identifier, External, Request, NativeId>,
-) => makeSqliteIdentityServices(database, mapping, "interactive");
+) =>
+  makeSqliteIdentityServices(mapping, "interactive").pipe(
+    Effect.provideServiceEffect(NativeDatabase, nativeDatabase(Database)),
+  );
 
 export const makeSubjectProvisioningServices = <
   Subject extends AnySQLiteTable,
@@ -96,28 +114,33 @@ export const makeSubjectProvisioningServices = <
   Request extends AnySQLiteTable,
   NativeId,
 >(
-  database: EffectSQLiteNodeDatabase<AnyRelations>,
   mapping: SubjectProvisioningTables<Subject, Identifier, Request, NativeId>,
-) => makeSqliteSubjectProvisioningServices(database, mapping, "interactive");
+) =>
+  makeSqliteSubjectProvisioningServices(mapping, "interactive").pipe(
+    Effect.provideServiceEffect(NativeDatabase, nativeDatabase(Database)),
+  );
 
 export const makeExternalIdentityServices = <
   Subject extends AnySQLiteTable,
   External extends AnySQLiteTable,
   NativeId,
 >(
-  database: EffectSQLiteNodeDatabase<AnyRelations>,
   mapping: ExternalIdentityTables<Subject, External, NativeId>,
-) => makeSqliteExternalIdentityServices(database, mapping);
+) =>
+  makeSqliteExternalIdentityServices(mapping).pipe(
+    Effect.provideServiceEffect(NativeDatabase, nativeDatabase(Database)),
+  );
 
 import { makeSqlitePasswordPreparedTarget } from "./drizzle/sqlite-password-prepared";
 
 const passwordPreparedTarget = makeSqlitePasswordPreparedTarget<
+  Database,
   EffectSQLiteNodeDatabase<AnyRelations>
->((database) =>
+>(Database, (service) =>
   sqlitePasswordConfiguration(
     "interactive",
-    sqlClientPasswordStandaloneGuard(database),
-    sqlClientProofStandaloneGuard(database),
+    sqlClientPasswordStandaloneGuard(service),
+    sqlClientProofStandaloneGuard(service),
   ),
 );
 
@@ -130,9 +153,10 @@ import { makeOAuthTarget } from "./drizzle/oauth-drivers";
 import { sqlClientOAuthStandaloneGuard } from "./drizzle/oauth-target";
 
 const oauthTarget = makeOAuthTarget<
+  Database,
   EffectSQLiteNodeDatabase<AnyRelations>,
   AnySQLiteTable<{ dialect: "sqlite" }>
->({
+>(Database, {
   mode: "interactive",
   dialect: "sqlite",
   locking: false,
@@ -158,9 +182,10 @@ import { makePasskeyTarget } from "./drizzle/passkey-drivers";
 import { sqlClientPasskeyStandaloneGuard } from "./drizzle/passkey-target";
 
 const passkeyTarget = makePasskeyTarget<
+  Database,
   EffectSQLiteNodeDatabase<AnyRelations>,
   AnySQLiteTable<{ dialect: "sqlite" }>
->({
+>(Database, {
   mode: "interactive",
   dialect: "sqlite",
   locking: false,
@@ -183,9 +208,10 @@ export const {
 import { makeTotpTarget, sqlClientTotpStandaloneGuard } from "./drizzle/totp-target";
 
 const totpTarget = makeTotpTarget<
+  Database,
   EffectSQLiteNodeDatabase<AnyRelations>,
   AnySQLiteTable<{ dialect: "sqlite" }>
->({
+>(Database, {
   mode: "interactive",
   dialect: "sqlite",
   locking: false,
@@ -197,9 +223,10 @@ export const { makeTotpPersistenceServices, coordinateTotpPersistence } = totpTa
 import { makePhoneTarget, sqlClientPhoneStandaloneGuard } from "./drizzle/phone-target";
 
 const phoneTarget = makePhoneTarget<
+  Database,
   EffectSQLiteNodeDatabase<AnyRelations>,
   AnySQLiteTable<{ dialect: "sqlite" }>
->({
+>(Database, {
   mode: "interactive",
   dialect: "sqlite",
   locking: false,

package/src/SqliteWasm.ts

@@ -1,7 +1,18 @@
+import { NativeDatabase } from "@yielded/auth-persistence/Adapter";
 import type { AnyRelations } from "drizzle-orm";
 import { type EffectSQLiteWasmDatabase, makeWithDefaults } from "drizzle-orm/effect-sqlite-wasm";
 import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
-import { Effect } from "effect";
+import { Context, Effect, Layer } from "effect";
+
+import { nativeDatabase } from "./drizzle/native-database";
+
+/** The application-owned Drizzle database used to construct persistence services. */
+export class Database extends Context.Service<Database, EffectSQLiteWasmDatabase<AnyRelations>>()(
+  "effect-auth/persistence-drizzle/SqliteWasm/Database",
+) {}
+
+/** Construct Drizzle from the driver's SQL-client Layer. */
+export const databaseLayer = Layer.effect(Database, makeWithDefaults({}));
 
 import { sqlClientEmailStandaloneGuard } from "./drizzle/email-target";
 import type {
@@ -22,29 +33,34 @@ import { makeSqlitePasswordTarget, sqlitePasswordConfiguration } from "./drizzle
 import { makeSqliteProofTarget, sqliteProofConfiguration } from "./drizzle/sqlite-proofs";
 import { makeSqliteSessionTarget, sqliteSessionConfiguration } from "./drizzle/sqlite-sessions";
 
-const sessionTarget = makeSqliteSessionTarget<EffectSQLiteWasmDatabase<AnyRelations>>((database) =>
-  sqliteSessionConfiguration("interactive", sqlClientSessionStandaloneGuard(database)),
+const sessionTarget = makeSqliteSessionTarget<Database, EffectSQLiteWasmDatabase<AnyRelations>>(
+  Database,
+  (service) => sqliteSessionConfiguration("interactive", sqlClientSessionStandaloneGuard(service)),
 );
 
-const proofTarget = makeSqliteProofTarget<EffectSQLiteWasmDatabase<AnyRelations>>((database) =>
-  sqliteProofConfiguration("interactive", sqlClientProofStandaloneGuard(database)),
+const proofTarget = makeSqliteProofTarget<Database, EffectSQLiteWasmDatabase<AnyRelations>>(
+  Database,
+  (service) => sqliteProofConfiguration("interactive", sqlClientProofStandaloneGuard(service)),
 );
 
-const passwordTarget = makeSqlitePasswordTarget<EffectSQLiteWasmDatabase<AnyRelations>>(
-  (database) =>
+const passwordTarget = makeSqlitePasswordTarget<Database, EffectSQLiteWasmDatabase<AnyRelations>>(
+  Database,
+  (service) =>
     sqlitePasswordConfiguration(
       "interactive",
-      sqlClientPasswordStandaloneGuard(database),
-      sqlClientProofStandaloneGuard(database),
+      sqlClientPasswordStandaloneGuard(service),
+      sqlClientProofStandaloneGuard(service),
     ),
 );
 
-const emailTarget = makeSqliteEmailTarget<EffectSQLiteWasmDatabase<AnyRelations>>((database) =>
-  sqliteEmailConfiguration(
-    "interactive",
-    sqlClientEmailStandaloneGuard(database),
-    sqlClientProofStandaloneGuard(database),
-  ),
+const emailTarget = makeSqliteEmailTarget<Database, EffectSQLiteWasmDatabase<AnyRelations>>(
+  Database,
+  (service) =>
+    sqliteEmailConfiguration(
+      "interactive",
+      sqlClientEmailStandaloneGuard(service),
+      sqlClientProofStandaloneGuard(service),
+    ),
 );
 
 export const {
@@ -86,9 +102,11 @@ export const makeIdentityServices = <
   Request extends AnySQLiteTable,
   NativeId,
 >(
-  database: EffectSQLiteWasmDatabase<AnyRelations>,
   mapping: IdentityTables<Subject, Identifier, External, Request, NativeId>,
-) => makeSqliteIdentityServices(database, mapping, "interactive");
+) =>
+  makeSqliteIdentityServices(mapping, "interactive").pipe(
+    Effect.provideServiceEffect(NativeDatabase, nativeDatabase(Database)),
+  );
 
 export const makeSubjectProvisioningServices = <
   Subject extends AnySQLiteTable,
@@ -96,28 +114,33 @@ export const makeSubjectProvisioningServices = <
   Request extends AnySQLiteTable,
   NativeId,
 >(
-  database: EffectSQLiteWasmDatabase<AnyRelations>,
   mapping: SubjectProvisioningTables<Subject, Identifier, Request, NativeId>,
-) => makeSqliteSubjectProvisioningServices(database, mapping, "interactive");
+) =>
+  makeSqliteSubjectProvisioningServices(mapping, "interactive").pipe(
+    Effect.provideServiceEffect(NativeDatabase, nativeDatabase(Database)),
+  );
 
 export const makeExternalIdentityServices = <
   Subject extends AnySQLiteTable,
   External extends AnySQLiteTable,
   NativeId,
 >(
-  database: EffectSQLiteWasmDatabase<AnyRelations>,
   mapping: ExternalIdentityTables<Subject, External, NativeId>,
-) => makeSqliteExternalIdentityServices(database, mapping);
+) =>
+  makeSqliteExternalIdentityServices(mapping).pipe(
+    Effect.provideServiceEffect(NativeDatabase, nativeDatabase(Database)),
+  );
 
 import { makeSqlitePasswordPreparedTarget } from "./drizzle/sqlite-password-prepared";
 
 const passwordPreparedTarget = makeSqlitePasswordPreparedTarget<
+  Database,
   EffectSQLiteWasmDatabase<AnyRelations>
->((database) =>
+>(Database, (service) =>
   sqlitePasswordConfiguration(
     "interactive",
-    sqlClientPasswordStandaloneGuard(database),
-    sqlClientProofStandaloneGuard(database),
+    sqlClientPasswordStandaloneGuard(service),
+    sqlClientProofStandaloneGuard(service),
   ),
 );
 
@@ -130,9 +153,10 @@ import { makeOAuthTarget } from "./drizzle/oauth-drivers";
 import { sqlClientOAuthStandaloneGuard } from "./drizzle/oauth-target";
 
 const oauthTarget = makeOAuthTarget<
+  Database,
   EffectSQLiteWasmDatabase<AnyRelations>,
   AnySQLiteTable<{ dialect: "sqlite" }>
->({
+>(Database, {
   mode: "interactive",
   dialect: "sqlite",
   locking: false,
@@ -158,9 +182,10 @@ import { makePasskeyTarget } from "./drizzle/passkey-drivers";
 import { sqlClientPasskeyStandaloneGuard } from "./drizzle/passkey-target";
 
 const passkeyTarget = makePasskeyTarget<
+  Database,
   EffectSQLiteWasmDatabase<AnyRelations>,
   AnySQLiteTable<{ dialect: "sqlite" }>
->({
+>(Database, {
   mode: "interactive",
   dialect: "sqlite",
   locking: false,
@@ -183,9 +208,10 @@ export const {
 import { makeTotpTarget, sqlClientTotpStandaloneGuard } from "./drizzle/totp-target";
 
 const totpTarget = makeTotpTarget<
+  Database,
   EffectSQLiteWasmDatabase<AnyRelations>,
   AnySQLiteTable<{ dialect: "sqlite" }>
->({
+>(Database, {
   mode: "interactive",
   dialect: "sqlite",
   locking: false,
@@ -197,9 +223,10 @@ export const { makeTotpPersistenceServices, coordinateTotpPersistence } = totpTa
 import { makePhoneTarget, sqlClientPhoneStandaloneGuard } from "./drizzle/phone-target";
 
 const phoneTarget = makePhoneTarget<
+  Database,
   EffectSQLiteWasmDatabase<AnyRelations>,
   AnySQLiteTable<{ dialect: "sqlite" }>
->({
+>(Database, {
   mode: "interactive",
   dialect: "sqlite",
   locking: false,

package/src/drizzle/d1-database.ts

@@ -0,0 +1,10 @@
+import type { D1Client } from "@effect/sql-d1/D1Client";
+import type { AnyRelations } from "drizzle-orm";
+import type { EffectSQLiteD1Database } from "drizzle-orm/effect-d1";
+import { Context } from "effect";
+
+/** Application-owned D1 database, including the client that owns native batches. */
+export class Database extends Context.Service<
+  Database,
+  EffectSQLiteD1Database<AnyRelations> & { readonly $client: D1Client }
+>()("effect-auth/persistence-drizzle/D1/Database") {}