A database last touched by a release older than v1-final crashed 1.5.0 startup with "no such table: plugin_storage": the v1->v2 data migration reads the final v1 schema, and the legacy drizzle replay that used to bring old databases forward was dropped in the rework. Vendor the v1 migration chain (apps/local/drizzle-legacy-v1, embedded into the binary) and replay it when the database's drizzle history is a prefix of the bundled chain, before reading the v1 snapshot.
Unified · Split
| @@ -0,0 +1,5 @@ | |||
| 1 | --- | ||
| 2 | "executor": patch | ||
| 3 | --- | ||
| 4 | |||
| 5 | Fix `executor web` crashing with `no such table: plugin_storage` when upgrading from an older v1 release. The v1 → v2 data migration now replays the bundled legacy schema migrations first, so databases last touched by any pre-1.5 version are brought up to the final v1 schema before their data is migrated. | ||
| @@ -252,13 +252,15 @@ const createEmbeddedWebUISource = async (mode: BuildMode) => { · 251 unmodified lines | |||
| 252 | }; | 252 | }; |
| 253 | 253 | ||
| 254 | // --------------------------------------------------------------------------- | 254 | // --------------------------------------------------------------------------- |
| 255 | // Embedded drizzle migrations — inlined as text imports so drizzle's | 255 | // Embedded legacy v1 drizzle migrations — inlined as text imports so drizzle's |
| 256 | // `migrate()` (which reads a folder from disk) can be given a tmpdir | 256 | // `migrate()` (which reads a folder from disk) can be given a tmpdir |
| 257 | // populated from the inlined contents at runtime. | 257 | // populated from the inlined contents at runtime. The v1→v2 data migration |
| 258 | // replays this chain to bring an older v1 database up to v1-final before | ||
| 259 | // reading it (v2's own schema is created from FumaDB DDL, not this folder). | ||
| 258 | // --------------------------------------------------------------------------- | 260 | // --------------------------------------------------------------------------- |
| 259 | 261 | ||
| 260 | const createEmbeddedMigrationsSource = async () => { | 262 | const createEmbeddedMigrationsSource = async () => { |
| 261 | const migrationsDir = resolve(webRoot, "drizzle"); | 263 | const migrationsDir = resolve(webRoot, "drizzle-legacy-v1"); |
| 262 | const files = (await Array.fromAsync(new Bun.Glob("**/*").scan({ cwd: migrationsDir }))) | 264 | const files = (await Array.fromAsync(new Bun.Glob("**/*").scan({ cwd: migrationsDir }))) |
| 263 | .map((f) => f.replaceAll("\\", "/")) | 265 | .map((f) => f.replaceAll("\\", "/")) |
| 264 | .sort(); | 266 | .sort(); |
| @@ -0,0 +1,180 @@ | |||
| 1 | CREATE TABLE `blob` ( | ||
| 2 | `namespace` text NOT NULL, | ||
| 3 | `key` text NOT NULL, | ||
| 4 | `value` text NOT NULL, | ||
| 5 | PRIMARY KEY(`namespace`, `key`) | ||
| 6 | ); | ||
| 7 | --> statement-breakpoint | ||
| 8 | CREATE TABLE `definition` ( | ||
| 9 | `id` text NOT NULL, | ||
| 10 | `scope_id` text NOT NULL, | ||
| 11 | `source_id` text NOT NULL, | ||
| 12 | `plugin_id` text NOT NULL, | ||
| 13 | `name` text NOT NULL, | ||
| 14 | `schema` text NOT NULL, | ||
| 15 | `created_at` integer NOT NULL, | ||
| 16 | PRIMARY KEY(`scope_id`, `id`) | ||
| 17 | ); | ||
| 18 | --> statement-breakpoint | ||
| 19 | CREATE INDEX `definition_scope_id_idx` ON `definition` (`scope_id`);--> statement-breakpoint | ||
| 20 | CREATE INDEX `definition_source_id_idx` ON `definition` (`source_id`);--> statement-breakpoint | ||
| 21 | CREATE INDEX `definition_plugin_id_idx` ON `definition` (`plugin_id`);--> statement-breakpoint | ||
| 22 | CREATE TABLE `google_discovery_binding` ( | ||
| 23 | `id` text NOT NULL, | ||
| 24 | `scope_id` text NOT NULL, | ||
| 25 | `source_id` text NOT NULL, | ||
| 26 | `binding` text NOT NULL, | ||
| 27 | `created_at` integer NOT NULL, | ||
| 28 | PRIMARY KEY(`scope_id`, `id`) | ||
| 29 | ); | ||
| 30 | --> statement-breakpoint | ||
| 31 | CREATE INDEX `google_discovery_binding_scope_id_idx` ON `google_discovery_binding` (`scope_id`);--> statement-breakpoint | ||
| 32 | CREATE INDEX `google_discovery_binding_source_id_idx` ON `google_discovery_binding` (`source_id`);--> statement-breakpoint | ||
| 33 | CREATE TABLE `google_discovery_oauth_session` ( | ||
| 34 | `id` text NOT NULL, | ||
| 35 | `scope_id` text NOT NULL, | ||
| 36 | `session` text NOT NULL, | ||
| 37 | `expires_at` integer NOT NULL, | ||
| 38 | PRIMARY KEY(`scope_id`, `id`) | ||
| 39 | ); | ||
| 40 | --> statement-breakpoint | ||
| 41 | CREATE INDEX `google_discovery_oauth_session_scope_id_idx` ON `google_discovery_oauth_session` (`scope_id`);--> statement-breakpoint | ||
| 42 | CREATE TABLE `google_discovery_source` ( | ||
| 43 | `id` text NOT NULL, | ||
| 44 | `scope_id` text NOT NULL, | ||
| 45 | `name` text NOT NULL, | ||
| 46 | `config` text NOT NULL, | ||
| 47 | `created_at` integer NOT NULL, | ||
| 48 | `updated_at` integer NOT NULL, | ||
| 49 | PRIMARY KEY(`scope_id`, `id`) | ||
| 50 | ); | ||
| 51 | --> statement-breakpoint | ||
| 52 | CREATE INDEX `google_discovery_source_scope_id_idx` ON `google_discovery_source` (`scope_id`);--> statement-breakpoint | ||
| 53 | CREATE TABLE `graphql_operation` ( | ||
| 54 | `id` text NOT NULL, | ||
| 55 | `scope_id` text NOT NULL, | ||
| 56 | `source_id` text NOT NULL, | ||
| 57 | `binding` text NOT NULL, | ||
| 58 | PRIMARY KEY(`scope_id`, `id`) | ||
| 59 | ); | ||
| 60 | --> statement-breakpoint | ||
| 61 | CREATE INDEX `graphql_operation_scope_id_idx` ON `graphql_operation` (`scope_id`);--> statement-breakpoint | ||
| 62 | CREATE INDEX `graphql_operation_source_id_idx` ON `graphql_operation` (`source_id`);--> statement-breakpoint | ||
| 63 | CREATE TABLE `graphql_source` ( | ||
| 64 | `id` text NOT NULL, | ||
| 65 | `scope_id` text NOT NULL, | ||
| 66 | `name` text NOT NULL, | ||
| 67 | `endpoint` text NOT NULL, | ||
| 68 | `headers` text, | ||
| 69 | PRIMARY KEY(`scope_id`, `id`) | ||
| 70 | ); | ||
| 71 | --> statement-breakpoint | ||
| 72 | CREATE INDEX `graphql_source_scope_id_idx` ON `graphql_source` (`scope_id`);--> statement-breakpoint | ||
| 73 | CREATE TABLE `mcp_binding` ( | ||
| 74 | `id` text NOT NULL, | ||
| 75 | `scope_id` text NOT NULL, | ||
| 76 | `source_id` text NOT NULL, | ||
| 77 | `binding` text NOT NULL, | ||
| 78 | `created_at` integer NOT NULL, | ||
| 79 | PRIMARY KEY(`scope_id`, `id`) | ||
| 80 | ); | ||
| 81 | --> statement-breakpoint | ||
| 82 | CREATE INDEX `mcp_binding_scope_id_idx` ON `mcp_binding` (`scope_id`);--> statement-breakpoint | ||
| 83 | CREATE INDEX `mcp_binding_source_id_idx` ON `mcp_binding` (`source_id`);--> statement-breakpoint | ||
| 84 | CREATE TABLE `mcp_oauth_session` ( | ||
| 85 | `id` text NOT NULL, | ||
| 86 | `scope_id` text NOT NULL, | ||
| 87 | `session` text NOT NULL, | ||
| 88 | `expires_at` integer NOT NULL, | ||
| 89 | `created_at` integer NOT NULL, | ||
| 90 | PRIMARY KEY(`scope_id`, `id`) | ||
| 91 | ); | ||
| 92 | --> statement-breakpoint | ||
| 93 | CREATE INDEX `mcp_oauth_session_scope_id_idx` ON `mcp_oauth_session` (`scope_id`);--> statement-breakpoint | ||
| 94 | CREATE TABLE `mcp_source` ( | ||
| 95 | `id` text NOT NULL, | ||
| 96 | `scope_id` text NOT NULL, | ||
| 97 | `name` text NOT NULL, | ||
| 98 | `config` text NOT NULL, | ||
| 99 | `created_at` integer NOT NULL, | ||
| 100 | PRIMARY KEY(`scope_id`, `id`) | ||
| 101 | ); | ||
| 102 | --> statement-breakpoint | ||
| 103 | CREATE INDEX `mcp_source_scope_id_idx` ON `mcp_source` (`scope_id`);--> statement-breakpoint | ||
| 104 | CREATE TABLE `openapi_oauth_session` ( | ||
| 105 | `id` text NOT NULL, | ||
| 106 | `scope_id` text NOT NULL, | ||
| 107 | `session` text NOT NULL, | ||
| 108 | `created_at` integer NOT NULL, | ||
| 109 | PRIMARY KEY(`scope_id`, `id`) | ||
| 110 | ); | ||
| 111 | --> statement-breakpoint | ||
| 112 | CREATE INDEX `openapi_oauth_session_scope_id_idx` ON `openapi_oauth_session` (`scope_id`);--> statement-breakpoint | ||
| 113 | CREATE TABLE `openapi_operation` ( | ||
| 114 | `id` text NOT NULL, | ||
| 115 | `scope_id` text NOT NULL, | ||
| 116 | `source_id` text NOT NULL, | ||
| 117 | `binding` text NOT NULL, | ||
| 118 | PRIMARY KEY(`scope_id`, `id`) | ||
| 119 | ); | ||
| 120 | --> statement-breakpoint | ||
| 121 | CREATE INDEX `openapi_operation_scope_id_idx` ON `openapi_operation` (`scope_id`);--> statement-breakpoint | ||
| 122 | CREATE INDEX `openapi_operation_source_id_idx` ON `openapi_operation` (`source_id`);--> statement-breakpoint | ||
| 123 | CREATE TABLE `openapi_source` ( | ||
| 124 | `id` text NOT NULL, | ||
| 125 | `scope_id` text NOT NULL, | ||
| 126 | `name` text NOT NULL, | ||
| 127 | `spec` text NOT NULL, | ||
| 128 | `base_url` text, | ||
| 129 | `headers` text, | ||
| 130 | `oauth2` text, | ||
| 131 | `invocation_config` text NOT NULL, | ||
| 132 | PRIMARY KEY(`scope_id`, `id`) | ||
| 133 | ); | ||
| 134 | --> statement-breakpoint | ||
| 135 | CREATE INDEX `openapi_source_scope_id_idx` ON `openapi_source` (`scope_id`);--> statement-breakpoint | ||
| 136 | CREATE TABLE `secret` ( | ||
| 137 | `id` text NOT NULL, | ||
| 138 | `scope_id` text NOT NULL, | ||
| 139 | `name` text NOT NULL, | ||
| 140 | `provider` text NOT NULL, | ||
| 141 | `created_at` integer NOT NULL, | ||
| 142 | PRIMARY KEY(`scope_id`, `id`) | ||
| 143 | ); | ||
| 144 | --> statement-breakpoint | ||
| 145 | CREATE INDEX `secret_scope_id_idx` ON `secret` (`scope_id`);--> statement-breakpoint | ||
| 146 | CREATE INDEX `secret_provider_idx` ON `secret` (`provider`);--> statement-breakpoint | ||
| 147 | CREATE TABLE `source` ( | ||
| 148 | `id` text NOT NULL, | ||
| 149 | `scope_id` text NOT NULL, | ||
| 150 | `plugin_id` text NOT NULL, | ||
| 151 | `kind` text NOT NULL, | ||
| 152 | `name` text NOT NULL, | ||
| 153 | `url` text, | ||
| 154 | `can_remove` integer DEFAULT true NOT NULL, | ||
| 155 | `can_refresh` integer DEFAULT false NOT NULL, | ||
| 156 | `can_edit` integer DEFAULT false NOT NULL, | ||
| 157 | `created_at` integer NOT NULL, | ||
| 158 | `updated_at` integer NOT NULL, | ||
| 159 | PRIMARY KEY(`scope_id`, `id`) | ||
| 160 | ); | ||
| 161 | --> statement-breakpoint | ||
| 162 | CREATE INDEX `source_scope_id_idx` ON `source` (`scope_id`);--> statement-breakpoint | ||
| 163 | CREATE INDEX `source_plugin_id_idx` ON `source` (`plugin_id`);--> statement-breakpoint | ||
| 164 | CREATE TABLE `tool` ( | ||
| 165 | `id` text NOT NULL, | ||
| 166 | `scope_id` text NOT NULL, | ||
| 167 | `source_id` text NOT NULL, | ||
| 168 | `plugin_id` text NOT NULL, | ||
| 169 | `name` text NOT NULL, | ||
| 170 | `description` text NOT NULL, | ||
| 171 | `input_schema` text, | ||
| 172 | `output_schema` text, | ||
| 173 | `created_at` integer NOT NULL, | ||
| 174 | `updated_at` integer NOT NULL, | ||
| 175 | PRIMARY KEY(`scope_id`, `id`) | ||
| 176 | ); | ||
| 177 | --> statement-breakpoint | ||
| 178 | CREATE INDEX `tool_scope_id_idx` ON `tool` (`scope_id`);--> statement-breakpoint | ||
| 179 | CREATE INDEX `tool_source_id_idx` ON `tool` (`source_id`);--> statement-breakpoint | ||
| 180 | CREATE INDEX `tool_plugin_id_idx` ON `tool` (`plugin_id`); | ||
| @@ -0,0 +1 @@ | |||
| 1 | ALTER TABLE `openapi_source` ADD `source_url` text; | ||
| @@ -0,0 +1,20 @@ | |||
| 1 | CREATE TABLE `connection` ( | ||
| 2 | `id` text NOT NULL, | ||
| 3 | `scope_id` text NOT NULL, | ||
| 4 | `provider` text NOT NULL, | ||
| 5 | `kind` text NOT NULL, | ||
| 6 | `identity_label` text, | ||
| 7 | `access_token_secret_id` text NOT NULL, | ||
| 8 | `refresh_token_secret_id` text, | ||
| 9 | `expires_at` integer, | ||
| 10 | `scope` text, | ||
| 11 | `provider_state` text, | ||
| 12 | `created_at` integer NOT NULL, | ||
| 13 | `updated_at` integer NOT NULL, | ||
| 14 | PRIMARY KEY(`scope_id`, `id`) | ||
| 15 | ); | ||
| 16 | --> statement-breakpoint | ||
| 17 | CREATE INDEX `connection_scope_id_idx` ON `connection` (`scope_id`);--> statement-breakpoint | ||
| 18 | CREATE INDEX `connection_provider_idx` ON `connection` (`provider`);--> statement-breakpoint | ||
| 19 | ALTER TABLE `secret` ADD `owned_by_connection_id` text;--> statement-breakpoint | ||
| 20 | CREATE INDEX `secret_owned_by_connection_id_idx` ON `secret` (`owned_by_connection_id`); | ||
| @@ -0,0 +1,16 @@ | |||
| 1 | CREATE TABLE `openapi_source_binding` ( | ||
| 2 | `id` text PRIMARY KEY NOT NULL, | ||
| 3 | `source_id` text NOT NULL, | ||
| 4 | `source_scope_id` text NOT NULL, | ||
| 5 | `target_scope_id` text NOT NULL, | ||
| 6 | `slot` text NOT NULL, | ||
| 7 | `value` text NOT NULL, | ||
| 8 | `created_at` integer NOT NULL, | ||
| 9 | `updated_at` integer NOT NULL | ||
| 10 | ); | ||
| 11 | --> statement-breakpoint | ||
| 12 | CREATE INDEX `openapi_source_binding_source_id_idx` ON `openapi_source_binding` (`source_id`);--> statement-breakpoint | ||
| 13 | CREATE INDEX `openapi_source_binding_source_scope_id_idx` ON `openapi_source_binding` (`source_scope_id`);--> statement-breakpoint | ||
| 14 | CREATE INDEX `openapi_source_binding_target_scope_id_idx` ON `openapi_source_binding` (`target_scope_id`);--> statement-breakpoint | ||
| 15 | CREATE INDEX `openapi_source_binding_slot_idx` ON `openapi_source_binding` (`slot`);--> statement-breakpoint | ||
| 16 | ALTER TABLE `connection` DROP COLUMN `kind`; | ||
| @@ -0,0 +1,17 @@ | |||
| 1 | CREATE TABLE `tool_policy` ( | ||
| 2 | `id` text NOT NULL, | ||
| 3 | `scope_id` text NOT NULL, | ||
| 4 | `pattern` text NOT NULL, | ||
| 5 | `action` text NOT NULL, | ||
| 6 | -- Fractional-indexing key (Jira lexorank style). Lex-ordered text; | ||
| 7 | -- always subdivisible by lengthening, so reorders never run out of | ||
| 8 | -- room. | ||
| 9 | `position` text NOT NULL, | ||
| 10 | `created_at` integer NOT NULL, | ||
| 11 | `updated_at` integer NOT NULL, | ||
| 12 | PRIMARY KEY(`scope_id`, `id`) | ||
| 13 | ); | ||
| 14 | --> statement-breakpoint | ||
| 15 | -- List queries are always `WHERE scope_id = ? ORDER BY position`, so the | ||
| 16 | -- composite index serves both the filter and the sort from one btree. | ||
| 17 | CREATE INDEX `tool_policy_scope_id_position_idx` ON `tool_policy` (`scope_id`, `position`); | ||
| @@ -0,0 +1,10 @@ | |||
| 1 | CREATE TABLE IF NOT EXISTS `mcp_oauth_session` ( | ||
| 2 | `id` text NOT NULL, | ||
| 3 | `scope_id` text NOT NULL, | ||
| 4 | `session` text NOT NULL, | ||
| 5 | `expires_at` integer NOT NULL, | ||
| 6 | `created_at` integer NOT NULL, | ||
| 7 | PRIMARY KEY(`scope_id`, `id`) | ||
| 8 | ); | ||
| 9 | --> statement-breakpoint | ||
| 10 | CREATE INDEX IF NOT EXISTS `mcp_oauth_session_scope_id_idx` ON `mcp_oauth_session` (`scope_id`); | ||
| @@ -0,0 +1,23 @@ | |||
| 1 | CREATE TABLE `oauth2_session` ( | ||
| 2 | `id` text NOT NULL, | ||
| 3 | `scope_id` text NOT NULL, | ||
| 4 | `plugin_id` text NOT NULL, | ||
| 5 | `strategy` text NOT NULL, | ||
| 6 | `connection_id` text NOT NULL, | ||
| 7 | `token_scope` text NOT NULL, | ||
| 8 | `redirect_url` text NOT NULL, | ||
| 9 | `payload` text NOT NULL, | ||
| 10 | `expires_at` integer NOT NULL, | ||
| 11 | `created_at` integer NOT NULL, | ||
| 12 | PRIMARY KEY(`scope_id`, `id`) | ||
| 13 | ); | ||
| 14 | --> statement-breakpoint | ||
| 15 | CREATE INDEX `oauth2_session_scope_id_idx` ON `oauth2_session` (`scope_id`);--> statement-breakpoint | ||
| 16 | CREATE INDEX `oauth2_session_plugin_id_idx` ON `oauth2_session` (`plugin_id`);--> statement-breakpoint | ||
| 17 | CREATE INDEX `oauth2_session_connection_id_idx` ON `oauth2_session` (`connection_id`);--> statement-breakpoint | ||
| 18 | DROP TABLE `google_discovery_oauth_session`;--> statement-breakpoint | ||
| 19 | DROP TABLE `mcp_oauth_session`;--> statement-breakpoint | ||
| 20 | DROP TABLE `openapi_oauth_session`;--> statement-breakpoint | ||
| 21 | ALTER TABLE `graphql_source` ADD `query_params` text;--> statement-breakpoint | ||
| 22 | ALTER TABLE `graphql_source` ADD `auth` text;--> statement-breakpoint | ||
| 23 | ALTER TABLE `openapi_source` ADD `query_params` text; | ||
| @@ -0,0 +1,579 @@ | |||
| 1 | -- Normalize all plugin secret/connection refs out of JSON columns | ||
| 2 | -- into proper relational shape: graphql, openapi, mcp, | ||
| 3 | -- google-discovery. Each block is a self-contained backfill of one | ||
| 4 | -- plugin's tables; collected here so the schema lands in one | ||
| 5 | -- migration step instead of four sequential ones. | ||
| 6 | -- | ||
| 7 | -- Old shape (per plugin): | ||
| 8 | -- {plugin}_source.{auth, headers, query_params, ...}: json blobs | ||
| 9 | -- openapi_source_binding.value: json union | ||
| 10 | -- {plugin}_source.config.{auth, headers, queryParams}: nested json | ||
| 11 | -- | ||
| 12 | -- New shape (per plugin): | ||
| 13 | -- Flat auth_* columns on the parent (auth_kind enum + per-kind id | ||
| 14 | -- columns, all indexed where they hold refs). | ||
| 15 | -- Child tables for SecretBackedMap entries: one row per (source, | ||
| 16 | -- header_name) keyed by JSON tuple [source_id,name] so user keys | ||
| 17 | -- with separators don't collide. `secret_id` indexed for the | ||
| 18 | -- usagesForSecret query. | ||
| 19 | |||
| 20 | -- ============================================================ | ||
| 21 | -- graphql | ||
| 22 | -- ============================================================ | ||
| 23 | |||
| 24 | -- Normalize graphql plugin: move secret/connection refs out of JSON | ||
| 25 | -- columns into proper relational shape so usagesForSecret / | ||
| 26 | -- usagesForConnection are one indexed SELECT instead of a JSON scan. | ||
| 27 | -- | ||
| 28 | -- Old shape: | ||
| 29 | -- graphql_source.headers json Record<name, string | {secretId,prefix?}> | ||
| 30 | -- graphql_source.query_params json Record<name, string | {secretId,prefix?}> | ||
| 31 | -- graphql_source.auth json {kind:"none"} | {kind:"oauth2", connectionId} | ||
| 32 | -- | ||
| 33 | -- New shape: | ||
| 34 | -- graphql_source.auth_kind enum("none","oauth2") NOT NULL | ||
| 35 | -- graphql_source.auth_connection_id text indexed nullable | ||
| 36 | -- graphql_source_header(scope_id, id, source_id, name, kind, text_value, secret_id, secret_prefix) | ||
| 37 | -- graphql_source_query_param(scope_id, id, source_id, name, kind, text_value, secret_id, secret_prefix) | ||
| 38 | |||
| 39 | CREATE TABLE `graphql_source_header` ( | ||
| 40 | `id` text NOT NULL, | ||
| 41 | `scope_id` text NOT NULL, | ||
| 42 | `source_id` text NOT NULL, | ||
| 43 | `name` text NOT NULL, | ||
| 44 | `kind` text NOT NULL, | ||
| 45 | `text_value` text, | ||
| 46 | `secret_id` text, | ||
| 47 | `secret_prefix` text, | ||
| 48 | PRIMARY KEY(`scope_id`, `id`) | ||
| 49 | ); | ||
| 50 | --> statement-breakpoint | ||
| 51 | CREATE INDEX `graphql_source_header_scope_id_idx` ON `graphql_source_header` (`scope_id`);--> statement-breakpoint | ||
| 52 | CREATE INDEX `graphql_source_header_source_id_idx` ON `graphql_source_header` (`source_id`);--> statement-breakpoint | ||
| 53 | CREATE INDEX `graphql_source_header_secret_id_idx` ON `graphql_source_header` (`secret_id`);--> statement-breakpoint | ||
| 54 | |||
| 55 | CREATE TABLE `graphql_source_query_param` ( | ||
| 56 | `id` text NOT NULL, | ||
| 57 | `scope_id` text NOT NULL, | ||
| 58 | `source_id` text NOT NULL, | ||
| 59 | `name` text NOT NULL, | ||
| 60 | `kind` text NOT NULL, | ||
| 61 | `text_value` text, | ||
| 62 | `secret_id` text, | ||
| 63 | `secret_prefix` text, | ||
| 64 | PRIMARY KEY(`scope_id`, `id`) | ||
| 65 | ); | ||
| 66 | --> statement-breakpoint | ||
| 67 | CREATE INDEX `graphql_source_query_param_scope_id_idx` ON `graphql_source_query_param` (`scope_id`);--> statement-breakpoint | ||
| 68 | CREATE INDEX `graphql_source_query_param_source_id_idx` ON `graphql_source_query_param` (`source_id`);--> statement-breakpoint | ||
| 69 | CREATE INDEX `graphql_source_query_param_secret_id_idx` ON `graphql_source_query_param` (`secret_id`);--> statement-breakpoint | ||
| 70 | |||
| 71 | -- New auth columns. `auth_kind` defaults to "none" so existing rows that | ||
| 72 | -- predate this migration are valid even if the json was null. | ||
| 73 | ALTER TABLE `graphql_source` ADD `auth_kind` text DEFAULT 'none' NOT NULL;--> statement-breakpoint | ||
| 74 | ALTER TABLE `graphql_source` ADD `auth_connection_id` text;--> statement-breakpoint | ||
| 75 | CREATE INDEX `graphql_source_auth_connection_id_idx` ON `graphql_source` (`auth_connection_id`);--> statement-breakpoint | ||
| 76 | |||
| 77 | -- Backfill auth from the JSON column. json_extract returns NULL for | ||
| 78 | -- missing paths, so a row with auth=NULL or kind="none" leaves | ||
| 79 | -- auth_connection_id NULL and auth_kind defaulted to "none". | ||
| 80 | UPDATE `graphql_source` | ||
| 81 | SET | ||
| 82 | `auth_kind` = COALESCE(json_extract(`auth`, '$.kind'), 'none'), | ||
| 83 | `auth_connection_id` = json_extract(`auth`, '$.connectionId') | ||
| 84 | WHERE `auth` IS NOT NULL;--> statement-breakpoint | ||
| 85 | |||
| 86 | -- Backfill headers. For each (source, header_name) pair: if the value | ||
| 87 | -- is a json object with .secretId, write a kind=secret row; otherwise | ||
| 88 | -- write a kind=text row with the literal string. json_each iterates | ||
| 89 | -- the keys of the headers object. | ||
| 90 | INSERT OR IGNORE INTO `graphql_source_header` | ||
| 91 | (`scope_id`, `id`, `source_id`, `name`, `kind`, `text_value`, `secret_id`, `secret_prefix`) | ||
| 92 | SELECT | ||
| 93 | s.`scope_id`, | ||
| 94 | json_array(s.`id`, h.`key`), | ||
| 95 | s.`id`, | ||
| 96 | h.`key`, | ||
| 97 | CASE | ||
| 98 | WHEN h.`type` = 'object' AND json_extract(h.`value`, '$.secretId') IS NOT NULL THEN 'secret' | ||
| 99 | ELSE 'text' | ||
| 100 | END, | ||
| 101 | CASE WHEN h.`type` = 'object' THEN NULL ELSE h.`value` END, | ||
| 102 | CASE WHEN h.`type` = 'object' THEN json_extract(h.`value`, '$.secretId') ELSE NULL END, | ||
| 103 | CASE WHEN h.`type` = 'object' THEN json_extract(h.`value`, '$.prefix') ELSE NULL END | ||
| 104 | FROM `graphql_source` s, json_each(s.`headers`) h | ||
| 105 | WHERE s.`headers` IS NOT NULL;--> statement-breakpoint | ||
| 106 | |||
| 107 | -- Same for query_params. | ||
| 108 | INSERT OR IGNORE INTO `graphql_source_query_param` | ||
| 109 | (`scope_id`, `id`, `source_id`, `name`, `kind`, `text_value`, `secret_id`, `secret_prefix`) | ||
| 110 | SELECT | ||
| 111 | s.`scope_id`, | ||
| 112 | json_array(s.`id`, q.`key`), | ||
| 113 | s.`id`, | ||
| 114 | q.`key`, | ||
| 115 | CASE | ||
| 116 | WHEN q.`type` = 'object' AND json_extract(q.`value`, '$.secretId') IS NOT NULL THEN 'secret' | ||
| 117 | ELSE 'text' | ||
| 118 | END, | ||
| 119 | CASE WHEN q.`type` = 'object' THEN NULL ELSE q.`value` END, | ||
| 120 | CASE WHEN q.`type` = 'object' THEN json_extract(q.`value`, '$.secretId') ELSE NULL END, | ||
| 121 | CASE WHEN q.`type` = 'object' THEN json_extract(q.`value`, '$.prefix') ELSE NULL END | ||
| 122 | FROM `graphql_source` s, json_each(s.`query_params`) q | ||
| 123 | WHERE s.`query_params` IS NOT NULL;--> statement-breakpoint | ||
| 124 | |||
| 125 | -- Drop the old JSON columns. SQLite ≥ 3.35 supports ALTER TABLE DROP | ||
| 126 | -- COLUMN directly; bun's bundled SQLite is well past that. | ||
| 127 | ALTER TABLE `graphql_source` DROP COLUMN `headers`;--> statement-breakpoint | ||
| 128 | ALTER TABLE `graphql_source` DROP COLUMN `query_params`;--> statement-breakpoint | ||
| 129 | ALTER TABLE `graphql_source` DROP COLUMN `auth`; | ||
| 130 | |||
| 131 | --> statement-breakpoint | ||
| 132 | |||
| 133 | -- ============================================================ | ||
| 134 | -- openapi | ||
| 135 | -- ============================================================ | ||
| 136 | |||
| 137 | -- Normalize openapi plugin: move every direct secret/connection ref out | ||
| 138 | -- of JSON columns into proper relational shape. | ||
| 139 | -- | ||
| 140 | -- Old shape: | ||
| 141 | -- openapi_source.query_params json Record<name, string | {secretId,prefix?}> | ||
| 142 | -- openapi_source.invocation_config json { specFetchCredentials?: { headers, queryParams } } | ||
| 143 | -- openapi_source_binding.value json discriminated union | ||
| 144 | -- {kind:"secret",secretId} | {kind:"connection",connectionId} | {kind:"text",text} | ||
| 145 | -- | ||
| 146 | -- New shape: | ||
| 147 | -- openapi_source_binding gains kind/secret_id/connection_id/text_value columns. | ||
| 148 | -- `headers` / `oauth2` on openapi_source stay JSON because they hold | ||
| 149 | -- slot names, not direct refs — the actual credentials reach those | ||
| 150 | -- slots through openapi_source_binding rows, which ARE normalized. | ||
| 151 | -- openapi_source_query_param: child table, secret-backed entries. | ||
| 152 | -- openapi_source_spec_fetch_header / spec_fetch_query_param: child | ||
| 153 | -- tables for the equivalent maps inside specFetchCredentials. | ||
| 154 | |||
| 155 | CREATE TABLE `openapi_source_query_param` ( | ||
| 156 | `id` text NOT NULL, | ||
| 157 | `scope_id` text NOT NULL, | ||
| 158 | `source_id` text NOT NULL, | ||
| 159 | `name` text NOT NULL, | ||
| 160 | `kind` text NOT NULL, | ||
| 161 | `text_value` text, | ||
| 162 | `secret_id` text, | ||
| 163 | `secret_prefix` text, | ||
| 164 | PRIMARY KEY(`scope_id`, `id`) | ||
| 165 | ); | ||
| 166 | --> statement-breakpoint | ||
| 167 | CREATE INDEX `openapi_source_query_param_scope_id_idx` ON `openapi_source_query_param` (`scope_id`);--> statement-breakpoint | ||
| 168 | CREATE INDEX `openapi_source_query_param_source_id_idx` ON `openapi_source_query_param` (`source_id`);--> statement-breakpoint | ||
| 169 | CREATE INDEX `openapi_source_query_param_secret_id_idx` ON `openapi_source_query_param` (`secret_id`);--> statement-breakpoint | ||
| 170 | |||
| 171 | CREATE TABLE `openapi_source_spec_fetch_header` ( | ||
| 172 | `id` text NOT NULL, | ||
| 173 | `scope_id` text NOT NULL, | ||
| 174 | `source_id` text NOT NULL, | ||
| 175 | `name` text NOT NULL, | ||
| 176 | `kind` text NOT NULL, | ||
| 177 | `text_value` text, | ||
| 178 | `secret_id` text, | ||
| 179 | `secret_prefix` text, | ||
| 180 | PRIMARY KEY(`scope_id`, `id`) | ||
| 181 | ); | ||
| 182 | --> statement-breakpoint | ||
| 183 | CREATE INDEX `openapi_source_spec_fetch_header_scope_id_idx` ON `openapi_source_spec_fetch_header` (`scope_id`);--> statement-breakpoint | ||
| 184 | CREATE INDEX `openapi_source_spec_fetch_header_source_id_idx` ON `openapi_source_spec_fetch_header` (`source_id`);--> statement-breakpoint | ||
| 185 | CREATE INDEX `openapi_source_spec_fetch_header_secret_id_idx` ON `openapi_source_spec_fetch_header` (`secret_id`);--> statement-breakpoint | ||
| 186 | |||
| 187 | CREATE TABLE `openapi_source_spec_fetch_query_param` ( | ||
| 188 | `id` text NOT NULL, | ||
| 189 | `scope_id` text NOT NULL, | ||
| 190 | `source_id` text NOT NULL, | ||
| 191 | `name` text NOT NULL, | ||
| 192 | `kind` text NOT NULL, | ||
| 193 | `text_value` text, | ||
| 194 | `secret_id` text, | ||
| 195 | `secret_prefix` text, | ||
| 196 | PRIMARY KEY(`scope_id`, `id`) | ||
| 197 | ); | ||
| 198 | --> statement-breakpoint | ||
| 199 | CREATE INDEX `openapi_source_spec_fetch_query_param_scope_id_idx` ON `openapi_source_spec_fetch_query_param` (`scope_id`);--> statement-breakpoint | ||
| 200 | CREATE INDEX `openapi_source_spec_fetch_query_param_source_id_idx` ON `openapi_source_spec_fetch_query_param` (`source_id`);--> statement-breakpoint | ||
| 201 | CREATE INDEX `openapi_source_spec_fetch_query_param_secret_id_idx` ON `openapi_source_spec_fetch_query_param` (`secret_id`);--> statement-breakpoint | ||
| 202 | |||
| 203 | -- New columns on openapi_source_binding to flatten the value json. | ||
| 204 | -- `kind` defaults to 'text' so the ALTER works on existing rows; the | ||
| 205 | -- backfill below stamps the real value. | ||
| 206 | ALTER TABLE `openapi_source_binding` ADD `kind` text DEFAULT 'text' NOT NULL;--> statement-breakpoint | ||
| 207 | ALTER TABLE `openapi_source_binding` ADD `secret_id` text;--> statement-breakpoint | ||
| 208 | ALTER TABLE `openapi_source_binding` ADD `connection_id` text;--> statement-breakpoint | ||
| 209 | ALTER TABLE `openapi_source_binding` ADD `text_value` text;--> statement-breakpoint | ||
| 210 | CREATE INDEX `openapi_source_binding_secret_id_idx` ON `openapi_source_binding` (`secret_id`);--> statement-breakpoint | ||
| 211 | CREATE INDEX `openapi_source_binding_connection_id_idx` ON `openapi_source_binding` (`connection_id`);--> statement-breakpoint | ||
| 212 | |||
| 213 | -- Backfill the binding columns from the legacy `value` JSON. We pull | ||
| 214 | -- $.kind into `kind` directly; for each kind the matching id field | ||
| 215 | -- (`secretId` / `connectionId` / `text`) gets copied into the matching | ||
| 216 | -- column. Rows whose value JSON is malformed or missing $.kind fall | ||
| 217 | -- through to kind='text' with a NULL text_value — same as a missing | ||
| 218 | -- text binding, the source will surface "binding not configured" at | ||
| 219 | -- invoke time rather than crashing the migration. | ||
| 220 | UPDATE `openapi_source_binding` | ||
| 221 | SET | ||
| 222 | `kind` = COALESCE(json_extract(`value`, '$.kind'), 'text'), | ||
| 223 | `secret_id` = CASE WHEN json_extract(`value`, '$.kind') = 'secret' THEN json_extract(`value`, '$.secretId') ELSE NULL END, | ||
| 224 | `connection_id` = CASE WHEN json_extract(`value`, '$.kind') = 'connection' THEN json_extract(`value`, '$.connectionId') ELSE NULL END, | ||
| 225 | `text_value` = CASE WHEN json_extract(`value`, '$.kind') = 'text' THEN json_extract(`value`, '$.text') ELSE NULL END | ||
| 226 | WHERE `value` IS NOT NULL;--> statement-breakpoint | ||
| 227 | |||
| 228 | -- Backfill openapi_source_query_param from openapi_source.query_params. | ||
| 229 | -- json_each iterates the keys of the query_params object. For each | ||
| 230 | -- entry: if the value is an object with .secretId, write a kind=secret | ||
| 231 | -- row; otherwise write a kind=text row with the literal string. | ||
| 232 | INSERT OR IGNORE INTO `openapi_source_query_param` | ||
| 233 | (`scope_id`, `id`, `source_id`, `name`, `kind`, `text_value`, `secret_id`, `secret_prefix`) | ||
| 234 | SELECT | ||
| 235 | s.`scope_id`, | ||
| 236 | json_array(s.`id`, q.`key`), | ||
| 237 | s.`id`, | ||
| 238 | q.`key`, | ||
| 239 | CASE | ||
| 240 | WHEN q.`type` = 'object' AND json_extract(q.`value`, '$.secretId') IS NOT NULL THEN 'secret' | ||
| 241 | ELSE 'text' | ||
| 242 | END, | ||
| 243 | CASE WHEN q.`type` = 'object' THEN NULL ELSE q.`value` END, | ||
| 244 | CASE WHEN q.`type` = 'object' THEN json_extract(q.`value`, '$.secretId') ELSE NULL END, | ||
| 245 | CASE WHEN q.`type` = 'object' THEN json_extract(q.`value`, '$.prefix') ELSE NULL END | ||
| 246 | FROM `openapi_source` s, json_each(s.`query_params`) q | ||
| 247 | WHERE s.`query_params` IS NOT NULL;--> statement-breakpoint | ||
| 248 | |||
| 249 | -- Backfill openapi_source_spec_fetch_header from | ||
| 250 | -- openapi_source.invocation_config.specFetchCredentials.headers. Same | ||
| 251 | -- shape as query_params; the JSON path is one level deeper. | ||
| 252 | INSERT OR IGNORE INTO `openapi_source_spec_fetch_header` | ||
| 253 | (`scope_id`, `id`, `source_id`, `name`, `kind`, `text_value`, `secret_id`, `secret_prefix`) | ||
| 254 | SELECT | ||
| 255 | s.`scope_id`, | ||
| 256 | json_array(s.`id`, h.`key`), | ||
| 257 | s.`id`, | ||
| 258 | h.`key`, | ||
| 259 | CASE | ||
| 260 | WHEN h.`type` = 'object' AND json_extract(h.`value`, '$.secretId') IS NOT NULL THEN 'secret' | ||
| 261 | ELSE 'text' | ||
| 262 | END, | ||
| 263 | CASE WHEN h.`type` = 'object' THEN NULL ELSE h.`value` END, | ||
| 264 | CASE WHEN h.`type` = 'object' THEN json_extract(h.`value`, '$.secretId') ELSE NULL END, | ||
| 265 | CASE WHEN h.`type` = 'object' THEN json_extract(h.`value`, '$.prefix') ELSE NULL END | ||
| 266 | FROM `openapi_source` s, json_each(json_extract(s.`invocation_config`, '$.specFetchCredentials.headers')) h | ||
| 267 | WHERE json_extract(s.`invocation_config`, '$.specFetchCredentials.headers') IS NOT NULL;--> statement-breakpoint | ||
| 268 | |||
| 269 | INSERT OR IGNORE INTO `openapi_source_spec_fetch_query_param` | ||
| 270 | (`scope_id`, `id`, `source_id`, `name`, `kind`, `text_value`, `secret_id`, `secret_prefix`) | ||
| 271 | SELECT | ||
| 272 | s.`scope_id`, | ||
| 273 | json_array(s.`id`, q.`key`), | ||
| 274 | s.`id`, | ||
| 275 | q.`key`, | ||
| 276 | CASE | ||
| 277 | WHEN q.`type` = 'object' AND json_extract(q.`value`, '$.secretId') IS NOT NULL THEN 'secret' | ||
| 278 | ELSE 'text' | ||
| 279 | END, | ||
| 280 | CASE WHEN q.`type` = 'object' THEN NULL ELSE q.`value` END, | ||
| 281 | CASE WHEN q.`type` = 'object' THEN json_extract(q.`value`, '$.secretId') ELSE NULL END, | ||
| 282 | CASE WHEN q.`type` = 'object' THEN json_extract(q.`value`, '$.prefix') ELSE NULL END | ||
| 283 | FROM `openapi_source` s, json_each(json_extract(s.`invocation_config`, '$.specFetchCredentials.queryParams')) q | ||
| 284 | WHERE json_extract(s.`invocation_config`, '$.specFetchCredentials.queryParams') IS NOT NULL;--> statement-breakpoint | ||
| 285 | |||
| 286 | -- Preserve any legacy OAuth payload from invocation_config.oauth2 into | ||
| 287 | -- the still-existing oauth2 column before we drop invocation_config. | ||
| 288 | -- migrateLegacyConnections runs after drizzle migrations and reads | ||
| 289 | -- oauth2 to detect the legacy shape; without this, rows that only had | ||
| 290 | -- their OAuth payload under invocation_config.oauth2 would lose it. | ||
| 291 | UPDATE `openapi_source` | ||
| 292 | SET `oauth2` = json_extract(`invocation_config`, '$.oauth2') | ||
| 293 | WHERE `oauth2` IS NULL | ||
| 294 | AND json_extract(`invocation_config`, '$.oauth2') IS NOT NULL;--> statement-breakpoint | ||
| 295 | |||
| 296 | -- Drop the legacy JSON columns now that everything is normalized. | ||
| 297 | ALTER TABLE `openapi_source_binding` DROP COLUMN `value`;--> statement-breakpoint | ||
| 298 | ALTER TABLE `openapi_source` DROP COLUMN `query_params`;--> statement-breakpoint | ||
| 299 | ALTER TABLE `openapi_source` DROP COLUMN `invocation_config`; | ||
| 300 | |||
| 301 | --> statement-breakpoint | ||
| 302 | |||
| 303 | -- ============================================================ | ||
| 304 | -- mcp | ||
| 305 | -- ============================================================ | ||
| 306 | |||
| 307 | -- Normalize mcp plugin: lift the McpConnectionAuth secret/connection | ||
| 308 | -- refs and the SecretBackedMap headers/query_params out of | ||
| 309 | -- mcp_source.config JSON into proper columns / child tables. | ||
| 310 | -- | ||
| 311 | -- Old shape: | ||
| 312 | -- mcp_source.config (json) — McpStoredSourceData discriminated union | ||
| 313 | -- remote: { transport, endpoint, remoteTransport?, queryParams?, | ||
| 314 | -- headers?, auth: McpConnectionAuth } | ||
| 315 | -- stdio: { transport, command, args?, env?, cwd? } | ||
| 316 | -- | ||
| 317 | -- New shape: | ||
| 318 | -- mcp_source gains: auth_kind enum, auth_header_name, auth_secret_id, | ||
| 319 | -- auth_secret_prefix, auth_connection_id, auth_client_id_secret_id, | ||
| 320 | -- auth_client_secret_secret_id. The remaining structural fields | ||
| 321 | -- stay in `config` as JSON because they're plugin-private and | ||
| 322 | -- vary by transport. | ||
| 323 | -- mcp_source_header / mcp_source_query_param: child tables for | ||
| 324 | -- remote sources' SecretBackedMap entries (same column shape as | ||
| 325 | -- graphql_source_header / openapi_source_query_param). | ||
| 326 | |||
| 327 | CREATE TABLE `mcp_source_header` ( | ||
| 328 | `id` text NOT NULL, | ||
| 329 | `scope_id` text NOT NULL, | ||
| 330 | `source_id` text NOT NULL, | ||
| 331 | `name` text NOT NULL, | ||
| 332 | `kind` text NOT NULL, | ||
| 333 | `text_value` text, | ||
| 334 | `secret_id` text, | ||
| 335 | `secret_prefix` text, | ||
| 336 | PRIMARY KEY(`scope_id`, `id`) | ||
| 337 | ); | ||
| 338 | --> statement-breakpoint | ||
| 339 | CREATE INDEX `mcp_source_header_scope_id_idx` ON `mcp_source_header` (`scope_id`);--> statement-breakpoint | ||
| 340 | CREATE INDEX `mcp_source_header_source_id_idx` ON `mcp_source_header` (`source_id`);--> statement-breakpoint | ||
| 341 | CREATE INDEX `mcp_source_header_secret_id_idx` ON `mcp_source_header` (`secret_id`);--> statement-breakpoint | ||
| 342 | |||
| 343 | CREATE TABLE `mcp_source_query_param` ( | ||
| 344 | `id` text NOT NULL, | ||
| 345 | `scope_id` text NOT NULL, | ||
| 346 | `source_id` text NOT NULL, | ||
| 347 | `name` text NOT NULL, | ||
| 348 | `kind` text NOT NULL, | ||
| 349 | `text_value` text, | ||
| 350 | `secret_id` text, | ||
| 351 | `secret_prefix` text, | ||
| 352 | PRIMARY KEY(`scope_id`, `id`) | ||
| 353 | ); | ||
| 354 | --> statement-breakpoint | ||
| 355 | CREATE INDEX `mcp_source_query_param_scope_id_idx` ON `mcp_source_query_param` (`scope_id`);--> statement-breakpoint | ||
| 356 | CREATE INDEX `mcp_source_query_param_source_id_idx` ON `mcp_source_query_param` (`source_id`);--> statement-breakpoint | ||
| 357 | CREATE INDEX `mcp_source_query_param_secret_id_idx` ON `mcp_source_query_param` (`secret_id`);--> statement-breakpoint | ||
| 358 | |||
| 359 | -- New auth columns. `auth_kind` defaults to "none" so the ALTER passes | ||
| 360 | -- on existing rows; the backfill below stamps the real value. | ||
| 361 | ALTER TABLE `mcp_source` ADD `auth_kind` text DEFAULT 'none' NOT NULL;--> statement-breakpoint | ||
| 362 | ALTER TABLE `mcp_source` ADD `auth_header_name` text;--> statement-breakpoint | ||
| 363 | ALTER TABLE `mcp_source` ADD `auth_secret_id` text;--> statement-breakpoint | ||
| 364 | ALTER TABLE `mcp_source` ADD `auth_secret_prefix` text;--> statement-breakpoint | ||
| 365 | ALTER TABLE `mcp_source` ADD `auth_connection_id` text;--> statement-breakpoint | ||
| 366 | ALTER TABLE `mcp_source` ADD `auth_client_id_secret_id` text;--> statement-breakpoint | ||
| 367 | ALTER TABLE `mcp_source` ADD `auth_client_secret_secret_id` text;--> statement-breakpoint | ||
| 368 | CREATE INDEX `mcp_source_auth_secret_id_idx` ON `mcp_source` (`auth_secret_id`);--> statement-breakpoint | ||
| 369 | CREATE INDEX `mcp_source_auth_connection_id_idx` ON `mcp_source` (`auth_connection_id`);--> statement-breakpoint | ||
| 370 | CREATE INDEX `mcp_source_auth_client_id_secret_id_idx` ON `mcp_source` (`auth_client_id_secret_id`);--> statement-breakpoint | ||
| 371 | CREATE INDEX `mcp_source_auth_client_secret_secret_id_idx` ON `mcp_source` (`auth_client_secret_secret_id`);--> statement-breakpoint | ||
| 372 | |||
| 373 | -- Backfill auth columns from config.auth — but only for rows whose | ||
| 374 | -- config.auth matches the *current* shape: | ||
| 375 | -- - kind=none (no extra fields) | ||
| 376 | -- - kind=header (secretId present) | ||
| 377 | -- - kind=oauth2 (connectionId present) | ||
| 378 | -- Truly-legacy rows (inline OAuth shape with accessTokenSecretId etc.) | ||
| 379 | -- are left untouched here so the post-migrate `migrateLegacyConnections` | ||
| 380 | -- script can convert them to a Connection and write the resulting | ||
| 381 | -- pointer to these columns. Setting auth_kind explicitly to NULL/none | ||
| 382 | -- on those rows would lose the legacy payload before it gets converted. | ||
| 383 | UPDATE `mcp_source` | ||
| 384 | SET | ||
| 385 | `auth_kind` = json_extract(`config`, '$.auth.kind'), | ||
| 386 | `auth_header_name` = json_extract(`config`, '$.auth.headerName'), | ||
| 387 | `auth_secret_id` = json_extract(`config`, '$.auth.secretId'), | ||
| 388 | `auth_secret_prefix` = json_extract(`config`, '$.auth.prefix'), | ||
| 389 | `auth_connection_id` = json_extract(`config`, '$.auth.connectionId'), | ||
| 390 | `auth_client_id_secret_id` = json_extract(`config`, '$.auth.clientIdSecretId'), | ||
| 391 | `auth_client_secret_secret_id` = json_extract(`config`, '$.auth.clientSecretSecretId') | ||
| 392 | WHERE `config` IS NOT NULL | ||
| 393 | AND ( | ||
| 394 | -- kind=none and "no auth at all" both leave auth_kind defaulted to | ||
| 395 | -- 'none' (the column DEFAULT), so we only UPDATE rows that have a | ||
| 396 | -- non-trivial current-shape auth payload to extract. | ||
| 397 | ( | ||
| 398 | json_extract(`config`, '$.auth.kind') = 'header' | ||
| 399 | AND json_extract(`config`, '$.auth.secretId') IS NOT NULL | ||
| 400 | ) | ||
| 401 | OR ( | ||
| 402 | json_extract(`config`, '$.auth.kind') = 'oauth2' | ||
| 403 | AND json_extract(`config`, '$.auth.connectionId') IS NOT NULL | ||
| 404 | ) | ||
| 405 | );--> statement-breakpoint | ||
| 406 | |||
| 407 | -- Backfill mcp_source_header from config.headers. Remote sources only; | ||
| 408 | -- stdio's config has no `.headers` key so json_each returns nothing. | ||
| 409 | INSERT OR IGNORE INTO `mcp_source_header` | ||
| 410 | (`scope_id`, `id`, `source_id`, `name`, `kind`, `text_value`, `secret_id`, `secret_prefix`) | ||
| 411 | SELECT | ||
| 412 | s.`scope_id`, | ||
| 413 | json_array(s.`id`, h.`key`), | ||
| 414 | s.`id`, | ||
| 415 | h.`key`, | ||
| 416 | CASE | ||
| 417 | WHEN h.`type` = 'object' AND json_extract(h.`value`, '$.secretId') IS NOT NULL THEN 'secret' | ||
| 418 | ELSE 'text' | ||
| 419 | END, | ||
| 420 | CASE WHEN h.`type` = 'object' THEN NULL ELSE h.`value` END, | ||
| 421 | CASE WHEN h.`type` = 'object' THEN json_extract(h.`value`, '$.secretId') ELSE NULL END, | ||
| 422 | CASE WHEN h.`type` = 'object' THEN json_extract(h.`value`, '$.prefix') ELSE NULL END | ||
| 423 | FROM `mcp_source` s, json_each(json_extract(s.`config`, '$.headers')) h | ||
| 424 | WHERE json_extract(s.`config`, '$.headers') IS NOT NULL;--> statement-breakpoint | ||
| 425 | |||
| 426 | INSERT OR IGNORE INTO `mcp_source_query_param` | ||
| 427 | (`scope_id`, `id`, `source_id`, `name`, `kind`, `text_value`, `secret_id`, `secret_prefix`) | ||
| 428 | SELECT | ||
| 429 | s.`scope_id`, | ||
| 430 | json_array(s.`id`, q.`key`), | ||
| 431 | s.`id`, | ||
| 432 | q.`key`, | ||
| 433 | CASE | ||
| 434 | WHEN q.`type` = 'object' AND json_extract(q.`value`, '$.secretId') IS NOT NULL THEN 'secret' | ||
| 435 | ELSE 'text' | ||
| 436 | END, | ||
| 437 | CASE WHEN q.`type` = 'object' THEN NULL ELSE q.`value` END, | ||
| 438 | CASE WHEN q.`type` = 'object' THEN json_extract(q.`value`, '$.secretId') ELSE NULL END, | ||
| 439 | CASE WHEN q.`type` = 'object' THEN json_extract(q.`value`, '$.prefix') ELSE NULL END | ||
| 440 | FROM `mcp_source` s, json_each(json_extract(s.`config`, '$.queryParams')) q | ||
| 441 | WHERE json_extract(s.`config`, '$.queryParams') IS NOT NULL;--> statement-breakpoint | ||
| 442 | |||
| 443 | -- Strip the now-extracted fields from the legacy config JSON. Skip | ||
| 444 | -- rows whose config.auth still holds a legacy inline-OAuth payload — | ||
| 445 | -- migrateLegacyConnections needs to read it to mint the matching | ||
| 446 | -- Connection. headers/queryParams are always safe to strip (already | ||
| 447 | -- copied to child tables). SQLite's json_remove returns the input | ||
| 448 | -- unchanged when a path is missing, so stdio rows pass through | ||
| 449 | -- cleanly. | ||
| 450 | UPDATE `mcp_source` | ||
| 451 | SET `config` = json_remove(`config`, '$.headers', '$.queryParams') | ||
| 452 | WHERE `config` IS NOT NULL;--> statement-breakpoint | ||
| 453 | |||
| 454 | UPDATE `mcp_source` | ||
| 455 | SET `config` = json_remove(`config`, '$.auth') | ||
| 456 | WHERE `config` IS NOT NULL | ||
| 457 | AND ( | ||
| 458 | json_extract(`config`, '$.auth.kind') = 'none' | ||
| 459 | OR ( | ||
| 460 | json_extract(`config`, '$.auth.kind') = 'header' | ||
| 461 | AND json_extract(`config`, '$.auth.secretId') IS NOT NULL | ||
| 462 | ) | ||
| 463 | OR ( | ||
| 464 | json_extract(`config`, '$.auth.kind') = 'oauth2' | ||
| 465 | AND json_extract(`config`, '$.auth.connectionId') IS NOT NULL | ||
| 466 | ) | ||
| 467 | ); | ||
| 468 | |||
| 469 | --> statement-breakpoint | ||
| 470 | |||
| 471 | -- ============================================================ | ||
| 472 | -- google-discovery | ||
| 473 | -- ============================================================ | ||
| 474 | |||
| 475 | -- Normalize google-discovery plugin: lift the GoogleDiscoveryAuth and | ||
| 476 | -- the credentials.{headers,queryParams} SecretBackedMaps out of | ||
| 477 | -- google_discovery_source.config JSON. | ||
| 478 | -- | ||
| 479 | -- Old shape: | ||
| 480 | -- google_discovery_source.config (json) — GoogleDiscoveryStoredSourceData | ||
| 481 | -- with `auth: {kind:"none"} | {kind:"oauth2", connectionId, clientId..., clientSecret..., scopes}` | ||
| 482 | -- and optional `credentials: { headers?, queryParams? }` | ||
| 483 | -- | ||
| 484 | -- New shape: | ||
| 485 | -- google_discovery_source gains: auth_kind, auth_connection_id, | ||
| 486 | -- auth_client_id_secret_id, auth_client_secret_secret_id, auth_scopes. | ||
| 487 | -- google_discovery_source_credential_header / _query_param: child | ||
| 488 | -- tables for the SecretBackedMap entries. | ||
| 489 | |||
| 490 | CREATE TABLE `google_discovery_source_credential_header` ( | ||
| 491 | `id` text NOT NULL, | ||
| 492 | `scope_id` text NOT NULL, | ||
| 493 | `source_id` text NOT NULL, | ||
| 494 | `name` text NOT NULL, | ||
| 495 | `kind` text NOT NULL, | ||
| 496 | `text_value` text, | ||
| 497 | `secret_id` text, | ||
| 498 | `secret_prefix` text, | ||
| 499 | PRIMARY KEY(`scope_id`, `id`) | ||
| 500 | ); | ||
| 501 | --> statement-breakpoint | ||
| 502 | CREATE INDEX `google_discovery_source_credential_header_scope_id_idx` ON `google_discovery_source_credential_header` (`scope_id`);--> statement-breakpoint | ||
| 503 | CREATE INDEX `google_discovery_source_credential_header_source_id_idx` ON `google_discovery_source_credential_header` (`source_id`);--> statement-breakpoint | ||
| 504 | CREATE INDEX `google_discovery_source_credential_header_secret_id_idx` ON `google_discovery_source_credential_header` (`secret_id`);--> statement-breakpoint | ||
| 505 | |||
| 506 | CREATE TABLE `google_discovery_source_credential_query_param` ( | ||
| 507 | `id` text NOT NULL, | ||
| 508 | `scope_id` text NOT NULL, | ||
| 509 | `source_id` text NOT NULL, | ||
| 510 | `name` text NOT NULL, | ||
| 511 | `kind` text NOT NULL, | ||
| 512 | `text_value` text, | ||
| 513 | `secret_id` text, | ||
| 514 | `secret_prefix` text, | ||
| 515 | PRIMARY KEY(`scope_id`, `id`) | ||
| 516 | ); | ||
| 517 | --> statement-breakpoint | ||
| 518 | CREATE INDEX `google_discovery_source_credential_query_param_scope_id_idx` ON `google_discovery_source_credential_query_param` (`scope_id`);--> statement-breakpoint | ||
| 519 | CREATE INDEX `google_discovery_source_credential_query_param_source_id_idx` ON `google_discovery_source_credential_query_param` (`source_id`);--> statement-breakpoint | ||
| 520 | CREATE INDEX `google_discovery_source_credential_query_param_secret_id_idx` ON `google_discovery_source_credential_query_param` (`secret_id`);--> statement-breakpoint | ||
| 521 | |||
| 522 | ALTER TABLE `google_discovery_source` ADD `auth_kind` text DEFAULT 'none' NOT NULL;--> statement-breakpoint | ||
| 523 | ALTER TABLE `google_discovery_source` ADD `auth_connection_id` text;--> statement-breakpoint | ||
| 524 | ALTER TABLE `google_discovery_source` ADD `auth_client_id_secret_id` text;--> statement-breakpoint | ||
| 525 | ALTER TABLE `google_discovery_source` ADD `auth_client_secret_secret_id` text;--> statement-breakpoint | ||
| 526 | ALTER TABLE `google_discovery_source` ADD `auth_scopes` text;--> statement-breakpoint | ||
| 527 | CREATE INDEX `google_discovery_source_auth_connection_id_idx` ON `google_discovery_source` (`auth_connection_id`);--> statement-breakpoint | ||
| 528 | CREATE INDEX `google_discovery_source_auth_client_id_secret_id_idx` ON `google_discovery_source` (`auth_client_id_secret_id`);--> statement-breakpoint | ||
| 529 | CREATE INDEX `google_discovery_source_auth_client_secret_secret_id_idx` ON `google_discovery_source` (`auth_client_secret_secret_id`);--> statement-breakpoint | ||
| 530 | |||
| 531 | -- Backfill auth columns from config.auth. | ||
| 532 | UPDATE `google_discovery_source` | ||
| 533 | SET | ||
| 534 | `auth_kind` = COALESCE(json_extract(`config`, '$.auth.kind'), 'none'), | ||
| 535 | `auth_connection_id` = json_extract(`config`, '$.auth.connectionId'), | ||
| 536 | `auth_client_id_secret_id` = json_extract(`config`, '$.auth.clientIdSecretId'), | ||
| 537 | `auth_client_secret_secret_id` = json_extract(`config`, '$.auth.clientSecretSecretId'), | ||
| 538 | `auth_scopes` = json_extract(`config`, '$.auth.scopes') | ||
| 539 | WHERE `config` IS NOT NULL;--> statement-breakpoint | ||
| 540 | |||
| 541 | -- Backfill credential header / query_param child rows. | ||
| 542 | INSERT OR IGNORE INTO `google_discovery_source_credential_header` | ||
| 543 | (`scope_id`, `id`, `source_id`, `name`, `kind`, `text_value`, `secret_id`, `secret_prefix`) | ||
| 544 | SELECT | ||
| 545 | s.`scope_id`, | ||
| 546 | json_array(s.`id`, h.`key`), | ||
| 547 | s.`id`, | ||
| 548 | h.`key`, | ||
| 549 | CASE | ||
| 550 | WHEN h.`type` = 'object' AND json_extract(h.`value`, '$.secretId') IS NOT NULL THEN 'secret' | ||
| 551 | ELSE 'text' | ||
| 552 | END, | ||
| 553 | CASE WHEN h.`type` = 'object' THEN NULL ELSE h.`value` END, | ||
| 554 | CASE WHEN h.`type` = 'object' THEN json_extract(h.`value`, '$.secretId') ELSE NULL END, | ||
| 555 | CASE WHEN h.`type` = 'object' THEN json_extract(h.`value`, '$.prefix') ELSE NULL END | ||
| 556 | FROM `google_discovery_source` s, json_each(json_extract(s.`config`, '$.credentials.headers')) h | ||
| 557 | WHERE json_extract(s.`config`, '$.credentials.headers') IS NOT NULL;--> statement-breakpoint | ||
| 558 | |||
| 559 | INSERT OR IGNORE INTO `google_discovery_source_credential_query_param` | ||
| 560 | (`scope_id`, `id`, `source_id`, `name`, `kind`, `text_value`, `secret_id`, `secret_prefix`) | ||
| 561 | SELECT | ||
| 562 | s.`scope_id`, | ||
| 563 | json_array(s.`id`, q.`key`), | ||
| 564 | s.`id`, | ||
| 565 | q.`key`, | ||
| 566 | CASE | ||
| 567 | WHEN q.`type` = 'object' AND json_extract(q.`value`, '$.secretId') IS NOT NULL THEN 'secret' | ||
| 568 | ELSE 'text' | ||
| 569 | END, | ||
| 570 | CASE WHEN q.`type` = 'object' THEN NULL ELSE q.`value` END, | ||
| 571 | CASE WHEN q.`type` = 'object' THEN json_extract(q.`value`, '$.secretId') ELSE NULL END, | ||
| 572 | CASE WHEN q.`type` = 'object' THEN json_extract(q.`value`, '$.prefix') ELSE NULL END | ||
| 573 | FROM `google_discovery_source` s, json_each(json_extract(s.`config`, '$.credentials.queryParams')) q | ||
| 574 | WHERE json_extract(s.`config`, '$.credentials.queryParams') IS NOT NULL;--> statement-breakpoint | ||
| 575 | |||
| 576 | -- Strip the extracted fields from the legacy config JSON. | ||
| 577 | UPDATE `google_discovery_source` | ||
| 578 | SET `config` = json_remove(`config`, '$.auth', '$.credentials') | ||
| 579 | WHERE `config` IS NOT NULL; | ||
| @@ -0,0 +1,1220 @@ | |||
| 1 | -- | ||
| 2 | -- Slug-normalization staging table. | ||
| 3 | -- | ||
| 4 | -- 0008 originally inlined a 41-deep `replace(replace(... lower(...) ...))` | ||
| 5 | -- chain everywhere it derived a slot_key from a header / param / oauth | ||
| 6 | -- scheme name. bun:sqlite's lemon parser stack overflows on that depth on | ||
| 7 | -- platforms with smaller thread stacks (notably the compiled CLI binary on | ||
| 8 | -- macOS), so we precompute slugs once into a temp table and reference them | ||
| 9 | -- via flat scalar subqueries below. | ||
| 10 | -- | ||
| 11 | CREATE TEMP TABLE `__slug_norm` ( | ||
| 12 | `raw` text PRIMARY KEY, | ||
| 13 | `slug` text NOT NULL DEFAULT '' | ||
| 14 | );--> statement-breakpoint | ||
| 15 | |||
| 16 | INSERT OR IGNORE INTO `__slug_norm` (`raw`) | ||
| 17 | SELECT DISTINCT `raw` FROM ( | ||
| 18 | SELECT h.`key` AS `raw` FROM `openapi_source` s, json_each(s.`headers`) h | ||
| 19 | WHERE s.`headers` IS NOT NULL AND h.`type` = 'object' | ||
| 20 | UNION | ||
| 21 | SELECT json_extract(s.`oauth2`, '$.securitySchemeName') FROM `openapi_source` s | ||
| 22 | WHERE s.`oauth2` IS NOT NULL | ||
| 23 | UNION | ||
| 24 | SELECT `name` FROM `openapi_source_query_param` WHERE `name` IS NOT NULL | ||
| 25 | UNION | ||
| 26 | SELECT `name` FROM `openapi_source_spec_fetch_header` WHERE `name` IS NOT NULL | ||
| 27 | UNION | ||
| 28 | SELECT `name` FROM `openapi_source_spec_fetch_query_param` WHERE `name` IS NOT NULL | ||
| 29 | UNION | ||
| 30 | SELECT `name` FROM `graphql_source_header` WHERE `name` IS NOT NULL | ||
| 31 | UNION | ||
| 32 | SELECT `name` FROM `graphql_source_query_param` WHERE `name` IS NOT NULL | ||
| 33 | UNION | ||
| 34 | SELECT `name` FROM `mcp_source_header` WHERE `name` IS NOT NULL | ||
| 35 | UNION | ||
| 36 | SELECT `name` FROM `mcp_source_query_param` WHERE `name` IS NOT NULL | ||
| 37 | ) WHERE `raw` IS NOT NULL AND `raw` != '';--> statement-breakpoint | ||
| 38 | |||
| 39 | UPDATE `__slug_norm` SET `slug` = lower(trim(`raw`));--> statement-breakpoint | ||
| 40 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, char(9), '-');--> statement-breakpoint | ||
| 41 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, char(10), '-');--> statement-breakpoint | ||
| 42 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, char(13), '-');--> statement-breakpoint | ||
| 43 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, ' ', '-');--> statement-breakpoint | ||
| 44 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '_', '-');--> statement-breakpoint | ||
| 45 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '.', '-');--> statement-breakpoint | ||
| 46 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, ':', '-');--> statement-breakpoint | ||
| 47 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '/', '-');--> statement-breakpoint | ||
| 48 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '@', '-');--> statement-breakpoint | ||
| 49 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '+', '-');--> statement-breakpoint | ||
| 50 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '&', '-');--> statement-breakpoint | ||
| 51 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '?', '-');--> statement-breakpoint | ||
| 52 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '#', '-');--> statement-breakpoint | ||
| 53 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '%', '-');--> statement-breakpoint | ||
| 54 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '$', '-');--> statement-breakpoint | ||
| 55 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, ',', '-');--> statement-breakpoint | ||
| 56 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, ';', '-');--> statement-breakpoint | ||
| 57 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '(', '-');--> statement-breakpoint | ||
| 58 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, ')', '-');--> statement-breakpoint | ||
| 59 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '[', '-');--> statement-breakpoint | ||
| 60 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, ']', '-');--> statement-breakpoint | ||
| 61 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '{', '-');--> statement-breakpoint | ||
| 62 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '}', '-');--> statement-breakpoint | ||
| 63 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '=', '-');--> statement-breakpoint | ||
| 64 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '~', '-');--> statement-breakpoint | ||
| 65 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '!', '-');--> statement-breakpoint | ||
| 66 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, char(34), '-');--> statement-breakpoint | ||
| 67 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, char(39), '-');--> statement-breakpoint | ||
| 68 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, char(92), '-');--> statement-breakpoint | ||
| 69 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '|', '-');--> statement-breakpoint | ||
| 70 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '*', '-');--> statement-breakpoint | ||
| 71 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '<', '-');--> statement-breakpoint | ||
| 72 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '>', '-');--> statement-breakpoint | ||
| 73 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '--', '-');--> statement-breakpoint | ||
| 74 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '--', '-');--> statement-breakpoint | ||
| 75 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '--', '-');--> statement-breakpoint | ||
| 76 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '--', '-');--> statement-breakpoint | ||
| 77 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '--', '-');--> statement-breakpoint | ||
| 78 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '--', '-');--> statement-breakpoint | ||
| 79 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '--', '-');--> statement-breakpoint | ||
| 80 | UPDATE `__slug_norm` SET `slug` = replace(`slug`, '--', '-');--> statement-breakpoint | ||
| 81 | UPDATE `__slug_norm` SET `slug` = trim(`slug`, '-');--> statement-breakpoint | ||
| 82 | UPDATE `__slug_norm` SET `slug` = CASE WHEN `slug` = '' THEN 'default' ELSE `slug` END;--> statement-breakpoint | ||
| 83 | |||
| 84 | -- local scoped credential/source-slot/OAuth cutover. | ||
| 85 | -- Squashes the PR-local migration chain into one runtime schema transition. | ||
| 86 | -- 0008_add_credential_binding.sql | ||
| 87 | CREATE TABLE `credential_binding` ( | ||
| 88 | `id` text NOT NULL, | ||
| 89 | `scope_id` text NOT NULL, | ||
| 90 | `plugin_id` text NOT NULL, | ||
| 91 | `source_id` text NOT NULL, | ||
| 92 | `source_scope_id` text NOT NULL, | ||
| 93 | `slot_key` text NOT NULL, | ||
| 94 | `kind` text NOT NULL, | ||
| 95 | `text_value` text, | ||
| 96 | `secret_id` text, | ||
| 97 | `connection_id` text, | ||
| 98 | `created_at` integer NOT NULL, | ||
| 99 | `updated_at` integer NOT NULL, | ||
| 100 | PRIMARY KEY(`scope_id`, `id`) | ||
| 101 | ); | ||
| 102 | --> statement-breakpoint | ||
| 103 | CREATE INDEX `credential_binding_scope_id_idx` ON `credential_binding` (`scope_id`);--> statement-breakpoint | ||
| 104 | CREATE INDEX `credential_binding_plugin_id_idx` ON `credential_binding` (`plugin_id`);--> statement-breakpoint | ||
| 105 | CREATE INDEX `credential_binding_source_id_idx` ON `credential_binding` (`source_id`);--> statement-breakpoint | ||
| 106 | CREATE INDEX `credential_binding_source_scope_id_idx` ON `credential_binding` (`source_scope_id`);--> statement-breakpoint | ||
| 107 | CREATE INDEX `credential_binding_slot_key_idx` ON `credential_binding` (`slot_key`);--> statement-breakpoint | ||
| 108 | CREATE INDEX `credential_binding_kind_idx` ON `credential_binding` (`kind`);--> statement-breakpoint | ||
| 109 | CREATE INDEX `credential_binding_secret_id_idx` ON `credential_binding` (`secret_id`);--> statement-breakpoint | ||
| 110 | CREATE INDEX `credential_binding_connection_id_idx` ON `credential_binding` (`connection_id`);--> statement-breakpoint | ||
| 111 | PRAGMA foreign_keys=OFF;--> statement-breakpoint | ||
| 112 | CREATE TABLE `__new_openapi_source_binding` ( | ||
| 113 | `id` text PRIMARY KEY NOT NULL, | ||
| 114 | `source_id` text NOT NULL, | ||
| 115 | `source_scope_id` text NOT NULL, | ||
| 116 | `target_scope_id` text NOT NULL, | ||
| 117 | `slot` text NOT NULL, | ||
| 118 | `kind` text NOT NULL, | ||
| 119 | `secret_id` text, | ||
| 120 | `connection_id` text, | ||
| 121 | `text_value` text, | ||
| 122 | `created_at` integer NOT NULL, | ||
| 123 | `updated_at` integer NOT NULL | ||
| 124 | ); | ||
| 125 | --> statement-breakpoint | ||
| 126 | INSERT INTO `__new_openapi_source_binding`("id", "source_id", "source_scope_id", "target_scope_id", "slot", "kind", "secret_id", "connection_id", "text_value", "created_at", "updated_at") SELECT "id", "source_id", "source_scope_id", "target_scope_id", "slot", "kind", "secret_id", "connection_id", "text_value", "created_at", "updated_at" FROM `openapi_source_binding`;--> statement-breakpoint | ||
| 127 | DROP TABLE `openapi_source_binding`;--> statement-breakpoint | ||
| 128 | ALTER TABLE `__new_openapi_source_binding` RENAME TO `openapi_source_binding`;--> statement-breakpoint | ||
| 129 | PRAGMA foreign_keys=ON;--> statement-breakpoint | ||
| 130 | CREATE INDEX `openapi_source_binding_source_id_idx` ON `openapi_source_binding` (`source_id`);--> statement-breakpoint | ||
| 131 | CREATE INDEX `openapi_source_binding_source_scope_id_idx` ON `openapi_source_binding` (`source_scope_id`);--> statement-breakpoint | ||
| 132 | CREATE INDEX `openapi_source_binding_target_scope_id_idx` ON `openapi_source_binding` (`target_scope_id`);--> statement-breakpoint | ||
| 133 | CREATE INDEX `openapi_source_binding_slot_idx` ON `openapi_source_binding` (`slot`);--> statement-breakpoint | ||
| 134 | CREATE INDEX `openapi_source_binding_secret_id_idx` ON `openapi_source_binding` (`secret_id`);--> statement-breakpoint | ||
| 135 | CREATE INDEX `openapi_source_binding_connection_id_idx` ON `openapi_source_binding` (`connection_id`);--> statement-breakpoint | ||
| 136 | |||
| 137 | -- 0009_migrate_openapi_source_bindings.sql | ||
| 138 | INSERT OR REPLACE INTO `credential_binding` ( | ||
| 139 | `id`, | ||
| 140 | `scope_id`, | ||
| 141 | `plugin_id`, | ||
| 142 | `source_id`, | ||
| 143 | `source_scope_id`, | ||
| 144 | `slot_key`, | ||
| 145 | `kind`, | ||
| 146 | `text_value`, | ||
| 147 | `secret_id`, | ||
| 148 | `connection_id`, | ||
| 149 | `created_at`, | ||
| 150 | `updated_at` | ||
| 151 | ) | ||
| 152 | SELECT | ||
| 153 | json_array('openapi', `source_scope_id`, `source_id`, `slot`), | ||
| 154 | `target_scope_id`, | ||
| 155 | 'openapi', | ||
| 156 | `source_id`, | ||
| 157 | `source_scope_id`, | ||
| 158 | `slot`, | ||
| 159 | `kind`, | ||
| 160 | `text_value`, | ||
| 161 | `secret_id`, | ||
| 162 | `connection_id`, | ||
| 163 | `created_at`, | ||
| 164 | `updated_at` | ||
| 165 | FROM `openapi_source_binding`;--> statement-breakpoint | ||
| 166 | DROP TABLE `openapi_source_binding`;--> statement-breakpoint | ||
| 167 | |||
| 168 | -- 0010_openapi_credential_slots.sql | ||
| 169 | -- Convert OpenAPI's remaining direct credential references to source-owned | ||
| 170 | -- slot structure plus shared core credential_binding rows. Runtime code only | ||
| 171 | -- reads the final slot model; this migration is the one-shot bridge. | ||
| 172 | |||
| 173 | -- Existing header JSON may still contain SecretBackedValue objects. Preserve | ||
| 174 | -- the source-owned header names, move secret ids to credential_binding, and | ||
| 175 | -- rewrite each object to { kind: "binding", slot, prefix? }. | ||
| 176 | CREATE TEMP TABLE `__openapi_header_slot_preflight` ( | ||
| 177 | `scope_id` text NOT NULL, | ||
| 178 | `source_id` text NOT NULL, | ||
| 179 | `slot_key` text NOT NULL, | ||
| 180 | PRIMARY KEY (`scope_id`, `source_id`, `slot_key`) | ||
| 181 | );--> statement-breakpoint | ||
| 182 | |||
| 183 | INSERT INTO `__openapi_header_slot_preflight` (`scope_id`, `source_id`, `slot_key`) | ||
| 184 | SELECT | ||
| 185 | s.`scope_id`, | ||
| 186 | s.`id`, | ||
| 187 | 'header:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = h.`key`), 'default') AS `slot_key` | ||
| 188 | FROM `openapi_source` s, json_each(s.`headers`) h | ||
| 189 | WHERE s.`headers` IS NOT NULL | ||
| 190 | AND h.`type` = 'object' | ||
| 191 | AND json_extract(h.`value`, '$.kind') IS NULL | ||
| 192 | AND json_extract(h.`value`, '$.secretId') IS NOT NULL;--> statement-breakpoint | ||
| 193 | |||
| 194 | DROP TABLE `__openapi_header_slot_preflight`;--> statement-breakpoint | ||
| 195 | |||
| 196 | WITH header_rows AS ( | ||
| 197 | SELECT | ||
| 198 | s.`scope_id`, | ||
| 199 | s.`id` AS `source_id`, | ||
| 200 | h.`key` AS `name`, | ||
| 201 | 'header:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = h.`key`), 'default') AS `slot_key`, | ||
| 202 | json_extract(h.`value`, '$.secretId') AS `secret_id` | ||
| 203 | FROM `openapi_source` s, json_each(s.`headers`) h | ||
| 204 | WHERE s.`headers` IS NOT NULL | ||
| 205 | AND h.`type` = 'object' | ||
| 206 | AND json_extract(h.`value`, '$.kind') IS NULL | ||
| 207 | AND json_extract(h.`value`, '$.secretId') IS NOT NULL | ||
| 208 | ) | ||
| 209 | INSERT OR REPLACE INTO `credential_binding` ( | ||
| 210 | `id`, `scope_id`, `plugin_id`, `source_id`, `source_scope_id`, `slot_key`, | ||
| 211 | `kind`, `text_value`, `secret_id`, `connection_id`, `created_at`, `updated_at` | ||
| 212 | ) | ||
| 213 | SELECT | ||
| 214 | json_array('openapi', r.`scope_id`, r.`source_id`, r.`slot_key`), | ||
| 215 | r.`scope_id`, | ||
| 216 | 'openapi', | ||
| 217 | r.`source_id`, | ||
| 218 | r.`scope_id`, | ||
| 219 | r.`slot_key`, | ||
| 220 | 'secret', | ||
| 221 | NULL, | ||
| 222 | r.`secret_id`, | ||
| 223 | NULL, | ||
| 224 | CAST(strftime('%s', 'now') AS INTEGER) * 1000, | ||
| 225 | CAST(strftime('%s', 'now') AS INTEGER) * 1000 | ||
| 226 | FROM header_rows r | ||
| 227 | WHERE NOT EXISTS ( | ||
| 228 | SELECT 1 FROM `credential_binding` b | ||
| 229 | WHERE b.`scope_id` = r.`scope_id` | ||
| 230 | AND b.`plugin_id` = 'openapi' | ||
| 231 | AND b.`source_id` = r.`source_id` | ||
| 232 | AND b.`source_scope_id` = r.`scope_id` | ||
| 233 | AND b.`slot_key` = r.`slot_key` | ||
| 234 | );--> statement-breakpoint | ||
| 235 | |||
| 236 | UPDATE `openapi_source` | ||
| 237 | SET `headers` = ( | ||
| 238 | SELECT json_group_object( | ||
| 239 | h.`key`, | ||
| 240 | CASE | ||
| 241 | WHEN h.`type` = 'object' | ||
| 242 | AND json_extract(h.`value`, '$.kind') IS NULL | ||
| 243 | AND json_extract(h.`value`, '$.secretId') IS NOT NULL | ||
| 244 | AND json_extract(h.`value`, '$.prefix') IS NOT NULL | ||
| 245 | THEN json_object( | ||
| 246 | 'kind', 'binding', | ||
| 247 | 'slot', 'header:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = h.`key`), 'default'), | ||
| 248 | 'prefix', json_extract(h.`value`, '$.prefix') | ||
| 249 | ) | ||
| 250 | WHEN h.`type` = 'object' | ||
| 251 | AND json_extract(h.`value`, '$.kind') IS NULL | ||
| 252 | AND json_extract(h.`value`, '$.secretId') IS NOT NULL | ||
| 253 | THEN json_object( | ||
| 254 | 'kind', 'binding', | ||
| 255 | 'slot', 'header:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = h.`key`), 'default') | ||
| 256 | ) | ||
| 257 | WHEN h.`type` IN ('object', 'array') THEN json(h.`value`) | ||
| 258 | ELSE h.`value` | ||
| 259 | END | ||
| 260 | ) | ||
| 261 | FROM json_each(`openapi_source`.`headers`) h | ||
| 262 | ) | ||
| 263 | WHERE `headers` IS NOT NULL;--> statement-breakpoint | ||
| 264 | |||
| 265 | -- OAuth2Auth JSON becomes OAuth2SourceConfig JSON plus explicit bindings for | ||
| 266 | -- the client id, optional client secret, and live connection id. | ||
| 267 | WITH oauth_rows AS ( | ||
| 268 | SELECT | ||
| 269 | s.`scope_id`, | ||
| 270 | s.`id` AS `source_id`, | ||
| 271 | json_extract(s.`oauth2`, '$.securitySchemeName') AS `security_scheme_name`, | ||
| 272 | 'oauth2:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = json_extract(s.`oauth2`, '$.securitySchemeName')), 'default') || ':client-id' AS `client_id_slot`, | ||
| 273 | json_extract(s.`oauth2`, '$.clientIdSecretId') AS `client_id_secret_id`, | ||
| 274 | json_extract(s.`oauth2`, '$.connectionId') AS `connection_id` | ||
| 275 | FROM `openapi_source` s | ||
| 276 | WHERE s.`oauth2` IS NOT NULL | ||
| 277 | AND json_extract(s.`oauth2`, '$.connectionId') IS NOT NULL | ||
| 278 | AND json_extract(s.`oauth2`, '$.clientIdSecretId') IS NOT NULL | ||
| 279 | ) | ||
| 280 | INSERT OR REPLACE INTO `credential_binding` ( | ||
| 281 | `id`, `scope_id`, `plugin_id`, `source_id`, `source_scope_id`, `slot_key`, | ||
| 282 | `kind`, `text_value`, `secret_id`, `connection_id`, `created_at`, `updated_at` | ||
| 283 | ) | ||
| 284 | SELECT | ||
| 285 | json_array('openapi', r.`scope_id`, r.`source_id`, r.`client_id_slot`), | ||
| 286 | r.`scope_id`, | ||
| 287 | 'openapi', | ||
| 288 | r.`source_id`, | ||
| 289 | r.`scope_id`, | ||
| 290 | r.`client_id_slot`, | ||
| 291 | 'secret', | ||
| 292 | NULL, | ||
| 293 | r.`client_id_secret_id`, | ||
| 294 | NULL, | ||
| 295 | CAST(strftime('%s', 'now') AS INTEGER) * 1000, | ||
| 296 | CAST(strftime('%s', 'now') AS INTEGER) * 1000 | ||
| 297 | FROM oauth_rows r | ||
| 298 | WHERE NOT EXISTS ( | ||
| 299 | SELECT 1 FROM `credential_binding` b | ||
| 300 | WHERE b.`scope_id` = r.`scope_id` | ||
| 301 | AND b.`plugin_id` = 'openapi' | ||
| 302 | AND b.`source_id` = r.`source_id` | ||
| 303 | AND b.`source_scope_id` = r.`scope_id` | ||
| 304 | AND b.`slot_key` = r.`client_id_slot` | ||
| 305 | );--> statement-breakpoint | ||
| 306 | |||
| 307 | WITH oauth_rows AS ( | ||
| 308 | SELECT | ||
| 309 | s.`scope_id`, | ||
| 310 | s.`id` AS `source_id`, | ||
| 311 | 'oauth2:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = json_extract(s.`oauth2`, '$.securitySchemeName')), 'default') || ':client-secret' AS `client_secret_slot`, | ||
| 312 | json_extract(s.`oauth2`, '$.clientSecretSecretId') AS `client_secret_secret_id` | ||
| 313 | FROM `openapi_source` s | ||
| 314 | WHERE s.`oauth2` IS NOT NULL | ||
| 315 | AND json_extract(s.`oauth2`, '$.connectionId') IS NOT NULL | ||
| 316 | AND json_extract(s.`oauth2`, '$.clientSecretSecretId') IS NOT NULL | ||
| 317 | ) | ||
| 318 | INSERT OR REPLACE INTO `credential_binding` ( | ||
| 319 | `id`, `scope_id`, `plugin_id`, `source_id`, `source_scope_id`, `slot_key`, | ||
| 320 | `kind`, `text_value`, `secret_id`, `connection_id`, `created_at`, `updated_at` | ||
| 321 | ) | ||
| 322 | SELECT | ||
| 323 | json_array('openapi', r.`scope_id`, r.`source_id`, r.`client_secret_slot`), | ||
| 324 | r.`scope_id`, | ||
| 325 | 'openapi', | ||
| 326 | r.`source_id`, | ||
| 327 | r.`scope_id`, | ||
| 328 | r.`client_secret_slot`, | ||
| 329 | 'secret', | ||
| 330 | NULL, | ||
| 331 | r.`client_secret_secret_id`, | ||
| 332 | NULL, | ||
| 333 | CAST(strftime('%s', 'now') AS INTEGER) * 1000, | ||
| 334 | CAST(strftime('%s', 'now') AS INTEGER) * 1000 | ||
| 335 | FROM oauth_rows r | ||
| 336 | WHERE NOT EXISTS ( | ||
| 337 | SELECT 1 FROM `credential_binding` b | ||
| 338 | WHERE b.`scope_id` = r.`scope_id` | ||
| 339 | AND b.`plugin_id` = 'openapi' | ||
| 340 | AND b.`source_id` = r.`source_id` | ||
| 341 | AND b.`source_scope_id` = r.`scope_id` | ||
| 342 | AND b.`slot_key` = r.`client_secret_slot` | ||
| 343 | );--> statement-breakpoint | ||
| 344 | |||
| 345 | WITH oauth_rows AS ( | ||
| 346 | SELECT | ||
| 347 | s.`scope_id`, | ||
| 348 | s.`id` AS `source_id`, | ||
| 349 | 'oauth2:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = json_extract(s.`oauth2`, '$.securitySchemeName')), 'default') || ':connection' AS `connection_slot`, | ||
| 350 | json_extract(s.`oauth2`, '$.connectionId') AS `connection_id` | ||
| 351 | FROM `openapi_source` s | ||
| 352 | WHERE s.`oauth2` IS NOT NULL | ||
| 353 | AND json_extract(s.`oauth2`, '$.connectionId') IS NOT NULL | ||
| 354 | ) | ||
| 355 | INSERT OR REPLACE INTO `credential_binding` ( | ||
| 356 | `id`, `scope_id`, `plugin_id`, `source_id`, `source_scope_id`, `slot_key`, | ||
| 357 | `kind`, `text_value`, `secret_id`, `connection_id`, `created_at`, `updated_at` | ||
| 358 | ) | ||
| 359 | SELECT | ||
| 360 | json_array('openapi', r.`scope_id`, r.`source_id`, r.`connection_slot`), | ||
| 361 | r.`scope_id`, | ||
| 362 | 'openapi', | ||
| 363 | r.`source_id`, | ||
| 364 | r.`scope_id`, | ||
| 365 | r.`connection_slot`, | ||
| 366 | 'connection', | ||
| 367 | NULL, | ||
| 368 | NULL, | ||
| 369 | r.`connection_id`, | ||
| 370 | CAST(strftime('%s', 'now') AS INTEGER) * 1000, | ||
| 371 | CAST(strftime('%s', 'now') AS INTEGER) * 1000 | ||
| 372 | FROM oauth_rows r | ||
| 373 | WHERE NOT EXISTS ( | ||
| 374 | SELECT 1 FROM `credential_binding` b | ||
| 375 | WHERE b.`scope_id` = r.`scope_id` | ||
| 376 | AND b.`plugin_id` = 'openapi' | ||
| 377 | AND b.`source_id` = r.`source_id` | ||
| 378 | AND b.`source_scope_id` = r.`scope_id` | ||
| 379 | AND b.`slot_key` = r.`connection_slot` | ||
| 380 | );--> statement-breakpoint | ||
| 381 | |||
| 382 | UPDATE `openapi_source` | ||
| 383 | SET `oauth2` = json_object( | ||
| 384 | 'kind', 'oauth2', | ||
| 385 | 'securitySchemeName', json_extract(`oauth2`, '$.securitySchemeName'), | ||
| 386 | 'flow', json_extract(`oauth2`, '$.flow'), | ||
| 387 | 'tokenUrl', json_extract(`oauth2`, '$.tokenUrl'), | ||
| 388 | 'authorizationUrl', json_extract(`oauth2`, '$.authorizationUrl'), | ||
| 389 | 'issuerUrl', json_extract(`oauth2`, '$.issuerUrl'), | ||
| 390 | 'clientIdSlot', 'oauth2:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = json_extract(`oauth2`, '$.securitySchemeName')), 'default') || ':client-id', | ||
| 391 | 'clientSecretSlot', | ||
| 392 | CASE | ||
| 393 | WHEN json_extract(`oauth2`, '$.clientSecretSecretId') IS NULL THEN NULL | ||
| 394 | ELSE 'oauth2:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = json_extract(`oauth2`, '$.securitySchemeName')), 'default') || ':client-secret' | ||
| 395 | END, | ||
| 396 | 'connectionSlot', 'oauth2:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = json_extract(`oauth2`, '$.securitySchemeName')), 'default') || ':connection', | ||
| 397 | 'scopes', json(COALESCE(json_extract(`oauth2`, '$.scopes'), '[]')) | ||
| 398 | ) | ||
| 399 | WHERE `oauth2` IS NOT NULL | ||
| 400 | AND json_extract(`oauth2`, '$.connectionId') IS NOT NULL;--> statement-breakpoint | ||
| 401 | |||
| 402 | -- Child credential rows become source-owned binding slots. | ||
| 403 | CREATE TEMP TABLE `__openapi_query_param_slot_preflight` ( | ||
| 404 | `scope_id` text NOT NULL, | ||
| 405 | `source_id` text NOT NULL, | ||
| 406 | `slot_key` text NOT NULL, | ||
| 407 | PRIMARY KEY (`scope_id`, `source_id`, `slot_key`) | ||
| 408 | );--> statement-breakpoint | ||
| 409 | |||
| 410 | INSERT INTO `__openapi_query_param_slot_preflight` (`scope_id`, `source_id`, `slot_key`) | ||
| 411 | SELECT | ||
| 412 | r.`scope_id`, | ||
| 413 | r.`source_id`, | ||
| 414 | 'query_param:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = r.`name`), 'default') AS `slot_key` | ||
| 415 | FROM `openapi_source_query_param` r | ||
| 416 | WHERE r.`kind` = 'secret' AND r.`secret_id` IS NOT NULL;--> statement-breakpoint | ||
| 417 | |||
| 418 | DROP TABLE `__openapi_query_param_slot_preflight`;--> statement-breakpoint | ||
| 419 | |||
| 420 | WITH rows AS ( | ||
| 421 | SELECT | ||
| 422 | r.`scope_id`, | ||
| 423 | r.`source_id`, | ||
| 424 | 'query_param:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = r.`name`), 'default') AS `slot_key`, | ||
| 425 | r.`secret_id` | ||
| 426 | FROM `openapi_source_query_param` r | ||
| 427 | WHERE r.`kind` = 'secret' AND r.`secret_id` IS NOT NULL | ||
| 428 | ) | ||
| 429 | INSERT OR REPLACE INTO `credential_binding` ( | ||
| 430 | `id`, `scope_id`, `plugin_id`, `source_id`, `source_scope_id`, `slot_key`, | ||
| 431 | `kind`, `text_value`, `secret_id`, `connection_id`, `created_at`, `updated_at` | ||
| 432 | ) | ||
| 433 | SELECT | ||
| 434 | json_array('openapi', r.`scope_id`, r.`source_id`, r.`slot_key`), | ||
| 435 | r.`scope_id`, | ||
| 436 | 'openapi', | ||
| 437 | r.`source_id`, | ||
| 438 | r.`scope_id`, | ||
| 439 | r.`slot_key`, | ||
| 440 | 'secret', | ||
| 441 | NULL, | ||
| 442 | r.`secret_id`, | ||
| 443 | NULL, | ||
| 444 | CAST(strftime('%s', 'now') AS INTEGER) * 1000, | ||
| 445 | CAST(strftime('%s', 'now') AS INTEGER) * 1000 | ||
| 446 | FROM rows r | ||
| 447 | WHERE NOT EXISTS ( | ||
| 448 | SELECT 1 FROM `credential_binding` b | ||
| 449 | WHERE b.`scope_id` = r.`scope_id` | ||
| 450 | AND b.`plugin_id` = 'openapi' | ||
| 451 | AND b.`source_id` = r.`source_id` | ||
| 452 | AND b.`source_scope_id` = r.`scope_id` | ||
| 453 | AND b.`slot_key` = r.`slot_key` | ||
| 454 | );--> statement-breakpoint | ||
| 455 | |||
| 456 | ALTER TABLE `openapi_source_query_param` ADD `slot_key` text;--> statement-breakpoint | ||
| 457 | ALTER TABLE `openapi_source_query_param` ADD `prefix` text;--> statement-breakpoint | ||
| 458 | UPDATE `openapi_source_query_param` | ||
| 459 | SET | ||
| 460 | `slot_key` = 'query_param:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = `name`), 'default'), | ||
| 461 | `prefix` = `secret_prefix`, | ||
| 462 | `kind` = 'binding' | ||
| 463 | WHERE `kind` = 'secret';--> statement-breakpoint | ||
| 464 | DROP INDEX `openapi_source_query_param_secret_id_idx`;--> statement-breakpoint | ||
| 465 | ALTER TABLE `openapi_source_query_param` DROP COLUMN `secret_id`;--> statement-breakpoint | ||
| 466 | ALTER TABLE `openapi_source_query_param` DROP COLUMN `secret_prefix`;--> statement-breakpoint | ||
| 467 | |||
| 468 | CREATE TEMP TABLE `__openapi_spec_fetch_header_slot_preflight` ( | ||
| 469 | `scope_id` text NOT NULL, | ||
| 470 | `source_id` text NOT NULL, | ||
| 471 | `slot_key` text NOT NULL, | ||
| 472 | PRIMARY KEY (`scope_id`, `source_id`, `slot_key`) | ||
| 473 | );--> statement-breakpoint | ||
| 474 | |||
| 475 | INSERT INTO `__openapi_spec_fetch_header_slot_preflight` (`scope_id`, `source_id`, `slot_key`) | ||
| 476 | SELECT | ||
| 477 | r.`scope_id`, | ||
| 478 | r.`source_id`, | ||
| 479 | 'spec_fetch_header:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = r.`name`), 'default') AS `slot_key` | ||
| 480 | FROM `openapi_source_spec_fetch_header` r | ||
| 481 | WHERE r.`kind` = 'secret' AND r.`secret_id` IS NOT NULL;--> statement-breakpoint | ||
| 482 | |||
| 483 | DROP TABLE `__openapi_spec_fetch_header_slot_preflight`;--> statement-breakpoint | ||
| 484 | |||
| 485 | WITH rows AS ( | ||
| 486 | SELECT | ||
| 487 | r.`scope_id`, | ||
| 488 | r.`source_id`, | ||
| 489 | 'spec_fetch_header:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = r.`name`), 'default') AS `slot_key`, | ||
| 490 | r.`secret_id` | ||
| 491 | FROM `openapi_source_spec_fetch_header` r | ||
| 492 | WHERE r.`kind` = 'secret' AND r.`secret_id` IS NOT NULL | ||
| 493 | ) | ||
| 494 | INSERT OR REPLACE INTO `credential_binding` ( | ||
| 495 | `id`, `scope_id`, `plugin_id`, `source_id`, `source_scope_id`, `slot_key`, | ||
| 496 | `kind`, `text_value`, `secret_id`, `connection_id`, `created_at`, `updated_at` | ||
| 497 | ) | ||
| 498 | SELECT | ||
| 499 | json_array('openapi', r.`scope_id`, r.`source_id`, r.`slot_key`), | ||
| 500 | r.`scope_id`, | ||
| 501 | 'openapi', | ||
| 502 | r.`source_id`, | ||
| 503 | r.`scope_id`, | ||
| 504 | r.`slot_key`, | ||
| 505 | 'secret', | ||
| 506 | NULL, | ||
| 507 | r.`secret_id`, | ||
| 508 | NULL, | ||
| 509 | CAST(strftime('%s', 'now') AS INTEGER) * 1000, | ||
| 510 | CAST(strftime('%s', 'now') AS INTEGER) * 1000 | ||
| 511 | FROM rows r | ||
| 512 | WHERE NOT EXISTS ( | ||
| 513 | SELECT 1 FROM `credential_binding` b | ||
| 514 | WHERE b.`scope_id` = r.`scope_id` | ||
| 515 | AND b.`plugin_id` = 'openapi' | ||
| 516 | AND b.`source_id` = r.`source_id` | ||
| 517 | AND b.`source_scope_id` = r.`scope_id` | ||
| 518 | AND b.`slot_key` = r.`slot_key` | ||
| 519 | );--> statement-breakpoint | ||
| 520 | |||
| 521 | ALTER TABLE `openapi_source_spec_fetch_header` ADD `slot_key` text;--> statement-breakpoint | ||
| 522 | ALTER TABLE `openapi_source_spec_fetch_header` ADD `prefix` text;--> statement-breakpoint | ||
| 523 | UPDATE `openapi_source_spec_fetch_header` | ||
| 524 | SET | ||
| 525 | `slot_key` = 'spec_fetch_header:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = `name`), 'default'), | ||
| 526 | `prefix` = `secret_prefix`, | ||
| 527 | `kind` = 'binding' | ||
| 528 | WHERE `kind` = 'secret';--> statement-breakpoint | ||
| 529 | DROP INDEX `openapi_source_spec_fetch_header_secret_id_idx`;--> statement-breakpoint | ||
| 530 | ALTER TABLE `openapi_source_spec_fetch_header` DROP COLUMN `secret_id`;--> statement-breakpoint | ||
| 531 | ALTER TABLE `openapi_source_spec_fetch_header` DROP COLUMN `secret_prefix`;--> statement-breakpoint | ||
| 532 | |||
| 533 | CREATE TEMP TABLE `__openapi_spec_fetch_query_param_slot_preflight` ( | ||
| 534 | `scope_id` text NOT NULL, | ||
| 535 | `source_id` text NOT NULL, | ||
| 536 | `slot_key` text NOT NULL, | ||
| 537 | PRIMARY KEY (`scope_id`, `source_id`, `slot_key`) | ||
| 538 | );--> statement-breakpoint | ||
| 539 | |||
| 540 | INSERT INTO `__openapi_spec_fetch_query_param_slot_preflight` (`scope_id`, `source_id`, `slot_key`) | ||
| 541 | SELECT | ||
| 542 | r.`scope_id`, | ||
| 543 | r.`source_id`, | ||
| 544 | 'spec_fetch_query_param:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = r.`name`), 'default') AS `slot_key` | ||
| 545 | FROM `openapi_source_spec_fetch_query_param` r | ||
| 546 | WHERE r.`kind` = 'secret' AND r.`secret_id` IS NOT NULL;--> statement-breakpoint | ||
| 547 | |||
| 548 | DROP TABLE `__openapi_spec_fetch_query_param_slot_preflight`;--> statement-breakpoint | ||
| 549 | |||
| 550 | WITH rows AS ( | ||
| 551 | SELECT | ||
| 552 | r.`scope_id`, | ||
| 553 | r.`source_id`, | ||
| 554 | 'spec_fetch_query_param:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = r.`name`), 'default') AS `slot_key`, | ||
| 555 | r.`secret_id` | ||
| 556 | FROM `openapi_source_spec_fetch_query_param` r | ||
| 557 | WHERE r.`kind` = 'secret' AND r.`secret_id` IS NOT NULL | ||
| 558 | ) | ||
| 559 | INSERT OR REPLACE INTO `credential_binding` ( | ||
| 560 | `id`, `scope_id`, `plugin_id`, `source_id`, `source_scope_id`, `slot_key`, | ||
| 561 | `kind`, `text_value`, `secret_id`, `connection_id`, `created_at`, `updated_at` | ||
| 562 | ) | ||
| 563 | SELECT | ||
| 564 | json_array('openapi', r.`scope_id`, r.`source_id`, r.`slot_key`), | ||
| 565 | r.`scope_id`, | ||
| 566 | 'openapi', | ||
| 567 | r.`source_id`, | ||
| 568 | r.`scope_id`, | ||
| 569 | r.`slot_key`, | ||
| 570 | 'secret', | ||
| 571 | NULL, | ||
| 572 | r.`secret_id`, | ||
| 573 | NULL, | ||
| 574 | CAST(strftime('%s', 'now') AS INTEGER) * 1000, | ||
| 575 | CAST(strftime('%s', 'now') AS INTEGER) * 1000 | ||
| 576 | FROM rows r | ||
| 577 | WHERE NOT EXISTS ( | ||
| 578 | SELECT 1 FROM `credential_binding` b | ||
| 579 | WHERE b.`scope_id` = r.`scope_id` | ||
| 580 | AND b.`plugin_id` = 'openapi' | ||
| 581 | AND b.`source_id` = r.`source_id` | ||
| 582 | AND b.`source_scope_id` = r.`scope_id` | ||
| 583 | AND b.`slot_key` = r.`slot_key` | ||
| 584 | );--> statement-breakpoint | ||
| 585 | |||
| 586 | ALTER TABLE `openapi_source_spec_fetch_query_param` ADD `slot_key` text;--> statement-breakpoint | ||
| 587 | ALTER TABLE `openapi_source_spec_fetch_query_param` ADD `prefix` text;--> statement-breakpoint | ||
| 588 | UPDATE `openapi_source_spec_fetch_query_param` | ||
| 589 | SET | ||
| 590 | `slot_key` = 'spec_fetch_query_param:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = `name`), 'default'), | ||
| 591 | `prefix` = `secret_prefix`, | ||
| 592 | `kind` = 'binding' | ||
| 593 | WHERE `kind` = 'secret';--> statement-breakpoint | ||
| 594 | DROP INDEX `openapi_source_spec_fetch_query_param_secret_id_idx`;--> statement-breakpoint | ||
| 595 | ALTER TABLE `openapi_source_spec_fetch_query_param` DROP COLUMN `secret_id`;--> statement-breakpoint | ||
| 596 | ALTER TABLE `openapi_source_spec_fetch_query_param` DROP COLUMN `secret_prefix`;--> statement-breakpoint | ||
| 597 | |||
| 598 | -- 0011_graphql_credential_slots.sql | ||
| 599 | -- Convert GraphQL's direct credential references to source-owned slot | ||
| 600 | -- structure plus shared core credential_binding rows. Runtime code only | ||
| 601 | -- reads the final slot model; this migration is the one-shot bridge. | ||
| 602 | |||
| 603 | ALTER TABLE `graphql_source` ADD `auth_connection_slot` text;--> statement-breakpoint | ||
| 604 | |||
| 605 | UPDATE `graphql_source` | ||
| 606 | SET `auth_connection_slot` = 'auth:oauth2:connection' | ||
| 607 | WHERE `auth_kind` = 'oauth2' | ||
| 608 | AND `auth_connection_id` IS NOT NULL;--> statement-breakpoint | ||
| 609 | |||
| 610 | INSERT OR REPLACE INTO `credential_binding` ( | ||
| 611 | `id`, `scope_id`, `plugin_id`, `source_id`, `source_scope_id`, `slot_key`, | ||
| 612 | `kind`, `text_value`, `secret_id`, `connection_id`, `created_at`, `updated_at` | ||
| 613 | ) | ||
| 614 | SELECT | ||
| 615 | json_array('graphql', s.`scope_id`, s.`id`, 'auth:oauth2:connection'), | ||
| 616 | s.`scope_id`, | ||
| 617 | 'graphql', | ||
| 618 | s.`id`, | ||
| 619 | s.`scope_id`, | ||
| 620 | 'auth:oauth2:connection', | ||
| 621 | 'connection', | ||
| 622 | NULL, | ||
| 623 | NULL, | ||
| 624 | s.`auth_connection_id`, | ||
| 625 | CAST(strftime('%s', 'now') AS INTEGER) * 1000, | ||
| 626 | CAST(strftime('%s', 'now') AS INTEGER) * 1000 | ||
| 627 | FROM `graphql_source` s | ||
| 628 | WHERE s.`auth_kind` = 'oauth2' | ||
| 629 | AND s.`auth_connection_id` IS NOT NULL;--> statement-breakpoint | ||
| 630 | |||
| 631 | DROP INDEX `graphql_source_auth_connection_id_idx`;--> statement-breakpoint | ||
| 632 | ALTER TABLE `graphql_source` DROP COLUMN `auth_connection_id`;--> statement-breakpoint | ||
| 633 | |||
| 634 | ALTER TABLE `graphql_source_header` ADD `slot_key` text;--> statement-breakpoint | ||
| 635 | ALTER TABLE `graphql_source_header` ADD `prefix` text;--> statement-breakpoint | ||
| 636 | |||
| 637 | CREATE TEMP TABLE `__graphql_header_slot_preflight` ( | ||
| 638 | `scope_id` text NOT NULL, | ||
| 639 | `source_id` text NOT NULL, | ||
| 640 | `slot_key` text NOT NULL, | ||
| 641 | PRIMARY KEY (`scope_id`, `source_id`, `slot_key`) | ||
| 642 | );--> statement-breakpoint | ||
| 643 | |||
| 644 | INSERT INTO `__graphql_header_slot_preflight` (`scope_id`, `source_id`, `slot_key`) | ||
| 645 | SELECT | ||
| 646 | h.`scope_id`, | ||
| 647 | h.`source_id`, | ||
| 648 | 'header:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = h.`name`), 'default') AS `slot_key` | ||
| 649 | FROM `graphql_source_header` h | ||
| 650 | WHERE h.`kind` = 'secret' | ||
| 651 | AND h.`secret_id` IS NOT NULL;--> statement-breakpoint | ||
| 652 | |||
| 653 | DROP TABLE `__graphql_header_slot_preflight`;--> statement-breakpoint | ||
| 654 | |||
| 655 | WITH header_rows AS ( | ||
| 656 | SELECT | ||
| 657 | h.`scope_id`, | ||
| 658 | h.`source_id`, | ||
| 659 | h.`name`, | ||
| 660 | 'header:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = h.`name`), 'default') AS `slot_key`, | ||
| 661 | h.`secret_id`, | ||
| 662 | h.`secret_prefix` | ||
| 663 | FROM `graphql_source_header` h | ||
| 664 | WHERE h.`kind` = 'secret' | ||
| 665 | AND h.`secret_id` IS NOT NULL | ||
| 666 | ) | ||
| 667 | INSERT OR REPLACE INTO `credential_binding` ( | ||
| 668 | `id`, `scope_id`, `plugin_id`, `source_id`, `source_scope_id`, `slot_key`, | ||
| 669 | `kind`, `text_value`, `secret_id`, `connection_id`, `created_at`, `updated_at` | ||
| 670 | ) | ||
| 671 | SELECT | ||
| 672 | json_array('graphql', r.`scope_id`, r.`source_id`, r.`slot_key`), | ||
| 673 | r.`scope_id`, | ||
| 674 | 'graphql', | ||
| 675 | r.`source_id`, | ||
| 676 | r.`scope_id`, | ||
| 677 | r.`slot_key`, | ||
| 678 | 'secret', | ||
| 679 | NULL, | ||
| 680 | r.`secret_id`, | ||
| 681 | NULL, | ||
| 682 | CAST(strftime('%s', 'now') AS INTEGER) * 1000, | ||
| 683 | CAST(strftime('%s', 'now') AS INTEGER) * 1000 | ||
| 684 | FROM header_rows r;--> statement-breakpoint | ||
| 685 | |||
| 686 | UPDATE `graphql_source_header` | ||
| 687 | SET | ||
| 688 | `kind` = 'binding', | ||
| 689 | `slot_key` = 'header:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = `name`), 'default'), | ||
| 690 | `prefix` = `secret_prefix`, | ||
| 691 | `text_value` = NULL | ||
| 692 | WHERE `kind` = 'secret' | ||
| 693 | AND `secret_id` IS NOT NULL;--> statement-breakpoint | ||
| 694 | |||
| 695 | DROP INDEX `graphql_source_header_secret_id_idx`;--> statement-breakpoint | ||
| 696 | ALTER TABLE `graphql_source_header` DROP COLUMN `secret_id`;--> statement-breakpoint | ||
| 697 | ALTER TABLE `graphql_source_header` DROP COLUMN `secret_prefix`;--> statement-breakpoint | ||
| 698 | |||
| 699 | ALTER TABLE `graphql_source_query_param` ADD `slot_key` text;--> statement-breakpoint | ||
| 700 | ALTER TABLE `graphql_source_query_param` ADD `prefix` text;--> statement-breakpoint | ||
| 701 | |||
| 702 | CREATE TEMP TABLE `__graphql_query_param_slot_preflight` ( | ||
| 703 | `scope_id` text NOT NULL, | ||
| 704 | `source_id` text NOT NULL, | ||
| 705 | `slot_key` text NOT NULL, | ||
| 706 | PRIMARY KEY (`scope_id`, `source_id`, `slot_key`) | ||
| 707 | );--> statement-breakpoint | ||
| 708 | |||
| 709 | INSERT INTO `__graphql_query_param_slot_preflight` (`scope_id`, `source_id`, `slot_key`) | ||
| 710 | SELECT | ||
| 711 | q.`scope_id`, | ||
| 712 | q.`source_id`, | ||
| 713 | 'query_param:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = q.`name`), 'default') AS `slot_key` | ||
| 714 | FROM `graphql_source_query_param` q | ||
| 715 | WHERE q.`kind` = 'secret' | ||
| 716 | AND q.`secret_id` IS NOT NULL;--> statement-breakpoint | ||
| 717 | |||
| 718 | DROP TABLE `__graphql_query_param_slot_preflight`;--> statement-breakpoint | ||
| 719 | |||
| 720 | WITH query_param_rows AS ( | ||
| 721 | SELECT | ||
| 722 | q.`scope_id`, | ||
| 723 | q.`source_id`, | ||
| 724 | q.`name`, | ||
| 725 | 'query_param:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = q.`name`), 'default') AS `slot_key`, | ||
| 726 | q.`secret_id`, | ||
| 727 | q.`secret_prefix` | ||
| 728 | FROM `graphql_source_query_param` q | ||
| 729 | WHERE q.`kind` = 'secret' | ||
| 730 | AND q.`secret_id` IS NOT NULL | ||
| 731 | ) | ||
| 732 | INSERT OR REPLACE INTO `credential_binding` ( | ||
| 733 | `id`, `scope_id`, `plugin_id`, `source_id`, `source_scope_id`, `slot_key`, | ||
| 734 | `kind`, `text_value`, `secret_id`, `connection_id`, `created_at`, `updated_at` | ||
| 735 | ) | ||
| 736 | SELECT | ||
| 737 | json_array('graphql', r.`scope_id`, r.`source_id`, r.`slot_key`), | ||
| 738 | r.`scope_id`, | ||
| 739 | 'graphql', | ||
| 740 | r.`source_id`, | ||
| 741 | r.`scope_id`, | ||
| 742 | r.`slot_key`, | ||
| 743 | 'secret', | ||
| 744 | NULL, | ||
| 745 | r.`secret_id`, | ||
| 746 | NULL, | ||
| 747 | CAST(strftime('%s', 'now') AS INTEGER) * 1000, | ||
| 748 | CAST(strftime('%s', 'now') AS INTEGER) * 1000 | ||
| 749 | FROM query_param_rows r;--> statement-breakpoint | ||
| 750 | |||
| 751 | UPDATE `graphql_source_query_param` | ||
| 752 | SET | ||
| 753 | `kind` = 'binding', | ||
| 754 | `slot_key` = 'query_param:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = `name`), 'default'), | ||
| 755 | `prefix` = `secret_prefix`, | ||
| 756 | `text_value` = NULL | ||
| 757 | WHERE `kind` = 'secret' | ||
| 758 | AND `secret_id` IS NOT NULL;--> statement-breakpoint | ||
| 759 | |||
| 760 | DROP INDEX `graphql_source_query_param_secret_id_idx`;--> statement-breakpoint | ||
| 761 | ALTER TABLE `graphql_source_query_param` DROP COLUMN `secret_id`;--> statement-breakpoint | ||
| 762 | ALTER TABLE `graphql_source_query_param` DROP COLUMN `secret_prefix`;--> statement-breakpoint | ||
| 763 | |||
| 764 | -- 0012_mcp_credential_slots.sql | ||
| 765 | -- Convert MCP direct credential references to source-owned slot structure | ||
| 766 | -- plus shared core credential_binding rows. Runtime code only reads the | ||
| 767 | -- final slot model; this migration is the one-shot bridge from old data. | ||
| 768 | |||
| 769 | ALTER TABLE `mcp_source` ADD `auth_header_slot` text;--> statement-breakpoint | ||
| 770 | ALTER TABLE `mcp_source` ADD `auth_header_prefix` text;--> statement-breakpoint | ||
| 771 | ALTER TABLE `mcp_source` ADD `auth_connection_slot` text;--> statement-breakpoint | ||
| 772 | ALTER TABLE `mcp_source` ADD `auth_client_id_slot` text;--> statement-breakpoint | ||
| 773 | ALTER TABLE `mcp_source` ADD `auth_client_secret_slot` text;--> statement-breakpoint | ||
| 774 | |||
| 775 | UPDATE `mcp_source` | ||
| 776 | SET | ||
| 777 | `auth_header_slot` = 'auth:header', | ||
| 778 | `auth_header_prefix` = `auth_secret_prefix` | ||
| 779 | WHERE `auth_kind` = 'header' | ||
| 780 | AND `auth_secret_id` IS NOT NULL;--> statement-breakpoint | ||
| 781 | |||
| 782 | INSERT OR REPLACE INTO `credential_binding` ( | ||
| 783 | `id`, `scope_id`, `plugin_id`, `source_id`, `source_scope_id`, `slot_key`, | ||
| 784 | `kind`, `text_value`, `secret_id`, `connection_id`, `created_at`, `updated_at` | ||
| 785 | ) | ||
| 786 | SELECT | ||
| 787 | json_array('mcp', s.`scope_id`, s.`id`, 'auth:header'), | ||
| 788 | s.`scope_id`, | ||
| 789 | 'mcp', | ||
| 790 | s.`id`, | ||
| 791 | s.`scope_id`, | ||
| 792 | 'auth:header', | ||
| 793 | 'secret', | ||
| 794 | NULL, | ||
| 795 | s.`auth_secret_id`, | ||
| 796 | NULL, | ||
| 797 | CAST(strftime('%s', 'now') AS INTEGER) * 1000, | ||
| 798 | CAST(strftime('%s', 'now') AS INTEGER) * 1000 | ||
| 799 | FROM `mcp_source` s | ||
| 800 | WHERE s.`auth_kind` = 'header' | ||
| 801 | AND s.`auth_secret_id` IS NOT NULL;--> statement-breakpoint | ||
| 802 | |||
| 803 | UPDATE `mcp_source` | ||
| 804 | SET | ||
| 805 | `auth_connection_slot` = 'auth:oauth2:connection', | ||
| 806 | `auth_client_id_slot` = CASE | ||
| 807 | WHEN `auth_client_id_secret_id` IS NOT NULL THEN 'auth:oauth2:client-id' | ||
| 808 | ELSE NULL | ||
| 809 | END, | ||
| 810 | `auth_client_secret_slot` = CASE | ||
| 811 | WHEN `auth_client_secret_secret_id` IS NOT NULL THEN 'auth:oauth2:client-secret' | ||
| 812 | ELSE NULL | ||
| 813 | END | ||
| 814 | WHERE `auth_kind` = 'oauth2' | ||
| 815 | AND `auth_connection_id` IS NOT NULL;--> statement-breakpoint | ||
| 816 | |||
| 817 | INSERT OR REPLACE INTO `credential_binding` ( | ||
| 818 | `id`, `scope_id`, `plugin_id`, `source_id`, `source_scope_id`, `slot_key`, | ||
| 819 | `kind`, `text_value`, `secret_id`, `connection_id`, `created_at`, `updated_at` | ||
| 820 | ) | ||
| 821 | SELECT | ||
| 822 | json_array('mcp', s.`scope_id`, s.`id`, 'auth:oauth2:connection'), | ||
| 823 | s.`scope_id`, | ||
| 824 | 'mcp', | ||
| 825 | s.`id`, | ||
| 826 | s.`scope_id`, | ||
| 827 | 'auth:oauth2:connection', | ||
| 828 | 'connection', | ||
| 829 | NULL, | ||
| 830 | NULL, | ||
| 831 | s.`auth_connection_id`, | ||
| 832 | CAST(strftime('%s', 'now') AS INTEGER) * 1000, | ||
| 833 | CAST(strftime('%s', 'now') AS INTEGER) * 1000 | ||
| 834 | FROM `mcp_source` s | ||
| 835 | WHERE s.`auth_kind` = 'oauth2' | ||
| 836 | AND s.`auth_connection_id` IS NOT NULL;--> statement-breakpoint | ||
| 837 | |||
| 838 | INSERT OR REPLACE INTO `credential_binding` ( | ||
| 839 | `id`, `scope_id`, `plugin_id`, `source_id`, `source_scope_id`, `slot_key`, | ||
| 840 | `kind`, `text_value`, `secret_id`, `connection_id`, `created_at`, `updated_at` | ||
| 841 | ) | ||
| 842 | SELECT | ||
| 843 | json_array('mcp', s.`scope_id`, s.`id`, 'auth:oauth2:client-id'), | ||
| 844 | s.`scope_id`, | ||
| 845 | 'mcp', | ||
| 846 | s.`id`, | ||
| 847 | s.`scope_id`, | ||
| 848 | 'auth:oauth2:client-id', | ||
| 849 | 'secret', | ||
| 850 | NULL, | ||
| 851 | s.`auth_client_id_secret_id`, | ||
| 852 | NULL, | ||
| 853 | CAST(strftime('%s', 'now') AS INTEGER) * 1000, | ||
| 854 | CAST(strftime('%s', 'now') AS INTEGER) * 1000 | ||
| 855 | FROM `mcp_source` s | ||
| 856 | WHERE s.`auth_kind` = 'oauth2' | ||
| 857 | AND s.`auth_client_id_secret_id` IS NOT NULL;--> statement-breakpoint | ||
| 858 | |||
| 859 | INSERT OR REPLACE INTO `credential_binding` ( | ||
| 860 | `id`, `scope_id`, `plugin_id`, `source_id`, `source_scope_id`, `slot_key`, | ||
| 861 | `kind`, `text_value`, `secret_id`, `connection_id`, `created_at`, `updated_at` | ||
| 862 | ) | ||
| 863 | SELECT | ||
| 864 | json_array('mcp', s.`scope_id`, s.`id`, 'auth:oauth2:client-secret'), | ||
| 865 | s.`scope_id`, | ||
| 866 | 'mcp', | ||
| 867 | s.`id`, | ||
| 868 | s.`scope_id`, | ||
| 869 | 'auth:oauth2:client-secret', | ||
| 870 | 'secret', | ||
| 871 | NULL, | ||
| 872 | s.`auth_client_secret_secret_id`, | ||
| 873 | NULL, | ||
| 874 | CAST(strftime('%s', 'now') AS INTEGER) * 1000, | ||
| 875 | CAST(strftime('%s', 'now') AS INTEGER) * 1000 | ||
| 876 | FROM `mcp_source` s | ||
| 877 | WHERE s.`auth_kind` = 'oauth2' | ||
| 878 | AND s.`auth_client_secret_secret_id` IS NOT NULL;--> statement-breakpoint | ||
| 879 | |||
| 880 | DROP INDEX `mcp_source_auth_secret_id_idx`;--> statement-breakpoint | ||
| 881 | DROP INDEX `mcp_source_auth_connection_id_idx`;--> statement-breakpoint | ||
| 882 | DROP INDEX `mcp_source_auth_client_id_secret_id_idx`;--> statement-breakpoint | ||
| 883 | DROP INDEX `mcp_source_auth_client_secret_secret_id_idx`;--> statement-breakpoint | ||
| 884 | ALTER TABLE `mcp_source` DROP COLUMN `auth_secret_id`;--> statement-breakpoint | ||
| 885 | ALTER TABLE `mcp_source` DROP COLUMN `auth_secret_prefix`;--> statement-breakpoint | ||
| 886 | ALTER TABLE `mcp_source` DROP COLUMN `auth_connection_id`;--> statement-breakpoint | ||
| 887 | ALTER TABLE `mcp_source` DROP COLUMN `auth_client_id_secret_id`;--> statement-breakpoint | ||
| 888 | ALTER TABLE `mcp_source` DROP COLUMN `auth_client_secret_secret_id`;--> statement-breakpoint | ||
| 889 | |||
| 890 | ALTER TABLE `mcp_source_header` ADD `slot_key` text;--> statement-breakpoint | ||
| 891 | ALTER TABLE `mcp_source_header` ADD `prefix` text;--> statement-breakpoint | ||
| 892 | |||
| 893 | CREATE TEMP TABLE `__mcp_header_slot_preflight` ( | ||
| 894 | `scope_id` text NOT NULL, | ||
| 895 | `source_id` text NOT NULL, | ||
| 896 | `slot_key` text NOT NULL, | ||
| 897 | PRIMARY KEY (`scope_id`, `source_id`, `slot_key`) | ||
| 898 | );--> statement-breakpoint | ||
| 899 | |||
| 900 | INSERT INTO `__mcp_header_slot_preflight` (`scope_id`, `source_id`, `slot_key`) | ||
| 901 | SELECT | ||
| 902 | h.`scope_id`, | ||
| 903 | h.`source_id`, | ||
| 904 | 'header:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = h.`name`), 'default') AS `slot_key` | ||
| 905 | FROM `mcp_source_header` h | ||
| 906 | WHERE h.`kind` = 'secret' | ||
| 907 | AND h.`secret_id` IS NOT NULL;--> statement-breakpoint | ||
| 908 | |||
| 909 | DROP TABLE `__mcp_header_slot_preflight`;--> statement-breakpoint | ||
| 910 | |||
| 911 | WITH header_rows AS ( | ||
| 912 | SELECT | ||
| 913 | h.`scope_id`, | ||
| 914 | h.`source_id`, | ||
| 915 | h.`name`, | ||
| 916 | 'header:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = h.`name`), 'default') AS `slot_key`, | ||
| 917 | h.`secret_id`, | ||
| 918 | h.`secret_prefix` | ||
| 919 | FROM `mcp_source_header` h | ||
| 920 | WHERE h.`kind` = 'secret' | ||
| 921 | AND h.`secret_id` IS NOT NULL | ||
| 922 | ) | ||
| 923 | INSERT OR REPLACE INTO `credential_binding` ( | ||
| 924 | `id`, `scope_id`, `plugin_id`, `source_id`, `source_scope_id`, `slot_key`, | ||
| 925 | `kind`, `text_value`, `secret_id`, `connection_id`, `created_at`, `updated_at` | ||
| 926 | ) | ||
| 927 | SELECT | ||
| 928 | json_array('mcp', r.`scope_id`, r.`source_id`, r.`slot_key`), | ||
| 929 | r.`scope_id`, | ||
| 930 | 'mcp', | ||
| 931 | r.`source_id`, | ||
| 932 | r.`scope_id`, | ||
| 933 | r.`slot_key`, | ||
| 934 | 'secret', | ||
| 935 | NULL, | ||
| 936 | r.`secret_id`, | ||
| 937 | NULL, | ||
| 938 | CAST(strftime('%s', 'now') AS INTEGER) * 1000, | ||
| 939 | CAST(strftime('%s', 'now') AS INTEGER) * 1000 | ||
| 940 | FROM header_rows r;--> statement-breakpoint | ||
| 941 | |||
| 942 | UPDATE `mcp_source_header` | ||
| 943 | SET | ||
| 944 | `kind` = 'binding', | ||
| 945 | `slot_key` = 'header:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = `name`), 'default'), | ||
| 946 | `prefix` = `secret_prefix`, | ||
| 947 | `text_value` = NULL | ||
| 948 | WHERE `kind` = 'secret' | ||
| 949 | AND `secret_id` IS NOT NULL;--> statement-breakpoint | ||
| 950 | |||
| 951 | DROP INDEX `mcp_source_header_secret_id_idx`;--> statement-breakpoint | ||
| 952 | ALTER TABLE `mcp_source_header` DROP COLUMN `secret_id`;--> statement-breakpoint | ||
| 953 | ALTER TABLE `mcp_source_header` DROP COLUMN `secret_prefix`;--> statement-breakpoint | ||
| 954 | |||
| 955 | ALTER TABLE `mcp_source_query_param` ADD `slot_key` text;--> statement-breakpoint | ||
| 956 | ALTER TABLE `mcp_source_query_param` ADD `prefix` text;--> statement-breakpoint | ||
| 957 | |||
| 958 | CREATE TEMP TABLE `__mcp_query_param_slot_preflight` ( | ||
| 959 | `scope_id` text NOT NULL, | ||
| 960 | `source_id` text NOT NULL, | ||
| 961 | `slot_key` text NOT NULL, | ||
| 962 | PRIMARY KEY (`scope_id`, `source_id`, `slot_key`) | ||
| 963 | );--> statement-breakpoint | ||
| 964 | |||
| 965 | INSERT INTO `__mcp_query_param_slot_preflight` (`scope_id`, `source_id`, `slot_key`) | ||
| 966 | SELECT | ||
| 967 | q.`scope_id`, | ||
| 968 | q.`source_id`, | ||
| 969 | 'query_param:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = q.`name`), 'default') AS `slot_key` | ||
| 970 | FROM `mcp_source_query_param` q | ||
| 971 | WHERE q.`kind` = 'secret' | ||
| 972 | AND q.`secret_id` IS NOT NULL;--> statement-breakpoint | ||
| 973 | |||
| 974 | DROP TABLE `__mcp_query_param_slot_preflight`;--> statement-breakpoint | ||
| 975 | |||
| 976 | WITH query_param_rows AS ( | ||
| 977 | SELECT | ||
| 978 | q.`scope_id`, | ||
| 979 | q.`source_id`, | ||
| 980 | q.`name`, | ||
| 981 | 'query_param:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = q.`name`), 'default') AS `slot_key`, | ||
| 982 | q.`secret_id`, | ||
| 983 | q.`secret_prefix` | ||
| 984 | FROM `mcp_source_query_param` q | ||
| 985 | WHERE q.`kind` = 'secret' | ||
| 986 | AND q.`secret_id` IS NOT NULL | ||
| 987 | ) | ||
| 988 | INSERT OR REPLACE INTO `credential_binding` ( | ||
| 989 | `id`, `scope_id`, `plugin_id`, `source_id`, `source_scope_id`, `slot_key`, | ||
| 990 | `kind`, `text_value`, `secret_id`, `connection_id`, `created_at`, `updated_at` | ||
| 991 | ) | ||
| 992 | SELECT | ||
| 993 | json_array('mcp', r.`scope_id`, r.`source_id`, r.`slot_key`), | ||
| 994 | r.`scope_id`, | ||
| 995 | 'mcp', | ||
| 996 | r.`source_id`, | ||
| 997 | r.`scope_id`, | ||
| 998 | r.`slot_key`, | ||
| 999 | 'secret', | ||
| 1000 | NULL, | ||
| 1001 | r.`secret_id`, | ||
| 1002 | NULL, | ||
| 1003 | CAST(strftime('%s', 'now') AS INTEGER) * 1000, | ||
| 1004 | CAST(strftime('%s', 'now') AS INTEGER) * 1000 | ||
| 1005 | FROM query_param_rows r;--> statement-breakpoint | ||
| 1006 | |||
| 1007 | UPDATE `mcp_source_query_param` | ||
| 1008 | SET | ||
| 1009 | `kind` = 'binding', | ||
| 1010 | `slot_key` = 'query_param:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = `name`), 'default'), | ||
| 1011 | `prefix` = `secret_prefix`, | ||
| 1012 | `text_value` = NULL | ||
| 1013 | WHERE `kind` = 'secret' | ||
| 1014 | AND `secret_id` IS NOT NULL;--> statement-breakpoint | ||
| 1015 | |||
| 1016 | DROP INDEX `mcp_source_query_param_secret_id_idx`;--> statement-breakpoint | ||
| 1017 | ALTER TABLE `mcp_source_query_param` DROP COLUMN `secret_id`;--> statement-breakpoint | ||
| 1018 | ALTER TABLE `mcp_source_query_param` DROP COLUMN `secret_prefix`;--> statement-breakpoint | ||
| 1019 | |||
| 1020 | -- 0013_normalize_oauth_connections.sql | ||
| 1021 | -- Normalize pre-unified OAuth connection rows to the canonical core | ||
| 1022 | -- provider/provider_state shape. Runtime refresh only reads provider='oauth2' | ||
| 1023 | -- and provider_state.kind after this one-shot data migration. | ||
| 1024 | |||
| 1025 | UPDATE `connection` | ||
| 1026 | SET | ||
| 1027 | `provider` = 'oauth2', | ||
| 1028 | `provider_state` = json_object( | ||
| 1029 | 'kind', CASE json_extract(`provider_state`, '$.flow') | ||
| 1030 | WHEN 'authorizationCode' THEN 'authorization-code' | ||
| 1031 | ELSE 'client-credentials' | ||
| 1032 | END, | ||
| 1033 | 'tokenEndpoint', json_extract(`provider_state`, '$.tokenUrl'), | ||
| 1034 | 'issuerUrl', NULL, | ||
| 1035 | 'clientIdSecretId', json_extract(`provider_state`, '$.clientIdSecretId'), | ||
| 1036 | 'clientSecretSecretId', CASE json_extract(`provider_state`, '$.flow') | ||
| 1037 | WHEN 'clientCredentials' THEN coalesce(json_extract(`provider_state`, '$.clientSecretSecretId'), '') | ||
| 1038 | ELSE json_extract(`provider_state`, '$.clientSecretSecretId') | ||
| 1039 | END, | ||
| 1040 | 'clientAuth', 'body', | ||
| 1041 | 'scopes', coalesce(json_extract(`provider_state`, '$.scopes'), json('[]')), | ||
| 1042 | 'scope', `scope` | ||
| 1043 | ), | ||
| 1044 | `updated_at` = CAST(strftime('%s', 'now') AS INTEGER) * 1000 | ||
| 1045 | WHERE `provider` = 'openapi:oauth2' | ||
| 1046 | AND json_extract(`provider_state`, '$.flow') IN ('authorizationCode', 'clientCredentials');--> statement-breakpoint | ||
| 1047 | |||
| 1048 | UPDATE `connection` | ||
| 1049 | SET | ||
| 1050 | `provider` = 'oauth2', | ||
| 1051 | `provider_state` = json_object( | ||
| 1052 | 'kind', 'dynamic-dcr', | ||
| 1053 | 'tokenEndpoint', coalesce( | ||
| 1054 | json_extract(`provider_state`, '$.tokenEndpoint'), | ||
| 1055 | json_extract(`provider_state`, '$.authorizationServerMetadata.token_endpoint'), | ||
| 1056 | '' | ||
| 1057 | ), | ||
| 1058 | 'issuerUrl', json_extract(`provider_state`, '$.authorizationServerMetadata.issuer'), | ||
| 1059 | 'authorizationServerUrl', json_extract(`provider_state`, '$.authorizationServerUrl'), | ||
| 1060 | 'authorizationServerMetadataUrl', json_extract(`provider_state`, '$.authorizationServerMetadataUrl'), | ||
| 1061 | 'idTokenSigningAlgValuesSupported', coalesce( | ||
| 1062 | json_extract(`provider_state`, '$.authorizationServerMetadata.id_token_signing_alg_values_supported'), | ||
| 1063 | json('[]') | ||
| 1064 | ), | ||
| 1065 | 'clientId', coalesce(json_extract(`provider_state`, '$.clientInformation.client_id'), ''), | ||
| 1066 | 'clientSecretSecretId', NULL, | ||
| 1067 | 'clientAuth', CASE json_extract(`provider_state`, '$.clientInformation.token_endpoint_auth_method') | ||
| 1068 | WHEN 'client_secret_basic' THEN 'basic' | ||
| 1069 | ELSE 'body' | ||
| 1070 | END, | ||
| 1071 | 'scopes', json('[]'), | ||
| 1072 | 'scope', `scope`, | ||
| 1073 | 'resource', json_extract(`provider_state`, '$.endpoint') | ||
| 1074 | ), | ||
| 1075 | `updated_at` = CAST(strftime('%s', 'now') AS INTEGER) * 1000 | ||
| 1076 | WHERE `provider` = 'mcp:oauth2';--> statement-breakpoint | ||
| 1077 | |||
| 1078 | UPDATE `connection` | ||
| 1079 | SET | ||
| 1080 | `provider` = 'oauth2', | ||
| 1081 | `provider_state` = json_object( | ||
| 1082 | 'kind', 'authorization-code', | ||
| 1083 | 'tokenEndpoint', 'https://oauth2.googleapis.com/token', | ||
| 1084 | 'issuerUrl', 'https://accounts.google.com', | ||
| 1085 | 'clientIdSecretId', json_extract(`provider_state`, '$.clientIdSecretId'), | ||
| 1086 | 'clientSecretSecretId', json_extract(`provider_state`, '$.clientSecretSecretId'), | ||
| 1087 | 'clientAuth', 'body', | ||
| 1088 | 'scopes', coalesce(json_extract(`provider_state`, '$.scopes'), json('[]')), | ||
| 1089 | 'scope', `scope` | ||
| 1090 | ), | ||
| 1091 | `updated_at` = CAST(strftime('%s', 'now') AS INTEGER) * 1000 | ||
| 1092 | WHERE `provider` IN ('google-discovery:google', 'google-discovery:oauth2');--> statement-breakpoint | ||
| 1093 | |||
| 1094 | -- 0014_openapi_header_rows.sql | ||
| 1095 | -- Move OpenAPI request headers out of openapi_source.headers JSON and into | ||
| 1096 | -- the same child-row slot model used by query params and spec-fetch | ||
| 1097 | -- credentials. Runtime code reads only openapi_source_header after this. | ||
| 1098 | |||
| 1099 | CREATE TABLE `openapi_source_header` ( | ||
| 1100 | `id` text NOT NULL, | ||
| 1101 | `scope_id` text NOT NULL, | ||
| 1102 | `source_id` text NOT NULL, | ||
| 1103 | `name` text NOT NULL, | ||
| 1104 | `kind` text NOT NULL, | ||
| 1105 | `text_value` text, | ||
| 1106 | `slot_key` text, | ||
| 1107 | `prefix` text, | ||
| 1108 | PRIMARY KEY(`scope_id`, `id`) | ||
| 1109 | );--> statement-breakpoint | ||
| 1110 | CREATE INDEX `openapi_source_header_scope_id_idx` ON `openapi_source_header` (`scope_id`);--> statement-breakpoint | ||
| 1111 | CREATE INDEX `openapi_source_header_source_id_idx` ON `openapi_source_header` (`source_id`);--> statement-breakpoint | ||
| 1112 | |||
| 1113 | CREATE TEMP TABLE `__openapi_header_row_slot_preflight` ( | ||
| 1114 | `scope_id` text NOT NULL, | ||
| 1115 | `source_id` text NOT NULL, | ||
| 1116 | `slot_key` text NOT NULL, | ||
| 1117 | PRIMARY KEY (`scope_id`, `source_id`, `slot_key`) | ||
| 1118 | );--> statement-breakpoint | ||
| 1119 | |||
| 1120 | INSERT INTO `__openapi_header_row_slot_preflight` (`scope_id`, `source_id`, `slot_key`) | ||
| 1121 | SELECT | ||
| 1122 | s.`scope_id`, | ||
| 1123 | s.`id`, | ||
| 1124 | 'header:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = h.`key`), 'default') AS `slot_key` | ||
| 1125 | FROM `openapi_source` s, json_each(s.`headers`) h | ||
| 1126 | WHERE s.`headers` IS NOT NULL | ||
| 1127 | AND h.`type` = 'object' | ||
| 1128 | AND json_extract(h.`value`, '$.secretId') IS NOT NULL | ||
| 1129 | AND COALESCE(json_extract(h.`value`, '$.kind'), 'secret') = 'secret';--> statement-breakpoint | ||
| 1130 | |||
| 1131 | DROP TABLE `__openapi_header_row_slot_preflight`;--> statement-breakpoint | ||
| 1132 | |||
| 1133 | WITH header_rows AS ( | ||
| 1134 | SELECT | ||
| 1135 | s.`scope_id`, | ||
| 1136 | s.`id` AS `source_id`, | ||
| 1137 | h.`key` AS `name`, | ||
| 1138 | 'header:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = h.`key`), 'default') AS `slot_key`, | ||
| 1139 | json_extract(h.`value`, '$.secretId') AS `secret_id` | ||
| 1140 | FROM `openapi_source` s, json_each(s.`headers`) h | ||
| 1141 | WHERE s.`headers` IS NOT NULL | ||
| 1142 | AND h.`type` = 'object' | ||
| 1143 | AND json_extract(h.`value`, '$.secretId') IS NOT NULL | ||
| 1144 | AND COALESCE(json_extract(h.`value`, '$.kind'), 'secret') = 'secret' | ||
| 1145 | ) | ||
| 1146 | INSERT OR REPLACE INTO `credential_binding` ( | ||
| 1147 | `id`, `scope_id`, `plugin_id`, `source_id`, `source_scope_id`, `slot_key`, | ||
| 1148 | `kind`, `text_value`, `secret_id`, `connection_id`, `created_at`, `updated_at` | ||
| 1149 | ) | ||
| 1150 | SELECT | ||
| 1151 | json_array('openapi', r.`scope_id`, r.`source_id`, r.`slot_key`), | ||
| 1152 | r.`scope_id`, | ||
| 1153 | 'openapi', | ||
| 1154 | r.`source_id`, | ||
| 1155 | r.`scope_id`, | ||
| 1156 | r.`slot_key`, | ||
| 1157 | 'secret', | ||
| 1158 | NULL, | ||
| 1159 | r.`secret_id`, | ||
| 1160 | NULL, | ||
| 1161 | CAST(strftime('%s', 'now') AS INTEGER) * 1000, | ||
| 1162 | CAST(strftime('%s', 'now') AS INTEGER) * 1000 | ||
| 1163 | FROM header_rows r | ||
| 1164 | WHERE NOT EXISTS ( | ||
| 1165 | SELECT 1 FROM `credential_binding` b | ||
| 1166 | WHERE b.`scope_id` = r.`scope_id` | ||
| 1167 | AND b.`plugin_id` = 'openapi' | ||
| 1168 | AND b.`source_id` = r.`source_id` | ||
| 1169 | AND b.`source_scope_id` = r.`scope_id` | ||
| 1170 | AND b.`slot_key` = r.`slot_key` | ||
| 1171 | );--> statement-breakpoint | ||
| 1172 | |||
| 1173 | INSERT OR REPLACE INTO `openapi_source_header` ( | ||
| 1174 | `id`, `scope_id`, `source_id`, `name`, `kind`, `text_value`, `slot_key`, `prefix` | ||
| 1175 | ) | ||
| 1176 | SELECT | ||
| 1177 | json_array(s.`id`, h.`key`), | ||
| 1178 | s.`scope_id`, | ||
| 1179 | s.`id`, | ||
| 1180 | h.`key`, | ||
| 1181 | CASE | ||
| 1182 | WHEN h.`type` = 'text' THEN 'text' | ||
| 1183 | WHEN h.`type` = 'object' AND json_extract(h.`value`, '$.kind') = 'text' THEN 'text' | ||
| 1184 | ELSE 'binding' | ||
| 1185 | END, | ||
| 1186 | CASE | ||
| 1187 | WHEN h.`type` = 'text' THEN h.`value` | ||
| 1188 | WHEN h.`type` = 'object' AND json_extract(h.`value`, '$.kind') = 'text' | ||
| 1189 | THEN json_extract(h.`value`, '$.text') | ||
| 1190 | ELSE NULL | ||
| 1191 | END, | ||
| 1192 | CASE | ||
| 1193 | WHEN h.`type` = 'object' AND json_extract(h.`value`, '$.kind') = 'binding' | ||
| 1194 | THEN json_extract(h.`value`, '$.slot') | ||
| 1195 | WHEN h.`type` = 'object' AND json_extract(h.`value`, '$.secretId') IS NOT NULL | ||
| 1196 | THEN 'header:' || COALESCE((SELECT `slug` FROM `__slug_norm` WHERE `raw` = h.`key`), 'default') | ||
| 1197 | ELSE NULL | ||
| 1198 | END, | ||
| 1199 | CASE | ||
| 1200 | WHEN h.`type` = 'object' | ||
| 1201 | THEN COALESCE(json_extract(h.`value`, '$.prefix'), json_extract(h.`value`, '$.secretPrefix')) | ||
| 1202 | ELSE NULL | ||
| 1203 | END | ||
| 1204 | FROM `openapi_source` s, json_each(s.`headers`) h | ||
| 1205 | WHERE s.`headers` IS NOT NULL | ||
| 1206 | AND ( | ||
| 1207 | h.`type` = 'text' | ||
| 1208 | OR ( | ||
| 1209 | h.`type` = 'object' | ||
| 1210 | AND ( | ||
| 1211 | json_extract(h.`value`, '$.kind') IN ('binding', 'text') | ||
| 1212 | OR json_extract(h.`value`, '$.secretId') IS NOT NULL | ||
| 1213 | ) | ||
| 1214 | ) | ||
| 1215 | );--> statement-breakpoint | ||
| 1216 | |||
| 1217 | ALTER TABLE `openapi_source` DROP COLUMN `headers`; | ||
| 1218 | |||
| 1219 | --> statement-breakpoint | ||
| 1220 | DROP TABLE `__slug_norm`; | ||
| @@ -0,0 +1,253 @@ | |||
| 1 | -- Repair OpenAPI OAuth residue from the scoped-credential cutover. | ||
| 2 | |||
| 3 | UPDATE `connection` | ||
| 4 | SET `provider` = 'oauth2', | ||
| 5 | `updated_at` = CAST(strftime('%s', 'now') AS INTEGER) * 1000 | ||
| 6 | WHERE `provider` = 'openapi:oauth2' | ||
| 7 | AND json_extract(`provider_state`, '$.kind') IS NOT NULL;--> statement-breakpoint | ||
| 8 | |||
| 9 | WITH oauth_connections AS ( | ||
| 10 | SELECT | ||
| 11 | b.`scope_id`, | ||
| 12 | b.`id` AS `binding_id`, | ||
| 13 | b.`plugin_id`, | ||
| 14 | b.`source_id`, | ||
| 15 | b.`source_scope_id`, | ||
| 16 | json_extract(s.`oauth2`, '$.clientIdSlot') AS `slot_key`, | ||
| 17 | json_extract(c.`provider_state`, '$.clientIdSecretId') AS `secret_id`, | ||
| 18 | b.`created_at` | ||
| 19 | FROM `credential_binding` b | ||
| 20 | JOIN `openapi_source` s | ||
| 21 | ON s.`id` = b.`source_id` | ||
| 22 | AND s.`scope_id` = b.`source_scope_id` | ||
| 23 | JOIN `connection` c | ||
| 24 | ON c.`id` = b.`connection_id` | ||
| 25 | AND c.`scope_id` = b.`scope_id` | ||
| 26 | WHERE b.`plugin_id` = 'openapi' | ||
| 27 | AND b.`kind` = 'connection' | ||
| 28 | AND s.`oauth2` IS NOT NULL | ||
| 29 | AND c.`provider` = 'oauth2' | ||
| 30 | AND json_extract(c.`provider_state`, '$.clientIdSecretId') IS NOT NULL | ||
| 31 | AND coalesce(json_extract(c.`provider_state`, '$.clientIdSecretId'), '') <> '' | ||
| 32 | ) | ||
| 33 | UPDATE `credential_binding` | ||
| 34 | SET | ||
| 35 | `secret_id` = ( | ||
| 36 | SELECT r.`secret_id` | ||
| 37 | FROM oauth_connections r | ||
| 38 | WHERE r.`scope_id` = `credential_binding`.`scope_id` | ||
| 39 | AND r.`plugin_id` = `credential_binding`.`plugin_id` | ||
| 40 | AND r.`source_id` = `credential_binding`.`source_id` | ||
| 41 | AND r.`source_scope_id` = `credential_binding`.`source_scope_id` | ||
| 42 | AND r.`slot_key` = `credential_binding`.`slot_key` | ||
| 43 | LIMIT 1 | ||
| 44 | ), | ||
| 45 | `text_value` = NULL, | ||
| 46 | `connection_id` = NULL, | ||
| 47 | `updated_at` = CAST(strftime('%s', 'now') AS INTEGER) * 1000 | ||
| 48 | WHERE `kind` = 'secret' | ||
| 49 | AND EXISTS ( | ||
| 50 | SELECT 1 | ||
| 51 | FROM oauth_connections r | ||
| 52 | WHERE r.`scope_id` = `credential_binding`.`scope_id` | ||
| 53 | AND r.`plugin_id` = `credential_binding`.`plugin_id` | ||
| 54 | AND r.`source_id` = `credential_binding`.`source_id` | ||
| 55 | AND r.`source_scope_id` = `credential_binding`.`source_scope_id` | ||
| 56 | AND r.`slot_key` = `credential_binding`.`slot_key` | ||
| 57 | );--> statement-breakpoint | ||
| 58 | |||
| 59 | WITH oauth_connections AS ( | ||
| 60 | SELECT | ||
| 61 | b.`scope_id`, | ||
| 62 | b.`id` AS `binding_id`, | ||
| 63 | b.`plugin_id`, | ||
| 64 | b.`source_id`, | ||
| 65 | b.`source_scope_id`, | ||
| 66 | json_extract(s.`oauth2`, '$.clientIdSlot') AS `slot_key`, | ||
| 67 | json_extract(c.`provider_state`, '$.clientIdSecretId') AS `secret_id`, | ||
| 68 | b.`created_at` | ||
| 69 | FROM `credential_binding` b | ||
| 70 | JOIN `openapi_source` s | ||
| 71 | ON s.`id` = b.`source_id` | ||
| 72 | AND s.`scope_id` = b.`source_scope_id` | ||
| 73 | JOIN `connection` c | ||
| 74 | ON c.`id` = b.`connection_id` | ||
| 75 | AND c.`scope_id` = b.`scope_id` | ||
| 76 | WHERE b.`plugin_id` = 'openapi' | ||
| 77 | AND b.`kind` = 'connection' | ||
| 78 | AND s.`oauth2` IS NOT NULL | ||
| 79 | AND c.`provider` = 'oauth2' | ||
| 80 | AND json_extract(c.`provider_state`, '$.clientIdSecretId') IS NOT NULL | ||
| 81 | AND coalesce(json_extract(c.`provider_state`, '$.clientIdSecretId'), '') <> '' | ||
| 82 | ) | ||
| 83 | INSERT INTO `credential_binding` ( | ||
| 84 | `id`, | ||
| 85 | `scope_id`, | ||
| 86 | `plugin_id`, | ||
| 87 | `source_id`, | ||
| 88 | `source_scope_id`, | ||
| 89 | `slot_key`, | ||
| 90 | `kind`, | ||
| 91 | `text_value`, | ||
| 92 | `secret_id`, | ||
| 93 | `connection_id`, | ||
| 94 | `created_at`, | ||
| 95 | `updated_at` | ||
| 96 | ) | ||
| 97 | SELECT | ||
| 98 | json_array('oconn-openapi-oauth-client', r.`binding_id`, r.`scope_id`, r.`slot_key`), | ||
| 99 | r.`scope_id`, | ||
| 100 | r.`plugin_id`, | ||
| 101 | r.`source_id`, | ||
| 102 | r.`source_scope_id`, | ||
| 103 | r.`slot_key`, | ||
| 104 | 'secret', | ||
| 105 | NULL, | ||
| 106 | r.`secret_id`, | ||
| 107 | NULL, | ||
| 108 | r.`created_at`, | ||
| 109 | CAST(strftime('%s', 'now') AS INTEGER) * 1000 | ||
| 110 | FROM oauth_connections r | ||
| 111 | WHERE r.`slot_key` IS NOT NULL | ||
| 112 | AND NOT EXISTS ( | ||
| 113 | SELECT 1 | ||
| 114 | FROM `credential_binding` existing | ||
| 115 | WHERE existing.`scope_id` = r.`scope_id` | ||
| 116 | AND existing.`plugin_id` = r.`plugin_id` | ||
| 117 | AND existing.`source_id` = r.`source_id` | ||
| 118 | AND existing.`source_scope_id` = r.`source_scope_id` | ||
| 119 | AND existing.`slot_key` = r.`slot_key` | ||
| 120 | ) | ||
| 121 | ON CONFLICT(`scope_id`, `id`) DO UPDATE SET | ||
| 122 | `plugin_id` = excluded.`plugin_id`, | ||
| 123 | `source_id` = excluded.`source_id`, | ||
| 124 | `source_scope_id` = excluded.`source_scope_id`, | ||
| 125 | `slot_key` = excluded.`slot_key`, | ||
| 126 | `kind` = excluded.`kind`, | ||
| 127 | `text_value` = excluded.`text_value`, | ||
| 128 | `secret_id` = excluded.`secret_id`, | ||
| 129 | `connection_id` = excluded.`connection_id`, | ||
| 130 | `updated_at` = excluded.`updated_at`;--> statement-breakpoint | ||
| 131 | |||
| 132 | WITH oauth_connections AS ( | ||
| 133 | SELECT | ||
| 134 | b.`scope_id`, | ||
| 135 | b.`id` AS `binding_id`, | ||
| 136 | b.`plugin_id`, | ||
| 137 | b.`source_id`, | ||
| 138 | b.`source_scope_id`, | ||
| 139 | json_extract(s.`oauth2`, '$.clientSecretSlot') AS `slot_key`, | ||
| 140 | json_extract(c.`provider_state`, '$.clientSecretSecretId') AS `secret_id`, | ||
| 141 | b.`created_at` | ||
| 142 | FROM `credential_binding` b | ||
| 143 | JOIN `openapi_source` s | ||
| 144 | ON s.`id` = b.`source_id` | ||
| 145 | AND s.`scope_id` = b.`source_scope_id` | ||
| 146 | JOIN `connection` c | ||
| 147 | ON c.`id` = b.`connection_id` | ||
| 148 | AND c.`scope_id` = b.`scope_id` | ||
| 149 | WHERE b.`plugin_id` = 'openapi' | ||
| 150 | AND b.`kind` = 'connection' | ||
| 151 | AND s.`oauth2` IS NOT NULL | ||
| 152 | AND c.`provider` = 'oauth2' | ||
| 153 | AND json_extract(c.`provider_state`, '$.clientSecretSecretId') IS NOT NULL | ||
| 154 | AND coalesce(json_extract(c.`provider_state`, '$.clientSecretSecretId'), '') <> '' | ||
| 155 | ) | ||
| 156 | UPDATE `credential_binding` | ||
| 157 | SET | ||
| 158 | `secret_id` = ( | ||
| 159 | SELECT r.`secret_id` | ||
| 160 | FROM oauth_connections r | ||
| 161 | WHERE r.`scope_id` = `credential_binding`.`scope_id` | ||
| 162 | AND r.`plugin_id` = `credential_binding`.`plugin_id` | ||
| 163 | AND r.`source_id` = `credential_binding`.`source_id` | ||
| 164 | AND r.`source_scope_id` = `credential_binding`.`source_scope_id` | ||
| 165 | AND r.`slot_key` = `credential_binding`.`slot_key` | ||
| 166 | LIMIT 1 | ||
| 167 | ), | ||
| 168 | `text_value` = NULL, | ||
| 169 | `connection_id` = NULL, | ||
| 170 | `updated_at` = CAST(strftime('%s', 'now') AS INTEGER) * 1000 | ||
| 171 | WHERE `kind` = 'secret' | ||
| 172 | AND EXISTS ( | ||
| 173 | SELECT 1 | ||
| 174 | FROM oauth_connections r | ||
| 175 | WHERE r.`scope_id` = `credential_binding`.`scope_id` | ||
| 176 | AND r.`plugin_id` = `credential_binding`.`plugin_id` | ||
| 177 | AND r.`source_id` = `credential_binding`.`source_id` | ||
| 178 | AND r.`source_scope_id` = `credential_binding`.`source_scope_id` | ||
| 179 | AND r.`slot_key` = `credential_binding`.`slot_key` | ||
| 180 | );--> statement-breakpoint | ||
| 181 | |||
| 182 | WITH oauth_connections AS ( | ||
| 183 | SELECT | ||
| 184 | b.`scope_id`, | ||
| 185 | b.`id` AS `binding_id`, | ||
| 186 | b.`plugin_id`, | ||
| 187 | b.`source_id`, | ||
| 188 | b.`source_scope_id`, | ||
| 189 | json_extract(s.`oauth2`, '$.clientSecretSlot') AS `slot_key`, | ||
| 190 | json_extract(c.`provider_state`, '$.clientSecretSecretId') AS `secret_id`, | ||
| 191 | b.`created_at` | ||
| 192 | FROM `credential_binding` b | ||
| 193 | JOIN `openapi_source` s | ||
| 194 | ON s.`id` = b.`source_id` | ||
| 195 | AND s.`scope_id` = b.`source_scope_id` | ||
| 196 | JOIN `connection` c | ||
| 197 | ON c.`id` = b.`connection_id` | ||
| 198 | AND c.`scope_id` = b.`scope_id` | ||
| 199 | WHERE b.`plugin_id` = 'openapi' | ||
| 200 | AND b.`kind` = 'connection' | ||
| 201 | AND s.`oauth2` IS NOT NULL | ||
| 202 | AND c.`provider` = 'oauth2' | ||
| 203 | AND json_extract(c.`provider_state`, '$.clientSecretSecretId') IS NOT NULL | ||
| 204 | AND coalesce(json_extract(c.`provider_state`, '$.clientSecretSecretId'), '') <> '' | ||
| 205 | ) | ||
| 206 | INSERT INTO `credential_binding` ( | ||
| 207 | `id`, | ||
| 208 | `scope_id`, | ||
| 209 | `plugin_id`, | ||
| 210 | `source_id`, | ||
| 211 | `source_scope_id`, | ||
| 212 | `slot_key`, | ||
| 213 | `kind`, | ||
| 214 | `text_value`, | ||
| 215 | `secret_id`, | ||
| 216 | `connection_id`, | ||
| 217 | `created_at`, | ||
| 218 | `updated_at` | ||
| 219 | ) | ||
| 220 | SELECT | ||
| 221 | json_array('oconn-openapi-oauth-secret', r.`binding_id`, r.`scope_id`, r.`slot_key`), | ||
| 222 | r.`scope_id`, | ||
| 223 | r.`plugin_id`, | ||
| 224 | r.`source_id`, | ||
| 225 | r.`source_scope_id`, | ||
| 226 | r.`slot_key`, | ||
| 227 | 'secret', | ||
| 228 | NULL, | ||
| 229 | r.`secret_id`, | ||
| 230 | NULL, | ||
| 231 | r.`created_at`, | ||
| 232 | CAST(strftime('%s', 'now') AS INTEGER) * 1000 | ||
| 233 | FROM oauth_connections r | ||
| 234 | WHERE r.`slot_key` IS NOT NULL | ||
| 235 | AND NOT EXISTS ( | ||
| 236 | SELECT 1 | ||
| 237 | FROM `credential_binding` existing | ||
| 238 | WHERE existing.`scope_id` = r.`scope_id` | ||
| 239 | AND existing.`plugin_id` = r.`plugin_id` | ||
| 240 | AND existing.`source_id` = r.`source_id` | ||
| 241 | AND existing.`source_scope_id` = r.`source_scope_id` | ||
| 242 | AND existing.`slot_key` = r.`slot_key` | ||
| 243 | ) | ||
| 244 | ON CONFLICT(`scope_id`, `id`) DO UPDATE SET | ||
| 245 | `plugin_id` = excluded.`plugin_id`, | ||
| 246 | `source_id` = excluded.`source_id`, | ||
| 247 | `source_scope_id` = excluded.`source_scope_id`, | ||
| 248 | `slot_key` = excluded.`slot_key`, | ||
| 249 | `kind` = excluded.`kind`, | ||
| 250 | `text_value` = excluded.`text_value`, | ||
| 251 | `secret_id` = excluded.`secret_id`, | ||
| 252 | `connection_id` = excluded.`connection_id`, | ||
| 253 | `updated_at` = excluded.`updated_at`; | ||
| @@ -0,0 +1,2 @@ | |||
| 1 | ALTER TABLE `credential_binding` ADD COLUMN `secret_scope_id` text;--> statement-breakpoint | ||
| 2 | CREATE INDEX `credential_binding_secret_scope_id_idx` ON `credential_binding` (`secret_scope_id`); | ||
| @@ -0,0 +1,215 @@ | |||
| 1 | CREATE TABLE IF NOT EXISTS `openapi_source` (`id` text NOT NULL, `scope_id` text NOT NULL, `name` text NOT NULL, `spec` text NOT NULL, `source_url` text, `base_url` text, `oauth2` text); | ||
| 2 | --> statement-breakpoint | ||
| 3 | CREATE TABLE IF NOT EXISTS `openapi_operation` (`id` text NOT NULL, `scope_id` text NOT NULL, `source_id` text NOT NULL, `binding` text NOT NULL); | ||
| 4 | --> statement-breakpoint | ||
| 5 | CREATE TABLE IF NOT EXISTS `openapi_source_header` (`id` text, `scope_id` text, `source_id` text, `name` text, `kind` text, `text_value` text, `slot_key` text, `prefix` text); | ||
| 6 | --> statement-breakpoint | ||
| 7 | CREATE TABLE IF NOT EXISTS `openapi_source_query_param` (`id` text, `scope_id` text, `source_id` text, `name` text, `kind` text, `text_value` text, `slot_key` text, `prefix` text); | ||
| 8 | --> statement-breakpoint | ||
| 9 | CREATE TABLE IF NOT EXISTS `openapi_source_spec_fetch_header` (`id` text, `scope_id` text, `source_id` text, `name` text, `kind` text, `text_value` text, `slot_key` text, `prefix` text); | ||
| 10 | --> statement-breakpoint | ||
| 11 | CREATE TABLE IF NOT EXISTS `openapi_source_spec_fetch_query_param` (`id` text, `scope_id` text, `source_id` text, `name` text, `kind` text, `text_value` text, `slot_key` text, `prefix` text); | ||
| 12 | --> statement-breakpoint | ||
| 13 | CREATE TABLE IF NOT EXISTS `graphql_source` (`id` text NOT NULL, `scope_id` text NOT NULL, `name` text NOT NULL, `endpoint` text NOT NULL, `auth_kind` text NOT NULL DEFAULT 'none', `auth_connection_slot` text); | ||
| 14 | --> statement-breakpoint | ||
| 15 | CREATE TABLE IF NOT EXISTS `graphql_source_header` (`id` text, `scope_id` text, `source_id` text, `name` text, `kind` text, `text_value` text, `slot_key` text, `prefix` text); | ||
| 16 | --> statement-breakpoint | ||
| 17 | CREATE TABLE IF NOT EXISTS `graphql_source_query_param` (`id` text, `scope_id` text, `source_id` text, `name` text, `kind` text, `text_value` text, `slot_key` text, `prefix` text); | ||
| 18 | --> statement-breakpoint | ||
| 19 | CREATE TABLE IF NOT EXISTS `graphql_operation` (`id` text NOT NULL, `scope_id` text NOT NULL, `source_id` text NOT NULL, `binding` text NOT NULL); | ||
| 20 | --> statement-breakpoint | ||
| 21 | CREATE TABLE IF NOT EXISTS `mcp_source` (`id` text NOT NULL, `scope_id` text NOT NULL, `name` text NOT NULL, `config` text NOT NULL, `auth_kind` text NOT NULL DEFAULT 'none', `auth_header_name` text, `auth_header_slot` text, `auth_header_prefix` text, `auth_connection_slot` text, `auth_client_id_slot` text, `auth_client_secret_slot` text, `created_at` integer); | ||
| 22 | --> statement-breakpoint | ||
| 23 | CREATE TABLE IF NOT EXISTS `mcp_source_header` (`id` text, `scope_id` text, `source_id` text, `name` text, `kind` text, `text_value` text, `slot_key` text, `prefix` text); | ||
| 24 | --> statement-breakpoint | ||
| 25 | CREATE TABLE IF NOT EXISTS `mcp_source_query_param` (`id` text, `scope_id` text, `source_id` text, `name` text, `kind` text, `text_value` text, `slot_key` text, `prefix` text); | ||
| 26 | --> statement-breakpoint | ||
| 27 | CREATE TABLE IF NOT EXISTS `mcp_binding` (`id` text NOT NULL, `scope_id` text NOT NULL, `source_id` text NOT NULL, `binding` text NOT NULL, `created_at` integer); | ||
| 28 | --> statement-breakpoint | ||
| 29 | CREATE TABLE IF NOT EXISTS `plugin_storage` ( | ||
| 30 | `id` text NOT NULL, | ||
| 31 | `scope_id` text NOT NULL, | ||
| 32 | `plugin_id` text NOT NULL, | ||
| 33 | `collection` text NOT NULL, | ||
| 34 | `key` text NOT NULL, | ||
| 35 | `data` text NOT NULL, | ||
| 36 | `created_at` integer NOT NULL, | ||
| 37 | `updated_at` integer NOT NULL, | ||
| 38 | PRIMARY KEY(`scope_id`, `id`) | ||
| 39 | ); | ||
| 40 | --> statement-breakpoint | ||
| 41 | CREATE INDEX IF NOT EXISTS `plugin_storage_scope_id_idx` ON `plugin_storage` (`scope_id`); | ||
| 42 | --> statement-breakpoint | ||
| 43 | CREATE INDEX IF NOT EXISTS `plugin_storage_plugin_id_collection_idx` ON `plugin_storage` (`plugin_id`, `collection`); | ||
| 44 | --> statement-breakpoint | ||
| 45 | CREATE INDEX IF NOT EXISTS `plugin_storage_key_idx` ON `plugin_storage` (`key`); | ||
| 46 | --> statement-breakpoint | ||
| 47 | INSERT OR REPLACE INTO `plugin_storage` (`id`, `scope_id`, `plugin_id`, `collection`, `key`, `data`, `created_at`, `updated_at`) | ||
| 48 | SELECT | ||
| 49 | json_array('openapi', 'source', s.`id`), | ||
| 50 | s.`scope_id`, | ||
| 51 | 'openapi', | ||
| 52 | 'source', | ||
| 53 | s.`id`, | ||
| 54 | json_object( | ||
| 55 | 'namespace', s.`id`, | ||
| 56 | 'scope', s.`scope_id`, | ||
| 57 | 'name', s.`name`, | ||
| 58 | 'config', json_patch( | ||
| 59 | json_patch( | ||
| 60 | json_patch( | ||
| 61 | json_patch( | ||
| 62 | json_patch( | ||
| 63 | json_patch( | ||
| 64 | json_object('spec', s.`spec`), | ||
| 65 | CASE WHEN s.`source_url` IS NULL THEN json_object() ELSE json_object('sourceUrl', s.`source_url`) END | ||
| 66 | ), | ||
| 67 | CASE WHEN s.`base_url` IS NULL THEN json_object() ELSE json_object('baseUrl', s.`base_url`) END | ||
| 68 | ), | ||
| 69 | CASE WHEN h.`headers` IS NULL THEN json_object() ELSE json_object('headers', json(h.`headers`)) END | ||
| 70 | ), | ||
| 71 | CASE WHEN q.`queryParams` IS NULL THEN json_object() ELSE json_object('queryParams', json(q.`queryParams`)) END | ||
| 72 | ), | ||
| 73 | CASE WHEN sfh.`headers` IS NULL AND sfq.`queryParams` IS NULL THEN json_object() ELSE json_object('specFetchCredentials', json_patch( | ||
| 74 | CASE WHEN sfh.`headers` IS NULL THEN json_object() ELSE json_object('headers', json(sfh.`headers`)) END, | ||
| 75 | CASE WHEN sfq.`queryParams` IS NULL THEN json_object() ELSE json_object('queryParams', json(sfq.`queryParams`)) END | ||
| 76 | )) END | ||
| 77 | ), | ||
| 78 | CASE WHEN s.`oauth2` IS NULL THEN json_object() ELSE json_object('oauth2', json(s.`oauth2`)) END | ||
| 79 | ) | ||
| 80 | ), | ||
| 81 | unixepoch('now') * 1000, | ||
| 82 | unixepoch('now') * 1000 | ||
| 83 | FROM `openapi_source` s | ||
| 84 | LEFT JOIN ( | ||
| 85 | SELECT `scope_id`, `source_id`, json_group_object(`name`, CASE WHEN `kind` = 'text' THEN json_quote(`text_value`) ELSE json_object('kind', 'binding', 'slot', `slot_key`, 'prefix', `prefix`) END) AS `headers` | ||
| 86 | FROM `openapi_source_header` | ||
| 87 | GROUP BY `scope_id`, `source_id` | ||
| 88 | ) h ON h.`scope_id` = s.`scope_id` AND h.`source_id` = s.`id` | ||
| 89 | LEFT JOIN ( | ||
| 90 | SELECT `scope_id`, `source_id`, json_group_object(`name`, CASE WHEN `kind` = 'text' THEN json_quote(`text_value`) ELSE json_object('kind', 'binding', 'slot', `slot_key`, 'prefix', `prefix`) END) AS `queryParams` | ||
| 91 | FROM `openapi_source_query_param` | ||
| 92 | GROUP BY `scope_id`, `source_id` | ||
| 93 | ) q ON q.`scope_id` = s.`scope_id` AND q.`source_id` = s.`id` | ||
| 94 | LEFT JOIN ( | ||
| 95 | SELECT `scope_id`, `source_id`, json_group_object(`name`, CASE WHEN `kind` = 'text' THEN json_quote(`text_value`) ELSE json_object('kind', 'binding', 'slot', `slot_key`, 'prefix', `prefix`) END) AS `headers` | ||
| 96 | FROM `openapi_source_spec_fetch_header` | ||
| 97 | GROUP BY `scope_id`, `source_id` | ||
| 98 | ) sfh ON sfh.`scope_id` = s.`scope_id` AND sfh.`source_id` = s.`id` | ||
| 99 | LEFT JOIN ( | ||
| 100 | SELECT `scope_id`, `source_id`, json_group_object(`name`, CASE WHEN `kind` = 'text' THEN json_quote(`text_value`) ELSE json_object('kind', 'binding', 'slot', `slot_key`, 'prefix', `prefix`) END) AS `queryParams` | ||
| 101 | FROM `openapi_source_spec_fetch_query_param` | ||
| 102 | GROUP BY `scope_id`, `source_id` | ||
| 103 | ) sfq ON sfq.`scope_id` = s.`scope_id` AND sfq.`source_id` = s.`id`; | ||
| 104 | --> statement-breakpoint | ||
| 105 | INSERT OR REPLACE INTO `plugin_storage` (`id`, `scope_id`, `plugin_id`, `collection`, `key`, `data`, `created_at`, `updated_at`) | ||
| 106 | SELECT json_array('openapi', 'operation', o.`id`), o.`scope_id`, 'openapi', 'operation', o.`id`, json_object('toolId', o.`id`, 'sourceId', o.`source_id`, 'binding', json(o.`binding`)), unixepoch('now') * 1000, unixepoch('now') * 1000 | ||
| 107 | FROM `openapi_operation` o; | ||
| 108 | --> statement-breakpoint | ||
| 109 | INSERT OR REPLACE INTO `plugin_storage` (`id`, `scope_id`, `plugin_id`, `collection`, `key`, `data`, `created_at`, `updated_at`) | ||
| 110 | SELECT | ||
| 111 | json_array('graphql', 'source', s.`id`), | ||
| 112 | s.`scope_id`, | ||
| 113 | 'graphql', | ||
| 114 | 'source', | ||
| 115 | s.`id`, | ||
| 116 | json_object( | ||
| 117 | 'namespace', s.`id`, | ||
| 118 | 'scope', s.`scope_id`, | ||
| 119 | 'name', s.`name`, | ||
| 120 | 'endpoint', s.`endpoint`, | ||
| 121 | 'headers', COALESCE(json(h.`headers`), json_object()), | ||
| 122 | 'queryParams', COALESCE(json(q.`queryParams`), json_object()), | ||
| 123 | 'auth', CASE WHEN s.`auth_kind` = 'oauth2' AND s.`auth_connection_slot` IS NOT NULL THEN json_object('kind', 'oauth2', 'connectionSlot', s.`auth_connection_slot`) ELSE json_object('kind', 'none') END | ||
| 124 | ), | ||
| 125 | unixepoch('now') * 1000, | ||
| 126 | unixepoch('now') * 1000 | ||
| 127 | FROM `graphql_source` s | ||
| 128 | LEFT JOIN ( | ||
| 129 | SELECT `scope_id`, `source_id`, json_group_object(`name`, CASE WHEN `kind` = 'text' THEN json_quote(`text_value`) ELSE json_object('kind', 'binding', 'slot', `slot_key`, 'prefix', `prefix`) END) AS `headers` | ||
| 130 | FROM `graphql_source_header` | ||
| 131 | GROUP BY `scope_id`, `source_id` | ||
| 132 | ) h ON h.`scope_id` = s.`scope_id` AND h.`source_id` = s.`id` | ||
| 133 | LEFT JOIN ( | ||
| 134 | SELECT `scope_id`, `source_id`, json_group_object(`name`, CASE WHEN `kind` = 'text' THEN json_quote(`text_value`) ELSE json_object('kind', 'binding', 'slot', `slot_key`, 'prefix', `prefix`) END) AS `queryParams` | ||
| 135 | FROM `graphql_source_query_param` | ||
| 136 | GROUP BY `scope_id`, `source_id` | ||
| 137 | ) q ON q.`scope_id` = s.`scope_id` AND q.`source_id` = s.`id`; | ||
| 138 | --> statement-breakpoint | ||
| 139 | INSERT OR REPLACE INTO `plugin_storage` (`id`, `scope_id`, `plugin_id`, `collection`, `key`, `data`, `created_at`, `updated_at`) | ||
| 140 | SELECT json_array('graphql', 'operation', o.`id`), o.`scope_id`, 'graphql', 'operation', o.`id`, json_object('toolId', o.`id`, 'sourceId', o.`source_id`, 'binding', json(o.`binding`)), unixepoch('now') * 1000, unixepoch('now') * 1000 | ||
| 141 | FROM `graphql_operation` o; | ||
| 142 | --> statement-breakpoint | ||
| 143 | INSERT OR REPLACE INTO `plugin_storage` (`id`, `scope_id`, `plugin_id`, `collection`, `key`, `data`, `created_at`, `updated_at`) | ||
| 144 | SELECT | ||
| 145 | json_array('mcp', 'source', s.`id`), | ||
| 146 | s.`scope_id`, | ||
| 147 | 'mcp', | ||
| 148 | 'source', | ||
| 149 | s.`id`, | ||
| 150 | json_object( | ||
| 151 | 'namespace', s.`id`, | ||
| 152 | 'scope', s.`scope_id`, | ||
| 153 | 'name', s.`name`, | ||
| 154 | 'config', CASE WHEN json_extract(s.`config`, '$.transport') = 'remote' THEN json_patch( | ||
| 155 | json_patch( | ||
| 156 | json_patch( | ||
| 157 | json(s.`config`), | ||
| 158 | CASE WHEN h.`headers` IS NULL THEN json_object() ELSE json_object('headers', json(h.`headers`)) END | ||
| 159 | ), | ||
| 160 | CASE WHEN q.`queryParams` IS NULL THEN json_object() ELSE json_object('queryParams', json(q.`queryParams`)) END | ||
| 161 | ), | ||
| 162 | json_object('auth', | ||
| 163 | CASE | ||
| 164 | WHEN s.`auth_kind` = 'header' THEN json_object('kind', 'header', 'headerName', COALESCE(s.`auth_header_name`, ''), 'secretSlot', s.`auth_header_slot`, 'prefix', s.`auth_header_prefix`) | ||
| 165 | WHEN s.`auth_kind` = 'oauth2' THEN json_object('kind', 'oauth2', 'connectionSlot', s.`auth_connection_slot`, 'clientIdSlot', s.`auth_client_id_slot`, 'clientSecretSlot', s.`auth_client_secret_slot`) | ||
| 166 | ELSE json_object('kind', 'none') | ||
| 167 | END | ||
| 168 | ) | ||
| 169 | ) ELSE json(s.`config`) END | ||
| 170 | ), | ||
| 171 | unixepoch('now') * 1000, | ||
| 172 | unixepoch('now') * 1000 | ||
| 173 | FROM `mcp_source` s | ||
| 174 | LEFT JOIN ( | ||
| 175 | SELECT `scope_id`, `source_id`, json_group_object(`name`, CASE WHEN `kind` = 'text' THEN json_quote(`text_value`) ELSE json_object('kind', 'binding', 'slot', `slot_key`, 'prefix', `prefix`) END) AS `headers` | ||
| 176 | FROM `mcp_source_header` | ||
| 177 | GROUP BY `scope_id`, `source_id` | ||
| 178 | ) h ON h.`scope_id` = s.`scope_id` AND h.`source_id` = s.`id` | ||
| 179 | LEFT JOIN ( | ||
| 180 | SELECT `scope_id`, `source_id`, json_group_object(`name`, CASE WHEN `kind` = 'text' THEN json_quote(`text_value`) ELSE json_object('kind', 'binding', 'slot', `slot_key`, 'prefix', `prefix`) END) AS `queryParams` | ||
| 181 | FROM `mcp_source_query_param` | ||
| 182 | GROUP BY `scope_id`, `source_id` | ||
| 183 | ) q ON q.`scope_id` = s.`scope_id` AND q.`source_id` = s.`id`; | ||
| 184 | --> statement-breakpoint | ||
| 185 | INSERT OR REPLACE INTO `plugin_storage` (`id`, `scope_id`, `plugin_id`, `collection`, `key`, `data`, `created_at`, `updated_at`) | ||
| 186 | SELECT json_array('mcp', 'binding', b.`id`), b.`scope_id`, 'mcp', 'binding', b.`id`, json_object('namespace', b.`source_id`, 'toolId', b.`id`, 'binding', json(b.`binding`)), COALESCE(b.`created_at`, unixepoch('now') * 1000), unixepoch('now') * 1000 | ||
| 187 | FROM `mcp_binding` b; | ||
| 188 | --> statement-breakpoint | ||
| 189 | DROP TABLE IF EXISTS `openapi_source`; | ||
| 190 | --> statement-breakpoint | ||
| 191 | DROP TABLE IF EXISTS `openapi_operation`; | ||
| 192 | --> statement-breakpoint | ||
| 193 | DROP TABLE IF EXISTS `openapi_source_header`; | ||
| 194 | --> statement-breakpoint | ||
| 195 | DROP TABLE IF EXISTS `openapi_source_query_param`; | ||
| 196 | --> statement-breakpoint | ||
| 197 | DROP TABLE IF EXISTS `openapi_source_spec_fetch_header`; | ||
| 198 | --> statement-breakpoint | ||
| 199 | DROP TABLE IF EXISTS `openapi_source_spec_fetch_query_param`; | ||
| 200 | --> statement-breakpoint | ||
| 201 | DROP TABLE IF EXISTS `graphql_source`; | ||
| 202 | --> statement-breakpoint | ||
| 203 | DROP TABLE IF EXISTS `graphql_source_header`; | ||
| 204 | --> statement-breakpoint | ||
| 205 | DROP TABLE IF EXISTS `graphql_source_query_param`; | ||
| 206 | --> statement-breakpoint | ||
| 207 | DROP TABLE IF EXISTS `graphql_operation`; | ||
| 208 | --> statement-breakpoint | ||
| 209 | DROP TABLE IF EXISTS `mcp_source`; | ||
| 210 | --> statement-breakpoint | ||
| 211 | DROP TABLE IF EXISTS `mcp_source_header`; | ||
| 212 | --> statement-breakpoint | ||
| 213 | DROP TABLE IF EXISTS `mcp_source_query_param`; | ||
| 214 | --> statement-breakpoint | ||
| 215 | DROP TABLE IF EXISTS `mcp_binding`; | ||
| @@ -0,0 +1 @@ | |||
| 1 | ALTER TABLE `connection` ADD `identity_override` text; | ||
| @@ -0,0 +1,97 @@ | |||
| 1 | { | ||
| 2 | "version": "7", | ||
| 3 | "dialect": "sqlite", | ||
| 4 | "entries": [ | ||
| 5 | { | ||
| 6 | "idx": 0, | ||
| 7 | "version": "6", | ||
| 8 | "when": 1776367901699, | ||
| 9 | "tag": "0000_overconfident_sharon_carter", | ||
| 10 | "breakpoints": true | ||
| 11 | }, | ||
| 12 | { | ||
| 13 | "idx": 1, | ||
| 14 | "version": "6", | ||
| 15 | "when": 1776680432025, | ||
| 16 | "tag": "0001_sour_catseye", | ||
| 17 | "breakpoints": true | ||
| 18 | }, | ||
| 19 | { | ||
| 20 | "idx": 2, | ||
| 21 | "version": "6", | ||
| 22 | "when": 1776732062873, | ||
| 23 | "tag": "0002_lively_sue_storm", | ||
| 24 | "breakpoints": true | ||
| 25 | }, | ||
| 26 | { | ||
| 27 | "idx": 3, | ||
| 28 | "version": "6", | ||
| 29 | "when": 1776976132767, | ||
| 30 | "tag": "0003_little_silk_fever", | ||
| 31 | "breakpoints": true | ||
| 32 | }, | ||
| 33 | { | ||
| 34 | "idx": 4, | ||
| 35 | "version": "6", | ||
| 36 | "when": 1777800000000, | ||
| 37 | "tag": "0004_add_tool_policy", | ||
| 38 | "breakpoints": true | ||
| 39 | }, | ||
| 40 | { | ||
| 41 | "idx": 5, | ||
| 42 | "version": "6", | ||
| 43 | "when": 1777850000000, | ||
| 44 | "tag": "0005_repair_mcp_oauth_session", | ||
| 45 | "breakpoints": true | ||
| 46 | }, | ||
| 47 | { | ||
| 48 | "idx": 6, | ||
| 49 | "version": "6", | ||
| 50 | "when": 1777850000001, | ||
| 51 | "tag": "0006_neat_terror", | ||
| 52 | "breakpoints": true | ||
| 53 | }, | ||
| 54 | { | ||
| 55 | "idx": 7, | ||
| 56 | "version": "6", | ||
| 57 | "when": 1778100000000, | ||
| 58 | "tag": "0007_normalize_plugin_secret_refs", | ||
| 59 | "breakpoints": true | ||
| 60 | }, | ||
| 61 | { | ||
| 62 | "idx": 8, | ||
| 63 | "version": "6", | ||
| 64 | "when": 1778128200000, | ||
| 65 | "tag": "0008_scoped_credentials_cutover", | ||
| 66 | "breakpoints": true | ||
| 67 | }, | ||
| 68 | { | ||
| 69 | "idx": 9, | ||
| 70 | "version": "6", | ||
| 71 | "when": 1778192434062, | ||
| 72 | "tag": "0009_repair_openapi_oauth_cutover_residue", | ||
| 73 | "breakpoints": true | ||
| 74 | }, | ||
| 75 | { | ||
| 76 | "idx": 10, | ||
| 77 | "version": "6", | ||
| 78 | "when": 1778192434063, | ||
| 79 | "tag": "0010_add_credential_binding_secret_scope", | ||
| 80 | "breakpoints": true | ||
| 81 | }, | ||
| 82 | { | ||
| 83 | "idx": 11, | ||
| 84 | "version": "6", | ||
| 85 | "when": 1779087600000, | ||
| 86 | "tag": "0011_plugin_storage_sources", | ||
| 87 | "breakpoints": true | ||
| 88 | }, | ||
| 89 | { | ||
| 90 | "idx": 12, | ||
| 91 | "version": "6", | ||
| 92 | "when": 1779998400000, | ||
| 93 | "tag": "0012_connection_identity_override", | ||
| 94 | "breakpoints": true | ||
| 95 | } | ||
| 96 | ] | ||
| 97 | } | ||
| @@ -1,4 +1,6 @@ | |||
| 1 | import { afterEach, beforeEach, describe, expect, it } from "@effect/vitest"; | 1 | import { afterEach, beforeEach, describe, expect, it } from "@effect/vitest"; |
| 2 | import { drizzle } from "drizzle-orm/libsql"; | ||
| 3 | import { migrate } from "drizzle-orm/libsql/migrator"; | ||
| 2 | import { Buffer } from "node:buffer"; | 4 | import { Buffer } from "node:buffer"; |
| 3 | import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"; | 5 | import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"; |
| 4 | import { tmpdir } from "node:os"; | 6 | import { tmpdir } from "node:os"; |
| @@ -14,6 +16,12 @@ import { migrateLocalV1ToV2IfNeeded } from "./v1-v2-migration"; · 9 unmodified lines | |||
| 14 | const AuthFile = Schema.Record(Schema.String, Schema.String); | 16 | const AuthFile = Schema.Record(Schema.String, Schema.String); |
| 15 | const decodeAuthFile = Schema.decodeUnknownSync(Schema.fromJsonString(AuthFile)); | 17 | const decodeAuthFile = Schema.decodeUnknownSync(Schema.fromJsonString(AuthFile)); |
| 16 | const decodeUnknownJson = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Unknown)); | 18 | const decodeUnknownJson = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Unknown)); |
| 19 | // Preserves every journal field (`when`, `breakpoints`, …) — drizzle's | ||
| 20 | // migrator needs them, so only `entries` is typed for the truncation filter. | ||
| 21 | const decodeJournal = (text: string) => | ||
| 22 | decodeUnknownJson(text) as { | ||
| 23 | readonly entries: ReadonlyArray<{ readonly idx: number; readonly tag: string }>; | ||
| 24 | }; | ||
| 17 | 25 | ||
| 18 | let workDir: string; | 26 | let workDir: string; |
| 19 | let previousXdgDataHome: string | undefined; | 27 | let previousXdgDataHome: string | undefined; |
| @@ -1107,4 +1115,75 @@ describe("local v1 -> v2 migration", () => { · 1087 unmodified lines | |||
| 1107 | ]); | 1115 | ]); |
| 1108 | client.close(); | 1116 | client.close(); |
| 1109 | }); | 1117 | }); |
| 1118 | |||
| 1119 | // Regression: a database last touched by a release OLDER than v1-final | ||
| 1120 | // (pre-0011 — no `plugin_storage` table) must be replayed through the | ||
| 1121 | // bundled legacy drizzle chain before the v1→v2 data migration reads it. | ||
| 1122 | // Without the replay, migration crashed with "no such table: plugin_storage" | ||
| 1123 | // on every fresh 1.5.0 install over old data. | ||
| 1124 | it("replays the legacy drizzle chain for a v1 database that predates v1-final", async () => { | ||
| 1125 | const scopeId = "executor-workspace-abcd1234"; | ||
| 1126 | const dataDir = join(workDir, "data"); | ||
| 1127 | const dbPath = join(dataDir, "data.db"); | ||
| 1128 | mkdirSync(dataDir, { recursive: true }); | ||
| 1129 | |||
| 1130 | // Build a REAL pre-0011 v1 database: apply the vendored legacy chain | ||
| 1131 | // truncated after 0010, so drizzle records the genuine hashes and the | ||
| 1132 | // schema has per-plugin source tables but no `plugin_storage`. | ||
| 1133 | const legacyDir = join(import.meta.dirname, "../../drizzle-legacy-v1"); | ||
| 1134 | const truncatedDir = join(workDir, "legacy-truncated"); | ||
| 1135 | mkdirSync(join(truncatedDir, "meta"), { recursive: true }); | ||
| 1136 | const journal = decodeJournal( | ||
| 1137 | readFileSync(join(legacyDir, "meta", "_journal.json")).toString(), | ||
| 1138 | ); | ||
| 1139 | const kept = journal.entries.filter((entry) => entry.idx <= 10); | ||
| 1140 | for (const entry of kept) { | ||
| 1141 | writeFileSync( | ||
| 1142 | join(truncatedDir, `${entry.tag}.sql`), | ||
| 1143 | readFileSync(join(legacyDir, `${entry.tag}.sql`)), | ||
| 1144 | ); | ||
| 1145 | } | ||
| 1146 | writeFileSync( | ||
| 1147 | join(truncatedDir, "meta", "_journal.json"), | ||
| 1148 | JSON.stringify({ ...journal, entries: kept }), | ||
| 1149 | ); | ||
| 1150 | |||
| 1151 | const seed = await openLocalLibsql(dbPath); | ||
| 1152 | await migrate(drizzle({ client: seed }), { migrationsFolder: truncatedDir }); | ||
| 1153 | const missing = await seed.execute( | ||
| 1154 | "SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'plugin_storage'", | ||
| 1155 | ); | ||
| 1156 | expect(missing.rows).toEqual([]); // genuinely pre-0011 | ||
| 1157 | const now = Date.now(); | ||
| 1158 | await executeSql( | ||
| 1159 | seed, | ||
| 1160 | "INSERT INTO source (id, scope_id, plugin_id, kind, name, url, can_remove, can_refresh, can_edit, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, 1, 1, 1, ?, ?)", | ||
| 1161 | ["context7", scopeId, "mcp", "mcp", "Context7", "https://mcp.context7.com/mcp", now, now], | ||
| 1162 | ); | ||
| 1163 | await executeSql( | ||
| 1164 | seed, | ||
| 1165 | "INSERT INTO mcp_source (id, scope_id, name, config, created_at) VALUES (?, ?, ?, ?, ?)", | ||
| 1166 | [ | ||
| 1167 | "context7", | ||
| 1168 | scopeId, | ||
| 1169 | "Context7", | ||
| 1170 | JSON.stringify({ transport: "remote", endpoint: "https://mcp.context7.com/mcp" }), | ||
| 1171 | now, | ||
| 1172 | ], | ||
| 1173 | ); | ||
| 1174 | seed.close(); | ||
| 1175 | |||
| 1176 | const result = await migrateLocalV1ToV2IfNeeded({ | ||
| 1177 | sqlitePath: dbPath, | ||
| 1178 | tables: collectTables(), | ||
| 1179 | namespace: "executor_local", | ||
| 1180 | tenantId: scopeId, | ||
| 1181 | }); | ||
| 1182 | |||
| 1183 | expect(result.migrated).toBe(true); | ||
| 1184 | const client = await openLocalLibsql(dbPath); | ||
| 1185 | const integrations = await client.execute("SELECT tenant, slug, plugin_id FROM integration"); | ||
| 1186 | expect(integrations.rows).toEqual([{ tenant: scopeId, slug: "context7", plugin_id: "mcp" }]); | ||
| 1187 | client.close(); | ||
| 1188 | }); | ||
| 1110 | }); | 1189 | }); |
| @@ -1,11 +1,13 @@ | |||
| 1 | /* oxlint-disable executor/no-json-parse, executor/no-raw-fetch, executor/no-try-catch-or-throw -- boundary: one-shot local SQLite/auth-file migration normalizes legacy on-disk state */ | 1 | /* oxlint-disable executor/no-json-parse, executor/no-raw-fetch, executor/no-try-catch-or-throw -- boundary: one-shot local SQLite/auth-file migration normalizes legacy on-disk state */ |
| 2 | 2 | ||
| 3 | import type { Client } from "@libsql/client"; | 3 | import type { Client } from "@libsql/client"; |
| 4 | import { drizzle } from "drizzle-orm/libsql"; | ||
| 5 | import { migrate } from "drizzle-orm/libsql/migrator"; | ||
| 4 | import { Effect } from "effect"; | 6 | import { Effect } from "effect"; |
| 5 | import { createId } from "fumadb/cuid"; | 7 | import { createId } from "fumadb/cuid"; |
| 6 | import { randomBytes } from "node:crypto"; | 8 | import { createHash, randomBytes } from "node:crypto"; |
| 7 | import * as fs from "node:fs"; | 9 | import * as fs from "node:fs"; |
| 8 | import { homedir } from "node:os"; | 10 | import { homedir, tmpdir } from "node:os"; |
| 9 | import { dirname, join } from "node:path"; | 11 | import { dirname, join } from "node:path"; |
| 10 | import { TextDecoder } from "node:util"; | 12 | import { TextDecoder } from "node:util"; |
| 11 | 13 | ||
| @@ -34,6 +36,7 @@ import { · 22 unmodified lines | |||
| 34 | import { makeKeychainProvider } from "@executor-js/plugin-keychain"; | 36 | import { makeKeychainProvider } from "@executor-js/plugin-keychain"; |
| 35 | 37 | ||
| 36 | import { createSqliteFumaDb } from "./sqlite-fumadb"; | 38 | import { createSqliteFumaDb } from "./sqlite-fumadb"; |
| 39 | import embeddedLegacyMigrations from "./embedded-migrations.gen"; | ||
| 37 | import { executeSql, openLocalLibsql, queryFirst, queryRows } from "./libsql"; | 40 | import { executeSql, openLocalLibsql, queryFirst, queryRows } from "./libsql"; |
| 38 | 41 | ||
| 39 | type Row = Record<string, unknown>; | 42 | type Row = Record<string, unknown>; |
| @@ -131,6 +134,79 @@ const isLocalV1Database = async (client: Client): Promise<boolean> => { · 91 unmodified lines | |||
| 131 | return !connectionColumns.has("tenant") || connectionColumns.has("scope_id"); | 134 | return !connectionColumns.has("tenant") || connectionColumns.has("scope_id"); |
| 132 | }; | 135 | }; |
| 133 | 136 | ||
| 137 | // --------------------------------------------------------------------------- | ||
| 138 | // Legacy v1 schema replay. | ||
| 139 | // | ||
| 140 | // The v1→v2 data migration below reads the v1-FINAL schema (it queries | ||
| 141 | // `plugin_storage`, which only exists after v1 migration 0011). A database | ||
| 142 | // last touched by an older release is still mid-chain, so replay the bundled | ||
| 143 | // legacy drizzle migrations (`apps/local/drizzle-legacy-v1`, embedded into | ||
| 144 | // the binary by apps/cli/src/build.ts) to bring it to v1-final first — the | ||
| 145 | // same step every pre-v1.5 release performed at startup. | ||
| 146 | // --------------------------------------------------------------------------- | ||
| 147 | |||
| 148 | const resolveLegacyMigrationsFolder = (): string => { | ||
| 149 | if (!embeddedLegacyMigrations) { | ||
| 150 | return join(import.meta.dirname, "../../drizzle-legacy-v1"); | ||
| 151 | } | ||
| 152 | // drizzle's migrate() reads a folder from disk; materialize the embedded | ||
| 153 | // contents into a tmpdir. | ||
| 154 | const dir = fs.mkdtempSync(join(tmpdir(), "executor-legacy-migrations-")); | ||
| 155 | for (const [rel, content] of Object.entries(embeddedLegacyMigrations)) { | ||
| 156 | const target = join(dir, rel); | ||
| 157 | fs.mkdirSync(dirname(target), { recursive: true }); | ||
| 158 | fs.writeFileSync(target, content); | ||
| 159 | } | ||
| 160 | return dir; | ||
| 161 | }; | ||
| 162 | |||
| 163 | const readBundledLegacyMigrationHashes = (migrationsFolder: string): readonly string[] => { | ||
| 164 | const journal = JSON.parse( | ||
| 165 | fs.readFileSync(join(migrationsFolder, "meta", "_journal.json")).toString(), | ||
| 166 | ) as { entries: ReadonlyArray<{ idx: number; tag: string }> }; | ||
| 167 | return [...journal.entries] | ||
| 168 | .sort((left, right) => left.idx - right.idx) | ||
| 169 | .map((entry) => | ||
| 170 | createHash("sha256") | ||
| 171 | .update(fs.readFileSync(join(migrationsFolder, `${entry.tag}.sql`)).toString()) | ||
| 172 | .digest("hex"), | ||
| 173 | ); | ||
| 174 | }; | ||
| 175 | |||
| 176 | const readAppliedLegacyMigrationHashes = async (client: Client): Promise<readonly string[]> => | ||
| 177 | ( | ||
| 178 | await queryRows<{ hash: string }>( | ||
| 179 | client, | ||
| 180 | "SELECT hash FROM __drizzle_migrations ORDER BY id ASC", | ||
| 181 | ) | ||
| 182 | ).map((row) => row.hash); | ||
| 183 | |||
| 184 | /** Bring a v1 database that predates v1-final up to the last v1 schema. Only | ||
| 185 | * replays when the database's drizzle history is a strict prefix of the | ||
| 186 | * bundled legacy chain — anything else is left as-is with a warning (the | ||
| 187 | * data migration may still succeed if the schema is close enough). */ | ||
| 188 | const replayLegacyV1Migrations = async (client: Client, warnings: string[]): Promise<void> => { | ||
| 189 | if (!(await tableExists(client, "__drizzle_migrations"))) { | ||
| 190 | warnings.push( | ||
| 191 | "v1 database has no drizzle migration history; skipping the legacy schema replay.", | ||
| 192 | ); | ||
| 193 | return; | ||
| 194 | } | ||
| 195 | const migrationsFolder = resolveLegacyMigrationsFolder(); | ||
| 196 | const bundled = readBundledLegacyMigrationHashes(migrationsFolder); | ||
| 197 | const applied = await readAppliedLegacyMigrationHashes(client); | ||
| 198 | const isPrefix = | ||
| 199 | applied.length <= bundled.length && applied.every((hash, index) => hash === bundled[index]); | ||
| 200 | if (!isPrefix) { | ||
| 201 | warnings.push( | ||
| 202 | "v1 database migration history does not match this build's bundled legacy migrations; reading the schema as-is.", | ||
| 203 | ); | ||
| 204 | return; | ||
| 205 | } | ||
| 206 | if (applied.length === bundled.length) return; // already v1-final | ||
| 207 | await migrate(drizzle({ client }), { migrationsFolder }); | ||
| 208 | }; | ||
| 209 | |||
| 134 | const textDecoder = new TextDecoder(); | 210 | const textDecoder = new TextDecoder(); |
| 135 | 211 | ||
| 136 | const decodeBytes = (value: ArrayBuffer | ArrayBufferView): string => { | 212 | const decodeBytes = (value: ArrayBuffer | ArrayBufferView): string => { |
| @@ -837,6 +913,8 @@ export const migrateLocalV1ToV2IfNeeded = async ( · 700 unmodified lines | |||
| 837 | const reader = await openLocalLibsql(options.sqlitePath); | 913 | const reader = await openLocalLibsql(options.sqlitePath); |
| 838 | try { | 914 | try { |
| 839 | if (!(await isLocalV1Database(reader))) return { migrated: false, warnings: [] }; | 915 | if (!(await isLocalV1Database(reader))) return { migrated: false, warnings: [] }; |
| 916 | const replayWarnings: string[] = []; | ||
| 917 | await replayLegacyV1Migrations(reader, replayWarnings); | ||
| 840 | const snapshot = await readV1Snapshot(reader, options.tenantId); | 918 | const snapshot = await readV1Snapshot(reader, options.tenantId); |
| 841 | const plan = planMigration(snapshot.input); | 919 | const plan = planMigration(snapshot.input); |
| 842 | const secretValues = await collectSecretValues(plan); | 920 | const secretValues = await collectSecretValues(plan); |
| @@ -872,7 +950,7 @@ export const migrateLocalV1ToV2IfNeeded = async ( · 29 unmodified lines | |||
| 872 | migrated: true, | 950 | migrated: true, |
| 873 | backupPath, | 951 | backupPath, |
| 874 | report: plan.report, | 952 | report: plan.report, |
| 875 | warnings: [...plan.report.warnings, ...secretValues.warnings], | 953 | warnings: [...replayWarnings, ...plan.report.warnings, ...secretValues.warnings], |
| 876 | }; | 954 | }; |
| 877 | } catch (cause) { | 955 | } catch (cause) { |
| 878 | if (target) await target.close(); | 956 | if (target) await target.close(); |