@yielded/auth-persistence 0.1.0-beta.7

package/dist/internal/configuration.d.mts

@@ -0,0 +1,174 @@
+import { PersistenceMappingError } from "./mapping-error.mjs";
+import { StorageRole } from "./storage-tables.mjs";
+import { Context, Effect, Layer, Schema } from "effect";
+import { SqlClient } from "effect/unstable/sql";
+import { PasskeyActionChallenge, PasskeyConfig, PasskeyConfigurationError, PasskeyCredentials, PasskeyEnrollmentContext, PasskeyManagementPersistence, PasskeyManagementPolicy, PasskeyMethodPolicy, PasskeyPersistence } from "@yielded/auth/Passkey";
+import { SubjectId } from "@yielded/auth/Schema";
+import { AuthenticationAuthority, AuthenticationRequirement, make } from "@yielded/auth/Sessions";
+import { EmailAction, EmailAddressPersistence } from "@yielded/auth/Email";
+import { PasswordAction, PasswordPersistence, PasswordUnavailable } from "@yielded/auth/Password";
+import { PhoneAdmission, PhoneSignInTargets } from "@yielded/auth/PhoneOtp";
+import { ProofPersistence } from "@yielded/auth/Proofs";
+import { LoginIdentifier } from "@yielded/auth/Identity";
+//#region src/internal/configuration.d.ts
+declare const PersistenceConfigurationError_base: Schema.Class<PersistenceConfigurationError, Schema.TaggedStruct<"PersistenceConfigurationError", {
+  readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class PersistenceConfigurationError extends PersistenceConfigurationError_base {}
+type ClaimsCodec = Schema.Codec<unknown, unknown, never, never>;
+interface PasskeyFeature {
+  readonly kind: "passkey";
+  readonly moduleId: string;
+  readonly policy: Effect.Effect<PasskeyMethodPolicy, PasskeyConfigurationError, PasskeyConfig>;
+  readonly management?: boolean;
+  readonly managementPolicy?: PasskeyManagementPolicy;
+}
+interface Strategy {
+  readonly strategy: object;
+  readonly persistence?: PasskeyFeature | {
+    readonly kind: "password" | "phone" | "email";
+    readonly moduleId: string;
+    readonly lifecycle?: boolean;
+    readonly management?: boolean;
+    readonly addresses?: boolean;
+  };
+  readonly RegistrationAuthority?: Context.Key<unknown, unknown>;
+}
+interface Definition<C extends ClaimsCodec, Id extends string> {
+  readonly namespace: string;
+  readonly claims: C;
+  readonly sessionMode?: string;
+  readonly sessions: ReturnType<typeof make<C, Id>>;
+  readonly strategies: Readonly<Record<string, Strategy>>;
+}
+type KeyId<T> = T extends Context.Key<infer Id, infer _Service> ? Id : never;
+type Enabled<A extends {
+  readonly strategies: Readonly<Record<string, Strategy>>;
+}, Kind extends "password" | "phone" | "email" | "passkey"> = Extract<A["strategies"][keyof A["strategies"]], {
+  persistence: {
+    kind: Kind;
+  };
+}>;
+type ManagedPassword<A extends {
+  readonly strategies: Readonly<Record<string, Strategy>>;
+}> = Extract<Enabled<A, "password">, {
+  persistence: {
+    management: true;
+  };
+}>;
+type ManagedPasskey<A extends {
+  readonly strategies: Readonly<Record<string, Strategy>>;
+}> = Extract<Enabled<A, "passkey">, {
+  persistence: {
+    management: true;
+  };
+}>;
+type PasskeyRequirement$1<A extends {
+  readonly strategies: Readonly<Record<string, Strategy>>;
+}> = Enabled<A, "passkey"> extends never ? never : PasskeyConfig;
+type RegistrationKey<S> = S extends {
+  readonly RegistrationAuthority: infer K;
+} ? K : never;
+type Registration<S> = RegistrationKey<S> extends Context.Key<infer _Id, infer Service> ? Service extends {
+  readonly register: (input: infer Input, ...args: never[]) => unknown;
+} ? Input extends {
+  readonly registration: infer Value;
+} ? Value : never : never : never;
+interface ProvisioningId<Id extends string> {
+  readonly authNamespace: Id;
+  readonly service: "PersistenceProvisioning";
+}
+type Provisioning<A extends {
+  readonly strategies: Readonly<Record<string, Strategy>>;
+}> = { readonly [K in keyof A["strategies"] as A["strategies"][K] extends {
+  persistence: {
+    kind: "password";
+    management: true;
+  };
+} ? K : never]: (input: {
+  readonly identifier: LoginIdentifier;
+  readonly registration: Registration<A["strategies"][K]>;
+}) => Effect.Effect<SubjectId, PasswordUnavailable>; };
+type ProvisioningRequirement<A extends {
+  readonly namespace: string;
+  readonly strategies: Readonly<Record<string, Strategy>>;
+}> = ManagedPassword<A> extends never ? never : ProvisioningId<A["namespace"]>;
+type ProofRoles = "proofRequests" | "proofSeries" | "proofGenerations" | "proofContinuations" | "proofScopes" | "proofAbuse" | "proofFailures" | "proofCommands";
+type UsesProofs<A extends {
+  readonly strategies: Readonly<Record<string, Strategy>>;
+}> = Enabled<A, "phone"> | Enabled<A, "email"> | ManagedPassword<A>;
+type Ports<C extends ClaimsCodec, Id extends string, A extends Definition<C, Id>> = AuthenticationAuthority | KeyId<A["sessions"]["StatefulSessionPersistence"]> | KeyId<A["sessions"]["SessionRepository"]> | (Enabled<A, "password"> extends never ? never : PasswordPersistence) | KeyId<RegistrationKey<ManagedPassword<A>>> | (Enabled<A, "passkey"> extends never ? never : PasskeyPersistence | PasskeyCredentials) | (ManagedPasskey<A> extends never ? never : PasskeyManagementPersistence | PasskeyEnrollmentContext) | (Enabled<A, "email"> extends never ? never : EmailAddressPersistence) | (UsesProofs<A> extends never ? never : ProofPersistence) | (Enabled<A, "phone"> extends never ? never : PhoneAdmission | PhoneSignInTargets);
+type Roles<C extends ClaimsCodec, Id extends string, A extends Definition<C, Id>> = "identifiers" | "credentials" | "sessions" | "sessionFlows" | (Enabled<A, "password"> extends never ? never : "passwords" | "passwordAttempts" | "passwordScopes" | "passwordCharges" | "passwordCommands") | (ManagedPassword<A> extends never ? never : "passwordRegistrations") | (Enabled<A, "phone"> extends never ? never : "phoneState") | (Enabled<A, "email"> extends never ? never : "emailCredentials" | "emailCommands") | (Enabled<A, "passkey"> extends never ? never : "passkeyCredentials" | "passkeyOwnership" | "passkeyHandles" | "passkeyModules" | "passkeyFlows" | "passkeyAdmissions" | "passkeyCharges") | (ManagedPasskey<A> extends never ? never : "passkeyCommands") | (UsesProofs<A> extends never ? never : ProofRoles);
+interface SubjectOptions<T extends object, NativeId> {
+  readonly table: T;
+  readonly id: string;
+  readonly status: string;
+  readonly activeValue: unknown;
+  readonly securityRevision: string;
+  readonly idCodec: Schema.Codec<SubjectId, NativeId>;
+  readonly requirements: (row: Readonly<Record<string, unknown>>) => Effect.Effect<AuthenticationRequirement, PersistenceMappingError>;
+  /** Defaults to sign-in requirements. Recovery can have a distinct application policy. */
+  readonly actionRequirements?: (row: Readonly<Record<string, unknown>>, action: PasswordAction | EmailAction | PasskeyActionChallenge["action"]) => Effect.Effect<AuthenticationRequirement, PersistenceMappingError>;
+}
+/** Codecs at the application-owned subject and timestamp boundary. */
+interface SubjectMapping {
+  readonly table: object;
+  readonly id: string;
+  readonly status: string;
+  readonly securityRevision: string;
+  readonly activeValue: unknown;
+  readonly requirements: SubjectOptions<object, unknown>["requirements"];
+  readonly actionRequirements: NonNullable<SubjectOptions<object, unknown>["actionRequirements"]>;
+  readonly toSubject: (value: unknown) => Effect.Effect<SubjectId, PersistenceMappingError>;
+  readonly toNative: (value: SubjectId) => Effect.Effect<unknown, PersistenceMappingError>;
+  readonly toSubjectSync: (value: unknown) => SubjectId;
+  readonly toNativeSync: (value: SubjectId) => unknown;
+}
+interface MappingInput {
+  readonly tables: Partial<Record<StorageRole, object>>;
+  readonly subjects: SubjectMapping;
+  readonly encodeInstant: (millis: number) => unknown;
+  readonly decodeInstant: (value: unknown) => Effect.Effect<number, PersistenceMappingError>;
+  readonly decodeInstantSync: (value: unknown) => number;
+}
+interface StorageLayout<T extends object, Role extends StorageRole = StorageRole> extends MappingInput {
+  readonly namespace: string;
+  readonly schema: Readonly<Record<Role, T>>;
+}
+interface ConfigId<Id extends string> {
+  readonly authNamespace: Id;
+  readonly service: "PersistenceConfig";
+}
+interface TimestampOptions<Instant> {
+  readonly type: "text" | "integer";
+  readonly codec: Schema.Codec<number, Instant>;
+}
+interface BoundPersistence<T extends object, R, C extends ClaimsCodec, Id extends string, A extends Definition<C, Id>> {
+  readonly Config: Context.Service<ConfigId<A["namespace"]>, StorageLayout<T, Roles<C, Id, A>>> & {
+    readonly layer: (value: StorageLayout<T, Roles<C, Id, A>>) => Layer.Layer<ConfigId<A["namespace"]>>;
+  };
+  /** Create only the application subject. Runs inside the owning auth SQL transaction;
+   * use that SqlClient (including Drizzle over it), and return the new subject ID.
+   * Do not perform external side effects or open an independent transaction here.
+   */
+  readonly Provisioning: Context.Service<ProvisioningRequirement<A>, Provisioning<A>>;
+  readonly layer: Layer.Layer<Ports<C, Id, A>, PersistenceConfigurationError, ConfigId<A["namespace"]> | ProvisioningRequirement<A> | PasskeyRequirement$1<A> | SqlClient.SqlClient | R>;
+  readonly managed: <N, Instant = number>(options: {
+    readonly subjects: SubjectOptions<T, N>;
+    readonly tables?: Partial<Record<Roles<C, Id, A>, T>>;
+    readonly prefix?: string;
+    readonly timestamps?: TimestampOptions<Instant>;
+  }) => StorageLayout<T, Roles<C, Id, A>>;
+  readonly map: <N, Instant = number>(options: {
+    readonly subjects: SubjectOptions<T, N>;
+    readonly tables: Readonly<Record<Roles<C, Id, A>, T>>;
+    readonly timestamps?: TimestampOptions<Instant>;
+  }) => StorageLayout<T, Roles<C, Id, A>>;
+}
+/** Shared configuration shape. The backend chooses table types and service requirements. */
+interface PersistenceApi<T extends object, R = never> {
+  readonly make: <C extends ClaimsCodec, const Id extends string, const A extends Definition<C, Id>>(auth: A & Definition<C, Id>) => BoundPersistence<T, R, C, Id, A>;
+}
+//#endregion
+export { BoundPersistence, ClaimsCodec, ConfigId, Definition, MappingInput, PasskeyFeature, PasskeyRequirement$1 as PasskeyRequirement, PersistenceApi, PersistenceConfigurationError, Ports, Provisioning, ProvisioningId, ProvisioningRequirement, Roles, StorageLayout, Strategy, SubjectMapping, SubjectOptions, TimestampOptions };
+//# sourceMappingURL=configuration.d.mts.map

package/dist/internal/configuration.mjs

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+//#region src/internal/configuration.ts
+var PersistenceConfigurationError = class extends Schema.TaggedError()("PersistenceConfigurationError", { reason: Schema.String }) {};
+//#endregion
+export { PersistenceConfigurationError };
+
+//# sourceMappingURL=configuration.mjs.map

package/dist/internal/configuration.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"configuration.mjs","names":[],"sources":["../../src/internal/configuration.ts"],"sourcesContent":["import type { EmailAction, EmailAddressPersistence } from \"@yielded/auth/Email\";\nimport type { LoginIdentifier } from \"@yielded/auth/Identity\";\nimport type {\n  PasskeyActionChallenge,\n  PasskeyConfig,\n  PasskeyCredentials,\n  PasskeyEnrollmentContext,\n  PasskeyManagementPersistence,\n  PasskeyManagementPolicy,\n  PasskeyMethodPolicy,\n  PasskeyPersistence,\n  PasskeyConfigurationError,\n} from \"@yielded/auth/Passkey\";\nimport type {\n  PasswordAction,\n  PasswordPersistence,\n  PasswordUnavailable,\n} from \"@yielded/auth/Password\";\nimport type { PhoneAdmission, PhoneSignInTargets } from \"@yielded/auth/PhoneOtp\";\nimport type { ProofPersistence } from \"@yielded/auth/Proofs\";\nimport type { SubjectId } from \"@yielded/auth/Schema\";\nimport type {\n  AuthenticationAuthority,\n  AuthenticationRequirement,\n  make as makeSessions,\n} from \"@yielded/auth/Sessions\";\nimport { type Context, type Effect, type Layer, Schema } from \"effect\";\nimport type { SqlClient } from \"effect/unstable/sql\";\n\nimport type { PersistenceMappingError } from \"./mapping-error\";\nimport type { StorageRole } from \"./storage-tables\";\n\nexport class PersistenceConfigurationError extends Schema.TaggedError<PersistenceConfigurationError>()(\n  \"PersistenceConfigurationError\",\n  { reason: Schema.String },\n) {}\n\nexport type ClaimsCodec = Schema.Codec<unknown, unknown, never, never>;\n\nexport interface PasskeyFeature {\n  readonly kind: \"passkey\";\n  readonly moduleId: string;\n  readonly policy: Effect.Effect<PasskeyMethodPolicy, PasskeyConfigurationError, PasskeyConfig>;\n  readonly management?: boolean;\n  readonly managementPolicy?: PasskeyManagementPolicy;\n}\n\nexport interface Strategy {\n  readonly strategy: object;\n  readonly persistence?:\n    | PasskeyFeature\n    | {\n        readonly kind: \"password\" | \"phone\" | \"email\";\n        readonly moduleId: string;\n        readonly lifecycle?: boolean;\n        readonly management?: boolean;\n        readonly addresses?: boolean;\n      };\n  readonly RegistrationAuthority?: Context.Key<unknown, unknown>;\n}\n\nexport interface Definition<C extends ClaimsCodec, Id extends string> {\n  readonly namespace: string;\n  readonly claims: C;\n  readonly sessionMode?: string;\n  readonly sessions: ReturnType<typeof makeSessions<C, Id>>;\n  readonly strategies: Readonly<Record<string, Strategy>>;\n}\n\ntype KeyId<T> = T extends Context.Key<infer Id, infer _Service> ? Id : never;\ntype Enabled<\n  A extends { readonly strategies: Readonly<Record<string, Strategy>> },\n  Kind extends \"password\" | \"phone\" | \"email\" | \"passkey\",\n> = Extract<A[\"strategies\"][keyof A[\"strategies\"]], { persistence: { kind: Kind } }>;\n\ntype ManagedPassword<A extends { readonly strategies: Readonly<Record<string, Strategy>> }> =\n  Extract<Enabled<A, \"password\">, { persistence: { management: true } }>;\n\ntype ManagedPasskey<A extends { readonly strategies: Readonly<Record<string, Strategy>> }> =\n  Extract<Enabled<A, \"passkey\">, { persistence: { management: true } }>;\n\nexport type PasskeyRequirement<\n  A extends { readonly strategies: Readonly<Record<string, Strategy>> },\n> = Enabled<A, \"passkey\"> extends never ? never : PasskeyConfig;\n\ntype RegistrationKey<S> = S extends { readonly RegistrationAuthority: infer K } ? K : never;\ntype Registration<S> =\n  RegistrationKey<S> extends Context.Key<infer _Id, infer Service>\n    ? Service extends { readonly register: (input: infer Input, ...args: never[]) => unknown }\n      ? Input extends { readonly registration: infer Value }\n        ? Value\n        : never\n      : never\n    : never;\n\nexport interface ProvisioningId<Id extends string> {\n  readonly authNamespace: Id;\n  readonly service: \"PersistenceProvisioning\";\n}\n\nexport type Provisioning<A extends { readonly strategies: Readonly<Record<string, Strategy>> }> = {\n  readonly [\n    K in keyof A[\"strategies\"] as A[\"strategies\"][K] extends {\n      persistence: { kind: \"password\"; management: true };\n    }\n      ? K\n      : never\n  ]: (input: {\n    readonly identifier: LoginIdentifier;\n    readonly registration: Registration<A[\"strategies\"][K]>;\n  }) => Effect.Effect<SubjectId, PasswordUnavailable>;\n};\n\nexport type ProvisioningRequirement<\n  A extends { readonly namespace: string; readonly strategies: Readonly<Record<string, Strategy>> },\n> = ManagedPassword<A> extends never ? never : ProvisioningId<A[\"namespace\"]>;\n\ntype ProofRoles =\n  | \"proofRequests\"\n  | \"proofSeries\"\n  | \"proofGenerations\"\n  | \"proofContinuations\"\n  | \"proofScopes\"\n  | \"proofAbuse\"\n  | \"proofFailures\"\n  | \"proofCommands\";\n\ntype UsesProofs<A extends { readonly strategies: Readonly<Record<string, Strategy>> }> =\n  | Enabled<A, \"phone\">\n  | Enabled<A, \"email\">\n  | ManagedPassword<A>;\n\nexport type Ports<C extends ClaimsCodec, Id extends string, A extends Definition<C, Id>> =\n  | AuthenticationAuthority\n  | KeyId<A[\"sessions\"][\"StatefulSessionPersistence\"]>\n  | KeyId<A[\"sessions\"][\"SessionRepository\"]>\n  | (Enabled<A, \"password\"> extends never ? never : PasswordPersistence)\n  | KeyId<RegistrationKey<ManagedPassword<A>>>\n  | (Enabled<A, \"passkey\"> extends never ? never : PasskeyPersistence | PasskeyCredentials)\n  | (ManagedPasskey<A> extends never\n      ? never\n      : PasskeyManagementPersistence | PasskeyEnrollmentContext)\n  | (Enabled<A, \"email\"> extends never ? never : EmailAddressPersistence)\n  | (UsesProofs<A> extends never ? never : ProofPersistence)\n  | (Enabled<A, \"phone\"> extends never ? never : PhoneAdmission | PhoneSignInTargets);\n\nexport type Roles<C extends ClaimsCodec, Id extends string, A extends Definition<C, Id>> =\n  | \"identifiers\"\n  | \"credentials\"\n  | \"sessions\"\n  | \"sessionFlows\"\n  | (Enabled<A, \"password\"> extends never\n      ? never\n      :\n          | \"passwords\"\n          | \"passwordAttempts\"\n          | \"passwordScopes\"\n          | \"passwordCharges\"\n          | \"passwordCommands\")\n  | (ManagedPassword<A> extends never ? never : \"passwordRegistrations\")\n  | (Enabled<A, \"phone\"> extends never ? never : \"phoneState\")\n  | (Enabled<A, \"email\"> extends never ? never : \"emailCredentials\" | \"emailCommands\")\n  | (Enabled<A, \"passkey\"> extends never\n      ? never\n      :\n          | \"passkeyCredentials\"\n          | \"passkeyOwnership\"\n          | \"passkeyHandles\"\n          | \"passkeyModules\"\n          | \"passkeyFlows\"\n          | \"passkeyAdmissions\"\n          | \"passkeyCharges\")\n  | (ManagedPasskey<A> extends never ? never : \"passkeyCommands\")\n  | (UsesProofs<A> extends never ? never : ProofRoles);\n\nexport interface SubjectOptions<T extends object, NativeId> {\n  readonly table: T;\n  readonly id: string;\n  readonly status: string;\n  readonly activeValue: unknown;\n  readonly securityRevision: string;\n  readonly idCodec: Schema.Codec<SubjectId, NativeId>;\n  readonly requirements: (\n    row: Readonly<Record<string, unknown>>,\n  ) => Effect.Effect<AuthenticationRequirement, PersistenceMappingError>;\n  /** Defaults to sign-in requirements. Recovery can have a distinct application policy. */\n  readonly actionRequirements?: (\n    row: Readonly<Record<string, unknown>>,\n    action: PasswordAction | EmailAction | PasskeyActionChallenge[\"action\"],\n  ) => Effect.Effect<AuthenticationRequirement, PersistenceMappingError>;\n}\n\n/** Codecs at the application-owned subject and timestamp boundary. */\nexport interface SubjectMapping {\n  readonly table: object;\n  readonly id: string;\n  readonly status: string;\n  readonly securityRevision: string;\n  readonly activeValue: unknown;\n  readonly requirements: SubjectOptions<object, unknown>[\"requirements\"];\n  readonly actionRequirements: NonNullable<SubjectOptions<object, unknown>[\"actionRequirements\"]>;\n  readonly toSubject: (value: unknown) => Effect.Effect<SubjectId, PersistenceMappingError>;\n  readonly toNative: (value: SubjectId) => Effect.Effect<unknown, PersistenceMappingError>;\n  readonly toSubjectSync: (value: unknown) => SubjectId;\n  readonly toNativeSync: (value: SubjectId) => unknown;\n}\n\nexport interface MappingInput {\n  readonly tables: Partial<Record<StorageRole, object>>;\n  readonly subjects: SubjectMapping;\n  readonly encodeInstant: (millis: number) => unknown;\n  readonly decodeInstant: (value: unknown) => Effect.Effect<number, PersistenceMappingError>;\n  readonly decodeInstantSync: (value: unknown) => number;\n}\n\nexport interface StorageLayout<\n  T extends object,\n  Role extends StorageRole = StorageRole,\n> extends MappingInput {\n  readonly namespace: string;\n  readonly schema: Readonly<Record<Role, T>>;\n}\n\nexport interface ConfigId<Id extends string> {\n  readonly authNamespace: Id;\n  readonly service: \"PersistenceConfig\";\n}\n\nexport interface TimestampOptions<Instant> {\n  readonly type: \"text\" | \"integer\";\n  readonly codec: Schema.Codec<number, Instant>;\n}\n\nexport interface BoundPersistence<\n  T extends object,\n  R,\n  C extends ClaimsCodec,\n  Id extends string,\n  A extends Definition<C, Id>,\n> {\n  readonly Config: Context.Service<ConfigId<A[\"namespace\"]>, StorageLayout<T, Roles<C, Id, A>>> & {\n    readonly layer: (\n      value: StorageLayout<T, Roles<C, Id, A>>,\n    ) => Layer.Layer<ConfigId<A[\"namespace\"]>>;\n  };\n  /** Create only the application subject. Runs inside the owning auth SQL transaction;\n   * use that SqlClient (including Drizzle over it), and return the new subject ID.\n   * Do not perform external side effects or open an independent transaction here.\n   */\n  readonly Provisioning: Context.Service<ProvisioningRequirement<A>, Provisioning<A>>;\n  readonly layer: Layer.Layer<\n    Ports<C, Id, A>,\n    PersistenceConfigurationError,\n    | ConfigId<A[\"namespace\"]>\n    | ProvisioningRequirement<A>\n    | PasskeyRequirement<A>\n    | SqlClient.SqlClient\n    | R\n  >;\n  readonly managed: <N, Instant = number>(options: {\n    readonly subjects: SubjectOptions<T, N>;\n    readonly tables?: Partial<Record<Roles<C, Id, A>, T>>;\n    readonly prefix?: string;\n    readonly timestamps?: TimestampOptions<Instant>;\n  }) => StorageLayout<T, Roles<C, Id, A>>;\n  readonly map: <N, Instant = number>(options: {\n    readonly subjects: SubjectOptions<T, N>;\n    readonly tables: Readonly<Record<Roles<C, Id, A>, T>>;\n    readonly timestamps?: TimestampOptions<Instant>;\n  }) => StorageLayout<T, Roles<C, Id, A>>;\n}\n\n/** Shared configuration shape. The backend chooses table types and service requirements. */\nexport interface PersistenceApi<T extends object, R = never> {\n  readonly make: <\n    C extends ClaimsCodec,\n    const Id extends string,\n    const A extends Definition<C, Id>,\n  >(\n    auth: A & Definition<C, Id>,\n  ) => BoundPersistence<T, R, C, Id, A>;\n}\n"],"mappings":";;AAgCA,IAAa,gCAAb,cAAmD,OAAO,YAA2C,CAAC,CACpG,iCACA,EAAE,QAAQ,OAAO,OAAO,CAC1B,CAAC,CAAC,CAAC"}

package/dist/internal/drizzle-migrations.mjs

@@ -0,0 +1,19 @@
+import { PersistenceConfigurationError } from "./configuration.mjs";
+import { Effect, Layer } from "effect";
+//#region src/internal/drizzle-migrations.ts
+/** Run Drizzle Kit output through the matching Drizzle driver. Loading files and
+* acquiring the database are deferred until the Layer is built. Drizzle owns the
+* migration journal and transaction; failed migrations prevent auth startup.
+*/
+const drizzleMigrationsLayer = (acquire, migrator) => (options) => Layer.effectDiscard(Effect.gen(function* () {
+	const database = yield* acquire;
+	const migrate = yield* migrator;
+	yield* yield* Effect.try({
+		try: () => migrate(database, options),
+		catch: () => PersistenceConfigurationError.make({ reason: "Could not read Drizzle migrations; check the migration source and format" })
+	});
+}));
+//#endregion
+export { drizzleMigrationsLayer };
+
+//# sourceMappingURL=drizzle-migrations.mjs.map

package/dist/internal/drizzle-migrations.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"drizzle-migrations.mjs","names":[],"sources":["../../src/internal/drizzle-migrations.ts"],"sourcesContent":["import { Effect, Layer } from \"effect\";\n\nimport { PersistenceConfigurationError } from \"./configuration\";\n\n/** Run Drizzle Kit output through the matching Drizzle driver. Loading files and\n * acquiring the database are deferred until the Layer is built. Drizzle owns the\n * migration journal and transaction; failed migrations prevent auth startup.\n */\nexport const drizzleMigrationsLayer =\n  <Database, Options, E, R>(\n    acquire: Effect.Effect<Database, never, R>,\n    migrator: Effect.Effect<(database: Database, options: Options) => Effect.Effect<void, E>>,\n  ) =>\n  (options: Options) =>\n    Layer.effectDiscard(\n      Effect.gen(function* () {\n        const database = yield* acquire;\n        const migrate = yield* migrator;\n\n        const migration = yield* Effect.try({\n          try: () => migrate(database, options),\n          catch: () =>\n            PersistenceConfigurationError.make({\n              reason: \"Could not read Drizzle migrations; check the migration source and format\",\n            }),\n        });\n\n        yield* migration;\n      }),\n    );\n"],"mappings":";;;;;;;AAQA,MAAa,0BAET,SACA,cAED,YACC,MAAM,cACJ,OAAO,IAAI,aAAa;CACtB,MAAM,WAAW,OAAO;CACxB,MAAM,UAAU,OAAO;CAUvB,OAAO,OARkB,OAAO,IAAI;EAClC,WAAW,QAAQ,UAAU,OAAO;EACpC,aACE,8BAA8B,KAAK,EACjC,QAAQ,2EACV,CAAC;CACL,CAAC;AAGH,CAAC,CACH"}

package/dist/internal/drizzle-postgres.mjs

@@ -0,0 +1,39 @@
+import { PersistenceConfigurationError } from "./configuration.mjs";
+import { makeComposedPasskeys } from "./passkeys.mjs";
+import { createPersistence } from "./persistence.mjs";
+import { drizzleQueryOperations } from "../drizzle/query-operations.mjs";
+import { getTableColumns } from "drizzle-orm";
+import { bigint, boolean, getTableConfig, pgTable, text, uniqueIndex } from "drizzle-orm/pg-core";
+//#region src/internal/drizzle-postgres.ts
+const makeTable = (definition) => pgTable(definition.name, Object.fromEntries(Object.entries(definition.columns).map(([key, column]) => {
+	const builder = column.type === "text" ? text(column.name) : column.type === "boolean" ? boolean(column.name) : bigint(column.name, { mode: "number" });
+	return [key, column.nullable ? builder : builder.notNull()];
+})), (columns) => definition.unique.map((keys, i) => {
+	const [first, ...rest] = keys;
+	if (first === void 0) throw PersistenceConfigurationError.make({ reason: "An empty unique key is invalid" });
+	return uniqueIndex(`${definition.name}_key_${i}`).on(columns[first], ...rest.map((key) => columns[key]));
+}));
+const describe = (table) => {
+	const config = getTableConfig(table);
+	return {
+		name: config.name,
+		...config.schema === void 0 ? {} : { schema: config.schema },
+		columns: Object.fromEntries(Object.entries(getTableColumns(table)).map(([key, column]) => [key, {
+			name: column.name,
+			type: column.dataType === "boolean" ? "boolean" : column.dataType === "number" ? "integer" : "text",
+			nullable: !column.notNull
+		}])),
+		unique: []
+	};
+};
+const postgresPersistence = (acquire) => createPersistence({
+	makeTable,
+	describe,
+	operations: drizzleQueryOperations,
+	acquire,
+	passkeys: makeComposedPasskeys(drizzleQueryOperations)
+});
+//#endregion
+export { postgresPersistence };
+
+//# sourceMappingURL=drizzle-postgres.mjs.map

package/dist/internal/drizzle-postgres.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"drizzle-postgres.mjs","names":[],"sources":["../../src/internal/drizzle-postgres.ts"],"sourcesContent":["import { getTableColumns } from \"drizzle-orm\";\nimport {\n  getTableConfig,\n  bigint,\n  boolean,\n  pgTable,\n  text,\n  uniqueIndex,\n  type PgTable,\n} from \"drizzle-orm/pg-core\";\nimport type { Effect } from \"effect\";\nimport type { SqlClient } from \"effect/unstable/sql/SqlClient\";\n\nimport { drizzleQueryOperations } from \"../drizzle/query-operations\";\nimport { PersistenceConfigurationError } from \"./configuration\";\nimport { makeComposedPasskeys } from \"./passkeys\";\nimport { createPersistence } from \"./persistence\";\nimport type { StorageTable } from \"./storage-tables\";\n\nconst makeTable = (definition: StorageTable) =>\n  pgTable(\n    definition.name,\n    Object.fromEntries(\n      Object.entries(definition.columns).map(([key, column]) => {\n        const builder =\n          column.type === \"text\"\n            ? text(column.name)\n            : column.type === \"boolean\"\n              ? boolean(column.name)\n              : bigint(column.name, { mode: \"number\" });\n\n        return [key, column.nullable ? builder : builder.notNull()];\n      }),\n    ),\n    (columns) =>\n      definition.unique.map((keys, i) => {\n        const [first, ...rest] = keys;\n\n        if (first === undefined)\n          throw PersistenceConfigurationError.make({ reason: \"An empty unique key is invalid\" });\n\n        return uniqueIndex(`${definition.name}_key_${i}`).on(\n          columns[first],\n          ...rest.map((key) => columns[key]),\n        );\n      }),\n  );\n\nconst describe = (table: PgTable): StorageTable => {\n  const config = getTableConfig(table);\n\n  return {\n    name: config.name,\n    ...(config.schema === undefined ? {} : { schema: config.schema }),\n    columns: Object.fromEntries(\n      Object.entries(getTableColumns(table)).map(([key, column]) => [\n        key,\n        {\n          name: column.name,\n          type:\n            column.dataType === \"boolean\"\n              ? \"boolean\"\n              : column.dataType === \"number\"\n                ? \"integer\"\n                : \"text\",\n          nullable: !column.notNull,\n        },\n      ]),\n    ),\n    unique: [],\n  };\n};\n\nexport const postgresPersistence = <R>(acquire: Effect.Effect<object, never, R | SqlClient>) =>\n  createPersistence<PgTable, R>({\n    makeTable,\n    describe,\n    operations: drizzleQueryOperations,\n    acquire,\n    passkeys: makeComposedPasskeys(drizzleQueryOperations),\n  });\n"],"mappings":";;;;;;;AAmBA,MAAM,aAAa,eACjB,QACE,WAAW,MACX,OAAO,YACL,OAAO,QAAQ,WAAW,OAAO,CAAC,CAAC,KAAK,CAAC,KAAK,YAAY;CACxD,MAAM,UACJ,OAAO,SAAS,SACZ,KAAK,OAAO,IAAI,IAChB,OAAO,SAAS,YACd,QAAQ,OAAO,IAAI,IACnB,OAAO,OAAO,MAAM,EAAE,MAAM,SAAS,CAAC;CAE9C,OAAO,CAAC,KAAK,OAAO,WAAW,UAAU,QAAQ,QAAQ,CAAC;AAC5D,CAAC,CACH,IACC,YACC,WAAW,OAAO,KAAK,MAAM,MAAM;CACjC,MAAM,CAAC,OAAO,GAAG,QAAQ;CAEzB,IAAI,UAAU,KAAA,GACZ,MAAM,8BAA8B,KAAK,EAAE,QAAQ,iCAAiC,CAAC;CAEvF,OAAO,YAAY,GAAG,WAAW,KAAK,OAAO,GAAG,CAAC,CAAC,GAChD,QAAQ,QACR,GAAG,KAAK,KAAK,QAAQ,QAAQ,IAAI,CACnC;AACF,CAAC,CACL;AAEF,MAAM,YAAY,UAAiC;CACjD,MAAM,SAAS,eAAe,KAAK;CAEnC,OAAO;EACL,MAAM,OAAO;EACb,GAAI,OAAO,WAAW,KAAA,IAAY,CAAC,IAAI,EAAE,QAAQ,OAAO,OAAO;EAC/D,SAAS,OAAO,YACd,OAAO,QAAQ,gBAAgB,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,YAAY,CAC5D,KACA;GACE,MAAM,OAAO;GACb,MACE,OAAO,aAAa,YAChB,YACA,OAAO,aAAa,WAClB,YACA;GACR,UAAU,CAAC,OAAO;EACpB,CACF,CAAC,CACH;EACA,QAAQ,CAAC;CACX;AACF;AAEA,MAAa,uBAA0B,YACrC,kBAA8B;CAC5B;CACA;CACA,YAAY;CACZ;CACA,UAAU,qBAAqB,sBAAsB;AACvD,CAAC"}

package/dist/internal/drizzle-sqlite.mjs

@@ -0,0 +1,37 @@
+import { PersistenceConfigurationError } from "./configuration.mjs";
+import { makeComposedPasskeys } from "./passkeys.mjs";
+import { createPersistence } from "./persistence.mjs";
+import { drizzleQueryOperations } from "../drizzle/query-operations.mjs";
+import { getTableColumns } from "drizzle-orm";
+import { getTableConfig, integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+//#region src/internal/drizzle-sqlite.ts
+const makeTable = (definition) => sqliteTable(definition.name, Object.fromEntries(Object.entries(definition.columns).map(([key, column]) => {
+	const builder = column.type === "text" ? text(column.name) : column.type === "boolean" ? integer(column.name, { mode: "boolean" }) : integer(column.name);
+	return [key, column.nullable ? builder : builder.notNull()];
+})), (columns) => definition.unique.map((keys, i) => {
+	const [first, ...rest] = keys;
+	if (first === void 0) throw PersistenceConfigurationError.make({ reason: "An empty unique key is invalid" });
+	return uniqueIndex(`${definition.name}_key_${i}`).on(columns[first], ...rest.map((key) => columns[key]));
+}));
+const describe = (table) => {
+	return {
+		name: getTableConfig(table).name,
+		columns: Object.fromEntries(Object.entries(getTableColumns(table)).map(([key, column]) => [key, {
+			name: column.name,
+			type: column.dataType === "boolean" ? "boolean" : column.dataType === "number" ? "integer" : "text",
+			nullable: !column.notNull
+		}])),
+		unique: []
+	};
+};
+const sqlitePersistence = (acquire) => createPersistence({
+	makeTable,
+	describe,
+	operations: drizzleQueryOperations,
+	acquire,
+	passkeys: makeComposedPasskeys(drizzleQueryOperations)
+});
+//#endregion
+export { sqlitePersistence };
+
+//# sourceMappingURL=drizzle-sqlite.mjs.map

package/dist/internal/drizzle-sqlite.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"drizzle-sqlite.mjs","names":[],"sources":["../../src/internal/drizzle-sqlite.ts"],"sourcesContent":["import { getTableColumns } from \"drizzle-orm\";\nimport {\n  getTableConfig,\n  integer,\n  sqliteTable,\n  text,\n  uniqueIndex,\n  type SQLiteTable,\n} from \"drizzle-orm/sqlite-core\";\nimport type { Effect } from \"effect\";\nimport type { SqlClient } from \"effect/unstable/sql/SqlClient\";\n\nimport { drizzleQueryOperations } from \"../drizzle/query-operations\";\nimport { PersistenceConfigurationError } from \"./configuration\";\nimport { makeComposedPasskeys } from \"./passkeys\";\nimport { createPersistence } from \"./persistence\";\nimport type { StorageTable } from \"./storage-tables\";\n\nconst makeTable = (definition: StorageTable) =>\n  sqliteTable(\n    definition.name,\n    Object.fromEntries(\n      Object.entries(definition.columns).map(([key, column]) => {\n        const builder =\n          column.type === \"text\"\n            ? text(column.name)\n            : column.type === \"boolean\"\n              ? integer(column.name, { mode: \"boolean\" })\n              : integer(column.name);\n\n        return [key, column.nullable ? builder : builder.notNull()];\n      }),\n    ),\n    (columns) =>\n      definition.unique.map((keys, i) => {\n        const [first, ...rest] = keys;\n\n        if (first === undefined)\n          throw PersistenceConfigurationError.make({ reason: \"An empty unique key is invalid\" });\n\n        return uniqueIndex(`${definition.name}_key_${i}`).on(\n          columns[first],\n          ...rest.map((key) => columns[key]),\n        );\n      }),\n  );\n\nconst describe = (table: SQLiteTable): StorageTable => {\n  const config = getTableConfig(table);\n\n  return {\n    name: config.name,\n    columns: Object.fromEntries(\n      Object.entries(getTableColumns(table)).map(([key, column]) => [\n        key,\n        {\n          name: column.name,\n          type:\n            column.dataType === \"boolean\"\n              ? \"boolean\"\n              : column.dataType === \"number\"\n                ? \"integer\"\n                : \"text\",\n          nullable: !column.notNull,\n        },\n      ]),\n    ),\n    unique: [],\n  };\n};\n\nexport const sqlitePersistence = <R>(acquire: Effect.Effect<object, never, R | SqlClient>) =>\n  createPersistence<SQLiteTable, R>({\n    makeTable,\n    describe,\n    operations: drizzleQueryOperations,\n    acquire,\n    passkeys: makeComposedPasskeys(drizzleQueryOperations),\n  });\n"],"mappings":";;;;;;;AAkBA,MAAM,aAAa,eACjB,YACE,WAAW,MACX,OAAO,YACL,OAAO,QAAQ,WAAW,OAAO,CAAC,CAAC,KAAK,CAAC,KAAK,YAAY;CACxD,MAAM,UACJ,OAAO,SAAS,SACZ,KAAK,OAAO,IAAI,IAChB,OAAO,SAAS,YACd,QAAQ,OAAO,MAAM,EAAE,MAAM,UAAU,CAAC,IACxC,QAAQ,OAAO,IAAI;CAE3B,OAAO,CAAC,KAAK,OAAO,WAAW,UAAU,QAAQ,QAAQ,CAAC;AAC5D,CAAC,CACH,IACC,YACC,WAAW,OAAO,KAAK,MAAM,MAAM;CACjC,MAAM,CAAC,OAAO,GAAG,QAAQ;CAEzB,IAAI,UAAU,KAAA,GACZ,MAAM,8BAA8B,KAAK,EAAE,QAAQ,iCAAiC,CAAC;CAEvF,OAAO,YAAY,GAAG,WAAW,KAAK,OAAO,GAAG,CAAC,CAAC,GAChD,QAAQ,QACR,GAAG,KAAK,KAAK,QAAQ,QAAQ,IAAI,CACnC;AACF,CAAC,CACL;AAEF,MAAM,YAAY,UAAqC;CAGrD,OAAO;EACL,MAHa,eAAe,KAGjB,CAAC,CAAC;EACb,SAAS,OAAO,YACd,OAAO,QAAQ,gBAAgB,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,YAAY,CAC5D,KACA;GACE,MAAM,OAAO;GACb,MACE,OAAO,aAAa,YAChB,YACA,OAAO,aAAa,WAClB,YACA;GACR,UAAU,CAAC,OAAO;EACpB,CACF,CAAC,CACH;EACA,QAAQ,CAAC;CACX;AACF;AAEA,MAAa,qBAAwB,YACnC,kBAAkC;CAChC;CACA;CACA,YAAY;CACZ;CACA,UAAU,qBAAqB,sBAAsB;AACvD,CAAC"}

package/dist/internal/email-kernel.d.mts

@@ -0,0 +1,13 @@
+import "./mapping-error.mjs";
+import "../drizzle/email-model.mjs";
+import "./query-operations.mjs";
+import "./proof-kernel.mjs";
+import { Context, DateTime, Effect, Option } from "effect";
+import { LifecycleHooks, PreparedCommit } from "@yielded/auth/Hooks";
+import { AuthenticationRevision, SecurityRevision } from "@yielded/auth/Sessions";
+import { EmailCredentialSnapshot, EmailUnavailable } from "@yielded/auth/Email";
+import { ProofCompletionInput } from "@yielded/auth/Proofs";
+import { LoginIdentifier } from "@yielded/auth/Identity";
+import { sql } from "drizzle-orm";
+import "effect/unstable/sql/SqlError";
+import "drizzle-orm/effect-core";