@authhero/kysely-adapter 12.8.3 → 12.10.0

package/dist/kysely-adapter.d.ts

@@ -792,6 +792,7 @@ declare const sqlClientSchema: z.ZodObject<{
     owner_user_id: z.ZodNullable<z.ZodOptional<z.ZodString>>;
     registration_type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
     registration_metadata: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    token_exchange: z.ZodNullable<z.ZodOptional<z.ZodString>>;
 }, z.core.$strip>;
 declare const sqlClientRegistrationTokenSchema: z.ZodObject<{
     id: z.ZodString;
@@ -938,6 +939,17 @@ interface Database {
         created_at: string;
         updated_at: string;
     };
+    token_exchange_profiles: {
+        id: string;
+        tenant_id: string;
+        name: string;
+        subject_token_type: string;
+        action_id: string | null;
+        type: string;
+        jwt_verification: string | null;
+        created_at: string;
+        updated_at: string;
+    };
     scim_configurations: {
         connection_id: string;
         tenant_id: string;
@@ -1024,6 +1036,48 @@ interface Database {
 declare function migrateToLatest(db: Kysely<Database>, debug?: boolean): Promise<void>;
 declare function migrateDown(db: Kysely<Database>, debug?: boolean): Promise<void>;
 
+interface PlannedStatement {
+    sql: string;
+    parameters: readonly unknown[];
+}
+interface PlannedMigration {
+    name: string;
+    /** Writes (DDL and DML) the migration would execute, in order. */
+    statements: PlannedStatement[];
+    /**
+     * Set when the migration threw during planning. The statements captured
+     * before the failure are still listed. This can be a dry-run artifact: a
+     * migration that reads a column an earlier pending migration adds will fail
+     * here because the earlier migration was never applied.
+     */
+    error?: string;
+    /** True when planning stopped at MAX_STATEMENTS_PER_MIGRATION. */
+    truncated?: boolean;
+}
+interface MigrationPlan {
+    /** Migrations already recorded as executed, in order. */
+    executed: string[];
+    /** Migrations `migrateToLatest` would run, in order. */
+    pending: PlannedMigration[];
+}
+/**
+ * Dry run of `migrateToLatest`: lists the pending migrations and the SQL each
+ * would execute, without changing the database.
+ *
+ * Each pending migration's `up` runs against a wrapper around `db` that
+ * passes reads through and captures writes. Nothing is written — including
+ * the `kysely_migration` bookkeeping tables, which are only read if present.
+ *
+ * Because captured writes are never applied, the plan can diverge from a real
+ * run where a migration depends on its own or an earlier migration's writes:
+ * "tolerate duplicate column" guards never fire (so an already-present column
+ * still shows up as an ALTER), and reads of not-yet-created columns fail (see
+ * `PlannedMigration.error`).
+ */
+declare function planMigrations(db: Kysely<Database>): Promise<MigrationPlan>;
+/** Renders a plan as an SQL-ish script for printing. */
+declare function formatMigrationPlan(plan: MigrationPlan): string;
+
 declare function createProxyRoutesAdapter(db: Kysely<Database>): ProxyRoutesAdapter;
 
 /**
@@ -1038,5 +1092,5 @@ declare function createAdapters(db: Kysely<Database>, databaseOptions?: {
     useTransactions: boolean;
 }): DataAdapters;
 
-export { createProxyDataAdapter, createProxyRoutesAdapter, createAdapters as default, migrateDown, migrateToLatest };
-export type { Database };
+export { createProxyDataAdapter, createProxyRoutesAdapter, createAdapters as default, formatMigrationPlan, migrateDown, migrateToLatest, planMigrations };
+export type { Database, MigrationPlan, PlannedMigration, PlannedStatement };