@yielded/auth-persistence 0.1.0-beta.24 → 0.1.0-beta.26

package/src/OAuthPersistence.ts

@@ -1,6 +1,5 @@
-/** Direct Effect SQL persistence for upstream OAuth accounts. PostgreSQL and SQLite
- * require interactive transactions; provider exchanges occur outside coordinators. */
-import type { LifecycleHooks } from "@yielded/auth/Hooks";
+/** Direct PostgreSQL and SQLite owners for upstream OAuth. Provider exchange stays outside these transactions. */
+import { hasCommitScope, type LifecycleHooks } from "@yielded/auth/Hooks";
 import {
   OAuthAccountsPersistence,
   OAuthSignInPersistence,
@@ -9,105 +8,111 @@ import {
   OAuthConnectedRevocations,
   OAuthUnavailable,
 } from "@yielded/auth/OAuth";
-import type { AuthenticationAuthority } from "@yielded/auth/Sessions";
-import { SessionUnavailable } from "@yielded/auth/Sessions";
 import { type Context, type Crypto, Effect, Predicate, Schema } from "effect";
 import { SqlClient } from "effect/sql";
 
 import { PersistenceConfigurationError } from "./internal/configuration";
-import type { AuthenticationAuthorityMapping as AuthorityMapping } from "./internal/models/session-model";
 import { makeNativeSqlTables } from "./internal/native-sql-table";
-import { makeOAuthKernel } from "./internal/oauth-kernel";
-import type { OAuthCoordinatorError, OAuthTargetConfiguration } from "./internal/oauth/target";
 import {
-  CurrentSessionSql,
-  makeSessionKernel,
-  type SessionSqlDatabase,
-} from "./internal/session-kernel";
+  makeNativeOAuthAccountsServices,
+  type OAuthNativeAccountsMapping,
+} from "./internal/oauth/native-accounts";
+import { makeNativeOAuthConnectedServices } from "./internal/oauth/native-connected";
+import type { OAuthNativeConnectedMapping } from "./internal/oauth/native-connected-state";
+import {
+  makeNativeOAuthRegistrationIntentServices,
+  makeNativeOAuthRegistrationServices,
+  type OAuthNativeRegistrationIntentMapping,
+  type OAuthNativeRegistrationMapping,
+} from "./internal/oauth/native-registration";
+import {
+  makeNativeOAuthRevocationServices,
+  type OAuthNativeRevocationMapping,
+} from "./internal/oauth/native-revocations";
+import { makeNativeOAuthSignInServices } from "./internal/oauth/native-sign-in";
+import { type OAuthNativeReadMapping } from "./internal/oauth/native-state";
+import { captureOAuthMapping } from "./internal/oauth/state";
+import { makeSqlCommitExecutor } from "./internal/sql-commit";
+import { sql, SqlExpression } from "./internal/sql-expression";
 import type {
   OAuthConnectedMapping,
   OAuthConnectedRevocationMapping,
 } from "./internal/sql-oauth-connected-model";
 import type {
-  SqlTableModel,
   OAuthAccountsMapping,
   OAuthSignInMapping,
   OAuthRegistrationIntentMapping,
   OAuthRegistrationMapping,
   OAuthRegistrationAuthority,
-  OAuthReferenceGuardDescriptor,
 } from "./internal/sql-oauth-model";
-import { makeSqlDatabase, sqlQueryOperations, sql } from "./internal/sql-query";
 import { validateSqlStorage } from "./internal/sql-storage-validation";
-import { Table, Fragment } from "./internal/sql-table";
+import { Table } from "./internal/sql-table";
 import { requireStandalone } from "./internal/standalone";
 import type { StorageTable } from "./internal/storage-tables";
-import { NativeDatabase } from "./internal/transaction-kernel";
-import type { TransactionNativeDatabase } from "./internal/transaction-kernel";
 export * from "./internal/sql-oauth-model";
 export * from "./internal/sql-oauth-connected-model";
-export { sql };
-export { and, eq } from "./internal/sql-query";
+export * from "./internal/oauth/native-layers";
+export { sql, and, eq } from "./internal/sql-expression";
+export { makeAuthenticationAuthorityServices } from "./internal/sql-authority";
 
-/** Physical identifiers and representations only; applications own migrations. */
 export const table = (definition: StorageTable) =>
   new Table(definition.name, definition.columns, definition.unique, definition.schema);
 
-/** Integer-millisecond engine clock, sampled after locks on either supported dialect. */
 export const clock = {
   encodeInstant: Schema.encodeSync(Schema.Int),
   decodeInstant: Schema.decodeUnknownSync(Schema.Int),
-  engineNowMillis: new Fragment((compiler) =>
-    compiler.dialect === "pg"
-      ? "cast(extract(epoch from clock_timestamp()) * 1000 as bigint)"
-      : "cast(round((julianday('now') - 2440587.5) * 86400000) as integer)",
+  engineNowMillis: new SqlExpression((client) =>
+    client.onDialectOrElse({
+      pg: () => client`cast(extract(epoch from clock_timestamp()) * 1000 as bigint)`,
+      orElse: () => client`cast(round((julianday('now') - 2440587.5) * 86400000) as integer)`,
+    }),
   ),
-};
-
-const operations = { ...sqlQueryOperations, validateStorage: validateSqlStorage };
-
-const kernels = {
-  pg: makeOAuthKernel(operations, () => "pg"),
-  sqlite: makeOAuthKernel(operations, () => "sqlite"),
+  toMillis: (expression: SqlExpression) => expression,
+  fromMillis: (expression: SqlExpression) => expression,
 };
 
 const acquire = Effect.gen(function* () {
   const client = yield* SqlClient.SqlClient;
 
-  const dialect = client.onDialectOrElse({
-    pg: () => "pg" as const,
-    sqlite: () => "sqlite" as const,
-    orElse: () => undefined,
-  });
-
-  // D1 exposes the SQLite compiler but its public driver brand identifies a
-  // batch-only client. Keep the default package free of a D1 runtime dependency.
-  if (dialect === undefined || Predicate.hasProperty(client, "~@effect/sql-d1/D1Client"))
+  if (
+    !client.onDialectOrElse({ pg: () => true, sqlite: () => true, orElse: () => false }) ||
+    Predicate.hasProperty(client, "~@effect/sql-d1/D1Client")
+  )
     return yield* PersistenceConfigurationError.make({
       reason: "OAuth persistence requires PostgreSQL or SQLite with interactive transactions",
     });
 
-  const database = yield* makeSqlDatabase(dialect);
+  return { client, tables: makeNativeSqlTables(client) };
+});
 
-  const configuration: OAuthTargetConfiguration = {
-    mode: "interactive",
-    dialect,
-    locking: dialect === "pg",
-    standaloneGuard: (service) => requireStandalone(() => OAuthUnavailable.make({}), service),
-  };
+const using = <M, A, E, R>(
+  original: M,
+  make: (tables: ReturnType<typeof makeNativeSqlTables>, mapping: M) => Effect.Effect<A, E, R>,
+) =>
+  Effect.gen(function* () {
+    const target = yield* acquire;
+    const mapping = captureOAuthMapping(original);
 
-  // Erase only the query-builder handle; batch methods are never selected by this adapter.
-  return {
-    database: database as unknown as TransactionNativeDatabase,
-    configuration,
-    kernel: kernels[dialect],
-  };
-});
+    yield* validateSqlStorage(mapping).pipe(Effect.mapError(() => OAuthUnavailable.make({})));
 
-const using = <A, E, R>(body: (input: Effect.Success<typeof acquire>) => Effect.Effect<A, E, R>) =>
-  Effect.flatMap(acquire, (input) =>
-    body(input).pipe(Effect.provideService(NativeDatabase, input.database)),
-  );
+    return yield* make(target.tables, mapping);
+  });
+
+const coordinate = <S, A, E, R, ES, RS>(
+  make: Effect.Effect<S, ES, RS>,
+  body: (services: S) => Effect.Effect<A, E, R>,
+) =>
+  Effect.gen(function* () {
+    const { client } = yield* acquire;
+
+    if (yield* hasCommitScope) return yield* OAuthUnavailable.make({});
+    yield* requireStandalone(() => OAuthUnavailable.make({}), client.transactionService);
+    const executor = yield* makeSqlCommitExecutor(() => OAuthUnavailable.make({}));
+
+    return yield* executor.coordinate(
+      Effect.flatMap(make.pipe(Effect.mapError(() => OAuthUnavailable.make({}))), body),
+    );
+  });
 
 export const makeOAuthSignInServices = <N>(
   mapping: OAuthSignInMapping<Table, Table, Table, Table, Table, N>,
@@ -116,220 +121,129 @@ export const makeOAuthSignInServices = <N>(
   OAuthUnavailable | PersistenceConfigurationError,
   Crypto.Crypto | LifecycleHooks | SqlClient.SqlClient
 > =>
-  using(({ kernel, configuration }) =>
-    kernel.target.makeTargetOAuthSignInServices(mapping, configuration),
+  using(mapping, (tables, value) =>
+    makeNativeOAuthSignInServices(tables, value as unknown as OAuthNativeReadMapping),
   );
 
-/** Run auth and application SQL in one adapter-owned transaction and commit journal. */
 export const coordinateOAuthSignIn = <N, A, E, R>(
   options: { readonly mapping: OAuthSignInMapping<Table, Table, Table, Table, Table, N> },
   body: Effect.Effect<A, E, R>,
 ): Effect.Effect<
   A,
-  OAuthCoordinatorError<E> | PersistenceConfigurationError,
+  E | OAuthUnavailable | PersistenceConfigurationError,
   Exclude<R, OAuthSignInPersistence> | Crypto.Crypto | LifecycleHooks | SqlClient.SqlClient
 > =>
-  using(({ kernel, configuration, database }) =>
-    kernel.target.coordinateTargetOAuthSignIn(
-      database,
-      options.mapping,
-      configuration,
-      (_transaction, services) =>
-        Effect.provideService(body, OAuthSignInPersistence, services.oauthSignInPersistence),
-    ),
+  coordinate(makeOAuthSignInServices(options.mapping), (services) =>
+    Effect.provideService(body, OAuthSignInPersistence, services.oauthSignInPersistence),
   );
 
-export const makeOAuthRegistrationIntentServices = <N>(
-  mapping: OAuthRegistrationIntentMapping<Table, Table, Table, Table, Table, Table, Table, N>,
+export const makeOAuthAccountsServices = <N>(
+  mapping: OAuthAccountsMapping<Table, Table, Table, Table, Table, N>,
 ): Effect.Effect<
-  { readonly oauthRegistrationIntents: OAuthRegistrationIntents["Service"] },
+  { readonly oauthAccountsPersistence: OAuthAccountsPersistence["Service"] },
   OAuthUnavailable | PersistenceConfigurationError,
   Crypto.Crypto | LifecycleHooks | SqlClient.SqlClient
 > =>
-  using(({ kernel, configuration }) =>
-    kernel.target.makeTargetOAuthRegistrationIntentServices(mapping, configuration),
+  using(mapping, (tables, value) =>
+    makeNativeOAuthAccountsServices(tables, value as unknown as OAuthNativeAccountsMapping),
   );
 
-/** Run auth and application SQL in one adapter-owned transaction and commit journal. */
-export const coordinateOAuthRegistrationIntents = <N, A, E, R>(
-  options: {
-    readonly mapping: OAuthRegistrationIntentMapping<
-      Table,
-      Table,
-      Table,
-      Table,
-      Table,
-      Table,
-      Table,
-      N
-    >;
-  },
+export const coordinateOAuthAccounts = <N, A, E, R>(
+  options: { readonly mapping: OAuthAccountsMapping<Table, Table, Table, Table, Table, N> },
   body: Effect.Effect<A, E, R>,
 ): Effect.Effect<
   A,
-  OAuthCoordinatorError<E> | PersistenceConfigurationError,
-  Exclude<R, OAuthRegistrationIntents> | Crypto.Crypto | LifecycleHooks | SqlClient.SqlClient
+  E | OAuthUnavailable | PersistenceConfigurationError,
+  Exclude<R, OAuthAccountsPersistence> | Crypto.Crypto | LifecycleHooks | SqlClient.SqlClient
 > =>
-  using(({ kernel, configuration, database }) =>
-    kernel.target.coordinateTargetOAuthRegistrationIntents(
-      database,
-      options.mapping,
-      configuration,
-      (_transaction, services) =>
-        Effect.provideService(body, OAuthRegistrationIntents, services.oauthRegistrationIntents),
-    ),
+  coordinate(makeOAuthAccountsServices(options.mapping), (services) =>
+    Effect.provideService(body, OAuthAccountsPersistence, services.oauthAccountsPersistence),
   );
 
-export const makeOAuthAccountsServices = <N>(
-  mapping: OAuthAccountsMapping<Table, Table, Table, Table, Table, Table, Table, N>,
+export const makeOAuthRegistrationIntentServices = <N>(
+  mapping: OAuthRegistrationIntentMapping<Table, Table, N>,
 ): Effect.Effect<
-  { readonly oauthAccountsPersistence: OAuthAccountsPersistence["Service"] },
+  { readonly oauthRegistrationIntents: OAuthRegistrationIntents["Service"] },
   OAuthUnavailable | PersistenceConfigurationError,
   Crypto.Crypto | LifecycleHooks | SqlClient.SqlClient
 > =>
-  using(({ kernel, configuration }) =>
-    kernel.target.makeTargetOAuthAccountsServices(mapping, configuration),
+  using(mapping, (tables, value) =>
+    makeNativeOAuthRegistrationIntentServices(
+      tables,
+      value as unknown as OAuthNativeRegistrationIntentMapping,
+    ),
   );
 
-/** Run auth and application SQL in one adapter-owned transaction and commit journal. */
-export const coordinateOAuthAccounts = <N, A, E, R>(
-  options: {
-    readonly mapping: OAuthAccountsMapping<Table, Table, Table, Table, Table, Table, Table, N>;
-  },
+export const coordinateOAuthRegistrationIntents = <N, A, E, R>(
+  options: { readonly mapping: OAuthRegistrationIntentMapping<Table, Table, N> },
   body: Effect.Effect<A, E, R>,
 ): Effect.Effect<
   A,
-  OAuthCoordinatorError<E> | PersistenceConfigurationError,
-  Exclude<R, OAuthAccountsPersistence> | Crypto.Crypto | LifecycleHooks | SqlClient.SqlClient
+  E | OAuthUnavailable | PersistenceConfigurationError,
+  Exclude<R, OAuthRegistrationIntents> | Crypto.Crypto | LifecycleHooks | SqlClient.SqlClient
 > =>
-  using(({ kernel, configuration, database }) =>
-    kernel.target.coordinateTargetOAuthAccounts(
-      database,
-      options.mapping,
-      configuration,
-      (_transaction, services) =>
-        Effect.provideService(body, OAuthAccountsPersistence, services.oauthAccountsPersistence),
-    ),
+  coordinate(makeOAuthRegistrationIntentServices(options.mapping), (services) =>
+    Effect.provideService(body, OAuthRegistrationIntents, services.oauthRegistrationIntents),
   );
 
 export const makeOAuthConnectedServices = <N>(
-  mapping: OAuthConnectedMapping<
-    Table,
-    Table,
-    Table,
-    Table,
-    Table,
-    Table,
-    Table,
-    Table,
-    Table,
-    Table,
-    N,
-    Table
-  >,
+  mapping: OAuthConnectedMapping<Table, Table, Table, Table, Table, N, Table>,
 ): Effect.Effect<
   { readonly oauthConnectedPersistence: OAuthConnectedPersistence["Service"] },
   OAuthUnavailable | PersistenceConfigurationError,
   Crypto.Crypto | LifecycleHooks | SqlClient.SqlClient
 > =>
-  using(({ kernel, configuration }) =>
-    kernel.connectedTarget.makeTargetOAuthConnectedServices(mapping, configuration),
+  using(mapping, (tables, value) =>
+    makeNativeOAuthConnectedServices(tables, value as unknown as OAuthNativeConnectedMapping),
   );
 
-/** Run auth and application SQL in one adapter-owned transaction and commit journal. */
 export const coordinateOAuthConnected = <N, A, E, R>(
-  options: {
-    readonly mapping: OAuthConnectedMapping<
-      Table,
-      Table,
-      Table,
-      Table,
-      Table,
-      Table,
-      Table,
-      Table,
-      Table,
-      Table,
-      N,
-      Table
-    >;
-  },
+  options: { readonly mapping: OAuthConnectedMapping<Table, Table, Table, Table, Table, N, Table> },
   body: Effect.Effect<A, E, R>,
 ): Effect.Effect<
   A,
-  OAuthCoordinatorError<E> | PersistenceConfigurationError,
+  E | OAuthUnavailable | PersistenceConfigurationError,
   Exclude<R, OAuthConnectedPersistence> | Crypto.Crypto | LifecycleHooks | SqlClient.SqlClient
 > =>
-  using(({ kernel, configuration, database }) =>
-    kernel.connectedTarget.coordinateTargetOAuthConnected(
-      database,
-      options.mapping,
-      configuration,
-      (_transaction, services) =>
-        Effect.provideService(body, OAuthConnectedPersistence, services.oauthConnectedPersistence),
-    ),
+  coordinate(makeOAuthConnectedServices(options.mapping), (services) =>
+    Effect.provideService(body, OAuthConnectedPersistence, services.oauthConnectedPersistence),
   );
 
 export const makeOAuthConnectedRevocationServices = <N>(
-  mapping: OAuthConnectedRevocationMapping<Table, Table, Table, Table, Table, Table, Table, N>,
+  mapping: OAuthConnectedRevocationMapping<Table, Table, Table, N>,
 ): Effect.Effect<
   { readonly oauthConnectedRevocations: OAuthConnectedRevocations["Service"] },
   OAuthUnavailable | PersistenceConfigurationError,
   Crypto.Crypto | LifecycleHooks | SqlClient.SqlClient
 > =>
-  using(({ kernel, configuration }) =>
-    kernel.connectedTarget.makeTargetOAuthConnectedRevocationServices(mapping, configuration),
+  using(mapping, (tables, value) =>
+    makeNativeOAuthRevocationServices(tables, value as unknown as OAuthNativeRevocationMapping),
   );
 
-/** Run auth and application SQL in one adapter-owned transaction and commit journal. */
 export const coordinateOAuthConnectedRevocations = <N, A, E, R>(
-  options: {
-    readonly mapping: OAuthConnectedRevocationMapping<
-      Table,
-      Table,
-      Table,
-      Table,
-      Table,
-      Table,
-      Table,
-      N
-    >;
-  },
+  options: { readonly mapping: OAuthConnectedRevocationMapping<Table, Table, Table, N> },
   body: Effect.Effect<A, E, R>,
 ): Effect.Effect<
   A,
-  OAuthCoordinatorError<E> | PersistenceConfigurationError,
+  E | OAuthUnavailable | PersistenceConfigurationError,
   Exclude<R, OAuthConnectedRevocations> | Crypto.Crypto | LifecycleHooks | SqlClient.SqlClient
 > =>
-  using(({ kernel, configuration, database }) =>
-    kernel.connectedTarget.coordinateTargetOAuthConnectedRevocations(
-      database,
-      options.mapping,
-      configuration,
-      (_transaction, services) =>
-        Effect.provideService(body, OAuthConnectedRevocations, services.oauthConnectedRevocations),
-    ),
+  coordinate(makeOAuthConnectedRevocationServices(options.mapping), (services) =>
+    Effect.provideService(body, OAuthConnectedRevocations, services.oauthConnectedRevocations),
   );
 
 export const makeOAuthRegistrationServices = <Registration, N>(
-  mapping: OAuthRegistrationMapping<
-    Registration,
-    Table,
-    Table,
-    Table,
-    Table,
-    Table,
-    Table,
-    Table,
-    N
-  >,
+  mapping: OAuthRegistrationMapping<Registration, Table, Table, Table, Table, Table, N>,
 ): Effect.Effect<
   { readonly registrationAuthority: OAuthRegistrationAuthority<Registration> },
   OAuthUnavailable | PersistenceConfigurationError,
   Crypto.Crypto | LifecycleHooks | SqlClient.SqlClient
 > =>
-  using(({ kernel, configuration }) =>
-    kernel.target.makeTargetOAuthRegistrationServices<Registration>(mapping, configuration),
+  using(mapping, (tables, value) =>
+    makeNativeOAuthRegistrationServices(
+      tables,
+      value as unknown as OAuthNativeRegistrationMapping<Registration>,
+    ),
   );
 
 export const coordinateOAuthRegistration = <Id, Registration, N, A, E, R>(
@@ -341,8 +255,6 @@ export const coordinateOAuthRegistration = <Id, Registration, N, A, E, R>(
       Table,
       Table,
       Table,
-      Table,
-      Table,
       N
     >;
     readonly target: Context.Key<Id, OAuthRegistrationAuthority<Registration>>;
@@ -350,78 +262,23 @@ export const coordinateOAuthRegistration = <Id, Registration, N, A, E, R>(
   body: Effect.Effect<A, E, R>,
 ): Effect.Effect<
   A,
-  OAuthCoordinatorError<E> | PersistenceConfigurationError,
+  E | OAuthUnavailable | PersistenceConfigurationError,
   Exclude<R, Id> | Crypto.Crypto | LifecycleHooks | SqlClient.SqlClient
 > =>
-  using(({ kernel, configuration, database }) =>
-    kernel.target.coordinateTargetOAuthRegistration<Registration, unknown, A, E, Exclude<R, Id>>(
-      database,
-      options.mapping,
-      configuration,
-      (_transaction, services) =>
-        Effect.provideService(body, options.target, services.registrationAuthority),
-    ),
+  coordinate(makeOAuthRegistrationServices(options.mapping), (services) =>
+    Effect.provideService(body, options.target, services.registrationAuthority),
   );
 
-/** Include these guards when login ownership may also hold retained grants. */
 export const oauthConnectedOwnershipReferences = <N>(
-  mapping: OAuthConnectedMapping<
-    Table,
-    Table,
-    Table,
-    Table,
-    Table,
-    Table,
-    Table,
-    Table,
-    Table,
-    Table,
-    N,
-    Table
-  >,
-  dialect: "pg" | "sqlite",
-) =>
-  // The selected compiler supplies Fragment handles; domain values retain their codecs.
-  kernels[dialect].connectedReference.oauthConnectedOwnershipReferences(mapping) as {
-    readonly connectedReferenceGuards: ReadonlyArray<OAuthReferenceGuardDescriptor<N>>;
-    readonly connectedReference: (input: {
-      readonly identityKey: string;
-      readonly subjectId: N;
-    }) => Fragment;
-  };
-
-export const {
-  oauthAccountsPersistenceLayer,
-  oauthSignInPersistenceLayer,
-  oauthRegistrationIntentsLayer,
-  oauthRegistrationAuthorityLayer,
-} = kernels.sqlite.target;
+  mapping: OAuthConnectedMapping<Table, Table, Table, Table, Table, N, Table>,
+) => ({
+  connectedReference: (input: { readonly identityKey: string; readonly subjectId: N }) => {
+    const g = mapping.grant;
+    const grant = sql`exists(select 1 from ${g.table} where ${g.table.columns[g.identityKey]} = ${input.identityKey} and ${g.table.columns[g.subjectId]} = ${input.subjectId})`;
 
-export const { oauthConnectedPersistenceLayer, oauthConnectedRevocationsLayer } =
-  kernels.sqlite.connectedTarget;
+    if (mapping.revocation.mode === "unsupported") return grant;
+    const j = mapping.revocation.job;
 
-/** Shared session issuance must validate the same subject and credential authority
- * as OAuth. Supply this service when it is not already provided by session storage. */
-export const makeAuthenticationAuthorityServices = <Claims, N>(
-  mapping: AuthorityMapping<Claims, SqlTableModel, SqlTableModel, SqlTableModel, SqlTableModel, N>,
-): Effect.Effect<
-  { readonly authenticationAuthority: AuthenticationAuthority["Service"] },
-  SessionUnavailable | PersistenceConfigurationError,
-  LifecycleHooks | SqlClient.SqlClient
-> =>
-  using(({ database, configuration }) =>
-    makeSessionKernel(operations, (client) => makeNativeSqlTables(client))
-      .makeSqlAuthenticationAuthority(mapping, {
-        mode: "interactive",
-        locking: configuration.locking,
-        standaloneGuard: requireStandalone(
-          () => SessionUnavailable.make({}),
-          database.$client.transactionService,
-        ),
-      })
-      .pipe(
-        // Both kernels capture the same raw SQL query-builder handle and client.
-        Effect.provideService(CurrentSessionSql, database as unknown as SessionSqlDatabase),
-        Effect.map((authenticationAuthority) => ({ authenticationAuthority })),
-      ),
-  );
+    return sql`(${grant}) or exists(select 1 from ${j.table} where ${j.table.columns[j.identityKey]} = ${input.identityKey} and ${j.table.columns[j.subjectId]} = ${input.subjectId})`;
+  },
+});

package/src/index.ts

@@ -4,6 +4,6 @@ export { OAuthProxyPersistence } from "./internal/oauth-proxy";
 export { BrowserLoginPersistence } from "./internal/browser-login";
 export { PersistenceConfigurationError } from "./internal/configuration";
 export { PersistenceMappingError } from "./internal/mapping-error";
-export { StorageColumn, StorageTable } from "./internal/storage-tables";
+export { StorageTable } from "./internal/storage-tables";
 
 export * as OAuthPersistence from "./OAuthPersistence.ts";