@yielded/auth-persistence-drizzle 0.1.0-beta.25 → 0.1.0-beta.26

package/src/drizzle/native-database.ts

@@ -1,23 +1,64 @@
-import type {
-  TransactionNativeDatabase,
-  SessionSqlDatabase,
-  PasswordSqlDatabase,
-  EmailSqlDatabase,
-  ProofSqlDatabase,
-} from "@yielded/auth-persistence/Adapter";
-import { Effect } from "effect";
+import type { SQL } from "drizzle-orm";
+import type { EffectDrizzleQueryError } from "drizzle-orm/effect-core";
+import { Context, Effect } from "effect";
+import type { SqlClient } from "effect/sql/SqlClient";
+import type { SqlError } from "effect/sql/SqlError";
+import type { Statement } from "effect/sql/Statement";
 
-/** Drizzle omits its captured $client from database class types, and only D1
- * exposes batch. Its generic query builders implement the SQL kernel contracts
- * through drizzleQueryOperations. The selected driver mode controls native calls. */
+/** Only installed driver handles are erased; domain values keep their schemas. */
+export interface NativePhysicalDatabase {
+  readonly $client: SqlClient & {
+    readonly batch: (
+      statements: ReadonlyArray<Statement<unknown>>,
+    ) => Effect.Effect<unknown, SqlError>;
+  };
+  readonly transaction: <A, E, R>(
+    body: (transaction: NativeDatabaseHandle) => Effect.Effect<A, E, R>,
+  ) => Effect.Effect<A, E | SqlError, R>;
+}
+
+/** The captured native Drizzle owner; never a shared/raw SQL resource. */
+export class NativeDatabase extends Context.Service<NativeDatabase, NativePhysicalDatabase>()(
+  "effect-auth/persistence/NativeDatabase",
+) {}
+
+export type NativeDatabaseHandle = NativeSqlDatabase & NativePhysicalDatabase;
+
+/* oxlint-disable no-explicit-any -- only native query-builder handles are erased; domain values use mapped codecs. */
+export interface NativeSqlQuery<A = ReadonlyArray<any>> extends Effect.Effect<
+  A,
+  EffectDrizzleQueryError | SqlError
+> {
+  readonly getSQL: () => SQL;
+  readonly toSQL: () => { readonly sql: string; readonly params: ReadonlyArray<unknown> };
+  readonly from: (...args: ReadonlyArray<any>) => NativeSqlQuery<A>;
+  readonly where: (...args: ReadonlyArray<any>) => NativeSqlQuery<A>;
+  readonly limit: (...args: ReadonlyArray<any>) => NativeSqlQuery<A>;
+  readonly orderBy: (...args: ReadonlyArray<any>) => NativeSqlQuery<A>;
+  readonly for: (...args: ReadonlyArray<any>) => NativeSqlQuery<A>;
+  readonly set: (...args: ReadonlyArray<any>) => NativeSqlQuery<A>;
+  readonly values: (...args: ReadonlyArray<any>) => NativeSqlQuery<A>;
+  readonly returning: (...args: ReadonlyArray<any>) => NativeSqlQuery<A>;
+  readonly $returningId: (...args: ReadonlyArray<any>) => NativeSqlQuery<A>;
+  readonly innerJoin: (...args: ReadonlyArray<any>) => NativeSqlQuery<A>;
+  readonly onConflictDoNothing: (...args: ReadonlyArray<any>) => NativeSqlQuery<A>;
+  readonly onDuplicateKeyUpdate: (...args: ReadonlyArray<any>) => NativeSqlQuery<A>;
+}
+
+export interface NativeSqlDatabase {
+  readonly select: (...args: ReadonlyArray<any>) => NativeSqlQuery;
+  readonly insert: (...args: ReadonlyArray<any>) => NativeSqlQuery;
+  readonly update: (...args: ReadonlyArray<any>) => NativeSqlQuery;
+  readonly delete: (...args: ReadonlyArray<any>) => NativeSqlQuery;
+  readonly transaction: <A, E, R>(
+    body: (transaction: NativeSqlDatabase) => Effect.Effect<A, E, R>,
+  ) => Effect.Effect<A, E | SqlError, R>;
+}
+
+/** Driver makers supply actual query objects and their captured native client.
+ * Drizzle class declarations omit that client and D1's batch method. */
 export const nativeDatabase = <Database, E, R>(acquire: Effect.Effect<Database, E, R>) =>
   Effect.map(
     acquire,
-    (database) =>
-      database as unknown as Database &
-        TransactionNativeDatabase &
-        SessionSqlDatabase &
-        PasswordSqlDatabase &
-        EmailSqlDatabase &
-        ProofSqlDatabase,
+    (database) => database as unknown as Database & NativePhysicalDatabase & NativeSqlDatabase,
   );

package/src/drizzle/native-sql-table.ts

@@ -11,7 +11,7 @@ import {
   is,
   Param,
   Placeholder,
-  type SQL,
+  SQL,
   Table,
   sql,
   type BuildQueryConfig,
@@ -155,105 +155,122 @@ export const makeDrizzleSqlTables = (
   const { database, dialect } = capture(capturedDatabase);
   const compile = compileWith(dialect);
 
-  return makeNativeSqlTables(client, (_client, physical): SqlTable => {
-    if (!is(physical, Table)) return invalid("Expected a Drizzle table");
-    const columns = getTableColumns(physical);
-    const entries = Object.entries(columns);
+  return makeNativeSqlTables(
+    client,
+    (_client, physical): SqlTable => {
+      if (!is(physical, Table)) return invalid("Expected a Drizzle table");
+      const columns = getTableColumns(physical);
+      const entries = Object.entries(columns);
 
-    const schema = is(physical, PgTable)
-      ? getPgTableConfig(physical).schema
-      : is(physical, MySqlTable)
-        ? getMysqlTableConfig(physical).schema
-        : undefined;
+      const schema = is(physical, PgTable)
+        ? getPgTableConfig(physical).schema
+        : is(physical, MySqlTable)
+          ? getMysqlTableConfig(physical).schema
+          : undefined;
 
-    const table = { name: getTableName(physical), ...(schema === undefined ? {} : { schema }) };
+      const table = { name: getTableName(physical), ...(schema === undefined ? {} : { schema }) };
 
-    const getColumn = (key: string) => {
-      const column = Object.hasOwn(columns, key) ? columns[key] : undefined;
+      const getColumn = (key: string) => {
+        const column = Object.hasOwn(columns, key) ? columns[key] : undefined;
 
-      if (column === undefined) return invalid("Missing Drizzle column");
+        if (column === undefined) return invalid("Missing Drizzle column");
 
-      return column;
-    };
+        return column;
+      };
 
-    const bind = (alias?: string): SqlTable => {
-      const reference = (key: string) => {
-        const column = getColumn(key);
+      const bind = (alias?: string): SqlTable => {
+        const reference = (key: string) => {
+          const column = getColumn(key);
 
-        return alias === undefined
-          ? sql`${column}`
-          : sql`${sql.identifier(alias)}.${sql.identifier(column.name)}`;
-      };
+          return alias === undefined
+            ? sql`${column}`
+            : sql`${sql.identifier(alias)}.${sql.identifier(column.name)}`;
+        };
 
-      return {
-        name: compile(
-          alias === undefined ? sql`${physical}` : sql`${physical} AS ${sql.identifier(alias)}`,
-        ),
-        as: bind,
-        column: (key) => compile(reference(key)),
-        unencodedTextColumn: (key) => {
+        const selection = (key: string) => {
           const column = getColumn(key);
 
-          return ["PgText", "PgVarchar", "SQLiteText", "MySqlText", "MySqlVarChar"].includes(
-            column.columnType,
-          ) &&
-            Predicate.hasProperty(column.mapToDriverValue, "isNoop") &&
-            column.mapToDriverValue.isNoop === true &&
-            Predicate.hasProperty(column.mapFromDriverValue, "isNoop") &&
-            column.mapFromDriverValue.isNoop === true &&
-            (dialect.codecs === undefined ||
-              (Predicate.hasProperty(dialect.codecs, "get") &&
-                typeof dialect.codecs.get === "function" &&
-                (["cast", "normalize", "castParam", "normalizeParam"] as const).every(
-                  (kind) => dialect.codecs?.get(column, kind) === undefined,
-                )))
-            ? { table, name: column.name }
-            : undefined;
-        },
-        fields: (prefix) =>
-          compile(
-            sql.join(
-              entries.map(([key, column], index) => {
-                const selection =
-                  dialect.codecs === undefined
-                    ? reference(key)
-                    : dialect.codecs.apply(column, "cast", reference(key));
+          return dialect.codecs === undefined
+            ? reference(key)
+            : dialect.codecs.apply(column, "cast", reference(key));
+        };
 
-                return sql`${selection} as ${sql.identifier(nativeSqlAlias(prefix, index))}`;
+        return {
+          keys: entries.map(([key]) => key),
+          name: compile(
+            alias === undefined ? sql`${physical}` : sql`${physical} AS ${sql.identifier(alias)}`,
+          ),
+          as: bind,
+          column: (key) => compile(reference(key)),
+          columnName: (key) => compile(sql`${sql.identifier(getColumn(key).name)}`),
+          selectedColumn: (key) => compile(sql`${selection(key)}`),
+          unencodedTextColumn: (key) => {
+            const column = getColumn(key);
+
+            return ["PgText", "PgVarchar", "SQLiteText", "MySqlText", "MySqlVarChar"].includes(
+              column.columnType,
+            ) &&
+              Predicate.hasProperty(column.mapToDriverValue, "isNoop") &&
+              column.mapToDriverValue.isNoop === true &&
+              Predicate.hasProperty(column.mapFromDriverValue, "isNoop") &&
+              column.mapFromDriverValue.isNoop === true &&
+              (dialect.codecs === undefined ||
+                (Predicate.hasProperty(dialect.codecs, "get") &&
+                  typeof dialect.codecs.get === "function" &&
+                  (["cast", "normalize", "castParam", "normalizeParam"] as const).every(
+                    (kind) => dialect.codecs?.get(column, kind) === undefined,
+                  )))
+              ? { table, name: column.name }
+              : undefined;
+          },
+          fields: (prefix) =>
+            compile(
+              sql.join(
+                entries.map(
+                  ([key], index) =>
+                    sql`${selection(key)} as ${sql.identifier(nativeSqlAlias(prefix, index))}`,
+                ),
+                sql`, `,
+              ),
+            ),
+          decode: (row, prefix) =>
+            Object.fromEntries(
+              entries.map(([key, column], index) => {
+                const alias = nativeSqlAlias(prefix, index);
+
+                if (!Object.hasOwn(row, alias)) return invalid("Missing SQL projection field");
+                const value = row[alias];
+
+                return [
+                  key,
+                  value === null
+                    ? null
+                    : column.mapFromDriverValue(
+                        dialect.codecs === undefined
+                          ? value
+                          : dialect.codecs.apply(column, "normalize", value),
+                      ),
+                ];
               }),
-              sql`, `,
             ),
-          ),
-        decode: (row, prefix) =>
-          Object.fromEntries(
-            entries.map(([key, column], index) => {
-              const alias = nativeSqlAlias(prefix, index);
-
-              if (!Object.hasOwn(row, alias)) return invalid("Missing SQL projection field");
-              const value = row[alias];
-
-              return [
-                key,
-                value === null
-                  ? null
-                  : column.mapFromDriverValue(
-                      dialect.codecs === undefined
-                        ? value
-                        : dialect.codecs.apply(column, "normalize", value),
-                    ),
-              ];
-            }),
-          ),
-        value: (key, value) => {
-          const column = getColumn(key);
-
-          return Statement.isFragment(value) ? value : compile(sql`${sql.param(value, column)}`);
-        },
-        insert: (values) => compile(database.insert(physical).values(writeValues(values)).getSQL()),
-        update: (values) => compile(database.update(physical).set(writeValues(values)).getSQL()),
+          value: (key, value) => {
+            const column = getColumn(key);
+
+            return Statement.isFragment(value) ? value : compile(sql`${sql.param(value, column)}`);
+          },
+          insert: (values) =>
+            compile(database.insert(physical).values(writeValues(values)).getSQL()),
+          update: (values) => compile(database.update(physical).set(writeValues(values)).getSQL()),
+        };
       };
-    };
 
-    return bind();
-  });
+      return bind();
+    },
+    (value) => {
+      if (Statement.isFragment(value)) return value;
+      if (!is(value, SQL)) return invalid("Expected a Drizzle SQL expression");
+
+      return compile(value);
+    },
+  );
 };

package/src/drizzle/native-target.ts

@@ -0,0 +1,120 @@
+import {
+  captureSqlBatchStatements,
+  makeSqlCommitExecutor,
+  requireStandalone,
+  SqlBatchCommit,
+  SqlNativeCommit,
+} from "@yielded/auth-persistence/Adapter";
+import { hasCommitScope, type LifecycleHooks } from "@yielded/auth/Hooks";
+import { Effect } from "effect";
+import { SqlClient } from "effect/sql";
+
+import { D1BatchStatements } from "./D1BatchStatements";
+import { NativeDatabase, type NativeDatabaseHandle } from "./native-database";
+import { makeDrizzleSqlTables } from "./native-sql-table";
+import {
+  makeDrizzleTransactionHandle,
+  type DrizzleTransactionConstructor,
+  type DrizzleTransactionFactory,
+} from "./transaction-handle";
+import { makeMysqlTransactionHandle, mysqlNativeCommit } from "./transaction-mysql";
+
+export interface NativeTargetConfiguration {
+  readonly mode: "native" | "batch";
+  readonly dialect: "pg" | "sqlite" | "mysql";
+  readonly transactionConstructor?: DrizzleTransactionConstructor;
+  readonly transactionFactory?: DrizzleTransactionFactory;
+}
+
+const physical = <A, E, R>(
+  work: Effect.Effect<A, E, R>,
+  database: Pick<NativeDatabaseHandle, "$client">,
+  configuration: NativeTargetConfiguration,
+) =>
+  configuration.dialect === "mysql"
+    ? Effect.provideService(work, SqlNativeCommit, mysqlNativeCommit(database.$client))
+    : work;
+
+/** Pure physical metadata and the exact driver's commit capability. Domain
+ * mappings, row codecs and decisions stay in their shared native workflow. */
+export const nativeTarget = Effect.fnUntraced(function* (configuration: NativeTargetConfiguration) {
+  const database = yield* NativeDatabase;
+
+  const batch: SqlBatchCommit["Service"] = {
+    client: database.$client,
+    execute: (statements) => database.$client.batch(statements).pipe(Effect.asVoid),
+  };
+
+  return {
+    tables: makeDrizzleSqlTables(database.$client, database),
+    batch: configuration.mode === "batch" ? batch : undefined,
+    provide: <A, E, R>(work: Effect.Effect<A, E, R>) =>
+      physical(
+        work.pipe(
+          Effect.provideService(SqlClient.SqlClient, database.$client),
+          Effect.provideService(SqlBatchCommit, configuration.mode === "batch" ? batch : undefined),
+        ),
+        database,
+        configuration,
+      ),
+  };
+});
+
+export const coordinateNativeTarget = <Failure, Services, Transaction, A, E, R, ES, RS>(
+  unavailable: () => Failure,
+  database: NativeDatabaseHandle,
+  configuration: NativeTargetConfiguration,
+  make: Effect.Effect<Services, ES, RS>,
+  body: (transaction: Transaction, services: Services) => Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  E | Failure,
+  Exclude<R, D1BatchStatements> | Exclude<RS, NativeDatabase> | LifecycleHooks
+> =>
+  physical(
+    Effect.gen(function* () {
+      if (yield* hasCommitScope) return yield* Effect.fail(unavailable());
+      if (configuration.mode !== "batch")
+        yield* requireStandalone(unavailable, database.$client.transactionService);
+      const executor = yield* makeSqlCommitExecutor(unavailable);
+
+      const work = Effect.gen(function* () {
+        const services = yield* make.pipe(
+          Effect.mapError(unavailable),
+          Effect.provideService(NativeDatabase, database),
+        );
+
+        const transaction = yield* Effect.suspend(() =>
+          configuration.mode === "batch"
+            ? Effect.succeed(undefined)
+            : configuration.dialect === "mysql"
+              ? makeMysqlTransactionHandle(database)
+              : Effect.succeed(
+                  configuration.transactionFactory?.(database) ??
+                    makeDrizzleTransactionHandle(database, configuration.transactionConstructor),
+                ),
+        ).pipe(Effect.mapError(unavailable));
+
+        const collector = yield* captureSqlBatchStatements;
+
+        // The validated physical driver constructor owns this class boundary.
+        return yield* body(transaction as Transaction, services).pipe(
+          Effect.provideService(D1BatchStatements, {
+            append: (statement) => collector.append(statement).pipe(Effect.orDie),
+          }),
+        );
+      });
+
+      return yield* configuration.mode === "batch"
+        ? executor.coordinateBatch(work)
+        : executor.coordinate(work);
+    }).pipe(
+      Effect.provideService(SqlClient.SqlClient, database.$client),
+      Effect.provideService(SqlBatchCommit, {
+        client: database.$client,
+        execute: (statements) => database.$client.batch(statements).pipe(Effect.asVoid),
+      }),
+    ),
+    database,
+    configuration,
+  );