@yielded/auth-persistence-drizzle 0.1.0-beta.0

package/src/drizzle/d1-totp.ts

@@ -0,0 +1,78 @@
+import type { D1Client } from "@effect/sql-d1/D1Client";
+import type { LifecycleHooks } from "@yielded/auth/Hooks";
+import { TotpUnavailable, TotpPersistence } from "@yielded/auth/Totp";
+import type { AnyRelations } from "drizzle-orm";
+import type { EffectSQLiteD1Database } from "drizzle-orm/effect-d1";
+import type { AnySQLiteTable } from "drizzle-orm/sqlite-core";
+import { Context, Effect } from "effect";
+
+import { makeD1Owner } from "./d1-planning";
+import { D1BatchStatements } from "./D1BatchStatements";
+import type { D1TotpMapping, TotpMapping, TotpMappingSource } from "./totp-model";
+import { coordinateTargetTotp, makeTotpTarget, type TotpCoordinatorError } from "./totp-target";
+type Database = EffectSQLiteD1Database<AnyRelations> & { readonly $client: D1Client };
+type Table = AnySQLiteTable;
+
+const configuration = {
+  mode: "batch" as const,
+  dialect: "sqlite" as const,
+  locking: false,
+  standaloneGuard: () => Effect.void,
+};
+
+/** Reads use a primary D1 session; observations and expiry are asserted in the same batch. */
+const target = makeTotpTarget<Database, Table, D1TotpMapping>(configuration);
+
+export const { makeTotpPersistenceServices } = target;
+
+export const coordinateTotpPersistence = <
+  D extends Database,
+  S extends Table,
+  F extends Table,
+  C extends Table,
+  N,
+  A,
+  E,
+  R,
+  RSetup = never,
+  DatabaseError = never,
+  DatabaseRequirements = never,
+>(
+  acquire: Effect.Effect<D, DatabaseError, DatabaseRequirements>,
+  options: { readonly mapping: TotpMappingSource<TotpMapping<S, F, C, N> & D1TotpMapping, RSetup> },
+  body: Effect.Effect<A, E, R>,
+): Effect.Effect<
+  A,
+  TotpCoordinatorError<E> | DatabaseError,
+  Exclude<R, TotpPersistence | D1BatchStatements> | LifecycleHooks | RSetup | DatabaseRequirements
+> =>
+  Effect.flatMap(acquire, (database) =>
+    coordinateTargetTotp(
+      database,
+      options.mapping,
+      configuration,
+      (_transaction, services, append) =>
+        Effect.gen(function* () {
+          const original = services.totpPersistence;
+
+          const nativeCollector = D1BatchStatements.of({
+            append: (statement) => Effect.sync(() => append(statement)),
+          });
+
+          const owner = yield* makeD1Owner(TotpUnavailable.make({})).pipe(
+            Effect.provideService(D1BatchStatements, nativeCollector),
+          );
+
+          const service: TotpPersistence["Service"] = {
+            snapshot: (input) => owner.run(original.snapshot(input)),
+            mutate: (input, prepare) => owner.run(original.mutate(input, prepare)),
+          };
+
+          const provided = Context.make(TotpPersistence, service).pipe(
+            Context.add(D1BatchStatements, owner.collector),
+          );
+
+          return yield* owner.close(Effect.provideContext(body, provided));
+        }),
+    ),
+  );

package/src/drizzle/email-model.ts

@@ -0,0 +1,202 @@
+import type * as Shared from "@yielded/auth-persistence/Adapter";
+import type { SQL, Table } from "drizzle-orm";
+
+import type { DrizzleTableModel } from "./table-model";
+
+export {
+  type RequiredEmailSignInConstraints,
+  requiredEmailSignInConstraints,
+  type RequiredEmailAddressConstraints,
+  requiredEmailAddressConstraints,
+  type EmailRegistrationState,
+  type EmailRegistrationIntent,
+  type RequiredEmailRegistrationConstraints,
+  requiredEmailRegistrationConstraints,
+} from "@yielded/auth-persistence/Adapter";
+
+export type EmailSubjectReadTable<Subject extends Table> = Shared.EmailSubjectReadTable<
+  DrizzleTableModel<Subject>
+>;
+
+export type EmailSubjectTable<Subject extends Table> = Shared.EmailSubjectTable<
+  DrizzleTableModel<Subject>
+>;
+
+export type EmailIdentifierReadTable<Identifier extends Table> = Shared.EmailIdentifierReadTable<
+  DrizzleTableModel<Identifier>
+>;
+
+export type EmailIdentifierTable<
+  Identifier extends Table,
+  NativeSubjectId,
+> = Shared.EmailIdentifierTable<DrizzleTableModel<Identifier>, NativeSubjectId, SQL>;
+
+export type EmailCredentialReadTable<
+  Subject extends Table,
+  Identifier extends Table,
+  Credential extends Table,
+  _NativeSubjectId,
+> = Shared.EmailCredentialReadTable<
+  DrizzleTableModel<Subject>,
+  DrizzleTableModel<Identifier>,
+  DrizzleTableModel<Credential>,
+  _NativeSubjectId
+>;
+
+export type EmailCredentialTable<
+  Subject extends Table,
+  Identifier extends Table,
+  Credential extends Table,
+  NativeSubjectId,
+> = Shared.EmailCredentialTable<
+  DrizzleTableModel<Subject>,
+  DrizzleTableModel<Identifier>,
+  DrizzleTableModel<Credential>,
+  NativeSubjectId
+>;
+
+export type EmailAuthorityCredentialTable<
+  Credential extends Table,
+  NativeSubjectId,
+> = Shared.EmailAuthorityCredentialTable<DrizzleTableModel<Credential>, NativeSubjectId>;
+
+export type EmailCommandTable<Command extends Table> = Shared.EmailCommandTable<
+  DrizzleTableModel<Command>
+>;
+
+export type EmailSignInMapping<
+  Subject extends Table,
+  Identifier extends Table,
+  Credential extends Table,
+  NativeSubjectId,
+> = Shared.EmailSignInMapping<
+  DrizzleTableModel<Subject>,
+  DrizzleTableModel<Identifier>,
+  DrizzleTableModel<Credential>,
+  NativeSubjectId
+>;
+
+export type EmailD1Clock = Shared.EmailD1Clock<SQL>;
+
+export type EmailAddressMapping<
+  Subject extends Table,
+  Identifier extends Table,
+  Credential extends Table,
+  AuthorityCredential extends Table,
+  Command extends Table,
+  NativeSubjectId,
+> = Shared.EmailAddressMapping<
+  DrizzleTableModel<Subject>,
+  DrizzleTableModel<Identifier>,
+  DrizzleTableModel<Credential>,
+  DrizzleTableModel<AuthorityCredential>,
+  DrizzleTableModel<Command>,
+  NativeSubjectId,
+  SQL
+>;
+
+export type D1EmailAddressMapping<
+  Subject extends Table,
+  Identifier extends Table,
+  Credential extends Table,
+  AuthorityCredential extends Table,
+  Command extends Table,
+  NativeSubjectId,
+> = Shared.D1EmailAddressMapping<
+  DrizzleTableModel<Subject>,
+  DrizzleTableModel<Identifier>,
+  DrizzleTableModel<Credential>,
+  DrizzleTableModel<AuthorityCredential>,
+  DrizzleTableModel<Command>,
+  NativeSubjectId,
+  SQL
+>;
+
+export type EmailRegistrationTable<
+  Registration,
+  Request extends Table,
+  NativeSubjectId,
+> = Shared.EmailRegistrationTable<Registration, DrizzleTableModel<Request>, NativeSubjectId>;
+
+export type EmailRegistrationProvisioning<
+  Registration,
+  Subject extends Table,
+  NativeSubjectId,
+> = Shared.EmailRegistrationProvisioning<Registration, DrizzleTableModel<Subject>, NativeSubjectId>;
+
+export type EmailRegistrationIdentifierTable<
+  Identifier extends Table,
+  NativeSubjectId,
+> = Shared.EmailRegistrationIdentifierTable<DrizzleTableModel<Identifier>, NativeSubjectId, SQL>;
+
+export type EmailRegistrationCredentialTable<
+  Credential extends Table,
+  NativeSubjectId,
+> = Shared.EmailRegistrationCredentialTable<DrizzleTableModel<Credential>, NativeSubjectId>;
+
+export type EmailRegistrationAuthorityCredentialTable<
+  Credential extends Table,
+  NativeSubjectId,
+> = Shared.EmailRegistrationAuthorityCredentialTable<
+  DrizzleTableModel<Credential>,
+  NativeSubjectId
+>;
+
+export type EmailRegistrationMapping<
+  Registration,
+  Subject extends Table,
+  Identifier extends Table,
+  Credential extends Table,
+  AuthorityCredential extends Table,
+  Request extends Table,
+  NativeSubjectId,
+> = Shared.EmailRegistrationMapping<
+  Registration,
+  DrizzleTableModel<Subject>,
+  DrizzleTableModel<Identifier>,
+  DrizzleTableModel<Credential>,
+  DrizzleTableModel<AuthorityCredential>,
+  DrizzleTableModel<Request>,
+  NativeSubjectId,
+  SQL
+>;
+
+export type AnyEmailSignInMapping = EmailSignInMapping<Table, Table, Table, unknown>;
+
+export type AnyEmailAddressMapping = EmailAddressMapping<
+  Table,
+  Table,
+  Table,
+  Table,
+  Table,
+  unknown
+>;
+
+export type AnyEmailRegistrationMapping<Registration = unknown> = EmailRegistrationMapping<
+  Registration,
+  Table,
+  Table,
+  Table,
+  Table,
+  Table,
+  unknown
+>;
+
+export type D1EmailRegistrationMapping<
+  Registration,
+  Subject extends Table,
+  Identifier extends Table,
+  Credential extends Table,
+  AuthorityCredential extends Table,
+  Request extends Table,
+  NativeSubjectId,
+> = Shared.D1EmailRegistrationMapping<
+  Registration,
+  DrizzleTableModel<Subject>,
+  DrizzleTableModel<Identifier>,
+  DrizzleTableModel<Credential>,
+  DrizzleTableModel<AuthorityCredential>,
+  DrizzleTableModel<Request>,
+  NativeSubjectId,
+  SQL
+>;